extract_curves 0.0.1

data/ruby_libs/pav/pix/node.rb

@@ -0,0 +1,712 @@
+require 'pav/pix'
+require 'pav/heap'
+require 'pav/pix/aapix'
+
+module PPix
+
+class NoReversePathwayError < RuntimeError
+	attr_accessor :pathway, :start_node
+	
+	def initialize(pathway, start_node=nil)
+		@pathway = pathway
+		@start_node = start_node
+	end
+end
+
+class NoReverseLinkError < NoReversePathwayError
+end
+
+class NoReverseConnError < NoReversePathwayError
+end
+
+class NodeLink
+	attr_reader :node, :conn_i, :c_reverse
+	
+	def initialize(node, conn_i)
+		@node = node
+		@conn_i = conn_i
+		@c_reverse = nil
+	end
+	
+	def ==(link)
+		@node.node_eql?(link.node) && @conn_i == link.conn_i
+	end
+	
+	def reverse
+		return @c_reverse if @c_reverse
+		conn = @node.conns[@conn_i]
+		exit = conn.exit
+		r_conn = conn.reverse(@node)
+		exit.conns.each_with_index { |cn, cn_i|
+			if cn == r_conn
+				return @c_reverse = NodeLink.new(exit, cn_i)
+			end
+		}
+		raise NoReverseLinkError.new(self, @node),
+		  #"#{self.class.name}.reverse: No rev. link: " +
+		  "#{self}; conn.: #{node.conns[@conn_i]}; r_conn: #{r_conn}" +
+		  (exit.conns.length < 50 ? '; '+NodeConn.conns_to_s(
+		  exit.conns) : '')
+		nil
+	end
+	
+	def expand_to_xy_path
+		@node.conns[@conn_i].path.expand_to_xy_path
+	end
+	
+	def exit
+		@node.conns[@conn_i].exit
+	end
+	
+	def length
+		@node.conns[@conn_i].length
+	end
+	
+	def path
+		@node.conns[@conn_i].path
+	end
+	
+	def conn
+		@node.conns[@conn_i]
+	end
+	
+	def to_s(how=0)
+		"#{@node}-[#{@conn_i}]->" + (how >= 1 ? 
+			@node.conns[@conn_i].exit.to_s : '')
+	end
+end
+
+class NodePath < Array
+	def ==(path2)
+		#$PDbgLog.sig_call(self.name + "#")
+		#$PDbgLog.puts_msg "self: #{self}; path2: #{path2}"
+		if self.length != path2.length
+		#	$PDbgLog.sig_return
+			return false
+		end
+		self.each_with_index { |link, i|
+			return false if !link = path2.at(i) }
+		#$PDbgLog.sig_return
+		true
+	end
+	
+	def +(path2)
+		self.dup.concat(path2)
+	end
+	
+	def get_length
+		res = 0
+		self.each { |link| res += link.length }
+		res
+	end
+	
+	def entry
+		return nil if self.empty?
+		self.first.node
+	end
+	
+	def exit
+		return nil if self.empty?
+		self.last.exit
+	end
+	
+	alias_method :reverse_links, :reverse
+	alias_method :reverse_links!, :reverse!
+	
+	def reverse
+		res = []
+		self.each_with_index { |link, i|
+			res[self.length-i] = link.reverse }
+	end
+	
+	def reverse!
+		0.upto(self.length-1) { |i| self[i] = self[i].reverse }
+		super
+	end
+	
+	def expand_to_xy_path
+		return [] if self.empty?
+		res = self.first.expand_to_xy_path
+		1.upto(self.length-1) { |i|
+			res.concat(self.at(i).expand_to_xy_path) }
+		res
+	end
+	
+	def to_s(how=1)
+		self.join(' ') << (how > 0 ? self.exit.to_s : '')
+	end
+	
+	def each_node
+		for link in self
+			yield(link.node)
+		end
+		if (exit = self.exit)
+			yield(exit)
+		end
+	end
+end
+
+class XyPath < Array
+	def self.yx_path_to_s(path)
+		path.collect { |yx| "(#{yx[1]}, #{yx[0]})" }.join(" ")
+	end
+	
+	def get_length
+		self.length - 1
+	end
+	
+	alias_method :entry, :first
+	alias_method :exit, :last
+	
+	def to_s
+		self.collect { |pix| pix.to_s }.join(" ")
+	end
+	
+	def eql?(path2)
+		#$PDbgLog.sig_call(self.name + "#")
+		#$PDbgLog.puts_msg "path1: #{path1}; path2: #{path2}"
+		if self.length != path2.length
+		#	$PDbgLog.sig_return
+			return false
+		end
+		self.each_with_index { |pix, i|
+			return false if pix.y != path2[i].y ||
+				pix.x != path2[i].x
+		}
+		#$PDbgLog.sig_return
+		true
+	end
+	
+	def starts_with(pfx_path)
+		return false unless self.length >= pfx_path.length
+		pfx_path.each_with_index { |pix, i|
+			return false if pix.yx != self.at(i).yx }
+		true
+	end
+	
+	def ends_with(sfx_path)
+		return false unless (ofs = self.length - sfx_path.length) >= 0
+		0.upto(sfx_path.length-1) { |i|
+			return false if sfx_path.at(i).yx != self.at(ofs+i).yx }
+		true
+	end
+	
+	def a_eql?(path2)
+		#$PDbgLog.sig_call(self.name + "#")
+		#$PDbgLog.puts_msg "self: #{self}; path2: #{path2}"
+		if self.length != path2.length
+		#	$PDbgLog.sig_return
+			return false
+		end
+		self.each_with_index { |pix, i|
+			return false if !pix.a_eql?(path2.at(i)) }
+		#$PDbgLog.sig_return
+		true
+	end
+	
+	def node_eql?(path2)
+		#$PDbgLog.sig_call(self.name + "#")
+		#$PDbgLog.puts_msg "self: #{self}; path2: #{path2}"
+		if self.length != path2.length
+		#	$PDbgLog.sig_return
+			return false
+		end
+		self.each_with_index { |node, i|
+			return false if !node.a_eql?(path2.at(i)) }
+		#$PDbgLog.sig_return
+		true
+	end
+	
+	alias_method :==, :node_eql?
+	
+	def a_starts_with(pfx_path)
+		return false unless self.length >= spath.length
+		self.each_with_index { |pix, i|
+			return false if !pix.a_eql?(pfx_path.at(i)) }
+		true
+	end
+	
+	def a_ends_with(sfx_path)
+		return false unless (ofs = self.length - sfx_path.length) >= 0
+		0.upto(sfx_path.length-1) { |i|
+			return false if !sfx_path.at(i).a_eql?(self.at(ofs+i)) }
+		true
+	end
+	
+	def dup
+		XyPath.new(self)
+	end
+	
+	def concat(path)
+		super(path[1, path.length-1])
+		self
+	end
+	
+	def +(path)
+		self.dup.concat(path[1, path.length-1])
+	end
+	
+	alias_method :expand_to_xy_path, :dup
+	
+	def xy_nodes
+		self[1, self.length-1]
+	end
+end
+
+class NodeConn
+	attr_reader :exit, :length
+	attr_accessor :path
+	
+	def self.conns_to_s(conns)
+		conns.collect {|cn| cn.to_s}.join(', ')
+	end
+	
+	def initialize(exit, length)
+		@exit = exit
+		@length = length
+		raise ArgumentError, "Conn.'s exit must be an AaXyNode!" unless
+			@exit.kind_of?(AaXyNode)
+		raise ArgumentError, "Conn.'s length must be numeric!" unless
+			@length.kind_of?(Numeric)
+	end
+	
+	def reverse(conn_0)
+		res = NodeConn.new(conn_0, length)
+		res.path = path.reverse
+		res
+	end
+	
+	def max_depth(to_parent_conn_i, visited={})
+		return @c_max_depth if @c_max_depth
+		@c_max_depth = @length +
+			@exit.dir_max_depth(to_parent_conn_i, visited)
+	end
+	
+	def to_s(how=0)
+		"<-#{@length}->#{@exit}" + (how<1 ? '' : ': ' + self.path.to_s)
+	end
+	
+	def eql?(conn)
+		@exit.node_eql?(conn.exit) && @length == conn.length &&
+			@path == conn.path
+	end
+	
+	alias_method :==, :eql?
+end
+
+class AaXyNode < AaXy
+	attr_reader :conns, :c_rev_conns
+	
+	def initialize(ax, ay, conns)
+		super(ax, ay)
+		@conns = conns
+		@c_rev_conns = []
+	end
+	
+	def rev_conn_idx(conn_i)
+		if (tmp = @c_rev_conns[conn_i])
+			return tmp
+		end
+		conn = @conns[conn_i]
+		l = conn.exit
+		rev_conn = conn.reverse(self)
+		l.conns.each_with_index { |cn, cn_i|
+			return cn_i if cn == rev_conn }
+		raise NoReverseConnError.new(conn, self),
+			"#{self.coords_to_s} #{@conns[conn_i].to_s(2)}!"
+		nil
+	end
+	
+	def to_parent_conn_idx(conn_i)
+		begin
+			self.rev_conn_idx(conn_i)
+		rescue NoReverseConnError
+			if self.node_eql?(@conns[conn_i].exit)
+				@c_rev_conns[conn_i] = conn_i
+			else
+				raise
+			end
+		end
+	end
+	
+	def clear_rev_conns_cache
+		@c_rev_conns.clear
+	end
+	
+	def delete_conn(conn_i)
+		@conns.delete_at(conn_i)
+		@c_rev_conns.delete_at(conn_i)
+	end
+	
+	def conns_to_s
+		NodeConn.conns_to_s(@conns)
+	end
+	
+	alias_method :node_eql?, :a_eql?
+	
+	def each_link
+		@conns.each_index { |conn_i| yield(NodeLink.new(self, conn_i)) }
+	end
+	
+	def get_min_lp_n_len(max_len=1.0/0.0)
+		#$PDbgLog.sig_call(self)
+		#$PDbgLog.print_msg self.coords_to_s + ", max_len=#{max_len}: "
+		p1, p2, len = *PSearch.first_norep_loop(self, max_len, max_len,
+		proc { |p| p.a_yx }) { |node, lev|
+		  res = []
+		  node.conns.each_with_index { |cn, cn_i|
+			res << [cn.exit,NodeLink.new(node,cn_i),lev+cn.length] }
+		  res
+		}
+		unless p1
+			#$PDbgLog.sig_return
+			return [nil, nil]
+		end
+		#$PDbgLog.puts_msg 'p1: ' + p1.collect { |link|
+		#	link ? link.to_s(1) : link.inspect }.join(' ')
+		#$PDbgLog.puts_msg 'p2: ' + p2.collect { |link|
+		#	link ? link.to_s(1) : link.inspect }.join(' ')
+		lp = NodePath.new
+		p2.reverse_each { |link| lp << link }
+		p1.each { |link| lp << link.reverse }
+		#$PDbgLog.sig_return(lp)
+		[lp, len]
+	end
+	
+	def dup_with_map(map)
+		if (tmp = map[self])
+			return tmp
+		end
+		res = map[self] = AaXyNod.new(self.ax, self.ay, conns=[])
+		@conns.each { |conn|
+			new_conn = NodeConn.new(conn.exit.dup_with_map(map),
+				conn.length)
+			new_conn.path = conn.path
+			conns << new_conn
+		}
+		res
+	end
+	
+	def dup_graph
+		self.dup_with_map({})
+	end
+	
+	def conn_max_depth(conn_i)
+		begin
+			rev_conn_i = self.rev_conn_idx(conn_i)
+		rescue NoReversePathwayError
+			rev_conn_i = -1
+		end
+		@conns[conn_i].max_depth(rev_conn_i)
+	end
+	
+	def dir_max_depth(to_parent_conn_i, visited)
+		#$PDbgLog.sig_call(self)
+		max_depth = 0
+		visited[self] = true
+		@conns.each_with_index { |conn, conn_i|
+			next if to_parent_conn_i == conn_i
+			if visited.include?(conn.exit)
+				max_depth = 1.0/0.0
+				break
+			end
+			tmp = conn.max_depth(self.rev_conn_idx(conn_i), visited)
+			max_depth = tmp if tmp > max_depth
+		}
+		#$PDbgLog.sig_return
+		max_depth
+	end
+	
+	def graph_each_conn_i(visited={}, &block)
+		if visited.include?(self)
+			vis_conns = visited[self]
+		else
+			vis_conns = visited[self] = []
+		end
+		@conns.each_with_index { |conn, conn_i|
+		  unless vis_conns[conn_i]
+			yield(self, conn_i)
+			vis_conns[conn_i] = true
+			begin
+			  visited[conn.exit] = [] unless
+				visited.include?(conn.exit)
+			  visited[conn.exit][self.rev_conn_idx(conn_i)] = true
+			rescue NoReversePathwayError
+			end
+			conn.exit.graph_each_conn_i(visited, &block)
+		  end
+		}
+	end
+	
+	def graph_each_node(visited={}, &block)
+		return if visited.include?(self)
+		visited[self] = true
+		yield(self)
+		@conns.each {|conn| conn.exit.graph_each_node(visited, &block) }
+	end
+	
+	def to_s(how=0)
+		res = self.coords_to_s
+		return res if how < 1
+		res.concat('+conns: ')
+		@conns.each_with_index { |conn, conn_i|
+			res.concat("[#{conn_i}]#{conn.to_s(how-1)}; ")
+		}
+		res[-2,2] = ''
+		res
+	end
+	
+	def graph_to_s
+		res = ''
+		self.graph_each_conn_i { |node, conn_i|
+			res.concat(node.to_s + ": [#{conn_i}]#{node.conns[
+				conn_i].to_s(2)}\n")
+		}
+		res
+	end
+end
+
+class NodeCalcPCachePathIter
+	attr_accessor :path_cache, :node
+	
+	def initialize(path_cache=nil, node=nil)
+		@path_cache = path_cache
+		@node = node
+	end
+	
+	def pop
+		to_link = path_cache[@node][1]
+		@node = to_link ? to_link.node : nil
+		to_link
+	end
+end
+
+class NodeCalc
+	attr_reader :node, :c_paths
+	attr_accessor :link_filter
+	
+	def initialize(node)
+		@node = node
+		@c_paths = {}
+		@link_filter = nil
+	end
+	
+	def find_shortest_path_to_node(dest, max_lev=1.0/0.0,
+	path_cache=@c_paths)
+		#$PDbgLog.sig_call(self)
+		if max_lev < 0
+			#$PDbgLog.sig_return("max_lev < 0: nil")
+			return nil
+		end
+		path_cache = {} unless path_cache
+		if @link_filter
+			#$PDbgLog.sig_return
+			return self.find_shortest_path_to_node_with_link_filter(
+				dest, max_lev, path_cache)
+		end
+		path_cache[@node] = [0, nil] unless path_cache.include?(@node)&&
+			path_cache[@node][0] <= 0 && path_cache[@node][1] == nil
+		tail = PMinHeap.new { |a,b| a[1] <=> b[1] }
+		path_cache.each_pair { |node, frm| tail.push([node, frm[0]]) }
+		while !tail.empty?
+			node, lev = *tail.pop
+			next if path_cache.include?(node) &&
+				path_cache[node][0] < lev
+			if path_cache.include?(dest)
+				res = NodePath.new; node = dest
+				to_link = path_cache[node][1]
+				while to_link
+					res << to_link
+					to_link = path_cache[to_link.node][1]
+				end
+				res.reverse_links!
+				#$PDbgLog.sig_return(res.inspect)
+				return res
+			end
+			node.conns.each_with_index { |conn,conn_i| l = conn.exit
+			  if (l_lev = lev+conn.length) <= max_lev &&
+			  (!path_cache.include?(l) || path_cache[l][0] > l_lev)
+				tail.push([l, l_lev])
+				path_cache[l]=[l_lev,NodeLink.new(node,conn_i)]
+			  end
+			}
+		end
+		#$PDbgLog.sig_return("nil")
+		nil
+	end
+	
+	def find_shortest_path_to_node_with_link_filter(dest, max_lev,
+	path_cache)
+		#$PDbgLog.sig_call(self)
+		path_cache[@node] = [0, nil] unless path_cache.include?(@node)&&
+			path_cache[@node][0] <= 0 && path_cache[@node][1] == nil
+		tail = PMinHeap.new { |a,b| a[1] <=> b[1] }
+		path_cache.each_pair { |node, frm| tail.push([node, frm[0]]) }
+		#$PDbgLog.print_msg "node#{@node.coords_to_s}, dest#{dest.
+		#	coords_to_s}, max_lev=#{max_lev}: "
+		while !tail.empty?
+			node, lev = *tail.pop
+		#	$PDbgLog.print_msg "node#{node.coords_to_s},lev=#{lev} "
+			next if path_cache.include?(node) &&
+				path_cache[node][0] < lev
+			if path_cache.include?(dest)
+				res = NodePath.new; node = dest
+				to_link = path_cache[node][1]
+				while to_link
+					res << to_link
+					to_link = path_cache[to_link.node][1]
+				end
+				res.reverse_links!
+				#$PDbgLog.sig_return('found ' + res.to_s + '.')
+				return res
+			end
+			node.conns.each_with_index { |conn,conn_i| l = conn.exit
+			  #$PDbgLog.print_msg "conn #{conn_i}: #{conn} "
+			  if (l_lev = lev+conn.length) <= max_lev &&
+			  (!path_cache.include?(l) || path_cache[l][0]>l_lev) &&
+			  @link_filter.call(link=NodeLink.new(node,conn_i))
+				tail.push([l, l_lev])
+				path_cache[l]=[l_lev, link]
+			  end
+			}
+		end
+		#$PDbgLog.sig_return("no path found.")
+		nil
+	end
+	
+	def self.path_cache_to_s(path_cache)
+		"{#{path_cache.keys.to_a.sort.collect{|k| k.to_s + "=>[#{
+		  path_cache[k][0]}, " + (path_cache[k][1] ?
+		  path_cache[k][1].to_s : 'nil') + "]"}.join(", ")}}"
+	end
+	
+	def self.path_cache_get_path_to_self(node, path_cache)
+		to_link = path_cache[node][1]
+		res = NodePath.new
+		while !to_link.node.node_eql?(node)
+			res << to_link
+			to_link = path_cache[to_link.node]
+		end
+		res << to_link
+		res.reverse_links!
+	end
+	
+	def self.path_cache_get_path(node, path_cache)
+		#$PDbgLog.sig_call(self)
+		#$PDbgLog.print_msg "node#{node}, path_cache: #{self.
+		#	path_cache_to_s(path_cache)}: "
+		to_link = path_cache[node][1]
+		res = NodePath.new
+		while to_link
+			res << to_link
+			to_link = path_cache[to_link.node][1]
+		end
+		res.reverse_links!
+		#$PDbgLog.sig_return(res.to_s(1))
+		res
+	end
+	
+	def find_first_path_to(dest, max_lev=1.0/0.0, path_cache=nil)
+		if max_lev < 0
+			return nil
+		end
+		if @link_filter
+			return self.find_first_path_to_with_link_filter(dest,
+				max_lev, path_cache)
+		end
+		if dest.kind_of?(Proc)
+			dest_proc = dest
+		else
+			dest_proc = proc {|node,lev| dest.node_eql?(node)}
+		end
+		tail = PMinHeap.new { |frm1,frm2| frm1[1] <=> frm2[1] }
+		unless path_cache
+			path_cache = @c_paths
+			unless dest.kind_of?(Proc)
+			  return NodeCalc.path_cache_get_path(dest,
+				path_cache) if path_cache.include?(dest)
+			end
+			path_cache.each_pair { |node, frm|
+				tail.push([node, frm[0]]) }
+		end
+		path_cache[@node] = [0, nil]
+		tail.push([@node, 0])
+		while !tail.empty?
+			node, lev = *tail.pop
+			next if path_cache.include?(node) &&
+				path_cache[node][0] < lev
+			if dest_proc.call(node, lev)
+				res = NodeCalc.path_cache_get_path(node,
+					path_cache)
+				return res
+			end
+			node.conns.each_with_index { |conn,conn_i| l = conn.exit
+			  if (l_lev = lev + conn.length) <= max_lev &&
+			  (!path_cache.include?(l) || path_cache[l][0] > l_lev)
+				tail.push([l, l_lev])
+				path_cache[l]=[l_lev,NodeLink.new(node,conn_i)]
+			  end
+			}
+		end
+		nil
+	end
+	
+	def find_first_path_to_with_link_filter(dest, max_lev, path_cache=nil)
+		#$PDbgLog.sig_call(self)
+		#$PDbgLog.print_msg "dest:#{dest}, max_lev=#{max_lev}"
+		if dest.kind_of?(Proc)
+			dest_proc = dest
+		else
+			dest_proc = proc {|node,lev| dest.node_eql?(node)}
+		end
+		tail = PMinHeap.new { |frm1,frm2| frm1[1] <=> frm2[1] }
+		unless path_cache
+			path_cache = @c_paths
+			if !dest.kind_of?(Proc) && path_cache.include?(dest)
+			  #$PDbgLog.sig_return(': cached.')
+			  return NodeCalc.path_cache_get_path(dest,
+				path_cache)
+			end
+			path_cache.each_pair { |node, frm|
+				tail.push([node, frm[0]]) }
+		end
+		path_cache[@node] = [0, nil]
+		tail.push([@node, 0])
+		while !tail.empty?
+			node, lev = *tail.pop
+			next if path_cache.include?(node) &&
+				path_cache[node][0] < lev
+			#$PDbgLog.print_msg "node#{node},lev=#{lev} "
+			if dest_proc.call(node, lev)
+				res = NodeCalc.path_cache_get_path(node,
+					path_cache)
+				#$PDbgLog.sig_return('Done.')
+				return res
+			end
+			node.conns.each_with_index { |conn,conn_i| l = conn.exit
+			  if (l_lev = lev + conn.length) <= max_lev &&
+			  (!path_cache.include?(l) || path_cache[l][0]>l_lev) &&
+			  @link_filter.call(link=NodeLink.new(node,conn_i))
+				tail.push([l, l_lev])
+				path_cache[l] = [l_lev, link]
+			  end
+			}
+		end
+		#$PDbgLog.sig_return(': nil')
+		nil
+	end
+	
+	def kill_path_cache!
+		@c_paths.clear
+	end
+	
+	def path_cache_each_path
+		iter = NodeCalcPCachePathIter.new(@c_paths)
+		@c_paths.each_key { |node|
+			iter.node = node
+			yield(iter)
+		}
+	end
+end
+
+end