mitkPlaneGeometry.h

Go to the documentation of this file.

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

Program:   Medical Imaging & Interaction Toolkit
Language:  C++
Date:      $Date$
Version:   $Revision$

Copyright (c) German Cancer Research Center, Division of Medical and
Biological Informatics. All rights reserved.
See MITKCopyright.txt or https://www.mitk.org/copyright.html for details.

This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE.  See the above copyright notices for more information.

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


#ifndef PLANEGEOMETRY_H_HEADER_INCLUDED_C1C68A2C
#define PLANEGEOMETRY_H_HEADER_INCLUDED_C1C68A2C

#include "mitkCommon.h"
#include "mitkGeometry2D.h"

#include <vnl/vnl_cross.h>

namespace mitk {

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



class MITK_CORE_EXPORT PlaneGeometry : public Geometry2D
{
public:
  mitkClassMacro(PlaneGeometry,Geometry2D);

  itkNewMacro(Self);

  enum PlaneOrientation { Transversal, Sagittal, Frontal };

  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 Point2D &atPt2d_units, 
    const Vector2D &vec_units, Vector2D &vec_mm) const;
  
  virtual void WorldToIndex(const Point2D &atPt2d_mm, 
    const Vector2D &vec_mm, Vector2D &vec_units) const;

  virtual void Initialize();

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


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


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


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

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


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


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


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

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

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


  static void EnsurePerpendicularNormal( AffineTransform3D* transform );


  Vector3D GetNormal() const;


  VnlVector GetNormalVnl() const;


  virtual ScalarType SignedDistance( const Point3D& pt3d_mm ) const;


  virtual bool IsAbove( const Point3D& pt3d_mm ) 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;


  virtual void SetIndexToWorldTransform( AffineTransform3D *transform);


  virtual void SetBounds( const BoundingBox::BoundsArrayType &bounds );


  AffineGeometryFrame3D::Pointer Clone() const;


  virtual void ExecuteOperation( Operation *operation );


protected:
  PlaneGeometry();

  virtual ~PlaneGeometry();

  virtual void InitializeGeometry( Self *newGeometry ) const;

  virtual void PrintSelf( std::ostream &os, itk::Indent indent ) const;
  
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 */