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

# ImageStackProjection3d

Transforms a volume that represents a stack of 2D images into a single 2D image.
Access to parameter description
ImageStackProjection3d creates a single image containing pixels transformed from a stack of input images according to a user-defined projection criterion.

### The gradient maxima projection, also known as z-stack algorithm

When acquiring a scene that is not orthogonal to the optical path (that is, not parallel to the sensor), it is generally not possible to directly get an image focused over the whole field. Nevertheless, it is possible to acquire several images of this scene, each one focused on a different region of the scene.
The ImageStackProjection3d algorithm can then be used to examine all images of this stack and retain the pixel presenting the best contrast to build the resulting image.

### Other pixel selection criteria

This algorithm also offers some basic selection criteria, such as intensity minimum or maximum. For instance, selecting the maximum intensity on a CT data set can be a way to simulate a classical projection radiography.

### Projection maps

When the projection mode is selective, like the intensity minima, maxima, or the gradient maxima, the algorithm also generates an output label image that shows the contribution source selected in the result image (the image index in the input stack).

(a) | (b)
(c) | (d)

Figure 1. Z-stack projection on a two images stack: (a) first image of the stack, (b) second image of the stack,
(c) gradient maxima projection, (d) pixel selection map (blue: from first image, red: from second image)

### Statistical criteria

Other criteria do not select a particular pixel from the stack, but computes each output value by performing an operation on the corresponding pixel stack. The available operators are mainly first order statistics like mean, standard deviation, energy, or entropy.

### Color management

When using a selective criterion on color images, the input is converted to the HSL color space and the criterion is evaluated on the lightness.
Other criteria cannot be applied on color image stacks, an exception is returned in this case.
See also

- VolumeProjection3d
- MorphologicalGradient2d
- GradientOperator2d

##
Function Syntax

This function returns a ImageStackProjection3dOutput structure containing outputImage and outputMapImage.

    // Output structure of the imageStackProjection3d function.
    struct ImageStackProjection3dOutput
    {
        /// The output image representing the volume projection according to the selected criterion.
        std::shared_ptr< iolink::ImageView > outputImage;
        /// The output map label image. Each pixel intensity represents the Z index used in the output image.
        std::shared_ptr< iolink::ImageView > outputMapImage;
    };

    // Function prototype
    ImageStackProjection3dOutput
    imageStackProjection3d( std::shared_ptr< iolink::ImageView > inputImage,
                            ImageStackProjection3d::ProjectionMode projectionMode,
                            ImageStackProjection3d::AutoScale autoScale,
                            int32_t smoothingSize,
                            ImageStackProjection3d::GradientOperator gradientOperator,
                            std::shared_ptr< iolink::ImageView > outputImage = nullptr,
                            std::shared_ptr< iolink::ImageView > outputMapImage = nullptr );

This function returns a tuple containing output_image and output_map_image.

    // Function prototype.
    image_stack_projection_3d(input_image: idt.ImageType,
                              projection_mode: ImageStackProjection3d.ProjectionMode = ImageStackProjection3d.ProjectionMode.GRADIENT_MAXIMA,
                              auto_scale: ImageStackProjection3d.AutoScale = ImageStackProjection3d.AutoScale.YES,
                              smoothing_size: int = 5,
                              gradient_operator: ImageStackProjection3d.GradientOperator = ImageStackProjection3d.GradientOperator.MORPHOLOGICAL_GRADIENT,
                              output_image: idt.ImageType = None,
                              output_map_image: idt.ImageType = None) -> Tuple[idt.ImageType, idt.ImageType]

This function returns a ImageStackProjection3dOutput structure containing outputImage and outputMapImage.

    /// Output structure of the ImageStackProjection3d function.
    public struct ImageStackProjection3dOutput
    {
        ///
        /// The output image representing the volume projection according to the selected criterion.
        ///
        public IOLink.ImageView outputImage;
        ///
        /// The output map label image. Each pixel intensity represents the Z index used in the output image.
        ///
        public IOLink.ImageView outputMapImage;
    };

    // Function prototype.
    public static ImageStackProjection3dOutput
    ImageStackProjection3d( IOLink.ImageView inputImage,
                            ImageStackProjection3d.ProjectionMode projectionMode = ImageDev.ImageStackProjection3d.ProjectionMode.GRADIENT_MAXIMA,
                            ImageStackProjection3d.AutoScale autoScale = ImageDev.ImageStackProjection3d.AutoScale.YES,
                            Int32 smoothingSize = 5,
                            ImageStackProjection3d.GradientOperator gradientOperator = ImageDev.ImageStackProjection3d.GradientOperator.MORPHOLOGICAL_GRADIENT,
                            IOLink.ImageView outputImage = null,
                            IOLink.ImageView outputMapImage = null );

##
Class Syntax

    // Command constructor.
    ImageStackProjection3d();

    /// Gets the inputImage parameter.
    /// A 3D volume representing a stack of 2D images.
    std::shared_ptr< iolink::ImageView > inputImage() const;
    /// Sets the inputImage parameter.
    /// A 3D volume representing a stack of 2D images.
    void setInputImage( std::shared_ptr< iolink::ImageView > inputImage );

    /// Gets the projectionMode parameter.
    /// The projection criterion (the rule used to transform a stack of pixels into a single pixel).
    ImageStackProjection3d::ProjectionMode projectionMode() const;
    /// Sets the projectionMode parameter.
    /// The projection criterion (the rule used to transform a stack of pixels into a single pixel).
    void setProjectionMode( const ImageStackProjection3d::ProjectionMode& projectionMode );

    /// Gets the autoScale parameter.
    /// The automatic intensity scaling mode to average the pixels of the stack. It is used only with the PROJECTION mode and is ignored with any other criterion.
    ImageStackProjection3d::AutoScale autoScale() const;
    /// Sets the autoScale parameter.
    /// The automatic intensity scaling mode to average the pixels of the stack. It is used only with the PROJECTION mode and is ignored with any other criterion.
    void setAutoScale( const ImageStackProjection3d::AutoScale& autoScale );

    /// Gets the smoothingSize parameter.
    /// The kernel size for smoothing the gradient before selecting the output value. It is used only with the GRADIENT_MAXIMA mode and is ignored with any other criterion.
    int32_t smoothingSize() const;
    /// Sets the smoothingSize parameter.
    /// The kernel size for smoothing the gradient before selecting the output value. It is used only with the GRADIENT_MAXIMA mode and is ignored with any other criterion.
    void setSmoothingSize( const int32_t& smoothingSize );

    /// Gets the gradientOperator parameter.
    /// The gradient operator to apply.It is used only with the GRADIENT_MAXIMA mode and is ignored with any other criterion.
    ImageStackProjection3d::GradientOperator gradientOperator() const;
    /// Sets the gradientOperator parameter.
    /// The gradient operator to apply.It is used only with the GRADIENT_MAXIMA mode and is ignored with any other criterion.
    void setGradientOperator( const ImageStackProjection3d::GradientOperator& gradientOperator );

    /// Gets the outputImage parameter.
    /// The output image representing the volume projection according to the selected criterion.
    std::shared_ptr< iolink::ImageView > outputImage() const;
    /// Sets the outputImage parameter.
    /// The output image representing the volume projection according to the selected criterion.
    void setOutputImage( std::shared_ptr< iolink::ImageView > outputImage );

    /// Gets the outputMapImage parameter.
    /// The output map label image. Each pixel intensity represents the Z index used in the output image.
    std::shared_ptr< iolink::ImageView > outputMapImage() const;
    /// Sets the outputMapImage parameter.
    /// The output map label image. Each pixel intensity represents the Z index used in the output image.
    void setOutputMapImage( std::shared_ptr< iolink::ImageView > outputMapImage );

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

    # Property of the inputImage parameter.
    ImageStackProjection3d.input_image
    # Property of the projectionMode parameter.
    ImageStackProjection3d.projection_mode
    # Property of the autoScale parameter.
    ImageStackProjection3d.auto_scale
    # Property of the smoothingSize parameter.
    ImageStackProjection3d.smoothing_size
    # Property of the gradientOperator parameter.
    ImageStackProjection3d.gradient_operator
    # Property of the outputImage parameter.
    ImageStackProjection3d.output_image
    # Property of the outputMapImage parameter.
    ImageStackProjection3d.output_map_image

    // Method to launch the command.
    execute()

    // Command constructor.
    ImageStackProjection3d()

    // Property of the inputImage parameter.
    ImageStackProjection3d.inputImage
    // Property of the projectionMode parameter.
    ImageStackProjection3d.projectionMode
    // Property of the autoScale parameter.
    ImageStackProjection3d.autoScale
    // Property of the smoothingSize parameter.
    ImageStackProjection3d.smoothingSize
    // Property of the gradientOperator parameter.
    ImageStackProjection3d.gradientOperator
    // Property of the outputImage parameter.
    ImageStackProjection3d.outputImage
    // Property of the outputMapImage parameter.
    ImageStackProjection3d.outputMapImage

    // Method to launch the command.
    Execute()

## Parameters

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| inputImage | A 3D volume representing a stack of 2D images. | Image | Binary, Label, Grayscale or Multispectral | nullptr
| projectionMode | The projection criterion (the rule used to transform a stack of pixels into a single pixel).
INTENSITY_MAXIMA | The pixel of highest intensity is selected in the stack. The map output is available with this mode.
GRADIENT_MAXIMA | The pixel of highest gradient is selected in the stack. The gradient is computed as defined by the gradientOperator parameter. The map output is available with this mode.
PROJECTION | The pixels of the stack are added up. If the autoScale mode is enabled, the result is normalized by the number of images of the stack, which is exactly the same as using the MEAN criterion. The map output is not available with this mode.
INTENSITY_MINIMA | The pixel of lowest intensity is selected in the stack. The map output is available with this mode.
MEDIAN | The pixel of median intensity is selected in the stack. The map output is not available with this mode.
MEAN | The pixels of the stack are averaged. The map output is not available with this mode.
VARIANCE | The output value is the standard deviation of the stack values. The map output is not available with this mode.
ENTROPY | The output value is the entropy of the stack values, based on this formula: $$ Entropy= -\sum_{i \in seq} {P(x_i)log(P(x_i))} $$ where $P(x_i)$ is the probability to have a pixel with value $x_i$ (it's the number of those pixels divided by the total number of pixels). The map output is not available with this mode.
ENERGY | The output value is the energy of the stack values, based on this formula: $$ Energy= \sum_{i \in seq} {P(x_i)^2} $$ The map output is not available with this mode.
| Enumeration |  | GRADIENT_MAXIMA
| autoScale | The automatic intensity scaling mode to average the pixels of the stack. It is used only with the PROJECTION mode and is ignored with any other criterion.
NO | The sum of intensities is not divided by the number of images in the stack.
YES | The sum of intensities is divided by the number of images in the stack.
| Enumeration |  | YES
| smoothingSize | The kernel size for smoothing the gradient before selecting the output value. It is used only with the GRADIENT_MAXIMA mode and is ignored with any other criterion. | Int32 | >=0 | 5
| gradientOperator | The gradient operator to apply.It is used only with the GRADIENT_MAXIMA mode and is ignored with any other criterion.
GAUSSIAN_GRADIENT | A gaussian gradient is performed (convolution with derivatives of gaussian function along the stack direction).
MORPHOLOGICAL_GRADIENT | A morphological gradient is performed (see MorphologicalGradient for definition). This is the recommended operator to use.
RECURSIVE_GRADIENT | A recursive gradient is performed (Canny-Deriche on stack direction).
| Enumeration |  | MORPHOLOGICAL_GRADIENT
| outputImage | The output image representing the volume projection according to the selected criterion. | Image |  | nullptr
| outputMapImage | The output map label image. Each pixel intensity represents the Z index used in the output image. | Image |  | nullptr

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| input_image | A 3D volume representing a stack of 2D images. | image | Binary, Label, Grayscale or Multispectral | None
| projection_mode | The projection criterion (the rule used to transform a stack of pixels into a single pixel).
INTENSITY_MAXIMA | The pixel of highest intensity is selected in the stack. The map output is available with this mode.
GRADIENT_MAXIMA | The pixel of highest gradient is selected in the stack. The gradient is computed as defined by the gradientOperator parameter. The map output is available with this mode.
PROJECTION | The pixels of the stack are added up. If the autoScale mode is enabled, the result is normalized by the number of images of the stack, which is exactly the same as using the MEAN criterion. The map output is not available with this mode.
INTENSITY_MINIMA | The pixel of lowest intensity is selected in the stack. The map output is available with this mode.
MEDIAN | The pixel of median intensity is selected in the stack. The map output is not available with this mode.
MEAN | The pixels of the stack are averaged. The map output is not available with this mode.
VARIANCE | The output value is the standard deviation of the stack values. The map output is not available with this mode.
ENTROPY | The output value is the entropy of the stack values, based on this formula: $$ Entropy= -\sum_{i \in seq} {P(x_i)log(P(x_i))} $$ where $P(x_i)$ is the probability to have a pixel with value $x_i$ (it's the number of those pixels divided by the total number of pixels). The map output is not available with this mode.
ENERGY | The output value is the energy of the stack values, based on this formula: $$ Energy= \sum_{i \in seq} {P(x_i)^2} $$ The map output is not available with this mode.
| enumeration |  | GRADIENT_MAXIMA
| auto_scale | The automatic intensity scaling mode to average the pixels of the stack. It is used only with the PROJECTION mode and is ignored with any other criterion.
NO | The sum of intensities is not divided by the number of images in the stack.
YES | The sum of intensities is divided by the number of images in the stack.
| enumeration |  | YES
| smoothing_size | The kernel size for smoothing the gradient before selecting the output value. It is used only with the GRADIENT_MAXIMA mode and is ignored with any other criterion. | int32 | >=0 | 5
| gradient_operator | The gradient operator to apply.It is used only with the GRADIENT_MAXIMA mode and is ignored with any other criterion.
GAUSSIAN_GRADIENT | A gaussian gradient is performed (convolution with derivatives of gaussian function along the stack direction).
MORPHOLOGICAL_GRADIENT | A morphological gradient is performed (see MorphologicalGradient for definition). This is the recommended operator to use.
RECURSIVE_GRADIENT | A recursive gradient is performed (Canny-Deriche on stack direction).
| enumeration |  | MORPHOLOGICAL_GRADIENT
| output_image | The output image representing the volume projection according to the selected criterion. | image |  | None
| output_map_image | The output map label image. Each pixel intensity represents the Z index used in the output image. | image |  | None

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| inputImage | A 3D volume representing a stack of 2D images. | Image | Binary, Label, Grayscale or Multispectral | null
| projectionMode | The projection criterion (the rule used to transform a stack of pixels into a single pixel).
INTENSITY_MAXIMA | The pixel of highest intensity is selected in the stack. The map output is available with this mode.
GRADIENT_MAXIMA | The pixel of highest gradient is selected in the stack. The gradient is computed as defined by the gradientOperator parameter. The map output is available with this mode.
PROJECTION | The pixels of the stack are added up. If the autoScale mode is enabled, the result is normalized by the number of images of the stack, which is exactly the same as using the MEAN criterion. The map output is not available with this mode.
INTENSITY_MINIMA | The pixel of lowest intensity is selected in the stack. The map output is available with this mode.
MEDIAN | The pixel of median intensity is selected in the stack. The map output is not available with this mode.
MEAN | The pixels of the stack are averaged. The map output is not available with this mode.
VARIANCE | The output value is the standard deviation of the stack values. The map output is not available with this mode.
ENTROPY | The output value is the entropy of the stack values, based on this formula: $$ Entropy= -\sum_{i \in seq} {P(x_i)log(P(x_i))} $$ where $P(x_i)$ is the probability to have a pixel with value $x_i$ (it's the number of those pixels divided by the total number of pixels). The map output is not available with this mode.
ENERGY | The output value is the energy of the stack values, based on this formula: $$ Energy= \sum_{i \in seq} {P(x_i)^2} $$ The map output is not available with this mode.
| Enumeration |  | GRADIENT_MAXIMA
| autoScale | The automatic intensity scaling mode to average the pixels of the stack. It is used only with the PROJECTION mode and is ignored with any other criterion.
NO | The sum of intensities is not divided by the number of images in the stack.
YES | The sum of intensities is divided by the number of images in the stack.
| Enumeration |  | YES
| smoothingSize | The kernel size for smoothing the gradient before selecting the output value. It is used only with the GRADIENT_MAXIMA mode and is ignored with any other criterion. | Int32 | >=0 | 5
| gradientOperator | The gradient operator to apply.It is used only with the GRADIENT_MAXIMA mode and is ignored with any other criterion.
GAUSSIAN_GRADIENT | A gaussian gradient is performed (convolution with derivatives of gaussian function along the stack direction).
MORPHOLOGICAL_GRADIENT | A morphological gradient is performed (see MorphologicalGradient for definition). This is the recommended operator to use.
RECURSIVE_GRADIENT | A recursive gradient is performed (Canny-Deriche on stack direction).
| Enumeration |  | MORPHOLOGICAL_GRADIENT
| outputImage | The output image representing the volume projection according to the selected criterion. | Image |  | null
| outputMapImage | The output map label image. Each pixel intensity represents the Z index used in the output image. | Image |  | null

## Object Examples

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

    ImageStackProjection3d imageStackProjection3dAlgo;
    imageStackProjection3dAlgo.setInputImage( polystyrene_seq );
    imageStackProjection3dAlgo.setProjectionMode( ImageStackProjection3d::ProjectionMode::GRADIENT_MAXIMA );
    imageStackProjection3dAlgo.setAutoScale( ImageStackProjection3d::AutoScale::YES );
    imageStackProjection3dAlgo.setSmoothingSize( 5 );
    imageStackProjection3dAlgo.setGradientOperator( ImageStackProjection3d::GradientOperator::GAUSSIAN_GRADIENT );
    imageStackProjection3dAlgo.execute();

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

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

    image_stack_projection_3d_algo = imagedev.ImageStackProjection3d()
    image_stack_projection_3d_algo.input_image = polystyrene_seq
    image_stack_projection_3d_algo.projection_mode = imagedev.ImageStackProjection3d.GRADIENT_MAXIMA
    image_stack_projection_3d_algo.auto_scale = imagedev.ImageStackProjection3d.YES
    image_stack_projection_3d_algo.smoothing_size = 5
    image_stack_projection_3d_algo.gradient_operator = imagedev.ImageStackProjection3d.GAUSSIAN_GRADIENT
    image_stack_projection_3d_algo.execute()

    print("output_image:", str(image_stack_projection_3d_algo.output_image))
    print("output_map_image:", str(image_stack_projection_3d_algo.output_map_image))

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

    ImageStackProjection3d imageStackProjection3dAlgo = new ImageStackProjection3d
    {
        inputImage = polystyrene_seq,
        projectionMode = ImageStackProjection3d.ProjectionMode.GRADIENT_MAXIMA,
        autoScale = ImageStackProjection3d.AutoScale.YES,
        smoothingSize = 5,
        gradientOperator = ImageStackProjection3d.GradientOperator.GAUSSIAN_GRADIENT
    };
    imageStackProjection3dAlgo.Execute();

    Console.WriteLine( "outputImage:" + imageStackProjection3dAlgo.outputImage.ToString() );
    Console.WriteLine( "outputMapImage:" + imageStackProjection3dAlgo.outputMapImage.ToString() );

## Function Examples

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

    auto result = imageStackProjection3d( polystyrene_seq, ImageStackProjection3d::ProjectionMode::GRADIENT_MAXIMA, ImageStackProjection3d::AutoScale::YES, 5, ImageStackProjection3d::GradientOperator::GAUSSIAN_GRADIENT );

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

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

    result_output_image, result_output_map_image = imagedev.image_stack_projection_3d(polystyrene_seq, imagedev.ImageStackProjection3d.GRADIENT_MAXIMA, imagedev.ImageStackProjection3d.YES, 5, imagedev.ImageStackProjection3d.GAUSSIAN_GRADIENT)

    print("output_image:", str(result_output_image))
    print("output_map_image:", str(result_output_map_image))

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

    Processing.ImageStackProjection3dOutput result = Processing.ImageStackProjection3d( polystyrene_seq, ImageStackProjection3d.ProjectionMode.GRADIENT_MAXIMA, ImageStackProjection3d.AutoScale.YES, 5, ImageStackProjection3d.GradientOperator.GAUSSIAN_GRADIENT );

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

© 2025 Thermo Fisher Scientific Inc. All rights reserved.