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

# AxisConnectivity3d

Generates a binary image filtering objects connected between two parallel planes of binary or label three-dimensional image.
Access to parameter description
Given two parallel planes and a binary (or label) input image, this algorithm generates a binary image containing each region that has a label present in both planes. If two disconnected regions with the same label are present on each plane, they are retained by the algorithm even if they do not cross the entire volume. To avoid this issue, the regions of the input image should be identified using a connected-component labeling algorithm; for example, by using the Labeling3d algorithm. If the input image is binary, this preliminary labeling step is automatically applied by the algorithm.
Both planes are defined by a point (P1 and P2) and their common normal N. If the input image is a binary image, it is first labeled. If it is label image it is used as is.
Two oblique plane images are then extracted and their histograms are computed. The output binary image is finally computed keeping the labels for which the histogram value is not null on both planes.

(a) | (b) | (c)

Figure 1. The Axis Connectivity algorithm applied on a segmented volume
(a) the input label image to process, (b) the selected planes, (c) the binary image retaining the connected objects between both planes
See also

- AxisPropagationDistance3d
- AxisPropagationBinary3d
- EstimateShortestPath3d

##
Function Syntax

This function returns outputBinaryImage.

    // Function prototype
    std::shared_ptr< iolink::ImageView >
    axisConnectivity3d( std::shared_ptr< iolink::ImageView > inputObjectImage,
                        const iolink::Vector3i32& originPoint,
                        const iolink::Vector3d& planeNormal,
                        const iolink::Vector3i32& extremity,
                        std::shared_ptr< iolink::ImageView > outputBinaryImage = nullptr );

This function returns outputBinaryImage.

    // Function prototype.
    axis_connectivity_3d(input_object_image: idt.ImageType,
                         origin_point: Iterable[int] = [1, 1, 1],
                         plane_normal: Union[Iterable[int], Iterable[float]] = [0.57735002040863037, 0.57735002040863037, 0.57735002040863037],
                         extremity: Iterable[int] = [1, 1, 1],
                         output_binary_image: idt.ImageType = None) -> idt.ImageType

This function returns outputBinaryImage.

    // Function prototype.
    public static IOLink.ImageView
    AxisConnectivity3d( IOLink.ImageView inputObjectImage,
                        int[] originPoint = null,
                        double[] planeNormal = null,
                        int[] extremity = null,
                        IOLink.ImageView outputBinaryImage = null );

##
Class Syntax

    // Command constructor.
    AxisConnectivity3d();

    /// 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 originPoint parameter.
    /// The X, Y, and Z pixel coordinates of a point P1 of the first plane.
    iolink::Vector3i32 originPoint() const;
    /// Sets the originPoint parameter.
    /// The X, Y, and Z pixel coordinates of a point P1 of the first plane.
    void setOriginPoint( const iolink::Vector3i32& originPoint );

    /// Gets the planeNormal parameter.
    /// The X, Y, and Z coordinates of the normal N to both planes.
    iolink::Vector3d planeNormal() const;
    /// Sets the planeNormal parameter.
    /// The X, Y, and Z coordinates of the normal N to both planes.
    void setPlaneNormal( const iolink::Vector3d& planeNormal );

    /// Gets the extremity parameter.
    /// The X, Y, and Z pixel coordinates of a point P2 of the second plane.
    iolink::Vector3i32 extremity() const;
    /// Sets the extremity parameter.
    /// The X, Y, and Z pixel coordinates of a point P2 of the second plane.
    void setExtremity( const iolink::Vector3i32& extremity );

    /// Gets the outputBinaryImage parameter.
    /// The binary output image which contains the retained objects. Its dimensions are forced to the same values as the input.
    std::shared_ptr< iolink::ImageView > outputBinaryImage() const;
    /// Sets the outputBinaryImage parameter.
    /// The binary output image which contains the retained objects. Its dimensions are forced to the same values as the input.
    void setOutputBinaryImage( std::shared_ptr< iolink::ImageView > outputBinaryImage );

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

    # Property of the inputObjectImage parameter.
    AxisConnectivity3d.input_object_image
    # Property of the originPoint parameter.
    AxisConnectivity3d.origin_point
    # Property of the planeNormal parameter.
    AxisConnectivity3d.plane_normal
    # Property of the extremity parameter.
    AxisConnectivity3d.extremity
    # Property of the outputBinaryImage parameter.
    AxisConnectivity3d.output_binary_image

    // Method to launch the command.
    execute()

    // Command constructor.
    AxisConnectivity3d()

    // Property of the inputObjectImage parameter.
    AxisConnectivity3d.inputObjectImage
    // Property of the originPoint parameter.
    AxisConnectivity3d.originPoint
    // Property of the planeNormal parameter.
    AxisConnectivity3d.planeNormal
    // Property of the extremity parameter.
    AxisConnectivity3d.extremity
    // Property of the outputBinaryImage parameter.
    AxisConnectivity3d.outputBinaryImage

    // 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
| originPoint | The X, Y, and Z pixel coordinates of a point P1 of the first plane. | Vector3i32 | >=0 | {1, 1, 1}
| planeNormal | The X, Y, and Z coordinates of the normal N to both planes. | Vector3d | Any value | {0.57735002040863037f, 0.57735002040863037f, 0.57735002040863037f}
| extremity | The X, Y, and Z pixel coordinates of a point P2 of the second plane. | Vector3i32 | >0 | {1, 1, 1}
| outputBinaryImage | The binary output image which contains the retained objects. Its dimensions 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
| origin_point | The X, Y, and Z pixel coordinates of a point P1 of the first plane. | vector3i32 | >=0 | [1, 1, 1]
| plane_normal | The X, Y, and Z coordinates of the normal N to both planes. | vector3d | Any value | [0.57735002040863037, 0.57735002040863037, 0.57735002040863037]
| extremity | The X, Y, and Z pixel coordinates of a point P2 of the second plane. | vector3i32 | >0 | [1, 1, 1]
| output_binary_image | The binary output image which contains the retained objects. Its dimensions 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
| originPoint | The X, Y, and Z pixel coordinates of a point P1 of the first plane. | Vector3i32 | >=0 | {1, 1, 1}
| planeNormal | The X, Y, and Z coordinates of the normal N to both planes. | Vector3d | Any value | {0.57735002040863037f, 0.57735002040863037f, 0.57735002040863037f}
| extremity | The X, Y, and Z pixel coordinates of a point P2 of the second plane. | Vector3i32 | >0 | {1, 1, 1}
| outputBinaryImage | The binary output image which contains the retained objects. Its dimensions 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" );

    AxisConnectivity3d axisConnectivity3dAlgo;
    axisConnectivity3dAlgo.setInputObjectImage( foam_sep );
    axisConnectivity3dAlgo.setOriginPoint( {1, 1, 1} );
    axisConnectivity3dAlgo.setPlaneNormal( {0.57735, 0.57735, 0.57735} );
    axisConnectivity3dAlgo.setExtremity( {1, 1, 1} );
    axisConnectivity3dAlgo.execute();

    std::cout << "outputBinaryImage:" << axisConnectivity3dAlgo.outputBinaryImage()->toString();

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

    axis_connectivity_3d_algo = imagedev.AxisConnectivity3d()
    axis_connectivity_3d_algo.input_object_image = foam_sep
    axis_connectivity_3d_algo.origin_point = [1, 1, 1]
    axis_connectivity_3d_algo.plane_normal = [0.57735, 0.57735, 0.57735]
    axis_connectivity_3d_algo.extremity = [1, 1, 1]
    axis_connectivity_3d_algo.execute()

    print("output_binary_image:", str(axis_connectivity_3d_algo.output_binary_image))

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

    AxisConnectivity3d axisConnectivity3dAlgo = new AxisConnectivity3d
    {
        inputObjectImage = foam_sep,
        originPoint = new int[]{1, 1, 1},
        planeNormal = new double[]{0.57735, 0.57735, 0.57735},
        extremity = new int[]{1, 1, 1}
    };
    axisConnectivity3dAlgo.Execute();

    Console.WriteLine( "outputBinaryImage:" + axisConnectivity3dAlgo.outputBinaryImage.ToString() );

## Function Examples

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

    auto result = axisConnectivity3d( foam_sep, {1, 1, 1}, {0.57735, 0.57735, 0.57735}, {1, 1, 1} );

    std::cout << "outputBinaryImage:" << result->toString();

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

    result = imagedev.axis_connectivity_3d(foam_sep, [1, 1, 1], [0.57735, 0.57735, 0.57735], [1, 1, 1])

    print("output_binary_image:", str(result))

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

    IOLink.ImageView result = Processing.AxisConnectivity3d( foam_sep, new int[]{1, 1, 1}, new double[]{0.57735, 0.57735, 0.57735}, new int[]{1, 1, 1} );

    Console.WriteLine( "outputBinaryImage:" + result.ToString() );

© 2025 Thermo Fisher Scientific Inc. All rights reserved.