summaryrefslogtreecommitdiff
path: root/src/lua5
diff options
context:
space:
mode:
Diffstat (limited to 'src/lua5')
-rw-r--r--src/lua5/.cvsignore9
-rw-r--r--src/lua5/im_fftw.lua48
-rw-r--r--src/lua5/im_process.lua326
-rw-r--r--src/lua5/imlua.c246
-rw-r--r--src/lua5/imlua.def24
-rw-r--r--src/lua5/imlua_aux.c255
-rw-r--r--src/lua5/imlua_aux.h82
-rw-r--r--src/lua5/imlua_avi.c44
-rw-r--r--src/lua5/imlua_avi.def4
-rw-r--r--src/lua5/imlua_capture.c421
-rw-r--r--src/lua5/imlua_capture.def5
-rw-r--r--src/lua5/imlua_convert.c79
-rw-r--r--src/lua5/imlua_fftw.c162
-rw-r--r--src/lua5/imlua_fftw.def4
-rw-r--r--src/lua5/imlua_file.c661
-rw-r--r--src/lua5/imlua_image.c1061
-rw-r--r--src/lua5/imlua_image.h38
-rw-r--r--src/lua5/imlua_jp2.c44
-rw-r--r--src/lua5/imlua_jp2.def4
-rw-r--r--src/lua5/imlua_kernel.c182
-rw-r--r--src/lua5/imlua_palette.c399
-rw-r--r--src/lua5/imlua_palette.h32
-rw-r--r--src/lua5/imlua_process.c3091
-rw-r--r--src/lua5/imlua_process.def4
-rw-r--r--src/lua5/imlua_util.c279
-rw-r--r--src/lua5/imlua_wmv.c44
-rw-r--r--src/lua5/imlua_wmv.def4
27 files changed, 7552 insertions, 0 deletions
diff --git a/src/lua5/.cvsignore b/src/lua5/.cvsignore
new file mode 100644
index 0000000..521532a
--- /dev/null
+++ b/src/lua5/.cvsignore
@@ -0,0 +1,9 @@
+so_locations
+*.dep
+*.wdep
+*.loh
+.plan
+.project
+*.err
+Makefile
+*.make
diff --git a/src/lua5/im_fftw.lua b/src/lua5/im_fftw.lua
new file mode 100644
index 0000000..e57c7bf
--- /dev/null
+++ b/src/lua5/im_fftw.lua
@@ -0,0 +1,48 @@
+
+-------------------------------------------------------------------------------
+-- Creates a new function, with the name suffixed by "New". This new function
+-- creates a new image, based on a source image, and calls the previous function
+-- with this new image.
+
+local function OneSourceOneDest (funcname, width, height, color_space, data_type)
+ local func = im[funcname]
+ assert(func) -- see if function is really defined
+
+ -- define function with "New" suffix
+ im[funcname.."New"] = function (src_image, ...)
+ -- create destination image
+ local dst_image = im.ImageCreateBased(src_image, width, height, color_space, data_type)
+
+ -- call previous method, repassing all parameters
+ func(src_image, dst_image, unpack(arg))
+ return dst_image
+ end
+end
+
+-------------------------------------------------------------------------------
+-- This function is similar to OneSourceOneDest, but it receives two source
+-- images.
+
+local function TwoSourcesOneDest (funcname, width, height, color_space, data_type)
+ local func = im[funcname]
+
+ -- see if function is really defined
+ assert(func, string.format("undefined function `%s'", funcname))
+
+ -- define function with "New" suffix
+ im[funcname.."New"] = function (src_image1, src_image2, ...)
+ -- create destination image
+ local dst_image = im.ImageCreateBased(src_image1, width, height, color_space, data_type)
+
+ -- call previous method, repassing all parameters
+ func(src_image1, src_image2, dst_image, unpack(arg))
+ return dst_image
+ end
+end
+
+-------------------------------------------------------------------------------
+
+TwoSourcesOneDest("ProcessCrossCorrelation")
+OneSourceOneDest("ProcessAutoCorrelation", nil, nil, nil, im.CFLOAT)
+OneSourceOneDest("ProcessFFT")
+OneSourceOneDest("ProcessIFFT")
diff --git a/src/lua5/im_process.lua b/src/lua5/im_process.lua
new file mode 100644
index 0000000..1d91d5e
--- /dev/null
+++ b/src/lua5/im_process.lua
@@ -0,0 +1,326 @@
+
+-------------------------------------------------------------------------------
+-- Creates a new function, with the name suffixed by "New". This new function
+-- creates a new image, based on a source image, and calls the previous function
+-- with this new image.
+-- We assume here that the functions returns only one parameter or none.
+
+local function OneSourceOneDest (funcname, width, height, color_space, data_type)
+ local func = im[funcname]
+ assert(func) -- see if function is really defined
+
+ -- define function with "New" suffix
+ im[funcname.."New"] = function (src_image, ...)
+ -- create destination image
+ local dst_image = im.ImageCreateBased(src_image, width, height, color_space, data_type)
+
+ -- call previous method, repassing all parameters
+ local ret = func(src_image, dst_image, unpack(arg))
+ if (ret) then
+ return ret, dst_image
+ else
+ return dst_image
+ end
+ end
+end
+
+-------------------------------------------------------------------------------
+-- This function is similar to OneSourceOneDest, but it receives two source
+-- images.
+
+local function TwoSourcesOneDest (funcname, width, height, color_space, data_type)
+ local func = im[funcname]
+
+ -- see if function is really defined
+ assert(func, string.format("undefined function `%s'", funcname))
+
+ -- define function with "New" suffix
+ im[funcname.."New"] = function (src_image1, src_image2, ...)
+ -- create destination image
+ local dst_image = im.ImageCreateBased(src_image1, width, height, color_space, data_type)
+
+ -- call previous method, repassing all parameters
+ local ret = func(src_image1, src_image2, dst_image, unpack(arg))
+ if (ret) then
+ return ret, dst_image
+ else
+ return dst_image
+ end
+ end
+end
+
+-------------------------------------------------------------------------------
+-- This function is similar to OneSourceOneDest, but it receives three source
+-- images.
+
+local function ThreeSourcesOneDest (funcname, width, height, color_space, data_type)
+ local func = im[funcname]
+ assert(func) -- see if function is really defined
+
+ -- define function with "New" suffix
+ im[funcname.."New"] = function (src_image1, src_image2, src_image3, ...)
+ -- create destination image
+ local dst_image = im.ImageCreateBased(src_image1, width, height, color_space, data_type)
+
+ -- call previous method, repassing all parameters
+ local ret = func(src_image1, src_image2, src_image3, dst_image, unpack(arg))
+ if (ret) then
+ return ret, dst_image
+ else
+ return dst_image
+ end
+ end
+end
+
+-------------------------------------------------------------------------------
+-- This function is similar to OneSourceOneDest, but it creates two destiny
+-- images.
+
+local function OneSourceTwoDests (funcname, width, height, color_space, data_type)
+ local func = im[funcname]
+ assert(func) -- see if function is really defined
+
+ -- define function with "New" suffix
+ im[funcname.."New"] = function (src_image, ...)
+ -- create destination image
+ local dst_image1 = im.ImageCreateBased(src_image, width, height, color_space, data_type)
+ local dst_image2 = im.ImageCreateBased(src_image, width, height, color_space, data_type)
+
+ -- call previous method, repassing all parameters
+ local ret = func(src_image, dst_image1, dst_image2, unpack(arg))
+ if (ret) then
+ return ret, dst_image1, dst_image2
+ else
+ return dst_image1, dst_image2
+ end
+ end
+end
+
+-------------------------------------------------------------------------------
+-- This function is similar to OneSourceOneDest, but it creates three destiny
+-- images.
+
+local function OneSourceThreeDests (funcname, width, height, color_space, data_type)
+ local func = im[funcname]
+ assert(func) -- see if function is really defined
+
+ -- define function with "New" suffix
+ im[funcname.."New"] = function (src_image, ...)
+ -- create destination image
+ local dst_image1 = im.ImageCreateBased(src_image, width, height, color_space, data_type)
+ local dst_image2 = im.ImageCreateBased(src_image, width, height, color_space, data_type)
+ local dst_image3 = im.ImageCreateBased(src_image, width, height, color_space, data_type)
+
+ -- call previous method, repassing all parameters
+ local ret = func(src_image, dst_image1, dst_image2, dst_image3, unpack(arg))
+ if (ret) then
+ return ret, dst_image1, dst_image2, dst_image3
+ else
+ return dst_image1, dst_image2, dst_image3
+ end
+ end
+end
+
+-------------------------------------------------------------------------------
+
+local function hough_height(image)
+ local function sqr(x) return x*x end
+ local rmax = math.sqrt(sqr(image:Width()) + sqr(image:Height())) / 2
+ return 2*rmax+1
+end
+
+OneSourceOneDest("AnalyzeFindRegions", nil, nil, nil, im.USHORT)
+OneSourceOneDest("ProcessPerimeterLine")
+OneSourceOneDest("ProcessPrune")
+OneSourceOneDest("ProcessFillHoles")
+OneSourceOneDest("ProcessHoughLines", 180, hough_height, im.GRAY, im.INT)
+OneSourceOneDest("ProcessHoughLinesDraw")
+OneSourceOneDest("ProcessDistanceTransform", nil, nil, nil, im.FLOAT)
+OneSourceOneDest("ProcessRegionalMaximum", nil, nil, im.BINARY, nil)
+
+function im.ProcessReduceNew (src_image, width, height)
+ local dst_image = im.ImageCreateBased(src_image, width, height)
+ return im.ProcessReduce(src_image, dst_image), dst_image
+end
+
+function im.ProcessResizeNew (src_image, width, height)
+ local dst_image = im.ImageCreateBased(src_image, width, height)
+ return im.ProcessResize(src_image, dst_image), dst_image
+end
+
+OneSourceOneDest("ProcessReduceBy4", function (image) return image:Width() / 2 end,
+ function (image) return image:Height() / 2 end)
+
+function im.ProcessCropNew (src_image, xmin, xmax, ymin, ymax)
+ local width = xmax - xmin + 1
+ local height = xmax - ymin + 1
+ local dst_image = im.ImageCreateBased(src_image, width, height)
+ im.ProcessCrop(src_image, dst_image, xmin, ymin)
+ return dst_image
+end
+
+TwoSourcesOneDest("ProcessInsert")
+
+function im.ProcessAddMarginsNew (src_image, xmin, xmax, ymin, ymax)
+ local width = xmax - xmin + 1
+ local height = xmax - ymin + 1
+ local dst_image = im.ImageCreateBased(src_image, width, height)
+ im.ProcessAddMargins(src_image, dst_image, xmin, ymin)
+ return dst_image
+end
+
+function im.ProcessRotateNew (src_image, cos0, sin0, order)
+ local width, height = im.ProcessCalcRotateSize(src_image:Width(), src_image:Height(), cos0, sin0)
+ local dst_image = im.ImageCreateBased(src_image, width, height)
+ return im.ProcessRotate(src_image, dst_image, cos0, sin0, order), dst_image
+end
+
+OneSourceOneDest("ProcessRotateRef")
+OneSourceOneDest("ProcessRotate90", function (image) return image:Height() end, function (image) return image:Width() end)
+OneSourceOneDest("ProcessRotate180")
+OneSourceOneDest("ProcessMirror")
+OneSourceOneDest("ProcessFlip")
+OneSourceOneDest("ProcessRadial")
+OneSourceOneDest("ProcessGrayMorphConvolve")
+OneSourceOneDest("ProcessGrayMorphErode")
+OneSourceOneDest("ProcessGrayMorphDilate")
+OneSourceOneDest("ProcessGrayMorphOpen")
+OneSourceOneDest("ProcessGrayMorphClose")
+OneSourceOneDest("ProcessGrayMorphTopHat")
+OneSourceOneDest("ProcessGrayMorphWell")
+OneSourceOneDest("ProcessGrayMorphGradient")
+OneSourceOneDest("ProcessBinMorphConvolve")
+OneSourceOneDest("ProcessBinMorphErode")
+OneSourceOneDest("ProcessBinMorphDilate")
+OneSourceOneDest("ProcessBinMorphOpen")
+OneSourceOneDest("ProcessBinMorphClose")
+OneSourceOneDest("ProcessBinMorphOutline")
+OneSourceOneDest("ProcessBinMorphThin")
+OneSourceOneDest("ProcessMedianConvolve")
+OneSourceOneDest("ProcessRangeConvolve")
+OneSourceOneDest("ProcessRankClosestConvolve")
+OneSourceOneDest("ProcessRankMaxConvolve")
+OneSourceOneDest("ProcessRankMinConvolve")
+OneSourceOneDest("ProcessConvolve")
+OneSourceOneDest("ProcessConvolveSep")
+OneSourceOneDest("ProcessConvolveRep")
+OneSourceOneDest("ProcessConvolveDual")
+OneSourceOneDest("ProcessCompassConvolve")
+OneSourceOneDest("ProcessMeanConvolve")
+OneSourceOneDest("ProcessGaussianConvolve")
+OneSourceOneDest("ProcessBarlettConvolve")
+OneSourceTwoDests("ProcessInterlaceSplit", nil, function (image) if (image:Height()) then return image:Height() else return image:Height()/2 end end)
+
+function im.ProcessInterlaceSplitNew(src_image)
+ -- create destination image
+ local dst_height1 = src_image:Height()/2
+ if math.mod(src_image:Height(), 2) then
+ dst_height1 = dst_height1 + 1
+ end
+
+ local dst_image1 = im.ImageCreateBased(src_image, nil, dst_height1)
+ local dst_image2 = im.ImageCreateBased(src_image, nil, src_image:Height()/2)
+
+ -- call method, repassing all parameters
+ im.ProcessInterlaceSplit(src_image, dst_image1, dst_image2)
+ return dst_image1, dst_image2
+end
+
+local function int_datatype (image)
+ local data_type = image:DataType()
+ if data_type == im.BYTE or data_type == im.USHORT then
+ data_type = im.INT
+ end
+ return data_type
+end
+
+OneSourceOneDest("ProcessDiffOfGaussianConvolve", nil, nil, nil, int_datatype)
+OneSourceOneDest("ProcessLapOfGaussianConvolve", nil, nil, nil, int_datatype)
+OneSourceOneDest("ProcessSobelConvolve")
+OneSourceOneDest("ProcessSplineEdgeConvolve")
+OneSourceOneDest("ProcessPrewittConvolve")
+OneSourceOneDest("ProcessZeroCrossing")
+OneSourceOneDest("ProcessCanny")
+OneSourceOneDest("ProcessUnArithmeticOp")
+TwoSourcesOneDest("ProcessArithmeticOp")
+
+function im.ProcessArithmeticConstOpNew (src_image, src_const, op)
+ local dst_image = im.ImageCreateBased(src_image)
+ im.ProcessArithmeticConstOp(src_image, src_const, dst_image, op)
+ return dst_image
+end
+
+TwoSourcesOneDest("ProcessBlendConst")
+ThreeSourcesOneDest("ProcessBlend")
+OneSourceTwoDests("ProcessSplitComplex")
+TwoSourcesOneDest("ProcessMergeComplex", nil, nil, nil, im.CFLOAT)
+
+function im.ProcessMultipleMeanNew (src_image_list, dst_image)
+ local dst_image = im.ImageCreateBased(src_image_list[1])
+ im.ProcessMultipleMean(src_image_list, dst_image)
+ return dst_image
+end
+
+function im.ProcessMultipleStdDevNew (src_image_list, mean_image)
+ local dst_image = im.ImageCreateBased(src_image_list[1])
+ im.ProcessMultipleStdDev(src_image_list, mean_image, dst_image)
+ return dst_image
+end
+
+TwoSourcesOneDest("ProcessAutoCovariance")
+OneSourceOneDest("ProcessMultiplyConj")
+OneSourceOneDest("ProcessQuantizeRGBUniform", nil, nil, im.MAP, nil)
+OneSourceOneDest("ProcessQuantizeGrayUniform")
+OneSourceOneDest("ProcessExpandHistogram")
+OneSourceOneDest("ProcessEqualizeHistogram")
+
+function im.ProcessSplitYChromaNew (src_image)
+ local y_image = im.ImageCreateBased(src_image, nil, nil, im.GRAY, im.BYTE)
+ local chroma_image = im.ImageCreateBased(src_image, nil, nil, im.RGB, im.BYTE)
+ im.ProcessSplitYChroma(src_image, y_image, chroma_image)
+ return y_image, chroma_image
+end
+
+OneSourceThreeDests("ProcessSplitHSI", nil, nil, im.GRAY, im.FLOAT)
+ThreeSourcesOneDest("ProcessMergeHSI", nil, nil, im.RGB, im.BYTE)
+
+function im.ProcessSplitComponentsNew (src_image)
+ local depth = src_image:Depth()
+ local dst_images = {}
+ for i = 1, depth do
+ table.insert(dst_images, im.ImageCreateBased(src_image, nil, nil, im.GRAY))
+ end
+ im.ProcessSplitComponents(src_image, dst_images)
+ return unpack(dst_images)
+end
+
+function im.ProcessMergeComponentsNew (src_image_list)
+ local dst_image = im.ImageCreateBased(src_image_list[1], nil, nil, im.RGB)
+ im.ProcessMergeComponents(src_image_list, dst_image)
+ return dst_image
+end
+
+OneSourceOneDest("ProcessNormalizeComponents", nil, nil, nil, im.FLOAT)
+OneSourceOneDest("ProcessReplaceColor")
+TwoSourcesOneDest("ProcessBitwiseOp")
+OneSourceOneDest("ProcessBitwiseNot")
+OneSourceOneDest("ProcessBitMask")
+OneSourceOneDest("ProcessBitPlane")
+OneSourceOneDest("ProcessToneGamut")
+OneSourceOneDest("ProcessUnNormalize", nil, nil, nil, im.BYTE)
+OneSourceOneDest("ProcessDirectConv", nil, nil, nil, im.BYTE)
+OneSourceOneDest("ProcessNegative")
+OneSourceOneDest("ProcessRangeContrastThreshold", nil, nil, im.BINARY, nil)
+OneSourceOneDest("ProcessLocalMaxThreshold", nil, nil, im.BINARY, nil)
+OneSourceOneDest("ProcessThreshold", nil, nil, im.BINARY, nil)
+TwoSourcesOneDest("ProcessThresholdByDiff")
+OneSourceOneDest("ProcessHysteresisThreshold", nil, nil, im.BINARY, nil)
+OneSourceOneDest("ProcessUniformErrThreshold", nil, nil, im.BINARY, nil)
+OneSourceOneDest("ProcessDifusionErrThreshold")
+OneSourceOneDest("ProcessPercentThreshold")
+OneSourceOneDest("ProcessOtsuThreshold")
+OneSourceOneDest("ProcessMinMaxThreshold", nil, nil, im.BINARY, nil)
+OneSourceOneDest("ProcessSliceThreshold", nil, nil, im.BINARY, nil)
+OneSourceOneDest("ProcessPixelate")
+OneSourceOneDest("ProcessPosterize")
+
diff --git a/src/lua5/imlua.c b/src/lua5/imlua.c
new file mode 100644
index 0000000..7d39ee7
--- /dev/null
+++ b/src/lua5/imlua.c
@@ -0,0 +1,246 @@
+/** \file
+ * \brief IM Lua 5 Binding
+ *
+ * See Copyright Notice in im_lib.h
+ * $Id: imlua.c,v 1.1 2008/10/17 06:16:32 scuri Exp $
+ */
+
+#include <string.h>
+#include <memory.h>
+#include <stdlib.h>
+
+#include "im.h"
+#include "im_lib.h"
+#include "im_image.h"
+#include "im_convert.h"
+
+#include <lua.h>
+#include <lauxlib.h>
+
+#include "imlua.h"
+#include "imlua_aux.h"
+#include "imlua_image.h"
+#include "imlua_palette.h"
+
+/*****************************************************************************\
+ im.Version()
+\*****************************************************************************/
+static int imluaVersion (lua_State *L)
+{
+ lua_pushstring(L, imVersion());
+ return 1;
+}
+
+/*****************************************************************************\
+ im.VersionDate()
+\*****************************************************************************/
+static int imluaVersionDate (lua_State *L)
+{
+ lua_pushstring(L, imVersionDate());
+ return 1;
+}
+
+/*****************************************************************************\
+ im.VersionNumber()
+\*****************************************************************************/
+static int imluaVersionNumber (lua_State *L)
+{
+ lua_pushnumber(L, imVersionNumber());
+ return 1;
+}
+
+/*****************************************************************************\
+ im.FormatList()
+\*****************************************************************************/
+static int imluaFormatList (lua_State *L)
+{
+ int i, format_count;
+ char *format_list[50];
+
+ imFormatList(format_list, &format_count);
+
+ lua_newtable(L);
+ for (i = 0; i < format_count; i++)
+ {
+ lua_pushstring(L, format_list[i]);
+ lua_settable(L, -2);
+ }
+
+ return 1;
+}
+
+/*****************************************************************************\
+ im.FormatInfo(format)
+\*****************************************************************************/
+static int imluaFormatInfo (lua_State *L)
+{
+ char desc[50];
+ char ext[50];
+ int can_sequence;
+ int error;
+
+ error = imFormatInfo(luaL_checkstring(L, 1), desc, ext, &can_sequence);
+
+ imlua_pusherror(L, error);
+ if (error)
+ return 1;
+
+ lua_pushstring(L, desc);
+ lua_pushstring(L, ext);
+ lua_pushboolean(L, can_sequence);
+
+ return 4;
+}
+
+/*****************************************************************************\
+ im.FormatCompressions(format)
+\*****************************************************************************/
+static int imluaFormatCompressions (lua_State *L)
+{
+ int i, comp_count;
+ int error;
+ char *comp[50];
+
+ int color_mode = luaL_optint(L, 2, -1);
+ int data_type = luaL_optint(L, 3, -1);
+
+ error = imFormatCompressions(luaL_checkstring(L, 1), comp, &comp_count, color_mode, data_type);
+
+ imlua_pusherror(L, error);
+ if (error)
+ return 1;
+
+ lua_newtable(L);
+ for (i = 0; i < comp_count; i++)
+ {
+ lua_pushstring(L, comp[i]);
+ lua_settable(L, -2);
+ }
+
+ return 2;
+}
+
+/*****************************************************************************\
+ im.FormatCanWriteImage(format, compression, color_mode, data_type)
+\*****************************************************************************/
+static int imluaFormatCanWriteImage (lua_State *L)
+{
+ const char *format = luaL_checkstring(L, 1);
+ const char *compression = luaL_checkstring(L, 2);
+ int color_mode = luaL_checkint(L, 3);
+ int data_type = luaL_checkint(L, 4);
+
+ lua_pushboolean(L, imFormatCanWriteImage(format, compression, color_mode, data_type));
+ return 1;
+}
+
+/*****************************************************************************\
+ Constants
+\*****************************************************************************/
+static const imlua_constant im_constants[] = {
+
+ { "BYTE", IM_BYTE, NULL },
+ { "USHORT", IM_USHORT, NULL },
+ { "INT", IM_INT, NULL },
+ { "FLOAT", IM_FLOAT, NULL },
+ { "CFLOAT", IM_CFLOAT, NULL },
+
+ { "RGB", IM_RGB, NULL },
+ { "MAP", IM_MAP, NULL },
+ { "GRAY", IM_GRAY, NULL },
+ { "BINARY", IM_BINARY, NULL },
+ { "CMYK", IM_CMYK, NULL },
+ { "YCBCR", IM_YCBCR, NULL },
+ { "LAB", IM_LAB, NULL },
+ { "LUV", IM_LUV, NULL },
+ { "XYZ", IM_XYZ, NULL },
+
+ { "ALPHA", IM_ALPHA, NULL },
+ { "PACKED", IM_PACKED, NULL },
+ { "TOPDOWN", IM_TOPDOWN, NULL },
+
+ { "ERR_NONE", IM_ERR_NONE, NULL },
+ { "ERR_OPEN", IM_ERR_OPEN, NULL },
+ { "ERR_ACCESS", IM_ERR_ACCESS, NULL },
+ { "ERR_FORMAT", IM_ERR_FORMAT, NULL },
+ { "ERR_DATA", IM_ERR_DATA, NULL },
+ { "ERR_COMPRESS", IM_ERR_COMPRESS, NULL },
+ { "ERR_MEM", IM_ERR_MEM, NULL },
+ { "ERR_COUNTER", IM_ERR_COUNTER, NULL },
+
+ { "CPX_REAL", IM_CPX_REAL, NULL },
+ { "CPX_IMAG", IM_CPX_IMAG, NULL },
+ { "CPX_MAG", IM_CPX_MAG, NULL },
+ { "CPX_PHASE", IM_CPX_PHASE, NULL },
+
+ { "GAMMA_LINEAR", IM_GAMMA_LINEAR, NULL },
+ { "GAMMA_LOGLITE", IM_GAMMA_LOGLITE, NULL },
+ { "GAMMA_LOGHEAVY", IM_GAMMA_LOGHEAVY, NULL },
+ { "GAMMA_EXPLITE", IM_GAMMA_EXPLITE, NULL },
+ { "GAMMA_EXPHEAVY", IM_GAMMA_EXPHEAVY, NULL },
+
+ { "CAST_MINMAX", IM_CAST_MINMAX, NULL },
+ { "CAST_FIXED", IM_CAST_FIXED, NULL },
+ { "CAST_DIRECT", IM_CAST_DIRECT, NULL },
+
+ { "_AUTHOR", 0, IM_AUTHOR },
+ { "_COPYRIGHT", 0, IM_COPYRIGHT },
+ { "_VERSION", 0, IM_VERSION },
+ { "_VERSION_NUMBER", IM_VERSION_NUMBER, NULL },
+ { "_VERSION_DATE", 0, IM_VERSION_DATE },
+ { "_DESCRIPTION", 0, IM_DESCRIPTION },
+ { "_NAME", 0, IM_NAME },
+
+ { NULL, -1, NULL },
+};
+
+void imlua_regconstants (lua_State *L, const imlua_constant *imconst)
+{
+ const imlua_constant *l = imconst;
+ for (; l->name; l++)
+ {
+ lua_pushstring(L, l->name);
+ if (l->str_value)
+ lua_pushstring(L, l->str_value);
+ else
+ lua_pushnumber(L, l->value);
+ lua_settable(L, -3);
+ }
+}
+
+static const luaL_reg im_lib[] = {
+ {"Version", imluaVersion},
+ {"VersionDate", imluaVersionDate},
+ {"VersionNumber", imluaVersionNumber},
+
+ {"FormatList", imluaFormatList},
+ {"FormatInfo", imluaFormatInfo},
+ {"FormatCompressions", imluaFormatCompressions},
+ {"FormatCanWriteImage", imluaFormatCanWriteImage},
+
+ {NULL, NULL}
+};
+
+int imlua_open (lua_State *L)
+{
+ luaL_register(L, "im", im_lib); /* leave "im" table at the top of the stack */
+ imlua_regconstants(L, im_constants);
+
+ imlua_open_file(L);
+ imlua_open_image(L);
+ imlua_open_convert(L);
+ imlua_open_util(L);
+ imlua_open_palette(L);
+
+ return 1;
+}
+
+int luaopen_imlua(lua_State *L)
+{
+ return imlua_open(L);
+}
+
+int luaopen_imlua51(lua_State *L)
+{
+ return imlua_open(L);
+}
diff --git a/src/lua5/imlua.def b/src/lua5/imlua.def
new file mode 100644
index 0000000..259c822
--- /dev/null
+++ b/src/lua5/imlua.def
@@ -0,0 +1,24 @@
+EXPORTS
+ luaopen_imlua
+ luaopen_imlua51
+ imlua_open
+ imlua_checkimage
+ imlua_newarrayulong
+ imlua_newarrayint
+ imlua_newarrayfloat
+ imlua_checkdatatype
+ imlua_checkcolorspace
+ imlua_toarrayint
+ imlua_toarrayfloat
+ imlua_toarrayulong
+ imlua_getn
+ imlua_checktype
+ imlua_checkmask
+ imlua_regconstants
+ imlua_pushimage
+ imlua_matchcolor
+ imlua_matchsize
+ imlua_matchdatatype
+ imlua_matchcolorspace
+ imlua_match
+ \ No newline at end of file
diff --git a/src/lua5/imlua_aux.c b/src/lua5/imlua_aux.c
new file mode 100644
index 0000000..d5df8ac
--- /dev/null
+++ b/src/lua5/imlua_aux.c
@@ -0,0 +1,255 @@
+/** \file
+ * \brief IM Lua 5 Binding
+ *
+ * See Copyright Notice in im_lib.h
+ * $Id: imlua_aux.c,v 1.1 2008/10/17 06:16:32 scuri Exp $
+ */
+
+#include <memory.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "im.h"
+#include "im_image.h"
+#include "im_util.h"
+
+#include <lua.h>
+#include <lauxlib.h>
+
+#include "imlua.h"
+#include "imlua_aux.h"
+#include "imlua_image.h"
+
+/*****************************************************************************\
+\*****************************************************************************/
+int imlua_getn (lua_State *L, int index)
+{
+ int n;
+ lua_pushstring(L, "table");
+ lua_gettable(L, LUA_GLOBALSINDEX);
+ lua_pushstring(L, "getn");
+ lua_gettable(L, -2);
+ lua_pushvalue(L, index);
+ lua_call(L, 1, 1);
+ n = luaL_checkint(L, -1);
+ lua_pop(L, 2);
+ return n;
+}
+
+/*****************************************************************************\
+ Creates an int array.
+\*****************************************************************************/
+int imlua_newarrayint (lua_State *L, int *value, int count, int start)
+{
+ int i;
+ lua_newtable(L);
+ for (i = 0; i < count; i++)
+ {
+ lua_pushnumber(L, value[i]);
+ lua_rawseti(L, -2, i+start);
+ }
+ return 1;
+}
+
+/*****************************************************************************\
+ Creates an unsigned long array.
+\*****************************************************************************/
+int imlua_newarrayulong (lua_State *L, unsigned long *value, int count, int start)
+{
+ int i;
+ lua_newtable(L);
+ for (i = 0; i < count; i++)
+ {
+ lua_pushnumber(L, value[i]);
+ lua_rawseti(L, -2, i+start);
+ }
+ return 1;
+}
+
+/*****************************************************************************\
+ Creates a float array.
+\*****************************************************************************/
+int imlua_newarrayfloat (lua_State *L, float *value, int count, int start)
+{
+ int i;
+ lua_newtable(L);
+ for (i = 0; i < count; i++)
+ {
+ lua_pushnumber(L, value[i]);
+ lua_rawseti(L, -2, i+start);
+ }
+ return 1;
+}
+
+/*****************************************************************************\
+ Retrieve an int array.
+\*****************************************************************************/
+int *imlua_toarrayint (lua_State *L, int index, int *count, int start)
+{
+ int i, n;
+ int *value = NULL;
+
+ if (lua_istable(L, index))
+ {
+ n = imlua_getn(L, index);
+ if (start == 0) n++;
+ if (count) *count = n;
+
+ value = (int*) malloc (sizeof(int) * n);
+ for (i = 0; i < n; i++)
+ {
+ lua_rawgeti(L, index, i+start);
+ value[i] = luaL_checkint(L, -1);
+ lua_pop(L, 1);
+ }
+ }
+ return value;
+}
+
+/*****************************************************************************\
+ Retrieve an ulong array.
+\*****************************************************************************/
+unsigned long *imlua_toarrayulong (lua_State *L, int index, int *count, int start)
+{
+ int i, n;
+ unsigned long *value = NULL;
+
+ if (lua_istable(L, index))
+ {
+ n = imlua_getn(L, index);
+ if (start == 0) n++;
+ if (count) *count = n;
+
+ value = (unsigned long*) malloc (sizeof(unsigned long) * n);
+ for (i = 0; i < n; i++)
+ {
+ lua_rawgeti(L, index, i+start);
+ value[i] = luaL_checkint(L, -1);
+ lua_pop(L, 1);
+ }
+ }
+ return value;
+}
+
+/*****************************************************************************\
+ Retrieve a float array.
+\*****************************************************************************/
+float *imlua_toarrayfloat (lua_State *L, int index, int *count, int start)
+{
+ int i, n;
+ float *value = NULL;
+
+ if (lua_istable(L, index))
+ {
+ n = imlua_getn(L, index);
+ if (start == 0) n++;
+ if (count) *count = n;
+
+ value = (float*) malloc (sizeof(float) * n);
+ for (i = 0; i < n; i++)
+ {
+ lua_rawgeti(L, index, i+start);
+ value[i] = (float) luaL_checknumber(L, -1);
+ lua_pop(L, 1);
+ }
+ }
+ return value;
+}
+
+
+/*****************************************************************************\
+ Creates a bit mask based on a string formatted as "11000110".
+\*****************************************************************************/
+unsigned char imlua_checkmask (lua_State *L, int index)
+{
+ int i;
+ unsigned char mask = 0;
+ const char *str = luaL_checkstring(L, index);
+ if (strlen(str) != 8)
+ luaL_argerror(L, index, "invalid mask, must have 8 elements");
+
+ for (i = 0; i < 8; i++)
+ {
+ char c = str[i];
+ if (c != '0' && c != '1')
+ luaL_argerror(L, index, "invalid mask, must have 0s or 1s only");
+
+ mask |= (c - '0') << (7 - i);
+ }
+
+ return mask;
+}
+
+/*****************************************************************************\
+ Checks data_type and color_space of an image. If it doesn't match throw a lua error.
+\*****************************************************************************/
+void imlua_checktype (lua_State *L, int index, imImage *image, int color_space, int data_type)
+{
+ if (image->data_type != data_type)
+ {
+ char msg[100] = "image data type must be ";
+ strcat(msg, imDataTypeName(data_type));
+ luaL_argerror(L, index, msg);
+ }
+
+ if (image->color_space != color_space)
+ {
+ char msg[100] = "image color space must be ";
+ strcat(msg, imColorModeSpaceName(color_space));
+ luaL_argerror(L, index, msg);
+ }
+}
+
+/*****************************************************************************\
+ Checks color_space of an image. If it doesn't match throw a lua error.
+\*****************************************************************************/
+void imlua_checkcolorspace (lua_State *L, int index, imImage *image, int color_space)
+{
+ if (image->color_space != color_space)
+ {
+ char msg[100] = "image color space must be ";
+ strcat(msg, imColorModeSpaceName(color_space));
+ luaL_argerror(L, index, msg);
+ }
+}
+
+/*****************************************************************************\
+ Checks a data_type of an image. If it doesn't match throw a lua error.
+\*****************************************************************************/
+void imlua_checkdatatype (lua_State *L, int index, imImage *image, int data_type)
+{
+ if (image->data_type != data_type)
+ {
+ char msg[100] = "image data type must be ";
+ strcat(msg, imDataTypeName(data_type));
+ luaL_argerror(L, index, msg);
+ }
+}
+
+/*****************************************************************************\
+ Checks if the size of the two images are equal. If it doesn't match throw a lua error.
+\*****************************************************************************/
+void imlua_matchsize(lua_State *L, imImage *image1, imImage *image2)
+{
+ imlua_matchcheck(L, imImageMatchSize(image1, image2), "images must have the same size");
+}
+
+void imlua_matchcolor(lua_State *L, imImage *image1, imImage *image2)
+{
+ imlua_matchcheck(L, imImageMatchColor(image1, image2), "images must have the same data type and color space");
+}
+
+void imlua_matchdatatype(lua_State *L, imImage *image1, imImage *image2)
+{
+ imlua_matchcheck(L, imImageMatchDataType(image1, image2), "images must have the same size and data type");
+}
+
+void imlua_matchcolorspace(lua_State *L, imImage *image1, imImage *image2)
+{
+ imlua_matchcheck(L, imImageMatchColorSpace(image1, image2), "images must have the same size and color space");
+}
+
+void imlua_match(lua_State *L, imImage *image1, imImage *image2)
+{
+ imlua_matchcheck(L, imImageMatch(image1, image2), "images must have the same size, data type and color space");
+}
diff --git a/src/lua5/imlua_aux.h b/src/lua5/imlua_aux.h
new file mode 100644
index 0000000..2dc4466
--- /dev/null
+++ b/src/lua5/imlua_aux.h
@@ -0,0 +1,82 @@
+/** \file
+ * \brief IM Lua 5 Binding
+ *
+ * See Copyright Notice in im_lib.h
+ * $Id: imlua_aux.h,v 1.1 2008/10/17 06:16:32 scuri Exp $
+ */
+
+#ifndef __IMLUA_AUX_H
+#define __IMLUA_AUX_H
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+
+/********************************/
+/* exported from "imlua_aux.c". */
+/********************************/
+
+/* get table size */
+
+int imlua_getn(lua_State *L, int index);
+
+/* array */
+
+int imlua_newarrayint(lua_State *L, int *value, int count, int start);
+int imlua_newarrayulong(lua_State *L, unsigned long *value, int count, int start);
+int imlua_newarrayfloat(lua_State *L, float *value, int count, int start);
+
+int *imlua_toarrayint(lua_State *L, int index, int *count, int start);
+unsigned long *imlua_toarrayulong (lua_State *L, int index, int *count, int start);
+float *imlua_toarrayfloat(lua_State *L, int index, int *count, int start);
+
+/* other parameter checking */
+
+unsigned char imlua_checkmask(lua_State *L, int index);
+
+void imlua_checktype(lua_State *L, int index, imImage *image, int color_space, int data_type);
+void imlua_checkdatatype(lua_State *L, int index, imImage *image, int data_type);
+void imlua_checkcolorspace(lua_State *L, int index, imImage *image, int color_space);
+
+void imlua_matchsize(lua_State *L, imImage *image1, imImage *image2);
+void imlua_matchcolor(lua_State *L, imImage *image1, imImage *image2);
+void imlua_matchdatatype(lua_State *L, imImage *image1, imImage *image2);
+void imlua_matchcolorspace(lua_State *L, imImage *image1, imImage *image2);
+void imlua_match(lua_State *L, imImage *image1, imImage *image2);
+
+/* used only when comparing two images */
+#define imlua_matchcheck(L, cond, extramsg) if (!(cond)) \
+ luaL_error(L, extramsg)
+
+#define imlua_pusherror(L, _e) ((_e == IM_ERR_NONE)? lua_pushnil(L): lua_pushnumber(L, _e))
+
+
+/********************************/
+/* exported from "imlua.c". */
+/********************************/
+
+/* constant registration. */
+
+typedef struct _imlua_constant {
+ const char *name;
+ lua_Number value;
+ const char *str_value;
+} imlua_constant;
+
+void imlua_regconstants(lua_State *L, const imlua_constant *imconst);
+
+
+/********************************/
+/* private module open */
+/********************************/
+
+void imlua_open_convert(lua_State *L); /* imlua_convert.c */
+void imlua_open_util(lua_State *L); /* imlua_util.c */
+void imlua_open_file(lua_State *L); /* imlua_file.c */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/src/lua5/imlua_avi.c b/src/lua5/imlua_avi.c
new file mode 100644
index 0000000..f2cd7f4
--- /dev/null
+++ b/src/lua5/imlua_avi.c
@@ -0,0 +1,44 @@
+/** \file
+ * \brief AVI format Lua 5 Binding
+ *
+ * See Copyright Notice in cd.h
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+
+#include "im_format_avi.h"
+
+#include <lua.h>
+#include <lauxlib.h>
+
+
+static int imlua_FormatRegisterAVI(lua_State *L)
+{
+ (void)L;
+ imFormatRegisterAVI();
+ return 0;
+}
+
+static const struct luaL_reg imlib[] = {
+ {"FormatRegisterAVI", imlua_FormatRegisterAVI},
+ {NULL, NULL},
+};
+
+
+static int imlua_avi_open (lua_State *L)
+{
+ imFormatRegisterAVI();
+ luaL_register(L, "im", imlib); /* leave "im" table at the top of the stack */
+ return 1;
+}
+
+int luaopen_imlua_avi(lua_State* L)
+{
+ return imlua_avi_open(L);
+}
+
+int luaopen_imlua_avi51(lua_State* L)
+{
+ return imlua_avi_open(L);
+}
diff --git a/src/lua5/imlua_avi.def b/src/lua5/imlua_avi.def
new file mode 100644
index 0000000..3086a0d
--- /dev/null
+++ b/src/lua5/imlua_avi.def
@@ -0,0 +1,4 @@
+EXPORTS
+ luaopen_imlua_avi
+ luaopen_imlua_avi51
+ \ No newline at end of file
diff --git a/src/lua5/imlua_capture.c b/src/lua5/imlua_capture.c
new file mode 100644
index 0000000..15d52ce
--- /dev/null
+++ b/src/lua5/imlua_capture.c
@@ -0,0 +1,421 @@
+/** \file
+ * \brief IM Lua 5 Binding
+ *
+ * See Copyright Notice in im_lib.h
+ * $Id: imlua_capture.c,v 1.1 2008/10/17 06:16:32 scuri Exp $
+ */
+
+#include <string.h>
+#include <memory.h>
+
+#include "im.h"
+#include "im_image.h"
+#include "im_capture.h"
+
+#include <lua.h>
+#include <lauxlib.h>
+
+#include "imlua.h"
+#include "imlua_aux.h"
+#include "imlua_image.h"
+
+
+
+static imVideoCapture** imlua_rawcheckvideocapture (lua_State *L, int param)
+{
+ return (imVideoCapture**)luaL_checkudata(L, param, "imVideoCapture");
+}
+
+static imVideoCapture* imlua_checkvideocapture (lua_State *L, int param)
+{
+ imVideoCapture** vc_p = imlua_rawcheckvideocapture(L, param);
+
+ if (!(*vc_p))
+ luaL_argerror(L, param, "destroyed imVideoCapture");
+
+ return *vc_p;
+}
+
+static void imlua_pushvideocapture(lua_State *L, imVideoCapture* vc)
+{
+ if (!vc)
+ lua_pushnil(L);
+ else
+ {
+ imVideoCapture** vc_p = (imVideoCapture**) lua_newuserdata(L, sizeof(imVideoCapture*));
+ *vc_p = vc;
+ luaL_getmetatable(L, "imVideoCapture");
+ lua_setmetatable(L, -2);
+ }
+}
+
+/*****************************************************************************\
+ im.VideoCaptureDeviceCount()
+\*****************************************************************************/
+static int imluaVideoCaptureDeviceCount (lua_State *L)
+{
+ lua_pushnumber(L, imVideoCaptureDeviceCount());
+ return 1;
+}
+
+/*****************************************************************************\
+ im.VideoCaptureDeviceDesc(device)
+\*****************************************************************************/
+static int imluaVideoCaptureDeviceDesc (lua_State *L)
+{
+ lua_pushstring(L, imVideoCaptureDeviceDesc(luaL_checkint(L, 1)));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.VideoCaptureDeviceDesc(device)
+\*****************************************************************************/
+static int imluaVideoCaptureReloadDevices (lua_State *L)
+{
+ lua_pushnumber(L, imVideoCaptureReloadDevices());
+ return 1;
+}
+
+/*****************************************************************************\
+ im.VideoCaptureCreate()
+\*****************************************************************************/
+static int imluaVideoCaptureCreate (lua_State *L)
+{
+ imlua_pushvideocapture(L, imVideoCaptureCreate());
+ return 1;
+}
+
+/*****************************************************************************\
+ vc:Connect([device])
+\*****************************************************************************/
+static int imluaVideoCaptureConnect (lua_State *L)
+{
+ imVideoCapture *vc = imlua_checkvideocapture(L, 1);
+ int device = luaL_optint(L, 2, -1);
+ lua_pushnumber(L, imVideoCaptureConnect(vc, device));
+ return 1;
+}
+
+/*****************************************************************************\
+ vc:Disconnect()
+\*****************************************************************************/
+static int imluaVideoCaptureDisconnect (lua_State *L)
+{
+ imVideoCaptureDisconnect(imlua_checkvideocapture(L, 1));
+ return 0;
+}
+
+/*****************************************************************************\
+ vc:DialogCount()
+\*****************************************************************************/
+static int imluaVideoCaptureDialogCount (lua_State *L)
+{
+ lua_pushnumber(L, imVideoCaptureDialogCount(imlua_checkvideocapture(L, 1)));
+ return 1;
+}
+
+/*****************************************************************************\
+ vc:ShowDialog()
+\*****************************************************************************/
+static int imluaVideoCaptureShowDialog (lua_State *L)
+{
+ imVideoCapture *vc = imlua_checkvideocapture(L, 1);
+ int dialog = luaL_checkint(L, 2);
+ void *parent = lua_touserdata(L, 3);
+
+ lua_pushnumber(L, imVideoCaptureShowDialog(vc, dialog, parent));
+ return 1;
+}
+
+/*****************************************************************************\
+ vc:DialogDesc()
+\*****************************************************************************/
+static int imluaVideoCaptureDialogDesc (lua_State *L)
+{
+ imVideoCapture *vc = imlua_checkvideocapture(L, 1);
+ int dialog = luaL_checkint(L, 2);
+
+ lua_pushstring(L, imVideoCaptureDialogDesc(vc, dialog));
+ return 1;
+}
+
+/*****************************************************************************\
+ vc:FormatCount()
+\*****************************************************************************/
+static int imluaVideoCaptureFormatCount (lua_State *L)
+{
+ lua_pushnumber(L, imVideoCaptureFormatCount(imlua_checkvideocapture(L, 1)));
+ return 1;
+}
+
+/*****************************************************************************\
+ vc:GetFormat()
+\*****************************************************************************/
+static int imluaVideoCaptureGetFormat (lua_State *L)
+{
+ imVideoCapture *vc = imlua_checkvideocapture(L, 1);
+ int format = luaL_checkint(L, 2);
+ int width, height;
+ char desc[10];
+
+ lua_pushnumber(L, imVideoCaptureGetFormat(vc, format, &width, &height, desc));
+ lua_pushnumber(L, width);
+ lua_pushnumber(L, height);
+ lua_pushstring(L, desc);
+
+ return 4;
+}
+
+/*****************************************************************************\
+ vc:GetImageSize()
+\*****************************************************************************/
+static int imluaVideoCaptureGetImageSize (lua_State *L)
+{
+ imVideoCapture *vc = imlua_checkvideocapture(L, 1);
+ int width, height;
+
+ imVideoCaptureGetImageSize(vc, &width, &height);
+ lua_pushnumber(L, width);
+ lua_pushnumber(L, height);
+
+ return 2;
+}
+
+/*****************************************************************************\
+ vc:SetImageSize()
+\*****************************************************************************/
+static int imluaVideoCaptureSetImageSize (lua_State *L)
+{
+ imVideoCapture *vc = imlua_checkvideocapture(L, 1);
+ int width = luaL_checkint(L, 2);
+ int height = luaL_checkint(L, 3);
+
+ lua_pushnumber(L, imVideoCaptureSetImageSize(vc, width, height));
+
+ return 1;
+}
+
+/*****************************************************************************\
+ vc:SetFormat()
+\*****************************************************************************/
+static int imluaVideoCaptureSetFormat (lua_State *L)
+{
+ imVideoCapture *vc = imlua_checkvideocapture(L, 1);
+ int format = luaL_checkint(L, 2);
+
+ lua_pushnumber(L, imVideoCaptureSetFormat(vc, format));
+
+ return 1;
+}
+
+/*****************************************************************************\
+ vc:ResetAttribute(attrib, fauto)
+\*****************************************************************************/
+static int imluaVideoCaptureResetAttribute (lua_State *L)
+{
+ imVideoCapture *vc = imlua_checkvideocapture(L, 1);
+ const char *attrib = luaL_checkstring(L, 2);
+ int fauto = luaL_checkint(L, 3);
+
+ lua_pushnumber(L, imVideoCaptureResetAttribute(vc, attrib, fauto));
+ return 1;
+}
+
+/*****************************************************************************\
+ vc:SetAttribute(attrib, percent)
+\*****************************************************************************/
+static int imluaVideoCaptureSetAttribute (lua_State *L)
+{
+ imVideoCapture *vc = imlua_checkvideocapture(L, 1);
+ const char *attrib = luaL_checkstring(L, 2);
+ float percent = (float) luaL_checknumber(L, 3);
+
+ lua_pushnumber(L, imVideoCaptureSetAttribute(vc, attrib, percent));
+ return 1;
+}
+
+/*****************************************************************************\
+ vc:GetAttribute(attrib)
+\*****************************************************************************/
+static int imluaVideoCaptureGetAttribute (lua_State *L)
+{
+ imVideoCapture *vc = imlua_checkvideocapture(L, 1);
+ const char *attrib = luaL_checkstring(L, 2);
+ float percent;
+
+ lua_pushnumber(L, imVideoCaptureGetAttribute(vc, attrib, &percent));
+ lua_pushnumber(L, percent);
+ return 2;
+}
+
+/*****************************************************************************\
+ vc:GetAttributeList()
+\*****************************************************************************/
+static int imluaVideoCaptureGetAttributeList (lua_State *L)
+{
+ imVideoCapture *vc = imlua_checkvideocapture(L, 1);
+ int num_attrib;
+ const char **attribs;
+ int i;
+
+ attribs = imVideoCaptureGetAttributeList(vc, &num_attrib);
+ lua_newtable(L);
+ for (i = 0; i < num_attrib; i++)
+ {
+ lua_pushstring(L, attribs[i]);
+ lua_rawseti(L, -2, i + 1);
+ }
+
+ return 1;
+}
+
+/*****************************************************************************\
+ vc:Frame(image)
+\*****************************************************************************/
+static int imluaVideoCaptureFrame (lua_State *L)
+{
+ imVideoCapture *vc = imlua_checkvideocapture(L, 1);
+ imImage *image = imlua_checkimage(L, 2);
+ int timeout = luaL_checkint(L, 3);
+
+ if (!(image->color_space == IM_RGB || image->color_space == IM_GRAY))
+ luaL_argerror(L, 2, "image must be of RGB or Gray color spaces");
+ imlua_checkdatatype(L, 2, image, IM_BYTE);
+
+ lua_pushnumber(L, imVideoCaptureFrame(vc, image->data[0], image->color_space, timeout));
+
+ return 1;
+}
+
+/*****************************************************************************\
+ vc:OneFrame(image)
+\*****************************************************************************/
+static int imluaVideoCaptureOneFrame (lua_State *L)
+{
+ imVideoCapture *vc = imlua_checkvideocapture(L, 1);
+ imImage *image = imlua_checkimage(L, 2);
+
+ if (!(image->color_space == IM_RGB || image->color_space == IM_GRAY))
+ luaL_argerror(L, 2, "image must be of RGB or Gray color spaces");
+ imlua_checkdatatype(L, 2, image, IM_BYTE);
+
+ lua_pushnumber(L, imVideoCaptureOneFrame(vc, image->data[0], image->color_space));
+
+ return 1;
+}
+
+/*****************************************************************************\
+ vc:Live(image)
+\*****************************************************************************/
+static int imluaVideoCaptureLive (lua_State *L)
+{
+ imVideoCapture *vc = imlua_checkvideocapture(L, 1);
+ int live = luaL_checkint(L, 2);
+
+ lua_pushnumber(L, imVideoCaptureLive(vc, live));
+
+ return 1;
+}
+
+/*****************************************************************************\
+ vc:Destroy()
+\*****************************************************************************/
+static int imluaVideoCaptureDestroy (lua_State *L)
+{
+ imVideoCapture **vc_p = imlua_rawcheckvideocapture(L, 1);
+ if (!(*vc_p))
+ luaL_argerror(L, 1, "destroyed imVideoCapture");
+
+ imVideoCaptureDestroy(*vc_p);
+ *vc_p = NULL; /* mark as destroyed */
+
+ return 0;
+}
+
+/*****************************************************************************\
+ gc
+\*****************************************************************************/
+static int imluaVideoCapture_gc (lua_State *L)
+{
+ imVideoCapture **vc_p = (imVideoCapture **)lua_touserdata(L, 1);
+ if (*vc_p)
+ {
+ imVideoCaptureDestroy(*vc_p);
+ *vc_p = NULL; /* mark as destroyed */
+ }
+ return 0;
+}
+
+/*****************************************************************************\
+ tostring
+\*****************************************************************************/
+static int imluaVideoCapture_tostring (lua_State *L)
+{
+ imVideoCapture **vc_p = (imVideoCapture **)lua_touserdata(L, 1);
+ lua_pushfstring(L, "imVideoCapture (%p)%s", vc_p, (*vc_p)? "": "-destroyed");
+ return 1;
+}
+
+static const luaL_reg imcapture_lib[] = {
+ {"VideoCaptureDeviceCount", imluaVideoCaptureDeviceCount},
+ {"VideoCaptureDeviceDesc", imluaVideoCaptureDeviceDesc},
+ {"VideoCaptureReloadDevices", imluaVideoCaptureReloadDevices},
+ {"VideoCaptureCreate", imluaVideoCaptureCreate},
+ {"VideoCaptureDestroy", imluaVideoCaptureDestroy},
+ {NULL, NULL}
+};
+
+static const luaL_reg imcapture_metalib[] = {
+ {"Destroy", imluaVideoCaptureDestroy},
+ {"Connect", imluaVideoCaptureConnect},
+ {"Disconnect", imluaVideoCaptureDisconnect},
+ {"DialogCount", imluaVideoCaptureDialogCount},
+ {"ShowDialog", imluaVideoCaptureShowDialog},
+ {"DialogDesc", imluaVideoCaptureDialogDesc},
+ {"FormatCount", imluaVideoCaptureFormatCount},
+ {"GetFormat", imluaVideoCaptureGetFormat},
+ {"SetFormat", imluaVideoCaptureSetFormat},
+ {"GetImageSize", imluaVideoCaptureGetImageSize},
+ {"SetImageSize", imluaVideoCaptureSetImageSize},
+ {"ResetAttribute", imluaVideoCaptureResetAttribute},
+ {"GetAttribute", imluaVideoCaptureGetAttribute},
+ {"SetAttribute", imluaVideoCaptureSetAttribute},
+ {"GetAttributeList", imluaVideoCaptureGetAttributeList},
+ {"OneFrame", imluaVideoCaptureOneFrame},
+ {"Frame", imluaVideoCaptureFrame},
+ {"Live", imluaVideoCaptureLive},
+
+ {"__gc", imluaVideoCapture_gc},
+ {"__tostring", imluaVideoCapture_tostring},
+
+ {NULL, NULL}
+};
+
+static void createmeta (lua_State *L)
+{
+ /* Object Oriented Access */
+ luaL_newmetatable(L, "imVideoCapture"); /* create new metatable for imVideoCapture handle */
+ lua_pushliteral(L, "__index");
+ lua_pushvalue(L, -2); /* push metatable */
+ lua_rawset(L, -3); /* metatable.__index = metatable */
+ luaL_register(L, NULL, imcapture_metalib); /* register methods */
+ lua_pop(L, 1); /* removes the metatable from the top of the stack */
+}
+
+int imlua_open_capture(lua_State *L)
+{
+ createmeta(L);
+ luaL_register(L, "im", imcapture_lib); /* leave "im" table at the top of the stack */
+ return 1;
+}
+
+int luaopen_imlua_capture(lua_State *L)
+{
+ return imlua_open_capture(L);
+}
+
+int luaopen_imlua_capture51(lua_State *L)
+{
+ return imlua_open_capture(L);
+}
+
diff --git a/src/lua5/imlua_capture.def b/src/lua5/imlua_capture.def
new file mode 100644
index 0000000..1b279cf
--- /dev/null
+++ b/src/lua5/imlua_capture.def
@@ -0,0 +1,5 @@
+EXPORTS
+ imlua_open_capture
+ luaopen_imlua_capture
+ luaopen_imlua_capture51
+ \ No newline at end of file
diff --git a/src/lua5/imlua_convert.c b/src/lua5/imlua_convert.c
new file mode 100644
index 0000000..5ec73c9
--- /dev/null
+++ b/src/lua5/imlua_convert.c
@@ -0,0 +1,79 @@
+/** \file
+ * \brief IM Lua 5 Binding
+ *
+ * See Copyright Notice in im_lib.h
+ * $Id: imlua_convert.c,v 1.1 2008/10/17 06:16:32 scuri Exp $
+ */
+
+#include "im.h"
+#include "im_image.h"
+#include "im_convert.h"
+
+#include <lua.h>
+#include <lauxlib.h>
+
+#include "imlua.h"
+#include "imlua_image.h"
+#include "imlua_aux.h"
+
+/*****************************************************************************\
+ im.ConvertDataType(src_image, dst_image, cpx2real, gamma, abssolute, cast_mode)
+\*****************************************************************************/
+static int imluaConvertDataType (lua_State *L)
+{
+ imImage* src_image = imlua_checkimage(L, 1);
+ imImage* dst_image = imlua_checkimage(L, 2);
+ int cpx2real = luaL_checkint(L, 3);
+ float gamma = (float) luaL_checknumber(L, 4);
+ int abssolute = luaL_checkint(L, 5);
+ int cast_mode = luaL_checkint(L, 6);
+
+ imlua_matchcolorspace(L, src_image, dst_image);
+ imlua_pusherror(L, imConvertDataType(src_image, dst_image, cpx2real, gamma, abssolute, cast_mode));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.ConvertColorSpace(src_image, dst_image)
+\*****************************************************************************/
+static int imluaConvertColorSpace (lua_State *L)
+{
+ imImage* src_image = imlua_checkimage(L, 1);
+ imImage* dst_image = imlua_checkimage(L, 2);
+
+ imlua_matchdatatype(L, src_image, dst_image);
+ imlua_pusherror(L, imConvertColorSpace(src_image, dst_image));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.ConvertToBitmap(src_image, dst_image, cpx2real, gamma, abssolute, cast_mode)
+\*****************************************************************************/
+static int imluaConvertToBitmap (lua_State *L)
+{
+ imImage* src_image = imlua_checkimage(L, 1);
+ imImage* dst_image = imlua_checkimage(L, 2);
+ int cpx2real = luaL_checkint(L, 3);
+ float gamma = (float) luaL_checknumber(L, 4);
+ int abssolute = luaL_checkint(L, 5);
+ int cast_mode = luaL_checkint(L, 6);
+
+ imlua_matchsize(L, src_image, dst_image);
+ imlua_matchcheck(L, imImageIsBitmap(dst_image), "image must be a bitmap");
+
+ imlua_pusherror(L, imConvertToBitmap(src_image, dst_image, cpx2real, gamma, abssolute, cast_mode));
+ return 1;
+}
+
+static const luaL_reg imconvert_lib[] = {
+ {"ConvertDataType", imluaConvertDataType},
+ {"ConvertColorSpace", imluaConvertColorSpace},
+ {"ConvertToBitmap", imluaConvertToBitmap},
+ {NULL, NULL}
+};
+
+void imlua_open_convert (lua_State *L)
+{
+ /* "im" table is at the top of the stack */
+ luaL_register(L, NULL, imconvert_lib);
+}
diff --git a/src/lua5/imlua_fftw.c b/src/lua5/imlua_fftw.c
new file mode 100644
index 0000000..0966572
--- /dev/null
+++ b/src/lua5/imlua_fftw.c
@@ -0,0 +1,162 @@
+/** \file
+ * \brief IM Lua 5 Binding
+ *
+ * See Copyright Notice in im_lib.h
+ * $Id: imlua_fftw.c,v 1.1 2008/10/17 06:16:32 scuri Exp $
+ */
+
+#include <memory.h>
+
+#include "im.h"
+#include "im_image.h"
+#include "im_process.h"
+#include "im_util.h"
+
+#include <lua.h>
+#include <lauxlib.h>
+
+#include "imlua.h"
+#include "imlua_aux.h"
+#include "imlua_image.h"
+
+
+/*****************************************************************************\
+ Domain Transform Operations
+\*****************************************************************************/
+
+/*****************************************************************************\
+ im.ProcessFFT(src_image, dst_image)
+\*****************************************************************************/
+static int imluaProcessFFT (lua_State *L)
+{
+ imImage* src_image = imlua_checkimage(L, 1);
+ imImage* dst_image = imlua_checkimage(L, 2);
+
+ imlua_matchsize(L, src_image, dst_image);
+ imlua_checkdatatype(L, 2, dst_image, IM_CFLOAT);
+
+ imProcessFFT(src_image, dst_image);
+ return 0;
+}
+
+/*****************************************************************************\
+ im.ProcessIFFT(src_image, dst_image)
+\*****************************************************************************/
+static int imluaProcessIFFT (lua_State *L)
+{
+ imImage* src_image = imlua_checkimage(L, 1);
+ imImage* dst_image = imlua_checkimage(L, 2);
+
+ imlua_matchsize(L, src_image, dst_image);
+ imlua_checkdatatype(L, 1, src_image, IM_CFLOAT);
+ imlua_checkdatatype(L, 2, dst_image, IM_CFLOAT);
+
+ imProcessIFFT(src_image, dst_image);
+ return 0;
+}
+
+/*****************************************************************************\
+ im.ProcessFFTRaw(src_image, inverse, center, normalize)
+\*****************************************************************************/
+static int imluaProcessFFTraw (lua_State *L)
+{
+ imImage* src_image = imlua_checkimage(L, 1);
+ int inverse = luaL_checkint(L, 2);
+ int center = luaL_checkint(L, 3);
+ int normalize = luaL_checkint(L, 4);
+
+ imlua_checkdatatype(L, 1, src_image, IM_CFLOAT);
+
+ imProcessFFTraw(src_image, inverse, center, normalize);
+ return 0;
+}
+
+/*****************************************************************************\
+ im.ProcessSwapQuadrants(src_image, inverse, center, normalize)
+\*****************************************************************************/
+static int imluaProcessSwapQuadrants (lua_State *L)
+{
+ imImage* src_image = imlua_checkimage(L, 1);
+ int center2origin = luaL_checkint(L, 2);
+
+ imlua_checkdatatype(L, 1, src_image, IM_CFLOAT);
+
+ imProcessSwapQuadrants(src_image, center2origin);
+ return 0;
+}
+
+/*****************************************************************************\
+ im.ProcessCrossCorrelation(image1, image2, dst_image)
+\*****************************************************************************/
+static int imluaProcessCrossCorrelation (lua_State *L)
+{
+ imImage* image1 = imlua_checkimage(L, 1);
+ imImage* image2 = imlua_checkimage(L, 2);
+ imImage* dst_image = imlua_checkimage(L, 3);
+
+ imlua_matchsize(L, image1, dst_image);
+ imlua_matchsize(L, image2, dst_image);
+ imlua_checkdatatype(L, 3, dst_image, IM_CFLOAT);
+
+ imProcessCrossCorrelation(image1, image2, dst_image);
+ return 0;
+}
+
+/*****************************************************************************\
+ im.ProcessAutoCorrelation(src_image, dst_image)
+\*****************************************************************************/
+static int imluaProcessAutoCorrelation (lua_State *L)
+{
+ imImage* src_image = imlua_checkimage(L, 1);
+ imImage* dst_image = imlua_checkimage(L, 2);
+
+ imlua_matchsize(L, src_image, dst_image);
+ imlua_checkdatatype(L, 2, dst_image, IM_CFLOAT);
+
+ imProcessAutoCorrelation(src_image, dst_image);
+ return 0;
+}
+
+static const luaL_reg imfftw_lib[] = {
+ {"ProcessFFT", imluaProcessFFT},
+ {"ProcessIFFT", imluaProcessIFFT},
+ {"ProcessFFTraw", imluaProcessFFTraw},
+ {"ProcessSwapQuadrants", imluaProcessSwapQuadrants},
+ {"ProcessCrossCorrelation", imluaProcessCrossCorrelation},
+ {"ProcessAutoCorrelation", imluaProcessAutoCorrelation},
+
+ {NULL, NULL}
+};
+
+int imlua_open_fftw (lua_State *L)
+{
+ luaL_register(L, "im", imfftw_lib); /* leave "im" table at the top of the stack */
+#ifdef TEC_BIGENDIAN
+#ifdef TEC_64
+#include "im_fftw_be64.loh"
+#else
+#include "im_fftw_be32.loh"
+#endif
+#else
+#ifdef TEC_64
+#ifdef WIN64
+#include "im_fftw_le64w.loh"
+#else
+#include "im_fftw_le64.loh"
+#endif
+#else
+#include "im_fftw.loh"
+#endif
+#endif
+ return 1;
+}
+
+int luaopen_imlua_fftw(lua_State *L)
+{
+ return imlua_open_fftw(L);
+}
+
+int luaopen_imlua_fftw51(lua_State *L)
+{
+ return imlua_open_fftw(L);
+}
diff --git a/src/lua5/imlua_fftw.def b/src/lua5/imlua_fftw.def
new file mode 100644
index 0000000..216c967
--- /dev/null
+++ b/src/lua5/imlua_fftw.def
@@ -0,0 +1,4 @@
+EXPORTS
+ imlua_open_fftw
+ luaopen_imlua_fftw
+ luaopen_imlua_fftw51 \ No newline at end of file
diff --git a/src/lua5/imlua_file.c b/src/lua5/imlua_file.c
new file mode 100644
index 0000000..fd20c36
--- /dev/null
+++ b/src/lua5/imlua_file.c
@@ -0,0 +1,661 @@
+/** \file
+ * \brief IM Lua 5 Binding
+ *
+ * See Copyright Notice in im_lib.h
+ * $Id: imlua_file.c,v 1.1 2008/10/17 06:16:32 scuri Exp $
+ */
+
+#include <string.h>
+#include <memory.h>
+#include <stdlib.h>
+
+#include "im.h"
+#include "im_raw.h"
+#include "im_image.h"
+#include "im_util.h"
+
+#include <lua.h>
+#include <lauxlib.h>
+
+#include "imlua.h"
+#include "imlua_aux.h"
+#include "imlua_image.h"
+#include "imlua_palette.h"
+
+
+
+static imFile** imlua_rawcheckfile(lua_State *L, int param)
+{
+ return (imFile**)luaL_checkudata(L, param, "imFile");
+}
+
+static imFile* imlua_checkfile (lua_State *L, int param)
+{
+ imFile** ifile_p = imlua_rawcheckfile(L, param);
+
+ if (!(*ifile_p))
+ luaL_argerror(L, param, "closed imFile");
+
+ return *ifile_p;
+}
+
+static int imlua_pushifileerror(lua_State *L, imFile* ifile, int error)
+{
+ if (error)
+ {
+ lua_pushnil(L);
+ imlua_pusherror(L, error);
+ return 2;
+ }
+ else
+ {
+ imFile** ifile_p = (imFile**) lua_newuserdata(L, sizeof(imFile*));
+ *ifile_p = ifile;
+ luaL_getmetatable(L, "imFile");
+ lua_setmetatable(L, -2);
+ return 1;
+ }
+}
+
+
+/*****************************************************************************\
+ im.FileOpen(filename)
+\*****************************************************************************/
+static int imluaFileOpen (lua_State *L)
+{
+ const char *filename = luaL_checkstring(L, 1);
+ int error;
+ imFile *ifile = imFileOpen(filename, &error);
+ return imlua_pushifileerror(L, ifile, error);
+}
+
+/*****************************************************************************\
+ im.FileOpenAs(filename)
+\*****************************************************************************/
+static int imluaFileOpenAs (lua_State *L)
+{
+ const char *filename = luaL_checkstring(L, 1);
+ const char *format = luaL_checkstring(L, 2);
+ int error;
+ imFile *ifile = imFileOpenAs(filename, format, &error);
+ return imlua_pushifileerror(L, ifile, error);
+}
+
+/*****************************************************************************\
+ im.FileOpenRaw(filename)
+\*****************************************************************************/
+static int imluaFileOpenRaw (lua_State *L)
+{
+ const char *filename = luaL_checkstring(L, 1);
+ int error;
+ imFile *ifile = imFileOpenRaw(filename, &error);
+ return imlua_pushifileerror(L, ifile, error);
+}
+
+/*****************************************************************************\
+ im.FileNew(filename, format)
+\*****************************************************************************/
+static int imluaFileNew (lua_State *L)
+{
+ const char *filename = luaL_checkstring(L, 1);
+ const char *format = luaL_checkstring(L, 2);
+ int error;
+
+ imFile *ifile = imFileNew(filename, format, &error);
+ return imlua_pushifileerror(L, ifile, error);
+}
+
+/*****************************************************************************\
+ im.FileNewRaw(filename)
+\*****************************************************************************/
+static int imluaFileNewRaw (lua_State *L)
+{
+ const char *filename = luaL_checkstring(L, 1);
+ int error;
+ imFile *ifile = imFileNewRaw(filename, &error);
+ return imlua_pushifileerror(L, ifile, error);
+}
+
+/*****************************************************************************\
+ file:Handle()
+\*****************************************************************************/
+static int imluaFileHandle (lua_State *L)
+{
+ lua_pushlightuserdata(L, imFileHandle(imlua_checkfile(L, 1), luaL_checkint(L, 2)));
+ return 1;
+}
+
+/*****************************************************************************\
+ file:LoadImage()
+\*****************************************************************************/
+static int imluaFileLoadImage (lua_State *L)
+{
+ imFile *ifile = imlua_checkfile(L, 1);
+ int index = luaL_optint(L, 2, 0);
+ int error;
+ imImage *image = imFileLoadImage(ifile, index, &error);
+ return imlua_pushimageerror(L, image, error);
+}
+
+/*****************************************************************************\
+ file:LoadImageFrame()
+\*****************************************************************************/
+static int imluaFileLoadImageFrame (lua_State *L)
+{
+ imFile *ifile = imlua_checkfile(L, 1);
+ int index = luaL_checkint(L, 2);
+ imImage *image = imlua_checkimage(L, 3);
+ int error;
+
+ imFileLoadImageFrame(ifile, index, image, &error);
+ imlua_pusherror(L, error);
+
+ return 1;
+}
+
+/*****************************************************************************\
+ file:LoadImageRegion()
+\*****************************************************************************/
+static int imluaFileLoadImageRegion (lua_State *L)
+{
+ imFile *ifile = imlua_checkfile(L, 1);
+ int index = luaL_checkint(L, 2);
+ int bitmap = luaL_checkint(L, 3);
+ int xmin = luaL_checkint(L, 4);
+ int xmax = luaL_checkint(L, 5);
+ int ymin = luaL_checkint(L, 6);
+ int ymax = luaL_checkint(L, 7);
+ int width = luaL_checkint(L, 8);
+ int height = luaL_checkint(L, 9);
+ int error;
+ imImage *image = imFileLoadImageRegion(ifile, index, bitmap, &error, xmin, xmax, ymin, ymax, width, height);
+ return imlua_pushimageerror(L, image, error);
+}
+
+/*****************************************************************************\
+ file:LoadBitmap()
+\*****************************************************************************/
+static int imluaFileLoadBitmap (lua_State *L)
+{
+ imFile *ifile = imlua_checkfile(L, 1);
+ int index = luaL_optint(L, 2, 0);
+ int error;
+ imImage *image = imFileLoadBitmap(ifile, index, &error);
+ return imlua_pushimageerror(L, image, error);
+}
+
+/*****************************************************************************\
+ file:LoadBitmapFrame()
+\*****************************************************************************/
+static int imluaFileLoadBitmapFrame (lua_State *L)
+{
+ imFile *ifile = imlua_checkfile(L, 1);
+ int index = luaL_checkint(L, 2);
+ imImage *image = imlua_checkimage(L, 3);
+ int error;
+
+ imFileLoadBitmapFrame(ifile, index, image, &error);
+ imlua_pusherror(L, error);
+
+ return 1;
+}
+
+/*****************************************************************************\
+ file:SaveImage()
+\*****************************************************************************/
+static int imluaFileSaveImage (lua_State *L)
+{
+ imFile *ifile = imlua_checkfile(L, 1);
+ imImage *image = imlua_checkimage(L, 2);
+
+ imlua_pusherror(L, imFileSaveImage(ifile, image));
+ return 1;
+}
+
+/*****************************************************************************\
+ file:GetInfo()
+\*****************************************************************************/
+static int imluaFileGetInfo (lua_State *L)
+{
+ int image_count;
+ char format[10];
+ char compression[20];
+
+ imFile *ifile = imlua_checkfile(L, 1);
+
+ imFileGetInfo(ifile, format, compression, &image_count);
+
+ lua_pushstring(L, format);
+ lua_pushstring(L, compression);
+ lua_pushnumber(L, image_count);
+
+ return 3;
+}
+
+/*****************************************************************************\
+ file:SetInfo()
+\*****************************************************************************/
+static int imluaFileSetInfo (lua_State *L)
+{
+ imFile *ifile = imlua_checkfile(L, 1);
+ const char *compression = luaL_checkstring(L, 2);
+
+ imFileSetInfo(ifile, compression);
+
+ return 0;
+}
+
+/*****************************************************************************\
+ file:SetAttribute(attrib, data_type, data)
+\*****************************************************************************/
+static int imluaFileSetAttribute (lua_State *L)
+{
+ int i, count = 0;
+ void *data = NULL;
+
+ imFile *ifile = imlua_checkfile(L, 1);
+ const char *attrib = luaL_checkstring(L, 2);
+ int data_type = luaL_checkint(L, 3);
+
+ if (!lua_isnil(L, 4))
+ {
+ if (lua_isstring(L, 4) && data_type != IM_BYTE)
+ luaL_argerror(L, 4, "if value is a string, then data type must be byte");
+ else
+ {
+ luaL_checktype(L, 4, LUA_TTABLE);
+ count = imlua_getn(L, 4);
+ data = malloc(imDataTypeSize(data_type) * count);
+ }
+
+ switch (data_type)
+ {
+ case IM_BYTE:
+ {
+ if (lua_isstring(L, 4))
+ {
+ const char* str = lua_tostring(L, 4);
+ count = strlen(str)+1;
+ data = malloc(imDataTypeSize(data_type) * count);
+ memcpy(data, str, count);
+ }
+ else
+ {
+ imbyte *d = (imbyte*) data;
+ for (i = 0; i < count; i++)
+ {
+ lua_rawgeti(L, 4, i+1);
+ d[i] = (imbyte) luaL_checkint(L, -1);
+ lua_pop(L, 1);
+ }
+ }
+ }
+ break;
+
+ case IM_USHORT:
+ {
+ imushort *d = (imushort*) data;
+ for (i = 0; i < count; i++)
+ {
+ lua_rawgeti(L, 4, i+1);
+ d[i] = (imushort) luaL_checkint(L, -1);
+ lua_pop(L, 1);
+ }
+ }
+ break;
+
+ case IM_INT:
+ {
+ int *d = (int*) data;
+ for (i = 0; i < count; i++)
+ {
+ lua_rawgeti(L, 4, i+1);
+ d[i] = luaL_checkint(L, -1);
+ lua_pop(L, 1);
+ }
+ }
+ break;
+
+ case IM_FLOAT:
+ {
+ float *d = (float*) data;
+ for (i = 0; i < count; i++)
+ {
+ lua_rawgeti(L, 4, i+1);
+ d[i] = (float) luaL_checknumber(L, -1);
+ lua_pop(L, 1);
+ }
+ }
+ break;
+
+ case IM_CFLOAT:
+ {
+ float *data_float = (float*) data;
+ for (i = 0; i < count; i++)
+ {
+ int two;
+ float *value = imlua_toarrayfloat(L, -1, &two, 1);
+ if (two != 2)
+ {
+ free(value);
+ luaL_argerror(L, 4, "invalid value");
+ }
+
+ data_float[i] = value[0];
+ data_float[i+1] = value[1];
+ free(value);
+ lua_pop(L, 1);
+ }
+ }
+ break;
+ }
+ }
+
+ imFileSetAttribute(ifile, attrib, data_type, count, data);
+ return 0;
+}
+
+/*****************************************************************************\
+ file:GetAttribute(attrib)
+\*****************************************************************************/
+static int imluaFileGetAttribute (lua_State *L)
+{
+ int data_type;
+ int i, count;
+ const void *data;
+ int as_string = 0;
+
+ imFile *ifile = imlua_checkfile(L, 1);
+ const char *attrib = luaL_checkstring(L, 2);
+
+ data = imFileGetAttribute(ifile, attrib, &data_type, &count);
+ if (!data)
+ {
+ lua_pushnil(L);
+ return 1;
+ }
+
+ if (data_type == IM_BYTE && lua_isboolean(L, 3))
+ as_string = lua_toboolean(L, 3);
+
+ if (!as_string)
+ lua_newtable(L);
+
+ switch (data_type)
+ {
+ case IM_BYTE:
+ {
+ if (as_string)
+ {
+ lua_pushstring(L, (const char*)data);
+ }
+ else
+ {
+ imbyte *data_byte = (imbyte*) data;
+ for (i = 0; i < count; i++, data_byte++)
+ {
+ lua_pushnumber(L, *data_byte);
+ lua_rawseti(L, -2, i+1);
+ }
+ }
+ }
+ break;
+
+ case IM_USHORT:
+ {
+ imushort *data_ushort = (imushort*) data;
+ for (i = 0; i < count; i++, data_ushort += 2)
+ {
+ lua_pushnumber(L, *data_ushort);
+ lua_rawseti(L, -2, i+1);
+ }
+ }
+ break;
+
+ case IM_INT:
+ {
+ int *data_int = (int*) data;
+ for (i = 0; i < count; i++, data_int++)
+ {
+ lua_pushnumber(L, *data_int);
+ lua_rawseti(L, -2, i+1);
+ }
+ }
+ break;
+
+ case IM_FLOAT:
+ {
+ float *data_float = (float*) data;
+ for (i = 0; i < count; i++, data_float++)
+ {
+ lua_pushnumber(L, *data_float);
+ lua_rawseti(L, -2, i+1);
+ }
+ }
+ break;
+
+ case IM_CFLOAT:
+ {
+ float *data_float = (float*) data;
+ for (i = 0; i < count; i++, data_float += 2)
+ {
+ imlua_newarrayfloat(L, data_float, 2, 1);
+ lua_rawseti(L, -2, i+1);
+ }
+ }
+ break;
+ }
+
+ lua_pushnumber(L, data_type);
+
+ return 2;
+}
+
+/*****************************************************************************\
+ file:GetAttributeList()
+\*****************************************************************************/
+static int imluaFileGetAttributeList (lua_State *L)
+{
+ int i, attrib_count;
+ char **attrib;
+
+ imFile* ifile = imlua_checkfile(L, 1);
+
+ imFileGetAttributeList(ifile, NULL, &attrib_count);
+
+ attrib = (char**) malloc(attrib_count * sizeof(char*));
+
+ imFileGetAttributeList(ifile, attrib, &attrib_count);
+
+ lua_newtable(L);
+ for (i = 0; i < attrib_count; i++)
+ {
+ lua_pushstring(L, attrib[i]);
+ lua_rawseti(L, -2, i+1);
+ }
+
+ return 1;
+}
+
+/*****************************************************************************\
+ file:GetPalette()
+\*****************************************************************************/
+static int imluaFileGetPalette (lua_State *L)
+{
+ imFile *ifile = imlua_checkfile(L, 1);
+ long* color = malloc(sizeof(long) * 256);
+ int count;
+ imFileGetPalette(ifile, color, &count);
+ imlua_pushpalette(L, color, count);
+ return 1;
+}
+
+/*****************************************************************************\
+ file:SetPalette(pal)
+\*****************************************************************************/
+static int imluaFileSetPalette (lua_State *L)
+{
+ imFile *ifile = imlua_checkfile(L, 1);
+ imluaPalette *pal = imlua_checkpalette(L, 2);
+ imFileSetPalette(ifile, pal->color, pal->count);
+ return 0;
+}
+
+/*****************************************************************************\
+ file:ReadImageInfo()
+\*****************************************************************************/
+static int imluaFileReadImageInfo (lua_State *L)
+{
+ int width, height;
+ int file_color_mode, file_data_type;
+ int error;
+
+ imFile *ifile = imlua_checkfile(L, 1);
+ int index = luaL_optint(L, 2, 0);
+
+ error = imFileReadImageInfo(ifile, index, &width, &height, &file_color_mode, &file_data_type);
+
+ imlua_pusherror(L, error);
+ if (error)
+ return 1;
+
+ lua_pushnumber(L, width);
+ lua_pushnumber(L, height);
+ lua_pushnumber(L, file_color_mode);
+ lua_pushnumber(L, file_data_type);
+ return 5;
+}
+
+/*****************************************************************************\
+ file:WriteImageInfo(width, height, user_color_mode, user_data_type)
+\*****************************************************************************/
+static int imluaFileWriteImageInfo (lua_State *L)
+{
+ imFile *ifile = imlua_checkfile(L, 1);
+ int width = luaL_checkint(L, 2);
+ int height = luaL_checkint(L, 3);
+ int user_color_mode = luaL_checkint(L, 4);
+ int user_data_type = luaL_checkint(L, 5);
+
+ imlua_pusherror(L, imFileWriteImageInfo(ifile, width, height, user_color_mode, user_data_type));
+ return 1;
+}
+
+/*****************************************************************************\
+ file:imFileReadImageData(data)
+\*****************************************************************************/
+static int imluaFileReadImageData (lua_State *L)
+{
+ imFile *ifile = imlua_checkfile(L, 1);
+ void* data = lua_touserdata(L, 2);
+ int convert2bitmap = luaL_checkint(L, 3);
+ int color_mode_flags = luaL_checkint(L, 4);
+ imlua_pusherror(L, imFileReadImageData(ifile, data, convert2bitmap, color_mode_flags));
+ return 1;
+}
+
+/*****************************************************************************\
+ file:imFileWriteImageData(data)
+\*****************************************************************************/
+static int imluaFileWriteImageData (lua_State *L)
+{
+ imFile *ifile = imlua_checkfile(L, 1);
+ void* data = lua_touserdata(L, 2);
+ imlua_pusherror(L, imFileWriteImageData(ifile, data));
+ return 1;
+}
+
+/*****************************************************************************\
+ file:Close()
+\*****************************************************************************/
+static int imluaFileClose (lua_State *L)
+{
+ imFile** ifile_p = imlua_rawcheckfile(L, 1);
+ if (!(*ifile_p))
+ luaL_argerror(L, 1, "closed imFile");
+
+ imFileClose(*ifile_p);
+ *ifile_p = NULL; /* mark as closed */
+ return 0;
+}
+
+/*****************************************************************************\
+ gc
+\*****************************************************************************/
+static int imluaFile_gc (lua_State *L)
+{
+ imFile **ifile_p = (imFile **)lua_touserdata(L, 1);
+ if (ifile_p && *ifile_p)
+ {
+ imFileClose(*ifile_p);
+ *ifile_p = NULL; /* mark as closed */
+ }
+ return 0;
+}
+
+/*****************************************************************************\
+ tostring
+\*****************************************************************************/
+static int imluaFile_tostring (lua_State *L)
+{
+ imFile **ifile_p = (imFile **)lua_touserdata(L, 1);
+ lua_pushfstring(L, "imFile(%p)%s", ifile_p, (*ifile_p)? "": "-closed");
+ return 1;
+}
+
+/*****************************************************************************\
+\*****************************************************************************/
+static const luaL_reg imfile_lib[] = {
+ {"FileOpen", imluaFileOpen},
+ {"FileOpenAs", imluaFileOpenAs},
+ {"FileOpenRaw", imluaFileOpenRaw},
+ {"FileNew", imluaFileNew},
+ {"FileNewRaw", imluaFileNewRaw},
+ {"FileClose", imluaFileClose},
+ {NULL, NULL}
+};
+
+static const luaL_reg imfile_metalib[] = {
+ {"Handle", imluaFileHandle},
+ {"Close", imluaFileClose},
+ {"LoadImage", imluaFileLoadImage},
+ {"LoadImageFrame", imluaFileLoadImageFrame},
+ {"LoadImageRegion", imluaFileLoadImageRegion},
+ {"LoadBitmap", imluaFileLoadBitmap},
+ {"LoadBitmapFrame", imluaFileLoadBitmapFrame},
+ {"SaveImage", imluaFileSaveImage},
+ {"GetInfo", imluaFileGetInfo},
+ {"SetInfo", imluaFileSetInfo},
+ {"SetAttribute", imluaFileSetAttribute},
+ {"GetAttribute", imluaFileGetAttribute},
+ {"GetAttributeList", imluaFileGetAttributeList},
+ {"GetPalette", imluaFileGetPalette},
+ {"SetPalette", imluaFileSetPalette},
+ {"ReadImageInfo", imluaFileReadImageInfo},
+ {"WriteImageInfo", imluaFileWriteImageInfo},
+ {"ReadImageData", imluaFileReadImageData},
+ {"WriteImageData", imluaFileWriteImageData},
+
+ {"__gc", imluaFile_gc},
+ {"__tostring", imluaFile_tostring},
+
+ {NULL, NULL}
+};
+
+static void createmeta (lua_State *L)
+{
+ /* Object Oriented Access */
+ luaL_newmetatable(L, "imFile"); /* create new metatable for imFile handles */
+ lua_pushliteral(L, "__index");
+ lua_pushvalue(L, -2); /* push metatable */
+ lua_rawset(L, -3); /* metatable.__index = metatable */
+ luaL_register(L, NULL, imfile_metalib); /* register methods */
+ lua_pop(L, 1); /* removes the metatable from the top of the stack */
+}
+
+void imlua_open_file (lua_State *L)
+{
+ /* "im" table is at the top of the stack */
+ createmeta(L);
+ luaL_register(L, NULL, imfile_lib);
+}
diff --git a/src/lua5/imlua_image.c b/src/lua5/imlua_image.c
new file mode 100644
index 0000000..22ed38c
--- /dev/null
+++ b/src/lua5/imlua_image.c
@@ -0,0 +1,1061 @@
+/** \file
+ * \brief IM Lua 5 Binding
+ *
+ * See Copyright Notice in im_lib.h
+ * $Id: imlua_image.c,v 1.1 2008/10/17 06:16:32 scuri Exp $
+ */
+
+#include <string.h>
+#include <memory.h>
+#include <stdlib.h>
+
+#include "im.h"
+#include "im_image.h"
+#include "im_util.h"
+
+#include <lua.h>
+#include <lauxlib.h>
+
+#include "imlua.h"
+#include "imlua_image.h"
+#include "imlua_palette.h"
+#include "imlua_aux.h"
+
+
+static imImage** imlua_rawcheckimage(lua_State *L, int param)
+{
+ return (imImage**) luaL_checkudata(L, param, "imImage");
+}
+
+imImage* imlua_checkimage(lua_State *L, int param)
+{
+ imImage** image_p = imlua_rawcheckimage(L, param);
+
+ if (!(*image_p))
+ luaL_argerror(L, param, "destroyed imImage");
+
+ return *image_p;
+}
+
+int imlua_pushimageerror(lua_State *L, imImage* image, int error)
+{
+ if (error)
+ {
+ lua_pushnil(L);
+ imlua_pusherror(L, error);
+ return 2;
+ }
+ else
+ {
+ imlua_pushimage(L, image);
+ return 1;
+ }
+}
+
+void imlua_pushimage(lua_State *L, imImage* image)
+{
+ if (!image)
+ lua_pushnil(L);
+ else
+ {
+ imImage **image_p = (imImage**) lua_newuserdata(L, sizeof(imImage*));
+ *image_p = image;
+ luaL_getmetatable(L, "imImage");
+ lua_setmetatable(L, -2);
+ }
+}
+
+/*****************************************************************************\
+ image channel, for indexing
+\*****************************************************************************/
+static imluaImageChannel *imlua_newimagechannel (lua_State *L, imImage *image, int channel)
+{
+ imluaImageChannel* imagechannel = (imluaImageChannel*) lua_newuserdata(L, sizeof(imluaImageChannel));
+ imagechannel->image = image;
+ imagechannel->channel = channel;
+ luaL_getmetatable(L, "imImageChannel");
+ lua_setmetatable(L, -2);
+ return imagechannel;
+}
+
+static imluaImageChannel* imlua_checkimagechannel (lua_State *L, int param)
+{
+ return (imluaImageChannel*) luaL_checkudata(L, param, "imImageChannel");
+}
+
+/*****************************************************************************\
+ image row, for indexing
+\*****************************************************************************/
+static imluaImageRow *imlua_newimagerow (lua_State *L, imImage *image, int channel, int row)
+{
+ imluaImageRow* imagerow = (imluaImageRow*) lua_newuserdata(L, sizeof(imluaImageRow));
+ imagerow->image = image;
+ imagerow->channel = channel;
+ imagerow->row = row;
+ luaL_getmetatable(L, "imImageChannelRow");
+ lua_setmetatable(L, -2);
+ return imagerow;
+}
+
+static imluaImageRow* imlua_checkimagerow (lua_State *L, int param)
+{
+ return (imluaImageRow*) luaL_checkudata(L, param, "imImageChannelRow");
+}
+
+/*****************************************************************************\
+ im.ImageCreate(width, height, color_space, data_type)
+\*****************************************************************************/
+static int imluaImageCreate (lua_State *L)
+{
+ int width = luaL_checkint(L, 1);
+ int height = luaL_checkint(L, 2);
+ int color_space = luaL_checkint(L, 3);
+ int data_type = luaL_checkint(L, 4);
+
+ imImage *image = imImageCreate(width, height, color_space, data_type);
+ imlua_pushimage(L, image);
+ return 1;
+}
+
+/*****************************************************************************\
+ image:AddAlpha()
+\*****************************************************************************/
+static int imluaImageAddAlpha (lua_State *L)
+{
+ imImageAddAlpha(imlua_checkimage(L, 1));
+ return 0;
+}
+
+/*****************************************************************************\
+ image:Reshape()
+\*****************************************************************************/
+static int imluaImageReshape (lua_State *L)
+{
+ imImage* im = imlua_checkimage(L, 1);
+ int width = luaL_checkint(L, 2);
+ int height = luaL_checkint(L, 3);
+
+ imImageReshape(im, width, height);
+ return 0;
+}
+
+/*****************************************************************************\
+ image:Copy()
+\*****************************************************************************/
+static int imluaImageCopy (lua_State *L)
+{
+ imImage* src_image = imlua_checkimage(L, 1);
+ imImage* dst_image = imlua_checkimage(L, 2);
+
+ imlua_match(L, src_image, dst_image);
+ imImageCopy(src_image, dst_image);
+ return 0;
+}
+
+/*****************************************************************************\
+ image:CopyData()
+\*****************************************************************************/
+static int imluaImageCopyData (lua_State *L)
+{
+ imImage* src_image = imlua_checkimage(L, 1);
+ imImage* dst_image = imlua_checkimage(L, 2);
+
+ imlua_match(L, src_image, dst_image);
+ imImageCopyData(src_image, dst_image);
+ return 0;
+}
+
+/*****************************************************************************\
+ image:Duplicate()
+\*****************************************************************************/
+static int imluaImageDuplicate (lua_State *L)
+{
+ imImage* image = imlua_checkimage(L, 1);
+ imImage *new_image = imImageDuplicate(image);
+ imlua_pushimage(L, new_image);
+ return 1;
+}
+
+/*****************************************************************************\
+ image:Clone()
+\*****************************************************************************/
+static int imluaImageClone (lua_State *L)
+{
+ imImage* image = imlua_checkimage(L, 1);
+ imImage *new_image = imImageClone(image);
+ imlua_pushimage(L, new_image);
+ return 1;
+}
+
+/*****************************************************************************\
+ image:SetAttribute(attrib, data_type, count, data)
+\*****************************************************************************/
+static int imluaImageSetAttribute (lua_State *L)
+{
+ int i, count = 0;
+ void *data = NULL;
+
+ imImage* image = imlua_checkimage(L, 1);
+ const char *attrib = luaL_checkstring(L, 2);
+ int data_type = luaL_checkint(L, 3);
+
+ if (!lua_isnil(L, 4))
+ {
+ if (lua_isstring(L, 4) && data_type != IM_BYTE)
+ luaL_argerror(L, 4, "if value is string, then data type must be byte");
+ else
+ {
+ luaL_checktype(L, 4, LUA_TTABLE);
+ count = imlua_getn(L, 4);
+ data = malloc(imDataTypeSize(data_type) * count);
+ }
+
+ switch (data_type)
+ {
+ case IM_BYTE:
+ {
+ if (lua_isstring(L, 4))
+ {
+ const char* str = lua_tostring(L, 4);
+ count = strlen(str)+1;
+ data = malloc(imDataTypeSize(data_type) * count);
+ memcpy(data, str, count);
+ }
+ else
+ {
+ imbyte *data_byte = (imbyte*) data;
+ for (i = 0; i < count; i++)
+ {
+ lua_rawgeti(L, 4, i+1);
+ data_byte[i] = (imbyte)luaL_checkint(L, -1);
+ lua_pop(L, 1);
+ }
+ }
+ }
+ break;
+
+ case IM_USHORT:
+ {
+ imushort *data_ushort = (imushort*) data;
+ for (i = 0; i < count; i++)
+ {
+ lua_rawgeti(L, 4, i+1);
+ data_ushort[i] = (imushort)luaL_checkint(L, -1);
+ lua_pop(L, 1);
+ }
+ }
+ break;
+
+ case IM_INT:
+ {
+ int *data_int = (int*) data;
+ for (i = 0; i < count; i++)
+ {
+ lua_rawgeti(L, 4, i+1);
+ data_int[i] = luaL_checkint(L, -1);
+ lua_pop(L, 1);
+ }
+ }
+ break;
+
+ case IM_FLOAT:
+ {
+ float *data_float = (float*) data;
+ for (i = 0; i < count; i++)
+ {
+ lua_rawgeti(L, 4, i+1);
+ data_float[i] = (float) luaL_checknumber(L, -1);
+ lua_pop(L, 1);
+ }
+ }
+ break;
+
+ case IM_CFLOAT:
+ {
+ float *data_float = (float*) data;
+ for (i = 0; i < count; i++)
+ {
+ int two;
+ float *value = imlua_toarrayfloat(L, -1, &two, 1);
+ if (two != 2)
+ {
+ free(value);
+ luaL_argerror(L, 4, "invalid value");
+ }
+
+ data_float[i] = value[0];
+ data_float[i+1] = value[1];
+ free(value);
+ lua_pop(L, 1);
+ }
+ }
+ break;
+ }
+ }
+
+ imImageSetAttribute(image, attrib, data_type, count, data);
+ return 0;
+}
+
+/*****************************************************************************\
+ image:GetAttribute(attrib)
+\*****************************************************************************/
+static int imluaImageGetAttribute (lua_State *L)
+{
+ int data_type;
+ int i, count;
+ const void *data;
+ int as_string = 0;
+
+ imImage* image = imlua_checkimage(L, 1);
+ const char *attrib = luaL_checkstring(L, 2);
+
+ data = imImageGetAttribute(image, attrib, &data_type, &count);
+ if (!data)
+ {
+ lua_pushnil(L);
+ return 1;
+ }
+
+ if (data_type == IM_BYTE && lua_isboolean(L, 3))
+ as_string = lua_toboolean(L, 3);
+
+ if (!as_string)
+ lua_newtable(L);
+
+ switch (data_type)
+ {
+ case IM_BYTE:
+ {
+ if (as_string)
+ {
+ lua_pushstring(L, (const char*)data);
+ }
+ else
+ {
+ imbyte *data_byte = (imbyte*) data;
+ for (i = 0; i < count; i++, data_byte++)
+ {
+ lua_pushnumber(L, *data_byte);
+ lua_rawseti(L, -2, i+1);
+ }
+ }
+ }
+ break;
+
+ case IM_USHORT:
+ {
+ imushort *data_ushort = (imushort*) data;
+ for (i = 0; i < count; i++, data_ushort += 2)
+ {
+ lua_pushnumber(L, *data_ushort);
+ lua_rawseti(L, -2, i+1);
+ }
+ }
+ break;
+
+ case IM_INT:
+ {
+ int *data_int = (int*) data;
+ for (i = 0; i < count; i++, data_int++)
+ {
+ lua_pushnumber(L, *data_int);
+ lua_rawseti(L, -2, i+1);
+ }
+ }
+ break;
+
+ case IM_FLOAT:
+ {
+ float *data_float = (float*) data;
+ for (i = 0; i < count; i++, data_float++)
+ {
+ lua_pushnumber(L, *data_float);
+ lua_rawseti(L, -2, i+1);
+ }
+ }
+ break;
+
+ case IM_CFLOAT:
+ {
+ float *data_float = (float*) data;
+ for (i = 0; i < count; i++, data_float += 2)
+ {
+ imlua_newarrayfloat(L, data_float, 2, 1);
+ lua_rawseti(L, -2, i+1);
+ }
+ }
+ break;
+ }
+
+ lua_pushnumber(L, data_type);
+
+ return 2;
+}
+
+/*****************************************************************************\
+ image:GetAttributeList()
+\*****************************************************************************/
+static int imluaImageGetAttributeList (lua_State *L)
+{
+ int i, attrib_count;
+ char **attrib;
+
+ imImage* image = imlua_checkimage(L, 1);
+
+ imImageGetAttributeList(image, NULL, &attrib_count);
+
+ attrib = (char**) malloc(attrib_count * sizeof(char*));
+
+ imImageGetAttributeList(image, attrib, &attrib_count);
+
+ lua_newtable(L);
+ for (i = 0; i < attrib_count; i++)
+ {
+ lua_pushstring(L, attrib[i]);
+ lua_rawseti(L, -2, i+1);
+ }
+
+ return 1;
+}
+
+/*****************************************************************************\
+ image:Clear()
+\*****************************************************************************/
+static int imluaImageClear (lua_State *L)
+{
+ imImageClear(imlua_checkimage(L, 1));
+ return 0;
+}
+
+/*****************************************************************************\
+ image:isBitmap()
+\*****************************************************************************/
+static int imluaImageIsBitmap (lua_State *L)
+{
+ lua_pushboolean(L, imImageIsBitmap(imlua_checkimage(L, 1)));
+ return 1;
+}
+
+/*****************************************************************************\
+ image:GetPalette()
+\*****************************************************************************/
+static int imluaImageGetPalette (lua_State *L)
+{
+ imImage *image = imlua_checkimage(L, 1);
+ long* color = malloc(sizeof(long) * 256);
+ memcpy(color, image->palette, sizeof(long) * 256);
+ imlua_pushpalette(L, color, 256);
+ return 1;
+}
+
+/*****************************************************************************\
+ image:SetPalette
+\*****************************************************************************/
+static int imluaImageSetPalette (lua_State *L)
+{
+ imImage *image = imlua_checkimage(L, 1);
+ imluaPalette *pal = imlua_checkpalette(L, 2);
+ imImageSetPalette(image, pal->color, pal->count);
+ return 0;
+}
+
+/*****************************************************************************\
+ image:CopyAttributes(dst_image)
+\*****************************************************************************/
+static int imluaImageCopyAttributes (lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *dst_image = imlua_checkimage(L, 2);
+
+ imImageCopyAttributes(src_image, dst_image);
+ return 0;
+}
+
+/*****************************************************************************\
+ image:MatchSize(image2)
+\*****************************************************************************/
+static int imluaImageMatchSize (lua_State *L)
+{
+ imImage *image1 = imlua_checkimage(L, 1);
+ imImage *image2 = imlua_checkimage(L, 2);
+
+ lua_pushboolean(L, imImageMatchSize(image1, image2));
+ return 1;
+}
+
+/*****************************************************************************\
+ image:MatchColor(image2)
+\*****************************************************************************/
+static int imluaImageMatchColor (lua_State *L)
+{
+ imImage *image1 = imlua_checkimage(L, 1);
+ imImage *image2 = imlua_checkimage(L, 2);
+
+ lua_pushboolean(L, imImageMatchColor(image1, image2));
+ return 1;
+}
+
+/*****************************************************************************\
+ image:MatchDataType(image2)
+\*****************************************************************************/
+static int imluaImageMatchDataType (lua_State *L)
+{
+ imImage *image1 = imlua_checkimage(L, 1);
+ imImage *image2 = imlua_checkimage(L, 2);
+
+ lua_pushboolean(L, imImageMatchDataType(image1, image2));
+ return 1;
+}
+
+/*****************************************************************************\
+ image:MatchColorSpace(image2)
+\*****************************************************************************/
+static int imluaImageMatchColorSpace (lua_State *L)
+{
+ imImage *image1 = imlua_checkimage(L, 1);
+ imImage *image2 = imlua_checkimage(L, 2);
+
+ lua_pushboolean(L, imImageMatchColorSpace(image1, image2));
+ return 1;
+}
+
+/*****************************************************************************\
+ image:Match(image2)
+\*****************************************************************************/
+static int imluaImageMatch (lua_State *L)
+{
+ imImage *image1 = imlua_checkimage(L, 1);
+ imImage *image2 = imlua_checkimage(L, 2);
+
+ lua_pushboolean(L, imImageMatch(image1, image2));
+ return 1;
+}
+
+/*****************************************************************************\
+ image:SetBinary()
+\*****************************************************************************/
+static int imluaImageSetBinary (lua_State *L)
+{
+ imImageSetBinary(imlua_checkimage(L, 1));
+ return 0;
+}
+
+/*****************************************************************************\
+ image:MakeBinary()
+\*****************************************************************************/
+static int imluaImageMakeBinary (lua_State *L)
+{
+ imImageMakeBinary(imlua_checkimage(L, 1));
+ return 0;
+}
+
+/*****************************************************************************\
+ image:Width()
+\*****************************************************************************/
+static int imluaImageWidth(lua_State *L)
+{
+ imImage *im = imlua_checkimage(L, 1);
+ lua_pushnumber(L, im->width);
+ return 1;
+}
+
+/*****************************************************************************\
+ image:Height()
+\*****************************************************************************/
+static int imluaImageHeight(lua_State *L)
+{
+ imImage *im = imlua_checkimage(L, 1);
+ lua_pushnumber(L, im->height);
+ return 1;
+}
+
+/*****************************************************************************\
+ image:Depth()
+\*****************************************************************************/
+static int imluaImageDepth(lua_State *L)
+{
+ imImage *im = imlua_checkimage(L, 1);
+ lua_pushnumber(L, im->depth);
+ return 1;
+}
+
+/*****************************************************************************\
+ image:DataType()
+\*****************************************************************************/
+static int imluaImageDataType(lua_State *L)
+{
+ imImage *im = imlua_checkimage(L, 1);
+ lua_pushnumber(L, im->data_type);
+ return 1;
+}
+
+/*****************************************************************************\
+ image:ColorSpace()
+\*****************************************************************************/
+static int imluaImageColorSpace(lua_State *L)
+{
+ imImage *im = imlua_checkimage(L, 1);
+ lua_pushnumber(L, im->color_space);
+ return 1;
+}
+
+/*****************************************************************************\
+ image:HasAlpha()
+\*****************************************************************************/
+static int imluaImageHasAlpha(lua_State *L)
+{
+ imImage *im = imlua_checkimage(L, 1);
+ lua_pushnumber(L, im->has_alpha);
+ return 1;
+}
+
+/*****************************************************************************\
+ im.FileImageLoad(filename, [index])
+\*****************************************************************************/
+static int imluaFileImageLoad (lua_State *L)
+{
+ const char *filename = luaL_checkstring(L, 1);
+ int index = luaL_optint(L, 2, 0);
+ int error;
+ imImage *image = imFileImageLoad(filename, index, &error);
+ return imlua_pushimageerror(L, image, error);
+}
+
+/*****************************************************************************\
+ im.FileImageLoadRegion(filename, [index])
+\*****************************************************************************/
+static int imluaFileImageLoadRegion (lua_State *L)
+{
+ const char *filename = luaL_checkstring(L, 1);
+ int index = luaL_checkint(L, 2);
+ int bitmap = luaL_checkint(L, 3);
+ int xmin = luaL_checkint(L, 4);
+ int xmax = luaL_checkint(L, 5);
+ int ymin = luaL_checkint(L, 6);
+ int ymax = luaL_checkint(L, 7);
+ int width = luaL_checkint(L, 8);
+ int height = luaL_checkint(L, 9);
+ int error;
+ imImage *image = imFileImageLoadRegion(filename, index, bitmap, &error, xmin, xmax, ymin, ymax, width, height);
+ return imlua_pushimageerror(L, image, error);
+}
+
+/*****************************************************************************\
+ im.FileImageLoadBitmap(filename, [index])
+\*****************************************************************************/
+static int imluaFileImageLoadBitmap (lua_State *L)
+{
+ const char *filename = luaL_checkstring(L, 1);
+ int index = luaL_optint(L, 2, 0);
+ int error;
+ imImage *image = imFileImageLoadBitmap(filename, index, &error);
+ return imlua_pushimageerror(L, image, error);
+}
+
+/*****************************************************************************\
+ im.FileImageSave(filename, format, image)
+\*****************************************************************************/
+static int imluaFileImageSave (lua_State *L)
+{
+ const char *file_name = luaL_checkstring(L, 1);
+ const char *format = luaL_checkstring(L, 2);
+ imImage *image = imlua_checkimage(L, 3);
+
+ imlua_pusherror(L, imFileImageSave(file_name, format, image));
+ return 1;
+}
+
+/*****************************************************************************\
+ image:Save(filename, format)
+\*****************************************************************************/
+static int imluaImageSave (lua_State *L)
+{
+ imImage *image = imlua_checkimage(L, 1);
+ const char *file_name = luaL_checkstring(L, 2);
+ const char *format = luaL_checkstring(L, 3);
+
+ imlua_pusherror(L, imFileImageSave(file_name, format, image));
+ return 1;
+}
+
+/*****************************************************************************\
+ image:Destroy()
+\*****************************************************************************/
+static int imluaImageDestroy (lua_State *L)
+{
+ imImage** image_p = imlua_rawcheckimage(L, 1);
+ if (!(*image_p))
+ luaL_argerror(L, 1, "destroyed imImage");
+
+ imImageDestroy(*image_p);
+ *image_p = NULL; /* mark as destroyed */
+ return 0;
+}
+
+/*****************************************************************************\
+ gc
+\*****************************************************************************/
+static int imluaImage_gc (lua_State *L)
+{
+ imImage** image_p = imlua_rawcheckimage(L, 1);
+ if (*image_p)
+ {
+ imImageDestroy(*image_p);
+ *image_p = NULL; /* mark as destroyed */
+ }
+
+ return 0;
+}
+
+/*****************************************************************************\
+ image tostring
+\*****************************************************************************/
+static int imluaImage_tostring (lua_State *L)
+{
+ imImage** image_p = (imImage**)lua_touserdata(L, 1);
+ if (*image_p)
+ {
+ imImage *image = *image_p;
+ lua_pushfstring(L, "imImage(%p) [width=%d,height=%d,color_space=%s,data_type=%s,depth=%d]",
+ image_p,
+ image->width,
+ image->height,
+ imColorModeSpaceName(image->color_space),
+ imDataTypeName(image->data_type),
+ image->depth
+ );
+ }
+ else
+ {
+ lua_pushfstring(L, "imImage(%p)-destroyed", image_p);
+ }
+
+ return 1;
+}
+
+/*****************************************************************************\
+ imagechannel tostring
+\*****************************************************************************/
+static int imluaImageChannel_tostring (lua_State *L)
+{
+ imluaImageChannel *imagechannel = imlua_checkimagechannel(L, 1);
+ lua_pushfstring(L, "imImageChannel(%p) [channel=%d]",
+ imagechannel,
+ imagechannel->channel
+ );
+ return 1;
+}
+
+/*****************************************************************************\
+ imagerow tostring
+\*****************************************************************************/
+static int imluaImageRow_tostring (lua_State *L)
+{
+ char buff[32];
+ imluaImageRow *imagerow = imlua_checkimagerow(L, 1);
+
+ sprintf(buff, "%p", lua_touserdata(L, 1));
+ lua_pushfstring(L, "imImageRow(%s) [channel=%d,row=%d]",
+ buff,
+ imagerow->channel,
+ imagerow->row
+ );
+ return 1;
+}
+
+/*****************************************************************************\
+ image row indexing
+\*****************************************************************************/
+static int imluaImageRow_index (lua_State *L)
+{
+ int index;
+ imluaImageRow *imagerow = imlua_checkimagerow(L, 1);
+ imImage *image = imagerow->image;
+ int channel = imagerow->channel;
+ int row = imagerow->row;
+ int column = luaL_checkint(L, 2);
+
+ if (column < 0 || column >= imagerow->image->width)
+ luaL_argerror(L, 2, "invalid column, out of bounds");
+
+ index = channel * image->width * image->height + row * image->width + column;
+
+ switch (image->data_type)
+ {
+ case IM_BYTE:
+ {
+ imbyte *bdata = (imbyte*) image->data[0];
+ lua_pushnumber(L, (lua_Number) bdata[index]);
+ }
+ break;
+
+ case IM_USHORT:
+ {
+ imushort *udata = (imushort*) image->data[0];
+ lua_pushnumber(L, (lua_Number) udata[index]);
+ }
+ break;
+
+ case IM_INT:
+ {
+ int *idata = (int*) image->data[0];
+ lua_pushnumber(L, (lua_Number) idata[index]);
+ }
+ break;
+
+ case IM_FLOAT:
+ {
+ float *fdata = (float*) image->data[0];
+ lua_pushnumber(L, (lua_Number) fdata[index]);
+ }
+ break;
+
+ case IM_CFLOAT:
+ {
+ float *cdata = (float*) image->data[0];
+ imlua_newarrayfloat(L, cdata + (2*index), 2, 1);
+ }
+ break;
+ }
+
+ return 1;
+}
+
+/*****************************************************************************\
+ image row new index
+\*****************************************************************************/
+static int imluaImageRow_newindex (lua_State *L)
+{
+ int index;
+ imluaImageRow *imagerow = imlua_checkimagerow(L, 1);
+ imImage *image = imagerow->image;
+ int channel = imagerow->channel;
+ int row = imagerow->row;
+ int column = luaL_checkint(L, 2);
+
+ if (column < 0 || column >= imagerow->image->width)
+ luaL_argerror(L, 2, "invalid column, out of bounds");
+
+ index = channel * image->width * image->height + row * image->width + column;
+
+ switch (image->data_type)
+ {
+ case IM_BYTE:
+ {
+ lua_Number value = luaL_checknumber(L, 3);
+ imbyte *bdata = (imbyte*) image->data[0];
+ bdata[index] = (imbyte) value;
+ }
+ break;
+
+ case IM_USHORT:
+ {
+ lua_Number value = luaL_checknumber(L, 3);
+ imushort *udata = (imushort*) image->data[0];
+ udata[index] = (imushort) value;
+ }
+ break;
+
+ case IM_INT:
+ {
+ lua_Number value = luaL_checknumber(L, 3);
+ int *idata = (int*) image->data[0];
+ idata[index] = (int) value;
+ }
+ break;
+
+ case IM_FLOAT:
+ {
+ lua_Number value = luaL_checknumber(L, 3);
+ float *fdata = (float*) image->data[0];
+ fdata[index] = (float) value;
+ }
+ break;
+
+ case IM_CFLOAT:
+ {
+ int count;
+ float *cdata = (float*) image->data[0];
+ float *value = imlua_toarrayfloat(L, 3, &count, 1);
+ if (count != 2)
+ {
+ free(value);
+ luaL_argerror(L, 3, "invalid value");
+ }
+
+ cdata[2*index] = value[0];
+ cdata[2*index+1] = value[1];
+ free(value);
+ }
+ break;
+ }
+
+ return 0;
+}
+
+/*****************************************************************************\
+ image channel indexing
+\*****************************************************************************/
+static int imluaImageChannel_index (lua_State *L)
+{
+ imluaImageChannel *imagechannel = imlua_checkimagechannel(L, 1);
+ int row = luaL_checkint(L, 2);
+
+ if (row < 0 || row >= imagechannel->image->height)
+ luaL_argerror(L, 2, "invalid row, out of bounds");
+
+ imlua_newimagerow(L, imagechannel->image, imagechannel->channel, row);
+ return 1;
+}
+
+/*****************************************************************************\
+ image indexing
+\*****************************************************************************/
+static int imluaImage_index (lua_State *L)
+{
+ imImage *image = imlua_checkimage(L, 1);
+
+ if (lua_isnumber(L, 2))
+ {
+ /* handle numeric indexing */
+ int channel = luaL_checkint(L, 2);
+
+ /* create channel */
+ if (channel < 0 || channel >= image->depth)
+ luaL_argerror(L, 2, "invalid channel, out of bounds");
+
+ imlua_newimagechannel(L, image, channel);
+ }
+ else if (lua_isstring(L, 2))
+ {
+ /* get raw method */
+ lua_getmetatable(L, 1);
+ lua_pushvalue(L, 2);
+ lua_rawget(L, -2);
+ }
+ else
+ {
+ lua_pushnil(L);
+ }
+
+ return 1;
+}
+
+static const luaL_reg imimage_lib[] = {
+ {"ImageCreate", imluaImageCreate},
+ {"ImageDestroy", imluaImageDestroy},
+ {"FileImageLoad", imluaFileImageLoad},
+ {"FileImageLoadBitmap", imluaFileImageLoadBitmap},
+ {"FileImageLoadRegion", imluaFileImageLoadRegion},
+ {"FileImageSave", imluaFileImageSave},
+ {NULL, NULL}
+};
+
+static const luaL_reg imimage_metalib[] = {
+ {"Destroy", imluaImageDestroy},
+ {"AddAlpha", imluaImageAddAlpha},
+ {"Reshape", imluaImageReshape},
+ {"Copy", imluaImageCopy},
+ {"CopyData", imluaImageCopyData},
+ {"Duplicate", imluaImageDuplicate},
+ {"Clone", imluaImageClone},
+ {"SetAttribute", imluaImageSetAttribute},
+ {"GetAttribute", imluaImageGetAttribute},
+ {"GetAttributeList", imluaImageGetAttributeList},
+ {"Clear", imluaImageClear},
+ {"IsBitmap", imluaImageIsBitmap},
+ {"SetPalette", imluaImageSetPalette},
+ {"GetPalette", imluaImageGetPalette},
+ {"CopyAttributes", imluaImageCopyAttributes},
+ {"MatchSize", imluaImageMatchSize},
+ {"MatchColor", imluaImageMatchColor},
+ {"MatchDataType", imluaImageMatchDataType},
+ {"MatchColorSpace", imluaImageMatchColorSpace},
+ {"Match", imluaImageMatch},
+ {"SetBinary", imluaImageSetBinary},
+ {"MakeBinary", imluaImageMakeBinary},
+ {"Width", imluaImageWidth},
+ {"Height", imluaImageHeight},
+ {"Depth", imluaImageDepth},
+ {"DataType", imluaImageDataType},
+ {"ColorSpace", imluaImageColorSpace},
+ {"HasAlpha", imluaImageHasAlpha},
+ {"Save", imluaImageSave},
+
+ {"__gc", imluaImage_gc},
+ {"__tostring", imluaImage_tostring},
+ {"__index", imluaImage_index},
+
+ {NULL, NULL}
+};
+
+static void createmeta (lua_State *L)
+{
+ luaL_newmetatable(L, "imImageChannel"); /* create new metatable for imImageChannel handles */
+ lua_pushliteral(L, "__index");
+ lua_pushcfunction(L, imluaImageChannel_index);
+ lua_rawset(L, -3);
+ lua_pushliteral(L, "__tostring");
+ lua_pushcfunction(L, imluaImageChannel_tostring);
+ lua_rawset(L, -3);
+ lua_pop(L, 1); /* removes the metatable from the top of the stack */
+
+ luaL_newmetatable(L, "imImageChannelRow"); /* create new metatable for imImageChannelRow handles */
+ lua_pushliteral(L, "__index");
+ lua_pushcfunction(L, imluaImageRow_index);
+ lua_rawset(L, -3);
+ lua_pushliteral(L, "__newindex");
+ lua_pushcfunction(L, imluaImageRow_newindex);
+ lua_rawset(L, -3);
+ lua_pushliteral(L, "__tostring");
+ lua_pushcfunction(L, imluaImageRow_tostring);
+ lua_rawset(L, -3);
+ lua_pop(L, 1); /* removes the metatable from the top of the stack */
+
+ /* Object Oriented Access */
+ luaL_newmetatable(L, "imImage"); /* create new metatable for imImage handles */
+ lua_pushliteral(L, "__index"); /* dummy code because imluaImage_index will overwrite this behavior */
+ lua_pushvalue(L, -2); /* push metatable */
+ lua_rawset(L, -3); /* metatable.__index = metatable */
+ luaL_register(L, NULL, imimage_metalib); /* register methods */
+ lua_pop(L, 1); /* removes the metatable from the top of the stack */
+}
+
+/* If all parameteres, besides the image, are nil, this is equivalent to image:Clone.
+ If any parameter is not nil, then the value is used instead of the one from the source image.
+ If a parameter is a function, then the function is called, passing the source
+ image as parameter, to obtain the substituion value. */
+static void reg_image(lua_State *L)
+{
+ const char* data = {
+"function im.ImageCreateBased(image, width, height, color_space, data_type) \n"
+" -- default values are those of the source image \n"
+" width = width or image:Width() \n"
+" height = height or image:Height() \n"
+" color_space = color_space or image:ColorSpace() \n"
+" data_type = data_type or image:DataType() \n"
+" \n"
+" -- callback to calculate parameters based on source image \n"
+" if type(width) == \"function\" then width = width(image) end \n"
+" if type(height) == \"function\" then height = height(image) end \n"
+" if type(color_space) == \"function\" then color_space = color_space(image) end \n"
+" if type(data_type) == \"function\" then data_type = data_type(image) end \n"
+" \n"
+" -- create a new image \n"
+" new_image = im.ImageCreate(width, height, color_space, data_type) \n"
+" image:CopyAttributes(new_image) \n"
+" return new_image \n"
+"end \n"
+ };
+
+ if (luaL_loadbuffer(L, data, strlen(data), "reg_image")==0) lua_pcall(L, 0, 0, 0);
+}
+
+void imlua_open_image (lua_State *L)
+{
+ /* "im" table is at the top of the stack */
+ createmeta(L);
+ luaL_register(L, NULL, imimage_lib);
+ reg_image(L);
+}
diff --git a/src/lua5/imlua_image.h b/src/lua5/imlua_image.h
new file mode 100644
index 0000000..0a39863
--- /dev/null
+++ b/src/lua5/imlua_image.h
@@ -0,0 +1,38 @@
+/** \file
+ * \brief IM Lua 5 Binding
+ *
+ * See Copyright Notice in im_lib.h
+ * $Id: imlua_image.h,v 1.1 2008/10/17 06:16:32 scuri Exp $
+ */
+
+#ifndef __IMLUA_IMAGE_H
+#define __IMLUA_IMAGE_H
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+
+typedef struct _imluaImageChannel {
+ imImage *image;
+ int channel;
+} imluaImageChannel;
+
+typedef struct _imluaImageRow {
+ imImage *image;
+ int channel;
+ int row;
+} imluaImageRow;
+
+void imlua_open_image(lua_State *L);
+
+int imlua_pushimageerror(lua_State *L, imImage* image, int error);
+void imlua_pushimage(lua_State *L, imImage* image);
+imImage* imlua_checkimage(lua_State *L, int param);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/src/lua5/imlua_jp2.c b/src/lua5/imlua_jp2.c
new file mode 100644
index 0000000..d69ba7e
--- /dev/null
+++ b/src/lua5/imlua_jp2.c
@@ -0,0 +1,44 @@
+/** \file
+ * \brief jp2 format Lua 5 Binding
+ *
+ * See Copyright Notice in cd.h
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+
+#include "im_format_jp2.h"
+
+#include <lua.h>
+#include <lauxlib.h>
+
+
+static int imlua_FormatRegisterJP2(lua_State *L)
+{
+ (void)L;
+ imFormatRegisterJP2();
+ return 0;
+}
+
+static const struct luaL_reg imlib[] = {
+ {"FormatRegisterJP2", imlua_FormatRegisterJP2},
+ {NULL, NULL},
+};
+
+
+static int imlua_jp2_open (lua_State *L)
+{
+ imFormatRegisterJP2();
+ luaL_register(L, "im", imlib); /* leave "im" table at the top of the stack */
+ return 1;
+}
+
+int luaopen_imlua_jp2(lua_State* L)
+{
+ return imlua_jp2_open(L);
+}
+
+int luaopen_imlua_jp251(lua_State* L)
+{
+ return imlua_jp2_open(L);
+}
diff --git a/src/lua5/imlua_jp2.def b/src/lua5/imlua_jp2.def
new file mode 100644
index 0000000..29aa05c
--- /dev/null
+++ b/src/lua5/imlua_jp2.def
@@ -0,0 +1,4 @@
+EXPORTS
+ luaopen_imlua_jp2
+ luaopen_imlua_jp251
+ \ No newline at end of file
diff --git a/src/lua5/imlua_kernel.c b/src/lua5/imlua_kernel.c
new file mode 100644
index 0000000..770a989
--- /dev/null
+++ b/src/lua5/imlua_kernel.c
@@ -0,0 +1,182 @@
+/** \file
+ * \brief IM Lua 5 Binding
+ *
+ * See Copyright Notice in im_lib.h
+ * $Id: imlua_kernel.c,v 1.1 2008/10/17 06:16:32 scuri Exp $
+ */
+
+#include <memory.h>
+#include <math.h>
+#include <stdlib.h>
+
+#include "im.h"
+#include "im_image.h"
+#include "im_process.h"
+#include "im_util.h"
+#include "im_kernel.h"
+
+#include <lua.h>
+#include <lauxlib.h>
+
+#include "imlua.h"
+#include "imlua_aux.h"
+#include "imlua_image.h"
+
+
+static int imluaKernelSobel(lua_State *L)
+{
+ imlua_pushimage(L, imKernelSobel());
+ return 1;
+}
+
+static int imluaKernelPrewitt(lua_State *L)
+{
+ imlua_pushimage(L, imKernelPrewitt());
+ return 1;
+}
+
+static int imluaKernelKirsh(lua_State *L)
+{
+ imlua_pushimage(L, imKernelKirsh());
+ return 1;
+}
+
+static int imluaKernelLaplacian4(lua_State *L)
+{
+ imlua_pushimage(L, imKernelLaplacian4());
+ return 1;
+}
+
+static int imluaKernelLaplacian8(lua_State *L)
+{
+ imlua_pushimage(L, imKernelLaplacian8());
+ return 1;
+}
+
+static int imluaKernelLaplacian5x5(lua_State *L)
+{
+ imlua_pushimage(L, imKernelLaplacian5x5());
+ return 1;
+}
+
+static int imluaKernelLaplacian7x7(lua_State *L)
+{
+ imlua_pushimage(L, imKernelLaplacian7x7());
+ return 1;
+}
+
+static int imluaKernelGradian3x3(lua_State *L)
+{
+ imlua_pushimage(L, imKernelGradian3x3());
+ return 1;
+}
+
+static int imluaKernelGradian7x7(lua_State *L)
+{
+ imlua_pushimage(L, imKernelGradian7x7());
+ return 1;
+}
+
+static int imluaKernelSculpt(lua_State *L)
+{
+ imlua_pushimage(L, imKernelSculpt());
+ return 1;
+}
+
+static int imluaKernelMean3x3(lua_State *L)
+{
+ imlua_pushimage(L, imKernelMean3x3());
+ return 1;
+}
+
+static int imluaKernelMean5x5(lua_State *L)
+{
+ imlua_pushimage(L, imKernelMean5x5());
+ return 1;
+}
+
+static int imluaKernelCircularMean5x5(lua_State *L)
+{
+ imlua_pushimage(L, imKernelCircularMean5x5());
+ return 1;
+}
+
+static int imluaKernelMean7x7(lua_State *L)
+{
+ imlua_pushimage(L, imKernelMean7x7());
+ return 1;
+}
+
+static int imluaKernelCircularMean7x7(lua_State *L)
+{
+ imlua_pushimage(L, imKernelCircularMean7x7());
+ return 1;
+}
+
+static int imluaKernelGaussian3x3(lua_State *L)
+{
+ imlua_pushimage(L, imKernelGaussian3x3());
+ return 1;
+}
+
+static int imluaKernelGaussian5x5(lua_State *L)
+{
+ imlua_pushimage(L, imKernelGaussian5x5());
+ return 1;
+}
+
+static int imluaKernelBarlett5x5(lua_State *L)
+{
+ imlua_pushimage(L, imKernelBarlett5x5());
+ return 1;
+}
+
+static int imluaKernelTopHat5x5(lua_State *L)
+{
+ imlua_pushimage(L, imKernelTopHat5x5());
+ return 1;
+}
+
+static int imluaKernelTopHat7x7(lua_State *L)
+{
+ imlua_pushimage(L, imKernelTopHat7x7());
+ return 1;
+}
+
+static int imluaKernelEnhance(lua_State *L)
+{
+ imlua_pushimage(L, imKernelEnhance());
+ return 1;
+}
+
+
+static const luaL_reg imkernel_lib[] = {
+ {"KernelSobel", imluaKernelSobel},
+ {"KernelPrewitt", imluaKernelPrewitt},
+ {"KernelKirsh", imluaKernelKirsh},
+ {"KernelLaplacian4", imluaKernelLaplacian4},
+ {"KernelLaplacian8", imluaKernelLaplacian8},
+ {"KernelLaplacian5x5", imluaKernelLaplacian5x5},
+ {"KernelLaplacian7x7", imluaKernelLaplacian7x7},
+ {"KernelGradian3x3", imluaKernelGradian3x3},
+ {"KernelGradian7x7", imluaKernelGradian7x7},
+ {"KernelSculpt", imluaKernelSculpt},
+ {"KernelMean3x3", imluaKernelMean3x3},
+ {"KernelMean5x5", imluaKernelMean5x5},
+ {"KernelCircularMean5x5", imluaKernelCircularMean5x5},
+ {"KernelMean7x7", imluaKernelMean7x7},
+ {"KernelCircularMean7x7", imluaKernelCircularMean7x7},
+ {"KernelGaussian3x3", imluaKernelGaussian3x3},
+ {"KernelGaussian5x5", imluaKernelGaussian5x5},
+ {"KernelBarlett5x5", imluaKernelBarlett5x5},
+ {"KernelTopHat5x5", imluaKernelTopHat5x5},
+ {"KernelTopHat7x7", imluaKernelTopHat7x7},
+ {"KernelEnhance", imluaKernelEnhance},
+ {NULL, NULL}
+};
+
+void imlua_open_kernel (lua_State *L)
+{
+ /* "im" table is at the top of the stack */
+ luaL_register(L, NULL, imkernel_lib);
+}
diff --git a/src/lua5/imlua_palette.c b/src/lua5/imlua_palette.c
new file mode 100644
index 0000000..80d23eb
--- /dev/null
+++ b/src/lua5/imlua_palette.c
@@ -0,0 +1,399 @@
+/** \file
+ * \brief IM Lua 5 Binding
+ *
+ * See Copyright Notice in im_lib.h
+ * $Id: imlua_palette.c,v 1.1 2008/10/17 06:16:32 scuri Exp $
+ */
+
+#include <string.h>
+#include <memory.h>
+#include <stdlib.h>
+
+#include "im.h"
+#include "im_image.h"
+#include "im_util.h"
+#include "im_palette.h"
+
+#include <lua.h>
+#include <lauxlib.h>
+
+#include "imlua.h"
+#include "imlua_aux.h"
+#include "imlua_palette.h"
+
+
+static imluaPalette* imlua_rawcheckpalette(lua_State *L, int param)
+{
+ void *p = lua_touserdata(L, param);
+ if (p != NULL) { /* value is a userdata? */
+ if (lua_getmetatable(L, param)) { /* does it have a metatable? */
+ lua_getfield(L, LUA_REGISTRYINDEX, "imPalette"); /* get correct metatable */
+ if (lua_rawequal(L, -1, -2)) { /* does it have the correct mt? */
+ lua_pop(L, 2); /* remove both metatables */
+ return (imluaPalette*)p;
+ }
+ lua_pop(L, 1); /* remove previous metatable */
+
+ /* check also for CD palette */
+ lua_getfield(L, LUA_REGISTRYINDEX, "cdPalette"); /* get correct metatable */
+ if (lua_rawequal(L, -1, -2)) { /* does it have the correct mt? */
+ lua_pop(L, 2); /* remove both metatables */
+ return (imluaPalette*)p;
+ }
+ }
+ }
+ luaL_typerror(L, param, "imPalette"); /* else error */
+ return NULL; /* to avoid warnings */
+}
+
+imluaPalette* imlua_checkpalette (lua_State *L, int param)
+{
+ imluaPalette* pal = imlua_rawcheckpalette(L, param);
+ if (!pal->color)
+ luaL_argerror(L, param, "destroyed imPalette");
+
+ return pal;
+}
+
+void imlua_pushpalette(lua_State *L, long* color, int count)
+{
+ imluaPalette *pal = (imluaPalette*) lua_newuserdata(L, sizeof(imluaPalette));
+ pal->count = count;
+ pal->color = color;
+ luaL_getmetatable(L, "imPalette");
+ lua_setmetatable(L, -2);
+}
+
+/***************************************************************************\
+* Creates a palette as a "imPalette" userdata. A palette can be *
+* considered and treated as a color table. *
+* im.PaletteCreate(count: number) -> (palette: "imPalette") *
+\***************************************************************************/
+static int imluaPaletteCreate(lua_State *L)
+{
+ long* color;
+
+ int count = luaL_optint(L, 1, 256);
+ if (count < 1 || count > 256)
+ luaL_argerror(L, 1, "palette count should be a positive integer and less then 256");
+
+ color = (long*)malloc(256*sizeof(long));
+ memset(color, 0, 256*sizeof(long));
+
+ imlua_pushpalette(L, color, count);
+ return 1;
+}
+
+
+/*****************************************************************************\
+ im.PaletteFindNearest
+\*****************************************************************************/
+static int imluaPaletteFindNearest (lua_State *L)
+{
+ imluaPalette *pal = imlua_checkpalette(L, 1);
+ long color = (long int) lua_touserdata(L, 1);
+
+ lua_pushnumber(L, imPaletteFindNearest(pal->color, pal->count, color));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.PaletteFindColor
+\*****************************************************************************/
+static int imluaPaletteFindColor (lua_State *L)
+{
+ imluaPalette *pal = imlua_checkpalette(L, 1);
+ long color = (long) lua_touserdata(L, 2);
+ unsigned char tol = (unsigned char)luaL_checkint(L, 3);
+
+ lua_pushnumber(L, imPaletteFindColor(pal->color, pal->count, color, tol));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.PaletteGray
+\*****************************************************************************/
+static int imluaPaletteGray (lua_State *L)
+{
+ imlua_pushpalette(L, imPaletteGray(), 256);
+ return 1;
+}
+
+/*****************************************************************************\
+ im.PaletteRed
+\*****************************************************************************/
+static int imluaPaletteRed (lua_State *L)
+{
+ imlua_pushpalette(L, imPaletteRed(), 256);
+ return 1;
+}
+
+/*****************************************************************************\
+ im.PaletteGreen
+\*****************************************************************************/
+static int imluaPaletteGreen (lua_State *L)
+{
+ imlua_pushpalette(L, imPaletteGreen(), 256);
+ return 1;
+}
+
+/*****************************************************************************\
+ im.PaletteBlue
+\*****************************************************************************/
+static int imluaPaletteBlue (lua_State *L)
+{
+ imlua_pushpalette(L, imPaletteBlue(), 256);
+ return 1;
+}
+
+/*****************************************************************************\
+ im.PaletteYellow
+\*****************************************************************************/
+static int imluaPaletteYellow (lua_State *L)
+{
+ imlua_pushpalette(L, imPaletteYellow(), 256);
+ return 1;
+}
+
+/*****************************************************************************\
+ im.PaletteMagenta
+\*****************************************************************************/
+static int imluaPaletteMagenta (lua_State *L)
+{
+ imlua_pushpalette(L, imPaletteMagenta(), 256);
+ return 1;
+}
+
+/*****************************************************************************\
+ im.PaletteCian
+\*****************************************************************************/
+static int imluaPaletteCian (lua_State *L)
+{
+ imlua_pushpalette(L, imPaletteCian(), 256);
+ return 1;
+}
+
+/*****************************************************************************\
+ im.PaletteRainbow
+\*****************************************************************************/
+static int imluaPaletteRainbow (lua_State *L)
+{
+ imlua_pushpalette(L, imPaletteRainbow(), 256);
+ return 1;
+}
+
+/*****************************************************************************\
+ im.PaletteHues
+\*****************************************************************************/
+static int imluaPaletteHues (lua_State *L)
+{
+ imlua_pushpalette(L, imPaletteHues(), 256);
+ return 1;
+}
+
+/*****************************************************************************\
+ im.PaletteBlueIce
+\*****************************************************************************/
+static int imluaPaletteBlueIce (lua_State *L)
+{
+ imlua_pushpalette(L, imPaletteBlueIce(), 256);
+ return 1;
+}
+
+/*****************************************************************************\
+ im.PaletteHotIron
+\*****************************************************************************/
+static int imluaPaletteHotIron (lua_State *L)
+{
+ imlua_pushpalette(L, imPaletteHotIron(), 256);
+ return 1;
+}
+
+/*****************************************************************************\
+ im.PaletteBlackBody
+\*****************************************************************************/
+static int imluaPaletteBlackBody (lua_State *L)
+{
+ imlua_pushpalette(L, imPaletteBlackBody(), 256);
+ return 1;
+}
+
+/*****************************************************************************\
+ im.PaletteHighContrast
+\*****************************************************************************/
+static int imluaPaletteHighContrast (lua_State *L)
+{
+ imlua_pushpalette(L, imPaletteHighContrast(), 256);
+ return 1;
+}
+
+/*****************************************************************************\
+ im.PaletteUniform
+\*****************************************************************************/
+static int imluaPaletteUniform (lua_State *L)
+{
+ imlua_pushpalette(L, imPaletteUniform(), 256);
+ return 1;
+}
+
+/*****************************************************************************\
+ im.PaletteUniformIndex
+\*****************************************************************************/
+static int imluaPaletteUniformIndex (lua_State *L)
+{
+ lua_pushnumber(L, imPaletteUniformIndex((long int) lua_touserdata(L, 1)));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.PaletteUniformIndexHalftoned
+\*****************************************************************************/
+static int imluaPaletteUniformIndexHalftoned (lua_State *L)
+{
+ long color = (long) lua_touserdata(L, 1);
+ int x = luaL_checkint(L, 2);
+ int y = luaL_checkint(L, 3);
+
+ lua_pushnumber(L, imPaletteUniformIndexHalftoned(color, x, y));
+ return 1;
+}
+
+/***************************************************************************\
+* Frees a previously allocated palette *
+* im.PaletteDestroy(palette: "imPalette") *
+\***************************************************************************/
+static int imluaPaletteDestroy (lua_State *L)
+{
+ imluaPalette *pal = imlua_rawcheckpalette(L, 1);
+ if (!pal->color)
+ luaL_argerror(L, 1, "destroyed imPalette");
+
+ free(pal->color);
+ pal->color = NULL; /* mark as destroyed */
+ pal->count = 0;
+
+ return 0;
+}
+
+/*****************************************************************************\
+ gc
+\*****************************************************************************/
+static int imluaPalette_gc(lua_State *L)
+{
+ imluaPalette *pal = (imluaPalette*)lua_touserdata(L, 1);
+ if (pal && pal->color)
+ {
+ free(pal->color);
+ pal->color = NULL; /* mark as destroyed */
+ pal->count = 0;
+ }
+
+ return 0;
+}
+
+/***************************************************************************\
+* color = palette[i] *
+\***************************************************************************/
+static int imluaPalette_index(lua_State *L)
+{
+ imluaPalette *pal = imlua_checkpalette(L, 1);
+ int index_i = luaL_checkint(L, 2);
+
+ if (index_i < 0 || index_i >= pal->count)
+ luaL_argerror(L, 2, "index is out of bounds");
+
+ lua_pushlightuserdata(L, (void*) pal->color[index_i]);
+ return 1;
+}
+
+/***************************************************************************\
+* palette[i] = color *
+\***************************************************************************/
+static int imluaPalette_newindex(lua_State *L)
+{
+ long color_i;
+ imluaPalette *pal = imlua_checkpalette(L, 1);
+ int index_i = luaL_checkint(L, 2);
+
+ if (index_i < 0 || index_i >= pal->count)
+ luaL_argerror(L, 2, "index is out of bounds");
+
+ if (!lua_islightuserdata(L, 3))
+ luaL_argerror(L, 3, "color must be a light user data");
+
+ color_i = (long int) lua_touserdata(L, 3);
+
+ pal->color[index_i] = color_i;
+ return 0;
+}
+
+/*****************************************************************************\
+ len
+\*****************************************************************************/
+static int imluaPalette_len(lua_State *L)
+{
+ imluaPalette *pal = (imluaPalette*)lua_touserdata(L, 1);
+ lua_pushinteger(L, pal->count);
+ return 1;
+}
+
+/*****************************************************************************\
+ tostring
+\*****************************************************************************/
+static int imluaPalette_tostring (lua_State *L)
+{
+ imluaPalette *pal = (imluaPalette*)lua_touserdata(L, 1);
+ lua_pushfstring(L, "imPalette(%p)%s", pal, (pal->color)? "": "-destroyed");
+ return 1;
+}
+
+static const luaL_reg impalette_lib[] = {
+ {"PaletteFindNearest", imluaPaletteFindNearest},
+ {"PaletteFindColor", imluaPaletteFindColor},
+ {"PaletteGray", imluaPaletteGray },
+ {"PaletteRed", imluaPaletteRed },
+ {"PaletteGreen", imluaPaletteGreen },
+ {"PaletteBlue", imluaPaletteBlue },
+ {"PaletteYellow", imluaPaletteYellow },
+ {"PaletteMagenta", imluaPaletteMagenta },
+ {"PaletteCian", imluaPaletteCian },
+ {"PaletteRainbow", imluaPaletteRainbow },
+ {"PaletteHues", imluaPaletteHues },
+ {"PaletteBlueIce", imluaPaletteBlueIce },
+ {"PaletteHotIron", imluaPaletteHotIron },
+ {"PaletteBlackBody", imluaPaletteBlackBody },
+ {"PaletteHighContrast", imluaPaletteHighContrast },
+ {"PaletteUniform", imluaPaletteUniform },
+ {"PaletteUniformIndex", imluaPaletteUniformIndex },
+ {"PaletteUniformIndexHalftoned", imluaPaletteUniformIndexHalftoned },
+
+ {"PaletteDestroy", imluaPaletteDestroy},
+ {"PaletteCreate", imluaPaletteCreate},
+
+ {NULL, NULL}
+};
+
+static const luaL_reg impalette_metalib[] = {
+ {"__gc", imluaPalette_gc},
+ {"__tostring", imluaPalette_tostring},
+ {"__index", imluaPalette_index},
+ {"__newindex", imluaPalette_newindex},
+ {"__len", imluaPalette_len},
+
+ {NULL, NULL}
+};
+
+static void createmeta (lua_State *L)
+{
+ /* there is no object orientation for imPalette, only array access */
+ luaL_newmetatable(L, "imPalette"); /* create new metatable for imPalette handles */
+ luaL_register(L, NULL, impalette_metalib); /* register methods */
+ lua_pop(L, 1); /* removes the metatable from the top of the stack */
+}
+
+void imlua_open_palette (lua_State *L)
+{
+ /* "im" table is at the top of the stack */
+ createmeta(L);
+ luaL_register(L, NULL, impalette_lib);
+}
diff --git a/src/lua5/imlua_palette.h b/src/lua5/imlua_palette.h
new file mode 100644
index 0000000..453fd01
--- /dev/null
+++ b/src/lua5/imlua_palette.h
@@ -0,0 +1,32 @@
+/** \file
+ * \brief IM Lua 5 Binding
+ *
+ * See Copyright Notice in im_lib.h
+ * $Id: imlua_palette.h,v 1.1 2008/10/17 06:16:32 scuri Exp $
+ */
+
+#ifndef __IMLUA_PALETTE_H
+#define __IMLUA_PALETTE_H
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+
+/* this is the same declaration used in the CD toolkit for cdPalette in Lua */
+typedef struct _imPalette {
+ long* color;
+ int count;
+} imluaPalette;
+
+void imlua_pushpalette(lua_State *L, long* color, int count);
+imluaPalette* imlua_checkpalette (lua_State *L, int param);
+
+void imlua_open_palette(lua_State *L);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/src/lua5/imlua_process.c b/src/lua5/imlua_process.c
new file mode 100644
index 0000000..8a6fe64
--- /dev/null
+++ b/src/lua5/imlua_process.c
@@ -0,0 +1,3091 @@
+/** \file
+ * \brief IM Lua 5 Binding
+ *
+ * See Copyright Notice in im_lib.h
+ * $Id: imlua_process.c,v 1.1 2008/10/17 06:16:32 scuri Exp $
+ */
+
+#include <memory.h>
+#include <math.h>
+#include <stdlib.h>
+
+#include "im.h"
+#include "im_image.h"
+#include "im_process.h"
+#include "im_util.h"
+
+#include <lua.h>
+#include <lauxlib.h>
+
+#include "imlua.h"
+#include "imlua_aux.h"
+#include "imlua_image.h"
+
+
+
+/*****************************************************************************\
+ Image Statistics Calculations
+\*****************************************************************************/
+
+/*****************************************************************************\
+ im.CalcRMSError(image1, image2)
+\*****************************************************************************/
+static int imluaCalcRMSError (lua_State *L)
+{
+ imImage* image1 = imlua_checkimage(L, 1);
+ imImage* image2 = imlua_checkimage(L, 2);
+
+ imlua_match(L, image1, image2);
+
+ lua_pushnumber(L, imCalcRMSError(image1, image2));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.CalcSNR(src_image, noise_image)
+\*****************************************************************************/
+static int imluaCalcSNR (lua_State *L)
+{
+ imImage* src_image = imlua_checkimage(L, 1);
+ imImage* noise_image = imlua_checkimage(L, 2);
+
+ imlua_match(L, src_image, noise_image);
+
+ lua_pushnumber(L, imCalcSNR(src_image, noise_image));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.CalcCountColors(src_image)
+\*****************************************************************************/
+static int imluaCalcCountColors (lua_State *L)
+{
+ imImage* src_image = imlua_checkimage(L, 1);
+
+ imlua_checkdatatype(L, 1, src_image, IM_BYTE);
+ if (src_image->color_space >= IM_CMYK)
+ luaL_argerror(L, 1, "color space can be RGB, Gray, Binary or Map only");
+
+ lua_pushnumber(L, imCalcCountColors(src_image));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.CalcHistogram(src_image, plane, cumulative)
+\*****************************************************************************/
+static int imluaCalcHistogram (lua_State *L)
+{
+ imImage* src_image = imlua_checkimage(L, 1);
+ int plane = luaL_checkint(L, 2);
+ int cumulative = luaL_checkint(L, 3);
+
+ switch (src_image->data_type)
+ {
+ case IM_BYTE:
+ {
+ unsigned long hist[256];
+ imCalcHistogram((imbyte*) src_image->data[plane], src_image->count, hist, cumulative);
+ imlua_newarrayulong(L, hist, 256, 0);
+ }
+ break;
+
+ case IM_USHORT:
+ {
+ unsigned long hist[65535];
+ imCalcUShortHistogram(src_image->data[plane], src_image->count, hist, cumulative);
+ imlua_newarrayulong(L, hist, 65535, 0);
+ }
+ break;
+
+ default:
+ luaL_argerror(L, 1, "data_type can be byte or ushort only");
+ break;
+ }
+
+ return 1;
+}
+
+/*****************************************************************************\
+ im.CalcGrayHistogram(src_image, cumulative)
+\*****************************************************************************/
+static int imluaCalcGrayHistogram (lua_State *L)
+{
+ unsigned long hist[256];
+ imImage* src_image = imlua_checkimage(L, 1);
+ int cumulative = luaL_checkint(L, 2);
+
+ imlua_checkdatatype(L, 1, src_image, IM_BYTE);
+ if (src_image->color_space >= IM_CMYK)
+ luaL_argerror(L, 1, "color space can be RGB, Gray, Binary or Map only");
+
+ imCalcGrayHistogram(src_image, hist, cumulative);
+ imlua_newarrayulong(L, hist, 256, 0);
+
+ return 1;
+}
+
+/*****************************************************************************\
+ im.CalcImageStatistics(src_image)
+\*****************************************************************************/
+static int imluaCalcImageStatistics (lua_State *L)
+{
+ imStats stats;
+ imImage *image = imlua_checkimage(L, 1);
+
+ if (image->data_type == IM_CFLOAT)
+ luaL_argerror(L, 1, "data type can NOT be of type cfloat");
+
+ imCalcImageStatistics(image, &stats);
+
+ lua_newtable(L);
+ lua_pushstring(L, "max"); lua_pushnumber(L, stats.max); lua_settable(L, -3);
+ lua_pushstring(L, "min"); lua_pushnumber(L, stats.min); lua_settable(L, -3);
+ lua_pushstring(L, "positive"); lua_pushnumber(L, stats.positive); lua_settable(L, -3);
+ lua_pushstring(L, "negative"); lua_pushnumber(L, stats.negative); lua_settable(L, -3);
+ lua_pushstring(L, "zeros"); lua_pushnumber(L, stats.zeros); lua_settable(L, -3);
+ lua_pushstring(L, "mean"); lua_pushnumber(L, stats.mean); lua_settable(L, -3);
+ lua_pushstring(L, "stddev"); lua_pushnumber(L, stats.stddev); lua_settable(L, -3);
+ return 1;
+}
+
+/*****************************************************************************\
+ im.CalcHistogramStatistics(src_image)
+\*****************************************************************************/
+static int imluaCalcHistogramStatistics (lua_State *L)
+{
+ imStats stats;
+ imImage *image = imlua_checkimage(L, 1);
+
+ imlua_checkdatatype(L, 1, image, IM_BYTE);
+
+ imCalcHistogramStatistics(image, &stats);
+
+ lua_newtable(L);
+ lua_pushstring(L, "max"); lua_pushnumber(L, stats.max); lua_settable(L, -3);
+ lua_pushstring(L, "min"); lua_pushnumber(L, stats.min); lua_settable(L, -3);
+ lua_pushstring(L, "positive"); lua_pushnumber(L, stats.positive); lua_settable(L, -3);
+ lua_pushstring(L, "negative"); lua_pushnumber(L, stats.negative); lua_settable(L, -3);
+ lua_pushstring(L, "zeros"); lua_pushnumber(L, stats.zeros); lua_settable(L, -3);
+ lua_pushstring(L, "mean"); lua_pushnumber(L, stats.mean); lua_settable(L, -3);
+ lua_pushstring(L, "stddev"); lua_pushnumber(L, stats.stddev); lua_settable(L, -3);
+ return 1;
+}
+
+/*****************************************************************************\
+ im.CalcHistoImageStatistics
+\*****************************************************************************/
+static int imluaCalcHistoImageStatistics (lua_State *L)
+{
+ int* median;
+ int* mode;
+
+ imImage *image = imlua_checkimage(L, 1);
+
+ imlua_checkdatatype(L, 1, image, IM_BYTE);
+
+ median = (int*)malloc(sizeof(int)*image->depth);
+ mode = (int*)malloc(sizeof(int)*image->depth);
+
+ imCalcHistoImageStatistics(image, median, mode);
+
+ imlua_newarrayint (L, median, image->depth, 0);
+ imlua_newarrayint (L, mode, image->depth, 0);
+
+ free(median);
+ free(mode);
+
+ return 2;
+}
+
+/*****************************************************************************\
+ Image Analysis
+\*****************************************************************************/
+
+/*****************************************************************************\
+ im.AnalyzeFindRegions(src_image, dst_image, connect, touch_border)
+\*****************************************************************************/
+static int imluaAnalyzeFindRegions (lua_State *L)
+{
+ imImage* src_image = imlua_checkimage(L, 1);
+ imImage* dst_image = imlua_checkimage(L, 2);
+ int connect = luaL_checkint(L, 3);
+ int touch_border = lua_toboolean(L, 4);
+
+ imlua_checkcolorspace(L, 1, src_image, IM_BINARY);
+ imlua_checktype(L, 2, dst_image, IM_GRAY, IM_USHORT);
+
+ luaL_argcheck(L, (connect == 4 || connect == 8), 3, "invalid connect value, must be 4 or 8");
+ lua_pushnumber(L, imAnalyzeFindRegions(src_image, dst_image, connect, touch_border));
+ return 1;
+}
+
+static int iGetMax(imImage* image)
+{
+ int max = 0;
+ int i;
+
+ imushort* data = (imushort*)image->data[0];
+ for (i = 0; i < image->count; i++)
+ {
+ if (*data > max)
+ max = *data;
+
+ data++;
+ }
+
+ return max;
+}
+
+static int imlua_checkregioncount(lua_State *L, int narg, imImage* image)
+{
+ if (lua_isnoneornil(L, narg)) return iGetMax(image);
+ else return (int)luaL_checknumber(L, narg);
+}
+
+
+/*****************************************************************************\
+ im.AnalyzeMeasureArea(image, [count])
+\*****************************************************************************/
+static int imluaAnalyzeMeasureArea (lua_State *L)
+{
+ int count;
+ int *area;
+
+ imImage* image = imlua_checkimage(L, 1);
+
+ imlua_checktype(L, 1, image, IM_GRAY, IM_USHORT);
+
+ count = imlua_checkregioncount(L, 2, image);
+ area = (int*) malloc(sizeof(int) * count);
+
+ imAnalyzeMeasureArea(image, area, count);
+
+ imlua_newarrayint(L, area, count, 0);
+ free(area);
+
+ return 1;
+}
+
+/*****************************************************************************\
+ im.AnalyzeMeasurePerimArea(image)
+\*****************************************************************************/
+static int imluaAnalyzeMeasurePerimArea (lua_State *L)
+{
+ int count;
+ float *perimarea;
+
+ imImage* image = imlua_checkimage(L, 1);
+
+ imlua_checktype(L, 1, image, IM_GRAY, IM_USHORT);
+
+ count = imlua_checkregioncount(L, 2, image);
+ perimarea = (float*) malloc(sizeof(float) * count);
+
+ imAnalyzeMeasurePerimArea(image, perimarea);
+
+ imlua_newarrayfloat (L, perimarea, count, 0);
+ free(perimarea);
+
+ return 1;
+}
+
+/*****************************************************************************\
+ im.AnalyzeMeasureCentroid(image, [area], [count])
+\*****************************************************************************/
+static int imluaAnalyzeMeasureCentroid (lua_State *L)
+{
+ int count;
+ float *cx, *cy;
+ int *area;
+
+ imImage* image = imlua_checkimage(L, 1);
+
+ imlua_checktype(L, 1, image, IM_GRAY, IM_USHORT);
+
+ area = imlua_toarrayint(L, 2, &count, 0);
+ count = imlua_checkregioncount(L, 3, image);
+
+ cx = (float*) malloc (sizeof(float) * count);
+ cy = (float*) malloc (sizeof(float) * count);
+
+ imAnalyzeMeasureCentroid(image, area, count, cx, cy);
+
+ imlua_newarrayfloat(L, cx, count, 0);
+ imlua_newarrayfloat(L, cy, count, 0);
+
+ if (area)
+ free(area);
+ free(cx);
+ free(cy);
+
+ return 2;
+}
+
+/*****************************************************************************\
+ im.AnalyzeMeasurePrincipalAxis(image, [area], [cx], [cy])
+\*****************************************************************************/
+static int imluaAnalyzeMeasurePrincipalAxis (lua_State *L)
+{
+ int count;
+ float *cx, *cy;
+ int *area;
+ float *major_slope, *major_length, *minor_slope, *minor_length;
+
+ imImage* image = imlua_checkimage(L, 1);
+
+ imlua_checktype(L, 1, image, IM_GRAY, IM_USHORT);
+
+ area = imlua_toarrayint(L, 2, &count, 0);
+ cx = imlua_toarrayfloat(L, 3, NULL, 0);
+ cy = imlua_toarrayfloat(L, 4, NULL, 0);
+ count = imlua_checkregioncount(L, 5, image);
+
+ major_slope = (float*) malloc (sizeof(float) * count);
+ major_length = (float*) malloc (sizeof(float) * count);
+ minor_slope = (float*) malloc (sizeof(float) * count);
+ minor_length = (float*) malloc (sizeof(float) * count);
+
+ imAnalyzeMeasurePrincipalAxis(image, area, cx, cy, count, major_slope, major_length, minor_slope, minor_length);
+
+ imlua_newarrayfloat(L, major_slope, count, 0);
+ imlua_newarrayfloat(L, major_length, count, 0);
+ imlua_newarrayfloat(L, minor_slope, count, 0);
+ imlua_newarrayfloat(L, minor_length, count, 0);
+
+ if (area)
+ free(area);
+ if (cx)
+ free(cx);
+ if (cy)
+ free(cy);
+
+ free(major_slope);
+ free(major_length);
+ free(minor_slope);
+ free(minor_length);
+
+ return 4;
+}
+
+/*****************************************************************************\
+ im.AnalyzeMeasureHoles
+\*****************************************************************************/
+static int imluaAnalyzeMeasureHoles (lua_State *L)
+{
+ int holes_count, count;
+ int connect;
+ int *area = NULL;
+ float *perim = NULL;
+
+ imImage* image = imlua_checkimage(L, 1);
+
+ imlua_checktype(L, 1, image, IM_GRAY, IM_USHORT);
+
+ connect = luaL_checkint(L, 2);
+ count = imlua_checkregioncount(L, 3, image);
+
+ area = (int*) malloc (sizeof(int) * count);
+ perim = (float*) malloc (sizeof(float) * count);
+
+ imAnalyzeMeasureHoles(image, connect, &holes_count, area, perim);
+
+ lua_pushnumber(L, holes_count);
+ imlua_newarrayint(L, area, holes_count, 0);
+ imlua_newarrayfloat(L, perim, holes_count, 0);
+
+ if (area)
+ free(area);
+ if (perim)
+ free(perim);
+
+ return 3;
+}
+
+/*****************************************************************************\
+ im.AnalyzeMeasurePerimeter(image, [count])
+\*****************************************************************************/
+static int imluaAnalyzeMeasurePerimeter (lua_State *L)
+{
+ int count;
+ float *perim;
+
+ imImage* image = imlua_checkimage(L, 1);
+
+ imlua_checktype(L, 1, image, IM_GRAY, IM_USHORT);
+
+ count = imlua_checkregioncount(L, 2, image);
+ perim = (float*) malloc(sizeof(float) * count);
+
+ imAnalyzeMeasurePerimeter(image, perim, count);
+
+ imlua_newarrayfloat(L, perim, count, 0);
+
+ free(perim);
+
+ return 1;
+}
+
+/*****************************************************************************\
+ im.ProcessPerimeterLine(src_image, dst_image)
+\*****************************************************************************/
+static int imluaProcessPerimeterLine (lua_State *L)
+{
+ imImage* src_image = imlua_checkimage(L, 1);
+ imImage* dst_image = imlua_checkimage(L, 2);
+
+ luaL_argcheck(L, (src_image->data_type < IM_FLOAT), 1, "image data type can be integer only");
+ imlua_match(L, src_image, dst_image);
+
+ imProcessPerimeterLine(src_image, dst_image);
+ return 0;
+}
+
+/*****************************************************************************\
+ im.ProcessPrune(src_image, dst_image, connect, start_size, end_size)
+\*****************************************************************************/
+static int imluaProcessPrune (lua_State *L)
+{
+ imImage* src_image = imlua_checkimage(L, 1);
+ imImage* dst_image = imlua_checkimage(L, 2);
+ int connect = luaL_checkint(L, 3);
+ int start_size = luaL_checkint(L, 4);
+ int end_size = luaL_checkint(L, 5);
+
+ imlua_checkcolorspace(L, 1, src_image, IM_BINARY);
+ imlua_match(L, src_image, dst_image);
+ luaL_argcheck(L, (connect == 4 || connect == 8), 3, "invalid connect value, must be 4 or 8");
+
+ imProcessPrune(src_image, dst_image, connect, start_size, end_size);
+ return 0;
+}
+
+/*****************************************************************************\
+ im.ProcessFillHoles(src_image, dst_image, connect)
+\*****************************************************************************/
+static int imluaProcessFillHoles (lua_State *L)
+{
+ imImage* src_image = imlua_checkimage(L, 1);
+ imImage* dst_image = imlua_checkimage(L, 2);
+ int connect = luaL_checkint(L, 3);
+
+ imlua_checkcolorspace(L, 1, src_image, IM_BINARY);
+ imlua_match(L, src_image, dst_image);
+ luaL_argcheck(L, (connect == 4 || connect == 8), 3, "invalid connect value, must be 4 or 8");
+
+ imProcessFillHoles(src_image, dst_image, connect);
+ return 0;
+}
+
+static void imlua_checkhoughsize(lua_State *L, imImage* image, imImage* hough_image, int param)
+{
+#define IMSQR(_x) (_x*_x)
+ int hough_rmax;
+ if (hough_image->width != 180)
+ luaL_argerror(L, param, "invalid image width");
+
+ hough_rmax = (int)(sqrt((double)(IMSQR(image->width) + IMSQR(image->height)))/2.0);
+ if (hough_image->height != 2*hough_rmax+1)
+ luaL_argerror(L, param, "invalid image height");
+}
+
+/*****************************************************************************\
+ im.ProcessHoughLines(src_image, dst_image)
+\*****************************************************************************/
+static int imluaProcessHoughLines (lua_State *L)
+{
+ imImage* src_image = imlua_checkimage(L, 1);
+ imImage* dst_image = imlua_checkimage(L, 2);
+
+ imlua_checkcolorspace(L, 1, src_image, IM_BINARY);
+ imlua_checktype(L, 2, dst_image, IM_GRAY, IM_INT);
+ imlua_checkhoughsize(L, src_image, dst_image, 2);
+
+ lua_pushboolean(L, imProcessHoughLines(src_image, dst_image));
+ return 0;
+}
+
+/*****************************************************************************\
+ im.ProcessHoughLinesDraw(src_image, hough_points, dst_image)
+\*****************************************************************************/
+static int imluaProcessHoughLinesDraw (lua_State *L)
+{
+ imImage* src_image = imlua_checkimage(L, 1);
+ imImage* hough_points = imlua_checkimage(L, 3);
+ imImage* dst_image = imlua_checkimage(L, 4);
+ imImage* hough = NULL;
+ if (lua_isuserdata(L, 2))
+ {
+ hough = imlua_checkimage(L, 2);
+ imlua_checktype(L, 2, hough, IM_GRAY, IM_INT);
+ imlua_checkhoughsize(L, src_image, hough, 2);
+ }
+
+ imlua_checktype(L, 1, src_image, IM_GRAY, IM_BYTE);
+ imlua_checkcolorspace(L, 3, hough_points, IM_BINARY);
+ imlua_checkhoughsize(L, src_image, hough_points, 3);
+ imlua_matchsize(L, src_image, dst_image);
+
+ lua_pushnumber(L, imProcessHoughLinesDraw(src_image, hough, hough_points, dst_image));
+ return 0;
+}
+
+/*****************************************************************************\
+ im.ProcessDistanceTransform(src_image, dst_image)
+\*****************************************************************************/
+static int imluaProcessDistanceTransform (lua_State *L)
+{
+ imImage* src_image = imlua_checkimage(L, 1);
+ imImage* dst_image = imlua_checkimage(L, 2);
+
+ imlua_checkcolorspace(L, 1, src_image, IM_BINARY);
+ imlua_checkdatatype(L, 2, dst_image, IM_FLOAT);
+ imlua_matchsize(L, src_image, dst_image);
+
+ imProcessDistanceTransform(src_image, dst_image);
+ return 0;
+}
+
+/*****************************************************************************\
+ im.ProcessRegionalMaximum(src_image, dst_image)
+\*****************************************************************************/
+static int imluaProcessRegionalMaximum (lua_State *L)
+{
+ imImage* src_image = imlua_checkimage(L, 1);
+ imImage* dst_image = imlua_checkimage(L, 2);
+
+ imlua_checktype(L, 1, src_image, IM_GRAY, IM_FLOAT);
+ imlua_checkcolorspace(L, 2, dst_image, IM_BINARY);
+ imlua_matchsize(L, src_image, dst_image);
+
+ imProcessRegionalMaximum(src_image, dst_image);
+ return 0;
+}
+
+/*****************************************************************************\
+ Image Resize
+\*****************************************************************************/
+
+/*****************************************************************************\
+ im.ProcessReduce(src_image, dst_image, order)
+\*****************************************************************************/
+static int imluaProcessReduce (lua_State *L)
+{
+ imImage* src_image = imlua_checkimage(L, 1);
+ imImage* dst_image = imlua_checkimage(L, 2);
+ int order = luaL_checkint(L, 3);
+
+ imlua_matchcolor(L, src_image, dst_image);
+ luaL_argcheck(L, (order == 0 || order == 1), 3, "invalid order, must be 0 or 1");
+
+ lua_pushboolean(L, imProcessReduce(src_image, dst_image, order));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.ProcessResize(src_image, dst_image, order)
+\*****************************************************************************/
+static int imluaProcessResize (lua_State *L)
+{
+ imImage* src_image = imlua_checkimage(L, 1);
+ imImage* dst_image = imlua_checkimage(L, 2);
+ int order = luaL_checkint(L, 3);
+
+ imlua_matchcolor(L, src_image, dst_image);
+ luaL_argcheck(L, (order == 0 || order == 1 || order == 3), 3, "invalid order, must be 0, 1 or 3");
+
+ lua_pushboolean(L, imProcessResize(src_image, dst_image, order));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.ProcessReduceBy4(src_image, dst_image)
+\*****************************************************************************/
+static int imluaProcessReduceBy4 (lua_State *L)
+{
+ imImage* src_image = imlua_checkimage(L, 1);
+ imImage* dst_image = imlua_checkimage(L, 2);
+
+ imlua_matchcolor(L, src_image, dst_image);
+ luaL_argcheck(L,
+ dst_image->width == (src_image->width / 2) &&
+ dst_image->height == (src_image->height / 2), 3, "destiny image size must be source image width/2, height/2");
+
+ imProcessReduceBy4(src_image, dst_image);
+ return 0;
+}
+
+/*****************************************************************************\
+ im.ProcessCrop(src_image, dst_image, xmin, ymin)
+\*****************************************************************************/
+static int imluaProcessCrop (lua_State *L)
+{
+ imImage* src_image = imlua_checkimage(L, 1);
+ imImage* dst_image = imlua_checkimage(L, 2);
+ int xmin = luaL_checkint(L, 3);
+ int ymin = luaL_checkint(L, 4);
+
+ imlua_matchcolor(L, src_image, dst_image);
+ luaL_argcheck(L, xmin > 0 && xmin < src_image->width, 3, "xmin must be > 0 and < width");
+ luaL_argcheck(L, ymin > 0 && ymin < src_image->height, 3, "ymin must be > 0 and < height");
+ luaL_argcheck(L, dst_image->width < (src_image->width - xmin), 2, "destiny image size must be smaller than source image width-xmin, height-ymin");
+ luaL_argcheck(L, dst_image->height < (src_image->height - ymin), 2, "destiny image size must be smaller than source image width-xmin, height-ymin");
+
+ imProcessCrop(src_image, dst_image, xmin, ymin);
+ return 0;
+}
+
+/*****************************************************************************\
+ im.ProcessInsert(src_image, region_image, dst_image, xmin, ymin)
+\*****************************************************************************/
+static int imluaProcessInsert (lua_State *L)
+{
+ imImage* src_image = imlua_checkimage(L, 1);
+ imImage* region_image = imlua_checkimage(L, 2);
+ imImage* dst_image = imlua_checkimage(L, 3);
+ int xmin = luaL_checkint(L, 4);
+ int ymin = luaL_checkint(L, 5);
+
+ imlua_matchcolor(L, src_image, dst_image);
+ luaL_argcheck(L, xmin > 0 && xmin < src_image->width, 3, "xmin must be > 0 and < width");
+ luaL_argcheck(L, ymin > 0 && ymin < src_image->height, 3, "ymin must be > 0 and < height");
+
+ imProcessInsert(src_image, region_image, dst_image, xmin, ymin);
+ return 0;
+}
+
+/*****************************************************************************\
+ im.ProcessAddMargins(src_image, dst_image, xmin, ymin)
+\*****************************************************************************/
+static int imluaProcessAddMargins (lua_State *L)
+{
+ imImage* src_image = imlua_checkimage(L, 1);
+ imImage* dst_image = imlua_checkimage(L, 2);
+ int xmin = luaL_checkint(L, 3);
+ int ymin = luaL_checkint(L, 4);
+
+ imlua_matchcolor(L, src_image, dst_image);
+ luaL_argcheck(L, dst_image->width > (src_image->width + xmin), 2, "destiny image size must be greatter than source image width+xmin, height+ymin");
+ luaL_argcheck(L, dst_image->height > (src_image->height + ymin), 2, "destiny image size must be greatter than source image width+xmin, height+ymin");
+
+ imProcessAddMargins(src_image, dst_image, xmin, ymin);
+ return 0;
+}
+
+
+
+/*****************************************************************************\
+ Geometric Operations
+\*****************************************************************************/
+
+/*****************************************************************************\
+ im.ProcessCalcRotateSize
+\*****************************************************************************/
+static int imluaProcessCalcRotateSize (lua_State *L)
+{
+ int new_width, new_height;
+
+ int width = luaL_checkint(L, 1);
+ int height = luaL_checkint(L, 2);
+ double cos0 = (double) luaL_checknumber(L, 3);
+ double sin0 = (double) luaL_checknumber(L, 4);
+
+ imProcessCalcRotateSize(width, height, &new_width, &new_height, cos0, sin0);
+ lua_pushnumber(L, new_width);
+ lua_pushnumber(L, new_height);
+ return 2;
+}
+
+/*****************************************************************************\
+ im.ProcessRotate
+\*****************************************************************************/
+static int imluaProcessRotate (lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *dst_image = imlua_checkimage(L, 2);
+ double cos0 = (double) luaL_checknumber(L, 3);
+ double sin0 = (double) luaL_checknumber(L, 4);
+ int order = luaL_checkint(L, 5);
+
+ imlua_matchcolor(L, src_image, dst_image);
+ luaL_argcheck(L, (order == 0 || order == 1 || order == 3), 5, "invalid order, must be 0, 1 or 3");
+
+ lua_pushboolean(L, imProcessRotate(src_image, dst_image, cos0, sin0, order));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.ProcessRotateRef
+\*****************************************************************************/
+static int imluaProcessRotateRef (lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *dst_image = imlua_checkimage(L, 2);
+ double cos0 = (double) luaL_checknumber(L, 3);
+ double sin0 = (double) luaL_checknumber(L, 4);
+ int x = luaL_checkint(L, 5);
+ int y = luaL_checkint(L, 6);
+ int to_origin = luaL_checkint(L, 7);
+ int order = luaL_checkint(L, 8);
+
+ imlua_matchcolor(L, src_image, dst_image);
+ luaL_argcheck(L, (order == 0 || order == 1 || order == 3), 5, "invalid order, must be 0, 1, or 3");
+
+ lua_pushboolean(L, imProcessRotateRef(src_image, dst_image, cos0, sin0, x, y, to_origin, order));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.ProcessRotate90
+\*****************************************************************************/
+static int imluaProcessRotate90 (lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *dst_image = imlua_checkimage(L, 2);
+ int dir = luaL_checkint(L, 3);
+
+ imlua_matchcolor(L, src_image, dst_image);
+ luaL_argcheck(L, dst_image->width == src_image->height && dst_image->height == src_image->width, 2, "destiny width and height must have the source height and width");
+ luaL_argcheck(L, (dir == -1 || dir == 1), 3, "invalid dir, can be -1 or 1 only");
+
+ imProcessRotate90(src_image, dst_image, dir);
+ return 0;
+}
+
+/*****************************************************************************\
+ im.ProcessRotate180
+\*****************************************************************************/
+static int imluaProcessRotate180 (lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *dst_image = imlua_checkimage(L, 2);
+
+ imlua_match(L, src_image, dst_image);
+
+ imProcessRotate180(src_image, dst_image);
+ return 0;
+}
+
+/*****************************************************************************\
+ im.ProcessMirror
+\*****************************************************************************/
+static int imluaProcessMirror (lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *dst_image = imlua_checkimage(L, 2);
+
+ imlua_match(L, src_image, dst_image);
+
+ imProcessMirror(src_image, dst_image);
+ return 0;
+}
+
+/*****************************************************************************\
+ im.ProcessFlip
+\*****************************************************************************/
+static int imluaProcessFlip (lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *dst_image = imlua_checkimage(L, 2);
+
+ imlua_match(L, src_image, dst_image);
+
+ imProcessFlip(src_image, dst_image);
+ return 0;
+}
+
+/*****************************************************************************\
+ im.ProcessInterlaceSplit
+\*****************************************************************************/
+static int imluaProcessInterlaceSplit (lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *dst_image1 = imlua_checkimage(L, 2);
+ imImage *dst_image2 = imlua_checkimage(L, 3);
+
+ imlua_matchcolor(L, src_image, dst_image1);
+ imlua_matchcolor(L, src_image, dst_image2);
+ luaL_argcheck(L, dst_image1->width == src_image->width && dst_image2->width == src_image->width, 2, "destiny width must be equal to source width");
+
+ if (src_image->height%2)
+ {
+ int dst_height1 = src_image->height/2 + 1;
+ luaL_argcheck(L, dst_image1->height == dst_height1, 2, "destiny1 height must be equal to source height/2+1 if height odd");
+ }
+ else
+ luaL_argcheck(L, dst_image1->height == src_image->height/2, 2, "destiny1 height must be equal to source height/2 if height even");
+
+ luaL_argcheck(L, dst_image2->height == src_image->height/2, 2, "destiny2 height must be equal to source height/2");
+
+ imProcessInterlaceSplit(src_image, dst_image1, dst_image2);
+ return 0;
+}
+
+/*****************************************************************************\
+ im.ProcessRadial
+\*****************************************************************************/
+static int imluaProcessRadial (lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *dst_image = imlua_checkimage(L, 2);
+ float k1 = (float) luaL_checknumber(L, 3);
+ int order = luaL_checkint(L, 4);
+
+ imlua_match(L, src_image, dst_image);
+ luaL_argcheck(L, (order == 0 || order == 1 || order == 3), 4, "invalid order");
+
+ lua_pushboolean(L, imProcessRadial(src_image, dst_image, k1, order));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.ProcessSwirl
+\*****************************************************************************/
+static int imluaProcessSwirl(lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *dst_image = imlua_checkimage(L, 2);
+ float k1 = (float) luaL_checknumber(L, 3);
+ int order = luaL_checkint(L, 4);
+
+ imlua_match(L, src_image, dst_image);
+ luaL_argcheck(L, (order == 0 || order == 1 || order == 3), 4, "invalid order, can be 0, 1 or 3");
+
+ lua_pushboolean(L, imProcessSwirl(src_image, dst_image, k1, order));
+ return 1;
+}
+
+static void imlua_checknotcfloat(lua_State *L, imImage *image, int index)
+{
+ if (image->data_type == IM_CFLOAT)
+ luaL_argerror(L, index, "image data type can NOT be cfloat");
+}
+
+
+/*****************************************************************************\
+ Morphology Operations for Gray Images
+\*****************************************************************************/
+
+/*****************************************************************************\
+ im.ProcessGrayMorphConvolve
+\*****************************************************************************/
+static int imluaProcessGrayMorphConvolve (lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *dst_image = imlua_checkimage(L, 2);
+ imImage *kernel = imlua_checkimage(L, 3);
+ int ismax = lua_toboolean(L, 4);
+
+ imlua_checknotcfloat(L, src_image, 1);
+ imlua_match(L, src_image, dst_image);
+ imlua_checkdatatype(L, 3, kernel, IM_INT);
+ imlua_matchsize(L, src_image, kernel);
+
+ lua_pushboolean(L, imProcessGrayMorphConvolve(src_image, dst_image, kernel, ismax));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.ProcessGrayMorphErode
+\*****************************************************************************/
+static int imluaProcessGrayMorphErode (lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *dst_image = imlua_checkimage(L, 2);
+ int kernel_size = luaL_checkint(L, 3);
+
+ imlua_checknotcfloat(L, src_image, 1);
+ imlua_match(L, src_image, dst_image);
+
+ lua_pushboolean(L, imProcessGrayMorphErode(src_image, dst_image, kernel_size));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.ProcessGrayMorphDilate
+\*****************************************************************************/
+static int imluaProcessGrayMorphDilate (lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *dst_image = imlua_checkimage(L, 2);
+ int kernel_size = luaL_checkint(L, 3);
+
+ imlua_checknotcfloat(L, src_image, 1);
+ imlua_match(L, src_image, dst_image);
+
+ lua_pushboolean(L, imProcessGrayMorphDilate(src_image, dst_image, kernel_size));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.ProcessGrayMorphOpen
+\*****************************************************************************/
+static int imluaProcessGrayMorphOpen (lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *dst_image = imlua_checkimage(L, 2);
+ int kernel_size = luaL_checkint(L, 3);
+
+ imlua_checknotcfloat(L, src_image, 1);
+ imlua_match(L, src_image, dst_image);
+
+ lua_pushboolean(L, imProcessGrayMorphOpen(src_image, dst_image, kernel_size));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.ProcessGrayMorphClose
+\*****************************************************************************/
+static int imluaProcessGrayMorphClose (lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *dst_image = imlua_checkimage(L, 2);
+ int kernel_size = luaL_checkint(L, 3);
+
+ imlua_checknotcfloat(L, src_image, 1);
+ imlua_match(L, src_image, dst_image);
+
+ lua_pushboolean(L, imProcessGrayMorphClose(src_image, dst_image, kernel_size));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.ProcessGrayMorphTopHat
+\*****************************************************************************/
+static int imluaProcessGrayMorphTopHat (lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *dst_image = imlua_checkimage(L, 2);
+ int kernel_size = luaL_checkint(L, 3);
+
+ imlua_checknotcfloat(L, src_image, 1);
+ imlua_match(L, src_image, dst_image);
+
+ lua_pushboolean(L, imProcessGrayMorphTopHat(src_image, dst_image, kernel_size));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.ProcessGrayMorphWell
+\*****************************************************************************/
+static int imluaProcessGrayMorphWell (lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *dst_image = imlua_checkimage(L, 2);
+ int kernel_size = luaL_checkint(L, 3);
+
+ imlua_checknotcfloat(L, src_image, 1);
+ imlua_match(L, src_image, dst_image);
+
+ lua_pushboolean(L, imProcessGrayMorphWell(src_image, dst_image, kernel_size));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.ProcessGrayMorphGradient
+\*****************************************************************************/
+static int imluaProcessGrayMorphGradient (lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *dst_image = imlua_checkimage(L, 2);
+ int kernel_size = luaL_checkint(L, 3);
+
+ imlua_checknotcfloat(L, src_image, 1);
+ imlua_match(L, src_image, dst_image);
+
+ lua_pushboolean(L, imProcessGrayMorphGradient(src_image, dst_image, kernel_size));
+ return 1;
+}
+
+
+
+/*****************************************************************************\
+ Morphology Operations for Binary Images
+\*****************************************************************************/
+
+/*****************************************************************************\
+ im.ProcessBinMorphConvolve
+\*****************************************************************************/
+static int imluaProcessBinMorphConvolve (lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *dst_image = imlua_checkimage(L, 2);
+ imImage *kernel = imlua_checkimage(L, 3);
+ int hit_white = luaL_checkint(L, 4);
+ int iter = luaL_checkint(L, 5);
+
+ imlua_checkcolorspace(L, 1, src_image, IM_BINARY);
+ imlua_match(L, src_image, dst_image);
+ imlua_checkdatatype(L, 3, kernel, IM_INT);
+ imlua_matchsize(L, src_image, kernel);
+
+ lua_pushboolean(L, imProcessBinMorphConvolve(src_image, dst_image, kernel, hit_white, iter));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.ProcessBinMorphErode
+\*****************************************************************************/
+static int imluaProcessBinMorphErode (lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *dst_image = imlua_checkimage(L, 2);
+ int kernel_size = luaL_checkint(L, 3);
+ int iter = luaL_checkint(L, 4);
+
+ imlua_checkcolorspace(L, 1, src_image, IM_BINARY);
+ imlua_match(L, src_image, dst_image);
+
+ lua_pushboolean(L, imProcessBinMorphErode(src_image, dst_image, kernel_size, iter));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.ProcessBinMorphDilate
+\*****************************************************************************/
+static int imluaProcessBinMorphDilate (lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *dst_image = imlua_checkimage(L, 2);
+ int kernel_size = luaL_checkint(L, 3);
+ int iter = luaL_checkint(L, 4);
+
+ imlua_checkcolorspace(L, 1, src_image, IM_BINARY);
+ imlua_match(L, src_image, dst_image);
+
+ lua_pushboolean(L, imProcessBinMorphDilate(src_image, dst_image, kernel_size, iter));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.ProcessBinMorphOpen
+\*****************************************************************************/
+static int imluaProcessBinMorphOpen (lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *dst_image = imlua_checkimage(L, 2);
+ int kernel_size = luaL_checkint(L, 3);
+ int iter = luaL_checkint(L, 4);
+
+ imlua_checkcolorspace(L, 1, src_image, IM_BINARY);
+ imlua_match(L, src_image, dst_image);
+
+ lua_pushboolean(L, imProcessBinMorphOpen(src_image, dst_image, kernel_size, iter));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.ProcessBinMorphClose
+\*****************************************************************************/
+static int imluaProcessBinMorphClose (lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *dst_image = imlua_checkimage(L, 2);
+ int kernel_size = luaL_checkint(L, 3);
+ int iter = luaL_checkint(L, 4);
+
+ imlua_checkcolorspace(L, 1, src_image, IM_BINARY);
+ imlua_match(L, src_image, dst_image);
+
+ lua_pushboolean(L, imProcessBinMorphClose(src_image, dst_image, kernel_size, iter));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.ProcessBinMorphOutline
+\*****************************************************************************/
+static int imluaProcessBinMorphOutline (lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *dst_image = imlua_checkimage(L, 2);
+ int kernel_size = luaL_checkint(L, 3);
+ int iter = luaL_checkint(L, 4);
+
+ imlua_checkcolorspace(L, 1, src_image, IM_BINARY);
+ imlua_match(L, src_image, dst_image);
+
+ lua_pushboolean(L, imProcessBinMorphOutline(src_image, dst_image, kernel_size, iter));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.ProcessBinMorphThin
+\*****************************************************************************/
+static int imluaProcessBinMorphThin (lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *dst_image = imlua_checkimage(L, 2);
+
+ imlua_checkcolorspace(L, 1, src_image, IM_BINARY);
+ imlua_match(L, src_image, dst_image);
+
+ imProcessBinMorphThin(src_image, dst_image);
+ return 0;
+}
+
+
+
+/*****************************************************************************\
+ Rank Convolution Operations
+\*****************************************************************************/
+
+/*****************************************************************************\
+ im.ProcessMedianConvolve
+\*****************************************************************************/
+static int imluaProcessMedianConvolve (lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *dst_image = imlua_checkimage(L, 2);
+ int kernel_size = luaL_checkint(L, 3);
+
+ imlua_checknotcfloat(L, src_image, 1);
+ imlua_match(L, src_image, dst_image);
+
+ lua_pushboolean(L, imProcessMedianConvolve(src_image, dst_image, kernel_size));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.ProcessRangeConvolve
+\*****************************************************************************/
+static int imluaProcessRangeConvolve (lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *dst_image = imlua_checkimage(L, 2);
+ int kernel_size = luaL_checkint(L, 3);
+
+ imlua_checknotcfloat(L, src_image, 1);
+ imlua_match(L, src_image, dst_image);
+
+ lua_pushboolean(L, imProcessRangeConvolve(src_image, dst_image, kernel_size));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.ProcessRankClosestConvolve
+\*****************************************************************************/
+static int imluaProcessRankClosestConvolve (lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *dst_image = imlua_checkimage(L, 2);
+ int kernel_size = luaL_checkint(L, 3);
+
+ imlua_checknotcfloat(L, src_image, 1);
+ imlua_match(L, src_image, dst_image);
+
+ lua_pushboolean(L, imProcessRankClosestConvolve(src_image, dst_image, kernel_size));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.ProcessRankMaxConvolve
+\*****************************************************************************/
+static int imluaProcessRankMaxConvolve (lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *dst_image = imlua_checkimage(L, 2);
+ int kernel_size = luaL_checkint(L, 3);
+
+ imlua_checknotcfloat(L, src_image, 1);
+ imlua_match(L, src_image, dst_image);
+
+ lua_pushboolean(L, imProcessRankMaxConvolve(src_image, dst_image, kernel_size));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.ProcessRankMinConvolve
+\*****************************************************************************/
+static int imluaProcessRankMinConvolve (lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *dst_image = imlua_checkimage(L, 2);
+ int kernel_size = luaL_checkint(L, 3);
+
+ imlua_checknotcfloat(L, src_image, 1);
+ imlua_match(L, src_image, dst_image);
+
+ lua_pushboolean(L, imProcessRankMinConvolve(src_image, dst_image, kernel_size));
+ return 1;
+}
+
+
+/*****************************************************************************\
+ Convolution Operations
+\*****************************************************************************/
+
+static void imlua_checkkernel(lua_State *L, imImage* kernel, int index)
+{
+ imlua_checkcolorspace(L, index, kernel, IM_GRAY);
+ luaL_argcheck(L, kernel->data_type == IM_INT || kernel->data_type == IM_FLOAT, index, "kernel data type can be int or float only");
+}
+
+/*****************************************************************************\
+ im.ProcessConvolve
+\*****************************************************************************/
+static int imluaProcessConvolve (lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *dst_image = imlua_checkimage(L, 2);
+ imImage *kernel = imlua_checkimage(L, 3);
+
+ imlua_match(L, src_image, dst_image);
+ imlua_checkkernel(L, kernel, 3);
+
+ lua_pushboolean(L, imProcessConvolve(src_image, dst_image, kernel));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.ProcessConvolveDual
+\*****************************************************************************/
+static int imluaProcessConvolveDual (lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *dst_image = imlua_checkimage(L, 2);
+ imImage *kernel1 = imlua_checkimage(L, 3);
+ imImage *kernel2 = imlua_checkimage(L, 4);
+
+ imlua_match(L, src_image, dst_image);
+ imlua_checkkernel(L, kernel1, 3);
+ imlua_checkkernel(L, kernel2, 4);
+
+ lua_pushboolean(L, imProcessConvolveDual(src_image, dst_image, kernel1, kernel2));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.ProcessConvolveRep
+\*****************************************************************************/
+static int imluaProcessConvolveRep (lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *dst_image = imlua_checkimage(L, 2);
+ imImage *kernel = imlua_checkimage(L, 3);
+ int count = luaL_checkint(L, 4);
+
+ imlua_match(L, src_image, dst_image);
+ imlua_checkkernel(L, kernel, 3);
+
+ lua_pushboolean(L, imProcessConvolveRep(src_image, dst_image, kernel, count));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.ProcessConvolveSep
+\*****************************************************************************/
+static int imluaProcessConvolveSep (lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *dst_image = imlua_checkimage(L, 2);
+ imImage *kernel = imlua_checkimage(L, 3);
+
+ imlua_match(L, src_image, dst_image);
+ imlua_checkkernel(L, kernel, 3);
+
+ lua_pushboolean(L, imProcessConvolveSep(src_image, dst_image, kernel));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.ProcessCompassConvolve
+\*****************************************************************************/
+static int imluaProcessCompassConvolve (lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *dst_image = imlua_checkimage(L, 2);
+ imImage *kernel = imlua_checkimage(L, 3);
+
+ imlua_checknotcfloat(L, src_image, 1);
+ imlua_match(L, src_image, dst_image);
+ imlua_checkkernel(L, kernel, 3);
+
+ lua_pushboolean(L, imProcessCompassConvolve(src_image, dst_image, kernel));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.ProcessRotateKernel
+\*****************************************************************************/
+static int imluaProcessRotateKernel (lua_State *L)
+{
+ imProcessRotateKernel(imlua_checkimage(L, 1));
+ return 0;
+}
+
+/*****************************************************************************\
+ im.ProcessDiffOfGaussianConvolve
+\*****************************************************************************/
+static int imluaProcessDiffOfGaussianConvolve (lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *dst_image = imlua_checkimage(L, 2);
+ float stddev1 = (float) luaL_checknumber(L, 3);
+ float stddev2 = (float) luaL_checknumber(L, 4);
+
+ if (src_image->data_type == IM_BYTE || src_image->data_type == IM_USHORT)
+ {
+ imlua_matchcolor(L, src_image, dst_image);
+ imlua_checkdatatype(L, 2, dst_image, IM_INT);
+ }
+ else
+ imlua_match(L, src_image, dst_image);
+
+ lua_pushboolean(L, imProcessDiffOfGaussianConvolve(src_image, dst_image, stddev1, stddev2));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.ProcessLapOfGaussianConvolve
+\*****************************************************************************/
+static int imluaProcessLapOfGaussianConvolve (lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *dst_image = imlua_checkimage(L, 2);
+ float stddev = (float) luaL_checknumber(L, 3);
+
+ if (src_image->data_type == IM_BYTE || src_image->data_type == IM_USHORT)
+ {
+ imlua_matchcolor(L, src_image, dst_image);
+ imlua_checkdatatype(L, 2, dst_image, IM_INT);
+ }
+ else
+ imlua_match(L, src_image, dst_image);
+
+ lua_pushboolean(L, imProcessLapOfGaussianConvolve(src_image, dst_image, stddev));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.ProcessMeanConvolve
+\*****************************************************************************/
+static int imluaProcessMeanConvolve (lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *dst_image = imlua_checkimage(L, 2);
+ int kernel_size = luaL_checkint(L, 3);
+
+ imlua_match(L, src_image, dst_image);
+
+ lua_pushboolean(L, imProcessMeanConvolve(src_image, dst_image, kernel_size));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.ProcessBarlettConvolve
+\*****************************************************************************/
+static int imluaProcessBarlettConvolve (lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *dst_image = imlua_checkimage(L, 2);
+ int kernel_size = luaL_checkint(L, 3);
+
+ imlua_match(L, src_image, dst_image);
+
+ lua_pushboolean(L, imProcessBarlettConvolve(src_image, dst_image, kernel_size));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.ProcessGaussianConvolve
+\*****************************************************************************/
+static int imluaProcessGaussianConvolve (lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *dst_image = imlua_checkimage(L, 2);
+ float stddev = (float) luaL_checknumber(L, 3);
+
+ imlua_match(L, src_image, dst_image);
+
+ lua_pushboolean(L, imProcessGaussianConvolve(src_image, dst_image, stddev));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.ProcessPrewittConvolve
+\*****************************************************************************/
+static int imluaProcessPrewittConvolve (lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *dst_image = imlua_checkimage(L, 2);
+
+ imlua_match(L, src_image, dst_image);
+
+ lua_pushboolean(L, imProcessPrewittConvolve(src_image, dst_image));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.ProcessSplineEdgeConvolve
+\*****************************************************************************/
+static int imluaProcessSplineEdgeConvolve (lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *dst_image = imlua_checkimage(L, 2);
+
+ imlua_match(L, src_image, dst_image);
+
+ lua_pushboolean(L, imProcessSplineEdgeConvolve(src_image, dst_image));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.ProcessSobelConvolve
+\*****************************************************************************/
+static int imluaProcessSobelConvolve (lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *dst_image = imlua_checkimage(L, 2);
+
+ imlua_match(L, src_image, dst_image);
+
+ lua_pushboolean(L, imProcessSobelConvolve(src_image, dst_image));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.ProcessZeroCrossing
+\*****************************************************************************/
+static int imluaProcessZeroCrossing (lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *dst_image = imlua_checkimage(L, 2);
+
+ luaL_argcheck(L, src_image->data_type == IM_INT || src_image->data_type == IM_FLOAT, 1, "image data type can be int or float only");
+ imlua_match(L, src_image, dst_image);
+
+ imProcessZeroCrossing(src_image, dst_image);
+ return 0;
+}
+
+/*****************************************************************************\
+ im.ProcessCanny
+\*****************************************************************************/
+static int imluaProcessCanny (lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *dst_image = imlua_checkimage(L, 2);
+ float stddev = (float) luaL_checknumber(L, 3);
+
+ imlua_checktype(L, 1, src_image, IM_GRAY, IM_BYTE);
+ imlua_match(L, src_image, dst_image);
+
+ imProcessCanny(src_image, dst_image, stddev);
+ return 0;
+}
+
+/*****************************************************************************\
+ im.GaussianStdDev2Repetitions
+\*****************************************************************************/
+static int imluaGaussianKernelSize2StdDev(lua_State *L)
+{
+ lua_pushnumber(L, imGaussianKernelSize2StdDev((int)luaL_checknumber(L, 1)));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.GaussianStdDev2KernelSize
+\*****************************************************************************/
+static int imluaGaussianStdDev2KernelSize (lua_State *L)
+{
+ lua_pushnumber(L, imGaussianStdDev2KernelSize((float)luaL_checknumber(L, 1)));
+ return 1;
+}
+
+
+
+/*****************************************************************************\
+ Arithmetic Operations
+\*****************************************************************************/
+
+/*****************************************************************************\
+ im.ProcessUnArithmeticOp
+\*****************************************************************************/
+static int imluaProcessUnArithmeticOp (lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *dst_image = imlua_checkimage(L, 2);
+ int op = luaL_checkint(L, 3);
+
+ imlua_matchcolorspace(L, src_image, dst_image);
+
+ imProcessUnArithmeticOp(src_image, dst_image, op);
+ return 0;
+}
+
+/*****************************************************************************\
+ im.ProcessArithmeticOp
+\*****************************************************************************/
+static int imluaProcessArithmeticOp (lua_State *L)
+{
+ imImage *src_image1 = imlua_checkimage(L, 1);
+ imImage *src_image2 = imlua_checkimage(L, 2);
+ imImage *dst_image = imlua_checkimage(L, 3);
+ int op = luaL_checkint(L, 4);
+
+ imlua_match(L, src_image1, src_image2);
+ imlua_matchsize(L, src_image1, dst_image);
+ imlua_matchsize(L, src_image2, dst_image);
+
+ switch (src_image1->data_type)
+ {
+ case IM_BYTE:
+ luaL_argcheck(L,
+ dst_image->data_type == IM_BYTE ||
+ dst_image->data_type == IM_USHORT ||
+ dst_image->data_type == IM_INT ||
+ dst_image->data_type == IM_FLOAT,
+ 2, "source image is byte, destiny image data type can be byte, ushort, int and float only.");
+ break;
+ case IM_USHORT:
+ luaL_argcheck(L,
+ dst_image->data_type == IM_USHORT ||
+ dst_image->data_type == IM_INT ||
+ dst_image->data_type == IM_FLOAT,
+ 2, "source image is ushort, destiny image data type can be ushort, int and float only.");
+ break;
+ case IM_INT:
+ luaL_argcheck(L,
+ dst_image->data_type == IM_INT ||
+ dst_image->data_type == IM_FLOAT,
+ 2, "source image is int, destiny image data type can be int and float only.");
+ break;
+ case IM_FLOAT:
+ luaL_argcheck(L,
+ dst_image->data_type == IM_FLOAT,
+ 2, "source image is float, destiny image data type can be float only.");
+ break;
+ case IM_CFLOAT:
+ luaL_argcheck(L,
+ dst_image->data_type == IM_CFLOAT,
+ 2, "source image is cfloat, destiny image data type can be cfloat only.");
+ break;
+ }
+
+ imProcessArithmeticOp(src_image1, src_image2, dst_image, op);
+ return 0;
+}
+
+/*****************************************************************************\
+ im.ProcessArithmeticConstOp
+\*****************************************************************************/
+static int imluaProcessArithmeticConstOp (lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ float src_const = (float) luaL_checknumber(L, 2);
+ imImage *dst_image = imlua_checkimage(L, 3);
+ int op = luaL_checkint(L, 4);
+
+ imlua_matchsize(L, src_image, dst_image);
+
+ switch (src_image->data_type)
+ {
+ case IM_BYTE:
+ luaL_argcheck(L,
+ dst_image->data_type == IM_BYTE ||
+ dst_image->data_type == IM_USHORT ||
+ dst_image->data_type == IM_INT ||
+ dst_image->data_type == IM_FLOAT,
+ 2, "source image is byte, destiny image data type can be byte, ushort, int and float only.");
+ break;
+ case IM_USHORT:
+ luaL_argcheck(L,
+ dst_image->data_type == IM_USHORT ||
+ dst_image->data_type == IM_INT ||
+ dst_image->data_type == IM_FLOAT,
+ 2, "source image is ushort, destiny image data type can be ushort, int and float only.");
+ break;
+ case IM_INT:
+ luaL_argcheck(L,
+ dst_image->data_type == IM_INT ||
+ dst_image->data_type == IM_FLOAT,
+ 2, "source image is int, destiny image data type can be int and float only.");
+ break;
+ case IM_FLOAT:
+ luaL_argcheck(L,
+ dst_image->data_type == IM_FLOAT,
+ 2, "source image is float, destiny image data type can be float only.");
+ break;
+ case IM_CFLOAT:
+ luaL_argcheck(L,
+ dst_image->data_type == IM_CFLOAT,
+ 2, "source image is cfloat, destiny image data type can be cfloat only.");
+ break;
+ }
+
+ imProcessArithmeticConstOp(src_image, src_const, dst_image, op);
+ return 0;
+}
+
+/*****************************************************************************\
+ im.ProcessBlendConst
+\*****************************************************************************/
+static int imluaProcessBlendConst (lua_State *L)
+{
+ imImage *src_image1 = imlua_checkimage(L, 1);
+ imImage *src_image2 = imlua_checkimage(L, 2);
+ imImage *dst_image = imlua_checkimage(L, 3);
+ float alpha = (float) luaL_checknumber(L, 4);
+
+ imlua_match(L, src_image1, src_image2);
+ imlua_match(L, src_image1, dst_image);
+
+ imProcessBlendConst(src_image1, src_image2, dst_image, alpha);
+ return 0;
+}
+
+/*****************************************************************************\
+ im.ProcessBlend
+\*****************************************************************************/
+static int imluaProcessBlend (lua_State *L)
+{
+ imImage *src_image1 = imlua_checkimage(L, 1);
+ imImage *src_image2 = imlua_checkimage(L, 2);
+ imImage *alpha_image = imlua_checkimage(L, 3);
+ imImage *dst_image = imlua_checkimage(L, 4);
+
+ imlua_match(L, src_image1, src_image2);
+ imlua_match(L, src_image1, dst_image);
+ imlua_matchdatatype(L, src_image1, alpha_image);
+
+ imProcessBlend(src_image1, src_image2, alpha_image, dst_image);
+ return 0;
+}
+
+/*****************************************************************************\
+ im.ProcessSplitComplex
+\*****************************************************************************/
+static int imluaProcessSplitComplex (lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *dst_image1 = imlua_checkimage(L, 2);
+ imImage *dst_image2 = imlua_checkimage(L, 3);
+ int polar = luaL_checkint(L, 4);
+
+ imlua_checkdatatype(L, 1, src_image, IM_CFLOAT);
+ imlua_checkdatatype(L, 2, dst_image1, IM_FLOAT);
+ imlua_checkdatatype(L, 3, dst_image2, IM_FLOAT);
+ imlua_matchcolorspace(L, src_image, dst_image1);
+ imlua_matchcolorspace(L, src_image, dst_image2);
+
+ imProcessSplitComplex(src_image, dst_image1, dst_image2, polar);
+ return 0;
+}
+
+/*****************************************************************************\
+ im.ProcessMergeComplex
+\*****************************************************************************/
+static int imluaProcessMergeComplex (lua_State *L)
+{
+ imImage *src_image1 = imlua_checkimage(L, 1);
+ imImage *src_image2 = imlua_checkimage(L, 2);
+ imImage *dst_image = imlua_checkimage(L, 3);
+ int polar = luaL_checkint(L, 5);
+
+ imlua_checkdatatype(L, 1, src_image1, IM_FLOAT);
+ imlua_checkdatatype(L, 2, src_image2, IM_FLOAT);
+ imlua_checkdatatype(L, 3, dst_image, IM_CFLOAT);
+ imlua_matchcolorspace(L, src_image1, src_image2);
+ imlua_matchcolorspace(L, src_image1, dst_image);
+
+ imProcessMergeComplex(src_image1, src_image2, dst_image, polar);
+ return 0;
+}
+
+/*****************************************************************************\
+ im.ProcessMultipleMean
+\*****************************************************************************/
+static int imluaProcessMultipleMean (lua_State *L)
+{
+ int i, src_image_count;
+ imImage *dst_image;
+ imImage **src_image_list;
+
+ luaL_checktype(L, 1, LUA_TTABLE);
+ src_image_count = imlua_getn(L, 1);
+
+ src_image_list = (imImage**)malloc(sizeof(imImage*)*src_image_count);
+
+ for (i = 0; i < src_image_count; i++)
+ {
+ lua_rawgeti(L, 1, i+1);
+ src_image_list[i] = imlua_checkimage(L, -1);
+ }
+
+ dst_image = imlua_checkimage(L, 2);
+
+ for (i = 0; i < src_image_count; i++)
+ {
+ int check = imImageMatchDataType(src_image_list[i], dst_image);
+ if (!check) free(src_image_list);
+ imlua_matchcheck(L, check, "images must have the same size and data type");
+ }
+
+ imProcessMultipleMean((const imImage**)src_image_list, src_image_count, dst_image);
+ free(src_image_list);
+ return 0;
+}
+
+/*****************************************************************************\
+ im.ProcessMultipleStdDev
+\*****************************************************************************/
+static int imluaProcessMultipleStdDev (lua_State *L)
+{
+ int i, src_image_count, check;
+ imImage *dst_image, *mean_image;
+ imImage **src_image_list;
+
+ if (!lua_istable(L, 1))
+ luaL_argerror(L, 1, "must be a table");
+
+ lua_pushstring(L, "table");
+ lua_gettable(L, LUA_GLOBALSINDEX);
+ lua_pushstring(L, "getn");
+ lua_gettable(L, -2);
+ src_image_count = luaL_checkint(L, -1);
+ lua_pop(L, 1);
+
+ src_image_list = (imImage**) malloc(src_image_count * sizeof(imImage*));
+
+ for (i = 0; i < src_image_count; i++)
+ {
+ lua_rawgeti(L, 1, i+1);
+ src_image_list[i] = imlua_checkimage(L, -1);
+ }
+
+ mean_image = imlua_checkimage(L, 2);
+ dst_image = imlua_checkimage(L, 3);
+
+ for (i = 0; i < src_image_count; i++)
+ {
+ check = imImageMatchDataType(src_image_list[i], dst_image);
+ if (!check) free(src_image_list);
+ imlua_matchcheck(L, check, "images must have the same size and data type");
+ }
+ check = imImageMatchDataType(mean_image, dst_image);
+ if (!check) free(src_image_list);
+ imlua_matchcheck(L, check, "images must have the same size and data type");
+
+ imProcessMultipleStdDev((const imImage**)src_image_list, src_image_count, mean_image, dst_image);
+ free(src_image_list);
+ return 0;
+}
+
+/*****************************************************************************\
+ im.ProcessAutoCovariance
+\*****************************************************************************/
+static int imluaProcessAutoCovariance (lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *mean_image = imlua_checkimage(L, 2);
+ imImage *dst_image = imlua_checkimage(L, 3);
+
+ imlua_match(L, src_image, mean_image);
+ imlua_matchcolorspace(L, src_image, dst_image);
+ imlua_checkdatatype(L, 3, dst_image, IM_FLOAT);
+
+ lua_pushnumber(L, imProcessAutoCovariance(src_image, mean_image, dst_image));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.ProcessMultiplyConj
+\*****************************************************************************/
+static int imluaProcessMultiplyConj (lua_State *L)
+{
+ imImage *src_image1 = imlua_checkimage(L, 1);
+ imImage *src_image2 = imlua_checkimage(L, 2);
+ imImage *dst_image = imlua_checkimage(L, 3);
+
+ imlua_match(L, src_image1, src_image2);
+ imlua_match(L, src_image1, dst_image);
+
+ imProcessMultiplyConj(src_image1, src_image2, dst_image);
+ return 0;
+}
+
+
+/*****************************************************************************\
+ Additional Image Quantization Operations
+\*****************************************************************************/
+
+/*****************************************************************************\
+ im.ProcessQuantizeRGBUniform
+\*****************************************************************************/
+static int imluaProcessQuantizeRGBUniform (lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *dst_image = imlua_checkimage(L, 2);
+ int dither = luaL_checkint(L, 3);
+
+ imlua_checktype(L, 1, src_image, IM_RGB, IM_BYTE);
+ imlua_checkcolorspace(L, 2, dst_image, IM_MAP);
+ imlua_matchsize(L, src_image, dst_image);
+
+ imProcessQuantizeRGBUniform(src_image, dst_image, dither);
+ return 0;
+}
+
+/*****************************************************************************\
+ im.ProcessQuantizeGrayUniform
+\*****************************************************************************/
+static int imluaProcessQuantizeGrayUniform (lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *dst_image = imlua_checkimage(L, 2);
+ int grays = luaL_checkint(L, 3);
+
+ imlua_checktype(L, 1, src_image, IM_GRAY, IM_BYTE);
+ imlua_checktype(L, 2, dst_image, IM_GRAY, IM_BYTE);
+ imlua_match(L, src_image, dst_image);
+
+ imProcessQuantizeGrayUniform(src_image, dst_image, grays);
+ return 0;
+}
+
+
+/*****************************************************************************\
+ Histogram Based Operations
+\*****************************************************************************/
+
+/*****************************************************************************\
+ im.ProcessExpandHistogram
+\*****************************************************************************/
+static int imluaProcessExpandHistogram (lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *dst_image = imlua_checkimage(L, 2);
+ float percent = (float) luaL_checknumber(L, 3);
+
+ imlua_checkdatatype(L, 1, src_image, IM_BYTE);
+ imlua_match(L, src_image, dst_image);
+ luaL_argcheck(L, src_image->color_space == IM_RGB || src_image->color_space == IM_GRAY, 1, "color space can be RGB or Gray only");
+ luaL_argcheck(L, dst_image->color_space == IM_RGB || dst_image->color_space == IM_GRAY, 2, "color space can be RGB or Gray only");
+
+ imProcessExpandHistogram(src_image, dst_image, percent);
+ return 0;
+}
+
+/*****************************************************************************\
+ im.ProcessEqualizeHistogram
+\*****************************************************************************/
+static int imluaProcessEqualizeHistogram (lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *dst_image = imlua_checkimage(L, 2);
+
+ imlua_checkdatatype(L, 1, src_image, IM_BYTE);
+ imlua_match(L, src_image, dst_image);
+ luaL_argcheck(L, src_image->color_space == IM_RGB || src_image->color_space == IM_GRAY, 1, "color space can be RGB or Gray only");
+ luaL_argcheck(L, dst_image->color_space == IM_RGB || dst_image->color_space == IM_GRAY, 2, "color space can be RGB or Gray only");
+
+ imProcessEqualizeHistogram(src_image, dst_image);
+ return 0;
+}
+
+
+
+/*****************************************************************************\
+ Color Processing Operations
+\*****************************************************************************/
+
+/*****************************************************************************\
+ im.ProcessSplitYChroma
+\*****************************************************************************/
+static int imluaProcessSplitYChroma (lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *y_image = imlua_checkimage(L, 2);
+ imImage *chroma_image = imlua_checkimage(L, 3);
+
+ imlua_checktype(L, 1, src_image, IM_RGB, IM_BYTE);
+ imlua_checktype(L, 2, y_image, IM_GRAY, IM_BYTE);
+ imlua_checktype(L, 3, chroma_image, IM_RGB, IM_BYTE);
+ imlua_matchsize(L, src_image, y_image);
+ imlua_matchsize(L, src_image, chroma_image);
+
+ imProcessSplitYChroma(src_image, y_image, chroma_image);
+ return 0;
+}
+
+/*****************************************************************************\
+ im.ProcessSplitHSI
+\*****************************************************************************/
+static int imluaProcessSplitHSI (lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *h_image = imlua_checkimage(L, 2);
+ imImage *s_image = imlua_checkimage(L, 3);
+ imImage *i_image = imlua_checkimage(L, 4);
+
+ imlua_checkcolorspace(L, 1, src_image, IM_RGB);
+ luaL_argcheck(L, src_image->data_type == IM_BYTE || src_image->data_type == IM_FLOAT, 1, "data type can be float or byte only");
+ imlua_checktype(L, 2, h_image, IM_GRAY, IM_FLOAT);
+ imlua_checktype(L, 3, s_image, IM_GRAY, IM_FLOAT);
+ imlua_checktype(L, 4, i_image, IM_GRAY, IM_FLOAT);
+ imlua_matchsize(L, src_image, h_image);
+ imlua_matchsize(L, src_image, s_image);
+ imlua_matchsize(L, src_image, i_image);
+
+ imProcessSplitHSI(src_image, h_image, s_image, i_image);
+ return 0;
+}
+
+/*****************************************************************************\
+ im.ProcessMergeHSI
+\*****************************************************************************/
+static int imluaProcessMergeHSI (lua_State *L)
+{
+ imImage *h_image = imlua_checkimage(L, 1);
+ imImage *s_image = imlua_checkimage(L, 2);
+ imImage *i_image = imlua_checkimage(L, 3);
+ imImage *dst_image = imlua_checkimage(L, 4);
+
+ imlua_checktype(L, 1, h_image, IM_GRAY, IM_FLOAT);
+ imlua_checktype(L, 2, s_image, IM_GRAY, IM_FLOAT);
+ imlua_checktype(L, 3, i_image, IM_GRAY, IM_FLOAT);
+ imlua_checkcolorspace(L, 4, dst_image, IM_RGB);
+ luaL_argcheck(L, dst_image->data_type == IM_BYTE || dst_image->data_type == IM_FLOAT, 4, "data type can be float or byte only");
+ imlua_matchsize(L, dst_image, h_image);
+ imlua_matchsize(L, dst_image, s_image);
+ imlua_matchsize(L, dst_image, i_image);
+
+ imProcessMergeHSI(h_image, s_image, i_image, dst_image);
+ return 0;
+}
+
+/*****************************************************************************\
+ im.ProcessSplitComponents(src_image, { r, g, b} )
+\*****************************************************************************/
+static int imluaProcessSplitComponents (lua_State *L)
+{
+ int i;
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage **dst_image_list;
+
+ luaL_checktype(L, 2, LUA_TTABLE);
+
+ if (imlua_getn(L, 2) != src_image->depth)
+ luaL_error(L, "number of destiny images must match the depth of the source image");
+
+ dst_image_list = (imImage**)malloc(sizeof(imImage*)*src_image->depth);
+
+ for (i = 0; i < src_image->depth; i++)
+ {
+ lua_pushnumber(L, i+1);
+ lua_gettable(L, 2);
+ dst_image_list[i] = imlua_checkimage(L, -1);
+ imlua_checkcolorspace(L, 2, dst_image_list[i], IM_GRAY); /* if error here, there will be a memory leak */
+ lua_pop(L, 1);
+ }
+
+ for (i = 0; i < src_image->depth; i++)
+ {
+ int check = imImageMatchDataType(src_image, dst_image_list[i]);
+ if (!check) free(dst_image_list);
+ imlua_matchcheck(L, check, "images must have the same size and data type");
+ }
+
+ imProcessSplitComponents(src_image, dst_image_list);
+
+ free(dst_image_list);
+
+ return 0;
+}
+
+/*****************************************************************************\
+ im.ProcessMergeComponents({r, g, b}, rgb)
+\*****************************************************************************/
+static int imluaProcessMergeComponents (lua_State *L)
+{
+ int i;
+ imImage** src_image_list;
+ imImage *dst_image;
+
+ luaL_checktype(L, 1, LUA_TTABLE);
+ dst_image = imlua_checkimage(L, 2);
+
+ if (imlua_getn(L, 1) != dst_image->depth)
+ luaL_error(L, "number of source images must match the depth of the destination image");
+
+ src_image_list = (imImage**)malloc(sizeof(imImage*)*dst_image->depth);
+
+ for (i = 0; i < dst_image->depth; i++)
+ {
+ lua_pushnumber(L, i+1);
+ lua_gettable(L, 1);
+ src_image_list[i] = imlua_checkimage(L, -1);
+ imlua_checkcolorspace(L, 1, src_image_list[i], IM_GRAY);
+ lua_pop(L, 1);
+ }
+
+ for (i = 0; i < dst_image->depth; i++)
+ {
+ int check = imImageMatchDataType(src_image_list[i], dst_image);
+ if (!check) free(src_image_list);
+ imlua_matchcheck(L, check, "images must have the same size and data type");
+ }
+
+ imProcessMergeComponents((const imImage**)src_image_list, dst_image);
+
+ free(src_image_list);
+
+ return 0;
+}
+
+/*****************************************************************************\
+ im.ProcessNormalizeComponents
+\*****************************************************************************/
+static int imluaProcessNormalizeComponents (lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *dst_image = imlua_checkimage(L, 2);
+
+ imlua_checkdatatype(L, 2, dst_image, IM_FLOAT);
+ imlua_matchcolorspace(L, src_image, dst_image);
+
+ imProcessNormalizeComponents(src_image, dst_image);
+ return 0;
+}
+
+/*****************************************************************************\
+ im.ProcessReplaceColor
+\*****************************************************************************/
+static int imluaProcessReplaceColor (lua_State *L)
+{
+ int src_count, dst_count;
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *dst_image = imlua_checkimage(L, 2);
+ float *src_color = imlua_toarrayfloat(L, 3, &src_count, 1);
+ float *dst_color = imlua_toarrayfloat(L, 4, &dst_count, 1);
+
+ imlua_checknotcfloat(L, src_image, 1);
+ imlua_match(L, src_image, dst_image);
+ luaL_argcheck(L, src_count == src_image->depth, 3, "the colors must have the same number of components of the images");
+ luaL_argcheck(L, dst_count == src_image->depth, 4, "the colors must have the same number of components of the images");
+
+ imProcessReplaceColor(src_image, dst_image, src_color, dst_color);
+ return 0;
+}
+
+
+
+/*****************************************************************************\
+ Logical Arithmetic Operations
+\*****************************************************************************/
+
+/*****************************************************************************\
+ im.ProcessBitwiseOp
+\*****************************************************************************/
+static int imluaProcessBitwiseOp (lua_State *L)
+{
+ imImage *src_image1 = imlua_checkimage(L, 1);
+ imImage *src_image2 = imlua_checkimage(L, 2);
+ imImage *dst_image = imlua_checkimage(L, 3);
+ int op = luaL_checkint(L, 4);
+
+ luaL_argcheck(L, (src_image1->data_type < IM_FLOAT), 1, "image data type can be integer only");
+ imlua_match(L, src_image1, src_image2);
+ imlua_match(L, src_image1, dst_image);
+
+ imProcessBitwiseOp(src_image1, src_image2, dst_image, op);
+ return 0;
+}
+
+/*****************************************************************************\
+ im.ProcessBitwiseNot
+\*****************************************************************************/
+static int imluaProcessBitwiseNot (lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *dst_image = imlua_checkimage(L, 2);
+
+ luaL_argcheck(L, (src_image->data_type < IM_FLOAT), 1, "image data type can be integer only");
+ imlua_match(L, src_image, dst_image);
+
+ imProcessBitwiseNot(src_image, dst_image);
+ return 0;
+}
+
+/*****************************************************************************\
+ im.ProcessBitMask(src_image, dst_image, mask, op)
+\*****************************************************************************/
+static int imluaProcessBitMask (lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *dst_image = imlua_checkimage(L, 2);
+ unsigned char mask = imlua_checkmask(L, 3);
+ int op = luaL_checkint(L, 4);
+
+ imlua_checkdatatype(L, 1, src_image, IM_BYTE);
+ imlua_match(L, src_image, dst_image);
+
+ imProcessBitMask(src_image, dst_image, mask, op);
+ return 0;
+}
+
+/*****************************************************************************\
+ im.ProcessBitPlane(src_image, dst_image, plane, reset)
+\*****************************************************************************/
+static int imluaProcessBitPlane (lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *dst_image = imlua_checkimage(L, 2);
+ int plane = luaL_checkint(L, 3);
+ int reset = luaL_checkint(L, 4);
+
+ imlua_checkdatatype(L, 1, src_image, IM_BYTE);
+ imlua_match(L, src_image, dst_image);
+
+ imProcessBitPlane(src_image, dst_image, plane, reset);
+ return 0;
+}
+
+
+
+/*****************************************************************************\
+ Synthetic Image Render
+\*****************************************************************************/
+
+/* NOTE: This breaks on multithread */
+static lua_State *g_renderState = NULL;
+int g_paramCount = 0;
+
+static float imluaRenderFunc (int x, int y, int d, float *param)
+{
+ lua_State *L = g_renderState;
+
+ luaL_checktype(L, 2, LUA_TFUNCTION);
+ lua_pushvalue(L, 2);
+ lua_pushnumber(L, x);
+ lua_pushnumber(L, y);
+ lua_pushnumber(L, d);
+ imlua_newarrayfloat(L, param, g_paramCount, 1);
+
+ lua_call(L, 4, 1);
+
+ return (float) luaL_checknumber(L, -1);
+}
+
+/*****************************************************************************\
+ im.ProcessRenderOp(image, function, name, param, plus)
+\*****************************************************************************/
+static int imluaProcessRenderOp (lua_State *L)
+{
+ int count;
+
+ imImage *image = imlua_checkimage(L, 1);
+ const char *render_name = luaL_checkstring(L, 3);
+ float *param = imlua_toarrayfloat(L, 4, &count, 1);
+ int plus = luaL_checkint(L, 5);
+
+ imlua_checknotcfloat(L, image, 1);
+
+ luaL_checktype(L, 2, LUA_TFUNCTION);
+
+ g_renderState = L;
+ g_paramCount = count;
+ lua_pushboolean(L, imProcessRenderOp(image, imluaRenderFunc, (char*) render_name, param, plus));
+ return 1;
+}
+
+static float imluaRenderCondFunc (int x, int y, int d, int *cond, float *param)
+{
+ lua_State *L = g_renderState;
+
+ luaL_checktype(L, 2, LUA_TFUNCTION);
+ lua_pushvalue(L, 2);
+ lua_pushnumber(L, x);
+ lua_pushnumber(L, y);
+ lua_pushnumber(L, d);
+ imlua_newarrayfloat(L, param, g_paramCount, 1);
+
+ lua_call(L, 4, 2);
+
+ *cond = luaL_checkint(L, -1);
+ return (float) luaL_checknumber(L, -2);
+}
+
+/*****************************************************************************\
+ im.ProcessRenderCondOp(image, function, name, param)
+\*****************************************************************************/
+static int imluaProcessRenderCondOp (lua_State *L)
+{
+ int count;
+
+ imImage *image = imlua_checkimage(L, 1);
+ const char *render_name = luaL_checkstring(L, 3);
+ float *param = imlua_toarrayfloat(L, 4, &count, 1);
+
+ imlua_checknotcfloat(L, image, 1);
+
+ luaL_checktype(L, 2, LUA_TFUNCTION);
+
+ g_renderState = L;
+ g_paramCount = count;
+ lua_pushboolean(L, imProcessRenderCondOp(image, imluaRenderCondFunc, (char*) render_name, param));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.ProcessRenderAddSpeckleNoise
+\*****************************************************************************/
+static int imluaProcessRenderAddSpeckleNoise (lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *dst_image = imlua_checkimage(L, 2);
+ float percent = (float) luaL_checknumber(L, 3);
+
+ imlua_checknotcfloat(L, src_image, 1);
+ imlua_match(L, src_image, dst_image);
+
+ lua_pushboolean(L, imProcessRenderAddSpeckleNoise(src_image, dst_image, percent));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.ProcessRenderAddGaussianNoise
+\*****************************************************************************/
+static int imluaProcessRenderAddGaussianNoise (lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *dst_image = imlua_checkimage(L, 2);
+ float mean = (float) luaL_checknumber(L, 3);
+ float stddev = (float) luaL_checknumber(L, 4);
+
+ imlua_checknotcfloat(L, src_image, 1);
+ imlua_match(L, src_image, dst_image);
+
+ lua_pushboolean(L, imProcessRenderAddGaussianNoise(src_image, dst_image, mean, stddev));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.ProcessRenderAddUniformNoise
+\*****************************************************************************/
+static int imluaProcessRenderAddUniformNoise (lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *dst_image = imlua_checkimage(L, 2);
+ float mean = (float) luaL_checknumber(L, 3);
+ float stddev = (float) luaL_checknumber(L, 4);
+
+ imlua_checknotcfloat(L, src_image, 1);
+ imlua_match(L, src_image, dst_image);
+
+ lua_pushboolean(L, imProcessRenderAddUniformNoise(src_image, dst_image, mean, stddev));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.ProcessRenderRandomNoise
+\*****************************************************************************/
+static int imluaProcessRenderRandomNoise (lua_State *L)
+{
+ imImage *image = imlua_checkimage(L, 1);
+ imlua_checknotcfloat(L, image, 1);
+ lua_pushboolean(L, imProcessRenderRandomNoise(image));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.ProcessRenderConstant(image, [count])
+\*****************************************************************************/
+static int imluaProcessRenderConstant (lua_State *L)
+{
+ int i;
+ float *value = NULL;
+
+ imImage *image = imlua_checkimage(L, 1);
+ int count = image->depth;
+
+ imlua_checknotcfloat(L, image, 1);
+
+ if (lua_istable(L, 2))
+ {
+ value = (float*) malloc (sizeof(float) * count);
+
+ for (i = 0; i < count; i++)
+ {
+ lua_rawgeti(L, 2, i+1);
+ value[i] = (float) lua_tonumber(L, -1);
+ lua_pop(L, 1);
+ }
+ }
+
+ lua_pushboolean(L, imProcessRenderConstant(image, value));
+
+ if (value)
+ free(value);
+
+ return 1;
+}
+
+/*****************************************************************************\
+ im.ProcessRenderWheel
+\*****************************************************************************/
+static int imluaProcessRenderWheel (lua_State *L)
+{
+ imImage *image = imlua_checkimage(L, 1);
+ int int_radius = luaL_checkint(L, 2);
+ int ext_radius = luaL_checkint(L, 3);
+
+ imlua_checknotcfloat(L, image, 1);
+
+ lua_pushboolean(L, imProcessRenderWheel(image, int_radius, ext_radius));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.ProcessRenderCone
+\*****************************************************************************/
+static int imluaProcessRenderCone (lua_State *L)
+{
+ imImage *image = imlua_checkimage(L, 1);
+ int radius = luaL_checkint(L, 2);
+
+ imlua_checknotcfloat(L, image, 1);
+
+ lua_pushboolean(L, imProcessRenderCone(image, radius));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.ProcessRenderTent
+\*****************************************************************************/
+static int imluaProcessRenderTent (lua_State *L)
+{
+ imImage *image = imlua_checkimage(L, 1);
+ int width = luaL_checkint(L, 2);
+ int height = luaL_checkint(L, 3);
+
+ imlua_checknotcfloat(L, image, 1);
+
+ lua_pushboolean(L, imProcessRenderTent(image, width, height));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.ProcessRenderRamp
+\*****************************************************************************/
+static int imluaProcessRenderRamp (lua_State *L)
+{
+ imImage *image = imlua_checkimage(L, 1);
+ int start = luaL_checkint(L, 2);
+ int end = luaL_checkint(L, 3);
+ int dir = luaL_checkint(L, 4);
+
+ imlua_checknotcfloat(L, image, 1);
+
+ lua_pushboolean(L, imProcessRenderRamp(image, start, end, dir));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.ProcessRenderBox
+\*****************************************************************************/
+static int imluaProcessRenderBox (lua_State *L)
+{
+ imImage *image = imlua_checkimage(L, 1);
+ int width = luaL_checkint(L, 2);
+ int height = luaL_checkint(L, 3);
+
+ imlua_checknotcfloat(L, image, 1);
+
+ lua_pushboolean(L, imProcessRenderBox(image, width, height));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.ProcessRenderSinc
+\*****************************************************************************/
+static int imluaProcessRenderSinc (lua_State *L)
+{
+ imImage *image = imlua_checkimage(L, 1);
+ float xperiod = (float) luaL_checknumber(L, 2);
+ float yperiod = (float) luaL_checknumber(L, 3);
+
+ imlua_checknotcfloat(L, image, 1);
+
+ lua_pushboolean(L, imProcessRenderSinc(image, xperiod, yperiod));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.ProcessRenderGaussian
+\*****************************************************************************/
+static int imluaProcessRenderGaussian (lua_State *L)
+{
+ imImage *image = imlua_checkimage(L, 1);
+ float stddev = (float) luaL_checknumber(L, 2);
+
+ imlua_checknotcfloat(L, image, 1);
+
+ lua_pushboolean(L, imProcessRenderGaussian(image, stddev));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.ProcessRenderLapOfGaussian
+\*****************************************************************************/
+static int imluaProcessRenderLapOfGaussian (lua_State *L)
+{
+ imImage *image = imlua_checkimage(L, 1);
+ float stddev = (float) luaL_checknumber(L, 2);
+
+ imlua_checknotcfloat(L, image, 1);
+
+ lua_pushboolean(L, imProcessRenderLapOfGaussian(image, stddev));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.ProcessRenderCosine
+\*****************************************************************************/
+static int imluaProcessRenderCosine (lua_State *L)
+{
+ imImage *image = imlua_checkimage(L, 1);
+ float xperiod = (float) luaL_checknumber(L, 2);
+ float yperiod = (float) luaL_checknumber(L, 3);
+
+ imlua_checknotcfloat(L, image, 1);
+
+ lua_pushboolean(L, imProcessRenderCosine(image, xperiod, yperiod));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.ProcessRenderGrid
+\*****************************************************************************/
+static int imluaProcessRenderGrid (lua_State *L)
+{
+ imImage *image = imlua_checkimage(L, 1);
+ int x_space = luaL_checkint(L, 2);
+ int y_space = luaL_checkint(L, 3);
+
+ imlua_checknotcfloat(L, image, 1);
+
+ lua_pushboolean(L, imProcessRenderGrid(image, x_space, y_space));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.ProcessRenderChessboard
+\*****************************************************************************/
+static int imluaProcessRenderChessboard (lua_State *L)
+{
+ imImage *image = imlua_checkimage(L, 1);
+ int x_space = luaL_checkint(L, 2);
+ int y_space = luaL_checkint(L, 3);
+
+ imlua_checknotcfloat(L, image, 1);
+
+ lua_pushboolean(L, imProcessRenderChessboard(image, x_space, y_space));
+ return 1;
+}
+
+
+
+/*****************************************************************************\
+ Tone Gamut Operations
+\*****************************************************************************/
+
+/*****************************************************************************\
+ im.ProcessToneGamut
+\*****************************************************************************/
+static int imluaProcessToneGamut (lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *dst_image = imlua_checkimage(L, 2);
+ int op = luaL_checkint(L, 3);
+ float *param = NULL;
+
+ imlua_checknotcfloat(L, src_image, 1);
+ imlua_match(L, src_image, dst_image);
+
+ param = imlua_toarrayfloat(L, 4, NULL, 1);
+
+ imProcessToneGamut(src_image, dst_image, op, param);
+
+ if (param)
+ free(param);
+
+ return 0;
+}
+
+/*****************************************************************************\
+ im.ProcessUnNormalize
+\*****************************************************************************/
+static int imluaProcessUnNormalize (lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *dst_image = imlua_checkimage(L, 2);
+
+ imlua_checkdatatype(L, 1, src_image, IM_FLOAT);
+ imlua_checkdatatype(L, 2, dst_image, IM_BYTE);
+ imlua_matchcolorspace(L, src_image, dst_image);
+
+ imProcessUnNormalize(src_image, dst_image);
+ return 0;
+}
+
+/*****************************************************************************\
+ im.ProcessDirectConv
+\*****************************************************************************/
+static int imluaProcessDirectConv (lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *dst_image = imlua_checkimage(L, 2);
+
+ luaL_argcheck(L,
+ src_image->data_type == IM_USHORT ||
+ src_image->data_type == IM_INT ||
+ src_image->data_type == IM_FLOAT,
+ 1, "data type can be ushort, int or float only");
+ imlua_checkdatatype(L, 2, dst_image, IM_BYTE);
+ imlua_matchsize(L, src_image, dst_image);
+
+ imProcessDirectConv(src_image, dst_image);
+ return 0;
+}
+
+/*****************************************************************************\
+ im.ProcessNegative
+\*****************************************************************************/
+static int imluaProcessNegative (lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *dst_image = imlua_checkimage(L, 2);
+
+ imlua_checknotcfloat(L, src_image, 1);
+ imlua_match(L, src_image, dst_image);
+
+ imProcessNegative(src_image, dst_image);
+ return 0;
+}
+
+
+
+/*****************************************************************************\
+ Threshold Operations
+\*****************************************************************************/
+
+/*****************************************************************************\
+ im.ProcessRangeContrastThreshold
+\*****************************************************************************/
+static int imluaProcessRangeContrastThreshold (lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *dst_image = imlua_checkimage(L, 2);
+ int kernel_size = luaL_checkint(L, 3);
+ int min_range = luaL_checkint(L, 4);
+
+ imlua_checktype(L, 1, src_image, IM_GRAY, IM_BYTE);
+ luaL_argcheck(L, (src_image->data_type < IM_FLOAT), 1, "image data type can be integer only");
+ imlua_checkcolorspace(L, 2, dst_image, IM_BINARY);
+ imlua_matchsize(L, src_image, dst_image);
+
+ lua_pushboolean(L, imProcessRangeContrastThreshold(src_image, dst_image, kernel_size, min_range));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.ProcessLocalMaxThreshold
+\*****************************************************************************/
+static int imluaProcessLocalMaxThreshold (lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *dst_image = imlua_checkimage(L, 2);
+ int kernel_size = luaL_checkint(L, 3);
+ int min_thres = luaL_checkint(L, 4);
+
+ imlua_checktype(L, 1, src_image, IM_GRAY, IM_BYTE);
+ luaL_argcheck(L, (src_image->data_type < IM_FLOAT), 1, "image data type can be integer only");
+ imlua_checkcolorspace(L, 2, dst_image, IM_BINARY);
+ imlua_matchsize(L, src_image, dst_image);
+
+ lua_pushboolean(L, imProcessLocalMaxThreshold(src_image, dst_image, kernel_size, min_thres));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.ProcessThreshold
+\*****************************************************************************/
+static int imluaProcessThreshold (lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *dst_image = imlua_checkimage(L, 2);
+ int level = luaL_checkint(L, 3);
+ int value = luaL_checkint(L, 4);
+
+ imlua_checktype(L, 1, src_image, IM_GRAY, IM_BYTE);
+ luaL_argcheck(L, (src_image->data_type < IM_FLOAT), 1, "image data type can be integer only");
+
+ imlua_checkcolorspace(L, 2, dst_image, IM_BINARY);
+ imlua_matchsize(L, src_image, dst_image);
+
+ imProcessThreshold(src_image, dst_image, level, value);
+ return 0;
+}
+
+/*****************************************************************************\
+ im.ProcessThresholdByDiff
+\*****************************************************************************/
+static int imluaProcessThresholdByDiff (lua_State *L)
+{
+ imImage *src_image1 = imlua_checkimage(L, 1);
+ imImage *src_image2 = imlua_checkimage(L, 2);
+ imImage *dst_image = imlua_checkimage(L, 3);
+
+ imlua_checktype(L, 1, src_image1, IM_GRAY, IM_BYTE);
+ imlua_match(L, src_image1, src_image2);
+ imlua_checkcolorspace(L, 2, dst_image, IM_BINARY);
+ imlua_matchsize(L, src_image1, dst_image);
+
+ imProcessThresholdByDiff(src_image1, src_image2, dst_image);
+ return 0;
+}
+
+/*****************************************************************************\
+ im.ProcessHysteresisThreshold
+\*****************************************************************************/
+static int imluaProcessHysteresisThreshold (lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *dst_image = imlua_checkimage(L, 2);
+ int low_thres = luaL_checkint(L, 3);
+ int high_thres = luaL_checkint(L, 4);
+
+ imlua_checktype(L, 1, src_image, IM_GRAY, IM_BYTE);
+ imlua_checkcolorspace(L, 2, dst_image, IM_BINARY);
+ imlua_matchsize(L, src_image, dst_image);
+
+ imProcessHysteresisThreshold(src_image, dst_image, low_thres, high_thres);
+ return 0;
+}
+
+/*****************************************************************************\
+ im.ProcessHysteresisThresEstimate
+\*****************************************************************************/
+static int imluaProcessHysteresisThresEstimate (lua_State *L)
+{
+ int low_thres, high_thres;
+
+ imImage *src_image = imlua_checkimage(L, 1);
+
+ imlua_checktype(L, 1, src_image, IM_GRAY, IM_BYTE);
+
+ imProcessHysteresisThresEstimate(src_image, &low_thres, &high_thres);
+ lua_pushnumber(L, low_thres);
+ lua_pushnumber(L, high_thres);
+
+ return 2;
+}
+
+/*****************************************************************************\
+ im.ProcessUniformErrThreshold
+\*****************************************************************************/
+static int imluaProcessUniformErrThreshold (lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *dst_image = imlua_checkimage(L, 2);
+
+ imlua_checktype(L, 1, src_image, IM_GRAY, IM_BYTE);
+ imlua_checkcolorspace(L, 2, dst_image, IM_BINARY);
+ imlua_matchsize(L, src_image, dst_image);
+
+ lua_pushboolean(L, imProcessUniformErrThreshold(src_image, dst_image));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.ProcessDifusionErrThreshold
+\*****************************************************************************/
+static int imluaProcessDifusionErrThreshold (lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *dst_image = imlua_checkimage(L, 2);
+ int level = luaL_checkint(L, 3);
+
+ imlua_checkdatatype(L, 1, src_image, IM_BYTE);
+ imlua_checkdatatype(L, 2, dst_image, IM_BYTE);
+ imlua_matchcheck(L, src_image->depth == dst_image->depth, "images must have the same depth");
+ imlua_matchsize(L, src_image, dst_image);
+
+ imProcessDifusionErrThreshold(src_image, dst_image, level);
+ return 0;
+}
+
+/*****************************************************************************\
+ im.ProcessPercentThreshold
+\*****************************************************************************/
+static int imluaProcessPercentThreshold (lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *dst_image = imlua_checkimage(L, 2);
+ float percent = (float) luaL_checknumber(L, 3);
+
+ imlua_checktype(L, 1, src_image, IM_GRAY, IM_BYTE);
+ imlua_checkcolorspace(L, 2, dst_image, IM_BINARY);
+ imlua_matchsize(L, src_image, dst_image);
+
+ lua_pushboolean(L, imProcessPercentThreshold(src_image, dst_image, percent));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.ProcessOtsuThreshold
+\*****************************************************************************/
+static int imluaProcessOtsuThreshold (lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *dst_image = imlua_checkimage(L, 2);
+
+ imlua_checktype(L, 1, src_image, IM_GRAY, IM_BYTE);
+ imlua_checkcolorspace(L, 2, dst_image, IM_BINARY);
+ imlua_matchsize(L, src_image, dst_image);
+
+ lua_pushnumber(L, imProcessOtsuThreshold(src_image, dst_image));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.ProcessMinMaxThreshold
+\*****************************************************************************/
+static int imluaProcessMinMaxThreshold (lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *dst_image = imlua_checkimage(L, 2);
+
+ imlua_checkcolorspace(L, 1, src_image, IM_GRAY);
+ luaL_argcheck(L, (src_image->data_type < IM_FLOAT), 1, "image data type can be integer only");
+ imlua_checkcolorspace(L, 2, dst_image, IM_BINARY);
+ imlua_matchsize(L, src_image, dst_image);
+
+ lua_pushboolean(L, imProcessMinMaxThreshold(src_image, dst_image));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.ProcessLocalMaxThresEstimate
+\*****************************************************************************/
+static int imluaProcessLocalMaxThresEstimate (lua_State *L)
+{
+ int thres;
+ imImage *image = imlua_checkimage(L, 1);
+
+ imlua_checkdatatype(L, 1, image, IM_BYTE);
+
+ imProcessLocalMaxThresEstimate(image, &thres);
+
+ lua_pushnumber(L, thres);
+ return 1;
+}
+
+/*****************************************************************************\
+ im.ProcessSliceThreshold
+\*****************************************************************************/
+static int imluaProcessSliceThreshold (lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *dst_image = imlua_checkimage(L, 2);
+
+ int start_level = luaL_checkint(L, 3);
+ int end_level = luaL_checkint(L, 4);
+
+ imlua_checkcolorspace(L, 1, src_image, IM_GRAY);
+ luaL_argcheck(L, (src_image->data_type < IM_FLOAT), 1, "image data type can be integer only");
+ imlua_checkcolorspace(L, 2, dst_image, IM_BINARY);
+ imlua_matchsize(L, src_image, dst_image);
+
+ imProcessSliceThreshold(src_image, dst_image, start_level, end_level);
+ return 0;
+}
+
+
+/*****************************************************************************\
+ Special Effects
+\*****************************************************************************/
+
+/*****************************************************************************\
+ im.ProcessPixelate
+\*****************************************************************************/
+static int imluaProcessPixelate (lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *dst_image = imlua_checkimage(L, 2);
+ int box_size = luaL_checkint(L, 3);
+
+ imlua_checkdatatype(L, 1, src_image, IM_BYTE);
+ imlua_match(L, src_image, dst_image);
+
+ imProcessPixelate(src_image, dst_image, box_size);
+ return 0;
+}
+
+/*****************************************************************************\
+ im.ProcessPosterize
+\*****************************************************************************/
+static int imluaProcessPosterize (lua_State *L)
+{
+ imImage *src_image = imlua_checkimage(L, 1);
+ imImage *dst_image = imlua_checkimage(L, 2);
+ int level = luaL_checkint(L, 3);
+
+ imlua_checkdatatype(L, 1, src_image, IM_BYTE);
+ imlua_match(L, src_image, dst_image);
+ luaL_argcheck(L, (level >= 1 && level <= 7), 3, "invalid level, must be >=1 and <=7");
+
+ imProcessPosterize(src_image, dst_image, level);
+ return 0;
+}
+
+
+
+static const luaL_reg improcess_lib[] = {
+ {"CalcRMSError", imluaCalcRMSError},
+ {"CalcSNR", imluaCalcSNR},
+ {"CalcCountColors", imluaCalcCountColors},
+ {"CalcHistogram", imluaCalcHistogram},
+ /*{"CalcUShortHistogram", imluaCalcUShortHistogram}, done by imluaCalcHistogram */
+ {"CalcGrayHistogram", imluaCalcGrayHistogram},
+ {"CalcImageStatistics", imluaCalcImageStatistics},
+ {"CalcHistogramStatistics", imluaCalcHistogramStatistics},
+ {"CalcHistoImageStatistics", imluaCalcHistoImageStatistics},
+
+ {"AnalyzeFindRegions", imluaAnalyzeFindRegions},
+ {"AnalyzeMeasureArea", imluaAnalyzeMeasureArea},
+ {"AnalyzeMeasurePerimArea", imluaAnalyzeMeasurePerimArea},
+ {"AnalyzeMeasureCentroid", imluaAnalyzeMeasureCentroid},
+ {"AnalyzeMeasurePrincipalAxis", imluaAnalyzeMeasurePrincipalAxis},
+ {"AnalyzeMeasurePerimeter", imluaAnalyzeMeasurePerimeter},
+ {"AnalyzeMeasureHoles", imluaAnalyzeMeasureHoles},
+
+ {"ProcessPerimeterLine", imluaProcessPerimeterLine},
+ {"ProcessPrune", imluaProcessPrune},
+ {"ProcessFillHoles", imluaProcessFillHoles},
+
+ {"ProcessHoughLines", imluaProcessHoughLines},
+ {"ProcessHoughLinesDraw", imluaProcessHoughLinesDraw},
+ {"ProcessDistanceTransform", imluaProcessDistanceTransform},
+ {"ProcessRegionalMaximum", imluaProcessRegionalMaximum},
+
+ {"ProcessReduce", imluaProcessReduce},
+ {"ProcessResize", imluaProcessResize},
+ {"ProcessReduceBy4", imluaProcessReduceBy4},
+ {"ProcessCrop", imluaProcessCrop},
+ {"ProcessAddMargins", imluaProcessAddMargins},
+ {"ProcessInsert", imluaProcessInsert},
+
+ {"ProcessCalcRotateSize", imluaProcessCalcRotateSize},
+ {"ProcessRotate", imluaProcessRotate},
+ {"ProcessRotateRef", imluaProcessRotateRef},
+ {"ProcessRotate90", imluaProcessRotate90},
+ {"ProcessRotate180", imluaProcessRotate180},
+ {"ProcessMirror", imluaProcessMirror},
+ {"ProcessFlip", imluaProcessFlip},
+ {"ProcessRadial", imluaProcessRadial},
+ {"ProcessSwirl", imluaProcessSwirl},
+ {"ProcessInterlaceSplit", imluaProcessInterlaceSplit},
+
+ {"ProcessGrayMorphConvolve", imluaProcessGrayMorphConvolve},
+ {"ProcessGrayMorphErode", imluaProcessGrayMorphErode},
+ {"ProcessGrayMorphDilate", imluaProcessGrayMorphDilate},
+ {"ProcessGrayMorphOpen", imluaProcessGrayMorphOpen},
+ {"ProcessGrayMorphClose", imluaProcessGrayMorphClose},
+ {"ProcessGrayMorphTopHat", imluaProcessGrayMorphTopHat},
+ {"ProcessGrayMorphWell", imluaProcessGrayMorphWell},
+ {"ProcessGrayMorphGradient", imluaProcessGrayMorphGradient},
+
+ {"ProcessBinMorphConvolve", imluaProcessBinMorphConvolve},
+ {"ProcessBinMorphErode", imluaProcessBinMorphErode},
+ {"ProcessBinMorphDilate", imluaProcessBinMorphDilate},
+ {"ProcessBinMorphOpen", imluaProcessBinMorphOpen},
+ {"ProcessBinMorphClose", imluaProcessBinMorphClose},
+ {"ProcessBinMorphOutline", imluaProcessBinMorphOutline},
+ {"ProcessBinMorphThin", imluaProcessBinMorphThin},
+
+ {"ProcessMedianConvolve", imluaProcessMedianConvolve},
+ {"ProcessRangeConvolve", imluaProcessRangeConvolve},
+ {"ProcessRankClosestConvolve", imluaProcessRankClosestConvolve},
+ {"ProcessRankMaxConvolve", imluaProcessRankMaxConvolve},
+ {"ProcessRankMinConvolve", imluaProcessRankMinConvolve},
+
+ {"ProcessConvolve", imluaProcessConvolve},
+ {"ProcessConvolveDual", imluaProcessConvolveDual},
+ {"ProcessConvolveRep", imluaProcessConvolveRep},
+ {"ProcessConvolveSep", imluaProcessConvolveSep},
+ {"ProcessCompassConvolve", imluaProcessCompassConvolve},
+ {"ProcessRotateKernel", imluaProcessRotateKernel},
+ {"ProcessDiffOfGaussianConvolve", imluaProcessDiffOfGaussianConvolve},
+ {"ProcessLapOfGaussianConvolve", imluaProcessLapOfGaussianConvolve},
+ {"ProcessMeanConvolve", imluaProcessMeanConvolve},
+ {"ProcessBarlettConvolve", imluaProcessBarlettConvolve},
+ {"ProcessGaussianConvolve", imluaProcessGaussianConvolve},
+ {"ProcessSobelConvolve", imluaProcessSobelConvolve},
+ {"ProcessPrewittConvolve", imluaProcessPrewittConvolve},
+ {"ProcessSplineEdgeConvolve", imluaProcessSplineEdgeConvolve},
+ {"ProcessZeroCrossing", imluaProcessZeroCrossing},
+ {"ProcessCanny", imluaProcessCanny},
+ {"GaussianKernelSize2StdDev", imluaGaussianKernelSize2StdDev},
+ {"GaussianStdDev2KernelSize", imluaGaussianStdDev2KernelSize},
+
+ {"ProcessUnArithmeticOp", imluaProcessUnArithmeticOp},
+ {"ProcessArithmeticOp", imluaProcessArithmeticOp},
+ {"ProcessArithmeticConstOp", imluaProcessArithmeticConstOp},
+ {"ProcessBlendConst", imluaProcessBlendConst},
+ {"ProcessBlend", imluaProcessBlend},
+ {"ProcessSplitComplex", imluaProcessSplitComplex},
+ {"ProcessMergeComplex", imluaProcessMergeComplex},
+ {"ProcessMultipleMean", imluaProcessMultipleMean},
+ {"ProcessMultipleStdDev", imluaProcessMultipleStdDev},
+ {"ProcessAutoCovariance", imluaProcessAutoCovariance},
+ {"ProcessMultiplyConj", imluaProcessMultiplyConj},
+
+ {"ProcessQuantizeRGBUniform", imluaProcessQuantizeRGBUniform},
+ {"ProcessQuantizeGrayUniform", imluaProcessQuantizeGrayUniform},
+
+ {"ProcessExpandHistogram", imluaProcessExpandHistogram},
+ {"ProcessEqualizeHistogram", imluaProcessEqualizeHistogram},
+
+ {"ProcessSplitYChroma", imluaProcessSplitYChroma},
+ {"ProcessSplitHSI", imluaProcessSplitHSI},
+ {"ProcessMergeHSI", imluaProcessMergeHSI},
+ {"ProcessSplitComponents", imluaProcessSplitComponents},
+ {"ProcessMergeComponents", imluaProcessMergeComponents},
+ {"ProcessNormalizeComponents", imluaProcessNormalizeComponents},
+ {"ProcessReplaceColor", imluaProcessReplaceColor},
+
+ {"ProcessBitwiseOp", imluaProcessBitwiseOp},
+ {"ProcessBitwiseNot", imluaProcessBitwiseNot},
+ {"ProcessBitMask", imluaProcessBitMask},
+ {"ProcessBitPlane", imluaProcessBitPlane},
+
+ {"ProcessRenderOp", imluaProcessRenderOp},
+ {"ProcessRenderCondOp", imluaProcessRenderCondOp},
+ {"ProcessRenderAddSpeckleNoise", imluaProcessRenderAddSpeckleNoise},
+ {"ProcessRenderAddGaussianNoise", imluaProcessRenderAddGaussianNoise},
+ {"ProcessRenderAddUniformNoise", imluaProcessRenderAddUniformNoise},
+ {"ProcessRenderRandomNoise", imluaProcessRenderRandomNoise},
+ {"ProcessRenderConstant", imluaProcessRenderConstant},
+ {"ProcessRenderWheel", imluaProcessRenderWheel},
+ {"ProcessRenderCone", imluaProcessRenderCone},
+ {"ProcessRenderTent", imluaProcessRenderTent},
+ {"ProcessRenderRamp", imluaProcessRenderRamp},
+ {"ProcessRenderBox", imluaProcessRenderBox},
+ {"ProcessRenderSinc", imluaProcessRenderSinc},
+ {"ProcessRenderGaussian", imluaProcessRenderGaussian},
+ {"ProcessRenderLapOfGaussian", imluaProcessRenderLapOfGaussian},
+ {"ProcessRenderCosine", imluaProcessRenderCosine},
+ {"ProcessRenderGrid", imluaProcessRenderGrid},
+ {"ProcessRenderChessboard", imluaProcessRenderChessboard},
+
+ {"ProcessToneGamut", imluaProcessToneGamut},
+ {"ProcessUnNormalize", imluaProcessUnNormalize},
+ {"ProcessDirectConv", imluaProcessDirectConv},
+ {"ProcessNegative", imluaProcessNegative},
+
+ {"ProcessRangeContrastThreshold", imluaProcessRangeContrastThreshold},
+ {"ProcessLocalMaxThreshold", imluaProcessLocalMaxThreshold},
+ {"ProcessThreshold", imluaProcessThreshold},
+ {"ProcessThresholdByDiff", imluaProcessThresholdByDiff},
+ {"ProcessHysteresisThreshold", imluaProcessHysteresisThreshold},
+ {"ProcessHysteresisThresEstimate", imluaProcessHysteresisThresEstimate},
+ {"ProcessUniformErrThreshold", imluaProcessUniformErrThreshold},
+ {"ProcessDifusionErrThreshold", imluaProcessDifusionErrThreshold},
+ {"ProcessPercentThreshold", imluaProcessPercentThreshold},
+ {"ProcessOtsuThreshold", imluaProcessOtsuThreshold},
+ {"ProcessMinMaxThreshold", imluaProcessMinMaxThreshold},
+ {"ProcessLocalMaxThresEstimate", imluaProcessLocalMaxThresEstimate},
+ {"ProcessSliceThreshold", imluaProcessSliceThreshold},
+
+ {"ProcessPixelate", imluaProcessPixelate},
+ {"ProcessPosterize", imluaProcessPosterize},
+
+ {NULL, NULL}
+};
+
+/*****************************************************************************\
+ Constants
+\*****************************************************************************/
+static const imlua_constant im_process_constants[] = {
+
+ { "UN_EQL", IM_UN_EQL, NULL },
+ { "UN_ABS", IM_UN_ABS, NULL },
+ { "UN_LESS", IM_UN_LESS, NULL },
+ { "UN_INC", IM_UN_INC, NULL },
+ { "UN_INV", IM_UN_INV, NULL },
+ { "UN_SQR", IM_UN_SQR, NULL },
+ { "UN_SQRT", IM_UN_SQRT, NULL },
+ { "UN_LOG", IM_UN_LOG, NULL },
+ { "UN_EXP", IM_UN_EXP, NULL },
+ { "UN_SIN", IM_UN_SIN, NULL },
+ { "UN_COS", IM_UN_COS, NULL },
+ { "UN_CONJ", IM_UN_CONJ, NULL },
+ { "UN_CPXNORM", IM_UN_CPXNORM, NULL },
+
+ { "BIN_ADD", IM_BIN_ADD, NULL },
+ { "BIN_SUB", IM_BIN_SUB, NULL },
+ { "BIN_MUL", IM_BIN_MUL, NULL },
+ { "BIN_DIV", IM_BIN_DIV, NULL },
+ { "BIN_DIFF", IM_BIN_DIFF, NULL },
+ { "BIN_POW", IM_BIN_POW, NULL },
+ { "BIN_MIN", IM_BIN_MIN, NULL },
+ { "BIN_MAX", IM_BIN_MAX, NULL },
+
+ { "BIT_AND", IM_BIT_AND, NULL },
+ { "BIT_OR", IM_BIT_OR, NULL },
+ { "BIT_XOR", IM_BIT_XOR, NULL },
+
+ { "GAMUT_NORMALIZE", IM_GAMUT_NORMALIZE, NULL },
+ { "GAMUT_POW", IM_GAMUT_POW, NULL },
+ { "GAMUT_LOG", IM_GAMUT_LOG, NULL },
+ { "GAMUT_EXP", IM_GAMUT_EXP, NULL },
+ { "GAMUT_INVERT", IM_GAMUT_INVERT, NULL },
+ { "GAMUT_ZEROSTART", IM_GAMUT_ZEROSTART, NULL },
+ { "GAMUT_SOLARIZE", IM_GAMUT_SOLARIZE, NULL },
+ { "GAMUT_SLICE", IM_GAMUT_SLICE, NULL },
+ { "GAMUT_EXPAND", IM_GAMUT_EXPAND, NULL },
+ { "GAMUT_CROP", IM_GAMUT_CROP, NULL },
+ { "GAMUT_BRIGHTCONT", IM_GAMUT_BRIGHTCONT, NULL },
+
+ { NULL, -1, NULL },
+};
+
+/* from imlua_kernel.c */
+void imlua_open_kernel(lua_State *L);
+
+int imlua_open_process(lua_State *L)
+{
+ luaL_register(L, "im", improcess_lib); /* leave "im" table at the top of the stack */
+ imlua_regconstants(L, im_process_constants);
+#ifdef TEC_BIGENDIAN
+#ifdef TEC_64
+#include "im_process_be64.loh"
+#else
+#include "im_process_be32.loh"
+#endif
+#else
+#ifdef TEC_64
+#ifdef WIN64
+#include "im_process_le64w.loh"
+#else
+#include "im_process_le64.loh"
+#endif
+#else
+#include "im_process.loh"
+#endif
+#endif
+ imlua_open_kernel(L);
+ return 1;
+}
+
+int luaopen_imlua_process(lua_State *L)
+{
+ return imlua_open_process(L);
+}
+
+int luaopen_imlua_process51(lua_State *L)
+{
+ return imlua_open_process(L);
+}
+
diff --git a/src/lua5/imlua_process.def b/src/lua5/imlua_process.def
new file mode 100644
index 0000000..2b77e77
--- /dev/null
+++ b/src/lua5/imlua_process.def
@@ -0,0 +1,4 @@
+EXPORTS
+ imlua_open_process
+ luaopen_imlua_process
+ luaopen_imlua_process51 \ No newline at end of file
diff --git a/src/lua5/imlua_util.c b/src/lua5/imlua_util.c
new file mode 100644
index 0000000..69cfb19
--- /dev/null
+++ b/src/lua5/imlua_util.c
@@ -0,0 +1,279 @@
+/** \file
+ * \brief IM Lua 5 Binding
+ *
+ * See Copyright Notice in im_lib.h
+ * $Id: imlua_util.c,v 1.1 2008/10/17 06:16:32 scuri Exp $
+ */
+
+#include "im.h"
+#include "im_util.h"
+#include "im_image.h"
+
+#include <lua.h>
+#include <lauxlib.h>
+
+#include "imlua.h"
+#include "imlua_aux.h"
+
+/*****************************************************************************\
+ im.ImageDataSize(width, height, color_mode, data_type)
+\*****************************************************************************/
+static int imluaImageDataSize (lua_State *L)
+{
+ int width = luaL_checkint(L, 1);
+ int height = luaL_checkint(L, 2);
+ int color_mode = luaL_checkint(L, 3);
+ int data_type = luaL_checkint(L, 4);
+
+ lua_pushnumber(L, imImageDataSize(width, height, color_mode, data_type));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.ImageLineSize(width, color_mode, data_type)
+\*****************************************************************************/
+static int imluaImageLineSize (lua_State *L)
+{
+ int width = luaL_checkint(L, 1);
+ int color_mode = luaL_checkint(L, 2);
+ int data_type = luaL_checkint(L, 3);
+
+ lua_pushnumber(L, imImageLineSize(width, color_mode, data_type));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.ImageLineCount(width, color_mode)
+\*****************************************************************************/
+static int imluaImageLineCount (lua_State *L)
+{
+ int width = luaL_checkint(L, 1);
+ int color_mode = luaL_checkint(L, 2);
+
+ lua_pushnumber(L, imImageLineCount(width, color_mode));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.ImageCheckFormat(width, color_mode)
+\*****************************************************************************/
+static int imluaImageCheckFormat (lua_State *L)
+{
+ int color_mode = luaL_checkint(L, 1);
+ int data_type = luaL_checkint(L, 2);
+
+ lua_pushboolean(L, imImageCheckFormat(color_mode, data_type));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.ColorModeSpaceName(color_mode)
+\*****************************************************************************/
+static int imluaColorModeSpaceName (lua_State *L)
+{
+ lua_pushstring(L, imColorModeSpaceName(luaL_checkint(L, 1)));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.ColorModeDepth(color_mode)
+\*****************************************************************************/
+static int imluaColorModeDepth (lua_State *L)
+{
+ lua_pushnumber(L, imColorModeDepth(luaL_checkint(L, 1)));
+ return 1;
+}
+
+/*****************************************************************************\
+
+\*****************************************************************************/
+
+/*****************************************************************************\
+ im.ColorModeSpace(color_mode)
+\*****************************************************************************/
+static int imluaColorModeSpace (lua_State *L)
+{
+ lua_pushnumber(L, imColorModeSpace(luaL_checkint(L, 1)));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.ColorModeHasAlpha(color_mode)
+\*****************************************************************************/
+static int imluaColorModeMatch (lua_State *L)
+{
+ lua_pushboolean(L, imColorModeMatch(luaL_checkint(L, 1), luaL_checkint(L, 1)));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.ColorModeHasAlpha(color_mode)
+\*****************************************************************************/
+static int imluaColorModeHasAlpha (lua_State *L)
+{
+ lua_pushboolean(L, imColorModeHasAlpha(luaL_checkint(L, 1)));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.ColorModeIsPacked(color_mode)
+\*****************************************************************************/
+static int imluaColorModeIsPacked (lua_State *L)
+{
+ lua_pushboolean(L, imColorModeIsPacked(luaL_checkint(L, 1)));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.ColorModeIsTopDown(color_mode)
+\*****************************************************************************/
+static int imluaColorModeIsTopDown (lua_State *L)
+{
+ lua_pushboolean(L, imColorModeIsTopDown(luaL_checkint(L, 1)));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.ColorModeToBitmap(color_mode)
+\*****************************************************************************/
+static int imluaColorModeToBitmap (lua_State *L)
+{
+ lua_pushnumber(L, imColorModeToBitmap(luaL_checkint(L, 1)));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.ColorModeIsBitmap
+\*****************************************************************************/
+static int imluaColorModeIsBitmap (lua_State *L)
+{
+ int color_mode = luaL_checkint(L, 1);
+ int data_type = luaL_checkint(L, 2);
+
+ lua_pushboolean(L, imColorModeIsBitmap(color_mode, data_type));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.DataTypeSize(data_type)
+\*****************************************************************************/
+static int imluaDataTypeSize (lua_State *L)
+{
+ lua_pushnumber(L, imDataTypeSize(luaL_checkint(L, 1)));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.DataTypeName(data_type)
+\*****************************************************************************/
+static int imluaDataTypeName (lua_State *L)
+{
+ lua_pushstring(L, imDataTypeName(luaL_checkint(L, 1)));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.DataTypeIntMax(data_type)
+\*****************************************************************************/
+static int imluaDataTypeIntMax(lua_State *L)
+{
+ lua_pushnumber(L, imDataTypeIntMax(luaL_checkint(L, 1)));
+ return 1;
+}
+
+/*****************************************************************************\
+ im.DataTypeIntMin(data_type)
+\*****************************************************************************/
+static int imluaDataTypeIntMin(lua_State *L)
+{
+ lua_pushnumber(L, imDataTypeIntMin(luaL_checkint(L, 1)));
+ return 1;
+}
+
+/***************************************************************************\
+* Creates a color as a light userdata. The color value is *
+* placed in the (void *) value. Not beautiful, but works best. *
+* im.ColorEncode(r, g, b: number) -> (c: color) *
+\***************************************************************************/
+static int imlua_colorencode(lua_State *L)
+{
+ int red_f, green_f, blue_f;
+ unsigned char red_i, green_i, blue_i;
+ long int color_i;
+
+ red_f = luaL_checkint(L, 1);
+ green_f = luaL_checkint(L, 2);
+ blue_f = luaL_checkint(L, 3);
+
+ if (red_f < 0 || red_f > 255)
+ luaL_argerror(L, 1, "color components values should be in range [0, 255]");
+ if (green_f < 0 || green_f > 255)
+ luaL_argerror(L, 2, "color components values should be in range [0, 255]");
+ if (blue_f < 0 || blue_f > 255)
+ luaL_argerror(L, 3, "color components values should be in range [0, 255]");
+
+ red_i = (unsigned char) (red_f);
+ green_i = (unsigned char) (green_f);
+ blue_i = (unsigned char) (blue_f);
+
+ color_i = imColorEncode(red_i, green_i, blue_i);
+ lua_pushlightuserdata(L, (void *)color_i);
+
+ return 1;
+}
+
+/***************************************************************************\
+* Decodes a color previously created. *
+* im.ColorDecode(c: color) -> (r, g, b: number) *
+\***************************************************************************/
+static int imlua_colordecode(lua_State *L)
+{
+ long int color_i;
+ unsigned char red_i, green_i, blue_i;
+
+ if (!lua_islightuserdata(L, 1))
+ luaL_argerror(L, 1, "color must be a light user data");
+
+ color_i = (long int) lua_touserdata(L,1);
+
+ imColorDecode(&red_i, &green_i, &blue_i, color_i);
+ lua_pushnumber(L, red_i);
+ lua_pushnumber(L, green_i);
+ lua_pushnumber(L, blue_i);
+
+ return 3;
+}
+
+static const luaL_reg imutil_lib[] = {
+ {"ImageDataSize", imluaImageDataSize},
+ {"ImageLineSize", imluaImageLineSize},
+ {"ImageLineCount", imluaImageLineCount},
+ {"ImageCheckFormat", imluaImageCheckFormat},
+
+ {"ColorModeSpace", imluaColorModeSpace},
+ {"ColorModeSpaceName", imluaColorModeSpaceName},
+ {"ColorModeDepth", imluaColorModeDepth},
+
+ {"ColorModeToBitmap", imluaColorModeToBitmap},
+ {"ColorModeIsBitmap", imluaColorModeIsBitmap},
+ {"ColorModeMatch", imluaColorModeMatch},
+ {"ColorModeHasAlpha", imluaColorModeHasAlpha},
+ {"ColorModeIsPacked", imluaColorModeIsPacked},
+ {"ColorModeIsTopDown", imluaColorModeIsTopDown},
+
+ {"DataTypeSize", imluaDataTypeSize},
+ {"DataTypeName", imluaDataTypeName},
+ {"DataTypeIntMax", imluaDataTypeIntMax},
+ {"DataTypeIntMin", imluaDataTypeIntMin},
+
+ {"ColorEncode", imlua_colorencode},
+ {"ColorDecode", imlua_colordecode},
+
+ {NULL, NULL}
+};
+
+void imlua_open_util(lua_State *L)
+{
+ /* "im" table is at the top of the stack */
+ luaL_register(L, NULL, imutil_lib);
+}
diff --git a/src/lua5/imlua_wmv.c b/src/lua5/imlua_wmv.c
new file mode 100644
index 0000000..7f61030
--- /dev/null
+++ b/src/lua5/imlua_wmv.c
@@ -0,0 +1,44 @@
+/** \file
+ * \brief wmv format Lua 5 Binding
+ *
+ * See Copyright Notice in cd.h
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+
+#include "im_format_wmv.h"
+
+#include <lua.h>
+#include <lauxlib.h>
+
+
+static int imlua_FormatRegisterWMV(lua_State *L)
+{
+ (void)L;
+ imFormatRegisterWMV();
+ return 0;
+}
+
+static const struct luaL_reg imlib[] = {
+ {"FormatRegisterWMV", imlua_FormatRegisterWMV},
+ {NULL, NULL},
+};
+
+
+static int imlua_wmv_open (lua_State *L)
+{
+ imFormatRegisterWMV();
+ luaL_register(L, "im", imlib); /* leave "im" table at the top of the stack */
+ return 1;
+}
+
+int luaopen_imlua_wmv(lua_State* L)
+{
+ return imlua_wmv_open(L);
+}
+
+int luaopen_imlua_wmv51(lua_State* L)
+{
+ return imlua_wmv_open(L);
+}
diff --git a/src/lua5/imlua_wmv.def b/src/lua5/imlua_wmv.def
new file mode 100644
index 0000000..0c05563
--- /dev/null
+++ b/src/lua5/imlua_wmv.def
@@ -0,0 +1,4 @@
+EXPORTS
+ luaopen_imlua_wmv
+ luaopen_imlua_wmv51
+ \ No newline at end of file
generated by cgit v1.2.3 (git 2.39.1) at 2025-11-04 11:51:08 +0000