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

# ResampleAffine2d

Resamples a two-dimensional image by defining an oriented bounding box and a geometric transform.
Access to parameter description
This algorithm allows the resampling of an input image onto a user-defined image domain, and optionally apply a geometric transform on it.
The output image domain is defined by a non-axis aligned bounding box (nAABB). To represent the nAABB, we use an AABB (boundingBoxMin, boundingBoxMax) and a angle (boundingBoxAngle).
An additional transformation can be applied to each output voxel position to produce the final resampled image. Each output voxel intensity is extracted from the input with a user-defined interpolation.
For example, this algorithm can be used:

- To extract a user-defined region of interest with a given pixel size (not necessary aligned with the input) from the input image.
- To generate a new image from a model image registered on reference image using the transform given by the AffineRegistration algorithm.

See also

- ResampleAffine3d

##
Function Syntax

This function returns outputImage.

    // Function prototype
    std::shared_ptr< iolink::ImageView >
    resampleAffine2d( std::shared_ptr< iolink::ImageView > inputImage,
                      ResampleAffine2d::InterpolationType interpolationType,
                      const iolink::Vector2d& boundingBoxMin,
                      const iolink::Vector2d& boundingBoxMax,
                      double boundingBoxAngle,
                      ResampleAffine2d::SamplingMode samplingMode,
                      const iolink::Vector2u32& imageDimensions,
                      double paddingValue,
                      const iolink::Matrix3d& transform,
                      std::shared_ptr< iolink::ImageView > outputImage = nullptr );

This function returns outputImage.

    // Function prototype.
    resample_affine_2d(input_image: idt.ImageType,
                       interpolation_type: ResampleAffine2d.InterpolationType = ResampleAffine2d.InterpolationType.LINEAR,
                       bounding_box_min: Union[Iterable[int], Iterable[float]] = [0, 0],
                       bounding_box_max: Union[Iterable[int], Iterable[float]] = [1, 1],
                       bounding_box_angle: float = 0,
                       sampling_mode: ResampleAffine2d.SamplingMode = ResampleAffine2d.SamplingMode.AUTOMATIC,
                       image_dimensions: Iterable[int] = [100, 100],
                       padding_value: float = 0,
                       transform: Union[idt.NDArrayAny, iolink.Matrix3d, iolink.Matrix3f] = _np.identity(3),
                       output_image: idt.ImageType = None) -> idt.ImageType

This function returns outputImage.

    // Function prototype.
    public static IOLink.ImageView
    ResampleAffine2d( IOLink.ImageView inputImage,
                      ResampleAffine2d.InterpolationType interpolationType = ImageDev.ResampleAffine2d.InterpolationType.LINEAR,
                      double[] boundingBoxMin = null,
                      double[] boundingBoxMax = null,
                      double boundingBoxAngle = 0,
                      ResampleAffine2d.SamplingMode samplingMode = ImageDev.ResampleAffine2d.SamplingMode.AUTOMATIC,
                      uint[] imageDimensions = null,
                      double paddingValue = 0,
                      IOLink.Matrix3d transform = null,
                      IOLink.ImageView outputImage = null );

##
Class Syntax

    // Command constructor.
    ResampleAffine2d();

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

    /// Gets the interpolationType parameter.
    /// The method used to calculate the intensity of each pixel in the result image.
    ResampleAffine2d::InterpolationType interpolationType() const;
    /// Sets the interpolationType parameter.
    /// The method used to calculate the intensity of each pixel in the result image.
    void setInterpolationType( const ResampleAffine2d::InterpolationType& interpolationType );

    /// Gets the boundingBoxMin parameter.
    /// The minimum X, and Y coordinates of the box that defines the image domain after a rotation, in world coordinates. The output image domain corresponds to this axis-aligned bounding box, rotated at an angle defined by the boundingBoxAngle parameter.
    iolink::Vector2d boundingBoxMin() const;
    /// Sets the boundingBoxMin parameter.
    /// The minimum X, and Y coordinates of the box that defines the image domain after a rotation, in world coordinates. The output image domain corresponds to this axis-aligned bounding box, rotated at an angle defined by the boundingBoxAngle parameter.
    void setBoundingBoxMin( const iolink::Vector2d& boundingBoxMin );

    /// Gets the boundingBoxMax parameter.
    /// The maximum X, and Y coordinates of the box that defines the image domain after a rotation, in world coordinates. The output image domain corresponds to this axis-aligned bounding box, rotated at an angle defined by the boundingBoxAngle parameter.
    iolink::Vector2d boundingBoxMax() const;
    /// Sets the boundingBoxMax parameter.
    /// The maximum X, and Y coordinates of the box that defines the image domain after a rotation, in world coordinates. The output image domain corresponds to this axis-aligned bounding box, rotated at an angle defined by the boundingBoxAngle parameter.
    void setBoundingBoxMax( const iolink::Vector2d& boundingBoxMax );

    /// Gets the boundingBoxAngle parameter.
    /// The rotation to apply to the box defined by boundingBoxMin and boundingBoxMax in order to define the domain of the output image.
    double boundingBoxAngle() const;
    /// Sets the boundingBoxAngle parameter.
    /// The rotation to apply to the box defined by boundingBoxMin and boundingBoxMax in order to define the domain of the output image.
    void setBoundingBoxAngle( const double& boundingBoxAngle );

    /// Gets the samplingMode parameter.
    /// The way to determine the resolution of the output image.
    ResampleAffine2d::SamplingMode samplingMode() const;
    /// Sets the samplingMode parameter.
    /// The way to determine the resolution of the output image.
    void setSamplingMode( const ResampleAffine2d::SamplingMode& samplingMode );

    /// Gets the imageDimensions parameter.
    /// The size in pixels of the output image in each axis direction. If the samplingMode parameter is set to AUTOMATIC, this parameter is ignored.
    iolink::Vector2u32 imageDimensions() const;
    /// Sets the imageDimensions parameter.
    /// The size in pixels of the output image in each axis direction. If the samplingMode parameter is set to AUTOMATIC, this parameter is ignored.
    void setImageDimensions( const iolink::Vector2u32& imageDimensions );

    /// Gets the paddingValue parameter.
    /// Specifies the output value if an output pixel position is outside the bounding box of the input image.
    double paddingValue() const;
    /// Sets the paddingValue parameter.
    /// Specifies the output value if an output pixel position is outside the bounding box of the input image.
    void setPaddingValue( const double& paddingValue );

    /// Gets the transform parameter.
    /// The geometric transformation applied to the input image before interpolation. It is represented by a 3x3 matrix. It is important to note that this transformation is the inverse transformation, which means that it maps a point from the output domain to the input domain.
    iolink::Matrix3d transform() const;
    /// Sets the transform parameter.
    /// The geometric transformation applied to the input image before interpolation. It is represented by a 3x3 matrix. It is important to note that this transformation is the inverse transformation, which means that it maps a point from the output domain to the input domain.
    void setTransform( const iolink::Matrix3d& transform );

    /// Gets the outputImage parameter.
    /// The output image. Its dimensions are either defined by the imageDimensions parameter, if the samplingMode parameter is MANUAL, or automatically computed to match the user-defined bounding box with a resolution close to that of the input image. Its calibration is automatically adapted. Its type and interpretation are the same as the input image.
    std::shared_ptr< iolink::ImageView > outputImage() const;
    /// Sets the outputImage parameter.
    /// The output image. Its dimensions are either defined by the imageDimensions parameter, if the samplingMode parameter is MANUAL, or automatically computed to match the user-defined bounding box with a resolution close to that of the input image. Its calibration is automatically adapted. Its type and interpretation are the same as the input image.
    void setOutputImage( std::shared_ptr< iolink::ImageView > outputImage );

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

    # Property of the inputImage parameter.
    ResampleAffine2d.input_image
    # Property of the interpolationType parameter.
    ResampleAffine2d.interpolation_type
    # Property of the boundingBoxMin parameter.
    ResampleAffine2d.bounding_box_min
    # Property of the boundingBoxMax parameter.
    ResampleAffine2d.bounding_box_max
    # Property of the boundingBoxAngle parameter.
    ResampleAffine2d.bounding_box_angle
    # Property of the samplingMode parameter.
    ResampleAffine2d.sampling_mode
    # Property of the imageDimensions parameter.
    ResampleAffine2d.image_dimensions
    # Property of the paddingValue parameter.
    ResampleAffine2d.padding_value
    # Property of the transform parameter.
    ResampleAffine2d.transform
    # Property of the outputImage parameter.
    ResampleAffine2d.output_image

    // Method to launch the command.
    execute()

    // Command constructor.
    ResampleAffine2d()

    // Property of the inputImage parameter.
    ResampleAffine2d.inputImage
    // Property of the interpolationType parameter.
    ResampleAffine2d.interpolationType
    // Property of the boundingBoxMin parameter.
    ResampleAffine2d.boundingBoxMin
    // Property of the boundingBoxMax parameter.
    ResampleAffine2d.boundingBoxMax
    // Property of the boundingBoxAngle parameter.
    ResampleAffine2d.boundingBoxAngle
    // Property of the samplingMode parameter.
    ResampleAffine2d.samplingMode
    // Property of the imageDimensions parameter.
    ResampleAffine2d.imageDimensions
    // Property of the paddingValue parameter.
    ResampleAffine2d.paddingValue
    // Property of the transform parameter.
    ResampleAffine2d.transform
    // Property of the outputImage parameter.
    ResampleAffine2d.outputImage

    // Method to launch the command.
    Execute()

## Parameters

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| inputImage | The input image to resample. It can have integer or floating point data type. | Image | Binary, Label, Grayscale or Multispectral | nullptr
| boundingBoxMin | The minimum X, and Y coordinates of the box that defines the image domain after a rotation, in world coordinates. The output image domain corresponds to this axis-aligned bounding box, rotated at an angle defined by the boundingBoxAngle parameter. | Vector2d | Any value | {0.f, 0.f}
| boundingBoxMax | The maximum X, and Y coordinates of the box that defines the image domain after a rotation, in world coordinates. The output image domain corresponds to this axis-aligned bounding box, rotated at an angle defined by the boundingBoxAngle parameter. | Vector2d | Any value | {1.f, 1.f}
| boundingBoxAngle | The rotation to apply to the box defined by boundingBoxMin and boundingBoxMax in order to define the domain of the output image. | Float64 | Any value | 0
| samplingMode | The way to determine the resolution of the output image.
AUTOMATIC | The pixel size is automatically computed to be as close as possible to that of the input image. This mode does not work if the transform is not the identity.
MANUAL | The output image dimensions are user-defined and the output pixel size is defined accordingly.
| Enumeration |  | AUTOMATIC
| imageDimensions | The size in pixels of the output image in each axis direction. If the samplingMode parameter is set to AUTOMATIC, this parameter is ignored. | Vector2u32 | != 0 | {100, 100}
| interpolationType | The method used to calculate the intensity of each pixel in the result image.
LINEAR | The value of the intensity is linearly interpolated in all directions.
NEAREST_NEIGHBOR | The value of the intensity is equal to the nearest intensity.
| Enumeration |  | LINEAR
| paddingValue | Specifies the output value if an output pixel position is outside the bounding box of the input image. | Float64 | Any value | 0
| transform | The geometric transformation applied to the input image before interpolation. It is represented by a 3x3 matrix. It is important to note that this transformation is the inverse transformation, which means that it maps a point from the output domain to the input domain. | Matrix3d |  | IDENTITY
| outputImage | The output image. Its dimensions are either defined by the imageDimensions parameter, if the samplingMode parameter is MANUAL, or automatically computed to match the user-defined bounding box with a resolution close to that of the input image. Its calibration is automatically adapted. Its type and interpretation are the same as the input image. | Image |  | nullptr

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| input_image | The input image to resample. It can have integer or floating point data type. | image | Binary, Label, Grayscale or Multispectral | None
| bounding_box_min | The minimum X, and Y coordinates of the box that defines the image domain after a rotation, in world coordinates. The output image domain corresponds to this axis-aligned bounding box, rotated at an angle defined by the boundingBoxAngle parameter. | vector2d | Any value | [0, 0]
| bounding_box_max | The maximum X, and Y coordinates of the box that defines the image domain after a rotation, in world coordinates. The output image domain corresponds to this axis-aligned bounding box, rotated at an angle defined by the boundingBoxAngle parameter. | vector2d | Any value | [1, 1]
| bounding_box_angle | The rotation to apply to the box defined by boundingBoxMin and boundingBoxMax in order to define the domain of the output image. | float64 | Any value | 0
| sampling_mode | The way to determine the resolution of the output image.
AUTOMATIC | The pixel size is automatically computed to be as close as possible to that of the input image. This mode does not work if the transform is not the identity.
MANUAL | The output image dimensions are user-defined and the output pixel size is defined accordingly.
| enumeration |  | AUTOMATIC
| image_dimensions | The size in pixels of the output image in each axis direction. If the samplingMode parameter is set to AUTOMATIC, this parameter is ignored. | vector2u32 | != 0 | [100, 100]
| interpolation_type | The method used to calculate the intensity of each pixel in the result image.
LINEAR | The value of the intensity is linearly interpolated in all directions.
NEAREST_NEIGHBOR | The value of the intensity is equal to the nearest intensity.
| enumeration |  | LINEAR
| padding_value | Specifies the output value if an output pixel position is outside the bounding box of the input image. | float64 | Any value | 0
| transform | The geometric transformation applied to the input image before interpolation. It is represented by a 3x3 matrix. It is important to note that this transformation is the inverse transformation, which means that it maps a point from the output domain to the input domain. | matrix |  | _np.identity(3)
| output_image | The output image. Its dimensions are either defined by the imageDimensions parameter, if the samplingMode parameter is MANUAL, or automatically computed to match the user-defined bounding box with a resolution close to that of the input image. Its calibration is automatically adapted. Its type and interpretation are the same as the input image. | image |  | None

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| inputImage | The input image to resample. It can have integer or floating point data type. | Image | Binary, Label, Grayscale or Multispectral | null
| boundingBoxMin | The minimum X, and Y coordinates of the box that defines the image domain after a rotation, in world coordinates. The output image domain corresponds to this axis-aligned bounding box, rotated at an angle defined by the boundingBoxAngle parameter. | Vector2d | Any value | {0f, 0f}
| boundingBoxMax | The maximum X, and Y coordinates of the box that defines the image domain after a rotation, in world coordinates. The output image domain corresponds to this axis-aligned bounding box, rotated at an angle defined by the boundingBoxAngle parameter. | Vector2d | Any value | {1f, 1f}
| boundingBoxAngle | The rotation to apply to the box defined by boundingBoxMin and boundingBoxMax in order to define the domain of the output image. | Float64 | Any value | 0
| samplingMode | The way to determine the resolution of the output image.
AUTOMATIC | The pixel size is automatically computed to be as close as possible to that of the input image. This mode does not work if the transform is not the identity.
MANUAL | The output image dimensions are user-defined and the output pixel size is defined accordingly.
| Enumeration |  | AUTOMATIC
| imageDimensions | The size in pixels of the output image in each axis direction. If the samplingMode parameter is set to AUTOMATIC, this parameter is ignored. | Vector2u32 | != 0 | {100, 100}
| interpolationType | The method used to calculate the intensity of each pixel in the result image.
LINEAR | The value of the intensity is linearly interpolated in all directions.
NEAREST_NEIGHBOR | The value of the intensity is equal to the nearest intensity.
| Enumeration |  | LINEAR
| paddingValue | Specifies the output value if an output pixel position is outside the bounding box of the input image. | Float64 | Any value | 0
| transform | The geometric transformation applied to the input image before interpolation. It is represented by a 3x3 matrix. It is important to note that this transformation is the inverse transformation, which means that it maps a point from the output domain to the input domain. | Matrix3d |  | IDENTITY
| outputImage | The output image. Its dimensions are either defined by the imageDimensions parameter, if the samplingMode parameter is MANUAL, or automatically computed to match the user-defined bounding box with a resolution close to that of the input image. Its calibration is automatically adapted. Its type and interpretation are the same as the input image. | Image |  | null

## Object Examples

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

    ResampleAffine2d resampleAffine2dAlgo;
    resampleAffine2dAlgo.setInputImage( polystyrene );
    resampleAffine2dAlgo.setInterpolationType( ResampleAffine2d::InterpolationType::LINEAR );
    resampleAffine2dAlgo.setBoundingBoxMin( {10, 15} );
    resampleAffine2dAlgo.setBoundingBoxMax( {40, 50} );
    resampleAffine2dAlgo.setBoundingBoxAngle( 0 );
    resampleAffine2dAlgo.setSamplingMode( ResampleAffine2d::SamplingMode::AUTOMATIC );
    resampleAffine2dAlgo.setImageDimensions( {100, 100} );
    resampleAffine2dAlgo.setPaddingValue( 0 );
    resampleAffine2dAlgo.setTransform( iolink::Matrix3d::identity() );
    resampleAffine2dAlgo.execute();

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

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

    resample_affine_2d_algo = imagedev.ResampleAffine2d()
    resample_affine_2d_algo.input_image = polystyrene
    resample_affine_2d_algo.interpolation_type = imagedev.ResampleAffine2d.LINEAR
    resample_affine_2d_algo.bounding_box_min = [10, 15]
    resample_affine_2d_algo.bounding_box_max = [40, 50]
    resample_affine_2d_algo.bounding_box_angle = 0
    resample_affine_2d_algo.sampling_mode = imagedev.ResampleAffine2d.AUTOMATIC
    resample_affine_2d_algo.image_dimensions = [100, 100]
    resample_affine_2d_algo.padding_value = 0
    resample_affine_2d_algo.transform = np.identity(3)
    resample_affine_2d_algo.execute()

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

    ImageView polystyrene = ViewIO.ReadImage( @"Data/images/polystyrene.tif" );
    IOLink.Matrix3d transform = IOLink.Matrix3d.Identity();

    ResampleAffine2d resampleAffine2dAlgo = new ResampleAffine2d
    {
        inputImage = polystyrene,
        interpolationType = ResampleAffine2d.InterpolationType.LINEAR,
        boundingBoxMin = new double[]{10, 15},
        boundingBoxMax = new double[]{40, 50},
        boundingBoxAngle = 0,
        samplingMode = ResampleAffine2d.SamplingMode.AUTOMATIC,
        imageDimensions = new uint[]{100, 100},
        paddingValue = 0,
        transform = transform
    };
    resampleAffine2dAlgo.Execute();

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

## Function Examples

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

    auto result = resampleAffine2d( polystyrene, ResampleAffine2d::InterpolationType::LINEAR, {10, 15}, {40, 50}, 0, ResampleAffine2d::SamplingMode::AUTOMATIC, {100, 100}, 0, iolink::Matrix3d::identity() );

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

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

    result = imagedev.resample_affine_2d(polystyrene, imagedev.ResampleAffine2d.LINEAR, [10, 15], [40, 50], 0, imagedev.ResampleAffine2d.AUTOMATIC, [100, 100], 0, np.identity(3))

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

    ImageView polystyrene = ViewIO.ReadImage( @"Data/images/polystyrene.tif" );
    IOLink.Matrix3d transform = IOLink.Matrix3d.Identity();

    IOLink.ImageView result = Processing.ResampleAffine2d( polystyrene, ResampleAffine2d.InterpolationType.LINEAR, new double[]{10, 15}, new double[]{40, 50}, 0, ResampleAffine2d.SamplingMode.AUTOMATIC, new uint[]{100, 100}, 0, transform );

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

© 2025 Thermo Fisher Scientific Inc. All rights reserved.