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

# LabelFilteringAnalysis

Computes measurements on objects and filters them from a label image.
Access to parameter description
For an introduction:

- section Image Analysis
- section Label Filtering

This algorithm is similar to the LabelAnalysis algorithm except that it applies a filter formula with its criteria to the analyzed image. Then it outputs the filtered label image and the corresponding analysis result object.
The input filter contains the criteria to preserve objects from the input label image. These criteria are defined by one or several analysis measurements ranges.
If the label input image has a coordinate system unit defined in its calibration property, the filter limit values and analysis results are expressed in this coordinate system unit.
See also

- LabelAnalysis
- LabelFiltering
- FilterAnalysis

##
Function Syntax

This function returns a LabelFilteringAnalysisOutput structure containing outputAnalysis and outputLabelImage.

    // Output structure of the labelFilteringAnalysis function.
    struct LabelFilteringAnalysisOutput
    {
        /// The output label image. Its dimensions and type are forced to the same values as the input.
        std::shared_ptr< iolink::ImageView > outputLabelImage;
        /// The output analysis.
        AnalysisMsr::Ptr outputAnalysis;
    };

    // Function prototype
    LabelFilteringAnalysisOutput
    labelFilteringAnalysis( std::shared_ptr< iolink::ImageView > inputLabelImage,
                            std::shared_ptr< iolink::ImageView > inputIntensityImage,
                            const std::string& inputFilter,
                            AnalysisMsr::Ptr outputAnalysis = nullptr,
                            std::shared_ptr< iolink::ImageView > outputLabelImage = nullptr );

This function returns a tuple containing output_analysis and output_label_image.

    // Function prototype.
    label_filtering_analysis(input_label_image: idt.ImageType,
                             input_intensity_image: idt.ImageType,
                             input_filter: str = "",
                             output_analysis: Union[Any, None] = None,
                             output_label_image: idt.ImageType = None) -> Tuple[AnalysisMsr, idt.ImageType]

This function returns a LabelFilteringAnalysisOutput structure containing outputAnalysis and outputLabelImage.

    /// Output structure of the LabelFilteringAnalysis function.
    public struct LabelFilteringAnalysisOutput
    {
        ///
        /// The output label image. Its dimensions and type are forced to the same values as the input.
        ///
        public IOLink.ImageView outputLabelImage;
        /// The output analysis.
        public AnalysisMsr outputAnalysis;
    };

    // Function prototype.
    public static LabelFilteringAnalysisOutput
    LabelFilteringAnalysis( IOLink.ImageView inputLabelImage,
                            IOLink.ImageView inputIntensityImage,
                            string inputFilter = "",
                            AnalysisMsr outputAnalysis = null,
                            IOLink.ImageView outputLabelImage = null );

##
Class Syntax

    // Command constructor.
    LabelFilteringAnalysis();

    /// Gets the inputLabelImage parameter.
    /// The label input image
    std::shared_ptr< iolink::ImageView > inputLabelImage() const;
    /// Sets the inputLabelImage parameter.
    /// The label input image
    void setInputLabelImage( std::shared_ptr< iolink::ImageView > inputLabelImage );

    /// Gets the inputIntensityImage parameter.
    /// The intensity input image. If it equals null, the label input image will be used as the intensity input image.
    std::shared_ptr< iolink::ImageView > inputIntensityImage() const;
    /// Sets the inputIntensityImage parameter.
    /// The intensity input image. If it equals null, the label input image will be used as the intensity input image.
    void setInputIntensityImage( std::shared_ptr< iolink::ImageView > inputIntensityImage );

    /// Gets the inputFilter parameter.
    /// The input filter formula.
    std::string inputFilter() const;
    /// Sets the inputFilter parameter.
    /// The input filter formula.
    void setInputFilter( const std::string& inputFilter );

    /// Gets the outputAnalysis parameter.
    /// The output analysis.
    AnalysisMsr::Ptr outputAnalysis() const;
    /// Sets the outputAnalysis parameter.
    /// The output analysis.
    void setOutputAnalysis( AnalysisMsr::Ptr outputAnalysis );

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

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

    # Property of the inputLabelImage parameter.
    LabelFilteringAnalysis.input_label_image
    # Property of the inputIntensityImage parameter.
    LabelFilteringAnalysis.input_intensity_image
    # Property of the inputFilter parameter.
    LabelFilteringAnalysis.input_filter
    # Property of the outputAnalysis parameter.
    LabelFilteringAnalysis.output_analysis
    # Property of the outputLabelImage parameter.
    LabelFilteringAnalysis.output_label_image

    // Method to launch the command.
    execute()

    // Command constructor.
    LabelFilteringAnalysis()

    // Property of the inputLabelImage parameter.
    LabelFilteringAnalysis.inputLabelImage
    // Property of the inputIntensityImage parameter.
    LabelFilteringAnalysis.inputIntensityImage
    // Property of the inputFilter parameter.
    LabelFilteringAnalysis.inputFilter
    // Property of the outputAnalysis parameter.
    LabelFilteringAnalysis.outputAnalysis
    // Property of the outputLabelImage parameter.
    LabelFilteringAnalysis.outputLabelImage

    // Method to launch the command.
    Execute()

## Parameters

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| inputLabelImage | The label input image | Image | Label | nullptr
| inputIntensityImage | The intensity input image. If it equals null, the label input image will be used as the intensity input image. | Image | Binary, Label, Grayscale or Multispectral | nullptr
| inputFilter | The input filter formula. The Label Filtering section details how to create a filter. | Filter |  | ""
| outputLabelImage | The output label image. Its dimensions and type are forced to the same values as the input. | Image |  | nullptr
| outputAnalysis | The output analysis. | AnalysisMsr |  | nullptr

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| input_label_image | The label input image | image | Label | None
| input_intensity_image | The intensity input image. If it equals null, the label input image will be used as the intensity input image. | image | Binary, Label, Grayscale or Multispectral | None
| input_filter | The input filter formula. The Label Filtering section details how to create a filter. | filter |  | ""
| output_label_image | The output label image. Its dimensions and type are forced to the same values as the input. | image |  | None
| output_analysis | The output analysis. | AnalysisMsr |  | None

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| inputLabelImage | The label input image | Image | Label | null
| inputIntensityImage | The intensity input image. If it equals null, the label input image will be used as the intensity input image. | Image | Binary, Label, Grayscale or Multispectral | null
| inputFilter | The input filter formula. The Label Filtering section details how to create a filter. | Filter |  | ""
| outputLabelImage | The output label image. Its dimensions and type are forced to the same values as the input. | Image |  | null
| outputAnalysis | The output analysis. | AnalysisMsr |  | null

## Object Examples

    auto polystyrene_sep_label = readVipImage( std::string( IMAGEDEVDATA_IMAGES_FOLDER ) + "polystyrene_sep_label.vip" );
    auto polystyrene = ioformat::readImage( std::string( IMAGEDEVDATA_IMAGES_FOLDER ) + "polystyrene.tif" );
    AnalysisMsr::Ptr analysis= AnalysisMsr::read( std::string( IMAGEDEVDATA_OBJECTS_FOLDER ) + "analysis.vip" );

    LabelFilteringAnalysis labelFilteringAnalysisAlgo;
    labelFilteringAnalysisAlgo.setInputLabelImage( polystyrene_sep_label );
    labelFilteringAnalysisAlgo.setInputIntensityImage( polystyrene );
    labelFilteringAnalysisAlgo.setInputFilter( "Area>=3000" );
    labelFilteringAnalysisAlgo.setOutputAnalysis( analysis );
    labelFilteringAnalysisAlgo.execute();

    std::cout << "Area2d: " << labelFilteringAnalysisAlgo.outputAnalysis()->get( NativeMeasurements::area2d )->value( 0 ) ;
    std::cout << "outputLabelImage:" << labelFilteringAnalysisAlgo.outputLabelImage()->toString();

    polystyrene_sep_label = imagedev.read_vip_image(imagedev_data.get_image_path("polystyrene_sep_label.vip"))
    polystyrene = ioformat.read_image(imagedev_data.get_image_path("polystyrene.tif"))
    analysis = imagedev.AnalysisMsr.read(imagedev_data.get_object_path("analysis.vip"))

    label_filtering_analysis_algo = imagedev.LabelFilteringAnalysis()
    label_filtering_analysis_algo.input_label_image = polystyrene_sep_label
    label_filtering_analysis_algo.input_intensity_image = polystyrene
    label_filtering_analysis_algo.input_filter = "Area>=3000"
    label_filtering_analysis_algo.output_analysis = analysis
    label_filtering_analysis_algo.execute()

    print("Area2d: ", str(label_filtering_analysis_algo.output_analysis.get(imagedev.native_measurements.Area2d).value(0)))
    print("output_label_image:", str(label_filtering_analysis_algo.output_label_image))

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

    LabelFilteringAnalysis labelFilteringAnalysisAlgo = new LabelFilteringAnalysis
    {
        inputLabelImage = polystyrene_sep_label,
        inputIntensityImage = polystyrene,
        inputFilter = "Area>=3000",
        outputAnalysis = analysis
    };
    labelFilteringAnalysisAlgo.Execute();

    Console.WriteLine( "Area2d: " + labelFilteringAnalysisAlgo.outputAnalysis.Get( NativeMeasurements.Area2d ).Value( 0 ) );
    Console.WriteLine( "outputLabelImage:" + labelFilteringAnalysisAlgo.outputLabelImage.ToString() );

## Function Examples

    auto polystyrene_sep_label = readVipImage( std::string( IMAGEDEVDATA_IMAGES_FOLDER ) + "polystyrene_sep_label.vip" );
    auto polystyrene = ioformat::readImage( std::string( IMAGEDEVDATA_IMAGES_FOLDER ) + "polystyrene.tif" );
    AnalysisMsr::Ptr analysis= AnalysisMsr::read( std::string( IMAGEDEVDATA_OBJECTS_FOLDER ) + "analysis.vip" );

    auto result = labelFilteringAnalysis( polystyrene_sep_label, polystyrene, "Area>=3000", analysis );

    std::cout << "Area2d: " << result.outputAnalysis->get( NativeMeasurements::area2d )->value( 0 ) ;
    std::cout << "outputLabelImage:" << result.outputLabelImage->toString();

    polystyrene_sep_label = imagedev.read_vip_image(imagedev_data.get_image_path("polystyrene_sep_label.vip"))
    polystyrene = ioformat.read_image(imagedev_data.get_image_path("polystyrene.tif"))
    analysis = imagedev.AnalysisMsr.read(imagedev_data.get_object_path("analysis.vip"))

    result_output_analysis, result_output_label_image = imagedev.label_filtering_analysis(polystyrene_sep_label, polystyrene, "Area>=3000", analysis)

    print("Area2d: ", str(result_output_analysis.get(imagedev.native_measurements.Area2d).value(0)))
    print("output_label_image:", str(result_output_label_image))

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

    Processing.LabelFilteringAnalysisOutput result = Processing.LabelFilteringAnalysis( polystyrene_sep_label, polystyrene, "Area>=3000", analysis );

    Console.WriteLine(  "Area2d: " + result.outputAnalysis.Get( NativeMeasurements.Area2d ).Value( 0 )  );
    Console.WriteLine( "outputLabelImage:" + result.outputLabelImage.ToString() );

© 2025 Thermo Fisher Scientific Inc. All rights reserved.