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_Included
#define mitkSurfaceInterpolationController_h_Included
 
#include "mitkColorProperty.h"
#include "mitkCommon.h"
#include "mitkInteractionConst.h"
#include "mitkProperties.h"
#include "mitkRestorePlanePositionOperation.h"
#include "mitkSurface.h"
#include <MitkSurfaceInterpolationExports.h>
 
#include "mitkComputeContourSetNormalsFilter.h"
#include "mitkCreateDistanceImageFromSurfaceFilter.h"
#include "mitkReduceContourSetFilter.h"
 
#include "mitkDataNode.h"
#include "mitkDataStorage.h"
 
#include "vtkAppendPolyData.h"
#include "vtkCellArray.h"
#include "vtkPoints.h"
#include "vtkPolyData.h"
#include "vtkPolygon.h"
#include "vtkSmartPointer.h"
 
#include "mitkImageTimeSelector.h"
#include "mitkVtkRepresentationProperty.h"
#include "vtkImageData.h"
#include "vtkMarchingCubes.h"
#include "vtkProperty.h"
 
#include "mitkProgressBar.h"
 
namespace mitk
{
  class MITKSURFACEINTERPOLATION_EXPORT SurfaceInterpolationController : public itk::Object
  {
  public:
    mitkClassMacroItkParent(SurfaceInterpolationController, itk::Object);
    itkFactorylessNewMacro(Self);
    itkCloneMacro(Self);
    itkGetMacro(DistanceImageSpacing, double);
 
    struct ContourPositionInformation
    {
      Surface::Pointer contour;
      Vector3D contourNormal;
      Point3D contourPoint;
    };
 
    typedef std::vector<ContourPositionInformation> ContourPositionInformationList;
    typedef std::vector<ContourPositionInformationList> ContourPositionInformationVec2D;
    typedef std::map<mitk::Image *, ContourPositionInformationVec2D> ContourListMap;
 
    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);
 
    bool RemoveContour(ContourPositionInformation contourInfo);
 
    void AddNewContours(std::vector<Surface::Pointer> newContours);
 
    const mitk::Surface *GetContour(ContourPositionInformation contourInfo);
 
    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();
 
    void ReinitializeInterpolation(mitk::Surface::Pointer contours);
 
    mitk::Image *GetImage();
 
    double EstimatePortionOfNeededMemory();
 
    unsigned int GetNumberOfInterpolationSessions();
 
  protected:
    SurfaceInterpolationController();
 
    ~SurfaceInterpolationController() override;
 
    template <typename TPixel, unsigned int VImageDimension>
    void GetImageBase(itk::Image<TPixel, VImageDimension> *input, itk::ImageBase<3>::Pointer &result);
 
  private:
    void ReinitializeInterpolation();
 
    void OnSegmentationDeleted(const itk::Object *caller, const itk::EventObject &event);
 
    void AddToInterpolationPipeline(ContourPositionInformation contourInfo);
 
    ReduceContourSetFilter::Pointer m_ReduceFilter;
    ComputeContourSetNormalsFilter::Pointer m_NormalsFilter;
    CreateDistanceImageFromSurfaceFilter::Pointer m_InterpolateSurfaceFilter;
 
    Surface::Pointer m_Contours;
 
    double m_DistanceImageSpacing;
 
    vtkSmartPointer<vtkPolyData> m_PolyData;
 
    mitk::DataStorage::Pointer m_DataStorage;
 
    ContourListMap m_ListOfInterpolationSessions;
 
    mitk::Surface::Pointer m_InterpolationResult;
 
    unsigned int m_CurrentNumberOfReducedContours;
 
    mitk::Image *m_SelectedSegmentation;
 
    std::map<mitk::Image *, unsigned long> m_SegmentationObserverTags;
 
    mitk::TimePointType m_CurrentTimePoint;
  };
}
#endif