vtkSlicerSegmentEditorLogic.h

Go to the documentation of this file.

/*==============================================================================
 
Program: 3D Slicer
 
Copyright (c) Laboratory for Percutaneous Surgery (PerkLab)
  Queen's University, Kingston, ON, Canada. All Rights Reserved.
 
  See COPYRIGHT.txt
  or http://www.slicer.org/copyright/copyright.txt for details.
 
  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.
 
  This file was originally developed by Csaba Pinter, PerkLab, Queen's University
  and was supported through the Applied Cancer Research Unit program of Cancer Care
  Ontario with funds provided by the Ontario Ministry of Health and Long-Term Care
 
==============================================================================*/
 
#ifndef __vtkSlicerSegmentEditorLogic_h
#define __vtkSlicerSegmentEditorLogic_h
 
// Module export include
#include "vtkSlicerSegmentationsModuleLogicExport.h"
 
// MRML includes
#include "vtkMRMLAbstractLogic.h"
class vtkMRMLAbstractViewNode;
class vtkMRMLApplicationLogic;
class vtkMRMLNode;
class vtkMRMLScalarVolumeNode;
class vtkMRMLScene;
class vtkMRMLSegmentationNode;
class vtkMRMLSegmentEditorNode;
class vtkMRMLSliceLogic;
class vtkMRMLSliceNode;
class vtkMRMLTransformNode;
class vtkMRMLVolumeNode;
 
// vtkSegmentationCore includes
class vtkOrientedImageData;
class vtkSegment;
class vtkSegmentation;
class vtkSegmentationHistory;
 
// VTK includes
#include <vtkCommand.h>
#include <vtkSmartPointer.h>
class vtkMatrix4x4;
class vtkPolyData;
 
// STD includes
#include <string>
#include <vector>

class VTK_SLICER_SEGMENTATIONS_LOGIC_EXPORT vtkSlicerSegmentEditorLogic : public vtkMRMLAbstractLogic
{
public:
  static vtkSlicerSegmentEditorLogic* New();
  vtkTypeMacro(vtkSlicerSegmentEditorLogic, vtkMRMLAbstractLogic);
 
  enum ModificationMode
  {
    ModificationModeSet,
    ModificationModeAdd,
    ModificationModeRemove,
    ModificationModeRemoveAll
  };
 
  enum Events
  {
    SegmentationHistoryChangedEvent = vtkCommand::UserEvent + 1,
    PauseRenderEvent,
    ResumeRenderEvent,
  };

  std::string AddEmptySegment(const std::string& segmentId = "", int segmentStatus = 0) const;

  static void AppendImage(vtkOrientedImageData* inputImage, vtkOrientedImageData* appendedImage);

  static void AppendPolyMask(vtkOrientedImageData* input, vtkPolyData* polyData, vtkMRMLSliceNode* sliceNode, vtkMRMLSegmentationNode* segmentationNode = nullptr);

  bool CanAddSegments() const;

  bool CanRedo() const;

  bool CanRemoveSegments() const;

  bool CanTriviallyConvertSourceRepresentationToBinaryLabelMap() const;

  bool CanUndo() const;

  void ClearUndoState() const;

  bool ContainsClosedSurfaceRepresentation() const;

  void CreateAndSetBlankSourceVolumeFromSegmentationGeometry() const;

  void CreateAndSetBlankSourceVolumeIfNeeded() const;

  static void CreateMaskImageFromPolyData(vtkPolyData* polyData, vtkOrientedImageData* outputMask, vtkMRMLSliceNode* sliceNode);

  void ExportSegmentationToColorTableNode() const;

  vtkOrientedImageData* GetAlignedSourceVolume() const;

  std::string GetCurrentSegmentID() const;

  int GetCurrentSegmentIndex() const;

  std::string GetDefaultTerminologyEntry() const;

  vtkOrientedImageData* GetMaskLabelmap() const;

  int GetMaximumNumberOfUndoStates() const;

  vtkOrientedImageData* GetModifierLabelmap() const;

  std::string GetNextSegmentID(int offset, bool visibleOnly) const;

  vtkOrientedImageData* GetReferenceGeometryImage() const;

  std::string GetReferenceImageGeometryString() const;

  static std::string GetReferenceImageGeometryStringFromSegmentation(vtkSegmentation* segmentation);

  vtkSegmentation* GetSegmentation() const;

  bool GetSegmentationIJKToRAS(vtkMatrix4x4* ijkToRas) const;

  vtkMRMLSegmentEditorNode* GetSegmentEditorNode() const;

  vtkMRMLSegmentationNode* GetSegmentationNode() const;

  vtkOrientedImageData* GetSelectedSegmentLabelmap() const;

  vtkMRMLScalarVolumeNode* GetSourceVolumeNode() const;

  vtkSegment* GetSelectedSegment() const;

  std::vector<std::string> GetSegmentIDs() const;

  std::vector<std::string> GetVisibleSegmentIDs() const;

  double GetSliceSpacing(vtkMRMLSliceNode* sliceNode) const;
  static double GetSliceSpacing(vtkMRMLSliceNode* sliceNode, vtkMRMLSliceLogic* sliceLogic);

  bool GetVerbose() const;

  static void ImageToWorldMatrix(vtkMRMLVolumeNode* node, vtkMatrix4x4* ijkToRas);

  static void ImageToWorldMatrix(vtkOrientedImageData* image, vtkMRMLSegmentationNode* node, vtkMatrix4x4* ijkToRas);

  bool IsSegmentationDisplayableInView(vtkMRMLAbstractViewNode* viewNode) const;

  bool IsSegmentationNodeValid() const;

  static bool IsSegmentIdInList(const std::string& segmentID, const std::vector<std::string>& visibleSegmentIDs);

  bool IsSegmentIdValid(const std::string& segmentId) const;

  bool IsSegmentIdVisible(const std::string& segmentID) const;

  bool IsSelectedSegmentVisible() const;
 
  void ModifySegmentByLabelmap(vtkMRMLSegmentationNode* segmentationNode,
                               const char* segmentID,
                               vtkOrientedImageData* modifierLabelmap,
                               ModificationMode modificationMode,
                               bool isPerSegment,
                               bool bypassMasking);
 
  void ModifySegmentByLabelmap(vtkMRMLSegmentationNode* segmentationNode,
                               const char* segmentID,
                               vtkOrientedImageData* modifierLabelmap,
                               ModificationMode modificationMode,
                               const int modificationExtent[6],
                               bool isPerSegment,
                               bool bypassMasking);

  void PauseRender();

  static std::array<int, 2> RasToXy(double ras[3], vtkMRMLSliceNode* sliceNode);

  void Redo() const;

  std::string RemoveSelectedSegment() const;

  bool ResetModifierLabelmapToDefault() const;

  void ResumeRender();

  bool SaveStateForUndo() const;

  void SelectPreviousSegment(bool visibleOnly) const;

  void SelectNextSegment(bool visibleOnly) const;

  void SelectFirstSegment(bool visibleOnly) const;

  void SelectSegmentAtOffset(int offset, bool visibleOnly) const;

  void SetDefaultTerminologyEntry(const std::string& entry);

  void SetMaximumNumberOfUndoStates(int) const;

  void SetCurrentSegmentID(const std::string& segmentID) const;

  void SetSegmentEditorNode(vtkMRMLSegmentEditorNode* newSegmentEditorNode);

  void SetSegmentationNode(vtkMRMLNode* node) const;

  void SetSegmentationNodeID(const std::string& nodeID) const;

  void SetSegmentationHistory(const vtkSmartPointer<vtkSegmentationHistory>& segmentationHistory);

  void SetSourceVolumeNode(vtkMRMLNode* node) const;

  void SetSourceVolumeNodeID(const std::string& nodeID) const;

  bool SetSourceRepresentationToBinaryLabelMap() const;

  void SetVerbose(bool isVerbose);

  void ToggleSegmentationSurfaceRepresentation(bool isSurfaceRepresentationOn) const;

  void ToggleSourceVolumeIntensityMask() const;

  bool TrivialSetSourceRepresentationToBinaryLabelmap() const;

  void Undo() const;

  void UpdateVolume(void* volumeToUpdate, bool& success);

  bool UpdateSelectedSegmentLabelmap() const;

  bool UpdateAlignedSourceVolume();

  bool UpdateMaskLabelmap() const;

  bool UpdateReferenceGeometryImage() const;

  static void XyzToRas(double inputXyz[3], double outputRas[3], vtkMRMLSliceNode* sliceNode);
  static std::array<double, 3> XyzToRas(double inputXyz[3], vtkMRMLSliceNode* sliceNode);

  static void XyToRas(int xy[2], double outputRas[3], vtkMRMLSliceNode* sliceNode);
  static void XyToRas(double xy[2], double outputRas[3], vtkMRMLSliceNode* sliceNode);
  static std::array<double, 3> XyToRas(int xy[2], vtkMRMLSliceNode* sliceNode);
  static void XyzToIjk(double inputXyz[3], int outputIjk[3], vtkMRMLSliceNode* sliceNode, vtkOrientedImageData* image, vtkMRMLTransformNode* parentTransform = nullptr);
  static std::array<int, 3> XyzToIjk(double inputXyz[3], vtkMRMLSliceNode* sliceNode, vtkOrientedImageData* image, vtkMRMLTransformNode* parentTransform = nullptr);
  static void XyToIjk(int xy[2], int outputIjk[3], vtkMRMLSliceNode* sliceNode, vtkOrientedImageData* image, vtkMRMLTransformNode* parentTransform = nullptr);
  static void XyToIjk(double xy[2], int outputIjk[3], vtkMRMLSliceNode* sliceNode, vtkOrientedImageData* image, vtkMRMLTransformNode* parentTransform = nullptr);
  static std::array<int, 3> XyToIjk(int xy[2], vtkMRMLSliceNode* sliceNode, vtkOrientedImageData* image, vtkMRMLTransformNode* parentTransform = nullptr);
 
protected:
  void ProcessMRMLNodesEvents(vtkObject* caller, unsigned long event, void* callData) override;
 
  vtkSlicerSegmentEditorLogic();
  ~vtkSlicerSegmentEditorLogic() override;
 
private:
  void UpdateSegmentationNodeObserver(vtkMRMLSegmentationNode* segmentationNode);

  vtkMRMLSegmentEditorNode* SegmentEditorNode;
  vtkSmartPointer<vtkSegmentationHistory> SegmentationHistory;

  vtkSmartPointer<vtkOrientedImageData> AlignedSourceVolume;
  vtkSmartPointer<vtkOrientedImageData> ModifierLabelmap;
  vtkSmartPointer<vtkOrientedImageData> SelectedSegmentLabelmap;
  vtkSmartPointer<vtkOrientedImageData> MaskLabelmap;
  vtkSmartPointer<vtkOrientedImageData> ReferenceGeometryImage;

  vtkMRMLVolumeNode* AlignedSourceVolumeUpdateSourceVolumeNode;
  vtkMRMLTransformNode* AlignedSourceVolumeUpdateSourceVolumeNodeTransform;
  vtkMRMLTransformNode* AlignedSourceVolumeUpdateSegmentationNodeTransform;
 
  std::string DefaultTerminologyEntry;
 
  unsigned long SegmentHistoryObs;
  vtkMRMLSegmentationNode* SegmentationNodeObs;
 
  // Warning verbosity level. Default = no warnings.
  bool IsVerbose;
};
 
#endif