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

# TensorVoting2d

Strengthens local features in a two-dimensional image according to their consistency with a model of smooth curves.
Access to parameter description
The purpose of this algorithm is to fill gaps inside features appearing in a score image along their orientations given by a vector image. The structural information contained in the feature image is propagated through a voting field.
The voting field used assumes that the best connection between two points with one orientation imposes a circular arc that decays with the radius according to a Gaussian function.
The voting field size (that is, the maximum length of gaps to fill) is defined by a scale parameter.
This voting field can be illustrated on the unit sphere:
Figure 1. Example of a stick voting field
Different outputs can be computed by this filter and can be enabled or not by a selection parameter.
Only the outputs necessary to the application have to be selected in order to minimize memory and computation time usage.
This filter can provide a spectral image output where each channel represents a tensor component set in the following order $I_{xx}$, $I_{xy}$, $I_{yy}$.
The saliency, ballness, and orientation vector images can be extracted from this tensor image. These metrics are defined as follows:

- Saliency $=\lambda _{1}-\lambda _{2}$. It can be interpreted as a measure of the orientation certainty or of the feature anisotropy.
- Ballness $=\lambda _{2}$. It can be interpreted as a measure of the orientation uncertainty or of the feature isotropy.
- Orientation $=e_{1}$. It represents the main orientation of the output tensor.

Where:

- $\lambda_{1}$ (resp. $\lambda_{2}$) is the largest (resp. smallest) eigenvalue.
- $e_{1}$ is the eigenvector corresponding to the $\lambda_{1}$ eigenvalue.

This method is referenced by Franken and van Almsick publication:
E.Franken, M.van Almsick, P.Rongen, L.Florack, B.ter Haar Romeny. "An efficient method for tensor voting using steerable filters". Computer Vision - ECCV 2006, Springer, pp. 228-240, 2006.
See also

- GaussianHessianMatrix2d
- EigenDecomposition2d
- EigenvaluesToStructureness2d

##
Function Syntax

This function returns a TensorVoting2dOutput structure containing outputTensorImage, outputVectorImage, outputSaliencyImage and outputBallnessImage.

    // Output structure of the tensorVoting2d function.
    struct TensorVoting2dOutput
    {
        /// The tensor output corresponding to the strengthened image.
        std::shared_ptr< iolink::ImageView > outputTensorImage;
        /// The orientation vector output image, defining the main orientation of the output tensor.
        std::shared_ptr< iolink::ImageView > outputVectorImage;
        /// The saliency output image representing the anisotropy of the structures.
        std::shared_ptr< iolink::ImageView > outputSaliencyImage;
        /// The ballness output image representing the isotropy of the structures.
        std::shared_ptr< iolink::ImageView > outputBallnessImage;
    };

    // Function prototype
    TensorVoting2dOutput
    tensorVoting2d( std::shared_ptr< iolink::ImageView > inputFeatureImage,
                    std::shared_ptr< iolink::ImageView > inputVectorImage,
                    double scale,
                    int32_t outputSelection,
                    std::shared_ptr< iolink::ImageView > outputTensorImage = nullptr,
                    std::shared_ptr< iolink::ImageView > outputVectorImage = nullptr,
                    std::shared_ptr< iolink::ImageView > outputSaliencyImage = nullptr,
                    std::shared_ptr< iolink::ImageView > outputBallnessImage = nullptr );

This function returns a tuple containing output_tensor_image, output_vector_image, output_saliency_image and output_ballness_image.

    // Function prototype.
    tensor_voting_2d(input_feature_image: idt.ImageType,
                     input_vector_image: idt.ImageType,
                     scale: float = 5,
                     output_selection: Union[int, str, TensorVoting2d.OutputSelection] = 4,
                     output_tensor_image: idt.ImageType = None,
                     output_vector_image: idt.ImageType = None,
                     output_saliency_image: idt.ImageType = None,
                     output_ballness_image: idt.ImageType = None) -> Tuple[idt.ImageType, idt.ImageType, idt.ImageType, idt.ImageType]

This function returns a TensorVoting2dOutput structure containing outputTensorImage, outputVectorImage, outputSaliencyImage and outputBallnessImage.

    /// Output structure of the TensorVoting2d function.
    public struct TensorVoting2dOutput
    {
        /// The tensor output corresponding to the strengthened image.
        public IOLink.ImageView outputTensorImage;
        ///
        /// The orientation vector output image, defining the main orientation of the output tensor.
        ///
        public IOLink.ImageView outputVectorImage;
        /// The saliency output image representing the anisotropy of the structures.
        public IOLink.ImageView outputSaliencyImage;
        /// The ballness output image representing the isotropy of the structures.
        public IOLink.ImageView outputBallnessImage;
    };

    // Function prototype.
    public static TensorVoting2dOutput
    TensorVoting2d( IOLink.ImageView inputFeatureImage,
                    IOLink.ImageView inputVectorImage,
                    double scale = 5,
                    Int32 outputSelection = 4,
                    IOLink.ImageView outputTensorImage = null,
                    IOLink.ImageView outputVectorImage = null,
                    IOLink.ImageView outputSaliencyImage = null,
                    IOLink.ImageView outputBallnessImage = null );

##
Class Syntax

    // Command constructor.
    TensorVoting2d();

    /// Gets the inputFeatureImage parameter.
    /// The feature input image. It can be produced by the EigenvaluesToStructureness2d algorithm.
    std::shared_ptr< iolink::ImageView > inputFeatureImage() const;
    /// Sets the inputFeatureImage parameter.
    /// The feature input image. It can be produced by the EigenvaluesToStructureness2d algorithm.
    void setInputFeatureImage( std::shared_ptr< iolink::ImageView > inputFeatureImage );

    /// Gets the inputVectorImage parameter.
    /// The vector input image indicating the orientation of the feature to strengthen. It can be produced by the EigenDecomposition2d algorithm. When used with an edge detector such as an Hessian matrix, the second eigenvector has to be selected since the first eigenvector is orthogonal to the structures.
    std::shared_ptr< iolink::ImageView > inputVectorImage() const;
    /// Sets the inputVectorImage parameter.
    /// The vector input image indicating the orientation of the feature to strengthen. It can be produced by the EigenDecomposition2d algorithm. When used with an edge detector such as an Hessian matrix, the second eigenvector has to be selected since the first eigenvector is orthogonal to the structures.
    void setInputVectorImage( std::shared_ptr< iolink::ImageView > inputVectorImage );

    /// Gets the scale parameter.
    /// The scale parameter acting on the gap length filled by the tensor voting algorithm. It is expressed in pixels.
    double scale() const;
    /// Sets the scale parameter.
    /// The scale parameter acting on the gap length filled by the tensor voting algorithm. It is expressed in pixels.
    void setScale( const double& scale );

    /// Gets the outputSelection parameter.
    /// The output images to be computed.
    int32_t outputSelection() const;
    /// Sets the outputSelection parameter.
    /// The output images to be computed.
    void setOutputSelection( const int32_t& outputSelection );

    /// Gets the outputTensorImage parameter.
    /// The tensor output corresponding to the strengthened image.
    std::shared_ptr< iolink::ImageView > outputTensorImage() const;
    /// Sets the outputTensorImage parameter.
    /// The tensor output corresponding to the strengthened image.
    void setOutputTensorImage( std::shared_ptr< iolink::ImageView > outputTensorImage );

    /// Gets the outputVectorImage parameter.
    /// The orientation vector output image, defining the main orientation of the output tensor.
    std::shared_ptr< iolink::ImageView > outputVectorImage() const;
    /// Sets the outputVectorImage parameter.
    /// The orientation vector output image, defining the main orientation of the output tensor.
    void setOutputVectorImage( std::shared_ptr< iolink::ImageView > outputVectorImage );

    /// Gets the outputSaliencyImage parameter.
    /// The saliency output image representing the anisotropy of the structures.
    std::shared_ptr< iolink::ImageView > outputSaliencyImage() const;
    /// Sets the outputSaliencyImage parameter.
    /// The saliency output image representing the anisotropy of the structures.
    void setOutputSaliencyImage( std::shared_ptr< iolink::ImageView > outputSaliencyImage );

    /// Gets the outputBallnessImage parameter.
    /// The ballness output image representing the isotropy of the structures.
    std::shared_ptr< iolink::ImageView > outputBallnessImage() const;
    /// Sets the outputBallnessImage parameter.
    /// The ballness output image representing the isotropy of the structures.
    void setOutputBallnessImage( std::shared_ptr< iolink::ImageView > outputBallnessImage );

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

    # Property of the inputFeatureImage parameter.
    TensorVoting2d.input_feature_image
    # Property of the inputVectorImage parameter.
    TensorVoting2d.input_vector_image
    # Property of the scale parameter.
    TensorVoting2d.scale
    # Property of the outputSelection parameter.
    TensorVoting2d.output_selection
    # Property of the outputTensorImage parameter.
    TensorVoting2d.output_tensor_image
    # Property of the outputVectorImage parameter.
    TensorVoting2d.output_vector_image
    # Property of the outputSaliencyImage parameter.
    TensorVoting2d.output_saliency_image
    # Property of the outputBallnessImage parameter.
    TensorVoting2d.output_ballness_image

    // Method to launch the command.
    execute()

    // Command constructor.
    TensorVoting2d()

    // Property of the inputFeatureImage parameter.
    TensorVoting2d.inputFeatureImage
    // Property of the inputVectorImage parameter.
    TensorVoting2d.inputVectorImage
    // Property of the scale parameter.
    TensorVoting2d.scale
    // Property of the outputSelection parameter.
    TensorVoting2d.outputSelection
    // Property of the outputTensorImage parameter.
    TensorVoting2d.outputTensorImage
    // Property of the outputVectorImage parameter.
    TensorVoting2d.outputVectorImage
    // Property of the outputSaliencyImage parameter.
    TensorVoting2d.outputSaliencyImage
    // Property of the outputBallnessImage parameter.
    TensorVoting2d.outputBallnessImage

    // Method to launch the command.
    Execute()

## Parameters

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| inputFeatureImage | The feature input image. It can be produced by the EigenvaluesToStructureness2d algorithm. This image must have only one spectral channel. | Image | Binary, Label or Grayscale | nullptr
| inputVectorImage | The vector input image indicating the orientation of the feature to strengthen. It can be produced by the EigenDecomposition2d algorithm. When used with an edge detector such as an Hessian matrix, the second eigenvector has to be selected since the first eigenvector is orthogonal to the structures. This image must have the same size as the feature input image and 2 spectral channels. Each vector is used to define an orientation and its norm is ignored. | Image | Binary, Label, Grayscale or Multispectral | nullptr
| scale | The scale parameter acting on the gap length filled by the tensor voting algorithm. It is expressed in pixels. | Float64 | >0 | 5
| outputSelection | The output images to be computed.
TENSOR | Enable the computation of the tensor output image. Associated value = 1.
ORIENTATION_VECTOR | Enable the computation of the orientation vector output image. Associated value = 2.
SALIENCY | Enable the computation of the saliency output image. Associated value = 4.
BALLNESS | Enable the computation of the ballness output image. Associated value = 8.
| MultipleChoice |  | SALIENCY
| outputTensorImage | The tensor output corresponding to the strengthened image. The spatial dimensions, calibration and interpretation of the output image are forced to the same values as the feature input. Type is forced to float. | Image |  | nullptr
| outputVectorImage | The orientation vector output image, defining the main orientation of the output tensor. The spatial dimensions, calibration, and interpretation of the output image are forced to the same values as the feature input. The size of the spectral serie component is forced to 2. Each vector defines the main orientation of the output tensor and its norm is equal to the saliency. Type is forced to float. | Image |  | nullptr
| outputSaliencyImage | The saliency output image representing the anisotropy of the structures. The spatial dimensions, calibration, and interpretation of the output image are forced to the same values as the feature input. Type is forced to float. | Image |  | nullptr
| outputBallnessImage | The ballness output image representing the isotropy of the structures. The spatial dimensions, calibration, and interpretation of the output image are forced to the same values as the feature input. Type is forced to float. | Image |  | nullptr

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| input_feature_image | The feature input image. It can be produced by the EigenvaluesToStructureness2d algorithm. This image must have only one spectral channel. | image | Binary, Label or Grayscale | None
| input_vector_image | The vector input image indicating the orientation of the feature to strengthen. It can be produced by the EigenDecomposition2d algorithm. When used with an edge detector such as an Hessian matrix, the second eigenvector has to be selected since the first eigenvector is orthogonal to the structures. This image must have the same size as the feature input image and 2 spectral channels. Each vector is used to define an orientation and its norm is ignored. | image | Binary, Label, Grayscale or Multispectral | None
| scale | The scale parameter acting on the gap length filled by the tensor voting algorithm. It is expressed in pixels. | float64 | >0 | 5
| output_selection | The output images to be computed.
TENSOR | Enable the computation of the tensor output image. Associated value = 1.
ORIENTATION_VECTOR | Enable the computation of the orientation vector output image. Associated value = 2.
SALIENCY | Enable the computation of the saliency output image. Associated value = 4.
BALLNESS | Enable the computation of the ballness output image. Associated value = 8.
| multiple_choice |  | SALIENCY
| output_tensor_image | The tensor output corresponding to the strengthened image. The spatial dimensions, calibration and interpretation of the output image are forced to the same values as the feature input. Type is forced to float. | image |  | None
| output_vector_image | The orientation vector output image, defining the main orientation of the output tensor. The spatial dimensions, calibration, and interpretation of the output image are forced to the same values as the feature input. The size of the spectral serie component is forced to 2. Each vector defines the main orientation of the output tensor and its norm is equal to the saliency. Type is forced to float. | image |  | None
| output_saliency_image | The saliency output image representing the anisotropy of the structures. The spatial dimensions, calibration, and interpretation of the output image are forced to the same values as the feature input. Type is forced to float. | image |  | None
| output_ballness_image | The ballness output image representing the isotropy of the structures. The spatial dimensions, calibration, and interpretation of the output image are forced to the same values as the feature input. Type is forced to float. | image |  | None

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| inputFeatureImage | The feature input image. It can be produced by the EigenvaluesToStructureness2d algorithm. This image must have only one spectral channel. | Image | Binary, Label or Grayscale | null
| inputVectorImage | The vector input image indicating the orientation of the feature to strengthen. It can be produced by the EigenDecomposition2d algorithm. When used with an edge detector such as an Hessian matrix, the second eigenvector has to be selected since the first eigenvector is orthogonal to the structures. This image must have the same size as the feature input image and 2 spectral channels. Each vector is used to define an orientation and its norm is ignored. | Image | Binary, Label, Grayscale or Multispectral | null
| scale | The scale parameter acting on the gap length filled by the tensor voting algorithm. It is expressed in pixels. | Float64 | >0 | 5
| outputSelection | The output images to be computed.
TENSOR | Enable the computation of the tensor output image. Associated value = 1.
ORIENTATION_VECTOR | Enable the computation of the orientation vector output image. Associated value = 2.
SALIENCY | Enable the computation of the saliency output image. Associated value = 4.
BALLNESS | Enable the computation of the ballness output image. Associated value = 8.
| MultipleChoice |  | SALIENCY
| outputTensorImage | The tensor output corresponding to the strengthened image. The spatial dimensions, calibration and interpretation of the output image are forced to the same values as the feature input. Type is forced to float. | Image |  | null
| outputVectorImage | The orientation vector output image, defining the main orientation of the output tensor. The spatial dimensions, calibration, and interpretation of the output image are forced to the same values as the feature input. The size of the spectral serie component is forced to 2. Each vector defines the main orientation of the output tensor and its norm is equal to the saliency. Type is forced to float. | Image |  | null
| outputSaliencyImage | The saliency output image representing the anisotropy of the structures. The spatial dimensions, calibration, and interpretation of the output image are forced to the same values as the feature input. Type is forced to float. | Image |  | null
| outputBallnessImage | The ballness output image representing the isotropy of the structures. The spatial dimensions, calibration, and interpretation of the output image are forced to the same values as the feature input. Type is forced to float. | Image |  | null

## Object Examples

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

    TensorVoting2d tensorVoting2dAlgo;
    tensorVoting2dAlgo.setInputFeatureImage( retina_structureness );
    tensorVoting2dAlgo.setInputVectorImage( retina_orientation_vector );
    tensorVoting2dAlgo.setScale( 5 );
    tensorVoting2dAlgo.setOutputSelection( 4 );
    tensorVoting2dAlgo.execute();

    std::cout << "outputTensorImage:" << tensorVoting2dAlgo.outputTensorImage()->toString();
    std::cout << "outputVectorImage:" << tensorVoting2dAlgo.outputVectorImage()->toString();
    std::cout << "outputSaliencyImage:" << tensorVoting2dAlgo.outputSaliencyImage()->toString();
    std::cout << "outputBallnessImage:" << tensorVoting2dAlgo.outputBallnessImage()->toString();

    retina_structureness = imagedev.read_vip_image(imagedev_data.get_image_path("retina_structureness.vip"))
    retina_orientation_vector = imagedev.read_vip_image(imagedev_data.get_image_path("retina_orientation_vector.vip"))

    tensor_voting_2d_algo = imagedev.TensorVoting2d()
    tensor_voting_2d_algo.input_feature_image = retina_structureness
    tensor_voting_2d_algo.input_vector_image = retina_orientation_vector
    tensor_voting_2d_algo.scale = 5
    tensor_voting_2d_algo.output_selection = 4
    tensor_voting_2d_algo.execute()

    print("output_tensor_image:", str(tensor_voting_2d_algo.output_tensor_image))
    print("output_vector_image:", str(tensor_voting_2d_algo.output_vector_image))
    print("output_saliency_image:", str(tensor_voting_2d_algo.output_saliency_image))
    print("output_ballness_image:", str(tensor_voting_2d_algo.output_ballness_image))

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

    TensorVoting2d tensorVoting2dAlgo = new TensorVoting2d
    {
        inputFeatureImage = retina_structureness,
        inputVectorImage = retina_orientation_vector,
        scale = 5,
        outputSelection = 4
    };
    tensorVoting2dAlgo.Execute();

    Console.WriteLine( "outputTensorImage:" + tensorVoting2dAlgo.outputTensorImage.ToString() );
    Console.WriteLine( "outputVectorImage:" + tensorVoting2dAlgo.outputVectorImage.ToString() );
    Console.WriteLine( "outputSaliencyImage:" + tensorVoting2dAlgo.outputSaliencyImage.ToString() );
    Console.WriteLine( "outputBallnessImage:" + tensorVoting2dAlgo.outputBallnessImage.ToString() );

## Function Examples

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

    auto result = tensorVoting2d( retina_structureness, retina_orientation_vector, 5, 4 );

    std::cout << "outputTensorImage:" << result.outputTensorImage->toString();
    std::cout << "outputVectorImage:" << result.outputVectorImage->toString();
    std::cout << "outputSaliencyImage:" << result.outputSaliencyImage->toString();
    std::cout << "outputBallnessImage:" << result.outputBallnessImage->toString();

    retina_structureness = imagedev.read_vip_image(imagedev_data.get_image_path("retina_structureness.vip"))
    retina_orientation_vector = imagedev.read_vip_image(imagedev_data.get_image_path("retina_orientation_vector.vip"))

    result_output_tensor_image, result_output_vector_image, result_output_saliency_image, result_output_ballness_image = imagedev.tensor_voting_2d(retina_structureness, retina_orientation_vector, 5, 4)

    print("output_tensor_image:", str(result_output_tensor_image))
    print("output_vector_image:", str(result_output_vector_image))
    print("output_saliency_image:", str(result_output_saliency_image))
    print("output_ballness_image:", str(result_output_ballness_image))

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

    Processing.TensorVoting2dOutput result = Processing.TensorVoting2d( retina_structureness, retina_orientation_vector, 5, 4 );

    Console.WriteLine( "outputTensorImage:" + result.outputTensorImage.ToString() );
    Console.WriteLine( "outputVectorImage:" + result.outputVectorImage.ToString() );
    Console.WriteLine( "outputSaliencyImage:" + result.outputSaliencyImage.ToString() );
    Console.WriteLine( "outputBallnessImage:" + result.outputBallnessImage.ToString() );

© 2025 Thermo Fisher Scientific Inc. All rights reserved.