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

# Frequency Domain

This group contains FFT's and related algorithms working in the frequency domain.

- ComplexFft: Computes the Fast Fourier Transform of an image.
- ComplexFftInverse: Computes the Fast Fourier inverse Transform of an image.
- ComplexCenteredFft: Computes the centered Fast Fourier Transform of an image.
- ComplexCenteredFftInverse: Computes the centered Fast Fourier inverse Transform of an image.
- CartesianToPolar2d: Transforms a pair of real and imaginary part two-dimensional images into a pair of module and phase images.
- PolarToCartesian2d: Transforms a pair of module and phase two-dimensional images into a pair of real and imaginary part images.
- ConvolutionWithImage: Performs a two or three-dimensional convolution between an input image $I$ and another image $K$ used as a convolution kernel.
- ConvolutionWithImage2d: Performs a two-dimensional convolution between an image and another image used as a convolution kernel.
- RadialFrequencyFilter2d: Filters a two-dimensional image by applying a radial background subtraction on the Fourier transform.
- GaborFiltering2d: Transforms a two-dimensional image thanks to Gabor filters, which are well known for localisation in frequency and space.

## Frequency Transforms

Frequency transforms are classical tools in signal processing where the measurement of spectra is used to characterize time-dependent processes such as speech patterns and radar or sonar data.
Some operations in image processing, such as noise detection and correction, are more effectively carried out in the frequency area. The Fourier transform expresses a function as a sum of sine and cosine components. In the Fast Fourier Transform (FFT) of a 2D (or 3D) image, there are two output images. The frequency information, or module, is stored in an image, while the phase information is stored in another.
The module, or frequency image, is a representation of the frequency of change in pixel values. This allows analysis and processing operations to be executed on the frequency component only.
The phase image contains information about the degree of change in pixel values and is used in combination with the module to reconstruct the image.
The Fourier transform itself is usually only an intermediate step. The algorithms that rely on the Fourier transform fall into three groups:

- Some operations involving periodicity, such as shifting, lineation or blurring, are better represented in the Fourier domain.
- Correlation, convolution, and many linear transformations are more efficiently implemented using the Fourier transform.
- When modified frequencies may be attributed to particular spatial phenomenon, such as noise or transitions, filtering operators or even direct cropping can be used to restore or enhance the image.

## Introduction to FFT

The FFT reduces the amount of computation to $N\times \log_2N$ operations instead of the $N^2$ operations involved in a normal Fourier transform.
For images, the classical method consists in computing 1-D FT's successively, since the Fourier transform is separable.
The Fourier transform is computed horizontally and then vertically on the intermediate result: $$ X(u,v)=\frac{1}{N}\sum_{k,l=0}^{N-1} x(k,l) \times e^{-\frac{2i\pi}{N}\times(uk+vl)} $$ $$ X(u,v)=\sum_{k,l} x(k,l) e^{-\frac{2i\pi}{N}\times uk} \times e^{-\frac{2i\pi}{N}\times lv} $$ $$ X(u,v)=\sum_{l} e^{-\frac{2i\pi}{N}\times lv} \left( \sum_{k} x(k,l) e^{-\frac{2i\pi} {N}\times ku} \right) = \sum_{l} e^{-\frac{2i\pi}{N}\times lv} K(u,l) $$ For an image of size $N \times N$, one computes the FT of each line to obtain the functions $K(u, l)$, and then the FT of the $K(u, l)$ along columns. In the discrete case, the Fourier transform of an image is a complex image with a real part and an imaginary part. We usually represent the modulus of the image, and sometimes its phase.
If $X(u, v)$ is the value of a pixel of the FT, we have $X(u,v)=R(u,v)+iI(u,v)$ where $R(u,v)$ is the real part and $I(u,v)$ the imaginary part.
The image of modulus, called the spectrum is defined as: $$ M(u,v) = \sqrt{R^2(u,v)+I^2(u,v)} $$ and the phase image as: $$ \Phi(u,v) = A\tan(\frac{I(u, v)}{R(u,v)}) $$ The Fourier transform may be written using an exponential notation: $$ X(u,v)=M(u,v) \times \exp(-2i\pi\Phi(u,v)) $$ The modulus is centered: the frequency (0,0) is placed at the center of the image. A negative frequency -u corresponds to the positive N-u frequency: $$ e^{-\frac{2i\pi(-u)k}{N}}=e^{-\frac{2i\pi(N-k)}{N}} $$ The modulus at point (0,0) is proportional to the mean of the image and has no significance from the frequency point of view. The transform usually has large values in the vicinity of the center and very low values elsewhere. This unequal dynamic distribution may make it necessary to transform the modulus to see it better. One must be careful that high values do not hide low ones.
Some suggest the use of the logarithm of the modulus for display; others, histogram equalization. It is also possible to stretch the histogram between two given bounds (including 95$\%$ of the pixels, for example), and clamp the values outside the range.

## Examples of Fourier Transforms

The modulus image has usually a rather isotropic central halo shape with a cross made of the central column and row. This image uniformity, except when particular structures are present, makes the modulus interpretation rather difficult, as shown in Figure 1.

Figure 1. An image and its Fourier transform modulus

### Impulse image

An impulse image is an image with zero values everywhere except for one location. The image is reduced to a single point:

- $ x(k_0, l_0) = a $
- $ x(k, l) = 0 $ everywhere else.

The discrete Fourier transform of a point is the complex constant: $$ X(u,v)=\frac{a}{N} \times e^{-\frac{2i\pi}{N}\times(uk_0+vl_0)} $$ $$ |X(u,v)|=\frac{|a|}{N} \times \left | e^{-\frac{2i\pi}{N}\times(uk_0+vl_0)} \right | = \frac{|a|}{N} $$ The modulus is constant and the spectrum is uniform.

### Constant image

For a constant image, for instance $x(k,l) = a$ for all k and l, the discrete Fourier transform is an image where only the frequency located at (0,0) in the Fourier space is non-zero: $$ X(u,v)=\frac{a}{N}\sum_{k,l=0}^{N-1} e^{-\frac{2i\pi}{N}\times(uk+vl)} $$ Thus: $$ \left\{\begin{array}{ll} X(0,0) = \frac{a}{N}\times N^2 \\ X(u,v) = \frac{a}{N} \times 0 = 0 & \mbox{elsewhere} \end{array}\right. $$

### Parallel lines

The function $cos(ux+vy)$ corresponds to waves perpendicular to the $(u,v)$ direction. The corresponding image looks like a succession of black and white stripes. The distance between two successive black (or white) strips is $ \sqrt{u^2+v^2}$.
The discrete Fourier transform is zero everywhere except at $(u, v)$ and $(-u, -v)$. Spectral analysis corresponds here to the intuitive notion that the Fourier transform of a base function of the Fourier space is reduced to a Dirac impulse function.
More generally, successive parallel lines of frequency $(u,v)$ have a Fourier transform with two peaks at location $(u,v)$ and $(-u,-v)$.
The peaks indicate the base frequency of the pattern. Real images rarely match a perfect model, but rather come close to a particular model that the Fourier transform can highlight.
Two possible reasons for deviation from a particular model are:

- If the pattern is not absolutely straight but exhibits a slight curving (such as fringes of interference for instance), peaks are not points anymore but are spread out over a surface whose spread and slant are related to the amount of curving in the lines.
- If the pattern is not really periodic or if it is noisy, a halo appears around the main frequency. The Fourier transform shows the general direction of the pattern, and sometimes its main frequency, which are not usually easy to determine on the spatial domain image.

### Periodic structures

The FFT can help to quantify a linear periodic structure. Figure 2 is an electron microscope view of fibers in a metal sample. The goal is to find their orientation and periodicity. The segments are not truly parallel, and the sections within the structure generate circular arcs around the base frequency in the Fourier spectrum image.

Figure 2. Periodic structure and its FFT modulus

### Edges or transitions

If an image contains an edge, or a transition along a line of orientation $ \theta $, its Fourier spectrum shows a line intersecting the center of the image with the orientation $ \theta + \pi /2 $, as in Figure 3. Along this line, the Fourier coefficients are larger than their neighbors.

Figure 3. Transition along a line
This explains the cross through the center of the Fourier spectrum. Since the image wraps around, the last and first columns, and the last and first lines are neighbors which may cause high-frequency artifacts to appear on the spectrum. These artifacts are absent if the values are not significantly different from the real transitions between rows or columns.

### Networks

In an image made up of cells or objects partitioning the image, as in Figure 4, the FFT illustrates the presence of a network. Two cells are at a mean distance equal to $d$. If the distribution is stationary (the density is constant in each subarea of the image, the cells have similar shapes) and isotropic (no privileged direction), the modulus of the Fourier transform is a bright ring centered in (0,0), of radius $N/d$ where $N$ is equal to the size of the image. The central cross is almost invisible in this case.

Figure 4. Networks or cell structures

### Shifting

Shifting can be detected between two similar and highly correlated images, translated one from the other by a vector $(a,b)$. This situation is frequent in the following situations:

- Motion study in a gas.
- Trajectory analysis.
- Remote sensing applications, where the two images are taken by two scanners slightly shifted.

The modulus of the difference of the Fourier transforms exhibits fringes, similar to interference fringes, in the directions $(a,b)$ and with a distance of: $$ \frac{N}{\sqrt{a^2+b^2}} $$ If sub-pixels shift, one must look at the difference of phase images. The shift appears as a plane whose equation is directly linked to the amount of the shift.

Figure 5. Gas image and its Fourier Transform

### Periodicity

Usually, periodicities stand out in the FFT. We already saw the case of parallel lines. More complex cases remain very close to that ideal situation.
For instance, considering the Fourier transform of an image of vertical parallel camshafts in Figure 6, the horizontal periodicity of the camshafts generates two peaks on the horizontal axis. The two symmetric peaks correspond to parallel and interrupted horizontal lines of the cams and spaced by an average distance of 21 pixels. For a 256x256 image, peaks are then at frequencies of $ \pm 256/21 = \pm 12$.
Other peaks are more difficult to interpret and result from periodic structures in the cams, in certain directions (vertical for example).

Figure 6. Camshafts and their FFT
© 2025 Thermo Fisher Scientific Inc. All rights reserved.