Functions

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, hg_width=180, hg_height=2*rmax+1, where rmax is the image diagonal/2 (rmax = srqrt(width*width + height*height)).
The hough transform defines "cos(theta) * X + sin(theta) * Y = rho" and the parameters are in the interval:
theta = "0 .. 179", rho = "-hg_height/2 .. hg_height/2" .
Where rho is the perpendicular distance from the center of the image and theta the angle with the normal. So do not confuse theta with the line angle, they are perpendicular.
Returns zero if the counter aborted.
Inspired from ideas in XITE, Copyright 1991, Blab, UiO
http://www.ifi.uio.no/~blab/Software/Xite/

im.ProcessHoughLines(src_image: imImage, dst_image: imImage) -> counter: boolean [in Lua 5] 

im.ProcessHoughLinesNew(image: imImage) -> counter: boolean, new_image: imImage [in Lua 5] 

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.
If the hough transform is not NULL, then the hough points are filtered to include only lines that are significally different from each other.
The hough image is the hough transform image, but it is optional and can be NULL. If not NULL then it will be used to filter lines that are very similar.
The hough points image is a hough transform image that was thresholded to a IM_BINARY image, usually using a Local Max threshold operation (see imProcessLocalMaxThreshold). 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.

im.ProcessHoughLinesDraw(src_image: imImage, hough: imImage, hough_points: imImage, dst_image: imImage) -> lines: number [in Lua 5] 

im.ProcessHoughLinesDrawNew(image: imImage, hough: imImage, hough_points: imImage) -> lines: number, new_image: imImage [in Lua 5] 

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.

im.ProcessCrossCorrelation(src_image1: imImage, src_image2: imImage, dst_image: imImage) [in Lua 5] 

im.ProcessCrossCorrelationNew(image1: imImage, image2: imImage) -> new_image: imImage [in Lua 5] 

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.

im.ProcessAutoCorrelation(src_image: imImage, dst_image: imImage) [in Lua 5] 

im.ProcessAutoCorrelationNew(image: imImage) -> new_image: imImage [in Lua 5] 

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.

im.ProcessDistanceTransform(src_image: imImage, dst_image: imImage) [in Lua 5] 

im.ProcessDistanceTransformNew(image: imImage) -> new_image: imImage [in Lua 5] 

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.

im.ProcessRegionalMaximum(src_image: imImage, dst_image: imImage) [in Lua 5] 

im.ProcessRegionalMaximumNew(image: imImage) -> new_image: imImage [in Lua 5]