mitkSegTool2D.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 mitkSegTool2D_h
#define mitkSegTool2D_h
 
#include <mitkCommon.h>
#include <mitkImage.h>
#include <mitkTool.h>
#include <MitkSegmentationExports.h>
 
#include <mitkInteractionPositionEvent.h>
 
#include <mitkInteractionConst.h>
#include <mitkPlanePositionManager.h>
#include <mitkRestorePlanePositionOperation.h>
 
#include <mitkDiffSliceOperation.h>
 
namespace mitk
{
  class BaseRenderer;
 
  class MITKSEGMENTATION_EXPORT SegTool2D : public Tool
  {
  public:
    mitkClassMacro(SegTool2D, Tool);
 
    static bool DetermineAffectedImageSlice(const Image *image,
                                            const PlaneGeometry *plane,
                                            int &affectedDimension,
                                            int &affectedSlice);
 
    static void UpdateSurfaceInterpolation(const Image *slice,
                                           const Image *workingImage,
                                           const PlaneGeometry *plane,
                                           bool detectIntersection);
 
    static Image::Pointer GetAffectedImageSliceAs2DImage(const InteractionPositionEvent* positionEvent, const Image* image, unsigned int component = 0);
 
    static Image::Pointer GetAffectedImageSliceAs2DImage(const PlaneGeometry* planeGeometry,
      const Image* image,
      TimeStepType timeStep,
      unsigned int component = 0);
    static Image::Pointer GetAffectedImageSliceAs2DImageByTimePoint(const PlaneGeometry* planeGeometry,
      const Image* image,
      TimePointType timePoint,
      unsigned int component = 0);
 
    static void WriteBackSegmentationResult(const DataNode* workingNode, const PlaneGeometry* planeGeometry, const Image* segmentationResult, TimeStepType timeStep);
 
    static void WriteSliceToVolume(Image* workingImage, const PlaneGeometry* planeGeometry, const Image* slice, TimeStepType timeStep, bool allowUndo);
 
    void SetShowMarkerNodes(bool);
 
    void SetEnable3DInterpolation(bool);
 
    void Activated() override;
    void Deactivated() override;
 
    itkSetMacro(IsTimePointChangeAware, bool);
    itkGetMacro(IsTimePointChangeAware, bool);
    itkBooleanMacro(IsTimePointChangeAware);
 
  protected:
    SegTool2D();             // purposely hidden
    SegTool2D(const char *, const us::Module *interactorModule = nullptr); // purposely hidden
    ~SegTool2D() override;
 
    DataNode* GetWorkingDataNode() const;
    Image* GetWorkingData() const;
 
    DataNode* GetReferenceDataNode() const;
    Image* GetReferenceData() const;
 
    virtual void OnTimePointChanged();
 
    struct SliceInformation
    {
      mitk::Image::ConstPointer slice;
      const mitk::PlaneGeometry *plane = nullptr;
      mitk::TimeStepType timestep = 0;
      unsigned int slicePosition;
 
      SliceInformation() = default;
      SliceInformation(const mitk::Image* aSlice, const mitk::PlaneGeometry* aPlane, mitk::TimeStepType aTimestep);
    };
 
    static void UpdateSurfaceInterpolation(const std::vector<SliceInformation>& sliceInfos,
      const Image* workingImage,
      bool detectIntersection,
      unsigned int activeLayerID,
      mitk::Label::PixelType activeLabelValue);
 
 
    bool FilterEvents(InteractionEvent *interactionEvent, DataNode *dataNode) override;
 
    Image::Pointer GetAffectedWorkingSlice(const InteractionPositionEvent *) const;
 
    Image::Pointer GetAffectedReferenceSlice(const InteractionPositionEvent *) const;
    Image::Pointer GetAffectedReferenceSlice(const PlaneGeometry* planeGeometry, TimeStepType timeStep) const;
 
    void WriteBackSegmentationResult(const InteractionPositionEvent *, const Image* segmentationResult);
 
    void WriteBackSegmentationResult(const PlaneGeometry *planeGeometry, const Image* segmentationResult, TimeStepType timeStep);
 
    void WriteBackSegmentationResults(const std::vector<SliceInformation> &sliceList, bool writeSliceToVolume = true);
 
    static void WriteBackSegmentationResults(const DataNode* workingNode, const std::vector<SliceInformation>& sliceList, bool writeSliceToVolume = true);
 
    static void WritePreviewOnWorkingImage(
      Image *targetSlice, const Image *sourceSlice, const Image *workingImage, int paintingPixelValue);
 
    static void WriteSliceToVolume(Image* workingImage, const SliceInformation &sliceInfo, bool allowUndo);
 
    int AddContourmarker(const PlaneGeometry* planeGeometry, unsigned int sliceIndex);
 
    void InteractiveSegmentationBugMessage(const std::string &message) const;
 
    static bool IsPositionEventInsideImageRegion(InteractionPositionEvent* positionEvent, const BaseData* data);
 
    BaseRenderer *m_LastEventSender = nullptr;
    unsigned int m_LastEventSlice = 0;
 
    itkGetMacro(LastTimePointTriggered, TimePointType);
 
  private:
    void OnTimePointChangedInternal();
 
    static void  RemoveContourFromInterpolator(const SliceInformation& sliceInfo);
 
    // The prefix of the contourmarkername. Suffix is a consecutive number
    const std::string m_Contourmarkername;
 
    bool m_ShowMarkerNodes = false;
    static bool m_SurfaceInterpolationEnabled;
 
    bool m_IsTimePointChangeAware = true;
 
    TimePointType m_LastTimePointTriggered = 0.;
  };
 
} // namespace
 
#endif