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

# RichardsonLucyDeconvolution

Restores a microscopy image with the Richardson-Lucy deconvolution.
Access to parameter description
This command is experimental, his signature may be modified between now and his final version.
This algorithm performs a fixed number of deconvolution steps using the Richardson Lucy deconvolution method which aims to remove the blur induced by the optical system, modelized by a Point Spread Function (PSF).
The process begins with an initial estimate of the output image, which is iteratively refined. At each iteration, the algorithm compares the convolution of the current estimate with the input PSF and updates the estimate accordingly.
The convolution can be performed either with a spatial or a frequency mode. When the size of the PSF is quite small (e.g., a 9x9x9 image in 3D), the spatial mode is faster to compute. However, the frequency mode is almost invariant with the PSF size and thus can be faster with high PSF (e.g., a 51x51x51 image in 3D). In any case, the frequency mode is much more memory consuming since it requires several 32-bit intermediate images to computes Fast Fourier Transforms (FFT). The threshold PSF size for having better performances between spatial and frequency modes depends on several criteria such as the input image size, type, and the used hardware (processor speed, number of threads, available RAM). It needs to be determined empirically.
The deconvolution can be performed on spectal images but need a spectral PSF to work properly.
Figure 1. Spatial and frequency mode time depending on the kernel size. (Done on a 1038x1038x30 image with 10 iterations with an Intel(R) Core(TM) i7-13850HX with 28 logicals processors).
References

- W.H. Richardson. "Bayesian-Based Iterative Method of Image Restoration". Journal of the Optical Society of America, vol. v62, is. 1, pp. 55-59, 1972.
- L.B. Lucy, An iterative technique for the rectification of observed distributions , Astronomical Journal, vol. 79, is. 6, pp. 745-754, 1974.

See also

- PointSpreadFunctionImage3d

##
Function Syntax

This function returns outputImage.

    // Function prototype
    std::shared_ptr< iolink::ImageView >
    richardsonLucyDeconvolution( std::shared_ptr< iolink::ImageView > inputImage,
                                 std::shared_ptr< iolink::ImageView > inputPsfImage,
                                 uint32_t numberOfIterations,
                                 RichardsonLucyDeconvolution::InitialEstimate initialEstimate,
                                 RichardsonLucyDeconvolution::FilterMode filterMode,
                                 std::shared_ptr< iolink::ImageView > outputImage = nullptr );

This function returns outputImage.

    // Function prototype.
    richardson_lucy_deconvolution(input_image: idt.ImageType,
                                  input_psf_image: idt.ImageType,
                                  number_of_iterations: int = 10,
                                  initial_estimate: RichardsonLucyDeconvolution.InitialEstimate = RichardsonLucyDeconvolution.InitialEstimate.CONSTANT,
                                  filter_mode: RichardsonLucyDeconvolution.FilterMode = RichardsonLucyDeconvolution.FilterMode.SPATIAL,
                                  output_image: idt.ImageType = None) -> idt.ImageType

This function returns outputImage.

    // Function prototype.
    public static IOLink.ImageView
    RichardsonLucyDeconvolution( IOLink.ImageView inputImage,
                                 IOLink.ImageView inputPsfImage,
                                 UInt32 numberOfIterations = 10,
                                 RichardsonLucyDeconvolution.InitialEstimate initialEstimate = ImageDev.RichardsonLucyDeconvolution.InitialEstimate.CONSTANT,
                                 RichardsonLucyDeconvolution.FilterMode filterMode = ImageDev.RichardsonLucyDeconvolution.FilterMode.SPATIAL,
                                 IOLink.ImageView outputImage = null );

##
Class Syntax

    // Command constructor.
    RichardsonLucyDeconvolution();

    /// Gets the inputImage parameter.
    /// The input image.
    std::shared_ptr< iolink::ImageView > inputImage() const;
    /// Sets the inputImage parameter.
    /// The input image.
    void setInputImage( std::shared_ptr< iolink::ImageView > inputImage );

    /// Gets the inputPsfImage parameter.
    /// The point spread function (PSF) that models the degradation filter. The PSF is passed as an image.
    std::shared_ptr< iolink::ImageView > inputPsfImage() const;
    /// Sets the inputPsfImage parameter.
    /// The point spread function (PSF) that models the degradation filter. The PSF is passed as an image.
    void setInputPsfImage( std::shared_ptr< iolink::ImageView > inputPsfImage );

    /// Gets the numberOfIterations parameter.
    /// The number of iterations performed.
    uint32_t numberOfIterations() const;
    /// Sets the numberOfIterations parameter.
    /// The number of iterations performed.
    void setNumberOfIterations( const uint32_t& numberOfIterations );

    /// Gets the initialEstimate parameter.
    /// The initial estimate of the deconvolution algorithm. If CONSTANT is chosen, a constant image is used initially.  Often, this yields smoother results than the second option, namely input data.
    RichardsonLucyDeconvolution::InitialEstimate initialEstimate() const;
    /// Sets the initialEstimate parameter.
    /// The initial estimate of the deconvolution algorithm. If CONSTANT is chosen, a constant image is used initially.  Often, this yields smoother results than the second option, namely input data.
    void setInitialEstimate( const RichardsonLucyDeconvolution::InitialEstimate& initialEstimate );

    /// Gets the filterMode parameter.
    /// The algorithm implementation used to perform the convolution.
    RichardsonLucyDeconvolution::FilterMode filterMode() const;
    /// Sets the filterMode parameter.
    /// The algorithm implementation used to perform the convolution.
    void setFilterMode( const RichardsonLucyDeconvolution::FilterMode& filterMode );

    /// Gets the outputImage parameter.
    /// The output image. The output image characteristics are forced to the same as the input image.
    std::shared_ptr< iolink::ImageView > outputImage() const;
    /// Sets the outputImage parameter.
    /// The output image. The output image characteristics are forced to the same as the input image.
    void setOutputImage( std::shared_ptr< iolink::ImageView > outputImage );

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

    # Property of the inputImage parameter.
    RichardsonLucyDeconvolution.input_image
    # Property of the inputPsfImage parameter.
    RichardsonLucyDeconvolution.input_psf_image
    # Property of the numberOfIterations parameter.
    RichardsonLucyDeconvolution.number_of_iterations
    # Property of the initialEstimate parameter.
    RichardsonLucyDeconvolution.initial_estimate
    # Property of the filterMode parameter.
    RichardsonLucyDeconvolution.filter_mode
    # Property of the outputImage parameter.
    RichardsonLucyDeconvolution.output_image

    // Method to launch the command.
    execute()

    // Command constructor.
    RichardsonLucyDeconvolution()

    // Property of the inputImage parameter.
    RichardsonLucyDeconvolution.inputImage
    // Property of the inputPsfImage parameter.
    RichardsonLucyDeconvolution.inputPsfImage
    // Property of the numberOfIterations parameter.
    RichardsonLucyDeconvolution.numberOfIterations
    // Property of the initialEstimate parameter.
    RichardsonLucyDeconvolution.initialEstimate
    // Property of the filterMode parameter.
    RichardsonLucyDeconvolution.filterMode
    // Property of the outputImage parameter.
    RichardsonLucyDeconvolution.outputImage

    // Method to launch the command.
    Execute()

## Parameters

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| inputImage | The input image. | Image | Binary, Label, Grayscale or Multispectral | nullptr
| inputPsfImage | The point spread function (PSF) that models the degradation filter. The PSF is passed as an image. | Image | Binary, Label, Grayscale or Multispectral | nullptr
| numberOfIterations | The number of iterations performed. | UInt32 | [1, 1000] | 10
| initialEstimate | The initial estimate of the deconvolution algorithm. If CONSTANT is chosen, a constant image is used initially. Often, this yields smoother results than the second option, namely input data.
CONSTANT | Use a constant image as the initial estimate.
INPUT_IMAGE | Use the input image as the initial estimate.
| Enumeration |  | CONSTANT
| filterMode | The algorithm implementation used to perform the convolution.
SPATIAL | The computation is performed applying a classic sliding window. Using this mode can provide a faster computation time, for small kernel image size.
FREQUENCY | The computation is performed by a multiplication in the Fourier domain. Using this mode provides a constant computation time, independent from the kernel image size.
| Enumeration |  | SPATIAL
| outputImage | The output image. The output image characteristics are forced to the same as the input image. | Image |  | nullptr

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| input_image | The input image. | image | Binary, Label, Grayscale or Multispectral | None
| input_psf_image | The point spread function (PSF) that models the degradation filter. The PSF is passed as an image. | image | Binary, Label, Grayscale or Multispectral | None
| number_of_iterations | The number of iterations performed. | uint32 | [1, 1000] | 10
| initial_estimate | The initial estimate of the deconvolution algorithm. If CONSTANT is chosen, a constant image is used initially. Often, this yields smoother results than the second option, namely input data.
CONSTANT | Use a constant image as the initial estimate.
INPUT_IMAGE | Use the input image as the initial estimate.
| enumeration |  | CONSTANT
| filter_mode | The algorithm implementation used to perform the convolution.
SPATIAL | The computation is performed applying a classic sliding window. Using this mode can provide a faster computation time, for small kernel image size.
FREQUENCY | The computation is performed by a multiplication in the Fourier domain. Using this mode provides a constant computation time, independent from the kernel image size.
| enumeration |  | SPATIAL
| output_image | The output image. The output image characteristics are forced to the same as the input image. | image |  | None

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| inputImage | The input image. | Image | Binary, Label, Grayscale or Multispectral | null
| inputPsfImage | The point spread function (PSF) that models the degradation filter. The PSF is passed as an image. | Image | Binary, Label, Grayscale or Multispectral | null
| numberOfIterations | The number of iterations performed. | UInt32 | [1, 1000] | 10
| initialEstimate | The initial estimate of the deconvolution algorithm. If CONSTANT is chosen, a constant image is used initially. Often, this yields smoother results than the second option, namely input data.
CONSTANT | Use a constant image as the initial estimate.
INPUT_IMAGE | Use the input image as the initial estimate.
| Enumeration |  | CONSTANT
| filterMode | The algorithm implementation used to perform the convolution.
SPATIAL | The computation is performed applying a classic sliding window. Using this mode can provide a faster computation time, for small kernel image size.
FREQUENCY | The computation is performed by a multiplication in the Fourier domain. Using this mode provides a constant computation time, independent from the kernel image size.
| Enumeration |  | SPATIAL
| outputImage | The output image. The output image characteristics are forced to the same as the input image. | Image |  | null

## Object Examples

    auto polystyrene = ioformat::readImage( std::string( IMAGEDEVDATA_IMAGES_FOLDER ) + "polystyrene.tif" );
    auto kernel_2d = readVipImage( std::string( IMAGEDEVDATA_IMAGES_FOLDER ) + "kernel_2d.vip" );

    RichardsonLucyDeconvolution richardsonLucyDeconvolutionAlgo;
    richardsonLucyDeconvolutionAlgo.setInputImage( polystyrene );
    richardsonLucyDeconvolutionAlgo.setInputPsfImage( kernel_2d );
    richardsonLucyDeconvolutionAlgo.setNumberOfIterations( 5 );
    richardsonLucyDeconvolutionAlgo.setInitialEstimate( RichardsonLucyDeconvolution::InitialEstimate::CONSTANT );
    richardsonLucyDeconvolutionAlgo.setFilterMode( RichardsonLucyDeconvolution::FilterMode::SPATIAL );
    richardsonLucyDeconvolutionAlgo.execute();

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

    polystyrene = ioformat.read_image(imagedev_data.get_image_path("polystyrene.tif"))
    kernel_2d = imagedev.read_vip_image(imagedev_data.get_image_path("kernel_2d.vip"))

    richardson_lucy_deconvolution_algo = imagedev.RichardsonLucyDeconvolution()
    richardson_lucy_deconvolution_algo.input_image = polystyrene
    richardson_lucy_deconvolution_algo.input_psf_image = kernel_2d
    richardson_lucy_deconvolution_algo.number_of_iterations = 5
    richardson_lucy_deconvolution_algo.initial_estimate = imagedev.RichardsonLucyDeconvolution.CONSTANT
    richardson_lucy_deconvolution_algo.filter_mode = imagedev.RichardsonLucyDeconvolution.SPATIAL
    richardson_lucy_deconvolution_algo.execute()

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

    ImageView polystyrene = ViewIO.ReadImage( @"Data/images/polystyrene.tif" );
    ImageView kernel_2d = Data.ReadVipImage( @"Data/images/kernel_2d.vip" );

    RichardsonLucyDeconvolution richardsonLucyDeconvolutionAlgo = new RichardsonLucyDeconvolution
    {
        inputImage = polystyrene,
        inputPsfImage = kernel_2d,
        numberOfIterations = 5,
        initialEstimate = RichardsonLucyDeconvolution.InitialEstimate.CONSTANT,
        filterMode = RichardsonLucyDeconvolution.FilterMode.SPATIAL
    };
    richardsonLucyDeconvolutionAlgo.Execute();

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

## Function Examples

    auto polystyrene = ioformat::readImage( std::string( IMAGEDEVDATA_IMAGES_FOLDER ) + "polystyrene.tif" );
    auto kernel_2d = readVipImage( std::string( IMAGEDEVDATA_IMAGES_FOLDER ) + "kernel_2d.vip" );

    auto result = richardsonLucyDeconvolution( polystyrene, kernel_2d, 5, RichardsonLucyDeconvolution::InitialEstimate::CONSTANT, RichardsonLucyDeconvolution::FilterMode::SPATIAL );

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

    polystyrene = ioformat.read_image(imagedev_data.get_image_path("polystyrene.tif"))
    kernel_2d = imagedev.read_vip_image(imagedev_data.get_image_path("kernel_2d.vip"))

    result = imagedev.richardson_lucy_deconvolution(polystyrene, kernel_2d, 5, imagedev.RichardsonLucyDeconvolution.CONSTANT, imagedev.RichardsonLucyDeconvolution.SPATIAL)

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

    ImageView polystyrene = ViewIO.ReadImage( @"Data/images/polystyrene.tif" );
    ImageView kernel_2d = Data.ReadVipImage( @"Data/images/kernel_2d.vip" );

    IOLink.ImageView result = Processing.RichardsonLucyDeconvolution( polystyrene, kernel_2d, 5, RichardsonLucyDeconvolution.InitialEstimate.CONSTANT, RichardsonLucyDeconvolution.FilterMode.SPATIAL );

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

© 2025 Thermo Fisher Scientific Inc. All rights reserved.