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

# OnnxPredictionSegmentation2d

Computes a prediction on a two-dimensional image from an ONNX model and applies a post processing to generate a label or a binary image.
Access to parameter description
For an introduction, please refer to the Deep Learning section.
The following steps are applied:

- Pre-processing
- Prediction
- Post-processing to generate a binary or label output

If the prediction output contains only one channel, the prediction score normalized between 0 and 1 is thresholded. The scores lower than 0.5 are considered as background and set to 0. Other scores are set to 1. The output image has the binary interpretation in this case.
If the prediction output contains two channels or more, the channel index presenting the highest score is assigned to each pixel of the output image. The first class, represented in the channel of index 0, is considered as background. The output image has the label interpretation in this case.

Figure 1. Membrane segmentation by deep learning prediction with a Unet model trained with the Avizo software.
This image is shown by courtesy of Albert Cardona. It is from a set of serial section TEM images of Drosophila brain tissue described in this paper:
A.Cardona, et al. "An Integrated Micro- and Macroarchitectural Analysis of the rosophila Brain by Computer-Assisted Serial Section Electron Microscopy." PLoS Biology 8(10). DOI: 10.1371/journal.pbio.1000502, Oct. 2010.
See also

- ReadOnnxModel
- OnnxPredictionSegmentation3d
- OnnxPredictionTwoOutputs2d
- OnnxPredictionFiltering2d

##
Function Syntax

This function returns outputObjectImage.

    // Function prototype
    std::shared_ptr< iolink::ImageView >
    onnxPredictionSegmentation2d( std::shared_ptr< iolink::ImageView > inputImage,
                                  OnnxModel::Ptr inputOnnxModel,
                                  OnnxPredictionSegmentation2d::DataFormat dataFormat,
                                  OnnxPredictionSegmentation2d::InputNormalizationType inputNormalizationType,
                                  const iolink::Vector2d& normalizationRange,
                                  OnnxPredictionSegmentation2d::NormalizationScope normalizationScope,
                                  const iolink::Vector2u32& tileSize,
                                  uint32_t tileOverlap,
                                  std::shared_ptr< iolink::ImageView > outputObjectImage = nullptr );

This function returns outputObjectImage.

    // Function prototype.
    onnx_prediction_segmentation_2d(input_image: idt.ImageType,
                                    input_onnx_model: Union[Any, None] = None,
                                    data_format: OnnxPredictionSegmentation2d.DataFormat = OnnxPredictionSegmentation2d.DataFormat.NHWC,
                                    input_normalization_type: OnnxPredictionSegmentation2d.InputNormalizationType = OnnxPredictionSegmentation2d.InputNormalizationType.STANDARDIZATION,
                                    normalization_range: Union[Iterable[int], Iterable[float]] = [0, 1],
                                    normalization_scope: OnnxPredictionSegmentation2d.NormalizationScope = OnnxPredictionSegmentation2d.NormalizationScope.GLOBAL,
                                    tile_size: Iterable[int] = [256, 256],
                                    tile_overlap: int = 32,
                                    output_object_image: idt.ImageType = None) -> idt.ImageType

This function returns outputObjectImage.

    // Function prototype.
    public static IOLink.ImageView
    OnnxPredictionSegmentation2d( IOLink.ImageView inputImage,
                                  OnnxModel inputOnnxModel = null,
                                  OnnxPredictionSegmentation2d.DataFormat dataFormat = ImageDev.OnnxPredictionSegmentation2d.DataFormat.NHWC,
                                  OnnxPredictionSegmentation2d.InputNormalizationType inputNormalizationType = ImageDev.OnnxPredictionSegmentation2d.InputNormalizationType.STANDARDIZATION,
                                  double[] normalizationRange = null,
                                  OnnxPredictionSegmentation2d.NormalizationScope normalizationScope = ImageDev.OnnxPredictionSegmentation2d.NormalizationScope.GLOBAL,
                                  uint[] tileSize = null,
                                  UInt32 tileOverlap = 32,
                                  IOLink.ImageView outputObjectImage = null );

##
Class Syntax

    // Command constructor.
    OnnxPredictionSegmentation2d();

    /// Gets the inputImage parameter.
    /// The input image. It can be a grayscale or color image, depending on the selected model.
    std::shared_ptr< iolink::ImageView > inputImage() const;
    /// Sets the inputImage parameter.
    /// The input image. It can be a grayscale or color image, depending on the selected model.
    void setInputImage( std::shared_ptr< iolink::ImageView > inputImage );

    /// Gets the inputOnnxModel parameter.
    /// The in memory ONNX model.
    OnnxModel::Ptr inputOnnxModel() const;
    /// Sets the inputOnnxModel parameter.
    /// The in memory ONNX model.
    void setInputOnnxModel( const OnnxModel::Ptr& inputOnnxModel );

    /// Gets the dataFormat parameter.
    /// The tensor layout expected as input by the model. The input image is automatically converted to this layout by the algorithm.
    OnnxPredictionSegmentation2d::DataFormat dataFormat() const;
    /// Sets the dataFormat parameter.
    /// The tensor layout expected as input by the model. The input image is automatically converted to this layout by the algorithm.
    void setDataFormat( const OnnxPredictionSegmentation2d::DataFormat& dataFormat );

    /// Gets the inputNormalizationType parameter.
    /// The type of normalization to apply before computing the prediction. It is recommended to apply the same pre-processing as during the training.
    OnnxPredictionSegmentation2d::InputNormalizationType inputNormalizationType() const;
    /// Sets the inputNormalizationType parameter.
    /// The type of normalization to apply before computing the prediction. It is recommended to apply the same pre-processing as during the training.
    void setInputNormalizationType( const OnnxPredictionSegmentation2d::InputNormalizationType& inputNormalizationType );

    /// Gets the normalizationRange parameter.
    /// The data range in which the input image is normalized before computing the prediction. It is recommended to apply the same pre-processing as during the training. This parameter is ignored if the normalization type is set to NONE.
    iolink::Vector2d normalizationRange() const;
    /// Sets the normalizationRange parameter.
    /// The data range in which the input image is normalized before computing the prediction. It is recommended to apply the same pre-processing as during the training. This parameter is ignored if the normalization type is set to NONE.
    void setNormalizationRange( const iolink::Vector2d& normalizationRange );

    /// Gets the normalizationScope parameter.
    /// The scope for computing normalization (mean, standard deviation, minimum or maximum). This parameter is ignored if the normalization type is set to NONE.
    OnnxPredictionSegmentation2d::NormalizationScope normalizationScope() const;
    /// Sets the normalizationScope parameter.
    /// The scope for computing normalization (mean, standard deviation, minimum or maximum). This parameter is ignored if the normalization type is set to NONE.
    void setNormalizationScope( const OnnxPredictionSegmentation2d::NormalizationScope& normalizationScope );

    /// Gets the tileSize parameter.
    /// The width and height in pixels of the sliding window. This size includes the user defined tile overlap. It must be a multiple of 2 to the power of the number of downsampling or upsampling layers.
    iolink::Vector2u32 tileSize() const;
    /// Sets the tileSize parameter.
    /// The width and height in pixels of the sliding window. This size includes the user defined tile overlap. It must be a multiple of 2 to the power of the number of downsampling or upsampling layers.
    void setTileSize( const iolink::Vector2u32& tileSize );

    /// Gets the tileOverlap parameter.
    /// The number of pixels used as overlap between the tiles. An overlap of zero may lead to artifacts in the prediction result. A non-zero overlap reduces such artifacts but increases the computation time.
    uint32_t tileOverlap() const;
    /// Sets the tileOverlap parameter.
    /// The number of pixels used as overlap between the tiles. An overlap of zero may lead to artifacts in the prediction result. A non-zero overlap reduces such artifacts but increases the computation time.
    void setTileOverlap( const uint32_t& tileOverlap );

    /// Gets the outputObjectImage parameter.
    /// The output image. Its dimensions, and calibration are forced to the same values as the input. Its interpretation is binary if the model produces one channel, label otherwise.
    std::shared_ptr< iolink::ImageView > outputObjectImage() const;
    /// Sets the outputObjectImage parameter.
    /// The output image. Its dimensions, and calibration are forced to the same values as the input. Its interpretation is binary if the model produces one channel, label otherwise.
    void setOutputObjectImage( std::shared_ptr< iolink::ImageView > outputObjectImage );

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

    # Property of the inputImage parameter.
    OnnxPredictionSegmentation2d.input_image
    # Property of the inputOnnxModel parameter.
    OnnxPredictionSegmentation2d.input_onnx_model
    # Property of the dataFormat parameter.
    OnnxPredictionSegmentation2d.data_format
    # Property of the inputNormalizationType parameter.
    OnnxPredictionSegmentation2d.input_normalization_type
    # Property of the normalizationRange parameter.
    OnnxPredictionSegmentation2d.normalization_range
    # Property of the normalizationScope parameter.
    OnnxPredictionSegmentation2d.normalization_scope
    # Property of the tileSize parameter.
    OnnxPredictionSegmentation2d.tile_size
    # Property of the tileOverlap parameter.
    OnnxPredictionSegmentation2d.tile_overlap
    # Property of the outputObjectImage parameter.
    OnnxPredictionSegmentation2d.output_object_image

    // Method to launch the command.
    execute()

    // Command constructor.
    OnnxPredictionSegmentation2d()

    // Property of the inputImage parameter.
    OnnxPredictionSegmentation2d.inputImage
    // Property of the inputOnnxModel parameter.
    OnnxPredictionSegmentation2d.inputOnnxModel
    // Property of the dataFormat parameter.
    OnnxPredictionSegmentation2d.dataFormat
    // Property of the inputNormalizationType parameter.
    OnnxPredictionSegmentation2d.inputNormalizationType
    // Property of the normalizationRange parameter.
    OnnxPredictionSegmentation2d.normalizationRange
    // Property of the normalizationScope parameter.
    OnnxPredictionSegmentation2d.normalizationScope
    // Property of the tileSize parameter.
    OnnxPredictionSegmentation2d.tileSize
    // Property of the tileOverlap parameter.
    OnnxPredictionSegmentation2d.tileOverlap
    // Property of the outputObjectImage parameter.
    OnnxPredictionSegmentation2d.outputObjectImage

    // Method to launch the command.
    Execute()

## Parameters

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| inputImage | The input image. It can be a grayscale or color image, depending on the selected model. | Image | Binary, Label, Grayscale or Multispectral | nullptr
| inputOnnxModel | The in memory ONNX model. It must be loaded with the ReadOnnxModel command. | OnnxModel |  | nullptr
| dataFormat | The tensor layout expected as input by the model. The input image is automatically converted to this layout by the algorithm.
NHWC | The layout is organized with interlaced channels. For instance, if the input is a color image, each pixel presents is RGB components successively.
NCHW | The layout is organized with separated channels. Each channel is an individual plane.
| Enumeration |  | NHWC
| inputNormalizationType | The type of normalization to apply before computing the prediction. It is recommended to apply the same pre-processing as during the training.
NONE | No normalization is applied before executing the prediction.
STANDARDIZATION | A normalization is applied by subtracting the mean and dividing by the standard deviation.
MIN_MAX | A normalization is applied by subtracting the minimum and dividing by data range.
| Enumeration |  | STANDARDIZATION
| normalizationRange | The data range in which the input image is normalized before computing the prediction. It is recommended to apply the same pre-processing as during the training. This parameter is ignored if the normalization type is set to NONE. | Vector2d | Any value | {0.f, 1.f}
| normalizationScope | The scope for computing normalization (mean, standard deviation, minimum or maximum). This parameter is ignored if the normalization type is set to NONE.
GLOBAL | The normalization is applied globally on the input batch.
PER_SLICE | The normalization is applied individually on each image of the input batch.
| Enumeration |  | GLOBAL
| tileSize | The width and height in pixels of the sliding window. This size includes the user defined tile overlap. It must be a multiple of 2 to the power of the number of downsampling or upsampling layers. Guidelines to select an appropriate tile size are available in the Tiling section. | Vector2u32 | != 0 | {256, 256}
| tileOverlap | The number of pixels used as overlap between the tiles. An overlap of zero may lead to artifacts in the prediction result. A non-zero overlap reduces such artifacts but increases the computation time. | UInt32 | Any value | 32
| outputObjectImage | The output image. Its dimensions, and calibration are forced to the same values as the input. Its interpretation is binary if the model produces one channel, label otherwise. | Image |  | nullptr

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| input_image | The input image. It can be a grayscale or color image, depending on the selected model. | image | Binary, Label, Grayscale or Multispectral | None
| input_onnx_model | The in memory ONNX model. It must be loaded with the ReadOnnxModel command. | OnnxModel |  | None
| data_format | The tensor layout expected as input by the model. The input image is automatically converted to this layout by the algorithm.
NHWC | The layout is organized with interlaced channels. For instance, if the input is a color image, each pixel presents is RGB components successively.
NCHW | The layout is organized with separated channels. Each channel is an individual plane.
| enumeration |  | NHWC
| input_normalization_type | The type of normalization to apply before computing the prediction. It is recommended to apply the same pre-processing as during the training.
NONE | No normalization is applied before executing the prediction.
STANDARDIZATION | A normalization is applied by subtracting the mean and dividing by the standard deviation.
MIN_MAX | A normalization is applied by subtracting the minimum and dividing by data range.
| enumeration |  | STANDARDIZATION
| normalization_range | The data range in which the input image is normalized before computing the prediction. It is recommended to apply the same pre-processing as during the training. This parameter is ignored if the normalization type is set to NONE. | vector2d | Any value | [0, 1]
| normalization_scope | The scope for computing normalization (mean, standard deviation, minimum or maximum). This parameter is ignored if the normalization type is set to NONE.
GLOBAL | The normalization is applied globally on the input batch.
PER_SLICE | The normalization is applied individually on each image of the input batch.
| enumeration |  | GLOBAL
| tile_size | The width and height in pixels of the sliding window. This size includes the user defined tile overlap. It must be a multiple of 2 to the power of the number of downsampling or upsampling layers. Guidelines to select an appropriate tile size are available in the Tiling section. | vector2u32 | != 0 | [256, 256]
| tile_overlap | The number of pixels used as overlap between the tiles. An overlap of zero may lead to artifacts in the prediction result. A non-zero overlap reduces such artifacts but increases the computation time. | uint32 | Any value | 32
| output_object_image | The output image. Its dimensions, and calibration are forced to the same values as the input. Its interpretation is binary if the model produces one channel, label otherwise. | image |  | None

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| inputImage | The input image. It can be a grayscale or color image, depending on the selected model. | Image | Binary, Label, Grayscale or Multispectral | null
| inputOnnxModel | The in memory ONNX model. It must be loaded with the ReadOnnxModel command. | OnnxModel |  | null
| dataFormat | The tensor layout expected as input by the model. The input image is automatically converted to this layout by the algorithm.
NHWC | The layout is organized with interlaced channels. For instance, if the input is a color image, each pixel presents is RGB components successively.
NCHW | The layout is organized with separated channels. Each channel is an individual plane.
| Enumeration |  | NHWC
| inputNormalizationType | The type of normalization to apply before computing the prediction. It is recommended to apply the same pre-processing as during the training.
NONE | No normalization is applied before executing the prediction.
STANDARDIZATION | A normalization is applied by subtracting the mean and dividing by the standard deviation.
MIN_MAX | A normalization is applied by subtracting the minimum and dividing by data range.
| Enumeration |  | STANDARDIZATION
| normalizationRange | The data range in which the input image is normalized before computing the prediction. It is recommended to apply the same pre-processing as during the training. This parameter is ignored if the normalization type is set to NONE. | Vector2d | Any value | {0f, 1f}
| normalizationScope | The scope for computing normalization (mean, standard deviation, minimum or maximum). This parameter is ignored if the normalization type is set to NONE.
GLOBAL | The normalization is applied globally on the input batch.
PER_SLICE | The normalization is applied individually on each image of the input batch.
| Enumeration |  | GLOBAL
| tileSize | The width and height in pixels of the sliding window. This size includes the user defined tile overlap. It must be a multiple of 2 to the power of the number of downsampling or upsampling layers. Guidelines to select an appropriate tile size are available in the Tiling section. | Vector2u32 | != 0 | {256, 256}
| tileOverlap | The number of pixels used as overlap between the tiles. An overlap of zero may lead to artifacts in the prediction result. A non-zero overlap reduces such artifacts but increases the computation time. | UInt32 | Any value | 32
| outputObjectImage | The output image. Its dimensions, and calibration are forced to the same values as the input. Its interpretation is binary if the model produces one channel, label otherwise. | Image |  | null

## Object Examples

    auto membrane = ioformat::readImage( std::string( IMAGEDEVDATA_IMAGES_FOLDER ) + "membrane.png" );
    OnnxModel::Ptr membraneModel= OnnxModel::read( std::string( IMAGEDEVDATA_OBJECTS_FOLDER ) + "membraneModel.onnx" );

    OnnxPredictionSegmentation2d onnxPredictionSegmentation2dAlgo;
    onnxPredictionSegmentation2dAlgo.setInputImage( membrane );
    onnxPredictionSegmentation2dAlgo.setInputOnnxModel( membraneModel );
    onnxPredictionSegmentation2dAlgo.setDataFormat( OnnxPredictionSegmentation2d::DataFormat::NHWC );
    onnxPredictionSegmentation2dAlgo.setInputNormalizationType( OnnxPredictionSegmentation2d::InputNormalizationType::STANDARDIZATION );
    onnxPredictionSegmentation2dAlgo.setNormalizationRange( {0, 1} );
    onnxPredictionSegmentation2dAlgo.setNormalizationScope( OnnxPredictionSegmentation2d::NormalizationScope::GLOBAL );
    onnxPredictionSegmentation2dAlgo.setTileSize( {128, 128} );
    onnxPredictionSegmentation2dAlgo.setTileOverlap( 32 );
    onnxPredictionSegmentation2dAlgo.execute();

    std::cout << "outputObjectImage:" << onnxPredictionSegmentation2dAlgo.outputObjectImage()->toString();

    membrane = ioformat.read_image(imagedev_data.get_image_path("membrane.png"))
    membrane_model = imagedev.OnnxModel.read(imagedev_data.get_object_path("membraneModel.onnx"))

    onnx_prediction_segmentation_2d_algo = imagedev.OnnxPredictionSegmentation2d()
    onnx_prediction_segmentation_2d_algo.input_image = membrane
    onnx_prediction_segmentation_2d_algo.input_onnx_model = membrane_model
    onnx_prediction_segmentation_2d_algo.data_format = imagedev.OnnxPredictionSegmentation2d.NHWC
    onnx_prediction_segmentation_2d_algo.input_normalization_type = imagedev.OnnxPredictionSegmentation2d.STANDARDIZATION
    onnx_prediction_segmentation_2d_algo.normalization_range = [0, 1]
    onnx_prediction_segmentation_2d_algo.normalization_scope = imagedev.OnnxPredictionSegmentation2d.GLOBAL
    onnx_prediction_segmentation_2d_algo.tile_size = [128, 128]
    onnx_prediction_segmentation_2d_algo.tile_overlap = 32
    onnx_prediction_segmentation_2d_algo.execute()

    print("output_object_image:", str(onnx_prediction_segmentation_2d_algo.output_object_image))

    ImageView membrane = ViewIO.ReadImage( @"Data/images/membrane.png" );
    OnnxModel membraneModel = OnnxModel.Read( @"Data/objects/membraneModel.onnx" );

    OnnxPredictionSegmentation2d onnxPredictionSegmentation2dAlgo = new OnnxPredictionSegmentation2d
    {
        inputImage = membrane,
        inputOnnxModel = membraneModel,
        dataFormat = OnnxPredictionSegmentation2d.DataFormat.NHWC,
        inputNormalizationType = OnnxPredictionSegmentation2d.InputNormalizationType.STANDARDIZATION,
        normalizationRange = new double[]{0, 1},
        normalizationScope = OnnxPredictionSegmentation2d.NormalizationScope.GLOBAL,
        tileSize = new uint[]{128, 128},
        tileOverlap = 32
    };
    onnxPredictionSegmentation2dAlgo.Execute();

    Console.WriteLine( "outputObjectImage:" + onnxPredictionSegmentation2dAlgo.outputObjectImage.ToString() );

## Function Examples

    auto membrane = ioformat::readImage( std::string( IMAGEDEVDATA_IMAGES_FOLDER ) + "membrane.png" );
    OnnxModel::Ptr membraneModel= OnnxModel::read( std::string( IMAGEDEVDATA_OBJECTS_FOLDER ) + "membraneModel.onnx" );

    auto result = onnxPredictionSegmentation2d( membrane, membraneModel, OnnxPredictionSegmentation2d::DataFormat::NHWC, OnnxPredictionSegmentation2d::InputNormalizationType::STANDARDIZATION, {0, 1}, OnnxPredictionSegmentation2d::NormalizationScope::GLOBAL, {128, 128}, 32 );

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

    membrane = ioformat.read_image(imagedev_data.get_image_path("membrane.png"))
    membrane_model = imagedev.OnnxModel.read(imagedev_data.get_object_path("membraneModel.onnx"))

    result = imagedev.onnx_prediction_segmentation_2d(membrane, membrane_model, imagedev.OnnxPredictionSegmentation2d.NHWC, imagedev.OnnxPredictionSegmentation2d.STANDARDIZATION, [0, 1], imagedev.OnnxPredictionSegmentation2d.GLOBAL, [128, 128], 32)

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

    ImageView membrane = ViewIO.ReadImage( @"Data/images/membrane.png" );
    OnnxModel membraneModel = OnnxModel.Read( @"Data/objects/membraneModel.onnx" );

    IOLink.ImageView result = Processing.OnnxPredictionSegmentation2d( membrane, membraneModel, OnnxPredictionSegmentation2d.DataFormat.NHWC, OnnxPredictionSegmentation2d.InputNormalizationType.STANDARDIZATION, new double[]{0, 1}, OnnxPredictionSegmentation2d.NormalizationScope.GLOBAL, new uint[]{128, 128}, 32 );

    Console.WriteLine( "outputObjectImage:" + result.ToString() );
    membraneModel.Dispose();

© 2025 Thermo Fisher Scientific Inc. All rights reserved.