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