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

# CudaTemplateMatching3d

Computes a similarity score for each voxel of a three-dimensional image for localizing a searched structure.
Access to parameter description
This command is experimental, his signature may be modified between now and his final version.
For an introduction: section Image Correlation.
This algorithm aims to detect a known structure, defined in a template image, within a three-dimensional image.
The template can be optionally transformed to be compared at different orientations and scales at each position of the input image. These transformations are provided in a data frame where each row represents a transformation to test, and each column, a component of the rotation and scale factor to apply.
For each transformation of the template, a cross-correlation is performed with the input image and the highest correlation score is retained for each voxel.
Two output images are provided by the algorithm:

- The main output image, indicating for each voxel the best correlation score of the template among all the tested transformations.
- The transform index image, indicating for each voxel the data frame row of the transformation providing this best correlation score.

Two types of masks can be managed by the algorithm:

- A binary mask, applied on the template. If this mask has a spherical shape, rotations can be disabled on it in order to save computation time.
- A filter mask, applied on the Fourier transform of the template image. It may be used to mitigate the missing wedge artifacts of an electron tomography acquisition or to emulate the point spread function of an optical system.

The main steps of a pattern detection by template matching are:

- Generate the list of rotations to apply on the template with RotationGenerator3d.
- Add the scale factors to apply to the generated data frame.
- In the case of an acquisition by electron tomography, generate a mask for the missing wedges with WedgeMaskImage3d.
- Run the template matching algorithm.
- Extract the relevant correlation peaks with PeakExtractor. The tuning of this step is critical in order to find appropriate parameters, providing a good compromise between true positive and false negative rates.
- Make the correspondance between the detected features and their associated transformations by reading the transform index of each extracted peak. The associated transformation can be found in the transform table provided as input of the template matching.

Reference:
A.M. Roseman. "Particle finding in electron micrographs using a fast local correlation algorithm", Ultramicroscopy, 94(3-4), pp. 225-236, 2003.
See also

- CudaCrossCorrelation2d
- WedgeMaskImage3d
- RotationGenerator3d
- Rotate3d
- PeakExtractor

##
Function Syntax

This function returns a CudaTemplateMatching3dOutput structure containing outputImage and outputTransformIndexImage.

    // Output structure of the cudaTemplateMatching3d function.
    struct CudaTemplateMatching3dOutput
    {
        /// The correlation scores image. Its dimensions are forced to the same values as the input. Its data type is forced to floating point.
        std::shared_ptr< iolink::ImageView > outputImage;
        /// The index image for transform. Its dimensions are forced to the same values as the input. Its data type is forced to unsigned integer.
        std::shared_ptr< iolink::ImageView > outputTransformIndexImage;
        /// The data frame indicating the rotations and scales to apply.
        std::shared_ptr< const iolink::DataFrameView > transformTable;
    };

    // Function prototype
    CudaTemplateMatching3dOutput
    cudaTemplateMatching3d( std::shared_ptr< iolink::ImageView > inputImage,
                            std::shared_ptr< iolink::ImageView > inputTemplate,
                            std::shared_ptr< iolink::ImageView > inputMask,
                            std::shared_ptr< iolink::ImageView > inputFilter,
                            bool rotateMask,
                            std::shared_ptr< const iolink::DataFrameView > transformTable,
                            CudaTemplateMatching3d::TilingMode tilingMode,
                            const iolink::Vector3u32& tileSize,
                            CudaContext::Ptr cudaContext,
                            std::shared_ptr< iolink::ImageView > outputImage = nullptr,
                            std::shared_ptr< iolink::ImageView > outputTransformIndexImage = nullptr );

This function returns a tuple containing output_image and output_transform_index_image.

    // Function prototype.
    cuda_template_matching_3d(input_image: idt.ImageType,
                              input_template: idt.ImageType,
                              input_mask: idt.ImageType,
                              input_filter: idt.ImageType,
                              rotate_mask: bool = False,
                              transform_table: Union[iolink.DataFrameView, None] = None,
                              tiling_mode: CudaTemplateMatching3d.TilingMode = CudaTemplateMatching3d.TilingMode.NONE,
                              tile_size: Iterable[int] = [128, 128, 128],
                              cuda_context: Union[CudaContext, None] = None,
                              output_image: idt.ImageType = None,
                              output_transform_index_image: idt.ImageType = None) -> Tuple[idt.ImageType, idt.ImageType]

This function returns a CudaTemplateMatching3dOutput structure containing outputImage and outputTransformIndexImage.

    /// Output structure of the CudaTemplateMatching3d function.
    public struct CudaTemplateMatching3dOutput
    {
        ///
        /// The correlation scores image. Its dimensions are forced to the same values as the input. Its data type is forced to floating point.
        ///
        public IOLink.ImageView outputImage;
        ///
        /// The index image for transform. Its dimensions are forced to the same values as the input. Its data type is forced to unsigned integer.
        ///
        public IOLink.ImageView outputTransformIndexImage;
        /// The data frame indicating the rotations and scales to apply.
        public IOLink.DataFrameView transformTable;
    };

    // Function prototype.
    public static CudaTemplateMatching3dOutput
    CudaTemplateMatching3d( IOLink.ImageView inputImage,
                            IOLink.ImageView inputTemplate,
                            IOLink.ImageView inputMask,
                            IOLink.ImageView inputFilter,
                            bool rotateMask = false,
                            IOLink.DataFrameView transformTable = null,
                            CudaTemplateMatching3d.TilingMode tilingMode = ImageDev.CudaTemplateMatching3d.TilingMode.NONE,
                            uint[] tileSize = null,
                            Data.CudaContext cudaContext = null,
                            IOLink.ImageView outputImage = null,
                            IOLink.ImageView outputTransformIndexImage = null );

##
Class Syntax

    // Command constructor.
    CudaTemplateMatching3d();

    /// Gets the inputImage parameter.
    /// The input image where the template is searched.
    std::shared_ptr< iolink::ImageView > inputImage() const;
    /// Sets the inputImage parameter.
    /// The input image where the template is searched.
    void setInputImage( std::shared_ptr< iolink::ImageView > inputImage );

    /// Gets the inputTemplate parameter.
    /// The template image. Its shape must be contained in the input image.
    std::shared_ptr< iolink::ImageView > inputTemplate() const;
    /// Sets the inputTemplate parameter.
    /// The template image. Its shape must be contained in the input image.
    void setInputTemplate( std::shared_ptr< iolink::ImageView > inputTemplate );

    /// Gets the inputMask parameter.
    /// The input mask. Its shape must be the same as the template image. This parameter is optional.
    std::shared_ptr< iolink::ImageView > inputMask() const;
    /// Sets the inputMask parameter.
    /// The input mask. Its shape must be the same as the template image. This parameter is optional.
    void setInputMask( std::shared_ptr< iolink::ImageView > inputMask );

    /// Gets the inputFilter parameter.
    /// The input filter image used to correct the input template in the Fourier domain. Its spacing must be the same as the input image. This parameter is optional.
    std::shared_ptr< iolink::ImageView > inputFilter() const;
    /// Sets the inputFilter parameter.
    /// The input filter image used to correct the input template in the Fourier domain. Its spacing must be the same as the input image. This parameter is optional.
    void setInputFilter( std::shared_ptr< iolink::ImageView > inputFilter );

    /// Gets the rotateMask parameter.
    /// The flag that indicates if the mask has to be rotated with the template.
    bool rotateMask() const;
    /// Sets the rotateMask parameter.
    /// The flag that indicates if the mask has to be rotated with the template.
    void setRotateMask( const bool& rotateMask );

    /// Gets the transformTable parameter.
    /// The data frame indicating the rotations and scales to apply.
    std::shared_ptr< const iolink::DataFrameView > transformTable() const;
    /// Sets the transformTable parameter.
    /// The data frame indicating the rotations and scales to apply.
    void setTransformTable( const std::shared_ptr< const iolink::DataFrameView >& transformTable );

    /// Gets the tilingMode parameter.
    /// The way to manage the GPU memory. If the input image is already on GPU, this parameter is ignored.
    CudaTemplateMatching3d::TilingMode tilingMode() const;
    /// Sets the tilingMode parameter.
    /// The way to manage the GPU memory. If the input image is already on GPU, this parameter is ignored.
    void setTilingMode( const CudaTemplateMatching3d::TilingMode& tilingMode );

    /// Gets the tileSize parameter.
    /// The tile width and height in voxels. They must be greater than or equal to the correlation kernel width and height. This parameter is used only in USER_DEFINED tiling mode.
    iolink::Vector3u32 tileSize() const;
    /// Sets the tileSize parameter.
    /// The tile width and height in voxels. They must be greater than or equal to the correlation kernel width and height. This parameter is used only in USER_DEFINED tiling mode.
    void setTileSize( const iolink::Vector3u32& tileSize );

    /// Gets the cudaContext parameter.
    /// The CUDA context information.
    CudaContext::Ptr cudaContext() const;
    /// Sets the cudaContext parameter.
    /// The CUDA context information.
    void setCudaContext( const CudaContext::Ptr& cudaContext );

    /// Gets the outputImage parameter.
    /// The correlation scores image. Its dimensions are forced to the same values as the input. Its data type is forced to floating point.
    std::shared_ptr< iolink::ImageView > outputImage() const;
    /// Sets the outputImage parameter.
    /// The correlation scores image. Its dimensions are forced to the same values as the input. Its data type is forced to floating point.
    void setOutputImage( std::shared_ptr< iolink::ImageView > outputImage );

    /// Gets the outputTransformIndexImage parameter.
    /// The index image for transform. Its dimensions are forced to the same values as the input. Its data type is forced to unsigned integer.
    std::shared_ptr< iolink::ImageView > outputTransformIndexImage() const;
    /// Sets the outputTransformIndexImage parameter.
    /// The index image for transform. Its dimensions are forced to the same values as the input. Its data type is forced to unsigned integer.
    void setOutputTransformIndexImage( std::shared_ptr< iolink::ImageView > outputTransformIndexImage );

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

    # Property of the inputImage parameter.
    CudaTemplateMatching3d.input_image
    # Property of the inputTemplate parameter.
    CudaTemplateMatching3d.input_template
    # Property of the inputMask parameter.
    CudaTemplateMatching3d.input_mask
    # Property of the inputFilter parameter.
    CudaTemplateMatching3d.input_filter
    # Property of the rotateMask parameter.
    CudaTemplateMatching3d.rotate_mask
    # Property of the transformTable parameter.
    CudaTemplateMatching3d.transform_table
    # Property of the tilingMode parameter.
    CudaTemplateMatching3d.tiling_mode
    # Property of the tileSize parameter.
    CudaTemplateMatching3d.tile_size
    # Property of the cudaContext parameter.
    CudaTemplateMatching3d.cuda_context
    # Property of the outputImage parameter.
    CudaTemplateMatching3d.output_image
    # Property of the outputTransformIndexImage parameter.
    CudaTemplateMatching3d.output_transform_index_image

    // Method to launch the command.
    execute()

    // Command constructor.
    CudaTemplateMatching3d()

    // Property of the inputImage parameter.
    CudaTemplateMatching3d.inputImage
    // Property of the inputTemplate parameter.
    CudaTemplateMatching3d.inputTemplate
    // Property of the inputMask parameter.
    CudaTemplateMatching3d.inputMask
    // Property of the inputFilter parameter.
    CudaTemplateMatching3d.inputFilter
    // Property of the rotateMask parameter.
    CudaTemplateMatching3d.rotateMask
    // Property of the transformTable parameter.
    CudaTemplateMatching3d.transformTable
    // Property of the tilingMode parameter.
    CudaTemplateMatching3d.tilingMode
    // Property of the tileSize parameter.
    CudaTemplateMatching3d.tileSize
    // Property of the cudaContext parameter.
    CudaTemplateMatching3d.cudaContext
    // Property of the outputImage parameter.
    CudaTemplateMatching3d.outputImage
    // Property of the outputTransformIndexImage parameter.
    CudaTemplateMatching3d.outputTransformIndexImage

    // Method to launch the command.
    Execute()

## Parameters

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| inputImage | The input image where the template is searched. | Image | Grayscale | nullptr
| inputTemplate | The template image. Its shape must be contained in the input image. | Image | Grayscale | nullptr
| inputMask | The input mask. Its shape must be the same as the template image. This parameter is optional. | Image | Binary | nullptr
| inputFilter | The input filter image used to correct the input template in the Fourier domain. Its spacing must be the same as the input image. This parameter is optional. The image should correspond to a centered representation of a Fourier transform, the zero frequency (DC component) must be positioned at the center of the image. This ensures that the symmetry and frequency components are correctly interpreted. Furthermore, the dimensions of the image should be odd to allow for a true center pixel, which facilitates the proper alignment of the frequency components around this central point. Since the correction process will be applied to the transformed templates, determining the minimum image size is complex and not straightforward. To simplify, we advise supplying an image with dimensions that are at least twice the size of the template's largest dimension. | Image | Binary or Grayscale | nullptr
| rotateMask | The flag that indicates if the mask has to be rotated with the template. It increases significantly the computation time but has to be set to True if the mask is not rotation invariant (not a sphere). This option can be used when only some rotations are applied. When some scale factors are provided in the transform table, it is recommended to set it to True. | Bool |  | false
| transformTable | The data frame indicating the rotations and scales to apply. The columns are (RZ1, RX2, RZ3, SX, SY, SZ), where (RZ1, RX2, RZ3) represents the rotation components with the proper Euler angles ZXZ convention, and (SX, SY, SZ), the scale factor for each axis. Their default values are respectively (0, 0, 0, 1, 1, 1). If some columns are omitted, their default values are considered. If this parameter is omitted no transform is applied (default values). The output of RotationGenerator3d can be directly set for this parameter. | DataFrameViewConst |  | nullptr
| tilingMode | The way to manage the GPU memory. If the input image is already on GPU, this parameter is ignored.
NONE | The entire input image is transferred to the GPU memory. If the total input, intermediate and output data size exceed the GPU memory, the computation will fail.
USER_DEFINED | The input image is processed by tiles of a predefined size.
| Enumeration |  | NONE
| tileSize | The tile width and height in voxels. They must be greater than or equal to the correlation kernel width and height. This parameter is used only in USER_DEFINED tiling mode. | Vector3u32 | Any value | {128, 128, 128}
| cudaContext | The CUDA context information. For more information: CudaContext | CudaContext |  | nullptr
| outputImage | The correlation scores image. Its dimensions are forced to the same values as the input. Its data type is forced to floating point. | Image |  | nullptr
| outputTransformIndexImage | The index image for transform. Its dimensions are forced to the same values as the input. Its data type is forced to unsigned integer. | Image |  | nullptr

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| input_image | The input image where the template is searched. | image | Grayscale | None
| input_template | The template image. Its shape must be contained in the input image. | image | Grayscale | None
| input_mask | The input mask. Its shape must be the same as the template image. This parameter is optional. | image | Binary | None
| input_filter | The input filter image used to correct the input template in the Fourier domain. Its spacing must be the same as the input image. This parameter is optional. The image should correspond to a centered representation of a Fourier transform, the zero frequency (DC component) must be positioned at the center of the image. This ensures that the symmetry and frequency components are correctly interpreted. Furthermore, the dimensions of the image should be odd to allow for a true center pixel, which facilitates the proper alignment of the frequency components around this central point. Since the correction process will be applied to the transformed templates, determining the minimum image size is complex and not straightforward. To simplify, we advise supplying an image with dimensions that are at least twice the size of the template's largest dimension. | image | Binary or Grayscale | None
| rotate_mask | The flag that indicates if the mask has to be rotated with the template. It increases significantly the computation time but has to be set to True if the mask is not rotation invariant (not a sphere). This option can be used when only some rotations are applied. When some scale factors are provided in the transform table, it is recommended to set it to True. | bool |  | False
| transform_table | The data frame indicating the rotations and scales to apply. The columns are (RZ1, RX2, RZ3, SX, SY, SZ), where (RZ1, RX2, RZ3) represents the rotation components with the proper Euler angles ZXZ convention, and (SX, SY, SZ), the scale factor for each axis. Their default values are respectively (0, 0, 0, 1, 1, 1). If some columns are omitted, their default values are considered. If this parameter is omitted no transform is applied (default values). The output of RotationGenerator3d can be directly set for this parameter. | data_frame_view_const |  | None
| tiling_mode | The way to manage the GPU memory. If the input image is already on GPU, this parameter is ignored.
NONE | The entire input image is transferred to the GPU memory. If the total input, intermediate and output data size exceed the GPU memory, the computation will fail.
USER_DEFINED | The input image is processed by tiles of a predefined size.
| enumeration |  | NONE
| tile_size | The tile width and height in voxels. They must be greater than or equal to the correlation kernel width and height. This parameter is used only in USER_DEFINED tiling mode. | vector3u32 | Any value | [128, 128, 128]
| cuda_context | The CUDA context information. For more information: CudaContext | cuda_context |  | None
| output_image | The correlation scores image. Its dimensions are forced to the same values as the input. Its data type is forced to floating point. | image |  | None
| output_transform_index_image | The index image for transform. Its dimensions are forced to the same values as the input. Its data type is forced to unsigned integer. | image |  | None

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| inputImage | The input image where the template is searched. | Image | Grayscale | null
| inputTemplate | The template image. Its shape must be contained in the input image. | Image | Grayscale | null
| inputMask | The input mask. Its shape must be the same as the template image. This parameter is optional. | Image | Binary | null
| inputFilter | The input filter image used to correct the input template in the Fourier domain. Its spacing must be the same as the input image. This parameter is optional. The image should correspond to a centered representation of a Fourier transform, the zero frequency (DC component) must be positioned at the center of the image. This ensures that the symmetry and frequency components are correctly interpreted. Furthermore, the dimensions of the image should be odd to allow for a true center pixel, which facilitates the proper alignment of the frequency components around this central point. Since the correction process will be applied to the transformed templates, determining the minimum image size is complex and not straightforward. To simplify, we advise supplying an image with dimensions that are at least twice the size of the template's largest dimension. | Image | Binary or Grayscale | null
| rotateMask | The flag that indicates if the mask has to be rotated with the template. It increases significantly the computation time but has to be set to True if the mask is not rotation invariant (not a sphere). This option can be used when only some rotations are applied. When some scale factors are provided in the transform table, it is recommended to set it to True. | Bool |  | false
| transformTable | The data frame indicating the rotations and scales to apply. The columns are (RZ1, RX2, RZ3, SX, SY, SZ), where (RZ1, RX2, RZ3) represents the rotation components with the proper Euler angles ZXZ convention, and (SX, SY, SZ), the scale factor for each axis. Their default values are respectively (0, 0, 0, 1, 1, 1). If some columns are omitted, their default values are considered. If this parameter is omitted no transform is applied (default values). The output of RotationGenerator3d can be directly set for this parameter. | DataFrameViewConst |  | null
| tilingMode | The way to manage the GPU memory. If the input image is already on GPU, this parameter is ignored.
NONE | The entire input image is transferred to the GPU memory. If the total input, intermediate and output data size exceed the GPU memory, the computation will fail.
USER_DEFINED | The input image is processed by tiles of a predefined size.
| Enumeration |  | NONE
| tileSize | The tile width and height in voxels. They must be greater than or equal to the correlation kernel width and height. This parameter is used only in USER_DEFINED tiling mode. | Vector3u32 | Any value | {128, 128, 128}
| cudaContext | The CUDA context information. For more information: CudaContext | CudaContext |  | null
| outputImage | The correlation scores image. Its dimensions are forced to the same values as the input. Its data type is forced to floating point. | Image |  | null
| outputTransformIndexImage | The index image for transform. Its dimensions are forced to the same values as the input. Its data type is forced to unsigned integer. | Image |  | null

## Object Examples

    auto fibers = readVipImage( std::string( IMAGEDEVDATA_IMAGES_FOLDER ) + "fibers.vip" );
    auto fibers_template = readVipImage( std::string( IMAGEDEVDATA_IMAGES_FOLDER ) + "fibers_template.vip" );
    auto fibers_template_mask = readVipImage( std::string( IMAGEDEVDATA_IMAGES_FOLDER ) + "fibers_template_mask.vip" );

    CudaTemplateMatching3d cudaTemplateMatching3dAlgo;
    cudaTemplateMatching3dAlgo.setInputImage( fibers );
    cudaTemplateMatching3dAlgo.setInputTemplate( fibers_template );
    cudaTemplateMatching3dAlgo.setInputMask( fibers_template_mask );
    cudaTemplateMatching3dAlgo.setInputFilter( nullptr );
    cudaTemplateMatching3dAlgo.setRotateMask( false );
    cudaTemplateMatching3dAlgo.setTransformTable( nullptr );
    cudaTemplateMatching3dAlgo.setTilingMode( CudaTemplateMatching3d::TilingMode::NONE );
    cudaTemplateMatching3dAlgo.setTileSize( {128, 128, 128} );
    cudaTemplateMatching3dAlgo.setCudaContext( nullptr );
    cudaTemplateMatching3dAlgo.setOutputImage( iolink::ImageViewFactory::allocate( iolink::VectorXu64( { 1, 1 } ), iolink::DataTypeId::UINT8 ) );
    cudaTemplateMatching3dAlgo.setOutputTransformIndexImage( iolink::ImageViewFactory::allocate( iolink::VectorXu64( { 1, 1 } ), iolink::DataTypeId::UINT8 ) );
    cudaTemplateMatching3dAlgo.execute();

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

    fibers = imagedev.read_vip_image(imagedev_data.get_image_path("fibers.vip"))
    fibers_template = imagedev.read_vip_image(imagedev_data.get_image_path("fibers_template.vip"))
    fibers_template_mask = imagedev.read_vip_image(imagedev_data.get_image_path("fibers_template_mask.vip"))

    cuda_template_matching_3d_algo = imagedev.CudaTemplateMatching3d()
    cuda_template_matching_3d_algo.input_image = fibers
    cuda_template_matching_3d_algo.input_template = fibers_template
    cuda_template_matching_3d_algo.input_mask = fibers_template_mask
    cuda_template_matching_3d_algo.input_filter = None
    cuda_template_matching_3d_algo.rotate_mask = False
    cuda_template_matching_3d_algo.transform_table = None
    cuda_template_matching_3d_algo.tiling_mode = imagedev.CudaTemplateMatching3d.NONE
    cuda_template_matching_3d_algo.tile_size = [128, 128, 128]
    cuda_template_matching_3d_algo.cuda_context = None
    cuda_template_matching_3d_algo.execute()

    print("output_image:", str(cuda_template_matching_3d_algo.output_image))
    print("output_transform_index_image:", str(cuda_template_matching_3d_algo.output_transform_index_image))

    ImageView fibers = Data.ReadVipImage( @"Data/images/fibers.vip" );
    ImageView fibers_template = Data.ReadVipImage( @"Data/images/fibers_template.vip" );
    ImageView fibers_template_mask = Data.ReadVipImage( @"Data/images/fibers_template_mask.vip" );

    CudaTemplateMatching3d cudaTemplateMatching3dAlgo = new CudaTemplateMatching3d
    {
        inputImage = fibers,
        inputTemplate = fibers_template,
        inputMask = fibers_template_mask,
        inputFilter = null,
        rotateMask = false,
        transformTable = null,
        tilingMode = CudaTemplateMatching3d.TilingMode.NONE,
        tileSize = new uint[]{128, 128, 128},
        cudaContext = null
    };
    cudaTemplateMatching3dAlgo.Execute();

    Console.WriteLine( "outputImage:" + cudaTemplateMatching3dAlgo.outputImage.ToString() );
    Console.WriteLine( "outputTransformIndexImage:" + cudaTemplateMatching3dAlgo.outputTransformIndexImage.ToString() );

## Function Examples

    auto fibers = readVipImage( std::string( IMAGEDEVDATA_IMAGES_FOLDER ) + "fibers.vip" );
    auto fibers_template = readVipImage( std::string( IMAGEDEVDATA_IMAGES_FOLDER ) + "fibers_template.vip" );
    auto fibers_template_mask = readVipImage( std::string( IMAGEDEVDATA_IMAGES_FOLDER ) + "fibers_template_mask.vip" );

    auto result = cudaTemplateMatching3d( fibers, fibers_template, fibers_template_mask, nullptr, false, nullptr, CudaTemplateMatching3d::TilingMode::NONE, {128, 128, 128}, nullptr , iolink::ImageViewFactory::allocate( iolink::VectorXu64( { 1, 1 } ), iolink::DataTypeId::UINT8 ), iolink::ImageViewFactory::allocate( iolink::VectorXu64( { 1, 1 } ), iolink::DataTypeId::UINT8 ));

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

    fibers = imagedev.read_vip_image(imagedev_data.get_image_path("fibers.vip"))
    fibers_template = imagedev.read_vip_image(imagedev_data.get_image_path("fibers_template.vip"))
    fibers_template_mask = imagedev.read_vip_image(imagedev_data.get_image_path("fibers_template_mask.vip"))

    result_output_image, result_output_transform_index_image = imagedev.cuda_template_matching_3d(fibers, fibers_template, fibers_template_mask, None, False, None, imagedev.CudaTemplateMatching3d.NONE, [128, 128, 128], None)

    print("output_image:", str(result_output_image))
    print("output_transform_index_image:", str(result_output_transform_index_image))

    ImageView fibers = Data.ReadVipImage( @"Data/images/fibers.vip" );
    ImageView fibers_template = Data.ReadVipImage( @"Data/images/fibers_template.vip" );
    ImageView fibers_template_mask = Data.ReadVipImage( @"Data/images/fibers_template_mask.vip" );

    Processing.CudaTemplateMatching3dOutput result = Processing.CudaTemplateMatching3d( fibers, fibers_template, fibers_template_mask, null, false, null, CudaTemplateMatching3d.TilingMode.NONE, new uint[]{128, 128, 128}, null );

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

© 2025 Thermo Fisher Scientific Inc. All rights reserved.