diff --git a/Modules/PlanarFigure/src/DataManagement/mitkPlanarEllipse.cpp b/Modules/PlanarFigure/src/DataManagement/mitkPlanarEllipse.cpp
index 6627a6c865..4c24cce19d 100644
--- a/Modules/PlanarFigure/src/DataManagement/mitkPlanarEllipse.cpp
+++ b/Modules/PlanarFigure/src/DataManagement/mitkPlanarEllipse.cpp
@@ -1,304 +1,304 @@
/*============================================================================
The Medical Imaging Interaction Toolkit (MITK)
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
============================================================================*/
#include "mitkPlanarEllipse.h"
#include "mitkPlaneGeometry.h"
#include "mitkProperties.h"
#include <algorithm>
mitk::PlanarEllipse::PlanarEllipse()
: FEATURE_ID_MAJOR_AXIS(Superclass::AddFeature("Major Axis", "mm")),
FEATURE_ID_MINOR_AXIS(Superclass::AddFeature("Minor Axis", "mm")),
FEATURE_ID_AREA(Superclass::AddFeature("Area", "mm2")),
m_MinRadius(0),
m_MaxRadius(100),
m_MinMaxRadiusContraintsActive(false),
m_TreatAsCircle(true)
{
// Ellipse has three control points
this->ResetNumberOfControlPoints(4);
this->SetNumberOfPolyLines(2);
this->SetProperty("closed", mitk::BoolProperty::New(true));
}
bool mitk::PlanarEllipse::SetControlPoint(unsigned int index, const Point2D &point, bool createIfDoesNotExist)
{
if (index == 0) // moving center point and control points accordingly
{
const Point2D ¢erPoint = GetControlPoint(0);
Point2D boundaryPoint1 = GetControlPoint(1);
Point2D boundaryPoint2 = GetControlPoint(2);
Point2D boundaryPoint3 = GetControlPoint(3);
const vnl_vector<ScalarType> vec = (point.GetVnlVector() - centerPoint.GetVnlVector());
boundaryPoint1[0] += vec[0];
boundaryPoint1[1] += vec[1];
boundaryPoint2[0] += vec[0];
boundaryPoint2[1] += vec[1];
boundaryPoint3[0] += vec[0];
boundaryPoint3[1] += vec[1];
PlanarFigure::SetControlPoint(0, point, createIfDoesNotExist);
PlanarFigure::SetControlPoint(1, boundaryPoint1, createIfDoesNotExist);
PlanarFigure::SetControlPoint(2, boundaryPoint2, createIfDoesNotExist);
PlanarFigure::SetControlPoint(3, boundaryPoint3, createIfDoesNotExist);
return true;
}
else if (index < 3)
{
PlanarFigure::SetControlPoint(index, point, createIfDoesNotExist);
int otherIndex = index + 1;
if (otherIndex > 2)
otherIndex = 1;
- const Point2D ¢erPoint = GetControlPoint(0);
+ const Point2D centerPoint = GetControlPoint(0);
Point2D otherPoint = GetControlPoint(otherIndex);
Point2D point3 = GetControlPoint(3);
const Vector2D vec1 = point - centerPoint;
Vector2D vec2;
if (index == 1 && m_TreatAsCircle)
{
const float x = vec1[0];
vec2[0] = vec1[1];
vec2[1] = x;
if (index == 1)
vec2[0] *= -1;
else
vec2[1] *= -1;
otherPoint = centerPoint + vec2;
PlanarFigure::SetControlPoint(otherIndex, otherPoint, createIfDoesNotExist);
const float r = centerPoint.EuclideanDistanceTo(otherPoint);
// adjust additional third control point
const Point2D p3 = this->GetControlPoint(3);
Vector2D vec3;
vec3[0] = p3[0] - centerPoint[0];
vec3[1] = p3[1] - centerPoint[1];
if (vec3[0] != 0 || vec3[1] != 0)
{
vec3.Normalize();
vec3 *= r;
}
else
{
vec3[0] = r;
vec3[1] = 0;
}
point3 = centerPoint + vec3;
PlanarFigure::SetControlPoint(3, point3, createIfDoesNotExist);
}
else if (vec1.GetNorm() > 0)
{
const float r = centerPoint.EuclideanDistanceTo(otherPoint);
const float x = vec1[0];
vec2[0] = vec1[1];
vec2[1] = x;
if (index == 1)
vec2[0] *= -1;
else
vec2[1] *= -1;
vec2.Normalize();
vec2 *= r;
if (vec2.GetNorm() > 0)
{
otherPoint = centerPoint + vec2;
PlanarFigure::SetControlPoint(otherIndex, otherPoint, createIfDoesNotExist);
}
// adjust third control point
Vector2D vec3 = point3 - centerPoint;
vec3.Normalize();
const double r1 = centerPoint.EuclideanDistanceTo(GetControlPoint(1));
const double r2 = centerPoint.EuclideanDistanceTo(GetControlPoint(2));
const Point2D newPoint = centerPoint + vec3 * std::max(r1, r2);
PlanarFigure::SetControlPoint(3, newPoint, createIfDoesNotExist);
m_TreatAsCircle = false;
}
return true;
}
else if (index == 3)
{
const Point2D centerPoint = GetControlPoint(0);
Vector2D vec3 = point - centerPoint;
vec3.Normalize();
const double r1 = centerPoint.EuclideanDistanceTo(GetControlPoint(1));
const double r2 = centerPoint.EuclideanDistanceTo(GetControlPoint(2));
const Point2D newPoint = centerPoint + vec3 * std::max(r1, r2);
PlanarFigure::SetControlPoint(index, newPoint, createIfDoesNotExist);
m_TreatAsCircle = false;
return true;
}
return false;
}
void mitk::PlanarEllipse::PlaceFigure(const mitk::Point2D &point)
{
PlanarFigure::PlaceFigure(point);
m_SelectedControlPoint = 1;
}
mitk::Point2D mitk::PlanarEllipse::ApplyControlPointConstraints(unsigned int index, const Point2D &point)
{
return point;
Point2D indexPoint;
this->GetPlaneGeometry()->WorldToIndex(point, indexPoint);
BoundingBox::BoundsArrayType bounds = this->GetPlaneGeometry()->GetBounds();
if (indexPoint[0] < bounds[0])
{
indexPoint[0] = bounds[0];
}
if (indexPoint[0] > bounds[1])
{
indexPoint[0] = bounds[1];
}
if (indexPoint[1] < bounds[2])
{
indexPoint[1] = bounds[2];
}
if (indexPoint[1] > bounds[3])
{
indexPoint[1] = bounds[3];
}
Point2D constrainedPoint;
this->GetPlaneGeometry()->IndexToWorld(indexPoint, constrainedPoint);
if (m_MinMaxRadiusContraintsActive)
{
if (index != 0)
{
const Point2D ¢erPoint = this->GetControlPoint(0);
const double euclideanDinstanceFromCenterToPoint1 = centerPoint.EuclideanDistanceTo(point);
Vector2D vectorProjectedPoint = point - centerPoint;
vectorProjectedPoint.Normalize();
if (euclideanDinstanceFromCenterToPoint1 > m_MaxRadius)
{
vectorProjectedPoint *= m_MaxRadius;
constrainedPoint = centerPoint;
constrainedPoint += vectorProjectedPoint;
}
else if (euclideanDinstanceFromCenterToPoint1 < m_MinRadius)
{
vectorProjectedPoint *= m_MinRadius;
constrainedPoint = centerPoint;
constrainedPoint += vectorProjectedPoint;
}
}
}
return constrainedPoint;
}
void mitk::PlanarEllipse::GeneratePolyLine()
{
// clear the PolyLine-Contrainer, it will be reconstructed soon enough...
this->ClearPolyLines();
const Point2D ¢erPoint = GetControlPoint(0);
const Point2D &boundaryPoint1 = GetControlPoint(1);
const Point2D &boundaryPoint2 = GetControlPoint(2);
Vector2D dir = boundaryPoint1 - centerPoint;
dir.Normalize();
vnl_matrix_fixed<float, 2, 2> rot;
// differentiate between clockwise and counterclockwise rotation
int start = 0;
int end = 64;
if (dir[1] < 0)
{
dir[0] = -dir[0];
start = -32;
end = 32;
}
// construct rotation matrix to align ellipse with control point vector
rot[0][0] = dir[0];
rot[1][1] = rot[0][0];
rot[1][0] = sin(acos(rot[0][0]));
rot[0][1] = -rot[1][0];
const double radius1 = centerPoint.EuclideanDistanceTo(boundaryPoint1);
const double radius2 = centerPoint.EuclideanDistanceTo(boundaryPoint2);
// Generate poly-line with 64 segments
for (int t = start; t < end; ++t)
{
const double alpha = (double)t * vnl_math::pi / 32.0;
// construct the new polyline point ...
vnl_vector_fixed<float, 2> vec;
vec[0] = radius1 * cos(alpha);
vec[1] = radius2 * sin(alpha);
vec = rot * vec;
Point2D polyLinePoint;
polyLinePoint[0] = centerPoint[0] + vec[0];
polyLinePoint[1] = centerPoint[1] + vec[1];
// ... and append it to the PolyLine.
// No extending supported here, so we can set the index of the PolyLineElement to '0'
this->AppendPointToPolyLine(0, polyLinePoint);
}
this->AppendPointToPolyLine(1, centerPoint);
this->AppendPointToPolyLine(1, this->GetControlPoint(3));
}
void mitk::PlanarEllipse::GenerateHelperPolyLine(double /*mmPerDisplayUnit*/, unsigned int /*displayHeight*/)
{
// A circle does not require a helper object
}
void mitk::PlanarEllipse::EvaluateFeaturesInternal()
{
const Point2D centerPoint = this->GetControlPoint(0);
const auto longAxisLength = centerPoint.EuclideanDistanceTo(this->GetControlPoint(1));
const auto shortAxisLength = centerPoint.EuclideanDistanceTo(this->GetControlPoint(2));
this->SetQuantity(FEATURE_ID_MAJOR_AXIS, 2 * longAxisLength);
this->SetQuantity(FEATURE_ID_MINOR_AXIS, 2 * shortAxisLength);
this->SetQuantity(FEATURE_ID_AREA, longAxisLength * shortAxisLength * itk::Math::pi);
}
void mitk::PlanarEllipse::PrintSelf(std::ostream &os, itk::Indent indent) const
{
Superclass::PrintSelf(os, indent);
}
bool mitk::PlanarEllipse::Equals(const mitk::PlanarFigure &other) const
{
const auto *otherEllipse = dynamic_cast<const mitk::PlanarEllipse *>(&other);
if (otherEllipse)
{
if (this->m_TreatAsCircle != otherEllipse->m_TreatAsCircle)
return false;
return Superclass::Equals(other);
}
else
{
return false;
}
}