mitkSurfaceInterpolationController.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 mitkSurfaceInterpolationController_h
#define mitkSurfaceInterpolationController_h
 
#include <mitkDataStorage.h>
#include <mitkImage.h>
#include <mitkLabel.h>
#include <mitkSurface.h>
 
#include <MitkSurfaceInterpolationExports.h>
 
namespace mitk
{
  class ComputeContourSetNormalsFilter;
  class CreateDistanceImageFromSurfaceFilter;
  class LabelSetImage;
  class ReduceContourSetFilter;
 
  class MITKSURFACEINTERPOLATION_EXPORT SurfaceInterpolationController : public itk::Object
  {
  public:
    mitkClassMacroItkParent(SurfaceInterpolationController, itk::Object);
    itkFactorylessNewMacro(Self);
    itkCloneMacro(Self);
    itkGetMacro(DistanceImageSpacing, double);
 
    struct MITKSURFACEINTERPOLATION_EXPORT ContourPositionInformation
    {
      int Pos;
      unsigned int SliceIndex;
      Surface::Pointer Contour;
      Vector3D ContourNormal;
      Point3D ContourPoint;
      mitk::PlaneGeometry* Plane;
      mitk::Label::PixelType LabelValue;
      unsigned int LayerValue;
      size_t TimeStep;
 
      ContourPositionInformation()
        : Pos(-1),
          SliceIndex(0),
          Plane(nullptr),
          LabelValue(std::numeric_limits<mitk::Label::PixelType>::max()),
          LayerValue(std::numeric_limits<unsigned int>::max()),
          TimeStep(std::numeric_limits<size_t>::max())
      {
      }
    };
 
    typedef std::vector<ContourPositionInformation> ContourPositionInformationList;
    typedef std::vector<ContourPositionInformationList> ContourPositionInformationVec2D;
 
    //  first index is the current time step. second index is the layerID. third index is the contour index.
    typedef std::vector<ContourPositionInformationVec2D> ContourPositionInformationVec3D;
 
    typedef std::map<mitk::Image *, ContourPositionInformationVec3D> ContourListMap;
    typedef std::map<mitk::Image *, ContourPositionInformationVec2D> ContourContainer;
 
    static SurfaceInterpolationController *GetInstance();
 
    void SetCurrentTimePoint(TimePointType tp)
    {
      if (m_CurrentTimePoint != tp)
      {
        m_CurrentTimePoint = tp;
 
        if (m_SelectedSegmentation)
        {
          this->ReinitializeInterpolation();
        }
      }
    };
 
    TimePointType GetCurrentTimePoint() const { return m_CurrentTimePoint; };
 
    void AddNewContour(Surface::Pointer newContour);
 
    void AddNewContours(const std::vector<Surface::Pointer>& newContours, std::vector<const mitk::PlaneGeometry*>& contourPlanes, bool reinitializeAction = false);
 
    const mitk::Surface *GetContour(const ContourPositionInformation& contourInfo);
 
    mitk::Point3D ComputeInteriorPointOfContour(const ContourPositionInformation& contour,
                                                 mitk::LabelSetImage * labelSetImage);
 
    void AddLabelSetConnection();
 
    void RemoveLabelSetConnection();
 
    void RemoveLabelSetConnection(mitk::LabelSetImage* labelSetImage, unsigned int layerID);
 
 
    void ReinitializeInterpolation();
 
    void RemoveObservers();
 
    void AddLabelSetConnection(unsigned int layerID);
 
    void UnsetSelectedImage()
    {
      m_SelectedSegmentation = nullptr;
    }
 
    unsigned int GetNumberOfLayersInCurrentSegmentation() const;
 
    void SetNumberOfLayersInCurrentSegmentation(unsigned int);
 
    void OnRemoveLayer();
 
    void OnAddLayer();
 
    unsigned int GetNumberOfContours();
 
    void Interpolate();
 
    mitk::Surface::Pointer GetInterpolationResult();
 
    void SetMinSpacing(double minSpacing);
 
    void SetMaxSpacing(double maxSpacing);
 
    void SetDistanceImageVolume(unsigned int distImageVolume);
 
    mitk::Image::Pointer GetCurrentSegmentation();
 
    Surface *GetContoursAsSurface();
 
    void SetDataStorage(DataStorage::Pointer ds);
 
    DEPRECATED(void SetCurrentSegmentationInterpolationList(mitk::Image::Pointer segmentation));
 
    void SetCurrentInterpolationSession(mitk::Image::Pointer currentSegmentationImage);
 
    DEPRECATED(void RemoveSegmentationFromContourList(mitk::Image *segmentation));
 
    void RemoveInterpolationSession(mitk::Image::Pointer segmentationImage);
 
    bool ReplaceInterpolationSession(mitk::Image::Pointer oldSession, mitk::Image::Pointer newSession);
 
    void RemoveAllInterpolationSessions();
 
    mitk::Image *GetImage();
 
    ContourPositionInformationList* GetContours(unsigned int timeStep, unsigned int layerID);
 
    void CompleteReinitialization(const std::vector<mitk::Surface::Pointer>& contourList,
                                           std::vector<const mitk::PlaneGeometry *>& contourPlanes);
 
    void RemoveContours(mitk::Label::PixelType label, unsigned int timeStep, unsigned int layerID);
 
    double EstimatePortionOfNeededMemory();
 
    void AddActiveLabelContoursForInterpolation(mitk::Label::PixelType activeLabel);
 
    unsigned int GetNumberOfInterpolationSessions();
 
    bool RemoveContour(ContourPositionInformation contourInfo);
 
    mitk::DataNode* GetSegmentationImageNode();
 
 
 
  protected:
    SurfaceInterpolationController();
 
    ~SurfaceInterpolationController() override;
 
    template <typename TPixel, unsigned int VImageDimension>
    void GetImageBase(itk::Image<TPixel, VImageDimension> *input, itk::ImageBase<3>::Pointer &result);
 
  private:
 
    void OnSegmentationDeleted(const itk::Object *caller, const itk::EventObject &event);
 
    void OnRemoveLabel(mitk::Label::PixelType removedLabelValue);
 
    void AddPlaneGeometryNodeToDataStorage(const ContourPositionInformation& contourInfo);
 
    void OnActiveLabel(mitk::Label::PixelType);
 
    void ClearInterpolationSession();
 
    void AddToInterpolationPipeline(ContourPositionInformation& contourInfo, bool reinitializationAction = false);
 
    void OnLayerChanged();
 
    itk::SmartPointer<ReduceContourSetFilter> m_ReduceFilter;
    itk::SmartPointer<ComputeContourSetNormalsFilter> m_NormalsFilter;
    itk::SmartPointer<CreateDistanceImageFromSurfaceFilter> m_InterpolateSurfaceFilter;
 
    mitk::Surface::Pointer m_Contours;
 
    double m_DistanceImageSpacing;
 
    vtkSmartPointer<vtkPolyData> m_PolyData;
 
    mitk::DataStorage::Pointer m_DataStorage;
 
    ContourContainer m_ListOfInterpolationSessions;
    ContourListMap m_ListOfContours;
 
    mitk::Surface::Pointer m_InterpolationResult;
 
    unsigned int m_CurrentNumberOfReducedContours;
    unsigned int m_NumberOfConnectionsAdded;
 
    mitk::Image *m_SelectedSegmentation;
 
    std::map<mitk::Image *, unsigned long> m_SegmentationObserverTags;
 
    mitk::TimePointType m_CurrentTimePoint;
 
    unsigned int m_ContourIndex;
    unsigned int m_ContourPosIndex;
    unsigned int m_NumberOfLayersInCurrentSegmentation;
 
    mitk::Label::PixelType m_PreviousActiveLabelValue;
    mitk::Label::PixelType m_CurrentActiveLabelValue;
 
    unsigned int m_PreviousLayerIndex;
    unsigned int m_CurrentLayerIndex;
  };
 
  namespace ContourExt
  {
    size_t GetContourOrientation(const mitk::Vector3D& ContourNormal);
 
    template<unsigned int VImageDimension>
    mitk::Point3D ComputeInteriorPointOfContour(const mitk::SurfaceInterpolationController::ContourPositionInformation& contour,
                                                 mitk::LabelSetImage * labelSetImage,
                                                 mitk::TimePointType currentTimePoint);
    std::vector< mitk::Point3D > GetBoundingBoxGridPoints(size_t planeDimension,
                                            double startDim1,
                                            size_t numPointsToSampleDim1,
                                            double deltaDim1,
                                            double startDim2,
                                            size_t numPointsToSampleDim2,
                                            double deltaDim2,
                                            double valuePlaneDim);
  };
 
}
 
#endif