mitkPlaneGeometry.h

Go to the documentation of this file.

/*============================================================================

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 PLANEGEOMETRY_H_HEADER_INCLUDED_C1C68A2C
#define PLANEGEOMETRY_H_HEADER_INCLUDED_C1C68A2C

#include "mitkBaseGeometry.h"
#include "mitkRestorePlanePositionOperation.h"
#include <MitkCoreExports.h>

#include <vnl/vnl_cross.h>

namespace mitk
{
  template <class TCoordRep, unsigned int NPointDimension>
  class Line;
  typedef Line<ScalarType, 3> Line3D;

  class PlaneGeometry;
  DEPRECATED(typedef PlaneGeometry Geometry2D);

  class MITKCORE_EXPORT PlaneGeometry : public BaseGeometry
  {
  public:
    mitkClassMacro(PlaneGeometry, BaseGeometry);

    itkFactorylessNewMacro(Self);
    itkCloneMacro(Self);

      enum PlaneOrientation {
        Axial,
        Sagittal,
        Frontal, // also known as "Coronal" in mitk.
        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;

    virtual void InitializeStandardPlane(const BaseGeometry *geometry3D,
                                         PlaneOrientation planeorientation = Axial,
                                         ScalarType zPosition = 0,
                                         bool frontside = true,
                                         bool rotated = false,
                                         bool top = true);

    virtual void InitializeStandardPlane(const BaseGeometry *geometry3D,
                                         bool top,
                                         PlaneOrientation planeorientation = Axial,
                                         bool frontside = true,
                                         bool rotated = false);

    virtual void InitializeStandardPlane(ScalarType width,
                                         ScalarType height,
                                         const AffineTransform3D *transform = nullptr,
                                         PlaneOrientation planeorientation = Axial,
                                         ScalarType zPosition = 0,
                                         bool frontside = true,
                                         bool rotated = false,
                                         bool top = true);

    virtual void InitializeStandardPlane(ScalarType width,
                                         ScalarType height,
                                         const Vector3D &spacing,
                                         PlaneOrientation planeorientation = Axial,
                                         ScalarType zPosition = 0,
                                         bool frontside = true,
                                         bool rotated = false,
                                         bool top = true);

    virtual void InitializeStandardPlane(ScalarType width,
                                         ScalarType height,
                                         const Vector3D &rightVector,
                                         const Vector3D &downVector,
                                         const Vector3D *spacing = nullptr);

    virtual void InitializeStandardPlane(ScalarType width,
                                         ScalarType height,
                                         const VnlVector &rightVector,
                                         const VnlVector &downVector,
                                         const Vector3D *spacing = nullptr);

    virtual void InitializeStandardPlane(const Vector3D &rightVector,
                                         const Vector3D &downVector,
                                         const Vector3D *spacing = nullptr);

    virtual void InitializeStandardPlane(const VnlVector &rightVector,
                                         const VnlVector &downVector,
                                         const Vector3D *spacing = nullptr);

    virtual void InitializePlane(const Point3D &origin, const Vector3D &normal);

    void SetMatrixByVectors(const VnlVector &rightVector, const VnlVector &downVector, ScalarType thickness = 1.0);

    static bool CheckRotationMatrix(AffineTransform3D *transform, double epsilon=1e-6);

    Vector3D GetNormal() const;

    VnlVector GetNormalVnl() const;

    virtual ScalarType SignedDistance(const Point3D &pt3d_mm) const;

    virtual bool IsAbove(const Point3D &pt3d_mm, bool considerBoundingBox = false) const;

    ScalarType DistanceFromPlane(const Point3D &pt3d_mm) const;

    inline ScalarType SignedDistanceFromPlane(const Point3D &pt3d_mm) const
    {
      ScalarType len = GetNormalVnl().two_norm();

      if (len == 0)
        return 0;

      return (pt3d_mm - GetOrigin()) * GetNormal() / len;
    }

    ScalarType DistanceFromPlane(const PlaneGeometry *plane) const { return fabs(SignedDistanceFromPlane(plane)); }
    inline ScalarType SignedDistanceFromPlane(const PlaneGeometry *plane) const
    {
      if (IsParallel(plane))
      {
        return SignedDistance(plane->GetOrigin());
      }
      return 0;
    }

    bool IntersectionLine(const PlaneGeometry *plane, Line3D &crossline) const;

    unsigned int IntersectWithPlane2D(const PlaneGeometry *plane, Point2D &lineFrom, Point2D &lineTo) const;

    double Angle(const PlaneGeometry *plane) const;

    double Angle(const Line3D &line) const;

    bool IntersectionPoint(const Line3D &line, Point3D &intersectionPoint) const;

    bool IntersectionPointParam(const Line3D &line, double &t) const;

    bool IsParallel(const PlaneGeometry *plane) const;

    bool IsOnPlane(const Point3D &point) const;

    bool IsOnPlane(const Line3D &line) const;

    bool IsOnPlane(const PlaneGeometry *plane) const;

    Point3D ProjectPointOntoPlane(const Point3D &pt) const;

    itk::LightObject::Pointer InternalClone() const override;

    void ExecuteOperation(Operation *operation) override;

    virtual bool Map(const mitk::Point3D &pt3d_mm, mitk::Point2D &pt2d_mm) const;

    virtual void Map(const mitk::Point2D &pt2d_mm, mitk::Point3D &pt3d_mm) const;

    virtual void SetSizeInUnits(mitk::ScalarType width, mitk::ScalarType height);

    virtual bool Project(const mitk::Point3D &pt3d_mm, mitk::Point3D &projectedPt3d_mm) const;

    virtual bool Map(const mitk::Point3D &atPt3d_mm, const mitk::Vector3D &vec3d_mm, mitk::Vector2D &vec2d_mm) const;

    virtual void Map(const mitk::Point2D &atPt2d_mm, const mitk::Vector2D &vec2d_mm, mitk::Vector3D &vec3d_mm) const;

    virtual bool Project(const mitk::Point3D &atPt3d_mm,
                         const mitk::Vector3D &vec3d_mm,
                         mitk::Vector3D &projectedVec3d_mm) const;

    virtual bool Project(const mitk::Vector3D &vec3d_mm, mitk::Vector3D &projectedVec3d_mm) const;

    inline ScalarType Distance(const Point3D &pt3d_mm) const { return fabs(SignedDistance(pt3d_mm)); }
    void SetReferenceGeometry(const mitk::BaseGeometry *geometry);

    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:
    virtual bool operator==(const PlaneGeometry *) const { return false; };
    virtual bool operator!=(const PlaneGeometry *) const { return false; };
  };
} // namespace mitk

#endif /* PLANEGEOMETRY_H_HEADER_INCLUDED_C1C68A2C */