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

# OrientationMapFourier3d

Determines a block-wise orientation of structures contained in a three-dimensional grayscale image.
Access to parameter description
For an introduction:

- section Image Analysis
- section Moment And Orientation

This algorithm computes local orientation of structures contained in a 3D input image. This is done using principal component analysis techniques. In particular, it estimates the main local orientation.
The image is first divided into blocks of a user-defined size. The blocks may overlap. Then the Fourier transform is computed on each block to extract the amplitude.
The covariance matrix is computed on each Fourier transformed blocks. The matrix is symmetric, thus, the Jacobi iterative method can be used to extract the eigenvalues and the eigenvectors. $$ M= \left[ \begin{array}{ccc}; M_{2x} & M_{2xy} & M_{2xz}\\ M_{2xy} & M_{2y} & M_{2yz}\\ M_{2xz} & M_{2yz} & M_{2z}\end{array}\right] $$ The main structure orientation is given by the eigenvector associated with the lowest eigenvalue. The confidence $C$ of the estimated main orientation is calculated as follows: $$ C=\frac{\lambda_1+\lambda_2-\lambda_3}{\lambda_1+\lambda_2+\lambda_3}$$ with $\lambda_1$ being the first eigenvalue (i.e., the maximum of eigenvalues), $\lambda_2$ being the second and $\lambda_3$ the third (the minimum of eigenvalues).
With this formula, the confidence is between 0.33 and 1, then, a normalization adapts the range between 0 and 1. This algorithm does not compute local orientation in a block in two cases:

- Density of structures is lower than 5
- Center of inertia is too far from the center of the block (for instance, the block is on a border of the object).

Finally, this algorithm provides two outputs:

- An image that, for each block, shows the detected structure orientation with an intensity equal to the confidence multiplied by 100
- A measurement object that, for each block, provides all computed features (orientation, confidence, moments, eigenvalues, ...)

Figure 1. Local orientation map of a 3D image with a rainbow LUT (red for high confidence)
See also

- MomentsOfInertia3d
- Eccentricity2d
- OrientationMatchingFourier3d

##
Function Syntax

This function returns a OrientationMapFourier3dOutput structure containing outputImage and outputMeasurement.

    // Output structure of the orientationMapFourier3d function.
    struct OrientationMapFourier3dOutput
    {
        /// The grayscale output image representing the oriented sticks computed in each block. Intensities correspond to the confidence of the estimated orientation multplied by 100. 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
    OrientationMapFourier3dOutput
    orientationMapFourier3d( std::shared_ptr< iolink::ImageView > inputImage,
                             int32_t blockSize,
                             OrientationMapFourier3d::BlockOverlap blockOverlap,
                             int32_t minThreshold,
                             int32_t maxThreshold,
                             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_map_fourier_3d(input_image: idt.ImageType,
                               block_size: int = 64,
                               block_overlap: OrientationMapFourier3d.BlockOverlap = OrientationMapFourier3d.BlockOverlap.YES,
                               min_threshold: int = 100,
                               max_threshold: int = 200,
                               output_image: idt.ImageType = None,
                               output_measurement: Union[Any, None] = None) -> Tuple[idt.ImageType, LocalOrientation3dMsr]

This function returns a OrientationMapFourier3dOutput structure containing outputImage and outputMeasurement.

    /// Output structure of the OrientationMapFourier3d function.
    public struct OrientationMapFourier3dOutput
    {
        ///
        /// The grayscale output image representing the oriented sticks computed in each block. Intensities correspond to the confidence of the estimated orientation multplied by 100. 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 OrientationMapFourier3dOutput
    OrientationMapFourier3d( IOLink.ImageView inputImage,
                             Int32 blockSize = 64,
                             OrientationMapFourier3d.BlockOverlap blockOverlap = ImageDev.OrientationMapFourier3d.BlockOverlap.YES,
                             Int32 minThreshold = 100,
                             Int32 maxThreshold = 200,
                             IOLink.ImageView outputImage = null,
                             LocalOrientation3dMsr outputMeasurement = null );

##
Class Syntax

    // Command constructor.
    OrientationMapFourier3d();

    /// 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.
    OrientationMapFourier3d::BlockOverlap blockOverlap() const;
    /// Sets the blockOverlap parameter.
    /// The policy for splitting the image into blocks.
    void setBlockOverlap( const OrientationMapFourier3d::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 outputImage parameter.
    /// The grayscale output image representing the oriented sticks computed in each block. Intensities correspond to the confidence of the estimated orientation multplied by 100. 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 the oriented sticks computed in each block. Intensities correspond to the confidence of the estimated orientation multplied by 100. 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.
    OrientationMapFourier3d.input_image
    # Property of the blockSize parameter.
    OrientationMapFourier3d.block_size
    # Property of the blockOverlap parameter.
    OrientationMapFourier3d.block_overlap
    # Property of the minThreshold parameter.
    OrientationMapFourier3d.min_threshold
    # Property of the maxThreshold parameter.
    OrientationMapFourier3d.max_threshold
    # Property of the outputImage parameter.
    OrientationMapFourier3d.output_image
    # Property of the outputMeasurement parameter.
    OrientationMapFourier3d.output_measurement

    // Method to launch the command.
    execute()

    // Command constructor.
    OrientationMapFourier3d()

    // Property of the inputImage parameter.
    OrientationMapFourier3d.inputImage
    // Property of the blockSize parameter.
    OrientationMapFourier3d.blockSize
    // Property of the blockOverlap parameter.
    OrientationMapFourier3d.blockOverlap
    // Property of the minThreshold parameter.
    OrientationMapFourier3d.minThreshold
    // Property of the maxThreshold parameter.
    OrientationMapFourier3d.maxThreshold
    // Property of the outputImage parameter.
    OrientationMapFourier3d.outputImage
    // Property of the outputMeasurement parameter.
    OrientationMapFourier3d.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 | 200
| outputImage | The grayscale output image representing the oriented sticks computed in each block. Intensities correspond to the confidence of the estimated orientation multplied by 100. 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 | 200
| output_image | The grayscale output image representing the oriented sticks computed in each block. Intensities correspond to the confidence of the estimated orientation multplied by 100. 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 | 200
| outputImage | The grayscale output image representing the oriented sticks computed in each block. Intensities correspond to the confidence of the estimated orientation multplied by 100. 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" );

    OrientationMapFourier3d orientationMapFourier3dAlgo;
    orientationMapFourier3dAlgo.setInputImage( foam );
    orientationMapFourier3dAlgo.setBlockSize( 10 );
    orientationMapFourier3dAlgo.setBlockOverlap( OrientationMapFourier3d::BlockOverlap::YES );
    orientationMapFourier3dAlgo.setMinThreshold( 100 );
    orientationMapFourier3dAlgo.setMaxThreshold( 200 );
    orientationMapFourier3dAlgo.execute();

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

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

    orientation_map_fourier_3d_algo = imagedev.OrientationMapFourier3d()
    orientation_map_fourier_3d_algo.input_image = foam
    orientation_map_fourier_3d_algo.block_size = 10
    orientation_map_fourier_3d_algo.block_overlap = imagedev.OrientationMapFourier3d.YES
    orientation_map_fourier_3d_algo.min_threshold = 100
    orientation_map_fourier_3d_algo.max_threshold = 200
    orientation_map_fourier_3d_algo.execute()

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

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

    OrientationMapFourier3d orientationMapFourier3dAlgo = new OrientationMapFourier3d
    {
        inputImage = foam,
        blockSize = 10,
        blockOverlap = OrientationMapFourier3d.BlockOverlap.YES,
        minThreshold = 100,
        maxThreshold = 200
    };
    orientationMapFourier3dAlgo.Execute();

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

## Function Examples

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

    auto result = orientationMapFourier3d( foam, 10, OrientationMapFourier3d::BlockOverlap::YES, 100, 200 );

    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_map_fourier_3d(foam, 10, imagedev.OrientationMapFourier3d.YES, 100, 200)

    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.OrientationMapFourier3dOutput result = Processing.OrientationMapFourier3d( foam, 10, OrientationMapFourier3d.BlockOverlap.YES, 100, 200 );

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

© 2025 Thermo Fisher Scientific Inc. All rights reserved.