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

# StackRescaleIntensity

Performs a linear scaling of the gray level values of each slice of an image stack.
Access to parameter description
This algorithm performs a linear scaling of the gray level values of each slice of an image stack to a user-specified interval. The linear scaling can be performed either using intensity intervals (scalingMode NORMALIZATION) or an average and a standard deviation (scalingMode STANDARDIZATION).

### Scaling mode NORMALIZATION

In Figure 1, the input gray levels of interest are in the user-specified interval [a, b], and the output range is the interval [c, d].
Figure 1. The intensity rescaling transformation by normalization
The input image is I, and the output image is O. Let [a, b] be the input range and [c, d] the output range, then:
$$ \begin{array}{ll} O(n,m)=c & ~\mbox{if $I(n,m) \leq a$}\\ O(n,m)=\left(\frac{d-c}{b-a}\right)(I(n,m)-a)+c & ~\mbox{if $a < I(n,m) \leq b$}\\ O(n,m)=d & ~\mbox{if $I(n,m) > b$}\end{array} $$

### Scaling mode STANDARDIZATION

The aim of intensity rescaling by standardization is to recenter the intensities of an image around a new mean while maintaining a defined standard deviation. In Figure 2, the red curve represents the histogram of an input image, while the blue curve represents the result of scaling with a higher mean and a smaller standard deviation.
Figure 2. Histogram of an image before and after a rescale by standardization
The formula used to compute the intensity of the output image is:
$$ O(n,m) = \left[\left(\frac{I(n,m)-\mu_I}{\sigma_I}\right)\sigma_O\right]+\mu_O $$ where:

- I is the input image
- O is the standardized image
- $ \mu_I $ is the mean of the input image inside the input range.
- $ \sigma_I $ is the standard deviation of the input image inside the input range.
- $ \mu_O $ is the expected mean for the output image.
- $ \sigma_O $ is the expected standard deviation for the output image.

The type of the output image is set by an enumerate as detailed in the Data Type Management section.
See also

- RescaleIntensity
- MatchContrast
- ApplyGrayscaleLut
- Logarithm

##
Function Syntax

This function returns outputImage.

    // Function prototype
    std::shared_ptr< iolink::ImageView >
    stackRescaleIntensity( std::shared_ptr< iolink::ImageView > inputImage,
                           StackRescaleIntensity::ScalingMode scalingMode,
                           StackRescaleIntensity::RangeMode inputRangeMode,
                           const iolink::Vector2d& percentageInputRange,
                           const iolink::Vector2d& intensityInputRange,
                           StackRescaleIntensity::ScalingScope scalingScope,
                           StackRescaleIntensity::RangeMode outputRangeMode,
                           const iolink::Vector2d& percentageOutputRange,
                           const iolink::Vector2d& intensityOutputRange,
                           const iolink::Vector2d& intensityOutputStatistics,
                           StackRescaleIntensity::OutputType outputType,
                           std::shared_ptr< iolink::ImageView > outputImage = nullptr );

This function returns outputImage.

    // Function prototype.
    stack_rescale_intensity(input_image: idt.ImageType,
                            scaling_mode: StackRescaleIntensity.ScalingMode = StackRescaleIntensity.ScalingMode.STANDARDIZATION,
                            input_range_mode: StackRescaleIntensity.RangeMode = StackRescaleIntensity.RangeMode.MIN_MAX,
                            percentage_input_range: Union[Iterable[int], Iterable[float]] = [2, 98],
                            intensity_input_range: Union[Iterable[int], Iterable[float]] = [0, 255],
                            scaling_scope: StackRescaleIntensity.ScalingScope = StackRescaleIntensity.ScalingScope.GLOBAL,
                            output_range_mode: StackRescaleIntensity.RangeMode = StackRescaleIntensity.RangeMode.MIN_MAX,
                            percentage_output_range: Union[Iterable[int], Iterable[float]] = [2, 98],
                            intensity_output_range: Union[Iterable[int], Iterable[float]] = [0, 255],
                            intensity_output_statistics: Union[Iterable[int], Iterable[float]] = [0, 1],
                            output_type: StackRescaleIntensity.OutputType = StackRescaleIntensity.OutputType.SAME_AS_INPUT,
                            output_image: idt.ImageType = None) -> idt.ImageType

This function returns outputImage.

    // Function prototype.
    public static IOLink.ImageView
    StackRescaleIntensity( IOLink.ImageView inputImage,
                           StackRescaleIntensity.ScalingMode scalingMode = ImageDev.StackRescaleIntensity.ScalingMode.STANDARDIZATION,
                           StackRescaleIntensity.RangeMode inputRangeMode = ImageDev.StackRescaleIntensity.RangeMode.MIN_MAX,
                           double[] percentageInputRange = null,
                           double[] intensityInputRange = null,
                           StackRescaleIntensity.ScalingScope scalingScope = ImageDev.StackRescaleIntensity.ScalingScope.GLOBAL,
                           StackRescaleIntensity.RangeMode outputRangeMode = ImageDev.StackRescaleIntensity.RangeMode.MIN_MAX,
                           double[] percentageOutputRange = null,
                           double[] intensityOutputRange = null,
                           double[] intensityOutputStatistics = null,
                           StackRescaleIntensity.OutputType outputType = ImageDev.StackRescaleIntensity.OutputType.SAME_AS_INPUT,
                           IOLink.ImageView outputImage = null );

##
Class Syntax

    // Command constructor.
    StackRescaleIntensity();

    /// Gets the inputImage parameter.
    /// The input image stack to normalize. If the input is a 3D volume, it will be considered as a stack of XY images.
    std::shared_ptr< iolink::ImageView > inputImage() const;
    /// Sets the inputImage parameter.
    /// The input image stack to normalize. If the input is a 3D volume, it will be considered as a stack of XY images.
    void setInputImage( std::shared_ptr< iolink::ImageView > inputImage );

    /// Gets the scalingMode parameter.
    /// The type of rescaling to apply on each slice.
    StackRescaleIntensity::ScalingMode scalingMode() const;
    /// Sets the scalingMode parameter.
    /// The type of rescaling to apply on each slice.
    void setScalingMode( const StackRescaleIntensity::ScalingMode& scalingMode );

    /// Gets the inputRangeMode parameter.
    /// The way to define the input intensity range, applied on each slice of the stack.
    StackRescaleIntensity::RangeMode inputRangeMode() const;
    /// Sets the inputRangeMode parameter.
    /// The way to define the input intensity range, applied on each slice of the stack.
    void setInputRangeMode( const StackRescaleIntensity::RangeMode& inputRangeMode );

    /// Gets the percentageInputRange parameter.
    /// The low and high histogram percentile to use when the input range mode is set to PERCENTILE (in percent). This parameter is ignored with other input range modes.
    iolink::Vector2d percentageInputRange() const;
    /// Sets the percentageInputRange parameter.
    /// The low and high histogram percentile to use when the input range mode is set to PERCENTILE (in percent). This parameter is ignored with other input range modes.
    void setPercentageInputRange( const iolink::Vector2d& percentageInputRange );

    /// Gets the intensityInputRange parameter.
    /// The input intensity range [a, b] to use when the input range mode is set to OTHER. This parameter is ignored with other input range modes.
    iolink::Vector2d intensityInputRange() const;
    /// Sets the intensityInputRange parameter.
    /// The input intensity range [a, b] to use when the input range mode is set to OTHER. This parameter is ignored with other input range modes.
    void setIntensityInputRange( const iolink::Vector2d& intensityInputRange );

    /// Gets the scalingScope parameter.
    /// The scope for computing the output parameters (mean, standard deviation, percentiles, minimum or maximum).
    StackRescaleIntensity::ScalingScope scalingScope() const;
    /// Sets the scalingScope parameter.
    /// The scope for computing the output parameters (mean, standard deviation, percentiles, minimum or maximum).
    void setScalingScope( const StackRescaleIntensity::ScalingScope& scalingScope );

    /// Gets the outputRangeMode parameter.
    /// The way to define the destination intensity range.
    StackRescaleIntensity::RangeMode outputRangeMode() const;
    /// Sets the outputRangeMode parameter.
    /// The way to define the destination intensity range.
    void setOutputRangeMode( const StackRescaleIntensity::RangeMode& outputRangeMode );

    /// Gets the percentageOutputRange parameter.
    /// The low and high histogram percentile to use when the output range mode is set to PERCENTILE (in percent). This parameter is ignored with other output range modes.
    iolink::Vector2d percentageOutputRange() const;
    /// Sets the percentageOutputRange parameter.
    /// The low and high histogram percentile to use when the output range mode is set to PERCENTILE (in percent). This parameter is ignored with other output range modes.
    void setPercentageOutputRange( const iolink::Vector2d& percentageOutputRange );

    /// Gets the intensityOutputRange parameter.
    /// The output minimum and maximum values used in normalization mode. This parameter is disabled in standardization mode and is only enabled if outputRangeMode is set to OTHER.
    iolink::Vector2d intensityOutputRange() const;
    /// Sets the intensityOutputRange parameter.
    /// The output minimum and maximum values used in normalization mode. This parameter is disabled in standardization mode and is only enabled if outputRangeMode is set to OTHER.
    void setIntensityOutputRange( const iolink::Vector2d& intensityOutputRange );

    /// Gets the intensityOutputStatistics parameter.
    /// The mean and standard deviation values used in standardization mode. This parameter is disabled in normalization mode and is only enabled if outputRangeMode is set to OTHER.
    iolink::Vector2d intensityOutputStatistics() const;
    /// Sets the intensityOutputStatistics parameter.
    /// The mean and standard deviation values used in standardization mode. This parameter is disabled in normalization mode and is only enabled if outputRangeMode is set to OTHER.
    void setIntensityOutputStatistics( const iolink::Vector2d& intensityOutputStatistics );

    /// Gets the outputType parameter.
    /// The output image data type.
    StackRescaleIntensity::OutputType outputType() const;
    /// Sets the outputType parameter.
    /// The output image data type.
    void setOutputType( const StackRescaleIntensity::OutputType& outputType );

    /// Gets the outputImage parameter.
    /// The output image. Its dimensions are forced to the same values as the input. Its data type is user-defined.
    std::shared_ptr< iolink::ImageView > outputImage() const;
    /// Sets the outputImage parameter.
    /// The output image. Its dimensions are forced to the same values as the input. Its data type is user-defined.
    void setOutputImage( std::shared_ptr< iolink::ImageView > outputImage );

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

    # Property of the inputImage parameter.
    StackRescaleIntensity.input_image
    # Property of the scalingMode parameter.
    StackRescaleIntensity.scaling_mode
    # Property of the inputRangeMode parameter.
    StackRescaleIntensity.input_range_mode
    # Property of the percentageInputRange parameter.
    StackRescaleIntensity.percentage_input_range
    # Property of the intensityInputRange parameter.
    StackRescaleIntensity.intensity_input_range
    # Property of the scalingScope parameter.
    StackRescaleIntensity.scaling_scope
    # Property of the outputRangeMode parameter.
    StackRescaleIntensity.output_range_mode
    # Property of the percentageOutputRange parameter.
    StackRescaleIntensity.percentage_output_range
    # Property of the intensityOutputRange parameter.
    StackRescaleIntensity.intensity_output_range
    # Property of the intensityOutputStatistics parameter.
    StackRescaleIntensity.intensity_output_statistics
    # Property of the outputType parameter.
    StackRescaleIntensity.output_type
    # Property of the outputImage parameter.
    StackRescaleIntensity.output_image

    // Method to launch the command.
    execute()

    // Command constructor.
    StackRescaleIntensity()

    // Property of the inputImage parameter.
    StackRescaleIntensity.inputImage
    // Property of the scalingMode parameter.
    StackRescaleIntensity.scalingMode
    // Property of the inputRangeMode parameter.
    StackRescaleIntensity.inputRangeMode
    // Property of the percentageInputRange parameter.
    StackRescaleIntensity.percentageInputRange
    // Property of the intensityInputRange parameter.
    StackRescaleIntensity.intensityInputRange
    // Property of the scalingScope parameter.
    StackRescaleIntensity.scalingScope
    // Property of the outputRangeMode parameter.
    StackRescaleIntensity.outputRangeMode
    // Property of the percentageOutputRange parameter.
    StackRescaleIntensity.percentageOutputRange
    // Property of the intensityOutputRange parameter.
    StackRescaleIntensity.intensityOutputRange
    // Property of the intensityOutputStatistics parameter.
    StackRescaleIntensity.intensityOutputStatistics
    // Property of the outputType parameter.
    StackRescaleIntensity.outputType
    // Property of the outputImage parameter.
    StackRescaleIntensity.outputImage

    // Method to launch the command.
    Execute()

## Parameters

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| inputImage | The input image stack to normalize. If the input is a 3D volume, it will be considered as a stack of XY images. | Image | Grayscale or Multispectral | nullptr
| scalingMode | The type of rescaling to apply on each slice.
STANDARDIZATION | The scaling is performed by subtracting the mean and dividing by the standard deviation.
NORMALIZATION | The scaling is performed by subtracting the minimum and dividing by data range.
| Enumeration |  | STANDARDIZATION
| inputRangeMode | The way to define the input intensity range, applied on each slice of the stack.
MIN_MAX | The input range is the minimum and maximum of each slice.
PERCENTILE | The input range is defined by two user-defined percentiles, computed on each slice.
OTHER | The input range is between user-defined bounds [a,b].
| Enumeration |  | MIN_MAX
| percentageInputRange | The low and high histogram percentile to use when the input range mode is set to PERCENTILE (in percent). This parameter is ignored with other input range modes. | Vector2d | [0, 100] | {2.f, 98.f}
| intensityInputRange | The input intensity range [a, b] to use when the input range mode is set to OTHER. This parameter is ignored with other input range modes. | Vector2d | Any value | {0.f, 255.f}
| scalingScope | The scope for computing the output parameters (mean, standard deviation, percentiles, minimum or maximum).
GLOBAL | The output parameters are computed globally on the input stack.
SLICE_AVERAGING | The output parameters are computed independently on each slice of the stack, and then averaged.
| Enumeration |  | GLOBAL
| outputRangeMode | The way to define the destination intensity range.
MIN_MAX | The destination range is the minimum and maximum, computed on the entire input data.
PERCENTILE | The output range is defined by two user-defined percentiles, computed on the entire input data.
OTHER | The output range is defined by two user-defined values.
| Enumeration |  | MIN_MAX
| percentageOutputRange | The low and high histogram percentile to use when the output range mode is set to PERCENTILE (in percent). This parameter is ignored with other output range modes. | Vector2d | [0, 100] | {2.f, 98.f}
| intensityOutputRange | The output minimum and maximum values used in normalization mode. This parameter is disabled in standardization mode and is only enabled if outputRangeMode is set to OTHER. | Vector2d | Any value | {0.f, 255.f}
| intensityOutputStatistics | The mean and standard deviation values used in standardization mode. This parameter is disabled in normalization mode and is only enabled if outputRangeMode is set to OTHER. | Vector2d | Any value | {0.f, 1.f}
| outputType | The output image data type.
UNSIGNED_INTEGER_8_BIT | The output image data type is 1 byte depth. Its possible intensities are unsigned integer from 0 to 255.
UNSIGNED_INTEGER_16_BIT | The output image data type is 2 bytes depth. Its possible intensities are unsigned integer from 0 to 65,535.
UNSIGNED_INTEGER_32_BIT | The output image data type is 4 bytes depth. Its possible intensities are signed integer from 0 to 4,294,967,295.
SIGNED_INTEGER_8_BIT | The output image data type is 1 byte depth. Its possible intensities are signed integer from -128 to 127.
SIGNED_INTEGER_16_BIT | The output image data type is 2 bytes depth. Its possible intensities are signed integer from -32,768 to 32,767.
SIGNED_INTEGER_32_BIT | The output image data type is 4 bytes depth. Its possible intensities are signed integer from -2,147,483,648 to 2,147,483,647.
FLOAT_32_BIT | The output image data type is 4 bytes depth. Its possible intensities are unsigned floating-point from -3.4E38 to 3.4E38.
FLOAT_64_BIT | The output image data type is 8 bytes depth. Its possible intensities are unsigned floating-point from -1.7E308 to 1.7E308.
SAME_AS_INPUT | The output image has the same type as the input image.
| Enumeration |  | SAME_AS_INPUT
| outputImage | The output image. Its dimensions are forced to the same values as the input. Its data type is user-defined. | Image |  | nullptr

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| input_image | The input image stack to normalize. If the input is a 3D volume, it will be considered as a stack of XY images. | image | Grayscale or Multispectral | None
| scaling_mode | The type of rescaling to apply on each slice.
STANDARDIZATION | The scaling is performed by subtracting the mean and dividing by the standard deviation.
NORMALIZATION | The scaling is performed by subtracting the minimum and dividing by data range.
| enumeration |  | STANDARDIZATION
| input_range_mode | The way to define the input intensity range, applied on each slice of the stack.
MIN_MAX | The input range is the minimum and maximum of each slice.
PERCENTILE | The input range is defined by two user-defined percentiles, computed on each slice.
OTHER | The input range is between user-defined bounds [a,b].
| enumeration |  | MIN_MAX
| percentage_input_range | The low and high histogram percentile to use when the input range mode is set to PERCENTILE (in percent). This parameter is ignored with other input range modes. | vector2d | [0, 100] | [2, 98]
| intensity_input_range | The input intensity range [a, b] to use when the input range mode is set to OTHER. This parameter is ignored with other input range modes. | vector2d | Any value | [0, 255]
| scaling_scope | The scope for computing the output parameters (mean, standard deviation, percentiles, minimum or maximum).
GLOBAL | The output parameters are computed globally on the input stack.
SLICE_AVERAGING | The output parameters are computed independently on each slice of the stack, and then averaged.
| enumeration |  | GLOBAL
| output_range_mode | The way to define the destination intensity range.
MIN_MAX | The destination range is the minimum and maximum, computed on the entire input data.
PERCENTILE | The output range is defined by two user-defined percentiles, computed on the entire input data.
OTHER | The output range is defined by two user-defined values.
| enumeration |  | MIN_MAX
| percentage_output_range | The low and high histogram percentile to use when the output range mode is set to PERCENTILE (in percent). This parameter is ignored with other output range modes. | vector2d | [0, 100] | [2, 98]
| intensity_output_range | The output minimum and maximum values used in normalization mode. This parameter is disabled in standardization mode and is only enabled if outputRangeMode is set to OTHER. | vector2d | Any value | [0, 255]
| intensity_output_statistics | The mean and standard deviation values used in standardization mode. This parameter is disabled in normalization mode and is only enabled if outputRangeMode is set to OTHER. | vector2d | Any value | [0, 1]
| output_type | The output image data type.
UNSIGNED_INTEGER_8_BIT | The output image data type is 1 byte depth. Its possible intensities are unsigned integer from 0 to 255.
UNSIGNED_INTEGER_16_BIT | The output image data type is 2 bytes depth. Its possible intensities are unsigned integer from 0 to 65,535.
UNSIGNED_INTEGER_32_BIT | The output image data type is 4 bytes depth. Its possible intensities are signed integer from 0 to 4,294,967,295.
SIGNED_INTEGER_8_BIT | The output image data type is 1 byte depth. Its possible intensities are signed integer from -128 to 127.
SIGNED_INTEGER_16_BIT | The output image data type is 2 bytes depth. Its possible intensities are signed integer from -32,768 to 32,767.
SIGNED_INTEGER_32_BIT | The output image data type is 4 bytes depth. Its possible intensities are signed integer from -2,147,483,648 to 2,147,483,647.
FLOAT_32_BIT | The output image data type is 4 bytes depth. Its possible intensities are unsigned floating-point from -3.4E38 to 3.4E38.
FLOAT_64_BIT | The output image data type is 8 bytes depth. Its possible intensities are unsigned floating-point from -1.7E308 to 1.7E308.
SAME_AS_INPUT | The output image has the same type as the input image.
| enumeration |  | SAME_AS_INPUT
| output_image | The output image. Its dimensions are forced to the same values as the input. Its data type is user-defined. | image |  | None

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| inputImage | The input image stack to normalize. If the input is a 3D volume, it will be considered as a stack of XY images. | Image | Grayscale or Multispectral | null
| scalingMode | The type of rescaling to apply on each slice.
STANDARDIZATION | The scaling is performed by subtracting the mean and dividing by the standard deviation.
NORMALIZATION | The scaling is performed by subtracting the minimum and dividing by data range.
| Enumeration |  | STANDARDIZATION
| inputRangeMode | The way to define the input intensity range, applied on each slice of the stack.
MIN_MAX | The input range is the minimum and maximum of each slice.
PERCENTILE | The input range is defined by two user-defined percentiles, computed on each slice.
OTHER | The input range is between user-defined bounds [a,b].
| Enumeration |  | MIN_MAX
| percentageInputRange | The low and high histogram percentile to use when the input range mode is set to PERCENTILE (in percent). This parameter is ignored with other input range modes. | Vector2d | [0, 100] | {2f, 98f}
| intensityInputRange | The input intensity range [a, b] to use when the input range mode is set to OTHER. This parameter is ignored with other input range modes. | Vector2d | Any value | {0f, 255f}
| scalingScope | The scope for computing the output parameters (mean, standard deviation, percentiles, minimum or maximum).
GLOBAL | The output parameters are computed globally on the input stack.
SLICE_AVERAGING | The output parameters are computed independently on each slice of the stack, and then averaged.
| Enumeration |  | GLOBAL
| outputRangeMode | The way to define the destination intensity range.
MIN_MAX | The destination range is the minimum and maximum, computed on the entire input data.
PERCENTILE | The output range is defined by two user-defined percentiles, computed on the entire input data.
OTHER | The output range is defined by two user-defined values.
| Enumeration |  | MIN_MAX
| percentageOutputRange | The low and high histogram percentile to use when the output range mode is set to PERCENTILE (in percent). This parameter is ignored with other output range modes. | Vector2d | [0, 100] | {2f, 98f}
| intensityOutputRange | The output minimum and maximum values used in normalization mode. This parameter is disabled in standardization mode and is only enabled if outputRangeMode is set to OTHER. | Vector2d | Any value | {0f, 255f}
| intensityOutputStatistics | The mean and standard deviation values used in standardization mode. This parameter is disabled in normalization mode and is only enabled if outputRangeMode is set to OTHER. | Vector2d | Any value | {0f, 1f}
| outputType | The output image data type.
UNSIGNED_INTEGER_8_BIT | The output image data type is 1 byte depth. Its possible intensities are unsigned integer from 0 to 255.
UNSIGNED_INTEGER_16_BIT | The output image data type is 2 bytes depth. Its possible intensities are unsigned integer from 0 to 65,535.
UNSIGNED_INTEGER_32_BIT | The output image data type is 4 bytes depth. Its possible intensities are signed integer from 0 to 4,294,967,295.
SIGNED_INTEGER_8_BIT | The output image data type is 1 byte depth. Its possible intensities are signed integer from -128 to 127.
SIGNED_INTEGER_16_BIT | The output image data type is 2 bytes depth. Its possible intensities are signed integer from -32,768 to 32,767.
SIGNED_INTEGER_32_BIT | The output image data type is 4 bytes depth. Its possible intensities are signed integer from -2,147,483,648 to 2,147,483,647.
FLOAT_32_BIT | The output image data type is 4 bytes depth. Its possible intensities are unsigned floating-point from -3.4E38 to 3.4E38.
FLOAT_64_BIT | The output image data type is 8 bytes depth. Its possible intensities are unsigned floating-point from -1.7E308 to 1.7E308.
SAME_AS_INPUT | The output image has the same type as the input image.
| Enumeration |  | SAME_AS_INPUT
| outputImage | The output image. Its dimensions are forced to the same values as the input. Its data type is user-defined. | Image |  | null

## Object Examples

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

    StackRescaleIntensity stackRescaleIntensityAlgo;
    stackRescaleIntensityAlgo.setInputImage( foam );
    stackRescaleIntensityAlgo.setScalingMode( StackRescaleIntensity::ScalingMode::STANDARDIZATION );
    stackRescaleIntensityAlgo.setInputRangeMode( StackRescaleIntensity::RangeMode::MIN_MAX );
    stackRescaleIntensityAlgo.setPercentageInputRange( {2, 98} );
    stackRescaleIntensityAlgo.setIntensityInputRange( {0, 255} );
    stackRescaleIntensityAlgo.setScalingScope( StackRescaleIntensity::ScalingScope::GLOBAL );
    stackRescaleIntensityAlgo.setOutputRangeMode( StackRescaleIntensity::RangeMode::MIN_MAX );
    stackRescaleIntensityAlgo.setPercentageOutputRange( {2, 98} );
    stackRescaleIntensityAlgo.setIntensityOutputRange( {0, 255} );
    stackRescaleIntensityAlgo.setIntensityOutputStatistics( {0, 1} );
    stackRescaleIntensityAlgo.setOutputType( StackRescaleIntensity::OutputType::SAME_AS_INPUT );
    stackRescaleIntensityAlgo.execute();

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

    foam = imagedev.read_vip_image(imagedev_data.get_image_path("foam.vip"))

    stack_rescale_intensity_algo = imagedev.StackRescaleIntensity()
    stack_rescale_intensity_algo.input_image = foam
    stack_rescale_intensity_algo.scaling_mode = imagedev.StackRescaleIntensity.STANDARDIZATION
    stack_rescale_intensity_algo.input_range_mode = imagedev.StackRescaleIntensity.MIN_MAX
    stack_rescale_intensity_algo.percentage_input_range = [2, 98]
    stack_rescale_intensity_algo.intensity_input_range = [0, 255]
    stack_rescale_intensity_algo.scaling_scope = imagedev.StackRescaleIntensity.GLOBAL
    stack_rescale_intensity_algo.output_range_mode = imagedev.StackRescaleIntensity.MIN_MAX
    stack_rescale_intensity_algo.percentage_output_range = [2, 98]
    stack_rescale_intensity_algo.intensity_output_range = [0, 255]
    stack_rescale_intensity_algo.intensity_output_statistics = [0, 1]
    stack_rescale_intensity_algo.output_type = imagedev.StackRescaleIntensity.SAME_AS_INPUT
    stack_rescale_intensity_algo.execute()

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

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

    StackRescaleIntensity stackRescaleIntensityAlgo = new StackRescaleIntensity
    {
        inputImage = foam,
        scalingMode = StackRescaleIntensity.ScalingMode.STANDARDIZATION,
        inputRangeMode = StackRescaleIntensity.RangeMode.MIN_MAX,
        percentageInputRange = new double[]{2, 98},
        intensityInputRange = new double[]{0, 255},
        scalingScope = StackRescaleIntensity.ScalingScope.GLOBAL,
        outputRangeMode = StackRescaleIntensity.RangeMode.MIN_MAX,
        percentageOutputRange = new double[]{2, 98},
        intensityOutputRange = new double[]{0, 255},
        intensityOutputStatistics = new double[]{0, 1},
        outputType = StackRescaleIntensity.OutputType.SAME_AS_INPUT
    };
    stackRescaleIntensityAlgo.Execute();

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

## Function Examples

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

    auto result = stackRescaleIntensity( foam, StackRescaleIntensity::ScalingMode::STANDARDIZATION, StackRescaleIntensity::RangeMode::MIN_MAX, {2, 98}, {0, 255}, StackRescaleIntensity::ScalingScope::GLOBAL, StackRescaleIntensity::RangeMode::MIN_MAX, {2, 98}, {0, 255}, {0, 1}, StackRescaleIntensity::OutputType::SAME_AS_INPUT );

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

    foam = imagedev.read_vip_image(imagedev_data.get_image_path("foam.vip"))

    result = imagedev.stack_rescale_intensity(foam, imagedev.StackRescaleIntensity.STANDARDIZATION, imagedev.StackRescaleIntensity.MIN_MAX, [2, 98], [0, 255], imagedev.StackRescaleIntensity.GLOBAL, imagedev.StackRescaleIntensity.MIN_MAX, [2, 98], [0, 255], [0, 1], imagedev.StackRescaleIntensity.SAME_AS_INPUT)

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

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

    IOLink.ImageView result = Processing.StackRescaleIntensity( foam, StackRescaleIntensity.ScalingMode.STANDARDIZATION, StackRescaleIntensity.RangeMode.MIN_MAX, new double[]{2, 98}, new double[]{0, 255}, StackRescaleIntensity.ScalingScope.GLOBAL, StackRescaleIntensity.RangeMode.MIN_MAX, new double[]{2, 98}, new double[]{0, 255}, new double[]{0, 1}, StackRescaleIntensity.OutputType.SAME_AS_INPUT );

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

© 2025 Thermo Fisher Scientific Inc. All rights reserved.