diff --git a/Modules/Core/include/mitkAnatomicalPlanes.h b/Modules/Core/include/mitkAnatomicalPlanes.h
new file mode 100644
index 0000000000..31cb7694ea
--- /dev/null
+++ b/Modules/Core/include/mitkAnatomicalPlanes.h
@@ -0,0 +1,27 @@
+/*============================================================================
+
+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.
+
+============================================================================*/
+
+#ifndef MITKANATOMICALPLANES_H
+#define MITKANATOMICALPLANES_H
+
+namespace mitk
+{
+ enum class AnatomicalPlane
+ {
+ Axial,
+ Sagittal,
+ Coronal,
+ Original
+ };
+}
+
+#endif // MITKANATOMICALPLANES_H
diff --git a/Modules/Core/include/mitkPlaneGeometry.h b/Modules/Core/include/mitkPlaneGeometry.h
index c160a76632..9e9cd52623 100644
--- a/Modules/Core/include/mitkPlaneGeometry.h
+++ b/Modules/Core/include/mitkPlaneGeometry.h
@@ -1,614 +1,608 @@
/*============================================================================
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.
============================================================================*/
/**
* \brief Describes the geometry of a plane object
*
* Describes a two-dimensional manifold, i.e., to put it simply,
* an object that can be described using a 2D coordinate-system.
*
* PlaneGeometry can map points between 3D world coordinates
* (in mm) and the described 2D coordinate-system (in mm) by first projecting
* the 3D point onto the 2D manifold and then calculating the 2D-coordinates
* (in mm). These 2D-mm-coordinates can be further converted into
* 2D-unit-coordinates (e.g., pixels), giving a parameter representation of
* the object with parameter values inside a rectangle
* (e.g., [0,0]..[width, height]), which is the bounding box (bounding range
* in z-direction always [0]..[1]).
*
* A PlaneGeometry describes the 2D representation within a 3D object (derived from BaseGeometry). For example,
* a single CT-image (slice) is 2D in the sense that you can access the
* pixels using 2D-coordinates, but is also 3D, as the pixels are really
* voxels, thus have an extension (thickness) in the 3rd dimension.
*
*
* Optionally, a reference BaseGeometry can be specified, which usually would
* be the geometry associated with the underlying dataset. This is currently
* used for calculating the intersection of inclined / rotated planes
* (represented as PlaneGeometry) with the bounding box of the associated
* BaseGeometry.
*
* \warning The PlaneGeometry are not necessarily up-to-date and not even
* initialized. As described in the previous paragraph, one of the
* Generate-/Copy-/UpdateOutputInformation methods have to initialize it.
* mitk::BaseData::GetPlaneGeometry() makes sure, that the PlaneGeometry is
* up-to-date before returning it (by setting the update extent appropriately
* and calling UpdateOutputInformation).
*
* Rule: everything is in mm (or ms for temporal information) if not
* stated otherwise.
* \ingroup Geometry
*/
#ifndef PLANEGEOMETRY_H_HEADER_INCLUDED_C1C68A2C
#define PLANEGEOMETRY_H_HEADER_INCLUDED_C1C68A2C
-#include "mitkBaseGeometry.h"
-#include "mitkRestorePlanePositionOperation.h"
#include <MitkCoreExports.h>
+#include <mitkAnatomicalPlanes.h>
+#include <mitkBaseGeometry.h>
+#include <mitkRestorePlanePositionOperation.h>
+
#include <vnl/vnl_cross.h>
namespace mitk
{
template <class TCoordRep, unsigned int NPointDimension>
class Line;
typedef Line<ScalarType, 3> Line3D;
class PlaneGeometry;
/** \deprecatedSince{2014_10} This class is deprecated. Please use PlaneGeometry instead. */
DEPRECATED(typedef PlaneGeometry Geometry2D);
/**
* \brief Describes a two-dimensional, rectangular plane
*
* \ingroup Geometry
*/
class MITKCORE_EXPORT PlaneGeometry : public BaseGeometry
{
public:
mitkClassMacro(PlaneGeometry, BaseGeometry);
/** Method for creation through the object factory. */
itkFactorylessNewMacro(Self);
itkCloneMacro(Self);
- enum PlaneOrientation {
- Axial,
- Sagittal,
- Coronal,
- None // This defines the PlaneGeometry for the 3D renderWindow which
- // curiously also needs a PlaneGeometry. This should be reconsidered some time.
- };
-
virtual void IndexToWorld(const Point2D &pt_units, Point2D &pt_mm) const;
virtual void WorldToIndex(const Point2D &pt_mm, Point2D &pt_units) const;
//##Documentation
//## @brief Convert (continuous or discrete) index coordinates of a \em vector
//## \a vec_units to world coordinates (in mm)
//## @deprecated First parameter (Point2D) is not used. If possible, please use void IndexToWorld(const
// mitk::Vector2D& vec_units, mitk::Vector2D& vec_mm) const.
//## For further information about coordinates types, please see the Geometry documentation
virtual void IndexToWorld(const mitk::Point2D &atPt2d_untis,
const mitk::Vector2D &vec_units,
mitk::Vector2D &vec_mm) const;
//##Documentation
//## @brief Convert (continuous or discrete) index coordinates of a \em vector
//## \a vec_units to world coordinates (in mm)
//## For further information about coordinates types, please see the Geometry documentation
virtual void IndexToWorld(const mitk::Vector2D &vec_units, mitk::Vector2D &vec_mm) const;
//##Documentation
//## @brief Convert world coordinates (in mm) of a \em vector
//## \a vec_mm to (continuous!) index coordinates.
//## @deprecated First parameter (Point2D) is not used. If possible, please use void WorldToIndex(const
// mitk::Vector2D& vec_mm, mitk::Vector2D& vec_units) const.
//## For further information about coordinates types, please see the Geometry documentation
virtual void WorldToIndex(const mitk::Point2D &atPt2d_mm,
const mitk::Vector2D &vec_mm,
mitk::Vector2D &vec_units) const;
//##Documentation
//## @brief Convert world coordinates (in mm) of a \em vector
//## \a vec_mm to (continuous!) index coordinates.
//## For further information about coordinates types, please see the Geometry documentation
virtual void WorldToIndex(const mitk::Vector2D &vec_mm, mitk::Vector2D &vec_units) const;
/**
- * \brief Initialize a plane with orientation \a planeorientation
+ * \brief Initialize a plane with orientation \a AnatomicalPlane
* (default: axial) with respect to \a BaseGeometry (default: identity).
* Spacing also taken from \a BaseGeometry.
*
* \warning A former version of this method created a geometry with unit
* spacing. For unit spacing use
*
* \code
* // for in-plane unit spacing:
* thisgeometry->SetSizeInUnits(thisgeometry->GetExtentInMM(0),
* thisgeometry->GetExtentInMM(1));
* // additionally, for unit spacing in normal direction (former version
* // did not do this):
* thisgeometry->SetExtentInMM(2, 1.0);
* \endcode
*/
virtual void InitializeStandardPlane(const BaseGeometry *geometry3D,
- PlaneOrientation planeorientation = Axial,
+ AnatomicalPlane planeorientation = AnatomicalPlane::Axial,
ScalarType zPosition = 0,
bool frontside = true,
bool rotated = false,
bool top = true);
/**
- * \brief Initialize a plane with orientation \a planeorientation
+ * \brief Initialize a plane with orientation \a AnatomicalPlane
* (default: axial) with respect to \a BaseGeometry (default: identity).
* Spacing also taken from \a BaseGeometry.
*
* \param geometry3D
* \param top if \a true, create plane at top, otherwise at bottom
- * (for PlaneOrientation Axial, for other plane locations respectively)
+ * (for AnatomicalPlane Axial, for other plane locations respectively)
* \param planeorientation
* \param frontside
* \param rotated
*/
virtual void InitializeStandardPlane(const BaseGeometry *geometry3D,
bool top,
- PlaneOrientation planeorientation = Axial,
+ AnatomicalPlane planeorientation = AnatomicalPlane::Axial,
bool frontside = true,
bool rotated = false);
/**
- * \brief Initialize a plane with orientation \a planeorientation
+ * \brief Initialize a plane with orientation \a AnatomicalPlane
* (default: axial) with respect to \a transform (default: identity)
* given width and height in units.
*
* \a Rotated means rotated by 180 degrees (1/2 rotation) within the plane.
* Rotation by 90 degrees (1/4 rotation) is not implemented as of now.
*
* \a Frontside/Backside:
* Viewed from below = frontside in the axial case;
* (radiologist's view versus neuro-surgeon's view, see:
* http://www.itk.org/Wiki/images/e/ed/DICOM-OrientationDiagram-Radiologist-vs-NeuroSurgeon.png )
* Viewed from front = frontside in the coronal case;
* Viewed from left = frontside in the sagittal case.
*
* \a Cave/Caution: Currently only RPI, LAI, LPS and RAS in the three standard planes are covered,
* i.e. 12 cases of 144: 3 standard planes * 48 coordinate orientations = 144 cases.
*/
virtual void InitializeStandardPlane(ScalarType width,
ScalarType height,
const AffineTransform3D *transform = nullptr,
- PlaneOrientation planeorientation = Axial,
+ AnatomicalPlane planeorientation = AnatomicalPlane::Axial,
ScalarType zPosition = 0,
bool frontside = true,
bool rotated = false,
bool top = true);
/**
- * \brief Initialize plane with orientation \a planeorientation
+ * \brief Initialize plane with orientation \a AnatomicalPlane
* (default: axial) given width, height and spacing.
*
*/
virtual void InitializeStandardPlane(ScalarType width,
ScalarType height,
const Vector3D &spacing,
- PlaneOrientation planeorientation = Axial,
+ AnatomicalPlane planeorientation = AnatomicalPlane::Axial,
ScalarType zPosition = 0,
bool frontside = true,
bool rotated = false,
bool top = true);
/**
* \brief Initialize plane by width and height in pixels, right-/down-vector
* (itk) to describe orientation in world-space (vectors will be normalized)
* and spacing (default: 1.0 mm in all directions).
*
* The vectors are normalized and multiplied by the respective spacing before
* they are set in the matrix.
*
* This overloaded version of InitializeStandardPlane() creates only righthanded
* coordinate orientations, unless spacing contains 1 or 3 negative entries.
*
*/
virtual void InitializeStandardPlane(ScalarType width,
ScalarType height,
const Vector3D &rightVector,
const Vector3D &downVector,
const Vector3D *spacing = nullptr);
/**
* \brief Initialize plane by width and height in pixels,
* right-/down-vector (vnl) to describe orientation in world-space (vectors
* will be normalized) and spacing (default: 1.0 mm in all directions).
*
* The vectors are normalized and multiplied by the respective spacing
* before they are set in the matrix.
*
* This overloaded version of InitializeStandardPlane() creates only righthanded
* coordinate orientations, unless spacing contains 1 or 3 negative entries.
*
*/
virtual void InitializeStandardPlane(ScalarType width,
ScalarType height,
const VnlVector &rightVector,
const VnlVector &downVector,
const Vector3D *spacing = nullptr);
/**
* \brief Initialize plane by right-/down-vector (itk) and spacing
* (default: 1.0 mm in all directions).
*
* The length of the right-/-down-vector is used as width/height in units,
* respectively. Then, the vectors are normalized and multiplied by the
* respective spacing before they are set in the matrix.
*/
virtual void InitializeStandardPlane(const Vector3D &rightVector,
const Vector3D &downVector,
const Vector3D *spacing = nullptr);
/**
* \brief Initialize plane by right-/down-vector (vnl) and spacing
* (default: 1.0 mm in all directions).
*
* The length of the right-/-down-vector is used as width/height in units,
* respectively. Then, the vectors are normalized and multiplied by the
* respective spacing before they are set in the matrix.
*/
virtual void InitializeStandardPlane(const VnlVector &rightVector,
const VnlVector &downVector,
const Vector3D *spacing = nullptr);
/**
* \brief Initialize plane by origin and normal (size is 1.0 mm in
* all directions, direction of right-/down-vector valid but
* undefined).
* \warning This function can only produce righthanded coordinate orientation, not lefthanded.
*/
virtual void InitializePlane(const Point3D &origin, const Vector3D &normal);
/**
* \brief Initialize plane by right-/down-vector.
*
* \warning The vectors are set into the matrix as they are,
* \em without normalization!
* This function creates a righthanded IndexToWorldTransform,
* only a negative thickness could still make it lefthanded.
*/
void SetMatrixByVectors(const VnlVector &rightVector, const VnlVector &downVector, ScalarType thickness = 1.0);
/**
* \brief Check if matrix is a rotation matrix:
* - determinant is 1?
* - R*R^T is ID?
* Output warning otherwise.
*/
static bool CheckRotationMatrix(AffineTransform3D *transform, double epsilon=1e-6);
/**
* \brief Normal of the plane
*
*/
Vector3D GetNormal() const;
/**
* \brief Normal of the plane as VnlVector
*
*/
VnlVector GetNormalVnl() const;
virtual ScalarType SignedDistance(const Point3D &pt3d_mm) const;
/**
* \brief Calculates, whether a point is below or above the plane. There are two different
*calculation methods, with or without consideration of the bounding box.
*/
virtual bool IsAbove(const Point3D &pt3d_mm, bool considerBoundingBox = false) const;
/**
* \brief Distance of the point from the plane
* (bounding-box \em not considered)
*
*/
ScalarType DistanceFromPlane(const Point3D &pt3d_mm) const;
/**
* \brief Signed distance of the point from the plane
* (bounding-box \em not considered)
*
* > 0 : point is in the direction of the direction vector.
*/
inline ScalarType SignedDistanceFromPlane(const Point3D &pt3d_mm) const
{
ScalarType len = GetNormalVnl().two_norm();
if (len == 0)
return 0;
return (pt3d_mm - GetOrigin()) * GetNormal() / len;
}
/**
* \brief Distance of the plane from another plane
* (bounding-box \em not considered)
*
* Result is 0 if planes are not parallel.
*/
ScalarType DistanceFromPlane(const PlaneGeometry *plane) const { return fabs(SignedDistanceFromPlane(plane)); }
/**
* \brief Signed distance of the plane from another plane
* (bounding-box \em not considered)
*
* Result is 0 if planes are not parallel.
*/
inline ScalarType SignedDistanceFromPlane(const PlaneGeometry *plane) const
{
if (IsParallel(plane))
{
return SignedDistance(plane->GetOrigin());
}
return 0;
}
/**
* \brief Calculate the intersecting line of two planes
*
* \return \a true planes are intersecting
* \return \a false planes do not intersect
*/
bool IntersectionLine(const PlaneGeometry *plane, Line3D &crossline) const;
/**
* \brief Calculate two points where another plane intersects the border of this plane
*
* \return number of intersection points (0..2). First interection point (if existing)
* is returned in \a lineFrom, second in \a lineTo.
*/
unsigned int IntersectWithPlane2D(const PlaneGeometry *plane, Point2D &lineFrom, Point2D &lineTo) const;
/**
* \brief Calculate the angle between two planes
*
* \return angle in radiants
*/
double Angle(const PlaneGeometry *plane) const;
/**
* \brief Calculate the angle between the plane and a line
*
* \return angle in radiants
*/
double Angle(const Line3D &line) const;
/**
* \brief Calculate intersection point between the plane and a line
*
* \param line
* \param intersectionPoint intersection point
* \return \a true if \em unique intersection exists, i.e., if line
* is \em not on or parallel to the plane
*/
bool IntersectionPoint(const Line3D &line, Point3D &intersectionPoint) const;
/**
* \brief Calculate line parameter of intersection point between the
* plane and a line
*
* \param line
* \param t parameter of line: intersection point is
* line.GetPoint()+t*line.GetDirection()
* \return \a true if \em unique intersection exists, i.e., if line
* is \em not on or parallel to the plane
*/
bool IntersectionPointParam(const Line3D &line, double &t) const;
/**
* \brief Returns whether the plane is parallel to another plane
*
* @return true iff the normal vectors both point to the same or exactly oposit direction
*/
bool IsParallel(const PlaneGeometry *plane) const;
/**
* \brief Returns whether the point is on the plane
* (bounding-box \em not considered)
*/
bool IsOnPlane(const Point3D &point) const;
/**
* \brief Returns whether the line is on the plane
* (bounding-box \em not considered)
*/
bool IsOnPlane(const Line3D &line) const;
/**
* \brief Returns whether the plane is on the plane
* (bounding-box \em not considered)
*
* @return true if the normal vector of the planes point to the same or the exactly oposit direction and
* the distance of the planes is < eps
*
*/
bool IsOnPlane(const PlaneGeometry *plane) const;
/**
* \brief Returns the lot from the point to the plane
*/
Point3D ProjectPointOntoPlane(const Point3D &pt) const;
itk::LightObject::Pointer InternalClone() const override;
/** Implements operation to re-orient the plane */
void ExecuteOperation(Operation *operation) override;
/**
* \brief Project a 3D point given in mm (\a pt3d_mm) onto the 2D
* geometry. The result is a 2D point in mm (\a pt2d_mm).
*
* The result is a 2D point in mm (\a pt2d_mm) relative to the upper-left
* corner of the geometry. To convert this point into units (e.g., pixels
* in case of an image), use WorldToIndex.
* \return true projection was possible
* \sa Project(const mitk::Point3D &pt3d_mm, mitk::Point3D
* &projectedPt3d_mm)
*/
virtual bool Map(const mitk::Point3D &pt3d_mm, mitk::Point2D &pt2d_mm) const;
/**
* \brief Converts a 2D point given in mm (\a pt2d_mm) relative to the
* upper-left corner of the geometry into the corresponding
* world-coordinate (a 3D point in mm, \a pt3d_mm).
*
* To convert a 2D point given in units (e.g., pixels in case of an
* image) into a 2D point given in mm (as required by this method), use
* IndexToWorld.
*/
virtual void Map(const mitk::Point2D &pt2d_mm, mitk::Point3D &pt3d_mm) const;
/**
* \brief Set the width and height of this 2D-geometry in units by calling
* SetBounds. This does \a not change the extent in mm!
*
* For an image, this is the number of pixels in x-/y-direction.
* \note In contrast to calling SetBounds directly, this does \a not change
* the extent in mm!
*/
virtual void SetSizeInUnits(mitk::ScalarType width, mitk::ScalarType height);
/**
* \brief Project a 3D point given in mm (\a pt3d_mm) onto the 2D
* geometry. The result is a 3D point in mm (\a projectedPt3d_mm).
*
* \return true projection was possible
*/
virtual bool Project(const mitk::Point3D &pt3d_mm, mitk::Point3D &projectedPt3d_mm) const;
/**
* \brief Project a 3D vector given in mm (\a vec3d_mm) onto the 2D
* geometry. The result is a 2D vector in mm (\a vec2d_mm).
*
* The result is a 2D vector in mm (\a vec2d_mm) relative to the
* upper-left
* corner of the geometry. To convert this point into units (e.g., pixels
* in case of an image), use WorldToIndex.
* \return true projection was possible
* \sa Project(const mitk::Vector3D &vec3d_mm, mitk::Vector3D
* &projectedVec3d_mm)
*/
virtual bool Map(const mitk::Point3D &atPt3d_mm, const mitk::Vector3D &vec3d_mm, mitk::Vector2D &vec2d_mm) const;
/**
* \brief Converts a 2D vector given in mm (\a vec2d_mm) relative to the
* upper-left corner of the geometry into the corresponding
* world-coordinate (a 3D vector in mm, \a vec3d_mm).
*
* To convert a 2D vector given in units (e.g., pixels in case of an
* image) into a 2D vector given in mm (as required by this method), use
* IndexToWorld.
*/
virtual void Map(const mitk::Point2D &atPt2d_mm, const mitk::Vector2D &vec2d_mm, mitk::Vector3D &vec3d_mm) const;
/**
* \brief Project a 3D vector given in mm (\a vec3d_mm) onto the 2D
* geometry. The result is a 3D vector in mm (\a projectedVec3d_mm).
*
* DEPRECATED. Use Project(vector,vector) instead
*
* \return true projection was possible
*/
virtual bool Project(const mitk::Point3D &atPt3d_mm,
const mitk::Vector3D &vec3d_mm,
mitk::Vector3D &projectedVec3d_mm) const;
/**
* \brief Project a 3D vector given in mm (\a vec3d_mm) onto the 2D
* geometry. The result is a 3D vector in mm (\a projectedVec3d_mm).
*
* \return true projection was possible
*/
virtual bool Project(const mitk::Vector3D &vec3d_mm, mitk::Vector3D &projectedVec3d_mm) const;
/**
* \brief Distance of the point from the geometry
* (bounding-box \em not considered)
*
*/
inline ScalarType Distance(const Point3D &pt3d_mm) const { return fabs(SignedDistance(pt3d_mm)); }
/**
* \brief Set the geometrical frame of reference in which this PlaneGeometry
* is placed.
*
* This would usually be the BaseGeometry of the underlying dataset, but
* setting it is optional.
*/
void SetReferenceGeometry(const mitk::BaseGeometry *geometry);
/**
* \brief Get the geometrical frame of reference for this PlaneGeometry.
*/
const BaseGeometry *GetReferenceGeometry() const;
bool HasReferenceGeometry() const;
static std::vector< int > CalculateDominantAxes(mitk::AffineTransform3D::MatrixType::InternalMatrixType& rotation_matrix);
protected:
PlaneGeometry();
PlaneGeometry(const PlaneGeometry &other);
~PlaneGeometry() override;
void PrintSelf(std::ostream &os, itk::Indent indent) const override;
const mitk::BaseGeometry *m_ReferenceGeometry;
//##Documentation
//## @brief PreSetSpacing
//##
//## These virtual function allows a different beahiour in subclasses.
//## Do implement them in every subclass of BaseGeometry. If not needed, use
//## {Superclass::PreSetSpacing();};
void PreSetSpacing(const mitk::Vector3D &aSpacing) override { Superclass::PreSetSpacing(aSpacing); };
//##Documentation
//## @brief CheckBounds
//##
//## This function is called in SetBounds. Assertions can be implemented in this function (see PlaneGeometry.cpp).
//## If you implement this function in a subclass, make sure, that all classes were your class inherits from
//## have an implementation of CheckBounds
//## (e.g. inheritance BaseGeometry <- A <- B. Implementation of CheckBounds in class B needs implementation in A as
// well!)
void CheckBounds(const BoundsArrayType &bounds) override;
//##Documentation
//## @brief CheckIndexToWorldTransform
//##
//## This function is called in SetIndexToWorldTransform. Assertions can be implemented in this function (see
// PlaneGeometry.cpp).
//## In Subclasses of BaseGeometry, implement own conditions or call Superclass::CheckBounds(bounds);.
void CheckIndexToWorldTransform(mitk::AffineTransform3D *transform) override;
private:
/**
* \brief Compares plane with another plane: \a true if IsOnPlane
* (bounding-box \em not considered)
*/
virtual bool operator==(const PlaneGeometry *) const { return false; };
/**
* \brief Compares plane with another plane: \a false if IsOnPlane
* (bounding-box \em not considered)
*/
virtual bool operator!=(const PlaneGeometry *) const { return false; };
};
} // namespace mitk
#endif /* PLANEGEOMETRY_H_HEADER_INCLUDED_C1C68A2C */
diff --git a/Modules/Core/include/mitkSliceNavigationController.h b/Modules/Core/include/mitkSliceNavigationController.h
index c446d79ea3..c2786aafe7 100644
--- a/Modules/Core/include/mitkSliceNavigationController.h
+++ b/Modules/Core/include/mitkSliceNavigationController.h
@@ -1,438 +1,426 @@
/*============================================================================
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.
============================================================================*/
#ifndef MITKSLICENAVIGATIONCONTROLLER_H
#define MITKSLICENAVIGATIONCONTROLLER_H
#include <MitkCoreExports.h>
#include <mitkBaseController.h>
#include <mitkMessage.h>
+#include <mitkAnatomicalPlanes.h>
#include <mitkRenderingManager.h>
#include <mitkRestorePlanePositionOperation.h>
#include <mitkTimeGeometry.h>
#pragma GCC visibility push(default)
#include <itkEventObject.h>
#pragma GCC visibility pop
#include <itkCommand.h>
namespace mitk
{
#define mitkTimeGeometryEventMacro(classname, super) \
class MITKCORE_EXPORT classname : public super \
{ \
public: \
typedef classname Self; \
typedef super Superclass; \
classname(TimeGeometry *aTimeGeometry, unsigned int aPos) : Superclass(aTimeGeometry, aPos) {} \
virtual ~classname() {} \
virtual const char *GetEventName() const { return #classname; } \
virtual bool CheckEvent(const ::itk::EventObject *e) const { return dynamic_cast<const Self *>(e); } \
virtual ::itk::EventObject *MakeObject() const { return new Self(GetTimeGeometry(), GetPos()); } \
private: \
void operator=(const Self &); \
}
class PlaneGeometry;
class BaseGeometry;
class BaseRenderer;
/**
* \brief Controls the selection of the slice the associated BaseRenderer
* will display
*
* A SliceNavigationController takes a BaseGeometry or a TimeGeometry as input world geometry
* (TODO what are the exact requirements?) and generates a TimeGeometry
* as output. The TimeGeometry holds a number of SlicedGeometry3Ds and
* these in turn hold a series of PlaneGeometries. One of these PlaneGeometries is
* selected as world geometry for the BaseRenderers associated to 2D views.
*
* The SliceNavigationController holds has Steppers (one for the slice, a
* second for the time step), which control the selection of a single
* PlaneGeometry from the TimeGeometry. SliceNavigationController generates
* ITK events to tell observers, like a BaseRenderer, when the selected slice
* or timestep changes.
*
* Example:
* \code
* // Initialization
* sliceCtrl = mitk::SliceNavigationController::New();
*
* // Tell the navigation controller the geometry to be sliced
* // (with geometry a BaseGeometry::ConstPointer)
* sliceCtrl->SetInputWorldTimeGeometry(geometry.GetPointer());
*
* // Tell the navigation controller in which direction it shall slice the data
- * sliceCtrl->SetViewDirection(mitk::SliceNavigationController::Axial);
+ * sliceCtrl->SetViewDirection(mitk::AnatomicalPlane::Axial);
*
* // Connect one or more BaseRenderer to this navigation controller, i.e.:
* // events sent by the navigation controller when stepping through the slices
* // (e.g. by sliceCtrl->GetSlice()->Next()) will be received by the BaseRenderer
* // (in this example only slice-changes, see also ConnectGeometryTimeEvent
* // and ConnectGeometryEvents.)
* sliceCtrl->ConnectGeometrySliceEvent(renderer.GetPointer());
*
* //create a world geometry and send the information to the connected renderer(s)
* sliceCtrl->Update();
* \endcode
*
*
* You can connect visible navigation widgets to a SliceNavigationController, e.g., a
* QmitkSliceNavigationWidget (for Qt):
*
* \code
* // Create the visible navigation widget (a slider with a spin-box)
* QmitkSliceNavigationWidget* navigationWidget =
* new QmitkSliceNavigationWidget(parent);
*
* // Connect the navigation widget to the slice-stepper of the
* // SliceNavigationController. For initialization (position, mininal and
* // maximal values) the values of the SliceNavigationController are used.
* // Thus, accessing methods of a navigation widget is normally not necessary,
* // since everything can be set via the (Qt-independent) SliceNavigationController.
* // The QmitkStepperAdapter converts the Qt-signals to Qt-independent
* // itk-events.
* new QmitkStepperAdapter(navigationWidget, sliceCtrl->GetSlice());
* \endcode
*
* If you do not want that all renderwindows are updated when a new slice is
* selected, you can use a specific RenderingManager, which updates only those
* renderwindows that should be updated. This is sometimes useful when a 3D view
* does not need to be updated when the slices in some 2D views are changed.
*
* \code
* // create a specific RenderingManager
* mitk::RenderingManager::Pointer myManager = mitk::RenderingManager::New();
*
* // tell the RenderingManager to update only renderwindow1 and renderwindow2
* myManager->AddRenderWindow(renderwindow1);
* myManager->AddRenderWindow(renderwindow2);
*
* // tell the SliceNavigationController of renderwindow1 and renderwindow2
* // to use the specific RenderingManager instead of the global one
* renderwindow1->GetSliceNavigationController()->SetRenderingManager(myManager);
* renderwindow2->GetSliceNavigationController()->SetRenderingManager(myManager);
* \endcode
*
* \todo implement for non-evenly-timed geometry!
* \ingroup NavigationControl
*/
class MITKCORE_EXPORT SliceNavigationController : public BaseController
{
public:
mitkClassMacro(SliceNavigationController, BaseController);
itkNewMacro(Self);
- /**
- * \brief Possible view directions, \a Original will use
- * the PlaneGeometry instances in a SlicedGeometry3D provided
- * as input world geometry (by SetInputWorldTimeGeometry).
- */
- enum ViewDirection
- {
- Axial,
- Sagittal,
- Coronal,
- Original
- };
-
/**
* \brief Set the input world time geometry out of which the
* geometries for slicing will be created.
*
* Any previous previous set input geometry (3D or Time) will
* be ignored in future.
*/
void SetInputWorldTimeGeometry(const TimeGeometry* geometry);
itkGetConstObjectMacro(InputWorldTimeGeometry, TimeGeometry);
/**
* \brief Access the created geometry
*/
itkGetConstObjectMacro(CreatedWorldGeometry, TimeGeometry);
itkGetObjectMacro(CreatedWorldGeometry, TimeGeometry);
/**
* \brief Set the desired view directions
*
* \sa ViewDirection
- * \sa Update(ViewDirection viewDirection, bool top = true,
+ * \sa Update(AnatomicalPlane viewDirection, bool top = true,
* bool frontside = true, bool rotated = false)
*/
- itkSetEnumMacro(ViewDirection, ViewDirection);
- itkGetEnumMacro(ViewDirection, ViewDirection);
+ itkSetEnumMacro(ViewDirection, AnatomicalPlane);
+ itkGetEnumMacro(ViewDirection, AnatomicalPlane);
/**
* \brief Set the default view direction
*
* This is used to re-initialize the view direction of the SNC to the
* default value with SetViewDirectionToDefault()
*
* \sa ViewDirection
- * \sa Update(ViewDirection viewDirection, bool top = true,
+ * \sa Update(AnatomicalPlane viewDirection, bool top = true,
* bool frontside = true, bool rotated = false)
*/
- itkSetEnumMacro(DefaultViewDirection, ViewDirection);
- itkGetEnumMacro(DefaultViewDirection, ViewDirection);
+ itkSetEnumMacro(DefaultViewDirection, AnatomicalPlane);
+ itkGetEnumMacro(DefaultViewDirection, AnatomicalPlane);
const char *GetViewDirectionAsString() const;
virtual void SetViewDirectionToDefault();
/**
* \brief Do the actual creation and send it to the connected
* observers (renderers)
*
*/
virtual void Update();
/**
* \brief Extended version of Update, additionally allowing to
* specify the direction/orientation of the created geometry.
*
*/
- virtual void Update(ViewDirection viewDirection, bool top = true, bool frontside = true, bool rotated = false);
+ virtual void Update(AnatomicalPlane viewDirection, bool top = true, bool frontside = true, bool rotated = false);
/**
* \brief Send the created geometry to the connected
* observers (renderers)
*
* Called by Update().
*/
virtual void SendCreatedWorldGeometry();
/**
* \brief Tell observers to re-read the currently selected 2D geometry
*
*/
virtual void SendCreatedWorldGeometryUpdate();
/**
* \brief Send the currently selected slice to the connected
* observers (renderers)
*
* Called by Update().
*/
virtual void SendSlice();
/**
* \brief Send the currently selected time to the connected
* observers (renderers)
*
* Called by Update().
*/
virtual void SendTime();
class MITKCORE_EXPORT TimeGeometryEvent : public itk::AnyEvent
{
public:
typedef TimeGeometryEvent Self;
typedef itk::AnyEvent Superclass;
TimeGeometryEvent(TimeGeometry* aTimeGeometry, unsigned int aPos) : m_TimeGeometry(aTimeGeometry), m_Pos(aPos) {}
~TimeGeometryEvent() override {}
const char* GetEventName() const override { return "TimeGeometryEvent"; }
bool CheckEvent(const ::itk::EventObject* e) const override { return dynamic_cast<const Self*>(e); }
::itk::EventObject* MakeObject() const override { return new Self(m_TimeGeometry, m_Pos); }
TimeGeometry* GetTimeGeometry() const { return m_TimeGeometry; }
unsigned int GetPos() const { return m_Pos; }
private:
TimeGeometry::Pointer m_TimeGeometry;
unsigned int m_Pos;
// TimeGeometryEvent(const Self&);
void operator=(const Self&); // just hide
};
mitkTimeGeometryEventMacro(GeometrySendEvent, TimeGeometryEvent);
mitkTimeGeometryEventMacro(GeometryUpdateEvent, TimeGeometryEvent);
mitkTimeGeometryEventMacro(GeometryTimeEvent, TimeGeometryEvent);
mitkTimeGeometryEventMacro(GeometrySliceEvent, TimeGeometryEvent);
template <typename T>
void ConnectGeometrySendEvent(T* receiver)
{
auto eventReceptorCommand = itk::ReceptorMemberCommand<T>::New();
eventReceptorCommand->SetCallbackFunction(receiver, &T::SetGeometry);
unsigned long tag = AddObserver(GeometrySendEvent(nullptr, 0), eventReceptorCommand);
m_ReceiverToObserverTagsMap[static_cast<void*>(receiver)].push_back(tag);
}
template <typename T>
void ConnectGeometryUpdateEvent(T* receiver)
{
auto eventReceptorCommand = itk::ReceptorMemberCommand<T>::New();
eventReceptorCommand->SetCallbackFunction(receiver, &T::UpdateGeometry);
unsigned long tag = AddObserver(GeometryUpdateEvent(nullptr, 0), eventReceptorCommand);
m_ReceiverToObserverTagsMap[static_cast<void*>(receiver)].push_back(tag);
}
template <typename T>
void ConnectGeometrySliceEvent(T* receiver)
{
auto eventReceptorCommand = itk::ReceptorMemberCommand<T>::New();
eventReceptorCommand->SetCallbackFunction(receiver, &T::SetGeometrySlice);
unsigned long tag = AddObserver(GeometrySliceEvent(nullptr, 0), eventReceptorCommand);
m_ReceiverToObserverTagsMap[static_cast<void*>(receiver)].push_back(tag);
}
template <typename T>
void ConnectGeometryTimeEvent(T* receiver)
{
auto eventReceptorCommand = itk::ReceptorMemberCommand<T>::New();
eventReceptorCommand->SetCallbackFunction(receiver, &T::SetGeometryTime);
unsigned long tag = AddObserver(GeometryTimeEvent(nullptr, 0), eventReceptorCommand);
m_ReceiverToObserverTagsMap[static_cast<void*>(receiver)].push_back(tag);
}
template <typename T>
void ConnectGeometryEvents(T* receiver)
{
// connect sendEvent only once
ConnectGeometrySliceEvent(receiver, false);
ConnectGeometryTimeEvent(receiver);
}
// use a templated method to get the right offset when casting to void*
template <typename T>
void Disconnect(T* receiver)
{
auto i = m_ReceiverToObserverTagsMap.find(static_cast<void*>(receiver));
if (i == m_ReceiverToObserverTagsMap.end())
return;
const std::list<unsigned long>& tags = i->second;
for (auto tagIter = tags.begin(); tagIter != tags.end(); ++tagIter)
{
RemoveObserver(*tagIter);
}
m_ReceiverToObserverTagsMap.erase(i);
}
Message1<const Point3D&> SetCrosshairEvent;
/**
* \brief To connect multiple SliceNavigationController, we can
* act as an observer ourselves: implemented interface
* \warning not implemented
*/
virtual void SetGeometry(const itk::EventObject& geometrySliceEvent);
/**
* \brief To connect multiple SliceNavigationController, we can
* act as an observer ourselves: implemented interface
*/
virtual void SetGeometrySlice(const itk::EventObject& geometrySliceEvent);
/**
* \brief To connect multiple SliceNavigationController, we can
* act as an observer ourselves: implemented interface
*/
virtual void SetGeometryTime(const itk::EventObject& geometryTimeEvent);
/** \brief Positions the SNC according to the specified point */
void SelectSliceByPoint(const Point3D& point);
/** \brief Returns the BaseGeometry of the currently selected time step. */
const BaseGeometry* GetCurrentGeometry3D();
/** \brief Returns the currently selected Plane in the current
* BaseGeometry (if existent).
*/
const PlaneGeometry* GetCurrentPlaneGeometry();
/** \brief Sets / gets the BaseRenderer associated with this SNC (if any).
* While the BaseRenderer is not directly used by SNC, this is a convenience
* method to enable BaseRenderer access via the SNC.
*/
itkSetObjectMacro(Renderer, BaseRenderer);
itkGetMacro(Renderer, BaseRenderer*);
/** \brief Re-orients the slice stack. All slices will be oriented to the given normal vector.
The given point (world coordinates) defines the selected slice.
Careful: The resulting axis vectors are not clearly defined this way. If you want to define them clearly, use
ReorientSlices (const Point3D &point, const Vector3D &axisVec0, const Vector3D &axisVec1).
*/
void ReorientSlices(const Point3D& point, const Vector3D& normal);
/** \brief Re-orients the slice stack so that all planes are oriented according to the
* given axis vectors. The given Point eventually defines selected slice.
*/
void ReorientSlices(const Point3D& point, const Vector3D& axisVec0, const Vector3D& axisVec1);
void ExecuteOperation(Operation* operation) override;
/**
* \brief Feature option to lock planes during mouse interaction.
* This option flag disables the mouse event which causes the center
* cross to move near by.
*/
itkSetMacro(SliceLocked, bool);
itkGetMacro(SliceLocked, bool);
itkBooleanMacro(SliceLocked);
/**
* \brief Feature option to lock slice rotation.
*
* This option flag disables separately the rotation of a slice which is
* implemented in mitkSliceRotator.
*/
itkSetMacro(SliceRotationLocked, bool);
itkGetMacro(SliceRotationLocked, bool);
itkBooleanMacro(SliceRotationLocked);
/**
* \brief Adjusts the numerical range of the slice stepper according to
* the current geometry orientation of this SNC's SlicedGeometry.
*/
void AdjustSliceStepperRange();
/** \brief Convenience method that returns the time step currently selected by the controller.*/
TimeStepType GetSelectedTimeStep() const;
/** \brief Convenience method that returns the time point that corresponds to the selected
* time step. The conversion is done using the time geometry of the SliceNavigationController.
* If the time geometry is not yet set, this function will always return 0.0.*/
TimePointType GetSelectedTimePoint() const;
protected:
SliceNavigationController();
~SliceNavigationController() override;
void CreateWorldGeometry(bool top, bool frontside, bool rotated);
TimeGeometry::ConstPointer m_InputWorldTimeGeometry;
TimeGeometry::Pointer m_CreatedWorldGeometry;
- ViewDirection m_ViewDirection;
- ViewDirection m_DefaultViewDirection;
+ AnatomicalPlane m_ViewDirection;
+ AnatomicalPlane m_DefaultViewDirection;
RenderingManager::Pointer m_RenderingManager;
BaseRenderer* m_Renderer;
bool m_BlockUpdate;
bool m_SliceLocked;
bool m_SliceRotationLocked;
typedef std::map<void*, std::list<unsigned long>> ObserverTagsMapType;
ObserverTagsMapType m_ReceiverToObserverTagsMap;
};
} // namespace mitk
#endif // MITKSLICENAVIGATIONCONTROLLER_H
diff --git a/Modules/Core/src/Controllers/mitkSliceNavigationController.cpp b/Modules/Core/src/Controllers/mitkSliceNavigationController.cpp
index 5d1b7aacc4..9eacf0b0f3 100644
--- a/Modules/Core/src/Controllers/mitkSliceNavigationController.cpp
+++ b/Modules/Core/src/Controllers/mitkSliceNavigationController.cpp
@@ -1,560 +1,542 @@
/*============================================================================
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 "mitkSliceNavigationController.h"
#include <mitkSliceNavigationHelper.h>
#include "mitkBaseRenderer.h"
#include "mitkOperation.h"
#include "mitkOperationActor.h"
-#include "mitkPlaneGeometry.h"
+
#include "mitkProportionalTimeGeometry.h"
#include "mitkArbitraryTimeGeometry.h"
#include "mitkSlicedGeometry3D.h"
#include "mitkVtkPropRenderer.h"
#include "mitkImage.h"
#include "mitkImagePixelReadAccessor.h"
#include "mitkInteractionConst.h"
#include "mitkNodePredicateDataType.h"
#include "mitkOperationEvent.h"
#include "mitkPixelTypeMultiplex.h"
+#include "mitkPlaneGeometry.h"
#include "mitkPlaneOperation.h"
#include "mitkPointOperation.h"
#include "mitkApplyTransformMatrixOperation.h"
namespace mitk
{
-
- PlaneGeometry::PlaneOrientation ViewDirectionToPlaneOrientation(SliceNavigationController::ViewDirection viewDiretion)
- {
- switch (viewDiretion)
- {
- case SliceNavigationController::Axial:
- return PlaneGeometry::Axial;
- case SliceNavigationController::Sagittal:
- return PlaneGeometry::Sagittal;
- case SliceNavigationController::Coronal:
- return PlaneGeometry::Coronal;
- case SliceNavigationController::Original:
- default:
- return PlaneGeometry::None;
- }
- }
-
SliceNavigationController::SliceNavigationController()
: BaseController()
, m_InputWorldTimeGeometry(TimeGeometry::ConstPointer())
, m_CreatedWorldGeometry(TimeGeometry::Pointer())
- , m_ViewDirection(Axial)
- , m_DefaultViewDirection(Axial)
+ , m_ViewDirection(AnatomicalPlane::Axial)
+ , m_DefaultViewDirection(AnatomicalPlane::Axial)
, m_RenderingManager(RenderingManager::Pointer())
, m_Renderer(nullptr)
, m_BlockUpdate(false)
, m_SliceLocked(false)
, m_SliceRotationLocked(false)
{
typedef itk::SimpleMemberCommand<SliceNavigationController> SNCCommandType;
SNCCommandType::Pointer sliceStepperChangedCommand, timeStepperChangedCommand;
sliceStepperChangedCommand = SNCCommandType::New();
timeStepperChangedCommand = SNCCommandType::New();
sliceStepperChangedCommand->SetCallbackFunction(this, &SliceNavigationController::SendSlice);
timeStepperChangedCommand->SetCallbackFunction(this, &SliceNavigationController::SendTime);
m_Slice->AddObserver(itk::ModifiedEvent(), sliceStepperChangedCommand);
m_Time->AddObserver(itk::ModifiedEvent(), timeStepperChangedCommand);
m_Slice->SetUnitName("mm");
m_Time->SetUnitName("ms");
}
SliceNavigationController::~SliceNavigationController()
{
// nothing here
}
void SliceNavigationController::SetInputWorldTimeGeometry(const TimeGeometry* geometry)
{
if (nullptr != geometry)
{
if (geometry->GetBoundingBoxInWorld()->GetDiagonalLength2() < eps)
{
itkWarningMacro("setting an empty bounding-box");
geometry = nullptr;
}
}
if (m_InputWorldTimeGeometry != geometry)
{
m_InputWorldTimeGeometry = geometry;
this->Modified();
}
}
void SliceNavigationController::SetViewDirectionToDefault()
{
m_ViewDirection = m_DefaultViewDirection;
}
const char* SliceNavigationController::GetViewDirectionAsString() const
{
const char* viewDirectionString;
switch (m_ViewDirection)
{
- case SliceNavigationController::Axial:
+ case AnatomicalPlane::Axial:
viewDirectionString = "Axial";
break;
- case SliceNavigationController::Sagittal:
+ case AnatomicalPlane::Sagittal:
viewDirectionString = "Sagittal";
break;
- case SliceNavigationController::Coronal:
+ case AnatomicalPlane::Coronal:
viewDirectionString = "Coronal";
break;
- case SliceNavigationController::Original:
+ case AnatomicalPlane::Original:
viewDirectionString = "Original";
break;
default:
- viewDirectionString = "No View Direction Available";
+ viewDirectionString = "No view direction available";
break;
}
return viewDirectionString;
}
void SliceNavigationController::Update()
{
if (!m_BlockUpdate)
{
- if (m_ViewDirection == Sagittal)
+ if (m_ViewDirection == AnatomicalPlane::Sagittal)
{
- this->Update(Sagittal, true, true, false);
+ this->Update(AnatomicalPlane::Sagittal, true, true, false);
}
- else if (m_ViewDirection == Coronal)
+ else if (m_ViewDirection == AnatomicalPlane::Coronal)
{
- this->Update(Coronal, false, true, false);
+ this->Update(AnatomicalPlane::Coronal, false, true, false);
}
- else if (m_ViewDirection == Axial)
+ else if (m_ViewDirection == AnatomicalPlane::Axial)
{
- this->Update(Axial, false, false, true);
+ this->Update(AnatomicalPlane::Axial, false, false, true);
}
else
{
this->Update(m_ViewDirection);
}
}
}
- void SliceNavigationController::Update(SliceNavigationController::ViewDirection viewDirection,
+ void SliceNavigationController::Update(AnatomicalPlane viewDirection,
bool top,
bool frontside,
bool rotated)
{
if (m_BlockUpdate)
{
return;
}
if (m_InputWorldTimeGeometry.IsNull())
{
return;
}
if (0 == m_InputWorldTimeGeometry->CountTimeSteps())
{
return;
}
m_BlockUpdate = true;
if (m_LastUpdateTime < m_InputWorldTimeGeometry->GetMTime())
{
Modified();
}
this->SetViewDirection(viewDirection);
if (m_LastUpdateTime < GetMTime())
{
m_LastUpdateTime = GetMTime();
this->CreateWorldGeometry(top, frontside, rotated);
}
// unblock update; we may do this now, because if m_BlockUpdate was already
// true before this method was entered, then we will never come here.
m_BlockUpdate = false;
// Send the geometry. Do this even if nothing was changed, because maybe
// Update() was only called to re-send the old geometry and time/slice data.
this->SendCreatedWorldGeometry();
this->SendSlice();
this->SendTime();
// Adjust the stepper range of slice stepper according to geometry
this->AdjustSliceStepperRange();
}
void SliceNavigationController::SendCreatedWorldGeometry()
{
if (!m_BlockUpdate)
{
this->InvokeEvent(GeometrySendEvent(m_CreatedWorldGeometry, 0));
}
}
void SliceNavigationController::SendCreatedWorldGeometryUpdate()
{
if (!m_BlockUpdate)
{
this->InvokeEvent(GeometryUpdateEvent(m_CreatedWorldGeometry, m_Slice->GetPos()));
}
}
void SliceNavigationController::SendSlice()
{
if (!m_BlockUpdate)
{
if (m_CreatedWorldGeometry.IsNotNull())
{
this->InvokeEvent(GeometrySliceEvent(m_CreatedWorldGeometry, m_Slice->GetPos()));
RenderingManager::GetInstance()->RequestUpdateAll();
}
}
}
void SliceNavigationController::SendTime()
{
if (!m_BlockUpdate)
{
if (m_CreatedWorldGeometry.IsNotNull())
{
this->InvokeEvent(GeometryTimeEvent(m_CreatedWorldGeometry, m_Time->GetPos()));
RenderingManager::GetInstance()->RequestUpdateAll();
}
}
}
void SliceNavigationController::SetGeometry(const itk::EventObject&)
{
// not implemented
}
void SliceNavigationController::SetGeometryTime(const itk::EventObject& geometryTimeEvent)
{
if (m_CreatedWorldGeometry.IsNull())
{
return;
}
const auto* timeEvent = dynamic_cast<const SliceNavigationController::GeometryTimeEvent*>(&geometryTimeEvent);
assert(timeEvent != nullptr);
TimeGeometry* timeGeometry = timeEvent->GetTimeGeometry();
assert(timeGeometry != nullptr);
auto timeStep = (int)timeEvent->GetPos();
ScalarType timeInMS;
timeInMS = timeGeometry->TimeStepToTimePoint(timeStep);
timeStep = m_CreatedWorldGeometry->TimePointToTimeStep(timeInMS);
this->GetTime()->SetPos(timeStep);
}
void SliceNavigationController::SetGeometrySlice(const itk::EventObject& geometrySliceEvent)
{
const auto* sliceEvent = dynamic_cast<const SliceNavigationController::GeometrySliceEvent*>(&geometrySliceEvent);
assert(sliceEvent != nullptr);
this->GetSlice()->SetPos(sliceEvent->GetPos());
}
void SliceNavigationController::SelectSliceByPoint(const Point3D& point)
{
if (m_CreatedWorldGeometry.IsNull())
{
return;
}
int selectedSlice = -1;
try
{
selectedSlice = SliceNavigationHelper::SelectSliceByPoint(m_CreatedWorldGeometry, point);
}
catch (const mitk::Exception& e)
{
MITK_ERROR << "Unable to select a slice by the given point " << point << "\n"
<< "Reason: " << e.GetDescription();
}
if (-1 == selectedSlice)
{
return;
}
this->GetSlice()->SetPos(selectedSlice);
this->SendCreatedWorldGeometryUpdate();
// send crosshair event
SetCrosshairEvent.Send(point);
}
void SliceNavigationController::ReorientSlices(const Point3D& point, const Vector3D& normal)
{
if (m_CreatedWorldGeometry.IsNull())
{
return;
}
PlaneOperation op(OpORIENT, point, normal);
m_CreatedWorldGeometry->ExecuteOperation(&op);
this->SendCreatedWorldGeometryUpdate();
}
void SliceNavigationController::ReorientSlices(const Point3D& point,
const Vector3D& axisVec0,
const Vector3D& axisVec1)
{
if (m_CreatedWorldGeometry.IsNull())
{
return;
}
PlaneOperation op(OpORIENT, point, axisVec0, axisVec1);
m_CreatedWorldGeometry->ExecuteOperation(&op);
this->SendCreatedWorldGeometryUpdate();
}
const BaseGeometry* SliceNavigationController::GetCurrentGeometry3D()
{
if (m_CreatedWorldGeometry.IsNull())
{
return nullptr;
}
return m_CreatedWorldGeometry->GetGeometryForTimeStep(this->GetTime()->GetPos());
}
const PlaneGeometry* SliceNavigationController::GetCurrentPlaneGeometry()
{
const auto* slicedGeometry = dynamic_cast<const SlicedGeometry3D*>(this->GetCurrentGeometry3D());
if (nullptr == slicedGeometry)
{
return nullptr;
}
return slicedGeometry->GetPlaneGeometry(this->GetSlice()->GetPos());
}
void SliceNavigationController::AdjustSliceStepperRange()
{
const auto* slicedGeometry = dynamic_cast<const SlicedGeometry3D*>(this->GetCurrentGeometry3D());
const Vector3D& direction = slicedGeometry->GetDirectionVector();
int c = 0;
int i, k = 0;
for (i = 0; i < 3; ++i)
{
if (fabs(direction[i]) < 0.000000001)
{
++c;
}
else
{
k = i;
}
}
if (c == 2)
{
ScalarType min = slicedGeometry->GetOrigin()[k];
ScalarType max = min + slicedGeometry->GetExtentInMM(k);
m_Slice->SetRange(min, max);
}
else
{
m_Slice->InvalidateRange();
}
}
void SliceNavigationController::ExecuteOperation(Operation* operation)
{
// switch on type
// - select best slice for a given point
// - rotate created world geometry according to Operation->SomeInfo()
if (!operation || m_CreatedWorldGeometry.IsNull())
{
return;
}
switch (operation->GetOperationType())
{
case OpMOVE: // should be a point operation
{
if (!m_SliceLocked) // do not move the cross position
{
// select a slice
auto* po = dynamic_cast<PointOperation*>(operation);
if (po && po->GetIndex() == -1)
{
this->SelectSliceByPoint(po->GetPoint());
}
else if (po &&
po->GetIndex() != -1) // undo case because index != -1, index holds the old position of this slice
{
this->GetSlice()->SetPos(po->GetIndex());
}
}
break;
}
case OpRESTOREPLANEPOSITION:
{
m_CreatedWorldGeometry->ExecuteOperation(operation);
this->SendCreatedWorldGeometryUpdate();
break;
}
case OpAPPLYTRANSFORMMATRIX:
{
m_CreatedWorldGeometry->ExecuteOperation(operation);
this->SendCreatedWorldGeometryUpdate();
break;
}
default:
{
// do nothing
break;
}
}
}
TimeStepType SliceNavigationController::GetSelectedTimeStep() const
{
return this->GetTime()->GetPos();
}
TimePointType SliceNavigationController::GetSelectedTimePoint() const
{
auto timeStep = this->GetSelectedTimeStep();
if (m_CreatedWorldGeometry.IsNull())
{
return 0.0;
}
if (!m_CreatedWorldGeometry->IsValidTimeStep(timeStep))
{
mitkThrow() << "SliceNavigationController is in an invalid state. It has a time step"
<< "selected that is not covered by its time geometry. Selected time step: " << timeStep
<< "; TimeGeometry steps count: " << m_CreatedWorldGeometry->CountTimeSteps();
}
return m_CreatedWorldGeometry->TimeStepToTimePoint(timeStep);
}
void SliceNavigationController::CreateWorldGeometry(bool top, bool frontside, bool rotated)
{
// initialize the viewplane
SlicedGeometry3D::Pointer slicedWorldGeometry;
BaseGeometry::ConstPointer currentGeometry;
// get the BaseGeometry (ArbitraryTimeGeometry or ProportionalTimeGeometry) of the current time step
auto currentTimeStep = this->GetTime()->GetPos();
if (m_InputWorldTimeGeometry->IsValidTimeStep(currentTimeStep))
{
currentGeometry = m_InputWorldTimeGeometry->GetGeometryForTimeStep(currentTimeStep);
}
else
{
currentGeometry = m_InputWorldTimeGeometry->GetGeometryForTimeStep(0);
}
- if (Original == m_ViewDirection)
+ if (AnatomicalPlane::Original == m_ViewDirection)
{
slicedWorldGeometry = dynamic_cast<SlicedGeometry3D*>(
m_InputWorldTimeGeometry->GetGeometryForTimeStep(currentTimeStep).GetPointer());
if (slicedWorldGeometry.IsNull())
{
slicedWorldGeometry = SlicedGeometry3D::New();
- slicedWorldGeometry->InitializePlanes(
- currentGeometry, PlaneGeometry::None, top, frontside, rotated);
+ slicedWorldGeometry->InitializePlanes(currentGeometry, AnatomicalPlane::Original, top, frontside, rotated);
slicedWorldGeometry->SetSliceNavigationController(this);
}
}
else
{
slicedWorldGeometry = SlicedGeometry3D::New();
- slicedWorldGeometry->InitializePlanes(
- currentGeometry, ViewDirectionToPlaneOrientation(m_ViewDirection), top, frontside, rotated);
+ slicedWorldGeometry->InitializePlanes(currentGeometry, m_ViewDirection, top, frontside, rotated);
slicedWorldGeometry->SetSliceNavigationController(this);
}
// reset the stepper
m_Slice->SetSteps(slicedWorldGeometry->GetSlices());
m_Slice->SetPos(0);
TimeStepType inputTimeSteps = m_InputWorldTimeGeometry->CountTimeSteps();
const TimeBounds& timeBounds = m_InputWorldTimeGeometry->GetTimeBounds();
m_Time->SetSteps(inputTimeSteps);
m_Time->SetPos(0);
m_Time->SetRange(timeBounds[0], timeBounds[1]);
currentTimeStep = this->GetTime()->GetPos();
assert(m_InputWorldTimeGeometry->GetGeometryForTimeStep(currentTimeStep).IsNotNull());
// create new time geometry and initialize it according to the type of the 'm_InputWorldTimeGeometry'
// the created world geometry will either have equidistant timesteps (ProportionalTimeGeometry)
// or individual time bounds for each timestep (ArbitraryTimeGeometry)
m_CreatedWorldGeometry = mitk::TimeGeometry::Pointer();
if (nullptr != dynamic_cast<const mitk::ProportionalTimeGeometry*>(m_InputWorldTimeGeometry.GetPointer()))
{
const TimePointType minimumTimePoint = m_InputWorldTimeGeometry->TimeStepToTimePoint(currentTimeStep);
const TimePointType stepDuration =
m_InputWorldTimeGeometry->TimeStepToTimePoint(currentTimeStep + 1) - minimumTimePoint;
auto createdTimeGeometry = ProportionalTimeGeometry::New();
createdTimeGeometry->Initialize(slicedWorldGeometry, inputTimeSteps);
createdTimeGeometry->SetFirstTimePoint(minimumTimePoint);
createdTimeGeometry->SetStepDuration(stepDuration);
m_CreatedWorldGeometry = createdTimeGeometry;
}
else
{
auto createdTimeGeometry = mitk::ArbitraryTimeGeometry::New();
createdTimeGeometry->ReserveSpaceForGeometries(inputTimeSteps);
const BaseGeometry::Pointer clonedGeometry = slicedWorldGeometry->Clone();
for (TimeStepType i = 0; i < inputTimeSteps; ++i)
{
const auto bounds = m_InputWorldTimeGeometry->GetTimeBounds(i);
createdTimeGeometry->AppendNewTimeStep(clonedGeometry, bounds[0], bounds[1]);
}
createdTimeGeometry->Update();
m_CreatedWorldGeometry = createdTimeGeometry;
}
}
} // namespace mitk
diff --git a/Modules/Core/src/DataManagement/mitkPlaneGeometry.cpp b/Modules/Core/src/DataManagement/mitkPlaneGeometry.cpp
index 1850b8dab4..30d2f6829b 100644
--- a/Modules/Core/src/DataManagement/mitkPlaneGeometry.cpp
+++ b/Modules/Core/src/DataManagement/mitkPlaneGeometry.cpp
@@ -1,972 +1,975 @@
/*============================================================================
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 "mitkPlaneGeometry.h"
#include "mitkInteractionConst.h"
#include "mitkLine.h"
#include "mitkPlaneOperation.h"
#include <itkSpatialOrientationAdapter.h>
#include <vtkTransform.h>
#include <vnl/vnl_cross.h>
namespace mitk
{
PlaneGeometry::PlaneGeometry() : Superclass(), m_ReferenceGeometry(nullptr) { Initialize(); }
PlaneGeometry::~PlaneGeometry() {}
PlaneGeometry::PlaneGeometry(const PlaneGeometry &other)
: Superclass(other), m_ReferenceGeometry(other.m_ReferenceGeometry)
{
}
bool PlaneGeometry::CheckRotationMatrix(mitk::AffineTransform3D *transform, double epsilon)
{
bool rotation = true;
auto matrix = transform->GetMatrix().GetVnlMatrix();
matrix.normalize_columns();
auto det = vnl_determinant(matrix);
if (fabs(det-1.0) > epsilon)
{
MITK_WARN << "Invalid rotation matrix! Determinant != 1 (" << det << ")";
rotation = false;
}
vnl_matrix_fixed<double, 3, 3> id; id.set_identity();
auto should_be_id = matrix*matrix.transpose();
should_be_id -= id;
auto max = should_be_id.absolute_value_max();
if (max > epsilon)
{
MITK_WARN << "Invalid rotation matrix! R*R^T != ID. Max value: " << max << " (should be 0)";
rotation = false;
}
return rotation;
}
void PlaneGeometry::CheckIndexToWorldTransform(mitk::AffineTransform3D *transform)
{
this->CheckRotationMatrix(transform);
}
void PlaneGeometry::CheckBounds(const BoundingBox::BoundsArrayType &bounds)
{
// error: unused parameter 'bounds'
// this happens in release mode, where the assert macro is defined empty
// hence we "use" the parameter:
(void)bounds;
// currently the unit rectangle must be starting at the origin [0,0]
assert(bounds[0] == 0);
assert(bounds[2] == 0);
// the unit rectangle must be two-dimensional
assert(bounds[1] > 0);
assert(bounds[3] > 0);
}
void PlaneGeometry::IndexToWorld(const Point2D &pt_units, Point2D &pt_mm) const
{
pt_mm[0] = GetExtentInMM(0) / GetExtent(0) * pt_units[0];
pt_mm[1] = GetExtentInMM(1) / GetExtent(1) * pt_units[1];
}
void PlaneGeometry::WorldToIndex(const Point2D &pt_mm, Point2D &pt_units) const
{
pt_units[0] = pt_mm[0] * (1.0 / (GetExtentInMM(0) / GetExtent(0)));
pt_units[1] = pt_mm[1] * (1.0 / (GetExtentInMM(1) / GetExtent(1)));
}
void PlaneGeometry::IndexToWorld(const Point2D & /*atPt2d_units*/, const Vector2D &vec_units, Vector2D &vec_mm) const
{
MITK_WARN << "Warning! Call of the deprecated function PlaneGeometry::IndexToWorld(point, vec, vec). Use "
"PlaneGeometry::IndexToWorld(vec, vec) instead!";
this->IndexToWorld(vec_units, vec_mm);
}
void PlaneGeometry::IndexToWorld(const Vector2D &vec_units, Vector2D &vec_mm) const
{
vec_mm[0] = (GetExtentInMM(0) / GetExtent(0)) * vec_units[0];
vec_mm[1] = (GetExtentInMM(1) / GetExtent(1)) * vec_units[1];
}
void PlaneGeometry::WorldToIndex(const Point2D & /*atPt2d_mm*/, const Vector2D &vec_mm, Vector2D &vec_units) const
{
MITK_WARN << "Warning! Call of the deprecated function PlaneGeometry::WorldToIndex(point, vec, vec). Use "
"PlaneGeometry::WorldToIndex(vec, vec) instead!";
this->WorldToIndex(vec_mm, vec_units);
}
void PlaneGeometry::WorldToIndex(const Vector2D &vec_mm, Vector2D &vec_units) const
{
vec_units[0] = vec_mm[0] * (1.0 / (GetExtentInMM(0) / GetExtent(0)));
vec_units[1] = vec_mm[1] * (1.0 / (GetExtentInMM(1) / GetExtent(1)));
}
void PlaneGeometry::InitializeStandardPlane(mitk::ScalarType width,
ScalarType height,
const Vector3D &spacing,
- PlaneGeometry::PlaneOrientation planeorientation,
+ AnatomicalPlane planeorientation,
ScalarType zPosition,
bool frontside,
bool rotated,
bool top)
{
AffineTransform3D::Pointer transform;
transform = AffineTransform3D::New();
AffineTransform3D::MatrixType matrix;
AffineTransform3D::MatrixType::InternalMatrixType &vnlmatrix = matrix.GetVnlMatrix();
vnlmatrix.set_identity();
vnlmatrix(0, 0) = spacing[0];
vnlmatrix(1, 1) = spacing[1];
vnlmatrix(2, 2) = spacing[2];
transform->SetIdentity();
transform->SetMatrix(matrix);
InitializeStandardPlane(width, height, transform.GetPointer(), planeorientation, zPosition, frontside, rotated, top);
}
void PlaneGeometry::InitializeStandardPlane(mitk::ScalarType width,
mitk::ScalarType height,
const AffineTransform3D *transform /* = nullptr */,
- PlaneGeometry::PlaneOrientation planeorientation /* = Axial */,
+ AnatomicalPlane planeorientation /* = Axial */,
mitk::ScalarType zPosition /* = 0 */,
bool frontside /* = true */,
bool rotated /* = false */,
bool top /* = true */)
{
Superclass::Initialize();
/// construct standard view.
// We define at the moment "frontside" as: axial from above,
// coronal from front (nose), sagittal from right.
// TODO: Double check with medicals doctors or radiologists [ ].
// We define the orientation in patient's view, e.g. LAI is in a axial cut
// (parallel to the triangle ear-ear-nose):
// first axis: To the left ear of the patient
// seecond axis: To the nose of the patient
// third axis: To the legs of the patient.
// Options are: L/R left/right; A/P anterior/posterior; I/S inferior/superior
// (AKA caudal/cranial).
// We note on all cases in the following switch block r.h. for right handed
// or l.h. for left handed to describe the different cases.
// However, which system is chosen is defined at the end of the switch block.
// CAVE / be careful: the vectors right and bottom are relative to the plane
// and do NOT describe e.g. the right side of the patient.
Point3D origin;
/** Bottom means downwards, DV means Direction Vector. Both relative to the image! */
VnlVector rightDV(3), bottomDV(3);
/** Origin of this plane is by default a zero vector and implicitly in the top-left corner: */
origin.Fill(0);
/** This is different to all definitions in MITK, except the QT mouse clicks.
* But it is like this here and we don't want to change a running system.
* Just be aware, that IN THIS FUNCTION we define the origin at the top left (e.g. your screen). */
/** NormalDirection defines which axis (i.e. column index in the transform matrix)
* is perpendicular to the plane: */
int normalDirection;
switch (planeorientation) // Switch through our limited choice of standard planes:
{
- case None:
- /** Orientation 'None' shall be done like the axial plane orientation,
+ case AnatomicalPlane::Original:
+ /** Orientation 'Original' shall be done like the axial plane,
* for whatever reasons. */
- case Axial:
+ case AnatomicalPlane::Axial:
if (frontside) // Radiologist's view from below. A cut along the triangle ear-ear-nose.
{
if (rotated == false)
/** Origin in the top-left corner, x=[1; 0; 0], y=[0; 1; 0], z=[0; 0; 1],
* origin=[0,0,zpos]: LAI (r.h.)
*
* 0---rightDV----> |
* | |
* | Picture of a finite, rectangular plane |
* | ( insert LOLCAT-scan here ^_^ ) |
* | |
* v _________________________________________|
*
*/
{
FillVector3D(origin, 0, 0, zPosition);
FillVector3D(rightDV, 1, 0, 0);
FillVector3D(bottomDV, 0, 1, 0);
}
else // Origin rotated to the bottom-right corner, x=[-1; 0; 0], y=[0; -1; 0], z=[0; 0; 1],
// origin=[w,h,zpos]: RPI (r.h.)
{ // Caveat emptor: Still using top-left as origin of index coordinate system!
FillVector3D(origin, width, height, zPosition);
FillVector3D(rightDV, -1, 0, 0);
FillVector3D(bottomDV, 0, -1, 0);
}
}
else // 'Backside, not frontside.' Neuro-Surgeons's view from above patient.
{
if (rotated == false) // x=[-1; 0; 0], y=[0; 1; 0], z=[0; 0; 1], origin=[w,0,zpos]: RAS (r.h.)
{
FillVector3D(origin, width, 0, zPosition);
FillVector3D(rightDV, -1, 0, 0);
FillVector3D(bottomDV, 0, 1, 0);
}
else // Origin in the bottom-left corner, x=[1; 0; 0], y=[0; -1; 0], z=[0; 0; 1],
// origin=[0,h,zpos]: LPS (r.h.)
{
FillVector3D(origin, 0, height, zPosition);
FillVector3D(rightDV, 1, 0, 0);
FillVector3D(bottomDV, 0, -1, 0);
}
}
normalDirection = 2; // That is S=Superior=z=third_axis=middlefinger in righthanded LPS-system.
break;
- case Coronal: // Coronal=Frontal plane; cuts through patient's ear-ear-heel-heel:
+ case AnatomicalPlane::Coronal: // Coronal=Frontal plane; cuts through patient's ear-ear-heel-heel:
if (frontside)
{
if (rotated == false) // x=[1; 0; 0], y=[0; 0; 1], z=[0; 1; 0], origin=[0,zpos,0]: LAI (r.h.)
{
FillVector3D(origin, 0, zPosition, 0);
FillVector3D(rightDV, 1, 0, 0);
FillVector3D(bottomDV, 0, 0, 1);
}
else // x=[-1;0;0], y=[0;0;-1], z=[0;1;0], origin=[w,zpos,h]: RAS (r.h.)
{
FillVector3D(origin, width, zPosition, height);
FillVector3D(rightDV, -1, 0, 0);
FillVector3D(bottomDV, 0, 0, -1);
}
}
else
{
if (rotated == false) // x=[-1;0;0], y=[0;0;1], z=[0;1;0], origin=[w,zpos,0]: RPI (r.h.)
{
FillVector3D(origin, width, zPosition, 0);
FillVector3D(rightDV, -1, 0, 0);
FillVector3D(bottomDV, 0, 0, 1);
}
else // x=[1;0;0], y=[0;1;0], z=[0;0;-1], origin=[0,zpos,h]: LPS (r.h.)
{
FillVector3D(origin, 0, zPosition, height);
FillVector3D(rightDV, 1, 0, 0);
FillVector3D(bottomDV, 0, 0, -1);
}
}
normalDirection = 1; // Normal vector = posterior direction.
break;
- case Sagittal: // Sagittal=Medial plane, the symmetry-plane mirroring your face.
+ case AnatomicalPlane::Sagittal: // Sagittal=Medial plane, the symmetry-plane mirroring your face.
if (frontside)
{
if (rotated == false) // x=[0;1;0], y=[0;0;1], z=[1;0;0], origin=[zpos,0,0]: LAI (r.h.)
{
FillVector3D(origin, zPosition, 0, 0);
FillVector3D(rightDV, 0, 1, 0);
FillVector3D(bottomDV, 0, 0, 1);
}
else // x=[0;-1;0], y=[0;0;-1], z=[1;0;0], origin=[zpos,w,h]: LPS (r.h.)
{
FillVector3D(origin, zPosition, width, height);
FillVector3D(rightDV, 0, -1, 0);
FillVector3D(bottomDV, 0, 0, -1);
}
}
else
{
if (rotated == false) // x=[0;-1;0], y=[0;0;1], z=[1;0;0], origin=[zpos,w,0]: RPI (r.h.)
{
FillVector3D(origin, zPosition, width, 0);
FillVector3D(rightDV, 0, -1, 0);
FillVector3D(bottomDV, 0, 0, 1);
}
else // x=[0;1;0], y=[0;0;-1], z=[1;0;0], origin=[zpos,0,h]: RAS (r.h.)
{
FillVector3D(origin, zPosition, 0, height);
FillVector3D(rightDV, 0, 1, 0);
FillVector3D(bottomDV, 0, 0, -1);
}
}
normalDirection = 0; // Normal vector = Lateral direction: Left in a LPS-system.
break;
default:
- itkExceptionMacro("unknown PlaneOrientation");
+ itkExceptionMacro("unknown AnatomicalPlane");
}
VnlVector normal(3);
FillVector3D(normal, 0, 0, 0);
normal[normalDirection] = top ? 1 : -1;
if ( transform != nullptr )
{
origin = transform->TransformPoint( origin );
rightDV = transform->TransformVector( rightDV ).as_ref();
bottomDV = transform->TransformVector( bottomDV ).as_ref();
normal = transform->TransformVector( normal ).as_ref();
}
ScalarType bounds[6] = {0, width, 0, height, 0, 1};
this->SetBounds(bounds);
AffineTransform3D::Pointer planeTransform = AffineTransform3D::New();
Matrix3D matrix;
matrix.GetVnlMatrix().set_column(0, rightDV.as_ref());
matrix.GetVnlMatrix().set_column(1, bottomDV.as_ref());
matrix.GetVnlMatrix().set_column(2, normal.as_ref());
planeTransform->SetMatrix(matrix);
planeTransform->SetOffset(this->GetIndexToWorldTransform()->GetOffset());
this->SetIndexToWorldTransform(planeTransform);
this->SetOrigin(origin);
}
std::vector< int > PlaneGeometry::CalculateDominantAxes(mitk::AffineTransform3D::MatrixType::InternalMatrixType& rotation_matrix)
{
std::vector< int > axes;
bool dominant_axis_error = false;
for (int i = 0; i < 3; ++i)
{
int dominantAxis = itk::Function::Max3(
rotation_matrix[0][i],
rotation_matrix[1][i],
rotation_matrix[2][i]
);
for (int j=0; j<i; ++j)
if (axes[j] == dominantAxis)
{
dominant_axis_error = true;
break;
}
if (dominant_axis_error)
break;
axes.push_back(dominantAxis);
}
if (dominant_axis_error)
{
MITK_DEBUG << "Error during dominant axis calculation. Using default.";
MITK_DEBUG << "This is either caused by an imperfect rotation matrix or if the rotation is axactly 45° around one or more axis.";
axes.clear();
for (int i = 0; i < 3; ++i)
axes.push_back(i);
}
return axes;
}
void PlaneGeometry::InitializeStandardPlane(const BaseGeometry *geometry3D,
- PlaneOrientation planeorientation,
+ AnatomicalPlane planeorientation,
ScalarType zPosition,
bool frontside,
bool rotated,
bool top)
{
this->SetReferenceGeometry(geometry3D);
ScalarType width, height;
// Inspired by:
// http://www.na-mic.org/Wiki/index.php/Coordinate_System_Conversion_Between_ITK_and_Slicer3
mitk::AffineTransform3D::MatrixType matrix = geometry3D->GetIndexToWorldTransform()->GetMatrix();
matrix.GetVnlMatrix().normalize_columns();
mitk::AffineTransform3D::MatrixType::InternalMatrixType inverseMatrix = matrix.GetTranspose();
/// The index of the sagittal, coronal and axial axes in the reference geometry.
auto axes = CalculateDominantAxes(inverseMatrix);
/// The direction of the sagittal, coronal and axial axes in the reference geometry.
/// +1 means that the direction is straight, i.e. greater index translates to greater
/// world coordinate. -1 means that the direction is inverted.
int directions[3];
ScalarType extents[3];
ScalarType spacings[3];
for (int i=0; i<3; ++i)
{
int dominantAxis = axes.at(i);
directions[i] = itk::Function::Sign(inverseMatrix[dominantAxis][i]);
extents[i] = geometry3D->GetExtent(dominantAxis);
spacings[i] = geometry3D->GetSpacing()[dominantAxis];
}
// matrix(column) = inverseTransformMatrix(row) * flippedAxes * spacing
matrix[0][0] = inverseMatrix[axes[0]][0] * directions[0] * spacings[0];
matrix[1][0] = inverseMatrix[axes[0]][1] * directions[0] * spacings[0];
matrix[2][0] = inverseMatrix[axes[0]][2] * directions[0] * spacings[0];
matrix[0][1] = inverseMatrix[axes[1]][0] * directions[1] * spacings[1];
matrix[1][1] = inverseMatrix[axes[1]][1] * directions[1] * spacings[1];
matrix[2][1] = inverseMatrix[axes[1]][2] * directions[1] * spacings[1];
matrix[0][2] = inverseMatrix[axes[2]][0] * directions[2] * spacings[2];
matrix[1][2] = inverseMatrix[axes[2]][1] * directions[2] * spacings[2];
matrix[2][2] = inverseMatrix[axes[2]][2] * directions[2] * spacings[2];
/// The "world origin" is the corner with the lowest physical coordinates.
/// We use it as a reference point so that we get the correct anatomical
/// orientations.
Point3D worldOrigin = geometry3D->GetOrigin();
for (int i = 0; i < 3; ++i)
{
/// The distance of the plane origin from the world origin in voxels.
double offset = directions[i] > 0 ? 0.0 : extents[i];
if (geometry3D->GetImageGeometry())
{
offset += directions[i] * 0.5;
}
for (int j = 0; j < 3; ++j)
{
worldOrigin[j] -= offset * matrix[j][i];
}
}
switch(planeorientation)
{
- case None:
- /** Orientation 'None' shall be done like the axial plane orientation,
+ case AnatomicalPlane::Original:
+ /** Orientation 'Original' shall be done like the axial plane orientation,
* for whatever reasons. */
- case Axial:
+ case AnatomicalPlane::Axial:
width = extents[0];
height = extents[1];
break;
- case Coronal:
+ case AnatomicalPlane::Coronal:
width = extents[0];
height = extents[2];
break;
- case Sagittal:
+ case AnatomicalPlane::Sagittal:
width = extents[1];
height = extents[2];
break;
default:
- itkExceptionMacro("unknown PlaneOrientation");
+ itkExceptionMacro("unknown AnatomicalPlane");
}
ScalarType bounds[6]= { 0, width, 0, height, 0, 1 };
this->SetBounds( bounds );
AffineTransform3D::Pointer transform = AffineTransform3D::New();
transform->SetMatrix(matrix);
transform->SetOffset(worldOrigin.GetVectorFromOrigin());
InitializeStandardPlane(
width, height, transform, planeorientation, zPosition, frontside, rotated, top);
}
- void PlaneGeometry::InitializeStandardPlane(
- const BaseGeometry *geometry3D, bool top, PlaneOrientation planeorientation, bool frontside, bool rotated)
+ void PlaneGeometry::InitializeStandardPlane(const BaseGeometry *geometry3D,
+ bool top,
+ AnatomicalPlane planeorientation,
+ bool frontside,
+ bool rotated)
{
/// The index of the sagittal, coronal and axial axes in world coordinate system.
int worldAxis;
switch(planeorientation)
{
- case None:
- /** Orientation 'None' shall be done like the axial plane orientation,
+ case AnatomicalPlane::Original:
+ /** Orientation 'Original' shall be done like the axial plane orientation,
* for whatever reasons. */
- case Axial:
+ case AnatomicalPlane::Axial:
worldAxis = 2;
break;
- case Coronal:
+ case AnatomicalPlane::Coronal:
worldAxis = 1;
break;
- case Sagittal:
+ case AnatomicalPlane::Sagittal:
worldAxis = 0;
break;
default:
- itkExceptionMacro("unknown PlaneOrientation");
+ itkExceptionMacro("unknown AnatomicalPlane");
}
// Inspired by:
// http://www.na-mic.org/Wiki/index.php/Coordinate_System_Conversion_Between_ITK_and_Slicer3
mitk::AffineTransform3D::ConstPointer affineTransform = geometry3D->GetIndexToWorldTransform();
mitk::AffineTransform3D::MatrixType matrix = affineTransform->GetMatrix();
matrix.GetVnlMatrix().normalize_columns();
mitk::AffineTransform3D::MatrixType::InternalMatrixType inverseMatrix = matrix.GetInverse();
/// The index of the sagittal, coronal and axial axes in the reference geometry.
int dominantAxis = CalculateDominantAxes(inverseMatrix).at(worldAxis);
ScalarType zPosition = top ? 0.5 : geometry3D->GetExtent(dominantAxis) - 0.5;
InitializeStandardPlane(geometry3D, planeorientation, zPosition, frontside, rotated, top);
}
void PlaneGeometry::InitializeStandardPlane(const Vector3D &rightVector,
const Vector3D &downVector,
const Vector3D *spacing)
{
InitializeStandardPlane(rightVector.GetVnlVector(), downVector.GetVnlVector(), spacing);
}
void PlaneGeometry::InitializeStandardPlane(const VnlVector &rightVector,
const VnlVector &downVector,
const Vector3D *spacing)
{
ScalarType width = rightVector.two_norm();
ScalarType height = downVector.two_norm();
InitializeStandardPlane(width, height, rightVector, downVector, spacing);
}
void PlaneGeometry::InitializeStandardPlane(mitk::ScalarType width,
ScalarType height,
const Vector3D &rightVector,
const Vector3D &downVector,
const Vector3D *spacing)
{
InitializeStandardPlane(width, height, rightVector.GetVnlVector(), downVector.GetVnlVector(), spacing);
}
void PlaneGeometry::InitializeStandardPlane(mitk::ScalarType width,
ScalarType height,
const VnlVector &rightVector,
const VnlVector &downVector,
const Vector3D *spacing)
{
assert(width > 0);
assert(height > 0);
VnlVector rightDV = rightVector;
rightDV.normalize();
VnlVector downDV = downVector;
downDV.normalize();
VnlVector normal = vnl_cross_3d(rightVector, downVector);
normal.normalize();
// Crossproduct vnl_cross_3d is always righthanded, but that is okay here
// because in this method we create a new IndexToWorldTransform and
// spacing with 1 or 3 negative components could still make it lefthanded.
if (spacing != nullptr)
{
rightDV *= (*spacing)[0];
downDV *= (*spacing)[1];
normal *= (*spacing)[2];
}
AffineTransform3D::Pointer transform = AffineTransform3D::New();
Matrix3D matrix;
matrix.GetVnlMatrix().set_column(0, rightDV);
matrix.GetVnlMatrix().set_column(1, downDV);
matrix.GetVnlMatrix().set_column(2, normal);
transform->SetMatrix(matrix);
transform->SetOffset(this->GetIndexToWorldTransform()->GetOffset());
ScalarType bounds[6] = {0, width, 0, height, 0, 1};
this->SetBounds(bounds);
this->SetIndexToWorldTransform(transform);
}
void PlaneGeometry::InitializePlane(const Point3D &origin, const Vector3D &normal)
{
VnlVector rightVectorVnl(3), downVectorVnl;
if (Equal(normal[1], 0.0f) == false)
{
FillVector3D(rightVectorVnl, 1.0f, -normal[0] / normal[1], 0.0f);
rightVectorVnl.normalize();
}
else
{
FillVector3D(rightVectorVnl, 0.0f, 1.0f, 0.0f);
}
downVectorVnl = vnl_cross_3d(normal.GetVnlVector(), rightVectorVnl);
downVectorVnl.normalize();
// Crossproduct vnl_cross_3d is always righthanded.
InitializeStandardPlane(rightVectorVnl, downVectorVnl);
SetOrigin(origin);
}
void PlaneGeometry::SetMatrixByVectors(const VnlVector &rightVector,
const VnlVector &downVector,
ScalarType thickness /* = 1.0 */)
{
VnlVector normal = vnl_cross_3d(rightVector, downVector);
normal.normalize();
normal *= thickness;
// Crossproduct vnl_cross_3d is always righthanded, but that is okay here
// because in this method we create a new IndexToWorldTransform and
// a negative thickness could still make it lefthanded.
AffineTransform3D::Pointer transform = AffineTransform3D::New();
Matrix3D matrix;
matrix.GetVnlMatrix().set_column(0, rightVector);
matrix.GetVnlMatrix().set_column(1, downVector);
matrix.GetVnlMatrix().set_column(2, normal);
transform->SetMatrix(matrix);
transform->SetOffset(this->GetIndexToWorldTransform()->GetOffset());
SetIndexToWorldTransform(transform);
}
Vector3D PlaneGeometry::GetNormal() const
{
Vector3D frontToBack;
frontToBack.SetVnlVector(this->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(2).as_ref());
return frontToBack;
}
VnlVector PlaneGeometry::GetNormalVnl() const
{
return this->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(2).as_ref();
}
ScalarType PlaneGeometry::DistanceFromPlane(const Point3D &pt3d_mm) const { return fabs(SignedDistance(pt3d_mm)); }
ScalarType PlaneGeometry::SignedDistance(const Point3D &pt3d_mm) const { return SignedDistanceFromPlane(pt3d_mm); }
bool PlaneGeometry::IsAbove(const Point3D &pt3d_mm, bool considerBoundingBox) const
{
if (considerBoundingBox)
{
Point3D pt3d_units;
BaseGeometry::WorldToIndex(pt3d_mm, pt3d_units);
return (pt3d_units[2] > this->GetBoundingBox()->GetBounds()[4]);
}
else
return SignedDistanceFromPlane(pt3d_mm) > 0;
}
bool PlaneGeometry::IntersectionLine(const PlaneGeometry* plane, Line3D& crossline) const
{
Vector3D normal = this->GetNormal();
normal.Normalize();
Vector3D planeNormal = plane->GetNormal();
planeNormal.Normalize();
Vector3D direction = itk::CrossProduct(normal, planeNormal);
if (direction.GetSquaredNorm() < eps)
return false;
crossline.SetDirection(direction);
double N1dN2 = normal * planeNormal;
double determinant = 1.0 - N1dN2 * N1dN2;
Vector3D origin = this->GetOrigin().GetVectorFromOrigin();
Vector3D planeOrigin = plane->GetOrigin().GetVectorFromOrigin();
double d1 = normal * origin;
double d2 = planeNormal * planeOrigin;
double c1 = (d1 - d2 * N1dN2) / determinant;
double c2 = (d2 - d1 * N1dN2) / determinant;
Vector3D p = normal * c1 + planeNormal * c2;
crossline.GetPoint()[0] = p.GetVnlVector()[0];
crossline.GetPoint()[1] = p.GetVnlVector()[1];
crossline.GetPoint()[2] = p.GetVnlVector()[2];
return true;
}
unsigned int PlaneGeometry::IntersectWithPlane2D(const PlaneGeometry *plane, Point2D &lineFrom, Point2D &lineTo) const
{
Line3D crossline;
if (this->IntersectionLine(plane, crossline) == false)
return 0;
Point2D point2;
Vector2D direction2;
this->Map(crossline.GetPoint(), point2);
this->Map(crossline.GetPoint(), crossline.GetDirection(), direction2);
return Line3D::RectangleLineIntersection(
0, 0, GetExtentInMM(0), GetExtentInMM(1), point2, direction2, lineFrom, lineTo);
}
double PlaneGeometry::Angle(const PlaneGeometry *plane) const
{
return angle(plane->GetMatrixColumn(2), GetMatrixColumn(2));
}
double PlaneGeometry::Angle(const Line3D &line) const
{
return vnl_math::pi_over_2 - angle(line.GetDirection().GetVnlVector(), GetMatrixColumn(2));
}
bool PlaneGeometry::IntersectionPoint(const Line3D &line, Point3D &intersectionPoint) const
{
Vector3D planeNormal = this->GetNormal();
planeNormal.Normalize();
Vector3D lineDirection = line.GetDirection();
lineDirection.Normalize();
double t = planeNormal * lineDirection;
if (fabs(t) < eps)
{
return false;
}
Vector3D diff;
diff = this->GetOrigin() - line.GetPoint();
t = (planeNormal * diff) / t;
intersectionPoint = line.GetPoint() + lineDirection * t;
return true;
}
bool PlaneGeometry::IntersectionPointParam(const Line3D &line, double &t) const
{
Vector3D planeNormal = this->GetNormal();
Vector3D lineDirection = line.GetDirection();
t = planeNormal * lineDirection;
if (fabs(t) < eps)
{
return false;
}
Vector3D diff;
diff = this->GetOrigin() - line.GetPoint();
t = (planeNormal * diff) / t;
return true;
}
bool PlaneGeometry::IsParallel(const PlaneGeometry *plane) const
{
return ((Angle(plane) < 10.0 * mitk::sqrteps) || (Angle(plane) > (vnl_math::pi - 10.0 * sqrteps)));
}
bool PlaneGeometry::IsOnPlane(const Point3D &point) const { return Distance(point) < eps; }
bool PlaneGeometry::IsOnPlane(const Line3D &line) const
{
return ((Distance(line.GetPoint()) < eps) && (Distance(line.GetPoint2()) < eps));
}
bool PlaneGeometry::IsOnPlane(const PlaneGeometry *plane) const
{
return (IsParallel(plane) && (Distance(plane->GetOrigin()) < eps));
}
Point3D PlaneGeometry::ProjectPointOntoPlane(const Point3D &pt) const
{
ScalarType len = this->GetNormalVnl().two_norm();
return pt - this->GetNormal() * this->SignedDistanceFromPlane(pt) / len;
}
itk::LightObject::Pointer PlaneGeometry::InternalClone() const
{
Self::Pointer newGeometry = new PlaneGeometry(*this);
newGeometry->UnRegister();
return newGeometry.GetPointer();
}
void PlaneGeometry::ExecuteOperation(Operation *operation)
{
vtkTransform *transform = vtkTransform::New();
transform->SetMatrix(this->GetVtkMatrix());
switch (operation->GetOperationType())
{
case OpORIENT:
{
auto *planeOp = dynamic_cast<mitk::PlaneOperation *>(operation);
if (planeOp == nullptr)
{
return;
}
Point3D center = planeOp->GetPoint();
Vector3D orientationVector = planeOp->GetNormal();
Vector3D defaultVector;
FillVector3D(defaultVector, 0.0, 0.0, 1.0);
Vector3D rotationAxis = itk::CrossProduct(orientationVector, defaultVector);
// double rotationAngle = acos( orientationVector[2] / orientationVector.GetNorm() );
double rotationAngle = atan2((double)rotationAxis.GetNorm(), (double)(orientationVector * defaultVector));
rotationAngle *= 180.0 / vnl_math::pi;
transform->PostMultiply();
transform->Identity();
transform->Translate(center[0], center[1], center[2]);
transform->RotateWXYZ(rotationAngle, rotationAxis[0], rotationAxis[1], rotationAxis[2]);
transform->Translate(-center[0], -center[1], -center[2]);
break;
}
case OpRESTOREPLANEPOSITION:
{
auto *op = dynamic_cast<mitk::RestorePlanePositionOperation *>(operation);
if (op == nullptr)
{
return;
}
AffineTransform3D::Pointer transform2 = AffineTransform3D::New();
Matrix3D matrix;
matrix.GetVnlMatrix().set_column(0, op->GetTransform()->GetMatrix().GetVnlMatrix().get_column(0));
matrix.GetVnlMatrix().set_column(1, op->GetTransform()->GetMatrix().GetVnlMatrix().get_column(1));
matrix.GetVnlMatrix().set_column(2, op->GetTransform()->GetMatrix().GetVnlMatrix().get_column(2));
transform2->SetMatrix(matrix);
Vector3D offset = op->GetTransform()->GetOffset();
transform2->SetOffset(offset);
this->SetIndexToWorldTransform(transform2);
ScalarType bounds[6] = {0, op->GetWidth(), 0, op->GetHeight(), 0, 1};
this->SetBounds(bounds);
this->Modified();
transform->Delete();
return;
}
default:
Superclass::ExecuteOperation(operation);
transform->Delete();
return;
}
this->SetVtkMatrixDeepCopy(transform);
this->Modified();
transform->Delete();
}
void PlaneGeometry::PrintSelf(std::ostream &os, itk::Indent indent) const
{
Superclass::PrintSelf(os, indent);
os << indent << " ScaleFactorMMPerUnitX: " << GetExtentInMM(0) / GetExtent(0) << std::endl;
os << indent << " ScaleFactorMMPerUnitY: " << GetExtentInMM(1) / GetExtent(1) << std::endl;
os << indent << " Normal: " << GetNormal() << std::endl;
}
bool PlaneGeometry::Map(const mitk::Point3D &pt3d_mm, mitk::Point2D &pt2d_mm) const
{
assert(this->IsBoundingBoxNull() == false);
Point3D pt3d_units;
Superclass::WorldToIndex(pt3d_mm, pt3d_units);
pt2d_mm[0] = pt3d_units[0] * GetExtentInMM(0) / GetExtent(0);
pt2d_mm[1] = pt3d_units[1] * GetExtentInMM(1) / GetExtent(1);
pt3d_units[2] = 0;
return this->GetBoundingBox()->IsInside(pt3d_units);
}
void PlaneGeometry::Map(const mitk::Point2D &pt2d_mm, mitk::Point3D &pt3d_mm) const
{
// pt2d_mm is measured from the origin of the world geometry (at least it called form BaseRendere::Mouse...Event)
Point3D pt3d_units;
pt3d_units[0] = pt2d_mm[0] / (GetExtentInMM(0) / GetExtent(0));
pt3d_units[1] = pt2d_mm[1] / (GetExtentInMM(1) / GetExtent(1));
pt3d_units[2] = 0;
// pt3d_units is a continuous index. We divided it with the Scale Factor (= spacing in x and y) to convert it from mm
// to index units.
//
pt3d_mm = GetIndexToWorldTransform()->TransformPoint(pt3d_units);
// now we convert the 3d index to a 3D world point in mm. We could have used IndexToWorld as well as
// GetITW->Transform...
}
void PlaneGeometry::SetSizeInUnits(mitk::ScalarType width, mitk::ScalarType height)
{
ScalarType bounds[6] = {0, width, 0, height, 0, 1};
ScalarType extent, newextentInMM;
if (GetExtent(0) > 0)
{
extent = GetExtent(0);
if (width > extent)
newextentInMM = GetExtentInMM(0) / width * extent;
else
newextentInMM = GetExtentInMM(0) * extent / width;
SetExtentInMM(0, newextentInMM);
}
if (GetExtent(1) > 0)
{
extent = GetExtent(1);
if (width > extent)
newextentInMM = GetExtentInMM(1) / height * extent;
else
newextentInMM = GetExtentInMM(1) * extent / height;
SetExtentInMM(1, newextentInMM);
}
SetBounds(bounds);
}
bool PlaneGeometry::Project(const mitk::Point3D &pt3d_mm, mitk::Point3D &projectedPt3d_mm) const
{
assert(this->IsBoundingBoxNull() == false);
Point3D pt3d_units;
Superclass::WorldToIndex(pt3d_mm, pt3d_units);
pt3d_units[2] = 0;
projectedPt3d_mm = GetIndexToWorldTransform()->TransformPoint(pt3d_units);
return this->GetBoundingBox()->IsInside(pt3d_units);
}
bool PlaneGeometry::Project(const mitk::Vector3D &vec3d_mm, mitk::Vector3D &projectedVec3d_mm) const
{
assert(this->IsBoundingBoxNull() == false);
Vector3D vec3d_units;
Superclass::WorldToIndex(vec3d_mm, vec3d_units);
vec3d_units[2] = 0;
projectedVec3d_mm = GetIndexToWorldTransform()->TransformVector(vec3d_units);
return true;
}
bool PlaneGeometry::Project(const mitk::Point3D &atPt3d_mm,
const mitk::Vector3D &vec3d_mm,
mitk::Vector3D &projectedVec3d_mm) const
{
MITK_WARN << "Deprecated function! Call Project(vec3D,vec3D) instead.";
assert(this->IsBoundingBoxNull() == false);
Vector3D vec3d_units;
Superclass::WorldToIndex(atPt3d_mm, vec3d_mm, vec3d_units);
vec3d_units[2] = 0;
projectedVec3d_mm = GetIndexToWorldTransform()->TransformVector(vec3d_units);
Point3D pt3d_units;
Superclass::WorldToIndex(atPt3d_mm, pt3d_units);
return this->GetBoundingBox()->IsInside(pt3d_units);
}
bool PlaneGeometry::Map(const mitk::Point3D &atPt3d_mm,
const mitk::Vector3D &vec3d_mm,
mitk::Vector2D &vec2d_mm) const
{
Point2D pt2d_mm_start, pt2d_mm_end;
Point3D pt3d_mm_end;
bool inside = Map(atPt3d_mm, pt2d_mm_start);
pt3d_mm_end = atPt3d_mm + vec3d_mm;
inside &= Map(pt3d_mm_end, pt2d_mm_end);
vec2d_mm = pt2d_mm_end - pt2d_mm_start;
return inside;
}
void PlaneGeometry::Map(const mitk::Point2D & /*atPt2d_mm*/,
const mitk::Vector2D & /*vec2d_mm*/,
mitk::Vector3D & /*vec3d_mm*/) const
{
//@todo implement parallel to the other Map method!
assert(false);
}
void PlaneGeometry::SetReferenceGeometry(const mitk::BaseGeometry *geometry) { m_ReferenceGeometry = geometry; }
const mitk::BaseGeometry *PlaneGeometry::GetReferenceGeometry() const { return m_ReferenceGeometry; }
bool PlaneGeometry::HasReferenceGeometry() const { return (m_ReferenceGeometry != nullptr); }
} // namespace