This class encapsulates a segmentation that can contain multiple segments and multiple representations for each segment. More...

#include <Libs/vtkSegmentationCore/vtkSegmentation.h>

Inheritance diagram for vtkSegmentation:

[legend]

Collaboration diagram for vtkSegmentation:

[legend]

Public Types
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 }

typedef std::map< std::string, vtkSmartPointer< vtkSegment > >	SegmentMap
	Container type for segments. Maps segment IDs to segment objects. More...

typedef vtkObject	Superclass

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

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

virtual void	ApplyLinearTransform (vtkAbstractTransform *transform)

virtual void	ApplyNonLinearTransform (vtkAbstractTransform *transform)

bool	CanAcceptRepresentation (std::string representationName)

bool	CanAcceptSegment (vtkSegment *segment)

void	ClearSegment (std::string segmentId)

void	CollapseBinaryLabelmaps (bool forceToSingleLayer=false)

bool	ContainsRepresentation (std::string representationName)

virtual void	CopyConversionParameters (vtkSegmentation *aSegmentation)
	Copy conversion parameters from another segmentation. More...

bool	CopySegmentFromSegmentation (vtkSegmentation *fromSegmentation, std::string segmentId, bool removeFromSource=false)

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

bool	CreateRepresentation (vtkSegmentationConverter::ConversionPathType path, vtkSegmentationConverterRule::ConversionParameterListType parameters)

virtual void	DeepCopy (vtkSegmentation *aSegmentation)
	Deep copy one segmentation into another. More...

void	DeserializeConversionParameters (std::string conversionParametersString)

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

void	DetermineCommonLabelmapExtent (int commonGeometryExtent[6], vtkOrientedImageData commonGeometryImage, vtkStringArray segmentIds, bool computeEffectiveExtent=false, bool addPadding=false)
	Determine common labelmap extent for whole segmentation, for python compatibility. More...

std::string	DetermineCommonLabelmapGeometry (int extentComputationMode=EXTENT_UNION_OF_SEGMENTS, const std::vector< std::string > &segmentIDs=std::vector< std::string >())

std::string	DetermineCommonLabelmapGeometry (int extentComputationMode, vtkStringArray *segmentIds)
	Determine common labelmap geometry for whole segmentation, for python compatibility. More...

bool	GenerateMergedLabelmap (vtkOrientedImageData mergedImageData, int extentComputationMode, vtkOrientedImageData mergedLabelmapGeometry=nullptr, const std::vector< std::string > &segmentIDs=std::vector< std::string >(), vtkIntArray *labelValues=nullptr)
	Merged labelmap functions. More...

std::string	GenerateUniqueSegmentID (std::string id)

void	GetAvailableRepresentationNames (std::set< std::string > &representationNames)
	Get all representations supported by the converter. More...

virtual void	GetBounds (double bounds[6])
	Get bounding box in global RAS in the form (xmin,xmax, ymin,ymax, zmin,zmax). More...

virtual const char *	GetClassName ()

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

std::string	GetConversionParameter (const std::string &name)

void	GetConversionParametersForPath (vtkSegmentationConverterRule::ConversionParameterListType &conversionParameters, const vtkSegmentationConverter::ConversionPathType &path)
	Get names of all conversion parameters used by the selected conversion path. More...

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

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

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

virtual std::string	GetMasterRepresentationName ()
	Get master representation name. More...

vtkSegment *	GetNthSegment (unsigned int index) const
	Request segment by index. More...

std::string	GetNthSegmentID (unsigned int index) const
	Get n-th segment ID. Return with "" if no segment is found by that index. More...

int	GetNumberOfLayers (std::string representationName="")
	Shared representation layer functions. More...

int	GetNumberOfSegments () const
	Request the total number of segments, primarily used for iterating over all segments. More...

void	GetPossibleConversions (const std::string &targetRepresentationName, vtkSegmentationConverter::ConversionPathAndCostListType &pathsCosts)
	Get all possible conversions between the master representation and a specified target representation. More...

vtkSegment *	GetSegment (std::string segmentId)

std::string	GetSegmentIdBySegment (vtkSegment *segment)

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

void	GetSegmentIDs (std::vector< std::string > &segmentIds)
	Get IDs for all contained segments. More...

void	GetSegmentIDs (vtkStringArray *segmentIds)
	Get IDs for all contained segments, for python compatibility. More...

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

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

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

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

int	GetSegmentIndex (const std::string &segmentId)

vtkDataObject *	GetSegmentRepresentation (std::string segmentId, std::string representationName)
	Get representation from segment. More...

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

int	GetUniqueLabelValueForSharedLabelmap (std::string segmentId)

int	GetUniqueLabelValueForSharedLabelmap (vtkOrientedImageData *labelmap)

void	InvalidateNonMasterRepresentations ()
	Invalidate (remove) non-master representations in all the segments if this segmentation node. More...

virtual int	IsA (const char *type)

bool	IsMasterRepresentationImageData ()
	Determine if master representation is (oriented) image data type. More...

bool	IsMasterRepresentationPolyData ()
	Determine if master representation is poly data type. More...

bool	IsSharedBinaryLabelmap (std::string segmentID)
	Shared labelmap utility functions. More...

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

void	PrintSelf (ostream &os, vtkIndent indent) override

virtual void	ReadXMLAttributes (const char **atts)
	Set attributes from name/value pairs. More...

void	RemoveAllSegments ()
	Remove all segments. More...

void	RemoveRepresentation (const std::string &representationName)
	Removes a representation from all segments if present. More...

void	RemoveSegment (std::string segmentId)

void	RemoveSegment (vtkSegment *segment)

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

void	SeparateSegmentLabelmap (std::string segmentId)
	Moves an existing segment from a shared labelmap into a separate labelmap containing only the specified segment. More...

std::string	SerializeAllConversionParameters ()

void	SetConversionParameter (const std::string &name, const std::string &value)
	Set a conversion parameter to all rules having this parameter. More...

bool	SetImageGeometryFromCommonLabelmapGeometry (vtkOrientedImageData imageData, vtkStringArray segmentIDs=nullptr, int extentComputationMode=vtkSegmentation::EXTENT_UNION_OF_EFFECTIVE_SEGMENTS)

virtual void	SetMasterRepresentationName (const std::string &representationName)

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

virtual void	WriteXML (ostream &of, int indent)
	Write this object's information to a MRML file in XML format. More...

Static Public Member Functions
static void	CopySegment (vtkSegment destination, vtkSegment source, vtkSegment baseline, std::map< vtkDataObject , vtkDataObject *> &cachedRepresentations)

static int	IsTypeOf (const char *type)

static vtkSegmentation *	New ()

static vtkSegmentation *	SafeDownCast (vtkObject *o)

Protected Member Functions
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)
	Converts a single segment to a representation. More...

void	RemoveSegment (SegmentMap::iterator segmentIt)

bool	SetMasterRepresentationModifiedEnabled (bool enabled)

bool	SetSegmentModifiedEnabled (bool enabled)

void	UpdateMasterRepresentationObservers ()

	vtkSegmentation ()

	~vtkSegmentation () override

Static Protected Member Functions
static void	OnMasterRepresentationModified (vtkObject caller, unsigned long eid, void clientData, void *callData)

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

Protected Attributes
vtkSegmentationConverter *	Converter
	Converter instance. More...

std::set< vtkSmartPointer< vtkDataObject > >	MasterRepresentationCache

vtkCallbackCommand *	MasterRepresentationCallbackCommand
	Command handling master representation modified events. More...

bool	MasterRepresentationModifiedEnabled
	Modified events of master representations are observed. More...

std::string	MasterRepresentationName

vtkCallbackCommand *	SegmentCallbackCommand
	Command handling segment modified events. More...

int	SegmentIdAutogeneratorIndex

std::deque< std::string >	SegmentIds

bool	SegmentModifiedEnabled
	Modified events of segments are observed. More...

SegmentMap	Segments
	Container of segments that belong to this segmentation. More...

Friends
class	qMRMLSegmentEditorWidgetPrivate

class	vtkMRMLSegmentationNode

class	vtkSegmentationModifier

class	vtkSlicerSegmentationsModuleLogic

Detailed Description

This class encapsulates a segmentation that can contain multiple segments and multiple representations for each segment.

The primary purpose of this class is to serve as a container to store the segments (in labelmap analogy the "labels"). Also provides generic functions on the segmentation level. Performs conversion to a specified representation, extracts geometry information etc.

Main points to remember:

Each segment has the same set of representations. This means that if segments are copied/moved between segmentations, then conversion will take place if possible (if not then copy will fail)
Default representations types are
- Binary labelmap (vtkOrientedImageData)
- Closed surface (vtkPolyData)
- Fractional labelmap (vtkOrientedImageData)
- Additional representations can be defined (SlicerRT adds two: Planar contour, Ribbon model) (https://github.com/SlicerRt/SlicerRT/tree/master/DicomRtImportExport/ConversionRules)
Conversion between representations are driven by a conversion graph in which the nodes are the representations and the edges are conversion rules
- When converting with the default method (
  See also
  CreateRepresentation without specifying a path), then the path with the lowest cost is used (rules have a cost field that gives a ballpark value for the conversion cost)
- Representation types can be defined by registering conversion algorithms (rules) that specify their source and target representations, and an estimated cost metric
Master representation
- Privileged representation type. Can be any of the available representations, but usually it's the original representation of the data (binary labelmap for editing, binary or fractional labelmap for DICOM SEG, planar contour for DICOM RT, etc.)
  - Using the proper master representation ensures that no information is lost, which is crucial to avoid discrepancies that can never be solved when data is permanently lost in conversion
- Properties
  - All conversions use it as source (up-to-date representations along conversion path are used if available)
  - When changed all other representations are invalidated (and is re-converted later from master)
  - It is the representation that is saved to disk

Schematic illustration of the segmentation container:

                      +=============================================+
                      |             Patient (vtkSegmentation)       |
                      +======================+======================+
                      |  Brain (vtkSegment)  |  Tumor (vtkSegment)  |
                      +======================+======================+
      Binary labelmap | vtkOrientedImageData | vtkOrientedImageData |
                      +----------------------+----------------------+
       Closed surface | vtkPolyData          | vtkPolyData          |
                      +----------------------+----------------------+
Custom representation | vtkDataObject        | vtkDataObject        |
                      +----------------------+----------------------+

Definition at line 92 of file vtkSegmentation.h.

Member Typedef Documentation

◆ SegmentMap

typedef std::map<std::string, vtkSmartPointer<vtkSegment> > vtkSegmentation::SegmentMap

Container type for segments. Maps segment IDs to segment objects.

Definition at line 129 of file vtkSegmentation.h.

◆ Superclass

typedef vtkObject vtkSegmentation::Superclass

Definition at line 133 of file vtkSegmentation.h.

Member Enumeration Documentation

◆ anonymous enum

anonymous enum

Enumerator
MasterRepresentationModified	Invoked when content of the master representation in a segment is changed.
RepresentationModified	Invoked when content of any representation (including the master representation) in a segment is changed.
SegmentAdded	Invoked if new segment is added.
SegmentRemoved	Invoked if a segment is removed.
SegmentModified	Invoked if a segment is modified (name changed, tags changed, etc). Note: the event is not invoked when content of a representation in a segment is changed.
ContainedRepresentationNamesModified	Invoked if a representation is created or removed in the segments (e.g., created by conversion from master).
SegmentsOrderModified	Invoked if segment IDs order is changed. Not called when a segment is added or removed.

Definition at line 95 of file vtkSegmentation.h.

◆ anonymous enum

anonymous enum

Enumerator
EXTENT_REFERENCE_GEOMETRY	Extent of common geometry is used as extent.
EXTENT_UNION_OF_SEGMENTS	Extent is computed as union of extent of all segments.
EXTENT_UNION_OF_SEGMENTS_PADDED	Extent is computed as union of extent of all segments, with a single-voxel padding added on each side.
EXTENT_UNION_OF_EFFECTIVE_SEGMENTS	Extent is computed as union of effective extent of all segments.
EXTENT_UNION_OF_EFFECTIVE_SEGMENTS_PADDED	Extent is computed as union of effective extent of all segments, with a single-voxel padding added on each side.

Definition at line 114 of file vtkSegmentation.h.

Constructor & Destructor Documentation

◆ vtkSegmentation()

vtkSegmentation::vtkSegmentation ( )

protected

◆ ~vtkSegmentation()

vtkSegmentation::~vtkSegmentation ( )

overrideprotected

Member Function Documentation

◆ AddEmptySegment()

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

Add empty segment containing empty instances of the contained representations

Parameters

segmentId ID of added segment. If empty then a default ID will be generated

See also: GenerateUniqueSegmentId

Parameters

segmentName	name of added segment. If empty then the segmentId will be used as name.
color	of added segment. If not specified then empty then vtkSegment::SEGMENT_COLOR_INVALID is used.

Returns: ID of the added segment. Empty on failure

◆ AddSegment()

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

Add a segment to this segmentation, do necessary conversions, and observe underlying data for changes. Necessary conversions:

If the segment can be added (
See also
CanAcceptSegment), and it does not contain the master representation, then the master representation is converted using the cheapest available path.
Make sure that the segment contains the same types of representations that are present in the existing segments of the segmentation (because we expect all segments in a segmentation to contain the same types of representations).
Parameters

segment the segment to observe

insertBeforeSegmentId if specified then the segment is inserted before insertBeforeSegmentId

Returns
Success flag

◆ ApplyLinearTransform()

virtual void vtkSegmentation::ApplyLinearTransform ( vtkAbstractTransform * transform )

virtual

Apply a linear transform on the master representation of the segments. The others will be invalidated Harden transform if poly data, apply to directions if oriented image data.

◆ ApplyNonLinearTransform()

virtual void vtkSegmentation::ApplyNonLinearTransform ( vtkAbstractTransform * transform )

virtual

Apply a non-linear transform on the master representation of the segments. The others will be invalidated Harden transform both if oriented image data and poly data.

◆ CanAcceptRepresentation()

bool vtkSegmentation::CanAcceptRepresentation ( std::string representationName )

Determine if the segmentation is ready to accept a certain type of representation by copy/move or import. It can accept a representation if it is the master representation of this segment or it is possible to convert to master representation (or the segmentation is empty).

◆ CanAcceptSegment()

bool vtkSegmentation::CanAcceptSegment ( vtkSegment * segment )

Determine if the segmentation is ready to accept a certain segment. It can accept a segment if it contains a representation that is acceptable, or if it is empty.

◆ ClearSegment()

void vtkSegmentation::ClearSegment ( std::string segmentId )

Clears the segment representation. If the segment is in a shared labelmap, it will be erased from the labelmap. Otherwise, the vtkDataObject will be initialized.

◆ CollapseBinaryLabelmaps()

void vtkSegmentation::CollapseBinaryLabelmaps ( bool forceToSingleLayer = false )

Reduce the binary labelmap representation to as few layers as possible.

Parameters

forceToSingleLayer If false, then the layers will not be overwritten by each other, if true then the layers can overwrite each other, but the result is guaranteed to have one layer

◆ ContainsRepresentation()

bool vtkSegmentation::ContainsRepresentation ( std::string representationName )

Determine if segments contain a certain representation type Note: This assumes the first segment contains the same type of representations as all segments (this should be the case by design)

◆ ConvertSegmentsUsingPath()

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

protected

◆ ConvertSegmentUsingPath()

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

protected

Convert given segment along a specified path

Parameters

segment	Segment to convert
path	Path to do the conversion along
overwriteExisting	If true then do each conversion step regardless the target representation exists. If false then skip those conversion steps that would overwrite existing representation

Returns: Success flag

◆ ConvertSingleSegment()

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

protected

Converts a single segment to a representation.

◆ CopyConversionParameters()

virtual void vtkSegmentation::CopyConversionParameters ( vtkSegmentation * aSegmentation )

virtual

Copy conversion parameters from another segmentation.

◆ CopySegment()

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

static

Deep copies source segment to destination segment. If the same representation is found in baseline with up-to-date timestamp then the representation is reused from baseline.

◆ CopySegmentFromSegmentation()

bool vtkSegmentation::CopySegmentFromSegmentation	(	vtkSegmentation *	fromSegmentation,
		std::string	segmentId,
		bool	removeFromSource = `false`
	)

Copy segment from one segmentation to this one

Parameters

fromSegmentation	Source segmentation
segmentId	ID of segment to copy
removeFromSource	If true, then delete segment from source segmentation after copying. Default value is false.

Returns: Success flag

◆ CreateRepresentation() [1/2]

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

Create a representation in all segments, using the conversion path with the lowest cost. The stored conversion parameters are used (which are the defaults if not changed by the user). Conversion starts from the master representation. If a representation along the path already exists then no conversion is performed. Note: The conversion functions are not in vtkSegmentationConverter, because they need to know about the master representation which is segmentation- specific, and also to allow optimizations (steps before per-segment conversion).

Parameters

targetRepresentationName	Name of the representation to create
alwaysConvert	If true, then conversion takes place even if target representation exists. False by default.

Returns: true on success

◆ CreateRepresentation() [2/2]

bool vtkSegmentation::CreateRepresentation	(	vtkSegmentationConverter::ConversionPathType	path,
		vtkSegmentationConverterRule::ConversionParameterListType	parameters
	)

Generate or update a representation in all segments, using the specified conversion path and parameters. Conversion starts from the master representation, and all representations along the path get overwritten.

Returns: true on success

◆ DeepCopy()

virtual void vtkSegmentation::DeepCopy ( vtkSegmentation * aSegmentation )

virtual

Deep copy one segmentation into another.

◆ DeserializeConversionParameters()

void vtkSegmentation::DeserializeConversionParameters ( std::string conversionParametersString )

Parse conversion parameters in string and set it to the segmentation converter Such a string can be constructed in a segmentation object using /sa SerializeAllConversionParameters

◆ DetermineCommonLabelmapExtent() [1/2]

void vtkSegmentation::DetermineCommonLabelmapExtent	(	int	commonGeometryExtent[6],
		vtkOrientedImageData *	commonGeometryImage,
		const std::vector< std::string > &	segmentIDs = `std::vector< std::string >()`,
		bool	computeEffectiveExtent = `false`,
		bool	addPadding = `false`
	)

Determine common labelmap extent for whole segmentation.

Parameters

commonGeometryExtent	Computed extent that contains all the specified segments.
commonGeometryImage	Extent will be returned in this image geometry
segmentIDs	List of IDs of segments to include in the merged labelmap. If empty or missing, then all segments are included
computeEffectiveExtent	Specifies if the extent of a segment is the whole extent or the effective extent (where voxel values >0 found)

◆ DetermineCommonLabelmapExtent() [2/2]

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

Determine common labelmap extent for whole segmentation, for python compatibility.

◆ DetermineCommonLabelmapGeometry() [1/2]

std::string vtkSegmentation::DetermineCommonLabelmapGeometry	(	int	extentComputationMode = `EXTENT_UNION_OF_SEGMENTS`,
		const std::vector< std::string > &	segmentIDs = `std::vector< std::string >()`
	)

Determine common labelmap geometry for whole segmentation. If the segmentation has reference image geometry conversion parameter, then oversample it to be at least as fine resolution as the highest resolution labelmap contained, otherwise just use the geometry of the highest resolution labelmap in the segments.

Parameters

extentComputationMode	Determines how to compute extents (EXTENT_REFERENCE_GEOMETRY, EXTENT_UNION_OF_SEGMENTS, EXTENT_UNION_OF_SEGMENTS_PADDED, EXTENT_UNION_OF_EFFECTIVE_SEGMENTS, or EXTENT_UNION_OF_EFFECTIVE_SEGMENTS_PADDED).
segmentIDs	List of IDs of segments to include in the merged labelmap. If empty or missing, then all segments are included

Returns: Geometry string that can be deserialized using

See also: vtkSegmentationConverter::SerializeImageGeometry

◆ DetermineCommonLabelmapGeometry() [2/2]

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

Determine common labelmap geometry for whole segmentation, for python compatibility.

◆ GenerateMergedLabelmap()

bool vtkSegmentation::GenerateMergedLabelmap	(	vtkOrientedImageData *	mergedImageData,
		int	extentComputationMode,
		vtkOrientedImageData *	mergedLabelmapGeometry = `nullptr`,
		const std::vector< std::string > &	segmentIDs = `std::vector< std::string >()`,
		vtkIntArray *	labelValues = `nullptr`
	)

Merged labelmap functions.

Create a merged labelmap from the segment IDs If no segment IDs are specified, then all segments will be merged

Parameters

mergedImageData	Output image data for the merged labelmap image data. Voxels of background volume will be of signed short type. Label value of n-th segment in segmentIDs list will be (n + 1), or will be specified in labelValues. Label value of background = 0.
extentComputationMode	Input that determines how to compute extents (EXTENT_REFERENCE_GEOMETRY, EXTENT_UNION_OF_SEGMENTS, EXTENT_UNION_OF_SEGMENTS_PADDED, EXTENT_UNION_OF_EFFECTIVE_SEGMENTS, or EXTENT_UNION_OF_EFFECTIVE_SEGMENTS_PADDED).
mergedLabelmapGeometry	Determines geometry of merged labelmap if not nullptr, automatically determined otherwise
segmentIDs	List of IDs of segments to include in the merged labelmap. If empty or missing, then all segments are included
labelValues	Input list of label values that will be used in the merged labelmap. If not specified, then the label values in the segmentation will be used. The size of the array should match the number of segment IDs used in the merged labelmap.

◆ GenerateUniqueSegmentID()

std::string vtkSegmentation::GenerateUniqueSegmentID ( std::string id )

Generate unique segment ID. If argument is empty then a new ID will be generated in the form "Segment_", where N is the number of segments. If argument is unique it is returned unchanged. If there is a segment with the given name, then it is postfixed by a number to make it unique.

◆ GetAvailableRepresentationNames()

void vtkSegmentation::GetAvailableRepresentationNames ( std::set< std::string > & representationNames )

inline

Get all representations supported by the converter.

Definition at line 303 of file vtkSegmentation.h.

◆ GetBounds()

virtual void vtkSegmentation::GetBounds ( double bounds[6] )

virtual

Get bounding box in global RAS in the form (xmin,xmax, ymin,ymax, zmin,zmax).

◆ GetClassName()

virtual const char* vtkSegmentation::GetClassName ( )

virtual

◆ GetContainedRepresentationNames()

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

Get representation names present in this segmentation in an output string vector Note: This assumes the first segment contains the same type of representations as all segments (this should be the case by design)

◆ GetConversionParameter()

std::string vtkSegmentation::GetConversionParameter ( const std::string & name )

inline

Get a conversion parameter from first rule containing this parameter Note: all parameters with the same name should contain the same value

Definition at line 452 of file vtkSegmentation.h.

◆ GetConversionParametersForPath()

void vtkSegmentation::GetConversionParametersForPath	(	vtkSegmentationConverterRule::ConversionParameterListType &	conversionParameters,
		const vtkSegmentationConverter::ConversionPathType &	path
	)

inline

Get names of all conversion parameters used by the selected conversion path.

Definition at line 455 of file vtkSegmentation.h.

◆ GetLayerDataObject()

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

Get the data object for a particular layer index If representationName is not specified, it will be set to the master representation name

◆ GetLayerIndex()

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

Get the layer index for a particular segment If representationName is not specified, it will be set to the master representation name

◆ GetLayerObjects()

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

Get a collection of all of the data objects in the segmentation If representationName is not specified, it will be set to the master representation name

◆ GetMasterRepresentationName()

virtual std::string vtkSegmentation::GetMasterRepresentationName ( )

virtual

Get master representation name.

◆ GetNthSegment()

vtkSegment* vtkSegmentation::GetNthSegment ( unsigned int index ) const

Request segment by index.

◆ GetNthSegmentID()

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

Get n-th segment ID. Return with "" if no segment is found by that index.

◆ GetNumberOfLayers()

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

Shared representation layer functions.

Get the number of unique vtkDataObject that are used for a particular representation type If representationName is not specified, it will be set to the master representation name

◆ GetNumberOfSegments()

int vtkSegmentation::GetNumberOfSegments ( ) const

Request the total number of segments, primarily used for iterating over all segments.

◆ GetPossibleConversions()

void vtkSegmentation::GetPossibleConversions	(	const std::string &	targetRepresentationName,
		vtkSegmentationConverter::ConversionPathAndCostListType &	pathsCosts
	)

Get all possible conversions between the master representation and a specified target representation.

◆ GetSegment()

vtkSegment* vtkSegmentation::GetSegment ( std::string segmentId )

Access a segment by ID

Parameters

segmentId Segment identifier in the container to access

◆ GetSegmentIdBySegment()

std::string vtkSegmentation::GetSegmentIdBySegment ( vtkSegment * segment )

Find segment ID by segment instance Returns empty string if segment is not found.

◆ GetSegmentIdBySegmentName()

std::string vtkSegmentation::GetSegmentIdBySegmentName ( std::string name )

Find segment ID by segment name. Search is case-insensitive. If multiple segments have the same name, the first match is returned. Returns empty string if segment is not found.

◆ GetSegmentIDs() [1/2]

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

Get IDs for all contained segments.

◆ GetSegmentIDs() [2/2]

void vtkSegmentation::GetSegmentIDs ( vtkStringArray * segmentIds )

Get IDs for all contained segments, for python compatibility.

◆ GetSegmentIDsForDataObject()

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

Get the segmentIDs that use a specific data object If representationName is not specified, it will be set to the master representation name

◆ GetSegmentIDsForLayer()

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

Get the segmentIDs contained in the specified layer If representationName is not specified, it will be set to the master representation name

◆ GetSegmentIDsSharingBinaryLabelmapRepresentation()

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

Gets the segment IDs that are shared with the specified segment binary labelmap

Parameters

originalSegmentId	ID of the specified segment
sharedSegmentIds	Output segment IDs
includeOriginalSegmentId	If true, the original segment ID is included in the output

◆ GetSegmentIDsSharingRepresentation()

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

Gets the segment IDs that are shared with the specified segment

Parameters

originalSegmentId	ID of the specified segment
representationName	Representation to check for shared segment IDs
sharedSegmentIds	Output segment IDs
includeOriginalSegmentId	If true, the original segment ID is included in the output

◆ GetSegmentIndex()

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

Get index of segment in the SegmentID list. Returns -1 if the segment ID is not in the SegmentID list.

See also: GetSegmentIDs

◆ GetSegmentRepresentation()

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

Get representation from segment.

◆ GetSegmentsByTag()

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

Get segments that contain a certain tag

Parameters

tag	Tag name to look for in segments
value	Tag value to look for in segments. If omitted or empty then any value is accepted

Returns: Vector of segments containing the requested tag

◆ GetUniqueLabelValueForSharedLabelmap() [1/2]

int vtkSegmentation::GetUniqueLabelValueForSharedLabelmap ( std::string segmentId )

Gets a unique shared labelmap value for the specified segment Compares all of the other segments that are shared with the specified segmentId to determine the a unique labelmap value

◆ GetUniqueLabelValueForSharedLabelmap() [2/2]

int vtkSegmentation::GetUniqueLabelValueForSharedLabelmap ( vtkOrientedImageData * labelmap )

Gets a unique shared labelmap value for the specified labelmap Returns labelmap->GetScalarRange()[1] + 1

◆ InvalidateNonMasterRepresentations()

void vtkSegmentation::InvalidateNonMasterRepresentations ( )

Invalidate (remove) non-master representations in all the segments if this segmentation node.

◆ IsA()

virtual int vtkSegmentation::IsA ( const char * type )

virtual

◆ IsMasterRepresentationImageData()

bool vtkSegmentation::IsMasterRepresentationImageData ( )

Determine if master representation is (oriented) image data type.

◆ IsMasterRepresentationPolyData()

bool vtkSegmentation::IsMasterRepresentationPolyData ( )

Determine if master representation is poly data type.

◆ IsSharedBinaryLabelmap()

bool vtkSegmentation::IsSharedBinaryLabelmap ( std::string segmentID )

Shared labelmap utility functions.

Returns true if the binary labelmap representation is shared

◆ IsTypeOf()

static int vtkSegmentation::IsTypeOf ( const char * type )

static

◆ MergeSegmentLabelmaps()

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

Merges the specified segments into the same shared labelmap This method can cause segments to overwrite each other during during merge. Segments with a higher index will overwrite segments with a lower index. If no segment IDs are specified, then all segments will be shared

◆ New()

static vtkSegmentation* vtkSegmentation::New ( )

static

◆ OnMasterRepresentationModified()

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

staticprotected

Callback function observing the master representation of each segment It fires a

See also: MasterRepresentationModifiedEvent if master representation is changed in ANY segment

◆ OnSegmentModified()

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

staticprotected

Callback function invoked when segment is modified. It calls Modified on the segmentation and rebuilds observations on the master representation of each segment

◆ PrintSelf()

void vtkSegmentation::PrintSelf	(	ostream &	os,
		vtkIndent	indent
	)

override

◆ ReadXMLAttributes()

virtual void vtkSegmentation::ReadXMLAttributes ( const char ** atts )

virtual

Set attributes from name/value pairs.

◆ RemoveAllSegments()

void vtkSegmentation::RemoveAllSegments ( )

Remove all segments.

◆ RemoveRepresentation()

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

Removes a representation from all segments if present.

◆ RemoveSegment() [1/3]

void vtkSegmentation::RemoveSegment ( std::string segmentId )

Remove a segment by ID

Parameters

segmentId Identifier of the segment to remove from the segmentation

◆ RemoveSegment() [2/3]

void vtkSegmentation::RemoveSegment ( vtkSegment * segment )

Remove a segment by value

Parameters

segment the segment to remove from the segmentation

◆ RemoveSegment() [3/3]

void vtkSegmentation::RemoveSegment ( SegmentMap::iterator segmentIt )

protected

Remove segment by iterator. The two

See also: RemoveSegment methods call this function after finding the iterator based on their different input arguments.

◆ ReorderSegments()

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

Reorder segment IDs so that the list of segment IDs are moved from their current position and inserted after the specified segment. If insertBeforeSegmentId is empty then segments are moved to the end of the segment list.

See also: SetSegmentIndex

◆ SafeDownCast()

static vtkSegmentation* vtkSegmentation::SafeDownCast ( vtkObject * o )

static

◆ SeparateSegmentLabelmap()

void vtkSegmentation::SeparateSegmentLabelmap ( std::string segmentId )

Moves an existing segment from a shared labelmap into a separate labelmap containing only the specified segment.

◆ SerializeAllConversionParameters()

std::string vtkSegmentation::SerializeAllConversionParameters ( )

Serialize all conversion parameters. The resulting string can be parsed in a segmentation object using /sa DeserializeConversionParameters

◆ SetConversionParameter()

void vtkSegmentation::SetConversionParameter	(	const std::string &	name,
		const std::string &	value
	)

inline

Set a conversion parameter to all rules having this parameter.

Definition at line 448 of file vtkSegmentation.h.

◆ SetImageGeometryFromCommonLabelmapGeometry()

bool vtkSegmentation::SetImageGeometryFromCommonLabelmapGeometry	(	vtkOrientedImageData *	imageData,
		vtkStringArray *	segmentIDs = `nullptr`,
		int	extentComputationMode = `vtkSegmentation::EXTENT_UNION_OF_EFFECTIVE_SEGMENTS`
	)

Updates image geometry (origin, spacing, axis directions, extents) based on labelmaps stored in the segmentation. Does not allocate memory (to allow just retrieving geometry information without using memory).

◆ SetMasterRepresentationModifiedEnabled()

bool vtkSegmentation::SetMasterRepresentationModifiedEnabled ( bool enabled )

protected

Temporarily enable/disable master representation modified event.

Returns: Old value of MasterRepresentationModifiedEnabled. In general, the old value should be restored after modified is temporarily disabled to ensure proper state when calling SetMasterRepresentationModifiedEnabled in nested functions.

◆ SetMasterRepresentationName()

virtual void vtkSegmentation::SetMasterRepresentationName ( const std::string & representationName )

virtual

Set master representation name. Need to make sure before setting the name that the newly set master representation exists in the segmentation! Use

See also: CreateRepresentation for that.

◆ SetSegmentIndex()

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

Changes segment order. Segment order may be used for display and generating merged labelmaps.

Returns: True if segment index has changed successfully (or the index has already been set).

See also: ReorderSegments

◆ SetSegmentModifiedEnabled()

bool vtkSegmentation::SetSegmentModifiedEnabled ( bool enabled )

protected

Temporarily enable/disable segment modified event.

Returns: Old value of SegmentModifiedEnabled. In general, the old value should be restored after modified is temporarily disabled to ensure proper state when calling SetSegmentModifiedEnabled in nested functions.

◆ UpdateMasterRepresentationObservers()

void vtkSegmentation::UpdateMasterRepresentationObservers ( )

protected

Check to ensure that all master representations are being observed, and observers on master representations that are no longer in the segmentation are removed

◆ WriteXML()

virtual void vtkSegmentation::WriteXML	(	ostream &	of,
		int	indent
	)

virtual

Write this object's information to a MRML file in XML format.

Friends And Related Function Documentation

◆ qMRMLSegmentEditorWidgetPrivate

friend class qMRMLSegmentEditorWidgetPrivate

friend

Definition at line 566 of file vtkSegmentation.h.

◆ vtkMRMLSegmentationNode

friend class vtkMRMLSegmentationNode

friend

Definition at line 563 of file vtkSegmentation.h.

◆ vtkSegmentationModifier

friend class vtkSegmentationModifier

friend

Definition at line 565 of file vtkSegmentation.h.

◆ vtkSlicerSegmentationsModuleLogic

friend class vtkSlicerSegmentationsModuleLogic

friend

Definition at line 564 of file vtkSegmentation.h.

Member Data Documentation

◆ Converter

vtkSegmentationConverter* vtkSegmentation::Converter

protected

Converter instance.

Definition at line 538 of file vtkSegmentation.h.

◆ MasterRepresentationCache

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

protected

Definition at line 561 of file vtkSegmentation.h.

◆ MasterRepresentationCallbackCommand

vtkCallbackCommand* vtkSegmentation::MasterRepresentationCallbackCommand

protected

Command handling master representation modified events.

Definition at line 544 of file vtkSegmentation.h.

◆ MasterRepresentationModifiedEnabled

bool vtkSegmentation::MasterRepresentationModifiedEnabled

protected

Modified events of master representations are observed.

Definition at line 547 of file vtkSegmentation.h.

◆ MasterRepresentationName

std::string vtkSegmentation::MasterRepresentationName

protected

Master representation type name.

This representation is saved on disk
If this representation is modified, the others are invalidated This value must be set by the creator of the segmentation object!

Definition at line 535 of file vtkSegmentation.h.

◆ SegmentCallbackCommand

vtkCallbackCommand* vtkSegmentation::SegmentCallbackCommand

protected

Command handling segment modified events.

Definition at line 541 of file vtkSegmentation.h.

◆ SegmentIdAutogeneratorIndex

int vtkSegmentation::SegmentIdAutogeneratorIndex

protected

This number is incremented and used for generating the next segment ID.

Definition at line 554 of file vtkSegmentation.h.

◆ SegmentIds

std::deque< std::string > vtkSegmentation::SegmentIds

protected

This contains the segment IDs in display order. (we could retrieve segment IDs from SegmentMap too, but that always contains segments in alphabetical order)

Definition at line 559 of file vtkSegmentation.h.

◆ SegmentModifiedEnabled

bool vtkSegmentation::SegmentModifiedEnabled

protected

Modified events of segments are observed.

Definition at line 550 of file vtkSegmentation.h.

◆ Segments

SegmentMap vtkSegmentation::Segments

protected

Container of segments that belong to this segmentation.

Definition at line 529 of file vtkSegmentation.h.

The documentation for this class was generated from the following file:

Libs/vtkSegmentationCore/vtkSegmentation.h

segment	the segment to observe
insertBeforeSegmentId	if specified then the segment is inserted before insertBeforeSegmentId

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Friends

Detailed Description

Member Typedef Documentation

◆ SegmentMap

◆ Superclass

Member Enumeration Documentation

◆ anonymous enum

◆ anonymous enum

Constructor & Destructor Documentation

◆ vtkSegmentation()

◆ ~vtkSegmentation()

Member Function Documentation

◆ AddEmptySegment()

◆ AddSegment()

◆ ApplyLinearTransform()

◆ ApplyNonLinearTransform()

◆ CanAcceptRepresentation()

◆ CanAcceptSegment()

◆ ClearSegment()

◆ CollapseBinaryLabelmaps()

◆ ContainsRepresentation()

◆ ConvertSegmentsUsingPath()

◆ ConvertSegmentUsingPath()

◆ ConvertSingleSegment()

◆ CopyConversionParameters()

◆ CopySegment()

◆ CopySegmentFromSegmentation()

◆ CreateRepresentation() [1/2]

◆ CreateRepresentation() [2/2]

◆ DeepCopy()

◆ DeserializeConversionParameters()

◆ DetermineCommonLabelmapExtent() [1/2]

◆ DetermineCommonLabelmapExtent() [2/2]

◆ DetermineCommonLabelmapGeometry() [1/2]

◆ DetermineCommonLabelmapGeometry() [2/2]

◆ GenerateMergedLabelmap()

◆ GenerateUniqueSegmentID()

◆ GetAvailableRepresentationNames()

◆ GetBounds()

◆ GetClassName()

◆ GetContainedRepresentationNames()

◆ GetConversionParameter()

◆ GetConversionParametersForPath()

◆ GetLayerDataObject()

◆ GetLayerIndex()

◆ GetLayerObjects()

◆ GetMasterRepresentationName()

◆ GetNthSegment()

◆ GetNthSegmentID()

◆ GetNumberOfLayers()

◆ GetNumberOfSegments()

◆ GetPossibleConversions()

◆ GetSegment()

◆ GetSegmentIdBySegment()

◆ GetSegmentIdBySegmentName()

◆ GetSegmentIDs() [1/2]

◆ GetSegmentIDs() [2/2]

◆ GetSegmentIDsForDataObject()

◆ GetSegmentIDsForLayer()

◆ GetSegmentIDsSharingBinaryLabelmapRepresentation()

◆ GetSegmentIDsSharingRepresentation()

◆ GetSegmentIndex()

◆ GetSegmentRepresentation()

◆ GetSegmentsByTag()

◆ GetUniqueLabelValueForSharedLabelmap() [1/2]

◆ GetUniqueLabelValueForSharedLabelmap() [2/2]

◆ InvalidateNonMasterRepresentations()

◆ IsA()

◆ IsMasterRepresentationImageData()

◆ IsMasterRepresentationPolyData()

◆ IsSharedBinaryLabelmap()

◆ IsTypeOf()

◆ MergeSegmentLabelmaps()

◆ New()