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