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

# ResampleElastic2d

Resamples an image after applying a transformation described by a displacement field.
Access to parameter description
For an introduction: section Image Registration.
This algorithm generates a new image in accordance with the elastic transformation defined by a displacement field, for instance given by the ElasticRegistration2d algorithm.
This resampling can be performed by controlling several parameters such has the output resolution, calibration or the policy for filling undefined values.

(a) | (b) | (c)

Figure 1. Elastic resampling: (a) the image to resample (artificially distorted image),
(b) the displacement field magnitude, (c) the resampled image
See also

- ElasticRegistration2d

##
Function Syntax

This function returns outputImage.

    // Function prototype
    std::shared_ptr< iolink::ImageView >
    resampleElastic2d( std::shared_ptr< iolink::ImageView > inputImage,
                       std::shared_ptr< iolink::ImageView > inputDisplacementField,
                       ResampleElastic2d::ExtrapolationType extrapolationType,
                       ResampleElastic2d::InterpolationType interpolationType,
                       const iolink::Vector2d& origin,
                       const iolink::Vector2d& voxelSize,
                       const iolink::Vector2u32& imageDimensions,
                       double paddingValue,
                       std::shared_ptr< iolink::ImageView > outputImage = nullptr );

This function returns outputImage.

    // Function prototype.
    resample_elastic_2d(input_image: idt.ImageType,
                        input_displacement_field: idt.ImageType,
                        extrapolation_type: ResampleElastic2d.ExtrapolationType = ResampleElastic2d.ExtrapolationType.PADDING_VALUE,
                        interpolation_type: ResampleElastic2d.InterpolationType = ResampleElastic2d.InterpolationType.LINEAR,
                        origin: Union[Iterable[int], Iterable[float]] = [0, 0],
                        voxel_size: Union[Iterable[int], Iterable[float]] = [1, 1],
                        image_dimensions: Iterable[int] = [100, 100],
                        padding_value: float = 0,
                        output_image: idt.ImageType = None) -> idt.ImageType

This function returns outputImage.

    // Function prototype.
    public static IOLink.ImageView
    ResampleElastic2d( IOLink.ImageView inputImage,
                       IOLink.ImageView inputDisplacementField,
                       ResampleElastic2d.ExtrapolationType extrapolationType = ImageDev.ResampleElastic2d.ExtrapolationType.PADDING_VALUE,
                       ResampleElastic2d.InterpolationType interpolationType = ImageDev.ResampleElastic2d.InterpolationType.LINEAR,
                       double[] origin = null,
                       double[] voxelSize = null,
                       uint[] imageDimensions = null,
                       double paddingValue = 0,
                       IOLink.ImageView outputImage = null );

##
Class Syntax

    // Command constructor.
    ResampleElastic2d();

    /// Gets the inputImage parameter.
    /// The grayscale input image to resample. It can have integer or floating point data type and several spectral channels.
    std::shared_ptr< iolink::ImageView > inputImage() const;
    /// Sets the inputImage parameter.
    /// The grayscale input image to resample. It can have integer or floating point data type and several spectral channels.
    void setInputImage( std::shared_ptr< iolink::ImageView > inputImage );

    /// Gets the inputDisplacementField parameter.
    /// The displacement field mapping the output pixels to the input pixels. It must have exactly two channels and 32-bit float data type. Each pixel of this image image contains two values: a displacement in the X direction (first channel) and one in the Y direction (second channel).
    std::shared_ptr< iolink::ImageView > inputDisplacementField() const;
    /// Sets the inputDisplacementField parameter.
    /// The displacement field mapping the output pixels to the input pixels. It must have exactly two channels and 32-bit float data type. Each pixel of this image image contains two values: a displacement in the X direction (first channel) and one in the Y direction (second channel).
    void setInputDisplacementField( std::shared_ptr< iolink::ImageView > inputDisplacementField );

    /// Gets the extrapolationType parameter.
    /// The type of extrapolation used to fill areas with no antecedent in the input image.
    ResampleElastic2d::ExtrapolationType extrapolationType() const;
    /// Sets the extrapolationType parameter.
    /// The type of extrapolation used to fill areas with no antecedent in the input image.
    void setExtrapolationType( const ResampleElastic2d::ExtrapolationType& extrapolationType );

    /// Gets the interpolationType parameter.
    /// The type of interpolation used.
    ResampleElastic2d::InterpolationType interpolationType() const;
    /// Sets the interpolationType parameter.
    /// The type of interpolation used.
    void setInterpolationType( const ResampleElastic2d::InterpolationType& interpolationType );

    /// Gets the origin parameter.
    /// The origin of the output image, in world coordinates.
    iolink::Vector2d origin() const;
    /// Sets the origin parameter.
    /// The origin of the output image, in world coordinates.
    void setOrigin( const iolink::Vector2d& origin );

    /// Gets the voxelSize parameter.
    /// The pixel size in world coordinates for the X and Y directions of the output image.
    iolink::Vector2d voxelSize() const;
    /// Sets the voxelSize parameter.
    /// The pixel size in world coordinates for the X and Y directions of the output image.
    void setVoxelSize( const iolink::Vector2d& voxelSize );

    /// Gets the imageDimensions parameter.
    /// The size in pixels of the output image in the X and Y directions.
    iolink::Vector2u32 imageDimensions() const;
    /// Sets the imageDimensions parameter.
    /// The size in pixels of the output image in the X and Y directions.
    void setImageDimensions( const iolink::Vector2u32& imageDimensions );

    /// Gets the paddingValue parameter.
    /// The padding value used to fill areas with no antecedent in the input image. This parameter is ignored if extrapolation type is not set to PADDING_VALUE.
    double paddingValue() const;
    /// Sets the paddingValue parameter.
    /// The padding value used to fill areas with no antecedent in the input image. This parameter is ignored if extrapolation type is not set to PADDING_VALUE.
    void setPaddingValue( const double& paddingValue );

    /// Gets the outputImage parameter.
    /// The resampled output image. Its resolution and bounding box are defined by the origin, voxelSize, and imageDimensions parameters. Its type is forced to floating point precision (32-bit).
    std::shared_ptr< iolink::ImageView > outputImage() const;
    /// Sets the outputImage parameter.
    /// The resampled output image. Its resolution and bounding box are defined by the origin, voxelSize, and imageDimensions parameters. Its type is forced to floating point precision (32-bit).
    void setOutputImage( std::shared_ptr< iolink::ImageView > outputImage );

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

    # Property of the inputImage parameter.
    ResampleElastic2d.input_image
    # Property of the inputDisplacementField parameter.
    ResampleElastic2d.input_displacement_field
    # Property of the extrapolationType parameter.
    ResampleElastic2d.extrapolation_type
    # Property of the interpolationType parameter.
    ResampleElastic2d.interpolation_type
    # Property of the origin parameter.
    ResampleElastic2d.origin
    # Property of the voxelSize parameter.
    ResampleElastic2d.voxel_size
    # Property of the imageDimensions parameter.
    ResampleElastic2d.image_dimensions
    # Property of the paddingValue parameter.
    ResampleElastic2d.padding_value
    # Property of the outputImage parameter.
    ResampleElastic2d.output_image

    // Method to launch the command.
    execute()

    // Command constructor.
    ResampleElastic2d()

    // Property of the inputImage parameter.
    ResampleElastic2d.inputImage
    // Property of the inputDisplacementField parameter.
    ResampleElastic2d.inputDisplacementField
    // Property of the extrapolationType parameter.
    ResampleElastic2d.extrapolationType
    // Property of the interpolationType parameter.
    ResampleElastic2d.interpolationType
    // Property of the origin parameter.
    ResampleElastic2d.origin
    // Property of the voxelSize parameter.
    ResampleElastic2d.voxelSize
    // Property of the imageDimensions parameter.
    ResampleElastic2d.imageDimensions
    // Property of the paddingValue parameter.
    ResampleElastic2d.paddingValue
    // Property of the outputImage parameter.
    ResampleElastic2d.outputImage

    // Method to launch the command.
    Execute()

## Parameters

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| inputImage | The grayscale input image to resample. It can have integer or floating point data type and several spectral channels. | Image | Grayscale | nullptr
| inputDisplacementField | The displacement field mapping the output pixels to the input pixels. It must have exactly two channels and 32-bit float data type. Each pixel of this image image contains two values: a displacement in the X direction (first channel) and one in the Y direction (second channel). | Image | Multispectral | nullptr
| extrapolationType | The type of extrapolation used to fill areas with no antecedent in the input image.
PADDING_VALUE | A constant value is used for extrapolation.
NEAREST_VALUE | The value of the nearest point is used for extrapolation.
| Enumeration |  | PADDING_VALUE
| interpolationType | The type of interpolation used.
NEAREST_NEIGHBOR | The value of the intensity is linearly interpolated in all directions.
LINEAR | The value of the intensity is equal to the nearest intensity.
| Enumeration |  | LINEAR
| origin | The origin of the output image, in world coordinates. | Vector2d | Any value | {0.f, 0.f}
| voxelSize | The pixel size in world coordinates for the X and Y directions of the output image. | Vector2d | >0 | {1.f, 1.f}
| imageDimensions | The size in pixels of the output image in the X and Y directions. | Vector2u32 | != 0 | {100, 100}
| paddingValue | The padding value used to fill areas with no antecedent in the input image. This parameter is ignored if extrapolation type is not set to PADDING_VALUE. | Float64 | Any value | 0
| outputImage | The resampled output image. Its resolution and bounding box are defined by the origin, voxelSize, and imageDimensions parameters. Its type is forced to floating point precision (32-bit). | Image |  | nullptr

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| input_image | The grayscale input image to resample. It can have integer or floating point data type and several spectral channels. | image | Grayscale | None
| input_displacement_field | The displacement field mapping the output pixels to the input pixels. It must have exactly two channels and 32-bit float data type. Each pixel of this image image contains two values: a displacement in the X direction (first channel) and one in the Y direction (second channel). | image | Multispectral | None
| extrapolation_type | The type of extrapolation used to fill areas with no antecedent in the input image.
PADDING_VALUE | A constant value is used for extrapolation.
NEAREST_VALUE | The value of the nearest point is used for extrapolation.
| enumeration |  | PADDING_VALUE
| interpolation_type | The type of interpolation used.
NEAREST_NEIGHBOR | The value of the intensity is linearly interpolated in all directions.
LINEAR | The value of the intensity is equal to the nearest intensity.
| enumeration |  | LINEAR
| origin | The origin of the output image, in world coordinates. | vector2d | Any value | [0, 0]
| voxel_size | The pixel size in world coordinates for the X and Y directions of the output image. | vector2d | >0 | [1, 1]
| image_dimensions | The size in pixels of the output image in the X and Y directions. | vector2u32 | != 0 | [100, 100]
| padding_value | The padding value used to fill areas with no antecedent in the input image. This parameter is ignored if extrapolation type is not set to PADDING_VALUE. | float64 | Any value | 0
| output_image | The resampled output image. Its resolution and bounding box are defined by the origin, voxelSize, and imageDimensions parameters. Its type is forced to floating point precision (32-bit). | image |  | None

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| inputImage | The grayscale input image to resample. It can have integer or floating point data type and several spectral channels. | Image | Grayscale | null
| inputDisplacementField | The displacement field mapping the output pixels to the input pixels. It must have exactly two channels and 32-bit float data type. Each pixel of this image image contains two values: a displacement in the X direction (first channel) and one in the Y direction (second channel). | Image | Multispectral | null
| extrapolationType | The type of extrapolation used to fill areas with no antecedent in the input image.
PADDING_VALUE | A constant value is used for extrapolation.
NEAREST_VALUE | The value of the nearest point is used for extrapolation.
| Enumeration |  | PADDING_VALUE
| interpolationType | The type of interpolation used.
NEAREST_NEIGHBOR | The value of the intensity is linearly interpolated in all directions.
LINEAR | The value of the intensity is equal to the nearest intensity.
| Enumeration |  | LINEAR
| origin | The origin of the output image, in world coordinates. | Vector2d | Any value | {0f, 0f}
| voxelSize | The pixel size in world coordinates for the X and Y directions of the output image. | Vector2d | >0 | {1f, 1f}
| imageDimensions | The size in pixels of the output image in the X and Y directions. | Vector2u32 | != 0 | {100, 100}
| paddingValue | The padding value used to fill areas with no antecedent in the input image. This parameter is ignored if extrapolation type is not set to PADDING_VALUE. | Float64 | Any value | 0
| outputImage | The resampled output image. Its resolution and bounding box are defined by the origin, voxelSize, and imageDimensions parameters. Its type is forced to floating point precision (32-bit). | Image |  | null

## Object Examples

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

    ResampleElastic2d resampleElastic2dAlgo;
    resampleElastic2dAlgo.setInputImage( retina );
    resampleElastic2dAlgo.setInputDisplacementField( retina_eigenvalues );
    resampleElastic2dAlgo.setExtrapolationType( ResampleElastic2d::ExtrapolationType::PADDING_VALUE );
    resampleElastic2dAlgo.setInterpolationType( ResampleElastic2d::InterpolationType::LINEAR );
    resampleElastic2dAlgo.setOrigin( {0.0, 0.0} );
    resampleElastic2dAlgo.setVoxelSize( {1.0, 1.0} );
    resampleElastic2dAlgo.setImageDimensions( {100, 100} );
    resampleElastic2dAlgo.setPaddingValue( 0 );
    resampleElastic2dAlgo.execute();

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

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

    resample_elastic_2d_algo = imagedev.ResampleElastic2d()
    resample_elastic_2d_algo.input_image = retina
    resample_elastic_2d_algo.input_displacement_field = retina_eigenvalues
    resample_elastic_2d_algo.extrapolation_type = imagedev.ResampleElastic2d.PADDING_VALUE
    resample_elastic_2d_algo.interpolation_type = imagedev.ResampleElastic2d.LINEAR
    resample_elastic_2d_algo.origin = [0.0, 0.0]
    resample_elastic_2d_algo.voxel_size = [1.0, 1.0]
    resample_elastic_2d_algo.image_dimensions = [100, 100]
    resample_elastic_2d_algo.padding_value = 0
    resample_elastic_2d_algo.execute()

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

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

    ResampleElastic2d resampleElastic2dAlgo = new ResampleElastic2d
    {
        inputImage = retina,
        inputDisplacementField = retina_eigenvalues,
        extrapolationType = ResampleElastic2d.ExtrapolationType.PADDING_VALUE,
        interpolationType = ResampleElastic2d.InterpolationType.LINEAR,
        origin = new double[]{0.0, 0.0},
        voxelSize = new double[]{1.0, 1.0},
        imageDimensions = new uint[]{100, 100},
        paddingValue = 0
    };
    resampleElastic2dAlgo.Execute();

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

## Function Examples

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

    auto result = resampleElastic2d( retina, retina_eigenvalues, ResampleElastic2d::ExtrapolationType::PADDING_VALUE, ResampleElastic2d::InterpolationType::LINEAR, {0.0, 0.0}, {1.0, 1.0}, {100, 100}, 0 );

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

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

    result = imagedev.resample_elastic_2d(retina, retina_eigenvalues, imagedev.ResampleElastic2d.PADDING_VALUE, imagedev.ResampleElastic2d.LINEAR, [0.0, 0.0], [1.0, 1.0], [100, 100], 0)

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

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

    IOLink.ImageView result = Processing.ResampleElastic2d( retina, retina_eigenvalues, ResampleElastic2d.ExtrapolationType.PADDING_VALUE, ResampleElastic2d.InterpolationType.LINEAR, new double[]{0.0, 0.0}, new double[]{1.0, 1.0}, new uint[]{100, 100}, 0 );

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

© 2025 Thermo Fisher Scientific Inc. All rights reserved.