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

# RandomSphereImage3d

Creates synthetic spheres in a binary image.
Access to parameter description
The RandomSphereImage3d algorithm creates a binary image containing a random distribution of spheres. The sphere radius range, distance, type of distribution, and number are parameters of the algorithm.
The following image is an example of the result with the default parameters:
Figure 1. Generation of 5 spheres
See also

- OrientedLinesImage3d
- RadialFunctionImage3d

##
Function Syntax

This function returns outputBinaryImage.

    // Function prototype
    std::shared_ptr< iolink::ImageView >
    randomSphereImage3d( const iolink::Vector3i32& imageSize,
                         int32_t sphereNumber,
                         RandomSphereImage3d::Distribution distribution,
                         const iolink::Vector2i32& radiusRange,
                         int32_t distance,
                         std::shared_ptr< iolink::ImageView > outputBinaryImage = nullptr );

This function returns outputBinaryImage.

    // Function prototype.
    random_sphere_image_3d(image_size: Iterable[int] = [100, 100, 100],
                           sphere_number: int = 5,
                           distribution: RandomSphereImage3d.Distribution = RandomSphereImage3d.Distribution.UNIFORM,
                           radius_range: Iterable[int] = [10, 20],
                           distance: int = 40,
                           output_binary_image: idt.ImageType = None) -> idt.ImageType

This function returns outputBinaryImage.

    // Function prototype.
    public static IOLink.ImageView
    RandomSphereImage3d( int[] imageSize = null,
                         Int32 sphereNumber = 5,
                         RandomSphereImage3d.Distribution distribution = ImageDev.RandomSphereImage3d.Distribution.UNIFORM,
                         int[] radiusRange = null,
                         Int32 distance = 40,
                         IOLink.ImageView outputBinaryImage = null );

##
Class Syntax

    // Command constructor.
    RandomSphereImage3d();

    /// Gets the imageSize parameter.
    /// The X, Y, and Z size in voxels of the output image.
    iolink::Vector3i32 imageSize() const;
    /// Sets the imageSize parameter.
    /// The X, Y, and Z size in voxels of the output image.
    void setImageSize( const iolink::Vector3i32& imageSize );

    /// Gets the sphereNumber parameter.
    /// The number of spheres to generate.
    int32_t sphereNumber() const;
    /// Sets the sphereNumber parameter.
    /// The number of spheres to generate.
    void setSphereNumber( const int32_t& sphereNumber );

    /// Gets the distribution parameter.
    /// The distribution type of the sphere radii.
    RandomSphereImage3d::Distribution distribution() const;
    /// Sets the distribution parameter.
    /// The distribution type of the sphere radii.
    void setDistribution( const RandomSphereImage3d::Distribution& distribution );

    /// Gets the radiusRange parameter.
    /// The minimum and maximum radius in voxels of the spheres (for Uniform distribution) or mean and standard deviation (for gaussian distribution).
    iolink::Vector2i32 radiusRange() const;
    /// Sets the radiusRange parameter.
    /// The minimum and maximum radius in voxels of the spheres (for Uniform distribution) or mean and standard deviation (for gaussian distribution).
    void setRadiusRange( const iolink::Vector2i32& radiusRange );

    /// Gets the distance parameter.
    /// The minimum distance between two sphere centers.
    int32_t distance() const;
    /// Sets the distance parameter.
    /// The minimum distance between two sphere centers.
    void setDistance( const int32_t& distance );

    /// Gets the outputBinaryImage parameter.
    /// The output 3D binary image.
    std::shared_ptr< iolink::ImageView > outputBinaryImage() const;
    /// Sets the outputBinaryImage parameter.
    /// The output 3D binary image.
    void setOutputBinaryImage( std::shared_ptr< iolink::ImageView > outputBinaryImage );

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

    # Property of the imageSize parameter.
    RandomSphereImage3d.image_size
    # Property of the sphereNumber parameter.
    RandomSphereImage3d.sphere_number
    # Property of the distribution parameter.
    RandomSphereImage3d.distribution
    # Property of the radiusRange parameter.
    RandomSphereImage3d.radius_range
    # Property of the distance parameter.
    RandomSphereImage3d.distance
    # Property of the outputBinaryImage parameter.
    RandomSphereImage3d.output_binary_image

    // Method to launch the command.
    execute()

    // Command constructor.
    RandomSphereImage3d()

    // Property of the imageSize parameter.
    RandomSphereImage3d.imageSize
    // Property of the sphereNumber parameter.
    RandomSphereImage3d.sphereNumber
    // Property of the distribution parameter.
    RandomSphereImage3d.distribution
    // Property of the radiusRange parameter.
    RandomSphereImage3d.radiusRange
    // Property of the distance parameter.
    RandomSphereImage3d.distance
    // Property of the outputBinaryImage parameter.
    RandomSphereImage3d.outputBinaryImage

    // Method to launch the command.
    Execute()

## Parameters

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| imageSize | The X, Y, and Z size in voxels of the output image. | Vector3i32 | >0 | {100, 100, 100}
| sphereNumber | The number of spheres to generate. | Int32 | >=1 | 5
| distribution | The distribution type of the sphere radii.
UNIFORM | The radius distribution is uniform (each radius of the range has an equiprobability to occur).
GAUSSIAN | The radius distribution is Gaussian (the mean radius of the range is much more represented than the minimum and maximum radii).
| Enumeration |  | UNIFORM
| radiusRange | The minimum and maximum radius in voxels of the spheres (for Uniform distribution) or mean and standard deviation (for gaussian distribution). | Vector2i32 | Any value | {10, 20}
| distance | The minimum distance between two sphere centers. | Int32 | >=0 | 40
| outputBinaryImage | The output 3D binary image. | Image |  | nullptr

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| image_size | The X, Y, and Z size in voxels of the output image. | vector3i32 | >0 | [100, 100, 100]
| sphere_number | The number of spheres to generate. | int32 | >=1 | 5
| distribution | The distribution type of the sphere radii.
UNIFORM | The radius distribution is uniform (each radius of the range has an equiprobability to occur).
GAUSSIAN | The radius distribution is Gaussian (the mean radius of the range is much more represented than the minimum and maximum radii).
| enumeration |  | UNIFORM
| radius_range | The minimum and maximum radius in voxels of the spheres (for Uniform distribution) or mean and standard deviation (for gaussian distribution). | vector2i32 | Any value | [10, 20]
| distance | The minimum distance between two sphere centers. | int32 | >=0 | 40
| output_binary_image | The output 3D binary image. | image |  | None

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| imageSize | The X, Y, and Z size in voxels of the output image. | Vector3i32 | >0 | {100, 100, 100}
| sphereNumber | The number of spheres to generate. | Int32 | >=1 | 5
| distribution | The distribution type of the sphere radii.
UNIFORM | The radius distribution is uniform (each radius of the range has an equiprobability to occur).
GAUSSIAN | The radius distribution is Gaussian (the mean radius of the range is much more represented than the minimum and maximum radii).
| Enumeration |  | UNIFORM
| radiusRange | The minimum and maximum radius in voxels of the spheres (for Uniform distribution) or mean and standard deviation (for gaussian distribution). | Vector2i32 | Any value | {10, 20}
| distance | The minimum distance between two sphere centers. | Int32 | >=0 | 40
| outputBinaryImage | The output 3D binary image. | Image |  | null

## Object Examples

    RandomSphereImage3d randomSphereImage3dAlgo;
    randomSphereImage3dAlgo.setImageSize( {100, 100, 100} );
    randomSphereImage3dAlgo.setSphereNumber( 5 );
    randomSphereImage3dAlgo.setDistribution( RandomSphereImage3d::Distribution::UNIFORM );
    randomSphereImage3dAlgo.setRadiusRange( {10, 20} );
    randomSphereImage3dAlgo.setDistance( 40 );
    randomSphereImage3dAlgo.execute();

    std::cout << "outputBinaryImage:" << randomSphereImage3dAlgo.outputBinaryImage()->toString();

    random_sphere_image_3d_algo = imagedev.RandomSphereImage3d()
    random_sphere_image_3d_algo.image_size = [100, 100, 100]
    random_sphere_image_3d_algo.sphere_number = 5
    random_sphere_image_3d_algo.distribution = imagedev.RandomSphereImage3d.UNIFORM
    random_sphere_image_3d_algo.radius_range = [10, 20]
    random_sphere_image_3d_algo.distance = 40
    random_sphere_image_3d_algo.execute()

    print("output_binary_image:", str(random_sphere_image_3d_algo.output_binary_image))

    RandomSphereImage3d randomSphereImage3dAlgo = new RandomSphereImage3d
    {
        imageSize = new int[]{100, 100, 100},
        sphereNumber = 5,
        distribution = RandomSphereImage3d.Distribution.UNIFORM,
        radiusRange = new int[]{10, 20},
        distance = 40
    };
    randomSphereImage3dAlgo.Execute();

    Console.WriteLine( "outputBinaryImage:" + randomSphereImage3dAlgo.outputBinaryImage.ToString() );

## Function Examples

    auto result = randomSphereImage3d( {100, 100, 100}, 5, RandomSphereImage3d::Distribution::UNIFORM, {10, 20}, 40 );

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

    result = imagedev.random_sphere_image_3d([100, 100, 100], 5, imagedev.RandomSphereImage3d.UNIFORM, [10, 20], 40)

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

    IOLink.ImageView result = Processing.RandomSphereImage3d( new int[]{100, 100, 100}, 5, RandomSphereImage3d.Distribution.UNIFORM, new int[]{10, 20}, 40 );

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

© 2025 Thermo Fisher Scientific Inc. All rights reserved.