extract_curves 0.0.1

data/CVS/Entries

@@ -0,0 +1,4 @@
+/extract_curves.gemspec/1.1.1.1/Tue Nov 15 17:32:08 2005//
+D/bin////
+D/ruby_ext////
+D/ruby_libs////

data/CVS/Repository

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

data/CVS/Root

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

data/bin/CVS/Entries

@@ -0,0 +1,5 @@
+/ec_rect2polar.rb/1.1.1.1/Tue Nov 15 17:32:11 2005//
+/ec_rev_lines.rb/1.1.1.1/Tue Nov 15 17:32:11 2005//
+/ec_sph_area.rb/1.1.1.1/Tue Nov 15 17:32:11 2005//
+/extract_curves.rb/1.1.1.1/Tue Nov 15 17:32:11 2005//
+D/tests////

data/bin/CVS/Repository

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

data/bin/CVS/Root

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

data/bin/ec_rect2polar.rb

@@ -0,0 +1,22 @@
+#!/usr/bin/ruby
+
+require 'complex'
+require 'pav/floatsio'
+
+x0, y0, kr, ktheta, format_str = *ARGV
+unless x0 && y0
+	puts "Usage: #{File.basename($0)} x_0 y_0 [k_r [k_theta [format_str]]]"
+	puts "  (x_0, y_0) = Projection of the zero pole."
+	puts "  k_r, k_theta = Coefficients for the linear (r, theta) pixel " +
+		"coordinates."
+	exit 1
+end
+x0 = x0.to_f; y0 = y0.to_f
+kr ? kr = kr.to_f : kr = 1.0
+ktheta ? ktheta = ktheta.to_f : ktheta = 1.0
+format_str = "%.29g\t%.29g" unless format_str
+
+FloatsInp.new($stdin).each_rec { |rec| x, y = *rec
+	r, theta = *Complex(x-x0, y-y0).polar
+	puts format_str % [theta * ktheta, r * kr]
+}

data/bin/ec_rev_lines.rb

@@ -0,0 +1,5 @@
+#!/usr/bin/ruby -w
+
+lns = $stdin.readlines
+lns.reverse!
+print lns

data/bin/ec_sph_area.rb

@@ -0,0 +1,30 @@
+#!/usr/bin/ruby
+
+require 'pav/floatsio'
+
+format_str = *ARGV
+if ARGV.include?("--usage") || ARGV.include?("--help")
+	puts "Usage: #{File.basename($0)} [format_str]"
+	puts "  Calculates the area of a spherical polygon given by "
+	puts "  (azimuth; angular distance from the pole) points in steradians."
+	exit 1
+end
+format_str = "%.30g" unless format_str
+
+area = 0.0
+EPS = 1e-300
+inp = FloatsInp.new($stdin)
+az0, d0 = inp.get_rec
+inp.each_rec { |rec| az, d = *rec
+	#puts "d0=#{d0.inspect}, az0=#{az0.inspect}, d=#{d.inspect}, az=#{
+	#	az.inspect}"
+	if (d - d0).abs < EPS
+		term = Math.cos( (d+d0)/2.0 )
+	else
+		term = (Math.sin(d) - Math.sin(d0)) / (d - d0)
+	end
+	area += (az - az0) * (1.0 - term)
+	d0 = d; az0 = az
+}
+
+puts format_str % area

data/bin/extract_curves.rb

@@ -0,0 +1,2145 @@
+#!/usr/bin/ruby
+
+require 'gtk2'
+
+if str = Gtk.check_version(2, 6, 0)
+	puts "This program requires GTK+ 2.6.0 or later"
+	puts str
+	exit
+end
+
+require 'thread'
+require 'pav/pix'
+require 'pav/dbg_log'
+require 'pav/floatsio'
+require 'pav/pix/blob'
+require 'pav/pix/curve'
+require 'pav/gtk/icons'
+require 'pav/attr_cache'
+require 'pav/string/ext'
+require 'pav/gtk/toolbar'
+require 'pav/pix/contour'
+require 'pav/pix/img_obj'
+require 'pav/string/words'
+require 'pav/pix/shaved_core'
+
+Gtk.init
+
+module PPix
+
+class Blob
+	attr_accessor :extract_curves_args
+end
+
+class Curve
+	self.img_obj_add_to_sub_objs :shaved_core
+	
+	def shaved_core
+		ec =self.curve_carpet.blob.extract_curves_args['extract_curves']
+		self.c_shaved_core(ec.min_hair_len, ec.min_hair_lp_len)
+	end
+	
+	def delete_shaved_core
+		self.c_delete_shaved_core
+	end
+end
+
+end
+
+class ECLogProgrBar < PLogProgrBar
+	attr_reader :progr_bar, :progr_box, :progr_label
+	
+	def initialize(dbg_log, progr_bar, progr_label, progr_box)
+		super(dbg_log)
+		@progr_bar = progr_bar
+		@progr_label = progr_label
+		@progr_box = progr_box
+		@progr_label.text = ""
+		@progr_bar.orientation = @progr_bar_orientation = 0
+		@progr_bar.fraction = 0.0
+		@progr_bar.show_text = false
+		@progr_box.pack_start(@progr_bar)
+		@progr_box.pack_start(@progr_label, false, false)
+		@tot_progr_units = 100.0
+		i = -1
+		Gtk.main_iteration_do(false) while (i += 1) < 10 &&
+			Gtk.events_pending?
+	end
+	
+	def total_progr_units=(val)
+		super(val)
+		if val
+			@progr_bar.show_text = true
+		else
+			@progr_bar.show_text = false
+		end
+		i = -1
+		Gtk.main_iteration_do(false) while (i += 1) < 10 &&
+			Gtk.events_pending?
+	end
+	
+	def disp_progr(progr_units_change)
+		if self.total_progr_units
+			if self.show_as[0,1] == "%"
+				pct =  self.fmt_str % (100.0*self.progr_units /
+					self.total_progr_units)
+			else
+				pct = "#{self.progr_units}/#{
+					self.total_progr_units}"
+			end
+			pct += self.show_as[1, self.show_as.length-1]
+			@progr_bar.fraction = Float(self.progr_units) /
+				self.total_progr_units
+		else
+			while self.progr_units > @tot_progr_units
+				@tot_progr_units *= 2
+				@progr_bar_orientation += 1
+			end
+			if self.show_as[0,1] == "%"
+				pct = ""
+			else
+				pct = "#{self.progr_units}" +
+					self.show_as[1,self.show_as.length-1]
+			end
+			@progr_bar.fraction = Float(self.progr_units) /
+				@tot_progr_units
+			@progr_bar.orientation = @progr_bar_orientation %= 2
+		end
+		@progr_label.text = pct
+		i = -1
+		Gtk.main_iteration_do(false) while (i += 1) < 10 &&
+			Gtk.events_pending?
+	end
+	
+	def finish
+		super
+		@progr_box.remove(@progr_label)
+		@progr_box.remove(@progr_bar)
+		i = -1
+		Gtk.main_iteration_do(false) while (i += 1) < 10 &&
+			Gtk.events_pending?
+	end
+end
+
+class StatusbarIO < IO
+	attr_reader :dbg_log, :statusbar, :tee_to, :last_ln
+	
+	def initialize(dbg_log, statusbar, tee_to=nil)
+		@dbg_log = dbg_log
+		@statusbar = statusbar
+		@tee_to = tee_to
+		@last_ln = ""
+	end
+	
+	def print_to_statusbar(str)
+		(@last_ln + str).each_line { |ln| @last_ln = ln }
+		@last_ln.eval_backspace!(@dbg_log.backspc)
+		@statusbar.pop(0)
+		@statusbar.push(0, @last_ln.chomp)
+		i = -1
+		Gtk.main_iteration_do(false) while (i += 1) < 10 &&
+			Gtk.events_pending?
+	end
+	
+	def print(str)
+		@tee_to.print(str) if @tee_to
+		self.print_to_statusbar(str)
+	end
+	
+	def puts(str)
+		@tee_to.puts(str) if @tee_to
+		self.print_to_statusbar(str)
+	end
+	
+	def tty?
+		if @tee_to
+			@tee_to.tty?
+		else
+			true
+		end
+	end
+end
+
+class ExtractCurvesApp < Gtk::Window
+	VERSION = [0, 0, 1]
+	VERSION_SUFFIX = "-beta"
+	MARK_WAYS = ["mark", "blink", "trace"]
+	
+	attr_reader :min_hair_len, :min_hair_lp_len
+	
+	def initialize
+		@job = nil
+		@in_progr = Mutex.new
+		@pixbuf = nil
+		@pixbuf_backing = @pixbuf_marked = @pixbuf_blinking = nil
+		@pixbuf_marked_objs = []
+		@pixbuf_blinking_objs = []
+		@pixbuf_traced_objs = []
+		@pixbuf_traced_obj_i = @pixbuf_traced_pix_i = 0
+		@blink_area = @blink_area_rect = nil
+		@drw_area_in_procs = false
+		@blob = nil
+		@external_contours = true
+		@min_hair_len = 10
+		@min_hair_lp_len = 10
+		@min_subblob_size = 1
+		@min_outer_lp_length = 0
+		@mark_blob = {""=>"blink"}
+		@pixels_mark_proc = proc { |pix| self.pixels_mark(pix) }
+		@pixels_unmark_proc = proc { |pix| self.pixels_unmark(pix) }
+		@fuzzy_clr_r = @fuzzy_clr_g = @fuzzy_clr_b = 10
+		@fuzzy_clr_h = @fuzzy_clr_s = @fuzzy_clr_v = 0.0
+		@clr_match_scheme = "rgb"
+		@clr_show_scheme = "rgb"
+		@pix_trace_tm_out = 100
+		@contour_geometry = 8
+		@ctxt_menu_m_cb = self.method("ctxt_menu_m_cb").to_proc
+		@ctxt_menu_d_cb = self.method("ctxt_menu_d_cb").to_proc
+		@ctxt_menu_s_cb = self.method("ctxt_menu_s_cb").to_proc
+		@ctxt_menu_e_cb = self.method("ctxt_menu_e_cb").to_proc
+		super(Gtk::Window::TOPLEVEL)
+		self.set_title("Extract Curves")
+		begin
+		  icon = Gdk::Pixbuf.new(PGtk.find_icon_file(
+		   'pav/icons/extract_curves/extract_curves-icon-rgb.ppm').to_s)
+		  self.set_icon(icon)
+		rescue IOError, Gdk::PixbufError
+		  warn self.class.name + ".initialize: Error: Failed to load " +
+		  	"icon:\n" + $!.class.name + ": #{$!}\n\tfrom " +
+			$!.backtrace.join("\n\tfrom ")
+		end
+		@trace_mark = Gdk::Pixbuf.new(PGtk.find_icon_file(
+			'pav/icons/extract_curves/trace_mark.xpm'))
+		quit_cb = proc { self.destroy; true }
+		signal_connect('delete_event', &quit_cb)
+		set_default_size(450, 450)
+		
+		# Root container:
+		table = Gtk::Table.new(1, 4, false)
+		add(table)
+		
+		# Menubar:
+		accel_group = Gtk::AccelGroup.new
+		add_accel_group(accel_group)
+		open_cb = self.method("open_cb").to_proc
+		load_blob_cb = self.method('load_blob_cb').to_proc
+		save_cb = proc { |*args|
+			objs = @pixbuf_marked_objs + @pixbuf_blinking_objs +
+				@pixbuf_traced_objs
+			return if objs.empty?
+			self.save_img_obj(*objs)
+		}
+		cancel_cb = proc { |*args| Thread.kill(@job) if @job }
+		ctxt_cb = proc { |*args| self.img_pop_context_menu  }
+		del_cb = proc { |*args| return unless @blob
+			self.img_exit_blob
+			@pixbuf.delete_blob(@blob)
+			self.del_blob
+			@blob = nil
+		}
+		zoom_100_cb = proc { |widget, event|
+			win, x, y, state = @drw_area.window.pointer
+			width = @drw_area.allocation.width
+			height = @drw_area.allocation.height
+			if x >= 0 && x < width && y >= 0 && y < height
+				@scrl_win.window.cursor = Gdk::Cursor.new(
+					Gdk::Cursor::TARGET)
+			end
+			self.drw_area_in_procs = true
+			@spinbtn_x.value = 1
+			@spinbtn_y.value = 1
+			self.drw_area_in_procs = false
+			@scrl_win.window.cursor = nil }
+		zoom_fit_cb = proc { |widget, event|
+		  if @pixbuf
+			win, x, y, state = @drw_area.window.pointer
+			width = @drw_area.allocation.width
+			height = @drw_area.allocation.height
+			if x >= 0 && x < width && y >= 0 && y < height
+				@scrl_win.window.cursor = Gdk::Cursor.new(
+					Gdk::Cursor::TARGET)
+			end
+			self.drw_area_in_procs = true
+			k = [Float(@scrl_win.allocation.width-10)/@pixbuf.width,
+			  Float(@scrl_win.allocation.height-10)/@pixbuf.height].
+			  min
+			@spinbtn_x.value = k
+			@spinbtn_y.value = k
+			self.drw_area_in_procs = false
+			@scrl_win.window.cursor = nil
+		  end
+		}
+		zoom_in_cb = proc { |widget, event|
+			win, x, y, state = @drw_area.window.pointer
+			width = @drw_area.allocation.width
+			height = @drw_area.allocation.height
+			if x >= 0 && x < width && y >= 0 && y < height
+				@scrl_win.window.cursor = Gdk::Cursor.new(
+					Gdk::Cursor::TARGET)
+			end
+			self.drw_area_in_procs = true
+			@spinbtn_x.value = @kx*1.5
+			@spinbtn_y.value = @ky*1.5
+			self.drw_area_in_procs = false
+			@scrl_win.window.cursor = nil }
+		zoom_out_cb = proc { |wgt, ev|
+			win, x, y, state = @drw_area.window.pointer
+			width = @drw_area.allocation.width
+			height = @drw_area.allocation.height
+			if x >= 0 && x < width && y >= 0 && y < height
+				@scrl_win.window.cursor = Gdk::Cursor.new(
+					Gdk::Cursor::TARGET)
+			end
+			self.drw_area_in_procs = true
+			@spinbtn_x.value = @kx/1.5
+			@spinbtn_y.value = @ky/1.5
+			self.drw_area_in_procs = false
+			@scrl_win.window.cursor = nil }
+		item_factory = Gtk::ItemFactory.new(
+			Gtk::ItemFactory::TYPE_MENU_BAR, '<main>', accel_group)
+		item_factory.create_items([
+			["/_File"],
+			["/File/_Open ...",  "<StockItem>", "<control>O",
+			 Gtk::Stock::OPEN, open_cb],
+			["/File/_Load blob ...", "<StockItem>", "<control>L",
+			 Gtk::Stock::OPEN, load_blob_cb],
+			["/File/_Save ...",  "<StockItem>", "<control>S",
+			 Gtk::Stock::SAVE, save_cb],
+			["/File/sep1",   "<Separator>", nil, nil],
+			["/File/_Quit",  "<StockItem>", "<control>Q",
+			 Gtk::Stock::QUIT, quit_cb],
+			["/_Edit"],
+			["/Edit/_Select blob"],
+			["/Edit/_Delete blob", "<StockItem>", "KP_Delete", 
+			 Gtk::Stock::DELETE, del_cb],
+			["/Edit/Cont_ext menu ...", "<Item>", "<control>E",
+			 nil, ctxt_cb],
+			["/_View"],
+			["/View/_Center selection", "<StockItem>", "c",
+			 Gtk::Stock::FIND,
+			 self.method('center_selection_cb').to_proc],
+			["/View/Center _marked", "<StockItem>", "<control>M",
+			 Gtk::Stock::FIND,self.method('center_objs_cb').to_proc,
+			 @pixbuf_marked_objs],
+			["/View/Center _blinking", "<StockItem>", "<control>B",
+			 Gtk::Stock::FIND,self.method('center_objs_cb').to_proc,
+			 @pixbuf_blinking_objs],
+			["/View/Center _traced", "<StockItem>", "<control>T",
+			 Gtk::Stock::FIND,self.method('center_objs_cb').to_proc,
+			 @pixbuf_traced_objs],
+			["/View/Zoom _100", "<StockItem>", "equal",
+			 Gtk::Stock::ZOOM_100, zoom_100_cb],
+			["/View/Zoom _fit", "<StockItem>", "asterisk",
+			 Gtk::Stock::ZOOM_FIT, zoom_fit_cb],
+			["/View/Zoom _in", "<StockItem>", "plus",
+			 Gtk::Stock::ZOOM_IN, zoom_in_cb],
+			["/View/Zoom _out", "<StockItem>", "minus",
+			 Gtk::Stock::ZOOM_OUT, zoom_out_cb],
+			["/_Help"],
+			["/Help/_About",  "<StockItem>", nil, Gtk::Stock::ABOUT,
+			                   self.method("about_cb").to_proc],
+		])
+		@select_blob_menu_branch = item_factory.get_widget(
+			'<main>/Edit').children.first
+		table.attach(item_factory.get_widget('<main>'),
+			# X direction            # Y direction
+			0, 1,                    0, 1,
+			Gtk::EXPAND | Gtk::FILL, 0,
+			0,                       0)
+		
+		# Toolbars:
+		tooltips = Gtk::Tooltips.new
+		tb_box = Gtk::HBox.new(false, 3)
+		toolbar = PGtk::Toolbar.new
+		toolbar.append(Gtk::Stock::OPEN,
+			"Open image file for curve recognition (^O)", &open_cb)
+		toolbar.append(Gtk::Stock::SAVE,
+		  "Save all marked, blinking and traced image objects to a " +
+			"file (^S)",
+		  &save_cb)
+		#toolbar.append(Gtk::Stock::CANCEL,
+		#  "Cancel the last started operation (^C)", &cancel_cb)
+		toolbar.append_space
+		toolbar.append(Gtk::Stock::QUIT, "Quit program (^Q)", &quit_cb)
+		tb_box.pack_start(toolbar, false, false)
+		# Options toolbar:
+		subtb = PGtk::Toolbar.new
+		subtb.dir_size_request = 400
+		tb_box.pack_start(subtb, true, true)
+		# Trace delay:
+		vbox = Gtk::VBox.new(true, 1)
+		subtb.append(vbox, "Time in miliseconds between the display " +
+			"of two subsequent pixels in an image object when " +
+			"tracing.", nil)
+		label = Gtk::Label.new("Trace delay:")
+		vbox.pack_start(label, false, false)
+		@trace_delay_adj = Gtk::Adjustment.new(@pix_trace_tm_out, 10.0,
+			100000.0, 1.0, 50.0, 50.0)
+		@trace_delay_spinbtn = Gtk::SpinButton.new(@trace_delay_adj,0,0)
+		tooltips.set_tip(@trace_delay_spinbtn, "Time in miliseconds " +
+			"spent by the tracing pixel at a given pixel position "+
+			"before moving to the next one when tracing an image " +
+			"object.", nil)
+		@trace_delay_adj.signal_connect("value_changed") { |wgt, ev|
+			self.pix_trace_tm_out=@trace_delay_spinbtn.value }
+		vbox.pack_start(@trace_delay_spinbtn, false, false)
+		# Compare pixel color to:
+		cmp_pix_clr_to_cb = proc { |data, wgt|
+			@cmp_pix_to = Gtk::ItemFactory.path_from_widget(wgt)
+			@cmp_pix_to[0, '<cmp_to>/'.length] = ''
+			if @cmp_pix_to == 'Blob mean color in circle; R='
+				@cmp_pix_hbox.pack_start(
+					@pix_cmp_circ_r_spinbtn)
+			else
+				@cmp_pix_hbox.remove(@pix_cmp_circ_r_spinbtn)
+			end
+		}
+		vbox = Gtk::VBox.new(true, 1)
+		subtb.append_space
+		subtb.append(vbox)
+		label = Gtk::Label.new("Compare matched pixel's color to:")
+		vbox.pack_start(label, true, true, 0)
+		@cmp_pix_hbox = Gtk::HBox.new(false, 0)
+		vbox.pack_start(@cmp_pix_hbox, true, true, 0)
+		optmenu = Gtk::OptionMenu.new
+		item_factory = Gtk::ItemFactory.new(Gtk::ItemFactory::TYPE_MENU,
+			'<cmp_to>', accel_group)
+		item_factory.create_items([
+			['/'+(@cmp_pix_to="Blob 8 neighbors' colors"), "<Item>",
+				nil, nil, cmp_pix_clr_to_cb],
+			["/Blob 4 neighbors' colors", "<Item>", nil, nil,
+				cmp_pix_clr_to_cb],
+			["/Blob mean color", "<Item>", nil, nil,
+				cmp_pix_clr_to_cb],
+			["/Blob mean color in circle; R=", "<Item>", nil, nil,
+				cmp_pix_clr_to_cb],
+		])
+		optmenu.menu = item_factory.get_widget('<cmp_to>')
+		@cmp_pix_hbox.pack_start(optmenu, false, false, 0)
+		adj = Gtk::Adjustment.new(1.0,1.0,1e6,1.0,10.0,1.0)
+		@pix_cmp_circ_r_spinbtn = Gtk::SpinButton.new(adj, 0, 0)
+		@cmp_pix_hbox.pack_start(@pix_cmp_circ_r_spinbtn,false,false,0)
+		# Color match tolerance:
+		match_clr_scheme_cb = proc { |data, wgt|
+			if Gtk::ItemFactory.path_from_widget(wgt).ends_with(
+			"RGB")
+				return if @clr_match_scheme == "rgb"
+				@clr_match_scheme = "rgb"
+				@clr_match_vbox.remove(@hsv_item_box)
+				@clr_match_vbox.pack_start(@rgb_item_box)
+			else
+				return if @clr_match_scheme == "hsv"
+				@clr_match_scheme = "hsv"
+				@clr_match_vbox.remove(@rgb_item_box)
+				@clr_match_vbox.pack_start(@hsv_item_box)
+			end
+		}
+		@clr_match_vbox = Gtk::VBox.new(true, 1)
+		label = Gtk::Label.new("Color matching tolerance:")
+		@clr_match_vbox.pack_start(label)
+		optmenu = Gtk::OptionMenu.new
+		item_factory = Gtk::ItemFactory.new(Gtk::ItemFactory::TYPE_MENU,
+			'<clr_scheme>', accel_group)
+		item_factory.create_items([
+			["/RGB", "<Item>", nil, nil, match_clr_scheme_cb],
+			["/HSV", "<Item>", nil, nil, match_clr_scheme_cb],
+		])
+		optmenu.menu = item_factory.get_widget('<clr_scheme>')
+		subtb.append_space
+		subtb.append(optmenu)
+		@rgb_item_box = Gtk::HBox.new(true, 2)
+		@clr_match_vbox.pack_start(@rgb_item_box, false, false)
+		#@clr_match_vbox.attach(@rgb_item_box, 0,1, 1,2, 0, 0, 0, 0)
+		subtb.append(@clr_match_vbox, nil, nil)
+		# Red:
+		hbox = Gtk::HBox.new(false, 1)
+		label = Gtk::Label.new("R:"); label.set_alignment(0, 0.5)
+		hbox.pack_start(label, false, false)
+		@fuzzy_clr_adj_r=Gtk::Adjustment.new(@fuzzy_clr_r, 0.0, 255.0,
+			1.0, 10.0, 1.0)
+		@fuzzy_clr_spinbtn_r = Gtk::SpinButton.new(@fuzzy_clr_adj_r,0,0)
+		tooltips.set_tip(@fuzzy_clr_spinbtn_r, ttip="When identifying "+
+			"a blob, match adjacent pixels whose color components "+
+			"differ not more than these settings.", nil)
+		@fuzzy_clr_adj_r.signal_connect("value_changed") { |wgt, ev|
+			@fuzzy_clr_r=@fuzzy_clr_spinbtn_r.value_as_int }
+		hbox.pack_start(@fuzzy_clr_spinbtn_r, false, false)
+		@rgb_item_box.pack_start(hbox)
+		# Green:
+		hbox = Gtk::HBox.new(false, 1)
+		label = Gtk::Label.new("G:"); label.set_alignment(0, 0.5)
+		hbox.pack_start(label, false, false)
+		@fuzzy_clr_adj_g=Gtk::Adjustment.new(@fuzzy_clr_g, 0.0, 255.0,
+			1.0, 10.0, 1.0)
+		@fuzzy_clr_spinbtn_g = Gtk::SpinButton.new(@fuzzy_clr_adj_g,0,0)
+		tooltips.set_tip(@fuzzy_clr_spinbtn_g, ttip, nil)
+		@fuzzy_clr_adj_g.signal_connect("value_changed") { |wgt, ev|
+			@fuzzy_clr_g=@fuzzy_clr_spinbtn_g.value_as_int }
+		hbox.pack_start(@fuzzy_clr_spinbtn_g, false, false)
+		@rgb_item_box.pack_start(hbox)
+		# Blue:
+		hbox = Gtk::HBox.new(false, 1)
+		label = Gtk::Label.new("B:"); label.set_alignment(0, 0.5)
+		hbox.pack_start(label, false, false)
+		@fuzzy_clr_adj_b=Gtk::Adjustment.new(@fuzzy_clr_b, 0.0, 255.0,
+			1.0, 10.0, 1.0)
+		@fuzzy_clr_spinbtn_b = Gtk::SpinButton.new(@fuzzy_clr_adj_b,0,0)
+		tooltips.set_tip(@fuzzy_clr_spinbtn_b, ttip, nil)
+		@fuzzy_clr_adj_b.signal_connect("value_changed") { |wgt, ev|
+			@fuzzy_clr_b=@fuzzy_clr_spinbtn_b.value_as_int }
+		hbox.pack_start(@fuzzy_clr_spinbtn_b, false, false)
+		@rgb_item_box.pack_start(hbox)
+		# Hue:
+		@hsv_item_box = Gtk::HBox.new(true, 2)
+		hbox = Gtk::HBox.new(false, 1)
+		label = Gtk::Label.new("H:"); label.set_alignment(0, 0.5)
+		hbox.pack_start(label, false, false)
+		@fuzzy_clr_adj_h=Gtk::Adjustment.new(0.0,0.0,360.0,1.0,10.0,1.0)
+		@fuzzy_clr_spinbtn_h = Gtk::SpinButton.new(@fuzzy_clr_adj_h,0,0)
+		tooltips.set_tip(@fuzzy_clr_spinbtn_h, ttip, nil)
+		@fuzzy_clr_adj_h.signal_connect("value_changed") { |wgt, ev|
+			@fuzzy_clr_h=@fuzzy_clr_spinbtn_h.value / 360.0 }
+		hbox.pack_start(@fuzzy_clr_spinbtn_h, false, false)
+		@hsv_item_box.pack_start(hbox)
+		# Saturation:
+		hbox = Gtk::HBox.new(false, 1)
+		label = Gtk::Label.new("S:"); label.set_alignment(0, 0.5)
+		hbox.pack_start(label, false, false)
+		@fuzzy_clr_adj_s=Gtk::Adjustment.new(0.0,0.0,100.0,1.0,10.0,1.0)
+		@fuzzy_clr_spinbtn_s = Gtk::SpinButton.new(@fuzzy_clr_adj_s,0,0)
+		tooltips.set_tip(@fuzzy_clr_spinbtn_s, ttip, nil)
+		@fuzzy_clr_adj_s.signal_connect("value_changed") { |wgt, ev|
+			@fuzzy_clr_s=@fuzzy_clr_spinbtn_s.value / 100.0 }
+		hbox.pack_start(@fuzzy_clr_spinbtn_s, false, false)
+		@hsv_item_box.pack_start(hbox)
+		# Value:
+		hbox = Gtk::HBox.new(false, 1)
+		label = Gtk::Label.new("V:"); label.set_alignment(0, 0.5)
+		hbox.pack_start(label, false, false)
+		@fuzzy_clr_adj_v=Gtk::Adjustment.new(0.0,0.0,100.0,1.0,10.0,1.0)
+		@fuzzy_clr_spinbtn_v = Gtk::SpinButton.new(@fuzzy_clr_adj_v,0,0)
+		tooltips.set_tip(@fuzzy_clr_spinbtn_v, ttip, nil)
+		@fuzzy_clr_adj_v.signal_connect("value_changed") { |wgt, ev|
+			@fuzzy_clr_v=@fuzzy_clr_spinbtn_v.value / 100.0 }
+		hbox.pack_start(@fuzzy_clr_spinbtn_v, false, false)
+		@hsv_item_box.pack_start(hbox)
+		@clr_match_vbox.pack_start(@hsv_item_box, false, false)
+		# Contour geometry:
+		ctr_geom_cb = proc { |data, wgt|
+			@contour_geometry = Gtk::ItemFactory.path_from_widget(
+				wgt)[-1,1].to_i
+		}
+		optmenu = Gtk::OptionMenu.new
+		item_factory = Gtk::ItemFactory.new(Gtk::ItemFactory::TYPE_MENU,
+			'<ctr_geom>', accel_group)
+		item_factory.create_items([
+			["/8", "<Item>", nil, nil, ctr_geom_cb],
+			["/4", "<Item>", nil, nil, ctr_geom_cb],
+		])
+		optmenu.menu = item_factory.get_widget('<ctr_geom>')
+		hbox = Gtk::HBox.new(false, 1)
+		hbox.pack_start(Gtk::Label.new("Contour\ngeometry:"),true,true)
+		hbox.pack_start(optmenu)
+		subtb.append_space
+		subtb.append(hbox)
+		# External contours?
+		btn = Gtk::CheckButton.new("E_xternal\ncontours")
+		btn.active = @external_contours = true
+		subtb.append_space
+		subtb.append(btn)
+		btn.signal_connect('clicked') { |wgt|
+			@external_contours = wgt.active? }
+		
+		# Min. subblob size, outer lp len, hair length, ...:
+		vbox = Gtk::VBox.new(true, 1)
+		subtb.append_space
+		subtb.append(vbox, nil, nil)
+		# Min. subblob size:
+		hbox = Gtk::HBox.new(false, 1)
+		#vbox.pack_start(hbox, false, false)
+		label = Gtk::Label.new("Min. subblob size:")
+		label.set_alignment(0.5, 0.5)
+		vbox.pack_start(label, false, false)
+		vbox.pack_start(hbox, false, false)
+		adj = Gtk::Adjustment.new(@min_subblob_size, 1.0, 1e12,
+			1.0, 100.0, 0.0)
+		@min_subblob_size_spinbtn = Gtk::SpinButton.new(adj, 0, 0)
+		@min_subblob_size_spinbtn.set_snap_to_ticks(true)
+		tooltips.set_tip(@min_subblob_size_spinbtn, "Blobs surrounded "+
+			"by a blob in detection, containing less than these " +
+			"many pixels will be incorporated in the surronding " +
+			"blob.", nil)
+		hbox.pack_start(@min_subblob_size_spinbtn, false, false)
+		adj.signal_connect("value_changed") { |wgt, ev|
+			@min_subblob_size = @min_subblob_size_spinbtn.value.to_i
+		}
+		label = Gtk::Label.new("pix"); label.set_alignment(0, 0.5)
+		hbox.pack_start(label, false, false)
+		# Min. outer loop length:
+		vbox = Gtk::VBox.new(true, 1)
+		subtb.append_space
+		subtb.append(vbox, nil, nil)
+		label = Gtk::Label.new("Min. outer loop len.:")
+		label.set_alignment(0.5, 0.5)
+		vbox.pack_start(label, false, false)
+		hbox = Gtk::HBox.new(false, 1)
+		vbox.pack_start(hbox, false, false)
+		adj = Gtk::Adjustment.new(@min_outer_lp_length, 1.0, 1e12,
+			1.0, 100.0, 0.0)
+		@min_outer_lp_length_spinbtn = Gtk::SpinButton.new(adj, 0, 0)
+		@min_outer_lp_length_spinbtn.set_snap_to_ticks(true)
+		tooltips.set_tip(@min_outer_lp_length_spinbtn, "Drop loops " +
+			"from a blob's outer contour carpet of length less " +
+			"than this one.", nil)
+		hbox.pack_start(@min_outer_lp_length_spinbtn, false, false)
+		adj.signal_connect("value_changed") { |wgt, ev|
+			@min_outer_lp_length =
+				@min_outer_lp_length_spinbtn.value.to_i
+		}
+		label = Gtk::Label.new("pix"); label.set_alignment(0, 0.5)
+		hbox.pack_start(label, false, false)
+		# Min. hair length:
+		vbox = Gtk::VBox.new(true, 1)
+		subtb.append_space
+		subtb.append(vbox, nil, nil)
+		hbox = Gtk::HBox.new(false, 1)
+		vbox.pack_start(hbox, true, true)
+		label = Gtk::Label.new("Min. hair length:")
+		label.set_alignment(0.5, 0.5)
+		hbox.pack_start(label, true, true)
+		hbox = Gtk::HBox.new(false, 1)
+		vbox.pack_start(hbox, false, false)
+		adj = Gtk::Adjustment.new(@min_hair_len, 0.0, 1e12,
+			1.0, 100.0, 0.0)
+		@min_hair_len_spinbtn = Gtk::SpinButton.new(adj, 0, 0)
+		@min_hair_len_spinbtn.set_snap_to_ticks(false)
+		tooltips.set_tip(@min_hair_len_spinbtn, "Branches of the " +
+			"curve of length less than this one will be shaved " +
+			"off for curve's shaved core.", nil)
+		hbox.pack_start(@min_hair_len_spinbtn, false, false)
+		adj.signal_connect("value_changed") { |wgt, ev|
+			@min_hair_len = @min_hair_len_spinbtn.value }
+		label = Gtk::Label.new("pix")
+		label.set_alignment(0, 0.5)
+		hbox.pack_start(label, false, false)
+		# Min. hair loop length:
+		vbox = Gtk::VBox.new(true, 1)
+		subtb.append_space
+		subtb.append(vbox, nil, nil)
+		hbox = Gtk::HBox.new(false, 1)
+		vbox.pack_start(hbox, false, false)
+		label = Gtk::Label.new("Min. hair loop len.:")
+		label.set_alignment(0.5, 0.5)
+		hbox.pack_end(label, false, false)
+		hbox = Gtk::HBox.new(false, 1)
+		vbox.pack_start(hbox, false, false)
+		adj = Gtk::Adjustment.new(@min_hair_lp_len, 0.0, 1e12,
+			1.0, 100.0, 0.0)
+		@min_hair_lp_len_spinbtn = Gtk::SpinButton.new(adj, 0, 0)
+		@min_hair_lp_len_spinbtn.set_snap_to_ticks(false)
+		tooltips.set_tip(@min_hair_lp_len_spinbtn, "Shortest loops of "+
+			"the curve of length less than this one will be " +
+			"deloopified for curve's shaved core.", nil)
+		hbox.pack_start(@min_hair_lp_len_spinbtn, false, false)
+		adj.signal_connect("value_changed") { |wgt, ev|
+			@min_hair_lp_len = @min_hair_lp_len_spinbtn.value }
+		label = Gtk::Label.new("pix")
+		label.set_alignment(0, 0.5)
+		hbox.pack_start(label, false, false)
+		
+		table.attach(tb_box,
+			# X direction            # Y direction
+			0, 1,                    1, 2,
+			Gtk::EXPAND | Gtk::FILL, 0,
+			0,                       0)
+		
+		# Image display frame:
+		@scrl_win = Gtk::ScrolledWindow.new
+		@scrl_win.set_policy(Gtk::POLICY_AUTOMATIC,
+			Gtk::POLICY_AUTOMATIC)
+		@scrl_win.shadow_type = Gtk::SHADOW_IN
+		table.attach(@scrl_win,
+			# X direction            # Y direction
+			0, 1,                    2, 3,
+			Gtk::EXPAND | Gtk::FILL, Gtk::EXPAND | Gtk::FILL,
+			0,                       0)
+		self.set_default_size(200, 200)
+		@drw_area = Gtk::DrawingArea.new
+		@scrl_win.add_with_viewport(@drw_area)
+		img_expose_cb = self.method("img_expose_cb").to_proc
+		img_motion_notify_cb=self.method("img_motion_notify_cb").to_proc
+		img_button_press_cb = self.method("img_button_press_cb").to_proc
+		@drw_area.signal_connect('expose_event', &img_expose_cb)
+		@drw_area.signal_connect('motion_notify_event',
+			&img_motion_notify_cb)
+		@drw_area.signal_connect('button_press_event',
+			&img_button_press_cb)
+		@drw_area.events |=	Gdk::Event::LEAVE_NOTIFY_MASK |
+					Gdk::Event::BUTTON_PRESS_MASK |
+					Gdk::Event::POINTER_MOTION_MASK |
+					Gdk::Event::POINTER_MOTION_HINT_MASK
+		@scrl_win.hadjustment.signal_connect('value_changed',
+			&img_motion_notify_cb)
+		@scrl_win.vadjustment.signal_connect('value_changed',
+			&img_motion_notify_cb)
+		
+		# x, y, kx, ky, statusbar:
+		bottom_box = Gtk::VBox.new(false, 3)
+		@progr_bar = Gtk::ProgressBar.new
+		@progr_label = Gtk::Label.new
+		@progr_bar_box = Gtk::HBox.new(false, 0)
+		@progr_bar_box.pack_start(@progr_bar)
+		@progr_bar_box.pack_start(@progr_label, false, false)
+		bottom_box.pack_start(@progr_bar_box)
+		hbox = Gtk::HBox.new(false, 3)
+		bottom_box.pack_start(hbox)
+		table.attach(bottom_box,
+			# X direction            # Y direction
+			0, 1,                    3, 4,
+			Gtk::EXPAND | Gtk::FILL, 0,
+			0,                       0)
+		
+		label = Gtk::Label.new("x="); label.set_alignment(1, 0.5)
+		hbox.pack_start(label, false, false)
+		@label_x = Gtk::Label.new; @label_x.set_alignment(0,0.5)
+		hbox.pack_start(@label_x,false,false)
+		label = Gtk::Label.new("y="); label.set_alignment(1, 0.5)
+		hbox.pack_start(label, false, false)
+		@label_y = Gtk::Label.new; @label_y.set_alignment(0,0.5)
+		hbox.pack_start(@label_y, false, false)
+		
+		# kx:
+		label = Gtk::Label.new("kx=")
+		label.set_alignment(1, 0.5)
+		hbox.pack_start(label, false, false)
+		adj = Gtk::Adjustment.new(1.0, 1.0e-10, 1000.0, 1.0, 5.0, 1.0)
+		@spinbtn_x = Gtk::SpinButton.new(adj, 0, 3)
+		adj.signal_connect("value_changed") { |wgt, ev|
+			self.kx=@spinbtn_x.value }
+		hbox.pack_start(@spinbtn_x, false, false)
+		#@scrl_win.hadjustment.step_increment =
+		@kx = 1
+		
+		# ky:
+		label = Gtk::Label.new("ky=")
+		label.set_alignment(1, 0.5)
+		hbox.pack_start(label, false, false)
+		adj = Gtk::Adjustment.new(1.0, 1.0e-10, 1000.0, 1.0, 5.0, 1.0)
+		@spinbtn_y = Gtk::SpinButton.new(adj, 0, 3)
+		adj.signal_connect("value_changed") { |wgt, ev|
+			self.ky=@spinbtn_y.value }
+		hbox.pack_start(@spinbtn_y, false, false)
+		#@scrl_win.vadjustment.step_increment =
+		@ky = 1
+		
+		# RGB/HSV:
+		show_clr_scheme_cb = proc { |data, wgt|
+			if Gtk::ItemFactory.path_from_widget(wgt).ends_with(
+			"RGB:")
+				@clr_show_scheme = "rgb"
+			else
+				@clr_show_scheme = "hsv"
+			end
+		}
+		optmenu = Gtk::OptionMenu.new
+		item_factory = Gtk::ItemFactory.new(Gtk::ItemFactory::TYPE_MENU,
+			'<clr_scheme>', accel_group)
+		item_factory.create_items([
+			["/RGB:","<Item>","<control>R",nil,show_clr_scheme_cb],
+			["/HSV:","<Item>","<control>H",nil,show_clr_scheme_cb],
+		])
+		optmenu.menu = item_factory.get_widget('<clr_scheme>')
+		hbox.pack_start(optmenu, false, false)
+		@label_clr = Gtk::Label.new
+		@label_clr.width_chars = 11
+		@label_clr.set_alignment(0, 0.5)
+		hbox.pack_start(@label_clr,false,false)
+		
+		# Statusbar:
+		@statusbar = Gtk::Statusbar.new
+		hbox.pack_start(@statusbar, true, true)
+		
+		# Timeout:
+		@prev_traced_x = @prev_traced_y = 0
+		@pix_trace_proc = proc {
+			tx = @prev_traced_x*@kx; ty = @prev_traced_y*@ky
+			if @kx >= @trace_mark.width
+				tw = @kx.ceil
+			else
+				tw = @trace_mark.width
+				tx = tx + @kx/2.0 - tw/2.0 
+			end
+			if @ky >= @trace_mark.height
+				th = @ky.ceil
+			else
+				th = @trace_mark.height
+				ty = ty + @ky/2.0 - th/2.0 
+			end
+			@drw_area.window.invalidate(Gdk::Rectangle.new(tx, ty,
+				tw+1, th+1), false)
+		  	if (obj = @pixbuf_traced_objs[@pixbuf_traced_obj_i])
+				if (@pixbuf_traced_pix_i+=1) >= obj.length
+					if (@pixbuf_traced_obj_i += 1) >=
+					@pixbuf_traced_objs.length
+						@pixbuf_traced_obj_i = 0
+					end
+					@pixbuf_traced_pix_i = 0
+				end
+			else
+				@pixbuf_traced_obj_i = 0
+				@pixbuf_traced_pix_i = 0
+			end
+			if (obj = @pixbuf_traced_objs[@pixbuf_traced_obj_i]) &&
+			(pix = obj[@pixbuf_traced_pix_i])
+				@prev_traced_x = pix.x + @pixbuf.border_width
+				@prev_traced_y = pix.y + @pixbuf.border_width
+				tx = @prev_traced_x*@kx; ty = @prev_traced_y*@ky
+				if @kx >= @trace_mark.width
+					tw = @kx.ceil
+				else
+					tw = @trace_mark.width
+					tx = tx + @kx/2.0 - tw/2.0 
+				end
+				if @ky >= @trace_mark.height
+					th = @ky.ceil
+				else
+					th = @trace_mark.height
+					ty = ty + @ky/2.0 - th/2.0 
+				end
+				@drw_area.window.invalidate(Gdk::Rectangle.new(
+					tx, ty, tw+1, th+1), false)
+			end
+			true
+		}
+		self.add_timeouts
+		
+		signal_connect('destroy'){ self.remove_timeouts; Gtk.main_quit }
+		
+		self.show_all
+		Gtk.main_iteration
+		@cmp_pix_hbox.remove(@pix_cmp_circ_r_spinbtn)
+		@clr_match_vbox.remove(@hsv_item_box)
+		@progr_bar_box.remove(@progr_label)
+		@progr_bar_box.remove(@progr_bar)
+		subtb.hide
+		Gtk.main_iteration
+		if $VERBOSE || $DEBUG
+			tee_to = $stdout
+		else
+			tee_to = nil
+		end
+		#$PDbgLog.outp = StatusbarIO.new($PDbgLog, @statusbar, tee_to)
+		$PDbgLog.progr_class = ECLogProgrBar
+		$PDbgLog.progr_init_args = [@progr_bar, @progr_label,
+			@progr_bar_box]
+	end
+	
+	def add_timeouts
+	  #$PDbgLog.sig_call(self)
+	  #$PDbgLog.puts_msg caller(1).join("\t\n")
+	  unless @blink_timeout_id
+		t = Gdk::Screen.default.get_setting("gtk-cursor-blink-time")
+		@blink_timeout_id = Gtk.timeout_add(t ? t.to_i : 1000) {
+			#return true if @job && @job.alive?
+			if @pixbuf_blinking
+				if @pixbuf_backing.equal?(@pixbuf_blinking)
+					@pixbuf_backing = @pixbuf_marked
+				else
+					@pixbuf_backing = @pixbuf_blinking
+				end
+				@drw_area.window.invalidate(@blink_area_rect,
+					false) if @blink_area_rect
+			end
+			true
+		}
+	  end
+	  unless @pix_trace_timeout_id
+		@pix_trace_timeout_id = Gtk.timeout_add(@pix_trace_tm_out,
+			&@pix_trace_proc)
+	  end
+	  #$PDbgLog.sig_return("Done.")
+	end
+	
+	def remove_timeouts
+		#$PDbgLog.sig_call(self)
+		#$PDbgLog.puts_msg caller(1).join("\t\n")
+		if @blink_timeout_id
+			Gtk.timeout_remove(@blink_timeout_id)
+			@blink_timeout_id = nil
+		end
+		if @pix_trace_timeout_id
+			Gtk.timeout_remove(@pix_trace_timeout_id)
+			@pix_trace_timeout_id = nil
+		end
+		#$PDbgLog.sig_return("Done.")
+	end
+	
+	def show_exc_dialog
+		dialog = Gtk::MessageDialog.new(self,
+			Gtk::Dialog::MODAL | Gtk::Dialog::DESTROY_WITH_PARENT,
+			Gtk::MessageDialog::ERROR,
+			Gtk::MessageDialog::BUTTONS_CLOSE)
+		dialog.title = $!.class.name
+		dialog.markup = "<b>#{$!.class.name}:</b> <b><i>#{$!.to_s}</i></b>\n\tfrom #{$!.backtrace.join("\n\tfrom ")}"
+		dialog.run
+		dialog.destroy
+	end
+	
+	def drw_area_in_procs=(val)
+		if val
+			return if @drw_area_in_procs
+			@drw_area_in_procs = true
+			@scrl_win.freeze_child_notify
+		else
+			return unless @drw_area_in_procs
+			@drw_area_in_procs = false
+			@scrl_win.thaw_child_notify
+			@drw_area.queue_draw
+		end
+	end
+	
+	def pixbuf=(val)
+		@pixbuf_backing = @pixbuf_marked = @pixbuf_blinking = nil
+		@pixbuf = val
+		if @pixbuf.bits_per_sample != 8
+			raise NotImplementError,
+			  "pixbuf with #{@pixbuf.bits_per_sample} bits/sample"
+		end
+		if @pixbuf.n_channels == 3
+			@pixbuf_drw_meth = Gdk::RGB.method("draw_rgb_image")
+		elsif @pixbuf.n_channels == 4
+			@pixbuf_drw_meth = Gdk::RGB.method("draw_rgb_32_image")
+		else
+			raise NotImplementError,
+				"pixbuf with #{@pixbuf.n_channels} channels"
+		end
+		@pixbuf = @pixbuf.add_border(1)
+		@pixbuf_blinking = nil
+		@pixbuf_backing = @pixbuf_marked = @pixbuf.dup
+		@blob = nil
+		@blink_area_rect = nil
+		@pixbuf_marked_objs.clear
+		@pixbuf_blinking_objs.clear
+		@pixbuf_traced_objs.clear
+		@drw_area.set_size_request(@pixbuf.width*@kx,@pixbuf.height*@ky)
+		@scrl_win.queue_draw
+		@label_x.width_chars = @pixbuf.width.to_s.length
+		@label_y.width_chars = @pixbuf.height.to_s.length
+	end
+	
+	def kx=(val)
+		return if val == @kx
+		#@scrl_win.hadjustment.step_increment =
+		dx = val - @kx
+		@kx = val
+		return unless @pixbuf
+		if @blink_area
+			@blink_area_rect = Gdk::Rectangle.new(
+				(@blink_area.x + @pixbuf.border_width)*@kx,
+				(@blink_area.y + @pixbuf.border_width)*@ky,
+				(@blink_area.width*@kx).ceil + 1,
+				(@blink_area.height*@ky).ceil + 1)
+		end
+		win, x, y, state = *@drw_area.window.pointer
+		@drw_area.set_size_request(@pixbuf.width*@kx,@pixbuf.height*@ky)
+		viewport = @scrl_win.children[0]
+		win, vx, vy, state = viewport.window.pointer
+		width = viewport.allocation.width
+		height = viewport.allocation.height
+		if @drw_area.allocation.width > width
+		  if vx >= 0 && vx < width && vy >= 0 && vy < height
+		  	viewport.hadjustment.value += x*dx / (@kx-dx)
+		  else
+		  	k_x = viewport.hadjustment.value + width/2
+		  	viewport.hadjustment.value += k_x*dx / (@kx-dx)
+		  end
+		end
+		@scrl_win.queue_draw
+	end
+	
+	def ky=(val)
+		return if val == @ky
+		#@scrl_win.vadjustment.step_increment =
+		dy = val - @ky
+		@ky = val
+		return unless @pixbuf
+		if @blink_area
+			@blink_area_rect = Gdk::Rectangle.new(
+				(@blink_area.x + @pixbuf.border_width)*@kx,
+				(@blink_area.y + @pixbuf.border_width)*@ky,
+				(@blink_area.width*@kx).ceil + 1,
+				(@blink_area.height*@ky).ceil + 1)
+		end
+		win, x, y, state = *@drw_area.window.pointer
+		@drw_area.set_size_request(@pixbuf.width*@kx,@pixbuf.height*@ky)
+		viewport = @scrl_win.children[0]
+		win, vx, vy, state = viewport.window.pointer
+		width = viewport.allocation.width
+		height = viewport.allocation.height
+		if @drw_area.allocation.height > height
+		  if vx >= 0 && vx < width && vy >= 0 && vy < height
+		  	viewport.vadjustment.value += y*dy / (@ky-dy)
+		  else
+		  	k_y = viewport.vadjustment.value + height/2
+		  	viewport.vadjustment.value += k_y*dy / (@ky-dy)
+		  end
+		end
+		@scrl_win.queue_draw
+	end
+	
+	def pix_trace_tm_out=(val)
+		return if val == @pix_trace_tm_out
+		@pix_trace_tm_out = val
+		if @pix_trace_timeout_id
+			Gtk.timeout_remove(@pix_trace_timeout_id)
+			@pix_trace_timeout_id = Gtk.timeout_add(
+				@pix_trace_tm_out, &@pix_trace_proc)
+		end
+	end
+	
+	def center_selection_cb(*args)
+		min_x = min_y = 1.0/0.0
+		max_x = max_y = 0
+		pr = proc { |obj|
+			min_x = obj.img_obj_min_ax.floor if
+				obj.img_obj_min_ax.floor < min_x
+			max_x = obj.img_obj_max_ax.ceil if
+				obj.img_obj_max_ax.ceil > max_x
+			min_y = obj.img_obj_min_ay.floor if
+				obj.img_obj_min_ay.floor < min_y
+			max_y = obj.img_obj_max_ay.ceil if
+				obj.img_obj_max_ay.ceil > max_y
+		}
+		@pixbuf_marked_objs.each(&pr)
+		@pixbuf_blinking_objs.each(&pr)
+		@pixbuf_traced_objs.each(&pr)
+		c_x = (min_x + max_x) * @kx / 2
+		c_y = (min_y + max_y) * @ky / 2
+		alloc = @scrl_win.children[0].allocation
+		tmp = c_x - alloc.width/2
+		@scrl_win.hadjustment.value = tmp > 0 ? tmp : 0
+		tmp = c_y - alloc.height/2
+		@scrl_win.vadjustment.value = tmp > 0 ? tmp : 0
+	end
+	
+	def center_objs_cb(objs, widget)
+		min_x = min_y = 1.0/0.0
+		max_x = max_y = 0
+		objs.each { |obj|
+			min_x = obj.img_obj_min_ax.floor if
+				obj.img_obj_min_ax.floor < min_x
+			max_x = obj.img_obj_max_ax.ceil if
+				obj.img_obj_max_ax.ceil > max_x
+			min_y = obj.img_obj_min_ay.floor if
+				obj.img_obj_min_ay.floor < min_y
+			max_y = obj.img_obj_max_ay.ceil if
+				obj.img_obj_max_ay.ceil > max_y
+		}
+		c_x = (min_x + max_x) * @kx / 2
+		c_y = (min_y + max_y) * @ky / 2
+		alloc = @scrl_win.children[0].allocation
+		tmp = c_x - alloc.width/2
+		@scrl_win.hadjustment.value = tmp > 0 ? tmp : 0
+		tmp = c_y - alloc.height/2
+		@scrl_win.vadjustment.value = tmp > 0 ? tmp : 0
+	end
+	
+	def write_img_obj(file, obj)
+		#$PDbgLog.sig_call(self)
+		#$PDbgLog.puts_msg "file: #{file.inspect}, obj: #{obj}"
+		obj.each { |pix|
+			file.puts "#{pix.ax}\t#{pix.ay}"
+		}
+		#$PDbgLog.sig_return
+	end
+	
+	def open_imagef(fpath)
+		begin
+			self.pixbuf = PPix::Pixbuf.new(fpath)
+			dir, name = *File.split(fpath)
+			self.title = "#{name} #{@pixbuf.picture_width}x#{
+			  @pixbuf.picture_height} (#{dir}) -- Extract Curves"
+		rescue IOError, Gdk::PixbufError
+			self.show_exc_dialog
+		end
+	end
+	
+	def load_blob_cb(*args)
+		return false unless @pixbuf && @in_progr.try_lock
+		dialog = Gtk::FileChooserDialog.new("Open blob", self,
+			Gtk::FileChooser::ACTION_OPEN, "gnome-vfs",
+			[Gtk::Stock::OPEN, Gtk::Dialog::RESPONSE_ACCEPT],
+			[Gtk::Stock::CANCEL, Gtk::Dialog::RESPONSE_CANCEL])
+		dialog.add_shortcut_folder("/tmp") if File.directory?("/tmp")
+		fpath = nil
+		resp = dialog.run
+		fpath = dialog.filename
+		dialog.destroy
+		i = -1
+		Gtk.main_iteration_do(false) while (i += 1) < 10 &&
+			Gtk.events_pending?
+		if resp != Gtk::Dialog::RESPONSE_ACCEPT || !fpath
+			@in_progr.unlock
+			return
+		end
+		begin
+		  File.open(fpath, 'r') { |f|
+		  	blob = nil
+			FloatsInp.new(f).each_rec { |rec| x, y = *rec
+				x = x.to_i; y = y.to_i
+				next unless x >= 0 && x<@pixbuf.picture_width &&
+					y >= 0 && y < @pixbuf.picture_height &&
+					@pixbuf.blob_id_at?(x, y, 0)
+				unless blob
+					blob_id = @pixbuf.add_blob(blob =
+					  PPix::Blob.new(@pixbuf,
+						@contour_geometry,
+						@external_contours,
+						@min_outer_lp_length))
+					blob.blob_id = blob_id
+				end
+				blob.add(@pixbuf.get_pix(x, y))
+			}
+			if blob
+				self.img_exit_blob
+				@blob = blob
+				@blob.extract_curves_args =
+					{'extract_curves' => self,
+					 'ctxt_menu_known_objs' => Set.new}
+				self.img_enter_blob
+				self.add_blob
+			end
+		  }
+		rescue IOError
+			self.show_exc_dialog
+		ensure
+			@in_progr.unlock
+		end
+	end
+	
+	def open_cb(*args)
+		return false unless @in_progr.try_lock
+		dialog = Gtk::FileChooserDialog.new(
+			"Open raster image file for curve extraction", nil,
+			Gtk::FileChooser::ACTION_OPEN, "gnome-vfs",
+			[Gtk::Stock::OPEN, Gtk::Dialog::RESPONSE_ACCEPT],
+			[Gtk::Stock::CANCEL, Gtk::Dialog::RESPONSE_CANCEL])
+		
+		# Filters:
+		filters = []
+		filter_any = Gtk::FileFilter.new
+		filter_any.name = "Recognized Images"
+		filter_any.add_pixbuf_formats
+		filter = Gtk::FileFilter.new; filter.name = "JPEG"
+		filter.add_pattern(pat="*.jpg"); filter_any.add_pattern(pat)
+		filter.add_pattern(pat="*.JPG"); filter_any.add_pattern(pat)
+		filter.add_pattern(pat="*.jpeg"); filter_any.add_pattern(pat)
+		filter.add_pattern(pat="*.JPEG"); filter_any.add_pattern(pat)
+		filters << filter
+		filter = Gtk::FileFilter.new; filter.name = "GIF"
+		filter.add_pattern(pat="*.gif"); filter_any.add_pattern(pat)
+		filter.add_pattern(pat="*.GIF"); filter_any.add_pattern(pat)
+		filters << filter
+		filter = Gtk::FileFilter.new; filter.name = "BitMap"
+		filter.add_pattern(pat="*.bmp"); filter_any.add_pattern(pat)
+		filter.add_pattern(pat="*.BMP"); filter_any.add_pattern(pat)
+		filters << filter
+		filter = Gtk::FileFilter.new; filter.name = "Portable PixMap"
+		filter.add_pattern(pat="*.ppm"); filter_any.add_pattern(pat)
+		filter.add_pattern(pat="*.PPM"); filter_any.add_pattern(pat)
+		filters << filter
+		filter = Gtk::FileFilter.new
+		filter.name = "Portable Network Graphics"
+		filter.add_pattern(pat="*.png"); filter_any.add_pattern(pat)
+		filter.add_pattern(pat="*.PNG"); filter_any.add_pattern(pat)
+		filters << filter
+		dialog.add_filter(filter_any)
+		filter = Gtk::FileFilter.new; filter.name = "All files"
+		filter.add_pattern("*")
+		dialog.add_filter(filter)
+		filters.each { |f| dialog.add_filter(f) }
+		
+		dialog.add_shortcut_folder("/tmp") if File.directory?("/tmp")
+		fpath = nil
+		resp = dialog.run
+		fpath = dialog.filename
+		dialog.destroy
+		i = -1
+		Gtk.main_iteration_do(false) while (i += 1) < 10 &&
+			Gtk.events_pending?
+		if resp != Gtk::Dialog::RESPONSE_ACCEPT || !fpath
+			@in_progr.unlock
+			return
+		end
+		begin
+			self.open_imagef(fpath)
+		ensure
+			@in_progr.unlock
+		end
+	end
+	
+	def arr_del_obj(arr, which)
+		#$PDbgLog.sig_call(self)
+		obj_i = nil
+		arr.each_with_index { |obj, idx|
+			#$PDbgLog.print_msg " obj#{idx}:%x" % obj.object_id
+			if obj.equal?(which)
+				obj_i = idx
+				break
+			end
+		}
+		if obj_i
+			#$PDbgLog.print_msg "; obj_i=#{obj_i}"
+			arr[obj_i,1] = nil
+		else
+			warn "#{self.class.name}.arr_del_obj: Image object "+
+				"to remove not found!"
+		end
+		#$PDbgLog.sig_return
+	end
+	
+	def xy_toggle_buf(buf, x, y, pix_done, rowstride, pix_length)
+		unless pix_done[k=[y, x]]
+			  s = @pixbuf.ofs0 + y*rowstride + x*pix_length
+			  s.upto(s + pix_length - 1) { |i|
+				buf[i] ^= 0xff
+			  }
+			  pix_done[k] = true
+		end
+	end
+	
+	def xy_toggle_2bufs(buf1, buf2, x, y, pix_done, rowstride, pix_length)
+		unless pix_done[k=[y, x]]
+			  s = @pixbuf.ofs0 + y*rowstride + x*pix_length
+			  s.upto(s + pix_length - 1) { |i|
+				buf1[i] ^= 0xff
+				buf2[i] ^= 0xff
+			  }
+			  pix_done[k] = true
+		end
+	end
+	
+	def pixels_mark_toggle(which)
+		#$PDbgLog.sig_call(self)
+		#$PDbgLog.puts_msg("#{which.length} pixel#{
+		#	which.length==1? "" : "s"}")
+		pix_done = {}
+		rowstride = @pixbuf.rowstride; pix_length = @pixbuf.pix_length
+		marked_pix = @pixbuf_marked.pixels
+		if @pixbuf_blinking
+			blinking_pix = @pixbuf_blinking.pixels
+			which.each { |pt| ax, ay = pt.ax, pt.ay
+				x1 = ax.floor; y1 = ay.floor
+				x2 = ax.ceil; y2 = ay.ceil
+				self.xy_toggle_2bufs(marked_pix, blinking_pix,
+					x1, y1, pix_done, rowstride, pix_length)
+				if x1 != x2
+				  if y1 != y2
+					self.xy_toggle_2bufs(marked_pix,
+					  blinking_pix, x2, y1, pix_done,
+					  rowstride, pix_length)
+					self.xy_toggle_2bufs(marked_pix,
+					  blinking_pix, x1, y2, pix_done,
+					  rowstride, pix_length)
+					self.xy_toggle_2bufs(marked_pix,
+					  blinking_pix, x2, y2, pix_done,
+					  rowstride, pix_length)
+				  else
+					self.xy_toggle_2bufs(marked_pix,
+					  blinking_pix, x2, y1, pix_done,
+					  rowstride, pix_length)
+				  end
+				elsif y1 != y2
+					self.xy_toggle_2bufs(marked_pix,
+					  blinking_pix, x1, y2, pix_done,
+					  rowstride, pix_length)
+				end
+			}
+		else
+			which.each { |pt| ax, ay = pt.ax, pt.ay
+				x1 = ax.floor; y1 = ay.floor
+				x2 = ax.ceil; y2 = ay.ceil
+				self.xy_toggle_buf(marked_pix, x1, y1, pix_done,
+					rowstride, pix_length)
+				if x1 != x2
+				  if y1 != y2
+					self.xy_toggle_buf(marked_pix, x2, y1,
+					  pix_done, rowstride, pix_length)
+					self.xy_toggle_buf(marked_pix, x1, y2,
+					  pix_done, rowstride, pix_length)
+					self.xy_toggle_buf(marked_pix, x2, y2,
+					  pix_done, rowstride, pix_length)
+				  else
+					self.xy_toggle_buf(marked_pix, x2, y1,
+					  pix_done, rowstride, pix_length)
+				  end
+				elsif y1 != y2
+					self.xy_toggle_buf(marked_pix, x1, y2,
+					  pix_done, rowstride, pix_length)
+				end
+			}
+		end
+		@drw_area.window.invalidate(Gdk::Rectangle.new(
+			(which.img_obj_min_ax.floor+@pixbuf.border_width)*@kx,
+			(which.img_obj_min_ay.floor+@pixbuf.border_width)*@ky,
+			(which.img_obj_max_ax.ceil+1-which.img_obj_min_x) *@kx,
+			(which.img_obj_max_ay.ceil+1-which.img_obj_min_y) *@ky),
+			false)
+		#$PDbgLog.sig_return
+	end
+	
+	def pixels_blink_toggle(which)
+		unless @pixbuf_blinking
+			@pixbuf_blinking = @pixbuf_marked.dup
+		end
+		pix_done = {}
+		rowstride = @pixbuf.rowstride; pix_length = @pixbuf.pix_length
+		blinking_pix = @pixbuf_blinking.pixels
+		which.each { |pt| ax, ay = pt.ax, pt.ay
+			x1 = ax.floor; y1 = ay.floor
+			x2 = ax.ceil; y2 = ay.ceil
+			self.xy_toggle_buf(blinking_pix, x1, y1, pix_done,
+				rowstride, pix_length)
+			if x1 != x2
+			  if y1 != y2
+				self.xy_toggle_buf(blinking_pix, x2, y1,
+				  pix_done, rowstride, pix_length)
+				self.xy_toggle_buf(blinking_pix, x1, y2,
+				  pix_done, rowstride, pix_length)
+				self.xy_toggle_buf(blinking_pix, x2, y2,
+				  pix_done, rowstride, pix_length)
+			  else
+				self.xy_toggle_buf(blinking_pix, x2, y1,
+				  pix_done, rowstride, pix_length)
+			  end
+			elsif y1 != y2
+				self.xy_toggle_buf(blinking_pix, x1, y2,
+				  pix_done, rowstride, pix_length)
+			end
+		}
+		@drw_area.window.invalidate(Gdk::Rectangle.new(
+			(which.img_obj_min_ax.floor+@pixbuf.border_width)*@kx,
+			(which.img_obj_min_ay.floor+@pixbuf.border_width)*@ky,
+		1+((which.img_obj_max_ax.ceil+1-which.img_obj_min_x)*@kx).ceil,
+		1+((which.img_obj_max_ay.ceil+1-which.img_obj_min_y)*@ky).ceil),
+			false)
+	end
+	
+	def pixels_mark(which)
+		self.pixels_mark_toggle(which)
+		@pixbuf_marked_objs.push(which)
+	end
+	
+	def pixels_unmark(which)
+		self.pixels_mark_toggle(which)
+		self.arr_del_obj(@pixbuf_marked_objs, which)
+	end
+	
+	def pixels_blink(which)
+		self.pixels_blink_toggle(which)
+		@pixbuf_blinking_objs.push(which)
+		return if which.empty?
+		@blink_area = Gdk::Rectangle.new(
+			which.first.x, which.first.y, 0, 0) unless @blink_area
+		end_x = [@blink_area.x + @blink_area.width-1,
+			which.img_obj_max_ax.ceil].max
+		end_y = [@blink_area.y + @blink_area.height-1,
+			which.img_obj_max_ay.ceil].max
+		@blink_area.x = [@blink_area.x, which.img_obj_min_ax.floor].min
+		@blink_area.y = [@blink_area.y, which.img_obj_min_ay.floor].min
+		@blink_area.width = end_x - @blink_area.x + 1
+		@blink_area.height = end_y - @blink_area.y + 1
+		if @blink_area_rect
+			@blink_area_rect.x =
+				(@blink_area.x + @pixbuf.border_width)*@kx
+			@blink_area_rect.width = (@blink_area.width*@kx).ceil+1
+			@blink_area_rect.y =
+				(@blink_area.y + @pixbuf.border_width)*@ky
+			@blink_area_rect.height =(@blink_area.height*@ky).ceil+1
+		else
+			@blink_area_rect = Gdk::Rectangle.new(
+				(@blink_area.x + @pixbuf.border_width)*@kx,
+				(@blink_area.y + @pixbuf.border_width)*@ky,
+				(@blink_area.width*@kx).ceil + 1,
+				(@blink_area.height*@ky).ceil + 1)
+		end
+	end
+	
+	def pixels_unblink(which)
+		self.pixels_blink_toggle(which) if @pixbuf_blinking
+		self.arr_del_obj(@pixbuf_blinking_objs, which)
+		return if which.empty?
+		end_x = @blink_area.x + @blink_area.width - 1
+		end_y = @blink_area.y + @blink_area.height - 1
+		if which.img_obj_max_ax.ceil >= end_x ||
+		which.img_obj_min_ax.floor <= @blink_area.x ||
+		which.img_obj_max_ay.ceil >= end_y ||
+		which.img_obj_min_ay.floor <= @blink_area.y
+		  if @pixbuf_blinking_objs.empty?
+			@blink_area = nil
+			@blink_area_rect = nil
+		  else
+			end_x = @blink_area.x = @pixbuf_blinking_objs[0].first.x
+			end_y = @blink_area.y = @pixbuf_blinking_objs[0].first.y
+			@pixbuf_blinking_objs.each { |obj|
+				@blink_area.x = [@blink_area.x,
+					obj.img_obj_min_ax.floor].min
+				end_x = [end_x, obj.img_obj_max_ax.ceil].max
+				@blink_area.y = [@blink_area.y,
+					obj.img_obj_min_ay.floor].min
+				end_y = [end_y, obj.img_obj_max_ay.ceil].max
+			}
+			@blink_area.width = end_x - @blink_area.x + 1
+			@blink_area.height = end_y - @blink_area.y + 1
+			@blink_area_rect.x =
+				(@blink_area.x + @pixbuf.border_width)*@kx
+			@blink_area_rect.width = (@blink_area.width*@kx).ceil+1
+			@blink_area_rect.y =
+				(@blink_area.y + @pixbuf.border_width)*@ky
+			@blink_area_rect.height =(@blink_area.height*@ky).ceil+1
+		  end
+		end
+	end
+	
+	def pixels_trace(which)
+		@pixbuf_traced_objs.push(which)
+	end
+	
+	def pixels_untrace(which)
+		self.arr_del_obj(@pixbuf_traced_objs, which)
+	end
+	
+	def img_exit_blob
+		#$PDbgLog.sig_call(self)
+		while !@pixbuf_marked_objs.empty?
+		#  $PDbgLog.puts_msg "unmark "+@pixbuf_marked_objs.first.inspect
+			self.pixels_unmark(@pixbuf_marked_objs.first)
+		end
+		while !@pixbuf_blinking_objs.empty?
+			#$PDbgLog.puts_msg "unblink " +
+			#	@pixbuf_blinking_objs.first.inspect
+			self.pixels_unblink(@pixbuf_blinking_objs.first)
+		end
+		while !@pixbuf_traced_objs.empty?
+	#	  $PDbgLog.puts_msg "untrace "+@pixbuf_traced_objs.first.inspect
+			self.pixels_untrace(@pixbuf_traced_objs.first)
+		end
+		#$PDbgLog.sig_call(self)
+	end
+	
+	def ref_img_obj(path)
+		#$PDbgLog.sig_call(self)
+		#$PDbgLog.print_msg "path=#{path.inspect}:"
+		obj = @blob
+		path = path[1...path.length] if path.starts_with("/")
+		while path.length > 0
+			if (i = path.index("/"))
+				attr_name = path[0, i].downcase_first
+				path = path[i+1...path.length]
+			else
+				attr_name = path.downcase_first
+				path = ""
+			end
+			#$PDbgLog.print_msg "obj=#{obj}:methods=#{[obj.
+			#	public_methods.sort-Object.methods].inspect},"
+			#$PDbgLog.print_msg "path=#{path.inspect},attr_name=#{
+			#	attr_name.inspect} "
+			if attr_name =~ /([A-Za-z =?]+) ([0-9]+)/
+				i = $2.to_i
+				attr_name = $1.gsub(" ", "_")
+				#$PDbgLog.print_msg "attr_name=#{attr_name.
+				#	inspect}, i=#{i} "
+				if obj.public_methods.include?(attr_name)
+					obj = obj.send(attr_name)[i]
+				elsif obj.public_methods.include?(mname=
+				attr_name.plural)
+					obj = obj.send(mname)[i]
+				else
+					#$PDbgLog.sig_return(
+					#	"no indexed method: nil")
+					return nil
+				end
+			else
+			  attr_name.gsub!(" ", "_")
+			  if obj.public_methods.include?(attr_name)
+				obj = obj.send(attr_name)
+			  else
+				#$PDbgLog.sig_return("no method #{attr_name.
+				#	inspect}: nil")
+				return nil
+			  end
+			end
+		end
+		#$PDbgLog.sig_return(obj)
+		obj
+	end
+	
+	def img_enter_blob
+		#$PDbgLog.sig_call(self)
+		self.remove_timeouts
+		@mark_blob.each_pair { |path, mw|
+			next if !(obj = self.ref_img_obj(path)) || obj.empty?
+			#$PDbgLog.puts_msg path + ": " + mw
+			self.method("pixels_"+mw).call(obj)
+		}
+		self.add_timeouts
+		#$PDbgLog.sig_return
+	end
+	
+	def img_motion_notify_cb(*args)
+		win, x, y, state = *@drw_area.window.pointer
+		x = (x/@kx).to_i; y = (y/@ky).to_i
+		if !@pixbuf || x < 0 || x >= @pixbuf.width || y < 0 ||
+		y >= @pixbuf.height
+			@label_x.text = "   "
+			@label_y.text = "   "
+			return
+		end
+		@label_x.text = "%-3d" % (rx=x - @pixbuf.border_width)
+		@label_y.text = "%-3d" % (ry=y - @pixbuf.border_width)
+		if rx >= 0 && rx < @pixbuf.picture_width &&
+		ry >= 0 && ry <  @pixbuf.picture_height
+		  rgb = *@pixbuf.get_pix(rx, ry).color_rgb
+		  if @clr_show_scheme == "rgb"
+			clr_text = "%3d,%3d,%3d" % rgb
+		  else
+		  	h, s, v = *@pixbuf.get_pix(rx,ry).color_hsv
+			clr_text = "%3.0f,%3.0f,%3.0f" %
+				[360.0*h, 100.0*s, 100.0*v]
+		  end
+		  bg = "\#%02x%02x%02x" % rgb
+		  fg = "\#%02x%02x%02x" % [rgb[0] > 127 ? 0 : 255,
+			rgb[1] > 127 ? 0 : 255, rgb[2] > 127 ? 0 : 255]
+		  @label_clr.set_markup("<span foreground=\"#{fg
+		  	}\" background=\"#{bg}\">#{clr_text}</span>")
+		end
+		true
+	end
+	
+	def img_expose_cb(drw_area, event)
+		#$PDbgLog.sig_call(self)
+		#$PDbgLog.print_msg "area: #{event.area.x}, #{event.area.y}, #{
+		#	event.area.width}, #{event.area.height}: "
+		if !@pixbuf || !@pixbuf_backing || !@pixbuf_drw_meth ||
+		(x0=event.area.x/@kx) >= @pixbuf.width ||
+		(y0=event.area.y/@ky) >= @pixbuf.height || @drw_area_in_procs
+			#$PDbgLog.sig_return(@drw_area_in_procs)
+			return @drw_area_in_procs
+		end
+		#$PDbgLog.puts_msg "pb_pix_cnt=#{@pixbuf.width*@pixbuf.height}"
+		pb = @pixbuf_backing
+		pb_pix = pb.pixels
+		end_x = (event.area.x + event.area.width-1)/@kx
+		end_y = (event.area.y + event.area.height-1)/@ky
+		end_x = @pixbuf.width-1 if end_x >= @pixbuf.width
+		end_y = @pixbuf.height-1 if end_y >= @pixbuf.height
+		rowstride = @pixbuf.rowstride; pix_length = @pixbuf.pix_length
+		ofs = ofs0 = y0 * rowstride + x0 * pix_length
+		end_ofs = end_y * rowstride + end_x * pix_length
+		width = end_x-x0 + 1; width_stride = width * pix_length
+		height = end_y-y0 + 1
+		t_width_stride = width_stride - pix_length
+		#sub_x0 = @kx - event.area.x % @kx
+		#sub_y0 = @ky - event.area.y % @ky
+		view_width = (width*@kx).ceil + 1
+		view_height = (height*@ky).ceil + 1
+		start_x = event.area.x; start_y = event.area.y
+		#$PDbgLog.print_msg "x0=#{x0}, y0=#{y0}, sub_x0=#{sub_x0
+		#	}, sub_y0=#{sub_y0}, end_x=#{end_x}, end_y=#{end_y
+		#	}, rowstride=#{rowstride}, pix_length=#{pix_length} "
+		if (trc_obj = @pixbuf_traced_objs[@pixbuf_traced_obj_i]) &&
+		(trc_pix = trc_obj[@pixbuf_traced_pix_i]) && (trc_pix_ofs=
+		@pixbuf.ofs0+rowstride*trc_pix.y+pix_length*trc_pix.x) >= ofs0&&
+		trc_pix_ofs <= end_ofs
+			trc_pix_ofs.upto(trc_pix_ofs+pix_length-1) { |tmp_ofs|
+				pb_pix[tmp_ofs] ^= 0xff
+			}
+			tw = @trace_mark.width
+			tx = tx0 = (@kx*(trc_pix.x+@pixbuf.border_width+0.5) -
+				tw/2 - start_x).to_i
+			if tx < 0
+				tw += tx
+				tx = 0
+			end
+			e_x = ((@pixbuf.width+2*@pixbuf.border_width)*@kx).ceil
+			tw = e_x - tx if tx + tw > e_x
+			th = @trace_mark.height
+			ty = ty0 = (@ky*(trc_pix.y+@pixbuf.border_width+0.5) -
+				th/2 - start_y).to_i
+			if ty < 0
+				th += ty
+				ty = 0
+			end
+			e_y = ((@pixbuf.height+2*@pixbuf.border_width)*@ky).ceil
+			th = e_y - ty if ty + th > e_y
+		else
+			trc_pix = nil
+		end
+		sc_pb = pb.gdk_scaled(@kx, @ky, start_x, start_y,
+		  view_width, view_height, @kx < 1 || @ky < 1 ?
+		  Gdk::Pixbuf::INTERP_BILINEAR : Gdk::Pixbuf::INTERP_NEAREST);
+		if trc_pix
+			sc_pb.composite!(@trace_mark,tx,ty, tw,th, tx0,ty0, 1,1,
+			  Gdk::Pixbuf::INTERP_NEAREST, 255)
+			trc_pix_ofs.upto(trc_pix_ofs+pix_length-1) { |tmp_ofs|
+				pb_pix[tmp_ofs] ^= 0xff
+			}
+		end
+		#@pixbuf_drw_meth.call(drw_area.window,drw_area.style.black_gc,
+		#	event.area.x, event.area.y,
+		#	(width-1)*@kx + sub_x0,(height-1)*@ky + sub_y0,
+		#	Gdk::RGB::Dither::NORMAL, pixels, rowstride,
+		#	(width-1)*@kx + sub_x0, (height-1)*@ky + sub_y0)
+		#@pixbuf_drw_meth.call(drw_area.window,drw_area.style.black_gc,
+		#	event.area.x, event.area.y,
+		#	event.area.width, event.area.height,
+		#	Gdk::RGB::Dither::NORMAL, pixels, rowstride,
+		#	event.area.width, event.area.height)
+		@pixbuf_drw_meth.call(drw_area.window,drw_area.style.black_gc,
+			start_x, start_y, view_width, view_height,
+			Gdk::RGB::Dither::NORMAL, sc_pb.pixels, sc_pb.rowstride,
+			view_width, view_height)
+		#$PDbgLog.sig_return
+		true
+	end
+	
+	def add_blob
+		#$PDbgLog.sig_call(self)
+		items = []
+		sel_cb = proc { |bl, wgt|
+			return if bl.equal?(@blob)
+			#$PDbgLog.sig_call(self)
+			#$PDbgLog.puts_msg "bl: #{bl.inspect}"
+			self.img_exit_blob
+			@blob = bl
+			self.img_enter_blob
+			#$PDbgLog.sig_return
+		}
+		if @pixbuf
+			@pixbuf.blob_id2ref_arr.each { |blob|
+				items << ["/Blob #{blob.blob_id} (#{blob.length
+				  } pix)", "<Item>", nil, nil, sel_cb, blob]
+			}
+		end
+		item_factory = Gtk::ItemFactory.new(Gtk::ItemFactory::TYPE_MENU,
+			'<blobs>', nil)
+		item_factory.create_items(items)
+		oldmenu = @select_blob_menu_branch.submenu
+		@select_blob_menu_branch.submenu = item_factory.get_widget(
+			'<blobs>')
+		oldmenu.destroy
+		#$PDbgLog.sig_return
+	end
+	
+	alias_method :del_blob, :add_blob
+	
+	def img_get_objs_at(drw_arr, event)
+		return false unless @pixbuf
+		## Pop the motion event and allow the registering of the next:
+		#win, x, y, state = event.window.pointer
+		x, y = event.x.to_i, event.y.to_i
+		x = (x/@kx).to_i - @pixbuf.border_width
+		y = (y/@ky).to_i - @pixbuf.border_width
+		return true if x < 0 || x >= @pixbuf.picture_width ||
+			y < 0 || y >= @pixbuf.picture_height ||
+			(@blob && @pixbuf.blob_id_at?(x, y, @blob.blob_id))
+		$PDbgLog.sig_call(self)
+		self.img_exit_blob
+		if @cmp_pix_to == "Blob mean color in circle; R="
+			cmp_pix_to = ['Blob mean color in a circle',
+				@pix_cmp_circ_r_spinbtn.value_as_int]
+		else
+			cmp_pix_to = @cmp_pix_to
+		end
+		$PDbgLog.print_msg "Getting blob(#{x}, #{y}): cmp. to: #{
+			cmp_pix_to.inspect}, #{@clr_match_scheme} tolerance: "
+		if @clr_match_scheme == "rgb"
+		  $PDbgLog.print_msg "#{@fuzzy_clr_r},#{@fuzzy_clr_g},#{
+		  	@fuzzy_clr_b}"
+		  toler_1 = @fuzzy_clr_r
+		  toler_2 = @fuzzy_clr_g
+		  toler_3 = @fuzzy_clr_b
+		else
+		  $PDbgLog.print_msg "#{@fuzzy_clr_h},#{@fuzzy_clr_s},#{
+		  	@fuzzy_clr_v}"
+		  toler_1 = @fuzzy_clr_h
+		  toler_2 = @fuzzy_clr_s
+		  toler_3 = @fuzzy_clr_v
+		end
+		$PDbgLog.puts_msg "; contour geometry=#{@contour_geometry
+			}, external contours?=#{@external_contours
+			}, min. subblob size=#{@min_subblob_size}."
+		@blob = @pixbuf.get_pix(x,y).blob(@contour_geometry,
+			@external_contours, @min_subblob_size-1,
+			@min_outer_lp_length, &PPix::Blob.mk_get_neighbs_proc(
+			@clr_match_scheme, cmp_pix_to, toler_1,toler_2,toler_3))
+		@blob.extract_curves_args =
+			{'extract_curves' => self,
+			 'ctxt_menu_known_objs' => Set.new} unless
+			 	@blob.extract_curves_args
+		self.img_enter_blob
+		self.add_blob
+		$PDbgLog.sig_return
+		true
+	end
+	
+	def mark_blob_switch_obj(obj, path, new_mark_way)
+		#$PDbgLog.sig_call(self)
+		#$PDbgLog.print_msg "path=#{path.inspect}"
+		new_mark_way = new_mark_way.downcase
+		return if @mark_blob[path] == new_mark_way ||
+			(!MARK_WAYS.include?(new_mark_way) && !@mark_blob[path])
+		if mw=@mark_blob[path]
+			self.method("pixels_un"+mw).call(obj)
+		end
+		if MARK_WAYS.include?(new_mark_way)
+			self.method("pixels_"+new_mark_way).call(obj)
+			@mark_blob[path] = new_mark_way
+		else
+			@mark_blob.delete(path)
+		end
+		#$PDbgLog.sig_return
+	end
+	
+	def save_img_obj(*objs)
+		dialog = Gtk::FileChooserDialog.new("Save image object to file",
+			nil, Gtk::FileChooser::ACTION_SAVE, "gnome-vfs",
+			[Gtk::Stock::SAVE, Gtk::Dialog::RESPONSE_ACCEPT],
+			[Gtk::Stock::CANCEL, Gtk::Dialog::RESPONSE_CANCEL])
+		resp = dialog.run
+		path = dialog.filename
+		dialog.destroy
+		return if resp != Gtk::Dialog::RESPONSE_ACCEPT
+		if FileTest.exist?(path)
+			dialog = Gtk::Dialog.new('Output File Exists',
+				self, Gtk::Dialog::MODAL |
+				Gtk::Dialog::DESTROY_WITH_PARENT,
+				['_Replace', 0],
+				['_Extend with new objects', 1],
+				[Gtk::Stock::CANCEL, 2])
+			hbox = Gtk::HBox.new(false, 0)
+			hbox.set_border_width(8)
+			dialog.vbox.pack_start(hbox, false, false, 0)
+			hbox.pack_start(Gtk::Image.new(
+			  Gtk::Stock::DIALOG_QUESTION, Gtk::IconSize::DIALOG),
+			  false, false, 0)
+			label = Gtk::Label.new
+			label.markup = "File <b>#{path}</b> already exists."
+			hbox.pack_start(label, false, false, 0)
+			hbox.show_all
+			resp = dialog.run
+			dialog.destroy
+			return if resp == 2
+			mode = ['w', 'a'].at(resp)
+		else
+			mode = 'w'
+		end
+		begin
+			open(path, mode) { |file| objs.each { |obj|
+				self.write_img_obj(file, obj)
+			}}
+		rescue IOError
+			self.show_exc_dialog
+		end
+	end
+	
+	def each_img_obj_with_details(obj, parent, attr_name, attr_key=nil,
+	path="", excl_set={}, &block)
+		#$PDbgLog.sig_call(self)
+		#$PDbgLog.print_msg "path=#{path.inspect}: "
+		obj.get_sub_img_objs(excl_set).each_pair { |name, val|
+			#$PDbgLog.print_msg "#{name} "
+			if val.kind_of?(PPix::ImageObject)
+				self.each_img_obj_with_details(val,obj,name,nil,
+					path+"/"+name.cap_first.gsub("_", " "),
+					excl_set,&block)
+			elsif val.kind_of?(Array)
+				if name[-1,1] == "s"
+					rname = name.singular.cap_first
+				else
+					rname = name.cap_first
+				end
+				rname.gsub!("_", " ")
+				val.each_with_index { |v, i|
+					self.each_img_obj_with_details(v, obj,
+						name, i, path+"/#{rname} #{i}",
+						excl_set, &block)
+				}
+			else
+				warn "#{self.class.name
+				  }.each_img_obj_with_details_: " +
+				  "NotImplementError: Image object container " +
+				  "of type #{val.class.name}; ignoring #{path
+				  }/#{name}"
+			end
+		}
+		yield(obj, parent, attr_name, attr_key, path)
+		#$PDbgLog.sig_return
+	end
+	
+	def ctxt_menu_m_cb(spec, widget)
+		return true unless widget.active?
+		obj, path = *spec
+		mw = Gtk::ItemFactory.path_from_widget(widget)
+		mw = mw['<root>/'.length...mw.length]
+		#$PDbgLog.sig_call(self)
+		#$PDbgLog.puts_msg("path=#{path.inspect}, mw=#{mw}")
+		self.mark_blob_switch_obj(obj, path, mw)
+		#$PDbgLog.sig_return
+		true
+	end
+	
+	def ctxt_menu_d_cb(spec, widget)
+		obj,parent,parent_mfactory,attr_name,path,del_meth,del_args =
+			*spec
+		del_meth.call(*del_args)
+		#$PDbgLog.sig_call(self)
+		if obj.equal?(@blob)
+			self.img_exit_blob
+			self.del_blob
+			@blob = nil
+		else
+			#$PDbgLog.puts_msg "obj: #{obj.object_id
+			#  }, parent: #{parent.object_id}; marked: #{
+			#  @pixbuf_marked_objs.collect { |o|
+			#  o.object_id }.inspect }; blinking: #{
+			#  @pixbuf_blinking_objs.collect { |o|
+			#  o.object_id }.inspect }; traced: #{
+			#  @pixbuf_traced_objs.collect { |o| o.object_id
+			#  }.inspect }"
+			#$PDbgLog.puts_msg(path)
+			pos = nil
+			item = nil
+			parent_menu = parent_mfactory.get_widget('<root>')
+			if obj.kind_of?(Array) || obj.kind_of?(Hash)
+			  dtext = 'Delete ' + attr_name.gsub('_', ' ')
+			  parent_menu.children.each_with_index { |item, pos|
+				next unless (text = item.children[0])
+				text = text.text
+				break if text == dtext
+			  }
+			  parent_menu.remove(item); item.destroy
+			  aname=attr_name.cap_first; aname.gsub!('_',' ')
+			  aname = (aname[-1,1] == 's' ? aname.singular : aname)
+			  aname.concat(' ')
+			  p = parent_menu.children.length
+			  while (p -= 1) >= 0
+			  	i = parent_menu.children.at(p)
+				next unless (text = i.children[0])
+				text = text.text
+			  	self.mark_blob_switch_obj(obj, path+'/'+text,
+					"None")
+				if text.starts_with(aname)
+					pos = p
+					parent_menu.remove(i); i.destroy
+				end
+			  end
+			  if obj.kind_of?(Array)
+				obj.each { |o| @blob.extract_curves_args[
+				  'ctxt_menu_known_objs'].delete(o.object_id) }
+			  else
+				obj.each_value { |o| @blob.extract_curves_args[
+				  'ctxt_menu_known_objs'].delete(o.object_id) }
+			  end
+			  epath = path
+			else
+			  self.mark_blob_switch_obj(obj, path, "None")
+			  parent_menu.children.each_with_index { |item, pos|
+				submenu = item.submenu
+				break if submenu && submenu.children.detect{|ch|
+					ch.object_id == widget.object_id }
+			  }
+			  @blob.extract_curves_args['ctxt_menu_known_objs'].
+				delete(obj.object_id)
+			  parent_menu.remove(item); item.destroy
+			  epath = path[0, path.rindex('/')]
+			end
+			m = attr_name.cap_first; m.gsub!('_', ' ')
+			parent_mfactory.create_item('/'+m, '<StockItem>', nil,
+			  Gtk::Stock::EXECUTE, [parent, attr_name, epath,
+			  parent_mfactory], &@ctxt_menu_e_cb)
+			item = parent_mfactory.get_widget('/'+m)
+			parent_menu.remove(item)
+			parent_menu.insert(item, pos)
+		end
+		#$PDbgLog.sig_return
+		true
+	end
+	
+	def ctxt_menu_s_cb(obj, widget)
+		path = Gtk::ItemFactory.path_from_widget(widget)
+		self.save_img_obj(obj)
+		true
+	end
+	
+	def ctxt_menu_e_cb(spec, widget)
+		pobj, attr_name, path, parent_mfactory = *spec
+		self.remove_timeouts
+		val = pobj.method(attr_name).call
+		self.add_timeouts
+		if @blob.extract_curves_args['ctxt_menu_known_objs'].include?(
+		val.object_id)
+			subitems = []
+		elsif val.kind_of?(PPix::ImageObject)
+			aname=attr_name.cap_first; aname.gsub!('_',' ')
+			subitems = [Gtk::MenuItem.new(aname)]
+			subitems[0].submenu=self.img_obj_mk_ctxt_menu(val, pobj,
+			  parent_mfactory, path + '/' + aname, attr_name, nil)
+			@blob.extract_curves_args['ctxt_menu_known_objs'] <<
+				val.object_id
+		elsif val.kind_of?(Array)
+		  if !val.empty? &&
+		  val.first.kind_of?(PPix::ImageObject)
+			subitems = []
+			aname=attr_name.cap_first; aname.gsub!('_',' ')
+			aname = (aname[-1,1] == 's' ? aname.singular :
+				aname)
+			pfx = path + '/' + aname
+			val.each_with_index { |obj, i| next if obj.empty?
+			  item = Gtk::MenuItem.new(aname + " #{i}")
+			  item.submenu = self.img_obj_mk_ctxt_menu(obj, pobj,
+			    parent_mfactory, pfx + " #{i}", attr_name, i)
+			  subitems << item
+			  @blob.extract_curves_args['ctxt_menu_known_objs'] <<
+				obj.object_id
+			}
+			if pobj.methods.include?(dmeth="delete_"+attr_name)
+				parent_mfactory.create_item(text='/Delete '+
+				  attr_name.gsub('_', ' '), '<StockItem>', '',
+				  Gtk::Stock::DELETE, [val, pobj,
+				  parent_mfactory, attr_name, path,
+				  pobj.method(dmeth), []], &@ctxt_menu_d_cb)
+				item = parent_mfactory.get_widget('<root>'+text)
+				parent_menu=parent_mfactory.get_widget('<root>')
+				parent_menu.remove(item)
+				pos = parent_menu.children.length
+				parent_menu.children.reverse_each { |i|
+					pos -= 1
+					break if i.gtype ==
+					  GLib::Type['GtkRadioMenuItem']
+				}
+				parent_menu.insert(item, pos-MARK_WAYS.length-1)
+			end
+		  end
+		elsif val.kind_of?(Hash)
+		  unless val.empty?
+		   flag = false
+		   val.each_value { |v|
+			flag=v.kind_of?(PPix::ImageObject); break }
+		   if flag
+			subitems = []
+			aname=attr_name.cap_first; aname.gsub!('_',' ')
+			aname = (aname[-1,1] == 's' ? aname.singular :
+				aname)
+			pfx = path + '/' + aname
+			val.each_pair { |key, obj| next if obj.empty?
+			  item = Gtk::MenuItem.new(aname + " #{key}")
+			  item.submenu = self.img_obj_mk_ctxt_menu(obj, pobj,
+			    parent_mfactory, pfx + " #{key}", attr_name, key)
+			  subitems << item
+			  @blob.extract_curves_args['ctxt_menu_known_objs'] <<
+				obj.object_id
+			}
+			if pobj.methods.include?(dmeth="delete_"+attr_name)
+				parent_mfactory.create_item(text='/Delete '+
+				  attr_name.gsub('_', ' '), '<StockItem>', '',
+				  Gtk::Stock::DELETE, [val, pobj,
+				  parent_mfactory, attr_name, path,
+				  pobj.method(dmeth), []], &@ctxt_menu_d_cb)
+				item = parent_mfactory.get_widget('<root>'+text)
+				parent_menu=parent_mfactory.get_widget('<root>')
+				parent_menu.remove(item)
+				pos = parent_menu.children.length
+				parent_menu.children.reverse_each { |i|
+					pos -= 1
+					break if i.gtype ==
+					  GLib::Type['GtkRadioMenuItem']
+				}
+				parent_menu.insert(item, pos-MARK_WAYS.length-1)
+			end
+		   end
+		  end
+		end
+		pos = nil
+		item = nil
+		parent_menu = parent_mfactory.get_widget('<root>')
+		parent_menu.children.each_with_index { |item, pos|
+			break if item.object_id == widget.object_id }
+		parent_menu.remove(item)
+		item.destroy
+		if subitems
+			subitems.reverse.each { |item|
+				parent_menu.insert(item, pos)
+				item.show_all
+			}
+		end
+	end
+	
+	def img_obj_mk_ctxt_menu(obj, parent, parent_mfactory, path, attr_name,
+	attr_key)
+		#$PDbgLog.sig_call(self)
+		#$PDbgLog.print_msg "path=#{path.inspect}: "
+		mfactory = Gtk::ItemFactory.new(Gtk::ItemFactory::TYPE_MENU,
+			'<root>', nil)
+		meths = obj.img_obj_possible_sub_obj_meths unless
+			(meths = obj.class.img_obj_sub_obj_meths)
+		menu = mfactory.get_widget('<root>')
+		unless meths.empty?
+			meths.each { |meth|
+				m = meth.cap_first; m.gsub!('_', ' ')
+				mfactory.create_item('/'+m, '<StockItem>', nil,
+				  Gtk::Stock::EXECUTE, [obj,meth,path,mfactory],
+				  &@ctxt_menu_e_cb)
+			}
+			mfactory.create_item('/sep1', '<Separator>')
+		end
+		mw = MARK_WAYS[0]
+		mfactory.create_item('/_'+mw.cap_first,
+			'<RadioItem>', nil, nil, [obj, path], &@ctxt_menu_m_cb)
+		fpath = '/' + mw.cap_first
+		MARK_WAYS[1, MARK_WAYS.length].each { |mw|
+			mfactory.create_item('/_' + mw.cap_first, fpath,
+				nil, nil, [obj, path], &@ctxt_menu_m_cb)
+		}
+		mfactory.create_item('/_None', fpath,
+			nil, nil, [obj, path], &@ctxt_menu_m_cb)
+		cur_mw = @mark_blob[path] || 'none'
+		mfactory.get_widget('/'+cur_mw.cap_first).activate
+		mfactory.create_item('/sep2', '<Separator>')
+		if attr_key
+		  if parent.methods.include?(dmeth="delete_"+attr_name.singular)
+			mfactory.create_item('/_Delete', '<StockItem>', nil,
+			  Gtk::Stock::DELETE, [obj,parent,parent_mfactory,
+			    attr_name,path,parent.method(dmeth),[attr_key]],
+			  &@ctxt_menu_d_cb)
+		  end
+		elsif parent.methods.include?(dmeth="delete_"+attr_name)
+			mfactory.create_item('/_Delete', '<StockItem>', nil,
+			  Gtk::Stock::DELETE, [obj,parent,parent_mfactory,
+			    attr_name,path,parent.method(dmeth),[]],
+			  &@ctxt_menu_d_cb)
+		end
+		mfactory.create_item('/_Save', '<StockItem>', '',
+			Gtk::Stock::SAVE, obj, &@ctxt_menu_s_cb)
+		mfactory.get_widget('<root>')
+		#$PDbgLog.sig_return
+	end
+	
+	def img_get_context_menu
+		return nil unless @blob
+		tmp = @blob.extract_curves_args['ctxt_menu']
+		return tmp if tmp
+		$PDbgLog.sig_call(self)
+		tmp = @blob.extract_curves_args['ctxt_menu'] =
+			self.img_obj_mk_ctxt_menu(@blob, @pixbuf, nil, "",
+				"blob", @blob)
+		item = Gtk::MenuItem.new("Blob #{@blob.blob_id}:")
+		item.sensitive = false
+		tmp.prepend(item)
+		$PDbgLog.sig_return
+		tmp
+	end
+	
+	def img_pop_context_menu
+	  menu = nil
+	  #@job = Thread.new(Thread.current) {
+	#	Thread.stop
+	#	$PDbgLog.sig_call(self)
+		menu = self.img_get_context_menu
+	#	$PDbgLog.sig_return("OK")
+	  #}
+	  #@job.run
+	  #Thread.pass while @job.alive?
+		return unless menu
+		$PDbgLog.sig_call(self)
+		#$PDbgLog.puts_msg "#{(menu.methods.sort - Object.methods).
+		#	join("\n")}"
+		menu.visible = true
+		menu.activate
+		menu.parent.modal = true
+		menu.parent.window_position = Gtk::Window::POS_MOUSE
+		menu.parent.show_all
+		menu.grab_focus
+		
+		while menu.visible?
+			Gtk.main_iteration
+		end
+		#menu.destroy
+		@scrl_win.queue_draw
+		$PDbgLog.sig_return("Done.")
+	end
+	
+	def img_button_press_cb(drw_area, event)
+		#$PDbgLog.sig_call(self)
+		unless @in_progr.try_lock
+			#$PDbgLog.sig_return(false)
+			return false
+		end
+		case event.button
+		  when 1 then self.img_get_objs_at(drw_area, event)
+		  when 3 then self.img_pop_context_menu
+		end
+		@in_progr.unlock
+		#$PDbgLog.sig_return(true)
+		return true
+	end
+	
+	def about_cb(*args)
+		authors = ["Pavel Penev <pavpen@berkeley.edu>"]
+		documentors = []
+		license = %Q[
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License as
+published by the Free Software Foundation; either version 2 of the
+License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public
+License along with the Gnome Library; see the file COPYING.LIB.  If not,
+write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA.
+]
+		transparent = Gdk::Pixbuf.new(PGtk.find_icon_file(
+			"pav/icons/extract_curves/extract_curves-logo-rgb.gif"))
+			#.add_alpha(true, 0xff, 0xff, 0xff)
+		
+		Gtk::AboutDialog.set_email_hook {|about, link|
+			puts "send mail to #{link}"
+		}
+		Gtk::AboutDialog.set_url_hook {|about, link|
+			puts "show url #{link}"
+		}
+		Gtk::AboutDialog.show(self,
+			:name => "Extract Curves",
+			:version => VERSION.join(".") + VERSION_SUFFIX,
+			:copyright => "(C) 2005 Pavel Minev Penev",
+			:license => license,
+			#:website => "http://www.gtk.org",
+			:comments => "Program to identify the specific " +
+				"characteristics of a motion which produced a "+
+				"geometric curve.",
+			:authors => authors,
+			#:documenters => documentors,
+			:logo => transparent)
+	end
+end
+
+if ARGV[0]
+  case ARGV[0]
+    when '--version'
+	puts ExtractCurvesApp::VERSION.join('.')
+	exit 0
+    when '--file-path'
+	puts File.expand_path(__FILE__)
+	exit 0
+  end
+end
+#PApp.new(ExtractCurvesApp).run
+app_win = ExtractCurvesApp.new
+app_win.show_all
+app_win.open_imagef(ARGV[0]) if ARGV[0]
+Gtk.main