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

  virtual vtkMRMLNode* CreateNodeInstance() VTK_OVERRIDE;

  virtual void ReadXMLAttributes( const char** atts) VTK_OVERRIDE;

  virtual void WriteXML(ostream& of, int indent) VTK_OVERRIDE;

  virtual void Copy(vtkMRMLNode *node) VTK_OVERRIDE;

  virtual void DeepCopy(vtkMRMLNode* node);

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

  virtual void GetRASBounds(double bounds[6]) VTK_OVERRIDE;

  virtual void GetBounds(double bounds[6]) VTK_OVERRIDE;

  virtual bool CanApplyNonLinearTransforms()const VTK_OVERRIDE;

  virtual void ApplyTransformMatrix(vtkMatrix4x4* transformMatrix) VTK_OVERRIDE;

  virtual void ApplyTransform(vtkAbstractTransform* transform) VTK_OVERRIDE;

  virtual vtkMRMLStorageNode* CreateDefaultStorageNode() VTK_OVERRIDE;

  virtual void CreateDefaultDisplayNodes() VTK_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 = NULL, const std::vector<std::string>& segmentIDs = std::vector<std::string>());
//ETX
#endif // __VTK_WRAP__

  virtual bool GenerateMergedLabelmapForAllSegments(vtkOrientedImageData* mergedImageData,
    int extentComputationMode = vtkSegmentation::EXTENT_UNION_OF_EFFECTIVE_SEGMENTS,
    vtkOrientedImageData* mergedLabelmapGeometry = NULL, vtkStringArray* segmentIDs = NULL);

  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 SetMasterRepresentationToBinaryLabelmap();
  virtual bool SetMasterRepresentationToClosedSurface();

  virtual bool CreateBinaryLabelmapRepresentation();

  virtual void RemoveBinaryLabelmapRepresentation();

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

  virtual bool CreateClosedSurfaceRepresentation();

  virtual void RemoveClosedSurfaceRepresentation();

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

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

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

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

protected:
  vtkSetObjectMacro(Segmentation, vtkSegmentation);

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

  void OnMasterRepresentationModified();

  void OnSegmentAdded(const char* segmentId);

  void OnSegmentRemoved(const char* segmentId);

  void OnSegmentModified(const char* segmentId);

protected:
  vtkMRMLSegmentationNode();
  virtual ~vtkMRMLSegmentationNode();
  vtkMRMLSegmentationNode(const vtkMRMLSegmentationNode&);
  void operator=(const vtkMRMLSegmentationNode&);

  vtkSegmentation* Segmentation;

  vtkSmartPointer<vtkCallbackCommand> SegmentationModifiedCallbackCommand;
};

#endif // __vtkMRMLSegmentationNode_h