Gecko [ nrupathungauniversityblr.ac.in ]

Name	Size	Permission
msinttypes	[ DIR ]	drwxr-xr-x
CMakeLists.txt	3.23 KB	-rwxr-xr-x
COPYING	2.25 KB	-rwxr-xr-x
Makefile.am	1.96 KB	-rwxr-xr-x
annotate.c	4.38 KB	-rwxr-xr-x
bdftogd	3.91 KB	-rwxr-xr-x
bmp.h	2.39 KB	-rwxr-xr-x
circletexttest.c	1.49 KB	-rwxr-xr-x
config.h.cmake	3.58 KB	-rwxr-xr-x
demoin.png	9.79 KB	-rwxr-xr-x
depcomp	11.84 KB	-rwxr-xr-x
entities.h	4.81 KB	-rwxr-xr-x
entities.html	41.11 KB	-rwxr-xr-x
entities.tcl	1.35 KB	-rwxr-xr-x
fontconfigtest.c	1.34 KB	-rwxr-xr-x
fontsizetest.c	2.3 KB	-rwxr-xr-x
fontwheeltest.c	3.23 KB	-rwxr-xr-x
gd.c	89.58 KB	-rwxr-xr-x
gd.h	50.14 KB	-rwxr-xr-x
gd2copypal.c	1.25 KB	-rwxr-xr-x
gd2time.c	1.19 KB	-rwxr-xr-x
gd2togif.c	939 B	-rwxr-xr-x
gd2topng.c	1.38 KB	-rwxr-xr-x
gd_bmp.c	25.78 KB	-rwxr-xr-x
gd_color.c	798 B	-rwxr-xr-x
gd_color.h	189 B	-rwxr-xr-x
gd_color_map.c	22.71 KB	-rwxr-xr-x
gd_color_map.h	478 B	-rwxr-xr-x
gd_color_map_test.c	570 B	-rwxr-xr-x
gd_color_match.c	1.49 KB	-rwxr-xr-x
gd_crop.c	5.75 KB	-rwxr-xr-x
gd_errors.h	1.47 KB	-rwxr-xr-x
gd_filename.c	6.41 KB	-rwxr-xr-x
gd_filter.c	21 KB	-rwxr-xr-x
gd_gd.c	7.1 KB	-rwxr-xr-x
gd_gd2.c	25.85 KB	-rwxr-xr-x
gd_gif_in.c	14.79 KB	-rwxr-xr-x
gd_gif_out.c	41 KB	-rwxr-xr-x
gd_intern.h	1.95 KB	-rwxr-xr-x
gd_interpolation.c	59.19 KB	-rwxr-xr-x
gd_io.c	3.42 KB	-rwxr-xr-x
gd_io.h	3.05 KB	-rwxr-xr-x
gd_io_dp.c	7.95 KB	-rwxr-xr-x
gd_io_file.c	2.41 KB	-rwxr-xr-x
gd_io_ss.c	2.66 KB	-rwxr-xr-x
gd_io_stream.cxx	4.11 KB	-rwxr-xr-x
gd_io_stream.h	3.63 KB	-rwxr-xr-x
gd_jpeg.c	34.5 KB	-rwxr-xr-x
gd_matrix.c	7.93 KB	-rwxr-xr-x
gd_nnquant.c	15 KB	-rwxr-xr-x
gd_nnquant.h	527 B	-rwxr-xr-x
gd_png.c	30.58 KB	-rwxr-xr-x
gd_rotate.c	12.25 KB	-rwxr-xr-x
gd_security.c	692 B	-rwxr-xr-x
gd_ss.c	1.27 KB	-rwxr-xr-x
gd_tga.c	8.61 KB	-rwxr-xr-x
gd_tga.h	1.66 KB	-rwxr-xr-x
gd_tiff.c	25.85 KB	-rwxr-xr-x
gd_topal.c	55.18 KB	-rwxr-xr-x
gd_transform.c	1.48 KB	-rwxr-xr-x
gd_version.c	827 B	-rwxr-xr-x
gd_wbmp.c	6.54 KB	-rwxr-xr-x
gd_webp.c	4.25 KB	-rwxr-xr-x
gd_xbm.c	5.68 KB	-rwxr-xr-x
gdcache.c	5.14 KB	-rwxr-xr-x
gdcache.h	2.83 KB	-rwxr-xr-x
gdcmpgif.c	1.86 KB	-rwxr-xr-x
gddemo.c	5.42 KB	-rwxr-xr-x
gdfontg.c	109.84 KB	-rwxr-xr-x
gdfontg.h	553 B	-rwxr-xr-x
gdfontl.c	104.83 KB	-rwxr-xr-x
gdfontl.h	551 B	-rwxr-xr-x
gdfontmb.c	76.33 KB	-rwxr-xr-x
gdfontmb.h	519 B	-rwxr-xr-x
gdfonts.c	66.55 KB	-rwxr-xr-x
gdfonts.h	515 B	-rwxr-xr-x
gdfontt.c	36.82 KB	-rwxr-xr-x
gdfontt.h	546 B	-rwxr-xr-x
gdft.c	49.23 KB	-rwxr-xr-x
gdfx.c	13.52 KB	-rwxr-xr-x
gdfx.h	2.34 KB	-rwxr-xr-x
gdhelpers.c	1.51 KB	-rwxr-xr-x
gdhelpers.h	2.31 KB	-rwxr-xr-x
gdkanji.c	11.97 KB	-rwxr-xr-x
gdparttopng.c	1.23 KB	-rwxr-xr-x
gdpp.cxx	6.43 KB	-rwxr-xr-x
gdpp.h	50.94 KB	-rwxr-xr-x
gdtables.c	4.67 KB	-rwxr-xr-x
gdtest.c	10.27 KB	-rwxr-xr-x
gdtestft.c	5.54 KB	-rwxr-xr-x
gdtopng.c	1.01 KB	-rwxr-xr-x
gdxpm.c	4.64 KB	-rwxr-xr-x
gifanimtest.c	682 B	-rwxr-xr-x
giftogd2.c	1.12 KB	-rwxr-xr-x
jisx0208.h	73.71 KB	-rwxr-xr-x
pngtogd.c	1.03 KB	-rwxr-xr-x
pngtogd2.c	1.23 KB	-rwxr-xr-x
snprintf.c	585 B	-rwxr-xr-x
testac.c	4.14 KB	-rwxr-xr-x
testtr.c	1.33 KB	-rwxr-xr-x
wbmp.c	6.18 KB	-rwxr-xr-x
wbmp.h	1.2 KB	-rwxr-xr-x
webpng.c	6.44 KB	-rwxr-xr-x

Code Editor : gdfx.c

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif /* HAVE_CONFIG_H */

#include "gd.h"
#include "gd_errors.h"
#include <math.h>

/* In tests this is sufficient to prevent obvious artifacts */
#define MAG 4

#define PI 3.141592
#define DEG2RAD(x) ((x)*PI/180.)

#define MAX(x,y) ((x) > (y) ? (x) : (y))
#define MIN(x,y) ((x) < (y) ? (x) : (y))

#define MAX4(x,y,z,w) \
	((MAX((x),(y))) > (MAX((z),(w))) ? (MAX((x),(y))) : (MAX((z),(w))))
#define MIN4(x,y,z,w) \
	((MIN((x),(y))) < (MIN((z),(w))) ? (MIN((x),(y))) : (MIN((z),(w))))

#define MAXX(x) MAX4(x[0],x[2],x[4],x[6])
#define MINX(x) MIN4(x[0],x[2],x[4],x[6])
#define MAXY(x) MAX4(x[1],x[3],x[5],x[7])
#define MINY(x) MIN4(x[1],x[3],x[5],x[7])

/*
	Function: gdImageStringFTCircle
*/
BGD_DECLARE(char *)
gdImageStringFTCircle (gdImagePtr im,
                       int cx,
                       int cy,
                       double radius,
                       double textRadius,
                       double fillPortion,
                       char *font,
                       double points, char *top, char *bottom, int fgcolor)
{
	char *err;
	int w;
	int brect[8];
	int sx1, sx2, sy1, sy2, sx, sy;
	int x, y;
	int fr, fg, fb, fa;
	int ox, oy;
	double prop;
	gdImagePtr im1;
	gdImagePtr im2;
	gdImagePtr im3;
	/* obtain brect so that we can size the image */
	err = gdImageStringFT ((gdImagePtr) NULL,
	                       &brect[0], 0, font, points * MAG, 0, 0, 0, bottom);
	if (err) {
		return err;
	}
	sx1 = MAXX (brect) - MINX (brect) + 6;
	sy1 = MAXY (brect) - MINY (brect) + 6;
	err = gdImageStringFT ((gdImagePtr) NULL,
	                       &brect[0], 0, font, points * MAG, 0, 0, 0, top);
	if (err) {
		return err;
	}
	sx2 = MAXX (brect) - MINX (brect) + 6;
	sy2 = MAXY (brect) - MINY (brect) + 6;
	/* Pad by 4 pixels to allow for slight errors
	   observed in the bounding box returned by freetype */
	if (sx1 > sx2) {
		sx = sx1 * 2 + 4;
	} else {
		sx = sx2 * 2 + 4;
	}
	if (sy1 > sy2) {
		sy = sy1;
	} else {
		sy = sy2;
	}
	im1 = gdImageCreateTrueColor (sx, sy);
	if (!im1) {
		return "could not create first image";
	}
	err = gdImageStringFT (im1, 0, gdTrueColor (255, 255, 255),
	                       font, points * MAG,
	                       0, ((sx / 2) - sx1) / 2, points * MAG, bottom);
	if (err) {
		gdImageDestroy (im1);
		return err;
	}
	/* We don't know the descent, which would be needed to do this
	   with the angle parameter. Instead, implement a simple
	   flip operation ourselves. */
	err = gdImageStringFT (im1, 0, gdTrueColor (255, 255, 255),
	                       font, points * MAG,
	                       0, sx / 2 + ((sx / 2) - sx2) / 2, points * MAG, top);
	if (err) {
		gdImageDestroy (im1);
		return err;
	}
	/* Flip in place is tricky, be careful not to double-swap things */
	if (sy & 1) {
		for (y = 0; (y <= (sy / 2)); y++) {
			int xlimit = sx - 2;
			if (y == (sy / 2)) {
				/* If there is a "middle" row, be careful
				   not to swap twice! */
				xlimit -= (sx / 4);
			}
			for (x = (sx / 2) + 2; (x < xlimit); x++) {
				int t;
				int ox = sx - x + (sx / 2) - 1;
				int oy = sy - y - 1;
				t = im1->tpixels[oy][ox];
				im1->tpixels[oy][ox] = im1->tpixels[y][x];
				im1->tpixels[y][x] = t;
			}
		}
	} else {
		for (y = 0; (y < (sy / 2)); y++) {
			int xlimit = sx - 2;
			for (x = (sx / 2) + 2; (x < xlimit); x++) {
				int t;
				int ox = sx - x + (sx / 2) - 1;
				int oy = sy - y - 1;
				t = im1->tpixels[oy][ox];
				im1->tpixels[oy][ox] = im1->tpixels[y][x];
				im1->tpixels[y][x] = t;
			}
		}
	}
#if STEP_PNGS
	{
		FILE *out = fopen ("gdfx1.png", "wb");
		gdImagePng (im1, out);
		fclose (out);
	}
#endif /* STEP_PNGS */
	/* Resample taller; the exact proportions of the text depend on the
	   ratio of textRadius to radius, and the value of fillPortion */
	if (sx > sy * 10) {
		w = sx;
	} else {
		w = sy * 10;
	}
	im2 = gdImageCreateTrueColor (w, w);
	if (!im2) {
		gdImageDestroy (im1);
		return "could not create resampled image";
	}
	prop = textRadius / radius;
	gdImageCopyResampled (im2, im1,
	                      gdImageSX (im2) * (1.0 - fillPortion) / 4,
	                      sy * 10 * (1.0 - prop),
	                      0, 0,
	                      gdImageSX (im2) * fillPortion / 2, sy * 10 * prop,
	                      gdImageSX (im1) / 2, gdImageSY (im1));
	gdImageCopyResampled (im2, im1,
	                      (gdImageSX (im2) / 2) +
	                      gdImageSX (im2) * (1.0 - fillPortion) / 4,
	                      sy * 10 * (1.0 - prop),
	                      gdImageSX (im1) / 2, 0,
	                      gdImageSX (im2) * fillPortion / 2, sy * 10 * prop,
	                      gdImageSX (im1) / 2, gdImageSY (im1));
#if STEP_PNGS
	{
		FILE *out = fopen ("gdfx2.png", "wb");
		gdImagePng (im2, out);
		fclose (out);
	}
#endif /* STEP_PNGS */

gdImageDestroy (im1);

/* Ready to produce a circle */
	im3 = gdImageSquareToCircle (im2, radius);
	if (im3 == NULL) {
		gdImageDestroy(im2);
		return 0;
	}
	gdImageDestroy (im2);
	/* Now blend im3 with the destination. Cheat a little. The
	   source (im3) is white-on-black, so we can use the
	   red component as a basis for alpha as long as we're
	   careful to shift off the extra bit and invert
	   (alpha ranges from 0 to 127 where 0 is OPAQUE).
	   Also be careful to allow for an alpha component
	   in the fgcolor parameter itself (gug!) */
	fr = gdTrueColorGetRed (fgcolor);
	fg = gdTrueColorGetGreen (fgcolor);
	fb = gdTrueColorGetBlue (fgcolor);
	fa = gdTrueColorGetAlpha (fgcolor);
	ox = cx - (im3->sx / 2);
	oy = cy - (im3->sy / 2);
	for (y = 0; (y < im3->sy); y++) {
		for (x = 0; (x < im3->sx); x++) {
			int a = gdTrueColorGetRed (im3->tpixels[y][x]) >> 1;
			a *= (127 - fa);
			a /= 127;
			a = 127 - a;
			gdImageSetPixel (im, x + ox, y + oy,
			                 gdTrueColorAlpha (fr, fg, fb, a));
		}
	}
	gdImageDestroy (im3);
	return 0;
}

#if GDFX_MAIN

int
main (int argc, char *argv[])
{
	FILE *in;
	FILE *out;
	gdImagePtr im;
	int radius;
	/* Create an image of text on a circle, with an
	   alpha channel so that we can copy it onto a
	   background */
	in = fopen ("eleanor.jpg", "rb");
	if (!in) {
		im = gdImageCreateTrueColor (300, 300);
	} else {
		im = gdImageCreateFromJpeg (in);
		fclose (in);
	}
	if (gdImageSX (im) < gdImageSY (im)) {
		radius = gdImageSX (im) / 2;
	} else {
		radius = gdImageSY (im) / 2;
	}
	gdImageStringFTCircle (im,
	                       gdImageSX (im) / 2,
	                       gdImageSY (im) / 2,
	                       radius,
	                       radius / 2,
	                       0.8,
	                       "arial",
	                       24,
	                       "top text",
	                       "bottom text", gdTrueColorAlpha (240, 240, 255, 32));
	out = fopen ("gdfx.png", "wb");
	if (!out) {
		gd_error("Can't create gdfx.png\n");
		return 1;
	}
	gdImagePng (im, out);
	fclose (out);
	gdImageDestroy (im);
	return 0;
}

#endif /* GDFX_MAIN */

/* Note: don't change these */
#define SUPER 2
#define SUPERBITS1 1
#define SUPERBITS2 2

/*
	Function: gdImageSquareToCircle
*/
BGD_DECLARE(gdImagePtr)
gdImageSquareToCircle (gdImagePtr im, int radius)
{
	int x, y;
	double c;
	gdImagePtr im2;
	if (im->sx != im->sy) {
		/* Source image must be square */
		return 0;
	}
	im2 = gdImageCreateTrueColor (radius * 2, radius * 2);
	if (!im2) {
		return 0;
	}
	/* Supersampling for a nicer result */
	c = (im2->sx / 2) * SUPER;
	for (y = 0; (y < im2->sy * SUPER); y++) {
		for (x = 0; (x < im2->sx * SUPER); x++) {
			double rho = sqrt ((x - c) * (x - c) + (y - c) * (y - c));
			int pix;
			int cpix;
			double theta;
			double ox;
			double oy;
			int red, green, blue, alpha;
			if (rho > c) {
				continue;
			}
			theta = atan2 (x - c, y - c) + PI / 2;
			if (theta < 0) {
				theta += 2 * PI;
			}
			/* Undo supersampling */
			oy = (rho * im->sx) / (im2->sx * SUPER / 2);
			ox = theta * im->sx / (3.141592653 * 2);
			pix = gdImageGetPixel (im, ox, oy);
			cpix = im2->tpixels[y >> SUPERBITS1][x >> SUPERBITS1];
			red =
			    (gdImageRed (im, pix) >> SUPERBITS2) + gdTrueColorGetRed (cpix);
			green =
			    (gdImageGreen (im, pix) >> SUPERBITS2) +
			    gdTrueColorGetGreen (cpix);
			blue =
			    (gdImageBlue (im, pix) >> SUPERBITS2) + gdTrueColorGetBlue (cpix);
			alpha =
			    (gdImageAlpha (im, pix) >> SUPERBITS2) +
			    gdTrueColorGetAlpha (cpix);
			im2->tpixels[y >> SUPERBITS1][x >> SUPERBITS1] =
			    gdTrueColorAlpha (red, green, blue, alpha);
		}
	}
	/* Restore full dynamic range, 0-63 yields 0-252. Replication of
	   first 2 bits in last 2 bits has the desired effect. Note
	   slightly different arithmetic for alpha which is 7-bit.
	   NOTE: only correct for SUPER == 2 */
	for (y = 0; (y < im2->sy); y++) {
		for (x = 0; (x < im2->sx); x++) {
			/* Copy first 2 bits to last 2 bits, matching the
			   dynamic range of the original cheaply */
			int cpix = im2->tpixels[y][x];

im2->tpixels[y][x] = gdTrueColorAlpha ((gdTrueColorGetRed (cpix) &
			                                        0xFC) +
			                                       ((gdTrueColorGetRed (cpix) &
			                                               0xC0) >> 6),
			                                       (gdTrueColorGetGreen (cpix) &
			                                        0xFC) +
			                                       ((gdTrueColorGetGreen (cpix)
			                                               & 0xC0) >> 6),
			                                       (gdTrueColorGetBlue (cpix) &
			                                        0xFC) +
			                                       ((gdTrueColorGetBlue (cpix) &
			                                               0xC0) >> 6),
			                                       (gdTrueColorGetAlpha (cpix) &
			                                        0x7C) +
			                                       ((gdTrueColorGetAlpha (cpix)
			                                               & 0x60) >> 6));
		}
	}
	return im2;
}

/* 2.0.16: Called by gdImageSharpen to avoid excessive code repetition
    Added on 2003-11-19 by
    Paul Troughton (paul<dot>troughton<at>ieee<dot>org)
    Given filter coefficents and colours of three adjacent pixels,
returns new colour for centre pixel
*/

int
gdImageSubSharpen (int pc, int c, int nc, float inner_coeff, float
                   outer_coeff)
{
	float red, green, blue, alpha;

red = inner_coeff * gdTrueColorGetRed (c) + outer_coeff *
	      (gdTrueColorGetRed (pc) + gdTrueColorGetRed (nc));
	green = inner_coeff * gdTrueColorGetGreen (c) + outer_coeff *
	        (gdTrueColorGetGreen (pc) + gdTrueColorGetGreen (nc));
	blue = inner_coeff * gdTrueColorGetBlue (c) + outer_coeff *
	       (gdTrueColorGetBlue (pc) + gdTrueColorGetBlue (nc));
	alpha = gdTrueColorGetAlpha (c);

/* Clamping, as can overshoot bounds in either direction */
	if (red > 255.0f) {
		red = 255.0f;
	}
	if (green > 255.0f) {
		green = 255.0f;
	}
	if (blue > 255.0f) {
		blue = 255.0f;
	}
	if (red < 0.0f) {
		red = 0.0f;
	}
	if (green < 0.0f) {
		green = 0.0f;
	}
	if (blue < 0.0f) {
		blue = 0.0f;
	}

return gdTrueColorAlpha ((int) red, (int) green, (int) blue, (int) alpha);
}

/*
	Function: gdImageSharpen

Sharpen function added on 2003-11-19
	by Paul Troughton (paul<dot>troughton<at>ieee<dot>org)
	Simple 3x3 convolution kernel
	Makes use of seperability
	Faster, but less flexible, than full-blown unsharp masking
	pct is sharpening percentage, and can be greater than 100
	Silently does nothing to non-truecolor images
	Silently does nothing for pct<0, as not a useful blurring function
	Leaves transparency/alpha-channel untouched
*/
BGD_DECLARE(void)
gdImageSharpen (gdImagePtr im, int pct)
{
	int x, y;
	int sx, sy;
	float inner_coeff, outer_coeff;

sx = im->sx;
	sy = im->sy;

/* Must sum to 1 to avoid overall change in brightness.
	 * Scaling chosen so that pct=100 gives 1-D filter [-1 6 -1]/4,
	 * resulting in a 2-D filter [1 -6 1; -6 36 -6; 1 -6 1]/16,
	 * which gives noticeable, but not excessive, sharpening
	 */

outer_coeff = -pct / 400.0;
	inner_coeff = 1 - 2 * outer_coeff;

/* Don't try to do anything with non-truecolor images, as
	   pointless,
	   * nor for pct<=0, as small kernel size leads to nasty
	   artefacts when blurring
	 */
	if ((im->trueColor) && (pct > 0)) {

/* First pass, 1-D convolution column-wise */
		for (x = 0; x < sx; x++) {

/* pc is colour of previous pixel; c of the
			   current pixel and nc of the next */
			int pc, c, nc;

/* Replicate edge pixel at image boundary */
			pc = gdImageGetPixel (im, x, 0);

/* Stop looping before last pixel to avoid
			   conditional within loop */
			for (y = 0; y < sy - 1; y++) {

c = gdImageGetPixel (im, x, y);

nc = gdImageGetTrueColorPixel (im, x, y + 1);

/* Update centre pixel to new colour */
				gdImageSetPixel (im, x, y,
				                 gdImageSubSharpen (pc, c, nc, inner_coeff,
				                                    outer_coeff));

/* Save original colour of current
				   pixel for next time round */
				pc = c;
			}

/* Deal with last pixel, replicating current
			   pixel at image boundary */
			c = gdImageGetPixel (im, x, y);
			gdImageSetPixel (im, x, y, gdImageSubSharpen
			                 (pc, c, c, inner_coeff, outer_coeff));
		}

/* Second pass, 1-D convolution row-wise */
		for (y = 0; y < sy; y++) {
			int pc, c;
			pc = gdImageGetPixel (im, 0, y);
			for (x = 0; x < sx - 1; x++) {
				int c, nc;
				c = gdImageGetPixel (im, x, y);
				nc = gdImageGetTrueColorPixel (im, x + 1, y);
				gdImageSetPixel (im, x, y,
				                 gdImageSubSharpen (pc, c, nc, inner_coeff,
				                                    outer_coeff));
				pc = c;
			}
			c = gdImageGetPixel (im, x, y);
			gdImageSetPixel (im, x, y, gdImageSubSharpen
			                 (pc, c, c, inner_coeff, outer_coeff));
		}
	}
}

${this.title}

Code Editor : gdfx.c