mitkSurfaceInterpolationController.h

Go to the documentation of this file.

/*===================================================================

The Medical Imaging Interaction Toolkit (MITK)

Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.

This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.

See LICENSE.txt or http://www.mitk.org for details.

===================================================================*/

#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 "mitkWeakPointer.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*, ContourPositionInformationList> ContourListMap;
    typedef std::map<mitk::Image *, ContourPositionInformationVec2D> ContourListMap;

    static SurfaceInterpolationController *GetInstance();

    void SetCurrentTimeStep(unsigned int ts)
    {
      if (m_CurrentTimeStep != ts)
      {
        m_CurrentTimeStep = ts;

        if (m_SelectedSegmentation)
        {
          this->ReinitializeInterpolation();
        }
      }
    };

    unsigned int GetCurrentTimeStep() { return m_CurrentTimeStep; };
    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();

    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;

    unsigned int m_CurrentTimeStep;
  };
}
#endif