mitkBaseGeometry.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 mitkBaseGeometry_h
#define mitkBaseGeometry_h
 
#include <mitkOperationActor.h>
#include <MitkCoreExports.h>
#include <mitkCommon.h>
 
#include <itkScalableAffineTransform.h>
#include <mitkNumericTypes.h>
#include <itkBoundingBox.h>
#include <itkIndex.h>
#include <itkQuaternionRigidTransform.h>
#include <mitkAffineTransform3D.h>
 
#include <mitkGeometryTransformHolder.h>
#include <vtkTransform.h>
 
class vtkMatrix4x4;
class vtkMatrixToLinearTransform;
class vtkLinearTransform;
 
namespace mitk
{
  typedef itk::BoundingBox<unsigned long, 3, ScalarType> BoundingBox;
 
  typedef itk::FixedArray<ScalarType, 2> TimeBounds;
 
  typedef itk::FixedArray<ScalarType, 3> FixedArrayType;
 
  class MITKCORE_EXPORT BaseGeometry : public itk::Object, public OperationActor
  {
  public:
    mitkClassMacroItkParent(BaseGeometry, itk::Object);
    itkCloneMacro(Self);
 
      // ********************************** TypeDef **********************************
 
      typedef GeometryTransformHolder::TransformType TransformType;
    typedef itk::BoundingBox<unsigned long, 3, ScalarType> BoundingBoxType;
    typedef BoundingBoxType::BoundsArrayType BoundsArrayType;
    typedef BoundingBoxType::Pointer BoundingBoxPointer;
 
    // ********************************** Origin, Spacing **********************************
 
    Point3D GetOrigin() const;
 
    void SetOrigin(const Point3D &origin);
 
    mitk::Vector3D GetSpacing() const;
 
    void SetSpacing(const mitk::Vector3D &aSpacing, bool enforceSetSpacing = false);
 
    VnlVector GetOriginVnl() const;
 
    // ********************************** other functions **********************************
 
    itkGetConstMacro(FrameOfReferenceID, unsigned int);
    itkSetMacro(FrameOfReferenceID, unsigned int);
 
    itkGetConstMacro(IndexToWorldTransformLastModified, unsigned long);
 
    void Modified() const override;
 
    friend class ModifiedLock;
 
    virtual bool IsValid() const;
 
    // ********************************** Initialize **********************************
 
    void Initialize();
 
    void InitializeGeometry(Self *newGeometry) const;
 
    // ********************************** Transformations Set/Get **********************************
 
    mitk::AffineTransform3D *GetIndexToWorldTransform();
 
    const mitk::AffineTransform3D *GetIndexToWorldTransform() const;
 
    void SetIndexToWorldTransform(mitk::AffineTransform3D *transform);
 
    void SetIndexToWorldTransformByVtkMatrix(vtkMatrix4x4 *vtkmatrix);
 
    void SetIndexToWorldTransformWithoutChangingSpacing(mitk::AffineTransform3D *transform);
 
    void SetIndexToWorldTransformByVtkMatrixWithoutChangingSpacing(vtkMatrix4x4 *vtkmatrix);
 
    vtkMatrix4x4 *GetVtkMatrix();
 
    const vtkMatrix4x4* GetVtkMatrix() const;
 
    vtkLinearTransform *GetVtkTransform() const;
 
    void SetIdentity();
 
    // ********************************** Transformations **********************************
 
    void Compose(const TransformType *other, bool pre = false);
 
    void Compose(const vtkMatrix4x4 *vtkmatrix, bool pre = false);
 
    void Translate(const Vector3D &vector);
 
    void ExecuteOperation(Operation *operation) override;
 
    void WorldToIndex(const mitk::Point3D &pt_mm, mitk::Point3D &pt_units) const;
 
    void WorldToIndex(const mitk::Vector3D &vec_mm, mitk::Vector3D &vec_units) const;
 
    template <unsigned int VIndexDimension>
    void WorldToIndex(const mitk::Point3D &pt_mm, itk::Index<VIndexDimension> &index) const
    {
      typedef itk::Index<VIndexDimension> IndexType;
      mitk::Point3D pt_units;
      this->WorldToIndex(pt_mm, pt_units);
      int i, dim = index.GetIndexDimension();
      if (dim > 3)
      {
        index.Fill(0);
        dim = 3;
      }
      for (i = 0; i < dim; ++i)
      {
        index[i] = itk::Math::RoundHalfIntegerUp<typename IndexType::IndexValueType>(pt_units[i]);
      }
    }
 
    void IndexToWorld(const mitk::Vector3D &vec_units, mitk::Vector3D &vec_mm) const;
 
    void IndexToWorld(const mitk::Point3D &pt_units, mitk::Point3D &pt_mm) const;
 
    template <unsigned int VIndexDimension>
    void IndexToWorld(const itk::Index<VIndexDimension> &index, mitk::Point3D &pt_mm) const
    {
      mitk::Point3D pt_units;
      pt_units.Fill(0);
      int i, dim = index.GetIndexDimension();
      if (dim > 3)
      {
        dim = 3;
      }
      for (i = 0; i < dim; ++i)
      {
        pt_units[i] = index[i];
      }
 
      IndexToWorld(pt_units, pt_mm);
    }
 
    template <class TCoordRep>
    void ItkPhysicalPointToWorld(const itk::Point<TCoordRep, 3> &itkPhysicalPoint, mitk::Point3D &pt_mm) const
    {
      mitk::FillArray(pt_mm, itkPhysicalPoint);
    }
 
    template <class TCoordRep>
    void WorldToItkPhysicalPoint(const mitk::Point3D &pt_mm, itk::Point<TCoordRep, 3> &itkPhysicalPoint) const
    {
      mitk::FillArray(itkPhysicalPoint, pt_mm);
    }
 
    // ********************************** BoundingBox **********************************
 
    itkGetConstObjectMacro(BoundingBox, BoundingBoxType);
 
// a bit of a misuse, but we want only doxygen to see the following:
#ifdef DOXYGEN_SKIP
    itkGetConstObjectMacro(BoundingBox, BoundingBoxType);
    const BoundsArrayType GetBounds() const;
#endif
    const BoundsArrayType GetBounds() const;
 
    void SetBounds(const BoundsArrayType &bounds);
 
    void SetFloatBounds(const float bounds[6]);
 
    void SetFloatBounds(const double bounds[6]);
 
    VnlVector GetMatrixColumn(unsigned int direction) const;
 
    mitk::BoundingBox::Pointer CalculateBoundingBoxRelativeToTransform(const mitk::AffineTransform3D *transform) const;
 
//##Documentation
//## @brief Set the time bounds (in ms)
// void SetTimeBounds(const TimeBounds& timebounds);
 
// ********************************** Geometry **********************************
 
#ifdef DOXYGEN_SKIP
    ScalarType GetExtent(unsigned int direction) const;
#endif
 
    ScalarType GetExtent(unsigned int direction) const;
 
    ScalarType GetExtentInMM(int direction) const;
 
    Vector3D GetAxisVector(unsigned int direction) const;
 
    virtual bool Is2DConvertable();
 
    Point3D GetCenter() const;
 
    double GetDiagonalLength2() const;
 
    double GetDiagonalLength() const;
 
    Point3D GetCornerPoint(int id) const;
 
    Point3D GetCornerPoint(bool xFront = true, bool yFront = true, bool zFront = true) const;
 
    void SetExtentInMM(int direction, ScalarType extentInMM);
 
    bool IsInside(const mitk::Point3D &p) const;
 
    bool IsIndexInside(const mitk::Point3D &index) const;
 
    template <unsigned int VIndexDimension>
    bool IsIndexInside(const itk::Index<VIndexDimension> &index) const
    {
      int i, dim = index.GetIndexDimension();
      Point3D pt_index;
      pt_index.Fill(0);
      for (i = 0; i < dim; ++i)
      {
        pt_index[i] = index[i];
      }
      return IsIndexInside(pt_index);
    }
 
    Point3D ClampPoint(const Point3D& point) const;
 
    // ********************************* Image Geometry ********************************
 
    virtual void ChangeImageGeometryConsideringOriginOffset(const bool isAnImageGeometry);
 
    itkGetConstMacro(ImageGeometry, bool)
 
      
      itkSetMacro(ImageGeometry, bool);
 
      itkBooleanMacro(ImageGeometry);
 
        const GeometryTransformHolder *GetGeometryTransformHolder() const;
 
    void MapAxesToOrientations(int axes[]) const;
 
  protected:
    // ********************************** Constructor **********************************
    BaseGeometry();
    BaseGeometry(const BaseGeometry &other);
    ~BaseGeometry() override;
 
    void PrintSelf(std::ostream &os, itk::Indent indent) const override;
 
    static const std::string GetTransformAsString(TransformType *transformType);
 
    itkGetConstMacro(NDimensions, unsigned int);
 
      bool IsBoundingBoxNull() const;
 
    bool IsIndexToWorldTransformNull() const;
 
    void SetVtkMatrixDeepCopy(vtkTransform *vtktransform);
 
    void _SetSpacing(const mitk::Vector3D &aSpacing, bool enforceSetSpacing = false);
 
    //##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();};
    virtual void PreSetSpacing(const mitk::Vector3D & /*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!)
    virtual void CheckBounds(const BoundsArrayType & /*bounds*/){};
 
    //##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);.
    virtual void CheckIndexToWorldTransform(mitk::AffineTransform3D * /*transform*/){};
 
  private:
    GeometryTransformHolder *m_GeometryTransform;
 
    void InitializeGeometryTransformHolder(const BaseGeometry *otherGeometry);
 
    //##Documentation
    //## @brief Bounding Box, which is axes-parallel in intrinsic coordinates
    //## (often integer indices of pixels)
    BoundingBoxPointer m_BoundingBox;
 
    unsigned int m_FrameOfReferenceID;
 
    // mitk::TimeBounds m_TimeBounds;
 
    static const unsigned int m_NDimensions = 3;
 
    mutable TransformType::Pointer m_InvertedTransform;
 
    mutable unsigned long m_IndexToWorldTransformLastModified;
 
    bool m_ImageGeometry;
 
    //##Documentation
    //## @brief ModifiedLockFlag is used to prohibit the call of Modified()
    //##
    //## For the use of this Flag, see class ModifiedLock. This flag should only be set
    //## by the ModifiedLock class!
    bool m_ModifiedLockFlag;
 
    //##Documentation
    //## @brief ModifiedcalledFlag is used to collect calls of Modified().
    //##
    //## For the use of this Flag, see class ModifiedLock. This flag should only be set
    //## by the Modified() function!
    mutable bool m_ModifiedCalledFlag;
  };
 
  // ********************************** Equal Functions **********************************
  //
  // Static compare functions mainly for testing
  //
  MITKCORE_EXPORT bool Equal(const mitk::BaseGeometry& leftHandSide,
    const mitk::BaseGeometry& rightHandSide,
    ScalarType coordinateEps,
    ScalarType directionEps,
    bool verbose = false);
 
  MITKCORE_EXPORT bool Equal(const mitk::BaseGeometry &leftHandSide,
                             const mitk::BaseGeometry &rightHandSide,
                             ScalarType eps = mitk::eps,
                             bool verbose = false);
 
  MITKCORE_EXPORT bool Equal(const mitk::BaseGeometry::TransformType &leftHandSide,
                             const mitk::BaseGeometry::TransformType &rightHandSide,
                             ScalarType eps,
                             bool verbose);
 
  MITKCORE_EXPORT bool Equal(const mitk::BaseGeometry::BoundingBoxType &leftHandSide,
                             const mitk::BaseGeometry::BoundingBoxType &rightHandSide,
                             ScalarType eps,
                             bool verbose);
 
  MITKCORE_EXPORT bool IsSubGeometry(const mitk::BaseGeometry& testGeo,
    const mitk::BaseGeometry& referenceGeo,
    ScalarType coordinateEps,
    ScalarType directionEps,
    bool verbose = false);
 
  MITKCORE_EXPORT bool IsSubGeometry(const mitk::BaseGeometry& testGeo,
    const mitk::BaseGeometry& referenceGeo,
    ScalarType eps = mitk::eps,
    bool verbose = false);
 
} // namespace mitk
 
#endif