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

# VolumeProjection3d

Creates a single image containing selected pixels from a volume image.
Access to parameter description
VolumeProjection3d flattens a 3D volume into an image with only two representative dimensions.
Each output pixel is assigned by browsing a selected axis and retaining the value corresponding to a projection criterion; for example, the maximal intensity.
The output image can be considered either as a 2D image or a 3D image.
Choosing a 3D output space is almost relevant for raising ambiguity when the selected axis is not Z and the result has to be displayed in a 3D viewer.
For instance, considering that the projection is performed along X:

- If the output space is 2D, the output image has two axes: X and Y. X corresponds to the Y input axis and Y to the Z input axis.
- If the output space is 3D, the output image has three axes: X, Y, and Z. The X size is 1. All axis are consistent with the input volume.

An optional output can be enabled to get a map representing the slice index of each selected pixel.
This map is not available in mean projection mode since, in this case, the output value is computed from all browsed intensities.

(a) | (b) | (c)

Figure 1. Mean Intensity projection: (a) The input volume,
(b) the mean projection along the Z axis, (c) mean projection along the Y axis
This algorithm is similar to ImageStackProjection3d, the main differences are:

- Only the intensity minimum, maximum, and mean projection modes are available.
- The projection axis can be user-defined (X, Y, or Z) and is not necessarily the Z axis.
- The output space can be set to 3D to preserve the original coordinate system of the input volume.

See also

- ImageStackProjection3d

##
Function Syntax

This function returns a VolumeProjection3dOutput structure containing outputImage and outputMapImage.

    // Output structure of the volumeProjection3d function.
    struct VolumeProjection3dOutput
    {
        /// The output image representing the volume projection according to the selected criterion.
        std::shared_ptr< iolink::ImageView > outputImage;
        /// Output image indicating the selected plane in INTENSITY_MINIMUM or INTENSITY_MAXIMUM mode (not available in INTENSITY_MEAN mode).
        std::shared_ptr< iolink::ImageView > outputMapImage;
    };

    // Function prototype
    VolumeProjection3dOutput
    volumeProjection3d( std::shared_ptr< iolink::ImageView > inputImage,
                        VolumeProjection3d::AxisDirection axisDirection,
                        VolumeProjection3d::ProjectionMode projectionMode,
                        VolumeProjection3d::DimensionalSpace dimensionalSpace,
                        bool createMapImage,
                        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.
    volume_projection_3d(input_image: idt.ImageType,
                         axis_direction: VolumeProjection3d.AxisDirection = VolumeProjection3d.AxisDirection.Z_AXIS,
                         projection_mode: VolumeProjection3d.ProjectionMode = VolumeProjection3d.ProjectionMode.INTENSITY_MEAN,
                         dimensional_space: VolumeProjection3d.DimensionalSpace = VolumeProjection3d.DimensionalSpace.SPACE_2D,
                         create_map_image: bool = False,
                         output_image: idt.ImageType = None,
                         output_map_image: idt.ImageType = None) -> Tuple[idt.ImageType, idt.ImageType]

This function returns a VolumeProjection3dOutput structure containing outputImage and outputMapImage.

    /// Output structure of the VolumeProjection3d function.
    public struct VolumeProjection3dOutput
    {
        ///
        /// The output image representing the volume projection according to the selected criterion.
        ///
        public IOLink.ImageView outputImage;
        ///
        /// Output image indicating the selected plane in INTENSITY_MINIMUM or INTENSITY_MAXIMUM mode (not available in INTENSITY_MEAN mode).
        ///
        public IOLink.ImageView outputMapImage;
    };

    // Function prototype.
    public static VolumeProjection3dOutput
    VolumeProjection3d( IOLink.ImageView inputImage,
                        VolumeProjection3d.AxisDirection axisDirection = ImageDev.VolumeProjection3d.AxisDirection.Z_AXIS,
                        VolumeProjection3d.ProjectionMode projectionMode = ImageDev.VolumeProjection3d.ProjectionMode.INTENSITY_MEAN,
                        VolumeProjection3d.DimensionalSpace dimensionalSpace = ImageDev.VolumeProjection3d.DimensionalSpace.SPACE_2D,
                        bool createMapImage = false,
                        IOLink.ImageView outputImage = null,
                        IOLink.ImageView outputMapImage = null );

##
Class Syntax

    // Command constructor.
    VolumeProjection3d();

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

    /// Gets the axisDirection parameter.
    /// The axis along which slices are projected.
    VolumeProjection3d::AxisDirection axisDirection() const;
    /// Sets the axisDirection parameter.
    /// The axis along which slices are projected.
    void setAxisDirection( const VolumeProjection3d::AxisDirection& axisDirection );

    /// Gets the projectionMode parameter.
    /// The projection criterion (the rule used to transform a stack of pixels into a single pixel).
    VolumeProjection3d::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 VolumeProjection3d::ProjectionMode& projectionMode );

    /// Gets the dimensionalSpace parameter.
    /// Define the dimensional space of the output image.
    VolumeProjection3d::DimensionalSpace dimensionalSpace() const;
    /// Sets the dimensionalSpace parameter.
    /// Define the dimensional space of the output image.
    void setDimensionalSpace( const VolumeProjection3d::DimensionalSpace& dimensionalSpace );

    /// Gets the createMapImage parameter.
    /// This parameter indicates whether the algorithm creates an output map image.
    bool createMapImage() const;
    /// Sets the createMapImage parameter.
    /// This parameter indicates whether the algorithm creates an output map image.
    void setCreateMapImage( const bool& createMapImage );

    /// 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.
    /// Output image indicating the selected plane in INTENSITY_MINIMUM or INTENSITY_MAXIMUM mode (not available in INTENSITY_MEAN mode).
    std::shared_ptr< iolink::ImageView > outputMapImage() const;
    /// Sets the outputMapImage parameter.
    /// Output image indicating the selected plane in INTENSITY_MINIMUM or INTENSITY_MAXIMUM mode (not available in INTENSITY_MEAN mode).
    void setOutputMapImage( std::shared_ptr< iolink::ImageView > outputMapImage );

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

    # Property of the inputImage parameter.
    VolumeProjection3d.input_image
    # Property of the axisDirection parameter.
    VolumeProjection3d.axis_direction
    # Property of the projectionMode parameter.
    VolumeProjection3d.projection_mode
    # Property of the dimensionalSpace parameter.
    VolumeProjection3d.dimensional_space
    # Property of the createMapImage parameter.
    VolumeProjection3d.create_map_image
    # Property of the outputImage parameter.
    VolumeProjection3d.output_image
    # Property of the outputMapImage parameter.
    VolumeProjection3d.output_map_image

    // Method to launch the command.
    execute()

    // Command constructor.
    VolumeProjection3d()

    // Property of the inputImage parameter.
    VolumeProjection3d.inputImage
    // Property of the axisDirection parameter.
    VolumeProjection3d.axisDirection
    // Property of the projectionMode parameter.
    VolumeProjection3d.projectionMode
    // Property of the dimensionalSpace parameter.
    VolumeProjection3d.dimensionalSpace
    // Property of the createMapImage parameter.
    VolumeProjection3d.createMapImage
    // Property of the outputImage parameter.
    VolumeProjection3d.outputImage
    // Property of the outputMapImage parameter.
    VolumeProjection3d.outputMapImage

    // Method to launch the command.
    Execute()

## Parameters

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| inputImage | The 3D input image. Color and grayscale images are accepted. The type of the image can be integer or float. | Image | Grayscale or Multispectral | nullptr
| axisDirection | The axis along which slices are projected. If axis direction is set to X, YZ slices are projected.
X_AXIS | The YZ slices are projected.
Y_AXIS | The XZ slices are projected.
Z_AXIS | The XY slices are projected.
| Enumeration |  | Z_AXIS
| 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.
INTENSITY_MINIMA | The pixel of lowest intensity is selected in the stack. The map output is available with this mode.
INTENSITY_MEAN | The pixels of the stack are averaged along the selected axis. The map output is not available with this mode.
| Enumeration |  | INTENSITY_MEAN
| dimensionalSpace | Define the dimensional space of the output image. If axis direction is set to X and space to 2D, the output X (resp. Y) axis corresponds to the Y (resp. Z) axis. If axis direction is set to X and space to 3D, the output X axis is one pixel thick.
SPACE_2D | The output image is a 2D image.
SPACE_3D | The output image is a 3D image.
| Enumeration |  | SPACE_2D
| createMapImage | This parameter indicates whether the algorithm creates an output map image. This parameter is ignored in INTENSITY_MEAN projection mode. | Bool |  | false
| outputImage | The output image representing the volume projection according to the selected criterion. This image can be either 2D or 3D of one pixel thickness in the selected axis direction. Its type is identical to the input image. | Image |  | nullptr
| outputMapImage | Output image indicating the selected plane in INTENSITY_MINIMUM or INTENSITY_MAXIMUM mode (not available in INTENSITY_MEAN mode). The output map image can be either 2D or 3D of one pixel thickness in the selected axis direction. Its type is integer 32 bits. | Image |  | nullptr

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| input_image | The 3D input image. Color and grayscale images are accepted. The type of the image can be integer or float. | image | Grayscale or Multispectral | None
| axis_direction | The axis along which slices are projected. If axis direction is set to X, YZ slices are projected.
X_AXIS | The YZ slices are projected.
Y_AXIS | The XZ slices are projected.
Z_AXIS | The XY slices are projected.
| enumeration |  | Z_AXIS
| 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.
INTENSITY_MINIMA | The pixel of lowest intensity is selected in the stack. The map output is available with this mode.
INTENSITY_MEAN | The pixels of the stack are averaged along the selected axis. The map output is not available with this mode.
| enumeration |  | INTENSITY_MEAN
| dimensional_space | Define the dimensional space of the output image. If axis direction is set to X and space to 2D, the output X (resp. Y) axis corresponds to the Y (resp. Z) axis. If axis direction is set to X and space to 3D, the output X axis is one pixel thick.
SPACE_2D | The output image is a 2D image.
SPACE_3D | The output image is a 3D image.
| enumeration |  | SPACE_2D
| create_map_image | This parameter indicates whether the algorithm creates an output map image. This parameter is ignored in INTENSITY_MEAN projection mode. | bool |  | False
| output_image | The output image representing the volume projection according to the selected criterion. This image can be either 2D or 3D of one pixel thickness in the selected axis direction. Its type is identical to the input image. | image |  | None
| output_map_image | Output image indicating the selected plane in INTENSITY_MINIMUM or INTENSITY_MAXIMUM mode (not available in INTENSITY_MEAN mode). The output map image can be either 2D or 3D of one pixel thickness in the selected axis direction. Its type is integer 32 bits. | image |  | None

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| inputImage | The 3D input image. Color and grayscale images are accepted. The type of the image can be integer or float. | Image | Grayscale or Multispectral | null
| axisDirection | The axis along which slices are projected. If axis direction is set to X, YZ slices are projected.
X_AXIS | The YZ slices are projected.
Y_AXIS | The XZ slices are projected.
Z_AXIS | The XY slices are projected.
| Enumeration |  | Z_AXIS
| 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.
INTENSITY_MINIMA | The pixel of lowest intensity is selected in the stack. The map output is available with this mode.
INTENSITY_MEAN | The pixels of the stack are averaged along the selected axis. The map output is not available with this mode.
| Enumeration |  | INTENSITY_MEAN
| dimensionalSpace | Define the dimensional space of the output image. If axis direction is set to X and space to 2D, the output X (resp. Y) axis corresponds to the Y (resp. Z) axis. If axis direction is set to X and space to 3D, the output X axis is one pixel thick.
SPACE_2D | The output image is a 2D image.
SPACE_3D | The output image is a 3D image.
| Enumeration |  | SPACE_2D
| createMapImage | This parameter indicates whether the algorithm creates an output map image. This parameter is ignored in INTENSITY_MEAN projection mode. | Bool |  | false
| outputImage | The output image representing the volume projection according to the selected criterion. This image can be either 2D or 3D of one pixel thickness in the selected axis direction. Its type is identical to the input image. | Image |  | null
| outputMapImage | Output image indicating the selected plane in INTENSITY_MINIMUM or INTENSITY_MAXIMUM mode (not available in INTENSITY_MEAN mode). The output map image can be either 2D or 3D of one pixel thickness in the selected axis direction. Its type is integer 32 bits. | Image |  | null

## Object Examples

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

    VolumeProjection3d volumeProjection3dAlgo;
    volumeProjection3dAlgo.setInputImage( foam );
    volumeProjection3dAlgo.setAxisDirection( VolumeProjection3d::AxisDirection::Z_AXIS );
    volumeProjection3dAlgo.setProjectionMode( VolumeProjection3d::ProjectionMode::INTENSITY_MEAN );
    volumeProjection3dAlgo.setDimensionalSpace( VolumeProjection3d::DimensionalSpace::SPACE_2D );
    volumeProjection3dAlgo.setCreateMapImage( false );
    volumeProjection3dAlgo.execute();

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

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

    volume_projection_3d_algo = imagedev.VolumeProjection3d()
    volume_projection_3d_algo.input_image = foam
    volume_projection_3d_algo.axis_direction = imagedev.VolumeProjection3d.Z_AXIS
    volume_projection_3d_algo.projection_mode = imagedev.VolumeProjection3d.INTENSITY_MEAN
    volume_projection_3d_algo.dimensional_space = imagedev.VolumeProjection3d.SPACE_2D
    volume_projection_3d_algo.create_map_image = False
    volume_projection_3d_algo.execute()

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

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

    VolumeProjection3d volumeProjection3dAlgo = new VolumeProjection3d
    {
        inputImage = foam,
        axisDirection = VolumeProjection3d.AxisDirection.Z_AXIS,
        projectionMode = VolumeProjection3d.ProjectionMode.INTENSITY_MEAN,
        dimensionalSpace = VolumeProjection3d.DimensionalSpace.SPACE_2D,
        createMapImage = false
    };
    volumeProjection3dAlgo.Execute();

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

## Function Examples

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

    auto result = volumeProjection3d( foam, VolumeProjection3d::AxisDirection::Z_AXIS, VolumeProjection3d::ProjectionMode::INTENSITY_MEAN, VolumeProjection3d::DimensionalSpace::SPACE_2D, false );

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

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

    result_output_image, result_output_map_image = imagedev.volume_projection_3d(foam, imagedev.VolumeProjection3d.Z_AXIS, imagedev.VolumeProjection3d.INTENSITY_MEAN, imagedev.VolumeProjection3d.SPACE_2D, False)

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

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

    Processing.VolumeProjection3dOutput result = Processing.VolumeProjection3d( foam, VolumeProjection3d.AxisDirection.Z_AXIS, VolumeProjection3d.ProjectionMode.INTENSITY_MEAN, VolumeProjection3d.DimensionalSpace.SPACE_2D, false );

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

© 2025 Thermo Fisher Scientific Inc. All rights reserved.