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

# OnnxPredictionFiltering3d

Computes a prediction on a three-dimensional image from an ONNX model and generates an image representing the prediction scores.
Access to parameter description
For an overview, please refer to the Deep Learning section.
This algorithm produces an image containing the raw prediction scores given by 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.
The following steps are applied:

- Pre-processing
- Prediction
- Post-processing to optionally restore the prediction result into the input data range

See also

- ReadOnnxModel
- OnnxPredictionSegmentation3d
- OnnxPredictionTwoOutputs3d
- OnnxPredictionFiltering2d

##
Function Syntax

This function returns outputImage.

    // Function prototype
    std::shared_ptr< iolink::ImageView >
    onnxPredictionFiltering3d( std::shared_ptr< iolink::ImageView > inputImage,
                               OnnxModel::Ptr inputOnnxModel,
                               OnnxPredictionFiltering3d::DataFormat dataFormat,
                               OnnxPredictionFiltering3d::InputNormalizationType inputNormalizationType,
                               const iolink::Vector2d& normalizationRange,
                               OnnxPredictionFiltering3d::NormalizationScope normalizationScope,
                               const iolink::Vector3u32& tileSize,
                               uint32_t tileOverlap,
                               OnnxPredictionFiltering3d::OutputNormalizationType outputNormalizationType,
                               OnnxPredictionFiltering3d::OutputType outputType,
                               std::shared_ptr< iolink::ImageView > outputImage = nullptr );

This function returns outputImage.

    // Function prototype.
    onnx_prediction_filtering_3d(input_image: idt.ImageType,
                                 input_onnx_model: Union[Any, None] = None,
                                 data_format: OnnxPredictionFiltering3d.DataFormat = OnnxPredictionFiltering3d.DataFormat.NDHWC,
                                 input_normalization_type: OnnxPredictionFiltering3d.InputNormalizationType = OnnxPredictionFiltering3d.InputNormalizationType.STANDARDIZATION,
                                 normalization_range: Union[Iterable[int], Iterable[float]] = [0, 1],
                                 normalization_scope: OnnxPredictionFiltering3d.NormalizationScope = OnnxPredictionFiltering3d.NormalizationScope.GLOBAL,
                                 tile_size: Iterable[int] = [128, 128, 128],
                                 tile_overlap: int = 16,
                                 output_normalization_type: OnnxPredictionFiltering3d.OutputNormalizationType = OnnxPredictionFiltering3d.OutputNormalizationType.NONE,
                                 output_type: OnnxPredictionFiltering3d.OutputType = OnnxPredictionFiltering3d.OutputType.SAME_AS_INPUT,
                                 output_image: idt.ImageType = None) -> idt.ImageType

This function returns outputImage.

    // Function prototype.
    public static IOLink.ImageView
    OnnxPredictionFiltering3d( IOLink.ImageView inputImage,
                               OnnxModel inputOnnxModel = null,
                               OnnxPredictionFiltering3d.DataFormat dataFormat = ImageDev.OnnxPredictionFiltering3d.DataFormat.NDHWC,
                               OnnxPredictionFiltering3d.InputNormalizationType inputNormalizationType = ImageDev.OnnxPredictionFiltering3d.InputNormalizationType.STANDARDIZATION,
                               double[] normalizationRange = null,
                               OnnxPredictionFiltering3d.NormalizationScope normalizationScope = ImageDev.OnnxPredictionFiltering3d.NormalizationScope.GLOBAL,
                               uint[] tileSize = null,
                               UInt32 tileOverlap = 16,
                               OnnxPredictionFiltering3d.OutputNormalizationType outputNormalizationType = ImageDev.OnnxPredictionFiltering3d.OutputNormalizationType.NONE,
                               OnnxPredictionFiltering3d.OutputType outputType = ImageDev.OnnxPredictionFiltering3d.OutputType.SAME_AS_INPUT,
                               IOLink.ImageView outputImage = null );

##
Class Syntax

    // Command constructor.
    OnnxPredictionFiltering3d();

    /// 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.
    OnnxPredictionFiltering3d::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 OnnxPredictionFiltering3d::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.
    OnnxPredictionFiltering3d::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 OnnxPredictionFiltering3d::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.
    OnnxPredictionFiltering3d::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 OnnxPredictionFiltering3d::NormalizationScope& normalizationScope );

    /// Gets the tileSize parameter.
    /// The width, height, and depth 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::Vector3u32 tileSize() const;
    /// Sets the tileSize parameter.
    /// The width, height, and depth 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::Vector3u32& 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 outputNormalizationType parameter.
    /// The type of normalization to apply after computing the prediction. This parameter is ignored if the input normalization type is set to NONE.
    OnnxPredictionFiltering3d::OutputNormalizationType outputNormalizationType() const;
    /// Sets the outputNormalizationType parameter.
    /// The type of normalization to apply after computing the prediction. This parameter is ignored if the input normalization type is set to NONE.
    void setOutputNormalizationType( const OnnxPredictionFiltering3d::OutputNormalizationType& outputNormalizationType );

    /// Gets the outputType parameter.
    /// The output data type. It can either be the same as the input type or forced to float. This parameter is ignored if the input normalization type is set to NONE.
    OnnxPredictionFiltering3d::OutputType outputType() const;
    /// Sets the outputType parameter.
    /// The output data type. It can either be the same as the input type or forced to float. This parameter is ignored if the input normalization type is set to NONE.
    void setOutputType( const OnnxPredictionFiltering3d::OutputType& outputType );

    /// Gets the outputImage parameter.
    /// The output image. Its spatial dimensions, and calibration are forced to the same values as the input. Its number of channels depends on the selected model. Its type depends on the selected output type.
    std::shared_ptr< iolink::ImageView > outputImage() const;
    /// Sets the outputImage parameter.
    /// The output image. Its spatial dimensions, and calibration are forced to the same values as the input. Its number of channels depends on the selected model. Its type depends on the selected output type.
    void setOutputImage( std::shared_ptr< iolink::ImageView > outputImage );

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

    # Property of the inputImage parameter.
    OnnxPredictionFiltering3d.input_image
    # Property of the inputOnnxModel parameter.
    OnnxPredictionFiltering3d.input_onnx_model
    # Property of the dataFormat parameter.
    OnnxPredictionFiltering3d.data_format
    # Property of the inputNormalizationType parameter.
    OnnxPredictionFiltering3d.input_normalization_type
    # Property of the normalizationRange parameter.
    OnnxPredictionFiltering3d.normalization_range
    # Property of the normalizationScope parameter.
    OnnxPredictionFiltering3d.normalization_scope
    # Property of the tileSize parameter.
    OnnxPredictionFiltering3d.tile_size
    # Property of the tileOverlap parameter.
    OnnxPredictionFiltering3d.tile_overlap
    # Property of the outputNormalizationType parameter.
    OnnxPredictionFiltering3d.output_normalization_type
    # Property of the outputType parameter.
    OnnxPredictionFiltering3d.output_type
    # Property of the outputImage parameter.
    OnnxPredictionFiltering3d.output_image

    // Method to launch the command.
    execute()

    // Command constructor.
    OnnxPredictionFiltering3d()

    // Property of the inputImage parameter.
    OnnxPredictionFiltering3d.inputImage
    // Property of the inputOnnxModel parameter.
    OnnxPredictionFiltering3d.inputOnnxModel
    // Property of the dataFormat parameter.
    OnnxPredictionFiltering3d.dataFormat
    // Property of the inputNormalizationType parameter.
    OnnxPredictionFiltering3d.inputNormalizationType
    // Property of the normalizationRange parameter.
    OnnxPredictionFiltering3d.normalizationRange
    // Property of the normalizationScope parameter.
    OnnxPredictionFiltering3d.normalizationScope
    // Property of the tileSize parameter.
    OnnxPredictionFiltering3d.tileSize
    // Property of the tileOverlap parameter.
    OnnxPredictionFiltering3d.tileOverlap
    // Property of the outputNormalizationType parameter.
    OnnxPredictionFiltering3d.outputNormalizationType
    // Property of the outputType parameter.
    OnnxPredictionFiltering3d.outputType
    // Property of the outputImage parameter.
    OnnxPredictionFiltering3d.outputImage

    // 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.
NDHWC | The layout is organized with interlaced channels. For instance, if the input is a color image, each pixel presents its RGB components successively.
NCDHW | The layout is organized with separate channels. Each channel is an individual plane.
| Enumeration |  | NDHWC
| 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_VOLUME | The normalization is applied individually on each image of the input batch.
| Enumeration |  | GLOBAL
| tileSize | The width, height, and depth 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. | Vector3u32 | != 0 | {128, 128, 128}
| 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 | 16
| outputNormalizationType | The type of normalization to apply after computing the prediction. This parameter is ignored if the input normalization type is set to NONE.
NONE | No normalization is applied on the output image.
INVERSE | The inverse operation is applied to set the output image in the same range as the input.
| Enumeration |  | NONE
| outputType | The output data type. It can either be the same as the input type or forced to float. This parameter is ignored if the input normalization type is set to NONE.
SAME_AS_INPUT | The output image has the same type as the input image.
FLOAT_32_BIT | The output image type is forced to floating point.
| Enumeration |  | SAME_AS_INPUT
| outputImage | The output image. Its spatial dimensions, and calibration are forced to the same values as the input. Its number of channels depends on the selected model. Its type depends on the selected output type. | 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.
NDHWC | The layout is organized with interlaced channels. For instance, if the input is a color image, each pixel presents its RGB components successively.
NCDHW | The layout is organized with separate channels. Each channel is an individual plane.
| enumeration |  | NDHWC
| 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_VOLUME | The normalization is applied individually on each image of the input batch.
| enumeration |  | GLOBAL
| tile_size | The width, height, and depth 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. | vector3u32 | != 0 | [128, 128, 128]
| 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 | 16
| output_normalization_type | The type of normalization to apply after computing the prediction. This parameter is ignored if the input normalization type is set to NONE.
NONE | No normalization is applied on the output image.
INVERSE | The inverse operation is applied to set the output image in the same range as the input.
| enumeration |  | NONE
| output_type | The output data type. It can either be the same as the input type or forced to float. This parameter is ignored if the input normalization type is set to NONE.
SAME_AS_INPUT | The output image has the same type as the input image.
FLOAT_32_BIT | The output image type is forced to floating point.
| enumeration |  | SAME_AS_INPUT
| output_image | The output image. Its spatial dimensions, and calibration are forced to the same values as the input. Its number of channels depends on the selected model. Its type depends on the selected output type. | 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.
NDHWC | The layout is organized with interlaced channels. For instance, if the input is a color image, each pixel presents its RGB components successively.
NCDHW | The layout is organized with separate channels. Each channel is an individual plane.
| Enumeration |  | NDHWC
| 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_VOLUME | The normalization is applied individually on each image of the input batch.
| Enumeration |  | GLOBAL
| tileSize | The width, height, and depth 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. | Vector3u32 | != 0 | {128, 128, 128}
| 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 | 16
| outputNormalizationType | The type of normalization to apply after computing the prediction. This parameter is ignored if the input normalization type is set to NONE.
NONE | No normalization is applied on the output image.
INVERSE | The inverse operation is applied to set the output image in the same range as the input.
| Enumeration |  | NONE
| outputType | The output data type. It can either be the same as the input type or forced to float. This parameter is ignored if the input normalization type is set to NONE.
SAME_AS_INPUT | The output image has the same type as the input image.
FLOAT_32_BIT | The output image type is forced to floating point.
| Enumeration |  | SAME_AS_INPUT
| outputImage | The output image. Its spatial dimensions, and calibration are forced to the same values as the input. Its number of channels depends on the selected model. Its type depends on the selected output type. | Image |  | null

## Object Examples

    auto chocolate_bar = readVipImage( std::string( IMAGEDEVDATA_IMAGES_FOLDER ) + "chocolate_bar.vip" );
    OnnxModel::Ptr segmentation3d= OnnxModel::read( std::string( IMAGEDEVDATA_OBJECTS_FOLDER ) + "segmentation3d.onnx" );

    OnnxPredictionFiltering3d onnxPredictionFiltering3dAlgo;
    onnxPredictionFiltering3dAlgo.setInputImage( chocolate_bar );
    onnxPredictionFiltering3dAlgo.setInputOnnxModel( segmentation3d );
    onnxPredictionFiltering3dAlgo.setDataFormat( OnnxPredictionFiltering3d::DataFormat::NDHWC );
    onnxPredictionFiltering3dAlgo.setInputNormalizationType( OnnxPredictionFiltering3d::InputNormalizationType::NONE );
    onnxPredictionFiltering3dAlgo.setNormalizationRange( {0, 1} );
    onnxPredictionFiltering3dAlgo.setNormalizationScope( OnnxPredictionFiltering3d::NormalizationScope::GLOBAL );
    onnxPredictionFiltering3dAlgo.setTileSize( {128, 128, 128} );
    onnxPredictionFiltering3dAlgo.setTileOverlap( 16 );
    onnxPredictionFiltering3dAlgo.setOutputNormalizationType( OnnxPredictionFiltering3d::OutputNormalizationType::NONE );
    onnxPredictionFiltering3dAlgo.setOutputType( OnnxPredictionFiltering3d::OutputType::SAME_AS_INPUT );
    onnxPredictionFiltering3dAlgo.execute();

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

    chocolate_bar = imagedev.read_vip_image(imagedev_data.get_image_path("chocolate_bar.vip"))
    segmentation_3d = imagedev.OnnxModel.read(imagedev_data.get_object_path("segmentation3d.onnx"))

    onnx_prediction_filtering_3d_algo = imagedev.OnnxPredictionFiltering3d()
    onnx_prediction_filtering_3d_algo.input_image = chocolate_bar
    onnx_prediction_filtering_3d_algo.input_onnx_model = segmentation_3d
    onnx_prediction_filtering_3d_algo.data_format = imagedev.OnnxPredictionFiltering3d.NDHWC
    onnx_prediction_filtering_3d_algo.input_normalization_type = imagedev.OnnxPredictionFiltering3d.InputNormalizationType.NONE
    onnx_prediction_filtering_3d_algo.normalization_range = [0, 1]
    onnx_prediction_filtering_3d_algo.normalization_scope = imagedev.OnnxPredictionFiltering3d.GLOBAL
    onnx_prediction_filtering_3d_algo.tile_size = [128, 128, 128]
    onnx_prediction_filtering_3d_algo.tile_overlap = 16
    onnx_prediction_filtering_3d_algo.output_normalization_type = imagedev.OnnxPredictionFiltering3d.OutputNormalizationType.NONE
    onnx_prediction_filtering_3d_algo.output_type = imagedev.OnnxPredictionFiltering3d.SAME_AS_INPUT
    onnx_prediction_filtering_3d_algo.execute()

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

    ImageView chocolate_bar = Data.ReadVipImage( @"Data/images/chocolate_bar.vip" );
    OnnxModel segmentation3d = OnnxModel.Read( @"Data/objects/segmentation3d.onnx" );

    OnnxPredictionFiltering3d onnxPredictionFiltering3dAlgo = new OnnxPredictionFiltering3d
    {
        inputImage = chocolate_bar,
        inputOnnxModel = segmentation3d,
        dataFormat = OnnxPredictionFiltering3d.DataFormat.NDHWC,
        inputNormalizationType = OnnxPredictionFiltering3d.InputNormalizationType.NONE,
        normalizationRange = new double[]{0, 1},
        normalizationScope = OnnxPredictionFiltering3d.NormalizationScope.GLOBAL,
        tileSize = new uint[]{128, 128, 128},
        tileOverlap = 16,
        outputNormalizationType = OnnxPredictionFiltering3d.OutputNormalizationType.NONE,
        outputType = OnnxPredictionFiltering3d.OutputType.SAME_AS_INPUT
    };
    onnxPredictionFiltering3dAlgo.Execute();

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

## Function Examples

    auto chocolate_bar = readVipImage( std::string( IMAGEDEVDATA_IMAGES_FOLDER ) + "chocolate_bar.vip" );
    OnnxModel::Ptr segmentation3d= OnnxModel::read( std::string( IMAGEDEVDATA_OBJECTS_FOLDER ) + "segmentation3d.onnx" );

    auto result = onnxPredictionFiltering3d( chocolate_bar, segmentation3d, OnnxPredictionFiltering3d::DataFormat::NDHWC, OnnxPredictionFiltering3d::InputNormalizationType::NONE, {0, 1}, OnnxPredictionFiltering3d::NormalizationScope::GLOBAL, {128, 128, 128}, 16, OnnxPredictionFiltering3d::OutputNormalizationType::NONE, OnnxPredictionFiltering3d::OutputType::SAME_AS_INPUT );

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

    chocolate_bar = imagedev.read_vip_image(imagedev_data.get_image_path("chocolate_bar.vip"))
    segmentation_3d = imagedev.OnnxModel.read(imagedev_data.get_object_path("segmentation3d.onnx"))

    result = imagedev.onnx_prediction_filtering_3d(chocolate_bar, segmentation_3d, imagedev.OnnxPredictionFiltering3d.NDHWC, imagedev.OnnxPredictionFiltering3d.InputNormalizationType.NONE, [0, 1], imagedev.OnnxPredictionFiltering3d.GLOBAL, [128, 128, 128], 16, imagedev.OnnxPredictionFiltering3d.OutputNormalizationType.NONE, imagedev.OnnxPredictionFiltering3d.SAME_AS_INPUT)

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

    ImageView chocolate_bar = Data.ReadVipImage( @"Data/images/chocolate_bar.vip" );
    OnnxModel segmentation3d = OnnxModel.Read( @"Data/objects/segmentation3d.onnx" );

    IOLink.ImageView result = Processing.OnnxPredictionFiltering3d( chocolate_bar, segmentation3d, OnnxPredictionFiltering3d.DataFormat.NDHWC, OnnxPredictionFiltering3d.InputNormalizationType.NONE, new double[]{0, 1}, OnnxPredictionFiltering3d.NormalizationScope.GLOBAL, new uint[]{128, 128, 128}, 16, OnnxPredictionFiltering3d.OutputNormalizationType.NONE, OnnxPredictionFiltering3d.OutputType.SAME_AS_INPUT );

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

© 2025 Thermo Fisher Scientific Inc. All rights reserved.