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

# ImageCurvature3d

Computes local gray level curvature in a two-dimensional image.
Access to parameter description
This algorithm computes, for each voxel of an input image, two local texture curvature attributes. The curvature estimation takes the voxel size into account.
The curvature is extracted from the gradient structure tensor of the input image.
Each voxel is then associated with two principle curvatures : $\kappa_{Max}$ and $\kappa_{Min}$.
The $\kappa_{Max}$ stands for maximum local curvature, whereas $\kappa_{Min}$ stands for minimum curvature.
Two important indicators can be extracted from these values:

- Gaussian curvature : $K=\kappa_{Max} \times \kappa_{Min}$
- Mean curvature : $H=\frac{1}{2}(\kappa_{Max} + \kappa_{Min})$

Gaussian curvature can be used to characterize local surface comportment:

- If Gaussian curvature is positive, both principle curvatures have same sign and local surface is dome-like (which means that it is locally lying on one side of its tangent plane). In this case, a positive curvature stands for a convex surface, whereas a negative value stands for a concave surface.
- If Gaussian curvature is negative, principle curvatures have opposite signs and the local surface is saddle-shaped (see figure 1).
- If Gaussian curvature is null, the surface is locally parabolic. If $\kappa_{Max}=0$, surface profile is locally valley-like. If $\kappa_{Min}=0$, surface profile is locally crest-like.

Figure 1. Saddle-shaped 3D curvature (image: Eric Gaba)
References:

- O. Monga, S. Benayou. "Using Partial Derivatives of 3D Images to Extract Typical Surface Features". Computer Vision and Image Understanding, CVIU. 61, pp. 225-236, 1995.
- B. Rieger, F.J. Timmermans, L.J. van Vliet, P.W. Verbeek. "On Curvature Estimation of ISO Surfaces in 3D Gray-Value Images and the Computation of Shape Descriptors". IEEE TRANSACTIONS ON PATTERN ANALYSIS AND MACHINE INTELLIGENCE, vol.26, no. 8, pp. 1088-1094, Aug. 2004.

See also

- GaussianGradientTensor3d
- StructureEnhancementFilter3d
- ImageCurvature2d

##
Function Syntax

This function returns a ImageCurvature3dOutput structure containing outputMaximumImage and outputMinimumImage.

    // Output structure of the imageCurvature3d function.
    struct ImageCurvature3dOutput
    {
        /// The maximum curvature output image. Each pixel value represents the maximum curvature in the world coordinates system. Its dimensions are forced to the same values as the input. Its data type is forced to floating point.
        std::shared_ptr< iolink::ImageView > outputMaximumImage;
        /// The minimum curvature output image. Each pixel value represents the minimum curvature in the world coordinates system. Its dimensions are forced to the same values as the input. Its data type is forced to floating point.
        std::shared_ptr< iolink::ImageView > outputMinimumImage;
    };

    // Function prototype
    ImageCurvature3dOutput
    imageCurvature3d( std::shared_ptr< iolink::ImageView > inputImage,
                      std::shared_ptr< iolink::ImageView > inputMaskImage,
                      double standardDeviation,
                      std::shared_ptr< iolink::ImageView > outputMaximumImage = nullptr,
                      std::shared_ptr< iolink::ImageView > outputMinimumImage = nullptr );

This function returns a tuple containing output_maximum_image and output_minimum_image.

    // Function prototype.
    image_curvature_3d(input_image: idt.ImageType,
                       input_mask_image: idt.ImageType,
                       standard_deviation: float = 4,
                       output_maximum_image: idt.ImageType = None,
                       output_minimum_image: idt.ImageType = None) -> Tuple[idt.ImageType, idt.ImageType]

This function returns a ImageCurvature3dOutput structure containing outputMaximumImage and outputMinimumImage.

    /// Output structure of the ImageCurvature3d function.
    public struct ImageCurvature3dOutput
    {
        ///
        /// The maximum curvature output image. Each pixel value represents the maximum curvature in the world coordinates system. Its dimensions are forced to the same values as the input. Its data type is forced to floating point.
        ///
        public IOLink.ImageView outputMaximumImage;
        ///
        /// The minimum curvature output image. Each pixel value represents the minimum curvature in the world coordinates system. Its dimensions are forced to the same values as the input. Its data type is forced to floating point.
        ///
        public IOLink.ImageView outputMinimumImage;
    };

    // Function prototype.
    public static ImageCurvature3dOutput
    ImageCurvature3d( IOLink.ImageView inputImage,
                      IOLink.ImageView inputMaskImage,
                      double standardDeviation = 4,
                      IOLink.ImageView outputMaximumImage = null,
                      IOLink.ImageView outputMinimumImage = null );

##
Class Syntax

    // Command constructor.
    ImageCurvature3d();

    /// Gets the inputImage parameter.
    /// The input image.
    std::shared_ptr< iolink::ImageView > inputImage() const;
    /// Sets the inputImage parameter.
    /// The input image.
    void setInputImage( std::shared_ptr< iolink::ImageView > inputImage );

    /// Gets the inputMaskImage parameter.
    /// The binary image designating the area to process. If it equals null, the algorithm is applied on the whole image. This image must have same dimensions as the input image.
    std::shared_ptr< iolink::ImageView > inputMaskImage() const;
    /// Sets the inputMaskImage parameter.
    /// The binary image designating the area to process. If it equals null, the algorithm is applied on the whole image. This image must have same dimensions as the input image.
    void setInputMaskImage( std::shared_ptr< iolink::ImageView > inputMaskImage );

    /// Gets the standardDeviation parameter.
    /// The standard deviation for Gaussian filter, expressed in world coordinates of the input image.
    double standardDeviation() const;
    /// Sets the standardDeviation parameter.
    /// The standard deviation for Gaussian filter, expressed in world coordinates of the input image.
    void setStandardDeviation( const double& standardDeviation );

    /// Gets the outputMaximumImage parameter.
    /// The maximum curvature output image. Each pixel value represents the maximum curvature in the world coordinates system. Its dimensions are forced to the same values as the input. Its data type is forced to floating point.
    std::shared_ptr< iolink::ImageView > outputMaximumImage() const;
    /// Sets the outputMaximumImage parameter.
    /// The maximum curvature output image. Each pixel value represents the maximum curvature in the world coordinates system. Its dimensions are forced to the same values as the input. Its data type is forced to floating point.
    void setOutputMaximumImage( std::shared_ptr< iolink::ImageView > outputMaximumImage );

    /// Gets the outputMinimumImage parameter.
    /// The minimum curvature output image. Each pixel value represents the minimum curvature in the world coordinates system. Its dimensions are forced to the same values as the input. Its data type is forced to floating point.
    std::shared_ptr< iolink::ImageView > outputMinimumImage() const;
    /// Sets the outputMinimumImage parameter.
    /// The minimum curvature output image. Each pixel value represents the minimum curvature in the world coordinates system. Its dimensions are forced to the same values as the input. Its data type is forced to floating point.
    void setOutputMinimumImage( std::shared_ptr< iolink::ImageView > outputMinimumImage );

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

    # Property of the inputImage parameter.
    ImageCurvature3d.input_image
    # Property of the inputMaskImage parameter.
    ImageCurvature3d.input_mask_image
    # Property of the standardDeviation parameter.
    ImageCurvature3d.standard_deviation
    # Property of the outputMaximumImage parameter.
    ImageCurvature3d.output_maximum_image
    # Property of the outputMinimumImage parameter.
    ImageCurvature3d.output_minimum_image

    // Method to launch the command.
    execute()

    // Command constructor.
    ImageCurvature3d()

    // Property of the inputImage parameter.
    ImageCurvature3d.inputImage
    // Property of the inputMaskImage parameter.
    ImageCurvature3d.inputMaskImage
    // Property of the standardDeviation parameter.
    ImageCurvature3d.standardDeviation
    // Property of the outputMaximumImage parameter.
    ImageCurvature3d.outputMaximumImage
    // Property of the outputMinimumImage parameter.
    ImageCurvature3d.outputMinimumImage

    // Method to launch the command.
    Execute()

## Parameters

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| inputImage | The input image. | Image | Binary, Label, Grayscale or Multispectral | nullptr
| inputMaskImage | The binary image designating the area to process. If it equals null, the algorithm is applied on the whole image. This image must have same dimensions as the input image. | Image | Binary | nullptr
| standardDeviation | The standard deviation for Gaussian filter, expressed in world coordinates of the input image. | Float64 | >0 | 4
| outputMaximumImage | The maximum curvature output image. Each pixel value represents the maximum curvature in the world coordinates system. Its dimensions are forced to the same values as the input. Its data type is forced to floating point. | Image |  | nullptr
| outputMinimumImage | The minimum curvature output image. Each pixel value represents the minimum curvature in the world coordinates system. 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. | image | Binary, Label, Grayscale or Multispectral | None
| input_mask_image | The binary image designating the area to process. If it equals null, the algorithm is applied on the whole image. This image must have same dimensions as the input image. | image | Binary | None
| standard_deviation | The standard deviation for Gaussian filter, expressed in world coordinates of the input image. | float64 | >0 | 4
| output_maximum_image | The maximum curvature output image. Each pixel value represents the maximum curvature in the world coordinates system. Its dimensions are forced to the same values as the input. Its data type is forced to floating point. | image |  | None
| output_minimum_image | The minimum curvature output image. Each pixel value represents the minimum curvature in the world coordinates system. 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. | Image | Binary, Label, Grayscale or Multispectral | null
| inputMaskImage | The binary image designating the area to process. If it equals null, the algorithm is applied on the whole image. This image must have same dimensions as the input image. | Image | Binary | null
| standardDeviation | The standard deviation for Gaussian filter, expressed in world coordinates of the input image. | Float64 | >0 | 4
| outputMaximumImage | The maximum curvature output image. Each pixel value represents the maximum curvature in the world coordinates system. Its dimensions are forced to the same values as the input. Its data type is forced to floating point. | Image |  | null
| outputMinimumImage | The minimum curvature output image. Each pixel value represents the minimum curvature in the world coordinates system. 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" );
    auto foam_sep = readVipImage( std::string( IMAGEDEVDATA_IMAGES_FOLDER ) + "foam_sep.vip" );

    ImageCurvature3d imageCurvature3dAlgo;
    imageCurvature3dAlgo.setInputImage( foam );
    imageCurvature3dAlgo.setInputMaskImage( foam_sep );
    imageCurvature3dAlgo.setStandardDeviation( 4.0 );
    imageCurvature3dAlgo.execute();

    std::cout << "outputMaximumImage:" << imageCurvature3dAlgo.outputMaximumImage()->toString();
    std::cout << "outputMinimumImage:" << imageCurvature3dAlgo.outputMinimumImage()->toString();

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

    image_curvature_3d_algo = imagedev.ImageCurvature3d()
    image_curvature_3d_algo.input_image = foam
    image_curvature_3d_algo.input_mask_image = foam_sep
    image_curvature_3d_algo.standard_deviation = 4.0
    image_curvature_3d_algo.execute()

    print("output_maximum_image:", str(image_curvature_3d_algo.output_maximum_image))
    print("output_minimum_image:", str(image_curvature_3d_algo.output_minimum_image))

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

    ImageCurvature3d imageCurvature3dAlgo = new ImageCurvature3d
    {
        inputImage = foam,
        inputMaskImage = foam_sep,
        standardDeviation = 4.0
    };
    imageCurvature3dAlgo.Execute();

    Console.WriteLine( "outputMaximumImage:" + imageCurvature3dAlgo.outputMaximumImage.ToString() );
    Console.WriteLine( "outputMinimumImage:" + imageCurvature3dAlgo.outputMinimumImage.ToString() );

## Function Examples

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

    auto result = imageCurvature3d( foam, foam_sep, 4.0 );

    std::cout << "outputMaximumImage:" << result.outputMaximumImage->toString();
    std::cout << "outputMinimumImage:" << result.outputMinimumImage->toString();

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

    result_output_maximum_image, result_output_minimum_image = imagedev.image_curvature_3d(foam, foam_sep, 4.0)

    print("output_maximum_image:", str(result_output_maximum_image))
    print("output_minimum_image:", str(result_output_minimum_image))

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

    Processing.ImageCurvature3dOutput result = Processing.ImageCurvature3d( foam, foam_sep, 4.0 );

    Console.WriteLine( "outputMaximumImage:" + result.outputMaximumImage.ToString() );
    Console.WriteLine( "outputMinimumImage:" + result.outputMinimumImage.ToString() );

© 2025 Thermo Fisher Scientific Inc. All rights reserved.