im.im_process_pnt

\file \brief Image Processing - Point Operations

See Copyright Notice in im_lib.h

Members

Aliases

imMultiPointColorOpFunc
alias imMultiPointColorOpFunc = int function(float* src_value, float* dst_value, float* params, void* userdata, int x, int y, int src_image_count, int src_depth, int dst_depth)

Custom multiple point color function. \n * Source values are copies, so they can be changed inside the function without affecting the original image. \n * Data will be set only if the returned value is non zero. * \verbatim func(src_value1_plane0: number, src_value1_plane1: number, ..., src_value2_plane0: number, src_value2_plane1: number, ... , params1, param2, ..., x: number, y: number) -> dst_value_plane0: number, dst_value_plane1: number, ... [in Lua 5] \endverbatim * In Lua, the source images data and the params table are unpacked. * Also each color plane is passed as a separate value, instead of inside an array. * And the returned value contains only the target values to update, or nil (also no return value) to leave target intact. * \ingroup point

imMultiPointOpFunc
alias imMultiPointOpFunc = int function(const(float)* src_value, float* dst_value, float* params, void* userdata, int x, int y, int d, int src_image_count)

Custom multiple point function. \n * Source values are copies, so they can be changed inside the function without affecting the original image. \n * Data will be set only if the returned value is non zero. * \verbatim func(src_value1: number, src_value2: number, ... , params1, param2, ..., x: number, y: number, d: number) -> dst_value: number [in Lua 5] \endverbatim * In Lua, the source images data and the params table are unpacked. * And the returned value contains only the target values to update, or nil (also no return value) to leave target intact. * \ingroup point

imRenderCondFunc
alias imRenderCondFunc = float function(int x, int y, int d, int* cond, float* params)

Render Conditional Funtion. * \verbatim func(x: number, y: number, d: number, params: table) -> value: number, cond: boolean [in Lua 5] \endverbatim * \ingroup render

imRenderFunc
alias imRenderFunc = float function(int x, int y, int d, float* params)

Render Funtion. * \verbatim func(x: number, y: number, d: number, params: table) -> value: number [in Lua 5] \endverbatim * \ingroup render

imUnaryPointColorOpFunc
alias imUnaryPointColorOpFunc = int function(const(float)* src_value, float* dst_value, float* params, void* userdata, int x, int y)

Custom unary point color function. \n * Data will be set only if the returned value is non zero. * \verbatim func(src_value_plane0: number, src_value_plane1: number, ... , params1, param2, ..., x: number, y: number) -> dst_value_plane0: number, dst_value_plane1: number, ... [in Lua 5] \endverbatim * In Lua, the params table is unpacked. * Also each color plane is passed as a separate value, instead of inside an array. * And the returned value contains only the target values to update, or nil (also no return value) to leave target intact. * \ingroup point

imUnaryPointOpFunc
alias imUnaryPointOpFunc = int function(float src_value, float* dst_value, float* params, void* userdata, int x, int y, int d)

Custom unary point function. \n * Data will be set only if the returned value is non zero. * \verbatim func(src_value: number, params1, param2, ..., x: number, y: number, d: number) -> dst_value: number [in Lua 5] \endverbatim * In Lua, the params table is unpacked. * And the returned value contains only the target values to update, or nil (also no return value) to leave target intact. * \ingroup point

Enums

imBinaryOp
enum imBinaryOp

Binary Arithmetic Operations. \n * Divide may lead to math exceptions. * \ingroup arithm

imLogicOp
enum imLogicOp

Logical Operations. * \ingroup logic

imToneGamut
enum imToneGamut

Tone Gamut Operations. * \ingroup tonegamut

imToneGamutFlags
enum imToneGamutFlags

Tone Gamut Flags. * Combine with imToneGamut values with bitwise or (|). * \ingroup tonegamut

imUnaryOp
enum imUnaryOp

Unary Arithmetic Operations. \n * (#) Inverse and log may lead to math exceptions. * \ingroup arithm

Functions

imImageAutoLevel
void imImageAutoLevel(imImage* _image, float _percent)

Same as \ref imProcessExpandHistogram. * * \verbatim image:AutoLevel(percent) [in Lua 5] \endverbatim * \ingroup imageenhance

imImageBrightnessContrast
void imImageBrightnessContrast(imImage* _image, float _bright_shift, float _contrast_factor)

Same as \ref imProcessToneGamut using \ref IM_GAMUT_BRIGHTCONT. * * \verbatim image:BrightnessContrast(bright_shift, contrast_factor: number) [in Lua 5] \endverbatim * \ingroup imageenhance

imImageEqualize
void imImageEqualize(imImage* _image)

Same as \ref imProcessEqualizeHistogram. * * \verbatim image:Equalize() [in Lua 5] \endverbatim * \ingroup imageenhance

imImageGamma
void imImageGamma(imImage* _image, float _gamma)

Same as \ref imProcessToneGamut using \ref IM_GAMUT_POW. * * \verbatim image:Gamma(gamma) [in Lua 5] \endverbatim * \ingroup imageenhance

imImageLevel
void imImageLevel(imImage* _image, float _start, float _end)

Same as \ref imProcessToneGamut using \ref IM_GAMUT_EXPAND. * * \verbatim image:Level(start, end) [in Lua 5] \endverbatim * \ingroup imageenhance

imImageNegative
void imImageNegative(imImage* _image)

Same as \ref imProcessNegative. * Also same as \ref imProcessToneGamut using \ref IM_GAMUT_INVERT. * * \verbatim image:Negative() [in Lua 5] \endverbatim * \ingroup imageenhance

imProcessAbnormalHyperionCorrection
void imProcessAbnormalHyperionCorrection(const(imImage)* src_image, imImage* dst_image, int threshold_consecutive, int threshold_percent, imImage* image_abnormal)

Applies the abnormal pixel correction as described in the article. (Since 3.8) \n * Images must be IM_GRAY. Source and Target must have the same datatype, and complex is not supported. \n * image_abnormal is optional, can be NULL. If not NULL, must be IM_BINARY and * it will store the abnormal pixels distribution. \n * Can be done in-place. \n * threshold_percent is the percentage of the height that must have abnormal pixels candidates. \n * threshold_consecutive is the minimum number of consecutive abnormal pixels candidates to be considered an abnormal range. * (usually the longest vertical ground feature in pixels)\n * \par * Based on "Detection and Correction of Abnormal Pixels in Hyperion Images" * from T. Han, D. G. Goodenough, A. Dyk, and J. Love * * \verbatim im.AbnormalHyperionCorrection(src_image: imImage, dst_image: imImage, threshold_consecutive, threshold_percent: number[, image_abnormal: imImage]) [in Lua 5] \endverbatim * \verbatim im.AbnormalHyperionCorrectionNew(src_image: imImage, threshold_consecutive, threshold_percent: number[, image_abnormal: imImage]) -> new_image: imImage [in Lua 5] \endverbatim * \ingroup remotesens

imProcessArithmeticConstOp
void imProcessArithmeticConstOp(const(imImage)* src_image, float src_const, imImage* dst_image, int op)

Apply a binary arithmetic operation with a constant value. \n * Can be done in-place, images must match color space and size. \n * Target image can be several types depending on source: \n * \li any integer -> any integer or real * \li real -> real * \li complex -> complex * The constant value is type casted to an appropriate type before the operation. \n * If source is complex, target complex must be the same data type (imcfloat-imcfloat or imcdouble-imcdouble only). \n * If target is byte, then the result is cropped to 0-255. * * \verbatim im.ProcessArithmeticConstOp(src_image: imImage, src_const: number, dst_image: imImage, op: number) [in Lua 5] \endverbatim * \verbatim im.ProcessArithmeticConstOpNew(image: imImage, src_const: number, op: number) -> new_image: imImage [in Lua 5] \endverbatim * \ingroup arithm

imProcessArithmeticOp
void imProcessArithmeticOp(const(imImage)* src_image1, const(imImage)* src_image2, imImage* dst_image, int op)

Apply a binary arithmetic operation. \n * Can be done in-place, images must match color space and size. \n * Source images must match, target image can be several types depending on source: \n * \li any integer -> any integer+ or real * \li real -> real * \li complex -> complex * One exception is that you can use src1=complex src2=real resulting dst=complex. \n * If source is complex, target complex must be the same data type (imcfloat-imcfloat or imcdouble-imcdouble only). \n * If target is integer then it must have equal or more precision than the source. \n * If target is byte, then the result is cropped to 0-255. * Alpha channel is not included. * * \verbatim im.ProcessArithmeticOp(src_image1: imImage, src_image2: imImage, dst_image: imImage, op: number) [in Lua 5] \endverbatim * \verbatim im.ProcessArithmeticOpNew(image1: imImage, image2: imImage, op: number) -> new_image: imImage [in Lua 5] \endverbatim * The New function will create a new image of the same type of the source images. * \ingroup arithm

imProcessAutoCovariance
int imProcessAutoCovariance(const(imImage)* src_image, const(imImage)* mean_image, imImage* dst_image)

Calculates the auto-covariance of an image with the mean of a set of images. \n * Images must match. Returns zero if the counter aborted. \n * Target is IM_FLOAT, except if source is IM_DOUBLE. * Returns zero if the counter aborted. * * \verbatim im.ProcessAutoCovariance(src_image: imImage, mean_image: imImage, dst_image: imImage) -> counter: boolean [in Lua 5] \endverbatim * \verbatim im.ProcessAutoCovarianceNew(src_image: imImage, mean_image: imImage) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim * \ingroup arithm

imProcessBitMask
void imProcessBitMask(const(imImage)* src_image, imImage* dst_image, ubyte mask, int op)

Apply a bit mask. \n * The same as imProcessBitwiseOp but the second image is replaced by a fixed mask. \n * Images must have data type IM_BYTE. It is valid only for AND, OR and XOR. Can be done in-place. * * \verbatim im.ProcessBitMask(src_image: imImage, dst_image: imImage, mask: string, op: number) [in Lua 5] \endverbatim * \verbatim im.ProcessBitMaskNew(src_image: imImage, mask: string, op: number) -> new_image: imImage [in Lua 5] \endverbatim * In Lua, mask is a string with 0s and 1s, for example: "11001111". * \ingroup logic

imProcessBitPlane
void imProcessBitPlane(const(imImage)* src_image, imImage* dst_image, int plane, int do_reset)

Extract or Reset a bit plane. For ex: 000X0000 or XXX0XXXX (plane=3).\n * Images must have data type IM_BYTE. Can be done in-place. * * \verbatim im.ProcessBitPlane(src_image: imImage, dst_image: imImage, plane: number, do_reset: boolean) [in Lua 5] \endverbatim * \verbatim im.ProcessBitPlaneNew(src_image: imImage, plane: number, do_reset: boolean) -> new_image: imImage [in Lua 5] \endverbatim * \ingroup logic

imProcessBitwiseNot
void imProcessBitwiseNot(const(imImage)* src_image, imImage* dst_image)

Apply a logical NOT operation.\n * Images must have data type integer. Can be done in-place. * * \verbatim im.ProcessBitwiseNot(src_image: imImage, dst_image: imImage) [in Lua 5] \endverbatim * \verbatim im.ProcessBitwiseNotNew(src_image: imImage) -> new_image: imImage [in Lua 5] \endverbatim * \ingroup logic

imProcessBitwiseOp
void imProcessBitwiseOp(const(imImage)* src_image1, const(imImage)* src_image2, imImage* dst_image, int op)

Apply a logical operation.\n * Images must have data type integer. Can be done in-place. * * \verbatim im.ProcessBitwiseOp(src_image1: imImage, src_image2: imImage, dst_image: imImage, op: number) [in Lua 5] \endverbatim * \verbatim im.ProcessBitwiseOpNew(src_image1: imImage, src_image2: imImage, op: number) -> new_image: imImage [in Lua 5] \endverbatim * \ingroup logic

imProcessBlend
void imProcessBlend(const(imImage)* src_image1, const(imImage)* src_image2, const(imImage)* alpha_image, imImage* dst_image)

Blend two images using an alpha channel = [a * alpha + b * (1 - alpha)]. \n * Can be done in-place, images must match. \n * alpha_image must have the same data type except for complex images that must be real, * and color_space must be IM_GRAY. * Maximum alpha values are based in \ref imColorMax. Minimum is always 0. * \verbatim im.ProcessBlend(src_image1: imImage, src_image2: imImage, alpha_image: imImage, dst_image: imImage) [in Lua 5] \endverbatim * \verbatim im.ProcessBlendNew(image1: imImage, image2: imImage, alpha_image: imImage) -> new_image: imImage [in Lua 5] \endverbatim * \ingroup arithm

imProcessBlendConst
void imProcessBlendConst(const(imImage)* src_image1, const(imImage)* src_image2, imImage* dst_image, float alpha)

Blend two images using an alpha value = [a * alpha + b * (1 - alpha)]. \n * Can be done in-place, images must match. \n * alpha value must be in the interval [0.0 - 1.0]. * * \verbatim im.ProcessBlendConst(src_image1: imImage, src_image2: imImage, dst_image: imImage, alpha: number) [in Lua 5] \endverbatim * \verbatim im.ProcessBlendConstNew(image1: imImage, image2: imImage, alpha: number) -> new_image: imImage [in Lua 5] \endverbatim * \ingroup arithm

imProcessCalcAutoGamma
float imProcessCalcAutoGamma(const(imImage)* image)

Calculates an automatic gamma factor. \n * gamma=log((mean-min)/(max-min))/log(0.5); * Usefull for \ref imProcessToneGamut when using IM_GAMUT_POW. * * \verbatim im.ProcessCalcAutoGamma(image: imImage) -> gamma: number [in Lua 5] \endverbatim * \ingroup tonegamut

imProcessCompose
void imProcessCompose(const(imImage)* src_image1, const(imImage)* src_image2, imImage* dst_image)

Compose two images that have an alpha channel using the OVER operator. \n * Can be done in-place, images must match. \n * Maximum alpha values are baed in \ref imColorMax. Minimum is always 0. * \verbatim im.ProcessCompose(src_image1: imImage, src_image2: imImage, dst_image: imImage) [in Lua 5] \endverbatim * \verbatim im.ProcessComposeNew(image1: imImage, image2: imImage) -> new_image: imImage [in Lua 5] \endverbatim * \ingroup arithm

imProcessConvertColorSpace
int imProcessConvertColorSpace(const(imImage)* src_image, imImage* dst_image)

Same as \ref imConvertColorSpace. * But returns zero if the counter aborted. * * \verbatim im.ProcessConvertColorSpace(src_image: imImage, dst_image: imImage) -> error: number [in Lua 5] \endverbatim * \verbatim im.ProcessConvertColorSpaceNew(image: imImage, color_space: number, has_alpha: boolean) -> error: number, new_image: imImage [in Lua 5] \endverbatim * \ingroup procconvert

imProcessConvertDataType
int imProcessConvertDataType(const(imImage)* src_image, imImage* dst_image, int cpx2real, float gamma, int absolute, int cast_mode)

Same as \ref imConvertDataType. * But returns zero if the counter aborted. * * \verbatim im.ProcessConvertDataType(src_image: imImage, dst_image: imImage, cpx2real: number, gamma: number, absolute: boolean, cast_mode: number) -> error: number [in Lua 5] \endverbatim * \verbatim im.ProcessConvertDataTypeNew(image: imImage, data_type: number, cpx2real: number, gamma: number, absolute: boolean, cast_mode: number) -> error: number, new_image: imImage [in Lua 5] \endverbatim * \ingroup procconvert

imProcessConvertToBitmap
int imProcessConvertToBitmap(const(imImage)* src_image, imImage* dst_image, int cpx2real, float gamma, int absolute, int cast_mode)

Same as \ref imConvertToBitmap. * But returns zero if the counter aborted. * * \verbatim im.ProcessConvertToBitmap(src_image: imImage, dst_image: imImage, cpx2real: number, gamma: number, absolute: boolean, cast_mode: number) -> error: number [in Lua 5] \endverbatim * \verbatim im.ProcessConvertToBitmapNew(image: imImage, color_space: number, has_alpha: boolean, cpx2real: number, gamma: number, absolute: boolean, cast_mode: number) -> error: number, new_image: imImage [in Lua 5] \endverbatim * \ingroup procconvert

imProcessDifusionErrThreshold
void imProcessDifusionErrThreshold(const(imImage)* src_image, imImage* dst_image, int level)

Apply a dithering on each image channel by using a difusion error method. \n * It can be applied on any IM_BYTE images. It will "threshold" each channel indivudually, so * source and target must be of the same depth. * Not using OpenMP when enabled. * * \verbatim im.ProcessDifusionErrThreshold(src_image: imImage, dst_image: imImage, level: number) [in Lua 5] \endverbatim * \verbatim im.ProcessDifusionErrThresholdNew(src_image: imImage, level: number) -> new_image: imImage [in Lua 5] \endverbatim * \ingroup threshold

imProcessDirectConv
void imProcessDirectConv(const(imImage)* src_image, imImage* dst_image)

Directly converts integer and real data types into IM_BYTE images. \n * This can also be done using \ref imConvertDataType with IM_CAST_DIRECT flag. * * \verbatim im.ProcessDirectConv(src_image: imImage, dst_image: imImage) [in Lua 5] \endverbatim * \verbatim im.ProcessDirectConvNew(src_image: imImage) -> new_image: imImage [in Lua 5] \endverbatim * \ingroup tonegamut

imProcessEqualizeHistogram
void imProcessEqualizeHistogram(const(imImage)* src_image, imImage* dst_image)

Performs an histogram equalization. \n * Images must be (IM_BYTE, IM_SHORT or IM_USHORT)/(IM_RGB or IM_GRAY). Can be done in-place. * * \verbatim im.ProcessEqualizeHistogram(src_image: imImage, dst_image: imImage) [in Lua 5] \endverbatim * \verbatim im.ProcessEqualizeHistogramNew(src_image: imImage) -> new_image: imImage [in Lua 5] \endverbatim * \ingroup histo

imProcessExpandHistogram
void imProcessExpandHistogram(const(imImage)* src_image, imImage* dst_image, float percent)

Performs an histogram expansion based on a percentage of the number of pixels. \n * Percentage is used to obtain the amount of pixels of the lowest level and the highest level, relative to the total of pixels. * The histogram is used an each level is summed while the result is less than the obtained amount from 0 (for the lowest level) and from the last level (for the highest). * If it is zero, then only empty counts of the histogram will be considered. \n * Images must be (IM_BYTE, IM_SHORT or IM_USHORT)/(IM_RGB or IM_GRAY). Can be done in-place. \n * To expand the gamut without using the histogram, by just specifying the lowest and highest levels * use the \ref IM_GAMUT_EXPAND tone gamut operation (\ref imProcessToneGamut). * * \verbatim im.ProcessExpandHistogram(src_image: imImage, dst_image: imImage, percent: number) [in Lua 5] \endverbatim * \verbatim im.ProcessExpandHistogramNew(src_image: imImage, percent: number) -> new_image: imImage [in Lua 5] \endverbatim * \ingroup histo

imProcessHysteresisThresEstimate
void imProcessHysteresisThresEstimate(const(imImage)* image, int* low_level, int* high_level)

Estimates hysteresis low and high threshold levels. \n * Image data type can be IM_BYTE, IM_SHORT or IM_USHORT. \n * Usefull for \ref imProcessHysteresisThreshold. * * \verbatim im.ProcessHysteresisThresEstimate(image: imImage) -> low_level: number, high_level: number [in Lua 5] \endverbatim * \ingroup threshold

imProcessHysteresisThreshold
void imProcessHysteresisThreshold(const(imImage)* src_image, imImage* dst_image, int low_thres, int high_thres)

Apply a threshold by the Hysteresis method. \n * Hysteresis thersholding of edge pixels. Starting at pixels with a * value greater than the HIGH threshold, trace a connected sequence * of pixels that have a value greater than the LOW threhsold. \n * complex is not supported. Can be done in-place for IM_BYTE source. \n * Note: could not find the original source code author name. * * \verbatim im.ProcessHysteresisThreshold(src_image: imImage, dst_image: imImage, low_thres: number, high_thres: number) [in Lua 5] \endverbatim * \verbatim im.ProcessHysteresisThresholdNew(src_image: imImage, low_thres: number, high_thres: number) -> new_image: imImage [in Lua 5] \endverbatim * \ingroup threshold

imProcessLocalMaxThresEstimate
void imProcessLocalMaxThresEstimate(const(imImage)* image, int* level)

Estimates Local Max threshold level for images. * Image can be IM_BYTE, IM_SHORT or IM_USHORT. \n * * \verbatim im.ProcessLocalMaxThresEstimate(image: imImage) -> level: number [in Lua 5] \endverbatim * \ingroup threshold

imProcessMergeComplex
void imProcessMergeComplex(const(imImage)* src_image1, const(imImage)* src_image2, imImage* dst_image, int polar)

Merges two images as the real and imaginary parts of a complex image, \n * or as magnitude and phase parts (polar = 1). \n * Source images must be real, target image must be complex. * * \verbatim im.ProcessMergeComplex(src_image1: imImage, src_image2: imImage, dst_image: imImage, polar: boolean) [in Lua 5] \endverbatim * \verbatim im.ProcessMergeComplexNew(image1: imImage, image2: imImage, polar: boolean) -> new_image: imImage [in Lua 5] \endverbatim * \ingroup arithm

imProcessMergeComponents
void imProcessMergeComponents(const(imImage)** src_image_list, imImage* dst_image)

Merges separate components into a multicomponent image, including alpha.\n * Source images must be IM_GRAY. Size and data types must be all the same.\n * The number of source images must match the depth of the target image, including alpha. * * \verbatim im.ProcessMergeComponents(src_image_list: table of imImage, dst_image: imImage) [in Lua 5] \endverbatim * \verbatim im.ProcessMergeComponentsNew(src_image_list: table of imImage) -> dst_image: imImage [in Lua 5] \endverbatim * \ingroup colorproc

imProcessMergeHSI
void imProcessMergeHSI(const(imImage)* h_image, const(imImage)* s_image, const(imImage)* i_image, imImage* dst_image)

Merge HSI planes into a RGB image. \n * Source images must be IM_GRAY/IM_FLOAT. Target image can be IM_RGB/IM_BYTE or IM_RGB/IM_FLOAT only. \n * Source and target must have the same size. See \ref hsi for a definition of the color conversion. * * \verbatim im.ProcessMergeHSI(h_image: imImage, s_image: imImage, i_image: imImage, dst_image: imImage) [in Lua 5] \endverbatim * \verbatim im.ProcessMergeHSINew(h_image: imImage, s_image: imImage, i_image: imImage) -> dst_image: imImage [in Lua 5] \endverbatim * \ingroup colorproc

imProcessMinMaxThreshold
float imProcessMinMaxThreshold(const(imImage)* src_image, imImage* dst_image)

Calculates the threshold level for manual threshold using (max-min)/2. \n * Returns the used level. \n * Source color space must be IM_GRAY, and target color space must be IM_BINARY. * complex is not supported. Can be done in-place for IM_BYTE source. \n * * \verbatim im.ProcessMinMaxThreshold(src_image: imImage, dst_image: imImage) -> level: number [in Lua 5] \endverbatim * \verbatim im.ProcessMinMaxThresholdNew(src_image: imImage) -> level: number, new_image: imImage [in Lua 5] \endverbatim * \ingroup threshold

imProcessMultiPointColorOp
int imProcessMultiPointColorOp(const(imImage)** src_image_list, int src_image_count, imImage* dst_image, imMultiPointColorOpFunc func, float* params, void* userdata, const(char)* op_name)

Apply an multiple point color operation using a custom function. * One pixel from each source affects the same pixel on target. \n * All source images must match in size, depth and data type. * Can be done in-place, source and target must match size, depth can be different. * Data type can be different between sources and target, but complex is not supported. \n * op_name is used only by the counter and can be NULL. * Returns zero if the counter aborted. * * \verbatim im.ProcessMultiPointColorOp(src_image: table of imImage, dst_image: imImage, func: function, params: table, [op_name: string]) -> counter: boolean [in Lua 5] \endverbatim * \verbatim im.ProcessMultiPointColorOpNew(src_image: table of imImage, func: function, params: table, [op_name: string]) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim * In Lua, the params table is passed to the function by using the Lua stack, * so its table can contain any type of objects, but they all must be unnamed. * \ingroup point

imProcessMultiPointOp
int imProcessMultiPointOp(const(imImage)** src_image_list, int src_image_count, imImage* dst_image, imMultiPointOpFunc func, float* params, void* userdata, const(char)* op_name)

Apply an multiple point operation using a custom function. * One pixel from each source affects the same pixel on target. \n * All source images must match in size, depth and data type. * Can be done in-place, source and target must match size and depth. * Data type can be different between sources and target, but complex is not supported. \n * op_name is used only by the counter and can be NULL. * Returns zero if the counter aborted. * * \verbatim im.ProcessMultiPointOp(src_image: table of imImage, dst_image: imImage, func: function, params: table, [op_name: string]) -> counter: boolean [in Lua 5] \endverbatim * \verbatim im.ProcessMultiPointOpNew(src_image: table of imImage, func: function, params: table, [op_name: string]) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim * In Lua, the params table is passed to the function by using the Lua stack, * so its table can contain any type of objects, but they all must be unnamed. * \ingroup point

imProcessMultipleMean
void imProcessMultipleMean(const(imImage)** src_image_list, int src_image_count, imImage* dst_image)

Calculates the mean of multiple images. \n * Images must match size and type. * * \verbatim im.ProcessMultipleMean(src_image_list: table of imImage, dst_image: imImage) [in Lua 5] \endverbatim * \verbatim im.ProcessMultipleMeanNew(src_image_list: table of imImage) -> new_image: imImage [in Lua 5] \endverbatim * \ingroup arithm

imProcessMultipleMedian
int imProcessMultipleMedian(const(imImage)** src_image_list, int src_image_count, imImage* dst_image)

Calculates the median of multiple images. \n * Images must match size and type. Complex is not supported.\n * Uses \ref imProcessMultiPointOp internally. * * \verbatim im.ProcessMultipleMedian(src_image_list: table of imImage, dst_image: imImage) -> counter: boolean [in Lua 5] \endverbatim * \verbatim im.ProcessMultipleMedianNew(src_image_list: table of imImage) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim * \ingroup arithm

imProcessMultipleStdDev
void imProcessMultipleStdDev(const(imImage)** src_image_list, int src_image_count, const(imImage)* mean_image, imImage* dst_image)

Calculates the standard deviation of multiple images. \n * Images must match size and type. Use \ref imProcessMultipleMean to calculate the mean_image. * * \verbatim im.ProcessMultipleStdDev(src_image_list: table of imImage, mean_image: imImage, dst_image: imImage) [in Lua 5] \endverbatim * \verbatim im.ProcessMultipleStdDevNew(src_image_list: table of imImage, mean_image: imImage) -> new_image: imImage [in Lua 5] \endverbatim * \ingroup arithm

imProcessMultiplyConj
void imProcessMultiplyConj(const(imImage)* src_image1, const(imImage)* src_image2, imImage* dst_image)

Multiplies the conjugate of one complex image with another complex image. \n * Images must match size. Conj(img1) * img2 \n * Can be done in-place. * * \verbatim im.ProcessMultiplyConj(src_image1: imImage, src_image2: imImage, dst_image: imImage) [in Lua 5] \endverbatim * \verbatim im.ProcessMultiplyConjNew(src_image1: imImage, src_image2: imImage) -> new_image: imImage [in Lua 5] \endverbatim * \ingroup arithm

imProcessNegative
void imProcessNegative(const(imImage)* src_image, imImage* dst_image)

A negative effect. Uses \ref imProcessToneGamut with IM_GAMUT_INVERT for non MAP images. \n * Supports all color spaces and all data types except complex. \n * Can be done in-place. * * \verbatim im.ProcessNegative(src_image: imImage, dst_image: imImage) [in Lua 5] \endverbatim * \verbatim im.ProcessNegativeNew(src_image: imImage) -> new_image: imImage [in Lua 5] \endverbatim * \ingroup tonegamut

imProcessNormDiffRatio
void imProcessNormDiffRatio(const(imImage)* image1, const(imImage)* image2, imImage* dst_image)

Calculates the Normalized Difference Ratio. \n * Uses the formula NormDiffRatio = (a-b)/(a+b), \n * The result image has [-1,1] interval. \n * Images must be IM_GRAY, and the target image must be IM_FLOAT, except if source is IM_DOUBLE. * * \verbatim im.ProcessNormDiffRatio(image1: imImage, image2: imImage, dst_image: imImage) [in Lua 5] \endverbatim * \verbatim im.ProcessNormDiffRatioNew(image1: imImage, image2: imImage) -> new_image: imImage [in Lua 5] \endverbatim * \ingroup remotesens

imProcessNormalizeComponents
void imProcessNormalizeComponents(const(imImage)* src_image, imImage* dst_image)

Normalize the color components by their sum. Example: c1 = c1/(c1+c2+c3). \n * It will not change the alpha channel if any. * Target is IM_FLOAT, except if source is IM_DOUBLE. * * \verbatim im.ProcessNormalizeComponents(src_image: imImage, dst_image: imImage) [in Lua 5] \endverbatim * \verbatim im.ProcessNormalizeComponentsNew(src_image: imImage) -> new_image: imImage [in Lua 5] \endverbatim * \ingroup colorproc

imProcessOtsuThreshold
int imProcessOtsuThreshold(const(imImage)* src_image, imImage* dst_image)

Calculates the threshold level for manual threshold using the Otsu approach. \n * Image can be IM_BYTE, IM_SHORT or IM_USHORT. \n * Source color space must be IM_GRAY, and target color space must be IM_BINARY. * Returns the used level. \n * Original implementation by Flavio Szenberg. * * \verbatim im.ProcessOtsuThreshold(src_image: imImage, dst_image: imImage) -> level: number [in Lua 5] \endverbatim * \verbatim im.ProcessOtsuThresholdNew(src_image: imImage) -> level: number, new_image: imImage [in Lua 5] \endverbatim * \ingroup threshold

imProcessPercentThreshold
int imProcessPercentThreshold(const(imImage)* src_image, imImage* dst_image, float percent)

Calculates the threshold level for manual threshold using a percentage of pixels * that should stay bellow the threshold. \n * Image data type can be IM_BYTE, IM_SHORT or IM_USHORT. \n * Source color space must be IM_GRAY, and target color space must be IM_BINARY. * Returns the used level. * * \verbatim im.ProcessPercentThreshold(src_image: imImage, dst_image: imImage, percent: number) -> level: number [in Lua 5] \endverbatim * \verbatim im.ProcessPercentThresholdNew(src_image: imImage, percent: number) -> level: number, new_image: imImage [in Lua 5] \endverbatim * \ingroup threshold

imProcessPixelate
void imProcessPixelate(const(imImage)* src_image, imImage* dst_image, int box_size)

Generates a zoom in effect averaging colors inside a square region. \n * Operates only on IM_BYTE images. * * \verbatim im.ProcessPixelate(src_image: imImage, dst_image: imImage, box_size: number) [in Lua 5] \endverbatim * \verbatim im.ProcessPixelateNew(src_image: imImage, box_size: number) -> new_image: imImage [in Lua 5] \endverbatim * \ingroup effects

imProcessPosterize
void imProcessPosterize(const(imImage)* src_image, imImage* dst_image, int level)

A simple Posterize effect. It reduces the number of colors in the image eliminating * less significant bit planes. Can have 1 to 7 levels. See \ref imProcessBitMask. \n * Images must have data type IM_BYTE. * * \verbatim im.ProcessPosterize(src_image: imImage, dst_image: imImage, level: number) [in Lua 5] \endverbatim * \verbatim im.ProcessPosterizeNew(src_image: imImage, level: number) -> new_image: imImage [in Lua 5] \endverbatim * \ingroup effects

imProcessQuantizeGrayUniform
void imProcessQuantizeGrayUniform(const(imImage)* src_image, imImage* dst_image, int grays)

Quantizes a gray scale image in less that 256 grays using uniform quantization. \n * Both images should be IM_BYTE/IM_GRAY, the target can be IM_MAP. Can be done in-place. \n * The result is in the 0-255 range, except when target is IM_MAP that is in the 0-(grays-1) range. * * \verbatim im.ProcessQuantizeGrayUniform(src_image: imImage, dst_image: imImage, grays: number) [in Lua 5] \endverbatim * \verbatim im.ProcessQuantizeGrayUniformNew(src_image: imImage, grays: number) -> new_image: imImage [in Lua 5] \endverbatim * \ingroup quantize

imProcessQuantizeRGBUniform
void imProcessQuantizeRGBUniform(const(imImage)* src_image, imImage* dst_image, int do_dither)

Converts a RGB image to a MAP image using uniform quantization * with an optional 8x8 ordered dither. The RGB image must have data type IM_BYTE. * * \verbatim im.ProcessQuantizeRGBUniform(src_image: imImage, dst_image: imImage, do_dither: boolean) [in Lua 5] \endverbatim * \verbatim im.ProcessQuantizeRGBUniformNew(src_image: imImage, do_dither: boolean) -> new_image: imImage [in Lua 5] \endverbatim * \ingroup quantize

imProcessRenderAddGaussianNoise
int imProcessRenderAddGaussianNoise(const(imImage)* src_image, imImage* dst_image, float mean, float stddev)

Render gaussian noise on existing data. Can be done in-place. * * \verbatim im.ProcessRenderAddGaussianNoise(src_image: imImage, dst_image: imImage, mean: number, stddev: number) -> counter: boolean [in Lua 5] \endverbatim * \verbatim im.ProcessRenderAddGaussianNoiseNew(src_image: imImage, mean: number, stddev: number) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim * \ingroup render

imProcessRenderAddSpeckleNoise
int imProcessRenderAddSpeckleNoise(const(imImage)* src_image, imImage* dst_image, float percent)

Render speckle noise on existing data. Can be done in-place. * * \verbatim im.ProcessRenderAddSpeckleNoise(src_image: imImage, dst_image: imImage, percent: number) -> counter: boolean [in Lua 5] \endverbatim * \verbatim im.ProcessRenderAddSpeckleNoiseNew(src_image: imImage, percent: number) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim * \ingroup render

imProcessRenderAddUniformNoise
int imProcessRenderAddUniformNoise(const(imImage)* src_image, imImage* dst_image, float mean, float stddev)

Render uniform noise on existing data. Can be done in-place. * * \verbatim im.ProcessRenderAddUniformNoise(src_image: imImage, dst_image: imImage, mean: number, stddev: number) -> counter: boolean [in Lua 5] \endverbatim * \verbatim im.ProcessRenderAddUniformNoiseNew(src_image: imImage, mean: number, stddev: number) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim * \ingroup render

imProcessRenderBox
int imProcessRenderBox(imImage* image, int box_width, int box_height)

Render a centered box. * * \verbatim im.ProcessRenderBox(image: imImage, box_width: number, box_height: number) -> counter: boolean [in Lua 5] \endverbatim * \ingroup render

imProcessRenderChessboard
int imProcessRenderChessboard(imImage* image, int x_space, int y_space)

Render a centered chessboard. * * \verbatim im.ProcessRenderChessboard(image: imImage, x_space: number, y_space: number) -> counter: boolean [in Lua 5] \endverbatim * \ingroup render

imProcessRenderCondOp
int imProcessRenderCondOp(imImage* image, imRenderCondFunc func, const(char)* render_name, float* params)

Render a synthetic image using a conditional render function. \n * Data will be rendered only if the condional parameter is true. \n * Returns zero if the counter aborted. * * \verbatim im.ProcessRenderCondOp(image: imImage, func: function, render_name: string, params: table) -> counter: boolean [in Lua 5] \endverbatim * \ingroup render

imProcessRenderCone
int imProcessRenderCone(imImage* image, int radius)

Render a centered cone. * * \verbatim im.ProcessRenderCone(image: imImage, radius: number) -> counter: boolean [in Lua 5] \endverbatim * \ingroup render

imProcessRenderConstant
int imProcessRenderConstant(imImage* image, float* value)

Render a constant. The number of values must match the depth of the image. * * \verbatim im.ProcessRenderConstant(image: imImage, value: table of number) -> counter: boolean [in Lua 5] \endverbatim * \ingroup render

imProcessRenderCosine
int imProcessRenderCosine(imImage* image, float x_period, float y_period)

Render a centered cosine. * * \verbatim im.ProcessRenderCosine(image: imImage, x_period: number, y_period: number) -> counter: boolean [in Lua 5] \endverbatim * \ingroup render

imProcessRenderFloodFill
void imProcessRenderFloodFill(imImage* image, int start_x, int start_y, float* replace_color, float tolerance)

Render a color flood fill. \n * Image must the IM_RGB color space. replace_color must have 3 components. * * \verbatim im.ProcessRenderFloodFill(image: imImage, start_x, start_y: number, replace_color: table of 3 numbers, tolerance: number) [in Lua 5] \endverbatim * \ingroup render

imProcessRenderGaussian
int imProcessRenderGaussian(imImage* image, float stddev)

Render a centered gaussian. * * \verbatim im.ProcessRenderGaussian(image: imImage, stddev: number) -> counter: boolean [in Lua 5] \endverbatim * \ingroup render

imProcessRenderGrid
int imProcessRenderGrid(imImage* image, int x_space, int y_space)

Render a centered grid. * * \verbatim im.ProcessRenderGrid(image: imImage, x_space: number, y_space: number) -> counter: boolean [in Lua 5] \endverbatim * \ingroup render

imProcessRenderLapOfGaussian
int imProcessRenderLapOfGaussian(imImage* image, float stddev)

Render the laplacian of a centered gaussian. * * \verbatim im.ProcessRenderLapOfGaussian(image: imImage, stddev: number) -> counter: boolean [in Lua 5] \endverbatim * \ingroup render

imProcessRenderOp
int imProcessRenderOp(imImage* image, imRenderFunc func, const(char)* render_name, float* params, int plus)

Render a synthetic image using a render function. \n * plus will make the render be added to the current image data, * or else all data will be replaced. All the render functions use this or the conditional function. \n * Returns zero if the counter aborted. * * \verbatim im.ProcessRenderOp(image: imImage, func: function, render_name: string, params: table, plus: boolean) -> counter: boolean [in Lua 5] \endverbatim * \ingroup render

imProcessRenderRamp
int imProcessRenderRamp(imImage* image, int start, int end, int vert_dir)

Render a ramp. Direction can be vertical (1) or horizontal (0). * * \verbatim im.ProcessRenderRamp(image: imImage, start: number, end: number, vert_dir: boolean) -> counter: boolean [in Lua 5] \endverbatim * \ingroup render

imProcessRenderRandomNoise
int imProcessRenderRandomNoise(imImage* image)

Render random noise. * * \verbatim im.ProcessRenderRandomNoise(image: imImage) -> counter: boolean [in Lua 5] \endverbatim * \ingroup render

imProcessRenderSinc
int imProcessRenderSinc(imImage* image, float x_period, float y_period)

Render a centered sinc. * * \verbatim im.ProcessRenderSinc(image: imImage, x_period: number, y_period: number) -> counter: boolean [in Lua 5] \endverbatim * \ingroup render

imProcessRenderTent
int imProcessRenderTent(imImage* image, int tent_width, int tent_height)

Render a centered tent. * * \verbatim im.ProcessRenderTent(image: imImage, tent_width: number, tent_height: number) -> counter: boolean [in Lua 5] \endverbatim * \ingroup render

imProcessRenderWheel
int imProcessRenderWheel(imImage* image, int internal_radius, int external_radius)

Render a centered wheel. * * \verbatim im.ProcessRenderWheel(image: imImage, internal_radius: number, external_radius: number) -> counter: boolean [in Lua 5] \endverbatim * \ingroup render

imProcessReplaceColor
void imProcessReplaceColor(const(imImage)* src_image, imImage* dst_image, float* src_color, float* dst_color)

Replaces the source color by the target color. \n * The color will be type casted to the image data type. \n * The colors must have the same number of components of the images. \n * Supports all color spaces and all data types except complex. * * \verbatim im.ProcessReplaceColor(src_image: imImage, dst_image: imImage, src_color: table of numbers, dst_color: table of numbers) [in Lua 5] \endverbatim * \verbatim im.ProcessReplaceColorNew(src_image: imImage, src_color: table of numbers, dst_color: table of numbers) -> new_image: imImage [in Lua 5] \endverbatim * \ingroup colorproc

imProcessSetAlphaColor
void imProcessSetAlphaColor(const(imImage)* src_image, imImage* dst_image, float* src_color, float dst_alpha)

Sets the alpha channel in target where the given color occours in source, * elsewhere alpha remains untouched. \n * The color must have the same number of components of the source image. \n * If target does not have an alpha channel, then its plane=0 is used. \n * Supports all color spaces for source and all data types except complex. * Images must have the same size. * * \verbatim im.ProcessSetAlphaColor(src_image: imImage, dst_image: imImage, src_color: table of numbers, dst_alpha: number) [in Lua 5] \endverbatim * \ingroup colorproc

imProcessShiftHSI
void imProcessShiftHSI(const(imImage)* src_image, imImage* dst_image, float h_shift, float s_shift, float i_shift)

Apply a shift using HSI coordinates. \n * Supports all data types except complex. \n * Can be done in-place. * * \verbatim im.ProcessShiftHSI(src_image: imImage, dst_image: imImage, h_shift, s_shift, i_shift: number) [in Lua 5] \endverbatim * \verbatim im.ProcessShiftHSI(src_image: imImage, h_shift, s_shift, i_shift: number) -> new_image: imImage [in Lua 5] \endverbatim * \ingroup tonegamut

imProcessSliceThreshold
void imProcessSliceThreshold(const(imImage)* src_image, imImage* dst_image, float start_level, float end_level)

Apply a manual threshold using an interval. \n * threshold = start_level <= a <= end_level ? 1: 0 \n * Normal value is 1 but another common value is 255. \n * Source color space must be IM_GRAY, and target color space must be IM_BINARY. * complex is not supported. Can be done in-place for IM_BYTE source. \n * * \verbatim im.ProcessSliceThreshold(src_image: imImage, dst_image: imImage, start_level: number, end_level: number) [in Lua 5] \endverbatim * \verbatim im.ProcessSliceThresholdNew(src_image: imImage, start_level: number, end_level: number) -> new_image: imImage [in Lua 5] \endverbatim * \ingroup threshold

imProcessSplitComplex
void imProcessSplitComplex(const(imImage)* src_image, imImage* dst_image1, imImage* dst_image2, int polar)

Split a complex image into two images with real and imaginary parts \n * or magnitude and phase parts (polar). \n * Source image must be complex, target images must be real. * * \verbatim im.ProcessSplitComplex(src_image: imImage, dst_image1: imImage, dst_image2: imImage, polar: boolean) [in Lua 5] \endverbatim * \verbatim im.ProcessSplitComplexNew(image: imImage, polar: boolean) -> dst_image1: imImage, dst_image2: imImage [in Lua 5] \endverbatim * \ingroup arithm

imProcessSplitComponents
void imProcessSplitComponents(const(imImage)* src_image, imImage** dst_image_list)

Split a multicomponent image into separate components, including alpha.\n * Target images must be IM_GRAY. Size and data types must be all the same.\n * The number of target images must match the depth of the source image, including alpha. * * \verbatim im.ProcessSplitComponents(src_image: imImage, dst_image_list: table of imImage) [in Lua 5] \endverbatim * \verbatim im.ProcessSplitComponentsNew(src_image: imImage) -> dst_image_list: table of imImage [in Lua 5] \endverbatim * \ingroup colorproc

imProcessSplitHSI
void imProcessSplitHSI(const(imImage)* src_image, imImage* h_image, imImage* s_image, imImage* i_image)

Split a RGB image into HSI planes. \n * Source image can be IM_RGB/IM_BYTE or IM_RGB/IM_FLOAT only. Target images are all IM_GRAY/IM_FLOAT. \n * Source images must normalized to 0-1 if type is IM_FLOAT (\ref imProcessToneGamut can be used). * See \ref hsi for a definition of the color conversion.\n * Source and target must have the same size. * * \verbatim im.ProcessSplitHSI(src_image: imImage, h_image: imImage, s_image: imImage, i_image: imImage) [in Lua 5] \endverbatim * \verbatim im.ProcessSplitHSINew(src_image: imImage) -> h_image: imImage, s_image: imImage, i_image: imImage [in Lua 5] \endverbatim * \ingroup colorproc

imProcessSplitYChroma
void imProcessSplitYChroma(const(imImage)* src_image, imImage* y_image, imImage* chroma_image)

Split a RGB image into luma and chroma. \n * Chroma is calculated as R-Y,G-Y,B-Y. Source image must be IM_RGB/IM_BYTE. \n * luma image is IM_GRAY/IM_BYTE and chroma is IM_RGB/IM_BYTE. \n * Source and target must have the same size. * * \verbatim im.ProcessSplitYChroma(src_image: imImage, y_image: imImage, chroma_image: imImage) [in Lua 5] \endverbatim * \verbatim im.ProcessSplitYChromaNew(src_image: imImage) -> y_image: imImage, chroma_image: imImage [in Lua 5] \endverbatim * \ingroup colorproc

imProcessThreshold
void imProcessThreshold(const(imImage)* src_image, imImage* dst_image, float level, int value)

Apply a manual threshold. \n * threshold = a <= level ? 0: value \n * Normal value is 1 but another common value is 255. Can be done in-place for IM_BYTE source. \n * Source color space must be IM_GRAY, and target color space must be IM_BINARY. * complex is not supported. \n * * \verbatim im.ProcessThreshold(src_image: imImage, dst_image: imImage, level: number, value: number) [in Lua 5] \endverbatim * \verbatim im.ProcessThresholdNew(src_image: imImage, level: number, value: number) -> new_image: imImage [in Lua 5] \endverbatim * \ingroup threshold

imProcessThresholdByDiff
void imProcessThresholdByDiff(const(imImage)* src_image1, const(imImage)* src_image2, imImage* dst_image)

Apply a threshold by the difference of two images. \n * threshold = a1 <= a2 ? 0: 1 \n * Source color space must be IM_GRAY, and target color space must be IM_BINARY. * complex is not supported. Can be done in-place for IM_BYTE source. \n * * \verbatim im.ProcessThresholdByDiff(src_image1: imImage, src_image2: imImage, dst_image: imImage) [in Lua 5] \endverbatim * \verbatim im.ProcessThresholdByDiffNew(src_image1: imImage, src_image2: imImage) -> new_image: imImage [in Lua 5] \endverbatim * \ingroup threshold

imProcessToneGamut
void imProcessToneGamut(const(imImage)* src_image, imImage* dst_image, int op, float* params)

Apply a gamut operation with arguments. \n * Supports all data types except complex. \n * For IM_GAMUT_NORMALIZE when min > 0 and max < 1, it will just do a copy. \n * IM_BYTE images have min=0 and max=255 always. \n * To control min and max values use the IM_GAMUT_MINMAX flag. * Can be done in-place. When there is no extra parameters, params can use NULL. * * \verbatim im.ProcessToneGamut(src_image: imImage, dst_image: imImage, op: number, params: table of number) [in Lua 5] \endverbatim * \verbatim im.ProcessToneGamutNew(src_image: imImage, op: number, params: table of number) -> new_image: imImage [in Lua 5] \endverbatim * See also \ref imageenhance. * \ingroup tonegamut

imProcessUnArithmeticOp
void imProcessUnArithmeticOp(const(imImage)* src_image, imImage* dst_image, int op)

Apply an arithmetic unary operation. \n * Can be done in-place, images must match color space and size. \n * Target image can be several types depending on source: \n * \li any integer -> any integer or real * \li real -> real * \li complex -> complex * If source is complex, target complex must be the same data type (imcfloat-imcfloat or imcdouble-imcdouble only). \n * If target is byte, then the result is cropped to 0-255. * * \verbatim im.ProcessUnArithmeticOp(src_image: imImage, dst_image: imImage, op: number) [in Lua 5] \endverbatim * \verbatim im.ProcessUnArithmeticOpNew(image: imImage, op: number) -> new_image: imImage [in Lua 5] \endverbatim * \ingroup arithm

imProcessUnNormalize
void imProcessUnNormalize(const(imImage)* src_image, imImage* dst_image)

Converts from (0-1) to (0-255), crop out of bounds values. \n * Source image must be real, and target image must be IM_BYTE. * * \verbatim im.ProcessUnNormalize(src_image: imImage, dst_image: imImage) [in Lua 5] \endverbatim * \verbatim im.ProcessUnNormalizeNew(src_image: imImage) -> new_image: imImage [in Lua 5] \endverbatim * \ingroup tonegamut

imProcessUnaryPointColorOp
int imProcessUnaryPointColorOp(const(imImage)* src_image, imImage* dst_image, imUnaryPointColorOpFunc func, float* params, void* userdata, const(char)* op_name)

Apply an unary point color operation using a custom function. * One pixel from the source affects the same pixel on target. \n * Can be done in-place, images must match size, depth can be different. * Data type can be different, but complex is not supported. \n * op_name is used only by the counter and can be NULL. * Returns zero if the counter aborted. * * \verbatim im.ProcessUnaryPointColorOp(src_image: imImage, dst_image: imImage, func: function, params: table, [op_name: string]) -> counter: boolean [in Lua 5] \endverbatim * \verbatim im.ProcessUnaryPointColorOpNew(image: imImage, func: function, params: table, [op_name: string]) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim * In Lua, the params table is passed to the function by using the Lua stack, * so its table can contain any type of objects, but they all must be unnamed. * \ingroup point

imProcessUnaryPointOp
int imProcessUnaryPointOp(const(imImage)* src_image, imImage* dst_image, imUnaryPointOpFunc func, float* params, void* userdata, const(char)* op_name)

Apply an unary point operation using a custom function. * One pixel from the source affects the same pixel on target. \n * Can be done in-place, images must match size and depth. * Data type can be different, but complex is not supported. \n * op_name is used only by the counter and can be NULL. * Returns zero if the counter aborted. * * \verbatim im.ProcessUnaryPointOp(src_image: imImage, dst_image: imImage, func: function, params: table, [op_name: string]) -> counter: boolean [in Lua 5] \endverbatim * \verbatim im.ProcessUnaryPointOpNew(image: imImage, func: function, params: table, [op_name: string]) -> counter: boolean, new_image: imImage [in Lua 5] \endverbatim * In Lua, the params table is passed to the function by using the Lua stack, * so its table can contain any type of objects, but they all must be unnamed. * \ingroup point

imProcessUniformErrThreshold
int imProcessUniformErrThreshold(const(imImage)* src_image, imImage* dst_image)

Calculates the threshold level for manual threshold using an uniform error approach. \n * Supports only IM_BYTE images. * Extracted from XITE, Copyright 1991, Blab, UiO \n * http://www.ifi.uio.no/~blab/Software/Xite/ \verbatim Reference: S. M. Dunn & D. Harwood & L. S. Davis: "Local Estimation of the Uniform Error Threshold" IEEE Trans. on PAMI, Vol PAMI-6, No 6, Nov 1984. Comments: It only works well on images whith large objects.

Mixins

__anonymous
mixin FreeEnumMembers!imUnaryOp
Undocumented in source but is binding to C. You might be able to learn more by searching the web for its name.
__anonymous
mixin FreeEnumMembers!imBinaryOp
Undocumented in source but is binding to C. You might be able to learn more by searching the web for its name.
__anonymous
mixin FreeEnumMembers!imLogicOp
Undocumented in source but is binding to C. You might be able to learn more by searching the web for its name.
__anonymous
mixin FreeEnumMembers!imToneGamut
Undocumented in source but is binding to C. You might be able to learn more by searching the web for its name.
__anonymous
mixin FreeEnumMembers!imToneGamutFlags
Undocumented in source but is binding to C. You might be able to learn more by searching the web for its name.

Meta