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

# ElasticRegistration2d

Computes the optimal elastic transformation to register a two-dimensional a moving image onto a fixed image.
Access to parameter description
For an introduction: section Image Registration.
Contrary to rigid tranformations, elastic transformations warp locally the moving image to align it with the fixed image. The implementation described here relies on the demon's algorithm published by Jean-Pierre Thirion [1].
This algorithm generates two images:

- A displacement image which represents the computed transformation. Each pixel of this image contains two values: a displacement to apply in the X direction and another to apply in the Y direction on the corresponding pixel of the moving image to be registered on the fixed image.
- The result of the registration of the moving image on the fixed image.

ElasticRegistration2d has two levels of regularization: fluid and elastic. The fluid regularization corresponds to the force field regularization and the elastic one corresponds to the displacement field regularization.
The force field is an elementary displacement which is iteratively added to the current displacement field during the registration procedure. This force field tends to decrease the similarity measurement between both images.
ElasticRegistration2d also provides a multi-resolution approach which prevents the optimization procedure from falling into a local extrema and also speeds up the calculation.
The coarsest and the finest resolution levels of the multi-resolution can be user-defined. The registration is evaluated at the coarsest level first and then iteratively at each level until the finest one. The higher the finest level, the faster the computation. The lower the finest level, the more accurate the registration.

(a) | (b) | (c)

Figure 1. Elastic registration by demon's algorithm: (a) the fixed image,
(b) the moving image (artificially distorted image), (c) the moving image registered on the fixed image
This algorithm can notify some information during the processing (pyramid level, number of iterations, energy) and can be interrupted. These information can be intercepted with the progress data callback function defined by the setProgressDataCallback function. In this case, data sent to the callback will be a string containing a JSON structure including the pyramid level, the number of iterations, and the energy. Intercepting these events slows down the execution.
More information on the callback functions can be found in the Processing interaction section.
Reference:

- [1] J.P.Thirion. Image matching as a diffusion process: an analogy with Maxwell s demons. Medical Image Analysis , Elsevier, vol. 2, no. 3, pp. 243 260, 1998

See also

- ResampleElastic2d
- AffineRegistration

##
Function Syntax

This function returns a ElasticRegistration2dOutput structure containing outputImage and outputDisplacementField.

    // Output structure of the elasticRegistration2d function.
    struct ElasticRegistration2dOutput
    {
        /// The moving image transformed by the output displacement field. Its dimensions are forced to the same values as the fixed image, its type is forced to floating point precision (32-bit).
        std::shared_ptr< iolink::ImageView > outputImage;
        /// The displacement field that maps a pixel of the moving image onto the corresponding pixel in the fixed image. Each pixel of the displacement image contains two values: the first one represents the displacement in the X direction and one in the Y direction. Its dimensions are forced to the same values as the moving image, and its type is forced to floating point precision (32-bit).
        std::shared_ptr< iolink::ImageView > outputDisplacementField;
    };

    // Function prototype
    ElasticRegistration2dOutput
    elasticRegistration2d( std::shared_ptr< iolink::ImageView > inputFixedImage,
                           std::shared_ptr< iolink::ImageView > inputMovingImage,
                           ElasticRegistration2d::MetricType metricType,
                           double tolerance,
                           const iolink::Vector2u32& pyramidLevels,
                           const iolink::Vector2d& elasticStandardDeviation,
                           const iolink::Vector2d& fluidStandardDeviation,
                           std::shared_ptr< iolink::ImageView > outputImage = nullptr,
                           std::shared_ptr< iolink::ImageView > outputDisplacementField = nullptr );

This function returns a tuple containing output_image and output_displacement_field.

    // Function prototype.
    elastic_registration_2d(input_fixed_image: idt.ImageType,
                            input_moving_image: idt.ImageType,
                            metric_type: ElasticRegistration2d.MetricType = ElasticRegistration2d.MetricType.MEAN_SQUARE_DIFFERENCE,
                            tolerance: float = 0.025,
                            pyramid_levels: Iterable[int] = [2, 0],
                            elastic_standard_deviation: Union[Iterable[int], Iterable[float]] = [10, 10],
                            fluid_standard_deviation: Union[Iterable[int], Iterable[float]] = [10, 10],
                            output_image: idt.ImageType = None,
                            output_displacement_field: idt.ImageType = None) -> Tuple[idt.ImageType, idt.ImageType]

This function returns a ElasticRegistration2dOutput structure containing outputImage and outputDisplacementField.

    /// Output structure of the ElasticRegistration2d function.
    public struct ElasticRegistration2dOutput
    {
        ///
        /// The moving image transformed by the output displacement field. Its dimensions are forced to the same values as the fixed image, its type is forced to floating point precision (32-bit).
        ///
        public IOLink.ImageView outputImage;
        ///
        /// The displacement field that maps a pixel of the moving image onto the corresponding pixel in the fixed image. Each pixel of the displacement image contains two values: the first one represents the displacement in the X direction and one in the Y direction. Its dimensions are forced to the same values as the moving image, and its type is forced to floating point precision (32-bit).
        ///
        public IOLink.ImageView outputDisplacementField;
    };

    // Function prototype.
    public static ElasticRegistration2dOutput
    ElasticRegistration2d( IOLink.ImageView inputFixedImage,
                           IOLink.ImageView inputMovingImage,
                           ElasticRegistration2d.MetricType metricType = ImageDev.ElasticRegistration2d.MetricType.MEAN_SQUARE_DIFFERENCE,
                           double tolerance = 0.025,
                           uint[] pyramidLevels = null,
                           double[] elasticStandardDeviation = null,
                           double[] fluidStandardDeviation = null,
                           IOLink.ImageView outputImage = null,
                           IOLink.ImageView outputDisplacementField = null );

##
Class Syntax

    // Command constructor.
    ElasticRegistration2d();

    /// Gets the inputFixedImage parameter.
    /// The input fixed grayscale image on which the moving image has to be registered.
    std::shared_ptr< iolink::ImageView > inputFixedImage() const;
    /// Sets the inputFixedImage parameter.
    /// The input fixed grayscale image on which the moving image has to be registered.
    void setInputFixedImage( std::shared_ptr< iolink::ImageView > inputFixedImage );

    /// Gets the inputMovingImage parameter.
    /// The input moving grayscale image to be registered. Its dimensions and type can be different than the moving image input.
    std::shared_ptr< iolink::ImageView > inputMovingImage() const;
    /// Sets the inputMovingImage parameter.
    /// The input moving grayscale image to be registered. Its dimensions and type can be different than the moving image input.
    void setInputMovingImage( std::shared_ptr< iolink::ImageView > inputMovingImage );

    /// Gets the metricType parameter.
    /// The type of metric used to measure the similarity/dissimilarity between the fixed and the transformed image.
    ElasticRegistration2d::MetricType metricType() const;
    /// Sets the metricType parameter.
    /// The type of metric used to measure the similarity/dissimilarity between the fixed and the transformed image.
    void setMetricType( const ElasticRegistration2d::MetricType& metricType );

    /// Gets the tolerance parameter.
    /// The maximum relative variation of the metric to stop the process. This variation is recomputed at each iteration.
    double tolerance() const;
    /// Sets the tolerance parameter.
    /// The maximum relative variation of the metric to stop the process. This variation is recomputed at each iteration.
    void setTolerance( const double& tolerance );

    /// Gets the pyramidLevels parameter.
    /// The two-dimensional vector representing the coarsest (resp. finest) resolution level in its first (resp. second) element.
    iolink::Vector2u32 pyramidLevels() const;
    /// Sets the pyramidLevels parameter.
    /// The two-dimensional vector representing the coarsest (resp. finest) resolution level in its first (resp. second) element.
    void setPyramidLevels( const iolink::Vector2u32& pyramidLevels );

    /// Gets the elasticStandardDeviation parameter.
    /// The standard deviation of the gaussian kernel used to smooth the displacement field at each iteration.
    iolink::Vector2d elasticStandardDeviation() const;
    /// Sets the elasticStandardDeviation parameter.
    /// The standard deviation of the gaussian kernel used to smooth the displacement field at each iteration.
    void setElasticStandardDeviation( const iolink::Vector2d& elasticStandardDeviation );

    /// Gets the fluidStandardDeviation parameter.
    /// The standard deviation of the gaussian kernel used to smooth the forces field at each iteration. This parameter value is critical to reach large displacements.
    iolink::Vector2d fluidStandardDeviation() const;
    /// Sets the fluidStandardDeviation parameter.
    /// The standard deviation of the gaussian kernel used to smooth the forces field at each iteration. This parameter value is critical to reach large displacements.
    void setFluidStandardDeviation( const iolink::Vector2d& fluidStandardDeviation );

    /// Gets the outputImage parameter.
    /// The moving image transformed by the output displacement field. Its dimensions are forced to the same values as the fixed image, its type is forced to floating point precision (32-bit).
    std::shared_ptr< iolink::ImageView > outputImage() const;
    /// Sets the outputImage parameter.
    /// The moving image transformed by the output displacement field. Its dimensions are forced to the same values as the fixed image, its type is forced to floating point precision (32-bit).
    void setOutputImage( std::shared_ptr< iolink::ImageView > outputImage );

    /// Gets the outputDisplacementField parameter.
    /// The displacement field that maps a pixel of the moving image onto the corresponding pixel in the fixed image. Each pixel of the displacement image contains two values: the first one represents the displacement in the X direction and one in the Y direction. Its dimensions are forced to the same values as the moving image, and its type is forced to floating point precision (32-bit).
    std::shared_ptr< iolink::ImageView > outputDisplacementField() const;
    /// Sets the outputDisplacementField parameter.
    /// The displacement field that maps a pixel of the moving image onto the corresponding pixel in the fixed image. Each pixel of the displacement image contains two values: the first one represents the displacement in the X direction and one in the Y direction. Its dimensions are forced to the same values as the moving image, and its type is forced to floating point precision (32-bit).
    void setOutputDisplacementField( std::shared_ptr< iolink::ImageView > outputDisplacementField );

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

    # Property of the inputFixedImage parameter.
    ElasticRegistration2d.input_fixed_image
    # Property of the inputMovingImage parameter.
    ElasticRegistration2d.input_moving_image
    # Property of the metricType parameter.
    ElasticRegistration2d.metric_type
    # Property of the tolerance parameter.
    ElasticRegistration2d.tolerance
    # Property of the pyramidLevels parameter.
    ElasticRegistration2d.pyramid_levels
    # Property of the elasticStandardDeviation parameter.
    ElasticRegistration2d.elastic_standard_deviation
    # Property of the fluidStandardDeviation parameter.
    ElasticRegistration2d.fluid_standard_deviation
    # Property of the outputImage parameter.
    ElasticRegistration2d.output_image
    # Property of the outputDisplacementField parameter.
    ElasticRegistration2d.output_displacement_field

    // Method to launch the command.
    execute()

    // Command constructor.
    ElasticRegistration2d()

    // Property of the inputFixedImage parameter.
    ElasticRegistration2d.inputFixedImage
    // Property of the inputMovingImage parameter.
    ElasticRegistration2d.inputMovingImage
    // Property of the metricType parameter.
    ElasticRegistration2d.metricType
    // Property of the tolerance parameter.
    ElasticRegistration2d.tolerance
    // Property of the pyramidLevels parameter.
    ElasticRegistration2d.pyramidLevels
    // Property of the elasticStandardDeviation parameter.
    ElasticRegistration2d.elasticStandardDeviation
    // Property of the fluidStandardDeviation parameter.
    ElasticRegistration2d.fluidStandardDeviation
    // Property of the outputImage parameter.
    ElasticRegistration2d.outputImage
    // Property of the outputDisplacementField parameter.
    ElasticRegistration2d.outputDisplacementField

    // Method to launch the command.
    Execute()

## Parameters

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| inputFixedImage | The input fixed grayscale image on which the moving image has to be registered. | Image | Grayscale | nullptr
| inputMovingImage | The input moving grayscale image to be registered. Its dimensions and type can be different than the moving image input. | Image | Grayscale | nullptr
| metricType | The type of metric used to measure the similarity/dissimilarity between the fixed and the transformed image.
MEAN_SQUARE_DIFFERENCE | The metric used is the Mean Squared Difference, it has to be minimized.
CORRELATION | The metric used is the Normalized Correlation, it has to be maximized.
| Enumeration |  | MEAN_SQUARE_DIFFERENCE
| tolerance | The maximum relative variation of the metric to stop the process. This variation is recomputed at each iteration. | Float64 | >0 | 0.025
| pyramidLevels | The two-dimensional vector representing the coarsest (resp. finest) resolution level in its first (resp. second) element. A value of 0 corresponds to the full resolution and a value of $N$ corresponds to a resolution of $ \frac{1}{2^N} $. | Vector2u32 | Any value | {2, 0}
| elasticStandardDeviation | The standard deviation of the gaussian kernel used to smooth the displacement field at each iteration. | Vector2d | >0 | {10.f, 10.f}
| fluidStandardDeviation | The standard deviation of the gaussian kernel used to smooth the forces field at each iteration. This parameter value is critical to reach large displacements. | Vector2d | >0 | {10.f, 10.f}
| outputImage | The moving image transformed by the output displacement field. Its dimensions are forced to the same values as the fixed image, its type is forced to floating point precision (32-bit). | Image |  | nullptr
| outputDisplacementField | The displacement field that maps a pixel of the moving image onto the corresponding pixel in the fixed image. Each pixel of the displacement image contains two values: the first one represents the displacement in the X direction and one in the Y direction. Its dimensions are forced to the same values as the moving image, and its type is forced to floating point precision (32-bit). | Image |  | nullptr

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| input_fixed_image | The input fixed grayscale image on which the moving image has to be registered. | image | Grayscale | None
| input_moving_image | The input moving grayscale image to be registered. Its dimensions and type can be different than the moving image input. | image | Grayscale | None
| metric_type | The type of metric used to measure the similarity/dissimilarity between the fixed and the transformed image.
MEAN_SQUARE_DIFFERENCE | The metric used is the Mean Squared Difference, it has to be minimized.
CORRELATION | The metric used is the Normalized Correlation, it has to be maximized.
| enumeration |  | MEAN_SQUARE_DIFFERENCE
| tolerance | The maximum relative variation of the metric to stop the process. This variation is recomputed at each iteration. | float64 | >0 | 0.025
| pyramid_levels | The two-dimensional vector representing the coarsest (resp. finest) resolution level in its first (resp. second) element. A value of 0 corresponds to the full resolution and a value of $N$ corresponds to a resolution of $ \frac{1}{2^N} $. | vector2u32 | Any value | [2, 0]
| elastic_standard_deviation | The standard deviation of the gaussian kernel used to smooth the displacement field at each iteration. | vector2d | >0 | [10, 10]
| fluid_standard_deviation | The standard deviation of the gaussian kernel used to smooth the forces field at each iteration. This parameter value is critical to reach large displacements. | vector2d | >0 | [10, 10]
| output_image | The moving image transformed by the output displacement field. Its dimensions are forced to the same values as the fixed image, its type is forced to floating point precision (32-bit). | image |  | None
| output_displacement_field | The displacement field that maps a pixel of the moving image onto the corresponding pixel in the fixed image. Each pixel of the displacement image contains two values: the first one represents the displacement in the X direction and one in the Y direction. Its dimensions are forced to the same values as the moving image, and its type is forced to floating point precision (32-bit). | image |  | None

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| inputFixedImage | The input fixed grayscale image on which the moving image has to be registered. | Image | Grayscale | null
| inputMovingImage | The input moving grayscale image to be registered. Its dimensions and type can be different than the moving image input. | Image | Grayscale | null
| metricType | The type of metric used to measure the similarity/dissimilarity between the fixed and the transformed image.
MEAN_SQUARE_DIFFERENCE | The metric used is the Mean Squared Difference, it has to be minimized.
CORRELATION | The metric used is the Normalized Correlation, it has to be maximized.
| Enumeration |  | MEAN_SQUARE_DIFFERENCE
| tolerance | The maximum relative variation of the metric to stop the process. This variation is recomputed at each iteration. | Float64 | >0 | 0.025
| pyramidLevels | The two-dimensional vector representing the coarsest (resp. finest) resolution level in its first (resp. second) element. A value of 0 corresponds to the full resolution and a value of $N$ corresponds to a resolution of $ \frac{1}{2^N} $. | Vector2u32 | Any value | {2, 0}
| elasticStandardDeviation | The standard deviation of the gaussian kernel used to smooth the displacement field at each iteration. | Vector2d | >0 | {10f, 10f}
| fluidStandardDeviation | The standard deviation of the gaussian kernel used to smooth the forces field at each iteration. This parameter value is critical to reach large displacements. | Vector2d | >0 | {10f, 10f}
| outputImage | The moving image transformed by the output displacement field. Its dimensions are forced to the same values as the fixed image, its type is forced to floating point precision (32-bit). | Image |  | null
| outputDisplacementField | The displacement field that maps a pixel of the moving image onto the corresponding pixel in the fixed image. Each pixel of the displacement image contains two values: the first one represents the displacement in the X direction and one in the Y direction. Its dimensions are forced to the same values as the moving image, and its type is forced to floating point precision (32-bit). | Image |  | null

## Object Examples

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

    ElasticRegistration2d elasticRegistration2dAlgo;
    elasticRegistration2dAlgo.setInputFixedImage( polystyrene );
    elasticRegistration2dAlgo.setInputMovingImage( polystyrene );
    elasticRegistration2dAlgo.setMetricType( ElasticRegistration2d::MetricType::MEAN_SQUARE_DIFFERENCE );
    elasticRegistration2dAlgo.setTolerance( 0.025 );
    elasticRegistration2dAlgo.setPyramidLevels( {2, 0} );
    elasticRegistration2dAlgo.setElasticStandardDeviation( {10.0, 10.0} );
    elasticRegistration2dAlgo.setFluidStandardDeviation( {10.0, 10.0} );
    elasticRegistration2dAlgo.execute();

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

    polystyrene = ioformat.read_image(imagedev_data.get_image_path("polystyrene.tif"))

    elastic_registration_2d_algo = imagedev.ElasticRegistration2d()
    elastic_registration_2d_algo.input_fixed_image = polystyrene
    elastic_registration_2d_algo.input_moving_image = polystyrene
    elastic_registration_2d_algo.metric_type = imagedev.ElasticRegistration2d.MEAN_SQUARE_DIFFERENCE
    elastic_registration_2d_algo.tolerance = 0.025
    elastic_registration_2d_algo.pyramid_levels = [2, 0]
    elastic_registration_2d_algo.elastic_standard_deviation = [10.0, 10.0]
    elastic_registration_2d_algo.fluid_standard_deviation = [10.0, 10.0]
    elastic_registration_2d_algo.execute()

    print("output_image:", str(elastic_registration_2d_algo.output_image))
    print("output_displacement_field:", str(elastic_registration_2d_algo.output_displacement_field))

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

    ElasticRegistration2d elasticRegistration2dAlgo = new ElasticRegistration2d
    {
        inputFixedImage = polystyrene,
        inputMovingImage = polystyrene,
        metricType = ElasticRegistration2d.MetricType.MEAN_SQUARE_DIFFERENCE,
        tolerance = 0.025,
        pyramidLevels = new uint[]{2, 0},
        elasticStandardDeviation = new double[]{10.0, 10.0},
        fluidStandardDeviation = new double[]{10.0, 10.0}
    };
    elasticRegistration2dAlgo.Execute();

    Console.WriteLine( "outputImage:" + elasticRegistration2dAlgo.outputImage.ToString() );
    Console.WriteLine( "outputDisplacementField:" + elasticRegistration2dAlgo.outputDisplacementField.ToString() );

## Function Examples

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

    auto result = elasticRegistration2d( polystyrene, polystyrene, ElasticRegistration2d::MetricType::MEAN_SQUARE_DIFFERENCE, 0.025, {2, 0}, {10.0, 10.0}, {10.0, 10.0} );

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

    polystyrene = ioformat.read_image(imagedev_data.get_image_path("polystyrene.tif"))

    result_output_image, result_output_displacement_field = imagedev.elastic_registration_2d(polystyrene, polystyrene, imagedev.ElasticRegistration2d.MEAN_SQUARE_DIFFERENCE, 0.025, [2, 0], [10.0, 10.0], [10.0, 10.0])

    print("output_image:", str(result_output_image))
    print("output_displacement_field:", str(result_output_displacement_field))

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

    Processing.ElasticRegistration2dOutput result = Processing.ElasticRegistration2d( polystyrene, polystyrene, ElasticRegistration2d.MetricType.MEAN_SQUARE_DIFFERENCE, 0.025, new uint[]{2, 0}, new double[]{10.0, 10.0}, new double[]{10.0, 10.0} );

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

© 2025 Thermo Fisher Scientific Inc. All rights reserved.