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

# SsimValue2d

Computes the mean structural similarity (SSIM) index between two two-dimensional images.
Access to parameter description
This algorithm provides a measure of similarity by computing the SSIM value for each pixel of the couple of image and by returning the mean of all these values.
For each pixel, we compute the SSIM value by using the following formula :
$$ SSIM(I_{1},I_{2}) = \frac{\left ( 2\mu_{1} \mu_{2} +C_{1}\right )\left ( 2\sigma_{12}+C_{2}\right )}{\left ( \mu_{1}^{2}+ \mu_{2}^{2} +C_{1}\right )\left ( \sigma_{1}^{2}+\sigma_{2}^{2}+C_{2}\right )}$$
Where:

- $\mu_{1}$ is the mean in the tile arround the current pixel in the image $I_{1}$,
- $\mu_{2}$ is the mean in the tile arround the current pixel in the image $I_{2}$,
- $\sigma_{1}$ is the standard deviation in the tile arround the current pixel in the image $I_{1}$,
- $\sigma_{2}$ is the standard deviation in the tile arround the current pixel in the image $I_{2}$,
- $\sigma_{12}$ is the covariance in the tile arround the current pixel in each image $I_{1}$ and $I_{2}$
- $C_{1}$ is a constant computed with the choosen range $R$ and the parameter $k_{1}$ as follow : $C_{1} = \left ( k_{1}R \right )^{2}$
- $C_{2}$ is a constant computed with the choosen range $R$ and the parameter $k_{2}$ as follow : $C_{2} = \left ( k_{2}R \right )^{2}$

(a) | (b) | (c)

Figure 1. Comparison of the SSIM values after adding an artificial gaussian noise of standard deviation $\sigma$ on an original image:
(a) the reference image to compare, (b) $\sigma$=25, SSIM = 0.05 , (c) $\sigma$=80, SSIM = 0.01
Reference:
Z. Wang, A.C. Bovik, H.R. Sheikh, and E.P. Simoncelli. "Image quality assessment: From error visibility to structural similarity". IEEE Transactions on Image Processing , vol. 13, pp. 600-612, Apr. 2004.
See also

- SimilarityMetricValue
- CompareImage
- SsimValue3d

##
Function Syntax

This function returns outputMeasurement.

    // Function prototype
    SsimValueMsr::Ptr
    ssimValue2d( std::shared_ptr< iolink::ImageView > inputImage1,
                 std::shared_ptr< iolink::ImageView > inputImage2,
                 const iolink::Vector2u32& tileSize,
                 SsimValue2d::RangeMode rangeMode,
                 double range,
                 double k1,
                 double k2,
                 SsimValueMsr::Ptr outputMeasurement = nullptr );

This function returns outputMeasurement.

    // Function prototype.
    ssim_value_2d(input_image1: idt.ImageType,
                  input_image2: idt.ImageType,
                  tile_size: Iterable[int] = [8, 8],
                  range_mode: SsimValue2d.RangeMode = SsimValue2d.RangeMode.DATA_TYPE_RANGE,
                  range: float = 255,
                  k1: float = 0.01,
                  k2: float = 0.03,
                  output_measurement: Union[Any, None] = None) -> SsimValueMsr

This function returns outputMeasurement.

    // Function prototype.
    public static SsimValueMsr
    SsimValue2d( IOLink.ImageView inputImage1,
                 IOLink.ImageView inputImage2,
                 uint[] tileSize = null,
                 SsimValue2d.RangeMode rangeMode = ImageDev.SsimValue2d.RangeMode.DATA_TYPE_RANGE,
                 double range = 255,
                 double k1 = 0.01,
                 double k2 = 0.03,
                 SsimValueMsr outputMeasurement = null );

##
Class Syntax

    // Command constructor.
    SsimValue2d();

    /// Gets the inputImage1 parameter.
    /// The first input image to compare.
    std::shared_ptr< iolink::ImageView > inputImage1() const;
    /// Sets the inputImage1 parameter.
    /// The first input image to compare.
    void setInputImage1( std::shared_ptr< iolink::ImageView > inputImage1 );

    /// Gets the inputImage2 parameter.
    /// The second input image to compare.
    std::shared_ptr< iolink::ImageView > inputImage2() const;
    /// Sets the inputImage2 parameter.
    /// The second input image to compare.
    void setInputImage2( std::shared_ptr< iolink::ImageView > inputImage2 );

    /// Gets the tileSize parameter.
    /// The X and Y sizes, in pixels, of the tile used to compute the SSIM for each pixel
    iolink::Vector2u32 tileSize() const;
    /// Sets the tileSize parameter.
    /// The X and Y sizes, in pixels, of the tile used to compute the SSIM for each pixel
    void setTileSize( const iolink::Vector2u32& tileSize );

    /// Gets the rangeMode parameter.
    /// The way to consider the dynamic range used to compute the regularization constants C1 and C2 of the similarity formula.
    SsimValue2d::RangeMode rangeMode() const;
    /// Sets the rangeMode parameter.
    /// The way to consider the dynamic range used to compute the regularization constants C1 and C2 of the similarity formula.
    void setRangeMode( const SsimValue2d::RangeMode& rangeMode );

    /// Gets the range parameter.
    /// The data range used to compute the constants C1 and C2 of the similarity formula. It corresponds to the distance between the maximum and minimum of the representative image intensities. It is used only if rangeMode parameter is set to OTHER value.
    double range() const;
    /// Sets the range parameter.
    /// The data range used to compute the constants C1 and C2 of the similarity formula. It corresponds to the distance between the maximum and minimum of the representative image intensities. It is used only if rangeMode parameter is set to OTHER value.
    void setRange( const double& range );

    /// Gets the k1 parameter.
    /// The small weight used to compute the regularization constant C1 of the similarity formula.
    double k1() const;
    /// Sets the k1 parameter.
    /// The small weight used to compute the regularization constant C1 of the similarity formula.
    void setK1( const double& k1 );

    /// Gets the k2 parameter.
    /// The small weight used to compute the regularization constant C2 of the similarity formula.
    double k2() const;
    /// Sets the k2 parameter.
    /// The small weight used to compute the regularization constant C2 of the similarity formula.
    void setK2( const double& k2 );

    /// Gets the outputMeasurement parameter.
    /// The output measurement results containing the SSIM value.
    SsimValueMsr::Ptr outputMeasurement() const;

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

    # Property of the inputImage1 parameter.
    SsimValue2d.input_image1
    # Property of the inputImage2 parameter.
    SsimValue2d.input_image2
    # Property of the tileSize parameter.
    SsimValue2d.tile_size
    # Property of the rangeMode parameter.
    SsimValue2d.range_mode
    # Property of the range parameter.
    SsimValue2d.range
    # Property of the k1 parameter.
    SsimValue2d.k1
    # Property of the k2 parameter.
    SsimValue2d.k2
    # Property of the outputMeasurement parameter.
    SsimValue2d.output_measurement

    // Method to launch the command.
    execute()

    // Command constructor.
    SsimValue2d()

    // Property of the inputImage1 parameter.
    SsimValue2d.inputImage1
    // Property of the inputImage2 parameter.
    SsimValue2d.inputImage2
    // Property of the tileSize parameter.
    SsimValue2d.tileSize
    // Property of the rangeMode parameter.
    SsimValue2d.rangeMode
    // Property of the range parameter.
    SsimValue2d.range
    // Property of the k1 parameter.
    SsimValue2d.k1
    // Property of the k2 parameter.
    SsimValue2d.k2
    // Property of the outputMeasurement parameter.
    SsimValue2d.outputMeasurement

    // Method to launch the command.
    Execute()

## Parameters

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| inputImage1 | The first input image to compare. | Image | Grayscale | nullptr
| inputImage2 | The second input image to compare. | Image | Binary, Label, Grayscale or Multispectral | nullptr
| tileSize | The X and Y sizes, in pixels, of the tile used to compute the SSIM for each pixel | Vector2u32 | >=1 | {8, 8}
| rangeMode | The way to consider the dynamic range used to compute the regularization constants C1 and C2 of the similarity formula.
DATA_TYPE_RANGE | The data range is determined by the theoretical maximum and minimum values of the data type.
OTHER | The data range is user-defined by the range parameter.
| Enumeration |  | DATA_TYPE_RANGE
| range | The data range used to compute the constants C1 and C2 of the similarity formula. It corresponds to the distance between the maximum and minimum of the representative image intensities. It is used only if rangeMode parameter is set to OTHER value. | Float64 | >0 | 255
| k1 | The small weight used to compute the regularization constant C1 of the similarity formula. | Float64 | >0 | 0.01
| k2 | The small weight used to compute the regularization constant C2 of the similarity formula. | Float64 | >0 | 0.03
| outputMeasurement | The output measurement results containing the SSIM value. | SsimValueMsr |  | nullptr

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| input_image1 | The first input image to compare. | image | Grayscale | None
| input_image2 | The second input image to compare. | image | Binary, Label, Grayscale or Multispectral | None
| tile_size | The X and Y sizes, in pixels, of the tile used to compute the SSIM for each pixel | vector2u32 | >=1 | [8, 8]
| range_mode | The way to consider the dynamic range used to compute the regularization constants C1 and C2 of the similarity formula.
DATA_TYPE_RANGE | The data range is determined by the theoretical maximum and minimum values of the data type.
OTHER | The data range is user-defined by the range parameter.
| enumeration |  | DATA_TYPE_RANGE
| range | The data range used to compute the constants C1 and C2 of the similarity formula. It corresponds to the distance between the maximum and minimum of the representative image intensities. It is used only if rangeMode parameter is set to OTHER value. | float64 | >0 | 255
| k1 | The small weight used to compute the regularization constant C1 of the similarity formula. | float64 | >0 | 0.01
| k2 | The small weight used to compute the regularization constant C2 of the similarity formula. | float64 | >0 | 0.03
| output_measurement | The output measurement results containing the SSIM value. | SsimValueMsr |  | None

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| inputImage1 | The first input image to compare. | Image | Grayscale | null
| inputImage2 | The second input image to compare. | Image | Binary, Label, Grayscale or Multispectral | null
| tileSize | The X and Y sizes, in pixels, of the tile used to compute the SSIM for each pixel | Vector2u32 | >=1 | {8, 8}
| rangeMode | The way to consider the dynamic range used to compute the regularization constants C1 and C2 of the similarity formula.
DATA_TYPE_RANGE | The data range is determined by the theoretical maximum and minimum values of the data type.
OTHER | The data range is user-defined by the range parameter.
| Enumeration |  | DATA_TYPE_RANGE
| range | The data range used to compute the constants C1 and C2 of the similarity formula. It corresponds to the distance between the maximum and minimum of the representative image intensities. It is used only if rangeMode parameter is set to OTHER value. | Float64 | >0 | 255
| k1 | The small weight used to compute the regularization constant C1 of the similarity formula. | Float64 | >0 | 0.01
| k2 | The small weight used to compute the regularization constant C2 of the similarity formula. | Float64 | >0 | 0.03
| outputMeasurement | The output measurement results containing the SSIM value. | SsimValueMsr |  | null

## Object Examples

    auto polystyrene = ioformat::readImage( std::string( IMAGEDEVDATA_IMAGES_FOLDER ) + "polystyrene.tif" );
    auto polystyrene_gaussian_noise = readVipImage( std::string( IMAGEDEVDATA_IMAGES_FOLDER ) + "polystyrene_gaussian_noise.vip" );

    SsimValue2d ssimValue2dAlgo;
    ssimValue2dAlgo.setInputImage1( polystyrene );
    ssimValue2dAlgo.setInputImage2( polystyrene_gaussian_noise );
    ssimValue2dAlgo.setTileSize( {8, 8} );
    ssimValue2dAlgo.setRangeMode( SsimValue2d::RangeMode::DATA_TYPE_RANGE );
    ssimValue2dAlgo.setRange( 255 );
    ssimValue2dAlgo.setK1( 0.01 );
    ssimValue2dAlgo.setK2( 0.03 );
    ssimValue2dAlgo.execute();

    std::cout << "ssim: " << ssimValue2dAlgo.outputMeasurement()->ssim( 0 ) ;

    polystyrene = ioformat.read_image(imagedev_data.get_image_path("polystyrene.tif"))
    polystyrene_gaussian_noise = imagedev.read_vip_image(imagedev_data.get_image_path("polystyrene_gaussian_noise.vip"))

    ssim_value_2d_algo = imagedev.SsimValue2d()
    ssim_value_2d_algo.input_image1 = polystyrene
    ssim_value_2d_algo.input_image2 = polystyrene_gaussian_noise
    ssim_value_2d_algo.tile_size = [8, 8]
    ssim_value_2d_algo.range_mode = imagedev.SsimValue2d.DATA_TYPE_RANGE
    ssim_value_2d_algo.range = 255
    ssim_value_2d_algo.k1 = 0.01
    ssim_value_2d_algo.k2 = 0.03
    ssim_value_2d_algo.execute()

    print("ssim: ", str(ssim_value_2d_algo.output_measurement.ssim(0)))

    ImageView polystyrene = ViewIO.ReadImage( @"Data/images/polystyrene.tif" );
    ImageView polystyrene_gaussian_noise = Data.ReadVipImage( @"Data/images/polystyrene_gaussian_noise.vip" );

    SsimValue2d ssimValue2dAlgo = new SsimValue2d
    {
        inputImage1 = polystyrene,
        inputImage2 = polystyrene_gaussian_noise,
        tileSize = new uint[]{8, 8},
        rangeMode = SsimValue2d.RangeMode.DATA_TYPE_RANGE,
        range = 255,
        k1 = 0.01,
        k2 = 0.03
    };
    ssimValue2dAlgo.Execute();

    Console.WriteLine( "ssim: " + ssimValue2dAlgo.outputMeasurement.ssim( 0 ) );

## Function Examples

    auto polystyrene = ioformat::readImage( std::string( IMAGEDEVDATA_IMAGES_FOLDER ) + "polystyrene.tif" );
    auto polystyrene_gaussian_noise = readVipImage( std::string( IMAGEDEVDATA_IMAGES_FOLDER ) + "polystyrene_gaussian_noise.vip" );

    auto result = ssimValue2d( polystyrene, polystyrene_gaussian_noise, {8, 8}, SsimValue2d::RangeMode::DATA_TYPE_RANGE, 255, 0.01, 0.03 );

    std::cout << "ssim: " << result->ssim( 0 ) ;

    polystyrene = ioformat.read_image(imagedev_data.get_image_path("polystyrene.tif"))
    polystyrene_gaussian_noise = imagedev.read_vip_image(imagedev_data.get_image_path("polystyrene_gaussian_noise.vip"))

    result = imagedev.ssim_value_2d(polystyrene, polystyrene_gaussian_noise, [8, 8], imagedev.SsimValue2d.DATA_TYPE_RANGE, 255, 0.01, 0.03)

    print("ssim: ", str(result.ssim(0)))

    ImageView polystyrene = ViewIO.ReadImage( @"Data/images/polystyrene.tif" );
    ImageView polystyrene_gaussian_noise = Data.ReadVipImage( @"Data/images/polystyrene_gaussian_noise.vip" );

    SsimValueMsr result = Processing.SsimValue2d( polystyrene, polystyrene_gaussian_noise, new uint[]{8, 8}, SsimValue2d.RangeMode.DATA_TYPE_RANGE, 255, 0.01, 0.03 );

    Console.WriteLine(  "ssim: " + result.ssim( 0 )  );

© 2025 Thermo Fisher Scientific Inc. All rights reserved.