static int gdColorMatch(gdImagePtr im, int col1, int col2, float threshold)
{
const int dr = gdImageRed(im, col1) - gdImageRed(im, col2);
const int dg = gdImageGreen(im, col1) - gdImageGreen(im, col2);
const int db = gdImageBlue(im, col1) - gdImageBlue(im, col2);
const int da = gdImageAlpha(im, col1) - gdImageAlpha(im, col2);
const double dist = sqrt(dr * dr + dg * dg + db * db + da * da);
const double dist_perc = sqrt(dist / (255^2 + 255^2 + 255^2));
return (dist_perc <= threshold);
//return (100.0 * dist / 195075) < threshold;
}
BGD_DECLARE(int) gdImagePixelate(gdImagePtr im, int block_size, const unsigned int mode)
{
int x, y;
if (block_size <= 0) {
return 0;
} else if (block_size == 1) {
return 1;
}
switch (mode) {
case GD_PIXELATE_UPPERLEFT:
for (y = 0; y < im->sy; y += block_size) {
for (x = 0; x < im->sx; x += block_size) {
if (gdImageBoundsSafe(im, x, y)) {
int c = gdImageGetPixel(im, x, y);
gdImageFilledRectangle(im, x, y, x + block_size - 1, y + block_size - 1, c);
}
}
}
break;
case GD_PIXELATE_AVERAGE:
for (y = 0; y < im->sy; y += block_size) {
for (x = 0; x < im->sx; x += block_size) {
int a, r, g, b, c;
int total;
int cx, cy;
a = r = g = b = c = total = 0;
/* sampling */
for (cy = 0; cy < block_size; cy++) {
for (cx = 0; cx < block_size; cx++) {
if (!gdImageBoundsSafe(im, x + cx, y + cy)) {
continue;
}
c = gdImageGetPixel(im, x + cx, y + cy);
a += gdImageAlpha(im, c);
r += gdImageRed(im, c);
g += gdImageGreen(im, c);
b += gdImageBlue(im, c);
total++;
}
}
/* drawing */
if (total > 0) {
c = gdImageColorResolveAlpha(im, r / total, g / total, b / total, a / total);
gdImageFilledRectangle(im, x, y, x + block_size - 1, y + block_size - 1, c);
}
}
}
break;
default:
return 0;
}
return 1;
}
/* This algorithm comes from pnmcrop (http://netpbm.sourceforge.net/)
* Three steps:
* - if 3 corners are equal.
* - if two are equal.
* - Last solution: average the colors
*/
static int gdGuessBackgroundColorFromCorners(gdImagePtr im, int *color)
{
const int tl = gdImageGetPixel(im, 0, 0);
const int tr = gdImageGetPixel(im, gdImageSX(im) - 1, 0);
const int bl = gdImageGetPixel(im, 0, gdImageSY(im) -1);
const int br = gdImageGetPixel(im, gdImageSX(im) - 1, gdImageSY(im) -1);
if (tr == bl && tr == br) {
*color = tr;
return 3;
} else if (tl == bl && tl == br) {
*color = tl;
return 3;
} else if (tl == tr && tl == br) {
*color = tl;
return 3;
} else if (tl == tr && tl == bl) {
*color = tl;
return 3;
} else if (tl == tr || tl == bl || tl == br) {
*color = tl;
return 2;
} else if (tr == bl || tr == br) {
*color = tr;
return 2;
} else if (br == bl) {
*color = bl;
return 2;
} else {
register int r,b,g,a;
r = (int)(0.5f + (gdImageRed(im, tl) + gdImageRed(im, tr) + gdImageRed(im, bl) + gdImageRed(im, br)) / 4);
g = (int)(0.5f + (gdImageGreen(im, tl) + gdImageGreen(im, tr) + gdImageGreen(im, bl) + gdImageGreen(im, br)) / 4);
b = (int)(0.5f + (gdImageBlue(im, tl) + gdImageBlue(im, tr) + gdImageBlue(im, bl) + gdImageBlue(im, br)) / 4);
a = (int)(0.5f + (gdImageAlpha(im, tl) + gdImageAlpha(im, tr) + gdImageAlpha(im, bl) + gdImageAlpha(im, br)) / 4);
*color = gdImageColorClosestAlpha(im, r, g, b, a);
return 0;
}
}
/* tiffWriter
* ----------
* Write the gd image as a tiff file (called by gdImageTiffCtx)
* Parameters are:
* image: gd image structure;
* out: the stream where to write
* bitDepth: depth in bits of each pixel
*/
BGD_DECLARE(void) tiffWriter(gdImagePtr image, gdIOCtx *out, int bitDepth)
{
int x, y;
int i;
int r, g, b, a;
TIFF *tiff;
int width, height;
int color;
char *scan;
int samplesPerPixel = 3;
int bitsPerSample;
int transparentColorR = -1;
int transparentColorG = -1;
int transparentColorB = -1;
uint16 extraSamples[1];
uint16 *colorMapRed = 0;
uint16 *colorMapGreen = 0;
uint16 *colorMapBlue = 0;
tiff_handle *th;
th = new_tiff_handle(out);
if (!th) {
return;
}
extraSamples[0] = EXTRASAMPLE_ASSOCALPHA;
/* read in the width/height of gd image */
width = gdImageSX(image);
height = gdImageSY(image);
/* reset clip region to whole image */
gdImageSetClip(image, 0, 0, width, height);
/* handle old-style single-colour mapping to 100% transparency */
if(image->transparent != 0xffffffff) {
/* set our 100% transparent colour value */
transparentColorR = gdImageRed(image, image->transparent);
transparentColorG = gdImageGreen(image, image->transparent);
transparentColorB = gdImageBlue(image, image->transparent);
}
/* Open tiff file writing routines, but use special read/write/seek
* functions so that tiff lib writes correct bits of tiff content to
* correct areas of file opened and modifieable by the gdIOCtx functions
*/
tiff = TIFFClientOpen("", "w", th, tiff_readproc,
tiff_writeproc,
tiff_seekproc,
tiff_closeproc,
tiff_sizeproc,
tiff_mapproc,
tiff_unmapproc);
TIFFSetField(tiff, TIFFTAG_IMAGEWIDTH, width);
TIFFSetField(tiff, TIFFTAG_IMAGELENGTH, height);
TIFFSetField(tiff, TIFFTAG_COMPRESSION, COMPRESSION_DEFLATE);
TIFFSetField(tiff, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
TIFFSetField(tiff, TIFFTAG_PHOTOMETRIC,
(bitDepth == 24) ? PHOTOMETRIC_RGB : PHOTOMETRIC_PALETTE);
bitsPerSample = (bitDepth == 24 || bitDepth == 8) ? 8 : 1;
TIFFSetField(tiff, TIFFTAG_BITSPERSAMPLE, bitsPerSample);
/* build the color map for 8 bit images */
if(bitDepth != 24) {
colorMapRed = (uint16 *) gdMalloc(3 * (1 << bitsPerSample));
if (!colorMapRed) {
return;
}
colorMapGreen = (uint16 *) gdMalloc(3 * (1 << bitsPerSample));
if (!colorMapGreen) {
return;
}
colorMapBlue = (uint16 *) gdMalloc(3 * (1 << bitsPerSample));
if (!colorMapBlue) {
return;
}
for(i = 0; i < image->colorsTotal; i++) {
colorMapRed[i] = gdImageRed(image,i) + (gdImageRed(image,i) * 256);
colorMapGreen[i] = gdImageGreen(image,i)+(gdImageGreen(image,i)*256);
colorMapBlue[i] = gdImageBlue(image,i) + (gdImageBlue(image,i)*256);
}
TIFFSetField(tiff, TIFFTAG_COLORMAP, colorMapRed, colorMapGreen,
colorMapBlue);
samplesPerPixel = 1;
}
/* here, we check if the 'save alpha' flag is set on the source gd image */
if( (bitDepth == 24) &&
(image->saveAlphaFlag || image->transparent != 0xffffffff)) {
/* so, we need to store the alpha values too!
* Also, tell TIFF what the extra sample means (associated alpha) */
samplesPerPixel = 4;
TIFFSetField(tiff, TIFFTAG_SAMPLESPERPIXEL, samplesPerPixel);
TIFFSetField(tiff, TIFFTAG_EXTRASAMPLES, 1, extraSamples);
} else {
TIFFSetField(tiff, TIFFTAG_SAMPLESPERPIXEL, samplesPerPixel);
}
TIFFSetField(tiff, TIFFTAG_ROWSPERSTRIP, 1);
if(overflow2(width, samplesPerPixel)) {
return;
}
if(!(scan = (char *)gdMalloc(width * samplesPerPixel))) {
return;
}
/* loop through y-coords, and x-coords */
for(y = 0; y < height; y++) {
for(x = 0; x < width; x++) {
/* generate scan line for writing to tiff */
color = gdImageGetPixel(image, x, y);
a = (127 - gdImageAlpha(image, color)) * 2;
a = (a == 0xfe) ? 0xff : a & 0xff;
b = gdImageBlue(image, color);
g = gdImageGreen(image, color);
r = gdImageRed(image, color);
/* if this pixel has the same RGB as the transparent colour,
* then set alpha fully transparent */
if( transparentColorR == r &&
transparentColorG == g &&
transparentColorB == b
) {
a = 0x00;
}
if(bitDepth != 24) {
/* write out 1 or 8 bit value in 1 byte
* (currently treats 1bit as 8bit) */
scan[(x * samplesPerPixel) + 0] = color;
} else {
/* write out 24 bit value in 3 (or 4 if transparent) bytes */
if(image->saveAlphaFlag || image->transparent != 0xffffffff) {
scan[(x * samplesPerPixel) + 3] = a;
}
scan[(x * samplesPerPixel) + 2] = b;
scan[(x * samplesPerPixel) + 1] = g;
scan[(x * samplesPerPixel) + 0] = r;
}
}
/* Write the scan line to the tiff */
if(TIFFWriteEncodedStrip(tiff, y, scan, width * samplesPerPixel) == -1){
/* error handler here */
fprintf(stderr, "Could not create TIFF\n");
return;
}
}
/* now cloase and free up resources */
TIFFClose(tiff);
gdFree(scan);
gdFree(th);
if(bitDepth != 24) {
gdFree(colorMapRed);
gdFree(colorMapGreen);
gdFree(colorMapBlue);
}
}
static EF_Error ef_internal_video_load_texture_gd_image(gdImage *image,
GLuint id,
int build_mipmaps)
{
GLint pixel_format;
GLint component_format;
GLsizei size;
uint8_t *data;
int width = gdImageSX(image);
int height = gdImageSY(image);
int widthLog2 = ceil(log2(width));
int heightLog2 = ceil(log2(height));
int sizeLog2 = widthLog2 > heightLog2 ? widthLog2 : heightLog2;
size = 1;
for(int i = 0; i < sizeLog2; i++)
size *= 2;
pixel_format = GL_RGBA;
component_format = GL_UNSIGNED_BYTE;
data = malloc(size*size*4);
for(int y = 0; y < size; y++) {
for(int x = 0; x < size; x++) {
if((y < height) && (x < width)) {
int color = gdImageGetPixel(image, x, y);
data[(x + y*size)*4] = gdImageRed(image, color);
data[(x + y*size)*4+1] = gdImageGreen(image, color);
data[(x + y*size)*4+2] = gdImageBlue(image, color);
int alpha = (127 - gdImageAlpha(image, color)) * 2;
data[(x + y*size)*4+3] = alpha;
} else {
data[(x + y*size)*4] = 0x00;
data[(x + y*size)*4+1] = 0x00;
data[(x + y*size)*4+2] = 0x00;
data[(x + y*size)*4+3] = 0x00;
}
}
}
glBindTexture(GL_TEXTURE_2D, id);
glPixelStorei(GL_UNPACK_ROW_LENGTH, size);
glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, size);
if(build_mipmaps) {
gluBuild2DMipmaps(GL_TEXTURE_2D,
pixel_format,
size, size,
pixel_format,
component_format,
data);
} else {
glTexImage2D(GL_TEXTURE_2D,
0,
pixel_format,
size, size,
0,
pixel_format,
component_format,
data);
}
free(data);
glBindTexture(GL_TEXTURE_2D, 0);
}
