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

# OrientationMatchingFourier3d

Estimates the probability of a sample to be locally oriented in a user-defined direction.
Access to parameter description
For an introduction:

- section Image Analysis
- section Moment And Orientation

The direction is defined using angles Phi and Theta in spherical coordinates as explained in the ImageDev 3D orientation convention.
The orientation similarity of a local region with a user-defined orientation is computed by applying the transformation to the inertia matrix, taking into account the changes induced by the basis. Consider the basis change illustrated below.
Figure 1. Basis change from cartesian to spherical coordinate system
One can demonstrate that the transformation of the vector $(V_x, V_y, V_z)$ in the basis $(e_x, e_y, e_z)$ to the vector $(V_r, V_\varphi, V_\theta)$ in the basis $(e_r, e_\varphi, e_\theta)$ is expressed as: $$ \left[ \begin{array}{c} V_r\\ V_\varphi\\ V_\theta\end{array}\right] = \left[ \begin{array}{ccc}; sin (\varphi) \cdot cos (\theta) & sin (\varphi) \cdot sin (\theta) & cos (\varphi)\\ cos (\varphi) \cdot cos (\theta) & cos (\varphi) \cdot sin (\theta) & sin (\varphi)\\ -sin (\theta) & cos (\theta) & 0 \end{array}\right] \left[ \begin{array}{c} V_x\\ V_y\\ V_z\end{array}\right] $$ We denote $P$ this transformation matrix.
Now let $M(x, y, z)$ be the inertia matrix in the basis $(e_x, e_y, e_z)$, the inertia matrix $M(r, \varphi, \theta)$ in the basis $(e_r, e_\varphi, e_\theta)$ is expressed as: $$ M(r, \varphi, \theta) = P \cdot M(x, y, z) \cdot P^{-1}$$
Finally, this algorithm provides two outputs:

- An image that, for each block, shows its similarity with the input orientation, equal to the confidence of the OrientationMapFourier3d algorithm multiplied by 100
- A measurement object that, for each block, provides all computed features (confidence, moments, eigenvalues, ...)

Figure 2. Local orientation matching of a 3D image with user-defined direction
See also

- MomentsOfInertia3d
- Eccentricity2d
- OrientationMapFourier3d

##
Function Syntax

This function returns a OrientationMatchingFourier3dOutput structure containing outputImage and outputMeasurement.

    // Output structure of the orientationMatchingFourier3d function.
    struct OrientationMatchingFourier3dOutput
    {
        /// The grayscale output image representing sticks oriented in the user-defined direction. Intensities correspond to a similarity score with the input orientation in percent. Image dimensions are forced to the same values as the input. Its type is unsigned 8-bit integer.
        std::shared_ptr< iolink::ImageView > outputImage;
        /// The output measurement result for each block.
        LocalOrientation3dMsr::Ptr outputMeasurement;
    };

    // Function prototype
    OrientationMatchingFourier3dOutput
    orientationMatchingFourier3d( std::shared_ptr< iolink::ImageView > inputImage,
                                  int32_t blockSize,
                                  OrientationMatchingFourier3d::BlockOverlap blockOverlap,
                                  int32_t minThreshold,
                                  int32_t maxThreshold,
                                  double phiAngle,
                                  double thetaAngle,
                                  std::shared_ptr< iolink::ImageView > outputImage = nullptr,
                                  LocalOrientation3dMsr::Ptr outputMeasurement = nullptr );

This function returns a tuple containing output_image and output_measurement.

    // Function prototype.
    orientation_matching_fourier_3d(input_image: idt.ImageType,
                                    block_size: int = 64,
                                    block_overlap: OrientationMatchingFourier3d.BlockOverlap = OrientationMatchingFourier3d.BlockOverlap.YES,
                                    min_threshold: int = 100,
                                    max_threshold: int = 300,
                                    phi_angle: float = 0,
                                    theta_angle: float = 0,
                                    output_image: idt.ImageType = None,
                                    output_measurement: Union[Any, None] = None) -> Tuple[idt.ImageType, LocalOrientation3dMsr]

This function returns a OrientationMatchingFourier3dOutput structure containing outputImage and outputMeasurement.

    /// Output structure of the OrientationMatchingFourier3d function.
    public struct OrientationMatchingFourier3dOutput
    {
        ///
        /// The grayscale output image representing sticks oriented in the user-defined direction. Intensities correspond to a similarity score with the input orientation in percent. Image dimensions are forced to the same values as the input. Its type is unsigned 8-bit integer.
        ///
        public IOLink.ImageView outputImage;
        /// The output measurement result for each block.
        public LocalOrientation3dMsr outputMeasurement;
    };

    // Function prototype.
    public static OrientationMatchingFourier3dOutput
    OrientationMatchingFourier3d( IOLink.ImageView inputImage,
                                  Int32 blockSize = 64,
                                  OrientationMatchingFourier3d.BlockOverlap blockOverlap = ImageDev.OrientationMatchingFourier3d.BlockOverlap.YES,
                                  Int32 minThreshold = 100,
                                  Int32 maxThreshold = 300,
                                  double phiAngle = 0,
                                  double thetaAngle = 0,
                                  IOLink.ImageView outputImage = null,
                                  LocalOrientation3dMsr outputMeasurement = null );

##
Class Syntax

    // Command constructor.
    OrientationMatchingFourier3d();

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

    /// Gets the blockSize parameter.
    /// The side size in pixels of the cubic blocks.
    int32_t blockSize() const;
    /// Sets the blockSize parameter.
    /// The side size in pixels of the cubic blocks.
    void setBlockSize( const int32_t& blockSize );

    /// Gets the blockOverlap parameter.
    /// The policy for splitting the image into blocks.
    OrientationMatchingFourier3d::BlockOverlap blockOverlap() const;
    /// Sets the blockOverlap parameter.
    /// The policy for splitting the image into blocks.
    void setBlockOverlap( const OrientationMatchingFourier3d::BlockOverlap& blockOverlap );

    /// Gets the minThreshold parameter.
    /// The minimum threshold value applied to the input grayscale image. Voxels having an intensity lower than this threshold are not considered by the algorithm.
    int32_t minThreshold() const;
    /// Sets the minThreshold parameter.
    /// The minimum threshold value applied to the input grayscale image. Voxels having an intensity lower than this threshold are not considered by the algorithm.
    void setMinThreshold( const int32_t& minThreshold );

    /// Gets the maxThreshold parameter.
    /// The maximum threshold value applied to the input grayscale image. Voxels having an intensity greater than this threshold are not considered by the algorithm.
    int32_t maxThreshold() const;
    /// Sets the maxThreshold parameter.
    /// The maximum threshold value applied to the input grayscale image. Voxels having an intensity greater than this threshold are not considered by the algorithm.
    void setMaxThreshold( const int32_t& maxThreshold );

    /// Gets the phiAngle parameter.
    /// The polar angle, in degrees, of the analysis orientation.
    double phiAngle() const;
    /// Sets the phiAngle parameter.
    /// The polar angle, in degrees, of the analysis orientation.
    void setPhiAngle( const double& phiAngle );

    /// Gets the thetaAngle parameter.
    /// The azimuthal angle, in degrees, of the analysis orientation.
    double thetaAngle() const;
    /// Sets the thetaAngle parameter.
    /// The azimuthal angle, in degrees, of the analysis orientation.
    void setThetaAngle( const double& thetaAngle );

    /// Gets the outputImage parameter.
    /// The grayscale output image representing sticks oriented in the user-defined direction. Intensities correspond to a similarity score with the input orientation in percent. Image dimensions are forced to the same values as the input. Its type is unsigned 8-bit integer.
    std::shared_ptr< iolink::ImageView > outputImage() const;
    /// Sets the outputImage parameter.
    /// The grayscale output image representing sticks oriented in the user-defined direction. Intensities correspond to a similarity score with the input orientation in percent. Image dimensions are forced to the same values as the input. Its type is unsigned 8-bit integer.
    void setOutputImage( std::shared_ptr< iolink::ImageView > outputImage );

    /// Gets the outputMeasurement parameter.
    /// The output measurement result for each block.
    LocalOrientation3dMsr::Ptr outputMeasurement() const;

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

    # Property of the inputImage parameter.
    OrientationMatchingFourier3d.input_image
    # Property of the blockSize parameter.
    OrientationMatchingFourier3d.block_size
    # Property of the blockOverlap parameter.
    OrientationMatchingFourier3d.block_overlap
    # Property of the minThreshold parameter.
    OrientationMatchingFourier3d.min_threshold
    # Property of the maxThreshold parameter.
    OrientationMatchingFourier3d.max_threshold
    # Property of the phiAngle parameter.
    OrientationMatchingFourier3d.phi_angle
    # Property of the thetaAngle parameter.
    OrientationMatchingFourier3d.theta_angle
    # Property of the outputImage parameter.
    OrientationMatchingFourier3d.output_image
    # Property of the outputMeasurement parameter.
    OrientationMatchingFourier3d.output_measurement

    // Method to launch the command.
    execute()

    // Command constructor.
    OrientationMatchingFourier3d()

    // Property of the inputImage parameter.
    OrientationMatchingFourier3d.inputImage
    // Property of the blockSize parameter.
    OrientationMatchingFourier3d.blockSize
    // Property of the blockOverlap parameter.
    OrientationMatchingFourier3d.blockOverlap
    // Property of the minThreshold parameter.
    OrientationMatchingFourier3d.minThreshold
    // Property of the maxThreshold parameter.
    OrientationMatchingFourier3d.maxThreshold
    // Property of the phiAngle parameter.
    OrientationMatchingFourier3d.phiAngle
    // Property of the thetaAngle parameter.
    OrientationMatchingFourier3d.thetaAngle
    // Property of the outputImage parameter.
    OrientationMatchingFourier3d.outputImage
    // Property of the outputMeasurement parameter.
    OrientationMatchingFourier3d.outputMeasurement

    // Method to launch the command.
    Execute()

## Parameters

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| inputImage | The grayscale input image. | Image | Grayscale | nullptr
| blockSize | The side size in pixels of the cubic blocks. | Int32 | >=1 | 64
| blockOverlap | The policy for splitting the image into blocks.
NO | The algorithm splits the image into contiguous blocks. The offset between two consecutive block origins is equal to the block size.
YES | The algorithm splits the image into overlapping blocks. The offset between two consecutive block origins is equal to the half of the block size.
| Enumeration |  | YES
| minThreshold | The minimum threshold value applied to the input grayscale image. Voxels having an intensity lower than this threshold are not considered by the algorithm. | Int32 | >=1 | 100
| maxThreshold | The maximum threshold value applied to the input grayscale image. Voxels having an intensity greater than this threshold are not considered by the algorithm. | Int32 | >=1 | 300
| phiAngle | The polar angle, in degrees, of the analysis orientation. | Float64 | Any value | 0
| thetaAngle | The azimuthal angle, in degrees, of the analysis orientation. | Float64 | Any value | 0
| outputImage | The grayscale output image representing sticks oriented in the user-defined direction. Intensities correspond to a similarity score with the input orientation in percent. Image dimensions are forced to the same values as the input. Its type is unsigned 8-bit integer. | Image |  | nullptr
| outputMeasurement | The output measurement result for each block. | LocalOrientation3dMsr |  | nullptr

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| input_image | The grayscale input image. | image | Grayscale | None
| block_size | The side size in pixels of the cubic blocks. | int32 | >=1 | 64
| block_overlap | The policy for splitting the image into blocks.
NO | The algorithm splits the image into contiguous blocks. The offset between two consecutive block origins is equal to the block size.
YES | The algorithm splits the image into overlapping blocks. The offset between two consecutive block origins is equal to the half of the block size.
| enumeration |  | YES
| min_threshold | The minimum threshold value applied to the input grayscale image. Voxels having an intensity lower than this threshold are not considered by the algorithm. | int32 | >=1 | 100
| max_threshold | The maximum threshold value applied to the input grayscale image. Voxels having an intensity greater than this threshold are not considered by the algorithm. | int32 | >=1 | 300
| phi_angle | The polar angle, in degrees, of the analysis orientation. | float64 | Any value | 0
| theta_angle | The azimuthal angle, in degrees, of the analysis orientation. | float64 | Any value | 0
| output_image | The grayscale output image representing sticks oriented in the user-defined direction. Intensities correspond to a similarity score with the input orientation in percent. Image dimensions are forced to the same values as the input. Its type is unsigned 8-bit integer. | image |  | None
| output_measurement | The output measurement result for each block. | LocalOrientation3dMsr |  | None

Parameter Name | Description | Type | Supported Values | Default Value
--- | --- | --- | --- | ---
| inputImage | The grayscale input image. | Image | Grayscale | null
| blockSize | The side size in pixels of the cubic blocks. | Int32 | >=1 | 64
| blockOverlap | The policy for splitting the image into blocks.
NO | The algorithm splits the image into contiguous blocks. The offset between two consecutive block origins is equal to the block size.
YES | The algorithm splits the image into overlapping blocks. The offset between two consecutive block origins is equal to the half of the block size.
| Enumeration |  | YES
| minThreshold | The minimum threshold value applied to the input grayscale image. Voxels having an intensity lower than this threshold are not considered by the algorithm. | Int32 | >=1 | 100
| maxThreshold | The maximum threshold value applied to the input grayscale image. Voxels having an intensity greater than this threshold are not considered by the algorithm. | Int32 | >=1 | 300
| phiAngle | The polar angle, in degrees, of the analysis orientation. | Float64 | Any value | 0
| thetaAngle | The azimuthal angle, in degrees, of the analysis orientation. | Float64 | Any value | 0
| outputImage | The grayscale output image representing sticks oriented in the user-defined direction. Intensities correspond to a similarity score with the input orientation in percent. Image dimensions are forced to the same values as the input. Its type is unsigned 8-bit integer. | Image |  | null
| outputMeasurement | The output measurement result for each block. | LocalOrientation3dMsr |  | null

## Object Examples

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

    OrientationMatchingFourier3d orientationMatchingFourier3dAlgo;
    orientationMatchingFourier3dAlgo.setInputImage( foam );
    orientationMatchingFourier3dAlgo.setBlockSize( 10 );
    orientationMatchingFourier3dAlgo.setBlockOverlap( OrientationMatchingFourier3d::BlockOverlap::YES );
    orientationMatchingFourier3dAlgo.setMinThreshold( 100 );
    orientationMatchingFourier3dAlgo.setMaxThreshold( 300 );
    orientationMatchingFourier3dAlgo.setPhiAngle( 0 );
    orientationMatchingFourier3dAlgo.setThetaAngle( 0 );
    orientationMatchingFourier3dAlgo.execute();

    std::cout << "outputImage:" << orientationMatchingFourier3dAlgo.outputImage()->toString();
    std::cout << "blockOriginX: " << orientationMatchingFourier3dAlgo.outputMeasurement()->blockOriginX( 0 ) ;

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

    orientation_matching_fourier_3d_algo = imagedev.OrientationMatchingFourier3d()
    orientation_matching_fourier_3d_algo.input_image = foam
    orientation_matching_fourier_3d_algo.block_size = 10
    orientation_matching_fourier_3d_algo.block_overlap = imagedev.OrientationMatchingFourier3d.YES
    orientation_matching_fourier_3d_algo.min_threshold = 100
    orientation_matching_fourier_3d_algo.max_threshold = 300
    orientation_matching_fourier_3d_algo.phi_angle = 0
    orientation_matching_fourier_3d_algo.theta_angle = 0
    orientation_matching_fourier_3d_algo.execute()

    print("output_image:", str(orientation_matching_fourier_3d_algo.output_image))
    print("blockOriginX: ", str(orientation_matching_fourier_3d_algo.output_measurement.block_origin_x(0)))

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

    OrientationMatchingFourier3d orientationMatchingFourier3dAlgo = new OrientationMatchingFourier3d
    {
        inputImage = foam,
        blockSize = 10,
        blockOverlap = OrientationMatchingFourier3d.BlockOverlap.YES,
        minThreshold = 100,
        maxThreshold = 300,
        phiAngle = 0,
        thetaAngle = 0
    };
    orientationMatchingFourier3dAlgo.Execute();

    Console.WriteLine( "outputImage:" + orientationMatchingFourier3dAlgo.outputImage.ToString() );
    Console.WriteLine( "blockOriginX: " + orientationMatchingFourier3dAlgo.outputMeasurement.blockOriginX( 0 ) );

## Function Examples

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

    auto result = orientationMatchingFourier3d( foam, 10, OrientationMatchingFourier3d::BlockOverlap::YES, 100, 300, 0, 0 );

    std::cout << "outputImage:" << result.outputImage->toString();
    std::cout << "blockOriginX: " << result.outputMeasurement->blockOriginX( 0 ) ;

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

    result_output_image, result_output_measurement = imagedev.orientation_matching_fourier_3d(foam, 10, imagedev.OrientationMatchingFourier3d.YES, 100, 300, 0, 0)

    print("output_image:", str(result_output_image))
    print("blockOriginX: ", str(result_output_measurement.block_origin_x(0)))

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

    Processing.OrientationMatchingFourier3dOutput result = Processing.OrientationMatchingFourier3d( foam, 10, OrientationMatchingFourier3d.BlockOverlap.YES, 100, 300, 0, 0 );

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

© 2025 Thermo Fisher Scientific Inc. All rights reserved.