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

# SurfaceUnfolding3d

Extracts a flattened 3D image from an input 3D image mapped to a surface mesh.
Access to parameter description
The input 3D surface is unfolded in order to appear as a flat layer of the output 3D image. Actually, the unfolded surface is a thick surface defined by the thickness parameter.
Thus, the result of this algorithm is also a 3D image corresponding to the region of the input volume defined by the input surface and a given thickness. The dimensions in voxels of the output image are defined by the size parameter.
This size is independent of the number of voxels in the input image and of the number of vertices in the input surface.
By default the thickness of the output volume is taken in the direction of the normal vectors to each cell of the input mesh.
If this behavior is not desired, these directions can be redefined with the directions parameter.
Creating a human dental panoramic image is a typical use case of this engine, where:

- The inputImage corresponds to a CT scan image of the head.
- The inputSurface is a surface which is centered on the teeth, jaw and facial bones.
- The thickness is usually 1 or 2 cm in order to fit the thickness of each tooth.

See also

- PolylineResampler3d
- PolylineExtrusion3d

##
Function Syntax

This function returns outputImage.

    // Function prototype
    std::shared_ptr< iolink::ImageView >
    surfaceUnfolding3d( std::shared_ptr< iolink::ImageView > inputImage,
                        std::shared_ptr<iolink::ArrayXd> inputSurface,
                        std::shared_ptr<iolink::ArrayXd> directions,
                        double thickness,
                        const iolink::Vector3u32& size,
                        SurfaceUnfolding3d::InterpolationType interpolationType,
                        double paddingValue,
                        std::shared_ptr< iolink::ImageView > outputImage = nullptr );

This function returns outputImage.

    // Function prototype.
    surface_unfolding_3d(input_image: idt.ImageType,
                         input_surface: Union[idt.NDArrayFloat, None],
                         directions: Union[idt.NDArrayFloat, None],
                         thickness: float = 1,
                         size: Iterable[int] = [1024, 1024, 256],
                         interpolation_type: SurfaceUnfolding3d.InterpolationType = SurfaceUnfolding3d.InterpolationType.LINEAR,
                         padding_value: float = 0,
                         output_image: idt.ImageType = None) -> idt.ImageType

This function returns outputImage.

    // Function prototype.
    public static IOLink.ImageView
    SurfaceUnfolding3d( IOLink.ImageView inputImage,
                        IOLink.ArrayXd inputSurface,
                        IOLink.ArrayXd directions,
                        double thickness = 1,
                        uint[] size = null,
                        SurfaceUnfolding3d.InterpolationType interpolationType = ImageDev.SurfaceUnfolding3d.InterpolationType.LINEAR,
                        double paddingValue = 0,
                        IOLink.ImageView outputImage = null );

##
Class Syntax

    // Command constructor.
    SurfaceUnfolding3d();

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

    /// Gets the inputSurface parameter.
    /// The input surface as a starting point for the process.
    std::shared_ptr<iolink::ArrayXd> inputSurface() const;
    /// Sets the inputSurface parameter.
    /// The input surface as a starting point for the process.
    void setInputSurface( std::shared_ptr<iolink::ArrayXd> inputSurface );

    /// Gets the directions parameter.
    /// Optional direction vectors used to unfold the surface.
    std::shared_ptr<iolink::ArrayXd> directions() const;
    /// Sets the directions parameter.
    /// Optional direction vectors used to unfold the surface.
    void setDirections( std::shared_ptr<iolink::ArrayXd> directions );

    /// Gets the thickness parameter.
    /// The output image thickness expressed in calibration unit.
    double thickness() const;
    /// Sets the thickness parameter.
    /// The output image thickness expressed in calibration unit.
    void setThickness( const double& thickness );

    /// Gets the size parameter.
    /// The dimensions of the output image in number of voxels, respectively in the X, Y, and Z directions.
    iolink::Vector3u32 size() const;
    /// Sets the size parameter.
    /// The dimensions of the output image in number of voxels, respectively in the X, Y, and Z directions.
    void setSize( const iolink::Vector3u32& size );

    /// Gets the interpolationType parameter.
    /// The interpolation mode.
    SurfaceUnfolding3d::InterpolationType interpolationType() const;
    /// Sets the interpolationType parameter.
    /// The interpolation mode.
    void setInterpolationType( const SurfaceUnfolding3d::InterpolationType& interpolationType );

    /// Gets the paddingValue parameter.
    /// The default output value.
    double paddingValue() const;
    /// Sets the paddingValue parameter.
    /// The default output value.
    void setPaddingValue( const double& paddingValue );

    /// Gets the outputImage parameter.
    /// The output image.
    std::shared_ptr< iolink::ImageView > outputImage() const;
    /// Sets the outputImage parameter.
    /// The output image.
    void setOutputImage( std::shared_ptr< iolink::ImageView > outputImage );

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

    # Property of the inputImage parameter.
    SurfaceUnfolding3d.input_image
    # Property of the inputSurface parameter.
    SurfaceUnfolding3d.input_surface
    # Property of the directions parameter.
    SurfaceUnfolding3d.directions
    # Property of the thickness parameter.
    SurfaceUnfolding3d.thickness
    # Property of the size parameter.
    SurfaceUnfolding3d.size
    # Property of the interpolationType parameter.
    SurfaceUnfolding3d.interpolation_type
    # Property of the paddingValue parameter.
    SurfaceUnfolding3d.padding_value
    # Property of the outputImage parameter.
    SurfaceUnfolding3d.output_image

    // Method to launch the command.
    execute()

    // Command constructor.
    SurfaceUnfolding3d()

    // Property of the inputImage parameter.
    SurfaceUnfolding3d.inputImage
    // Property of the inputSurface parameter.
    SurfaceUnfolding3d.inputSurface
    // Property of the directions parameter.
    SurfaceUnfolding3d.directions
    // Property of the thickness parameter.
    SurfaceUnfolding3d.thickness
    // Property of the size parameter.
    SurfaceUnfolding3d.size
    // Property of the interpolationType parameter.
    SurfaceUnfolding3d.interpolationType
    // Property of the paddingValue parameter.
    SurfaceUnfolding3d.paddingValue
    // Property of the outputImage parameter.
    SurfaceUnfolding3d.outputImage

    // Method to launch the command.
    Execute()

## Parameters

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| inputImage | The input 3D image. | Image | Grayscale | nullptr
| inputSurface | The input surface as a starting point for the process. The dimensions of the ArrayXd must be [3, n, m] with : 3, the number of coordinates of a 3d point respectively corresponding to X, Y, and Z expressed in the calibration unit. n, the number of columns of the mesh corresponding to the X axis of the output image. m, the number of rows of the mesh corresponding to the Y axis of the output image. | ArrayXd |  | nullptr
| directions | Optional direction vectors used to unfold the surface. By default this field does not contain any data, which means that the algorithm will compute direction vectors as the normal vector to each vertex of the input surface inSurface. If this field is set, it must contain as many vectors as the number of vertices in inputSurface. If provided, the dimensions must be equivalent to the dimension of inputSurface. | ArrayXd |  | nullptr
| thickness | The output image thickness expressed in calibration unit. | Float64 | >=0 | 1
| size | The dimensions of the output image in number of voxels, respectively in the X, Y, and Z directions. This parameter defines the resolution of the output image. It is recommended to set this size in order to obtain a voxel size close to that of the input image. | Vector3u32 | != 0 | {1024, 1024, 256}
| interpolationType | The interpolation mode. Method used to calculate the intensity of each pixel in the result image.
NEAREST_NEIGHBOR | The value of the intensity is equal to the nearest intensity.
LINEAR | The value of the intensity is linearly interpolated in all directions.
| Enumeration |  | LINEAR
| paddingValue | The default output value. This value is used to fill output regions having no correspondence in the input image. | Float64 | Any value | 0
| outputImage | The output image. Its dimensions are defined by the size parameter. Its type, calibration, and interpretation are the same as the input image. | Image |  | nullptr

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| input_image | The input 3D image. | image | Grayscale | None
| input_surface | The input surface as a starting point for the process. The dimensions of the ArrayXd must be [3, n, m] with : 3, the number of coordinates of a 3d point respectively corresponding to X, Y, and Z expressed in the calibration unit. n, the number of columns of the mesh corresponding to the X axis of the output image. m, the number of rows of the mesh corresponding to the Y axis of the output image. | arrayXd |  | nullptr
| directions | Optional direction vectors used to unfold the surface. By default this field does not contain any data, which means that the algorithm will compute direction vectors as the normal vector to each vertex of the input surface inSurface. If this field is set, it must contain as many vectors as the number of vertices in inputSurface. If provided, the dimensions must be equivalent to the dimension of inputSurface. | arrayXd |  | nullptr
| thickness | The output image thickness expressed in calibration unit. | float64 | >=0 | 1
| size | The dimensions of the output image in number of voxels, respectively in the X, Y, and Z directions. This parameter defines the resolution of the output image. It is recommended to set this size in order to obtain a voxel size close to that of the input image. | vector3u32 | != 0 | [1024, 1024, 256]
| interpolation_type | The interpolation mode. Method used to calculate the intensity of each pixel in the result image.
NEAREST_NEIGHBOR | The value of the intensity is equal to the nearest intensity.
LINEAR | The value of the intensity is linearly interpolated in all directions.
| enumeration |  | LINEAR
| padding_value | The default output value. This value is used to fill output regions having no correspondence in the input image. | float64 | Any value | 0
| output_image | The output image. Its dimensions are defined by the size parameter. Its type, calibration, and interpretation are the same as the input image. | image |  | None

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| inputImage | The input 3D image. | Image | Grayscale | null
| inputSurface | The input surface as a starting point for the process. The dimensions of the ArrayXd must be [3, n, m] with : 3, the number of coordinates of a 3d point respectively corresponding to X, Y, and Z expressed in the calibration unit. n, the number of columns of the mesh corresponding to the X axis of the output image. m, the number of rows of the mesh corresponding to the Y axis of the output image. | ArrayXd |  | nullptr
| directions | Optional direction vectors used to unfold the surface. By default this field does not contain any data, which means that the algorithm will compute direction vectors as the normal vector to each vertex of the input surface inSurface. If this field is set, it must contain as many vectors as the number of vertices in inputSurface. If provided, the dimensions must be equivalent to the dimension of inputSurface. | ArrayXd |  | nullptr
| thickness | The output image thickness expressed in calibration unit. | Float64 | >=0 | 1
| size | The dimensions of the output image in number of voxels, respectively in the X, Y, and Z directions. This parameter defines the resolution of the output image. It is recommended to set this size in order to obtain a voxel size close to that of the input image. | Vector3u32 | != 0 | {1024, 1024, 256}
| interpolationType | The interpolation mode. Method used to calculate the intensity of each pixel in the result image.
NEAREST_NEIGHBOR | The value of the intensity is equal to the nearest intensity.
LINEAR | The value of the intensity is linearly interpolated in all directions.
| Enumeration |  | LINEAR
| paddingValue | The default output value. This value is used to fill output regions having no correspondence in the input image. | Float64 | Any value | 0
| outputImage | The output image. Its dimensions are defined by the size parameter. Its type, calibration, and interpretation are the same as the input image. | Image |  | null

## Object Examples

    auto polystyrene = ioformat::readImage( std::string( IMAGEDEVDATA_IMAGES_FOLDER ) + "polystyrene.tif" );
    std::shared_ptr< iolink::ArrayXd> surfaceMesh( new iolink::ArrayXd( { 0 } ) );
    readArrayXd( std::string( IMAGEDEVDATA_OBJECTS_FOLDER ) + "surfaceMesh.arrayxd", surfaceMesh);
    std::shared_ptr< iolink::ArrayXd> surfaceNormals( new iolink::ArrayXd( { 0 } ) );
    readArrayXd( std::string( IMAGEDEVDATA_OBJECTS_FOLDER ) + "surfaceNormals.arrayxd", surfaceNormals);

    SurfaceUnfolding3d surfaceUnfolding3dAlgo;
    surfaceUnfolding3dAlgo.setInputImage( polystyrene );
    surfaceUnfolding3dAlgo.setInputSurface( surfaceMesh );
    surfaceUnfolding3dAlgo.setDirections( surfaceNormals );
    surfaceUnfolding3dAlgo.setThickness( 1 );
    surfaceUnfolding3dAlgo.setSize( {50, 40, 20} );
    surfaceUnfolding3dAlgo.setInterpolationType( SurfaceUnfolding3d::InterpolationType::LINEAR );
    surfaceUnfolding3dAlgo.setPaddingValue( 0 );
    surfaceUnfolding3dAlgo.execute();

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

    polystyrene = ioformat.read_image(imagedev_data.get_image_path("polystyrene.tif"))
    surface_mesh = np.zeros(0, dtype=np.double)
    surface_mesh = imagedev.read_array_xd(imagedev_data.get_object_path("surfaceMesh.arrayxd"), surface_mesh)
    surface_normals = np.zeros(0, dtype=np.double)
    surface_normals = imagedev.read_array_xd(imagedev_data.get_object_path("surfaceNormals.arrayxd"), surface_normals)

    surface_unfolding_3d_algo = imagedev.SurfaceUnfolding3d()
    surface_unfolding_3d_algo.input_image = polystyrene
    surface_unfolding_3d_algo.input_surface = surface_mesh
    surface_unfolding_3d_algo.directions = surface_normals
    surface_unfolding_3d_algo.thickness = 1
    surface_unfolding_3d_algo.size = [50, 40, 20]
    surface_unfolding_3d_algo.interpolation_type = imagedev.SurfaceUnfolding3d.LINEAR
    surface_unfolding_3d_algo.padding_value = 0
    surface_unfolding_3d_algo.execute()

    print("output_image:", str(surface_unfolding_3d_algo.output_image))

    ImageView polystyrene = ViewIO.ReadImage( @"Data/images/polystyrene.tif" );
    IOLink.ArrayXd surfaceMesh = new IOLink.ArrayXd(new IOLink.VectorXu64( 0 ) ) ;
    surfaceMesh = Data.ReadArrayXd( @"Data/objects/surfaceMesh.arrayxd", surfaceMesh );
    IOLink.ArrayXd surfaceNormals = new IOLink.ArrayXd(new IOLink.VectorXu64( 0 ) ) ;
    surfaceNormals = Data.ReadArrayXd( @"Data/objects/surfaceNormals.arrayxd", surfaceNormals );

    SurfaceUnfolding3d surfaceUnfolding3dAlgo = new SurfaceUnfolding3d
    {
        inputImage = polystyrene,
        inputSurface = surfaceMesh,
        directions = surfaceNormals,
        thickness = 1,
        size = new uint[]{50, 40, 20},
        interpolationType = SurfaceUnfolding3d.InterpolationType.LINEAR,
        paddingValue = 0
    };
    surfaceUnfolding3dAlgo.Execute();

    Console.WriteLine( "outputImage:" + surfaceUnfolding3dAlgo.outputImage.ToString() );

## Function Examples

    auto polystyrene = ioformat::readImage( std::string( IMAGEDEVDATA_IMAGES_FOLDER ) + "polystyrene.tif" );
    std::shared_ptr< iolink::ArrayXd> surfaceMesh( new iolink::ArrayXd( { 0 } ) );
    readArrayXd( std::string( IMAGEDEVDATA_OBJECTS_FOLDER ) + "surfaceMesh.arrayxd", surfaceMesh);
    std::shared_ptr< iolink::ArrayXd> surfaceNormals( new iolink::ArrayXd( { 0 } ) );
    readArrayXd( std::string( IMAGEDEVDATA_OBJECTS_FOLDER ) + "surfaceNormals.arrayxd", surfaceNormals);

    auto result = surfaceUnfolding3d( polystyrene, surfaceMesh, surfaceNormals, 1, {50, 40, 20}, SurfaceUnfolding3d::InterpolationType::LINEAR, 0 );

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

    polystyrene = ioformat.read_image(imagedev_data.get_image_path("polystyrene.tif"))
    surface_mesh = np.zeros(0, dtype=np.double)
    surface_mesh = imagedev.read_array_xd(imagedev_data.get_object_path("surfaceMesh.arrayxd"), surface_mesh)
    surface_normals = np.zeros(0, dtype=np.double)
    surface_normals = imagedev.read_array_xd(imagedev_data.get_object_path("surfaceNormals.arrayxd"), surface_normals)

    result = imagedev.surface_unfolding_3d(polystyrene, surface_mesh, surface_normals, 1, [50, 40, 20], imagedev.SurfaceUnfolding3d.LINEAR, 0)

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

    ImageView polystyrene = ViewIO.ReadImage( @"Data/images/polystyrene.tif" );
    IOLink.ArrayXd surfaceMesh = new IOLink.ArrayXd(new IOLink.VectorXu64( 0 ) ) ;
    surfaceMesh = Data.ReadArrayXd( @"Data/objects/surfaceMesh.arrayxd", surfaceMesh );
    IOLink.ArrayXd surfaceNormals = new IOLink.ArrayXd(new IOLink.VectorXu64( 0 ) ) ;
    surfaceNormals = Data.ReadArrayXd( @"Data/objects/surfaceNormals.arrayxd", surfaceNormals );

    IOLink.ImageView result = Processing.SurfaceUnfolding3d( polystyrene, surfaceMesh, surfaceNormals, 1, new uint[]{50, 40, 20}, SurfaceUnfolding3d.InterpolationType.LINEAR, 0 );

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

© 2025 Thermo Fisher Scientific Inc. All rights reserved.