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

# StructureEnhancementFilter3d

Enhances structures of interest in a three-dimensional image using a multi-scale analysis.
Access to parameter description

## Overview

This algorithm generates a score image that can be used with the goal of segmenting the input image.
It computes a score between 0 and 1 for each voxel: 1 representing a good match with a structure model and 0 a background pixel. This provides a powerful technique for automatically identifying structures such as blood vessels.
The score can be computed either on an Hessian matrix to detect ridge structures or on a gradient structure tensor for object edges and corners.
The structure models available are:

- Balls (spherical structures with Hessian in 2D, object corners with gradient tensor)
- Rods (linear structures)
- Plates (planar structures)

The principle of the algorithm can be summarized as follows:

- A set of tensor fields is extracted from the image by filtering the image at different scales.
- A score image is extracted from each tensor field by analyzing the eigenvalues of tensors.
- The final score is obtained by selecting the maximum of all score images.

References:

- 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.
- A. Martinez-Sanchez, I. Garcia, S. Asano, V. Lucic, and J.-J. Fernandez, "Robust membrane detection based on tensor voting for electron tomography", Journal of Structural Biology, vol.186, issue.1, pp.49-61, 2014.

## Tensor Extraction

Two modes are available for computing the tensor field: the gradient mode and the Hessian mode. The first one is based on the gradient structure tensor, the second one on the Hessian matrix.

### Gradient mode

With the gradient mode, the gradient tensor is extracted. This tensor, also referred to as structure tensor or second order moment matrix, is a matrix derived from the gradient of the image. This matrix summarizes the predominant directions of the gradient around the pixel of interest. $$ S_w(p) = \left( \begin{array}{ccc} \int w(r) (I_x(p - r)) ^ 2\, d r & \int w(r) I_x(p - r)I_y(p - r)\, d r & \int w(r) I_x(p - r)I_z(p - r)\, d r\\ \int w(r) I_x(p - r)I_y(p - r)\, d r & \int w(r) (I_y(p - r)) ^ 2\, d r & \int w(r) I_y(p - r)I_z(p - r)\, d r\\ \int w(r) I_x(p - r)I_z(p - r)\, d r & \int w(r) I_y(p - r)I_z(p - r)\, d r & \int w(r) (I_z(p - r)) ^ 2\, d r\\ \end{array} \right) $$
Where $w(r)$ is a gaussian kernel controlling the scale of analysis.

### Hessian mode

With this mode, the tensor field is based on the extraction of the Hessian matrix of the image. This Hessian matrix is computed by filtering the image with the derivative of a Gaussian kernel. The standard deviation of the kernel controls the scale of analysis.

## Feature extraction

The structureType parameter controls the type of structure that is extracted from the tensor field (rod or ball). Let $\lambda_{1}$, $\lambda_{2}$ and $\lambda_{3}$ where $\mid \lambda_{1} \mid \geq \mid \lambda_{2} \mid \geq \mid \lambda_{3} \mid $.
Let first introduce $ \mathcal{R}_b = \frac{ \lambda_1 }{ \sqrt{ \lambda_2 \lambda_3 } } $, and $ \mathcal{R}_a = \frac{ \lambda_2 }{ \lambda_3 } $
The first ratio attains its maximum for blob-like structure. The second ratio distinguishes plate-like and rod-like structures.
The score for the rod structure type corresponds to:
$$ \text{score}_{\text{ROD}} = (1-\exp(-\frac{\mathcal{R}_a^2}{2\alpha^2}))\exp(-\frac{\mathcal{R}_b^2} {2\beta^2})(1-\exp(-\frac{S^2}{2c^2})) $$ The score for the ball structure type favors isotropic tensors and is computed as follows:
$$ \text{score}_{\text{BALL}} = (1-\exp(-\frac{\mathcal{R}_a^2}{2\alpha^2})) (1-\exp(-\frac{\mathcal{R}_b^2}{2\beta^2}))(1-\exp(-\frac{S^2}{2c^2})) \\ $$ The score for the plane structure type favors isotropic tensors and is computed as follows: $$ \text{score}_{\text{PLANE}} = \exp(-\frac{\mathcal{R}_a^2}{2\alpha^2})\exp(-\frac{\mathcal{R}_b^2} {2\beta^2})(1-\exp(-\frac{S^2}{2c^2})) $$ Where:

- $S$ is the tensor norm $ S = \sqrt{\sum \lambda_i^2} $,
- $\alpha$ is a threshold which controls the flatness sensitivity,
- $\beta$ is a threshold which controls the blobness sensitivity,
- and $c$ is a sensitivity threshold which controls the noise influence. $c = \text{ noiseCutoff } \times S_{ max }$ with $S_{ max }$ the maximum Hessian norm in the image.

With the Hessian mode, the lightness parameter limits the feature extraction to dark or bright objects by analyzing the sign of eigenvalues. This parameter is ignored in gradient mode where tensors are positive definite matrices.
The following table summarizes enhanced features according to the parameters. \begin{array}{|l||l|l|l|l|l|} \hline \textbf{Tensor Type} &\textbf{Structure Type} & \textbf{$\lambda_1$} & \textbf{$\lambda_2$} & \textbf{$\lambda_3$} &\textbf{Highlighted features} \\ \hline \hline \text{HESSIAN} & \text{PLANE} & \text{Strong} & \text{Weak} & \text{Weak} & \text{Plate-like structures}\\ \hline \text{HESSIAN} & \text{ROD} & \text{Strong} & \text{Strong} & \text{Weak} & \text{Ridges, tubular structures} \\ \hline \text{HESSIAN} & \text{BALL} & \text{Strong} & \text{Strong} & \text{Strong} & \text{Blobs, ball-like structures}\\ \hline \text{GRADIENT} & \text{PLANE} & \text{Strong} & \text{Weak} & \text{Weak} & \text{Object faces} \\ \hline \text{GRADIENT} & \text{ROD} & \text{Strong} & \text{Strong} & \text{Weak} & \text{Object edges} \\ \hline \text{GRADIENT} & \text{BALL} & \text{Strong} & \text{Strong} & \text{Strong} & \text{Blobs/Object corners} \\ \hline \end{array} See also

- ImageCurvature3d
- GaussianHessianMatrix3d
- GaussianGradientTensor3d
- ScaleSpaceLogFilter3d
- StructureEnhancementFilter2d

##
Function Syntax

This function returns outputImage.

    // Function prototype
    std::shared_ptr< iolink::ImageView >
    structureEnhancementFilter3d( std::shared_ptr< iolink::ImageView > inputImage,
                                  StructureEnhancementFilter3d::TensorType tensorType,
                                  const iolink::Vector2d& standardDeviationRange,
                                  double standardDeviationStep,
                                  StructureEnhancementFilter3d::Lightness lightness,
                                  StructureEnhancementFilter3d::StructureType structureType,
                                  std::shared_ptr< iolink::ImageView > outputImage = nullptr );

This function returns outputImage.

    // Function prototype.
    structure_enhancement_filter_3d(input_image: idt.ImageType,
                                    tensor_type: StructureEnhancementFilter3d.TensorType = StructureEnhancementFilter3d.TensorType.HESSIAN,
                                    standard_deviation_range: Union[Iterable[int], Iterable[float]] = [1, 3],
                                    standard_deviation_step: float = 1,
                                    lightness: StructureEnhancementFilter3d.Lightness = StructureEnhancementFilter3d.Lightness.BRIGHT,
                                    structure_type: StructureEnhancementFilter3d.StructureType = StructureEnhancementFilter3d.StructureType.ROD,
                                    output_image: idt.ImageType = None) -> idt.ImageType

This function returns outputImage.

    // Function prototype.
    public static IOLink.ImageView
    StructureEnhancementFilter3d( IOLink.ImageView inputImage,
                                  StructureEnhancementFilter3d.TensorType tensorType = ImageDev.StructureEnhancementFilter3d.TensorType.HESSIAN,
                                  double[] standardDeviationRange = null,
                                  double standardDeviationStep = 1,
                                  StructureEnhancementFilter3d.Lightness lightness = ImageDev.StructureEnhancementFilter3d.Lightness.BRIGHT,
                                  StructureEnhancementFilter3d.StructureType structureType = ImageDev.StructureEnhancementFilter3d.StructureType.ROD,
                                  IOLink.ImageView outputImage = null );

##
Class Syntax

    // Command constructor.
    StructureEnhancementFilter3d();

    /// Gets the inputImage parameter.
    /// The input image. The image type can be integer or floating point.
    std::shared_ptr< iolink::ImageView > inputImage() const;
    /// Sets the inputImage parameter.
    /// The input image. The image type can be integer or floating point.
    void setInputImage( std::shared_ptr< iolink::ImageView > inputImage );

    /// Gets the tensorType parameter.
    /// The type of tensor to compute: gradient tensor or Hessian matrix.
    StructureEnhancementFilter3d::TensorType tensorType() const;
    /// Sets the tensorType parameter.
    /// The type of tensor to compute: gradient tensor or Hessian matrix.
    void setTensorType( const StructureEnhancementFilter3d::TensorType& tensorType );

    /// Gets the standardDeviationRange parameter.
    /// Standard deviation of the Gaussian kernel at the minimum and maximum scale.
    iolink::Vector2d standardDeviationRange() const;
    /// Sets the standardDeviationRange parameter.
    /// Standard deviation of the Gaussian kernel at the minimum and maximum scale.
    void setStandardDeviationRange( const iolink::Vector2d& standardDeviationRange );

    /// Gets the standardDeviationStep parameter.
    /// Standard deviation step. Structures will be detected from minimum to maximum standard deviation at a pitch of this value.
    double standardDeviationStep() const;
    /// Sets the standardDeviationStep parameter.
    /// Standard deviation step. Structures will be detected from minimum to maximum standard deviation at a pitch of this value.
    void setStandardDeviationStep( const double& standardDeviationStep );

    /// Gets the lightness parameter.
    /// The lightness type of structures to enhance.
    StructureEnhancementFilter3d::Lightness lightness() const;
    /// Sets the lightness parameter.
    /// The lightness type of structures to enhance.
    void setLightness( const StructureEnhancementFilter3d::Lightness& lightness );

    /// Gets the structureType parameter.
    /// The shape of the structures to enhance.
    StructureEnhancementFilter3d::StructureType structureType() const;
    /// Sets the structureType parameter.
    /// The shape of the structures to enhance.
    void setStructureType( const StructureEnhancementFilter3d::StructureType& structureType );

    /// Gets the outputImage parameter.
    /// The output image reprensenting the matching score between 0 and 1. Its dimensions are forced to the same values as the input. Its data type is forced to floating point.
    std::shared_ptr< iolink::ImageView > outputImage() const;
    /// Sets the outputImage parameter.
    /// The output image reprensenting the matching score between 0 and 1. Its dimensions are forced to the same values as the input. Its data type is forced to floating point.
    void setOutputImage( std::shared_ptr< iolink::ImageView > outputImage );

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

    # Property of the inputImage parameter.
    StructureEnhancementFilter3d.input_image
    # Property of the tensorType parameter.
    StructureEnhancementFilter3d.tensor_type
    # Property of the standardDeviationRange parameter.
    StructureEnhancementFilter3d.standard_deviation_range
    # Property of the standardDeviationStep parameter.
    StructureEnhancementFilter3d.standard_deviation_step
    # Property of the lightness parameter.
    StructureEnhancementFilter3d.lightness
    # Property of the structureType parameter.
    StructureEnhancementFilter3d.structure_type
    # Property of the outputImage parameter.
    StructureEnhancementFilter3d.output_image

    // Method to launch the command.
    execute()

    // Command constructor.
    StructureEnhancementFilter3d()

    // Property of the inputImage parameter.
    StructureEnhancementFilter3d.inputImage
    // Property of the tensorType parameter.
    StructureEnhancementFilter3d.tensorType
    // Property of the standardDeviationRange parameter.
    StructureEnhancementFilter3d.standardDeviationRange
    // Property of the standardDeviationStep parameter.
    StructureEnhancementFilter3d.standardDeviationStep
    // Property of the lightness parameter.
    StructureEnhancementFilter3d.lightness
    // Property of the structureType parameter.
    StructureEnhancementFilter3d.structureType
    // Property of the outputImage parameter.
    StructureEnhancementFilter3d.outputImage

    // Method to launch the command.
    Execute()

## Parameters

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| inputImage | The input image. The image type can be integer or floating point. | Image | Grayscale | nullptr
| tensorType | The type of tensor to compute: gradient tensor or Hessian matrix.
HESSIAN | The Hessian matrix is extracted.
GRADIENT | The gradient structure tensor is extracted.
| Enumeration |  | HESSIAN
| standardDeviationRange | Standard deviation of the Gaussian kernel at the minimum and maximum scale. | Vector2d | >=0.1 | {1.f, 3.f}
| standardDeviationStep | Standard deviation step. Structures will be detected from minimum to maximum standard deviation at a pitch of this value. | Float64 | >0 | 1
| lightness | The lightness type of structures to enhance.
BRIGHT | Extracts bright structures from dark background.
DARK | Extracts dark structures from bright background.
| Enumeration |  | BRIGHT
| structureType | The shape of the structures to enhance.
ROD | The tubular structures are enhanced.
BALL | The blob-like structures are enhanced.
PLANE | The plate-like structures are enhanced.
| Enumeration |  | ROD
| outputImage | The output image reprensenting the matching score between 0 and 1. Its dimensions are forced to the same values as the input. Its data type is forced to floating point. | Image |  | nullptr

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| input_image | The input image. The image type can be integer or floating point. | image | Grayscale | None
| tensor_type | The type of tensor to compute: gradient tensor or Hessian matrix.
HESSIAN | The Hessian matrix is extracted.
GRADIENT | The gradient structure tensor is extracted.
| enumeration |  | HESSIAN
| standard_deviation_range | Standard deviation of the Gaussian kernel at the minimum and maximum scale. | vector2d | >=0.1 | [1, 3]
| standard_deviation_step | Standard deviation step. Structures will be detected from minimum to maximum standard deviation at a pitch of this value. | float64 | >0 | 1
| lightness | The lightness type of structures to enhance.
BRIGHT | Extracts bright structures from dark background.
DARK | Extracts dark structures from bright background.
| enumeration |  | BRIGHT
| structure_type | The shape of the structures to enhance.
ROD | The tubular structures are enhanced.
BALL | The blob-like structures are enhanced.
PLANE | The plate-like structures are enhanced.
| enumeration |  | ROD
| output_image | The output image reprensenting the matching score between 0 and 1. Its dimensions are forced to the same values as the input. Its data type is forced to floating point. | image |  | None

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| inputImage | The input image. The image type can be integer or floating point. | Image | Grayscale | null
| tensorType | The type of tensor to compute: gradient tensor or Hessian matrix.
HESSIAN | The Hessian matrix is extracted.
GRADIENT | The gradient structure tensor is extracted.
| Enumeration |  | HESSIAN
| standardDeviationRange | Standard deviation of the Gaussian kernel at the minimum and maximum scale. | Vector2d | >=0.1 | {1f, 3f}
| standardDeviationStep | Standard deviation step. Structures will be detected from minimum to maximum standard deviation at a pitch of this value. | Float64 | >0 | 1
| lightness | The lightness type of structures to enhance.
BRIGHT | Extracts bright structures from dark background.
DARK | Extracts dark structures from bright background.
| Enumeration |  | BRIGHT
| structureType | The shape of the structures to enhance.
ROD | The tubular structures are enhanced.
BALL | The blob-like structures are enhanced.
PLANE | The plate-like structures are enhanced.
| Enumeration |  | ROD
| outputImage | The output image reprensenting the matching score between 0 and 1. Its dimensions are forced to the same values as the input. Its data type is forced to floating point. | Image |  | null

## Object Examples

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

    StructureEnhancementFilter3d structureEnhancementFilter3dAlgo;
    structureEnhancementFilter3dAlgo.setInputImage( foam );
    structureEnhancementFilter3dAlgo.setTensorType( StructureEnhancementFilter3d::TensorType::HESSIAN );
    structureEnhancementFilter3dAlgo.setStandardDeviationRange( {1.0, 3.0} );
    structureEnhancementFilter3dAlgo.setStandardDeviationStep( 1.0 );
    structureEnhancementFilter3dAlgo.setLightness( StructureEnhancementFilter3d::Lightness::BRIGHT );
    structureEnhancementFilter3dAlgo.setStructureType( StructureEnhancementFilter3d::StructureType::ROD );
    structureEnhancementFilter3dAlgo.execute();

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

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

    structure_enhancement_filter_3d_algo = imagedev.StructureEnhancementFilter3d()
    structure_enhancement_filter_3d_algo.input_image = foam
    structure_enhancement_filter_3d_algo.tensor_type = imagedev.StructureEnhancementFilter3d.HESSIAN
    structure_enhancement_filter_3d_algo.standard_deviation_range = [1.0, 3.0]
    structure_enhancement_filter_3d_algo.standard_deviation_step = 1.0
    structure_enhancement_filter_3d_algo.lightness = imagedev.StructureEnhancementFilter3d.BRIGHT
    structure_enhancement_filter_3d_algo.structure_type = imagedev.StructureEnhancementFilter3d.ROD
    structure_enhancement_filter_3d_algo.execute()

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

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

    StructureEnhancementFilter3d structureEnhancementFilter3dAlgo = new StructureEnhancementFilter3d
    {
        inputImage = foam,
        tensorType = StructureEnhancementFilter3d.TensorType.HESSIAN,
        standardDeviationRange = new double[]{1.0, 3.0},
        standardDeviationStep = 1.0,
        lightness = StructureEnhancementFilter3d.Lightness.BRIGHT,
        structureType = StructureEnhancementFilter3d.StructureType.ROD
    };
    structureEnhancementFilter3dAlgo.Execute();

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

## Function Examples

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

    auto result = structureEnhancementFilter3d( foam, StructureEnhancementFilter3d::TensorType::HESSIAN, {1.0, 3.0}, 1.0, StructureEnhancementFilter3d::Lightness::BRIGHT, StructureEnhancementFilter3d::StructureType::ROD );

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

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

    result = imagedev.structure_enhancement_filter_3d(foam, imagedev.StructureEnhancementFilter3d.HESSIAN, [1.0, 3.0], 1.0, imagedev.StructureEnhancementFilter3d.BRIGHT, imagedev.StructureEnhancementFilter3d.ROD)

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

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

    IOLink.ImageView result = Processing.StructureEnhancementFilter3d( foam, StructureEnhancementFilter3d.TensorType.HESSIAN, new double[]{1.0, 3.0}, 1.0, StructureEnhancementFilter3d.Lightness.BRIGHT, StructureEnhancementFilter3d.StructureType.ROD );

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

© 2025 Thermo Fisher Scientific Inc. All rights reserved.