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

# CudaGaussianFilter3d

Applies a three-dimensional Gaussian filter using either a separable finite kernel.
Access to parameter description
This command is experimental, his signature may be modified between now and his final version.
This algorithm performs a 3D smoothing filter whose impulse response is a Gaussian function. $$ f(x,y,z) = e^{ \frac{-x ^ 2 }{2\sigma_x ^ 2 } }e^{ \frac{-y ^ 2 }{2\sigma_y ^ 2 }} e^{ \frac{-z ^ 2 }{2\sigma_z ^ 2 } } $$ Where:

- $x$, $y$ and $z$ represent the offsets from the pixel to process,
- $\sigma_x$, $\sigma_y$ and $\sigma_z$ is the standard deviation along each axis.

It can be applied using either a separable or a recursive filter.
The separable mode is based on a Finite Impulse Response (FIR) algorithm applied in separable way (a three-dimensional convolution separated in three one-dimensional filters). Using this mode, the computation time is proportional to the kernel size, which is determined by using the standard deviation and the kernel size factor.
See also

- CudaBoxFilter2d
- CudaMedianFilter2d
- GaussianFilter3d

##
Function Syntax

This function returns outputImage.

    // Function prototype
    std::shared_ptr< iolink::ImageView >
    cudaGaussianFilter3d( std::shared_ptr< iolink::ImageView > inputImage,
                          CudaGaussianFilter3d::FilterMode filterMode,
                          const iolink::Vector3d& standardDeviation,
                          double kernelSizeFactor,
                          CudaGaussianFilter3d::OutputType outputType,
                          bool lowMemory,
                          CudaGaussianFilter3d::TilingMode tilingMode,
                          const iolink::Vector3u32& tileSize,
                          CudaContext::Ptr cudaContext,
                          std::shared_ptr< iolink::ImageView > outputImage = nullptr );

This function returns outputImage.

    // Function prototype.
    cuda_gaussian_filter_3d(input_image: idt.ImageType,
                            filter_mode: CudaGaussianFilter3d.FilterMode = CudaGaussianFilter3d.FilterMode.SEPARABLE,
                            standard_deviation: Union[Iterable[int], Iterable[float]] = [1, 1, 1],
                            kernel_size_factor: float = 2,
                            output_type: CudaGaussianFilter3d.OutputType = CudaGaussianFilter3d.OutputType.SAME_AS_INPUT,
                            low_memory: bool = False,
                            tiling_mode: CudaGaussianFilter3d.TilingMode = CudaGaussianFilter3d.TilingMode.NONE,
                            tile_size: Iterable[int] = [128, 128, 128],
                            cuda_context: Union[CudaContext, None] = None,
                            output_image: idt.ImageType = None) -> idt.ImageType

This function returns outputImage.

    // Function prototype.
    public static IOLink.ImageView
    CudaGaussianFilter3d( IOLink.ImageView inputImage,
                          CudaGaussianFilter3d.FilterMode filterMode = ImageDev.CudaGaussianFilter3d.FilterMode.SEPARABLE,
                          double[] standardDeviation = null,
                          double kernelSizeFactor = 2,
                          CudaGaussianFilter3d.OutputType outputType = ImageDev.CudaGaussianFilter3d.OutputType.SAME_AS_INPUT,
                          bool lowMemory = false,
                          CudaGaussianFilter3d.TilingMode tilingMode = ImageDev.CudaGaussianFilter3d.TilingMode.NONE,
                          uint[] tileSize = null,
                          Data.CudaContext cudaContext = null,
                          IOLink.ImageView outputImage = null );

##
Class Syntax

    // Command constructor.
    CudaGaussianFilter3d();

    /// Gets the inputImage parameter.
    /// The input image. The type of image can be integer or float.@BR
    std::shared_ptr< iolink::ImageView > inputImage() const;
    /// Sets the inputImage parameter.
    /// The input image. The type of image can be integer or float.@BR
    void setInputImage( std::shared_ptr< iolink::ImageView > inputImage );

    /// Gets the filterMode parameter.
    /// The algorithm implementation used to compute the gaussian filter.
    CudaGaussianFilter3d::FilterMode filterMode() const;
    /// Sets the filterMode parameter.
    /// The algorithm implementation used to compute the gaussian filter.
    void setFilterMode( const CudaGaussianFilter3d::FilterMode& filterMode );

    /// Gets the standardDeviation parameter.
    /// The standard deviation value for each direction (X, Y, Z) in voxel units. Each value must be greater or equal to 0.0.
    iolink::Vector3d standardDeviation() const;
    /// Sets the standardDeviation parameter.
    /// The standard deviation value for each direction (X, Y, Z) in voxel units. Each value must be greater or equal to 0.0.
    void setStandardDeviation( const iolink::Vector3d& standardDeviation );

    /// Gets the kernelSizeFactor parameter.
    /// This parameter is used to compute the size of the kernel applied in the SEPARABLE mode. The kernel size value is twice the kernelSizeFactor multiplied by the standard deviation associated with the axis. If the resulting kernel size is even, it is incremented by one in order to ensure an odd kernel size.
    double kernelSizeFactor() const;
    /// Sets the kernelSizeFactor parameter.
    /// This parameter is used to compute the size of the kernel applied in the SEPARABLE mode. The kernel size value is twice the kernelSizeFactor multiplied by the standard deviation associated with the axis. If the resulting kernel size is even, it is incremented by one in order to ensure an odd kernel size.
    void setKernelSizeFactor( const double& kernelSizeFactor );

    /// Gets the outputType parameter.
    /// The output data type. It can either be the same as the input type, or forced to be float. In the case of floating input images, this parameter has no effect.
    CudaGaussianFilter3d::OutputType outputType() const;
    /// Sets the outputType parameter.
    /// The output data type. It can either be the same as the input type, or forced to be float. In the case of floating input images, this parameter has no effect.
    void setOutputType( const CudaGaussianFilter3d::OutputType& outputType );

    /// Gets the lowMemory parameter.
    /// This parameter defines if the SEPARABLE algorithm must limit its memory usage. If equal to false, a temporary 32-bit float image is used to store the result before casting it to the output type. The result is thus less precise and faster to compute when this parameter is set to true.
    bool lowMemory() const;
    /// Sets the lowMemory parameter.
    /// This parameter defines if the SEPARABLE algorithm must limit its memory usage. If equal to false, a temporary 32-bit float image is used to store the result before casting it to the output type. The result is thus less precise and faster to compute when this parameter is set to true.
    void setLowMemory( const bool& lowMemory );

    /// Gets the tilingMode parameter.
    /// The way to manage the GPU memory.
    CudaGaussianFilter3d::TilingMode tilingMode() const;
    /// Sets the tilingMode parameter.
    /// The way to manage the GPU memory.
    void setTilingMode( const CudaGaussianFilter3d::TilingMode& tilingMode );

    /// Gets the tileSize parameter.
    /// The tile width and height in pixels. This parameter is used only in USER_DEFINED tiling mode.
    iolink::Vector3u32 tileSize() const;
    /// Sets the tileSize parameter.
    /// The tile width and height in pixels. This parameter is used only in USER_DEFINED tiling mode.
    void setTileSize( const iolink::Vector3u32& tileSize );

    /// Gets the cudaContext parameter.
    /// CUDA context information.
    CudaContext::Ptr cudaContext() const;
    /// Sets the cudaContext parameter.
    /// CUDA context information.
    void setCudaContext( const CudaContext::Ptr& cudaContext );

    /// Gets the outputImage parameter.
    /// The output image. Dimensions, calibration, and interpretation of the output image are forced to the same values as the input.
    std::shared_ptr< iolink::ImageView > outputImage() const;
    /// Sets the outputImage parameter.
    /// The output image. Dimensions, calibration, and interpretation of the output image are forced to the same values as the input.
    void setOutputImage( std::shared_ptr< iolink::ImageView > outputImage );

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

    # Property of the inputImage parameter.
    CudaGaussianFilter3d.input_image
    # Property of the filterMode parameter.
    CudaGaussianFilter3d.filter_mode
    # Property of the standardDeviation parameter.
    CudaGaussianFilter3d.standard_deviation
    # Property of the kernelSizeFactor parameter.
    CudaGaussianFilter3d.kernel_size_factor
    # Property of the outputType parameter.
    CudaGaussianFilter3d.output_type
    # Property of the lowMemory parameter.
    CudaGaussianFilter3d.low_memory
    # Property of the tilingMode parameter.
    CudaGaussianFilter3d.tiling_mode
    # Property of the tileSize parameter.
    CudaGaussianFilter3d.tile_size
    # Property of the cudaContext parameter.
    CudaGaussianFilter3d.cuda_context
    # Property of the outputImage parameter.
    CudaGaussianFilter3d.output_image

    // Method to launch the command.
    execute()

    // Command constructor.
    CudaGaussianFilter3d()

    // Property of the inputImage parameter.
    CudaGaussianFilter3d.inputImage
    // Property of the filterMode parameter.
    CudaGaussianFilter3d.filterMode
    // Property of the standardDeviation parameter.
    CudaGaussianFilter3d.standardDeviation
    // Property of the kernelSizeFactor parameter.
    CudaGaussianFilter3d.kernelSizeFactor
    // Property of the outputType parameter.
    CudaGaussianFilter3d.outputType
    // Property of the lowMemory parameter.
    CudaGaussianFilter3d.lowMemory
    // Property of the tilingMode parameter.
    CudaGaussianFilter3d.tilingMode
    // Property of the tileSize parameter.
    CudaGaussianFilter3d.tileSize
    // Property of the cudaContext parameter.
    CudaGaussianFilter3d.cudaContext
    // Property of the outputImage parameter.
    CudaGaussianFilter3d.outputImage

    // Method to launch the command.
    Execute()

## Parameters

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| inputImage | The input image. The type of image can be integer or float. | Image | Binary, Label, Grayscale or Multispectral | nullptr
| filterMode | The algorithm implementation used to compute the gaussian filter.
SEPARABLE | This mode uses a Finite Impulse Response algorithm on the X, Y, and Z directions.
| Enumeration |  | SEPARABLE
| standardDeviation | The standard deviation value for each direction (X, Y, Z) in voxel units. Each value must be greater or equal to 0.0. | Vector3d | >=0 | {1.f, 1.f, 1.f}
| kernelSizeFactor | This parameter is used to compute the size of the kernel applied in the SEPARABLE mode. The kernel size value is twice the kernelSizeFactor multiplied by the standard deviation associated with the axis. If the resulting kernel size is even, it is incremented by one in order to ensure an odd kernel size. | Float64 | >0 | 2
| outputType | The output data type. It can either be the same as the input type, or forced to be float. In the case of floating input images, this parameter has no effect.
SAME_AS_INPUT | The output image has same type as the input image. In the case of integer images, this mode can lead to a loss of precision.
FLOAT_32_BIT | The output image type is forced to floating point.
| Enumeration |  | SAME_AS_INPUT
| lowMemory | This parameter defines if the SEPARABLE algorithm must limit its memory usage. If equal to false, a temporary 32-bit float image is used to store the result before casting it to the output type. The result is thus less precise and faster to compute when this parameter is set to true. | Bool |  | false
| tilingMode | The way to manage the GPU memory.
NONE | The entire input image is transferred to the GPU memory. If the total input, intermediate and output data size exceed the GPU memory, the computation will fail.
USER_DEFINED | The input image is processed by tiles of a predefined size.
| Enumeration |  | NONE
| tileSize | The tile width and height in pixels. This parameter is used only in USER_DEFINED tiling mode. | Vector3u32 | Any value | {128, 128, 128}
| cudaContext | CUDA context information. | CudaContext |  | nullptr
| outputImage | The output image. Dimensions, calibration, and interpretation of the output image are forced to the same values as the input. | Image |  | nullptr

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| input_image | The input image. The type of image can be integer or float. | image | Binary, Label, Grayscale or Multispectral | None
| filter_mode | The algorithm implementation used to compute the gaussian filter.
SEPARABLE | This mode uses a Finite Impulse Response algorithm on the X, Y, and Z directions.
| enumeration |  | SEPARABLE
| standard_deviation | The standard deviation value for each direction (X, Y, Z) in voxel units. Each value must be greater or equal to 0.0. | vector3d | >=0 | [1, 1, 1]
| kernel_size_factor | This parameter is used to compute the size of the kernel applied in the SEPARABLE mode. The kernel size value is twice the kernelSizeFactor multiplied by the standard deviation associated with the axis. If the resulting kernel size is even, it is incremented by one in order to ensure an odd kernel size. | float64 | >0 | 2
| output_type | The output data type. It can either be the same as the input type, or forced to be float. In the case of floating input images, this parameter has no effect.
SAME_AS_INPUT | The output image has same type as the input image. In the case of integer images, this mode can lead to a loss of precision.
FLOAT_32_BIT | The output image type is forced to floating point.
| enumeration |  | SAME_AS_INPUT
| low_memory | This parameter defines if the SEPARABLE algorithm must limit its memory usage. If equal to false, a temporary 32-bit float image is used to store the result before casting it to the output type. The result is thus less precise and faster to compute when this parameter is set to true. | bool |  | False
| tiling_mode | The way to manage the GPU memory.
NONE | The entire input image is transferred to the GPU memory. If the total input, intermediate and output data size exceed the GPU memory, the computation will fail.
USER_DEFINED | The input image is processed by tiles of a predefined size.
| enumeration |  | NONE
| tile_size | The tile width and height in pixels. This parameter is used only in USER_DEFINED tiling mode. | vector3u32 | Any value | [128, 128, 128]
| cuda_context | CUDA context information. | cuda_context |  | None
| output_image | The output image. Dimensions, calibration, and interpretation of the output image are forced to the same values as the input. | image |  | None

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| inputImage | The input image. The type of image can be integer or float. | Image | Binary, Label, Grayscale or Multispectral | null
| filterMode | The algorithm implementation used to compute the gaussian filter.
SEPARABLE | This mode uses a Finite Impulse Response algorithm on the X, Y, and Z directions.
| Enumeration |  | SEPARABLE
| standardDeviation | The standard deviation value for each direction (X, Y, Z) in voxel units. Each value must be greater or equal to 0.0. | Vector3d | >=0 | {1f, 1f, 1f}
| kernelSizeFactor | This parameter is used to compute the size of the kernel applied in the SEPARABLE mode. The kernel size value is twice the kernelSizeFactor multiplied by the standard deviation associated with the axis. If the resulting kernel size is even, it is incremented by one in order to ensure an odd kernel size. | Float64 | >0 | 2
| outputType | The output data type. It can either be the same as the input type, or forced to be float. In the case of floating input images, this parameter has no effect.
SAME_AS_INPUT | The output image has same type as the input image. In the case of integer images, this mode can lead to a loss of precision.
FLOAT_32_BIT | The output image type is forced to floating point.
| Enumeration |  | SAME_AS_INPUT
| lowMemory | This parameter defines if the SEPARABLE algorithm must limit its memory usage. If equal to false, a temporary 32-bit float image is used to store the result before casting it to the output type. The result is thus less precise and faster to compute when this parameter is set to true. | Bool |  | false
| tilingMode | The way to manage the GPU memory.
NONE | The entire input image is transferred to the GPU memory. If the total input, intermediate and output data size exceed the GPU memory, the computation will fail.
USER_DEFINED | The input image is processed by tiles of a predefined size.
| Enumeration |  | NONE
| tileSize | The tile width and height in pixels. This parameter is used only in USER_DEFINED tiling mode. | Vector3u32 | Any value | {128, 128, 128}
| cudaContext | CUDA context information. | CudaContext |  | null
| outputImage | The output image. Dimensions, calibration, and interpretation of the output image are forced to the same values as the input. | Image |  | null

## Object Examples

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

    CudaGaussianFilter3d cudaGaussianFilter3dAlgo;
    cudaGaussianFilter3dAlgo.setInputImage( foam );
    cudaGaussianFilter3dAlgo.setFilterMode( CudaGaussianFilter3d::FilterMode::SEPARABLE );
    cudaGaussianFilter3dAlgo.setStandardDeviation( {1.0, 1.0, 1.0} );
    cudaGaussianFilter3dAlgo.setKernelSizeFactor( 2.0 );
    cudaGaussianFilter3dAlgo.setOutputType( CudaGaussianFilter3d::OutputType::SAME_AS_INPUT );
    cudaGaussianFilter3dAlgo.setLowMemory( false );
    cudaGaussianFilter3dAlgo.setTilingMode( CudaGaussianFilter3d::TilingMode::NONE );
    cudaGaussianFilter3dAlgo.setTileSize( {128, 128, 128} );
    cudaGaussianFilter3dAlgo.setCudaContext( nullptr );
    cudaGaussianFilter3dAlgo.setOutputImage( iolink::ImageViewFactory::allocate( iolink::VectorXu64( { 1, 1 } ), iolink::DataTypeId::UINT8 ) );
    cudaGaussianFilter3dAlgo.execute();

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

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

    cuda_gaussian_filter_3d_algo = imagedev.CudaGaussianFilter3d()
    cuda_gaussian_filter_3d_algo.input_image = foam
    cuda_gaussian_filter_3d_algo.filter_mode = imagedev.CudaGaussianFilter3d.SEPARABLE
    cuda_gaussian_filter_3d_algo.standard_deviation = [1.0, 1.0, 1.0]
    cuda_gaussian_filter_3d_algo.kernel_size_factor = 2.0
    cuda_gaussian_filter_3d_algo.output_type = imagedev.CudaGaussianFilter3d.SAME_AS_INPUT
    cuda_gaussian_filter_3d_algo.low_memory = False
    cuda_gaussian_filter_3d_algo.tiling_mode = imagedev.CudaGaussianFilter3d.NONE
    cuda_gaussian_filter_3d_algo.tile_size = [128, 128, 128]
    cuda_gaussian_filter_3d_algo.cuda_context = None
    cuda_gaussian_filter_3d_algo.execute()

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

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

    CudaGaussianFilter3d cudaGaussianFilter3dAlgo = new CudaGaussianFilter3d
    {
        inputImage = foam,
        filterMode = CudaGaussianFilter3d.FilterMode.SEPARABLE,
        standardDeviation = new double[]{1.0, 1.0, 1.0},
        kernelSizeFactor = 2.0,
        outputType = CudaGaussianFilter3d.OutputType.SAME_AS_INPUT,
        lowMemory = false,
        tilingMode = CudaGaussianFilter3d.TilingMode.NONE,
        tileSize = new uint[]{128, 128, 128},
        cudaContext = null
    };
    cudaGaussianFilter3dAlgo.Execute();

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

## Function Examples

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

    auto result = cudaGaussianFilter3d( foam, CudaGaussianFilter3d::FilterMode::SEPARABLE, {1.0, 1.0, 1.0}, 2.0, CudaGaussianFilter3d::OutputType::SAME_AS_INPUT, false, CudaGaussianFilter3d::TilingMode::NONE, {128, 128, 128}, nullptr , iolink::ImageViewFactory::allocate( iolink::VectorXu64( { 1, 1 } ), iolink::DataTypeId::UINT8 ));

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

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

    result = imagedev.cuda_gaussian_filter_3d(foam, imagedev.CudaGaussianFilter3d.SEPARABLE, [1.0, 1.0, 1.0], 2.0, imagedev.CudaGaussianFilter3d.SAME_AS_INPUT, False, imagedev.CudaGaussianFilter3d.NONE, [128, 128, 128], None)

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

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

    IOLink.ImageView result = Processing.CudaGaussianFilter3d( foam, CudaGaussianFilter3d.FilterMode.SEPARABLE, new double[]{1.0, 1.0, 1.0}, 2.0, CudaGaussianFilter3d.OutputType.SAME_AS_INPUT, false, CudaGaussianFilter3d.TilingMode.NONE, new uint[]{128, 128, 128}, null );

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

© 2025 Thermo Fisher Scientific Inc. All rights reserved.