int imAnalyzeFindRegions(const imImage* image, imImage* NewImage, int connect, int touch_border)
{
imImageSetAttribute(NewImage, "REGION_CONNECT", IM_BYTE, 1, connect==4?"4":"8");
if (touch_border)
return DoAnalyzeFindRegionsBorder(image->width, image->height, (imbyte*)image->data[0], (imushort*)NewImage->data[0], connect);
else
return DoAnalyzeFindRegions(image->width, image->height, (imbyte*)image->data[0], (imushort*)NewImage->data[0], connect);
}
static imImage* iKernelCreate(int w, int h, int* data, const char* desc)
{
imImage* kernel = imImageCreate(w, h, IM_GRAY, IM_INT);
int* kernel_data = (int*)kernel->data[0];
memcpy(kernel_data, data, kernel->size);
imImageSetAttribute(kernel, "Description", IM_BYTE, -1, (void*)desc);
return kernel;
}
int imProcessGrayMorphDilate(const imImage* src_image, imImage* dst_image, int kernel_size)
{
imImage* kernel = imImageCreate(kernel_size, kernel_size, IM_GRAY, IM_INT);
imImageSetAttribute(kernel, "Description", IM_BYTE, -1, (void*)"Dilate");
// Kernel is all zeros
int ret = imProcessGrayMorphConvolve(src_image, dst_image, kernel, 1);
imImageDestroy(kernel);
return ret;
}
void* imImageGetOpenGLData(const imImage* image, int *format)
{
if (!imImageIsBitmap(image))
return NULL;
int transp_count;
imbyte* transp_index = (imbyte*)imImageGetAttribute(image, "TransparencyIndex", NULL, NULL);
imbyte* transp_map = (imbyte*)imImageGetAttribute(image, "TransparencyMap", NULL, &transp_count);
imbyte* transp_color = (imbyte*)imImageGetAttribute(image, "TransparencyColor", NULL, NULL);
int glformat;
switch(image->color_space)
{
case IM_MAP:
if (image->has_alpha || transp_map || transp_index)
glformat = GL_RGBA;
else
glformat = GL_RGB;
break;
case IM_RGB:
if (image->has_alpha || transp_color)
glformat = GL_RGBA;
else
glformat = GL_RGB;
break;
case IM_BINARY:
default: /* IM_GRAY */
if (image->has_alpha || transp_map || transp_index)
glformat = GL_LUMINANCE_ALPHA;
else
glformat = GL_LUMINANCE;
break;
}
int gldepth;
switch (glformat)
{
case GL_RGB:
gldepth = 3;
break;
case GL_RGBA:
gldepth = 4;
break;
case GL_LUMINANCE_ALPHA:
gldepth = 2;
break;
default: /* GL_LUMINANCE */
gldepth = 1;
break;
}
int size = image->count*gldepth;
imImageSetAttribute(image, "GLDATA", IM_BYTE, size, NULL);
imbyte* gldata = (imbyte*)imImageGetAttribute(image, "GLDATA", NULL, NULL);
int depth = image->depth;
if (image->has_alpha)
depth++;
/* copy data, including alpha */
if (image->color_space != IM_MAP)
{
imConvertPacking(image->data[0], gldata, image->width, image->height, depth, gldepth, IM_BYTE, 0);
if (image->color_space == IM_BINARY)
iImageMakeGray(gldata, gldepth, image->count);
}
else
{
/* copy map data */
memcpy(gldata, image->data[0], image->size); /* size does not include alpha */
/* expand MAP to RGB or RGBA */
imConvertMapToRGB(gldata, image->count, gldepth, 1, image->palette, image->palette_count);
if (image->has_alpha)
iImageGLCopyMapAlpha((imbyte*)image->data[1], gldata, gldepth, image->count); /* copy the alpha plane */
}
/* set alpha based on attributes */
if (!image->has_alpha)
{
if (image->color_space == IM_RGB)
{
if (transp_color)
iImageGLSetTranspColor(gldata, image->count, *(transp_color+0), *(transp_color+1), *(transp_color+2));
}
else
{
if (transp_map)
iImageGLSetTranspMap((imbyte*)image->data[0], gldata, image->count, transp_map, transp_count);
else if (transp_index)
iImageGLSetTranspIndex((imbyte*)image->data[0], gldata, gldepth, image->count, *transp_index);
}
}
if (format) *format = glformat;
return gldata;
}
/*****************************************************************************\
image:SetAttribute(attrib, data_type, 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_SHORT:
{
short *data_short = (short*) data;
for (i = 0; i < count; i++)
{
lua_rawgeti(L, 4, i+1);
data_short[i] = (short)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;
}
