extract-curves 0.1.1

data/ruby_libs/pav/floatsio.rb

@@ -0,0 +1,53 @@
+class FloatsInp
+	@@float_pat = Regexp.compile(/[+-]?(?:[0-9]+[.]?[0-9]*|[0-9]*[.]?[0-9]+)(?:[eE]?[0-9]*[.]?[0-9]*|)/)
+	
+	attr_reader :io, :rec_buf
+	
+	def initialize(*args)
+		@rec_buf = []
+		if args[0].kind_of?(IO)
+			@io = args[0]
+		else
+			@io = File.new(*args)
+		end
+	end
+	
+	def method_missing(id, *args, &block)
+		@io.send(id, *args, &block)
+	end
+	
+	def get_float
+		if @rec_buf.empty? && (ln = self.gets)
+			ln.scan(@@float_pat) { |f| @rec_buf << f.to_f }
+		end
+		@rec_buf.shift
+	end
+	
+	def each_float
+		while (f = self.get_float)
+			yield(f)
+		end
+	end
+	
+	def get_rec
+		if @rec_buf.empty?
+			return nil unless (ln = self.gets)
+			ln.scan(@@float_pat) { |f| @rec_buf << f.to_f }
+		end
+		res = @rec_buf
+		@rec_buf = []
+		res
+	end
+	
+	def each_rec
+		while (rec = self.get_rec)
+			yield(rec)
+		end
+	end
+	
+	def read_recs
+		res = []
+		self.each_rec { |rec| res << rec }
+		res
+	end
+end

data/ruby_libs/pav/generator_cache.rb

@@ -0,0 +1,165 @@
+#require 'generator'
+
+class GeneratorCacheArr < Array
+	def initialize(gen_spec=nil)
+		if !gen_spec
+			@gen_func = Proc.new
+		elsif gen_spec.kind_of?(Proc) || gen_spec.kind_of?(Method)
+			@gen_func = gen_spec
+		else
+			@gen_func = gen_spec.method("each")
+		end
+		@end = false
+		@next_lm = nil
+		super()
+		self.rewind
+	end
+	
+	def end?
+		@end
+	end
+	
+	def next?
+		!@end
+	end
+	
+	def rewind
+		callcc { |@ret|
+			@gen_func.call { |lm|
+				callcc { |@next_lm| @ret.call }
+				self << lm
+			}
+			@end = true
+			@next_lm = proc {
+				raise EOFError, "no more elements available" }
+			@ret.call
+		}
+		self.clear
+	end
+	
+	def next
+		callcc { |@ret| @next_lm.call }
+		self.last
+	end
+	
+	def current
+		self.last
+	end
+	
+	def index
+		self.length - 1
+	end
+	
+	def cache_upto(last_i)
+		if last_i
+			self.length.upto(last_i) {
+				return if @end
+				self.next
+			}
+		else
+			while !@end
+				self.next
+			end
+		end
+	end
+	
+	def [](*args)
+		if args.length == 1
+			i = args[0]
+			if i.kind_of? Range
+				if i.first < 0
+					last_i = nil
+				elsif i.last >= i.first
+					last_i = i.last + (i.exclude_end? ? 0:1)
+				else
+					if i.last + (i.exclude_end? ? 0:-1) < 0
+						last_i = nil
+					else
+						last_i = i.first
+					end
+				end
+			elsif i.kind_of? Array
+				last_i = i.max
+			elsif i.kind_of? Integer
+				if i < 0
+					last_i = nil
+				else
+					last_i = i
+				end
+			else
+				raise ArgumentError,
+					"Wrong single argument: #{i.inspect}"
+			end
+		elsif args.length == 2
+			last_i = args[0] + args[1] - 1
+		else
+			raise ArgumentError,
+				"Wrong numbef of arguments: #{args.inspect}"
+		end
+		self.cache_upto(last_i)
+		super(*args)
+	end
+end
+
+=begin
+class GeneratorCacheArr < Generator
+	def initialize(*args, &block)
+		@arr = []
+		super(*args, &block)
+	end
+	
+	def cache_upto(last_i)
+		if last_i
+			self.index.upto(last_i) {
+				return if self.end?
+				@arr << self.next
+			}
+		else
+			while !self.end?
+				@arr << self.next
+			end
+		end
+	end
+	
+	def [](*args)
+		if args.length == 1
+			i = args[0]
+			if i.kind_of? Range
+				if i.first < 0
+					last_i = nil
+				elsif i.last >= i.first
+					last_i = i.last + (i.exclude_end? ? 0:1)
+				else
+					if i.last + (i.exclude_end? ? 0:-1) < 0
+						last_i = nil
+					else
+						last_i = i.first
+					end
+				end
+			elsif i.kind_of? Array
+				last_i = i.max
+			elsif i.kind_of? Integer
+				if i < 0
+					last_i = -i-1
+				else
+					last_i = i
+				end
+			else
+				raise ArgumentError,
+					"Wrong single argument: #{i.inspect}"
+			end
+		elsif args.length == 2
+			last_i = args[0] + args[1] - 1
+		else
+			raise ArgumentError,
+				"Wrong numbef of arguments: #{args.inspect}"
+		end
+		self.cache_upto(last_i)
+		@arr[*args]
+	end
+	
+	def []=(*args)
+		@arr.[]=(*args)
+	end
+end
+=end

data/ruby_libs/pav/graph/node.rb

@@ -0,0 +1,602 @@
+require 'pav/pix'
+require 'pav/heap'
+require 'pav/collection/std'
+
+module PGraph
+
+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_k, :c_reverse
+	
+	def initialize(node, conn_k)
+		@node = node
+		@conn_k = conn_k
+		@c_reverse = nil
+	end
+	
+	def ==(link)
+		@node.node_eql?(link.node) && @conn_k == link.conn_k
+	end
+	
+	def reverse
+		return @c_reverse if @c_reverse
+		conn = @node.conns[@conn_k]
+		exit = conn.exit
+		r_conn = conn.reverse(@node)
+		exit.conns.each_key_value { |cn_k, cn|
+			if cn == r_conn
+				return @c_reverse = NodeLink.new(exit, cn_k)
+			end
+		}
+		raise NoReverseLinkError.new(self, @node),
+		  #"#{self.class.name}.reverse: No rev. link: " +
+		  "#{self}; conn.: #{node.conns[@conn_k]}; r_conn: #{r_conn}" +
+		  (exit.conns.length < 50 ? '; '+NodeConn.conns_to_s(
+		  exit.conns) : '')
+		nil
+	end
+	
+	def exit
+		@node.conns[@conn_k].exit
+	end
+	
+	def length
+		@node.conns[@conn_k].length
+	end
+	
+	def path
+		@node.conns[@conn_k].path
+	end
+	
+	def conn
+		@node.conns[@conn_k]
+	end
+	
+	def to_s(how=0)
+		"#{@node}-[#{@conn_k}]->" + (how >= 1 ? 
+			@node.conns[@conn_k].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 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 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 a Node!" unless
+			@exit.kind_of?(Node)
+		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_k, visited={})
+		return @c_max_depth if @c_max_depth
+		@c_max_depth = @length +
+			@exit.dir_max_depth(to_parent_conn_k, 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 Node
+	attr_reader :data, :conns, :c_rev_conns
+	attr_accessor :parent
+	
+	def initialize(data, conns)
+		@data = data
+		@conns = conns
+		@c_rev_conns = conns.class.new
+	end
+	
+	def rev_conn_key(conn_k)
+		if (tmp = @c_rev_conns[conn_k])
+			return tmp
+		end
+		conn = @conns[conn_k]
+		l = conn.exit
+		rev_conn = conn.reverse(self)
+		l.conns.each_key_value { |cn_k, cn|
+			return cn_k if cn == rev_conn }
+		raise NoReverseConnError.new(conn, self),
+			"#{self.coords_to_s} #{@conns[conn_k].to_s(2)}!"
+		nil
+	end
+	
+	def to_parent_conn_key(conn_k)
+		begin
+			self.rev_conn_key(conn_k)
+		rescue NoReverseConnError
+			if self.node_eql?(@conns[conn_k].exit)
+				@c_rev_conns[conn_k] = conn_k
+			else
+				raise
+			end
+		end
+	end
+	
+	def clear_rev_conns_cache
+		@c_rev_conns.clear
+	end
+	
+	def delete_conn(conn_k)
+		@conns.delete_key(conn_k)
+		@c_rev_conns.delete_key(conn_k)
+	end
+	
+	def conns_to_s
+		NodeConn.conns_to_s(@conns)
+	end
+	
+	def eql?(node)
+		@data.eql?(node.data)
+	end
+	
+	alias_method :node_eql?, :eql?
+	
+	def hash
+		@data.hash
+	end
+	
+	def each_link
+		@conns.each_key { |conn_k| yield(NodeLink.new(self, conn_k)) }
+	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.data }) { |node, lev|
+		  res = []
+		  node.conns.each_key_value { |cn_k, cn|
+			res << [cn.exit,NodeLink.new(node,cn_k),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] = Node.new(@data, conns=@conns.class.new)
+		@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_k)
+		begin
+			rev_conn_k = self.rev_conn_key(conn_k)
+		rescue NoReversePathwayError
+			rev_conn_k = nil
+		end
+		@conns[conn_k].max_depth(rev_conn_k)
+	end
+	
+	def dir_max_depth(to_parent_conn_k, visited)
+		#$PDbgLog.sig_call(self)
+		max_depth = 0
+		visited[self] = true
+		@conns.each_key_value { |conn_k, conn|
+			next if to_parent_conn_k == conn_k
+			if visited.include?(conn.exit)
+				max_depth = 1.0/0.0
+				break
+			end
+			tmp = conn.max_depth(self.rev_conn_key(conn_k), visited)
+			max_depth = tmp if tmp > max_depth
+		}
+		#$PDbgLog.sig_return
+		max_depth
+	end
+	
+	def graph_each_conn_k(visited={}, &block)
+		if visited.include?(self)
+			vis_conns = visited[self]
+		else
+			vis_conns = visited[self] = @conns.class.new
+		end
+		@conns.each_key_value { |conn_k, conn|
+		  unless vis_conns[conn_k]
+			yield(self, conn_k)
+			vis_conns[conn_k] = true
+			begin
+			  visited[conn.exit] = conn.exit.conns.class.new unless
+				visited.include?(conn.exit)
+			  visited[conn.exit][self.rev_conn_key(conn_k)] = true
+			rescue NoReversePathwayError
+			end
+			conn.exit.graph_each_conn_k(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 = @data.to_s
+		return res if how < 1
+		res.concat('+conns: ')
+		@conns.each_key_value { |conn_k, conn|
+			res.concat("[#{conn_k}]#{conn.to_s(how-1)}; ")
+		}
+		res[-2,2] = ''
+		res
+	end
+	
+	def graph_to_s
+		res = ''
+		self.graph_each_conn_k { |node, conn_k|
+			res.concat(node.to_s + ": [#{conn_k}]#{node.conns[
+				conn_k].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_key_value { |conn_k,conn| 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_k)]
+			  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_key_value { |conn_k,conn| l = conn.exit
+			  #$PDbgLog.print_msg "conn #{conn_k}: #{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_k))
+				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_key_value { |conn_k,conn| 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_k)]
+			  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_key_value { |conn_k,conn| 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_k))
+				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