pixbufutils 0.0.3 → 0.0.4

data/ext/pixbufutils/extconf.rb

@@ -19,24 +19,69 @@ end
 # Look for headers in {gem_root}/ext/{package}
 if use_gems
   %w[
- glib2    ].each do |package|
-      require package
-      $CFLAGS += " -I"+Gem.loaded_specs[package].full_gem_path+"/ext/"+package
+ glib2].each do |package|
+    require package
+    if Gem.loaded_specs[package]
+      $CFLAGS += " -I" + Gem.loaded_specs[package].full_gem_path + "/ext/" + package
+    else
+      if fn = $".find { |n| n.sub(/[.](so|rb)$/,'') == package }
+        dr = $:.find { |d| File.exist?(File.join(d, fn)) }
+        pt = File.join(dr,fn) if dr && fn
+      else
+        pt = "??"
+      end
+      STDERR.puts "require '" + package + "' loaded '"+pt+"' instead of the gem - trying to continue, but build may fail"
+    end
   end
 end
 if RbConfig::CONFIG.has_key?('rubyhdrdir')
-$CFLAGS += " -I" + RbConfig::CONFIG['rubyhdrdir']+'/ruby'
+  $CFLAGS += " -I" + RbConfig::CONFIG['rubyhdrdir']+'/ruby'
 end
 
 $CFLAGS += " -I."
 have_func("rb_errinfo")
 PKGConfig.have_package("gdk-pixbuf-2.0") or exit(-1)
 PKGConfig.have_package("gdk-2.0") or exit(-1)
-have_header("gdk-pixbuf/gdk-pixbuf.h") or exit(-1)
-have_header("rbglib.h") or exit(-1)
-have_header("rbgobject.h") or exit(-1)
-have_header("tiffio.h") or exit(-1)
-have_header("gdk/gdk.h") or exit(-1)
+
+unless have_header("gdk-pixbuf/gdk-pixbuf.h")
+  paths = Gem.find_files("gdk-pixbuf/gdk-pixbuf.h")
+  paths.each do |path|
+    $CFLAGS += " '-I#{File.dirname(path)}'"
+  end
+  have_header("gdk-pixbuf/gdk-pixbuf.h") or exit -1
+end
+
+unless have_header("rbglib.h")
+  paths = Gem.find_files("rbglib.h")
+  paths.each do |path|
+    $CFLAGS += " '-I#{File.dirname(path)}'"
+  end
+  have_header("rbglib.h") or exit -1
+end
+
+unless have_header("rbgobject.h")
+  paths = Gem.find_files("rbgobject.h")
+  paths.each do |path|
+    $CFLAGS += " '-I#{File.dirname(path)}'"
+  end
+  have_header("rbgobject.h") or exit -1
+end
+
+unless have_header("tiffio.h")
+  paths = Gem.find_files("tiffio.h")
+  paths.each do |path|
+    $CFLAGS += " '-I#{File.dirname(path)}'"
+  end
+  have_header("tiffio.h") or exit -1
+end
+
+unless have_header("gdk/gdk.h")
+  paths = Gem.find_files("gdk/gdk.h")
+  paths.each do |path|
+    $CFLAGS += " '-I#{File.dirname(path)}'"
+  end
+  have_header("gdk/gdk.h") or exit -1
+end
 have_library("tiff") or exit(-1)
 $LIBS += " -ltiff"
 

data/ext/pixbufutils/extract-alpha.h

@@ -0,0 +1,66 @@
+static GdkPixbuf *pixbuf_extract_alpha(GdkPixbuf *src, int cutoff, int force_2bit)
+{
+	int        s_has_alpha, d_has_alpha;
+	int        s_width, s_height, s_rowstride;
+	int        d_width, d_height, d_rowstride;
+	GdkPixbuf *dest;
+	guchar    *s_pix, *sp;
+        guchar    *d_pix, *dp;
+	int        i, j, pix_width, grey;
+
+	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);
+	g_return_val_if_fail(s_has_alpha, NULL);
+
+	dest = gdk_pixbuf_new(GDK_COLORSPACE_RGB, FALSE, 8, s_width, s_height);
+
+	g_return_val_if_fail(dest != NULL, NULL);
+
+	d_rowstride = gdk_pixbuf_get_rowstride(dest);
+	d_pix = gdk_pixbuf_get_pixels(dest);
+
+	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);
+
+	pix_width = (s_has_alpha ? 4 : 3);
+
+	for (i = 0; i < s_height; i++) {
+		sp = s_pix;
+		dp = d_pix;
+
+		for (j = 0; j < s_width; j++) {
+			grey = sp[3];
+
+			if (grey < cutoff)
+				grey = 0;
+
+			if (force_2bit)
+				grey = (grey >= cutoff ? 255 : 0);
+
+			dp[0] = grey;	/* red */
+			dp[1] = grey;	/* green */
+			dp[2] = grey;	/* blue */
+
+			dp += 3;
+			sp += 4;
+		}
+
+		d_pix += d_rowstride;
+		s_pix += s_rowstride;
+	}
+
+	return dest;
+}
+
+

data/ext/pixbufutils/filter.h

@@ -0,0 +1,376 @@
+#include <math.h>
+
+static GdkPixbuf *pixbuf_adjust_brightness(GdkPixbuf *src, GdkPixbuf *dest, int adjust) {
+  int        s_has_alpha, d_has_alpha;
+	int        s_width, s_height, s_rowstride;
+	int        d_width, d_height, d_rowstride;
+	guchar    *s_pix, *sp;
+  guchar    *d_pix, *dp;
+	int        i, j, pix_width;
+  int        mod = (int) floor(255 * (adjust/100));
+
+
+	g_return_val_if_fail(src != NULL, NULL);
+	g_return_val_if_fail(dest != 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);
+
+	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);
+
+	pix_width = (s_has_alpha ? 4 : 3);
+
+
+
+	for (i = 0; i < s_height; i++) {
+		sp = s_pix;
+		dp = d_pix;
+
+		for (j = 0; j < s_width; j++) {
+
+      dp[0] = (unsigned char) MAX(MIN(mod + sp[0], 255), 0);
+      dp[1] = (unsigned char) MAX(MIN(mod + sp[1], 255), 0);
+      dp[2] = (unsigned char) MAX(MIN(mod + sp[2], 255), 0);
+
+			if (s_has_alpha)
+			{
+				dp[3] = sp[3];	/* alpha */
+			}
+
+			dp += pix_width;
+			sp += pix_width;
+		}
+
+		d_pix += d_rowstride;
+		s_pix += s_rowstride;
+	}
+
+	return dest;
+}
+
+inline unsigned char pix_value(int value)
+{
+  if (value < 0)
+    return 0;
+  if (value > 255)
+    return 255;
+  return (unsigned char) value;
+}
+
+static GdkPixbuf *pixbuf_adjust_saturation(GdkPixbuf *src, GdkPixbuf *dest, int adjust) {
+  int        s_has_alpha, d_has_alpha;
+	int        s_width, s_height, s_rowstride;
+	int        d_width, d_height, d_rowstride;
+	guchar    *s_pix, *sp;
+  guchar    *d_pix, *dp, max;
+	int        i, j, pix_width;
+  double     mod = adjust * -0.01;
+
+
+	g_return_val_if_fail(src != NULL, NULL);
+	g_return_val_if_fail(dest != 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);
+
+	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);
+
+	pix_width = (s_has_alpha ? 4 : 3);
+
+	for (i = 0; i < s_height; i++) {
+		sp = s_pix;
+		dp = d_pix;
+
+		for (j = 0; j < s_width; j++) {
+      max = sp[0];
+      if (sp[1] > max)
+        max = sp[1];
+      if (sp[2] > max)
+        max = sp[2];
+
+
+      if (max != sp[0])
+        dp[0] = pix_value(sp[0] + ((double)(max - sp[0])) * mod);
+      else
+        dp[0] = sp[0];
+
+      if (max != sp[1])
+        dp[1] = pix_value(sp[1] + ((double)(max - sp[1])) * mod);
+      else
+        dp[1] = sp[1];
+
+      if (max != sp[2])
+        dp[2] = pix_value(sp[2] + ((double)(max - sp[2])) * mod);
+      else
+        dp[2] = sp[2];
+
+			if (s_has_alpha)
+			{
+				dp[3] = sp[3];	/* alpha */
+			}
+
+			dp += pix_width;
+			sp += pix_width;
+		}
+
+		d_pix += d_rowstride;
+		s_pix += s_rowstride;
+	}
+
+	return dest;
+}
+
+
+static GdkPixbuf *pixbuf_adjust_vibrance(GdkPixbuf *src, GdkPixbuf *dest, int adjust) {
+  int        s_has_alpha, d_has_alpha;
+	int        s_width, s_height, s_rowstride;
+	int        d_width, d_height, d_rowstride;
+	guchar    *s_pix, *sp;
+  guchar    *d_pix, *dp;
+	int        i, j, pix_width, avg, max;
+  double     mod = adjust * -1;
+
+
+	g_return_val_if_fail(src != NULL, NULL);
+	g_return_val_if_fail(dest != 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);
+
+	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);
+
+	pix_width = (s_has_alpha ? 4 : 3);
+
+	for (i = 0; i < s_height; i++) {
+		sp = s_pix;
+		dp = d_pix;
+
+		for (j = 0; j < s_width; j++) {
+      max = sp[0];
+      if (sp[1] > max)
+        max = sp[1];
+      if (sp[2] > max)
+        max = sp[2];
+
+      avg = (sp[0] + sp[1] + sp[2])/3;
+      mod = ((abs(max - avg) * 2/255) * -1 * adjust) / 100.0;
+
+      if (max != sp[0])
+        dp[0] = (unsigned char) MAX(MIN(sp[0] + ( max - sp[0] ) * mod , 255), 0);
+      if (max != sp[1])
+        dp[1] = (unsigned char) MAX(MIN(sp[1] + ( max - sp[1] ) * mod , 255), 0);
+      if (max != sp[2])
+        dp[2] = (unsigned char) MAX(MIN(sp[2] + ( max - sp[2] ) * mod , 255), 0);
+
+			if (s_has_alpha)
+			{
+				dp[3] = sp[3];	/* alpha */
+			}
+
+			dp += pix_width;
+			sp += pix_width;
+		}
+
+		d_pix += d_rowstride;
+		s_pix += s_rowstride;
+	}
+
+	return dest;
+}
+static GdkPixbuf *pixbuf_adjust_contrast(GdkPixbuf *src, GdkPixbuf *dest, int adjust) {
+  int        s_has_alpha, d_has_alpha;
+	int        s_width, s_height, s_rowstride;
+	int        d_width, d_height, d_rowstride;
+	guchar    *s_pix, *sp;
+  guchar    *d_pix, *dp;
+	int        i, j, pix_width;
+  double     mod = pow(((double)adjust + 100.0)/100.0, 2);
+
+
+	g_return_val_if_fail(src != NULL, NULL);
+	g_return_val_if_fail(dest != 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);
+
+	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);
+
+	pix_width = (s_has_alpha ? 4 : 3);
+
+	for (i = 0; i < s_height; i++) {
+		sp = s_pix;
+		dp = d_pix;
+
+		for (j = 0; j < s_width; j++) {
+
+      dp[0] = (unsigned char) MAX(MIN(127 + ( (((double)sp[0]) - 127) * mod ), 255), 0);
+      dp[1] = (unsigned char) MAX(MIN(127 + ( (((double)sp[1]) - 127) * mod ), 255), 0);
+      dp[2] = (unsigned char) MAX(MIN(127 + ( (((double)sp[2]) - 127) * mod ), 255), 0);
+
+			if (s_has_alpha)
+			{
+				dp[3] = sp[3];	/* alpha */
+			}
+
+			dp += pix_width;
+			sp += pix_width;
+		}
+
+		d_pix += d_rowstride;
+		s_pix += s_rowstride;
+	}
+
+	return dest;
+}
+
+
+static GdkPixbuf *pixbuf_convolution_matrix(GdkPixbuf *src, GdkPixbuf *dest, int matrix_size, double *matrix, double divisor)
+{
+	int        s_has_alpha, d_has_alpha;
+	int        s_width, s_height, s_rowstride;
+	int        d_width, d_height, d_rowstride;
+	guchar    *s_pix, *sp, *cp;
+  guchar    *d_pix, *dp;
+	int        i, j, pix_width;
+
+  int xx, yy, mp;
+  int matrix_from, matrix_to;
+  double sum_red, sum_green, sum_blue;
+
+	g_return_val_if_fail(src != NULL, NULL);
+	g_return_val_if_fail(dest != 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);
+
+	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);
+
+	pix_width = (s_has_alpha ? 4 : 3);
+
+  mp = matrix_size >> 1;
+  matrix_from = -1 * mp;
+  matrix_to = mp;
+
+/*
+  fprintf(stderr, "FILTER: %i -> %i", matrix_from, matrix_to);
+  for (yy = matrix_from; yy <= matrix_to; yy ++) {
+    for (xx = matrix_from; xx <= matrix_to; xx ++) {
+      int index = ((mp + yy) * matrix_size) + (mp + xx);
+      double multiplier = matrix[ index ];
+      if ((xx == matrix_from)) {
+        fprintf(stderr, "\n");
+      }
+      fprintf(stderr, "(%i,%i) [%i] : %5.3f  ", xx, yy, index, multiplier);
+    }
+  }
+  fprintf(stderr, "\n\n");
+// */
+
+	for (i = 0; i < s_height; i++) {
+		sp = s_pix;
+		dp = d_pix;
+
+		for (j = 0; j < s_width; j++) {
+      sum_red = 0.0;
+      sum_green = 0.0;
+      sum_blue = 0.0;
+
+      for (yy = matrix_from; yy <= matrix_to; yy ++) {
+        for (xx = matrix_from; xx <= matrix_to; xx ++) {
+
+          int index = ((mp + yy) * matrix_size) + (mp + xx);
+          double multiplier = matrix[ index ];
+
+          if ( ((j + xx) < 0) || ((j + xx) >= s_width) ||
+               ((i + yy) < 0) || ((i + yy) >= s_height) ) {
+            sum_red   += multiplier;
+            sum_green += multiplier;
+            sum_blue  += multiplier;
+            continue;
+          }
+
+          cp = sp + (yy * s_rowstride) + (xx * pix_width);
+          sum_red   += (multiplier * (double)cp[0]);
+          sum_green += (multiplier * (double)cp[1]);
+          sum_blue  += (multiplier * (double)cp[2]);
+        }
+      }
+      sum_red   /= divisor;
+      sum_green /= divisor;
+      sum_blue  /= divisor;
+
+			dp[0] = (unsigned char)MIN(MAX(sum_red,   0.0), 255.0);	/* red */
+			dp[1] = (unsigned char)MIN(MAX(sum_green, 0.0), 255.0);	/* green */
+			dp[2] = (unsigned char)MIN(MAX(sum_blue,  0.0), 255.0);	/* blue */
+
+			if (s_has_alpha)
+			{
+				dp[3] = sp[3];	/* alpha */
+			}
+
+			dp += pix_width;
+			sp += pix_width;
+		}
+
+		d_pix += d_rowstride;
+		s_pix += s_rowstride;
+	}
+
+	return dest;
+}
+