mitkSegWithPreviewTool.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 mitkSegWithPreviewTool_h
#define mitkSegWithPreviewTool_h
 
#include "mitkTool.h"
#include "mitkCommon.h"
#include "mitkDataNode.h"
#include "mitkToolCommand.h"
#include <MitkSegmentationExports.h>
 
namespace mitk
{
  class MITKSEGMENTATION_EXPORT SegWithPreviewTool : public Tool
  {
  public:
 
    mitkClassMacro(SegWithPreviewTool, Tool);
 
    void Activated() override;
    void Deactivated() override;
 
    void ConfirmSegmentation();
 
    itkSetMacro(CreateAllTimeSteps, bool);
    itkGetMacro(CreateAllTimeSteps, bool);
    itkBooleanMacro(CreateAllTimeSteps);
 
    itkSetMacro(KeepActiveAfterAccept, bool);
    itkGetMacro(KeepActiveAfterAccept, bool);
    itkBooleanMacro(KeepActiveAfterAccept);
 
    itkSetMacro(IsTimePointChangeAware, bool);
    itkGetMacro(IsTimePointChangeAware, bool);
    itkBooleanMacro(IsTimePointChangeAware);
 
    itkSetMacro(ResetsToEmptyPreview, bool);
    itkGetMacro(ResetsToEmptyPreview, bool);
    itkBooleanMacro(ResetsToEmptyPreview);
 
    itkSetMacro(UseSpecialPreviewColor, bool);
    itkGetMacro(UseSpecialPreviewColor, bool);
    itkBooleanMacro(UseSpecialPreviewColor);
 
    itkSetMacro(RequestDeactivationConfirmation, bool);
    itkGetMacro(RequestDeactivationConfirmation, bool);
    itkBooleanMacro(RequestDeactivationConfirmation);
 
    /*itk macro was not used on purpose, to avoid the change of mtime.*/
    void SetMergeStyle(MultiLabelSegmentation::MergeStyle mergeStyle);
    itkGetMacro(MergeStyle, MultiLabelSegmentation::MergeStyle);
 
    /*itk macro was not used on purpose, to avoid the change of mtime.*/
    void SetOverwriteStyle(MultiLabelSegmentation::OverwriteStyle overwriteStyle);
    itkGetMacro(OverwriteStyle, MultiLabelSegmentation::OverwriteStyle);
 
    enum class LabelTransferScope
    {
      ActiveLabel, //Only the selected label will be transferred from the preview segmentation
                   //to the result segmentation.
                   //If this mode is selected the class expects that GetSelectedLabels indicate
                   //the label in the preview.
      SelectedLabels, //The labels defined as selected labels will be transferred.
      AllLabels //Transfer all labels of the preview
    };
    /*itk macro was not used on purpose, to avoid the change of mtime.*/
    void SetLabelTransferScope(LabelTransferScope labelTransferScope);
    itkGetMacro(LabelTransferScope, LabelTransferScope);
 
    using SelectedLabelVectorType = std::vector<Label::PixelType>;
    void SetSelectedLabels(const SelectedLabelVectorType& labelsToTransfer);
    itkGetMacro(SelectedLabels, SelectedLabelVectorType);
 
    enum class LabelTransferMode
    {
      MapLabel, //Only the active label will be transferred from preview to segmentation.
      AddLabel //The labels defined as selected labels will be transferred.
    };
    /*itk macro was not used on purpose, to avoid the change of mtime.*/
    void SetLabelTransferMode(LabelTransferMode labelTransferMode);
    itkGetMacro(LabelTransferMode, LabelTransferMode);
 
    bool CanHandle(const BaseData* referenceData, const BaseData* workingData) const override;
 
    void UpdatePreview(bool ignoreLazyPreviewSetting = false);
 
    bool IsUpdating() const;
 
    std::string GetCurrentSegmentationName();
 
    virtual DataNode* GetTargetSegmentationNode() const;
    LabelSetImage* GetTargetSegmentation() const;
 
    LabelSetImage* GetPreviewSegmentation();
    const LabelSetImage* GetPreviewSegmentation() const;
    DataNode* GetPreviewSegmentationNode();
 
  protected:
    ToolCommand::Pointer m_ProgressCommand;
 
    SegWithPreviewTool(bool lazyDynamicPreviews = false); // purposely hidden
    SegWithPreviewTool(bool lazyDynamicPreviews, const char* interactorType, const us::Module* interactorModule = nullptr); // purposely hidden
 
    ~SegWithPreviewTool() override;
 
    const char* GetGroup() const override;
 
    static Image::ConstPointer GetImageByTimeStep(const Image* image, TimeStepType timestep);
    static Image::Pointer GetImageByTimeStep(Image* image, TimeStepType timestep);
    static Image::ConstPointer GetImageByTimePoint(const Image* image, TimePointType timePoint);
 
    void EnsureTargetSegmentationNodeInDataStorage() const;
 
    virtual void InitiateToolByInput();
 
    virtual void UpdatePrepare();
 
    virtual void UpdateCleanUp();
 
    virtual void ConfirmCleanUp();
 
    using LabelMappingType = std::vector<std::pair<Label::PixelType, Label::PixelType> >;
 
    virtual void PreparePreviewToResultTransfer(const LabelMappingType& labelMapping);
 
    static void TransferLabelInformation(const LabelMappingType& labelMapping,
      const mitk::LabelSetImage* source, mitk::LabelSetImage* target);
 
    static void TransferLabelSetImageContent(const LabelSetImage* source, LabelSetImage* target, TimeStepType timeStep);
 
    virtual void DoUpdatePreview(const Image* inputAtTimeStep, const Image* oldSegAtTimeStep, LabelSetImage* previewImage, TimeStepType timeStep) = 0;
 
    const Image* GetSegmentationInput() const;
 
    const Image* GetReferenceData() const;
 
    void ResetPreviewNode();
 
    void ResetPreviewContent();
 
    void ResetPreviewContentAtTimeStep(unsigned int timeStep);
 
    TimePointType GetLastTimePointOfUpdate() const;
 
    LabelSetImage::LabelValueType GetActiveLabelValueOfPreview() const;
 
    itkGetConstMacro(UserDefinedActiveLabel, Label::PixelType);
 
    itkSetObjectMacro(WorkingPlaneGeometry, PlaneGeometry);
    itkGetConstObjectMacro(WorkingPlaneGeometry, PlaneGeometry);
 
    bool ConfirmBeforeDeactivation() override;
 
  private:
    void TransferImageAtTimeStep(const Image* sourceImage, Image* destinationImage, const TimeStepType timeStep, const LabelMappingType& labelMapping);
 
    void CreateResultSegmentationFromPreview();
 
    void OnRoiDataChanged();
    void OnTimePointChanged();
 
    bool EnsureUpToDateUserDefinedActiveLabel();
 
    LabelMappingType GetLabelMapping() const;
 
    DataNode::Pointer m_PreviewSegmentationNode;
    DataNode::Pointer m_ReferenceDataNode;
    DataNode::Pointer m_SegmentationInputNode;
 
    bool m_CreateAllTimeSteps = false;
 
    bool m_KeepActiveAfterAccept = false;
 
    bool m_LazyDynamicPreviews = false;
 
    bool m_IsTimePointChangeAware = true;
 
    bool m_ResetsToEmptyPreview = false;
 
    bool m_UseSpecialPreviewColor = true;
 
    TimePointType m_LastTimePointOfUpdate = 0.;
 
    bool m_IsUpdating = false;
 
    Label::PixelType m_UserDefinedActiveLabel = 1;
 
    PlaneGeometry::Pointer m_WorkingPlaneGeometry;
 
    MultiLabelSegmentation::MergeStyle m_MergeStyle = MultiLabelSegmentation::MergeStyle::Replace;
    MultiLabelSegmentation::OverwriteStyle m_OverwriteStyle = MultiLabelSegmentation::OverwriteStyle::RegardLocks;
 
    LabelTransferScope m_LabelTransferScope = LabelTransferScope::ActiveLabel;
    SelectedLabelVectorType m_SelectedLabels = {};
 
    LabelTransferMode m_LabelTransferMode = LabelTransferMode::MapLabel;
 
    bool m_IsPreviewGenerated = false;
 
    bool m_RequestDeactivationConfirmation = false;
  };
 
} // namespace
 
#endif