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

# SupervisedTextureClassification3d

Performs a segmentation of a three-dimensional grayscale image, based on a texture model automatically built from a training input image.
Access to parameter description
As an introduction:

- section Image Segmentation
- section Supervised Texture Classification

This algorithm automatically chains the 3 steps of the texture classification workflow: model creation, training, and model application.
See also

- AutoIntensityClassification
- TextureClassificationCreate
- TextureClassificationTrain
- TextureClassificationApply
- SupervisedTextureClassification3d

##
Function Syntax

This function returns a SupervisedTextureClassification3dOutput structure containing outputLabelImage and outputMapImage.

    // Output structure of the supervisedTextureClassification3d function.
    struct SupervisedTextureClassification3dOutput
    {
        /// The output label image representing the texture classification result. Its dimensions and type are forced to the same values as the training input.
        std::shared_ptr< iolink::ImageView > outputLabelImage;
        /// The output map image. Its dimensions are forced to the same values as the training image. In CLASS_DISTANCE mode, its number of channels is equal to the number of classes defined in the training image. Its data type is forced to floating point.
        std::shared_ptr< iolink::ImageView > outputMapImage;
    };

    // Function prototype
    SupervisedTextureClassification3dOutput
    supervisedTextureClassification3d( std::shared_ptr< iolink::ImageView > inputImage,
                                       std::shared_ptr< iolink::ImageView > inputTrainingImage,
                                       int32_t featureGroup,
                                       const iolink::Vector2u32& radiusRange,
                                       uint32_t radiusStep,
                                       uint32_t coocRadius,
                                       SupervisedTextureClassification3d::CoocTextonShape coocTextonShape,
                                       uint32_t coocTextonSize,
                                       double minSeparationPercentage,
                                       SupervisedTextureClassification3d::OutputMapType outputMapType,
                                       std::shared_ptr< iolink::ImageView > outputLabelImage = nullptr,
                                       std::shared_ptr< iolink::ImageView > outputMapImage = nullptr );

This function returns a tuple containing output_label_image and output_map_image.

    // Function prototype.
    supervised_texture_classification_3d(input_image: idt.ImageType,
                                         input_training_image: idt.ImageType,
                                         feature_group: Union[int, str, SupervisedTextureClassification3d.FeatureGroup] = 28,
                                         radius_range: Iterable[int] = [2, 8],
                                         radius_step: int = 6,
                                         cooc_radius: int = 6,
                                         cooc_texton_shape: SupervisedTextureClassification3d.CoocTextonShape = SupervisedTextureClassification3d.CoocTextonShape.SPHERE,
                                         cooc_texton_size: int = 2,
                                         min_separation_percentage: float = 3,
                                         output_map_type: SupervisedTextureClassification3d.OutputMapType = SupervisedTextureClassification3d.OutputMapType.CLOSEST_DISTANCE,
                                         output_label_image: idt.ImageType = None,
                                         output_map_image: idt.ImageType = None) -> Tuple[idt.ImageType, idt.ImageType]

This function returns a SupervisedTextureClassification3dOutput structure containing outputLabelImage and outputMapImage.

    /// Output structure of the SupervisedTextureClassification3d function.
    public struct SupervisedTextureClassification3dOutput
    {
        ///
        /// The output label image representing the texture classification result. Its dimensions and type are forced to the same values as the training input.
        ///
        public IOLink.ImageView outputLabelImage;
        ///
        /// The output map image. Its dimensions are forced to the same values as the training image. In CLASS_DISTANCE mode, its number of channels is equal to the number of classes defined in the training image. Its data type is forced to floating point.
        ///
        public IOLink.ImageView outputMapImage;
    };

    // Function prototype.
    public static SupervisedTextureClassification3dOutput
    SupervisedTextureClassification3d( IOLink.ImageView inputImage,
                                       IOLink.ImageView inputTrainingImage,
                                       Int32 featureGroup = 28,
                                       uint[] radiusRange = null,
                                       UInt32 radiusStep = 6,
                                       UInt32 coocRadius = 6,
                                       SupervisedTextureClassification3d.CoocTextonShape coocTextonShape = ImageDev.SupervisedTextureClassification3d.CoocTextonShape.SPHERE,
                                       UInt32 coocTextonSize = 2,
                                       double minSeparationPercentage = 3,
                                       SupervisedTextureClassification3d.OutputMapType outputMapType = ImageDev.SupervisedTextureClassification3d.OutputMapType.CLOSEST_DISTANCE,
                                       IOLink.ImageView outputLabelImage = null,
                                       IOLink.ImageView outputMapImage = null );

##
Class Syntax

    // Command constructor.
    SupervisedTextureClassification3d();

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

    /// Gets the inputTrainingImage parameter.
    /// The input label training image (16 or 32 bits) where each label represents a class sample for the training step.
    std::shared_ptr< iolink::ImageView > inputTrainingImage() const;
    /// Sets the inputTrainingImage parameter.
    /// The input label training image (16 or 32 bits) where each label represents a class sample for the training step.
    void setInputTrainingImage( std::shared_ptr< iolink::ImageView > inputTrainingImage );

    /// Gets the featureGroup parameter.
    /// The groups of textural features to compute. This list defines all the textural attributes proposed for performing the classification.
    int32_t featureGroup() const;
    /// Sets the featureGroup parameter.
    /// The groups of textural features to compute. This list defines all the textural attributes proposed for performing the classification.
    void setFeatureGroup( const int32_t& featureGroup );

    /// Gets the radiusRange parameter.
    /// The minimum and maximum radius, in voxels, of the circular neighborhoods used for computing textural features.
    iolink::Vector2u32 radiusRange() const;
    /// Sets the radiusRange parameter.
    /// The minimum and maximum radius, in voxels, of the circular neighborhoods used for computing textural features.
    void setRadiusRange( const iolink::Vector2u32& radiusRange );

    /// Gets the radiusStep parameter.
    /// The step, in voxels, used to define the set of radius between minimum and maximum. The maximum radius is systematically added to the radius list.
    uint32_t radiusStep() const;
    /// Sets the radiusStep parameter.
    /// The step, in voxels, used to define the set of radius between minimum and maximum. The maximum radius is systematically added to the radius list.
    void setRadiusStep( const uint32_t& radiusStep );

    /// Gets the coocRadius parameter.
    /// The radius, in voxels, of the circular neighborhood used by the co-occurrence features. This parameter is ignored if none of the co-occurrence feature groups is selected.
    uint32_t coocRadius() const;
    /// Sets the coocRadius parameter.
    /// The radius, in voxels, of the circular neighborhood used by the co-occurrence features. This parameter is ignored if none of the co-occurrence feature groups is selected.
    void setCoocRadius( const uint32_t& coocRadius );

    /// Gets the coocTextonShape parameter.
    /// The shape of the co-occurrence texton (the pattern defined by the set of co-occurrence vectors). This parameter is ignored if none of the co-occurrence feature groups is selected.
    SupervisedTextureClassification3d::CoocTextonShape coocTextonShape() const;
    /// Sets the coocTextonShape parameter.
    /// The shape of the co-occurrence texton (the pattern defined by the set of co-occurrence vectors). This parameter is ignored if none of the co-occurrence feature groups is selected.
    void setCoocTextonShape( const SupervisedTextureClassification3d::CoocTextonShape& coocTextonShape );

    /// Gets the coocTextonSize parameter.
    /// The size, in voxels, of the texton shape for co-occurrence features. This parameter is ignored if none of the co-occurrence feature groups is selected.
    uint32_t coocTextonSize() const;
    /// Sets the coocTextonSize parameter.
    /// The size, in voxels, of the texton shape for co-occurrence features. This parameter is ignored if none of the co-occurrence feature groups is selected.
    void setCoocTextonSize( const uint32_t& coocTextonSize );

    /// Gets the minSeparationPercentage parameter.
    /// This parameter controls the rejection criteria of the feature selection algorithm (FS).
    double minSeparationPercentage() const;
    /// Sets the minSeparationPercentage parameter.
    /// This parameter controls the rejection criteria of the feature selection algorithm (FS).
    void setMinSeparationPercentage( const double& minSeparationPercentage );

    /// Gets the outputMapType parameter.
    /// The type of uncertainty map image to compute.
    SupervisedTextureClassification3d::OutputMapType outputMapType() const;
    /// Sets the outputMapType parameter.
    /// The type of uncertainty map image to compute.
    void setOutputMapType( const SupervisedTextureClassification3d::OutputMapType& outputMapType );

    /// Gets the outputLabelImage parameter.
    /// The output label image representing the texture classification result. Its dimensions and type are forced to the same values as the training input.
    std::shared_ptr< iolink::ImageView > outputLabelImage() const;
    /// Sets the outputLabelImage parameter.
    /// The output label image representing the texture classification result. Its dimensions and type are forced to the same values as the training input.
    void setOutputLabelImage( std::shared_ptr< iolink::ImageView > outputLabelImage );

    /// Gets the outputMapImage parameter.
    /// The output map image. Its dimensions are forced to the same values as the training image. In CLASS_DISTANCE mode, its number of channels is equal to the number of classes defined in the training image. Its data type is forced to floating point.
    std::shared_ptr< iolink::ImageView > outputMapImage() const;
    /// Sets the outputMapImage parameter.
    /// The output map image. Its dimensions are forced to the same values as the training image. In CLASS_DISTANCE mode, its number of channels is equal to the number of classes defined in the training image. Its data type is forced to floating point.
    void setOutputMapImage( std::shared_ptr< iolink::ImageView > outputMapImage );

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

    # Property of the inputImage parameter.
    SupervisedTextureClassification3d.input_image
    # Property of the inputTrainingImage parameter.
    SupervisedTextureClassification3d.input_training_image
    # Property of the featureGroup parameter.
    SupervisedTextureClassification3d.feature_group
    # Property of the radiusRange parameter.
    SupervisedTextureClassification3d.radius_range
    # Property of the radiusStep parameter.
    SupervisedTextureClassification3d.radius_step
    # Property of the coocRadius parameter.
    SupervisedTextureClassification3d.cooc_radius
    # Property of the coocTextonShape parameter.
    SupervisedTextureClassification3d.cooc_texton_shape
    # Property of the coocTextonSize parameter.
    SupervisedTextureClassification3d.cooc_texton_size
    # Property of the minSeparationPercentage parameter.
    SupervisedTextureClassification3d.min_separation_percentage
    # Property of the outputMapType parameter.
    SupervisedTextureClassification3d.output_map_type
    # Property of the outputLabelImage parameter.
    SupervisedTextureClassification3d.output_label_image
    # Property of the outputMapImage parameter.
    SupervisedTextureClassification3d.output_map_image

    // Method to launch the command.
    execute()

    // Command constructor.
    SupervisedTextureClassification3d()

    // Property of the inputImage parameter.
    SupervisedTextureClassification3d.inputImage
    // Property of the inputTrainingImage parameter.
    SupervisedTextureClassification3d.inputTrainingImage
    // Property of the featureGroup parameter.
    SupervisedTextureClassification3d.featureGroup
    // Property of the radiusRange parameter.
    SupervisedTextureClassification3d.radiusRange
    // Property of the radiusStep parameter.
    SupervisedTextureClassification3d.radiusStep
    // Property of the coocRadius parameter.
    SupervisedTextureClassification3d.coocRadius
    // Property of the coocTextonShape parameter.
    SupervisedTextureClassification3d.coocTextonShape
    // Property of the coocTextonSize parameter.
    SupervisedTextureClassification3d.coocTextonSize
    // Property of the minSeparationPercentage parameter.
    SupervisedTextureClassification3d.minSeparationPercentage
    // Property of the outputMapType parameter.
    SupervisedTextureClassification3d.outputMapType
    // Property of the outputLabelImage parameter.
    SupervisedTextureClassification3d.outputLabelImage
    // Property of the outputMapImage parameter.
    SupervisedTextureClassification3d.outputMapImage

    // Method to launch the command.
    Execute()

## Parameters

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| inputImage | The input grayscale image to segment. | Image | Grayscale | nullptr
| inputTrainingImage | The input label training image (16 or 32 bits) where each label represents a class sample for the training step. | Image | Label | nullptr
| featureGroup | The groups of textural features to compute. This list defines all the textural attributes proposed for performing the classification.
DIRECTIONAL_COOCCURRENCE | Features based on co-occurrence matrices. One feature is extracted from each co-occurrence vector. Associated value = 1.
ROTATION_INVARIANT_COOCCURRENCE | Features based on co-occurrence matrices. Three statistical features are extracted from all vectors. Associated value = 2.
FIRST_ORDER_STATISTICS | Features based on first order statistics that are not computed using a histogram. Associated value = 4.
HISTOGRAM_STATISTICS | Features based on histogram statistics, including histogram quantiles. Associated value = 8.
INTENSITY | Feature based on the intensity value of the input image. Associated value = 16.
| MultipleChoice |  | FIRST_ORDER_STATISTICS | HISTOGRAM_STATISTICS | INTENSITY
| radiusRange | The minimum and maximum radius, in voxels, of the circular neighborhoods used for computing textural features. | Vector2u32 | >=1 | {2, 8}
| radiusStep | The step, in voxels, used to define the set of radius between minimum and maximum. The maximum radius is systematically added to the radius list. | UInt32 | >=1 | 6
| coocRadius | The radius, in voxels, of the circular neighborhood used by the co-occurrence features. This parameter is ignored if none of the co-occurrence feature groups is selected. | UInt32 | >=1 | 6
| coocTextonShape | The shape of the co-occurrence texton (the pattern defined by the set of co-occurrence vectors). This parameter is ignored if none of the co-occurrence feature groups is selected. The texton shape represents the distribution of points around the target point for computing the co-occurrence matrices. Associated to the texton size, it defines the set of vectors that are used for computing co-occurrence features. For instance, in 2D, a cube shape of size 3 defines the co-occurrence vectors (-3, -3), (0, -3), (3, -3), (-3, 0), (3, 0), (-3, 3), (0, 3) and (3, 3).
CUBE | The set of all points associated to corners, edge centers, and face centers of a cube with a half side size defined by the coocTextonSize parameter.
SPHERE | The set of all the points located at the same euclidean distance defined by the coocTextonSize parameter from the center. This mode is recommended when a repetitive texture is mono-scale.
BALL | The set of all the points located at a distance less or equal to the coocTextonSize parameter from the center. This mode can be useful to classify a multi-scale repetitive texture, but may be very time consuming.
| Enumeration |  | SPHERE
| coocTextonSize | The size, in voxels, of the texton shape for co-occurrence features. This parameter is ignored if none of the co-occurrence feature groups is selected. This size is constrained by the radius parameter. The constraint depends on the texton shape. For instance, with a cube texton, the texton size cannot exceed the rounded value of $radius \times \sqrt{3}$. | UInt32 | >=1 | 2
| minSeparationPercentage | This parameter controls the rejection criteria of the feature selection algorithm (FS). A measure is rejected if its contribution does not increase enough the separation power of the classification model. This ratio indicates the minimal relative growth required to keep a measure. More information is available in the Feature Selection section. This value must be greater than or equal to 0.0. | Float64 | [0, 100] | 3
| outputMapType | The type of uncertainty map image to compute.
CLOSEST_DISTANCE | The uncertainty map represents the Mahalanobis distance to the class selected by the classification. The closer to 0 this metric is, the more confident the classification.
RELATIVE_DISTANCE | The uncertainty map represents the Mahalanobis distance to the class selected by the classification (d1) weighted by the gap with the second closest distance (d2). The smaller this metric is, the more confident and less ambiguous the classification. $$ Map Value = log \left( \frac {d1}{d2 - d1} \right) $$
CLASS_DISTANCE | The uncertainty map is a multichannel image where each channel represents the distance to the corresponding class.
NONE | No uncertainty map is computed.
| Enumeration |  | CLOSEST_DISTANCE
| outputLabelImage | The output label image representing the texture classification result. Its dimensions and type are forced to the same values as the training input. | Image |  | nullptr
| outputMapImage | The output map image. Its dimensions are forced to the same values as the training image. In CLASS_DISTANCE mode, its number of channels is equal to the number of classes defined in the training image. Its data type is forced to floating point. | Image |  | nullptr

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| input_image | The input grayscale image to segment. | image | Grayscale | None
| input_training_image | The input label training image (16 or 32 bits) where each label represents a class sample for the training step. | image | Label | None
| feature_group | The groups of textural features to compute. This list defines all the textural attributes proposed for performing the classification.
DIRECTIONAL_COOCCURRENCE | Features based on co-occurrence matrices. One feature is extracted from each co-occurrence vector. Associated value = 1.
ROTATION_INVARIANT_COOCCURRENCE | Features based on co-occurrence matrices. Three statistical features are extracted from all vectors. Associated value = 2.
FIRST_ORDER_STATISTICS | Features based on first order statistics that are not computed using a histogram. Associated value = 4.
HISTOGRAM_STATISTICS | Features based on histogram statistics, including histogram quantiles. Associated value = 8.
INTENSITY | Feature based on the intensity value of the input image. Associated value = 16.
| multiple_choice |  | FIRST_ORDER_STATISTICS | HISTOGRAM_STATISTICS | INTENSITY
| radius_range | The minimum and maximum radius, in voxels, of the circular neighborhoods used for computing textural features. | vector2u32 | >=1 | [2, 8]
| radius_step | The step, in voxels, used to define the set of radius between minimum and maximum. The maximum radius is systematically added to the radius list. | uint32 | >=1 | 6
| cooc_radius | The radius, in voxels, of the circular neighborhood used by the co-occurrence features. This parameter is ignored if none of the co-occurrence feature groups is selected. | uint32 | >=1 | 6
| cooc_texton_shape | The shape of the co-occurrence texton (the pattern defined by the set of co-occurrence vectors). This parameter is ignored if none of the co-occurrence feature groups is selected. The texton shape represents the distribution of points around the target point for computing the co-occurrence matrices. Associated to the texton size, it defines the set of vectors that are used for computing co-occurrence features. For instance, in 2D, a cube shape of size 3 defines the co-occurrence vectors (-3, -3), (0, -3), (3, -3), (-3, 0), (3, 0), (-3, 3), (0, 3) and (3, 3).
CUBE | The set of all points associated to corners, edge centers, and face centers of a cube with a half side size defined by the coocTextonSize parameter.
SPHERE | The set of all the points located at the same euclidean distance defined by the coocTextonSize parameter from the center. This mode is recommended when a repetitive texture is mono-scale.
BALL | The set of all the points located at a distance less or equal to the coocTextonSize parameter from the center. This mode can be useful to classify a multi-scale repetitive texture, but may be very time consuming.
| enumeration |  | SPHERE
| cooc_texton_size | The size, in voxels, of the texton shape for co-occurrence features. This parameter is ignored if none of the co-occurrence feature groups is selected. This size is constrained by the radius parameter. The constraint depends on the texton shape. For instance, with a cube texton, the texton size cannot exceed the rounded value of $radius \times \sqrt{3}$. | uint32 | >=1 | 2
| min_separation_percentage | This parameter controls the rejection criteria of the feature selection algorithm (FS). A measure is rejected if its contribution does not increase enough the separation power of the classification model. This ratio indicates the minimal relative growth required to keep a measure. More information is available in the Feature Selection section. This value must be greater than or equal to 0.0. | float64 | [0, 100] | 3
| output_map_type | The type of uncertainty map image to compute.
CLOSEST_DISTANCE | The uncertainty map represents the Mahalanobis distance to the class selected by the classification. The closer to 0 this metric is, the more confident the classification.
RELATIVE_DISTANCE | The uncertainty map represents the Mahalanobis distance to the class selected by the classification (d1) weighted by the gap with the second closest distance (d2). The smaller this metric is, the more confident and less ambiguous the classification. $$ Map Value = log \left( \frac {d1}{d2 - d1} \right) $$
CLASS_DISTANCE | The uncertainty map is a multichannel image where each channel represents the distance to the corresponding class.
NONE | No uncertainty map is computed.
| enumeration |  | CLOSEST_DISTANCE
| output_label_image | The output label image representing the texture classification result. Its dimensions and type are forced to the same values as the training input. | image |  | None
| output_map_image | The output map image. Its dimensions are forced to the same values as the training image. In CLASS_DISTANCE mode, its number of channels is equal to the number of classes defined in the training image. Its data type is forced to floating point. | image |  | None

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| inputImage | The input grayscale image to segment. | Image | Grayscale | null
| inputTrainingImage | The input label training image (16 or 32 bits) where each label represents a class sample for the training step. | Image | Label | null
| featureGroup | The groups of textural features to compute. This list defines all the textural attributes proposed for performing the classification.
DIRECTIONAL_COOCCURRENCE | Features based on co-occurrence matrices. One feature is extracted from each co-occurrence vector. Associated value = 1.
ROTATION_INVARIANT_COOCCURRENCE | Features based on co-occurrence matrices. Three statistical features are extracted from all vectors. Associated value = 2.
FIRST_ORDER_STATISTICS | Features based on first order statistics that are not computed using a histogram. Associated value = 4.
HISTOGRAM_STATISTICS | Features based on histogram statistics, including histogram quantiles. Associated value = 8.
INTENSITY | Feature based on the intensity value of the input image. Associated value = 16.
| MultipleChoice |  | FIRST_ORDER_STATISTICS | HISTOGRAM_STATISTICS | INTENSITY
| radiusRange | The minimum and maximum radius, in voxels, of the circular neighborhoods used for computing textural features. | Vector2u32 | >=1 | {2, 8}
| radiusStep | The step, in voxels, used to define the set of radius between minimum and maximum. The maximum radius is systematically added to the radius list. | UInt32 | >=1 | 6
| coocRadius | The radius, in voxels, of the circular neighborhood used by the co-occurrence features. This parameter is ignored if none of the co-occurrence feature groups is selected. | UInt32 | >=1 | 6
| coocTextonShape | The shape of the co-occurrence texton (the pattern defined by the set of co-occurrence vectors). This parameter is ignored if none of the co-occurrence feature groups is selected. The texton shape represents the distribution of points around the target point for computing the co-occurrence matrices. Associated to the texton size, it defines the set of vectors that are used for computing co-occurrence features. For instance, in 2D, a cube shape of size 3 defines the co-occurrence vectors (-3, -3), (0, -3), (3, -3), (-3, 0), (3, 0), (-3, 3), (0, 3) and (3, 3).
CUBE | The set of all points associated to corners, edge centers, and face centers of a cube with a half side size defined by the coocTextonSize parameter.
SPHERE | The set of all the points located at the same euclidean distance defined by the coocTextonSize parameter from the center. This mode is recommended when a repetitive texture is mono-scale.
BALL | The set of all the points located at a distance less or equal to the coocTextonSize parameter from the center. This mode can be useful to classify a multi-scale repetitive texture, but may be very time consuming.
| Enumeration |  | SPHERE
| coocTextonSize | The size, in voxels, of the texton shape for co-occurrence features. This parameter is ignored if none of the co-occurrence feature groups is selected. This size is constrained by the radius parameter. The constraint depends on the texton shape. For instance, with a cube texton, the texton size cannot exceed the rounded value of $radius \times \sqrt{3}$. | UInt32 | >=1 | 2
| minSeparationPercentage | This parameter controls the rejection criteria of the feature selection algorithm (FS). A measure is rejected if its contribution does not increase enough the separation power of the classification model. This ratio indicates the minimal relative growth required to keep a measure. More information is available in the Feature Selection section. This value must be greater than or equal to 0.0. | Float64 | [0, 100] | 3
| outputMapType | The type of uncertainty map image to compute.
CLOSEST_DISTANCE | The uncertainty map represents the Mahalanobis distance to the class selected by the classification. The closer to 0 this metric is, the more confident the classification.
RELATIVE_DISTANCE | The uncertainty map represents the Mahalanobis distance to the class selected by the classification (d1) weighted by the gap with the second closest distance (d2). The smaller this metric is, the more confident and less ambiguous the classification. $$ Map Value = log \left( \frac {d1}{d2 - d1} \right) $$
CLASS_DISTANCE | The uncertainty map is a multichannel image where each channel represents the distance to the corresponding class.
NONE | No uncertainty map is computed.
| Enumeration |  | CLOSEST_DISTANCE
| outputLabelImage | The output label image representing the texture classification result. Its dimensions and type are forced to the same values as the training input. | Image |  | null
| outputMapImage | The output map image. Its dimensions are forced to the same values as the training image. In CLASS_DISTANCE mode, its number of channels is equal to the number of classes defined in the training image. Its data type is forced to floating point. | Image |  | null

## Object Examples

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

    SupervisedTextureClassification3d supervisedTextureClassification3dAlgo;
    supervisedTextureClassification3dAlgo.setInputImage( foam );
    supervisedTextureClassification3dAlgo.setInputTrainingImage( foam_sep_label );
    supervisedTextureClassification3dAlgo.setFeatureGroup( 4 );
    supervisedTextureClassification3dAlgo.setRadiusRange( {2, 4} );
    supervisedTextureClassification3dAlgo.setRadiusStep( 4 );
    supervisedTextureClassification3dAlgo.setCoocRadius( 4 );
    supervisedTextureClassification3dAlgo.setCoocTextonShape( SupervisedTextureClassification3d::CoocTextonShape::CUBE );
    supervisedTextureClassification3dAlgo.setCoocTextonSize( 2 );
    supervisedTextureClassification3dAlgo.setMinSeparationPercentage( 3 );
    supervisedTextureClassification3dAlgo.setOutputMapType( SupervisedTextureClassification3d::OutputMapType::CLOSEST_DISTANCE );
    supervisedTextureClassification3dAlgo.execute();

    std::cout << "outputLabelImage:" << supervisedTextureClassification3dAlgo.outputLabelImage()->toString();
    std::cout << "outputMapImage:" << supervisedTextureClassification3dAlgo.outputMapImage()->toString();

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

    supervised_texture_classification_3d_algo = imagedev.SupervisedTextureClassification3d()
    supervised_texture_classification_3d_algo.input_image = foam
    supervised_texture_classification_3d_algo.input_training_image = foam_sep_label
    supervised_texture_classification_3d_algo.feature_group = 4
    supervised_texture_classification_3d_algo.radius_range = [2, 4]
    supervised_texture_classification_3d_algo.radius_step = 4
    supervised_texture_classification_3d_algo.cooc_radius = 4
    supervised_texture_classification_3d_algo.cooc_texton_shape = imagedev.SupervisedTextureClassification3d.CUBE
    supervised_texture_classification_3d_algo.cooc_texton_size = 2
    supervised_texture_classification_3d_algo.min_separation_percentage = 3
    supervised_texture_classification_3d_algo.output_map_type = imagedev.SupervisedTextureClassification3d.CLOSEST_DISTANCE
    supervised_texture_classification_3d_algo.execute()

    print("output_label_image:", str(supervised_texture_classification_3d_algo.output_label_image))
    print("output_map_image:", str(supervised_texture_classification_3d_algo.output_map_image))

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

    SupervisedTextureClassification3d supervisedTextureClassification3dAlgo = new SupervisedTextureClassification3d
    {
        inputImage = foam,
        inputTrainingImage = foam_sep_label,
        featureGroup = 4,
        radiusRange = new uint[]{2, 4},
        radiusStep = 4,
        coocRadius = 4,
        coocTextonShape = SupervisedTextureClassification3d.CoocTextonShape.CUBE,
        coocTextonSize = 2,
        minSeparationPercentage = 3,
        outputMapType = SupervisedTextureClassification3d.OutputMapType.CLOSEST_DISTANCE
    };
    supervisedTextureClassification3dAlgo.Execute();

    Console.WriteLine( "outputLabelImage:" + supervisedTextureClassification3dAlgo.outputLabelImage.ToString() );
    Console.WriteLine( "outputMapImage:" + supervisedTextureClassification3dAlgo.outputMapImage.ToString() );

## Function Examples

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

    auto result = supervisedTextureClassification3d( foam, foam_sep_label, 4, {2, 4}, 4, 4, SupervisedTextureClassification3d::CoocTextonShape::CUBE, 2, 3, SupervisedTextureClassification3d::OutputMapType::CLOSEST_DISTANCE );

    std::cout << "outputLabelImage:" << result.outputLabelImage->toString();
    std::cout << "outputMapImage:" << result.outputMapImage->toString();

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

    result_output_label_image, result_output_map_image = imagedev.supervised_texture_classification_3d(foam, foam_sep_label, 4, [2, 4], 4, 4, imagedev.SupervisedTextureClassification3d.CUBE, 2, 3, imagedev.SupervisedTextureClassification3d.CLOSEST_DISTANCE)

    print("output_label_image:", str(result_output_label_image))
    print("output_map_image:", str(result_output_map_image))

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

    Processing.SupervisedTextureClassification3dOutput result = Processing.SupervisedTextureClassification3d( foam, foam_sep_label, 4, new uint[]{2, 4}, 4, 4, SupervisedTextureClassification3d.CoocTextonShape.CUBE, 2, 3, SupervisedTextureClassification3d.OutputMapType.CLOSEST_DISTANCE );

    Console.WriteLine( "outputLabelImage:" + result.outputLabelImage.ToString() );
    Console.WriteLine( "outputMapImage:" + result.outputMapImage.ToString() );

© 2025 Thermo Fisher Scientific Inc. All rights reserved.