vtkMRMLSegmentationNode.h

Go to the documentation of this file.

/*==============================================================================
 
  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 __vtkMRMLSegmentationNode_h
#define __vtkMRMLSegmentationNode_h
 
// MRML includes
#include <vtkMRML.h>
#include <vtkMRMLDisplayableNode.h>
#include <vtkMRMLColorTableNode.h>
 
// STD includes
#include <cstdlib>
 
// vtkSegmentationCore includes
#include "vtkSegmentation.h"
 
class vtkCallbackCommand;
class vtkIntArray;
class vtkMRMLScene;
class vtkMRMLSegmentationDisplayNode;
class vtkMRMLSubjectHierarchyNode;
class vtkMRMLScalarVolumeNode;
class vtkPolyData;

class VTK_MRML_EXPORT vtkMRMLSegmentationNode : public vtkMRMLDisplayableNode
{
public:
  // Define constants
  static const char* GetSegmentIDAttributeName() { return "segmentID"; };
 
  static vtkMRMLSegmentationNode* New();
  vtkTypeMacro(vtkMRMLSegmentationNode, vtkMRMLDisplayableNode);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  vtkMRMLNode* CreateNodeInstance() override;

  void ReadXMLAttributes(const char** atts) override;

  void WriteXML(ostream& of, int indent) override;

  vtkMRMLCopyContentMacro(vtkMRMLSegmentationNode);

  const char* GetNodeTagName() override { return "Segmentation"; };

  void GetRASBounds(double bounds[6]) override;

  void GetBounds(double bounds[6]) override;

  bool CanApplyNonLinearTransforms() const override;

  void ApplyTransformMatrix(vtkMatrix4x4* transformMatrix) override;

  void ApplyTransform(vtkAbstractTransform* transform) override;

  vtkMRMLStorageNode* CreateDefaultStorageNode() override;

  void CreateDefaultDisplayNodes() override;

  virtual void OnSubjectHierarchyUIDAdded(vtkMRMLSubjectHierarchyNode* shNode, vtkIdType itemWithNewUID);

  virtual vtkIdType GetSegmentSubjectHierarchyItem(std::string segmentID, vtkMRMLSubjectHierarchyNode* shNode);
 
#ifndef __VTK_WRAP__
  // BTX
  virtual bool GenerateMergedLabelmap(vtkOrientedImageData* mergedImageData,
                                      int extentComputationMode,
                                      vtkOrientedImageData* mergedLabelmapGeometry = nullptr,
                                      const std::vector<std::string>& segmentIDs = std::vector<std::string>(),
                                      vtkIntArray* labelValues = nullptr);
// ETX
#endif // __VTK_WRAP__

  virtual bool GenerateMergedLabelmapForAllSegments(vtkOrientedImageData* mergedImageData,
                                                    int extentComputationMode = vtkSegmentation::EXTENT_UNION_OF_EFFECTIVE_SEGMENTS,
                                                    vtkOrientedImageData* mergedLabelmapGeometry = nullptr,
                                                    vtkStringArray* segmentIDs = nullptr,
                                                    vtkIntArray* labelValues = nullptr);
 
  enum
  {
    EditAllowedEverywhere = 0,
    EditAllowedInsideAllSegments,
    EditAllowedInsideVisibleSegments,
    EditAllowedOutsideAllSegments,
    EditAllowedOutsideVisibleSegments,
    EditAllowedInsideSingleSegment,
    EditAllowed_Last
  };


  static const char* ConvertMaskModeToString(int mode);
  static int ConvertMaskModeFromString(const char* modeStr);

  virtual bool GenerateEditMask(vtkOrientedImageData* maskImage,
                                int editMode,
                                vtkOrientedImageData* referenceGeometry,
                                std::string editedSegmentID = "",
                                std::string maskSegmentID = "",
                                vtkOrientedImageData* sourceVolume = nullptr,
                                double editableIntensityRange[2] = nullptr,
                                vtkMRMLSegmentationDisplayNode* displayNode = nullptr);

  static std::string GetReferenceImageGeometryReferenceRole() { return "referenceImageGeometryRef"; };
  virtual void SetReferenceImageGeometryParameterFromVolumeNode(vtkMRMLScalarVolumeNode* volumeNode);

  vtkGetObjectMacro(Segmentation, vtkSegmentation);
  void SetAndObserveSegmentation(vtkSegmentation* segmentation);
 
  // Convenience functions for commonly needed features


  virtual bool SetSourceRepresentationToBinaryLabelmap();
  virtual bool SetSourceRepresentationToClosedSurface();

  virtual bool SetMasterRepresentationToBinaryLabelmap()
  {
    vtkWarningMacro("vtkSegmentation::SetMasterRepresentationToBinaryLabelmap() method is deprecated, please use SetSourceRepresentationToBinaryLabelmap method instead");
    return this->SetSourceRepresentationToClosedSurface();
  };

  virtual bool SetMasterRepresentationToClosedSurface()
  {
    vtkWarningMacro("vtkSegmentation::SetMasterRepresentationToClosedSurface() method is deprecated, please use SetSourceRepresentationToClosedSurface method instead");
    return this->SetSourceRepresentationToClosedSurface();
  };

  virtual bool CreateBinaryLabelmapRepresentation();

  virtual void RemoveBinaryLabelmapRepresentation();

  virtual bool GetBinaryLabelmapRepresentation(const std::string segmentId, vtkOrientedImageData* outputBinaryLabelmap);

  virtual vtkOrientedImageData* GetBinaryLabelmapInternalRepresentation(const std::string segmentId);

  virtual bool CreateClosedSurfaceRepresentation();

  virtual void RemoveClosedSurfaceRepresentation();

  virtual bool GetClosedSurfaceRepresentation(const std::string segmentId, vtkPolyData* outputClosedSurface);

  virtual vtkPolyData* GetClosedSurfaceInternalRepresentation(const std::string segmentId);

  virtual std::string AddSegmentFromClosedSurfaceRepresentation(vtkPolyData* polyData, std::string segmentName = "", double color[3] = nullptr, std::string segmentId = "");

  std::string AddSegmentFromBinaryLabelmapRepresentation(vtkOrientedImageData* imageData, std::string segmentName = "", double color[3] = nullptr, std::string segmentId = "");

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

  double* GetSegmentCenter(const std::string& segmentID) VTK_SIZEHINT(3);
  void GetSegmentCenter(const std::string& segmentID, double center[3]);


  double* GetSegmentCenterRAS(const std::string& segmentID) VTK_SIZEHINT(3);
  void GetSegmentCenterRAS(const std::string& segmentID, double centerRAS[3]);


  vtkSetMacro(SegmentListFilterEnabled, bool);
  vtkGetMacro(SegmentListFilterEnabled, bool);
  vtkBooleanMacro(SegmentListFilterEnabled, bool);


  vtkSetMacro(SegmentListFilterOptions, std::string);
  vtkGetMacro(SegmentListFilterOptions, std::string);


  void SetLabelmapConversionColorTableNodeID(const char* labelmapConversionColorTableNodeID);
  const char* GetLabelmapConversionColorTableNodeID();
  vtkMRMLColorTableNode* GetLabelmapConversionColorTableNode();

  enum
  {
    ReferenceImageGeometryChangedEvent = 23000,
    SegmentationChangedEvent
  };
 
protected:
  vtkSetObjectMacro(Segmentation, vtkSegmentation);

  static void SegmentationModifiedCallback(vtkObject* caller, unsigned long eid, void* clientData, void* callData);

  void OnSourceRepresentationModified();

  void OnSegmentAdded(const char* segmentId);

  void OnSegmentRemoved(const char* segmentId);

  void OnSegmentModified(const char* segmentId);
 
  static const char* GetLabelmapConversionColorTableNodeReferenceRole() { return "labelmapConversionColorTableNode"; };
  static const char* GetLabelmapConversionColorTableNodeReferenceMRMLAttributeName() { return "labelmapConversionColorTableNodeRef"; };

  void OnNodeReferenceAdded(vtkMRMLNodeReference* reference) override;

  void OnNodeReferenceModified(vtkMRMLNodeReference* reference) override;

  void OnNodeReferenceRemoved(vtkMRMLNodeReference* reference) override;
 
protected:
  vtkMRMLSegmentationNode();
  ~vtkMRMLSegmentationNode() override;
  vtkMRMLSegmentationNode(const vtkMRMLSegmentationNode&);
  void operator=(const vtkMRMLSegmentationNode&);

  vtkSegmentation* Segmentation;

  vtkSmartPointer<vtkCallbackCommand> SegmentationModifiedCallbackCommand;

  double SegmentCenterTmp[4];
 
  bool SegmentListFilterEnabled;
  std::string SegmentListFilterOptions;
};
 
#endif