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

# OnnxPredictionTwoOutputs2d

Computes a prediction on a two-dimensional image from an ONNX model and generates two images.
Access to parameter description
For an overview, please refer to the Deep Learning section.
This algorithm produces two images given by the execution of the model. Depending on how the model has been trained, it can be used either to perform image filtering, or segmentation by applying an appropriate post-processing step afterwards.
This algorithm may be especially useful for applying a StarDist model which provides two outputs: an object probability map and the star-convex polygon distances for a set of orientation.
The following steps are applied:

- Pre-processing
- Prediction

See also

- ReadOnnxModel
- OnnxPredictionTwoOutputs3d
- OnnxPredictionSegmentation2d
- OnnxPredictionFiltering2d

##
Function Syntax

This function returns a OnnxPredictionTwoOutputs2dOutput structure containing outputImage1 and outputImage2.

    // Output structure of the onnxPredictionTwoOutputs2d function.
    struct OnnxPredictionTwoOutputs2dOutput
    {
        /// The first output image. Its dimensions and data type are determined by the model.
        std::shared_ptr< iolink::ImageView > outputImage1;
        /// The second output image. Its dimensions and data type are determined by the model.
        std::shared_ptr< iolink::ImageView > outputImage2;
    };

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

This function returns a tuple containing output_image1 and output_image2.

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

This function returns a OnnxPredictionTwoOutputs2dOutput structure containing outputImage1 and outputImage2.

    /// Output structure of the OnnxPredictionTwoOutputs2d function.
    public struct OnnxPredictionTwoOutputs2dOutput
    {
        ///
        /// The first output image. Its dimensions and data type are determined by the model.
        ///
        public IOLink.ImageView outputImage1;
        ///
        /// The second output image. Its dimensions and data type are determined by the model.
        ///
        public IOLink.ImageView outputImage2;
    };

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

##
Class Syntax

    // Command constructor.
    OnnxPredictionTwoOutputs2d();

    /// 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.
    OnnxPredictionTwoOutputs2d::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 OnnxPredictionTwoOutputs2d::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.
    OnnxPredictionTwoOutputs2d::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 OnnxPredictionTwoOutputs2d::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.
    OnnxPredictionTwoOutputs2d::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 OnnxPredictionTwoOutputs2d::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 outputImage1 parameter.
    /// The first output image. Its dimensions and data type are determined by the model.
    std::shared_ptr< iolink::ImageView > outputImage1() const;
    /// Sets the outputImage1 parameter.
    /// The first output image. Its dimensions and data type are determined by the model.
    void setOutputImage1( std::shared_ptr< iolink::ImageView > outputImage1 );

    /// Gets the outputImage2 parameter.
    /// The second output image. Its dimensions and data type are determined by the model.
    std::shared_ptr< iolink::ImageView > outputImage2() const;
    /// Sets the outputImage2 parameter.
    /// The second output image. Its dimensions and data type are determined by the model.
    void setOutputImage2( std::shared_ptr< iolink::ImageView > outputImage2 );

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

    # Property of the inputImage parameter.
    OnnxPredictionTwoOutputs2d.input_image
    # Property of the inputOnnxModel parameter.
    OnnxPredictionTwoOutputs2d.input_onnx_model
    # Property of the dataFormat parameter.
    OnnxPredictionTwoOutputs2d.data_format
    # Property of the inputNormalizationType parameter.
    OnnxPredictionTwoOutputs2d.input_normalization_type
    # Property of the normalizationRange parameter.
    OnnxPredictionTwoOutputs2d.normalization_range
    # Property of the normalizationScope parameter.
    OnnxPredictionTwoOutputs2d.normalization_scope
    # Property of the tileSize parameter.
    OnnxPredictionTwoOutputs2d.tile_size
    # Property of the tileOverlap parameter.
    OnnxPredictionTwoOutputs2d.tile_overlap
    # Property of the outputImage1 parameter.
    OnnxPredictionTwoOutputs2d.output_image1
    # Property of the outputImage2 parameter.
    OnnxPredictionTwoOutputs2d.output_image2

    // Method to launch the command.
    execute()

    // Command constructor.
    OnnxPredictionTwoOutputs2d()

    // Property of the inputImage parameter.
    OnnxPredictionTwoOutputs2d.inputImage
    // Property of the inputOnnxModel parameter.
    OnnxPredictionTwoOutputs2d.inputOnnxModel
    // Property of the dataFormat parameter.
    OnnxPredictionTwoOutputs2d.dataFormat
    // Property of the inputNormalizationType parameter.
    OnnxPredictionTwoOutputs2d.inputNormalizationType
    // Property of the normalizationRange parameter.
    OnnxPredictionTwoOutputs2d.normalizationRange
    // Property of the normalizationScope parameter.
    OnnxPredictionTwoOutputs2d.normalizationScope
    // Property of the tileSize parameter.
    OnnxPredictionTwoOutputs2d.tileSize
    // Property of the tileOverlap parameter.
    OnnxPredictionTwoOutputs2d.tileOverlap
    // Property of the outputImage1 parameter.
    OnnxPredictionTwoOutputs2d.outputImage1
    // Property of the outputImage2 parameter.
    OnnxPredictionTwoOutputs2d.outputImage2

    // 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 its RGB components successively.
NCHW | The layout is organized with separate 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
| outputImage1 | The first output image. Its dimensions and data type are determined by the model. | Image |  | nullptr
| outputImage2 | The second output image. Its dimensions and data type are determined by the model. | 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 its RGB components successively.
NCHW | The layout is organized with separate 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_image1 | The first output image. Its dimensions and data type are determined by the model. | image |  | None
| output_image2 | The second output image. Its dimensions and data type are determined by the model. | 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 its RGB components successively.
NCHW | The layout is organized with separate 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
| outputImage1 | The first output image. Its dimensions and data type are determined by the model. | Image |  | null
| outputImage2 | The second output image. Its dimensions and data type are determined by the model. | Image |  | null

## Object Examples

    auto grayscale_images_2d_float = readVipImage( std::string( IMAGEDEVDATA_IMAGES_FOLDER ) + "grayscale_images_2d_float.vip" );
    OnnxModel::Ptr model2d_2outputs= OnnxModel::read( std::string( IMAGEDEVDATA_OBJECTS_FOLDER ) + "model2d-2outputs.onnx" );

    OnnxPredictionTwoOutputs2d onnxPredictionTwoOutputs2dAlgo;
    onnxPredictionTwoOutputs2dAlgo.setInputImage( grayscale_images_2d_float );
    onnxPredictionTwoOutputs2dAlgo.setInputOnnxModel( model2d_2outputs );
    onnxPredictionTwoOutputs2dAlgo.setDataFormat( OnnxPredictionTwoOutputs2d::DataFormat::NHWC );
    onnxPredictionTwoOutputs2dAlgo.setInputNormalizationType( OnnxPredictionTwoOutputs2d::InputNormalizationType::STANDARDIZATION );
    onnxPredictionTwoOutputs2dAlgo.setNormalizationRange( {0, 1} );
    onnxPredictionTwoOutputs2dAlgo.setNormalizationScope( OnnxPredictionTwoOutputs2d::NormalizationScope::GLOBAL );
    onnxPredictionTwoOutputs2dAlgo.setTileSize( {128, 128} );
    onnxPredictionTwoOutputs2dAlgo.setTileOverlap( 32 );
    onnxPredictionTwoOutputs2dAlgo.execute();

    std::cout << "outputImage1:" << onnxPredictionTwoOutputs2dAlgo.outputImage1()->toString();
    std::cout << "outputImage2:" << onnxPredictionTwoOutputs2dAlgo.outputImage2()->toString();

    grayscale_images_2d_float = imagedev.read_vip_image(imagedev_data.get_image_path("grayscale_images_2d_float.vip"))
    model_2d_2outputs = imagedev.OnnxModel.read(imagedev_data.get_object_path("model2d-2outputs.onnx"))

    onnx_prediction_two_outputs_2d_algo = imagedev.OnnxPredictionTwoOutputs2d()
    onnx_prediction_two_outputs_2d_algo.input_image = grayscale_images_2d_float
    onnx_prediction_two_outputs_2d_algo.input_onnx_model = model_2d_2outputs
    onnx_prediction_two_outputs_2d_algo.data_format = imagedev.OnnxPredictionTwoOutputs2d.NHWC
    onnx_prediction_two_outputs_2d_algo.input_normalization_type = imagedev.OnnxPredictionTwoOutputs2d.STANDARDIZATION
    onnx_prediction_two_outputs_2d_algo.normalization_range = [0, 1]
    onnx_prediction_two_outputs_2d_algo.normalization_scope = imagedev.OnnxPredictionTwoOutputs2d.GLOBAL
    onnx_prediction_two_outputs_2d_algo.tile_size = [128, 128]
    onnx_prediction_two_outputs_2d_algo.tile_overlap = 32
    onnx_prediction_two_outputs_2d_algo.execute()

    print("output_image1:", str(onnx_prediction_two_outputs_2d_algo.output_image1))
    print("output_image2:", str(onnx_prediction_two_outputs_2d_algo.output_image2))

    ImageView grayscale_images_2d_float = Data.ReadVipImage( @"Data/images/grayscale_images_2d_float.vip" );
    OnnxModel model2d_2outputs = OnnxModel.Read( @"Data/objects/model2d-2outputs.onnx" );

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

    Console.WriteLine( "outputImage1:" + onnxPredictionTwoOutputs2dAlgo.outputImage1.ToString() );
    Console.WriteLine( "outputImage2:" + onnxPredictionTwoOutputs2dAlgo.outputImage2.ToString() );

## Function Examples

    auto grayscale_images_2d_float = readVipImage( std::string( IMAGEDEVDATA_IMAGES_FOLDER ) + "grayscale_images_2d_float.vip" );
    OnnxModel::Ptr model2d_2outputs= OnnxModel::read( std::string( IMAGEDEVDATA_OBJECTS_FOLDER ) + "model2d-2outputs.onnx" );

    auto result = onnxPredictionTwoOutputs2d( grayscale_images_2d_float, model2d_2outputs, OnnxPredictionTwoOutputs2d::DataFormat::NHWC, OnnxPredictionTwoOutputs2d::InputNormalizationType::STANDARDIZATION, {0, 1}, OnnxPredictionTwoOutputs2d::NormalizationScope::GLOBAL, {128, 128}, 32 );

    std::cout << "outputImage1:" << result.outputImage1->toString();
    std::cout << "outputImage2:" << result.outputImage2->toString();

    grayscale_images_2d_float = imagedev.read_vip_image(imagedev_data.get_image_path("grayscale_images_2d_float.vip"))
    model_2d_2outputs = imagedev.OnnxModel.read(imagedev_data.get_object_path("model2d-2outputs.onnx"))

    result_output_image1, result_output_image2 = imagedev.onnx_prediction_two_outputs_2d(grayscale_images_2d_float, model_2d_2outputs, imagedev.OnnxPredictionTwoOutputs2d.NHWC, imagedev.OnnxPredictionTwoOutputs2d.STANDARDIZATION, [0, 1], imagedev.OnnxPredictionTwoOutputs2d.GLOBAL, [128, 128], 32)

    print("output_image1:", str(result_output_image1))
    print("output_image2:", str(result_output_image2))

    ImageView grayscale_images_2d_float = Data.ReadVipImage( @"Data/images/grayscale_images_2d_float.vip" );
    OnnxModel model2d_2outputs = OnnxModel.Read( @"Data/objects/model2d-2outputs.onnx" );

    Processing.OnnxPredictionTwoOutputs2dOutput result = Processing.OnnxPredictionTwoOutputs2d( grayscale_images_2d_float, model2d_2outputs, OnnxPredictionTwoOutputs2d.DataFormat.NHWC, OnnxPredictionTwoOutputs2d.InputNormalizationType.STANDARDIZATION, new double[]{0, 1}, OnnxPredictionTwoOutputs2d.NormalizationScope.GLOBAL, new uint[]{128, 128}, 32 );

    Console.WriteLine( "outputImage1:" + result.outputImage1.ToString() );
    Console.WriteLine( "outputImage2:" + result.outputImage2.ToString() );
    model2d_2outputs.Dispose();

© 2025 Thermo Fisher Scientific Inc. All rights reserved.