extract_curves 0.0.1-i586-linux

data/ruby_libs/pav/pix/img_obj.rb

@@ -0,0 +1,751 @@
+require 'set'
+require 'pav/pix'
+require 'pav/heap'
+
+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
+	@img_obj_meths = []
+	
+	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
+	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 self.img_obj_sub_obj_meths
+		@img_obj_sub_obj_meths
+	end
+	
+	def self.get_img_obj_sub_obj_meths
+		return @img_obj_sub_obj_meths if @img_obj_sub_obj_meths
+		begin
+		  return (@img_obj_sub_obj_meths=@img_obj_sub_obj_meths.dup) if
+			(@img_obj_sub_obj_meths =
+				self.superclass.get_img_obj_sub_obj_meths)
+		rescue NoMethodError
+		end
+		@img_obj_sub_obj_meths = []
+	end
+	
+	def self.img_obj_add_sub_obj(*args)
+		self.get_img_obj_sub_obj_meths.concat(args.collect{|m| m.to_s})
+	end
+	
+	def self.img_obj_add_to_sub_objs(*args)
+		return unless @img_obj_sub_obj_meths
+		@img_obj_sub_obj_meths.concat(args.collect{|m| m.to_s})
+	end
+	
+	def img_obj_possible_sub_obj_meths
+		(self.public_methods - Object.instance_methods -
+		Array.instance_methods - SubArr.instance_methods -
+		["rewind", "rebuild", "get_sub_img_objs"]).delete_if { |meth|
+			meth.starts_with("_") || meth.starts_with("delete_") ||
+				![-1, 0].include?(self.method(meth).arity)
+		}
+	end
+	
+	def get_sub_img_objs(excl_set={})
+		#$PDbgLog.sig_call(self)
+		#$PDbgLog.print_msg self.inspect
+		objs = {}
+		if (meths = self.class.img_obj_sub_obj_meths)
+		  meths.each { |meth|
+			res = self.send(meth)
+			next if excl_set.include?(res.object_id)
+			objs[meth] = res
+			excl_set[res.object_id] = true
+		  }
+		  #$PDbgLog.sig_return
+		  return objs
+		end
+		self.img_obj_possible_sub_obj_meths.each { |meth|
+			res = self.send(meth)
+			#$PDbgLog.print_msg "meth=#{meth}:%x " % res.object_id
+			next if excl_set.include?(res.object_id)
+			if res.kind_of?(ImageObject)
+				objs[meth] = res
+				excl_set[res.object_id] = true
+			elsif res.kind_of?(Array) && !res.empty? &&
+			res.first.kind_of?(ImageObject)
+				objs[meth] = res
+				excl_set[res.object_id] = true
+			elsif res.kind_of?(Hash) && !res.empty?
+				flag = true
+				res.each_value { |v|
+					flag = v.kind_of?(ImageObject)
+					break
+				}
+				if flag
+					objs[meth] = res
+					excl_set[res.object_id] = true
+				end
+			end
+		}
+		#$PDbgLog.sig_return
+		objs
+	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
+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