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

# MarkerBasedWatershed2d

Performs a fast determination of the watershed lines in a two-dimensional grayscale image from a predefined set of markers.
Access to parameter description
For an introduction:

- section Image Segmentation
- section Introduction To Watershed

This algorithm performs a fast determination of the watershed lines from specified markers in a label image.
It determines the crest lines separating the markers.
Three ways of presenting the resulting image are provided:

- Crest lines are output in a binary image.
- Marked basins are output in a label image with crest lines considered as background.
- Marked basins are output in a label image with crest lines filled by a marker value.

Note: Because two bits are used to code the pixels during the algorithm, the input gray level image should range from 0 to 16383. If the range is greater, a normalization is applied to reduce the dynamic of this image.
See also

- HExtremaWatershed
- SeparateObjects
- MarkerBasedWatershedByBlock
- MarkerBasedWatershed3d

##
Function Syntax

This function returns outputImage.

    // Function prototype
    std::shared_ptr< iolink::ImageView >
    markerBasedWatershed2d( std::shared_ptr< iolink::ImageView > inputGrayImage,
                            std::shared_ptr< iolink::ImageView > inputMarkerImage,
                            MarkerBasedWatershed2d::AlgorithmMode algorithmMode,
                            MarkerBasedWatershed2d::OutputType outputType,
                            MarkerBasedWatershed2d::Neighborhood neighborhood,
                            std::shared_ptr< iolink::ImageView > outputImage = nullptr );

This function returns outputImage.

    // Function prototype.
    marker_based_watershed_2d(input_gray_image: idt.ImageType,
                              input_marker_image: idt.ImageType,
                              algorithm_mode: MarkerBasedWatershed2d.AlgorithmMode = MarkerBasedWatershed2d.AlgorithmMode.REPEATABLE,
                              output_type: MarkerBasedWatershed2d.OutputType = MarkerBasedWatershed2d.OutputType.SEPARATED_REGIONS,
                              neighborhood: MarkerBasedWatershed2d.Neighborhood = MarkerBasedWatershed2d.Neighborhood.CONNECTIVITY_4,
                              output_image: idt.ImageType = None) -> idt.ImageType

This function returns outputImage.

    // Function prototype.
    public static IOLink.ImageView
    MarkerBasedWatershed2d( IOLink.ImageView inputGrayImage,
                            IOLink.ImageView inputMarkerImage,
                            MarkerBasedWatershed2d.AlgorithmMode algorithmMode = ImageDev.MarkerBasedWatershed2d.AlgorithmMode.REPEATABLE,
                            MarkerBasedWatershed2d.OutputType outputType = ImageDev.MarkerBasedWatershed2d.OutputType.SEPARATED_REGIONS,
                            MarkerBasedWatershed2d.Neighborhood neighborhood = ImageDev.MarkerBasedWatershed2d.Neighborhood.CONNECTIVITY_4,
                            IOLink.ImageView outputImage = null );

##
Class Syntax

    // Command constructor.
    MarkerBasedWatershed2d();

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

    /// Gets the inputMarkerImage parameter.
    /// The input label image of markers.
    std::shared_ptr< iolink::ImageView > inputMarkerImage() const;
    /// Sets the inputMarkerImage parameter.
    /// The input label image of markers.
    void setInputMarkerImage( std::shared_ptr< iolink::ImageView > inputMarkerImage );

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

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

    /// Gets the neighborhood parameter.
    /// The type of neighborhood used for the propagation.
    MarkerBasedWatershed2d::Neighborhood neighborhood() const;
    /// Sets the neighborhood parameter.
    /// The type of neighborhood used for the propagation.
    void setNeighborhood( const MarkerBasedWatershed2d::Neighborhood& neighborhood );

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

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

    # Property of the inputGrayImage parameter.
    MarkerBasedWatershed2d.input_gray_image
    # Property of the inputMarkerImage parameter.
    MarkerBasedWatershed2d.input_marker_image
    # Property of the algorithmMode parameter.
    MarkerBasedWatershed2d.algorithm_mode
    # Property of the outputType parameter.
    MarkerBasedWatershed2d.output_type
    # Property of the neighborhood parameter.
    MarkerBasedWatershed2d.neighborhood
    # Property of the outputImage parameter.
    MarkerBasedWatershed2d.output_image

    // Method to launch the command.
    execute()

    // Command constructor.
    MarkerBasedWatershed2d()

    // Property of the inputGrayImage parameter.
    MarkerBasedWatershed2d.inputGrayImage
    // Property of the inputMarkerImage parameter.
    MarkerBasedWatershed2d.inputMarkerImage
    // Property of the algorithmMode parameter.
    MarkerBasedWatershed2d.algorithmMode
    // Property of the outputType parameter.
    MarkerBasedWatershed2d.outputType
    // Property of the neighborhood parameter.
    MarkerBasedWatershed2d.neighborhood
    // Property of the outputImage parameter.
    MarkerBasedWatershed2d.outputImage

    // Method to launch the command.
    Execute()

## Parameters

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| inputGrayImage | The input grayscale image representing the landscape of the watershed. | Image | Grayscale | nullptr
| inputMarkerImage | The input label image of markers. | Image | Label | nullptr
| 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
| outputType | The type of output image.
LINES | The output is a binary image representing only the watershed lines.
CONTIGUOUS_REGIONS | The output is a label image representing only the marked basins. Pixels belonging to the watershed lines are filled with the most present label of their 8 neighbors.
SEPARATED_REGIONS | The output is a label image representing only the marked basins. Pixels belonging to the watershed lines are considered as background (set to 0).
| Enumeration |  | SEPARATED_REGIONS
| neighborhood | The type of neighborhood used for the propagation.
CONNECTIVITY_4 | Connected components are defined by a 4-neighbor connectivity. The connectivity pattern is a cross.
CONNECTIVITY_8 | Connected components are defined by a 8-neighbor connectivity. The connectivity pattern is a square.
| Enumeration |  | CONNECTIVITY_4
| outputImage | The output binary image. Its dimensions are forced to the same values as the input image. Its type depends on the selected outputType and potentially on the highest label of the inputMarkerImage. | Image |  | nullptr

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| input_gray_image | The input grayscale image representing the landscape of the watershed. | image | Grayscale | None
| input_marker_image | The input label image of markers. | image | Label | None
| 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
| output_type | The type of output image.
LINES | The output is a binary image representing only the watershed lines.
CONTIGUOUS_REGIONS | The output is a label image representing only the marked basins. Pixels belonging to the watershed lines are filled with the most present label of their 8 neighbors.
SEPARATED_REGIONS | The output is a label image representing only the marked basins. Pixels belonging to the watershed lines are considered as background (set to 0).
| enumeration |  | SEPARATED_REGIONS
| neighborhood | The type of neighborhood used for the propagation.
CONNECTIVITY_4 | Connected components are defined by a 4-neighbor connectivity. The connectivity pattern is a cross.
CONNECTIVITY_8 | Connected components are defined by a 8-neighbor connectivity. The connectivity pattern is a square.
| enumeration |  | CONNECTIVITY_4
| output_image | The output binary image. Its dimensions are forced to the same values as the input image. Its type depends on the selected outputType and potentially on the highest label of the inputMarkerImage. | image |  | None

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| inputGrayImage | The input grayscale image representing the landscape of the watershed. | Image | Grayscale | null
| inputMarkerImage | The input label image of markers. | Image | Label | null
| 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
| outputType | The type of output image.
LINES | The output is a binary image representing only the watershed lines.
CONTIGUOUS_REGIONS | The output is a label image representing only the marked basins. Pixels belonging to the watershed lines are filled with the most present label of their 8 neighbors.
SEPARATED_REGIONS | The output is a label image representing only the marked basins. Pixels belonging to the watershed lines are considered as background (set to 0).
| Enumeration |  | SEPARATED_REGIONS
| neighborhood | The type of neighborhood used for the propagation.
CONNECTIVITY_4 | Connected components are defined by a 4-neighbor connectivity. The connectivity pattern is a cross.
CONNECTIVITY_8 | Connected components are defined by a 8-neighbor connectivity. The connectivity pattern is a square.
| Enumeration |  | CONNECTIVITY_4
| outputImage | The output binary image. Its dimensions are forced to the same values as the input image. Its type depends on the selected outputType and potentially on the highest label of the inputMarkerImage. | Image |  | null

## Object Examples

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

    MarkerBasedWatershed2d markerBasedWatershed2dAlgo;
    markerBasedWatershed2dAlgo.setInputGrayImage( polystyrene );
    markerBasedWatershed2dAlgo.setInputMarkerImage( polystyrene_sep_label );
    markerBasedWatershed2dAlgo.setAlgorithmMode( MarkerBasedWatershed2d::AlgorithmMode::REPEATABLE );
    markerBasedWatershed2dAlgo.setOutputType( MarkerBasedWatershed2d::OutputType::LINES );
    markerBasedWatershed2dAlgo.setNeighborhood( MarkerBasedWatershed2d::Neighborhood::CONNECTIVITY_4 );
    markerBasedWatershed2dAlgo.execute();

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

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

    marker_based_watershed_2d_algo = imagedev.MarkerBasedWatershed2d()
    marker_based_watershed_2d_algo.input_gray_image = polystyrene
    marker_based_watershed_2d_algo.input_marker_image = polystyrene_sep_label
    marker_based_watershed_2d_algo.algorithm_mode = imagedev.MarkerBasedWatershed2d.REPEATABLE
    marker_based_watershed_2d_algo.output_type = imagedev.MarkerBasedWatershed2d.LINES
    marker_based_watershed_2d_algo.neighborhood = imagedev.MarkerBasedWatershed2d.CONNECTIVITY_4
    marker_based_watershed_2d_algo.execute()

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

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

    MarkerBasedWatershed2d markerBasedWatershed2dAlgo = new MarkerBasedWatershed2d
    {
        inputGrayImage = polystyrene,
        inputMarkerImage = polystyrene_sep_label,
        algorithmMode = MarkerBasedWatershed2d.AlgorithmMode.REPEATABLE,
        outputType = MarkerBasedWatershed2d.OutputType.LINES,
        neighborhood = MarkerBasedWatershed2d.Neighborhood.CONNECTIVITY_4
    };
    markerBasedWatershed2dAlgo.Execute();

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

## Function Examples

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

    auto result = markerBasedWatershed2d( polystyrene, polystyrene_sep_label, MarkerBasedWatershed2d::AlgorithmMode::REPEATABLE, MarkerBasedWatershed2d::OutputType::LINES, MarkerBasedWatershed2d::Neighborhood::CONNECTIVITY_4 );

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

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

    result = imagedev.marker_based_watershed_2d(polystyrene, polystyrene_sep_label, imagedev.MarkerBasedWatershed2d.REPEATABLE, imagedev.MarkerBasedWatershed2d.LINES, imagedev.MarkerBasedWatershed2d.CONNECTIVITY_4)

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

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

    IOLink.ImageView result = Processing.MarkerBasedWatershed2d( polystyrene, polystyrene_sep_label, MarkerBasedWatershed2d.AlgorithmMode.REPEATABLE, MarkerBasedWatershed2d.OutputType.LINES, MarkerBasedWatershed2d.Neighborhood.CONNECTIVITY_4 );

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

© 2025 Thermo Fisher Scientific Inc. All rights reserved.