extract-curves 0.1.1-mswin32

data/ruby_libs/pav/pix/img_obj.rb

@@ -0,0 +1,865 @@
+require 'set'
+require 'ostruct'
+require 'pav/pix'
+require 'pav/heap'
+require 'pav/guiobj'
+
+module PPix
+
+module MPixbufPix
+	def img_obj_subpix8(sub_n)
+		# @img_obj_subpix8 = [] unless @img_obj_subpix8
+		# tmp = @img_obj_subpix8[sub_n]
+		# return tmp if tmp
+		#$PDbgLog.sig_call(self)
+		#$PDbgLog.puts_msg self.coords_to_s + ", sub_n=#{sub_n}"
+		#res =
+		#@img_obj_subpix8[sub_n] =
+		ImageObjectSubpix.new(Subpix8.new(self, sub_n))
+		#$PDbgLog.puts_msg res.inspect
+		#$PDbgLog.sig_return
+		#res
+	end
+	
+	def connections(&get_neighbs)
+		#$PDbgLog.sig_call(self)
+		#$PDbgLog.print_msg(self.coords_to_s)
+		res = []
+		visited = {}
+		for neighb in yield(self)
+			#$PDbgLog.print_msg " neighb#{neighb.coords_to_s}: "
+			next if visited.include?(neighb.a_yx)
+			res << [tmp_pix=neighb]
+			prev_pix = self
+			while (pix_ngbs = yield(tmp_pix)).length == 2
+				if pix_ngbs.first.a_eql?(prev_pix)
+					prev_pix = tmp_pix
+					tmp_pix = pix_ngbs.last
+				else
+					prev_pix = tmp_pix
+					tmp_pix = pix_ngbs.first
+				end
+				res.last << tmp_pix
+				if self.a_eql?(tmp_pix)
+					visited[prev_pix.a_yx] = true
+					break
+				end
+			end
+			#$PDbgLog.puts_msg "."
+		end
+		#$PDbgLog.sig_return
+		res
+	end
+	
+	def rev_conn_idx(conns, conn_i, rev_conns)
+		#$PDbgLog.sig_call(self)
+		#$PDbgLog.puts_msg "(#{conn_i}) from (#{self.x}, #{self.y})."
+		path = conns[conn_i]
+		#$PDbgLog.puts_msg "path: #{PixbufPix.path_to_s(path)}"
+		end_pix = path.last
+		if self.a_eql?(end_pix)
+			return conn_i
+		else
+			path = path.reverse[1, path.length-1] << self
+			#$PDbgLog.puts_msg "rev_path: #{
+			#	PixbufPix.path_to_s(path)}"
+			rev_conns.each_with_index { |rev_conn, i|
+				#$PDbgLog.puts_msg "rev_conn: #{
+				#	PixbufPix.path_to_s(rev_conn)}"
+				if PixbufPix.a_paths_eql?(path, rev_conn)
+					return i
+				end
+			}
+		end
+		#$PDbgLog.sig_return
+		nil
+	end
+	
+	def find_shortest_pix_path_to(dest, levs_left=-1, &get_neighbs)
+		#$PDbgLog.sig_call(self)
+		if dest.kind_of?(Proc)
+			dest_proc = dest
+		else
+			dest_proc = proc { |px| px.y==dest.y && px.x==dest.x }
+		end
+		path_cache = { self.yx => 0 }
+		tail = [[self, 0]]
+		#$PDbgLog.print_msg "dest=#{dest}, from #{
+		#	self.coords_to_s}, levs_left=#{levs_left}: "
+		if levs_left == 0
+			#$PDbgLog.sig_return("levs_left==0: nil")
+			return nil
+		end
+		while !tail.empty?
+			pix, lev = *tail.shift
+			#if lev > 100
+			  #$PDbgLog.print_msg
+			  #puts "dest=#{dest}, from #{
+			  #  self.coords_to_s}, levs_left=#{levs_left}: #{tail.
+			  #  length},#{pix.coords_to_s},#{lev}; "
+			#end
+		#	$PDbgLog.print_msg "#{tail.length},#{pix.coords_to_s},#{
+			#	lev}; "
+			if dest_proc.call(pix)
+				res = []
+				i = path_cache[pix.yx]
+				while i > 0
+					res[i-=1] = pix
+					yield(pix).each { |pix|
+						break if path_cache[pix.yx] == i
+					}
+				end
+				#$PDbgLog.sig_return(PixbufPix.path_to_s(res))
+				return res
+			end
+			yield(pix).each { |neighb|
+				unless (path_cache.include?(neighb.yx) &&
+				path_cache[neighb.yx] <= lev+1) ||
+				lev+1 == levs_left
+					tail.push([neighb, lev+1])
+					path_cache[neighb.yx] = lev+1
+				end
+			}
+		end
+		#$PDbgLog.sig_return("nil")
+		nil
+	end
+	
+	def find_shortest_pix_path_into(res, dest, levs_left=-1, path_cache={},
+	tail=[], neighbs=[]) # &get_neighbs
+		#$PDbgLog.sig_call(self)
+		if dest.kind_of?(Proc)
+			dest_proc = dest
+		else
+			dest_proc = proc { |px| px.y==dest.y && px.x==dest.x }
+		end
+		path_cache.clear; path_cache[self.yx] = 0
+		tail.clear; tail << self << 0
+		#$PDbgLog.print_msg "dest=#{dest}, from #{
+		#	self.coords_to_s}, levs_left=#{levs_left}: "
+		if levs_left == 0
+			#$PDbgLog.sig_return("levs_left==0: nil")
+			return nil
+		end
+		while !tail.empty?
+			pix = tail.shift; lev = tail.shift
+			#if lev > 100
+			  #$PDbgLog.print_msg
+			  #puts "dest=#{dest}, from #{
+			  #  self.coords_to_s}, levs_left=#{levs_left}: #{tail.
+			  #  length},#{pix.coords_to_s},#{lev}; "
+			#end
+		#	$PDbgLog.print_msg "#{tail.length},#{pix.coords_to_s},#{
+			#	lev}; "
+			if dest_proc.call(pix)
+				res.clear
+				i = path_cache[pix.yx]
+				while i > 0
+					res[i-=1] = pix
+					yield(pix, neighbs).each { |pix|
+						break if path_cache[pix.yx] == i
+					}
+				end
+				#$PDbgLog.sig_return(PixbufPix.path_to_s(res))
+				return res
+			end
+			yield(pix, neighbs).each { |neighb|
+				unless (path_cache.include?(neighb.yx) &&
+				path_cache[neighb.yx] <= lev+1) ||
+				lev+1 == levs_left
+					tail << neighb << (lev+1)
+					path_cache[neighb.yx] = lev+1
+				end
+			}
+		end
+		#$PDbgLog.sig_return("nil")
+		nil
+	end
+	
+	def find_first_path_to(dest, max_lev=1.0/0.0, &get_neighbs_levs)
+		$PDbgLog.sig_call(self)
+		if dest.kind_of?(Proc)
+			dest_proc = dest
+		else
+			dest_proc = proc { |px| dest.a_eql?(px) }
+		end
+		path_cache = { self.a_yx => [nil, 0] }
+		tail = PMinHeap.new { |frm1,frm2| frm1[1] <=> frm2[1] }
+		tail.push([self, 0])
+		if max_lev < 1
+			$PDbgLog.sig_return("max_lev < 1: nil")
+			return nil
+		end
+		while !tail.empty?
+			pix, lev = *tail.pop
+			if dest_proc.call(pix, lev)
+				frm = path_cache[pix.a_yx]
+				res = [pix]
+				while frm[0]
+					res << frm[0]
+					frm = path_cache[frm[0].a_yx]
+				end
+				$PDbgLog.sig_return(PixbufPix.path_to_s(
+					res.reverse))
+				return res.reverse!
+			end
+			yield(pix, lev).each { |args| neighb, neighb_lev = *args
+				unless (path_cache.include?(neighb.a_yx) &&
+				path_cache[neighb.a_yx][1] <= neighb_lev) ||
+				neighb_lev > max_lev
+					tail.push([neighb, neighb_lev])
+					path_cache[neighb.a_yx]=[pix,neighb_lev]
+				end
+			}
+		end
+		$PDbgLog.sig_return("nil")
+		nil
+	end
+	
+	def inspect
+	  idmem = self.object_id & ( (1 << (8*self.object_id.size)) - 1 )
+	  "<#{self.class.name}:0x%x #{self.coords_to_s}" % idmem +
+	  "#{self.instance_variables.collect { |var| " " + var + "=" +
+	  self.instance_variable_get(var).inspect }.join(",")}>"
+	end
+end
+
+class ImageObjectSubpix #< ImageObjectPix
+	attr_reader :subpix, :ppix
+	
+	def initialize(subpix)
+		@subpix = subpix
+		super(subpix.img_pix)
+		@ppix = ppix
+	end
+	
+	def method_missing(id, *args, &block)
+		begin
+			@subpix.send(id, *args, &block)
+		rescue NoMethodError
+			@subpix.img_pix.send(id, *args, &block)
+		end
+	end
+	
+	def to_s
+		@subpix.to_s
+	end
+	
+	def inspect
+	  idmem = self.object_id & ( (1 << (8*self.object_id.size)) - 1 )
+	  "<#{self.class.name}:0x%x @subpix#{@subpix.to_s}"%idmem +
+	  "#{self.instance_variables.collect{|var|"#{var}=#{self.
+	  instance_variable_get(var).inspect}"}.join(",")}>" #"
+	end
+end
+
+class ImageObject
+	include PGuiObj::MObj
+	
+	def self.create_array(arr)
+		PGuiObj::ObjArray.create(arr, [], OpenStruct.new(
+			'marshal_dump_btn' => false, 'dump_to_s_btn' => false,
+			'dump_inspect_btn' => false))
+	end
+	
+	def self.write_objs(file, format, objs)
+		#$PDbgLog.sig_call(self)
+		#$PDbgLog.puts_msg "file: #{file.inspect}, obj: #{obj}"
+		if format[0].kind_of?(String) && format[0].downcase == 'txt'
+		  if file.kind_of?(String)
+		    open(file, format[1]) { |file| objs.each { |obj|
+			obj.each { |pix| file.puts "#{pix.ax}\t#{pix.ay}" }
+		    }}
+		  else
+		    objs.each { |obj|
+			obj.each { |pix| file.puts "#{pix.ax}\t#{pix.ay}" }
+		    }
+		  end
+		else
+		  #outp_buf = PPix::Pixbuf.new(Gdk::Pixbuf::COLORSPACE_RGB,
+		  #	false, 8, format[0], format[1])
+		  #pixels = outp_buf.pixels
+		  #rowstride = outp_buf.rowstride
+		  #pix_len = outp_buf.pix_length
+		  outp_buf = Gdk::Image.new(Gdk::Image::FASTEST,
+		  	Gdk::Visual.best, width=format[0], height=format[1])
+		  white = ~0
+		  objs.each { |obj| obj.each { |pix|
+			ax = pix.ax; ay = pix.ay
+			x1 = ax.floor; y1 = ay.floor
+			x2 = ax.ceil; y2 = ay.ceil
+			outp_buf.put_pixel(x1, y1, white) if x1 >= 0 &&
+			  x1 < width && y1 >= 0 && y1 < height
+			if x1 != x2
+			  if y1 != y2
+				outp_buf.put_pixel(x2, y1, white) if x2 >= 0 &&
+				  x2 < width && y1 >= 0 && y1 < height
+				outp_buf.put_pixel(x1, y2, white) if x1 >= 0 &&
+				  x1 < width && y2 >= 0 && y2 < height
+				outp_buf.put_pixel(x2, y2, white) if x2 >= 0 &&
+				  x2 < width && y2 >= 0 && y2 < height
+			  else
+				outp_buf.put_pixel(x2, y1, white) if x2 >= 0 &&
+				  x2 < width && y1 >= 0 && y1 < height
+			  end
+			elsif y1 != y2
+				outp_buf.put_pixel(x1, y2, white) if x1 >= 0 &&
+				  x1 < width && y2 >= 0 && y2 < height
+			end
+		  } }
+		  if file.kind_of?(String)
+			Gdk::Pixbuf.from_image(
+			  Gdk::Colormap.new(Gdk::Visual.best, true), outp_buf,
+			  0, 0, format[0], format[1], nil, 0, 0).
+			 save(file, format[2])
+		  else
+			file.write(outp_buf.save_to_buffer(format[2]))
+		  end
+		end
+		#$PDbgLog.sig_return
+	end
+	
+	def self.save_objs(pixbuf_width, pixbuf_height, 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])
+		dialog.preview_widget_active = false
+		dialog.default_response = Gtk::Dialog::RESPONSE_ACCEPT
+		dialog.set_extra_widget(fmt_hbox = Gtk::HBox.new(false, 0))
+		fmt_hbox.pack_start(Gtk::Label.new('Output format: '), false,
+			false, 0)
+		fmt_hbox.pack_start(fmt_combo = Gtk::ComboBox.new,false,false,0)
+		fmt_combo.append_text('Auto (by extension)')
+		fmt_combo.append_text('Tab-separated text (.txt)')
+		fmt_hbox.show_all
+		fmts = {}
+		i = 2
+		PPix::Pixbuf.formats.each { |fmt|
+		  fmt_combo.append_text("#{fmt.description} (.#{fmt.name})")
+		  fmts[fmt.name] = i
+		  fmts[i] = fmt.name
+		  i += 1
+		}
+		fmts['txt'] = 1
+		fmt_combo.active = 0
+		fmt_active = nil
+		path = nil
+		sel_proc = proc { |path|
+		  if fmt_combo.active == 0
+		    if path && (dot_idx = path.rindex('.'))
+			if (fmt_active = fmts[path[dot_idx+1...path.length]])
+			  valid = true
+			else
+			  valid = false
+			end
+		    else
+			valid = false
+		    end
+		  else
+		    valid = true
+		  end
+		  dialog.set_response_sensitive(Gtk::Dialog::RESPONSE_ACCEPT,
+		  	valid)
+		  true
+		}
+		dialog.signal_connect('selection-changed') { |dlg, *args|
+			sel_proc.call(dlg.filename); false }
+		fmt_combo.signal_connect('changed') { |*args|
+			sel_proc.call(dialog.filename); false }
+		find_entry_proc = proc { |wgt|
+			if wgt.kind_of?(Gtk::Entry)
+				wgt
+			elsif wgt.kind_of?(Gtk::Container)
+				res = nil
+				wgt.children.each { |child|
+				  break if (res = find_entry_proc.call(child))
+				}
+				res
+			end
+		}
+		if entry = find_entry_proc.call(dialog)
+			entry_mod_proc = proc { |entry, *args|
+				sel_proc.call(entry.text); false }
+			entry.signal_connect('changed', &entry_mod_proc)
+		end
+		resp = dialog.run
+		path = dialog.filename
+		fmt_active = fmt_combo.active if fmt_combo.active != 0
+		dialog.destroy
+		return if resp != Gtk::Dialog::RESPONSE_ACCEPT
+		if fmt_active == 1
+			fmt = 'txt'
+		else
+			fmt = fmts[fmt_active]
+		end
+		if FileTest.exist?(path)
+		  if fmt != 'txt'
+			return unless PGtk.overwrite_dialog(path)
+			fmt = [pixbuf_width, pixbuf_height, fmt]
+		  else
+			dialog = Gtk::Dialog.new('Output File Exists', nil,
+				Gtk::Dialog::MODAL,
+				['_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)
+			fmt = [fmt, mode]
+		  end
+		else
+		  if fmt == 'txt'
+			fmt = [fmt, 'w']
+		  else
+			fmt = [pixbuf_width, pixbuf_height, fmt]
+		  end
+		end
+		begin
+			self.write_objs(path, fmt, objs)
+		rescue IOError, Gdk::PixbufError
+			PGtk.show_exc_dialog
+		end
+	end
+	
+	def initialize(times_arr=0, obj_start_i=nil, end_i=nil)
+		if end_i
+			@__under__ = SubArr.new(times_arr, obj_start_i, end_i)
+		elsif obj_start_i
+			@__under__ = Array.new(times_arr, obj_start_i)
+		else
+			@__under__ = Array.new(times_arr)
+		end
+		self.img_obj_rebuild
+		self.pguiobj_init(nil, OpenStruct.new('marshal_dump_btn'=>false,
+			'dump_to_s_btn' => false, 'dump_inspect_btn' => false))
+	end
+	
+  (Array.instance_methods+SubArr.instance_methods-Object.instance_methods-
+  ["[]=", "<<", "push", "+", "-", "*", "concat", "replace"]).
+	uniq!.each { |meth|
+	  if meth[-1,1] == "="
+	    module_eval <<-"eval_end"
+		def #{meth}(val)
+			@__under__.#{meth}(val)
+		end
+	    eval_end
+	  else
+	    module_eval <<-"eval_end"
+		def #{meth}(*args, &block)
+			@__under__.#{meth}(*args, &block)
+		end
+	    eval_end
+	  end
+	}
+	
+	def []=(*args, &block)
+		@__under__.[]=(*args, &block)
+	end
+	
+	def replace(*args, &block)
+		@__under__.replace(*args, &block)
+		self
+	end
+	
+	def concat(*args, &block)
+		@__under__.concat(*args, &block)
+		self
+	end
+	
+	def <<(*args, &block)
+		@__under__.<<(*args, &block)
+		self
+	end
+	
+	def push(*args, &block)
+		@__under__.push(*args, &block)
+		self
+	end
+	
+	def +(*args, &block)
+		ImageObject.new.replace(@__under__.+(*args, &block))
+	end
+	
+	def -(*args, &block)
+		ImageObject.new.replace(@__under__.-(*args, &block))
+	end
+	
+	def *(*args, &block)
+		ImageObject.new.replace(@__under__.*(*args, &block))
+	end
+	
+	def dup
+		ImageObject.new(@__under__.dup)
+	end
+	
+	def img_obj_rebuild
+		@img_obj_min_x = @img_obj_max_x = nil
+		@img_obj_min_y = @img_obj_max_y = nil
+		@img_obj_min_ax = @img_obj_max_ax = nil
+		@img_obj_min_ay = @img_obj_max_ay = nil
+		@img_obj_yx_set = nil
+		@img_obj_ayx_set = nil
+	end
+	
+	def img_obj_yx_set
+		return @img_obj_yx_set if @img_obj_yx_set
+		@img_obj_yx_set = Set.new
+		self.each { |pix| @img_obj_yx_set.add(pix.yx) }
+		@img_obj_yx_set
+	end
+	
+	def img_obj_ayx_set
+		return @img_obj_ayx_set if @img_obj_ayx_set
+		@img_obj_ayx_set = Set.new
+		self.each { |pix| @img_obj_ayx_set.add(pix.a_yx) }
+		@img_obj_ayx_set
+	end
+	
+	def img_obj_find_xy_rect
+		return if self.empty?
+		@img_obj_min_x = @img_obj_max_x = self.first.x
+		@img_obj_min_y = @img_obj_max_y = self.first.y
+		self.each { |pix|
+			if pix.x < @img_obj_min_x
+				@img_obj_min_x = pix.x
+			elsif pix.x > @img_obj_max_x
+				@img_obj_max_x = pix.x
+			end
+			if pix.y < @img_obj_min_y
+				@img_obj_min_y = pix.y
+			elsif pix.y > @img_obj_max_y
+				@img_obj_max_y = pix.y
+			end
+		}
+	end
+	
+	def img_obj_find_axy_rect
+		return if self.empty?
+		@img_obj_min_ax = @img_obj_max_ax = self.first.ax
+		@img_obj_min_ay = @img_obj_max_ay = self.first.ay
+		self.each { |pix|
+			if pix.ax < @img_obj_min_ax
+				@img_obj_min_ax = pix.ax
+			elsif pix.ax > @img_obj_max_ax
+				@img_obj_max_ax = pix.ax
+			end
+			if pix.ay < @img_obj_min_ay
+				@img_obj_min_ay = pix.ay
+			elsif pix.ay > @img_obj_max_ay
+				@img_obj_max_ay = pix.ay
+			end
+		}
+	end
+	
+	def img_obj_min_x
+		self.img_obj_find_xy_rect unless @img_obj_min_x
+		@img_obj_min_x
+	end
+	
+	def img_obj_max_x
+		self.img_obj_find_xy_rect unless @img_obj_max_x
+		@img_obj_max_x
+	end
+	
+	def img_obj_min_y
+		self.img_obj_find_xy_rect unless @img_obj_min_y
+		@img_obj_min_y
+	end
+	
+	def img_obj_max_y
+		self.img_obj_find_xy_rect unless @img_obj_max_y
+		@img_obj_max_y
+	end
+	
+	def img_obj_min_ax
+		self.img_obj_find_axy_rect unless @img_obj_min_ax
+		@img_obj_min_ax
+	end
+	
+	def img_obj_max_ax
+		self.img_obj_find_axy_rect unless @img_obj_max_ax
+		@img_obj_max_ax
+	end
+	
+	def img_obj_min_ay
+		self.img_obj_find_axy_rect unless @img_obj_min_ay
+		@img_obj_min_ay
+	end
+	
+	def img_obj_max_ay
+		self.img_obj_find_axy_rect unless @img_obj_max_ay
+		@img_obj_max_ay
+	end
+	
+	def img_obj_freeze
+		@__under__.freeze
+	end
+	
+	def opt_spanning_tree(min, mk_conn, get_conns)
+		return if self.empty?
+		# Start from a node pixel:
+		return if (conns = get_conns.call(self.first)).empty?
+		#$PDbgLog.sig_call(self)
+		pix = conns[0].last
+		spanned = {pix.yx => true}
+		active_conns = min ? PMinHeap.new{|cn1,cn2| cn1[3] <=> cn2[3]} :
+			PMinHeap.new { |cn1, cn2| cn2[3] <=> cn1[3] }
+		get_conns.call(pix).each_with_index { |conn, conn_i|
+		  active_conns.push([pix, conn.last, conn_i, conn.length]) }
+		cn = nil
+		loop do
+		#	$PDbgLog.print_msg "#{spanned.length}/#{self.length
+		#	  }; spanned: #{PixbufPix.yx_path_to_s(spanned.keys.sort
+		#	  )}; active_conns: #{active_conns.collect{|frm|
+		#	  frm[0].coords_to_s + "--" + frm[1].coords_to_s +
+		#	  ",#{frm[2]}:#{frm[3]}"}.join("; ")}. "
+			loop do
+				unless (cn = active_conns.pop)
+					#$PDbgLog.sig_return
+					return
+				end
+				break unless spanned.include?(cn[1].yx)
+			end
+			#$PDbgLog.puts_msg "Calling mk_conn(#{cn[0].coords_to_s
+			#	}, #{cn[2]})"
+			mk_conn.call(cn[0], cn[2])
+			spanned[cn[1].yx] = true
+			get_conns.call(cn[1]).each_with_index { |conn, conn_i|
+				next if spanned.include?(conn.last.yx)
+				active_conns.push([cn[1], conn.last, conn_i,
+					conn.length])
+			}
+		end
+		#$PDbgLog.sig_return
+	end
+	
+	def self.img_obj_add_meths(*meths)
+		#$PDbgLog.sig_call(self)
+		#$PDbgLog.puts_msg "meths: #{meths.inspect}"
+		PGuiObj::MObj.pguiobj_add_methods_to(self, *meths)
+		#$PDbgLog.sig_return
+	end
+end
+
+class ImageObjectPixCalc
+	attr_reader :pix, :path_cache, :first_path_cache, :get_pix_proc
+	
+	def initialize(pix, &get_pix_proc)
+		@pix = pix
+		@path_cache = {}
+		@first_path_cache = {}
+		@get_pix_proc = get_pix_proc
+	end
+	
+	def find_shortest_pix_path_to_pix(dest, levs_left=-1,
+	path_cache=@path_cache, &get_neighbs)
+		#$PDbgLog.sig_call(self)
+		path_cache = {} unless path_cache
+		tail = [[@pix, 0]]
+		path_cache[@pix.a_yx]=0 unless path_cache.include?(@pix.a_yx) &&
+			path_cache[@pix.a_yx] <= 0
+		#$PDbgLog.print_msg "dest=#{dest}, from #{
+		#	@pix.coords_to_s}, levs_left=#{levs_left}: "
+		if levs_left == 0
+			#$PDbgLog.sig_return("levs_left==0: nil")
+			return nil
+		end
+		while !tail.empty?
+			pix, lev = *tail.shift
+			if path_cache.include?(dest.a_yx)
+				res = []; pix = dest
+				i = path_cache[pix.a_yx]
+				while i > 0
+					res[i-=1] = pix
+					yield(pix).each { |pix|
+						break if path_cache[pix.a_yx]==i
+					}
+				end
+				#$PDbgLog.sig_return(PixbufPix.path_to_s(res))
+				return res
+			end
+			yield(pix).each { |neighb|
+				unless (path_cache.include?(neighb.a_yx) &&
+				path_cache[neighb.a_yx] <= lev+1) ||
+				lev+1 == levs_left
+					tail.push([neighb, lev+1])
+					path_cache[neighb.a_yx] = lev+1
+				end
+			}
+		end
+		#$PDbgLog.sig_return("nil")
+		nil
+	end
+	
+	def find_shortest_path_pix_to(dest, levs_left=-1, &get_neighbs)
+		#$PDbgLog.sig_call(self)
+		if dest.kind_of?(Proc)
+			dest_proc = dest
+		else
+			#$PDbgLog.sig_return
+			return self.find_shortest_pix_path_to_pix(dest,
+				levs_left, {}, &get_neighbs)
+		end
+		path_cache = { @pix.a_yx => 0 }
+		tail = [[@pix, 0]]
+		#$PDbgLog.print_msg "dest=#{dest}, from #{
+		#	@pix.coords_to_s}, levs_left=#{levs_left}: "
+		if levs_left == 0
+			#$PDbgLog.sig_return("levs_left==0: nil")
+			return nil
+		end
+		while !tail.empty?
+			pix, lev = *tail.shift
+			#if lev > 100
+			  #$PDbgLog.print_msg
+			  #puts "dest=#{dest}, from #{
+			  #  @pix.coords_to_s}, levs_left=#{levs_left}: #{tail.
+			  #  length},#{pix.coords_to_s},#{lev}; "
+			#end
+		#	$PDbgLog.print_msg "#{tail.length},#{pix.coords_to_s},#{
+			#	lev}; "
+			if dest_proc.call(pix)
+				res = []
+				i = path_cache[pix.a_yx]
+				while i > 0
+					res[i-=1] = pix
+					yield(pix).each { |pix|
+						break if path_cache[pix.a_yx]==i
+					}
+				end
+				#$PDbgLog.sig_return(PixbufPix.path_to_s(res))
+				return res
+			end
+			yield(pix).each { |neighb|
+				unless (path_cache.include?(neighb.a_yx) &&
+				path_cache[neighb.a_yx] <= lev+1) ||
+				lev+1 == levs_left
+					tail.push([neighb, lev+1])
+					path_cache[neighb.a_yx] = lev+1
+				end
+			}
+		end
+		#$PDbgLog.sig_return("nil")
+		nil
+	end
+	
+	def self.path_cache_to_s(path_cache)
+		"{#{path_cache.keys.to_a.sort.collect{|k| k.inspect + "=>[" +
+			(path_cache[k][0] ? path_cache[k][0].coords_to_s : 'nil'
+			)+"], #{path_cache[k][1]}"}.join(", ")}}"
+	end
+	
+	def self.first_path_cache_get_path(pix, path_cache)
+		frm = path_cache[pix.yx]
+		res = [pix]
+		while frm[0]
+			res << frm[0]
+			frm = path_cache[frm[0].yx]
+		end
+		res.reverse!
+	end
+	
+	def self.first_path_cache_get_path_to_self(pix, path_cache)
+		frm = path_cache[pix.yx]
+		res = [pix]
+		while frm[0].yx != @pix.yx
+			res << frm[0]
+			frm = path_cache[frm[0].yx]
+		end
+		res << frm[0]
+		res.reverse!
+	end
+	
+	def self.first_path_cache_get_ayx_path(pix, path_cache)
+		#$PDbgLog.sig_call(self)
+		#$PDbgLog.print_msg "pix#{pix.coords_to_s} path_cache: #{self.
+		#	path_cache_to_s(path_cache)}: "
+		frm = path_cache[pix.a_yx]
+		res = [pix]
+		while frm[0]
+			#$PDbgLog.print_msg "#{frm[0].a_yx.inspect} "
+			res << frm[0]
+			frm = path_cache[frm[0].a_yx]
+		end
+		#$PDbgLog.sig_return
+		res.reverse!
+	end
+	
+	def find_first_path_to(dest, max_lev=1.0/0.0, path_cache=nil,
+	&get_neighbs_levs)
+		if dest.kind_of?(Proc)
+			dest_proc = dest
+		else
+			dest_proc = proc {|px,lev| dest.a_eql?(px)}
+		end
+		tail = PMinHeap.new { |frm1,frm2| frm1[1] <=> frm2[1] }
+		unless path_cache
+			path_cache = @first_path_cache
+			unless dest.kind_of?(Proc)
+			  return ImageObjectPixCalc.
+			    first_path_cache_get_ayx_path(dest, path_cache) if
+				path_cache.include?(dest.a_yx)
+			end
+			path_cache.each_pair { |pix, frm|
+				tail.push([@get_pix_proc.call(pix[1], pix[0]),
+					frm[1]])
+			}
+		end
+		#$PDbgLog.sig_call(self)
+		path_cache[@pix.a_yx] = [nil, 0]
+		tail.push([@pix, 0])
+		if max_lev < 1
+			#$PDbgLog.sig_return("max_lev < 1: nil")
+			return nil
+		end
+		while !tail.empty?
+			#$PDbgLog.puts_msg "tail: " + tail.collect { |frm|
+			#  (frm[0] ? frm[0].coords_to_s : frm[0].inspect) +
+			#  ":#{frm[1]}" }.join(" ")
+			pix, lev = *tail.pop
+			#$PDbgLog.puts_msg "path_cache: #{ImageObjectPixCalc.
+			#	path_cache_to_s(path_cache)}"
+			#$PDbgLog.print_msg pix.coords_to_s + ",#{lev}"
+			#$PDbgLog.print_msg "<-#{path_cache[pix.a_yx][0] ?
+			#  path_cache[pix.a_yx][0].coords_to_s :
+			#  path_cache[pix.a_yx][0].inspect} "
+			next if path_cache.include?(pix.a_yx) &&
+				path_cache[pix.a_yx][1] < lev
+			if dest_proc.call(pix, lev)
+				res = ImageObjectPixCalc.
+				  first_path_cache_get_ayx_path(pix, path_cache)
+				#$PDbgLog.sig_return(PixbufPix.path_to_s(res))
+				return res
+			end
+			yield(pix, lev).each { |args| neighb, neighb_lev = *args
+				unless (path_cache.include?(neighb.a_yx) &&
+				path_cache[neighb.a_yx][1] <= neighb_lev) ||
+				neighb_lev > max_lev
+					tail.push([neighb, neighb_lev])
+					path_cache[neighb.a_yx]=[pix,neighb_lev]
+				end
+			}
+		end
+		#$PDbgLog.sig_return("nil")
+		nil
+	end
+	
+	def kill_path_cache!
+		@path_cache.clear
+		@first_path_cache.clear
+	end
+end
+
+end