redeye 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6f0acad32d2e9ee0122e452c3cff1f4823cd4193
+  data.tar.gz: fbc4592fd714bf7bbddd1a4e0631484e8f56b590
+SHA512:
+  metadata.gz: d481371139a391fa4b863e11b65b8b6599da2cf7d021a25f92250a2f835d018cda834c490baa5b72a6d479ca58a64bc07092ffc7c4d8fae60c425680a264f2df
+  data.tar.gz: 6211f766b9827c43c6001e7f0b30ac9ce47b1389059fa590a93e70a10cd34f7117e1d091f8c2b03037ea7fc1b33d1f4d888fb618e5606f6c0c9204f30e8cd2ec

data/README.md

@@ -0,0 +1,5 @@
+redye
+=====
+
+Simple Ruby / GdkPixbuf redeye correction library
+

data/Rakefile

@@ -0,0 +1,48 @@
+require 'rubygems'
+gem 'rake-compiler'
+require 'rake/extensiontask'
+BASE_DIR = Dir.pwd
+require 'rubygems/package_task'
+require 'rake/testtask'
+
+exts = []
+
+namespace :prepare do
+FileList["ext/*/*.cr"].each do |cr|
+	dir = File.dirname(cr)
+	name = File.basename(dir)
+	desc "Generate source for #{name}"
+	task(name.intern) do
+		sh 'rubber-generate', '--build-dir', dir, cr
+	end
+end
+end
+
+spec = Gem::Specification.new do |s|
+	s.name = "redeye"
+	s.author = "Geoff Youngs"
+	s.email = "git@intersect-uk.co.uk"
+	s.version = "1.0.0"
+	s.homepage = "http://github.com/geoffyoungs/redeye"
+	s.summary = "Redeye correction for Gdk::Pixbuf"
+	s.add_dependency("rubber-generate", ">= 0.0.17")
+	s.add_dependency("glib2", ">= 1.1.9")
+	s.add_dependency("gdk_pixbuf2", ">= 1.1.9")
+	s.platform = Gem::Platform::RUBY
+	s.extensions = FileList["ext/*/extconf.rb"]
+	s.files = FileList['ext/*/*.{c,h,cr,rd}'] + ['Rakefile', 'README.md'] + FileList['lib/**/*.rb']
+s.description = <<-EOF
+Redeye correction methods for redeye
+EOF
+end
+Gem::PackageTask.new(spec) do |pkg|
+    pkg.need_tar = true
+end
+Rake::ExtensionTask.new("redeye", spec)
+
+Rake::TestTask.new do |t|
+	t.test_files = FileList['test/*_test.rb']
+end
+
+task :default, :compile
+

data/ext/redeye/extconf.rb

@@ -0,0 +1,102 @@
+require 'mkmf'
+use_gems = false
+begin
+  require 'mkmf-gnome2'
+rescue LoadError
+  use_gems = true
+end
+
+if use_gems or Object.const_defined?('Gem')
+  require 'rubygems'
+  gem 'glib2'
+  require 'mkmf-gnome2'
+  %w[rbglib.h rbgtk.h rbpango.h rbatk.h].each do |header|
+  	Gem.find_files(header).each do |f|
+		$CFLAGS += " '-I#{File.dirname(f)}'"
+	end
+  end
+end
+# Look for headers in {gem_root}/ext/{package}
+if use_gems
+  %w[
+ glib2 gdk_pixbuf2 atk gtk2    ].each do |package|
+      require package
+      $CFLAGS += " -I"+Gem.loaded_specs[package].full_gem_path+"/ext/"+package
+  end
+end
+if RbConfig::CONFIG.has_key?('rubyhdrdir')
+$CFLAGS += " -I" + RbConfig::CONFIG['rubyhdrdir']+'/ruby'
+end
+
+$CFLAGS += " -I."
+have_func("rb_errinfo")
+PKGConfig.have_package("gtk+-2.0") or exit(-1)
+have_header("gdk-pixbuf/gdk-pixbuf.h") or exit(-1)
+
+STDOUT.print("checking for new allocation framework... ") # for ruby-1.7
+if Object.respond_to? :allocate
+  STDOUT.print "yes
+"
+  $defs << "-DHAVE_OBJECT_ALLOCATE"
+else
+  STDOUT.print "no
+"
+end
+
+top = File.expand_path(File.dirname(__FILE__) + '/..') # XXX
+$CFLAGS += " " + ['glib/src'].map{|d|
+  "-I" + File.join(top, d)
+}.join(" ")
+
+have_func("rb_define_alloc_func") # for ruby-1.8
+
+#set_output_lib('libruby-redeye.a')
+if /cygwin|mingw/ =~ RUBY_PLATFORM
+  top = "../.."
+  [
+    ["glib/src", "ruby-glib2"],
+  ].each{|d,l|
+    $LDFLAGS << sprintf(" -L%s/%s", top, d)
+    $libs << sprintf(" -l%s", l)
+  }
+end
+begin
+  srcdir = File.expand_path(File.dirname($0))
+
+  begin
+
+    obj_ext = "."+$OBJEXT
+
+    $libs = $libs.split(/ /).uniq.join(' ')
+    $source_files = Dir.glob(sprintf("%s/*.c", srcdir)).map{|fname|
+      fname[0, srcdir.length+1] = ''
+      fname
+    }
+    $objs = $source_files.collect do |item|
+      item.gsub(/.c$/, obj_ext)
+    end
+
+    #
+    # create Makefile
+    #
+    $defs << "-DRUBY_REDEYE_COMPILATION"
+    # $CFLAGS << $defs.join(' ')
+    create_makefile("redeye", srcdir)
+    raise Interrupt if not FileTest.exist? "Makefile"
+
+    File.open("Makefile", "a") do |mfile|
+      $source_files.each do |e|
+        mfile.print sprintf("%s: %s
+", e.gsub(/.c$/, obj_ext), e)
+      end
+    end
+  ensure
+    #Dir.chdir ".."
+  end
+
+  #create_top_makefile()
+rescue Interrupt
+  print "  [error] " + $!.to_s + "
+"
+end
+

data/ext/redeye/redeye.c

@@ -0,0 +1,885 @@
+#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
+/* Includes */
+#include <ruby.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include "gdk-pixbuf/gdk-pixbuf.h"
+
+/* Setup types */
+/* Try not to clash with other definitions of bool... */
+typedef int rubber_bool;
+#define bool rubber_bool
+
+/* Prototypes */
+#include "rbglib.h"
+
+#include "rbgtk.h"
+
+#if defined(G_PLATFORM_WIN32) && !defined(RUBY_GTK2_STATIC_COMPILATION)
+#  ifdef RUBY_GTK2_COMPILATION
+#    define RUBY_GTK2_VAR __declspec(dllexport)
+#  else
+#    define RUBY_GTK2_VAR extern __declspec(dllimport)
+#  endif
+#else
+#  define RUBY_GTK2_VAR extern
+#endif
+
+RUBY_GTK2_VAR VALUE mGtk;
+RUBY_GTK2_VAR VALUE mGdk;
+
+#define RBGTK_INITIALIZE(obj,gtkobj) (rbgtk_initialize_gtkobject(obj, GTK_OBJECT(gtkobj)))
+static VALUE cRedEye;
+static VALUE
+RedEye___alloc__(VALUE self);
+static VALUE
+RedEye_initialize(VALUE self, VALUE __v_pixbuf, VALUE __v_minX, VALUE __v_minY, VALUE __v_maxX, VALUE __v_maxY);
+static VALUE
+RedEye_identify_blobs(int __p_argc, VALUE *__p_argv, VALUE self);
+static VALUE
+RedEye_correct_blob(VALUE self, VALUE __v_blob_id);
+static VALUE
+RedEye_highlight_blob(int __p_argc, VALUE *__p_argv, VALUE self);
+static VALUE
+RedEye_preview_blob(int __p_argc, VALUE *__p_argv, VALUE self);
+static VALUE
+RedEye_preview(VALUE self);
+static VALUE
+RedEye_pixbuf(VALUE self);
+static VALUE structRegion;
+
+/* Inline C code */
+
+
+#define assert(x) if (!(x)) { rb_raise(rb_eRuntimeError, "Assertion: '%s' failed.", #x); }
+
+typedef struct {
+	char red,green,blue;
+} rgb_t;
+
+typedef struct {
+	int minX, maxX, minY, maxY;
+	int width, height;
+	int noPixels, mergeWith;
+} region_info;
+
+typedef struct {
+	struct {
+		int minX, maxX, minY, maxY;
+		int width, height;
+	} area;
+	struct {
+		int *data;
+		region_info *region;
+		int len, size;
+	} regions;
+	int *mask;
+	GdkPixbuf *pixbuf, *preview;
+} redeyeop_t;
+
+#define MIN_RED_VAL 20
+
+static inline VALUE 
+unref_pixbuf(GdkPixbuf *pixbuf)
+{
+	volatile VALUE pb = Qnil;
+	
+	pb = GOBJ2RVAL(pixbuf);
+	
+	g_object_unref(pixbuf);
+	
+	return pb;
+}
+
+static void identify_possible_redeye_pixels(redeyeop_t *op,
+	double green_sensitivity, double blue_sensitivity,
+	int min_red_val) 
+{
+		guchar *data = gdk_pixbuf_get_pixels(op->pixbuf);
+		int rowstride = gdk_pixbuf_get_rowstride(op->pixbuf);
+		int pixWidth = gdk_pixbuf_get_has_alpha(op->pixbuf) ? 4 : 3;
+		
+		int y, ry = 0, x, rx = 0;
+		for ( y = op->area.minY; y < op->area.maxY; y++ )
+		{
+		   guchar *thisLine = data + (rowstride * y);
+			guchar *pixel;
+		   
+			pixel = thisLine + (op->area.minX * pixWidth);
+			rx = 0;
+		   
+		   for ( x = op->area.minX; x < op->area.maxX; x++ )
+		   {
+		   
+		   	int r,g,b;
+		   	
+		   	r = pixel[0];
+		   	g = pixel[1];
+		   	b = pixel[2];
+			   
+			   gboolean threshMet;
+			   
+			   threshMet = (((double)r) > (green_sensitivity * (double)g)) && 
+			   		(((double)r) > (blue_sensitivity * (double)b)) && 
+			   		(r > min_red_val);
+			   
+			   if(threshMet)
+			      op->mask[ rx + ry ] = r;
+			   else
+			      op->mask[ rx + ry ] = 0; /* MEMZERO should have done its job ? */
+			   
+			   pixel += pixWidth;
+			   rx ++;
+			}
+		
+		   ry += op->area.width;
+		}
+}
+
+
+inline int group_at(redeyeop_t *op, int px, int py)
+{
+	int index, region;
+	
+	if (px < 0 || py < 0)
+		return 0;
+	
+	index = px + ( py * op->area.width );
+	
+	if (index < 0)
+		return 0;
+	if (index > (op->area.width * op->area.height))
+		return 0;
+	
+	region = op->regions.data[ index ];
+	if (region > 0) {
+		if (op->regions.region[ region ].mergeWith) {
+			return op->regions.region[ region ].mergeWith;
+		} else {
+			return region;
+		}
+	} else {
+		return 0;
+	}
+}
+
+#define group_for(x,y) group_at(op, x, y)
+
+static void identify_blob_groupings(redeyeop_t *op) 
+{
+	volatile int next_blob_id = 1, blob_id, y, x;
+	
+	
+	for( y = 0; y < op->area.height; y++ )
+	{
+		for ( x = 0; x < op->area.width; x++ )
+		{
+			if (op->mask[ x + (y * op->area.width) ] > 0) {
+				gboolean existing = FALSE;
+				int sx, sy, group = 0;
+				// Target pixel is true
+				blob_id = 0;
+				
+				for (sy = y; sy >= y - 1; sy --) {
+					sx = (sy == y) ? x : x + 1;
+					for (; sx >= (x - 1); sx --) {
+					/*if ((sx >= x) && (sy >= y))
+							goto blob_scan_done;*/
+							
+						if (sx >= 0 && sy >= 0)
+							group = group_for(sx, sy);
+						
+						if (group) {
+							existing = TRUE;
+							if (blob_id) {
+								int target = MIN(blob_id, group);
+								int from  = MAX(blob_id, group);
+								
+								if (op->regions.region[target].mergeWith > 0) {
+									// Already merged
+									target = op->regions.region[target].mergeWith;
+								}
+								op->regions.region[from].mergeWith = target;
+								
+								// Merge blob_id & group
+							}
+							blob_id = group;
+						}
+					}
+				}
+
+				if (blob_id == 0)
+				{ // Allocate new group
+					blob_id = next_blob_id;
+					op->regions.region[blob_id].minX = x;
+					op->regions.region[blob_id].maxX = x;
+					op->regions.region[blob_id].minY = y;
+					op->regions.region[blob_id].maxY = y;
+					op->regions.region[blob_id].width = 1;
+					op->regions.region[blob_id].height = 1;
+					op->regions.region[blob_id].noPixels = 1;
+					op->regions.region[blob_id].mergeWith = 0;
+					
+					next_blob_id ++;
+					op->regions.len  = next_blob_id;
+					
+					if (next_blob_id >= op->regions.size) {
+						int extra, new_size;
+						
+						/*
+						 * Realloc in increasingly large chunks to reduce memory fragmentation
+						 */
+						extra = op->regions.size;
+						new_size = op->regions.size + extra;
+												
+						REALLOC_N(op->regions.region, region_info, new_size);
+						
+						op->regions.size = new_size;
+					}
+				}
+				
+				if (existing) 
+				{
+					op->regions.region[blob_id].minX = MIN(x, op->regions.region[blob_id].minX);
+					op->regions.region[blob_id].maxX = MAX(x, op->regions.region[blob_id].maxX);
+					op->regions.region[blob_id].minY = MIN(y, op->regions.region[blob_id].minY);
+					op->regions.region[blob_id].maxY = MAX(y, op->regions.region[blob_id].maxY);
+					op->regions.region[blob_id].width = op->regions.region[blob_id].maxX - 
+																op->regions.region[blob_id].minX + 1;
+					op->regions.region[blob_id].height =  op->regions.region[blob_id].maxY - 
+																op->regions.region[blob_id].minY + 1;
+					op->regions.region[blob_id].noPixels ++;
+				}
+				
+				op->regions.data[ x + (y * op->area.width) ] = blob_id;
+			}
+		}
+	}
+	/*FILE *fp = fopen("regions.txt","w");*/
+	for (y = 0; y < op->area.height; y++) {
+		for (x = 0; x < op->area.width; x++) {
+			int g = group_at(op, x, y); // Returns the merged group...
+			op->regions.data[ x + (y * op->area.width) ] = g;
+			/*
+			if (op->regions.len <= 0xf || 1)
+			{
+			if (g == 0) 
+				fprintf(fp, " ");
+			else
+				fprintf(fp, "%x", g);
+			}
+			else
+			{
+			if (g == 0) 
+				fprintf(fp, "  ");
+			else
+				fprintf(fp, "%x ", g);
+			}*/
+		}
+		/*fprintf(fp, "\n");*/
+	}
+	/*fclose(fp);*/
+}
+#define NO_REGIONS_DEFAULT 20
+#define MIN_ID 1
+
+
+static redeyeop_t *new_redeye(void)
+{
+	 redeyeop_t *ptr = ALLOC(redeyeop_t);
+	 MEMZERO(ptr, redeyeop_t,  1);
+	 return ptr;
+}
+
+static void free_redeye(redeyeop_t *ptr)
+{
+	if (ptr->mask)
+		free(ptr->mask);
+	if (ptr->regions.data);
+		free(ptr->regions.data);
+	if (ptr->regions.region);
+		free(ptr->regions.region);
+	if (ptr->pixbuf)
+		g_object_unref(ptr->pixbuf);
+	if (ptr->preview)
+		g_object_unref(ptr->preview);
+	free(ptr);
+}
+
+
+inline gboolean in_region(redeyeop_t *op, int x, int y, int blob_id)
+{
+	int index;
+	
+	if ( x < op->area.minX || x > op->area.maxX ||
+		  y < op->area.minY || y > op->area.maxY )
+		return FALSE;
+	
+	index = (x - op->area.minX) + ((y - op->area.minY) * op->area.width);
+	
+	return op->regions.data[index] == blob_id;
+}
+
+inline double alpha_level_for_pixel(redeyeop_t *op, int x, int y, int blob_id)
+{
+	int j = 0, c = 0, xm, ym;
+	
+	if (in_region(op, x, y, blob_id))
+		return 1.0;
+	
+	for ( xm = -2; xm <= 2; xm++ )
+	{
+		for ( ym = -2; ym <= 2; ym ++ )
+		{
+			c ++;
+			if (xm == 0 && ym == 0)
+				continue;
+			if (in_region(op, x+xm, y+ym, blob_id))
+				j ++;
+		}
+	}
+	
+	return ((double)j)/((double)c);
+}
+
+inline char col(double val)
+{
+	if (val < 0) return 0;
+	if (val > 255) return 255;
+	return val;
+		
+}
+
+static GdkPixbuf *redeye_preview(redeyeop_t *op, gboolean reset)
+{
+	int width, height;
+	width  = op->area.width;
+	height = op->area.height;
+	
+	if (width + op->area.minX > gdk_pixbuf_get_width(op->pixbuf)) {
+		width = gdk_pixbuf_get_width(op->pixbuf) - op->area.minX;
+	}
+	if (height + op->area.minY > gdk_pixbuf_get_height(op->pixbuf)) {
+		height = gdk_pixbuf_get_height(op->pixbuf) - op->area.minY;
+	}
+		
+	if ( op->preview == NULL ) 
+	{
+		GdkPixbuf *sub = NULL;
+		sub = gdk_pixbuf_new_subpixbuf(op->pixbuf, op->area.minX, op->area.minY, 
+							width, height);
+		
+		op->preview = gdk_pixbuf_copy(sub);
+		g_object_unref(sub);
+	} else if (reset) {
+		gdk_pixbuf_copy_area(op->pixbuf, op->area.minX, op->area.minY, 
+					width, height, op->preview, 0, 0);
+	}
+	
+	return op->preview;
+}
+
+static void desaturate_blob(redeyeop_t *op, int blob_id)
+{
+	int y, x;
+	int minX, minY, maxX, maxY;
+	
+	minY = MAX(0, op->area.minY + op->regions.region[blob_id].minY - 1);
+	maxY = MIN(op->area.maxY + op->regions.region[blob_id].maxY + 1, 
+		gdk_pixbuf_get_height(op->pixbuf)-1);
+	minX = MAX(0, op->area.minX + op->regions.region[blob_id].minX - 1);
+	maxX = MIN(op->area.maxX + op->regions.region[blob_id].maxX + 1, 
+		gdk_pixbuf_get_width(op->pixbuf)-1);
+	
+	guchar *data = gdk_pixbuf_get_pixels(op->pixbuf);
+	int rowstride = gdk_pixbuf_get_rowstride(op->pixbuf);
+	int pixWidth = gdk_pixbuf_get_has_alpha(op->pixbuf) ? 4 : 3;
+	
+	for ( y = minY; y <= maxY; y++ )
+	{
+	   guchar *thisLine = data + (rowstride * y);
+		guchar *pixel;
+		
+		pixel = thisLine + (minX * pixWidth);
+	   
+	   for ( x = minX; x <= maxX; x++ )
+	   {
+	   
+		 	double alpha = alpha_level_for_pixel(op, x, y, blob_id);
+		 	int r,g,b,grey;
+		 		
+		  	r = pixel[0];
+		  	g = pixel[1];
+		  	b = pixel[2];
+		 	
+		 	if (alpha > 0)
+		 	{
+		   	grey = alpha * ((double)( 5 * (double)r + 60 * (double)g + 30 * (double)b)) / 100.0 +
+						(1 - alpha) * r;
+
+		 		pixel[0] = col((grey * alpha) + (1-alpha) * r);
+		 		pixel[1] = col((grey * alpha) + (1-alpha) * g);
+		 		pixel[2] = col((grey * alpha) + (1-alpha) * b);
+		 	}
+		 	
+		 	pixel += pixWidth;
+		}
+	}
+	
+}
+
+static void highlight_blob(redeyeop_t *op, int blob_id, int colour)
+{
+	int y, x;
+	int minX, minY, maxX, maxY;
+	int hr, hg, hb;
+	
+	hr = (colour >> 16) & 0xff;
+	hg = (colour >> 8) & 0xff;
+	hb = (colour) & 0xff;
+	
+	minY = MAX(0, op->area.minY - 1);
+	maxY = MIN(op->area.maxY + 1, gdk_pixbuf_get_height(op->pixbuf)-1);
+	minX = MAX(0, op->area.minX - 1);
+	maxX = MIN(op->area.maxX + 1, gdk_pixbuf_get_width(op->pixbuf)-1);
+	
+	guchar *data = gdk_pixbuf_get_pixels(op->pixbuf);
+	int rowstride = gdk_pixbuf_get_rowstride(op->pixbuf);
+	int pixWidth = gdk_pixbuf_get_has_alpha(op->pixbuf) ? 4 : 3;
+
+	for ( y = minY; y <= maxY; y++ )
+	{
+	   guchar *thisLine = data + (rowstride * y);
+		guchar *pixel;
+		
+		pixel = thisLine + (minX * pixWidth);
+	   
+	   for ( x = minX; x <= maxX; x++ )
+	   {
+	   
+		 	double alpha = alpha_level_for_pixel(op, x, y, blob_id);
+		 	int r,g,b;
+		 		
+		  	r = (pixel[0]);
+		  	g = (pixel[1]);
+		  	b = (pixel[2]);
+		 	
+		 	
+		 	if (alpha > 0)
+		 	{
+		  		
+		  		pixel[0] = col((1-alpha) * r + (alpha * hr));
+		  		pixel[1] = col((1-alpha) * g + (alpha * hg));
+		  		pixel[2] = col((1-alpha) * b + (alpha * hb));
+		 	}
+		 	
+		 	pixel += pixWidth;
+		}
+	}
+	
+}
+
+
+static void preview_blob(redeyeop_t *op, int blob_id, int colour, gboolean reset_preview)
+{
+	int y, x;
+	int minX, minY, maxX, maxY;
+	int hr, hg, hb;
+	
+	redeye_preview(op, reset_preview);
+	
+	hr = (colour >> 16) & 0xff;
+	hg = (colour >> 8) & 0xff;
+	hb = (colour) & 0xff;
+	
+	minY = 0;
+	maxY = gdk_pixbuf_get_height(op->preview)-1;
+	minX = 0;
+	maxX = gdk_pixbuf_get_width(op->preview)-1;
+	
+	guchar *data = gdk_pixbuf_get_pixels(op->preview);
+	int rowstride = gdk_pixbuf_get_rowstride(op->preview);
+	int pixWidth = gdk_pixbuf_get_has_alpha(op->preview) ? 4 : 3;
+
+	for ( y = minY; y <= maxY; y++ )
+	{
+	   guchar *thisLine = data + (rowstride * y);
+		guchar *pixel;
+		
+		pixel = thisLine + (minX * pixWidth);
+	   
+	   for ( x = minX; x <= maxX; x++ )
+	   {
+	   
+		 	double alpha = alpha_level_for_pixel(op, x + op->area.minX, y + op->area.minY, blob_id);
+		 	int r,g,b;
+		 		
+		  	r = (pixel[0]);
+		  	g = (pixel[1]);
+		  	b = (pixel[2]);
+		 	
+		 	
+		 	if (alpha > 0)
+		 	{
+		  		
+		  		pixel[0] = col((1-alpha) * r + (alpha * hr));
+		  		pixel[1] = col((1-alpha) * g + (alpha * hg));
+		  		pixel[2] = col((1-alpha) * b + (alpha * hb));
+		 	}
+		 	
+		 	pixel += pixWidth;
+		}
+	}
+	
+}
+
+
+/* Code */
+static VALUE
+RedEye___alloc__(VALUE self)
+{
+  VALUE __p_retval = Qnil;
+
+#line 536 "/home/geoff/Projects/redeye/ext/redeye/redeye.cr"
+  do { __p_retval = Data_Wrap_Struct(self, NULL, free_redeye, new_redeye()); goto out; } while(0);
+out:
+  return __p_retval;
+}
+
+static VALUE
+RedEye_initialize(VALUE self, VALUE __v_pixbuf, VALUE __v_minX, VALUE __v_minY, VALUE __v_maxX, VALUE __v_maxY)
+{
+  GdkPixbuf * pixbuf; GdkPixbuf * __orig_pixbuf;
+  int minX; int __orig_minX;
+  int minY; int __orig_minY;
+  int maxX; int __orig_maxX;
+  int maxY; int __orig_maxY;
+  __orig_pixbuf = pixbuf = GDK_PIXBUF(RVAL2GOBJ(__v_pixbuf));
+  __orig_minX = minX = NUM2INT(__v_minX);
+  __orig_minY = minY = NUM2INT(__v_minY);
+  __orig_maxX = maxX = NUM2INT(__v_maxX);
+  __orig_maxY = maxY = NUM2INT(__v_maxY);
+
+#line 540 "/home/geoff/Projects/redeye/ext/redeye/redeye.cr"
+
+  do {
+  redeyeop_t * op  ;
+ Data_Get_Struct(self, redeyeop_t, op);
+  op->pixbuf = pixbuf;
+  op->preview = NULL;
+  g_object_ref(op->pixbuf);
+  op->area.minX = minX;
+  op->area.maxX = maxX;
+  op->area.minY = minY;
+  op->area.maxY = maxY;
+  op->area.width = maxX - minX + 1;
+  op->area.height = maxY - minY + 1;
+  assert(op->pixbuf != NULL);
+  assert(op->area.maxX <= gdk_pixbuf_get_width(op->pixbuf));
+  assert(op->area.minX >= 0);
+  assert(op->area.minX < op->area.maxX);
+  assert(op->area.maxY <= gdk_pixbuf_get_height(op->pixbuf));
+  assert(op->area.minY >= 0);
+  assert(op->area.minY < op->area.maxY);
+  op->mask = ALLOC_N(int, op->area.width * op->area.height);
+  op->regions.data = ALLOC_N(int, op->area.width * op->area.height);
+  op->regions.region = ALLOC_N(region_info, NO_REGIONS_DEFAULT);
+  op->regions.len = 0;
+  op->regions.size = NO_REGIONS_DEFAULT;
+ 
+
+  } while(0);
+
+;
+  return Qnil;
+}
+
+static VALUE
+RedEye_identify_blobs(int __p_argc, VALUE *__p_argv, VALUE self)
+{
+  VALUE __p_retval = Qnil;
+  VALUE __v_green_sensitivity = Qnil;
+  double green_sensitivity; double __orig_green_sensitivity;
+  VALUE __v_blue_sensitivity = Qnil;
+  double blue_sensitivity; double __orig_blue_sensitivity;
+  VALUE __v_min_red_val = Qnil;
+  int min_red_val; int __orig_min_red_val;
+
+  /* Scan arguments */
+  rb_scan_args(__p_argc, __p_argv, "03",&__v_green_sensitivity, &__v_blue_sensitivity, &__v_min_red_val);
+
+  /* Set defaults */
+  if (__p_argc > 0)
+    __orig_green_sensitivity = green_sensitivity = NUM2DBL(__v_green_sensitivity);
+  else
+    green_sensitivity = 2.0;
+
+  if (__p_argc > 1)
+    __orig_blue_sensitivity = blue_sensitivity = NUM2DBL(__v_blue_sensitivity);
+  else
+    blue_sensitivity = 0.0;
+
+  if (__p_argc > 2)
+    __orig_min_red_val = min_red_val = NUM2INT(__v_min_red_val);
+  else
+    min_red_val = MIN_RED_VAL;
+
+
+#line 575 "/home/geoff/Projects/redeye/ext/redeye/redeye.cr"
+
+  do {
+  redeyeop_t * op  ;
+ Data_Get_Struct(self, redeyeop_t, op);
+  MEMZERO(op->mask, int, op->area.width * op->area.height);
+  MEMZERO(op->regions.data, int, op->area.width * op->area.height);
+  identify_possible_redeye_pixels(op, green_sensitivity, blue_sensitivity, min_red_val);
+  identify_blob_groupings(op);
+  volatile VALUE  ary  =
+ rb_ary_new2(op->regions.len);
+  int  i  ;
+ for (i = MIN_ID;
+  i < op->regions.len;
+  i++) { region_info * r  =
+ &op->regions.region[i];
+  /* Ignore CCD noise */ if (r->noPixels < 2) continue;
+  rb_ary_push(ary, rb_struct_new(structRegion, self, INT2NUM(i), INT2NUM(r->minX), INT2NUM(r->minY), INT2NUM(r->maxX), INT2NUM(r->maxY), INT2NUM(r->width), INT2NUM(r->height), INT2NUM(r->noPixels)));
+  } do { __p_retval = ary; goto out; } while(0);
+
+  } while(0);
+
+out:
+  return __p_retval;
+}
+
+static VALUE
+RedEye_correct_blob(VALUE self, VALUE __v_blob_id)
+{
+  int blob_id; int __orig_blob_id;
+  __orig_blob_id = blob_id = NUM2INT(__v_blob_id);
+
+#line 600 "/home/geoff/Projects/redeye/ext/redeye/redeye.cr"
+
+  do {
+  redeyeop_t * op  ;
+ Data_Get_Struct(self, redeyeop_t, op);
+  if (op->regions.len <= blob_id) rb_raise(rb_eIndexError, "Only %i blobs in region - %i is invalid", op->regions.len, blob_id);
+  desaturate_blob(op, blob_id);
+ 
+
+  } while(0);
+
+  return Qnil;
+}
+
+static VALUE
+RedEye_highlight_blob(int __p_argc, VALUE *__p_argv, VALUE self)
+{
+  VALUE __v_blob_id = Qnil;
+  int blob_id; int __orig_blob_id;
+  VALUE __v_col = Qnil;
+  int col; int __orig_col;
+
+  /* Scan arguments */
+  rb_scan_args(__p_argc, __p_argv, "11",&__v_blob_id, &__v_col);
+
+  /* Set defaults */
+  __orig_blob_id = blob_id = NUM2INT(__v_blob_id);
+
+  if (__p_argc > 1)
+    __orig_col = col = NUM2INT(__v_col);
+  else
+    col = 0x00ff00;
+
+
+#line 612 "/home/geoff/Projects/redeye/ext/redeye/redeye.cr"
+
+  do {
+  redeyeop_t * op  ;
+ Data_Get_Struct(self, redeyeop_t, op);
+  if (op->regions.len <= blob_id) rb_raise(rb_eIndexError, "Only %i blobs in region - %i is invalid", op->regions.len, blob_id);
+  highlight_blob(op, blob_id, col);
+ 
+
+  } while(0);
+
+  return Qnil;
+}
+
+static VALUE
+RedEye_preview_blob(int __p_argc, VALUE *__p_argv, VALUE self)
+{
+  VALUE __p_retval = Qnil;
+  VALUE __v_blob_id = Qnil;
+  int blob_id; int __orig_blob_id;
+  VALUE __v_col = Qnil;
+  int col; int __orig_col;
+  VALUE __v_reset_preview = Qnil;
+  gboolean reset_preview; gboolean __orig_reset_preview;
+
+  /* Scan arguments */
+  rb_scan_args(__p_argc, __p_argv, "12",&__v_blob_id, &__v_col, &__v_reset_preview);
+
+  /* Set defaults */
+  __orig_blob_id = blob_id = NUM2INT(__v_blob_id);
+
+  if (__p_argc > 1)
+    __orig_col = col = NUM2INT(__v_col);
+  else
+    col = 0x00ff00;
+
+  if (__p_argc > 2)
+    __orig_reset_preview = reset_preview = RTEST(__v_reset_preview);
+  else
+    reset_preview = TRUE;
+
+
+#line 623 "/home/geoff/Projects/redeye/ext/redeye/redeye.cr"
+
+  do {
+  redeyeop_t * op  ;
+ Data_Get_Struct(self, redeyeop_t, op);
+  if (op->regions.len <= blob_id) rb_raise(rb_eIndexError, "Only %i blobs in region - %i is invalid", op->regions.len, blob_id);
+  preview_blob(op, blob_id, col, reset_preview);
+  do { __p_retval = GOBJ2RVAL(GDK_PIXBUF(op->preview)); goto out; } while(0);
+
+  } while(0);
+
+out:
+  return __p_retval;
+}
+
+static VALUE
+RedEye_preview(VALUE self)
+{
+  VALUE __p_retval = Qnil;
+
+#line 635 "/home/geoff/Projects/redeye/ext/redeye/redeye.cr"
+
+  do {
+  redeyeop_t * op  ;
+ Data_Get_Struct(self, redeyeop_t, op);
+  do { __p_retval = GOBJ2RVAL(GDK_PIXBUF(redeye_preview(op, FALSE))); goto out; } while(0);
+
+  } while(0);
+
+out:
+  return __p_retval;
+}
+
+static VALUE
+RedEye_pixbuf(VALUE self)
+{
+  VALUE __p_retval = Qnil;
+
+#line 642 "/home/geoff/Projects/redeye/ext/redeye/redeye.cr"
+
+  do {
+  redeyeop_t * op  ;
+ Data_Get_Struct(self, redeyeop_t, op);
+  do { __p_retval = GOBJ2RVAL(GDK_PIXBUF(op->pixbuf)); goto out; } while(0);
+
+  } while(0);
+
+out:
+  return __p_retval;
+}
+
+static VALUE
+Region_ratio(VALUE self)
+{
+  VALUE __p_retval = Qnil;
+
+#line 497 "/home/geoff/Projects/redeye/ext/redeye/redeye.cr"
+  int width,height;
+  double min,max,ratio;
+  width = NUM2INT(rb_struct_getmember(self, rb_intern("width")));
+  height = NUM2INT(rb_struct_getmember(self, rb_intern("height")));
+  min = (double)MIN(width,height);
+  max = (double)MAX(width,height);
+  ratio = (min / max);
+  do { __p_retval =  rb_float_new(ratio); goto out; } while(0);
+out:
+  return __p_retval;
+}
+
+static VALUE
+Region_density(VALUE self)
+{
+  VALUE __p_retval = Qnil;
+
+#line 507 "/home/geoff/Projects/redeye/ext/redeye/redeye.cr"
+
+  do {
+  int noPixels, width, height;
+  double  density  ;
+ noPixels = NUM2INT(rb_struct_getmember(self, rb_intern("noPixels")));
+  width = NUM2INT(rb_struct_getmember(self, rb_intern("width")));
+  height = NUM2INT(rb_struct_getmember(self, rb_intern("height")));
+  density = ((double)noPixels / (double)(width * height));
+  do { __p_retval =  rb_float_new(density); goto out; } while(0);
+
+  } while(0);
+
+out:
+  return __p_retval;
+}
+
+static VALUE
+Region_squareish_query(int __p_argc, VALUE *__p_argv, VALUE self)
+{
+  VALUE __p_retval = Qnil;
+  VALUE __v_min_ratio = Qnil;
+  double min_ratio; double __orig_min_ratio;
+  VALUE __v_min_density = Qnil;
+  double min_density; double __orig_min_density;
+
+  /* Scan arguments */
+  rb_scan_args(__p_argc, __p_argv, "02",&__v_min_ratio, &__v_min_density);
+
+  /* Set defaults */
+  if (__p_argc > 0)
+    __orig_min_ratio = min_ratio = NUM2DBL(__v_min_ratio);
+  else
+    min_ratio = 0.5;
+
+  if (__p_argc > 1)
+    __orig_min_density = min_density = NUM2DBL(__v_min_density);
+  else
+    min_density = 0.5;
+
+
+#line 518 "/home/geoff/Projects/redeye/ext/redeye/redeye.cr"
+  int noPixels, width, height;
+  double min, max, ratio, density;
+  noPixels = NUM2INT(rb_struct_getmember(self, rb_intern("noPixels")));
+  width = NUM2INT(rb_struct_getmember(self, rb_intern("width")));
+  height = NUM2INT(rb_struct_getmember(self, rb_intern("height")));
+  min = (double)MIN(width,height);
+  max = (double)MAX(width,height);
+  ratio = (min / max);
+  density = ((double)noPixels / (double)(width * height));
+  do { __p_retval =  ((((ratio >= min_ratio) && (density > min_density))) ? Qtrue : Qfalse); goto out; } while(0);
+out:
+  return __p_retval;
+}
+
+/* Init */
+void
+Init_redeye(void)
+{
+  cRedEye = rb_define_class("RedEye", rb_cObject);
+ rb_define_alloc_func(cRedEye, RedEye___alloc__);
+  rb_define_method(cRedEye, "initialize", RedEye_initialize, 5);
+  rb_define_method(cRedEye, "identify_blobs", RedEye_identify_blobs, -1);
+  rb_define_method(cRedEye, "correct_blob", RedEye_correct_blob, 1);
+  rb_define_method(cRedEye, "highlight_blob", RedEye_highlight_blob, -1);
+  rb_define_method(cRedEye, "preview_blob", RedEye_preview_blob, -1);
+  rb_define_method(cRedEye, "preview", RedEye_preview, 0);
+  rb_define_method(cRedEye, "pixbuf", RedEye_pixbuf, 0);
+  structRegion = rb_struct_define("Region", "op", "id", "minX", "minY", "maxX", "maxY", "width", "height", "noPixels", NULL);
+    rb_define_const(cRedEye, "Region", structRegion);
+  rb_define_method(structRegion, "ratio", Region_ratio, 0);
+  rb_define_method(structRegion, "density", Region_density, 0);
+  rb_define_method(structRegion, "squareish?", Region_squareish_query, -1);
+}