vtkSlicerSegmentationsModuleLogic.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
 
==============================================================================*/
 
// .NAME vtkSlicerSegmentationsModuleLogic - Logic class for segmentation handling
// .SECTION Description
// This class manages the logic associated with converting and handling
// segmentation node objects.
 
#ifndef __vtkSlicerSegmentationsModuleLogic_h
#define __vtkSlicerSegmentationsModuleLogic_h
 
// Slicer includes
#include "vtkSlicerModuleLogic.h"
#include "vtkSlicerSegmentationsModuleLogicExport.h"
 
// Segmentations includes
#include "vtkMRMLSegmentationNode.h"
 
class vtkCallbackCommand;
class vtkOrientedImageData;
class vtkPolyData;
class vtkDataObject;
class vtkGeneralTransform;
 
class vtkMRMLSegmentationStorageNode;
class vtkMRMLSegmentEditorNode;
class vtkMRMLScalarVolumeNode;
class vtkMRMLLabelMapVolumeNode;
class vtkMRMLVolumeNode;
class vtkMRMLModelNode;
class vtkSlicerTerminologiesModuleLogic;
 
class VTK_SLICER_SEGMENTATIONS_LOGIC_EXPORT vtkSlicerSegmentationsModuleLogic : public vtkSlicerModuleLogic
{
public:
  static vtkSlicerSegmentationsModuleLogic* New();
  vtkTypeMacro(vtkSlicerSegmentationsModuleLogic, vtkSlicerModuleLogic);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  static vtkMRMLSegmentationNode* GetSegmentationNodeForSegmentation(vtkMRMLScene* scene, vtkSegmentation* segmentation);

  static vtkMRMLSegmentationNode* GetSegmentationNodeForSegment(vtkMRMLScene* scene, vtkSegment* segment, std::string& segmentId);

  vtkMRMLSegmentationNode* LoadSegmentationFromFile(const char* filename,
                                                    bool autoOpacities = true,
                                                    const char* nodeName = nullptr,
                                                    vtkMRMLColorTableNode* colorTableNode = nullptr,
                                                    vtkMRMLMessageCollection* userMessages = nullptr);

  static bool CreateLabelmapVolumeFromOrientedImageData(vtkOrientedImageData* orientedImageData, vtkMRMLLabelMapVolumeNode* labelmapVolumeNode);

  static bool CopyOrientedImageDataToVolumeNode(vtkOrientedImageData* orientedImageData,
                                                vtkMRMLVolumeNode* volumeNode,
                                                bool shallowCopy = true,
                                                bool shiftImageDataExtentToZeroStart = true);

  static vtkOrientedImageData* CreateOrientedImageDataFromVolumeNode(vtkMRMLScalarVolumeNode* volumeNode, vtkMRMLTransformNode* outputParentTransformNode = nullptr);

  static int DoesLabelmapContainSingleLabel(vtkMRMLLabelMapVolumeNode* labelmapVolumeNode);

  static void GetAllLabelValues(vtkIntArray* labels, vtkImageData* labelmap);

  static vtkSegment* CreateSegmentFromLabelmapVolumeNode(vtkMRMLLabelMapVolumeNode* labelmapVolumeNode, vtkMRMLSegmentationNode* segmentationNode = nullptr);

  static vtkSegment* CreateSegmentFromModelNode(vtkMRMLModelNode* modelNode, vtkMRMLSegmentationNode* segmentationNode = nullptr);

  static vtkMRMLSegmentationNode* GetSegmentationNodeForSegmentSubjectHierarchyItem(vtkIdType segmentShItemID, vtkMRMLScene* scene);

  static vtkSegment* GetSegmentForSegmentSubjectHierarchyItem(vtkIdType segmentShItemID, vtkMRMLScene* scene);

  static bool ExportSegmentToRepresentationNode(vtkSegment* segment, vtkMRMLNode* representationNode);

  static bool ExportSegmentsToModels(vtkMRMLSegmentationNode* segmentationNode, const std::vector<std::string>& segmentIDs, vtkIdType folderItemId);

  static bool ExportSegmentsToModels(vtkMRMLSegmentationNode* segmentationNode, vtkStringArray* segmentIds, vtkIdType folderItemId);

  static bool ExportVisibleSegmentsToModels(vtkMRMLSegmentationNode* segmentationNode, vtkIdType folderItemId);

  static bool ExportAllSegmentsToModels(vtkMRMLSegmentationNode* segmentationNode, vtkIdType folderItemId);

  static vtkMRMLColorTableNode* AddColorTableNodeForSegmentation(vtkMRMLSegmentationNode* segmentationNode);

  static bool ExportSegmentsToColorTableNode(vtkMRMLSegmentationNode* segmentationNode,
                                             const std::vector<std::string>& segmentID,
                                             vtkMRMLColorTableNode* colorTableNode,
                                             vtkIntArray* labelValues = nullptr);

  static bool ExportSegmentsToLabelmapNode(vtkMRMLSegmentationNode* segmentationNode,
                                           const std::vector<std::string>& segmentIDs,
                                           vtkMRMLLabelMapVolumeNode* labelmapNode,
                                           vtkMRMLVolumeNode* referenceVolumeNode = nullptr,
                                           int extentComputationMode = vtkSegmentation::EXTENT_UNION_OF_EFFECTIVE_SEGMENTS,
                                           vtkMRMLColorTableNode* colorTableNode = nullptr);

  static bool ExportSegmentsToLabelmapNode(vtkMRMLSegmentationNode* segmentationNode,
                                           vtkStringArray* segmentIDs,
                                           vtkMRMLLabelMapVolumeNode* labelmapNode,
                                           vtkMRMLVolumeNode* referenceVolumeNode = nullptr,
                                           int extentComputationMode = vtkSegmentation::EXTENT_UNION_OF_EFFECTIVE_SEGMENTS,
                                           vtkMRMLColorTableNode* colorTableNode = nullptr);

  static bool ExportVisibleSegmentsToLabelmapNode(vtkMRMLSegmentationNode* segmentationNode,
                                                  vtkMRMLLabelMapVolumeNode* labelmapNode,
                                                  vtkMRMLVolumeNode* referenceVolumeNode = nullptr,
                                                  int extentComputationMode = vtkSegmentation::EXTENT_UNION_OF_EFFECTIVE_SEGMENTS);

  static bool ExportAllSegmentsToLabelmapNode(vtkMRMLSegmentationNode* segmentationNode,
                                              vtkMRMLLabelMapVolumeNode* labelmapNode,
                                              int extentComputationMode = vtkSegmentation::EXTENT_UNION_OF_EFFECTIVE_SEGMENTS);

  static bool ImportLabelmapToSegmentationNode(vtkMRMLLabelMapVolumeNode* labelmapNode,
                                               vtkMRMLSegmentationNode* segmentationNode,
                                               std::string insertBeforeSegmentId = "",
                                               vtkMRMLMessageCollection* userMessages = nullptr);

  static bool ImportLabelmapToSegmentationNode(vtkOrientedImageData* labelmapImage,
                                               vtkMRMLSegmentationNode* segmentationNode,
                                               std::string baseSegmentName = "",
                                               std::string insertBeforeSegmentId = "",
                                               vtkMRMLMessageCollection* userMessages = nullptr);

  static bool ImportLabelmapToSegmentationNode(vtkMRMLLabelMapVolumeNode* labelmapNode,
                                               vtkMRMLSegmentationNode* segmentationNode,
                                               vtkStringArray* updatedSegmentIDs,
                                               vtkMRMLMessageCollection* userMessages = nullptr);

  static bool ImportLabelmapToSegmentationNode(vtkOrientedImageData* labelmapImage,
                                               vtkMRMLSegmentationNode* segmentationNode,
                                               vtkStringArray* updatedSegmentIDs,
                                               vtkGeneralTransform* labelmapToSegmentationTransform = nullptr,
                                               vtkMRMLMessageCollection* userMessages = nullptr);

  bool ImportLabelmapToSegmentationNodeWithTerminology(vtkMRMLLabelMapVolumeNode* labelmapNode,
                                                       vtkMRMLSegmentationNode* segmentationNode,
                                                       std::string terminologyContextName,
                                                       std::string insertBeforeSegmentId = "",
                                                       vtkMRMLMessageCollection* userMessages = nullptr);

  static bool ImportModelToSegmentationNode(vtkMRMLModelNode* modelNode, vtkMRMLSegmentationNode* segmentationNode, std::string insertBeforeSegmentId = "");

  static bool ImportModelsToSegmentationNode(vtkIdType folderItemId, vtkMRMLSegmentationNode* segmentationNode, std::string insertBeforeSegmentId = "");

  static bool ExportSegmentsClosedSurfaceRepresentationToFiles(std::string destinationFolder,
                                                               vtkMRMLSegmentationNode* segmentationNode,
                                                               vtkStringArray* segmentIds = nullptr,
                                                               std::string fileFormat = "STL",
                                                               bool lps = true,
                                                               double sizeScale = 1.0,
                                                               bool merge = false);

  static void GetLabelValuesFromColorNode(vtkMRMLSegmentationNode* segmentationNode, vtkMRMLColorTableNode* colorTableNode, vtkStringArray* segmentIds, vtkIntArray* labelValues);

  static bool ExportSegmentsBinaryLabelmapRepresentationToFiles(std::string destinationFolder,
                                                                vtkMRMLSegmentationNode* segmentationNode,
                                                                vtkStringArray* segmentIds = nullptr,
                                                                std::string extension = "nrrd",
                                                                bool useCompression = false,
                                                                vtkMRMLVolumeNode* referenceVolumeNode = nullptr,
                                                                int extentComputationMode = vtkSegmentation::EXTENT_REFERENCE_GEOMETRY,
                                                                vtkMRMLColorTableNode* colorTableNode = nullptr);

  static vtkDataObject* CreateRepresentationForOneSegment(vtkSegmentation* segmentation, std::string segmentID, std::string representationName);

  static bool ApplyParentTransformToOrientedImageData(vtkMRMLTransformableNode* transformableNode,
                                                      vtkOrientedImageData* orientedImageData,
                                                      bool linearInterpolation = false,
                                                      double backgroundColor[4] = nullptr);

  static bool ApplyParentTransformToPolyData(vtkMRMLTransformableNode* transformableNode, vtkPolyData* polyData);

  static bool GetTransformBetweenRepresentationAndSegmentation(vtkMRMLTransformableNode* representationNode,
                                                               vtkMRMLSegmentationNode* segmentationNode,
                                                               vtkGeneralTransform* representationToSegmentationTransform);

  static bool GetSegmentRepresentation(vtkMRMLSegmentationNode* segmentationNode,
                                       std::string segmentID,
                                       std::string representationName,
                                       vtkDataObject* segmentRepresentation,
                                       bool applyParentTransform = true);

  static bool GetSegmentBinaryLabelmapRepresentation(vtkMRMLSegmentationNode* segmentationNode,
                                                     std::string segmentID,
                                                     vtkOrientedImageData* imageData,
                                                     bool applyParentTransform = true);

  static bool GetSegmentClosedSurfaceRepresentation(vtkMRMLSegmentationNode* segmentationNode, std::string segmentID, vtkPolyData* polyData, bool applyParentTransform = true);

  enum
  {
    MODE_REPLACE = 0,
    MODE_MERGE_MAX,
    MODE_MERGE_MIN,
    MODE_MERGE_MASK
  };
  static bool SetBinaryLabelmapToSegment(vtkOrientedImageData* labelmap,
                                         vtkMRMLSegmentationNode* segmentationNode,
                                         std::string segmentID,
                                         int mergeMode = MODE_REPLACE,
                                         const int extent[6] = nullptr,
                                         bool minimumOfAllSegments = false,
                                         const std::vector<std::string>& segmentIdsToOverwrite = {});

  bool SetTerminologyToSegmentationFromLabelmapNode(vtkMRMLSegmentationNode* segmentationNode, vtkMRMLLabelMapVolumeNode* labelmapNode, std::string terminologyContextName);

  vtkMRMLSegmentationNode* GetDefaultSegmentationNode();

  bool GetDefaultSurfaceSmoothingEnabled();
  void SetDefaultSurfaceSmoothingEnabled(bool enabled);

  vtkMRMLSegmentEditorNode* GetDefaultSegmentEditorNode();

  int GetDefaultOverwriteMode();
  void SetDefaultOverwriteMode(int mode);
 
  enum SegmentStatus
  {
    NotStarted,
    InProgress,
    Completed,
    Flagged,
    LastStatus
  };

  static const char* GetSegmentStatusAsHumanReadableString(int segmentStatus);
  static const char* GetSegmentStatusAsMachineReadableString(int segmentStatus);
  static int GetSegmentStatusFromMachineReadableString(std::string statusString);

  static const char* GetStatusTagName();
  static int GetSegmentStatus(vtkSegment* segment);
  static void SetSegmentStatus(vtkSegment* segment, int status);
  static bool ClearSegment(vtkMRMLSegmentationNode* segmentationNode, std::string segmentID);

  static bool GetSharedSegmentIDsInMask(vtkMRMLSegmentationNode* segmentationNode,
                                        std::string sharedSegmentID,
                                        vtkOrientedImageData* mask,
                                        const int extent[6],
                                        std::vector<std::string>& segmentIDs,
                                        int maskThreshold = 0.0,
                                        bool includeInputSharedSegmentID = false);

  static bool ReconvertAllRepresentations(vtkMRMLSegmentationNode* segmentationNode, const std::vector<std::string>& segmentIDs = {});

  static void CollapseBinaryLabelmaps(vtkMRMLSegmentationNode* segmentationNode, bool forceToSingleLayer);

  static void GenerateMergedLabelmapInReferenceGeometry(vtkMRMLSegmentationNode* segmentationNode,
                                                        vtkMRMLVolumeNode* referenceVolumeNode,
                                                        vtkStringArray* segmentIDs,
                                                        int extentComputationMode,
                                                        vtkOrientedImageData* mergedLabelmap_Reference,
                                                        vtkIntArray* labelValues = nullptr);

  static bool IsEffectiveExentOutsideReferenceVolume(vtkMRMLVolumeNode* referenceVolumeNode, vtkMRMLSegmentationNode* segmentationNode, vtkStringArray* segmentIDs = nullptr);

  static bool IsSegmentationExentOutsideReferenceGeometry(vtkOrientedImageData* referenceGeometry, vtkOrientedImageData* segmentationGeometry);
 
protected:
  void SetMRMLSceneInternal(vtkMRMLScene* newScene) override;

  void RegisterNodes() override;

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

  void OnMRMLSceneNodeAdded(vtkMRMLNode* node) override;
 
  static bool ExportSegmentsClosedSurfaceRepresentationToStlFiles(std::string destinationFolder,
                                                                  vtkMRMLSegmentationNode* segmentationNode,
                                                                  const std::vector<std::string>& segmentIDs,
                                                                  bool lps,
                                                                  double sizeScale,
                                                                  bool merge);
  static bool ExportSegmentsClosedSurfaceRepresentationToObjFile(std::string destinationFolder,
                                                                 vtkMRMLSegmentationNode* segmentationNode,
                                                                 const std::vector<std::string>& segmentIDs,
                                                                 bool lps,
                                                                 double sizeScale);

  static std::string GetSafeFileName(std::string originalName);
 
protected:
  vtkSlicerSegmentationsModuleLogic();
  ~vtkSlicerSegmentationsModuleLogic() override;

  vtkCallbackCommand* SubjectHierarchyUIDCallbackCommand;
 
private:
  vtkSlicerSegmentationsModuleLogic(const vtkSlicerSegmentationsModuleLogic&) = delete;
  void operator=(const vtkSlicerSegmentationsModuleLogic&) = delete;
};
 
#endif