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

# AxisPropagationDistance3d

Simulates the propagation through a phase of a three-dimensional image and computes an image of traveled distances.
Access to parameter description
For an introduction:

- section Image Analysis
- section Propagation

The values set in the output image correspond to the distance traveled to reach a voxel starting from an image border used as seed. This border is defined by the axis and propagationDirection parameters.
The maskAndSeedValues and maximumThreshold parameters identify areas of the image in which propagation can be done; therefore, it allows identifying non-porous areas.
Propagation is performed from the seeds, along the user defined axis, through voxels of intensity X verifying the following four conditions:

- The voxel is connected (adjacent) to a voxel already 'propagated'.
- X is different from the first maskAndSeedValues value.
- X is greater or equal to the second maskAndSeedValues value.
- X is smaller or equal to the maximumThreshold value.

The following images illustrate this algorithm results:

Figure 1. Input CT core sample image (left) and propagation distance image (right)
In the binary case, the maskAndSeedValues and maximumThreshold are ignored. The propagation does not reject any specific value, propagates through 0 intensity values and stops on 1 intensity values. It amounts to considering maskAndSeedValues at [2, 0] and maximumThreshold at 0.
See also

- AxisPropagationBinaryWithSeeds3d
- EstimateShortestPath3d
- CentroidPathTortuosity3d

##
Function Syntax

This function returns a AxisPropagationDistance3dOutput structure containing outputImage and outputMeasurement.

    // Output structure of the axisPropagationDistance3d function.
    struct AxisPropagationDistance3dOutput
    {
        /// The grayscale output image where each voxel intensity value represents the propagation distance from the seeds. This distance is expressed in voxels; it is not calibrated. Its dimensions and type are forced to the same values as the input.
        std::shared_ptr< iolink::ImageView > outputImage;
        /// The output measurement result.
        AxisPropagationDistance3dMsr::Ptr outputMeasurement;
    };

    // Function prototype
    AxisPropagationDistance3dOutput
    axisPropagationDistance3d( std::shared_ptr< iolink::ImageView > inputImage,
                               const iolink::Vector2i32& maskAndSeedValues,
                               int32_t maximumThreshold,
                               AxisPropagationDistance3d::Axis axis,
                               AxisPropagationDistance3d::PropagationDirection propagationDirection,
                               std::shared_ptr< iolink::ImageView > outputImage = nullptr,
                               AxisPropagationDistance3dMsr::Ptr outputMeasurement = nullptr );

This function returns a tuple containing output_image and output_measurement.

    // Function prototype.
    axis_propagation_distance_3d(input_image: idt.ImageType,
                                 mask_and_seed_values: Iterable[int] = [255, -1024],
                                 maximum_threshold: int = 128,
                                 axis: AxisPropagationDistance3d.Axis = AxisPropagationDistance3d.Axis.Z_AXIS,
                                 propagation_direction: AxisPropagationDistance3d.PropagationDirection = AxisPropagationDistance3d.PropagationDirection.MIN_TO_MAX,
                                 output_image: idt.ImageType = None,
                                 output_measurement: Union[Any, None] = None) -> Tuple[idt.ImageType, AxisPropagationDistance3dMsr]

This function returns a AxisPropagationDistance3dOutput structure containing outputImage and outputMeasurement.

    /// Output structure of the AxisPropagationDistance3d function.
    public struct AxisPropagationDistance3dOutput
    {
        ///
        /// The grayscale output image where each voxel intensity value represents the propagation distance from the seeds. This distance is expressed in voxels; it is not calibrated. Its dimensions and type are forced to the same values as the input.
        ///
        public IOLink.ImageView outputImage;
        /// The output measurement result.
        public AxisPropagationDistance3dMsr outputMeasurement;
    };

    // Function prototype.
    public static AxisPropagationDistance3dOutput
    AxisPropagationDistance3d( IOLink.ImageView inputImage,
                               int[] maskAndSeedValues = null,
                               Int32 maximumThreshold = 128,
                               AxisPropagationDistance3d.Axis axis = ImageDev.AxisPropagationDistance3d.Axis.Z_AXIS,
                               AxisPropagationDistance3d.PropagationDirection propagationDirection = ImageDev.AxisPropagationDistance3d.PropagationDirection.MIN_TO_MAX,
                               IOLink.ImageView outputImage = null,
                               AxisPropagationDistance3dMsr outputMeasurement = null );

##
Class Syntax

    // Command constructor.
    AxisPropagationDistance3d();

    /// Gets the inputImage parameter.
    /// The input grayscale, binary, or color image. In the case of a binary image, the background represents the phase where the propagation has to be performed.
    std::shared_ptr< iolink::ImageView > inputImage() const;
    /// Sets the inputImage parameter.
    /// The input grayscale, binary, or color image. In the case of a binary image, the background represents the phase where the propagation has to be performed.
    void setInputImage( std::shared_ptr< iolink::ImageView > inputImage );

    /// Gets the maskAndSeedValues parameter.
    /// The first value is a mask value. Voxels with this intensity value are not infiltrated by the propagation. The second value is the seed value. Voxels with an intensity value lower than this seed value are not infiltrated by the propagation. A value lower than the second value of maskAndSeedValues or greater or equal to maximumThreshold is ignored. This parameter is ignored in binary case, and then is forced to [2, 0].
    iolink::Vector2i32 maskAndSeedValues() const;
    /// Sets the maskAndSeedValues parameter.
    /// The first value is a mask value. Voxels with this intensity value are not infiltrated by the propagation. The second value is the seed value. Voxels with an intensity value lower than this seed value are not infiltrated by the propagation. A value lower than the second value of maskAndSeedValues or greater or equal to maximumThreshold is ignored. This parameter is ignored in binary case, and then is forced to [2, 0].
    void setMaskAndSeedValues( const iolink::Vector2i32& maskAndSeedValues );

    /// Gets the maximumThreshold parameter.
    /// The maximum propagation intensity value. Voxels having an intensity value greater or equal to this value are rejected by the propagation. This parameter is ignored in binary case, and is forced to 1.
    int32_t maximumThreshold() const;
    /// Sets the maximumThreshold parameter.
    /// The maximum propagation intensity value. Voxels having an intensity value greater or equal to this value are rejected by the propagation. This parameter is ignored in binary case, and is forced to 1.
    void setMaximumThreshold( const int32_t& maximumThreshold );

    /// Gets the axis parameter.
    /// The axis along which the propagation is performed.
    AxisPropagationDistance3d::Axis axis() const;
    /// Sets the axis parameter.
    /// The axis along which the propagation is performed.
    void setAxis( const AxisPropagationDistance3d::Axis& axis );

    /// Gets the propagationDirection parameter.
    /// The direction in which the propagation is performed.
    AxisPropagationDistance3d::PropagationDirection propagationDirection() const;
    /// Sets the propagationDirection parameter.
    /// The direction in which the propagation is performed.
    void setPropagationDirection( const AxisPropagationDistance3d::PropagationDirection& propagationDirection );

    /// Gets the outputImage parameter.
    /// The grayscale output image where each voxel intensity value represents the propagation distance from the seeds. This distance is expressed in voxels; it is not calibrated. Its dimensions and type are forced to the same values as the input.
    std::shared_ptr< iolink::ImageView > outputImage() const;
    /// Sets the outputImage parameter.
    /// The grayscale output image where each voxel intensity value represents the propagation distance from the seeds. This distance is expressed in voxels; it is not calibrated. Its dimensions and type are forced to the same values as the input.
    void setOutputImage( std::shared_ptr< iolink::ImageView > outputImage );

    /// Gets the outputMeasurement parameter.
    /// The output measurement result.
    AxisPropagationDistance3dMsr::Ptr outputMeasurement() const;

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

    # Property of the inputImage parameter.
    AxisPropagationDistance3d.input_image
    # Property of the maskAndSeedValues parameter.
    AxisPropagationDistance3d.mask_and_seed_values
    # Property of the maximumThreshold parameter.
    AxisPropagationDistance3d.maximum_threshold
    # Property of the axis parameter.
    AxisPropagationDistance3d.axis
    # Property of the propagationDirection parameter.
    AxisPropagationDistance3d.propagation_direction
    # Property of the outputImage parameter.
    AxisPropagationDistance3d.output_image
    # Property of the outputMeasurement parameter.
    AxisPropagationDistance3d.output_measurement

    // Method to launch the command.
    execute()

    // Command constructor.
    AxisPropagationDistance3d()

    // Property of the inputImage parameter.
    AxisPropagationDistance3d.inputImage
    // Property of the maskAndSeedValues parameter.
    AxisPropagationDistance3d.maskAndSeedValues
    // Property of the maximumThreshold parameter.
    AxisPropagationDistance3d.maximumThreshold
    // Property of the axis parameter.
    AxisPropagationDistance3d.axis
    // Property of the propagationDirection parameter.
    AxisPropagationDistance3d.propagationDirection
    // Property of the outputImage parameter.
    AxisPropagationDistance3d.outputImage
    // Property of the outputMeasurement parameter.
    AxisPropagationDistance3d.outputMeasurement

    // Method to launch the command.
    Execute()

## Parameters

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| inputImage | The input grayscale, binary, or color image. In the case of a binary image, the background represents the phase where the propagation has to be performed. | Image | Binary, Label or Grayscale | nullptr
| maskAndSeedValues | The first value is a mask value. Voxels with this intensity value are not infiltrated by the propagation. The second value is the seed value. Voxels with an intensity value lower than this seed value are not infiltrated by the propagation. A value lower than the second value of maskAndSeedValues or greater or equal to maximumThreshold is ignored. This parameter is ignored in binary case, and then is forced to [2, 0]. | Vector2i32 | Any value | {255, -1024}
| maximumThreshold | The maximum propagation intensity value. Voxels having an intensity value greater or equal to this value are rejected by the propagation. This parameter is ignored in binary case, and is forced to 1. | Int32 | Any value | 128
| axis | The axis along which the propagation is performed.
X_AXIS | The propagation is performed along the X axis.
Y_AXIS | The propagation is performed along the Y axis.
Z_AXIS | The propagation is performed along the Z axis.
| Enumeration |  | Z_AXIS
| propagationDirection | The direction in which the propagation is performed.
MIN_TO_MAX | The propagation is performed from the first to the last slice index.
MAX_TO_MIN | The propagation is performed from the last to the first slice index.
| Enumeration |  | MIN_TO_MAX
| outputImage | The grayscale output image where each voxel intensity value represents the propagation distance from the seeds. This distance is expressed in voxels; it is not calibrated. Its dimensions and type are forced to the same values as the input. | Image |  | nullptr
| outputMeasurement | The output measurement result. | AxisPropagationDistance3dMsr |  | nullptr

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| input_image | The input grayscale, binary, or color image. In the case of a binary image, the background represents the phase where the propagation has to be performed. | image | Binary, Label or Grayscale | None
| mask_and_seed_values | The first value is a mask value. Voxels with this intensity value are not infiltrated by the propagation. The second value is the seed value. Voxels with an intensity value lower than this seed value are not infiltrated by the propagation. A value lower than the second value of maskAndSeedValues or greater or equal to maximumThreshold is ignored. This parameter is ignored in binary case, and then is forced to [2, 0]. | vector2i32 | Any value | [255, -1024]
| maximum_threshold | The maximum propagation intensity value. Voxels having an intensity value greater or equal to this value are rejected by the propagation. This parameter is ignored in binary case, and is forced to 1. | int32 | Any value | 128
| axis | The axis along which the propagation is performed.
X_AXIS | The propagation is performed along the X axis.
Y_AXIS | The propagation is performed along the Y axis.
Z_AXIS | The propagation is performed along the Z axis.
| enumeration |  | Z_AXIS
| propagation_direction | The direction in which the propagation is performed.
MIN_TO_MAX | The propagation is performed from the first to the last slice index.
MAX_TO_MIN | The propagation is performed from the last to the first slice index.
| enumeration |  | MIN_TO_MAX
| output_image | The grayscale output image where each voxel intensity value represents the propagation distance from the seeds. This distance is expressed in voxels; it is not calibrated. Its dimensions and type are forced to the same values as the input. | image |  | None
| output_measurement | The output measurement result. | AxisPropagationDistance3dMsr |  | None

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| inputImage | The input grayscale, binary, or color image. In the case of a binary image, the background represents the phase where the propagation has to be performed. | Image | Binary, Label or Grayscale | null
| maskAndSeedValues | The first value is a mask value. Voxels with this intensity value are not infiltrated by the propagation. The second value is the seed value. Voxels with an intensity value lower than this seed value are not infiltrated by the propagation. A value lower than the second value of maskAndSeedValues or greater or equal to maximumThreshold is ignored. This parameter is ignored in binary case, and then is forced to [2, 0]. | Vector2i32 | Any value | {255, -1024}
| maximumThreshold | The maximum propagation intensity value. Voxels having an intensity value greater or equal to this value are rejected by the propagation. This parameter is ignored in binary case, and is forced to 1. | Int32 | Any value | 128
| axis | The axis along which the propagation is performed.
X_AXIS | The propagation is performed along the X axis.
Y_AXIS | The propagation is performed along the Y axis.
Z_AXIS | The propagation is performed along the Z axis.
| Enumeration |  | Z_AXIS
| propagationDirection | The direction in which the propagation is performed.
MIN_TO_MAX | The propagation is performed from the first to the last slice index.
MAX_TO_MIN | The propagation is performed from the last to the first slice index.
| Enumeration |  | MIN_TO_MAX
| outputImage | The grayscale output image where each voxel intensity value represents the propagation distance from the seeds. This distance is expressed in voxels; it is not calibrated. Its dimensions and type are forced to the same values as the input. | Image |  | null
| outputMeasurement | The output measurement result. | AxisPropagationDistance3dMsr |  | null

## Object Examples

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

    AxisPropagationDistance3d axisPropagationDistance3dAlgo;
    axisPropagationDistance3dAlgo.setInputImage( foam_sep );
    axisPropagationDistance3dAlgo.setMaskAndSeedValues( {255, -1024} );
    axisPropagationDistance3dAlgo.setMaximumThreshold( 128 );
    axisPropagationDistance3dAlgo.setAxis( AxisPropagationDistance3d::Axis::X_AXIS );
    axisPropagationDistance3dAlgo.setPropagationDirection( AxisPropagationDistance3d::PropagationDirection::MIN_TO_MAX );
    axisPropagationDistance3dAlgo.execute();

    std::cout << "outputImage:" << axisPropagationDistance3dAlgo.outputImage()->toString();
    std::cout << "isVolumePierced: " << axisPropagationDistance3dAlgo.outputMeasurement()->isVolumePierced( ) ;

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

    axis_propagation_distance_3d_algo = imagedev.AxisPropagationDistance3d()
    axis_propagation_distance_3d_algo.input_image = foam_sep
    axis_propagation_distance_3d_algo.mask_and_seed_values = [255, -1024]
    axis_propagation_distance_3d_algo.maximum_threshold = 128
    axis_propagation_distance_3d_algo.axis = imagedev.AxisPropagationDistance3d.X_AXIS
    axis_propagation_distance_3d_algo.propagation_direction = imagedev.AxisPropagationDistance3d.MIN_TO_MAX
    axis_propagation_distance_3d_algo.execute()

    print("output_image:", str(axis_propagation_distance_3d_algo.output_image))
    print("isVolumePierced: ", str(axis_propagation_distance_3d_algo.output_measurement.is_volume_pierced()))

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

    AxisPropagationDistance3d axisPropagationDistance3dAlgo = new AxisPropagationDistance3d
    {
        inputImage = foam_sep,
        maskAndSeedValues = new int[]{255, -1024},
        maximumThreshold = 128,
        axis = AxisPropagationDistance3d.Axis.X_AXIS,
        propagationDirection = AxisPropagationDistance3d.PropagationDirection.MIN_TO_MAX
    };
    axisPropagationDistance3dAlgo.Execute();

    Console.WriteLine( "outputImage:" + axisPropagationDistance3dAlgo.outputImage.ToString() );
    Console.WriteLine( "isVolumePierced: " + axisPropagationDistance3dAlgo.outputMeasurement.isVolumePierced( ) );

## Function Examples

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

    auto result = axisPropagationDistance3d( foam_sep, {255, -1024}, 128, AxisPropagationDistance3d::Axis::X_AXIS, AxisPropagationDistance3d::PropagationDirection::MIN_TO_MAX );

    std::cout << "outputImage:" << result.outputImage->toString();
    std::cout << "isVolumePierced: " << result.outputMeasurement->isVolumePierced( ) ;

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

    result_output_image, result_output_measurement = imagedev.axis_propagation_distance_3d(foam_sep, [255, -1024], 128, imagedev.AxisPropagationDistance3d.X_AXIS, imagedev.AxisPropagationDistance3d.MIN_TO_MAX)

    print("output_image:", str(result_output_image))
    print("isVolumePierced: ", str(result_output_measurement.is_volume_pierced()))

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

    Processing.AxisPropagationDistance3dOutput result = Processing.AxisPropagationDistance3d( foam_sep, new int[]{255, -1024}, 128, AxisPropagationDistance3d.Axis.X_AXIS, AxisPropagationDistance3d.PropagationDirection.MIN_TO_MAX );

    Console.WriteLine( "outputImage:" + result.outputImage.ToString() );
    Console.WriteLine(  "isVolumePierced: " + result.outputMeasurement.isVolumePierced( )  );

© 2025 Thermo Fisher Scientific Inc. All rights reserved.