00001 /** \file 00002 * \brief Image Processing - Local Operations 00003 * 00004 * See Copyright Notice in im_lib.h 00005 */ 00006 00007 #ifndef __IM_PROCESS_LOC_H 00008 #define __IM_PROCESS_LOC_H 00009 00010 #include "im_image.h" 00011 00012 #if defined(__cplusplus) 00013 extern "C" { 00014 #endif 00015 00016 00017 00018 /** \defgroup resize Image Resize 00019 * \par 00020 * Operations to change the image size. 00021 * \par 00022 * See \ref im_process_loc.h 00023 * \ingroup process */ 00024 00025 /** Only reduze the image size using the given decimation order. \n 00026 * Supported decimation orders: 00027 * \li 0 - zero order (mean) 00028 * \li 1 - first order (bilinear decimation) 00029 * Images must be of the same type. If image type is IM_MAP or IM_BINARY, must use order=0. \n 00030 * Returns zero if the counter aborted. 00031 * 00032 * \verbatim im.ProcessReduce(src_image: imImage, dst_image: imImage, order: number) -> counter: boolean [in Lua 5] \endverbatim 00033 * \verbatim im.ProcessReduceNew(image: imImage, order: number) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim 00034 * \ingroup resize */ 00035 int imProcessReduce(const imImage* src_image, imImage* dst_image, int order); 00036 00037 /** Change the image size using the given interpolation order. \n 00038 * Supported interpolation orders: 00039 * \li 0 - zero order (near neighborhood) 00040 * \li 1 - first order (bilinear interpolation) 00041 * \li 3 - third order (bicubic interpolation) 00042 * Images must be of the same type. If image type is IM_MAP or IM_BINARY, must use order=0. \n 00043 * Returns zero if the counter aborted. 00044 * 00045 * \verbatim im.ProcessResize(src_image: imImage, dst_image: imImage, order: number) -> counter: boolean [in Lua 5] \endverbatim 00046 * \verbatim im.ProcessResizeNew(image: imImage, order: number) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim 00047 * \ingroup resize */ 00048 int imProcessResize(const imImage* src_image, imImage* dst_image, int order); 00049 00050 /** Reduze the image area by 4 (w/2,h/2). \n 00051 * Images must be of the same type. Destiny image size must be source image width/2, height/2. 00052 * Can not operate on IM_MAP nor IM_BINARY images. 00053 * 00054 * \verbatim im.ProcessReduceBy4(src_image: imImage, dst_image: imImage) [in Lua 5] \endverbatim 00055 * \verbatim im.ProcessReduceBy4New(image: imImage) -> new_image: imImage [in Lua 5] \endverbatim 00056 * \ingroup resize */ 00057 void imProcessReduceBy4(const imImage* src_image, imImage* dst_image); 00058 00059 /** Extract a rectangular region from an image. \n 00060 * Images must be of the same type. Destiny image size must be smaller than source image width-xmin, height-ymin. \n 00061 * ymin and xmin must be >0 and <size. 00062 * 00063 * \verbatim im.ProcessCrop(src_image: imImage, dst_image: imImage, xmin: number, ymin: number) [in Lua 5] \endverbatim 00064 * \verbatim im.ProcessCropNew(image: imImage, xmin: number, xmax: number, ymin: number, ymax: number) -> new_image: imImage [in Lua 5] \endverbatim 00065 * \ingroup resize */ 00066 void imProcessCrop(const imImage* src_image, imImage* dst_image, int xmin, int ymin); 00067 00068 /** Insert a rectangular region in an image. \n 00069 * Images must be of the same type. Region image size can be larger than source image. \n 00070 * ymin and xmin must be >0 and <size. \n 00071 * Source and destiny must be of the same size. Can be done in place. 00072 * 00073 * \verbatim im.ProcessInsert(src_image: imImage, region_image: imImage, dst_image: imImage, xmin: number, ymin: number) [in Lua 5] \endverbatim 00074 * \verbatim im.ProcessInsertNew(image: imImage, region_image: imImage, xmin: number, ymin: number) -> new_image: imImage [in Lua 5] \endverbatim 00075 * \ingroup resize */ 00076 void imProcessInsert(const imImage* src_image, const imImage* region_image, imImage* dst_image, int xmin, int ymin); 00077 00078 /** Increase the image size by adding pixels with zero value. \n 00079 * Images must be of the same type. Destiny image size must be greatter than source image width+xmin, height+ymin. 00080 * 00081 * \verbatim im.ProcessAddMargins(src_image: imImage, dst_image: imImage, xmin: number, ymin: number) [in Lua 5] \endverbatim 00082 * \verbatim im.ProcessAddMarginsNew(image: imImage, xmin: number, xmax: number, ymin: number, ymax: number) -> new_image: imImage [in Lua 5] \endverbatim 00083 * \ingroup resize */ 00084 void imProcessAddMargins(const imImage* src_image, imImage* dst_image, int xmin, int ymin); 00085 00086 00087 00088 /** \defgroup geom Geometric Operations 00089 * \par 00090 * Operations to change the shape of the image. 00091 * \par 00092 * See \ref im_process_loc.h 00093 * \ingroup process */ 00094 00095 /** Calculates the size of the new image after rotation. 00096 * 00097 * \verbatim im.ProcessCalcRotateSize(width: number, height: number, cos0: number, sin0: number) [in Lua 5] \endverbatim 00098 * \ingroup geom */ 00099 void imProcessCalcRotateSize(int width, int height, int *new_width, int *new_height, double cos0, double sin0); 00100 00101 /** Rotates the image using the given interpolation order (see \ref imProcessResize). \n 00102 * Images must be of the same type. The destiny size can be calculated using \ref imProcessCalcRotateSize to fit the new image size, 00103 * or can be any size, including the original size. The rotation is relative to the center of the image. \n 00104 * Returns zero if the counter aborted. 00105 * 00106 * \verbatim im.ProcessRotate(src_image: imImage, dst_image: imImage, cos0: number, sin0: number, order: number) -> counter: boolean [in Lua 5] \endverbatim 00107 * \verbatim im.ProcessRotateNew(image: imImage, cos0: number, sin0: number, order: number) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim 00108 * \ingroup geom */ 00109 int imProcessRotate(const imImage* src_image, imImage* dst_image, double cos0, double sin0, int order); 00110 00111 /** Rotates the image using the given interpolation order (see \ref imProcessResize). \n 00112 * Images must be of the same type. Destiny can have any size, including the original size. \n 00113 * The rotation is relative to the reference point. But the result can be shifted to the origin. \n 00114 * Returns zero if the counter aborted. 00115 * 00116 * \verbatim im.ProcessRotateRef(src_image: imImage, dst_image: imImage, cos0: number, sin0: number, x: number, y: number, to_origin: boolean, order: number) -> counter: boolean [in Lua 5] \endverbatim 00117 * \verbatim im.ProcessRotateRefNew(image: imImage, cos0: number, sin0: number, x: number, y: number, to_origin: boolean, order: number) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim 00118 * \ingroup geom */ 00119 int imProcessRotateRef(const imImage* src_image, imImage* dst_image, double cos0, double sin0, int x, int y, int to_origin, int order); 00120 00121 /** Rotates the image in 90 degrees counterclockwise or clockwise. Swap columns by lines. \n 00122 * Images must be of the same type. Destiny width and height must be source height and width. \n 00123 * Direction can be clockwise (1) or counter clockwise (-1). 00124 * 00125 * \verbatim im.ProcessRotate90(src_image: imImage, dst_image: imImage, dir_clockwise: boolean) [in Lua 5] \endverbatim 00126 * \verbatim im.ProcessRotate90New(image: imImage, dir_clockwise: boolean) -> new_image: imImage [in Lua 5] \endverbatim 00127 * \ingroup geom */ 00128 void imProcessRotate90(const imImage* src_image, imImage* dst_image, int dir_clockwise); 00129 00130 /** Rotates the image in 180 degrees. Swap columns and swap lines. \n 00131 * Images must be of the same type and size. 00132 * 00133 * \verbatim im.ProcessRotate180(src_image: imImage, dst_image: imImage) [in Lua 5] \endverbatim 00134 * \verbatim im.ProcessRotate180New(image: imImage) -> new_image: imImage [in Lua 5] \endverbatim 00135 * \ingroup geom */ 00136 void imProcessRotate180(const imImage* src_image, imImage* dst_image); 00137 00138 /** Mirror the image in a horizontal flip. Swap columns. \n 00139 * Images must be of the same type and size. 00140 * Can be done in-place. 00141 * 00142 * \verbatim im.ProcessMirror(src_image: imImage, dst_image: imImage) [in Lua 5] \endverbatim 00143 * \verbatim im.ProcessMirrorNew(image: imImage) -> new_image: imImage [in Lua 5] \endverbatim 00144 * \ingroup geom */ 00145 void imProcessMirror(const imImage* src_image, imImage* dst_image); 00146 00147 /** Apply a vertical flip. Swap lines. \n 00148 * Images must be of the same type and size. 00149 * Can be done in-place. 00150 * 00151 * \verbatim im.ProcessFlip(src_image: imImage, dst_image: imImage) [in Lua 5] \endverbatim 00152 * \verbatim im.ProcessFlipNew(image: imImage) -> new_image: imImage [in Lua 5] \endverbatim 00153 * \ingroup geom */ 00154 void imProcessFlip(const imImage* src_image, imImage* dst_image); 00155 00156 /** Apply a radial distortion using the given interpolation order (see imProcessResize). \n 00157 * Images must be of the same type and size. Returns zero if the counter aborted. 00158 * 00159 * \verbatim im.ProcessRadial(src_image: imImage, dst_image: imImage, k1: number, order: number) -> counter: boolean [in Lua 5] \endverbatim 00160 * \verbatim im.ProcessRadialNew(image: imImage, k1: number, order: number) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim 00161 * \ingroup geom */ 00162 int imProcessRadial(const imImage* src_image, imImage* dst_image, float k1, int order); 00163 00164 /** Apply a swirl distortion using the given interpolation order (see imProcessResize). \n 00165 * Images must be of the same type and size. Returns zero if the counter aborted. 00166 * 00167 * \verbatim im.ProcessSwirl(src_image: imImage, dst_image: imImage, k: number, order: number) -> counter: boolean [in Lua 5] \endverbatim 00168 * \verbatim im.ProcessSwirlNew(image: imImage, k: number, order: number) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim 00169 * \ingroup geom */ 00170 int imProcessSwirl(const imImage* src_image, imImage* dst_image, float k1, int order); 00171 00172 /** Split the image in two images, one containing the odd lines and other containing the even lines. \n 00173 * Images must be of the same type. Height of the output images must be half the height of the input image. 00174 * If the height of the input image is odd then the first image must have height equals to half+1. 00175 * 00176 * \verbatim im.ProcessInterlaceSplit(src_image: imImage, dst_image1: imImage, dst_image2: imImage) [in Lua 5] \endverbatim 00177 * \verbatim im.ProcessInterlaceSplitNew(image: imImage) -> new_image1: imImage, new_image2: imImage [in Lua 5] \endverbatim 00178 * \ingroup geom */ 00179 void imProcessInterlaceSplit(const imImage* src_image, imImage* dst_image1, imImage* dst_image2); 00180 00181 00182 00183 /** \defgroup morphgray Morphology Operations for Gray Images 00184 * \par 00185 * See \ref im_process_loc.h 00186 * \ingroup process */ 00187 00188 /** Base gray morphology convolution. \n 00189 * Supports all data types except IM_CFLOAT. Can be applied on color images. \n 00190 * Kernel is always IM_INT. Use kernel size odd for better results. \n 00191 * Use -1 for don't care positions in kernel. Kernel values are added to image values, then \n 00192 * you can use the maximum or the minimum within the kernel area. \n 00193 * No border extensions are used. 00194 * All the gray morphology operations use this function. \n 00195 * If the kernel image attribute "Description" exists it is used by the counter. 00196 * 00197 * \verbatim im.ProcessGrayMorphConvolve(src_image: imImage, dst_image: imImage, kernel: imImage, ismax: boolean) -> counter: boolean [in Lua 5] \endverbatim 00198 * \verbatim im.ProcessGrayMorphConvolveNew(image: imImage, kernel: imImage, ismax: boolean) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim 00199 * \ingroup morphgray */ 00200 int imProcessGrayMorphConvolve(const imImage* src_image, imImage* dst_image, const imImage* kernel, int ismax); 00201 00202 /** Gray morphology convolution with a kernel full of "0"s and use minimum value. 00203 * 00204 * \verbatim im.ProcessGrayMorphErode(src_image: imImage, dst_image: imImage, kernel_size: number) -> counter: boolean [in Lua 5] \endverbatim 00205 * \verbatim im.ProcessGrayMorphErodeNew(image: imImage, kernel_size: number) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim 00206 * \ingroup morphgray */ 00207 int imProcessGrayMorphErode(const imImage* src_image, imImage* dst_image, int kernel_size); 00208 00209 /** Gray morphology convolution with a kernel full of "0"s and use maximum value. 00210 * 00211 * \verbatim im.ProcessGrayMorphDilate(src_image: imImage, dst_image: imImage, kernel_size: number) -> counter: boolean [in Lua 5] \endverbatim 00212 * \verbatim im.ProcessGrayMorphDilateNew(image: imImage, kernel_size: number) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim 00213 * \ingroup morphgray */ 00214 int imProcessGrayMorphDilate(const imImage* src_image, imImage* dst_image, int kernel_size); 00215 00216 /** Erode+Dilate. 00217 * 00218 * \verbatim im.ProcessGrayMorphOpen(src_image: imImage, dst_image: imImage, kernel_size: number) -> counter: boolean [in Lua 5] \endverbatim 00219 * \verbatim im.ProcessGrayMorphOpenNew(image: imImage, kernel_size: number) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim 00220 * \ingroup morphgray */ 00221 int imProcessGrayMorphOpen(const imImage* src_image, imImage* dst_image, int kernel_size); 00222 00223 /** Dilate+Erode. 00224 * 00225 * \verbatim im.ProcessGrayMorphClose(src_image: imImage, dst_image: imImage, kernel_size: number) -> counter: boolean [in Lua 5] \endverbatim 00226 * \verbatim im.ProcessGrayMorphCloseNew(image: imImage, kernel_size: number) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim 00227 * \ingroup morphgray */ 00228 int imProcessGrayMorphClose(const imImage* src_image, imImage* dst_image, int kernel_size); 00229 00230 /** Open+Difference. 00231 * 00232 * \verbatim im.ProcessGrayMorphTopHat(src_image: imImage, dst_image: imImage, kernel_size: number) -> counter: boolean [in Lua 5] \endverbatim 00233 * \verbatim im.ProcessGrayMorphTopHatNew(image: imImage, kernel_size: number) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim 00234 * \ingroup morphgray */ 00235 int imProcessGrayMorphTopHat(const imImage* src_image, imImage* dst_image, int kernel_size); 00236 00237 /** Close+Difference. 00238 * 00239 * \verbatim im.ProcessGrayMorphWell(src_image: imImage, dst_image: imImage, kernel_size: number) -> counter: boolean [in Lua 5] \endverbatim 00240 * \verbatim im.ProcessGrayMorphWellNew(image: imImage, kernel_size: number) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim 00241 * \ingroup morphgray */ 00242 int imProcessGrayMorphWell(const imImage* src_image, imImage* dst_image, int kernel_size); 00243 00244 /** Difference(Erode, Dilate). 00245 * 00246 * \verbatim im.ProcessGrayMorphGradient(src_image: imImage, dst_image: imImage, kernel_size: number) -> counter: boolean [in Lua 5] \endverbatim 00247 * \verbatim im.ProcessGrayMorphGradientNew(image: imImage, kernel_size: number) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim 00248 * \ingroup morphgray */ 00249 int imProcessGrayMorphGradient(const imImage* src_image, imImage* dst_image, int kernel_size); 00250 00251 00252 00253 /** \defgroup morphbin Morphology Operations for Binary Images 00254 * \par 00255 * See \ref im_process_loc.h 00256 * \ingroup process */ 00257 00258 /** Base binary morphology convolution. \n 00259 * Images are all IM_BINARY. Kernel is IM_INT, but values can be only 1, 0 or -1. Use kernel size odd for better results. \n 00260 * Hit white means hit=1 and miss=0, or else hit=0 and miss=1. \n 00261 * Use -1 for don't care positions in kernel. Kernel values are simply compared with image values. \n 00262 * The operation can be repeated by a number of iterations. 00263 * The border is zero extended. \n 00264 * Almost all the binary morphology operations use this function.\n 00265 * If the kernel image attribute "Description" exists it is used by the counter. 00266 * 00267 * \verbatim im.ProcessBinMorphConvolve(src_image: imImage, dst_image: imImage, kernel: imImage, hit_white: boolean, iter: number) -> counter: boolean [in Lua 5] \endverbatim 00268 * \verbatim im.ProcessBinMorphConvolveNew(image: imImage, kernel: imImage, hit_white: boolean, iter: number) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim 00269 * \ingroup morphbin */ 00270 int imProcessBinMorphConvolve(const imImage* src_image, imImage* dst_image, const imImage* kernel, int hit_white, int iter); 00271 00272 /** Binary morphology convolution with a kernel full of "1"s and hit white. 00273 * 00274 * \verbatim im.ProcessBinMorphErode(src_image: imImage, dst_image: imImage, kernel_size: number, iter: number) -> counter: boolean [in Lua 5] \endverbatim 00275 * \verbatim im.ProcessBinMorphErodeNew(image: imImage, kernel_size: number, iter: number) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim 00276 * \ingroup morphbin */ 00277 int imProcessBinMorphErode(const imImage* src_image, imImage* dst_image, int kernel_size, int iter); 00278 00279 /** Binary morphology convolution with a kernel full of "0"s and hit black. 00280 * 00281 * \verbatim im.ProcessBinMorphDilate(src_image: imImage, dst_image: imImage, kernel_size: number, iter: number) -> counter: boolean [in Lua 5] \endverbatim 00282 * \verbatim im.ProcessBinMorphDilateNew(image: imImage, kernel_size: number, iter: number) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim 00283 * \ingroup morphbin */ 00284 int imProcessBinMorphDilate(const imImage* src_image, imImage* dst_image, int kernel_size, int iter); 00285 00286 /** Erode+Dilate. 00287 * When iteration is more than one it means Erode+Erode+Erode+...+Dilate+Dilate+Dilate+... 00288 * 00289 * \verbatim im.ProcessBinMorphOpen(src_image: imImage, dst_image: imImage, kernel_size: number, iter: number) -> counter: boolean [in Lua 5] \endverbatim 00290 * \verbatim im.ProcessBinMorphOpenNew(image: imImage, kernel_size: number, iter: number) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim 00291 * \ingroup morphbin */ 00292 int imProcessBinMorphOpen(const imImage* src_image, imImage* dst_image, int kernel_size, int iter); 00293 00294 /** Dilate+Erode. 00295 * 00296 * \verbatim im.ProcessBinMorphClose(src_image: imImage, dst_image: imImage, kernel_size: number, iter: number) -> counter: boolean [in Lua 5] \endverbatim 00297 * \verbatim im.ProcessBinMorphCloseNew(image: imImage, kernel_size: number, iter: number) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim 00298 * \ingroup morphbin */ 00299 int imProcessBinMorphClose(const imImage* src_image, imImage* dst_image, int kernel_size, int iter); 00300 00301 /** Erode+Difference. \n 00302 * The difference from the source image is applied only once. 00303 * 00304 * \verbatim im.ProcessBinMorphOutline(src_image: imImage, dst_image: imImage, kernel_size: number, iter: number) -> counter: boolean [in Lua 5] \endverbatim 00305 * \verbatim im.ProcessBinMorphOutlineNew(image: imImage, kernel_size: number, iter: number) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim 00306 * \ingroup morphbin */ 00307 int imProcessBinMorphOutline(const imImage* src_image, imImage* dst_image, int kernel_size, int iter); 00308 00309 /** Thins the supplied binary image using Rosenfeld's parallel thinning algorithm. \n 00310 * Reference: \n 00311 * "Efficient Binary Image Thinning using Neighborhood Maps" \n 00312 * by Joseph M. Cychosz, 3ksnn64@ecn.purdue.edu \n 00313 * in "Graphics Gems IV", Academic Press, 1994 00314 * 00315 * \verbatim im.ProcessBinMorphThin(src_image: imImage, dst_image: imImage) [in Lua 5] \endverbatim 00316 * \verbatim im.ProcessBinMorphThinNew(image: imImage) -> new_image: imImage [in Lua 5] \endverbatim 00317 * \ingroup morphbin */ 00318 void imProcessBinMorphThin(const imImage* src_image, imImage* dst_image); 00319 00320 00321 00322 /** \defgroup rank Rank Convolution Operations 00323 * \par 00324 * All the rank convolution use the same base function. Near the border the base function 00325 * includes only the real image pixels in the rank. No border extensions are used. 00326 * \par 00327 * See \ref im_process_loc.h 00328 * \ingroup process */ 00329 00330 /** Rank convolution using the median value. \n 00331 * Returns zero if the counter aborted. \n 00332 * Supports all data types except IM_CFLOAT. Can be applied on color images. 00333 * 00334 * \verbatim im.ProcessMedianConvolve(src_image: imImage, dst_image: imImage, kernel_size: number) -> counter: boolean [in Lua 5] \endverbatim 00335 * \verbatim im.ProcessMedianConvolveNew(image: imImage, kernel_size: number) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim 00336 * \ingroup rank */ 00337 int imProcessMedianConvolve(const imImage* src_image, imImage* dst_image, int kernel_size); 00338 00339 /** Rank convolution using (maximum-minimum) value. \n 00340 * Returns zero if the counter aborted. \n 00341 * Supports all data types except IM_CFLOAT. Can be applied on color images. 00342 * 00343 * \verbatim im.ProcessRangeConvolve(src_image: imImage, dst_image: imImage, kernel_size: number) -> counter: boolean [in Lua 5] \endverbatim 00344 * \verbatim im.ProcessRangeConvolveNew(image: imImage, kernel_size: number) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim 00345 * \ingroup rank */ 00346 int imProcessRangeConvolve(const imImage* src_image, imImage* dst_image, int kernel_size); 00347 00348 /** Rank convolution using the closest maximum or minimum value. \n 00349 * Returns zero if the counter aborted. \n 00350 * Supports all data types except IM_CFLOAT. Can be applied on color images. 00351 * 00352 * \verbatim im.ProcessRankClosestConvolve(src_image: imImage, dst_image: imImage, kernel_size: number) -> counter: boolean [in Lua 5] \endverbatim 00353 * \verbatim im.ProcessRankClosestConvolveNew(image: imImage, kernel_size: number) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim 00354 * \ingroup rank */ 00355 int imProcessRankClosestConvolve(const imImage* src_image, imImage* dst_image, int kernel_size); 00356 00357 /** Rank convolution using the maximum value. \n 00358 * Returns zero if the counter aborted. \n 00359 * Supports all data types except IM_CFLOAT. Can be applied on color images. 00360 * 00361 * \verbatim im.ProcessRankMaxConvolve(src_image: imImage, dst_image: imImage, kernel_size: number) -> counter: boolean [in Lua 5] \endverbatim 00362 * \verbatim im.ProcessRankMaxConvolveNew(image: imImage, kernel_size: number) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim 00363 * \ingroup rank */ 00364 int imProcessRankMaxConvolve(const imImage* src_image, imImage* dst_image, int kernel_size); 00365 00366 /** Rank convolution using the minimum value. \n 00367 * Returns zero if the counter aborted. \n 00368 * Supports all data types except IM_CFLOAT. Can be applied on color images. 00369 * 00370 * \verbatim im.ProcessRankMinConvolve(src_image: imImage, dst_image: imImage, kernel_size: number) -> counter: boolean [in Lua 5] \endverbatim 00371 * \verbatim im.ProcessRankMinConvolveNew(image: imImage, kernel_size: number) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim 00372 * \ingroup rank */ 00373 int imProcessRankMinConvolve(const imImage* src_image, imImage* dst_image, int kernel_size); 00374 00375 /** Threshold using a rank convolution with a range contrast function. \n 00376 * Supports all integer IM_GRAY images as source, and IM_BINARY as destiny. \n 00377 * Local variable threshold by the method of Bernsen. \n 00378 * Extracted from XITE, Copyright 1991, Blab, UiO \n 00379 * http://www.ifi.uio.no/~blab/Software/Xite/ 00380 \verbatim 00381 Reference: 00382 Bernsen, J: "Dynamic thresholding of grey-level images" 00383 Proc. of the 8th ICPR, Paris, Oct 1986, 1251-1255. 00384 Author: Oivind Due Trier 00385 \endverbatim 00386 * Returns zero if the counter aborted. 00387 * 00388 * \verbatim im.ProcessRangeContrastThreshold(src_image: imImage, dst_image: imImage, kernel_size: number, min_range: number) -> counter: boolean [in Lua 5] \endverbatim 00389 * \verbatim im.ProcessRangeContrastThresholdNew(image: imImage, kernel_size: number, min_range: number) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim 00390 * \ingroup threshold */ 00391 int imProcessRangeContrastThreshold(const imImage* src_image, imImage* dst_image, int kernel_size, int min_range); 00392 00393 /** Threshold using a rank convolution with a local max function. \n 00394 * Returns zero if the counter aborted. \n 00395 * Supports all integer IM_GRAY images as source, and IM_BINARY as destiny. 00396 * 00397 * \verbatim im.ProcessLocalMaxThreshold(src_image: imImage, dst_image: imImage, kernel_size: number, min_level: number) -> counter: boolean [in Lua 5] \endverbatim 00398 * \verbatim im.ProcessLocalMaxThresholdNew(image: imImage, kernel_size: number, min_level: number) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim 00399 * \ingroup threshold */ 00400 int imProcessLocalMaxThreshold(const imImage* src_image, imImage* dst_image, int kernel_size, int min_level); 00401 00402 00403 00404 /** \defgroup convolve Convolution Operations 00405 * \par 00406 * See \ref im_process_loc.h 00407 * \ingroup process */ 00408 00409 /** Base Convolution with a kernel. \n 00410 * Kernel can be IM_INT or IM_FLOAT, but always IM_GRAY. Use kernel size odd for better results. \n 00411 * Supports all data types. The border is mirrored. \n 00412 * Returns zero if the counter aborted. Most of the convolutions use this function.\n 00413 * If the kernel image attribute "Description" exists it is used by the counter. 00414 * 00415 * \verbatim im.ProcessConvolve(src_image: imImage, dst_image: imImage, kernel: imImage) -> counter: boolean [in Lua 5] \endverbatim 00416 * \verbatim im.ProcessConvolveNew(image: imImage, kernel: imImage) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim 00417 * \ingroup convolve */ 00418 int imProcessConvolve(const imImage* src_image, imImage* dst_image, const imImage* kernel); 00419 00420 /** Base convolution when the kernel is separable. Only the first line and the first column will be used. \n 00421 * Returns zero if the counter aborted.\n 00422 * If the kernel image attribute "Description" exists it is used by the counter. 00423 * 00424 * \verbatim im.ProcessConvolveSep(src_image: imImage, dst_image: imImage, kernel: imImage) -> counter: boolean [in Lua 5] \endverbatim 00425 * \verbatim im.ProcessConvolveSepNew(image: imImage, kernel: imImage) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim 00426 * \ingroup convolve */ 00427 int imProcessConvolveSep(const imImage* src_image, imImage* dst_image, const imImage* kernel); 00428 00429 /** Base Convolution with two kernels. The result is the magnitude of the result of each convolution. \n 00430 * Kernel can be IM_INT or IM_FLOAT, but always IM_GRAY. Use kernel size odd for better results. \n 00431 * Supports all data types. The border is mirrored. \n 00432 * Returns zero if the counter aborted. Most of the convolutions use this function.\n 00433 * If the kernel image attribute "Description" exists it is used by the counter. 00434 * 00435 * \verbatim im.ProcessConvolveDual(src_image: imImage, dst_image: imImage, kernel1, kernel2: imImage) -> counter: boolean [in Lua 5] \endverbatim 00436 * \verbatim im.ProcessConvolveDualNew(image: imImage, kernel1, kernel2: imImage) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim 00437 * \ingroup convolve */ 00438 int imProcessConvolveDual(const imImage* src_image, imImage* dst_image, const imImage *kernel1, const imImage *kernel2); 00439 00440 /** Repeats the convolution a number of times. \n 00441 * Returns zero if the counter aborted.\n 00442 * If the kernel image attribute "Description" exists it is used by the counter. 00443 * 00444 * \verbatim im.ProcessConvolveRep(src_image: imImage, dst_image: imImage, kernel: imImage, count: number) -> counter: boolean [in Lua 5] \endverbatim 00445 * \verbatim im.ProcessConvolveRepNew(image: imImage, kernel: imImage, count: number) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim 00446 * \ingroup convolve */ 00447 int imProcessConvolveRep(const imImage* src_image, imImage* dst_image, const imImage* kernel, int count); 00448 00449 /** Convolve with a kernel rotating it 8 times and getting the absolute maximum value. \n 00450 * Kernel must be square. \n 00451 * The rotation is implemented only for kernel sizes 3x3, 5x5 and 7x7. \n 00452 * Supports all data types except IM_CFLOAT. 00453 * Returns zero if the counter aborted.\n 00454 * If the kernel image attribute "Description" exists it is used by the counter. 00455 * 00456 * \verbatim im.ProcessCompassConvolve(src_image: imImage, dst_image: imImage, kernel: imImage) -> counter: boolean [in Lua 5] \endverbatim 00457 * \verbatim im.ProcessCompassConvolveNew(image: imImage, kernel: imImage) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim 00458 * \ingroup convolve */ 00459 int imProcessCompassConvolve(const imImage* src_image, imImage* dst_image, imImage* kernel); 00460 00461 /** Utility function to rotate a kernel one time. 00462 * 00463 * \verbatim im.ProcessRotateKernel(kernel: imImage) [in Lua 5] \endverbatim 00464 * \ingroup convolve */ 00465 void imProcessRotateKernel(imImage* kernel); 00466 00467 /** Difference(Gaussian1, Gaussian2). \n 00468 * Supports all data types, 00469 * but if source is IM_BYTE or IM_USHORT destiny image must be of type IM_INT. 00470 * 00471 * \verbatim im.ProcessDiffOfGaussianConvolve(src_image: imImage, dst_image: imImage, stddev1: number, stddev2: number) -> counter: boolean [in Lua 5] \endverbatim 00472 * \verbatim im.ProcessDiffOfGaussianConvolveNew(image: imImage, stddev1: number, stddev2: number) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim 00473 * \ingroup convolve */ 00474 int imProcessDiffOfGaussianConvolve(const imImage* src_image, imImage* dst_image, float stddev1, float stddev2); 00475 00476 /** Convolution with a laplacian of a gaussian kernel. \n 00477 * Supports all data types, 00478 * but if source is IM_BYTE or IM_USHORT destiny image must be of type IM_INT. 00479 * 00480 * \verbatim im.ProcessLapOfGaussianConvolve(src_image: imImage, dst_image: imImage, stddev: number) -> counter: boolean [in Lua 5] \endverbatim 00481 * \verbatim im.ProcessLapOfGaussianConvolveNew(image: imImage, stddev: number) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim 00482 * \ingroup convolve */ 00483 int imProcessLapOfGaussianConvolve(const imImage* src_image, imImage* dst_image, float stddev); 00484 00485 /** Convolution with a kernel full of "1"s inside a circle. \n 00486 * Supports all data types. 00487 * 00488 * \verbatim im.ProcessMeanConvolve(src_image: imImage, dst_image: imImage, kernel_size: number) -> counter: boolean [in Lua 5] \endverbatim 00489 * \verbatim im.ProcessMeanConvolveNew(image: imImage, kernel_size: number) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim 00490 * \ingroup convolve */ 00491 int imProcessMeanConvolve(const imImage* src_image, imImage* dst_image, int kernel_size); 00492 00493 /** Convolution with a float gaussian kernel. \n 00494 * If sdtdev is negative its magnitude will be used as the kernel size. \n 00495 * Supports all data types. 00496 * 00497 * \verbatim im.ProcessGaussianConvolve(src_image: imImage, dst_image: imImage, stddev: number) -> counter: boolean [in Lua 5] \endverbatim 00498 * \verbatim im.ProcessGaussianConvolveNew(image: imImage, stddev: number) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim 00499 * \ingroup convolve */ 00500 int imProcessGaussianConvolve(const imImage* src_image, imImage* dst_image, float stddev); 00501 00502 /** Convolution with a barlett kernel. \n 00503 * Supports all data types. 00504 * 00505 * \verbatim im.ProcessBarlettConvolve(src_image: imImage, dst_image: imImage, kernel_size: number) -> counter: boolean [in Lua 5] \endverbatim 00506 * \verbatim im.ProcessBarlettConvolveNew(image: imImage, kernel_size: number) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim 00507 * \ingroup convolve */ 00508 int imProcessBarlettConvolve(const imImage* src_image, imImage* dst_image, int kernel_size); 00509 00510 /** Magnitude of the sobel convolution. \n 00511 * Supports all data types. 00512 * 00513 * \verbatim im.ProcessSobelConvolve(src_image: imImage, dst_image: imImage) -> counter: boolean [in Lua 5] \endverbatim 00514 * \verbatim im.ProcessSobelConvolveNew(image: imImage) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim 00515 * \ingroup convolve */ 00516 int imProcessSobelConvolve(const imImage* src_image, imImage* dst_image); 00517 00518 /** Magnitude of the prewitt convolution. \n 00519 * Supports all data types. 00520 * 00521 * \verbatim im.ProcessPrewittConvolve(src_image: imImage, dst_image: imImage) -> counter: boolean [in Lua 5] \endverbatim 00522 * \verbatim im.ProcessPrewittConvolveNew(image: imImage) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim 00523 * \ingroup convolve */ 00524 int imProcessPrewittConvolve(const imImage* src_image, imImage* dst_image); 00525 00526 /** Spline edge dectection. \n 00527 * Supports all data types. 00528 * 00529 * \verbatim im.ProcessSplineEdgeConvolve(src_image: imImage, dst_image: imImage) -> counter: boolean [in Lua 5] \endverbatim 00530 * \verbatim im.ProcessSplineEdgeConvolveNew(image: imImage) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim 00531 * \ingroup convolve */ 00532 int imProcessSplineEdgeConvolve(const imImage* src_image, imImage* dst_image); 00533 00534 /** Finds the zero crossings of IM_INT and IM_FLOAT images. Crossings are marked with non zero values 00535 * indicating the intensity of the edge. It is usually used after a second derivative, laplace. \n 00536 * Extracted from XITE, Copyright 1991, Blab, UiO \n 00537 * http://www.ifi.uio.no/~blab/Software/Xite/ 00538 * 00539 * \verbatim im.ProcessZeroCrossing(src_image: imImage, dst_image: imImage) [in Lua 5] \endverbatim 00540 * \verbatim im.ProcessZeroCrossingNew(image: imImage) -> new_image: imImage [in Lua 5] \endverbatim 00541 * \ingroup convolve */ 00542 void imProcessZeroCrossing(const imImage* src_image, imImage* dst_image); 00543 00544 /** First part of the Canny edge detector. Includes the gaussian filtering and the nonmax suppression. \n 00545 * After using this you could apply a Hysteresis Threshold, see \ref imProcessHysteresisThreshold. \n 00546 * Image must be IM_BYTE/IM_GRAY. \n 00547 * Implementation from the book: 00548 \verbatim 00549 J. R. Parker 00550 "Algoritms for Image Processing and Computer Vision" 00551 WILEY 00552 \endverbatim 00553 * 00554 * \verbatim im.ProcessCanny(src_image: imImage, dst_image: imImage, stddev: number) [in Lua 5] \endverbatim 00555 * \verbatim im.ProcessCannyNew(image: imImage, stddev: number) -> new_image: imImage [in Lua 5] \endverbatim 00556 * \ingroup convolve */ 00557 void imProcessCanny(const imImage* src_image, imImage* dst_image, float stddev); 00558 00559 /** Calculates the kernel size given the standard deviation. \n 00560 * If sdtdev is negative its magnitude will be used as the kernel size. 00561 * 00562 * \verbatim im.GaussianStdDev2KernelSize(stddev: number) -> kernel_size: number [in Lua 5] \endverbatim 00563 * \ingroup convolve */ 00564 int imGaussianStdDev2KernelSize(float stddev); 00565 00566 /** Calculates the standard deviation given the kernel size. 00567 * 00568 * \verbatim im.GaussianKernelSize2StdDev(kernel_size: number) -> stddev: number [in Lua 5] \endverbatim 00569 * \ingroup convolve */ 00570 float imGaussianKernelSize2StdDev(int kernel_size); 00571 00572 /** Edge enhancement using Unsharp mask. stddev control the gaussian filter, 00573 * amount controls how much the edges will enhance the image (0<amount<1), and 00574 * threshold controls which edges will be considered, it compares to twice of the absolute size of the edge. 00575 * Although very similar to \ref imProcessSharp, produces better results. 00576 * 00577 * \verbatim im.ProcessUnsharp(src_image: imImage, dst_image: imImage, stddev: number, amount: number, threshold: number) [in Lua 5] \endverbatim 00578 * \verbatim im.ProcessUnsharpNew(image: imImage, stddev: number, amount: number, threshold: number) -> new_image: imImage [in Lua 5] \endverbatim 00579 * \ingroup convolve */ 00580 int imProcessUnsharp(const imImage* src_image, imImage* dst_image, float stddev, float amount, float threshold); 00581 00582 /** Edge enhancement using Laplacian8 mask. 00583 * amount controls how much the edges will enhance the image (0<amount<1), and 00584 * threshold controls which edges will be considered, it compares to twice of the absolute size of the edge. 00585 * 00586 * \verbatim im.ProcessSharp(src_image: imImage, dst_image: imImage, amount: number, threshold: number) [in Lua 5] \endverbatim 00587 * \verbatim im.ProcessSharpNew(image: imImage, amount: number, threshold: number) -> new_image: imImage [in Lua 5] \endverbatim 00588 * \ingroup convolve */ 00589 int imProcessSharp(const imImage* src_image, imImage* dst_image, float amount, float threshold); 00590 00591 /** Edge enhancement using a given kernel. 00592 * If kernel has all positive values, then the unsharp technique is used, else sharp is used. 00593 * amount controls how much the edges will enhance the image (0<amount<1), and 00594 * threshold controls which edges will be considered, it compares to twice of the absolute size of the edge. 00595 * 00596 * \verbatim im.ProcessSharp(src_image: imImage, dst_image: imImage, amount: number, threshold: number) [in Lua 5] \endverbatim 00597 * \verbatim im.ProcessSharpNew(image: imImage, amount: number, threshold: number) -> new_image: imImage [in Lua 5] \endverbatim 00598 * \ingroup convolve */ 00599 int imProcessSharpKernel(const imImage* src_image, const imImage* kernel, imImage* dst_image, float amount, float threshold); 00600 00601 00602 #if defined(__cplusplus) 00603 } 00604 #endif 00605 00606 #endif