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_Included
#define mitkSegTool2D_h_Included

#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;

      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);


    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;

    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