mitkSegmentationInterpolationController.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 mitkSegmentationInterpolationController_h
#define mitkSegmentationInterpolationController_h
 
#include "mitkCommon.h"
#include "mitkImage.h"
#include <MitkSegmentationExports.h>
#include <mitkShapeBasedInterpolationAlgorithm.h>
 
#include <itkImage.h>
#include <itkObjectFactory.h>
 
#include <map>
#include <mutex>
#include <utility>
#include <vector>
 
namespace mitk
{
  class Image;
 
  class MITKSEGMENTATION_EXPORT SegmentationInterpolationController : public itk::Object
  {
  public:
    mitkClassMacroItkParent(SegmentationInterpolationController, itk::Object);
    itkFactorylessNewMacro(Self);
    itkCloneMacro(Self);
 
      static SegmentationInterpolationController *InterpolatorForImage(const Image *);
 
    void BlockModified(bool);
 
    void SetSegmentationVolume(const Image *segmentation);
 
    void SetChangedSlice(const Image *sliceDiff,
                         unsigned int sliceDimension,
                         unsigned int sliceIndex,
                         unsigned int timeStep);
    void SetChangedVolume(const Image *sliceDiff, unsigned int timeStep);
 
    Image::Pointer Interpolate(unsigned int sliceDimension,
                               unsigned int sliceIndex,
                               const mitk::PlaneGeometry *currentPlane,
                               unsigned int timeStep,
                               mitk::ShapeBasedInterpolationAlgorithm::Pointer algorithm = nullptr);
 
    void OnImageModified(const itk::EventObject &);
 
    void Activate2DInterpolation(bool);
 
    void EnableSliceImageCache();
 
    void DisableSliceImageCache();
 
    static SegmentationInterpolationController *GetInstance();
 
  protected:
    class MITKSEGMENTATION_EXPORT SetChangedSliceOptions
    {
    public:
      SetChangedSliceOptions(
        unsigned int sd, unsigned int si, unsigned int d0, unsigned int d1, unsigned int t, const void *pixels)
        : sliceDimension(sd), sliceIndex(si), dim0(d0), dim1(d1), timeStep(t), pixelData(pixels)
      {
      }
 
      unsigned int sliceDimension;
      unsigned int sliceIndex;
      unsigned int dim0;
      unsigned int dim1;
      unsigned int timeStep;
      const void *pixelData;
    };
 
    typedef std::vector<unsigned int> DirtyVectorType;
    // typedef std::vector< DirtyVectorType[3] > TimeResolvedDirtyVectorType; // cannot work with C++, so next line is
    // used for implementation
    typedef std::vector<std::vector<DirtyVectorType>> TimeResolvedDirtyVectorType;
    typedef std::map<const Image *, SegmentationInterpolationController *> InterpolatorMapType;
 
    SegmentationInterpolationController(); // purposely hidden
    ~SegmentationInterpolationController() override;
 
    template <typename DATATYPE>
    void ScanChangedSlice(const itk::Image<DATATYPE, 2> *, const SetChangedSliceOptions &options);
 
    template <typename TPixel, unsigned int VImageDimension>
    void ScanChangedVolume(const itk::Image<TPixel, VImageDimension> *, unsigned int timeStep);
 
    template <typename DATATYPE>
    void ScanWholeVolume(const itk::Image<DATATYPE, 3> *, const Image *volume, unsigned int timeStep);
 
    void PrintStatus();
 
    mitk::Image::Pointer ExtractSlice(const PlaneGeometry* planeGeometry, unsigned int sliceIndex, unsigned int timeStep, bool cache = false);
 
    TimeResolvedDirtyVectorType m_SegmentationCountInSlice;
 
    static InterpolatorMapType s_InterpolatorForImage;
 
    Image::ConstPointer m_Segmentation;
    std::pair<unsigned long, bool> m_SegmentationModifiedObserverTag; // first: actual tag, second: tag assigned / valid?
    bool m_BlockModified;
    bool m_2DInterpolationActivated;
 
    bool m_EnableSliceImageCache;
    std::map<std::pair<unsigned int, unsigned int>, Image::Pointer> m_SliceImageCache;
    std::mutex m_SliceImageCacheMutex;
  };
 
} // namespace
 
#endif