mitkSlicedGeometry3D.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 mitkSlicedGeometry3D_h
#define mitkSlicedGeometry3D_h
 
#include "mitkBaseGeometry.h"
#include "mitkPlaneGeometry.h"
 
namespace mitk
{
  class SliceNavigationController;
  class NavigationController;
 
  class MITKCORE_EXPORT SlicedGeometry3D : public mitk::BaseGeometry
  {
  public:
    mitkClassMacro(SlicedGeometry3D, BaseGeometry);
 
      itkFactorylessNewMacro(Self);
      itkCloneMacro(Self);
 
      virtual mitk::PlaneGeometry *GetPlaneGeometry(int s) const;
    DEPRECATED(const PlaneGeometry *GetGeometry2D(int s)) { return GetPlaneGeometry(s); }
    DEPRECATED(void SetGeometry2D(PlaneGeometry *geo, int s)) { SetPlaneGeometry(geo, s); }
    //##Documentation
    //## @brief When switching from an Image Geometry to a normal Geometry (and the other way around), you have to
    //change
    // the origin as well (See Geometry Documentation)! This function will change the "isImageGeometry" bool flag and
    // changes the origin respectively.
    void ChangeImageGeometryConsideringOriginOffset(const bool isAnImageGeometry) override;
 
    // virtual void SetTimeBounds( const mitk::TimeBounds& timebounds );
    const mitk::BoundingBox *GetBoundingBox() const override;
 
    itkGetConstMacro(Slices, unsigned int);
 
      virtual bool SetPlaneGeometry(mitk::PlaneGeometry *geometry2D, int s);
 
    virtual bool IsValidSlice(int s = 0) const;
 
    virtual const BaseGeometry* GetReferenceGeometry() const;
 
    virtual void SetReferenceGeometry(const BaseGeometry *referenceGeometry);
 
    bool HasReferenceGeometry() const;
 
    virtual void SetSliceNavigationController(mitk::SliceNavigationController *snc);
    mitk::SliceNavigationController *GetSliceNavigationController();
 
    itkGetConstMacro(EvenlySpaced, bool);
 
      virtual void SetEvenlySpaced(bool on = true);
 
    virtual void SetDirectionVector(const mitk::Vector3D &directionVector);
    itkGetConstMacro(DirectionVector, const mitk::Vector3D &);
 
      itk::LightObject::Pointer InternalClone() const override;
 
#ifndef SWIG
 
    static const std::string SLICES;
    const static std::string DIRECTION_VECTOR;
    const static std::string EVENLY_SPACED;
 
#endif // !SWIG
 
    virtual void InitializeSlicedGeometry(unsigned int slices);
 
    virtual void InitializeEvenlySpaced(mitk::PlaneGeometry *geometry2D, unsigned int slices);
 
    virtual void InitializeEvenlySpaced(mitk::PlaneGeometry *geometry2D,
                                        mitk::ScalarType zSpacing,
                                        unsigned int slices);
 
    virtual void InitializePlanes(const mitk::BaseGeometry *geometry3D,
                                  mitk::AnatomicalPlane orientation,
                                  bool top = true,
                                  bool frontside = true,
                                  bool rotated = false);
 
    void SetImageGeometry(const bool isAnImageGeometry) override;
 
    void ExecuteOperation(Operation *operation) override;
 
    static double CalculateSpacing(const mitk::Vector3D &spacing, const mitk::Vector3D &d);
 
  protected:
    SlicedGeometry3D();
 
    SlicedGeometry3D(const SlicedGeometry3D &other);
 
    ~SlicedGeometry3D() override;
 
    virtual void ReinitializePlanes(const Point3D &center, const Point3D &referencePoint);
 
    ScalarType GetLargestExtent(const BaseGeometry *geometry);
 
    void PrintSelf(std::ostream &os, itk::Indent indent) const override;
 
    double CalculateSpacing(const mitk::Vector3D &direction) const;
 
    mitk::Vector3D AdjustNormal(const mitk::Vector3D &normal) const;
 
    mutable std::vector<PlaneGeometry::Pointer> m_PlaneGeometries;
 
    bool m_EvenlySpaced;
 
    mutable mitk::Vector3D m_DirectionVector;
 
    unsigned int m_Slices;
 
    const mitk::BaseGeometry *m_ReferenceGeometry;
 
    // mitk::NavigationController *m_NavigationController;
    mitk::SliceNavigationController *m_SliceNavigationController;
 
    //##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;
  };
} // namespace mitk
 
#endif