pixbufutils 0.0.3 → 0.0.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1ba2ec614619680bd44bf1e4c122ba3b8dc1c830
+  data.tar.gz: 41112646a90c2c68aa2f2f8da9750732e83130d5
+SHA512:
+  metadata.gz: 524e1a045190ed226aa85f41e72051e509cc9dbc7d6d60004f0e6ff3c90cc7d204648eef0887a604c5e415a90e45e6172d5ff040b619dcc26a74047212d1cd66
+  data.tar.gz: dd0d72083538fd27eb43d72a391420b61bc3c3b00bc62a3181bd29b18f959e47f55c21a21e9a9de9401ec0fa45e71dd20dc29a07883f6548f930158b3fac7b86

data/Rakefile

@@ -22,7 +22,7 @@ spec = Gem::Specification.new do |s|
 	s.name = "pixbufutils"
 	s.author = "Geoff Youngs"
 	s.email = "git@intersect-uk.co.uk"
-	s.version = "0.0.3"
+	s.version = "0.0.4"
 	s.homepage = "http://github.com/geoffyoungs/pixbufutils"
 	s.summary = "Additional utils for Gdk::Pixbuf"
 	s.add_dependency("rubber-generate", ">= 0.0.17")

data/ext/pixbufutils/auto-equalize.h

@@ -0,0 +1,102 @@
+// Auto-equalize stuff here...
+//
+
+static long **
+get_cumulative (histogram *data)
+{
+	long **cumulative;
+	int    i, v;
+
+	cumulative = ALLOC_N(long *, N_CHANNELS);
+	for (i = 0; i < N_CHANNELS; i++) {
+		int s;
+
+		cumulative[i] = ALLOC_N(long, 256);
+		s = 0;
+		for (v = 0; v < 256; v++) {
+			s += data->values[i][v];
+			cumulative[i][v] = s;
+		}
+	}
+
+	return cumulative;
+}
+
+
+static void
+free_cumulative (long **cumulative)
+{
+	int i;
+	for (i = 0; i <  N_CHANNELS; i++)
+		free(cumulative[i]);
+
+	free(cumulative);
+}
+
+
+static GdkPixbuf *
+auto_equalize(GdkPixbuf *src, GdkPixbuf *dest)
+{
+	int        s_has_alpha, d_has_alpha;
+	int        s_width, s_height, s_rowstride;
+	guchar    *s_pix, *sp;
+	int        i, j, n_channels, r, g, b, a;
+  histogram *data;
+  long    ** cumulative = NULL;
+  double     factor;
+
+
+	int        d_width, d_height, d_rowstride;
+  guchar    *d_pix, *dp;
+
+	g_return_val_if_fail(src != NULL, NULL);
+
+	s_width = gdk_pixbuf_get_width(src);
+	s_height = gdk_pixbuf_get_height(src);
+	s_has_alpha = gdk_pixbuf_get_has_alpha(src);
+	s_rowstride = gdk_pixbuf_get_rowstride(src);
+	s_pix = gdk_pixbuf_get_pixels(src);
+  n_channels = s_has_alpha ? 4 : 3;
+
+  d_width = gdk_pixbuf_get_width(dest);
+	d_height = gdk_pixbuf_get_height(dest);
+	d_has_alpha = gdk_pixbuf_get_has_alpha(dest);
+	d_rowstride = gdk_pixbuf_get_rowstride(dest);
+	d_pix = gdk_pixbuf_get_pixels(dest);
+
+	g_return_val_if_fail(d_width == s_width, NULL);
+	g_return_val_if_fail(d_height == s_height, NULL);
+	g_return_val_if_fail(d_has_alpha == s_has_alpha, NULL);
+
+  data = histogram_from_pixbuf(src);
+  cumulative = get_cumulative(data);
+  factor = 255.0/(s_width * s_height);
+
+	for (i = 0; i < s_height; i++) {
+		sp = s_pix + (i * s_rowstride);
+		dp = d_pix + (i * d_rowstride);
+
+		for (j = 0; j < s_width; j++) {
+      r = *sp++;
+      g = *sp++;
+      b = *sp++;
+      if (s_has_alpha) {
+        a = *sp++;
+      }
+      /*fprintf(stderr, "r=%i,g=%i,b=%i -> count %li %li %li -- ", r, g, b, data->values[CHAN_RED][r], data->values[CHAN_GREEN][g], data->values[CHAN_BLUE][b]);
+      fprintf(stderr, "r=%i,g=%i,b=%i -> cumulative %li %li %li \n", r, g, b, cumulative[CHAN_RED][r], cumulative[CHAN_GREEN][g], cumulative[CHAN_BLUE][b]);*/
+      *dp ++ = (unsigned char)((double)cumulative[CHAN_RED][r] * factor);
+      *dp ++ = (unsigned char)((double)cumulative[CHAN_GREEN][g] * factor);
+      *dp ++ = (unsigned char)((double)cumulative[CHAN_BLUE][b] * factor);
+      if (s_has_alpha) {
+        *dp ++ = (unsigned char)((double)cumulative[CHAN_ALPHA][a] * factor);
+      }
+    }
+  }
+
+  free_cumulative(cumulative);
+  free_histogram(data);
+
+  return dest;
+}
+

data/ext/pixbufutils/blend5050.h

@@ -0,0 +1,63 @@
+static GdkPixbuf *pixbuf_blend5050(GdkPixbuf *src1, GdkPixbuf *src2)
+{
+	int        s1_has_alpha, s2_has_alpha;
+	int        s1_width, s1_height, s1_rowstride;
+	int        d_width, d_height, d_rowstride;
+	int        s2_width, s2_height, s2_rowstride;
+	guchar    *s1_pix, *sp;
+        guchar    *d_pix, *dp;
+        guchar    *s2_pix, *mp;
+	int        i, j;
+	GdkPixbuf *dest;
+
+	g_return_val_if_fail(src1 != NULL, NULL);
+
+	s1_width      = gdk_pixbuf_get_width(src1);
+	s1_height     = gdk_pixbuf_get_height(src1);
+	s1_has_alpha  = gdk_pixbuf_get_has_alpha(src1);
+	s1_rowstride  = gdk_pixbuf_get_rowstride(src1);
+	s1_pix        = gdk_pixbuf_get_pixels(src1);
+
+	g_return_val_if_fail(src2 != NULL, NULL);
+
+	s2_width      = gdk_pixbuf_get_width(src2);
+	s2_height     = gdk_pixbuf_get_height(src2);
+	s2_has_alpha  = gdk_pixbuf_get_has_alpha(src2);
+	s2_rowstride  = gdk_pixbuf_get_rowstride(src2);
+	s2_pix        = gdk_pixbuf_get_pixels(src2);
+
+	g_return_val_if_fail(s2_width     == s1_width,     NULL);
+	g_return_val_if_fail(s2_height    == s1_height,    NULL);
+	g_return_val_if_fail(s2_has_alpha == s1_has_alpha, NULL);
+
+	d_width       = s2_width;
+	d_height      = s2_height;
+
+	dest = gdk_pixbuf_new(GDK_COLORSPACE_RGB, TRUE, 8, d_width, d_height);
+
+	g_return_val_if_fail(dest != NULL, NULL);
+
+	d_rowstride   = gdk_pixbuf_get_rowstride(dest);
+	d_pix         = gdk_pixbuf_get_pixels(dest);
+
+	for (i = 0; i < s2_height; i++) {
+		sp = s1_pix + (i * s1_rowstride);
+		mp = s2_pix + (i * s2_rowstride);
+		dp = d_pix  + (i * d_rowstride);
+
+		for (j = 0; j < s2_width; j++) {
+			*(dp++) = ((*(sp++)) >> 1) + ((*(mp++)) >> 1);	/* red   */
+			*(dp++) = ((*(sp++)) >> 1) + ((*(mp++)) >> 1);	/* green */
+			*(dp++) = ((*(sp++)) >> 1) + ((*(mp++)) >> 1);	/* blue  */
+
+			if (s1_has_alpha)
+				*(dp++) = ((*(sp++)) >> 1) + ((*(mp++)) >> 1);	/* alpha */
+			else
+				*(dp++) = 0xff;					/* alpha */
+
+		}
+	}
+
+	return dest;
+}
+

data/ext/pixbufutils/blur.h

@@ -0,0 +1,358 @@
+static GdkPixbuf *
+pixbuf_blur(GdkPixbuf *src, gint radius)
+{
+	/* Pixels and Rowstride To Perform Blur On */
+	guchar *pixels;
+	GdkPixbuf *pixbuf;
+	gint rowstride, width, height;
+
+	pixbuf = gdk_pixbuf_copy(src);
+
+	/* Get Pixels and Rowstride Of Image Buffer */
+	if (pixbuf)
+	{
+		pixels = gdk_pixbuf_get_pixels (pixbuf);
+		rowstride = gdk_pixbuf_get_rowstride (pixbuf);
+		width = gdk_pixbuf_get_width(pixbuf);
+		height = gdk_pixbuf_get_height(pixbuf);
+		/*printf("%i, %i, %i, %i\n", rowstride, width, height, rowstride/width);*/
+	}
+	else
+	{
+		return NULL;
+	}
+	if (radius > 1)
+	{
+		/* Some Important Consts */
+		gint bytes = rowstride/width;
+		gboolean alpha = (bytes == 4);
+
+		gint div = radius+radius+1;
+		gint divsum = ((div+1)>>1)*((div+1)>>1);
+		gint dv[256*divsum]; /* Table of Const RGBA Values */
+
+		/* Some Important Variables */
+		guchar stack[div][bytes];
+		gint stackpointer;
+		gint stackstart;
+		gint vmin[MAX(width,height)];
+		guchar *sir;
+		gint rbs;
+
+		gint current = 0;
+
+		/* RGBA Sums
+			0 - Sum of Incoming pixels(the radius pixels above the Center/to left of Center)
+			1 - Sum of Outgoing pixels(the Center and the radius pixels below the Center/to right of Center)
+			2 - Sum of All pixels within radius
+		*/
+		gint rgba_sums[3][bytes];
+
+		/* RGBA Values */
+		guchar rgba[bytes][width*height];
+
+		/* Temp Indexes/Counters */
+		gint x, y, i, p, yp, yi=0, yw=0;
+
+		for (i=0; i<256*divsum; i++)
+		{
+			dv[i] = (i/divsum);
+		}
+
+		for (y=0; y < height; y++)
+		{
+			/* initialize sums to zero */
+			for (i = 0; i<bytes; i++)
+			{
+				rgba_sums[0][i] = 0;
+				rgba_sums[1][i] = 0;
+				rgba_sums[2][i] = 0;
+			}
+
+			/* Calculate Initial Sums For radius */
+			for(i=-radius; i<=radius; i++)
+			{
+				current = (yi + MIN(width - 1, MAX(i,0)))*bytes;
+
+				sir = stack[i+radius];
+
+				sir[0] = pixels[current + 0];
+				sir[1] = pixels[current + 1];
+				sir[2] = pixels[current + 2];
+				sir[3] = pixels[current + 3];
+
+				rbs = (radius + 1) - abs(i);
+
+				rgba_sums[2][0] += sir[0]*rbs;
+				rgba_sums[2][1] += sir[1]*rbs;
+				rgba_sums[2][2] += sir[2]*rbs;
+				if (alpha)
+				{
+					rgba_sums[2][3] += sir[3]*rbs;
+				}
+
+				if (i>0)
+				{
+					rgba_sums[0][0] += sir[0];
+					rgba_sums[0][1] += sir[1];
+					rgba_sums[0][2] += sir[2];
+					if (alpha)
+					{
+						rgba_sums[0][3] += sir[3];
+					}
+				}
+				else
+				{
+					rgba_sums[1][0] += sir[0];
+					rgba_sums[1][1] += sir[1];
+					rgba_sums[1][2] += sir[2];
+					if (alpha)
+					{
+						rgba_sums[1][3] += sir[3];
+					}
+				}
+			}
+
+			stackpointer = radius;
+
+			for (x=0; x<width; x++)
+			{
+				rgba[0][yi] = dv[rgba_sums[2][0]];
+				rgba[1][yi] = dv[rgba_sums[2][1]];
+				rgba[2][yi] = dv[rgba_sums[2][2]];
+				if (alpha)
+				{
+					rgba[3][yi] = dv[rgba_sums[2][3]];
+				}
+
+				rgba_sums[2][0] -= rgba_sums[1][0];
+				rgba_sums[2][1] -= rgba_sums[1][1];
+				rgba_sums[2][2] -= rgba_sums[1][2];
+				if (alpha)
+				{
+					rgba_sums[2][3] -= rgba_sums[1][3];
+				}
+
+				stackstart = stackpointer - radius + div;
+				sir = stack[stackstart%div];
+
+				rgba_sums[1][0] -= sir[0];
+				rgba_sums[1][1] -= sir[1];
+				rgba_sums[1][2] -= sir[2];
+				if (alpha)
+				{
+					rgba_sums[1][3] -= sir[3];
+				}
+
+				if(y==0)
+				{
+					vmin[x] = MIN(x + radius + 1, width - 1);
+				}
+
+				current = (yw + vmin[x])*bytes;
+
+				sir[0] = pixels[current + 0];
+				sir[1] = pixels[current + 1];
+				sir[2] = pixels[current + 2];
+				if (alpha)
+				{
+					sir[3] = pixels[current + 3];
+				}
+
+				rgba_sums[0][0] += sir[0];
+				rgba_sums[0][1] += sir[1];
+				rgba_sums[0][2] += sir[2];
+				if (alpha)
+				{
+					rgba_sums[0][3] += sir[3];
+				}
+
+				rgba_sums[2][0] += rgba_sums[0][0];
+				rgba_sums[2][1] += rgba_sums[0][1];
+				rgba_sums[2][2] += rgba_sums[0][2];
+				if (alpha)
+				{
+					rgba_sums[2][3] += rgba_sums[0][3];
+				}
+
+				stackpointer=(stackpointer+1)%div;
+				sir=stack[(stackpointer)%div];
+
+				rgba_sums[1][0] += sir[0];
+				rgba_sums[1][1] += sir[1];
+				rgba_sums[1][2] += sir[2];
+				if (alpha)
+				{
+					rgba_sums[1][3] += sir[3];
+				}
+
+				rgba_sums[0][0] -= sir[0];
+				rgba_sums[0][1] -= sir[1];
+				rgba_sums[0][2] -= sir[2];
+				if (alpha)
+				{
+					rgba_sums[0][3] -= sir[3];
+				}
+
+				yi++;
+			}
+
+			yw += width;
+		}
+
+		for (x=0; x<width; x++)
+		{
+			yp=-radius*width;
+
+			/* initialize sums to zero */
+			for (i = 0; i<bytes; i++)
+			{
+				rgba_sums[0][i] = 0;
+				rgba_sums[1][i] = 0;
+				rgba_sums[2][i] = 0;
+			}
+
+			/* Calculate Initial Sums For radius */
+			for(i=-radius; i<=radius; i++)
+			{
+				yi = MAX(0,yp) + x;
+
+				sir = stack[i+radius];
+
+				sir[0] = rgba[0][yi];
+				sir[1] = rgba[1][yi];
+				sir[2] = rgba[2][yi];
+				if (alpha)
+				{
+					sir[3] = rgba[3][yi];
+				}
+
+				rbs = (radius + 1) - abs(i);
+
+				rgba_sums[2][0] += rgba[0][yi]*rbs;
+				rgba_sums[2][1] += rgba[1][yi]*rbs;
+				rgba_sums[2][2] += rgba[2][yi]*rbs;
+				if (alpha)
+				{
+					rgba_sums[2][3] += rgba[3][yi]*rbs;
+				}
+
+				if (i>0)
+				{
+					rgba_sums[0][0] += sir[0];
+					rgba_sums[0][1] += sir[1];
+					rgba_sums[0][2] += sir[2];
+					if (alpha)
+					{
+						rgba_sums[0][3] += sir[3];
+					}
+				}
+				else
+				{
+					rgba_sums[1][0] += sir[0];
+					rgba_sums[1][1] += sir[1];
+					rgba_sums[1][2] += sir[2];
+					if (alpha)
+					{
+						rgba_sums[1][3] += sir[3];
+					}
+				}
+
+				if(i < height - 1)
+				{
+					yp += width;
+				}
+			}
+
+			yi = x;
+			stackpointer = radius;
+
+			for (y=0; y<height; y++)
+			{
+				current = (yi)*bytes;
+
+				pixels[current + 0] = dv[rgba_sums[2][0]];
+				pixels[current + 1] = dv[rgba_sums[2][1]];
+				pixels[current + 2] = dv[rgba_sums[2][2]];
+				if (alpha)
+				{
+					pixels[current + 3] = dv[rgba_sums[2][3]];
+				}
+
+				rgba_sums[2][0] -= rgba_sums[1][0];
+				rgba_sums[2][1] -= rgba_sums[1][1];
+				rgba_sums[2][2] -= rgba_sums[1][2];
+				if (alpha)
+				{
+					rgba_sums[2][3] -= rgba_sums[1][3];
+				}
+
+				stackstart = stackpointer - radius + div;
+				sir = stack[stackstart%div];
+
+				rgba_sums[1][0] -= sir[0];
+				rgba_sums[1][1] -= sir[1];
+				rgba_sums[1][2] -= sir[2];
+				if (alpha)
+				{
+					rgba_sums[1][3] -= sir[3];
+	     			}
+
+				if (x == 0)
+				{
+					vmin[y] = MIN(y + (radius + 1), height - 1)*width;
+				}
+
+				p = x + vmin[y];
+
+				sir[0] = rgba[0][p];
+				sir[1] = rgba[1][p];
+				sir[2] = rgba[2][p];
+				if (alpha)
+				{
+					sir[3] = rgba[3][p];
+				}
+
+				rgba_sums[0][0] += sir[0];
+				rgba_sums[0][1] += sir[1];
+				rgba_sums[0][2] += sir[2];
+				if (alpha)
+				{
+					rgba_sums[0][3] += sir[3];
+				}
+
+				rgba_sums[2][0] += rgba_sums[0][0];
+				rgba_sums[2][1] += rgba_sums[0][1];
+				rgba_sums[2][2] += rgba_sums[0][2];
+				if (alpha)
+				{
+					rgba_sums[2][3] += rgba_sums[0][3];
+				}
+
+				stackpointer = (stackpointer+1)%div;
+				sir = stack[stackpointer];
+
+				rgba_sums[1][0] += sir[0];
+				rgba_sums[1][1] += sir[1];
+				rgba_sums[1][2] += sir[2];
+				if (alpha)
+				{
+					rgba_sums[1][3] += sir[3];
+				}
+
+				rgba_sums[0][0] -= sir[0];
+				rgba_sums[0][1] -= sir[1];
+				rgba_sums[0][2] -= sir[2];
+				if (alpha)
+				{
+					rgba_sums[0][3] -= sir[3];
+				}
+
+				yi += width;
+			}
+		}
+	}
+
+	return pixbuf;
+}
+