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 mitkPlaneGeometry_h
#define mitkPlaneGeometry_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 MITKCORE_EXPORT PlaneGeometry : public BaseGeometry
  {
  public:
    mitkClassMacro(PlaneGeometry, BaseGeometry);
 
    itkFactorylessNewMacro(Self);
    itkCloneMacro(Self);
 
    virtual void IndexToWorld(const Point2D &pt_units, Point2D &pt_mm) const;
 
    virtual void WorldToIndex(const Point2D &pt_mm, Point2D &pt_units) const;
 
    virtual void IndexToWorld(const mitk::Vector2D &vec_units, mitk::Vector2D &vec_mm) const;
 
    virtual void WorldToIndex(const mitk::Vector2D &vec_mm, mitk::Vector2D &vec_units) const;
 
    virtual void InitializeStandardPlane(const BaseGeometry *geometry3D,
                                         AnatomicalPlane planeorientation = AnatomicalPlane::Axial,
                                         ScalarType zPosition = 0,
                                         bool frontside = true,
                                         bool rotated = false,
                                         bool top = true);
 
    virtual void InitializeStandardPlane(const BaseGeometry *geometry3D,
                                         bool top,
                                         AnatomicalPlane planeorientation = AnatomicalPlane::Axial,
                                         bool frontside = true,
                                         bool rotated = false);
 
    virtual void InitializeStandardPlane(ScalarType width,
                                         ScalarType height,
                                         const AffineTransform3D *transform = nullptr,
                                         AnatomicalPlane planeorientation = AnatomicalPlane::Axial,
                                         ScalarType zPosition = 0,
                                         bool frontside = true,
                                         bool rotated = false,
                                         bool top = true);
 
    virtual void InitializeStandardPlane(ScalarType width,
                                         ScalarType height,
                                         const Vector3D &spacing,
                                         AnatomicalPlane planeorientation = AnatomicalPlane::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;
 
    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::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;
 
  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;
 
    mitkCloneMacro(Self);
 
  private:
    virtual bool operator==(const PlaneGeometry *) const { return false; };
    virtual bool operator!=(const PlaneGeometry *) const { return false; };
  };
} // namespace mitk
 
#endif