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

# Waterpixel

Computes an image of atomic regions that share common characteristics.
Access to parameter description
For an introduction:

- section Image Segmentation

Superpixel techniques consist in segmenting an image into regions by considering similarity measures. The idea is to create a group of pixels that share common characteristics (like pixel intensity). The motivation is to obtain regions that represent meaningful descriptions with far less data than when using all image pixels.
Superpixels replace the rigid pixel structure by delineating regions that maintain meaning in the image, so the regions provide information about the structure of the scene, making other processing tasks simpler than using single image pixels.
The Waterpixel algorithm computes an image of binary borders or labeled regions associated to a grid of user-defined cell size. This grid is warped to fit the input image high intensities, generally representing edges. The warping is performed by applying a watershed on the input image. Markers used by the watershed are choosen as local minima close to the cell centers.
In order to ensure a regular size to the output superpixels, the input image is blended with the grid. A regularization factor is used to control the weight given to the grid relatively to the original intensities.

(a) | (b) | (c)

Figure 1. Superpixel generation with the waterpixel algorithm:(a) Input image given by a morphological gradient,
(b) waterpixels emphasizing the regular grid (high regularization factor), (c) waterpixels emphasizing the input image (low regularization factor)
Reference:
V. Machairas, E. Decenciere, T. Walter. "Waterpixels: Superpixels based on the watershed transformation". IEEE International Conference On Image Processing, Paris, France, Oct 2014.
See also

- BoxGridImage2d
- MarkerBasedWatershed2d

##
Function Syntax

This function returns outputImage.

    // Function prototype
    std::shared_ptr< iolink::ImageView >
    waterpixel( std::shared_ptr< iolink::ImageView > inputImage,
                uint32_t cellSize,
                uint32_t factor,
                Waterpixel::AlgorithmMode algorithmMode,
                Waterpixel::OutputType outputType,
                std::shared_ptr< iolink::ImageView > outputImage = nullptr );

This function returns outputImage.

    // Function prototype.
    waterpixel(input_image: idt.ImageType,
               cell_size: int = 25,
               factor: int = 10,
               algorithm_mode: Waterpixel.AlgorithmMode = Waterpixel.AlgorithmMode.REPEATABLE,
               output_type: Waterpixel.OutputType = Waterpixel.OutputType.SEPARATED_REGIONS,
               output_image: idt.ImageType = None) -> idt.ImageType

This function returns outputImage.

    // Function prototype.
    public static IOLink.ImageView
    Waterpixel( IOLink.ImageView inputImage,
                UInt32 cellSize = 25,
                UInt32 factor = 10,
                Waterpixel.AlgorithmMode algorithmMode = ImageDev.Waterpixel.AlgorithmMode.REPEATABLE,
                Waterpixel.OutputType outputType = ImageDev.Waterpixel.OutputType.SEPARATED_REGIONS,
                IOLink.ImageView outputImage = null );

##
Class Syntax

    // Command constructor.
    Waterpixel();

    /// Gets the inputImage parameter.
    /// The input grayscale image highlighting object boundaries, generally a gradient image.
    std::shared_ptr< iolink::ImageView > inputImage() const;
    /// Sets the inputImage parameter.
    /// The input grayscale image highlighting object boundaries, generally a gradient image.
    void setInputImage( std::shared_ptr< iolink::ImageView > inputImage );

    /// Gets the cellSize parameter.
    /// The side size, in pixels, of the square cells used to generate superpixels.
    uint32_t cellSize() const;
    /// Sets the cellSize parameter.
    /// The side size, in pixels, of the square cells used to generate superpixels.
    void setCellSize( const uint32_t& cellSize );

    /// Gets the factor parameter.
    /// The spatial regularization factor.
    uint32_t factor() const;
    /// Sets the factor parameter.
    /// The spatial regularization factor.
    void setFactor( const uint32_t& factor );

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

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

    /// Gets the outputImage parameter.
    /// The output 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 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 inputImage parameter.
    Waterpixel.input_image
    # Property of the cellSize parameter.
    Waterpixel.cell_size
    # Property of the factor parameter.
    Waterpixel.factor
    # Property of the algorithmMode parameter.
    Waterpixel.algorithm_mode
    # Property of the outputType parameter.
    Waterpixel.output_type
    # Property of the outputImage parameter.
    Waterpixel.output_image

    // Method to launch the command.
    execute()

    // Command constructor.
    Waterpixel()

    // Property of the inputImage parameter.
    Waterpixel.inputImage
    // Property of the cellSize parameter.
    Waterpixel.cellSize
    // Property of the factor parameter.
    Waterpixel.factor
    // Property of the algorithmMode parameter.
    Waterpixel.algorithmMode
    // Property of the outputType parameter.
    Waterpixel.outputType
    // Property of the outputImage parameter.
    Waterpixel.outputImage

    // Method to launch the command.
    Execute()

## Parameters

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| inputImage | The input grayscale image highlighting object boundaries, generally a gradient image. | Image | Grayscale | nullptr
| cellSize | The side size, in pixels, of the square cells used to generate superpixels. | UInt32 | >=3 | 25
| factor | The spatial regularization factor. A low value makes the output superpixels fit on original intensities and generates irregular regions. A high value makes the output superpixels fit on cell boundaries. | UInt32 | Any value | 10
| outputType | The type of output.
LINES | The output image is a binary image containing superpixels boundaries.
CONTIGUOUS_REGIONS | The output image is a label image representing connected superpixels.
SEPARATED_REGIONS | The output image is a label image representing superpixels separated by a line of background.
| Enumeration |  | SEPARATED_REGIONS
| 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
| outputImage | The output 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_image | The input grayscale image highlighting object boundaries, generally a gradient image. | image | Grayscale | None
| cell_size | The side size, in pixels, of the square cells used to generate superpixels. | uint32 | >=3 | 25
| factor | The spatial regularization factor. A low value makes the output superpixels fit on original intensities and generates irregular regions. A high value makes the output superpixels fit on cell boundaries. | uint32 | Any value | 10
| output_type | The type of output.
LINES | The output image is a binary image containing superpixels boundaries.
CONTIGUOUS_REGIONS | The output image is a label image representing connected superpixels.
SEPARATED_REGIONS | The output image is a label image representing superpixels separated by a line of background.
| enumeration |  | SEPARATED_REGIONS
| 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_image | The output 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
--- | --- | --- | --- | ---
| inputImage | The input grayscale image highlighting object boundaries, generally a gradient image. | Image | Grayscale | null
| cellSize | The side size, in pixels, of the square cells used to generate superpixels. | UInt32 | >=3 | 25
| factor | The spatial regularization factor. A low value makes the output superpixels fit on original intensities and generates irregular regions. A high value makes the output superpixels fit on cell boundaries. | UInt32 | Any value | 10
| outputType | The type of output.
LINES | The output image is a binary image containing superpixels boundaries.
CONTIGUOUS_REGIONS | The output image is a label image representing connected superpixels.
SEPARATED_REGIONS | The output image is a label image representing superpixels separated by a line of background.
| Enumeration |  | SEPARATED_REGIONS
| 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
| outputImage | The output 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 ateneub_grad = ioformat::readImage( std::string( IMAGEDEVDATA_IMAGES_FOLDER ) + "ateneub_grad.tif" );

    Waterpixel waterpixelAlgo;
    waterpixelAlgo.setInputImage( ateneub_grad );
    waterpixelAlgo.setCellSize( 25 );
    waterpixelAlgo.setFactor( 10 );
    waterpixelAlgo.setAlgorithmMode( Waterpixel::AlgorithmMode::REPEATABLE );
    waterpixelAlgo.setOutputType( Waterpixel::OutputType::SEPARATED_REGIONS );
    waterpixelAlgo.execute();

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

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

    waterpixel_algo = imagedev.Waterpixel()
    waterpixel_algo.input_image = ateneub_grad
    waterpixel_algo.cell_size = 25
    waterpixel_algo.factor = 10
    waterpixel_algo.algorithm_mode = imagedev.Waterpixel.REPEATABLE
    waterpixel_algo.output_type = imagedev.Waterpixel.SEPARATED_REGIONS
    waterpixel_algo.execute()

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

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

    Waterpixel waterpixelAlgo = new Waterpixel
    {
        inputImage = ateneub_grad,
        cellSize = 25,
        factor = 10,
        algorithmMode = Waterpixel.AlgorithmMode.REPEATABLE,
        outputType = Waterpixel.OutputType.SEPARATED_REGIONS
    };
    waterpixelAlgo.Execute();

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

## Function Examples

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

    auto result = waterpixel( ateneub_grad, 25, 10, Waterpixel::AlgorithmMode::REPEATABLE, Waterpixel::OutputType::SEPARATED_REGIONS );

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

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

    result = imagedev.waterpixel(ateneub_grad, 25, 10, imagedev.Waterpixel.REPEATABLE, imagedev.Waterpixel.SEPARATED_REGIONS)

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

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

    IOLink.ImageView result = Processing.Waterpixel( ateneub_grad, 25, 10, Waterpixel.AlgorithmMode.REPEATABLE, Waterpixel.OutputType.SEPARATED_REGIONS );

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

© 2025 Thermo Fisher Scientific Inc. All rights reserved.