extract_curves 0.0.1

data/ruby_ext/CVS/Entries

@@ -0,0 +1 @@
+D/pav////

data/ruby_ext/CVS/Repository

@@ -0,0 +1 @@
+extract-curves/ruby_ext

data/ruby_ext/CVS/Root

@@ -0,0 +1 @@
+:ext:pavpen@rubyforge.org:/var/cvs/extract-curves

data/ruby_ext/pav/CVS/Entries

@@ -0,0 +1,14 @@
+/Makefile/1.1.1.1/Tue Nov 15 17:32:09 2005//
+/Makefile.mingw32/1.1.1.1/Tue Nov 15 17:32:09 2005//
+/cstr.c/1.1.1.1/Tue Nov 15 17:32:09 2005//
+/cstr.h/1.1.1.1/Tue Nov 15 17:32:08 2005//
+/extconf.rb/1.1.1.1/Tue Nov 15 17:32:08 2005//
+/pav.c/1.1.1.1/Tue Nov 15 17:32:09 2005//
+/pgtk.c/1.1.1.1/Tue Nov 15 17:32:08 2005//
+/pgtk.h/1.1.1.1/Tue Nov 15 17:32:09 2005//
+/pix.c/1.1.1.1/Tue Nov 15 17:32:08 2005//
+/pix.h/1.1.1.1/Tue Nov 15 17:32:09 2005//
+/rbconfig.rb/1.1.1.1/Tue Nov 15 17:32:09 2005//
+/t.rb/1.1.1.1/Tue Nov 15 17:32:08 2005//
+/t1.rb/1.1.1.1/Tue Nov 15 17:32:09 2005//
+D

data/ruby_ext/pav/CVS/Repository

@@ -0,0 +1 @@
+extract-curves/ruby_ext/pav

data/ruby_ext/pav/CVS/Root

@@ -0,0 +1 @@
+:ext:pavpen@rubyforge.org:/var/cvs/extract-curves

data/ruby_ext/pav/cstr.c

@@ -0,0 +1,82 @@
+#include "cstr.h"
+#include <rubysig.h>
+#include <stdlib.h>
+#include <string.h>
+
+VALUE prb_str_view_new(VALUE from_obj, char *ptr, long len)
+{
+	VALUE	res;
+	
+	res = rb_str_new(NULL, 0);
+	//rb_gc_register_address(&res);
+/*	rb_funcall(rb_eval_string("ObjectSpace"), rb_intern("define_finalizer"),
+		2, res, rb_funcall(rb_funcall(res, rb_intern("method"), 1,
+			rb_str_new2("sterilize")), rb_intern("to_proc"), 0)); */
+	RSTRING(res)->aux.shared = from_obj;
+	RSTRING(res)->aux.capa = RSTRING(res)->len = len;
+	FL_SET(res, RBASIC(res)->flags | (ELTS_SHARED |FL_USER3/*|STR_ASSOC*/));
+	RUBY_CRITICAL(free(RSTRING(res)->ptr));
+	RSTRING(res)->ptr = ptr;
+	return res;
+}
+
+VALUE prb_str_cstr_view_new(int argc, VALUE *argv, VALUE self)
+{
+	char	*ptr;
+	
+	if (argc > 3 || argc < 2) {
+		rb_raise(rb_eArgError, "Invalid number of arguments (%i); use "
+		  "String.cstr_view_new(from_rb_obj, char *[, length])", argc);
+	}
+	ptr = (char*) NUM2ULONG(argv[1]);
+	if (argc == 2) {
+		return(prb_str_view_new(argv[0], ptr, strlen(ptr)));
+	} else {
+		return(prb_str_view_new(argv[0], ptr, NUM2LONG(argv[2])));
+	}
+}
+
+VALUE prb_str_ptr(VALUE self)
+{
+	return ULONG2NUM((unsigned long) RSTRING(self)->ptr);
+}
+
+VALUE prb_cstr_sterilize(VALUE self, VALUE obj_id)
+{
+	RSTRING(self)->ptr = NULL;
+	RSTRING(self)->aux.capa = RSTRING(self)->len = 0;
+	return Qnil;
+}
+
+__inline__ VALUE prb_cstr_new1(char *ptr, long len, VALUE from_obj)
+{
+	return rb_funcall(prb_cCStrView, rb_intern("new"),3,LONG2NUM((long)ptr),
+			LONG2NUM(len), from_obj);
+}
+
+VALUE prb_cstr_new(int argc, VALUE *argv, VALUE self)
+{
+	VALUE	res;
+	char	*ptr;
+	
+	if (argc > 3 || argc < 2) {
+		rb_raise(rb_eArgError, "Invalid number of arguments (%i); use "
+			"CStrView.new(char *[, length], from_rb_obj)", argc);
+	}
+	res = rb_call_super(0, NULL);
+	//rb_gc_register_address(&res);
+	rb_funcall(rb_eval_string("ObjectSpace"), rb_intern("define_finalizer"),
+		2, res, rb_funcall(rb_funcall(res, rb_intern("method"), 1,
+			rb_str_new2("sterilize")), rb_intern("to_proc"), 0));
+	ptr = (char*) NUM2LONG(argv[0]);
+	if (argc == 2) {
+		RSTRING(res)->aux.shared = argv[1];
+		RSTRING(res)->aux.capa = RSTRING(res)->len = strlen(ptr);
+	} else {
+		RSTRING(res)->aux.shared = argv[2];
+		RSTRING(res)->aux.capa = RSTRING(res)->len = NUM2LONG(argv[1]);
+	}
+	RSTRING(res)->ptr = ptr;
+	return res;
+}
+

data/ruby_ext/pav/cstr.h

@@ -0,0 +1,17 @@
+#ifndef PAV_CSTR_H
+#define PAV_CSTR_H
+
+#include <ruby.h>
+
+VALUE prb_cCStrView;
+
+VALUE prb_str_new6(VALUE from_obj, char *ptr, long len);
+VALUE prb_str_view_new(VALUE from_obj, char *ptr, long len);
+VALUE prb_str_cstr_view_new(int argc, VALUE *argv, VALUE self);
+VALUE prb_str_ptr(VALUE self);
+
+VALUE prb_cstr_sterilize(VALUE self, VALUE obj_id);
+VALUE prb_cstr_new(int argc, VALUE *argv, VALUE self);
+__inline__ VALUE prb_cstr_new1(char *ptr, long len, VALUE from_obj);
+
+#endif /* PAV_CSTR_H */

data/ruby_ext/pav/extconf.rb

@@ -0,0 +1,22 @@
+#!/usr/bin/ruby
+
+# To cross-compile for Win32 on Linux:
+# 	shell$ export PKG_CONFIG_PATH=/devel/target/mswin32/lib/pkgconfig
+# 	shell$ export TARGET_PLATFORM_RUBYLIB=/devel/target/mswin32/lib/ruby/site_ruby/1.8:/devel/target/mswin32/lib/ruby/site_ruby/1.8/i386-msvcrt:/devel/target/mswin32/lib/ruby/1.8:/devel/target/mswin32/lib/ruby/1.8/i386-target-mswin32
+# 	shell$ ruby1.8 extconf.rb
+
+if targ_rb_lib_paths = ENV['TARGET_PLATFORM_RUBYLIB']
+	targ_rb_lib_paths.split(':').reverse_each { |lpath| $:.unshift(lpath) }
+end
+
+#require 'rbconfig'
+#Config::CONFIG.keys.sort.each { |k| puts "#{k} = #{Config::CONFIG[k]}" }
+#puts Config::DESTDIR
+#puts Config::TOPDIR
+
+require 'mkmf'
+
+have_header('string.h')
+
+pkg_config('gobject-2.0 gdk-pixbuf-2.0 glib-2.0')
+create_makefile('pav')

data/ruby_ext/pav/pav.c

@@ -0,0 +1,162 @@
+#include <ruby.h>
+// #include <gtk/gtk.h>
+#include "pix.h"
+#include "cstr.h"
+#include "pgtk.h"
+
+VALUE	prb_mPPix;
+
+static __inline__ VALUE adjs_ary(const int *adjs, int n)
+{
+	int		x, y;
+	const int	*adj, *end_a = adjs + 2*n;
+	VALUE		res = rb_ary_new2(n);
+	
+	for ( adj = adjs; adj < end_a; adj++ ) {
+		x = *adj; adj++; y = *adj;
+		rb_ary_push(res, rb_funcall(prb_cPPix_Xy, rb_intern("new"), 2,
+			INT2NUM(x), INT2NUM(y)));
+	}
+	return res;
+}
+
+void Init_pav()
+{
+	rb_require("gtk2");
+	
+	// class String
+	rb_define_singleton_method(rb_cString, "cstr_view_new",
+			prb_str_cstr_view_new, -1);
+	rb_define_method(rb_cString, "ptr", prb_str_ptr, 0);
+	
+	// class CStrView
+	prb_cCStrView = rb_define_class("CStrView", rb_cString);
+	rb_define_singleton_method(prb_cCStrView, "new", prb_cstr_new, -1);
+	rb_define_method(prb_cCStrView, "sterilize", prb_cstr_sterilize, 1);
+	
+	// module PGtk
+	prb_mPGtk = rb_define_module("PGtk");
+	rb_define_module_function(prb_mPGtk, "user_cache_dir",
+			prb_pgtk_user_cache_dir, 0);
+	rb_define_module_function(prb_mPGtk, "user_data_dir",
+			prb_pgtk_user_data_dir, 0);
+	rb_define_module_function(prb_mPGtk, "user_config_dir",
+			prb_pgtk_user_config_dir, 0);
+	rb_define_module_function(prb_mPGtk, "system_data_dirs",
+			prb_pgtk_system_data_dirs, 0);
+	rb_define_module_function(prb_mPGtk, "system_config_dirs",
+			prb_pgtk_system_config_dirs, 0);
+	
+	// module PPix
+	prb_mPPix = rb_define_module("PPix");
+	// class PPix::Xy
+	prb_cPPix_Xy = rb_define_class_under(prb_mPPix, "Xy", rb_cObject);
+	rb_define_method(prb_cPPix_Xy, "initialize", prb_xy_init, 2);
+	rb_define_method(prb_cPPix_Xy, "x", prb_xy_x, 0);
+	rb_define_method(prb_cPPix_Xy, "y", prb_xy_y, 0);
+	rb_define_method(prb_cPPix_Xy, "yx", prb_xy_yx, 0);
+	rb_define_method(prb_cPPix_Xy, "hash", prb_xy_hash, 0);
+	rb_define_method(prb_cPPix_Xy, "to_s", prb_xy_to_s, 0);
+	rb_define_method(prb_cPPix_Xy, "coords_to_s", prb_xy_to_s, 0);
+	
+	prb_rbPixAdjs8 = adjs_ary(prb_PixAdjs, 8);
+	prb_rbPixAdjs8_NoUp = adjs_ary(prb_PixAdjs_NoUp, 5);
+	prb_rbPixAdjs8_NoDown = adjs_ary(prb_PixAdjs_NoDown, 5);
+	prb_rbPixAdjs8_NoLeft = adjs_ary(prb_PixAdjs_NoLeft, 5);
+	prb_rbPixAdjs8_NoRight = adjs_ary(prb_PixAdjs_NoRight, 5);
+	prb_rbPixAdjs8_NoUpDown = adjs_ary(prb_PixAdjs_NoUpDown, 2);
+	prb_rbPixAdjs8_NoLeftRight = adjs_ary(prb_PixAdjs_NoLeftRight, 2);
+	prb_rbPixAdjs8_NoLeftUp = adjs_ary(prb_PixAdjs_NoLeftUp, 3);
+	prb_rbPixAdjs8_NoLeftDown = adjs_ary(prb_PixAdjs_NoLeftDown, 3);
+	prb_rbPixAdjs8_NoRightUp = adjs_ary(prb_PixAdjs_NoRightUp, 3);
+	prb_rbPixAdjs8_NoRightDown = adjs_ary(prb_PixAdjs_NoRightDown, 3);
+	prb_rbPixAdjs8_NoLeftRightUp = adjs_ary(prb_PixAdjs_NoLeftRightUp, 1);
+	prb_rbPixAdjs8_NoLeftRightDown =adjs_ary(prb_PixAdjs_NoLeftRightDown,1);
+	prb_rbPixAdjs8_NoLeftUpDown = adjs_ary(prb_PixAdjs_NoLeftUpDown, 1);
+	prb_rbPixAdjs8_NoRightUpDown = adjs_ary(prb_PixAdjs_NoRightUpDown, 1);
+	prb_rbPixAdjs8_None = rb_ary_new2(0);
+	prb_rbPixAdjs4 = adjs_ary(prb_PixAdjs, 4);
+	prb_rbPixAdjs4_NoUp = adjs_ary(prb_PixAdjs_NoUp, 3);
+	prb_rbPixAdjs4_NoDown = adjs_ary(prb_PixAdjs_NoDown, 3);
+	prb_rbPixAdjs4_NoLeft = adjs_ary(prb_PixAdjs_NoLeft, 3);
+	prb_rbPixAdjs4_NoRight = adjs_ary(prb_PixAdjs_NoRight, 3);
+	prb_rbPixAdjs4_NoUpDown = prb_rbPixAdjs8_NoUpDown;
+	prb_rbPixAdjs4_NoLeftRight = prb_rbPixAdjs8_NoLeftRight;
+	prb_rbPixAdjs4_NoLeftUp = adjs_ary(prb_PixAdjs_NoLeftUp, 2);
+	prb_rbPixAdjs4_NoLeftDown = adjs_ary(prb_PixAdjs_NoLeftDown, 2);
+	prb_rbPixAdjs4_NoRightUp = adjs_ary(prb_PixAdjs_NoRightUp, 2);
+	prb_rbPixAdjs4_NoRightDown = adjs_ary(prb_PixAdjs_NoRightDown, 2);
+	prb_rbPixAdjs4_NoLeftRightUp = prb_rbPixAdjs8_NoLeftRightUp;
+	prb_rbPixAdjs4_NoLeftRightDown = prb_rbPixAdjs8_NoLeftRightDown;
+	prb_rbPixAdjs4_NoLeftUpDown = prb_rbPixAdjs8_NoLeftUpDown;
+	prb_rbPixAdjs4_NoRightUpDown = prb_rbPixAdjs8_NoRightUpDown;
+	prb_rbPixAdjs4_None = prb_rbPixAdjs8_None;
+	rb_define_const(prb_cPPix_Xy, "ADJACENT4", prb_rbPixAdjs4);
+	rb_define_const(prb_cPPix_Xy, "ADJACENT8", prb_rbPixAdjs8);
+	
+	// module PPix::PixbufPix
+	prb_mPPix_MPixbufPix = rb_define_module_under(prb_mPPix, "MPixbufPix");
+	rb_define_singleton_method(prb_mPPix_MPixbufPix, "rgb_to_hsv",
+			prb_pixbuf_pix_rgb_to_hsv, 3);
+	rb_define_method(prb_mPPix_MPixbufPix,"pixbuf",prb_pixbuf_pix_pixbuf,0);
+	rb_define_method(prb_mPPix_MPixbufPix, "color_id",
+			prb_pixbuf_pix_color_id, 0);
+	rb_define_method(prb_mPPix_MPixbufPix, "color_rgb",
+			prb_pixbuf_pix_color_rgb, 0);
+	rb_define_method(prb_mPPix_MPixbufPix, "color_hsv",
+			prb_pixbuf_pix_color_hsv, 0);
+	rb_define_method(prb_mPPix_MPixbufPix, "virtual?",
+			prb_pixbuf_pix_is_virtual, 0);
+	rb_define_method(prb_mPPix_MPixbufPix, "border?",
+			prb_pixbuf_pix_is_border, 1);
+	rb_define_method(prb_mPPix_MPixbufPix, "border8?",
+			prb_pixbuf_pix_is_border8, 0);
+	rb_define_method(prb_mPPix_MPixbufPix, "border4?",
+			prb_pixbuf_pix_is_border4, 0);
+	rb_define_method(prb_mPPix_MPixbufPix, "adj", prb_pixbuf_pix_adj, 1);
+	rb_define_method(prb_mPPix_MPixbufPix, "adj8", prb_pixbuf_pix_adj8, 0);
+	rb_define_method(prb_mPPix_MPixbufPix, "adj4", prb_pixbuf_pix_adj4, 0);
+	rb_define_method(prb_mPPix_MPixbufPix, "adj_cocolor",
+			prb_pixbuf_pix_adj_cocolor, 1);
+	rb_define_method(prb_mPPix_MPixbufPix, "adj_cocolor8",
+			prb_pixbuf_pix_adj_cocolor8, 0);
+	rb_define_method(prb_mPPix_MPixbufPix, "adj_cocolor4",
+			prb_pixbuf_pix_adj_cocolor4, 0);
+	rb_define_method(prb_mPPix_MPixbufPix, "adj_fuzzy_rgb_cocolor",
+			prb_pixbuf_pix_adj_fuzzy_rgb_cocolor, 4);
+	rb_define_method(prb_mPPix_MPixbufPix, "adj_fuzzy_hsv_cocolor",
+			prb_pixbuf_pix_adj_fuzzy_rgb_cocolor, 4);
+	
+	// class PPix::PixbufPix
+	prb_cPPix_PixbufPix = rb_define_class_under(prb_mPPix, "PixbufPix",
+			prb_cPPix_Xy);
+	rb_include_module(prb_cPPix_PixbufPix, prb_mPPix_MPixbufPix);
+	rb_define_method(prb_cPPix_PixbufPix, "initialize", prb_pixbuf_pix_init,
+			3);
+	
+	// class PPix::Pixbuf
+	prb_cPPix_Pixbuf = rb_define_class_under(prb_mPPix, "Pixbuf",
+			rb_eval_string("Gdk::Pixbuf"));
+	rb_define_method(prb_cPPix_Pixbuf, "initialize", prb_pixbuf_init, -1);
+	rb_define_method(prb_cPPix_Pixbuf,"pixels_ptr",prb_pixbuf_pixels_ptr,0);
+	rb_define_method(prb_cPPix_Pixbuf, "pixels", prb_pixbuf_pixels, 0);
+	rb_define_method(prb_cPPix_Pixbuf, "sample_length",
+			prb_pixbuf_sample_length, 0);
+	rb_define_method(prb_cPPix_Pixbuf,"pix_length",prb_pixbuf_pix_length,0);
+	rb_define_method(prb_cPPix_Pixbuf, "picture_width",
+			prb_pixbuf_picture_width, 0);
+	rb_define_method(prb_cPPix_Pixbuf, "picture_height",
+			prb_pixbuf_picture_height, 0);
+	rb_define_method(prb_cPPix_Pixbuf, "ofs0", prb_pixbuf_ofs0, 0);
+	rb_define_method(prb_cPPix_Pixbuf, "pix_mask", prb_pixbuf_pix_mask, 0);
+	rb_define_method(prb_cPPix_Pixbuf, "border_width",
+			prb_pixbuf_border_width, 0);
+	rb_define_method(prb_cPPix_Pixbuf, "get_pix", prb_pixbuf_get_pix, 2);
+	rb_define_method(prb_cPPix_Pixbuf, "dup", prb_pixbuf_dup, 0);
+	rb_define_method(prb_cPPix_Pixbuf, "scale", prb_pixbuf_scale, -1);
+	rb_define_method(prb_cPPix_Pixbuf,"add_border",prb_pixbuf_add_border,1);
+	/*rb_define_method(prb_cPPix_Pixbuf, "subpixbuf",
+			prb_pixbuf_subpixbuf, 4);*/
+	rb_define_method(prb_cPPix_Pixbuf, "scaled", prb_pixbuf_scaled, 7);
+	rb_define_method(prb_cPPix_Pixbuf,"gdk_scaled",prb_pixbuf_gdk_scaled,7);
+}

data/ruby_ext/pav/pgtk.c

@@ -0,0 +1,40 @@
+#include "pgtk.h"
+#include <glib.h>
+#include <ruby.h>
+
+VALUE prb_pgtk_user_cache_dir(VALUE self)
+{
+	return rb_str_new2(g_get_user_cache_dir());
+}
+
+VALUE prb_pgtk_user_data_dir(VALUE self)
+{
+	return rb_str_new2(g_get_user_data_dir());
+}
+
+VALUE prb_pgtk_user_config_dir(VALUE self)
+{
+	return rb_str_new2(g_get_user_config_dir());
+}
+
+VALUE prb_pgtk_system_data_dirs(VALUE self)
+{
+	VALUE res = rb_ary_new();
+	const char * const *	paths;
+	
+	for ( paths = g_get_system_data_dirs(); *paths; paths++ ) {
+		rb_ary_push(res, rb_str_new2(*paths));
+	}
+	return res;
+}
+
+VALUE prb_pgtk_system_config_dirs(VALUE self)
+{
+	VALUE res = rb_ary_new();
+	const char * const *	paths;
+	
+	for ( paths = g_get_system_config_dirs(); *paths; paths++ ) {
+		rb_ary_push(res, rb_str_new2(*paths));
+	}
+	return res;
+}

data/ruby_ext/pav/pgtk.h

@@ -0,0 +1,14 @@
+#ifndef PAV_PGTK_H
+#define PAV_PGTK_H
+
+#include <ruby.h>
+
+VALUE prb_mPGtk;
+
+VALUE prb_pgtk_user_cache_dir(VALUE self);
+VALUE prb_pgtk_user_data_dir(VALUE self);
+VALUE prb_pgtk_user_config_dir(VALUE self);
+VALUE prb_pgtk_system_data_dirs(VALUE self);
+VALUE prb_pgtk_system_config_dirs(VALUE self);
+
+#endif /* PAV_PGTK_H */

data/ruby_ext/pav/pix.c

@@ -0,0 +1,806 @@
+#include <math.h>
+#include <ruby.h>
+#include <intern.h>
+#include <stdlib.h>
+#include <string.h>
+#include <glib-object.h>
+
+#include "pix.h"
+#include "cstr.h"
+
+const int prb_PixAdjs[] ={1, 0, 0, -1, -1, 0, 0, 1, 1, -1, -1, -1, -1, 1, 1, 1};
+const int prb_PixAdjs_NoUp[] = {1, 0, -1, 0, 0, 1, -1, 1, 1, 1};
+const int prb_PixAdjs_NoDown[] = {1, 0, 0, -1, -1, 0, 1, -1, -1, -1};
+const int prb_PixAdjs_NoLeft[] = {1, 0, 0, -1, 0, 1, 1, -1, 1, 1};
+const int prb_PixAdjs_NoRight[] = {0, -1, -1, 0, 0, 1, -1, -1, -1, 1};
+const int prb_PixAdjs_NoUpDown[] = {1, 0, -1, 0};
+const int prb_PixAdjs_NoLeftRight[] = {0, -1, 0, 1};
+const int prb_PixAdjs_NoLeftUp[] = {1, 0, 0, 1, 1, 1};
+const int prb_PixAdjs_NoLeftDown[] = {1, 0, 0, -1, 1, -1};
+const int prb_PixAdjs_NoRightUp[] = {-1, 0, 0, 1, -1, 1};
+const int prb_PixAdjs_NoRightDown[] = {0, -1, -1, 0, -1, -1};
+const int prb_PixAdjs_NoLeftRightUp[] = {0, 1};
+const int prb_PixAdjs_NoLeftRightDown[] = {0, -1};
+const int prb_PixAdjs_NoLeftUpDown[] = {1, 0};
+const int prb_PixAdjs_NoRightUpDown[] = {-1, 0};
+
+VALUE prb_xy_init(VALUE self, VALUE x, VALUE y)
+{
+	rb_iv_set(self, "@x", x);
+	rb_iv_set(self, "@y", y);
+	rb_iv_set(self,"@yx", rb_ary_new3(2, y, x));
+	return Qnil;
+}
+
+VALUE prb_xy_x(VALUE self)
+{
+	return rb_iv_get(self, "@x");
+}
+
+VALUE prb_xy_y(VALUE self)
+{
+	return rb_iv_get(self, "@y");
+}
+
+VALUE prb_xy_yx(VALUE self)
+{
+	return rb_iv_get(self, "@yx");
+}
+
+VALUE prb_xy_hash(VALUE self)
+{
+	return LONG2NUM(NUM2LONG(rb_iv_get(self, "@y"))*32768 +
+		NUM2LONG(rb_iv_get(self, "@x")));
+}
+
+VALUE prb_xy_to_s(VALUE self)
+{
+	VALUE		res;
+	
+	res = rb_str_buf_new2("(");
+	res = rb_str_buf_append(res, rb_obj_as_string(rb_iv_get(self, "@x")));
+	res = rb_str_buf_append(res, rb_str_new2(", "));
+	res = rb_str_buf_append(res, rb_obj_as_string(rb_iv_get(self, "@y")));
+	res = rb_str_buf_append(res, rb_str_new2(")"));
+	return res;
+}
+
+void prb_color_rgb_to_hsv(int r, int g, int b, double *h, double *s, double *v)
+{
+	double	d_c_delta, d_max_c; // c = (RGB) component, h = hue
+	
+#define PRB_CRTS_WITH_SORTED_CS(min_c,h_min_val,mid_c,h_mid_val,max_c,h_val,mt)\
+	d_max_c = (double) (max_c); \
+	(*v) = d_max_c / 255.0; \
+	if ( (min_c) == (max_c) ) {\
+		(*h) = (*s) = 0.0; \
+	} else {\
+		d_c_delta = (double) (max_c - min_c); \
+		(*s) = d_c_delta / d_max_c; \
+		(*h) = (h_val) / 6.0; \
+	}
+	
+	PRB_3_FPASS_SORTED_WITH_PROPS(r,
+			(g-b) < 0 ? (6.0 + ((double)(g-b)) / d_c_delta) :
+			(((double) (g-b)) / d_c_delta),
+		g, 2.0 + ((double) (b-r)) / d_c_delta,
+		b, 4.0 + ((double) (r-g)) / d_c_delta, PRB_CRTS_WITH_SORTED_CS,)
+}
+
+VALUE prb_pixbuf_pix_rgb_to_hsv(VALUE klass, VALUE r, VALUE g, VALUE b)
+{
+	double	h, s, v;
+	
+	prb_color_rgb_to_hsv(NUM2INT(r), NUM2INT(g), NUM2INT(b), &h, &s, &v);
+	return rb_ary_new3(3, rb_float_new(h),rb_float_new(s),rb_float_new(v));
+}
+
+VALUE prb_pixbuf_pix_init(VALUE self, VALUE pixbuf, VALUE x, VALUE y)
+{
+	VALUE	args[] = {x, y};
+	
+	rb_call_super(2, args);
+	rb_iv_set(self,"@pixbuf", pixbuf);
+	return Qnil;
+}
+
+VALUE prb_pixbuf_pix_pixbuf(VALUE self)
+{
+	return rb_iv_get(self, "@pixbuf");
+}
+
+VALUE prb_pixbuf_pix_color_id(VALUE self)
+{
+	VALUE		pixbuf;
+	int		width, height, border_width, x, y, rowstride, pix_len;
+	unsigned char	*pixels;
+	
+	pixbuf = rb_iv_get(self, "@pixbuf");
+	pixels = (unsigned char*) RSTRING(rb_iv_get(pixbuf,"@pixels"))->ptr;
+	width = NUM2INT(rb_funcall(pixbuf, rb_intern("width"), 0));
+	height = NUM2INT(rb_funcall(pixbuf, rb_intern("height"), 0));
+	border_width = NUM2INT(rb_iv_get(pixbuf, "@border_width"));
+	x = NUM2INT(rb_funcall(self, rb_intern("x"), 0)) + border_width;
+	y = NUM2INT(rb_funcall(self, rb_intern("y"), 0)) + border_width;
+	if ( x < 0 )
+		x = 0;
+	else if ( x >= width )
+		x = width - 1;
+	if ( y < 0 )
+		y = 0;
+	else if ( y >= height)
+		y = height - 1;
+	rowstride = NUM2INT(rb_funcall(pixbuf, rb_intern("rowstride"), 0));
+	pix_len = NUM2INT(rb_iv_get(pixbuf, "@pix_length"));
+	return LONG2NUM((*((long*)(pixels + y*rowstride + x*pix_len))) &
+		NUM2LONG(rb_iv_get(pixbuf, "@pix_mask")));
+}
+
+VALUE prb_pixbuf_pix_color_rgb(VALUE self)
+{
+	VALUE		pixbuf;
+	int		width, height, border_width, x, y, rowstride, pix_len;
+	unsigned char	*pixels, *pix_ptr;
+	
+	pixbuf = rb_iv_get(self, "@pixbuf");
+	pixels = (unsigned char*) RSTRING(rb_iv_get(pixbuf,"@pixels"))->ptr;
+	width = NUM2INT(rb_funcall(pixbuf, rb_intern("width"), 0));
+	height = NUM2INT(rb_funcall(pixbuf, rb_intern("height"), 0));
+	border_width = NUM2INT(rb_iv_get(pixbuf, "@border_width"));
+	x = NUM2INT(rb_funcall(self, rb_intern("x"), 0)) + border_width;
+	y = NUM2INT(rb_funcall(self, rb_intern("y"), 0)) + border_width;
+	if ( x < 0 )
+		x = 0;
+	else if ( x >= width )
+		x = width - 1;
+	if ( y < 0 )
+		y = 0;
+	else if ( y >= height)
+		y = height - 1;
+	rowstride = NUM2INT(rb_funcall(pixbuf, rb_intern("rowstride"), 0));
+	pix_len = NUM2INT(rb_iv_get(pixbuf, "@pix_length"));
+	pix_ptr = pixels + y*rowstride + x*pix_len;
+	return rb_ary_new3(3, INT2NUM(pix_ptr[0]), INT2NUM(pix_ptr[1]),
+			INT2NUM(pix_ptr[2]));
+}
+
+VALUE prb_pixbuf_pix_color_hsv(VALUE self)
+{
+	double		h, s, v;
+	VALUE		pixbuf;
+	int		width, height, border_width, x, y, rowstride, pix_len;
+	unsigned char	*pixels, *pix_ptr;
+	
+	pixbuf = rb_iv_get(self, "@pixbuf");
+	pixels = (unsigned char*) RSTRING(rb_iv_get(pixbuf,"@pixels"))->ptr;
+	width = NUM2INT(rb_funcall(pixbuf, rb_intern("width"), 0));
+	height = NUM2INT(rb_funcall(pixbuf, rb_intern("height"), 0));
+	border_width = NUM2INT(rb_iv_get(pixbuf, "@border_width"));
+	x = NUM2INT(rb_funcall(self, rb_intern("x"), 0)) + border_width;
+	y = NUM2INT(rb_funcall(self, rb_intern("y"), 0)) + border_width;
+	if ( x < 0 )
+		x = 0;
+	else if ( x >= width )
+		x = width - 1;
+	if ( y < 0 )
+		y = 0;
+	else if ( y >= height)
+		y = height - 1;
+	rowstride = NUM2INT(rb_funcall(pixbuf, rb_intern("rowstride"), 0));
+	pix_len = NUM2INT(rb_iv_get(pixbuf, "@pix_length"));
+	pix_ptr = pixels + y*rowstride + x*pix_len;
+	prb_color_rgb_to_hsv(pix_ptr[0], pix_ptr[1], pix_ptr[2], &h, &s, &v);
+	return rb_ary_new3(3, rb_float_new(h),rb_float_new(s),rb_float_new(v));
+}
+
+VALUE prb_pixbuf_pix_is_virtual(VALUE self)
+{
+	VALUE		pixbuf;
+	int		x, y;
+	
+	pixbuf = rb_iv_get(self, "@pixbuf");
+	x = NUM2INT(rb_funcall(self, rb_intern("x"), 0));
+	y = NUM2INT(rb_funcall(self, rb_intern("y"), 0));
+	if ( x < 0 || x >= NUM2INT(rb_iv_get(pixbuf, "@picture_width")) ||
+	y < 0 || y >= NUM2INT(rb_iv_get(pixbuf, "@picture_height")) ) {
+		return Qtrue;
+	} else {
+		return Qfalse;
+	}
+}
+
+VALUE prb_pixbuf_pix_is_border(VALUE self, VALUE adjacents)
+{
+	VALUE		pixbuf, *adj, *adjs = RARRAY(adjacents)->ptr,
+			*a_end = adjs + RARRAY(adjacents)->len;
+	unsigned char	*pixels;
+	int		rowstride, pix_len, x0, y0, x, y, width, height;
+	long		clr_id, mask;
+	ID		id_x = rb_intern("x"), id_y = rb_intern("y");
+	
+	pixbuf = rb_iv_get(self, "@pixbuf");
+	x0 = NUM2INT(rb_funcall(self, rb_intern("x"), 0));
+	y0 = NUM2INT(rb_funcall(self, rb_intern("y"), 0));
+	width = NUM2INT(rb_iv_get(pixbuf, "@picture_width"));
+	height = NUM2INT(rb_iv_get(pixbuf, "@picture_height"));
+	pixels = (unsigned char*) RSTRING(rb_iv_get(pixbuf,"@pixels"))->ptr +
+		NUM2INT(rb_iv_get(pixbuf, "@ofs0"));
+	rowstride = NUM2INT(rb_funcall(pixbuf, rb_intern("rowstride"), 0));
+	pix_len = NUM2INT(rb_iv_get(pixbuf, "@pix_length"));
+	mask = NUM2LONG(rb_iv_get(pixbuf, "@pix_mask"));
+	clr_id = (*((long*) (pixels + y0*rowstride + x0*pix_len))) & mask;
+	for ( adj = adjs; adj < a_end; adj++ ) {
+		x = x0 + NUM2INT(rb_funcall(*adj, id_x, 0));
+		y = y0 + NUM2INT(rb_funcall(*adj, id_y, 0));
+		if (x < 0 || x >= width || y < 0 || y >= height ||
+		(( *((long*)(pixels+y*rowstride+x*pix_len))) & mask) != clr_id)
+			return Qtrue;
+	}
+	return Qfalse;
+}
+
+VALUE prb_pixbuf_pix_is_border_in_8(VALUE self, unsigned int neighbs_cnt)
+{
+	VALUE		pixbuf;
+	unsigned char	*pixels;
+	int		rowstride, pix_len, x0, y0, x, y, width, height;
+	const int	*adj, *a_end = prb_PixAdjs + 2*neighbs_cnt;
+	long		clr_id, mask;
+	
+	x0 = NUM2INT(rb_funcall(self, rb_intern("x"), 0));
+	y0 = NUM2INT(rb_funcall(self, rb_intern("y"), 0));
+	if ( x0 < 1 || y0 < 1 )
+		return Qtrue;
+	pixbuf = rb_iv_get(self, "@pixbuf");
+	width = NUM2INT(rb_iv_get(pixbuf, "@picture_width"));
+	height = NUM2INT(rb_iv_get(pixbuf, "@picture_height"));
+	if ( x0 >= width-1 || y0 >= height-1 )
+		return Qtrue;
+	pixels = (unsigned char*) RSTRING(rb_iv_get(pixbuf,"@pixels"))->ptr +
+		NUM2INT(rb_iv_get(pixbuf, "@ofs0"));
+	rowstride = NUM2INT(rb_funcall(pixbuf, rb_intern("rowstride"), 0));
+	pix_len = NUM2INT(rb_iv_get(pixbuf, "@pix_length"));
+	mask = NUM2LONG(rb_iv_get(pixbuf, "@pix_mask"));
+	clr_id = (*((long*) (pixels + y0*rowstride + x0*pix_len))) & mask;
+	for ( adj = prb_PixAdjs; adj < a_end; adj++ ) {
+		x = x0 + (*adj); adj++;
+		y = y0 + (*adj);
+		if ( ((*((long*)(pixels + y*rowstride + x*pix_len))) & mask) !=
+		clr_id )
+			return Qtrue;
+	}
+	return Qfalse;
+}
+
+VALUE prb_pixbuf_pix_is_border8(VALUE self)
+{
+	return prb_pixbuf_pix_is_border_in_8(self, 8);
+}
+
+VALUE prb_pixbuf_pix_is_border4(VALUE self)
+{
+	return prb_pixbuf_pix_is_border_in_8(self, 4);
+}
+
+VALUE prb_pixbuf_pix_adj(VALUE self, VALUE adjacents)
+{
+	VALUE		res = rb_ary_new2(RARRAY(adjacents)->len), pixbuf, *adj,
+			*adjs = RARRAY(adjacents)->ptr,
+			*a_end = adjs + RARRAY(adjacents)->len;
+	unsigned char	*pixels;
+	int		rowstride, pix_len, x0, y0, x, y, width, height;
+	ID		id_x = rb_intern("x"), id_y = rb_intern("y"),
+			id_get_pix = rb_intern("get_pix");
+	
+	pixbuf = rb_iv_get(self, "@pixbuf");
+	x0 = NUM2INT(rb_funcall(self, rb_intern("x"), 0));
+	y0 = NUM2INT(rb_funcall(self, rb_intern("y"), 0));
+	width = NUM2INT(rb_iv_get(pixbuf, "@picture_width"));
+	height = NUM2INT(rb_iv_get(pixbuf, "@picture_height"));
+	pixels = (unsigned char*) RSTRING(rb_iv_get(pixbuf,"@pixels"))->ptr +
+		NUM2INT(rb_iv_get(pixbuf, "@ofs0"));
+	rowstride = NUM2INT(rb_funcall(pixbuf, rb_intern("rowstride"), 0));
+	pix_len = NUM2INT(rb_iv_get(pixbuf, "@pix_length"));
+	for ( adj = adjs; adj < a_end; adj++ ) {
+		x = x0 + NUM2INT(rb_funcall(*adj, id_x, 0));
+		y = y0 + NUM2INT(rb_funcall(*adj, id_y, 0));
+		if (x >= 0 && x < width && y >= 0 && y <= height)
+			rb_ary_push(res, rb_funcall(pixbuf, id_get_pix, 2,
+				INT2NUM(x), INT2NUM(y)));
+	}
+	return res;
+}
+
+VALUE prb_pixbuf_pix_adj8(VALUE self)
+{
+	VALUE		pixbuf, res;
+	int		adj_cnt, x0, y0, x, y;
+	const int	*adj, *a_end;
+	ID		id_get_pix = rb_intern("get_pix");
+	
+	pixbuf = rb_iv_get(self, "@pixbuf");
+	x0 = NUM2INT(rb_funcall(self, rb_intern("x"), 0));
+	y0 = NUM2INT(rb_funcall(self, rb_intern("y"), 0));
+	adj_cnt = PRB_PIX_ADJS8(x0, y0, 0, 0,
+		NUM2INT(rb_iv_get(pixbuf, "@picture_width"))-1,
+		NUM2INT(rb_iv_get(pixbuf, "@picture_height"))-1, adj);
+	a_end = adj + 2*adj_cnt;
+	res = rb_ary_new2(adj_cnt);
+	for ( ; adj < a_end; adj++ ) {
+		x = x0 + *adj; adj++; y = y0 + *adj;
+		rb_ary_push(res, rb_funcall(pixbuf, id_get_pix, 2,
+			INT2NUM(x), INT2NUM(y)));
+	}
+	return res;
+}
+
+VALUE prb_pixbuf_pix_adj4(VALUE self)
+{
+	VALUE		pixbuf, res;
+	int		adj_cnt, x0, y0, x, y;
+	const int	*adj, *a_end;
+	ID		id_get_pix = rb_intern("get_pix");
+	
+	pixbuf = rb_iv_get(self, "@pixbuf");
+	x0 = NUM2INT(rb_funcall(self, rb_intern("x"), 0));
+	y0 = NUM2INT(rb_funcall(self, rb_intern("y"), 0));
+	adj_cnt = PRB_PIX_ADJS4(x0, y0, 0, 0,
+		NUM2INT(rb_iv_get(pixbuf, "@picture_width"))-1,
+		NUM2INT(rb_iv_get(pixbuf, "@picture_height"))-1, adj);
+	a_end = adj + 2*adj_cnt;
+	res = rb_ary_new2(adj_cnt);
+	for ( ; adj < a_end; adj++ ) {
+		x = x0 + *adj; adj++; y = y0 + *adj;
+		rb_ary_push(res, rb_funcall(pixbuf, id_get_pix, 2,
+			INT2NUM(x), INT2NUM(y)));
+	}
+	return res;
+}
+
+VALUE prb_pixbuf_pix_adj_cocolor(VALUE self, VALUE adjacents)
+{
+	VALUE		res = rb_ary_new2(RARRAY(adjacents)->len), pixbuf, *adj,
+			*adjs = RARRAY(adjacents)->ptr,
+			*a_end = adjs + RARRAY(adjacents)->len;
+	unsigned char	*pixels;
+	int		rowstride, pix_len, x0, y0, x, y, width, height;
+	long		clr_id, mask;
+	ID		id_x = rb_intern("x"), id_y = rb_intern("y"),
+			id_get_pix = rb_intern("get_pix");
+	
+	pixbuf = rb_iv_get(self, "@pixbuf");
+	x0 = NUM2INT(rb_funcall(self, id_x, 0));
+	y0 = NUM2INT(rb_funcall(self, id_y, 0));
+	width = NUM2INT(rb_iv_get(pixbuf, "@picture_width"));
+	height = NUM2INT(rb_iv_get(pixbuf, "@picture_height"));
+	pixels = (unsigned char*) RSTRING(rb_iv_get(pixbuf,"@pixels"))->ptr +
+		NUM2INT(rb_iv_get(pixbuf, "@ofs0"));
+	rowstride = NUM2INT(rb_funcall(pixbuf, rb_intern("rowstride"), 0));
+	pix_len = NUM2INT(rb_iv_get(pixbuf, "@pix_length"));
+	mask = NUM2LONG(rb_iv_get(pixbuf, "@pix_mask"));
+	clr_id = (*((long*) (pixels + y0*rowstride + x0*pix_len))) &
+		mask;
+	for ( adj = adjs; adj < a_end; adj++ ) {
+		x = x0 + NUM2INT(rb_funcall(*adj, id_x, 0));
+		y = y0 + NUM2INT(rb_funcall(*adj, id_y, 0));
+		if (x >= 0 && x < width && y >= 0 && y <= height &&
+		((*((long*)(pixels+y*rowstride+x*pix_len))) & mask) == clr_id )
+			rb_ary_push(res, rb_funcall(pixbuf, id_get_pix, 2,
+				INT2NUM(x), INT2NUM(y)));
+	}
+	return res;
+}
+
+VALUE prb_pixbuf_pix_adj_cocolor8(VALUE self)
+{
+	VALUE		pixbuf, res;
+	int		adj_cnt, x0, y0, x, y;
+	const int	*adj, *a_end;
+	unsigned char	*pixels;
+	int		rowstride, pix_len;
+	long		clr_id, mask;
+	ID		id_get_pix = rb_intern("get_pix");
+	
+	pixbuf = rb_iv_get(self, "@pixbuf");
+	x0 = NUM2INT(rb_funcall(self, rb_intern("x"), 0));
+	y0 = NUM2INT(rb_funcall(self, rb_intern("y"), 0));
+	adj_cnt = PRB_PIX_ADJS8(x0, y0, 0, 0,
+		NUM2INT(rb_iv_get(pixbuf, "@picture_width"))-1,
+		NUM2INT(rb_iv_get(pixbuf, "@picture_height"))-1, adj);
+	a_end = adj + 2*adj_cnt;
+	pixels = (unsigned char*) RSTRING(rb_iv_get(pixbuf,"@pixels"))->ptr +
+		NUM2INT(rb_iv_get(pixbuf, "@ofs0"));
+	rowstride = NUM2INT(rb_funcall(pixbuf, rb_intern("rowstride"), 0));
+	pix_len = NUM2INT(rb_iv_get(pixbuf, "@pix_length"));
+	mask = NUM2LONG(rb_iv_get(pixbuf, "@pix_mask"));
+	clr_id = (*((long*) (pixels + y0*rowstride + x0*pix_len))) & mask;
+	res = rb_ary_new2(adj_cnt);
+	for ( ; adj < a_end; adj++ ) {
+		x = x0 + *adj; adj++; y = y0 + *adj;
+		if ( ((*((long*)(pixels+y*rowstride+x*pix_len))) & mask) ==
+		clr_id )
+			rb_ary_push(res, rb_funcall(pixbuf, id_get_pix, 2,
+				INT2NUM(x), INT2NUM(y)));
+	}
+	return res;
+}
+
+VALUE prb_pixbuf_pix_adj_cocolor4(VALUE self)
+{
+	VALUE		pixbuf, res;
+	int		adj_cnt, x0, y0, x, y;
+	const int	*adj, *a_end;
+	unsigned char	*pixels;
+	int		rowstride, pix_len;
+	long		clr_id, mask;
+	ID		id_get_pix = rb_intern("get_pix");
+	
+	pixbuf = rb_iv_get(self, "@pixbuf");
+	x0 = NUM2INT(rb_funcall(self, rb_intern("x"), 0));
+	y0 = NUM2INT(rb_funcall(self, rb_intern("y"), 0));
+	adj_cnt = PRB_PIX_ADJS4(x0, y0, 0, 0,
+		NUM2INT(rb_iv_get(pixbuf, "@picture_width"))-1,
+		NUM2INT(rb_iv_get(pixbuf, "@picture_height"))-1, adj);
+	a_end = adj + 2*adj_cnt;
+	pixels = (unsigned char*) RSTRING(rb_iv_get(pixbuf,"@pixels"))->ptr +
+		NUM2INT(rb_iv_get(pixbuf, "@ofs0"));
+	rowstride = NUM2INT(rb_funcall(pixbuf, rb_intern("rowstride"), 0));
+	pix_len = NUM2INT(rb_iv_get(pixbuf, "@pix_length"));
+	mask = NUM2LONG(rb_iv_get(pixbuf, "@pix_mask"));
+	clr_id = (*((long*) (pixels + y0*rowstride + x0*pix_len))) & mask;
+	res = rb_ary_new2(adj_cnt);
+	for ( ; adj < a_end; adj++ ) {
+		x = x0 + *adj; adj++; y = y0 + *adj;
+		if ( ((*((long*)(pixels+y*rowstride+x*pix_len))) & mask) ==
+		clr_id )
+			rb_ary_push(res, rb_funcall(pixbuf, id_get_pix, 2,
+				INT2NUM(x), INT2NUM(y)));
+	}
+	return res;
+}
+
+VALUE
+prb_pixbuf_pix_adj_fuzzy_rgb_cocolor
+(VALUE self, VALUE adjacents, VALUE rb_r_toler, VALUE rb_g_toler,
+ VALUE rb_b_toler)
+{
+	VALUE		res = rb_ary_new2(RARRAY(adjacents)->len), pixbuf, *adj,
+			*adjs = RARRAY(adjacents)->ptr,
+			*a_end = adjs + RARRAY(adjacents)->len;
+	unsigned char	*pixels, *pix_ptr;
+	int		rowstride, pix_len, width, height, x0,y0, x, y, r, g, b,
+			r_toler = NUM2INT(rb_r_toler),
+			g_toler = NUM2INT(rb_g_toler),
+			b_toler = NUM2INT(rb_b_toler);
+	ID		id_x = rb_intern("x"), id_y = rb_intern("y"),
+			id_get_pix = rb_intern("get_pix");
+	
+	pixbuf = rb_iv_get(self, "@pixbuf");
+	x0 = NUM2INT(rb_funcall(self, id_x, 0));
+	y0 = NUM2INT(rb_funcall(self, id_y, 0));
+	width = NUM2INT(rb_iv_get(pixbuf, "@picture_width"));
+	height = NUM2INT(rb_iv_get(pixbuf, "@picture_height"));
+	pixels = (unsigned char *) RSTRING(rb_iv_get(pixbuf,"@pixels"))->ptr +
+		NUM2INT(rb_iv_get(pixbuf, "@ofs0"));
+	rowstride = NUM2INT(rb_funcall(pixbuf, rb_intern("rowstride"), 0));
+	pix_len = NUM2INT(rb_iv_get(pixbuf, "@pix_length"));
+	pix_ptr = pixels + y0*rowstride + x0*pix_len;
+	r = pix_ptr[0]; g = pix_ptr[1]; b = pix_ptr[2];
+	for ( adj = adjs; adj < a_end; adj++ ) {
+		x = x0 + NUM2INT(rb_funcall(*adj, id_x, 0));
+		y = y0 + NUM2INT(rb_funcall(*adj, id_y, 0));
+		if (x >= 0 && x < width && y >= 0 && y <= height) {
+		  pix_ptr = pixels + y*rowstride + x*pix_len;
+		  if (abs(r-pix_ptr[0]) < r_toler &&
+		  abs(g-pix_ptr[1]) < g_toler && abs(b-pix_ptr[2]) < b_toler)
+			rb_ary_push(res, rb_funcall(pixbuf, id_get_pix, 2,
+				INT2NUM(x), INT2NUM(y)));
+		}
+	}
+	return res;
+}
+
+VALUE
+prb_pixbuf_pix_adj_fuzzy_hsv_cocolor
+(VALUE self, VALUE adjacents, VALUE rb_h_toler, VALUE rb_s_toler,
+ VALUE rb_v_toler)
+{
+	VALUE		res = rb_ary_new2(RARRAY(adjacents)->len), pixbuf, *adj,
+			*adjs = RARRAY(adjacents)->ptr,
+			*a_end = adjs + RARRAY(adjacents)->len;
+	unsigned char	*pixels, *pix_ptr;
+	int		rowstride, pix_len, width, height, x0, y0, x, y;
+	double		h, s, v, th, ts, tv, h_toler =RFLOAT(rb_h_toler)->value,
+			s_toler = RFLOAT(rb_s_toler)->value,
+			v_toler = RFLOAT(rb_v_toler)->value;
+	ID		id_x = rb_intern("x"), id_y = rb_intern("y"),
+			id_get_pix = rb_intern("get_pix");
+	
+	pixbuf = rb_iv_get(self, "@pixbuf");
+	x0 = NUM2INT(rb_funcall(self, id_x, 0));
+	y0 = NUM2INT(rb_funcall(self, id_y, 0));
+	width = NUM2INT(rb_iv_get(pixbuf, "@picture_width"));
+	height = NUM2INT(rb_iv_get(pixbuf, "@picture_height"));
+	pixels = (unsigned char*) RSTRING(rb_iv_get(pixbuf,"@pixels"))->ptr +
+		NUM2INT(rb_iv_get(pixbuf, "@ofs0"));
+	rowstride = NUM2INT(rb_funcall(pixbuf, rb_intern("rowstride"), 0));
+	pix_len = NUM2INT(rb_iv_get(pixbuf, "@pix_length"));
+	pix_ptr = pixels + y0*rowstride + x0*pix_len;
+	prb_color_rgb_to_hsv(pix_ptr[0], pix_ptr[1], pix_ptr[2], &h, &s, &v);
+	for ( adj = adjs; adj < a_end; adj++ ) {
+		x = x0 + NUM2INT(rb_funcall(*adj, id_x, 0));
+		y = y0 + NUM2INT(rb_funcall(*adj, id_y, 0));
+		if (x >= 0 && x < width && y >= 0 && y <= height) {
+		  pix_ptr = pixels + y*rowstride + x*pix_len;
+		  prb_color_rgb_to_hsv(pix_ptr[0], pix_ptr[1], pix_ptr[2],
+				  &th, &ts, &tv);
+		  if (fabs(h-th) < h_toler && fabs(s-ts) < s_toler &&
+		  fabs(v-tv) < v_toler)
+			rb_ary_push(res, rb_funcall(pixbuf, id_get_pix, 2,
+				INT2NUM(x), INT2NUM(y)));
+		}
+	}
+	return res;
+}
+
+VALUE prb_pixbuf_pixels_ptr(VALUE self)
+{
+	VALUE		glib_ptr;
+	unsigned char	**pixels;
+	
+	glib_ptr = rb_funcall(self, rb_intern("get_property"), 1,
+			rb_str_new2("pixels"));
+	Data_Get_Struct(glib_ptr, unsigned char*, pixels);
+	return INT2NUM((long) pixels);
+}
+
+VALUE prb_pixbuf_pixels(VALUE self)
+{
+	return rb_iv_get(self, "@pixels");
+}
+
+VALUE prb_pixbuf_sample_length(VALUE self)
+{
+	return rb_iv_get(self, "@sample_length");
+}
+
+VALUE prb_pixbuf_pix_length(VALUE self)
+{
+	return rb_iv_get(self, "@pix_length");
+}
+
+VALUE prb_pixbuf_picture_width(VALUE self)
+{
+	return rb_iv_get(self, "@picture_width");
+}
+
+VALUE prb_pixbuf_picture_height(VALUE self)
+{
+	return rb_iv_get(self, "@picture_height");
+}
+
+VALUE prb_pixbuf_ofs0(VALUE self)
+{
+	return rb_iv_get(self, "@ofs0");
+}
+
+VALUE prb_pixbuf_pix_mask(VALUE self)
+{
+	return rb_iv_get(self, "@pix_mask");
+}
+
+VALUE prb_pixbuf_border_width(VALUE self)
+{
+	return rb_iv_get(self, "@border_width");
+}
+
+static void prb_pixbuf_do_init(VALUE self)
+{
+	VALUE		glib_ptr, rb_width, rb_height;
+	unsigned char	**pixels;
+	int		width, height, rowstride, n_channels, bits_per_sample,
+			sample_len, pix_len, i;
+	long		pix_mask;
+	
+	glib_ptr = rb_funcall(self, rb_intern("get_property"), 1,
+			rb_str_new2("pixels"));
+	Data_Get_Struct(glib_ptr, unsigned char*, pixels);
+	rb_width = rb_funcall(self, rb_intern("width"), 0);
+	width = NUM2INT(rb_width);
+	rb_height = rb_funcall(self, rb_intern("height"), 0);
+	height = NUM2INT(rb_height);
+	rowstride = NUM2INT(rb_funcall(self, rb_intern("rowstride"), 0));
+	n_channels = NUM2INT(rb_funcall(self, rb_intern("n_channels"), 0));
+	bits_per_sample = NUM2INT(rb_funcall(self, rb_intern("bits_per_sample"),
+				0));
+	
+	if (bits_per_sample % 8)
+		rb_raise(rb_eNotImpError, "bits_per_sample = %i",
+				bits_per_sample);
+	rb_iv_set(self, "@pixels", prb_cstr_new1((char*) pixels, height > 0 ?
+		(height-1)*rowstride + width*
+		((n_channels * bits_per_sample + 7)/8) : 0, self));
+	rb_iv_set(self,"@sample_length",INT2NUM(sample_len=bits_per_sample>>3));
+	rb_iv_set(self, "@pix_length", INT2NUM(pix_len=sample_len*n_channels));
+	rb_iv_set(self, "@picture_width", rb_width);
+	rb_iv_set(self, "@picture_height", rb_height);
+	rb_iv_set(self, "@border_width", INT2NUM(0));
+	rb_iv_set(self, "@ofs0", INT2NUM(0));
+	pix_mask = 0;
+	for ( i = 0; i < pix_len; i++ ) {
+		pix_mask = (pix_mask << 8) | 0xff;
+	}
+	rb_iv_set(self, "@pix_mask", LONG2NUM(pix_mask));
+}
+
+VALUE prb_pixbuf_init(int argc, VALUE *argv, VALUE self)
+{
+	rb_call_super(argc, argv);
+	prb_pixbuf_do_init(self);
+	return Qnil;
+}
+
+VALUE prb_pixbuf_get_pix(VALUE self, VALUE x, VALUE y)
+{
+	return rb_funcall(prb_cPPix_PixbufPix, rb_intern("new"), 3, self, x, y);
+}
+
+VALUE prb_pixbuf_dup(VALUE self)
+{
+	VALUE 	res, rb_width, rb_height;
+	int	height;
+	
+	rb_width = rb_funcall(self, rb_intern("width"), 0);
+	rb_height = rb_funcall(self, rb_intern("height"), 0);
+	res = rb_funcall(prb_cPPix_Pixbuf, rb_intern("new"), 5,
+		rb_funcall(self, rb_intern("colorspace"), 0),
+		rb_funcall(self, rb_intern("has_alpha?"), 0),
+		rb_funcall(self, rb_intern("bits_per_sample"), 0),
+		rb_width, rb_height);
+	rb_iv_set(res, "@border_width", rb_iv_get(self, "@border_width"));
+	rb_iv_set(res, "@ofs0", rb_iv_get(self, "@ofs0"));
+	height = NUM2INT(rb_height);
+	memcpy(RSTRING(rb_iv_get(res, "@pixels"))->ptr,
+		RSTRING(rb_iv_get(self, "@pixels"))->ptr,
+		height > 0 ? (height-1)*NUM2INT(rb_funcall(self,
+		rb_intern("rowstride"), 0)) + NUM2INT(rb_width)*NUM2INT(
+		rb_iv_get(self, "@pix_length")) : 0);
+	return res;
+}
+
+VALUE prb_pixbuf_scale(int argc, VALUE *argv, VALUE self)
+{
+	VALUE 	res;
+	
+	res = rb_call_super(argc, argv);
+	RBASIC(res)->klass = prb_cPPix_Pixbuf;
+	prb_pixbuf_do_init(res);
+	return res;
+}
+
+VALUE prb_pixbuf_add_border(VALUE self, VALUE rb_b_width)
+{
+	int		width, height, rowstride, b_width = NUM2INT(rb_b_width),
+			row_len, new_rowstride, new_width, new_height, pix_len,
+			t_skip, margin_len;
+	unsigned char	*pixels, *src_pix, *src0;
+	VALUE		res;
+	
+	if ( b_width < 0 )
+		rb_raise(rb_eNotImpError, "Negative width=%i", b_width);
+	if ( b_width == 0 )
+		return rb_funcall(self, rb_intern("dup"), 0);
+	width = NUM2INT(rb_funcall(self, rb_intern("width"), 0));
+	height = NUM2INT(rb_funcall(self, rb_intern("height"), 0));
+	rowstride = NUM2INT(rb_funcall(self, rb_intern("rowstride"), 0));
+	pix_len = NUM2INT(rb_iv_get(self, "@pix_length"));
+	new_width = width + 2*b_width;
+	new_height = height + 2*b_width;
+	res = rb_funcall(self, rb_intern("scale"), 3, INT2NUM(new_width),
+		INT2NUM(new_height),
+		rb_eval_string("Gdk::Pixbuf::INTERP_TILES"));
+	pixels = (unsigned char*) RSTRING(rb_iv_get(res, "@pixels"))->ptr;
+	new_rowstride = NUM2INT(rb_funcall(res, rb_intern("rowstride"), 0));
+	row_len = pix_len * width;
+	margin_len = pix_len * b_width;
+	t_skip = new_rowstride - row_len - margin_len;
+	memset(pixels, 0, b_width*new_rowstride);
+	pixels += (height + b_width)*new_rowstride;
+	memset(pixels, 0, (b_width-1)*new_rowstride + new_width*pix_len);
+	src0 = (unsigned char*) RSTRING(rb_iv_get(self,"@pixels"))->ptr;
+	for ( src_pix = src0 +(height-1)*rowstride; src_pix >= src0;
+	src_pix -= rowstride ) {
+		pixels -= t_skip;
+		memset(pixels, 0, t_skip); pixels -= row_len;
+		memmove(pixels, src_pix, row_len); pixels -= margin_len;
+		memset(pixels, 0, margin_len);
+	}
+	rb_iv_set(res, "@ofs0", LONG2NUM(NUM2LONG(rb_iv_get(self, "@ofs0")) +
+			b_width*(new_rowstride + pix_len)));
+	rb_iv_set(res, "@border_width",INT2NUM(
+			NUM2INT(rb_iv_get(self,"@border_width")) + b_width));
+	rb_iv_set(res, "@picture_width", rb_iv_get(self, "@picture_width"));
+	rb_iv_set(res, "@picture_height", rb_iv_get(self, "@picture_height"));
+	return res;
+}
+
+/*
+VALUE
+prb_pixbuf_subpixbuf
+(VALUE self, VALUE r_x, VALUE r_y, VALUE r_width, VALUE r_height)
+{
+	VALUE		res, args, rb_rowstride;
+	unsigned char	*pixels;
+	int		rowstride, pix_len, x = NUM2INT(r_x), y = NUM2INT(r_y),
+			width = NUM2INT(r_width), height = NUM2INT(r_height),
+			self_width, self_height;
+	
+	pixels = RSTRING(rb_iv_get(self,"@pixels"))->ptr;
+	self_width = NUM2INT(rb_funcall(self, rb_intern("width"), 0));
+	self_height = NUM2INT(rb_funcall(self, rb_intern("height"), 0));
+	if ( x >= self_width )
+		rb_raise(rb_eArgError, "x(%i) >= width(%i)", x, self_width);
+	if ( y >= self_height )
+		rb_raise(rb_eArgError, "y(%i) >= height", y, self_height);
+	rb_rowstride = rb_funcall(self, rb_intern("rowstride"), 0);
+	rowstride = NUM2INT(rb_rowstride);
+	pix_len = NUM2INT(rb_iv_get(self, "@pix_length"));
+	args = rb_hash_new();
+	if ( x + width > self_width )
+		width = self_width - x;
+	if ( y + height > self_height )
+		height = self_height - y;
+	rb_hash_aset(args, rb_str_new2("colorspace"), rb_funcall(self,
+			rb_intern("colorspace"), 0));
+	rb_hash_aset(args, rb_str_new2("has_alpha"), rb_funcall(self,
+			rb_intern("has_alpha?"), 0));
+	rb_hash_aset(args, rb_str_new2("bits_per_sample"), rb_funcall(self,
+			rb_intern("bits_per_sample"), 0));
+	rb_hash_aset(args, rb_str_new2("width"), INT2NUM(width));
+	rb_hash_aset(args, rb_str_new2("height"), INT2NUM(height));
+	rb_hash_aset(args, rb_str_new2("rowstride"), rb_rowstride);
+	rb_hash_aset(args, rb_str_new2("pixels"), prb_cstr_new1(pixels +
+		y*rowstride + x*pix_len,
+		height > 0 ? (height-1)*rowstride + width*pix_len : 0, self));
+	res =rb_funcall(rb_eval_string("Gdk::Pixbuf"),rb_intern("new!"),1,args);
+	RBASIC(res)->klass = prb_cPPix_Pixbuf;
+	prb_pixbuf_do_init(res);
+	return res;
+}
+*/
+
+VALUE
+prb_pixbuf_scaled
+(VALUE self, VALUE r_kx, VALUE r_ky, VALUE r_x, VALUE r_y, VALUE r_width,
+ VALUE r_height, VALUE r_interp)
+{
+	VALUE	res_pb;
+	
+	res_pb = rb_funcall(prb_cPPix_Pixbuf, rb_intern("new"), 5,
+		rb_funcall(self, rb_intern("colorspace"),0),
+		rb_funcall(self, rb_intern("has_alpha?"), 0),
+		rb_funcall(self, rb_intern("bits_per_sample"), 0),
+		INT2NUM(NUM2INT(r_width)+1),INT2NUM(NUM2INT(r_height)+1));
+	rb_funcall(res_pb, rb_intern("scale!"), 10,self, INT2NUM(0), INT2NUM(0),
+		r_width,r_height, rb_float_new(-NUM2INT(r_x)),
+		rb_float_new(-NUM2INT(r_y)), r_kx, r_ky, r_interp);
+	return res_pb;
+}
+
+VALUE
+prb_pixbuf_gdk_scaled
+(VALUE self, VALUE r_kx, VALUE r_ky, VALUE r_x, VALUE r_y, VALUE r_width,
+ VALUE r_height, VALUE r_interp)
+{
+	VALUE	res_pb;
+	
+	res_pb = rb_funcall(rb_eval_string("Gdk::Pixbuf"), rb_intern("new"), 5,
+		rb_funcall(self, rb_intern("colorspace"),0),
+		rb_funcall(self, rb_intern("has_alpha?"), 0),
+		rb_funcall(self, rb_intern("bits_per_sample"), 0),
+		INT2NUM(NUM2INT(r_width)+1),INT2NUM(NUM2INT(r_height)+1));
+	rb_funcall(res_pb, rb_intern("scale!"), 10,self, INT2NUM(0), INT2NUM(0),
+		r_width,r_height, rb_float_new(-NUM2INT(r_x)),
+		rb_float_new(-NUM2INT(r_y)), r_kx, r_ky, r_interp);
+	return res_pb;
+}