ImageDev

- Getting Started
- ImageDev Python
- ImageDev C#
- ImageDev C++
- Licensing Information
- Redistributable Files
- Processing
- Image Manipulation
- - Synthetic Images
  - - RandomImage2d
    - RandomImage3d
    - RandomGaussianImage2d
    - RandomGaussianImage3d
    - RadialFunctionImage2d
    - RadialFunctionImage3d
    - OrientedLinesImage2d
    - OrientedLinesImage3d
    - RandomSphereImage3d
    - BoxGridImage2d
    - BoxGridImage3d
    - WedgeMaskImage3d
    - PointSpreadFunctionImage3d
  - Image Editing
  - - ConvertImage
    - ResetImage
    - CopyImage
    - PasteImage2d
    - PasteImage3d
    - CropImage2d
    - CropImage3d
    - SampleImage2d
    - SampleImage3d
    - InterlaceFrames2d
    - DeinterlaceFrames2d
  - Stack Operations
  - - SequenceConcatenation
    - SequenceToMultispectral
    - SequenceToVolume
    - VolumeToSequence
    - MultispectralToSequence
    - GetSliceFromVolume3d
    - SetSliceToVolume3d
    - GetObliqueSliceFromVolume3d
    - ImageStackProjection3d
    - VolumeProjection3d
- Geometry And Matching
- - Geometric Transforms
  - - Shearing3d
    - TranslateImage2d
    - TranslateImage3d
    - Flip2d
    - Flip3d
    - FlipImage2d
    - FlipImage3d
    - TransposeImage2d
    - TransposeImage3d
    - SwapQuadrants
    - Rotate2d
    - Rotate3d
    - RotationGenerator3d
    - Resize2d
    - Resize3d
    - RescaleByFactor
    - RescaleImageByFactor
    - ResampleAffine2d
    - ResampleAffine3d
    - ResampleElastic2d
    - SurfaceUnfolding3d
  - Pattern Recognition
  - - BinaryCorrelation2d
    - CrossCorrelation2d
    - CorrelationByDifference2d
    - CorrelationBySignChange2d
  - Registration
  - - ImagePrealignment3d
    - AffineRegistration
    - ElasticRegistration2d
- Arithmetic And Logic
- - Arithmetical Operations
  - - AbsoluteValue
    - AbsoluteMaximumWithImage
    - ArithmeticOperationWithImage
    - ArithmeticOperationWithValue
    - BlendWithImage
    - BlendWithValue
    - DirectionalBlending2d
    - CombineByMask
    - ImageFormula
    - EigenDecomposition2d
    - EigenDecomposition3d
  - Logical Operations
  - - MaskImage
    - LogicalOperationWithImage
    - LogicalOperationWithValue
    - LogicalNot
    - InvertImage
    - BitShift
- Image Filtering
- - Grayscale Transforms
  - - RescaleIntensity
    - StackRescaleIntensity
    - MatchContrast
    - HistogramEqualization
    - Clahe2d
    - Clahe3d
    - AdaptiveHistogramEqualization
    - ApplyGrayscaleLut
    - BackgroundImage2d
    - RadialBackgroundImage2d
    - ShadingCorrection
    - Exponential
    - Logarithm
    - Square
    - SquareRoot
    - RingArtifactRemoval3d
    - BeamHardeningCorrection3d
  - Color Transforms
  - - ColorToLightness
    - GetColorChannel
    - ColorToGrayscale
    - GrayscaleToColor
    - ColorSpaceConversion
    - ColorAntialiasing2d
    - BayerToRgb2d
    - DecorrelationStretch2d
    - BlendAlphaChannelWithImage
    - BlendAlphaChannelWithValue
  - Smoothing And Denoising
  - - BoxFilter2d
    - BoxFilter3d
    - MedianFilter2d
    - MedianFilter3d
    - GaussianFilter2d
    - GaussianFilter3d
    - ExponentialFilter2d
    - RecursiveExponentialFilter2d
    - RecursiveExponentialFilter3d
    - NonLocalMeansFilter2d
    - NonLocalMeansFilter3d
    - CurvatureDrivenDiffusion
    - BilateralFilter2d
    - BilateralFilter3d
    - MajorityFilter2d
    - MajorityFilter3d
    - SigmaFilter2d
    - SigmaFilter3d
    - Despeckle2d
    - Despeckle3d
    - NagaoFilter2d
    - NagaoFilter3d
    - SnnFilter2d
    - SnnFilter3d
    - FlowInpainting
  - Sharpening
  - - Deblurring2d
    - Delineate2d
    - Delineate3d
    - UnsharpMasking2d
    - UnsharpMasking3d
    - Shade2d
    - RichardsonLucyDeconvolution
  - Texture Filters
  - - MeanFilter2d
    - MeanFilter3d
    - VarianceFilter2d
    - VarianceFilter3d
    - SkewnessFilter2d
    - SkewnessFilter3d
    - KurtosisFilter2d
    - KurtosisFilter3d
    - ContrastFilter2d
    - ContrastFilter3d
    - VariationFilter2d
    - VariationFilter3d
    - EnergyFilter2d
    - EnergyFilter3d
    - EntropyFilter2d
    - EntropyFilter3d
    - AutocorrelationFilter
    - LocalAutocorrelationFilter2d
    - ImageCurvature2d
    - ImageCurvature3d
    - StructureEnhancementFilter2d
    - StructureEnhancementFilter3d
    - ScaleSpaceLogFilter2d
    - ScaleSpaceLogFilter3d
  - Frequency Domain
  - - ComplexFft
    - ComplexFftInverse
    - ComplexCenteredFft
    - ComplexCenteredFftInverse
    - CartesianToPolar2d
    - PolarToCartesian2d
    - ConvolutionWithImage
    - ConvolutionWithImage2d
    - RadialFrequencyFilter2d
    - GaborFiltering2d
- Edge Detection
- - Gradient
  - - GradientOperator2d
    - GradientOperator3d
    - VectorToMagnitude2d
    - VectorToMagnitude3d
    - GradientVector2d
    - GradientVector3d
    - GradientMagnitude2d
    - GradientMagnitude3d
    - MorphologicalGradient2d
    - MorphologicalGradient3d
    - RadialGradientCentered2d
    - RadialGradientCentered3d
    - RadialGradientContour2d
    - RadialGradientContour3d
    - RadialGradientLabel2d
    - RadialGradientLabel3d
  - Laplacian
  - - DobFilter2d
    - DobFilter3d
    - MorphologicalLaplacian
    - RecursiveLaplacian2d
    - RecursiveLaplacian3d
  - Other Derivatives
  - - GaussianDerivative2d
    - GaussianDerivative3d
    - GaussianHessianMatrix2d
    - GaussianHessianMatrix3d
    - GaussianGradientTensor2d
    - GaussianGradientTensor3d
  - Edge Marking
  - - ImageLocalMaxima2d
    - ImageLocalMaxima3d
    - RidgeDetection
    - ZeroCrossings2d
    - DijkstraShortestPath2d
    - EigenvaluesToStructureness2d
    - EigenvaluesToStructureness3d
    - TensorVoting2d
    - CannyEdgeDetector2d
    - CannyEdgeDetector3d
- Image Segmentation
- - Binarization
  - - Thresholding
    - ThresholdingByCriterion
    - AutoThresholdingBright
    - AutoThresholdingDark
    - ColorThresholding
    - TopHat
    - FeatureAdaptiveThresholding
    - AdaptiveThresholding2d
    - AdaptiveThresholding3d
    - HysteresisThresholding
  - Labeling
  - - Labeling2d
    - Labeling3d
    - ReorderLabels
    - AssignLabel
    - AddObjectToLabel
    - GroupCloseLabelsl2d
  - Feature Selection
  - - KillBorder2d
    - KillBorder3d
    - RemoveSmallSpots
    - ObjectBoundaries
    - BinarySmoothing2d
    - BinarySmoothing3d
    - LabelInterfaces
  - Separating And Filling
  - - FillHoles2d
    - FillHoles3d
    - RemoveSmallHoles
    - FillImageBorder3d
    - ExpandLabelBoundaries
    - SeparateObjects
    - HExtremaWatershed
    - SeparateObjectsByBlock
    - HExtremaWatershedByBlock
    - ConvexHull2d
  - Region Growing
  - - MarkerBasedWatershed2d
    - MarkerBasedWatershed3d
    - MarkerBasedWatershedByBlock
    - MarkerBasedWatershedBasinsByBlock
    - ExpandLabelsOnBackground
    - FloodFillThreshold2d
    - FloodFillThreshold3d
    - Waterpixel
  - Computational Geometry
  - - PolylineResampler2d
    - PolylineResampler3d
    - PolylineExtrusion3d
    - SurfaceFitting3d
- Mathematical Morphology
- - Erosion And Dilation
  - - Erosion2d
    - Erosion3d
    - Dilation2d
    - Dilation3d
    - ErosionDisk2d
    - ErosionDisk3d
    - ErosionBall3d
    - DilationDisk2d
    - DilationDisk3d
    - DilationBall3d
    - ErosionLine2d
    - ErosionLine3d
    - DilationLine2d
    - DilationLine3d
    - ErosionColor2d
    - DilationColor2d
    - SelectiveErosion2d
    - SelectiveErosion3d
    - SelectiveDilation2d
    - SelectiveDilation3d
  - Opening And Closing
  - - Opening2d
    - Opening3d
    - Closing2d
    - Closing3d
    - OpeningDisk2d
    - OpeningDisk3d
    - OpeningBall3d
    - ClosingDisk2d
    - ClosingDisk3d
    - ClosingBall3d
    - OpeningLine2d
    - OpeningLine3d
    - ClosingLine2d
    - ClosingLine3d
    - OpeningLineMaximum
    - ClosingLineMinimum
    - OpeningColor2d
    - ClosingColor2d
    - OpeningByReconstruction2d
    - OpeningByReconstruction3d
    - ClosingByReconstruction2d
    - ClosingByReconstruction3d
    - OpeningDiskByReconstruction2d
    - OpeningBallByReconstruction3d
    - ClosingDiskByReconstruction2d
    - ClosingBallByReconstruction3d
    - SelectiveOpening2d
    - SelectiveOpening3d
    - SelectiveClosing2d
    - SelectiveClosing3d
  - Hit Or Miss And Skeleton
  - - Skeleton
    - Centerline3d
    - InfluenceZones
    - Centroid2d
    - EndPoints2d
    - EndPoints3d
    - Pruning2d
    - Pruning3d
    - IsolatedPoints2d
    - IsolatedPoints3d
    - TriplePoints2d
    - InteriorPoints2d
    - ApplyMorphologicalLut2d
    - ApplyMorphologicalLut3d
  - Geodesic Transformations
  - - ReconstructionFromMarkers2d
    - ReconstructionFromMarkers3d
    - GrayscaleReconstruction2d
    - GrayscaleReconstruction3d
    - GrayscaleFillHoles2d
    - GrayscaleFillHoles3d
    - HExtrema2d
    - HExtrema3d
    - RegionalExtrema2d
    - RegionalExtrema3d
    - UltimateErosion
  - Distance Maps
  - - DistanceMap2d
    - DistanceMap3d
    - EuclideanDistanceMap3d
    - EuclideanDistanceMap2d
    - GeodesicDistanceMap
    - ClosestBoundaryPoints2d
    - ClosestBoundaryPoints3d
    - TimeMap
    - LocalThicknessMap3d
    - GeodesicPropagation2d
    - GeodesicMaxima
    - GeodesicMinima
- Image Analysis
- - Image Measurements
  - - BinaryAnalysis
    - Area2d
    - Area3d
    - IntensityIntegral2d
    - IntensityIntegral3d
    - ObjectCount
    - DistanceMean2d
    - EulerNumber2d
    - EulerNumber3d
    - FractalDimension
    - CurvatureIntegrals3d
  - Image Statistics
  - - IntensityExtrema
    - IntensityStatistics
    - IntensityMaskedStatistics
    - IntensityHistogram
    - IntensityBinHistogram
    - AutoThresholdingValue
    - CompareImage
    - CompareValue
    - SimilarityMetricValue
    - SsimValue2d
    - SsimValue3d
    - RegionSimilarity
    - RadialIntensityProfile2d
    - RadialIntensityProfile3d
    - CylindricalIntensityProfile3d
    - RadialAutocorrelationProfile
    - Cooccurrence2d
    - MeasureGaussianNoise
    - LocalMaxima2d
    - LocalMaxima3d
    - PeakExtractor
    - LocalDensityMap2d
    - LocalDensityMap3d
    - SegmentationMetrics
  - Individual Measurements
  - - VolumeFractionByLabel
    - LabelCountByRegion
    - VolumeFractionByRegion
    - LabelAnalysis
    - LabelFiltering
    - LabelFilteringAnalysis
    - FilterAnalysis
    - MeasurementToImage
    - FilterByMeasurement
    - SieveLabeling
  - Moments And Orientations
  - - MomentsOfInertia2d
    - MomentsOfInertia3d
    - InertiaMoment2d
    - Eccentricity2d
    - OrientationMapFourier3d
    - OrientationMatchingFourier3d
  - Morphometry
  - - ObjectVolume
    - TotalImageVolume
    - ObjectBoundaryArea
    - TotalImageBoundaryArea
    - AverageObjectAreaPerSlice3d
    - AverageObjectCountPerSlice3d
    - ObjectImageRatio
    - ObjectSpecificSurface
    - ObjectSurfaceDensity
    - PorosityPercentage3d
    - FragmentationIndex
    - StructureModelIndex3d
    - AverageObjectThickness3d
    - AverageSpaceThickness3d
    - ObjectLinearDensity3d
    - DegreeOfAnisotropy
  - Propagation
  - - AxisPropagationBinary3d
    - AxisPropagationBinaryWithSeeds3d
    - AxisPropagationLabel3d
    - AxisPropagationLabelWithSeeds3d
    - AxisPropagationDistance3d
    - EstimateShortestPath3d
    - PercolationThreshold3d
    - AxisConnectivity3d
    - CentroidPathTortuosity3d
- Machine Learning
- - Classification
  - - AutoSegmentation3Phases
    - AutoIntensityClassification
    - SupervisedTextureClassification2d
    - SupervisedTextureClassification3d
    - TextureClassificationCreate
    - TextureClassificationTrain
    - TextureClassificationApply
  - Deep learning
  - - OnnxPredictionFiltering2d
    - OnnxPredictionFiltering3d
    - OnnxPredictionSegmentation2d
    - OnnxPredictionSegmentation3d
    - OnnxPredictionTwoOutputs2d
    - OnnxPredictionTwoOutputs3d
- Business Application
- - Dental
  - - DentalWallSegmentation3d
    - DentalMeshExtraction3d
    - DentalUnfolding3d
- IO
- - Image Data
  - - ReadVipImage
    - WriteVipImage
  - Algebraic Data
  - - ReadArrayXd
    - ReadArrayXi64
    - WriteArrayXd
    - WriteArrayXi64
  - Model
  - - ReadOnnxModel
- CUDA
- - Geometry And Matching
  - - CudaCrossCorrelation2d
    - CudaTemplateMatching3d
  - Image Filtering
  - - CudaBoxFilter2d
    - CudaMedianFilter2d
    - CudaGaussianFilter3d
    - CudaAdaptiveManifoldNlmFilter
  - Mathematical Morphology
  - - CudaErosion2d
    - CudaDilation2d
    - CudaOpening2d
    - CudaClosing2d
- Utilities
- Initialization
- Processing
- Syntax Check
- Visualization
- Data Object
- Image Data
- Kernels
- - MorphologicalKernel2d
  - MorphologicalKernel3d
  - MorphologicalLut2d
  - MorphologicalLut3d
- Model
- - TextureClassificationModel
  - OnnxModel
- Global Measurements
- - Image Measurements
  - - Area2dMsr
    - Area3dMsr
    - IntensityIntegral2dMsr
    - IntensityIntegral3dMsr
    - ObjectCountMsr
    - DistanceMeanMsr
    - Euler2dMsr
    - Euler3dMsr
    - FractalMsr
    - CurvatureIntegralsMsr
  - Image Statistics
  - - IntensityExtremaMsr
    - StatisticsMsr
    - IntensityHistogramMsr
    - IntensityBinHistogramMsr
    - CompareMsr
    - SimilarityMetricValueMsr
    - SsimValueMsr
    - RegionSimilarityMsr
    - SegmentationMetricsObjectMsr
    - SegmentationMetricsImageMsr
    - CylindricalIntensityProfileMsr
    - RadialIntensityProfileMsr
    - CorrelationMsr
    - CoocurrrenceMsr
    - GaussianNoiseMsr
    - LocalMaximaMsr
    - PeakExtractorMsr
  - Individual Measurements
  - - VolumeFractionByLabelMsr
    - LabelCountByRegionMsr
    - VolumeFractionByRegionMsr
  - Moments And Orientations
  - - MomentsOfInertia2dMsr
    - MomentsOfInertia3dMsr
    - MeanInertiaMomentMsr
    - Eccentricity2dMsr
    - LocalOrientation3dMsr
  - Morphometry
  - - ObjectVolumeMsr
    - ImageVolumeMsr
    - ObjectBoundaryAreaMsr
    - ImageBoundaryAreaMsr
    - AverageObjectAreaPerSliceMsr
    - AverageObjectCountPerSliceMsr
    - ObjectImageRatioMsr
    - ObjectSpecificSurfaceMsr
    - ObjectSurfaceDensityMsr
    - PorosityPercentageMsr
    - FragmentationMsr
    - StructureModelIndexMsr
    - AverageObjectThicknessMsr
    - AverageSpaceThicknessMsr
    - ObjectLinearDensityMsr
    - AnisotropyDegreeMsr
  - Propagation
  - - AxisPropagationBinary3dMsr
    - AxisPropagationLabel3dMsr
    - AxisPropagationDistance3dMsr
    - PercolationThreshold3dMsr
    - CentroidTortuosity3dMsr
  - Geometry And Matching
  - - CrossCorrelation2dMsr
  - Edge Detection
  - - CannyEdgeDetectorMsr
  - Image Segmentation
  - - AutoThresholdingMsr
    - AutoSegmentation3PhasesMsr
  - Mathematical Morphology
  - - ApplyMorphologicalLutMsr
- Analysis Measurements
- - AnalysisMsr
  - Measurement
  - Native Measurements
  - - Geometry
    - Feret
    - Intensity
    - Histogram
    - Inertia
    - Locate
    - Segment
    - Cooccurrence
  - CustomMeasurement
  - MeasurementAttributes
  - - Quantile
    - Histogram
    - Feret2d
    - Feret3d
    - NeighborCount
    - Cooccurrence
    - Breadth3d
  - MeasurementGroup
- Measurement Information
- - FieldInformation
  - CustomMeasurementInfo
- CUDA
- - CudaContext
- User Guide
- First Steps
- - Hello ImageDev
  - Initialize ImageDev
- Image Management
- - Create 2D Image
  - Create 3D Image
  - Data Transfer
- Standard Processing
- - Denoising
  - Thresholding
- Image Analysis
- - Global Analysis
  - Label Analysis
  - Measurement Browsing
  - Measurement Group
  - Custom Analysis
- Advanced Processing
- - Algorithm Tracking
- Typical Use Cases
- - Particle Analysis
  - Pore Analysis

# Centerline3d

Extracts the centerline of a binary three-dimensional image.
Access to parameter description
A centerline is a path with a tree topology that approximates the input shape. The extraction procedure enforces the path to be equidistant to its boundaries. A Euclidean distance map is computed to control the path centering.
This algorithm searches for a graph with tree topology (without loops). If objects contain loops, the algorithm does not fail; instead, it just ignores certain connectivity so that the tree topology of the graph is preserved.
The algorithm searches iteratively for the longest branch that can be added to the tree.
Secondary branches also can be detected, either by predefining the number of searched branches or by adding them automatically. In this last case, a new branch is added to the tree at a candidate crossing point, only if the length b is greater than a sensibility parameter multiplied by the distance a, where a and b are shown in Figure 1.
Figure 1. New branch sensibility
This algorithm generates two types of output:

- A binary or label image representing the detected centerlines by voxels having an intensity greater than or equal to 1.
- A geometric output modeling the centerlines by a set of polylines. This line set is provided by two output parameters: a list of vertices, and a list of indexes indicating how the vertices are connected.

Note: This algorithm must have the entire input data loaded in memory to be computed. Consequently, it cannot be used as part of an out-of-core processing recipe.
See also

- EuclideanDistanceMap3d
- EndPoints3d
- Pruning3d
- Skeleton

##
Function Syntax

This function returns a Centerline3dOutput structure containing outputIndices, outputVertices and outputObjectImage.

    // Output structure of the centerline3d function.
    struct Centerline3dOutput
    {
        /// The output image. Its size and type are forced to the same values as the input.
        std::shared_ptr< iolink::ImageView > outputObjectImage;
        /// The list of indices of the output line set.
        std::shared_ptr<iolink::ArrayXi64> outputIndices;
        /// The list of vertices of the output line set.
        std::shared_ptr<iolink::ArrayXd> outputVertices;
    };

    // Function prototype
    Centerline3dOutput
    centerline3d( std::shared_ptr< iolink::ImageView > inputObjectImage,
                  bool autoMode,
                  uint32_t numberOfBranches,
                  double newBranchSensibility,
                  double distanceMapSmoothing,
                  uint32_t lineSetSmoothing,
                  std::shared_ptr<iolink::ArrayXi64> outputIndices = nullptr,
                  std::shared_ptr<iolink::ArrayXd> outputVertices = nullptr,
                  std::shared_ptr< iolink::ImageView > outputObjectImage = nullptr );

This function returns a tuple containing output_indices, output_vertices and output_object_image.

    // Function prototype.
    centerline_3d(input_object_image: idt.ImageType,
                  auto_mode: bool = True,
                  number_of_branches: int = 3,
                  new_branch_sensibility: float = 3,
                  distance_map_smoothing: float = 0.3,
                  line_set_smoothing: int = 3,
                  output_indices: Union[idt.NDArrayInt, None] = None,
                  output_vertices: Union[idt.NDArrayFloat, None] = None,
                  output_object_image: idt.ImageType = None) -> Tuple[Union[idt.NDArrayInt, None], Union[idt.NDArrayFloat, None], idt.ImageType]

This function returns a Centerline3dOutput structure containing outputIndices, outputVertices and outputObjectImage.

    /// Output structure of the Centerline3d function.
    public struct Centerline3dOutput
    {
        /// The output image. Its size and type are forced to the same values as the input.
        public IOLink.ImageView outputObjectImage;
        /// The list of indices of the output line set.
        public IOLink.ArrayXi64 outputIndices;
        /// The list of vertices of the output line set.
        public IOLink.ArrayXd outputVertices;
    };

    // Function prototype.
    public static Centerline3dOutput
    Centerline3d( IOLink.ImageView inputObjectImage,
                  bool autoMode = true,
                  UInt32 numberOfBranches = 3,
                  double newBranchSensibility = 3,
                  double distanceMapSmoothing = 0.3,
                  UInt32 lineSetSmoothing = 3,
                  IOLink.ArrayXi64 outputIndices = null,
                  IOLink.ArrayXd outputVertices = null,
                  IOLink.ImageView outputObjectImage = null );

##
Class Syntax

    // Command constructor.
    Centerline3d();

    /// Gets the inputObjectImage parameter.
    /// The binary or label input image.
    std::shared_ptr< iolink::ImageView > inputObjectImage() const;
    /// Sets the inputObjectImage parameter.
    /// The binary or label input image.
    void setInputObjectImage( std::shared_ptr< iolink::ImageView > inputObjectImage );

    /// Gets the autoMode parameter.
    /// The way to determine the number of branches.
    bool autoMode() const;
    /// Sets the autoMode parameter.
    /// The way to determine the number of branches.
    void setAutoMode( const bool& autoMode );

    /// Gets the numberOfBranches parameter.
    /// The expected number of branches. This parameter is ignored if autoMode is set to YES.
    uint32_t numberOfBranches() const;
    /// Sets the numberOfBranches parameter.
    /// The expected number of branches. This parameter is ignored if autoMode is set to YES.
    void setNumberOfBranches( const uint32_t& numberOfBranches );

    /// Gets the newBranchSensibility parameter.
    /// The minimum length of a branch added automatically. This parameter is ignored if autoMode is set to NO.
    double newBranchSensibility() const;
    /// Sets the newBranchSensibility parameter.
    /// The minimum length of a branch added automatically. This parameter is ignored if autoMode is set to NO.
    void setNewBranchSensibility( const double& newBranchSensibility );

    /// Gets the distanceMapSmoothing parameter.
    /// The smoothing level of the distance map. It controls the standard deviation of a Gaussian filter on the distance map, which is computed internally to make the tree centered. Smoothing the distance map can remove artifacts in the tree, like oscillations.
    double distanceMapSmoothing() const;
    /// Sets the distanceMapSmoothing parameter.
    /// The smoothing level of the distance map. It controls the standard deviation of a Gaussian filter on the distance map, which is computed internally to make the tree centered. Smoothing the distance map can remove artifacts in the tree, like oscillations.
    void setDistanceMapSmoothing( const double& distanceMapSmoothing );

    /// Gets the lineSetSmoothing parameter.
    /// The number of smoothing iterations applied to the output polyline set. Each smoothing iteration applies a mean filter of size 3 on the vertices of the polylines.
    uint32_t lineSetSmoothing() const;
    /// Sets the lineSetSmoothing parameter.
    /// The number of smoothing iterations applied to the output polyline set. Each smoothing iteration applies a mean filter of size 3 on the vertices of the polylines.
    void setLineSetSmoothing( const uint32_t& lineSetSmoothing );

    /// Gets the outputIndices parameter.
    /// The list of indices of the output line set.
    std::shared_ptr<iolink::ArrayXi64> outputIndices() const;
    /// Sets the outputIndices parameter.
    /// The list of indices of the output line set.
    void setOutputIndices( std::shared_ptr<iolink::ArrayXi64> outputIndices );

    /// Gets the outputVertices parameter.
    /// The list of vertices of the output line set.
    std::shared_ptr<iolink::ArrayXd> outputVertices() const;
    /// Sets the outputVertices parameter.
    /// The list of vertices of the output line set.
    void setOutputVertices( std::shared_ptr<iolink::ArrayXd> outputVertices );

    /// Gets the outputObjectImage parameter.
    /// The output image. Its size and type are forced to the same values as the input.
    std::shared_ptr< iolink::ImageView > outputObjectImage() const;
    /// Sets the outputObjectImage parameter.
    /// The output image. Its size and type are forced to the same values as the input.
    void setOutputObjectImage( std::shared_ptr< iolink::ImageView > outputObjectImage );

    // Method to launch the command.
    void execute();

    # Property of the inputObjectImage parameter.
    Centerline3d.input_object_image
    # Property of the autoMode parameter.
    Centerline3d.auto_mode
    # Property of the numberOfBranches parameter.
    Centerline3d.number_of_branches
    # Property of the newBranchSensibility parameter.
    Centerline3d.new_branch_sensibility
    # Property of the distanceMapSmoothing parameter.
    Centerline3d.distance_map_smoothing
    # Property of the lineSetSmoothing parameter.
    Centerline3d.line_set_smoothing
    # Property of the outputIndices parameter.
    Centerline3d.output_indices
    # Property of the outputVertices parameter.
    Centerline3d.output_vertices
    # Property of the outputObjectImage parameter.
    Centerline3d.output_object_image

    // Method to launch the command.
    execute()

    // Command constructor.
    Centerline3d()

    // Property of the inputObjectImage parameter.
    Centerline3d.inputObjectImage
    // Property of the autoMode parameter.
    Centerline3d.autoMode
    // Property of the numberOfBranches parameter.
    Centerline3d.numberOfBranches
    // Property of the newBranchSensibility parameter.
    Centerline3d.newBranchSensibility
    // Property of the distanceMapSmoothing parameter.
    Centerline3d.distanceMapSmoothing
    // Property of the lineSetSmoothing parameter.
    Centerline3d.lineSetSmoothing
    // Property of the outputIndices parameter.
    Centerline3d.outputIndices
    // Property of the outputVertices parameter.
    Centerline3d.outputVertices
    // Property of the outputObjectImage parameter.
    Centerline3d.outputObjectImage

    // Method to launch the command.
    Execute()

## Parameters

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| inputObjectImage | The binary or label input image. | Image | Binary or Label | nullptr
| autoMode | The way to determine the number of branches.
NO | The number of branches is user defined. Branches are added until the numberOfBranches connections is reached.
YES | The number of branches is automatically detected in accordance with the newBranchSensibility parameter.
| Bool |  | true
| numberOfBranches | The expected number of branches. This parameter is ignored if autoMode is set to YES. | UInt32 | >=1 | 3
| newBranchSensibility | The minimum length of a branch added automatically. This parameter is ignored if autoMode is set to NO. | Float64 | >=1 | 3
| distanceMapSmoothing | The smoothing level of the distance map. It controls the standard deviation of a Gaussian filter on the distance map, which is computed internally to make the tree centered. Smoothing the distance map can remove artifacts in the tree, like oscillations. | Float64 | >=0.01 | 0.3
| lineSetSmoothing | The number of smoothing iterations applied to the output polyline set. Each smoothing iteration applies a mean filter of size 3 on the vertices of the polylines. | UInt32 | Any value | 3
| outputVertices | The list of vertices of the output line set. The indexation of the generated arrayX is {coordinate, index}, where coordinate is the axis index (0 for X, 1 for Y, and 2 for Z) and index is a label identifying the vertex. | ArrayXd |  | nullptr
| outputIndices | The list of indices of the output line set. The vertices corresponding to two consecutive indices of this list are connected. An index that equals -1 indicates that the current polyline has ended and the next one begins. | ArrayXi64 |  | nullptr
| outputObjectImage | The output image. Its size and type are forced to the same values as the input. | Image |  | nullptr

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| input_object_image | The binary or label input image. | image | Binary or Label | None
| auto_mode | The way to determine the number of branches.
NO | The number of branches is user defined. Branches are added until the numberOfBranches connections is reached.
YES | The number of branches is automatically detected in accordance with the newBranchSensibility parameter.
| bool |  | True
| number_of_branches | The expected number of branches. This parameter is ignored if autoMode is set to YES. | uint32 | >=1 | 3
| new_branch_sensibility | The minimum length of a branch added automatically. This parameter is ignored if autoMode is set to NO. | float64 | >=1 | 3
| distance_map_smoothing | The smoothing level of the distance map. It controls the standard deviation of a Gaussian filter on the distance map, which is computed internally to make the tree centered. Smoothing the distance map can remove artifacts in the tree, like oscillations. | float64 | >=0.01 | 0.3
| line_set_smoothing | The number of smoothing iterations applied to the output polyline set. Each smoothing iteration applies a mean filter of size 3 on the vertices of the polylines. | uint32 | Any value | 3
| output_vertices | The list of vertices of the output line set. The indexation of the generated arrayX is {coordinate, index}, where coordinate is the axis index (0 for X, 1 for Y, and 2 for Z) and index is a label identifying the vertex. | arrayXd |  | nullptr
| output_indices | The list of indices of the output line set. The vertices corresponding to two consecutive indices of this list are connected. An index that equals -1 indicates that the current polyline has ended and the next one begins. | arrayXi64 |  | nullptr
| output_object_image | The output image. Its size and type are forced to the same values as the input. | image |  | None

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| inputObjectImage | The binary or label input image. | Image | Binary or Label | null
| autoMode | The way to determine the number of branches.
NO | The number of branches is user defined. Branches are added until the numberOfBranches connections is reached.
YES | The number of branches is automatically detected in accordance with the newBranchSensibility parameter.
| Bool |  | true
| numberOfBranches | The expected number of branches. This parameter is ignored if autoMode is set to YES. | UInt32 | >=1 | 3
| newBranchSensibility | The minimum length of a branch added automatically. This parameter is ignored if autoMode is set to NO. | Float64 | >=1 | 3
| distanceMapSmoothing | The smoothing level of the distance map. It controls the standard deviation of a Gaussian filter on the distance map, which is computed internally to make the tree centered. Smoothing the distance map can remove artifacts in the tree, like oscillations. | Float64 | >=0.01 | 0.3
| lineSetSmoothing | The number of smoothing iterations applied to the output polyline set. Each smoothing iteration applies a mean filter of size 3 on the vertices of the polylines. | UInt32 | Any value | 3
| outputVertices | The list of vertices of the output line set. The indexation of the generated arrayX is {coordinate, index}, where coordinate is the axis index (0 for X, 1 for Y, and 2 for Z) and index is a label identifying the vertex. | ArrayXd |  | nullptr
| outputIndices | The list of indices of the output line set. The vertices corresponding to two consecutive indices of this list are connected. An index that equals -1 indicates that the current polyline has ended and the next one begins. | ArrayXi64 |  | nullptr
| outputObjectImage | The output image. Its size and type are forced to the same values as the input. | Image |  | null

## Object Examples

    auto foam_sep = readVipImage( std::string( IMAGEDEVDATA_IMAGES_FOLDER ) + "foam_sep.vip" );

    Centerline3d centerline3dAlgo;
    centerline3dAlgo.setInputObjectImage( foam_sep );
    centerline3dAlgo.setAutoMode( true );
    centerline3dAlgo.setNumberOfBranches( 1 );
    centerline3dAlgo.setNewBranchSensibility( 3.0 );
    centerline3dAlgo.setDistanceMapSmoothing( 1.0 );
    centerline3dAlgo.setLineSetSmoothing( 3 );
    centerline3dAlgo.execute();

    std::cout << "outputIndices:" << centerline3dAlgo.outputIndices()->shape();
    std::cout << "outputVertices:" << centerline3dAlgo.outputVertices()->shape();
    std::cout << "outputObjectImage:" << centerline3dAlgo.outputObjectImage()->toString();

    foam_sep = imagedev.read_vip_image(imagedev_data.get_image_path("foam_sep.vip"))

    centerline_3d_algo = imagedev.Centerline3d()
    centerline_3d_algo.input_object_image = foam_sep
    centerline_3d_algo.auto_mode = True
    centerline_3d_algo.number_of_branches = 1
    centerline_3d_algo.new_branch_sensibility = 3.0
    centerline_3d_algo.distance_map_smoothing = 1.0
    centerline_3d_algo.line_set_smoothing = 3
    centerline_3d_algo.execute()

    print("output_indices:", str(centerline_3d_algo.output_indices))
    print("output_vertices:", str(centerline_3d_algo.output_vertices))
    print("output_object_image:", str(centerline_3d_algo.output_object_image))

    ImageView foam_sep = Data.ReadVipImage( @"Data/images/foam_sep.vip" );

    Centerline3d centerline3dAlgo = new Centerline3d
    {
        inputObjectImage = foam_sep,
        autoMode = true,
        numberOfBranches = 1,
        newBranchSensibility = 3.0,
        distanceMapSmoothing = 1.0,
        lineSetSmoothing = 3
    };
    centerline3dAlgo.Execute();

    Console.WriteLine( "outputIndices:" + centerline3dAlgo.outputIndices.ToString() );
    Console.WriteLine( "outputVertices:" + centerline3dAlgo.outputVertices.ToString() );
    Console.WriteLine( "outputObjectImage:" + centerline3dAlgo.outputObjectImage.ToString() );

## Function Examples

    auto foam_sep = readVipImage( std::string( IMAGEDEVDATA_IMAGES_FOLDER ) + "foam_sep.vip" );

    auto result = centerline3d( foam_sep, true, 1, 3.0, 1.0, 3 );

    std::cout << "outputIndices:" << result.outputIndices->shape();
    std::cout << "outputVertices:" << result.outputVertices->shape();
    std::cout << "outputObjectImage:" << result.outputObjectImage->toString();

    foam_sep = imagedev.read_vip_image(imagedev_data.get_image_path("foam_sep.vip"))

    result_output_indices, result_output_vertices, result_output_object_image = imagedev.centerline_3d(foam_sep, True, 1, 3.0, 1.0, 3)

    print("output_indices:", str(result_output_indices))
    print("output_vertices:", str(result_output_vertices))
    print("output_object_image:", str(result_output_object_image))

    ImageView foam_sep = Data.ReadVipImage( @"Data/images/foam_sep.vip" );

    Processing.Centerline3dOutput result = Processing.Centerline3d( foam_sep, true, 1, 3.0, 1.0, 3 );

    Console.WriteLine( "outputIndices:" + result.outputIndices.ToString() );
    Console.WriteLine( "outputVertices:" + result.outputVertices.ToString() );
    Console.WriteLine( "outputObjectImage:" + result.outputObjectImage.ToString() );

© 2025 Thermo Fisher Scientific Inc. All rights reserved.