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"

class vtkAbstractTransform;
class vtkCallbackCommand;
class vtkCollection;
class vtkIntArray;
class vtkStringArray;

class vtkSegmentationCore_EXPORT vtkSegmentation : public vtkObject
{
public:
  enum
    {
    MasterRepresentationModified = 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 IsMasterRepresentationPolyData();

  bool IsMasterRepresentationImageData();

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

  void InvalidateNonMasterRepresentations();


#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(vtkSegmentationConverter::ConversionPathType path,
                            vtkSegmentationConverterRule::ConversionParameterListType 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,
    vtkSegmentationConverter::ConversionPathAndCostListType &pathsCosts);

  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(vtkSegmentationConverterRule::ConversionParameterListType& conversionParameters,
    const vtkSegmentationConverter::ConversionPathType& path) { this->Converter->GetConversionParametersForPath(conversionParameters, path); };

  std::string SerializeAllConversionParameters();

  void DeserializeConversionParameters(std::string conversionParametersString);

// Get/set methods

  vtkGetMacro(MasterRepresentationName, std::string);
  virtual void SetMasterRepresentationName(const std::string& representationName);

  static void CopySegment(vtkSegment* destination, vtkSegment* source, vtkSegment* baseline,
    std::map<vtkDataObject*, vtkDataObject*>& cachedRepresentations);

protected:
  bool ConvertSegmentsUsingPath(std::vector<std::string> segmentIDs, vtkSegmentationConverter::ConversionPathType path, bool overwriteExisting = false);

  bool ConvertSegmentUsingPath(vtkSegment* segment, vtkSegmentationConverter::ConversionPathType path, bool overwriteExisting = false);

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

  void RemoveSegment(SegmentMap::iterator segmentIt);

  bool SetMasterRepresentationModifiedEnabled(bool enabled);

  bool SetSegmentModifiedEnabled(bool enabled);

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

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

  void UpdateMasterRepresentationObservers();

protected:
  vtkSegmentation();
  ~vtkSegmentation() override;

protected:
  SegmentMap Segments;

  std::string MasterRepresentationName;

  vtkSegmentationConverter* Converter;

  vtkCallbackCommand* SegmentCallbackCommand;

  vtkCallbackCommand* MasterRepresentationCallbackCommand;

  bool MasterRepresentationModifiedEnabled;

  bool SegmentModifiedEnabled;

  int SegmentIdAutogeneratorIndex;

  std::deque< std::string > SegmentIds;

  std::set<vtkSmartPointer<vtkDataObject> > MasterRepresentationCache;

  friend class vtkMRMLSegmentationNode;
  friend class vtkSlicerSegmentationsModuleLogic;
  friend class vtkSegmentationModifier;
  friend class qMRMLSegmentEditorWidgetPrivate;

private:
  vtkSegmentation(const vtkSegmentation&) = delete;
  void operator=(const vtkSegmentation&) = delete;
};

#endif // __vtkSegmentation_h