IM: Domain Transform Operations

IM - Imaging Libray

previous page next page

Domain Transform Operations
[Image Processing]

Detailed Description

FFT, Wavelts, Hough, Distance.
FFTW Copyright Matteo Frigo, Steven G. Johnson and the MIT.
http://www.fftw.org
See fftw.h or fftw3.h
Must link with "im_fftw.lib" for FFTW version 2.1.5, and "im_fftw3.lib" for version 3.0.1.
Both libraries are available because version 3 was not that fast from version 2, and its file size is 3x bigger than version 2. But version 3 was not compiled using hardware otimizations.
The FFTW lib has a GPL license. The license of the "im_fftw.lib" library is automatically the GPL. So you cannot use it for commercial applications without contacting the authors.
See im_process_glo.h


Functions

void imProcessFFT (const imImage *src_image, imImage *dst_image)
void imProcessIFFT (const imImage *src_image, imImage *dst_image)
void imProcessFFTraw (imImage *src_image, int inverse, int center, int normalize)
void imProcessSwapQuadrants (imImage *src_image, int center2origin)
int imProcessHoughLines (const imImage *src_image, imImage *dst_image)
int imProcessHoughLinesDraw (const imImage *src_image, const imImage *hough_points, imImage *dst_image)
void imProcessCrossCorrelation (const imImage *src_image1, const imImage *src_image2, imImage *dst_image)
void imProcessAutoCorrelation (const imImage *src_image, imImage *dst_image)
void imProcessDistanceTransform (const imImage *src_image, imImage *dst_image)
void imProcessRegionalMaximum (const imImage *src_image, imImage *dst_image)

Function Documentation

void imProcessFFT (  const imImage *  src_image,
imImage *  dst_image
) 
 

Forward FFT.
The result has its lowest frequency at the center of the image.
This is an unnormalized fft.
Images must be of the same size. Destiny image must be of type complex.

void imProcessIFFT (  const imImage *  src_image,
imImage *  dst_image
) 
 

Inverse FFT.
The image has its lowest frequency restored to the origin before the transform.
The result is normalized by (width*height).
Images must be of the same size and both must be of type complex.

void imProcessFFTraw (  imImage *  src_image,
int  inverse,
int  center,
int  normalize
) 
 

Raw in-place FFT (forward or inverse).
The lowest frequency can be centered after forward, or can be restored to the origin before inverse.
The result can be normalized after the transform by sqrt(w*h) [1] or by (w*h) [2], or left unnormalized [0].
Images must be of the same size and both must be of type complex.

void imProcessSwapQuadrants (  imImage *  src_image,
int  center2origin
) 
 

Auxiliary function for the raw FFT.
This is the function used internally to change the lowest frequency position in the image.
If the image size has even dimensions the flag "center2origin" is useless. But if it is odd, you must specify if its from center to origin (usually used before inverse) or from origin to center (usually used after forward).
Notice that this function is used for images in the the frequency domain.
Image type must be complex.

int imProcessHoughLines (  const imImage *  src_image,
imImage *  dst_image
) 
 

Hough Lines Transform.
It will detect white lines in a black background. So the source image must be a IM_BINARY image with the white lines of interest enhanced. The better the threshold with the white lines the better the line detection.
The destiny image must have IM_GRAY, IM_INT, width=180, height=2*rmax+1, where rmax is the image diagonal/2.
The houfh transform defines "cos(theta) * X + sin(theta) * Y = rho" and the parameters are in the interval:
theta = "0 .. 179", rho = "-height/2 .. height/2" .
Returns zero if the counter aborted.
Inspired from ideas in XITE, Copyright 1991, Blab, UiO
http://www.ifi.uio.no/~blab/Software/Xite/

int imProcessHoughLinesDraw (  const imImage *  src_image,
const imImage *  hough_points,
imImage *  dst_image
) 
 

Draw detected hough lines.
The source image must be IM_GRAY and IM_BYTE. The destiny image can be a clone of the source image or it can be the source image for in place processing.
The hough points image is a hough transform image that was thresholded to a IM_BINARY image, usually using a Local Max threshold operation. Again the better the threshold the better the results.
The destiny image will be set to IM_MAP, and the detected lines will be drawn using a red color.
Returns the number of detected lines.

void imProcessCrossCorrelation (  const imImage *  src_image1,
const imImage *  src_image2,
imImage *  dst_image
) 
 

Calculates the Cross Correlation in the frequency domain.
CrossCorr(a,b) = IFFT(Conj(FFT(a))*FFT(b))
Images must be of the same size and only destiny image must be of type complex.

void imProcessAutoCorrelation (  const imImage *  src_image,
imImage *  dst_image
) 
 

Calculates the Auto Correlation in the frequency domain.
Uses the cross correlation. Images must be of the same size and only destiny image must be of type complex.

void imProcessDistanceTransform (  const imImage *  src_image,
imImage *  dst_image
) 
 

Calculates the Distance Transform of a binary image using an aproximation of the euclidian distance.
Each white pixel in the binary image is assigned a value equal to its distance from the nearest black pixel.
Uses a two-pass algorithm incrementally calculating the distance.
Source image must be IM_BINARY, destiny must be IM_FLOAT.

void imProcessRegionalMaximum (  const imImage *  src_image,
imImage *  dst_image
) 
 

Marks all the regional maximum of the distance transform.
source is IMGRAY/IM_FLOAT destiny in IM_BINARY.
We consider maximum all connected pixel values that have smaller pixel values around it.


previous page start next page