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

# GradientOperator2d

Provides different algorithms to perform an edge detection based on the first derivative of a two-dimensional image.
Access to parameter description
This command is deprecated, it will be removed in ImageDev 2025.1.
You can use GradientVector2d or GradientMagnitude2d instead.
For an introduction:

- section Edge Detection
- section Gradient
- section Images Filters

GradientOperator2d computes a first order derivative in each image axis direction. To minimize the effect of noise, the algorithm can be combined with a smoothing filter for computing the gradient. A smoothing scale parameter determines the smoothing intensity. If its value is large, noise is reduced but edges are less sharp and only the most significant edges are revealed (this behavior is reversed for the Shen and Castan algorithm). It is important to select the right coefficient to lower the noise just enough without defocusing the edges. Finally the algorithm optionally computes the magnitude of the gradient vectors either by selecting its maximum component or its Euclidean norm.
The following algorithms are proposed to extract the edges of an image:

- Canny-Deriche: It performs a recursive gradient computation with an IIR (Infinite Impulse Response) filter by derivating the Deriche [1] smoothing filter which has the two-dimensional form: $$ f(x,y)=b^2(\alpha|x|+1)e^{-\alpha|x|}\cdot(\alpha|y|+1)e^{-\alpha|y|}~~where~~b=\frac{\alpha}{4} $$ For color images, the magnitude is computed with the maximum of intensity or the Euclidean mean of the color components.
- Shen-Castan: It calculates the gradient of Shen and Castan [2]. It is a recursive and exponential filter that smooths an object and then extracts its edges. It is based on the Shen operator: $$ f(x,y)=\frac{p^2}{4} e^{(-p(|x|+|y|))} $$
  The highest $p$ is, the more edges we get. For color images the magnitude is computed with the maximum of intensity or the Euclidean mean of the color components.
- Canny: It is similar to Canny-Deriche but using a FIR (finite impulse response) filter [3]. It performs an approximation to get the Canny-Deriche in X and Y directions using a convolution kernel 7x5 for X and 5x7 for Y. The result is nearly the same as Canny-Deriche, but the process is much faster.
- Gaussian: It performs a convolution with the derivatives of a Gaussian function along each image axis.
- Sobel: It performs a convolution with the Sobel Kernel. It cannot be applied on color images. $$ \mathbf{G_x} = \begin{bmatrix} -1 & 0 & +1 \\ -2 & 0 & +2 \\ -1 & 0 & +1 \end{bmatrix} \quad \mbox{and} \quad \mathbf{G_y} = \begin{bmatrix} -1 & -2 & -1 \\ 0 & 0 & 0 \\ +1 & +2 & +1 \end{bmatrix} $$
- Prewitt: It performs a convolution with the Prewitt Kernel. It cannot be applied on color images. $$ \mathbf{G_x} = \begin{bmatrix} -1 & 0 & +1 \\ -1 & 0 & +1 \\ -1 & 0 & +1 \end{bmatrix} \quad \mbox{and} \quad \mathbf{G_y} = \begin{bmatrix} -1 & -1 & -1 \\ 0 & 0 & 0 \\ +1 & +1 & +1 \end{bmatrix} $$

Notices:

- The output data type is determined by applying the Basic rules defined for arithmetic operations.
- To limit overflows, some normalizations are applied with most of the proposed operators by dividing the output gray levels by the sum of absolute values of the kernel coefficients.
- The Prewitt and Sobel operators do not apply normalizations and are thus inclined to produce overflows.
- By default, the maximum component of each directional gradient is computed. Depending on the selected operator, other output can be selected such as the Euclidean norm or the gradient components.
- The smoothing factor has a totally different meaning depending on the selected gradient operator. It represents a smoothing percentage with Canny-Deriche, a sharpenness factor with Shen and Castan, a standard-deviation with the Gaussian and is ignored with Canny, Sobel and Prewitt.

References
[1] R.Deriche. "Using Canny's criteria to derive a recursively implemented optimal edge detector". International Journal of Computer Vision, vol.1, no 2, pp. 167-187, Jun. 1987.
[2] J.Shen, S.Castan. "An optimal linear operator for step edge detection". CVGIP : Graphical Models and Image Processing, vol.54, no 2, pp. 112-133, Mar. 1992.
[3] J.F.Canny. "A computational approach to edge detection." IEEE Transactions on Pattern Analysis and Machine Intelligence, vol.8, No 6, pp. 679-698, Nov. 1986.
See also

- VectorToMagnitude2d
- GradientOperator3d
- MorphologicalGradient2d

##
Function Syntax

This function returns a GradientOperator2dOutput structure containing outputImageX, outputImageY, outputAmplitudeImage and outputOrientationImage.

    // Output structure of the gradientOperator2d function.
    struct GradientOperator2dOutput
    {
        /// The X-gradient output image.
        std::shared_ptr< iolink::ImageView > outputImageX;
        /// The Y-gradient output image.
        std::shared_ptr< iolink::ImageView > outputImageY;
        /// The gradient amplitude output image.
        std::shared_ptr< iolink::ImageView > outputAmplitudeImage;
        /// The gradient orientation output image.
        std::shared_ptr< iolink::ImageView > outputOrientationImage;
    };

    // Function prototype
    GradientOperator2dOutput
    gradientOperator2d( std::shared_ptr< iolink::ImageView > inputImage,
                        GradientOperator2d::GradientOperator gradientOperator,
                        GradientOperator2d::GradientMode gradientMode,
                        double smoothingFactor,
                        std::shared_ptr< iolink::ImageView > outputImageX = nullptr,
                        std::shared_ptr< iolink::ImageView > outputImageY = nullptr,
                        std::shared_ptr< iolink::ImageView > outputAmplitudeImage = nullptr,
                        std::shared_ptr< iolink::ImageView > outputOrientationImage = nullptr );

This function returns a tuple containing output_image_x, output_image_y, output_amplitude_image and output_orientation_image.

    // Function prototype.
    gradient_operator_2d(input_image: idt.ImageType,
                         gradient_operator: GradientOperator2d.GradientOperator = GradientOperator2d.GradientOperator.CANNY_DERICHE,
                         gradient_mode: GradientOperator2d.GradientMode = GradientOperator2d.GradientMode.AMPLITUDE_MAXIMUM,
                         smoothing_factor: float = 60,
                         output_image_x: idt.ImageType = None,
                         output_image_y: idt.ImageType = None,
                         output_amplitude_image: idt.ImageType = None,
                         output_orientation_image: idt.ImageType = None) -> Tuple[idt.ImageType, idt.ImageType, idt.ImageType, idt.ImageType]

This function returns a GradientOperator2dOutput structure containing outputImageX, outputImageY, outputAmplitudeImage and outputOrientationImage.

    /// Output structure of the GradientOperator2d function.
    public struct GradientOperator2dOutput
    {
        /// The X-gradient output image.
        public IOLink.ImageView outputImageX;
        /// The Y-gradient output image.
        public IOLink.ImageView outputImageY;
        /// The gradient amplitude output image.
        public IOLink.ImageView outputAmplitudeImage;
        /// The gradient orientation output image.
        public IOLink.ImageView outputOrientationImage;
    };

    // Function prototype.
    public static GradientOperator2dOutput
    GradientOperator2d( IOLink.ImageView inputImage,
                        GradientOperator2d.GradientOperator gradientOperator = ImageDev.GradientOperator2d.GradientOperator.CANNY_DERICHE,
                        GradientOperator2d.GradientMode gradientMode = ImageDev.GradientOperator2d.GradientMode.AMPLITUDE_MAXIMUM,
                        double smoothingFactor = 60,
                        IOLink.ImageView outputImageX = null,
                        IOLink.ImageView outputImageY = null,
                        IOLink.ImageView outputAmplitudeImage = null,
                        IOLink.ImageView outputOrientationImage = null );

##
Class Syntax

    // Command constructor.
    GradientOperator2d();

    /// 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 gradientOperator parameter.
    /// The gradient operator to apply.
    GradientOperator2d::GradientOperator gradientOperator() const;
    /// Sets the gradientOperator parameter.
    /// The gradient operator to apply.
    void setGradientOperator( const GradientOperator2d::GradientOperator& gradientOperator );

    /// Gets the gradientMode parameter.
    /// The output image to compute.
    GradientOperator2d::GradientMode gradientMode() const;
    /// Sets the gradientMode parameter.
    /// The output image to compute.
    void setGradientMode( const GradientOperator2d::GradientMode& gradientMode );

    /// Gets the smoothingFactor parameter.
    /// The smoothing factor defines the gradient sharpness. It is only used with Canny Deriche, Shen Castan, and Gaussian operators. It has a totally different meaning depending on the selected gradient operator. Its value must be between 0 and 100.
    double smoothingFactor() const;
    /// Sets the smoothingFactor parameter.
    /// The smoothing factor defines the gradient sharpness. It is only used with Canny Deriche, Shen Castan, and Gaussian operators. It has a totally different meaning depending on the selected gradient operator. Its value must be between 0 and 100.
    void setSmoothingFactor( const double& smoothingFactor );

    /// Gets the outputImageX parameter.
    /// The X-gradient output image.
    std::shared_ptr< iolink::ImageView > outputImageX() const;
    /// Sets the outputImageX parameter.
    /// The X-gradient output image.
    void setOutputImageX( std::shared_ptr< iolink::ImageView > outputImageX );

    /// Gets the outputImageY parameter.
    /// The Y-gradient output image.
    std::shared_ptr< iolink::ImageView > outputImageY() const;
    /// Sets the outputImageY parameter.
    /// The Y-gradient output image.
    void setOutputImageY( std::shared_ptr< iolink::ImageView > outputImageY );

    /// Gets the outputAmplitudeImage parameter.
    /// The gradient amplitude output image.
    std::shared_ptr< iolink::ImageView > outputAmplitudeImage() const;
    /// Sets the outputAmplitudeImage parameter.
    /// The gradient amplitude output image.
    void setOutputAmplitudeImage( std::shared_ptr< iolink::ImageView > outputAmplitudeImage );

    /// Gets the outputOrientationImage parameter.
    /// The gradient orientation output image.
    std::shared_ptr< iolink::ImageView > outputOrientationImage() const;
    /// Sets the outputOrientationImage parameter.
    /// The gradient orientation output image.
    void setOutputOrientationImage( std::shared_ptr< iolink::ImageView > outputOrientationImage );

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

    # Property of the inputImage parameter.
    GradientOperator2d.input_image
    # Property of the gradientOperator parameter.
    GradientOperator2d.gradient_operator
    # Property of the gradientMode parameter.
    GradientOperator2d.gradient_mode
    # Property of the smoothingFactor parameter.
    GradientOperator2d.smoothing_factor
    # Property of the outputImageX parameter.
    GradientOperator2d.output_image_x
    # Property of the outputImageY parameter.
    GradientOperator2d.output_image_y
    # Property of the outputAmplitudeImage parameter.
    GradientOperator2d.output_amplitude_image
    # Property of the outputOrientationImage parameter.
    GradientOperator2d.output_orientation_image

    // Method to launch the command.
    execute()

    // Command constructor.
    GradientOperator2d()

    // Property of the inputImage parameter.
    GradientOperator2d.inputImage
    // Property of the gradientOperator parameter.
    GradientOperator2d.gradientOperator
    // Property of the gradientMode parameter.
    GradientOperator2d.gradientMode
    // Property of the smoothingFactor parameter.
    GradientOperator2d.smoothingFactor
    // Property of the outputImageX parameter.
    GradientOperator2d.outputImageX
    // Property of the outputImageY parameter.
    GradientOperator2d.outputImageY
    // Property of the outputAmplitudeImage parameter.
    GradientOperator2d.outputAmplitudeImage
    // Property of the outputOrientationImage parameter.
    GradientOperator2d.outputOrientationImage

    // 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
| gradientOperator | The gradient operator to apply.
CANNY_DERICHE | The gradient is computed using the Canny-Deriche algorithm. Supported gradient output modes : AMPLITUDE_MAXIMUM, AMPLITUDE_EUCLIDEAN, AMPLITUDE_AND_ORIENTATION and X_AND_Y_GRADIENTS.
SHEN_CASTAN | The gradient is computed using the Shen and Castan algorithm. Supported gradient output modes : AMPLITUDE_MAXIMUM.
KERNEL3X3 | The gradient is computed using the Sobel 3x3 kernel algorithm. Supported gradient output modes : AMPLITUDE_MAXIMUM, AMPLITUDE_EUCLIDEAN, AMPLITUDE_AND_ORIENTATION and X_AND_Y_GRADIENTS.
CANNY | The gradient is computed using the Canny algorithm. Supported gradient output modes : AMPLITUDE_MAXIMUM and AMPLITUDE_EUCLIDEAN.
GAUSSIAN | The gradient is computed using the Gaussian algorithm. Supported gradient output modes : AMPLITUDE_MAXIMUM, AMPLITUDE_EUCLIDEAN, AMPLITUDE_AND_ORIENTATION and X_AND_Y_GRADIENTS.
SOBEL | The gradient is computed using the Sobel algorithm. Supported gradient output modes : AMPLITUDE_MAXIMUM, AMPLITUDE_EUCLIDEAN, AMPLITUDE_AND_ORIENTATION and X_AND_Y_GRADIENTS.
PREWITT | The gradient is computed using the Prewitt algorithm. Supported gradient output modes : AMPLITUDE_MAXIMUM, AMPLITUDE_EUCLIDEAN, AMPLITUDE_AND_ORIENTATION and X_AND_Y_GRADIENTS.
| Enumeration |  | CANNY_DERICHE
| gradientMode | The output image to compute.
AMPLITUDE_MAXIMUM | This option computes the gradient maximal amplitude. Only the outputAmplitudeImage output is set using this mode.
AMPLITUDE_EUCLIDEAN | This option computes the gradient Euclidean amplitude. Only the outputAmplitudeImage output is set using this mode.
AMPLITUDE_AND_ORIENTATION | This option computes Euclidean amplitude and orientation in degrees (between -128 and +128 degrees). Both outputAmplitudeImage and outputOrientationImage outputs are set using this mode.
X_AND_Y_GRADIENTS | This option computes gradient in X and Y directions. Both outputImageX and outputImageY outputs are set using this mode.
| Enumeration |  | AMPLITUDE_MAXIMUM
| smoothingFactor | The smoothing factor defines the gradient sharpness. It is only used with Canny Deriche, Shen Castan, and Gaussian operators. It has a totally different meaning depending on the selected gradient operator. Its value must be between 0 and 100. Canny-Deriche: it is inversely proportional to Deriche alpha smoothing factor, in pixels. Low values provide sharp gradient. $SmoothingFactor=\frac{(5.3-\alpha)}{5}\times 100$ Shen And Castan: it is proportional to Shen Castan p smoothing factor, in pixels. High values provide sharp gradient. Gaussian: the Gaussian kernel standard deviation, in pixels. Low values provide sharp gradient. Prewitt, Sobel, Canny: it is ignored. | Float64 | ]0, 100] | 60
| outputImageX | The X-gradient output image. | Image |  | nullptr
| outputImageY | The Y-gradient output image. | Image |  | nullptr
| outputAmplitudeImage | The gradient amplitude output image. | Image |  | nullptr
| outputOrientationImage | The gradient orientation output image. | Image |  | nullptr

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| input_image | The input image. | image | Binary, Label, Grayscale or Multispectral | None
| gradient_operator | The gradient operator to apply.
CANNY_DERICHE | The gradient is computed using the Canny-Deriche algorithm. Supported gradient output modes : AMPLITUDE_MAXIMUM, AMPLITUDE_EUCLIDEAN, AMPLITUDE_AND_ORIENTATION and X_AND_Y_GRADIENTS.
SHEN_CASTAN | The gradient is computed using the Shen and Castan algorithm. Supported gradient output modes : AMPLITUDE_MAXIMUM.
KERNEL3X3 | The gradient is computed using the Sobel 3x3 kernel algorithm. Supported gradient output modes : AMPLITUDE_MAXIMUM, AMPLITUDE_EUCLIDEAN, AMPLITUDE_AND_ORIENTATION and X_AND_Y_GRADIENTS.
CANNY | The gradient is computed using the Canny algorithm. Supported gradient output modes : AMPLITUDE_MAXIMUM and AMPLITUDE_EUCLIDEAN.
GAUSSIAN | The gradient is computed using the Gaussian algorithm. Supported gradient output modes : AMPLITUDE_MAXIMUM, AMPLITUDE_EUCLIDEAN, AMPLITUDE_AND_ORIENTATION and X_AND_Y_GRADIENTS.
SOBEL | The gradient is computed using the Sobel algorithm. Supported gradient output modes : AMPLITUDE_MAXIMUM, AMPLITUDE_EUCLIDEAN, AMPLITUDE_AND_ORIENTATION and X_AND_Y_GRADIENTS.
PREWITT | The gradient is computed using the Prewitt algorithm. Supported gradient output modes : AMPLITUDE_MAXIMUM, AMPLITUDE_EUCLIDEAN, AMPLITUDE_AND_ORIENTATION and X_AND_Y_GRADIENTS.
| enumeration |  | CANNY_DERICHE
| gradient_mode | The output image to compute.
AMPLITUDE_MAXIMUM | This option computes the gradient maximal amplitude. Only the outputAmplitudeImage output is set using this mode.
AMPLITUDE_EUCLIDEAN | This option computes the gradient Euclidean amplitude. Only the outputAmplitudeImage output is set using this mode.
AMPLITUDE_AND_ORIENTATION | This option computes Euclidean amplitude and orientation in degrees (between -128 and +128 degrees). Both outputAmplitudeImage and outputOrientationImage outputs are set using this mode.
X_AND_Y_GRADIENTS | This option computes gradient in X and Y directions. Both outputImageX and outputImageY outputs are set using this mode.
| enumeration |  | AMPLITUDE_MAXIMUM
| smoothing_factor | The smoothing factor defines the gradient sharpness. It is only used with Canny Deriche, Shen Castan, and Gaussian operators. It has a totally different meaning depending on the selected gradient operator. Its value must be between 0 and 100. Canny-Deriche: it is inversely proportional to Deriche alpha smoothing factor, in pixels. Low values provide sharp gradient. $SmoothingFactor=\frac{(5.3-\alpha)}{5}\times 100$ Shen And Castan: it is proportional to Shen Castan p smoothing factor, in pixels. High values provide sharp gradient. Gaussian: the Gaussian kernel standard deviation, in pixels. Low values provide sharp gradient. Prewitt, Sobel, Canny: it is ignored. | float64 | ]0, 100] | 60
| output_image_x | The X-gradient output image. | image |  | None
| output_image_y | The Y-gradient output image. | image |  | None
| output_amplitude_image | The gradient amplitude output image. | image |  | None
| output_orientation_image | The gradient orientation output image. | image |  | None

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| inputImage | The input image. | Image | Binary, Label, Grayscale or Multispectral | null
| gradientOperator | The gradient operator to apply.
CANNY_DERICHE | The gradient is computed using the Canny-Deriche algorithm. Supported gradient output modes : AMPLITUDE_MAXIMUM, AMPLITUDE_EUCLIDEAN, AMPLITUDE_AND_ORIENTATION and X_AND_Y_GRADIENTS.
SHEN_CASTAN | The gradient is computed using the Shen and Castan algorithm. Supported gradient output modes : AMPLITUDE_MAXIMUM.
KERNEL3X3 | The gradient is computed using the Sobel 3x3 kernel algorithm. Supported gradient output modes : AMPLITUDE_MAXIMUM, AMPLITUDE_EUCLIDEAN, AMPLITUDE_AND_ORIENTATION and X_AND_Y_GRADIENTS.
CANNY | The gradient is computed using the Canny algorithm. Supported gradient output modes : AMPLITUDE_MAXIMUM and AMPLITUDE_EUCLIDEAN.
GAUSSIAN | The gradient is computed using the Gaussian algorithm. Supported gradient output modes : AMPLITUDE_MAXIMUM, AMPLITUDE_EUCLIDEAN, AMPLITUDE_AND_ORIENTATION and X_AND_Y_GRADIENTS.
SOBEL | The gradient is computed using the Sobel algorithm. Supported gradient output modes : AMPLITUDE_MAXIMUM, AMPLITUDE_EUCLIDEAN, AMPLITUDE_AND_ORIENTATION and X_AND_Y_GRADIENTS.
PREWITT | The gradient is computed using the Prewitt algorithm. Supported gradient output modes : AMPLITUDE_MAXIMUM, AMPLITUDE_EUCLIDEAN, AMPLITUDE_AND_ORIENTATION and X_AND_Y_GRADIENTS.
| Enumeration |  | CANNY_DERICHE
| gradientMode | The output image to compute.
AMPLITUDE_MAXIMUM | This option computes the gradient maximal amplitude. Only the outputAmplitudeImage output is set using this mode.
AMPLITUDE_EUCLIDEAN | This option computes the gradient Euclidean amplitude. Only the outputAmplitudeImage output is set using this mode.
AMPLITUDE_AND_ORIENTATION | This option computes Euclidean amplitude and orientation in degrees (between -128 and +128 degrees). Both outputAmplitudeImage and outputOrientationImage outputs are set using this mode.
X_AND_Y_GRADIENTS | This option computes gradient in X and Y directions. Both outputImageX and outputImageY outputs are set using this mode.
| Enumeration |  | AMPLITUDE_MAXIMUM
| smoothingFactor | The smoothing factor defines the gradient sharpness. It is only used with Canny Deriche, Shen Castan, and Gaussian operators. It has a totally different meaning depending on the selected gradient operator. Its value must be between 0 and 100. Canny-Deriche: it is inversely proportional to Deriche alpha smoothing factor, in pixels. Low values provide sharp gradient. $SmoothingFactor=\frac{(5.3-\alpha)}{5}\times 100$ Shen And Castan: it is proportional to Shen Castan p smoothing factor, in pixels. High values provide sharp gradient. Gaussian: the Gaussian kernel standard deviation, in pixels. Low values provide sharp gradient. Prewitt, Sobel, Canny: it is ignored. | Float64 | ]0, 100] | 60
| outputImageX | The X-gradient output image. | Image |  | null
| outputImageY | The Y-gradient output image. | Image |  | null
| outputAmplitudeImage | The gradient amplitude output image. | Image |  | null
| outputOrientationImage | The gradient orientation output image. | Image |  | null

## Object Examples

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

    GradientOperator2d gradientOperator2dAlgo;
    gradientOperator2dAlgo.setInputImage( polystyrene );
    gradientOperator2dAlgo.setGradientOperator( GradientOperator2d::GradientOperator::CANNY_DERICHE );
    gradientOperator2dAlgo.setGradientMode( GradientOperator2d::GradientMode::AMPLITUDE_MAXIMUM );
    gradientOperator2dAlgo.setSmoothingFactor( 60.0 );
    gradientOperator2dAlgo.execute();

    std::cout << "outputImageX:" << gradientOperator2dAlgo.outputImageX()->toString();
    std::cout << "outputImageY:" << gradientOperator2dAlgo.outputImageY()->toString();
    std::cout << "outputAmplitudeImage:" << gradientOperator2dAlgo.outputAmplitudeImage()->toString();
    std::cout << "outputOrientationImage:" << gradientOperator2dAlgo.outputOrientationImage()->toString();

    polystyrene = ioformat.read_image(imagedev_data.get_image_path("polystyrene.tif"))

    gradient_operator_2d_algo = imagedev.GradientOperator2d()
    gradient_operator_2d_algo.input_image = polystyrene
    gradient_operator_2d_algo.gradient_operator = imagedev.GradientOperator2d.CANNY_DERICHE
    gradient_operator_2d_algo.gradient_mode = imagedev.GradientOperator2d.AMPLITUDE_MAXIMUM
    gradient_operator_2d_algo.smoothing_factor = 60.0
    gradient_operator_2d_algo.execute()

    print("output_image_x:", str(gradient_operator_2d_algo.output_image_x))
    print("output_image_y:", str(gradient_operator_2d_algo.output_image_y))
    print("output_amplitude_image:", str(gradient_operator_2d_algo.output_amplitude_image))
    print("output_orientation_image:", str(gradient_operator_2d_algo.output_orientation_image))

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

    GradientOperator2d gradientOperator2dAlgo = new GradientOperator2d
    {
        inputImage = polystyrene,
        gradientOperator = GradientOperator2d.GradientOperator.CANNY_DERICHE,
        gradientMode = GradientOperator2d.GradientMode.AMPLITUDE_MAXIMUM,
        smoothingFactor = 60.0
    };
    gradientOperator2dAlgo.Execute();

    Console.WriteLine( "outputImageX:" + gradientOperator2dAlgo.outputImageX.ToString() );
    Console.WriteLine( "outputImageY:" + gradientOperator2dAlgo.outputImageY.ToString() );
    Console.WriteLine( "outputAmplitudeImage:" + gradientOperator2dAlgo.outputAmplitudeImage.ToString() );
    Console.WriteLine( "outputOrientationImage:" + gradientOperator2dAlgo.outputOrientationImage.ToString() );

## Function Examples

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

    auto result = gradientOperator2d( polystyrene, GradientOperator2d::GradientOperator::CANNY_DERICHE, GradientOperator2d::GradientMode::AMPLITUDE_MAXIMUM, 60.0 );

    std::cout << "outputImageX:" << result.outputImageX->toString();
    std::cout << "outputImageY:" << result.outputImageY->toString();
    std::cout << "outputAmplitudeImage:" << result.outputAmplitudeImage->toString();
    std::cout << "outputOrientationImage:" << result.outputOrientationImage->toString();

    polystyrene = ioformat.read_image(imagedev_data.get_image_path("polystyrene.tif"))

    result_output_image_x, result_output_image_y, result_output_amplitude_image, result_output_orientation_image = imagedev.gradient_operator_2d(polystyrene, imagedev.GradientOperator2d.CANNY_DERICHE, imagedev.GradientOperator2d.AMPLITUDE_MAXIMUM, 60.0)

    print("output_image_x:", str(result_output_image_x))
    print("output_image_y:", str(result_output_image_y))
    print("output_amplitude_image:", str(result_output_amplitude_image))
    print("output_orientation_image:", str(result_output_orientation_image))

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

    Processing.GradientOperator2dOutput result = Processing.GradientOperator2d( polystyrene, GradientOperator2d.GradientOperator.CANNY_DERICHE, GradientOperator2d.GradientMode.AMPLITUDE_MAXIMUM, 60.0 );

    Console.WriteLine( "outputImageX:" + result.outputImageX.ToString() );
    Console.WriteLine( "outputImageY:" + result.outputImageY.ToString() );
    Console.WriteLine( "outputAmplitudeImage:" + result.outputAmplitudeImage.ToString() );
    Console.WriteLine( "outputOrientationImage:" + result.outputOrientationImage.ToString() );

© 2025 Thermo Fisher Scientific Inc. All rights reserved.