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

# Rotate2d

Applies a rotation of a given angle on a two-dimensional image around a given point or the center of the image.
Access to parameter description
For an introduction: section 2D Rotations.
This algorithm performs a rotation of an image by a user-defined angle $\theta$ and a center $C$.
The new coordinates $(x', y')$ can be expressed as a function of the old coordinates $(x, y)$: $$ \left\{\begin{matrix}x'&=&(x-x_0)\cdot\cos\theta - (y-y_0)\cdot\sin\theta + x_0\\ y'&=&(x-x_0)\cdot\sin\theta + (y-y_0)\cdot\cos\theta + y_0\end{matrix}\right\} $$ where $(x_0,y_0)$ are the coordinates of the center of the rotation. Or in matrix notation: $$ \begin{bmatrix}x'\\y'\end{bmatrix} = \begin{bmatrix}\cos\theta&-\sin\theta\\\sin\theta&\cos\theta\end{bmatrix} \cdot\begin{bmatrix}x-x_0\\y-y_0\end{bmatrix} + \begin{bmatrix}x_0\\y_0\end{bmatrix} $$ If the dimensions of the output image are the same as those of the input, the destination pixels may be outside the image, and these pixels are then ignored. An output resizing option automatically modifies the dimensions of the image to make all the input data visible in the output image. This option is enabled by default.
On the other hand, some pixels in the output image may not have a corresponding pixel in the input image. In this case, a user-defined padding value is assigned to these pixels.
Furthermore, the $(x, y)$ coordinates obtained are not always integers, even though an image is a discrete space. The following figure illustrates the grid of the resultant image, the point $M'$ being a pixel in this image. The points are generated from the rotation of the original image and do not fit on the grid.
Figure 1. Image grid rotation
To calculate the intensity of each pixel $M'$, two methods are possible:

- Take the gray level of the nearest neighbor. For the above example $M'$ would be given the intensity of $M'_1: g'=g'_1$
- Take into account the four nearest neighbors and calculate the gray level based on the average of the four points, weighted by their distance, as in: $$ g'=\frac{f_1\times g'_1+f_2\times g'_2+f_3\times g'_3+f_4\times g'_4}{f_1+f_2+f_3+f_4} $$

If $d_j$ denotes the distance $M'_j M'$, $f_i$ is defined as: $$ f_i=\prod_{\substack{j=1\\j\neq i}}^{j=4}d_j $$ e.g., $f_1=d_2d_3d_4$.
The choice of the $f_i$'s ensures that the interpolated value is equal to $g'_j$ if $M'$ matches $M'_j$. This method gives better results but requires more computation time.

(a) | (b) | (c)

Figure 1. Centered 30 degrees rotation of a 1024x1024 image: (a) the input image,
(b) rotation without output resizing (1024x1024 image), (c) rotation with output resizing (1398x1398 image).
See also

- TranslateImage2d
- Resize2d
- ResampleAffine2d
- Rotate3d

##
Function Syntax

This function returns outputImage.

    // Function prototype
    std::shared_ptr< iolink::ImageView >
    rotate2d( std::shared_ptr< iolink::ImageView > inputImage,
              double rotationAngle,
              Rotate2d::CenterMode centerMode,
              const iolink::Vector2d& rotationCenter,
              Rotate2d::InterpolationType interpolationType,
              bool outputResizing,
              double paddingValue,
              std::shared_ptr< iolink::ImageView > outputImage = nullptr );

This function returns outputImage.

    // Function prototype.
    rotate_2d(input_image: idt.ImageType,
              rotation_angle: float = 90,
              center_mode: Rotate2d.CenterMode = Rotate2d.CenterMode.IMAGE_CENTER,
              rotation_center: Union[Iterable[int], Iterable[float]] = [0, 0],
              interpolation_type: Rotate2d.InterpolationType = Rotate2d.InterpolationType.NEAREST_NEIGHBOR,
              output_resizing: bool = True,
              padding_value: float = 0,
              output_image: idt.ImageType = None) -> idt.ImageType

This function returns outputImage.

    // Function prototype.
    public static IOLink.ImageView
    Rotate2d( IOLink.ImageView inputImage,
              double rotationAngle = 90,
              Rotate2d.CenterMode centerMode = ImageDev.Rotate2d.CenterMode.IMAGE_CENTER,
              double[] rotationCenter = null,
              Rotate2d.InterpolationType interpolationType = ImageDev.Rotate2d.InterpolationType.NEAREST_NEIGHBOR,
              bool outputResizing = true,
              double paddingValue = 0,
              IOLink.ImageView outputImage = null );

##
Class Syntax

    // Command constructor.
    Rotate2d();

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

    /// Gets the rotationAngle parameter.
    /// The angle of the rotation in degrees.
    double rotationAngle() const;
    /// Sets the rotationAngle parameter.
    /// The angle of the rotation in degrees.
    void setRotationAngle( const double& rotationAngle );

    /// Gets the centerMode parameter.
    /// The way to define the rotation center
    Rotate2d::CenterMode centerMode() const;
    /// Sets the centerMode parameter.
    /// The way to define the rotation center
    void setCenterMode( const Rotate2d::CenterMode& centerMode );

    /// Gets the rotationCenter parameter.
    /// The rotation center coordinates. This parameter is ignored in IMAGE_CENTER mode.
    iolink::Vector2d rotationCenter() const;
    /// Sets the rotationCenter parameter.
    /// The rotation center coordinates. This parameter is ignored in IMAGE_CENTER mode.
    void setRotationCenter( const iolink::Vector2d& rotationCenter );

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

    /// Gets the outputResizing parameter.
    /// The output shape policy. If set to True, the output image is resized to ensure that all input data is visible. Otherwise, the output shape remains the same as the input shape.
    bool outputResizing() const;
    /// Sets the outputResizing parameter.
    /// The output shape policy. If set to True, the output image is resized to ensure that all input data is visible. Otherwise, the output shape remains the same as the input shape.
    void setOutputResizing( const bool& outputResizing );

    /// Gets the paddingValue parameter.
    /// The background value for output voxels which are outside the input image domain.
    double paddingValue() const;
    /// Sets the paddingValue parameter.
    /// The background value for output voxels which are outside the input image domain.
    void setPaddingValue( const double& paddingValue );

    /// Gets the outputImage parameter.
    /// The output image. Its type is forced to the same values as the input. Its dimensions are identical to or greater than the input image, according to the outputResizing parameter.
    std::shared_ptr< iolink::ImageView > outputImage() const;
    /// Sets the outputImage parameter.
    /// The output image. Its type is forced to the same values as the input. Its dimensions are identical to or greater than the input image, according to the outputResizing parameter.
    void setOutputImage( std::shared_ptr< iolink::ImageView > outputImage );

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

    # Property of the inputImage parameter.
    Rotate2d.input_image
    # Property of the rotationAngle parameter.
    Rotate2d.rotation_angle
    # Property of the centerMode parameter.
    Rotate2d.center_mode
    # Property of the rotationCenter parameter.
    Rotate2d.rotation_center
    # Property of the interpolationType parameter.
    Rotate2d.interpolation_type
    # Property of the outputResizing parameter.
    Rotate2d.output_resizing
    # Property of the paddingValue parameter.
    Rotate2d.padding_value
    # Property of the outputImage parameter.
    Rotate2d.output_image

    // Method to launch the command.
    execute()

    // Command constructor.
    Rotate2d()

    // Property of the inputImage parameter.
    Rotate2d.inputImage
    // Property of the rotationAngle parameter.
    Rotate2d.rotationAngle
    // Property of the centerMode parameter.
    Rotate2d.centerMode
    // Property of the rotationCenter parameter.
    Rotate2d.rotationCenter
    // Property of the interpolationType parameter.
    Rotate2d.interpolationType
    // Property of the outputResizing parameter.
    Rotate2d.outputResizing
    // Property of the paddingValue parameter.
    Rotate2d.paddingValue
    // Property of the outputImage parameter.
    Rotate2d.outputImage

    // Method to launch the command.
    Execute()

## Parameters

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| inputImage | The input image. | Image | Binary, Label, Grayscale or Multispectral | nullptr
| rotationAngle | The angle of the rotation in degrees. | Float64 | Any value | 90
| centerMode | The way to define the rotation center
IMAGE_CENTER | The rotation center is the center of the input image.
OTHER | The rotation center is user-defined. It can be set with the rotationCenter parameter.
| Enumeration |  | IMAGE_CENTER
| rotationCenter | The rotation center coordinates. This parameter is ignored in IMAGE_CENTER mode. | Vector2d | Any value | {0.f, 0.f}
| interpolationType | The interpolation mode. Method used to calculate the intensity of each pixel in the result image.
NEAREST_NEIGHBOR | Assign the gray level of the nearest pixel.
LINEAR | Assign the bilinear interpolation from the four nearest pixels.
| Enumeration |  | NEAREST_NEIGHBOR
| outputResizing | The output shape policy. If set to True, the output image is resized to ensure that all input data is visible. Otherwise, the output shape remains the same as the input shape. | Bool |  | true
| paddingValue | The background value for output voxels which are outside the input image domain. | Float64 | Any value | 0
| outputImage | The output image. Its type is forced to the same values as the input. Its dimensions are identical to or greater than the input image, according to the outputResizing parameter. | Image |  | nullptr

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| input_image | The input image. | image | Binary, Label, Grayscale or Multispectral | None
| rotation_angle | The angle of the rotation in degrees. | float64 | Any value | 90
| center_mode | The way to define the rotation center
IMAGE_CENTER | The rotation center is the center of the input image.
OTHER | The rotation center is user-defined. It can be set with the rotationCenter parameter.
| enumeration |  | IMAGE_CENTER
| rotation_center | The rotation center coordinates. This parameter is ignored in IMAGE_CENTER mode. | vector2d | Any value | [0, 0]
| interpolation_type | The interpolation mode. Method used to calculate the intensity of each pixel in the result image.
NEAREST_NEIGHBOR | Assign the gray level of the nearest pixel.
LINEAR | Assign the bilinear interpolation from the four nearest pixels.
| enumeration |  | NEAREST_NEIGHBOR
| output_resizing | The output shape policy. If set to True, the output image is resized to ensure that all input data is visible. Otherwise, the output shape remains the same as the input shape. | bool |  | True
| padding_value | The background value for output voxels which are outside the input image domain. | float64 | Any value | 0
| output_image | The output image. Its type is forced to the same values as the input. Its dimensions are identical to or greater than the input image, according to the outputResizing parameter. | image |  | None

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| inputImage | The input image. | Image | Binary, Label, Grayscale or Multispectral | null
| rotationAngle | The angle of the rotation in degrees. | Float64 | Any value | 90
| centerMode | The way to define the rotation center
IMAGE_CENTER | The rotation center is the center of the input image.
OTHER | The rotation center is user-defined. It can be set with the rotationCenter parameter.
| Enumeration |  | IMAGE_CENTER
| rotationCenter | The rotation center coordinates. This parameter is ignored in IMAGE_CENTER mode. | Vector2d | Any value | {0f, 0f}
| interpolationType | The interpolation mode. Method used to calculate the intensity of each pixel in the result image.
NEAREST_NEIGHBOR | Assign the gray level of the nearest pixel.
LINEAR | Assign the bilinear interpolation from the four nearest pixels.
| Enumeration |  | NEAREST_NEIGHBOR
| outputResizing | The output shape policy. If set to True, the output image is resized to ensure that all input data is visible. Otherwise, the output shape remains the same as the input shape. | Bool |  | true
| paddingValue | The background value for output voxels which are outside the input image domain. | Float64 | Any value | 0
| outputImage | The output image. Its type is forced to the same values as the input. Its dimensions are identical to or greater than the input image, according to the outputResizing parameter. | Image |  | null

## Object Examples

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

    Rotate2d rotate2dAlgo;
    rotate2dAlgo.setInputImage( polystyrene );
    rotate2dAlgo.setRotationAngle( 40.5 );
    rotate2dAlgo.setCenterMode( Rotate2d::CenterMode::IMAGE_CENTER );
    rotate2dAlgo.setRotationCenter( {15.5, 32} );
    rotate2dAlgo.setInterpolationType( Rotate2d::InterpolationType::NEAREST_NEIGHBOR );
    rotate2dAlgo.setOutputResizing( true );
    rotate2dAlgo.setPaddingValue( 0 );
    rotate2dAlgo.execute();

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

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

    rotate_2d_algo = imagedev.Rotate2d()
    rotate_2d_algo.input_image = polystyrene
    rotate_2d_algo.rotation_angle = 40.5
    rotate_2d_algo.center_mode = imagedev.Rotate2d.IMAGE_CENTER
    rotate_2d_algo.rotation_center = [15.5, 32]
    rotate_2d_algo.interpolation_type = imagedev.Rotate2d.NEAREST_NEIGHBOR
    rotate_2d_algo.output_resizing = True
    rotate_2d_algo.padding_value = 0
    rotate_2d_algo.execute()

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

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

    Rotate2d rotate2dAlgo = new Rotate2d
    {
        inputImage = polystyrene,
        rotationAngle = 40.5,
        centerMode = Rotate2d.CenterMode.IMAGE_CENTER,
        rotationCenter = new double[]{15.5, 32},
        interpolationType = Rotate2d.InterpolationType.NEAREST_NEIGHBOR,
        outputResizing = true,
        paddingValue = 0
    };
    rotate2dAlgo.Execute();

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

## Function Examples

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

    auto result = rotate2d( polystyrene, 40.5, Rotate2d::CenterMode::IMAGE_CENTER, {15.5, 32}, Rotate2d::InterpolationType::NEAREST_NEIGHBOR, true, 0 );

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

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

    result = imagedev.rotate_2d(polystyrene, 40.5, imagedev.Rotate2d.IMAGE_CENTER, [15.5, 32], imagedev.Rotate2d.NEAREST_NEIGHBOR, True, 0)

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

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

    IOLink.ImageView result = Processing.Rotate2d( polystyrene, 40.5, Rotate2d.CenterMode.IMAGE_CENTER, new double[]{15.5, 32}, Rotate2d.InterpolationType.NEAREST_NEIGHBOR, true, 0 );

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

© 2025 Thermo Fisher Scientific Inc. All rights reserved.