1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
|
/** \file
* \brief Image Processing - Global Operations
*
* See Copyright Notice in im_lib.h
*/
#ifndef __IM_PROCESS_GLO_H
#define __IM_PROCESS_GLO_H
#include "im_image.h"
#if defined(__cplusplus)
extern "C" {
#endif
/** \defgroup transform Other Domain Transform Operations
* \par
* Hough, Distance.
*
* See \ref im_process_glo.h
* \ingroup process */
/** Hough Lines Transform. \n
* 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. \n
* 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)). \n
* The hough transform defines "cos(theta) * X + sin(theta) * Y = rho" and the parameters are in the interval: \n
* theta = "0 .. 179", rho = "-hg_height/2 .. hg_height/2" .\n
* 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. \n
* Returns zero if the counter aborted. \n
* Inspired from ideas in XITE, Copyright 1991, Blab, UiO \n
* http://www.ifi.uio.no/~blab/Software/Xite/
*
* \verbatim im.ProcessHoughLines(src_image: imImage, dst_image: imImage) -> counter: boolean [in Lua 5] \endverbatim
* \verbatim im.ProcessHoughLinesNew(image: imImage) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim
* \ingroup transform */
int imProcessHoughLines(const imImage* src_image, imImage* dst_image);
/** Draw detected hough lines. \n
* 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. \n
* If the hough transform is not NULL, then the hough points are filtered to include only lines
* that are significally different from each other. \n
* 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. \n
* 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 \ref imProcessLocalMaxThreshold). Again the better the threshold the better the results. \n
* The destiny image will be set to IM_MAP, and the detected lines will be drawn using a red color. \n
* Returns the number of detected lines.
*
* \verbatim im.ProcessHoughLinesDraw(src_image: imImage, hough: imImage, hough_points: imImage, dst_image: imImage) -> lines: number [in Lua 5] \endverbatim
* \verbatim im.ProcessHoughLinesDrawNew(image: imImage, hough: imImage, hough_points: imImage) -> lines: number, new_image: imImage [in Lua 5] \endverbatim
* \ingroup transform */
int imProcessHoughLinesDraw(const imImage* src_image, const imImage* hough, const imImage* hough_points, imImage* dst_image);
/** Calculates the Cross Correlation in the frequency domain. \n
* CrossCorr(a,b) = IFFT(Conj(FFT(a))*FFT(b)) \n
* Images must be of the same size and only destiny image must be of type complex.
*
* \verbatim im.ProcessCrossCorrelation(src_image1: imImage, src_image2: imImage, dst_image: imImage) [in Lua 5] \endverbatim
* \verbatim im.ProcessCrossCorrelationNew(image1: imImage, image2: imImage) -> new_image: imImage [in Lua 5] \endverbatim
* \ingroup transform */
void imProcessCrossCorrelation(const imImage* src_image1, const imImage* src_image2, imImage* dst_image);
/** Calculates the Auto Correlation in the frequency domain. \n
* Uses the cross correlation.
* Images must be of the same size and only destiny image must be of type complex.
*
* \verbatim im.ProcessAutoCorrelation(src_image: imImage, dst_image: imImage) [in Lua 5] \endverbatim
* \verbatim im.ProcessAutoCorrelationNew(image: imImage) -> new_image: imImage [in Lua 5] \endverbatim
* \ingroup transform */
void imProcessAutoCorrelation(const imImage* src_image, imImage* dst_image);
/** Calculates the Distance Transform of a binary image
* using an aproximation of the euclidian distance.\n
* Each white pixel in the binary image is
* assigned a value equal to its distance from the nearest
* black pixel. \n
* Uses a two-pass algorithm incrementally calculating the distance. \n
* Source image must be IM_BINARY, destiny must be IM_FLOAT.
*
* \verbatim im.ProcessDistanceTransform(src_image: imImage, dst_image: imImage) [in Lua 5] \endverbatim
* \verbatim im.ProcessDistanceTransformNew(image: imImage) -> new_image: imImage [in Lua 5] \endverbatim
* \ingroup transform */
void imProcessDistanceTransform(const imImage* src_image, imImage* dst_image);
/** Marks all the regional maximum of the distance transform. \n
* source is IMGRAY/IM_FLOAT destiny in IM_BINARY. \n
* We consider maximum all connected pixel values that have smaller pixel values around it.
*
* \verbatim im.ProcessRegionalMaximum(src_image: imImage, dst_image: imImage) [in Lua 5] \endverbatim
* \verbatim im.ProcessRegionalMaximumNew(image: imImage) -> new_image: imImage [in Lua 5] \endverbatim
* \ingroup transform */
void imProcessRegionalMaximum(const imImage* src_image, imImage* dst_image);
/** \defgroup fourier Fourier Transform Operations
* \par
* All Fourier transforms use FFTW library. \n
* The pre-compiled binaries for FFTW version 2.1.5 includes all the necessary files.
* The pre-compiled binaries for FFTW version 3.x depends on an external library, not provided.
* To build the code that uses FFTW version 3 you must define USE_FFTW3.
* \par
* FFTW Copyright Matteo Frigo, Steven G. Johnson and the MIT. \n
* http://www.fftw.org \n
* See "fftw.h"
* \par
* Must link with "im_fftw" library. \n
* \par
* IMPORTANT: The FFTW lib has a GPL license. The license of the "im_fftw" library is automatically the GPL.
* So you cannot use it for commercial applications without contacting the authors.
* \par
* See \ref im_process_glo.h
* \ingroup process */
/** Forward FFT. \n
* The result has its lowest frequency at the center of the image. \n
* This is an unnormalized fft. \n
* Images must be of the same size. Destiny image must be of type complex.
*
* \verbatim im.ProcessFFT(src_image: imImage, dst_image: imImage) [in Lua 5] \endverbatim
* \verbatim im.ProcessFFTNew(image: imImage) -> new_image: imImage [in Lua 5] \endverbatim
* \ingroup fourier */
void imProcessFFT(const imImage* src_image, imImage* dst_image);
/** Inverse FFT. \n
* The image has its lowest frequency restored to the origin before the transform. \n
* The result is normalized by (width*height). \n
* Images must be of the same size and both must be of type complex.
*
* \verbatim im.ProcessIFFT(src_image: imImage, dst_image: imImage) [in Lua 5] \endverbatim
* \verbatim im.ProcessIFFTNew(image: imImage) -> new_image: imImage [in Lua 5] \endverbatim
* \ingroup fourier */
void imProcessIFFT(const imImage* src_image, imImage* dst_image);
/** Raw in-place FFT (forward or inverse). \n
* The lowest frequency can be centered after forward, or
* can be restored to the origin before inverse. \n
* The result can be normalized after the transform by sqrt(w*h) [1] or by (w*h) [2],
* or left unnormalized [0]. \n
* Images must be of the same size and both must be of type complex.
*
* \verbatim im.ProcessFFTraw(image: imImage, inverse: number, center: number, normalize: number) [in Lua 5] \endverbatim
* \ingroup fourier */
void imProcessFFTraw(imImage* image, int inverse, int center, int normalize);
/** Auxiliary function for the raw FFT. \n
* This is the function used internally to change the lowest frequency position in the image. \n
* 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). \n
* Notice that this function is used for images in the the frequency domain. \n
* Image type must be complex.
*
* \verbatim im.ProcessSwapQuadrants(image: imImage, center2origin: number) [in Lua 5] \endverbatim
* \ingroup fourier */
void imProcessSwapQuadrants(imImage* image, int center2origin);
#if defined(__cplusplus)
}
#endif
#endif
|
