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

# EigenvaluesToStructureness2d

Computes a structure score image from the eigenvalues of a two-dimensional tensor image.
Access to parameter description
This algorithm allows extracting tubular or blob-like structures from dark or bright background.
The computation is based on eigenvalues $\lambda_{1}$ and $\lambda_{2}$ where $\mid \lambda_{1} \mid \geq \mid \lambda_{2} \mid $.
The structure score for bright tubular structures corresponds to:
$score = \left\{ \begin{array}{l l} 0 & \quad \text{if $\lambda_{1} > 0$, }\\ exp(- \frac{ \big( \frac{\lambda_{2}}{\lambda_{1}} \big) ^{2} }{2 \beta^{2} } ) \big(1-exp \big(- \frac{S^{2}}{2c^{2}} \big) \big) \\ \end{array} \right.$
The score for bright blob-like structures is computed as follows:
$ score = \left\{ \begin{array}{l l} 0 & \quad \text{if $\lambda_{1} > 0$ or $\lambda_{2} > 0$, }\\ \big(1-exp(- \frac{ \big( \frac{\lambda_{2}}{\lambda_{1}} \big) ^{2} }{2 \beta^{2} } )\big) \big(1-exp \big(- \frac{S^{2}}{2c^{2}} \big) \big) \\ \end{array} \right.$
Where:

- $S$ is the Hessian norm $S = \sqrt{\lambda_{1}^{2}\lambda_{2}^{2}}$
- $\beta$ is a threshold which controls the blobness sensitivity,
- c is a sensitivity threshold wich controls the noise influence.
$c = noiseCutoff \cdot S_{max}$ with $S_{max}$ the maximum Hessian norm in the image.

For dark objects the conditions on $\lambda_{1}$ and $\lambda_{2}$ are reversed.
This algorithm outputs a float grayscale image where each pixel intensity represents a structure score between 0 and 1.
The method for tubular structures is referenced by Alejandro Frangi publication:
A.F.Frangi, W.J.Niessen, K.L.Vincken, M.A.Viergever. "Multiscale vessel enhancement filtering". Lecture Notes in Computer Science(MICCAI), vol. 1496, pp. 130-137, 1998.
See also

- GaussianHessianMatrix2d
- EigenDecomposition2d

##
Function Syntax

This function returns outputImage.

    // Function prototype
    std::shared_ptr< iolink::ImageView >
    eigenvaluesToStructureness2d( std::shared_ptr< iolink::ImageView > inputEigenvaluesImage,
                                  EigenvaluesToStructureness2d::Lightness lightness,
                                  EigenvaluesToStructureness2d::StructureType structureType,
                                  double beta,
                                  double noiseCutoff,
                                  std::shared_ptr< iolink::ImageView > outputImage = nullptr );

This function returns outputImage.

    // Function prototype.
    eigenvalues_to_structureness_2d(input_eigenvalues_image: idt.ImageType,
                                    lightness: EigenvaluesToStructureness2d.Lightness = EigenvaluesToStructureness2d.Lightness.BRIGHT,
                                    structure_type: EigenvaluesToStructureness2d.StructureType = EigenvaluesToStructureness2d.StructureType.ROD,
                                    beta: float = 0.75,
                                    noise_cutoff: float = 0.5,
                                    output_image: idt.ImageType = None) -> idt.ImageType

This function returns outputImage.

    // Function prototype.
    public static IOLink.ImageView
    EigenvaluesToStructureness2d( IOLink.ImageView inputEigenvaluesImage,
                                  EigenvaluesToStructureness2d.Lightness lightness = ImageDev.EigenvaluesToStructureness2d.Lightness.BRIGHT,
                                  EigenvaluesToStructureness2d.StructureType structureType = ImageDev.EigenvaluesToStructureness2d.StructureType.ROD,
                                  double beta = 0.75,
                                  double noiseCutoff = 0.5,
                                  IOLink.ImageView outputImage = null );

##
Class Syntax

    // Command constructor.
    EigenvaluesToStructureness2d();

    /// Gets the inputEigenvaluesImage parameter.
    /// The input image containing the eigenvalues field. Type must be float. Spectral series size is 2 (channel 0 = largest eigenvalue, channel 1 = smallest eigenvalue).
    std::shared_ptr< iolink::ImageView > inputEigenvaluesImage() const;
    /// Sets the inputEigenvaluesImage parameter.
    /// The input image containing the eigenvalues field. Type must be float. Spectral series size is 2 (channel 0 = largest eigenvalue, channel 1 = smallest eigenvalue).
    void setInputEigenvaluesImage( std::shared_ptr< iolink::ImageView > inputEigenvaluesImage );

    /// Gets the lightness parameter.
    /// The type of structure lightness to extract.
    EigenvaluesToStructureness2d::Lightness lightness() const;
    /// Sets the lightness parameter.
    /// The type of structure lightness to extract.
    void setLightness( const EigenvaluesToStructureness2d::Lightness& lightness );

    /// Gets the structureType parameter.
    /// The type of structure shapes to extract.
    EigenvaluesToStructureness2d::StructureType structureType() const;
    /// Sets the structureType parameter.
    /// The type of structure shapes to extract.
    void setStructureType( const EigenvaluesToStructureness2d::StructureType& structureType );

    /// Gets the beta parameter.
    /// The blobness sensitivity threshold. It corresponds to the beta term of the score equation.
    double beta() const;
    /// Sets the beta parameter.
    /// The blobness sensitivity threshold. It corresponds to the beta term of the score equation.
    void setBeta( const double& beta );

    /// Gets the noiseCutoff parameter.
    /// The noise scale factor. It is used for computing the c term of the score equation.
    double noiseCutoff() const;
    /// Sets the noiseCutoff parameter.
    /// The noise scale factor. It is used for computing the c term of the score equation.
    void setNoiseCutoff( const double& noiseCutoff );

    /// Gets the outputImage parameter.
    /// The score output image. X and Y dimensions, calibration and interpretation of the output image are forced to the same values as the input. The spectral dimension is forced to 1. Type is forced to float and all values are between 0 and 1.
    std::shared_ptr< iolink::ImageView > outputImage() const;
    /// Sets the outputImage parameter.
    /// The score output image. X and Y dimensions, calibration and interpretation of the output image are forced to the same values as the input. The spectral dimension is forced to 1. Type is forced to float and all values are between 0 and 1.
    void setOutputImage( std::shared_ptr< iolink::ImageView > outputImage );

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

    # Property of the inputEigenvaluesImage parameter.
    EigenvaluesToStructureness2d.input_eigenvalues_image
    # Property of the lightness parameter.
    EigenvaluesToStructureness2d.lightness
    # Property of the structureType parameter.
    EigenvaluesToStructureness2d.structure_type
    # Property of the beta parameter.
    EigenvaluesToStructureness2d.beta
    # Property of the noiseCutoff parameter.
    EigenvaluesToStructureness2d.noise_cutoff
    # Property of the outputImage parameter.
    EigenvaluesToStructureness2d.output_image

    // Method to launch the command.
    execute()

    // Command constructor.
    EigenvaluesToStructureness2d()

    // Property of the inputEigenvaluesImage parameter.
    EigenvaluesToStructureness2d.inputEigenvaluesImage
    // Property of the lightness parameter.
    EigenvaluesToStructureness2d.lightness
    // Property of the structureType parameter.
    EigenvaluesToStructureness2d.structureType
    // Property of the beta parameter.
    EigenvaluesToStructureness2d.beta
    // Property of the noiseCutoff parameter.
    EigenvaluesToStructureness2d.noiseCutoff
    // Property of the outputImage parameter.
    EigenvaluesToStructureness2d.outputImage

    // Method to launch the command.
    Execute()

## Parameters

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| inputEigenvaluesImage | The input image containing the eigenvalues field. Type must be float. Spectral series size is 2 (channel 0 = largest eigenvalue, channel 1 = smallest eigenvalue). | Image | Multispectral | nullptr
| lightness | The type of structure lightness to extract.
BRIGHT | Extracts bright structures from dark background.
DARK | Extracts dark structures from bright background.
| Enumeration |  | BRIGHT
| structureType | The type of structure shapes to extract.
ROD | Extracts rod-like (tubular) structures.
BALL | Extracts blob-like (spherical) structures.
| Enumeration |  | ROD
| beta | The blobness sensitivity threshold. It corresponds to the beta term of the score equation. | Float64 | >0 | 0.75
| noiseCutoff | The noise scale factor. It is used for computing the c term of the score equation. | Float64 | >0 | 0.5
| outputImage | The score output image. X and Y dimensions, calibration and interpretation of the output image are forced to the same values as the input. The spectral dimension is forced to 1. Type is forced to float and all values are between 0 and 1. | Image |  | nullptr

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| input_eigenvalues_image | The input image containing the eigenvalues field. Type must be float. Spectral series size is 2 (channel 0 = largest eigenvalue, channel 1 = smallest eigenvalue). | image | Multispectral | None
| lightness | The type of structure lightness to extract.
BRIGHT | Extracts bright structures from dark background.
DARK | Extracts dark structures from bright background.
| enumeration |  | BRIGHT
| structure_type | The type of structure shapes to extract.
ROD | Extracts rod-like (tubular) structures.
BALL | Extracts blob-like (spherical) structures.
| enumeration |  | ROD
| beta | The blobness sensitivity threshold. It corresponds to the beta term of the score equation. | float64 | >0 | 0.75
| noise_cutoff | The noise scale factor. It is used for computing the c term of the score equation. | float64 | >0 | 0.5
| output_image | The score output image. X and Y dimensions, calibration and interpretation of the output image are forced to the same values as the input. The spectral dimension is forced to 1. Type is forced to float and all values are between 0 and 1. | image |  | None

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| inputEigenvaluesImage | The input image containing the eigenvalues field. Type must be float. Spectral series size is 2 (channel 0 = largest eigenvalue, channel 1 = smallest eigenvalue). | Image | Multispectral | null
| lightness | The type of structure lightness to extract.
BRIGHT | Extracts bright structures from dark background.
DARK | Extracts dark structures from bright background.
| Enumeration |  | BRIGHT
| structureType | The type of structure shapes to extract.
ROD | Extracts rod-like (tubular) structures.
BALL | Extracts blob-like (spherical) structures.
| Enumeration |  | ROD
| beta | The blobness sensitivity threshold. It corresponds to the beta term of the score equation. | Float64 | >0 | 0.75
| noiseCutoff | The noise scale factor. It is used for computing the c term of the score equation. | Float64 | >0 | 0.5
| outputImage | The score output image. X and Y dimensions, calibration and interpretation of the output image are forced to the same values as the input. The spectral dimension is forced to 1. Type is forced to float and all values are between 0 and 1. | Image |  | null

## Object Examples

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

    EigenvaluesToStructureness2d eigenvaluesToStructureness2dAlgo;
    eigenvaluesToStructureness2dAlgo.setInputEigenvaluesImage( retina_eigenvalues );
    eigenvaluesToStructureness2dAlgo.setLightness( EigenvaluesToStructureness2d::Lightness::BRIGHT );
    eigenvaluesToStructureness2dAlgo.setStructureType( EigenvaluesToStructureness2d::StructureType::ROD );
    eigenvaluesToStructureness2dAlgo.setBeta( 0.75 );
    eigenvaluesToStructureness2dAlgo.setNoiseCutoff( 0.5 );
    eigenvaluesToStructureness2dAlgo.execute();

    std::cout << "outputImage:" << eigenvaluesToStructureness2dAlgo.outputImage()->toString();

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

    eigenvalues_to_structureness_2d_algo = imagedev.EigenvaluesToStructureness2d()
    eigenvalues_to_structureness_2d_algo.input_eigenvalues_image = retina_eigenvalues
    eigenvalues_to_structureness_2d_algo.lightness = imagedev.EigenvaluesToStructureness2d.BRIGHT
    eigenvalues_to_structureness_2d_algo.structure_type = imagedev.EigenvaluesToStructureness2d.ROD
    eigenvalues_to_structureness_2d_algo.beta = 0.75
    eigenvalues_to_structureness_2d_algo.noise_cutoff = 0.5
    eigenvalues_to_structureness_2d_algo.execute()

    print("output_image:", str(eigenvalues_to_structureness_2d_algo.output_image))

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

    EigenvaluesToStructureness2d eigenvaluesToStructureness2dAlgo = new EigenvaluesToStructureness2d
    {
        inputEigenvaluesImage = retina_eigenvalues,
        lightness = EigenvaluesToStructureness2d.Lightness.BRIGHT,
        structureType = EigenvaluesToStructureness2d.StructureType.ROD,
        beta = 0.75,
        noiseCutoff = 0.5
    };
    eigenvaluesToStructureness2dAlgo.Execute();

    Console.WriteLine( "outputImage:" + eigenvaluesToStructureness2dAlgo.outputImage.ToString() );

## Function Examples

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

    auto result = eigenvaluesToStructureness2d( retina_eigenvalues, EigenvaluesToStructureness2d::Lightness::BRIGHT, EigenvaluesToStructureness2d::StructureType::ROD, 0.75, 0.5 );

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

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

    result = imagedev.eigenvalues_to_structureness_2d(retina_eigenvalues, imagedev.EigenvaluesToStructureness2d.BRIGHT, imagedev.EigenvaluesToStructureness2d.ROD, 0.75, 0.5)

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

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

    IOLink.ImageView result = Processing.EigenvaluesToStructureness2d( retina_eigenvalues, EigenvaluesToStructureness2d.Lightness.BRIGHT, EigenvaluesToStructureness2d.StructureType.ROD, 0.75, 0.5 );

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

© 2025 Thermo Fisher Scientific Inc. All rights reserved.