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); }