vtkSegmentation.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 __vtkSegmentation_h
#define __vtkSegmentation_h
 
// VTK includes
#include <vtkObject.h>
#include <vtkSmartPointer.h>
 
// STD includes
#include <map>
#include <deque>
#include <vector>
 
// SegmentationCore includes
#include "vtkSegment.h"
#include "vtkSegmentationConverter.h"
#include "vtkSegmentationConverterRule.h"
 
#include "vtkSegmentationCoreConfigure.h"
 
#include <vtkSingleton.h>
 
class vtkAbstractTransform;
class vtkCallbackCommand;
class vtkCollection;
class vtkIntArray;
class vtkMinimalStandardRandomSequence;
class vtkSegmentationConversionPath;
class vtkStringArray;

class vtkSegmentationCore_EXPORT vtkSegmentation : public vtkObject
{
public:
  enum
  {
    SourceRepresentationModified = 62100,
    RepresentationModified,
    SegmentAdded,
    SegmentRemoved,
    SegmentModified,
    ContainedRepresentationNamesModified,
    SegmentsOrderModified,
  };
 
  enum
  {
    EXTENT_REFERENCE_GEOMETRY,
    EXTENT_UNION_OF_SEGMENTS,
    EXTENT_UNION_OF_SEGMENTS_PADDED,
    EXTENT_UNION_OF_EFFECTIVE_SEGMENTS,
    EXTENT_UNION_OF_EFFECTIVE_SEGMENTS_PADDED,
    EXTENT_UNION_OF_EFFECTIVE_SEGMENTS_AND_REFERENCE_GEOMETRY
  };

  typedef std::map<std::string, vtkSmartPointer<vtkSegment>> SegmentMap;
 
public:
  static vtkSegmentation* New();
  vtkTypeMacro(vtkSegmentation, vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  virtual void ReadXMLAttributes(const char** atts);

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

  virtual void DeepCopy(vtkSegmentation* aSegmentation);

  virtual void CopyConversionParameters(vtkSegmentation* aSegmentation);

  virtual void GetBounds(double bounds[6]);

  virtual void ApplyLinearTransform(vtkAbstractTransform* transform);

  virtual void ApplyNonLinearTransform(vtkAbstractTransform* transform);
 
#ifndef __VTK_WRAP__
  std::string DetermineCommonLabelmapGeometry(int extentComputationMode = EXTENT_UNION_OF_SEGMENTS, const std::vector<std::string>& segmentIDs = std::vector<std::string>());

  void DetermineCommonLabelmapExtent(int commonGeometryExtent[6],
                                     vtkOrientedImageData* commonGeometryImage,
                                     const std::vector<std::string>& segmentIDs = std::vector<std::string>(),
                                     bool computeEffectiveExtent = false,
                                     bool addPadding = false);
#endif // __VTK_WRAP__

  std::string DetermineCommonLabelmapGeometry(int extentComputationMode, vtkStringArray* segmentIds);

  void DetermineCommonLabelmapExtent(int commonGeometryExtent[6],
                                     vtkOrientedImageData* commonGeometryImage,
                                     vtkStringArray* segmentIds,
                                     bool computeEffectiveExtent = false,
                                     bool addPadding = false);

  bool SetImageGeometryFromCommonLabelmapGeometry(vtkOrientedImageData* imageData,
                                                  vtkStringArray* segmentIDs = nullptr,
                                                  int extentComputationMode = vtkSegmentation::EXTENT_UNION_OF_EFFECTIVE_SEGMENTS);
 
  // Segment related methods

  bool AddSegment(vtkSegment* segment, std::string segmentId = "", std::string insertBeforeSegmentId = "");

  std::string GenerateUniqueSegmentID(std::string id = "");

  void RemoveSegment(std::string segmentId);

  void RemoveSegment(vtkSegment* segment);

  void RemoveAllSegments();

  vtkSegment* GetSegment(std::string segmentId);

  void GetSegmentIDs(std::vector<std::string>& segmentIds);

  void GetSegmentIDs(vtkStringArray* segmentIds);

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

  int GetNumberOfSegments() const;

  vtkSegment* GetNthSegment(unsigned int index) const;

  std::string GetNthSegmentID(unsigned int index) const;

  int GetSegmentIndex(const std::string& segmentId);

  bool SetSegmentIndex(const std::string& segmentId, unsigned int newIndex);

  void ReorderSegments(std::vector<std::string> segmentIdsToMove, std::string insertBeforeSegmentId = "");

  std::string GetSegmentIdBySegment(vtkSegment* segment);

  std::string GetSegmentIdBySegmentName(std::string name);

  std::vector<vtkSegment*> GetSegmentsByTag(std::string tag, std::string value = "");

  vtkDataObject* GetSegmentRepresentation(std::string segmentId, std::string representationName);

  bool CopySegmentFromSegmentation(vtkSegmentation* fromSegmentation, std::string segmentId, bool removeFromSource = false);
 
  // Representation related methods

  void GetContainedRepresentationNames(std::vector<std::string>& representationNames);

  bool ContainsRepresentation(std::string representationName);

  bool IsSourceRepresentationPolyData();

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

  bool IsSourceRepresentationImageData();

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

  void GetAvailableRepresentationNames(std::set<std::string>& representationNames) { this->Converter->GetAvailableRepresentationNames(representationNames); };

  void InvalidateNonSourceRepresentations();

  void InvalidateNonMasterRepresentations()
  {
    vtkWarningMacro("vtkSegmentation::InvalidateNonMasterRepresentations() method is deprecated, please use InvalidateNonSourceRepresentations method instead");
    this->InvalidateNonSourceRepresentations();
  };

 
#ifndef __VTK_WRAP__
  bool GenerateMergedLabelmap(vtkOrientedImageData* mergedImageData,
                              int extentComputationMode,
                              vtkOrientedImageData* mergedLabelmapGeometry = nullptr,
                              const std::vector<std::string>& segmentIDs = std::vector<std::string>(),
                              vtkIntArray* labelValues = nullptr);
#endif // __VTK_WRAP__


  bool IsSharedBinaryLabelmap(std::string segmentID);

  void GetSegmentIDsSharingRepresentation(std::string originalSegmentId,
                                          std::string representationName,
                                          std::vector<std::string>& sharedSegmentIds,
                                          bool includeOriginalSegmentId = true);

  void GetSegmentIDsSharingBinaryLabelmapRepresentation(std::string originalSegmentId, std::vector<std::string>& sharedSegmentIds, bool includeOriginalSegmentId = true);

  int GetUniqueLabelValueForSharedLabelmap(std::string segmentId);

  int GetUniqueLabelValueForSharedLabelmap(vtkOrientedImageData* labelmap);

  void MergeSegmentLabelmaps(std::vector<std::string> mergeSegmentIds);

  void SeparateSegmentLabelmap(std::string segmentId);

  void ClearSegment(std::string segmentId);


  int GetNumberOfLayers(std::string representationName = "");

  int GetLayerIndex(std::string segmentId, std::string representationName = "");

  vtkDataObject* GetLayerDataObject(int layer, std::string representationName = "");

  void GetLayerObjects(vtkCollection* layerObjects, std::string representationName = "");

  std::vector<std::string> GetSegmentIDsForLayer(int layer, std::string representationName = "");

  std::vector<std::string> GetSegmentIDsForDataObject(vtkDataObject* dataObject, std::string representationName = "");

  void CollapseBinaryLabelmaps(bool forceToSingleLayer = false);
 
  // Conversion related methods

  bool CreateRepresentation(const std::string& targetRepresentationName, bool alwaysConvert = false);

  bool CreateRepresentation(vtkSegmentationConversionPath* path, vtkSegmentationConversionParameters* parameters);

  void RemoveRepresentation(const std::string& representationName);

  bool CanAcceptRepresentation(std::string representationName);

  bool CanAcceptSegment(vtkSegment* segment);

  std::string AddEmptySegment(std::string segmentId = "", std::string segmentName = "", double color[3] = nullptr);

  void GetPossibleConversions(const std::string& targetRepresentationName, vtkSegmentationConversionPaths* paths);

  void SetConversionParameter(const std::string& name, const std::string& value) { this->Converter->SetConversionParameter(name, value); };

  std::string GetConversionParameter(const std::string& name) { return this->Converter->GetConversionParameter(name); };

  void GetConversionParametersForPath(vtkSegmentationConversionParameters* conversionParameters, vtkSegmentationConversionPath* path)
  {
    this->Converter->GetConversionParametersForPath(conversionParameters, path);
  };

  std::string SerializeAllConversionParameters();

  void DeserializeConversionParameters(std::string conversionParametersString);
 
  // Get/set methods

  vtkGetMacro(SourceRepresentationName, std::string);
  virtual void SetSourceRepresentationName(const std::string& representationName);

  virtual void SetMasterRepresentationName(const std::string& representationName)
  {
    vtkWarningMacro("vtkSegmentation::SetMasterRepresentationName() method is deprecated, please use SetSourceRepresentationName method instead");
    this->SetSourceRepresentationName(representationName);
  };

  virtual std::string GetMasterRepresentationName()
  {
    vtkWarningMacro("vtkSegmentation::GetMasterRepresentationName() method is deprecated, please use GetSourceRepresentationName method instead");
    return this->GetSourceRepresentationName();
  };

  static void CopySegment(vtkSegment* destination, vtkSegment* source, vtkSegment* baseline, std::map<vtkDataObject*, vtkDataObject*>& cachedRepresentations);
 
  vtkSetMacro(UUIDSegmentIDs, bool);
  vtkGetMacro(UUIDSegmentIDs, bool);
  vtkBooleanMacro(UUIDSegmentIDs, bool);
 
  static vtkMinimalStandardRandomSequence* GetSegmentIDRandomSequenceInstance();
 
protected:
  bool ConvertSegmentsUsingPath(std::vector<std::string> segmentIDs, vtkSegmentationConversionPath* path, bool overwriteExisting = false);

  bool ConvertSegmentUsingPath(vtkSegment* segment, vtkSegmentationConversionPath* path, bool overwriteExisting = false);

  bool ConvertSingleSegment(std::string segmentId, std::string targetRepresentationName);

  void RemoveSegment(SegmentMap::iterator segmentIt);

  bool SetSourceRepresentationModifiedEnabled(bool enabled);

  bool SetSegmentModifiedEnabled(bool enabled);
 
protected:
  static void OnSegmentModified(vtkObject* caller, unsigned long eid, void* clientData, void* callData);

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

  void UpdateSourceRepresentationObservers();

  static std::string GenerateUUIDDerivedUID();

  static std::string GenerateRandomSegmentID(int suffixLength, std::string validCharacters = "");

  std::string GenerateUniqueSegmentName(std::string base);
 
protected:
  vtkSegmentation();
  ~vtkSegmentation() override;
 
protected:
  SegmentMap Segments;

  std::string SourceRepresentationName;

  vtkSegmentationConverter* Converter;

  vtkCallbackCommand* SegmentCallbackCommand;

  vtkCallbackCommand* SourceRepresentationCallbackCommand;

  bool SourceRepresentationModifiedEnabled;

  bool SegmentModifiedEnabled;

  int SegmentIdAutogeneratorIndex;

  std::deque<std::string> SegmentIds;
 
  std::set<vtkSmartPointer<vtkDataObject>> SourceRepresentationCache;
 
  bool UUIDSegmentIDs;

  friend class vtkSegmentationRandomSequenceInitialize;

  static void classInitialize();
  static void classFinalize();
 
  friend class vtkMRMLSegmentationNode;
  friend class vtkSlicerSegmentationsModuleLogic;
  friend class vtkSegmentationModifier;
  friend class qMRMLSegmentEditorWidgetPrivate;
 
private:
  vtkSegmentation(const vtkSegmentation&) = delete;
  void operator=(const vtkSegmentation&) = delete;
};
 
VTK_SINGLETON_DECLARE_INITIALIZER(vtkSegmentationCore_EXPORT, vtkSegmentationRandomSequence);
 
#endif