extract-curves 0.1.1-i586-linux

data/ruby_libs/pav/pix/subpix.rb

@@ -0,0 +1,212 @@
+require 'pav/pix'
+
+module PPix
+
+class PixbufPix
+	def subpix8(sub_n)
+		@subpix8 = [] unless @subpix8
+		tmp = @subpix8[sub_n]
+		return tmp if tmp
+		@subpix8[sub_n] = Subpix8.new(self, sub_n)
+	end
+	
+	def subpix4(sub_n)
+		@subpix4 = [] unless @subpix4
+		tmp = @subpix4[sub_n]
+		return tmp if tmp
+		@subpix4[sub_n] = Subpix4.new(self, sub_n)
+	end
+end
+
+class SubXy < Xy
+	attr_accessor :sub_n
+	
+	def initialize(x, y, sub_n)
+		super(x, y)
+		@sub_n = sub_n
+	end
+	
+	def yxn
+		self.yx + [@sub_n]
+	end
+	
+	def to_s
+		"(#{self.x}, #{self.y}, sub=#{@sub_n})"
+	end
+	
+	def inspect
+		idmem = self.object_id & ( (1 << (8*self.object_id.size)) - 1 )
+		"<#{self.class.name}:0x%x: " % idmem + self.to_s + ">"
+	end
+	
+	def <=>(subxy)
+		self.yxn <=> subxy.yxn
+	end
+	
+	def eql?(subxy)
+		subxy && self.y == subxy.y && self.x == subxy.x &&
+			self.sub_n == subxy.sub_n
+	end
+end
+
+class Subpix < SubXy
+	attr_reader :img_pix
+	
+	def self.mk_sub_n_neighbs(adj_subpix_order)
+	  subpix_cnt = 2*adj_subpix_order.length
+	  ofs1 = adj_subpix_order.length - 2
+	  ofs2 = adj_subpix_order.length + 2
+	  (0...subpix_cnt).collect { |n|
+		res = [	SubXy.new(0, 0, (n-1) % subpix_cnt),
+			SubXy.new(0, 0, (n+1) % subpix_cnt)]
+		if (n & 1) == 0
+		  a1 = adj_subpix_order[n/2 - 1]
+		  a2 = adj_subpix_order[n/2]
+		  res[1,0]=[SubXy.new(a1.x,a1.y,(n+ofs1) % subpix_cnt)]
+		  res << SubXy.new(a2.x,a2.y,(n+ofs2) % subpix_cnt)
+		else
+			a1_2 = adj_subpix_order[n/2]
+			res[1,0] = [SubXy.new(a1_2.x, a1_2.y,
+				(n + adj_subpix_order.length) % subpix_cnt)]
+		end
+		res
+	  } << (0...subpix_cnt).collect { |n| SubXy.new(0, 0, n) }
+	end
+	
+	def self.path_to_s(path)
+		path.collect { |subpix| subpix.to_s }.join(" ")
+	end
+	
+	def initialize(img_pix, sub_n)
+		@img_pix = img_pix
+		super(@img_pix.x, @img_pix.y, sub_n)
+	end
+	
+	def adj
+		self.neighbs.find_all { |ngb|
+			ngb.img_pix.x >= 0 &&
+			ngb.img_pix.x < ngb.img_pix.pixbuf.picture_width &&
+			ngb.img_pix.y >= 0 &&
+			ngb.img_pix.y < ngb.img_pix.pixbuf.picture_height
+		}
+	end
+	
+	cache_attr! :adj
+end
+
+class Subpix8 < Subpix
+	SUB_N_NEIGHBS = Subpix.mk_sub_n_neighbs(Xy::ADJ8_CCW_ORDER)
+	SUB_N_BORDER = SUB_N_NEIGHBS
+	
+	def neighbs
+		SUB_N_NEIGHBS[@sub_n].collect { |ngb_spec|
+			@img_pix.pixbuf.get_pix(@img_pix.x + ngb_spec.dx,
+				@img_pix.y + ngb_spec.dy).
+			subpix8(ngb_spec.sub_n)
+		}
+	end
+	
+	def neighbs_into(res=[])
+		res.clear
+		SUB_N_NEIGHBS[@sub_n].each { |ngb_spec|
+			res << @img_pix.pixbuf.get_pix(@img_pix.x + ngb_spec.dx,
+				@img_pix.y+ngb_spec.dy).subpix8(ngb_spec.sub_n)
+		}
+		res
+	end
+	
+	alias_method :border, :neighbs
+	alias_method :border_into, :neighbs_into
+	
+	def self.vertical?(sub_n)
+		[7, 15].include?(sub_n)
+	end
+	
+	def self.horizontal?(sub_n)
+		[3, 11].include?(sub_n)
+	end
+	
+	def vertical?
+		[7, 15].include?(@sub_n)
+	end
+	
+	def horizontal?
+		[3, 11].include?(@sub_n)
+	end
+	
+	def to_s
+		"(#{self.x}, #{self.y}, sub8=#{self.sub_n})"
+	end
+	
+	cache_attr! :neighbs, :border
+end
+
+class Subpix4 < Subpix
+	SUB_N_NEIGHBS = Subpix.mk_sub_n_neighbs(PixbufPix::ADJ4_CCW_ORDER)
+	SUB_N_BORDER = (0...8).collect { |i|
+		res = SUB_N_NEIGHBS[i]
+		if i & 1 == 0
+			a = PixbufPix::ADJ8_CCW_ORDER[i]
+			res += [SubXy.new(a.x, a.y, (i+4) % 8)]
+		end
+		res
+	} << SUB_N_NEIGHBS.last
+	
+	def neighbs
+		SUB_N_NEIGHBS[@sub_n].collect { |ngb_spec|
+			@img_pix.pixbuf.get_pix(@img_pix.x + ngb_spec.dx,
+				@img_pix.y + ngb_spec.dy).
+			subpix4(ngb_spec.sub_n)
+		}
+	end
+	
+	def border
+		SUB_N_BORDER[@sub_n].collect { |ngb_spec|
+			@img_pix.pixbuf.get_pix(@img_pix.x + ngb_spec.dx,
+				@img_pix.y + ngb_spec.dy).
+			subpix4(ngb_spec.sub_n)
+		}
+	end
+	
+	def neighbs_into(res=[])
+		res.clear
+		SUB_N_NEIGHBS[@sub_n].each { |ngb_spec|
+			res << @img_pix.pixbuf.get_pix(@img_pix.x + ngb_spec.dx,
+				@img_pix.y+ngb_spec.dy).subpix4(ngb_spec.sub_n)
+		}
+		res
+	end
+	
+	def border_into(res=[])
+		res.clear
+		SUB_N_BORDER[@sub_n].each { |ngb_spec|
+			res << @img_pix.pixbuf.get_pix(@img_pix.x + ngb_spec.dx,
+				@img_pix.y+ngb_spec.dy).subpix4(ngb_spec.sub_n)
+		}
+		res
+	end
+	
+	def self.vertical?(sub_n)
+		[3, 7].include?(sub_n)
+	end
+	
+	def self.horizontal?(sub_n)
+		[1, 5].include?(sub_n)
+	end
+	
+	def vertical?
+		[3, 7].include?(@sub_n)
+	end
+	
+	def horizontal?
+		[1, 5].include?(@sub_n)
+	end
+	
+	def to_s
+		"(#{self.x}, #{self.y}, sub4=#{self.sub_n})"
+	end
+	
+	cache_attr! :neighbs, :border
+end
+
+end

data/ruby_libs/pav/rand_accessible.rb

@@ -0,0 +1,16 @@
+module RandomlyReadable
+
+def [](i, len=nil)
+	if len
+		is = i...i+len
+	else
+		if i.kind_of?(Integer)
+			return at(i)
+		else
+			is = i
+		end
+	end
+	is.collect { |i| at(i) }
+end
+
+end

data/ruby_libs/pav/rangeset.rb

@@ -0,0 +1,63 @@
+require 'pav/search'
+
+class RangeSet
+	attr_accessor :ranges
+	
+	def initialize
+		@ranges = []
+		@cmp_proc = proc { |range, n| range[0] <=> n }
+	end
+	
+	def extend_range_to(range_i, end_n)
+		j = range_i
+		j += 1 while j+1 < @ranges.length && @ranges[j+1][0] <= end_n
+		end_n = @ranges[j][1] if @ranges[j][1] > end_n
+		@ranges[range_i][1] = end_n
+		@ranges[range_i+1..j] = nil
+	end
+	
+	def merge_range!(start_n, end_n)
+		if (i = PSearch.bsearch(@ranges, start_n, &@cmp_proc)) >= 0
+			self.extend_range_to(i, end_n)
+		else
+			i = -i-1
+			if i > 0 && @ranges[i-1][1] >= start_n
+				self.extend_range_to(i-1, end_n)
+			elsif i < @ranges.length && @ranges[i][0] <= end_n
+				@ranges[i][0] = start_n
+				self.extend_range_to(i, end_n)
+			else
+				@ranges[i, 0] = [[start_n, end_n]]
+			end
+		end
+	end
+	
+	def include?(n)
+		return true if (i = PSearch.bsearch(@ranges, n, &@cmp_proc))>=0
+		i = -i-1
+		i > 0 && @ranges[i-1][1] >= n
+	end
+	
+	alias_method :member?, :include?
+	
+	def range_end(n)
+		if (i = PSearch.bsearch(@ranges, n, &@cmp_proc)) >= 0
+			@ranges[i][1]
+		else
+			i = -i-1
+			if i > 0 && @ranges[i-1][1] >= n
+				@ranges[i-1][1]
+			else
+				n
+			end
+		end
+	end
+	
+	def inspect
+		idmem = self.object_id & ( (1 << (8*self.object_id.size)) - 1 )
+		"#<#{self.class.name}:0x%x: " % idmem + @ranges.collect { |r|
+		"#{r[0]}..#{r[1]}"}.join(", ") + ">"
+	end
+	
+	alias_method :to_s, :inspect
+end

data/ruby_libs/pav/search.rb

@@ -0,0 +1,210 @@
+require 'pav/heap'
+
+module PSearch
+
+def self.bsearch(arr, lm, start_i=0, end_i=nil) # &block = optional comparator
+	end_i = arr.length-1 if !end_i
+	if block_given?
+		while start_i < end_i
+			mid_i = (end_i + start_i) / 2
+			if (leg = yield(arr[mid_i], lm)) > 0
+				end_i = mid_i-1
+			elsif leg < 0
+				start_i = mid_i+1
+			else
+				return mid_i
+			end
+		end
+		if start_i == end_i
+			if (leg = yield(arr[start_i], lm)) == 0
+				return start_i
+			elsif leg > 0
+				return -start_i-1
+			else
+				return -start_i-2
+			end
+		end
+	else
+		while start_i < end_i
+			mid_i = (end_i + start_i) / 2
+			if (val = arr[mid_i]) > lm
+				end_i = mid_i-1
+			elsif val < lm
+				start_i = mid_i+1
+			else
+				return mid_i
+			end
+		end
+		if start_i == end_i
+			if arr[start_i] == lm
+				return start_i
+			elsif arr[start_i] > lm
+				return -start_i-1
+			else
+				return -start_i-2
+			end
+		end
+	end
+	-start_i-1
+end
+
+def self.path_cache_get_path(path_cache, start_pos, pos, get_pos_id_proc=nil)
+	#$PDbgLog.sig_call(self)
+	#$PDbgLog.print_msg "start_pos=#{start_pos}, pos=#{pos}: "
+#	$PDbgLog.print_msg "path_cache: #{path_cache.keys.sort.collect{|k|
+#		k.inspect+'=>[' + path_cache[k].join(', ') + ']'}.join('; ')}: "
+	res = []
+	if get_pos_id_proc
+		pos, to_link = *path_cache[get_pos_id_proc.call(pos)]
+		return res unless to_link
+		start_pos_id = get_pos_id_proc.call(start_pos)
+		while to_link
+			res << to_link
+			break if get_pos_id_proc.call(pos) == start_pos_id
+			pos, to_link = *path_cache[get_pos_id_proc.call(pos)]
+		end
+	else
+		pos, to_link = *path_cache[pos]
+		return res unless pos
+		while to_link
+			res << to_link
+			break if pos == start_pos
+			pos, to_link = *path_cache[pos]
+		end
+	end
+	#$PDbgLog.sig_return(res.join(' '))
+	res
+end
+
+# Wave (breadth) / Dijkstra search:
+def self.first_loop(start_pos, dest_proc, max_lev=1.0/0.0, get_pos_id_proc=nil)
+# &get_neighb_posns
+  #$PDbgLog.sig_call(self)
+  path_cache={}
+  tail = PMinHeap.new { |frm1,frm2| frm1[1] <=> frm2[1] }
+  if get_pos_id_proc
+	yield(start_pos, 0).each { |args| neighb, to_link, neighb_lev = *args
+		unless (path_cache.include?(get_pos_id_proc.call(neighb)) &&
+		path_cache[get_pos_id_proc.call(neighb)][2] <= neighb_lev) ||
+		neighb_lev > max_lev
+			tail.push([neighb, neighb_lev])
+			path_cache[get_pos_id_proc.call(neighb)] =
+				[start_pos, to_link, neighb_lev]
+		end
+	}
+	while !tail.empty?
+		#$PDbgLog.puts_msg "tail: " + tail.collect { |frm|
+		#  (frm[0] ? frm[0].coords_to_s : frm[0].inspect) +
+		#  ":#{frm[1]}" }.join(" ")
+		pos, lev = *tail.pop
+		next if (tmp=path_cache[get_pos_id_proc.call(pos)])&& tmp[2]<lev
+		if dest_proc.call(pos, lev)
+			(res = self.path_cache_get_path(path_cache, start_pos,
+				pos, get_pos_id_proc)).reverse!
+			#$PDbgLog.sig_return
+			return res
+		end
+		yield(pos, lev).each { |args| neighb, to_link,neighb_lev = *args
+			unless ((tmp=path_cache[get_pos_id_proc.call(neighb)])&&
+			tmp[2] <= neighb_lev) || neighb_lev > max_lev
+				tail.push([neighb, neighb_lev])
+				path_cache[get_pos_id_proc.call(neighb)] =
+					[pos, to_link, neighb_lev]
+			end
+		}
+	end
+	#$PDbgLog.sig_return("nil")
+	nil
+  else
+	yield(start_pos, 0).each { |args| neighb, to_link, neighb_lev = *args
+		unless (path_cache.include?(neighb) &&
+		path_cache[neighb][2] <= neighb_lev) || neighb_lev > max_lev
+			tail.push([neighb, neighb_lev])
+			path_cache[neighb] = [start_pos, to_link, neighb_lev]
+		end
+	}
+	while !tail.empty?
+		#$PDbgLog.puts_msg "tail: " + tail.collect { |frm|
+		#  (frm[0] ? frm[0].coords_to_s : frm[0].inspect) +
+		#  ":#{frm[1]}" }.join(" ")
+		pos, lev = *tail.pop
+		next if path_cache.include?(pos) && path_cache[pos][2] < lev
+		if dest_proc.call(pos, lev)
+			(res = self.path_cache_get_path(path_cache, start_pos,
+				pos)).reverse!
+			#$PDbgLog.sig_return
+			return res
+		end
+		yield(pos, lev).each { |args| neighb, to_link,neighb_lev = *args
+			unless (path_cache.include?(neighb) &&
+			path_cache[neighb][2] <= neighb_lev) ||
+			neighb_lev > max_lev
+				tail.push([neighb, neighb_lev])
+				path_cache[neighb] = [pos, to_link, neighb_lev]
+			end
+		}
+	end
+	#$PDbgLog.sig_return("nil")
+	nil
+  end
+end
+
+# Find a loop which functions without a repetition of a connection in the
+# _undirected_ graph of positions.
+def self.first_norep_loop(start_pos, max_lev=1.0/0.0, max_len=1.0/0.0,
+get_pos_id_proc=nil) # &get_neighb_posns
+  #$PDbgLog.sig_call(self)
+  tail = PMinHeap.new { |frm1,frm2| frm1[1] <=> frm2[1] }
+  get_pos_id_proc = proc { |a| a } unless get_pos_id_proc
+  start_pos_id = get_pos_id_proc.call(start_pos)
+  path_cache = {start_pos_id => [nil, nil, 0, -1]}
+  sol = nil
+	yield(start_pos, 0).each_with_index { |args, thr_i|
+		neighb, to_link, neighb_lev = *args
+		next if neighb_lev > max_lev
+		if (tmp=path_cache[get_pos_id_proc.call(neighb)])
+			len = tmp[2] + neighb_lev
+			if (!sol || sol[3] > len) && len <= max_len
+				sol = [neighb, start_pos, to_link, len]
+			end
+		else
+			tail.push([neighb, neighb_lev, thr_i])
+			path_cache[get_pos_id_proc.call(neighb)] =
+				[start_pos, to_link, neighb_lev, thr_i]
+		end
+	}
+	loop do
+		if sol
+			p1 = self.path_cache_get_path(path_cache, start_pos,
+				sol[0], get_pos_id_proc)
+			path_cache[get_pos_id_proc.call(sol[0])] = [sol[1],
+				sol[2]]
+			#$PDbgLog.sig_return
+			return [p1, self.path_cache_get_path(path_cache,
+			  	start_pos, sol[0], get_pos_id_proc), sol[3]]
+		end
+		if tail.empty?
+			#$PDbgLog.sig_return("nil")
+			return nil
+		end
+		pos, lev, thr_i = *tail.pop
+		next if (tmp=path_cache[get_pos_id_proc.call(pos)]) &&tmp[2]<lev
+		yield(pos, lev).each { |args| neighb, to_link,neighb_lev = *args
+			next if neighb_lev > max_lev ||
+				get_pos_id_proc.call(neighb) == start_pos_id
+			if (tmp=path_cache[get_pos_id_proc.call(neighb)]) &&
+			tmp[3] != thr_i
+				if (len=tmp[2] + neighb_lev) <= max_len &&
+				(!sol || sol[3] > len)
+					sol = [neighb, pos, to_link, len]
+				end
+			elsif !tmp || tmp[2] > neighb_lev
+				tail.push([neighb, neighb_lev, thr_i])
+				path_cache[get_pos_id_proc.call(neighb)] =
+					[pos, to_link, neighb_lev, thr_i]
+			end
+		}
+	end
+end
+
+end