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