1 /** \file 2 * \brief Image Processing - Local Operations 3 * 4 * See Copyright Notice in im_lib.d 5 */ 6 7 module im.process_loc; 8 9 import im.image; 10 11 extern (C) @safe nothrow: 12 13 14 15 /** \defgroup resize Image Resize 16 * \par 17 * Operations to change the image size. \n 18 * All size operations include the alpha channel if any. 19 * \par 20 * See \ref im_process_loc.h 21 * \ingroup process */ 22 23 /** Only reduze the image size using the given decimation order. \n 24 * Supported decimation orders: 25 * \li 0 - zero order (mean) [default in Lua for MAP and BINARY] 26 * \li 1 - first order (bilinear decimation) [default in Lua] 27 * Images must be of the same type. If image type is IM_MAP or IM_BINARY, must use order=0. \n 28 * Returns zero if the counter aborted. 29 * 30 * \verbatim im.ProcessReduce(src_image: imImage, dst_image: imImage, order: number) -> counter: boolean [in Lua 5] \endverbatim 31 * \verbatim im.ProcessReduceNew(image: imImage, width, height[, order]: number) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim 32 * \ingroup resize */ 33 int imProcessReduce(const(imImage) * src_image, imImage* dst_image, int order); 34 35 /** Change the image size using the given interpolation order. \n 36 * Supported interpolation orders: 37 * \li 0 - zero order (near neighborhood) [default in Lua for MAP and BINARY] 38 * \li 1 - first order (bilinear interpolation) [default in Lua] 39 * \li 3 - third order (bicubic interpolation) 40 * Images must be of the same type. If image type is IM_MAP or IM_BINARY, must use order=0. \n 41 * Returns zero if the counter aborted. 42 * 43 * \verbatim im.ProcessResize(src_image: imImage, dst_image: imImage, order: number) -> counter: boolean [in Lua 5] \endverbatim 44 * \verbatim im.ProcessResizeNew(image: imImage, width, height[, order]: number) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim 45 * \ingroup resize */ 46 int imProcessResize(const(imImage) * src_image, imImage* dst_image, int order); 47 48 /** Reduze the image area by 4 (w/2,h/2). \n 49 * Images must be of the same type. Target image size must be source image width/2, height/2. 50 * Can not operate on IM_MAP nor IM_BINARY images. 51 * 52 * \verbatim im.ProcessReduceBy4(src_image: imImage, dst_image: imImage) [in Lua 5] \endverbatim 53 * \verbatim im.ProcessReduceBy4New(image: imImage) -> new_image: imImage [in Lua 5] \endverbatim 54 * \ingroup resize */ 55 void imProcessReduceBy4(const(imImage) * src_image, imImage* dst_image); 56 57 /** Extract a rectangular region from an image. \n 58 * Images must be of the same type. Target image size must be smaller than source image width-xmin, height-ymin. \n 59 * ymin and xmin must be >0 and <size. 60 * 61 * \verbatim im.ProcessCrop(src_image: imImage, dst_image: imImage, xmin: number, ymin: number) [in Lua 5] \endverbatim 62 * \verbatim im.ProcessCropNew(image: imImage, xmin, xmax, ymin, ymax: number) -> new_image: imImage [in Lua 5] \endverbatim 63 * \ingroup resize */ 64 void imProcessCrop(const(imImage) * src_image, imImage* dst_image, int xmin, int ymin); 65 66 /** Insert a rectangular region in an image. \n 67 * Images must be of the same type. Region image size can be larger than source image. \n 68 * ymin and xmin must be >0 and <size. \n 69 * Source and target must be of the same size. Can be done in-place. 70 * 71 * \verbatim im.ProcessInsert(src_image: imImage, region_image: imImage, dst_image: imImage, xmin: number, ymin: number) [in Lua 5] \endverbatim 72 * \verbatim im.ProcessInsertNew(image: imImage, region_image: imImage, xmin: number, ymin: number) -> new_image: imImage [in Lua 5] \endverbatim 73 * \ingroup resize */ 74 void imProcessInsert(const(imImage) * src_image, const(imImage) * region_image, imImage* dst_image, int xmin, int ymin); 75 76 /** Increase the image size by adding pixels with zero value. \n 77 * Images must be of the same type. Target image size must be greatter or equal than source image width+xmin, height+ymin. 78 * 79 * \verbatim im.ProcessAddMargins(src_image: imImage, dst_image: imImage, xmin: number, ymin: number) [in Lua 5] \endverbatim 80 * \verbatim im.ProcessAddMarginsNew(image: imImage, xmin, xmax, ymin, ymax: number) -> new_image: imImage [in Lua 5] \endverbatim 81 * \ingroup resize */ 82 void imProcessAddMargins(const(imImage) * src_image, imImage* dst_image, int xmin, int ymin); 83 84 85 86 /** \defgroup geom Geometric Operations 87 * \par 88 * Operations to change the shape of the image. \n 89 * All geometric operations include the alpha channel if any. 90 * \par 91 * See \ref im_process_loc.h 92 * \ingroup process */ 93 94 /** Calculates the size of the new image after rotation. 95 * 96 * \verbatim im.ProcessCalcRotateSize(width: number, height: number, cos0: number, sin0: number) [in Lua 5] \endverbatim 97 * \ingroup geom */ 98 void imProcessCalcRotateSize(int width, int height, int *new_width, int *new_height, double cos0, double sin0); 99 100 /** Rotates the image using the given interpolation order (see \ref imProcessResize). \n 101 * Images must be of the same type. The target size can be calculated using \ref imProcessCalcRotateSize to fit the new image size, 102 * or can be any size, including the original size. The rotation is relative to the center of the image. \n 103 * Returns zero if the counter aborted. 104 * 105 * \verbatim im.ProcessRotate(src_image: imImage, dst_image: imImage, cos0: number, sin0: number[, order]: number) -> counter: boolean [in Lua 5] \endverbatim 106 * \verbatim im.ProcessRotateNew(image: imImage, cos0, sin0, order: number) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim 107 * \ingroup geom */ 108 int imProcessRotate(const(imImage) * src_image, imImage* dst_image, double cos0, double sin0, int order); 109 110 /** Rotates the image using the given interpolation order (see \ref imProcessResize). \n 111 * Images must be of the same type. Target can have any size, including the original size. \n 112 * The rotation is relative to the reference point. But the result can be shifted to the origin. \n 113 * Returns zero if the counter aborted. 114 * 115 * \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 116 * \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 117 * \ingroup geom */ 118 int imProcessRotateRef(const(imImage) * src_image, imImage* dst_image, double cos0, double sin0, int x, int y, int to_origin, int order); 119 120 /** Rotates the image in 90 degrees counterclockwise or clockwise. Swap columns by lines. \n 121 * Images must be of the same type. Target width and height must be source height and width. \n 122 * Direction can be clockwise (1) or counter clockwise (-1). 123 * 124 * \verbatim im.ProcessRotate90(src_image: imImage, dst_image: imImage, dir_clockwise: boolean) [in Lua 5] \endverbatim 125 * \verbatim im.ProcessRotate90New(image: imImage, dir_clockwise: boolean) -> new_image: imImage [in Lua 5] \endverbatim 126 * \ingroup geom */ 127 void imProcessRotate90(const(imImage) * src_image, imImage* dst_image, int dir_clockwise); 128 129 /** Rotates the image in 180 degrees. Swap columns and swap lines. \n 130 * Images must be of the same type and size. 131 * 132 * \verbatim im.ProcessRotate180(src_image: imImage, dst_image: imImage) [in Lua 5] \endverbatim 133 * \verbatim im.ProcessRotate180New(image: imImage) -> new_image: imImage [in Lua 5] \endverbatim 134 * \ingroup geom */ 135 void imProcessRotate180(const(imImage) * src_image, imImage* dst_image); 136 137 /** Mirror the image in a horizontal flip. Swap columns. \n 138 * Images must be of the same type and size. 139 * Can be done in-place. 140 * 141 * \verbatim im.ProcessMirror(src_image: imImage, dst_image: imImage) [in Lua 5] \endverbatim 142 * \verbatim im.ProcessMirrorNew(image: imImage) -> new_image: imImage [in Lua 5] \endverbatim 143 * \ingroup geom */ 144 void imProcessMirror(const(imImage) * src_image, imImage* dst_image); 145 146 /** Apply a vertical flip. Swap lines. \n 147 * Images must be of the same type and size. 148 * Can be done in-place. 149 * 150 * \verbatim im.ProcessFlip(src_image: imImage, dst_image: imImage) [in Lua 5] \endverbatim 151 * \verbatim im.ProcessFlipNew(image: imImage) -> new_image: imImage [in Lua 5] \endverbatim 152 * \ingroup geom */ 153 void imProcessFlip(const(imImage) * src_image, imImage* dst_image); 154 155 /** Apply a radial distortion using the given interpolation order (see imProcessResize). \n 156 * Images must be of the same type and size. Returns zero if the counter aborted. 157 * 158 * \verbatim im.ProcessRadial(src_image: imImage, dst_image: imImage, k1: number, order: number) -> counter: boolean [in Lua 5] \endverbatim 159 * \verbatim im.ProcessRadialNew(image: imImage, k1: number[, order]: number) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim 160 * \ingroup geom */ 161 int imProcessRadial(const(imImage) * src_image, imImage* dst_image, float k1, int order); 162 163 /** Apply a swirl distortion using the given interpolation order (see imProcessResize). \n 164 * Images must be of the same type and size. Returns zero if the counter aborted. 165 * 166 * \verbatim im.ProcessSwirl(src_image: imImage, dst_image: imImage, k: number, order: number) -> counter: boolean [in Lua 5] \endverbatim 167 * \verbatim im.ProcessSwirlNew(image: imImage, k: number[, order]: number) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim 168 * \ingroup geom */ 169 int imProcessSwirl(const(imImage) * src_image, imImage* dst_image, float k1, int order); 170 171 /** Split the image in two images, one containing the odd lines and other containing the even lines. \n 172 * Images must be of the same type. Height of the output images must be half the height of the input image. 173 * If the height of the input image is odd then the first image must have height equals to half+1. 174 * 175 * \verbatim im.ProcessInterlaceSplit(src_image: imImage, dst_image1: imImage, dst_image2: imImage) [in Lua 5] \endverbatim 176 * \verbatim im.ProcessInterlaceSplitNew(image: imImage) -> new_image1: imImage, new_image2: imImage [in Lua 5] \endverbatim 177 * \ingroup geom */ 178 void imProcessInterlaceSplit(const(imImage) * src_image, imImage* dst_image1, imImage* dst_image2); 179 180 181 182 /** \defgroup morphgray Morphology Operations for Gray Images 183 * \par 184 * See \ref im_process_loc.h 185 * \ingroup process */ 186 187 /** Base gray morphology convolution. \n 188 * Supports all data types except complex. Can be applied on color images. \n 189 * Kernel is always IM_INT. Use kernel size odd for better results. \n 190 * Use -1 for don't care positions in kernel. Kernel values are added to image values, then \n 191 * you can use the maximum or the minimum within the kernel area. \n 192 * No border extensions are used. 193 * All the gray morphology operations use this function. \n 194 * If the kernel image attribute "Description" exists it is used by the counter. 195 * 196 * \verbatim im.ProcessGrayMorphConvolve(src_image: imImage, dst_image: imImage, kernel: imImage, ismax: boolean) -> counter: boolean [in Lua 5] \endverbatim 197 * \verbatim im.ProcessGrayMorphConvolveNew(image: imImage, kernel: imImage, ismax: boolean) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim 198 * \ingroup morphgray */ 199 int imProcessGrayMorphConvolve(const(imImage) * src_image, imImage* dst_image, const(imImage) * kernel, int ismax); 200 201 /** Gray morphology convolution with a kernel full of "0"s and use minimum value. 202 * 203 * \verbatim im.ProcessGrayMorphErode(src_image: imImage, dst_image: imImage, kernel_size: number) -> counter: boolean [in Lua 5] \endverbatim 204 * \verbatim im.ProcessGrayMorphErodeNew(image: imImage, kernel_size: number) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim 205 * \ingroup morphgray */ 206 int imProcessGrayMorphErode(const(imImage) * src_image, imImage* dst_image, int kernel_size); 207 208 /** Gray morphology convolution with a kernel full of "0"s and use maximum value. 209 * 210 * \verbatim im.ProcessGrayMorphDilate(src_image: imImage, dst_image: imImage, kernel_size: number) -> counter: boolean [in Lua 5] \endverbatim 211 * \verbatim im.ProcessGrayMorphDilateNew(image: imImage, kernel_size: number) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim 212 * \ingroup morphgray */ 213 int imProcessGrayMorphDilate(const(imImage) * src_image, imImage* dst_image, int kernel_size); 214 215 /** Erode+Dilate. 216 * 217 * \verbatim im.ProcessGrayMorphOpen(src_image: imImage, dst_image: imImage, kernel_size: number) -> counter: boolean [in Lua 5] \endverbatim 218 * \verbatim im.ProcessGrayMorphOpenNew(image: imImage, kernel_size: number) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim 219 * \ingroup morphgray */ 220 int imProcessGrayMorphOpen(const(imImage) * src_image, imImage* dst_image, int kernel_size); 221 222 /** Dilate+Erode. 223 * 224 * \verbatim im.ProcessGrayMorphClose(src_image: imImage, dst_image: imImage, kernel_size: number) -> counter: boolean [in Lua 5] \endverbatim 225 * \verbatim im.ProcessGrayMorphCloseNew(image: imImage, kernel_size: number) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim 226 * \ingroup morphgray */ 227 int imProcessGrayMorphClose(const(imImage) * src_image, imImage* dst_image, int kernel_size); 228 229 /** Open+Difference. 230 * 231 * \verbatim im.ProcessGrayMorphTopHat(src_image: imImage, dst_image: imImage, kernel_size: number) -> counter: boolean [in Lua 5] \endverbatim 232 * \verbatim im.ProcessGrayMorphTopHatNew(image: imImage, kernel_size: number) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim 233 * \ingroup morphgray */ 234 int imProcessGrayMorphTopHat(const(imImage) * src_image, imImage* dst_image, int kernel_size); 235 236 /** Close+Difference. 237 * 238 * \verbatim im.ProcessGrayMorphWell(src_image: imImage, dst_image: imImage, kernel_size: number) -> counter: boolean [in Lua 5] \endverbatim 239 * \verbatim im.ProcessGrayMorphWellNew(image: imImage, kernel_size: number) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim 240 * \ingroup morphgray */ 241 int imProcessGrayMorphWell(const(imImage) * src_image, imImage* dst_image, int kernel_size); 242 243 /** Difference(Erode, Dilate). 244 * 245 * \verbatim im.ProcessGrayMorphGradient(src_image: imImage, dst_image: imImage, kernel_size: number) -> counter: boolean [in Lua 5] \endverbatim 246 * \verbatim im.ProcessGrayMorphGradientNew(image: imImage, kernel_size: number) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim 247 * \ingroup morphgray */ 248 int imProcessGrayMorphGradient(const(imImage) * src_image, imImage* dst_image, int kernel_size); 249 250 251 252 /** \defgroup morphbin Morphology Operations for Binary Images 253 * \par 254 * See \ref im_process_loc.h 255 * \ingroup process */ 256 257 /** Base binary morphology convolution. \n 258 * 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 259 * Hit white means hit=1 and miss=0, or else hit=0 and miss=1. \n 260 * Use -1 for don't care positions in kernel. Kernel values are simply compared with image values. \n 261 * The operation can be repeated by a number of iterations. 262 * The border is zero extended. \n 263 * Almost all the binary morphology operations use this function.\n 264 * If the kernel image attribute "Description" exists it is used by the counter. 265 * 266 * \verbatim im.ProcessBinMorphConvolve(src_image: imImage, dst_image: imImage, kernel: imImage, hit_white: boolean, iter: number) -> counter: boolean [in Lua 5] \endverbatim 267 * \verbatim im.ProcessBinMorphConvolveNew(image: imImage, kernel: imImage, hit_white: boolean, iter: number) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim 268 * \ingroup morphbin */ 269 int imProcessBinMorphConvolve(const(imImage) * src_image, imImage* dst_image, const(imImage) * kernel, int hit_white, int iter); 270 271 /** Binary morphology convolution with a kernel full of "1"s and hit white. 272 * 273 * \verbatim im.ProcessBinMorphErode(src_image: imImage, dst_image: imImage, kernel_size: number, iter: number) -> counter: boolean [in Lua 5] \endverbatim 274 * \verbatim im.ProcessBinMorphErodeNew(image: imImage, kernel_size: number, iter: number) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim 275 * \ingroup morphbin */ 276 int imProcessBinMorphErode(const(imImage) * src_image, imImage* dst_image, int kernel_size, int iter); 277 278 /** Binary morphology convolution with a kernel full of "0"s and hit black. 279 * 280 * \verbatim im.ProcessBinMorphDilate(src_image: imImage, dst_image: imImage, kernel_size: number, iter: number) -> counter: boolean [in Lua 5] \endverbatim 281 * \verbatim im.ProcessBinMorphDilateNew(image: imImage, kernel_size: number, iter: number) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim 282 * \ingroup morphbin */ 283 int imProcessBinMorphDilate(const(imImage) * src_image, imImage* dst_image, int kernel_size, int iter); 284 285 /** Erode+Dilate. 286 * When iteration is more than one it means Erode+Erode+Erode+...+Dilate+Dilate+Dilate+... 287 * 288 * \verbatim im.ProcessBinMorphOpen(src_image: imImage, dst_image: imImage, kernel_size: number, iter: number) -> counter: boolean [in Lua 5] \endverbatim 289 * \verbatim im.ProcessBinMorphOpenNew(image: imImage, kernel_size: number, iter: number) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim 290 * \ingroup morphbin */ 291 int imProcessBinMorphOpen(const(imImage) * src_image, imImage* dst_image, int kernel_size, int iter); 292 293 /** Dilate+Erode. 294 * 295 * \verbatim im.ProcessBinMorphClose(src_image: imImage, dst_image: imImage, kernel_size: number, iter: number) -> counter: boolean [in Lua 5] \endverbatim 296 * \verbatim im.ProcessBinMorphCloseNew(image: imImage, kernel_size: number, iter: number) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim 297 * \ingroup morphbin */ 298 int imProcessBinMorphClose(const(imImage) * src_image, imImage* dst_image, int kernel_size, int iter); 299 300 /** Erode+Difference. \n 301 * The difference from the source image is applied only once. 302 * 303 * \verbatim im.ProcessBinMorphOutline(src_image: imImage, dst_image: imImage, kernel_size: number, iter: number) -> counter: boolean [in Lua 5] \endverbatim 304 * \verbatim im.ProcessBinMorphOutlineNew(image: imImage, kernel_size: number, iter: number) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim 305 * \ingroup morphbin */ 306 int imProcessBinMorphOutline(const(imImage) * src_image, imImage* dst_image, int kernel_size, int iter); 307 308 /** Thins the supplied binary image using Rosenfeld's parallel thinning algorithm. \n 309 * Reference: \n 310 * "Efficient Binary Image Thinning using Neighborhood Maps" \n 311 * by Joseph M. Cychosz, 3ksnn64@ecn.purdue.edu \n 312 * in "Graphics Gems IV", Academic Press, 1994 \n 313 * Not using OpenMP when enabled. 314 * 315 * \verbatim im.ProcessBinMorphThin(src_image: imImage, dst_image: imImage) [in Lua 5] \endverbatim 316 * \verbatim im.ProcessBinMorphThinNew(image: imImage) -> new_image: imImage [in Lua 5] \endverbatim 317 * \ingroup morphbin */ 318 void imProcessBinMorphThin(const(imImage) * src_image, imImage* dst_image); 319 320 321 322 /** \defgroup rank Rank Convolution Operations 323 * \par 324 * All the rank convolution use the same base function. Near the border the base function 325 * includes only the real image pixels in the rank. No border extensions are used. 326 * \par 327 * See \ref im_process_loc.h 328 * \ingroup process */ 329 330 /** Rank convolution using the median value. \n 331 * Returns zero if the counter aborted. \n 332 * Supports all data types except complex. Can be applied on color images. 333 * 334 * \verbatim im.ProcessMedianConvolve(src_image: imImage, dst_image: imImage, kernel_size: number) -> counter: boolean [in Lua 5] \endverbatim 335 * \verbatim im.ProcessMedianConvolveNew(image: imImage, kernel_size: number) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim 336 * \ingroup rank */ 337 int imProcessMedianConvolve(const(imImage) * src_image, imImage* dst_image, int kernel_size); 338 339 /** Rank convolution using (maximum-minimum) value. \n 340 * Returns zero if the counter aborted. \n 341 * Supports all data types except complex. Can be applied on color images. 342 * 343 * \verbatim im.ProcessRangeConvolve(src_image: imImage, dst_image: imImage, kernel_size: number) -> counter: boolean [in Lua 5] \endverbatim 344 * \verbatim im.ProcessRangeConvolveNew(image: imImage, kernel_size: number) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim 345 * \ingroup rank */ 346 int imProcessRangeConvolve(const(imImage) * src_image, imImage* dst_image, int kernel_size); 347 348 /** Rank convolution using the closest maximum or minimum value. \n 349 * Returns zero if the counter aborted. \n 350 * Supports all data types except complex. Can be applied on color images. 351 * 352 * \verbatim im.ProcessRankClosestConvolve(src_image: imImage, dst_image: imImage, kernel_size: number) -> counter: boolean [in Lua 5] \endverbatim 353 * \verbatim im.ProcessRankClosestConvolveNew(image: imImage, kernel_size: number) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim 354 * \ingroup rank */ 355 int imProcessRankClosestConvolve(const(imImage) * src_image, imImage* dst_image, int kernel_size); 356 357 /** Rank convolution using the maximum value. \n 358 * Returns zero if the counter aborted. \n 359 * Supports all data types except complex. Can be applied on color images. 360 * 361 * \verbatim im.ProcessRankMaxConvolve(src_image: imImage, dst_image: imImage, kernel_size: number) -> counter: boolean [in Lua 5] \endverbatim 362 * \verbatim im.ProcessRankMaxConvolveNew(image: imImage, kernel_size: number) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim 363 * \ingroup rank */ 364 int imProcessRankMaxConvolve(const(imImage) * src_image, imImage* dst_image, int kernel_size); 365 366 /** Rank convolution using the minimum value. \n 367 * Returns zero if the counter aborted. \n 368 * Supports all data types except complex. Can be applied on color images. 369 * 370 * \verbatim im.ProcessRankMinConvolve(src_image: imImage, dst_image: imImage, kernel_size: number) -> counter: boolean [in Lua 5] \endverbatim 371 * \verbatim im.ProcessRankMinConvolveNew(image: imImage, kernel_size: number) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim 372 * \ingroup rank */ 373 int imProcessRankMinConvolve(const(imImage) * src_image, imImage* dst_image, int kernel_size); 374 375 /** Threshold using a rank convolution with a range contrast function. \n 376 * Supports all integer IM_GRAY images as source, and IM_BINARY as target. \n 377 * Local variable threshold by the method of Bernsen. \n 378 * Extracted from XITE, Copyright 1991, Blab, UiO \n 379 * http://www.ifi.uio.no/~blab/Software/Xite/ 380 \verbatim 381 Reference: 382 Bernsen, J: "Dynamic thresholding of grey-level images" 383 Proc. of the 8th ICPR, Paris, Oct 1986, 1251-1255. 384 Author: Oivind Due Trier 385 \endverbatim 386 * Returns zero if the counter aborted. 387 * 388 * \verbatim im.ProcessRangeContrastThreshold(src_image: imImage, dst_image: imImage, kernel_size: number, min_range: number) -> counter: boolean [in Lua 5] \endverbatim 389 * \verbatim im.ProcessRangeContrastThresholdNew(image: imImage, kernel_size: number, min_range: number) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim 390 * \ingroup threshold */ 391 int imProcessRangeContrastThreshold(const(imImage) * src_image, imImage* dst_image, int kernel_size, int min_range); 392 393 /** Threshold using a rank convolution with a local max function. \n 394 * Returns zero if the counter aborted. \n 395 * Supports all integer IM_GRAY images as source, and IM_BINARY as target. 396 * 397 * \verbatim im.ProcessLocalMaxThreshold(src_image: imImage, dst_image: imImage, kernel_size: number, min_level: number) -> counter: boolean [in Lua 5] \endverbatim 398 * \verbatim im.ProcessLocalMaxThresholdNew(image: imImage, kernel_size: number, min_level: number) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim 399 * \ingroup threshold */ 400 int imProcessLocalMaxThreshold(const(imImage) * src_image, imImage* dst_image, int kernel_size, int min_level); 401 402 403 404 /** \defgroup convolve Convolution Operations 405 * \par 406 * See \ref im_process_loc.h 407 * \ingroup process */ 408 409 /** Base Convolution with a kernel. \n 410 * Kernel can be IM_INT or IM_FLOAT, but always IM_GRAY. Use kernel size odd for better results. \n 411 * Supports all data types. The border is mirrored. \n 412 * Returns zero if the counter aborted. Most of the convolutions use this function.\n 413 * If the kernel image attribute "Description" exists it is used by the counter. 414 * 415 * \verbatim im.ProcessConvolve(src_image: imImage, dst_image: imImage, kernel: imImage) -> counter: boolean [in Lua 5] \endverbatim 416 * \verbatim im.ProcessConvolveNew(image: imImage, kernel: imImage) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim 417 * \ingroup convolve */ 418 int imProcessConvolve(const(imImage) * src_image, imImage* dst_image, const(imImage) * kernel); 419 420 /** Base convolution when the kernel is separable. Only the first line and the first column will be used. \n 421 * Returns zero if the counter aborted.\n 422 * If the kernel image attribute "Description" exists it is used by the counter. 423 * 424 * \verbatim im.ProcessConvolveSep(src_image: imImage, dst_image: imImage, kernel: imImage) -> counter: boolean [in Lua 5] \endverbatim 425 * \verbatim im.ProcessConvolveSepNew(image: imImage, kernel: imImage) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim 426 * \ingroup convolve */ 427 int imProcessConvolveSep(const(imImage) * src_image, imImage* dst_image, const(imImage) * kernel); 428 429 /** Base Convolution with two kernels. The result is the magnitude of the result of each convolution. \n 430 * Kernel can be IM_INT or IM_FLOAT, but always IM_GRAY. Use kernel size odd for better results. \n 431 * Supports all data types. The border is mirrored. \n 432 * Returns zero if the counter aborted. Most of the convolutions use this function.\n 433 * If the kernel image attribute "Description" exists it is used by the counter. 434 * 435 * \verbatim im.ProcessConvolveDual(src_image: imImage, dst_image: imImage, kernel1, kernel2: imImage) -> counter: boolean [in Lua 5] \endverbatim 436 * \verbatim im.ProcessConvolveDualNew(image: imImage, kernel1, kernel2: imImage) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim 437 * \ingroup convolve */ 438 int imProcessConvolveDual(const(imImage) * src_image, imImage* dst_image, const(imImage) *kernel1, const(imImage) *kernel2); 439 440 /** Repeats the convolution a number of times. \n 441 * Returns zero if the counter aborted.\n 442 * If the kernel image attribute "Description" exists it is used by the counter. 443 * 444 * \verbatim im.ProcessConvolveRep(src_image: imImage, dst_image: imImage, kernel: imImage, count: number) -> counter: boolean [in Lua 5] \endverbatim 445 * \verbatim im.ProcessConvolveRepNew(image: imImage, kernel: imImage, count: number) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim 446 * \ingroup convolve */ 447 int imProcessConvolveRep(const(imImage) * src_image, imImage* dst_image, const(imImage) * kernel, int count); 448 449 /** Convolve with a kernel rotating it 8 times and getting the absolute maximum value. \n 450 * Kernel must be square. \n 451 * The rotation is implemented only for kernel sizes 3x3, 5x5 and 7x7. \n 452 * Supports all data types except complex. 453 * Returns zero if the counter aborted.\n 454 * If the kernel image attribute "Description" exists it is used by the counter. 455 * 456 * \verbatim im.ProcessCompassConvolve(src_image: imImage, dst_image: imImage, kernel: imImage) -> counter: boolean [in Lua 5] \endverbatim 457 * \verbatim im.ProcessCompassConvolveNew(image: imImage, kernel: imImage) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim 458 * \ingroup convolve */ 459 int imProcessCompassConvolve(const(imImage) * src_image, imImage* dst_image, imImage* kernel); 460 461 /** Utility function to rotate a kernel one time. 462 * 463 * \verbatim im.ProcessRotateKernel(kernel: imImage) [in Lua 5] \endverbatim 464 * \ingroup convolve */ 465 void imProcessRotateKernel(imImage* kernel); 466 467 /** Difference(Gaussian1, Gaussian2). \n 468 * Supports all data types, 469 * but if source is IM_BYTE or IM_USHORT target image must be of type IM_INT. 470 * 471 * \verbatim im.ProcessDiffOfGaussianConvolve(src_image: imImage, dst_image: imImage, stddev1: number, stddev2: number) -> counter: boolean [in Lua 5] \endverbatim 472 * \verbatim im.ProcessDiffOfGaussianConvolveNew(image: imImage, stddev1: number, stddev2: number) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim 473 * \ingroup convolve */ 474 int imProcessDiffOfGaussianConvolve(const(imImage) * src_image, imImage* dst_image, float stddev1, float stddev2); 475 476 /** Convolution with a laplacian of a gaussian kernel. \n 477 * Supports all data types, 478 * but if source is IM_BYTE or IM_USHORT target image must be of type IM_INT. 479 * 480 * \verbatim im.ProcessLapOfGaussianConvolve(src_image: imImage, dst_image: imImage, stddev: number) -> counter: boolean [in Lua 5] \endverbatim 481 * \verbatim im.ProcessLapOfGaussianConvolveNew(image: imImage, stddev: number) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim 482 * \ingroup convolve */ 483 int imProcessLapOfGaussianConvolve(const(imImage) * src_image, imImage* dst_image, float stddev); 484 485 /** Convolution with a kernel full of "1"s inside a circle. \n 486 * Supports all data types. 487 * 488 * \verbatim im.ProcessMeanConvolve(src_image: imImage, dst_image: imImage, kernel_size: number) -> counter: boolean [in Lua 5] \endverbatim 489 * \verbatim im.ProcessMeanConvolveNew(image: imImage, kernel_size: number) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim 490 * \ingroup convolve */ 491 int imProcessMeanConvolve(const(imImage) * src_image, imImage* dst_image, int kernel_size); 492 493 /** Convolution with a float gaussian kernel. \n 494 * If sdtdev is negative its magnitude will be used as the kernel size. \n 495 * Supports all data types. 496 * 497 * \verbatim im.ProcessGaussianConvolve(src_image: imImage, dst_image: imImage, stddev: number) -> counter: boolean [in Lua 5] \endverbatim 498 * \verbatim im.ProcessGaussianConvolveNew(image: imImage, stddev: number) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim 499 * \ingroup convolve */ 500 int imProcessGaussianConvolve(const(imImage) * src_image, imImage* dst_image, float stddev); 501 502 /** Convolution with a barlett kernel. \n 503 * Supports all data types. 504 * 505 * \verbatim im.ProcessBarlettConvolve(src_image: imImage, dst_image: imImage, kernel_size: number) -> counter: boolean [in Lua 5] \endverbatim 506 * \verbatim im.ProcessBarlettConvolveNew(image: imImage, kernel_size: number) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim 507 * \ingroup convolve */ 508 int imProcessBarlettConvolve(const(imImage) * src_image, imImage* dst_image, int kernel_size); 509 510 /** Magnitude of the sobel convolution. \n 511 * Supports all data types. 512 * 513 * \verbatim im.ProcessSobelConvolve(src_image: imImage, dst_image: imImage) -> counter: boolean [in Lua 5] \endverbatim 514 * \verbatim im.ProcessSobelConvolveNew(image: imImage) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim 515 * \ingroup convolve */ 516 int imProcessSobelConvolve(const(imImage) * src_image, imImage* dst_image); 517 518 /** Magnitude of the prewitt convolution. \n 519 * Supports all data types. 520 * 521 * \verbatim im.ProcessPrewittConvolve(src_image: imImage, dst_image: imImage) -> counter: boolean [in Lua 5] \endverbatim 522 * \verbatim im.ProcessPrewittConvolveNew(image: imImage) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim 523 * \ingroup convolve */ 524 int imProcessPrewittConvolve(const(imImage) * src_image, imImage* dst_image); 525 526 /** Spline edge dectection. \n 527 * Supports all data types. 528 * 529 * \verbatim im.ProcessSplineEdgeConvolve(src_image: imImage, dst_image: imImage) -> counter: boolean [in Lua 5] \endverbatim 530 * \verbatim im.ProcessSplineEdgeConvolveNew(image: imImage) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim 531 * \ingroup convolve */ 532 int imProcessSplineEdgeConvolve(const(imImage) * src_image, imImage* dst_image); 533 534 /** Finds the zero crossings of IM_SHORT, IM_INT, IM_FLOAT and IM_DOUBLE images. Crossings are marked with non zero values 535 * indicating the intensity of the edge. It is usually used after a second derivative, laplace. \n 536 * Extracted from XITE, Copyright 1991, Blab, UiO \n 537 * http://www.ifi.uio.no/~blab/Software/Xite/ 538 * 539 * \verbatim im.ProcessZeroCrossing(src_image: imImage, dst_image: imImage) [in Lua 5] \endverbatim 540 * \verbatim im.ProcessZeroCrossingNew(image: imImage) -> new_image: imImage [in Lua 5] \endverbatim 541 * \ingroup convolve */ 542 void imProcessZeroCrossing(const(imImage) * src_image, imImage* dst_image); 543 544 /** First part of the Canny edge detector. Includes the gaussian filtering and the nonmax suppression. \n 545 * After using this you could apply a Hysteresis Threshold, see \ref imProcessHysteresisThreshold. \n 546 * Image must be IM_BYTE/IM_GRAY. \n 547 * Implementation from the book: 548 \verbatim 549 J. R. Parker 550 "Algoritms for Image Processing and Computer Vision" 551 WILEY 552 \endverbatim 553 * 554 * \verbatim im.ProcessCanny(src_image: imImage, dst_image: imImage, stddev: number) [in Lua 5] \endverbatim 555 * \verbatim im.ProcessCannyNew(image: imImage, stddev: number) -> new_image: imImage [in Lua 5] \endverbatim 556 * \ingroup convolve */ 557 void imProcessCanny(const(imImage) * src_image, imImage* dst_image, float stddev); 558 559 /** Calculates the kernel size given the standard deviation. \n 560 * If sdtdev is negative its magnitude will be used as the kernel size. 561 * 562 * \verbatim im.GaussianStdDev2KernelSize(stddev: number) -> kernel_size: number [in Lua 5] \endverbatim 563 * \ingroup convolve */ 564 int imGaussianStdDev2KernelSize(float stddev); 565 566 /** Calculates the standard deviation given the kernel size. 567 * 568 * \verbatim im.GaussianKernelSize2StdDev(kernel_size: number) -> stddev: number [in Lua 5] \endverbatim 569 * \ingroup convolve */ 570 float imGaussianKernelSize2StdDev(int kernel_size); 571 572 /** Edge enhancement using Unsharp mask. stddev control the gaussian filter, 573 * amount controls how much the edges will enhance the image (0<amount<1), and 574 * threshold controls which edges will be considered, it compares to twice of the absolute size of the edge. 575 * Although very similar to \ref imProcessSharp, produces better results. 576 * 577 * \verbatim im.ProcessUnsharp(src_image: imImage, dst_image: imImage, stddev: number, amount: number, threshold: number) [in Lua 5] \endverbatim 578 * \verbatim im.ProcessUnsharpNew(image: imImage, stddev: number, amount: number, threshold: number) -> new_image: imImage [in Lua 5] \endverbatim 579 * \ingroup convolve */ 580 int imProcessUnsharp(const(imImage) * src_image, imImage* dst_image, float stddev, float amount, float threshold); 581 582 /** Edge enhancement using Laplacian8 mask. 583 * amount controls how much the edges will enhance the image (0<amount<1), and 584 * threshold controls which edges will be considered, it compares to twice of the absolute size of the edge. 585 * 586 * \verbatim im.ProcessSharp(src_image: imImage, dst_image: imImage, amount: number, threshold: number) [in Lua 5] \endverbatim 587 * \verbatim im.ProcessSharpNew(image: imImage, amount: number, threshold: number) -> new_image: imImage [in Lua 5] \endverbatim 588 * \ingroup convolve */ 589 int imProcessSharp(const(imImage) * src_image, imImage* dst_image, float amount, float threshold); 590 591 /** Edge enhancement using a given kernel. 592 * If kernel has all positive values, then the unsharp technique is used, else sharp is used. 593 * amount controls how much the edges will enhance the image (0<amount<1), and 594 * threshold controls which edges will be considered, it compares to twice of the absolute size of the edge. 595 * 596 * \verbatim im.ProcessSharp(src_image: imImage, dst_image: imImage, amount: number, threshold: number) [in Lua 5] \endverbatim 597 * \verbatim im.ProcessSharpNew(image: imImage, amount: number, threshold: number) -> new_image: imImage [in Lua 5] \endverbatim 598 * \ingroup convolve */ 599 int imProcessSharpKernel(const(imImage) * src_image, const(imImage) * kernel, imImage* dst_image, float amount, float threshold); 600