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

    void SetShowMarkerNodes(bool);

    void SetEnable3DInterpolation(bool);

  protected:
    SegTool2D();             // purposely hidden
    SegTool2D(const char *, const us::Module *interactorModule = nullptr); // purposely hidden
    ~SegTool2D() override;

    struct SliceInformation
    {
      mitk::Image::Pointer slice;
      mitk::PlaneGeometry *plane;
      unsigned int timestep;

      SliceInformation() {}
      SliceInformation(mitk::Image *slice, mitk::PlaneGeometry *plane, unsigned int timestep)
      {
        this->slice = slice;
        this->plane = plane;
        this->timestep = timestep;
      }
    };

    bool FilterEvents(InteractionEvent *interactionEvent, DataNode *dataNode) override;

    Image::Pointer GetAffectedImageSliceAs2DImage(const InteractionPositionEvent *positionEvent, const Image *image, unsigned int component = 0);

    Image::Pointer GetAffectedImageSliceAs2DImage(const PlaneGeometry *planeGeometry,
                                                  const Image *image,
                                                  unsigned int timeStep,
                                                  unsigned int component = 0);

    Image::Pointer GetAffectedWorkingSlice(const InteractionPositionEvent *);

    Image::Pointer GetAffectedReferenceSlice(const InteractionPositionEvent *);

    void WriteBackSegmentationResult(const InteractionPositionEvent *, Image *);

    void WriteBackSegmentationResult(const PlaneGeometry *planeGeometry, Image *, unsigned int timeStep);

    void WriteBackSegmentationResult(const std::vector<SliceInformation> &sliceList, bool writeSliceToVolume = true);

    void WritePreviewOnWorkingImage(
      Image *targetSlice, Image *sourceSlice, Image *workingImage, int paintingPixelValue, int timestep);

    void WriteSliceToVolume(const SliceInformation &sliceInfo);
    int AddContourmarker();

    void InteractiveSegmentationBugMessage(const std::string &message);

    BaseRenderer *m_LastEventSender;
    unsigned int m_LastEventSlice;

  private:
    // The prefix of the contourmarkername. Suffix is a consecutive number
    const std::string m_Contourmarkername;

    bool m_ShowMarkerNodes;
    static bool m_SurfaceInterpolationEnabled;
  };

} // namespace

#endif