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

# DentalMeshExtraction3d

Computes a quadrilateral mesh fitting on the dental wall defined in a three-dimensional binary image.
Access to parameter description
For an introduction to dental panoramics: section Dental applications
This algorithm extracts a mesh and fits it on a binary dental wall computed with the DentalWallSegmentation3d algorithm.
The output surface is a quadrilateral mesh for which

- the columns are parallel to the Z axis of the input volume.
- the rows as polylines following the median axis of the jaw at each XY slice of the input volume intersecting the mesh.

Each cell can be considered as a square, even if for approximation reasons, column and row lengths may slightly differ.
Cells are extracted to represent approximately 10x10 voxel squares in the input volume.
The main steps of this algorithm are:

- Extraction of an arch curve which is a list of vertices modeling the dental arch in a 2D plane.
- Extrusion of this curve to build an initial mesh.

Fitting of this mesh on a weight volume representing the center of the teeth for building an arch mesh.
If an input arch curve is provided, the first step is skipped. This arch curve is systematically resampled to generate a polyline on which two consecutive vertices are approximately 10 voxels apart.

Figure 2. Dental mesh extraction: (left) the initial CBCT and (right) the resulting mesh
See also

- DentalWallSegmentation3d
- SurfaceFitting3d
- SurfaceUnfolding3d
- DentalUnfolding3d

##
Function Syntax

This function returns a DentalMeshExtraction3dOutput structure containing outputArchCurve, outputInsideArchCurve, outputOutsideArchCurve, outputDirections and outputMesh.

    // Output structure of the dentalMeshExtraction3d function.
    struct DentalMeshExtraction3dOutput
    {
        /// The polyline representing the dental arch in the XY plan. This polyline must be represented as a two-dimensional array storing the coordinates of each vertex. If not set, it is automatically computed.
        std::shared_ptr<iolink::ArrayXd> inputArchCurve;
        /// The polyline representing the dental arch which is used to compute the arch mesh. This polyline is represented as a two-dimensional array storing the coordinates of each vertex. . If the input arch curve is not set, it is automatically computed from the input CBCT image. Otherwise, it corresponds to the resampled input arch curve. Curve vertex coordinates are expressed in mm.
        std::shared_ptr<iolink::ArrayXd> outputArchCurve;
        /// The polyline representing the inside border of the search area for fitting the arch mesh. This curve is computed by shifting the arch curve inside the jaws to the search distance. This polyline is represented as a two-dimensional array storing the coordinates of each vertex. Curve vertex coordinates are expressed in mm.
        std::shared_ptr<iolink::ArrayXd> outputInsideArchCurve;
        /// The polyline representing the outside border of the search area for fitting the arch mesh. This curve is computed by shifting the arch curve outside the jaws to the search distance. This polyline is represented as a two-dimensional array storing the coordinates of each vertex. Curve vertices are expressed in mm.
        std::shared_ptr<iolink::ArrayXd> outputOutsideArchCurve;
        /// The arch mesh vertex normals. These directions are calculated on the initial mesh prior to fitting. It is recommended to use these normals to unfold the tooth dental and generate a panoramic.  The fitted mesh vertex normals tend to cross each other and therefore generate artifacts.
        std::shared_ptr<iolink::ArrayXd> outputDirections;
        /// The quadrilateral mesh forming the surface fitted to the dental wall. This surface can be used to unfold the dental wall and generate a panoramic. This mesh is represented as a three-dimensional array storing the coordinates of each vertex.
        std::shared_ptr<iolink::ArrayXd> outputMesh;
    };

    // Function prototype
    DentalMeshExtraction3dOutput
    dentalMeshExtraction3d( std::shared_ptr< iolink::ImageView > inputBinaryImage,
                            std::shared_ptr< iolink::ImageView > inputImage,
                            std::shared_ptr<iolink::ArrayXd> inputArchCurve,
                            double extrusionDown,
                            double extrusionUp,
                            double searchLength,
                            std::shared_ptr<iolink::ArrayXd> outputArchCurve = nullptr,
                            std::shared_ptr<iolink::ArrayXd> outputInsideArchCurve = nullptr,
                            std::shared_ptr<iolink::ArrayXd> outputOutsideArchCurve = nullptr,
                            std::shared_ptr<iolink::ArrayXd> outputDirections = nullptr,
                            std::shared_ptr<iolink::ArrayXd> outputMesh = nullptr );

This function returns a tuple containing output_arch_curve, output_inside_arch_curve, output_outside_arch_curve, output_directions and output_mesh.

    // Function prototype.
    dental_mesh_extraction_3d(input_binary_image: idt.ImageType,
                              input_image: idt.ImageType,
                              input_arch_curve: Union[idt.NDArrayFloat, None],
                              extrusion_down: float = 30,
                              extrusion_up: float = 30,
                              search_length: float = 15,
                              output_arch_curve: Union[idt.NDArrayFloat, None] = None,
                              output_inside_arch_curve: Union[idt.NDArrayFloat, None] = None,
                              output_outside_arch_curve: Union[idt.NDArrayFloat, None] = None,
                              output_directions: Union[idt.NDArrayFloat, None] = None,
                              output_mesh: Union[idt.NDArrayFloat, None] = None) -> Tuple[Union[idt.NDArrayFloat, None], Union[idt.NDArrayFloat, None], Union[idt.NDArrayFloat, None], Union[idt.NDArrayFloat, None], Union[idt.NDArrayFloat, None]]

This function returns a DentalMeshExtraction3dOutput structure containing outputArchCurve, outputInsideArchCurve, outputOutsideArchCurve, outputDirections and outputMesh.

    /// Output structure of the DentalMeshExtraction3d function.
    public struct DentalMeshExtraction3dOutput
    {
        ///
        /// The polyline representing the dental arch in the XY plan. This polyline must be represented as a two-dimensional array storing the coordinates of each vertex. If not set, it is automatically computed.
        ///
        public IOLink.ArrayXd inputArchCurve;
        ///
        /// The polyline representing the dental arch which is used to compute the arch mesh. This polyline is represented as a two-dimensional array storing the coordinates of each vertex. . If the input arch curve is not set, it is automatically computed from the input CBCT image. Otherwise, it corresponds to the resampled input arch curve. Curve vertex coordinates are expressed in mm.
        ///
        public IOLink.ArrayXd outputArchCurve;
        ///
        /// The polyline representing the inside border of the search area for fitting the arch mesh. This curve is computed by shifting the arch curve inside the jaws to the search distance. This polyline is represented as a two-dimensional array storing the coordinates of each vertex. Curve vertex coordinates are expressed in mm.
        ///
        public IOLink.ArrayXd outputInsideArchCurve;
        ///
        /// The polyline representing the outside border of the search area for fitting the arch mesh. This curve is computed by shifting the arch curve outside the jaws to the search distance. This polyline is represented as a two-dimensional array storing the coordinates of each vertex. Curve vertices are expressed in mm.
        ///
        public IOLink.ArrayXd outputOutsideArchCurve;
        ///
        /// The arch mesh vertex normals. These directions are calculated on the initial mesh prior to fitting. It is recommended to use these normals to unfold the tooth dental and generate a panoramic.  The fitted mesh vertex normals tend to cross each other and therefore generate artifacts.
        ///
        public IOLink.ArrayXd outputDirections;
        ///
        /// The quadrilateral mesh forming the surface fitted to the dental wall. This surface can be used to unfold the dental wall and generate a panoramic. This mesh is represented as a three-dimensional array storing the coordinates of each vertex.
        ///
        public IOLink.ArrayXd outputMesh;
    };

    // Function prototype.
    public static DentalMeshExtraction3dOutput
    DentalMeshExtraction3d( IOLink.ImageView inputBinaryImage,
                            IOLink.ImageView inputImage,
                            IOLink.ArrayXd inputArchCurve,
                            double extrusionDown = 30,
                            double extrusionUp = 30,
                            double searchLength = 15,
                            IOLink.ArrayXd outputArchCurve = null,
                            IOLink.ArrayXd outputInsideArchCurve = null,
                            IOLink.ArrayXd outputOutsideArchCurve = null,
                            IOLink.ArrayXd outputDirections = null,
                            IOLink.ArrayXd outputMesh = null );

##
Class Syntax

    // Command constructor.
    DentalMeshExtraction3d();

    /// Gets the inputBinaryImage parameter.
    /// The input binary image representing the extracted dental wall. Its dimensions are equal to the input image dimensions divided by the sampling factor used at the segmentation step.
    std::shared_ptr< iolink::ImageView > inputBinaryImage() const;
    /// Sets the inputBinaryImage parameter.
    /// The input binary image representing the extracted dental wall. Its dimensions are equal to the input image dimensions divided by the sampling factor used at the segmentation step.
    void setInputBinaryImage( std::shared_ptr< iolink::ImageView > inputBinaryImage );

    /// Gets the inputImage parameter.
    /// The input 3D CBCT image of the head (LP orientation). It is used to compute automatically the arch curve. It is ignored if an input arch curve is user-defined
    std::shared_ptr< iolink::ImageView > inputImage() const;
    /// Sets the inputImage parameter.
    /// The input 3D CBCT image of the head (LP orientation). It is used to compute automatically the arch curve. It is ignored if an input arch curve is user-defined
    void setInputImage( std::shared_ptr< iolink::ImageView > inputImage );

    /// Gets the inputArchCurve parameter.
    /// The polyline representing the dental arch in the XY plan. This polyline must be represented as a two-dimensional array storing the coordinates of each vertex. If not set, it is automatically computed.
    std::shared_ptr<iolink::ArrayXd> inputArchCurve() const;
    /// Sets the inputArchCurve parameter.
    /// The polyline representing the dental arch in the XY plan. This polyline must be represented as a two-dimensional array storing the coordinates of each vertex. If not set, it is automatically computed.
    void setInputArchCurve( std::shared_ptr<iolink::ArrayXd> inputArchCurve );

    /// Gets the extrusionDown parameter.
    /// The extrusion length of dental arch curve in the direction of head towards feet. This length is expressed in mm.
    double extrusionDown() const;
    /// Sets the extrusionDown parameter.
    /// The extrusion length of dental arch curve in the direction of head towards feet. This length is expressed in mm.
    void setExtrusionDown( const double& extrusionDown );

    /// Gets the extrusionUp parameter.
    /// The extrusion length of dental arch curve in the direction of feet towards head. This length is expressed in mm.
    double extrusionUp() const;
    /// Sets the extrusionUp parameter.
    /// The extrusion length of dental arch curve in the direction of feet towards head. This length is expressed in mm.
    void setExtrusionUp( const double& extrusionUp );

    /// Gets the searchLength parameter.
    /// The search distance where the initial mesh is fitted to the arch curve. This distance is expressed in mm.
    double searchLength() const;
    /// Sets the searchLength parameter.
    /// The search distance where the initial mesh is fitted to the arch curve. This distance is expressed in mm.
    void setSearchLength( const double& searchLength );

    /// Gets the outputArchCurve parameter.
    /// The polyline representing the dental arch which is used to compute the arch mesh. This polyline is represented as a two-dimensional array storing the coordinates of each vertex. . If the input arch curve is not set, it is automatically computed from the input CBCT image. Otherwise, it corresponds to the resampled input arch curve. Curve vertex coordinates are expressed in mm.
    std::shared_ptr<iolink::ArrayXd> outputArchCurve() const;
    /// Sets the outputArchCurve parameter.
    /// The polyline representing the dental arch which is used to compute the arch mesh. This polyline is represented as a two-dimensional array storing the coordinates of each vertex. . If the input arch curve is not set, it is automatically computed from the input CBCT image. Otherwise, it corresponds to the resampled input arch curve. Curve vertex coordinates are expressed in mm.
    void setOutputArchCurve( std::shared_ptr<iolink::ArrayXd> outputArchCurve );

    /// Gets the outputInsideArchCurve parameter.
    /// The polyline representing the inside border of the search area for fitting the arch mesh. This curve is computed by shifting the arch curve inside the jaws to the search distance. This polyline is represented as a two-dimensional array storing the coordinates of each vertex. Curve vertex coordinates are expressed in mm.
    std::shared_ptr<iolink::ArrayXd> outputInsideArchCurve() const;
    /// Sets the outputInsideArchCurve parameter.
    /// The polyline representing the inside border of the search area for fitting the arch mesh. This curve is computed by shifting the arch curve inside the jaws to the search distance. This polyline is represented as a two-dimensional array storing the coordinates of each vertex. Curve vertex coordinates are expressed in mm.
    void setOutputInsideArchCurve( std::shared_ptr<iolink::ArrayXd> outputInsideArchCurve );

    /// Gets the outputOutsideArchCurve parameter.
    /// The polyline representing the outside border of the search area for fitting the arch mesh. This curve is computed by shifting the arch curve outside the jaws to the search distance. This polyline is represented as a two-dimensional array storing the coordinates of each vertex. Curve vertices are expressed in mm.
    std::shared_ptr<iolink::ArrayXd> outputOutsideArchCurve() const;
    /// Sets the outputOutsideArchCurve parameter.
    /// The polyline representing the outside border of the search area for fitting the arch mesh. This curve is computed by shifting the arch curve outside the jaws to the search distance. This polyline is represented as a two-dimensional array storing the coordinates of each vertex. Curve vertices are expressed in mm.
    void setOutputOutsideArchCurve( std::shared_ptr<iolink::ArrayXd> outputOutsideArchCurve );

    /// Gets the outputDirections parameter.
    /// The arch mesh vertex normals. These directions are calculated on the initial mesh prior to fitting. It is recommended to use these normals to unfold the tooth dental and generate a panoramic.  The fitted mesh vertex normals tend to cross each other and therefore generate artifacts.
    std::shared_ptr<iolink::ArrayXd> outputDirections() const;
    /// Sets the outputDirections parameter.
    /// The arch mesh vertex normals. These directions are calculated on the initial mesh prior to fitting. It is recommended to use these normals to unfold the tooth dental and generate a panoramic.  The fitted mesh vertex normals tend to cross each other and therefore generate artifacts.
    void setOutputDirections( std::shared_ptr<iolink::ArrayXd> outputDirections );

    /// Gets the outputMesh parameter.
    /// The quadrilateral mesh forming the surface fitted to the dental wall. This surface can be used to unfold the dental wall and generate a panoramic. This mesh is represented as a three-dimensional array storing the coordinates of each vertex.
    std::shared_ptr<iolink::ArrayXd> outputMesh() const;
    /// Sets the outputMesh parameter.
    /// The quadrilateral mesh forming the surface fitted to the dental wall. This surface can be used to unfold the dental wall and generate a panoramic. This mesh is represented as a three-dimensional array storing the coordinates of each vertex.
    void setOutputMesh( std::shared_ptr<iolink::ArrayXd> outputMesh );

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

    # Property of the inputBinaryImage parameter.
    DentalMeshExtraction3d.input_binary_image
    # Property of the inputImage parameter.
    DentalMeshExtraction3d.input_image
    # Property of the inputArchCurve parameter.
    DentalMeshExtraction3d.input_arch_curve
    # Property of the extrusionDown parameter.
    DentalMeshExtraction3d.extrusion_down
    # Property of the extrusionUp parameter.
    DentalMeshExtraction3d.extrusion_up
    # Property of the searchLength parameter.
    DentalMeshExtraction3d.search_length
    # Property of the outputArchCurve parameter.
    DentalMeshExtraction3d.output_arch_curve
    # Property of the outputInsideArchCurve parameter.
    DentalMeshExtraction3d.output_inside_arch_curve
    # Property of the outputOutsideArchCurve parameter.
    DentalMeshExtraction3d.output_outside_arch_curve
    # Property of the outputDirections parameter.
    DentalMeshExtraction3d.output_directions
    # Property of the outputMesh parameter.
    DentalMeshExtraction3d.output_mesh

    // Method to launch the command.
    execute()

    // Command constructor.
    DentalMeshExtraction3d()

    // Property of the inputBinaryImage parameter.
    DentalMeshExtraction3d.inputBinaryImage
    // Property of the inputImage parameter.
    DentalMeshExtraction3d.inputImage
    // Property of the inputArchCurve parameter.
    DentalMeshExtraction3d.inputArchCurve
    // Property of the extrusionDown parameter.
    DentalMeshExtraction3d.extrusionDown
    // Property of the extrusionUp parameter.
    DentalMeshExtraction3d.extrusionUp
    // Property of the searchLength parameter.
    DentalMeshExtraction3d.searchLength
    // Property of the outputArchCurve parameter.
    DentalMeshExtraction3d.outputArchCurve
    // Property of the outputInsideArchCurve parameter.
    DentalMeshExtraction3d.outputInsideArchCurve
    // Property of the outputOutsideArchCurve parameter.
    DentalMeshExtraction3d.outputOutsideArchCurve
    // Property of the outputDirections parameter.
    DentalMeshExtraction3d.outputDirections
    // Property of the outputMesh parameter.
    DentalMeshExtraction3d.outputMesh

    // Method to launch the command.
    Execute()

## Parameters

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| inputBinaryImage | The input binary image representing the extracted dental wall. Its dimensions are equal to the input image dimensions divided by the sampling factor used at the segmentation step. | Image | Binary or Grayscale | nullptr
| inputImage | The input 3D CBCT image of the head (LP orientation). It is used to compute automatically the arch curve. It is ignored if an input arch curve is user-defined | Image | Grayscale | nullptr
| inputArchCurve | The polyline representing the dental arch in the XY plan. This polyline must be represented as a two-dimensional array storing the coordinates of each vertex. If not set, it is automatically computed. The indexation of this ArrayXd must be {coordinate, index}, where coordinate is the axis index (0 for X, 1 for Y and 2 for Z) and index is a label identifying the vertex. | ArrayXd |  | nullptr
| extrusionDown | The extrusion length of dental arch curve in the direction of head towards feet. This length is expressed in mm. | Float64 | >=0 | 30
| extrusionUp | The extrusion length of dental arch curve in the direction of feet towards head. This length is expressed in mm. | Float64 | >=0 | 30
| searchLength | The search distance where the initial mesh is fitted to the arch curve. This distance is expressed in mm. | Float64 | >=0 | 15
| outputArchCurve | The polyline representing the dental arch which is used to compute the arch mesh. This polyline is represented as a two-dimensional array storing the coordinates of each vertex. . If the input arch curve is not set, it is automatically computed from the input CBCT image. Otherwise, it corresponds to the resampled input arch curve. Curve vertex coordinates are expressed in mm. The indexation of the generated ArrayXd is {coordinate, index}, where coordinate is the axis index (0 for X, 1 for Y and 2 for Z) and index is a label identifying the vertex. | ArrayXd |  | nullptr
| outputInsideArchCurve | The polyline representing the inside border of the search area for fitting the arch mesh. This curve is computed by shifting the arch curve inside the jaws to the search distance. This polyline is represented as a two-dimensional array storing the coordinates of each vertex. Curve vertex coordinates are expressed in mm. The indexation of the generated ArrayXd is {coordinate, index}, where coordinate is the axis index (0 for X, 1 for Y and 2 for Z) and index is a label identifying the vertex. | ArrayXd |  | nullptr
| outputOutsideArchCurve | The polyline representing the outside border of the search area for fitting the arch mesh. This curve is computed by shifting the arch curve outside the jaws to the search distance. This polyline is represented as a two-dimensional array storing the coordinates of each vertex. Curve vertices are expressed in mm. The indexation of the generated ArrayXd is {coordinate, index}, where coordinate is the axis index (0 for X, 1 for Y and 2 for Z) and index is a label identifying the vertex. | ArrayXd |  | nullptr
| outputDirections | The arch mesh vertex normals. These directions are calculated on the initial mesh prior to fitting. It is recommended to use these normals to unfold the tooth dental and generate a panoramic. The fitted mesh vertex normals tend to cross each other and therefore generate artifacts. The dimensions of this ArrayXd are [3, N, M] with : 3, the number of coordinates of a 3D vector, respectively corresponding to X, Y, and Z. N, the number of vertices per column of the mesh (N-1 cells per column). M, the number of vertices per row of the mesh (M-1 cells per row). | ArrayXd |  | nullptr
| outputMesh | The quadrilateral mesh forming the surface fitted to the dental wall. This surface can be used to unfold the dental wall and generate a panoramic. This mesh is represented as a three-dimensional array storing the coordinates of each vertex. 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 vertices per column of the mesh (N-1 cells per column). M, the number of vertices per row of the mesh (M-1 cells per row). | ArrayXd |  | nullptr

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| input_binary_image | The input binary image representing the extracted dental wall. Its dimensions are equal to the input image dimensions divided by the sampling factor used at the segmentation step. | image | Binary or Grayscale | None
| input_image | The input 3D CBCT image of the head (LP orientation). It is used to compute automatically the arch curve. It is ignored if an input arch curve is user-defined | image | Grayscale | None
| input_arch_curve | The polyline representing the dental arch in the XY plan. This polyline must be represented as a two-dimensional array storing the coordinates of each vertex. If not set, it is automatically computed. The indexation of this ArrayXd must be {coordinate, index}, where coordinate is the axis index (0 for X, 1 for Y and 2 for Z) and index is a label identifying the vertex. | arrayXd |  | nullptr
| extrusion_down | The extrusion length of dental arch curve in the direction of head towards feet. This length is expressed in mm. | float64 | >=0 | 30
| extrusion_up | The extrusion length of dental arch curve in the direction of feet towards head. This length is expressed in mm. | float64 | >=0 | 30
| search_length | The search distance where the initial mesh is fitted to the arch curve. This distance is expressed in mm. | float64 | >=0 | 15
| output_arch_curve | The polyline representing the dental arch which is used to compute the arch mesh. This polyline is represented as a two-dimensional array storing the coordinates of each vertex. . If the input arch curve is not set, it is automatically computed from the input CBCT image. Otherwise, it corresponds to the resampled input arch curve. Curve vertex coordinates are expressed in mm. The indexation of the generated ArrayXd is {coordinate, index}, where coordinate is the axis index (0 for X, 1 for Y and 2 for Z) and index is a label identifying the vertex. | arrayXd |  | nullptr
| output_inside_arch_curve | The polyline representing the inside border of the search area for fitting the arch mesh. This curve is computed by shifting the arch curve inside the jaws to the search distance. This polyline is represented as a two-dimensional array storing the coordinates of each vertex. Curve vertex coordinates are expressed in mm. The indexation of the generated ArrayXd is {coordinate, index}, where coordinate is the axis index (0 for X, 1 for Y and 2 for Z) and index is a label identifying the vertex. | arrayXd |  | nullptr
| output_outside_arch_curve | The polyline representing the outside border of the search area for fitting the arch mesh. This curve is computed by shifting the arch curve outside the jaws to the search distance. This polyline is represented as a two-dimensional array storing the coordinates of each vertex. Curve vertices are expressed in mm. The indexation of the generated ArrayXd is {coordinate, index}, where coordinate is the axis index (0 for X, 1 for Y and 2 for Z) and index is a label identifying the vertex. | arrayXd |  | nullptr
| output_directions | The arch mesh vertex normals. These directions are calculated on the initial mesh prior to fitting. It is recommended to use these normals to unfold the tooth dental and generate a panoramic. The fitted mesh vertex normals tend to cross each other and therefore generate artifacts. The dimensions of this ArrayXd are [3, N, M] with : 3, the number of coordinates of a 3D vector, respectively corresponding to X, Y, and Z. N, the number of vertices per column of the mesh (N-1 cells per column). M, the number of vertices per row of the mesh (M-1 cells per row). | arrayXd |  | nullptr
| output_mesh | The quadrilateral mesh forming the surface fitted to the dental wall. This surface can be used to unfold the dental wall and generate a panoramic. This mesh is represented as a three-dimensional array storing the coordinates of each vertex. 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 vertices per column of the mesh (N-1 cells per column). M, the number of vertices per row of the mesh (M-1 cells per row). | arrayXd |  | nullptr

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| inputBinaryImage | The input binary image representing the extracted dental wall. Its dimensions are equal to the input image dimensions divided by the sampling factor used at the segmentation step. | Image | Binary or Grayscale | null
| inputImage | The input 3D CBCT image of the head (LP orientation). It is used to compute automatically the arch curve. It is ignored if an input arch curve is user-defined | Image | Grayscale | null
| inputArchCurve | The polyline representing the dental arch in the XY plan. This polyline must be represented as a two-dimensional array storing the coordinates of each vertex. If not set, it is automatically computed. The indexation of this ArrayXd must be {coordinate, index}, where coordinate is the axis index (0 for X, 1 for Y and 2 for Z) and index is a label identifying the vertex. | ArrayXd |  | nullptr
| extrusionDown | The extrusion length of dental arch curve in the direction of head towards feet. This length is expressed in mm. | Float64 | >=0 | 30
| extrusionUp | The extrusion length of dental arch curve in the direction of feet towards head. This length is expressed in mm. | Float64 | >=0 | 30
| searchLength | The search distance where the initial mesh is fitted to the arch curve. This distance is expressed in mm. | Float64 | >=0 | 15
| outputArchCurve | The polyline representing the dental arch which is used to compute the arch mesh. This polyline is represented as a two-dimensional array storing the coordinates of each vertex. . If the input arch curve is not set, it is automatically computed from the input CBCT image. Otherwise, it corresponds to the resampled input arch curve. Curve vertex coordinates are expressed in mm. The indexation of the generated ArrayXd is {coordinate, index}, where coordinate is the axis index (0 for X, 1 for Y and 2 for Z) and index is a label identifying the vertex. | ArrayXd |  | nullptr
| outputInsideArchCurve | The polyline representing the inside border of the search area for fitting the arch mesh. This curve is computed by shifting the arch curve inside the jaws to the search distance. This polyline is represented as a two-dimensional array storing the coordinates of each vertex. Curve vertex coordinates are expressed in mm. The indexation of the generated ArrayXd is {coordinate, index}, where coordinate is the axis index (0 for X, 1 for Y and 2 for Z) and index is a label identifying the vertex. | ArrayXd |  | nullptr
| outputOutsideArchCurve | The polyline representing the outside border of the search area for fitting the arch mesh. This curve is computed by shifting the arch curve outside the jaws to the search distance. This polyline is represented as a two-dimensional array storing the coordinates of each vertex. Curve vertices are expressed in mm. The indexation of the generated ArrayXd is {coordinate, index}, where coordinate is the axis index (0 for X, 1 for Y and 2 for Z) and index is a label identifying the vertex. | ArrayXd |  | nullptr
| outputDirections | The arch mesh vertex normals. These directions are calculated on the initial mesh prior to fitting. It is recommended to use these normals to unfold the tooth dental and generate a panoramic. The fitted mesh vertex normals tend to cross each other and therefore generate artifacts. The dimensions of this ArrayXd are [3, N, M] with : 3, the number of coordinates of a 3D vector, respectively corresponding to X, Y, and Z. N, the number of vertices per column of the mesh (N-1 cells per column). M, the number of vertices per row of the mesh (M-1 cells per row). | ArrayXd |  | nullptr
| outputMesh | The quadrilateral mesh forming the surface fitted to the dental wall. This surface can be used to unfold the dental wall and generate a panoramic. This mesh is represented as a three-dimensional array storing the coordinates of each vertex. 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 vertices per column of the mesh (N-1 cells per column). M, the number of vertices per row of the mesh (M-1 cells per row). | ArrayXd |  | nullptr

## Object Examples

    auto dental_binary = readVipImage( std::string( IMAGEDEVDATA_IMAGES_FOLDER ) + "dental_binary.vip" );
    auto dental_cbct = ioformat::readImage( std::string( IMAGEDEVDATA_IMAGES_FOLDER ) + "dental_cbct.am" );

    DentalMeshExtraction3d dentalMeshExtraction3dAlgo;
    dentalMeshExtraction3dAlgo.setInputBinaryImage( dental_binary );
    dentalMeshExtraction3dAlgo.setInputImage( dental_cbct );
    dentalMeshExtraction3dAlgo.setInputArchCurve( nullptr );
    dentalMeshExtraction3dAlgo.setExtrusionDown( 30 );
    dentalMeshExtraction3dAlgo.setExtrusionUp( 30 );
    dentalMeshExtraction3dAlgo.setSearchLength( 15 );
    dentalMeshExtraction3dAlgo.execute();

    std::cout << "outputArchCurve:" << dentalMeshExtraction3dAlgo.outputArchCurve()->shape();
    std::cout << "outputInsideArchCurve:" << dentalMeshExtraction3dAlgo.outputInsideArchCurve()->shape();
    std::cout << "outputOutsideArchCurve:" << dentalMeshExtraction3dAlgo.outputOutsideArchCurve()->shape();
    std::cout << "outputDirections:" << dentalMeshExtraction3dAlgo.outputDirections()->shape();
    std::cout << "outputMesh:" << dentalMeshExtraction3dAlgo.outputMesh()->shape();

    dental_binary = imagedev.read_vip_image(imagedev_data.get_image_path("dental_binary.vip"))
    dental_cbct = ioformat.read_image(imagedev_data.get_image_path("dental_cbct.am"))

    dental_mesh_extraction_3d_algo = imagedev.DentalMeshExtraction3d()
    dental_mesh_extraction_3d_algo.input_binary_image = dental_binary
    dental_mesh_extraction_3d_algo.input_image = dental_cbct
    dental_mesh_extraction_3d_algo.input_arch_curve = None
    dental_mesh_extraction_3d_algo.extrusion_down = 30
    dental_mesh_extraction_3d_algo.extrusion_up = 30
    dental_mesh_extraction_3d_algo.search_length = 15
    dental_mesh_extraction_3d_algo.execute()

    print("output_arch_curve:", str(dental_mesh_extraction_3d_algo.output_arch_curve))
    print("output_inside_arch_curve:", str(dental_mesh_extraction_3d_algo.output_inside_arch_curve))
    print("output_outside_arch_curve:", str(dental_mesh_extraction_3d_algo.output_outside_arch_curve))
    print("output_directions:", str(dental_mesh_extraction_3d_algo.output_directions))
    print("output_mesh:", str(dental_mesh_extraction_3d_algo.output_mesh))

    ImageView dental_binary = Data.ReadVipImage( @"Data/images/dental_binary.vip" );
    ImageView dental_cbct = ViewIO.ReadImage( @"Data/images/dental_cbct.am" );

    DentalMeshExtraction3d dentalMeshExtraction3dAlgo = new DentalMeshExtraction3d
    {
        inputBinaryImage = dental_binary,
        inputImage = dental_cbct,
        inputArchCurve = null,
        extrusionDown = 30,
        extrusionUp = 30,
        searchLength = 15
    };
    dentalMeshExtraction3dAlgo.Execute();

    Console.WriteLine( "outputArchCurve:" + dentalMeshExtraction3dAlgo.outputArchCurve.ToString() );
    Console.WriteLine( "outputInsideArchCurve:" + dentalMeshExtraction3dAlgo.outputInsideArchCurve.ToString() );
    Console.WriteLine( "outputOutsideArchCurve:" + dentalMeshExtraction3dAlgo.outputOutsideArchCurve.ToString() );
    Console.WriteLine( "outputDirections:" + dentalMeshExtraction3dAlgo.outputDirections.ToString() );
    Console.WriteLine( "outputMesh:" + dentalMeshExtraction3dAlgo.outputMesh.ToString() );

## Function Examples

    auto dental_binary = readVipImage( std::string( IMAGEDEVDATA_IMAGES_FOLDER ) + "dental_binary.vip" );
    auto dental_cbct = ioformat::readImage( std::string( IMAGEDEVDATA_IMAGES_FOLDER ) + "dental_cbct.am" );

    auto result = dentalMeshExtraction3d( dental_binary, dental_cbct, nullptr, 30, 30, 15 );

    std::cout << "outputArchCurve:" << result.outputArchCurve->shape();
    std::cout << "outputInsideArchCurve:" << result.outputInsideArchCurve->shape();
    std::cout << "outputOutsideArchCurve:" << result.outputOutsideArchCurve->shape();
    std::cout << "outputDirections:" << result.outputDirections->shape();
    std::cout << "outputMesh:" << result.outputMesh->shape();

    dental_binary = imagedev.read_vip_image(imagedev_data.get_image_path("dental_binary.vip"))
    dental_cbct = ioformat.read_image(imagedev_data.get_image_path("dental_cbct.am"))

    result_output_arch_curve, result_output_inside_arch_curve, result_output_outside_arch_curve, result_output_directions, result_output_mesh = imagedev.dental_mesh_extraction_3d(dental_binary, dental_cbct, None, 30, 30, 15)

    print("output_arch_curve:", str(result_output_arch_curve))
    print("output_inside_arch_curve:", str(result_output_inside_arch_curve))
    print("output_outside_arch_curve:", str(result_output_outside_arch_curve))
    print("output_directions:", str(result_output_directions))
    print("output_mesh:", str(result_output_mesh))

    ImageView dental_binary = Data.ReadVipImage( @"Data/images/dental_binary.vip" );
    ImageView dental_cbct = ViewIO.ReadImage( @"Data/images/dental_cbct.am" );

    Processing.DentalMeshExtraction3dOutput result = Processing.DentalMeshExtraction3d( dental_binary, dental_cbct, null, 30, 30, 15 );

    Console.WriteLine( "outputArchCurve:" + result.outputArchCurve.ToString() );
    Console.WriteLine( "outputInsideArchCurve:" + result.outputInsideArchCurve.ToString() );
    Console.WriteLine( "outputOutsideArchCurve:" + result.outputOutsideArchCurve.ToString() );
    Console.WriteLine( "outputDirections:" + result.outputDirections.ToString() );
    Console.WriteLine( "outputMesh:" + result.outputMesh.ToString() );

© 2025 Thermo Fisher Scientific Inc. All rights reserved.