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

# HExtremaWatershed

Computes the watershed lines of a grayscale image.
Access to parameter description
For an introduction:

- section Introduction To Watershed
- section Geodesic Transformations

This algorithm applies a watershed using as a landscape image either, in dark objects mode, the input image directly or, in bright objects mode, its negative.
A contrast level parameter is used to reduce the number of markers for the watershed process and thus of false positive separation lines.
This algorithm is a high-level combination of numerical reconstruction and watershed algorithms.
There is a limitation to the separation ability: if some particles overlap too much, they are not separated by the algorithm. A sensible criteria is that the distance between particle centroids should be larger than their greatest radius.
This algorithm can be used on the gradient modulus to compute best-fit contours.
Note: This algorithm requires up to 8 times the size of the input image as free memory. If the system does not have enough free memory, this algorithm will fail during its computation. In this case, the HExtremaWatershedByBlock should be used instead.
See also

- SeparateObjects
- HExtremaWatershedByBlock
- MarkerBasedWatershed2d
- HExtrema2d

##
Function Syntax

This function returns outputImage.

    // Function prototype
    std::shared_ptr< iolink::ImageView >
    hExtremaWatershed( std::shared_ptr< iolink::ImageView > inputGrayImage,
                       HExtremaWatershed::ObjectLightness objectLightness,
                       int32_t contrastValue,
                       HExtremaWatershed::OutputType outputType,
                       HExtremaWatershed::AlgorithmMode algorithmMode,
                       HExtremaWatershed::Neighborhood neighborhood,
                       std::shared_ptr< iolink::ImageView > outputImage = nullptr );

This function returns outputImage.

    // Function prototype.
    h_extrema_watershed(input_gray_image: idt.ImageType,
                        object_lightness: HExtremaWatershed.ObjectLightness = HExtremaWatershed.ObjectLightness.DARK_OBJECTS,
                        contrast_value: int = 30,
                        output_type: HExtremaWatershed.OutputType = HExtremaWatershed.OutputType.SEPARATED_OBJECTS,
                        algorithm_mode: HExtremaWatershed.AlgorithmMode = HExtremaWatershed.AlgorithmMode.REPEATABLE,
                        neighborhood: HExtremaWatershed.Neighborhood = HExtremaWatershed.Neighborhood.CONNECTIVITY_26,
                        output_image: idt.ImageType = None) -> idt.ImageType

This function returns outputImage.

    // Function prototype.
    public static IOLink.ImageView
    HExtremaWatershed( IOLink.ImageView inputGrayImage,
                       HExtremaWatershed.ObjectLightness objectLightness = ImageDev.HExtremaWatershed.ObjectLightness.DARK_OBJECTS,
                       Int32 contrastValue = 30,
                       HExtremaWatershed.OutputType outputType = ImageDev.HExtremaWatershed.OutputType.SEPARATED_OBJECTS,
                       HExtremaWatershed.AlgorithmMode algorithmMode = ImageDev.HExtremaWatershed.AlgorithmMode.REPEATABLE,
                       HExtremaWatershed.Neighborhood neighborhood = ImageDev.HExtremaWatershed.Neighborhood.CONNECTIVITY_26,
                       IOLink.ImageView outputImage = null );

##
Class Syntax

    // Command constructor.
    HExtremaWatershed();

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

    /// Gets the objectLightness parameter.
    /// The lightness of objects to separate.
    HExtremaWatershed::ObjectLightness objectLightness() const;
    /// Sets the objectLightness parameter.
    /// The lightness of objects to separate.
    void setObjectLightness( const HExtremaWatershed::ObjectLightness& objectLightness );

    /// Gets the contrastValue parameter.
    /// The depth of the valley used to select the markers of the watershed.
    int32_t contrastValue() const;
    /// Sets the contrastValue parameter.
    /// The depth of the valley used to select the markers of the watershed.
    void setContrastValue( const int32_t& contrastValue );

    /// Gets the outputType parameter.
    /// The type of result image.
    HExtremaWatershed::OutputType outputType() const;
    /// Sets the outputType parameter.
    /// The type of result image.
    void setOutputType( const HExtremaWatershed::OutputType& outputType );

    /// Gets the algorithmMode parameter.
    /// The mode for applying the watershed algorithm.
    HExtremaWatershed::AlgorithmMode algorithmMode() const;
    /// Sets the algorithmMode parameter.
    /// The mode for applying the watershed algorithm.
    void setAlgorithmMode( const HExtremaWatershed::AlgorithmMode& algorithmMode );

    /// Gets the neighborhood parameter.
    /// The 3D neighborhood configuration. This parameter is ignored with a 2D input image.
    HExtremaWatershed::Neighborhood neighborhood() const;
    /// Sets the neighborhood parameter.
    /// The 3D neighborhood configuration. This parameter is ignored with a 2D input image.
    void setNeighborhood( const HExtremaWatershed::Neighborhood& neighborhood );

    /// Gets the outputImage parameter.
    /// The output grayscale, binary or label image. Its dimensions are forced to the same values as the input image. Its type depends on the outputType parameter.
    std::shared_ptr< iolink::ImageView > outputImage() const;
    /// Sets the outputImage parameter.
    /// The output grayscale, binary or label image. Its dimensions are forced to the same values as the input image. Its type depends on the outputType parameter.
    void setOutputImage( std::shared_ptr< iolink::ImageView > outputImage );

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

    # Property of the inputGrayImage parameter.
    HExtremaWatershed.input_gray_image
    # Property of the objectLightness parameter.
    HExtremaWatershed.object_lightness
    # Property of the contrastValue parameter.
    HExtremaWatershed.contrast_value
    # Property of the outputType parameter.
    HExtremaWatershed.output_type
    # Property of the algorithmMode parameter.
    HExtremaWatershed.algorithm_mode
    # Property of the neighborhood parameter.
    HExtremaWatershed.neighborhood
    # Property of the outputImage parameter.
    HExtremaWatershed.output_image

    // Method to launch the command.
    execute()

    // Command constructor.
    HExtremaWatershed()

    // Property of the inputGrayImage parameter.
    HExtremaWatershed.inputGrayImage
    // Property of the objectLightness parameter.
    HExtremaWatershed.objectLightness
    // Property of the contrastValue parameter.
    HExtremaWatershed.contrastValue
    // Property of the outputType parameter.
    HExtremaWatershed.outputType
    // Property of the algorithmMode parameter.
    HExtremaWatershed.algorithmMode
    // Property of the neighborhood parameter.
    HExtremaWatershed.neighborhood
    // Property of the outputImage parameter.
    HExtremaWatershed.outputImage

    // Method to launch the command.
    Execute()

## Parameters

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| inputGrayImage | The input grayscale image. | Image | Grayscale | nullptr
| objectLightness | The lightness of objects to separate.
DARK_OBJECTS | The watershed is directly applied on the input image in order to separate dark areas.
BRIGHT_OBJECTS | The watershed is applied on the negative of the input image in order to separate bright areas.
| Enumeration |  | DARK_OBJECTS
| outputType | The type of result image.
SEPARATED_OBJECTS | The result image is a grayscale image representing the original from which separation lines are added to dark objects or subtracted from bright objects (split areas).
WATERSHED_RIDGES | The result image is a binary image representing the separation lines (watershed).
SEPARATED_BASINS | The result image is a label image representing the catchment areas (labeled complement of the watershed).
CONTIGUOUS_BASINS | The result image is a label image representing the catchment areas with separation lines filled by a label.
| Enumeration |  | SEPARATED_OBJECTS
| algorithmMode | The mode for applying the watershed algorithm.
REPEATABLE | The result is repeatable but slower to compute.
FAST | The result is faster to compute but not repeatable because of asynchronous parallel computation. Since a watershed problem does not generally have a unique solution, two processings of the same image can lead to two different results (both exact).
| Enumeration |  | REPEATABLE
| contrastValue | The depth of the valley used to select the markers of the watershed. | Int32 | >=0 | 30
| neighborhood | The 3D neighborhood configuration. This parameter is ignored with a 2D input image.
CONNECTIVITY_6 | The structuring element is composed of voxels with a common face with the voxel of interest.
CONNECTIVITY_18 | The structuring element is composed of voxels with at least one common edge.
CONNECTIVITY_26 | The structuring element is a full cube.
| Enumeration |  | CONNECTIVITY_26
| outputImage | The output grayscale, binary or label image. Its dimensions are forced to the same values as the input image. Its type depends on the outputType parameter. | Image |  | nullptr

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| input_gray_image | The input grayscale image. | image | Grayscale | None
| object_lightness | The lightness of objects to separate.
DARK_OBJECTS | The watershed is directly applied on the input image in order to separate dark areas.
BRIGHT_OBJECTS | The watershed is applied on the negative of the input image in order to separate bright areas.
| enumeration |  | DARK_OBJECTS
| output_type | The type of result image.
SEPARATED_OBJECTS | The result image is a grayscale image representing the original from which separation lines are added to dark objects or subtracted from bright objects (split areas).
WATERSHED_RIDGES | The result image is a binary image representing the separation lines (watershed).
SEPARATED_BASINS | The result image is a label image representing the catchment areas (labeled complement of the watershed).
CONTIGUOUS_BASINS | The result image is a label image representing the catchment areas with separation lines filled by a label.
| enumeration |  | SEPARATED_OBJECTS
| algorithm_mode | The mode for applying the watershed algorithm.
REPEATABLE | The result is repeatable but slower to compute.
FAST | The result is faster to compute but not repeatable because of asynchronous parallel computation. Since a watershed problem does not generally have a unique solution, two processings of the same image can lead to two different results (both exact).
| enumeration |  | REPEATABLE
| contrast_value | The depth of the valley used to select the markers of the watershed. | int32 | >=0 | 30
| neighborhood | The 3D neighborhood configuration. This parameter is ignored with a 2D input image.
CONNECTIVITY_6 | The structuring element is composed of voxels with a common face with the voxel of interest.
CONNECTIVITY_18 | The structuring element is composed of voxels with at least one common edge.
CONNECTIVITY_26 | The structuring element is a full cube.
| enumeration |  | CONNECTIVITY_26
| output_image | The output grayscale, binary or label image. Its dimensions are forced to the same values as the input image. Its type depends on the outputType parameter. | image |  | None

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| inputGrayImage | The input grayscale image. | Image | Grayscale | null
| objectLightness | The lightness of objects to separate.
DARK_OBJECTS | The watershed is directly applied on the input image in order to separate dark areas.
BRIGHT_OBJECTS | The watershed is applied on the negative of the input image in order to separate bright areas.
| Enumeration |  | DARK_OBJECTS
| outputType | The type of result image.
SEPARATED_OBJECTS | The result image is a grayscale image representing the original from which separation lines are added to dark objects or subtracted from bright objects (split areas).
WATERSHED_RIDGES | The result image is a binary image representing the separation lines (watershed).
SEPARATED_BASINS | The result image is a label image representing the catchment areas (labeled complement of the watershed).
CONTIGUOUS_BASINS | The result image is a label image representing the catchment areas with separation lines filled by a label.
| Enumeration |  | SEPARATED_OBJECTS
| algorithmMode | The mode for applying the watershed algorithm.
REPEATABLE | The result is repeatable but slower to compute.
FAST | The result is faster to compute but not repeatable because of asynchronous parallel computation. Since a watershed problem does not generally have a unique solution, two processings of the same image can lead to two different results (both exact).
| Enumeration |  | REPEATABLE
| contrastValue | The depth of the valley used to select the markers of the watershed. | Int32 | >=0 | 30
| neighborhood | The 3D neighborhood configuration. This parameter is ignored with a 2D input image.
CONNECTIVITY_6 | The structuring element is composed of voxels with a common face with the voxel of interest.
CONNECTIVITY_18 | The structuring element is composed of voxels with at least one common edge.
CONNECTIVITY_26 | The structuring element is a full cube.
| Enumeration |  | CONNECTIVITY_26
| outputImage | The output grayscale, binary or label image. Its dimensions are forced to the same values as the input image. Its type depends on the outputType parameter. | Image |  | null

## Object Examples

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

    HExtremaWatershed hExtremaWatershedAlgo;
    hExtremaWatershedAlgo.setInputGrayImage( foam );
    hExtremaWatershedAlgo.setObjectLightness( HExtremaWatershed::ObjectLightness::DARK_OBJECTS );
    hExtremaWatershedAlgo.setContrastValue( 30 );
    hExtremaWatershedAlgo.setOutputType( HExtremaWatershed::OutputType::SEPARATED_OBJECTS );
    hExtremaWatershedAlgo.setAlgorithmMode( HExtremaWatershed::AlgorithmMode::REPEATABLE );
    hExtremaWatershedAlgo.setNeighborhood( HExtremaWatershed::Neighborhood::CONNECTIVITY_26 );
    hExtremaWatershedAlgo.execute();

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

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

    h_extrema_watershed_algo = imagedev.HExtremaWatershed()
    h_extrema_watershed_algo.input_gray_image = foam
    h_extrema_watershed_algo.object_lightness = imagedev.HExtremaWatershed.DARK_OBJECTS
    h_extrema_watershed_algo.contrast_value = 30
    h_extrema_watershed_algo.output_type = imagedev.HExtremaWatershed.SEPARATED_OBJECTS
    h_extrema_watershed_algo.algorithm_mode = imagedev.HExtremaWatershed.REPEATABLE
    h_extrema_watershed_algo.neighborhood = imagedev.HExtremaWatershed.CONNECTIVITY_26
    h_extrema_watershed_algo.execute()

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

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

    HExtremaWatershed hExtremaWatershedAlgo = new HExtremaWatershed
    {
        inputGrayImage = foam,
        objectLightness = HExtremaWatershed.ObjectLightness.DARK_OBJECTS,
        contrastValue = 30,
        outputType = HExtremaWatershed.OutputType.SEPARATED_OBJECTS,
        algorithmMode = HExtremaWatershed.AlgorithmMode.REPEATABLE,
        neighborhood = HExtremaWatershed.Neighborhood.CONNECTIVITY_26
    };
    hExtremaWatershedAlgo.Execute();

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

## Function Examples

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

    auto result = hExtremaWatershed( foam, HExtremaWatershed::ObjectLightness::DARK_OBJECTS, 30, HExtremaWatershed::OutputType::SEPARATED_OBJECTS, HExtremaWatershed::AlgorithmMode::REPEATABLE, HExtremaWatershed::Neighborhood::CONNECTIVITY_26 );

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

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

    result = imagedev.h_extrema_watershed(foam, imagedev.HExtremaWatershed.DARK_OBJECTS, 30, imagedev.HExtremaWatershed.SEPARATED_OBJECTS, imagedev.HExtremaWatershed.REPEATABLE, imagedev.HExtremaWatershed.CONNECTIVITY_26)

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

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

    IOLink.ImageView result = Processing.HExtremaWatershed( foam, HExtremaWatershed.ObjectLightness.DARK_OBJECTS, 30, HExtremaWatershed.OutputType.SEPARATED_OBJECTS, HExtremaWatershed.AlgorithmMode.REPEATABLE, HExtremaWatershed.Neighborhood.CONNECTIVITY_26 );

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

© 2025 Thermo Fisher Scientific Inc. All rights reserved.