extract_curves 0.0.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/pix.rb

@@ -0,0 +1,402 @@
+require 'gtk2'
+require 'sync'
+require 'observer'
+require 'pav/sub_arr'
+require 'pav/attr_cache'
+require 'pav/string/ext'
+
+begin
+ require 'pav/pav'
+rescue LoadError
+
+module PPix
+
+class Xy
+	attr_accessor :x, :y
+	
+	def initialize(x, y)
+		@x = x
+		@y = y
+	end
+	
+	def coords_to_s
+		"(#{@x}, #{@y})"
+	end
+end
+
+class Xy
+	ADJACENT4 = [Xy.new(1, 0), Xy.new(0, 1), Xy.new(-1, 0), Xy.new(0, -1)]
+	ADJACENT8 = ADJACENT4 + [Xy.new(1,1), Xy.new(-1,1),
+					Xy.new(-1,-1), Xy.new(1, -1)]
+end
+
+class PixbufPix < Xy
+	include AttrCache
+	
+	attr_reader :pixbuf, :x, :y, :color_id, :yx
+	
+	def self.rgb_to_hsv(r, g, b)
+		# From the colorsys module of Python 2.4:
+		maxc = [r, g, b].max
+		minc = [r, g, b].min
+		v = maxc
+		return [0.0, 0.0, v] if minc == maxc
+		s = (maxc-minc) / maxc
+		rc = (maxc-r) / (maxc-minc)
+		gc = (maxc-g) / (maxc-minc)
+		bc = (maxc-b) / (maxc-minc)
+		if r == maxc then h = bc-gc
+		elsif g == maxc then h = 2.0+rc-bc
+		else h = 4.0+gc-rc; end
+		h = (h/6.0) % 1.0
+		[h, s, v]
+	end
+	
+	def initialize(pixbuf, x, y)
+		@pixbuf = pixbuf
+		@x = x
+		@y = y
+		@yx = [y, x]
+		#@pixbuf.add_observer(PixbufObserver.new(self))
+	end
+	
+	def color_id
+		#$PDbgLog.sig_call(self); c =
+		@pixbuf.pixels[@pixbuf.ofs0 + @y*@pixbuf.rowstride +
+			@x*@pixbuf.pix_length, @pixbuf.pix_length]
+		#$PDbgLog.sig_return("#{self.coords_to_s}: #{c.unpack("H*")}")
+		#c
+	end
+	
+	def color_rgb
+		#$PDbgLog.sig_call(self)
+		cid = self.color_id; clen = @pixbuf.sample_length
+		#res =
+		[cid[0,clen].bits_to_i, cid[clen, clen].bits_to_i,
+			cid[2*clen, clen].bits_to_i]
+		#$PDbgLog.sig_return("color_id=#{cid.inspect}: #{res.inspect}")
+		#res
+	end
+	
+	def color_hsv
+		r, g, b = *self.color_rgb
+		c_max = Float((1 << @pixbuf.bits_per_sample) - 1)
+		PixbufPix.rgb_to_hsv(r/c_max, g/c_max, b/c_max)
+	end
+	
+	def virtual?
+		@x < 0 || @x >= @pixbuf.picture_width || @y < 0 ||
+		@y >= @pixbuf.picture_height
+	end
+	
+	def border?(adjacents = ADJACENT8)
+		clr = self.color_id
+		for adj in adjacents
+			x, y = @x + adj.x, @y + adj.y
+			return true if x < 0 || x >= @pixbuf.picture_width ||
+				y < 0 || y >= @pixbuf.picture_height
+			return true if @pixbuf.get_pix(x, y).color_id != clr
+		end
+		false
+	end
+	
+	def border8?
+		self.border?
+	end
+	
+	def border4?
+		self.border?(ADJACENT4)
+	end
+	
+	def adj(adjacents = ADJACENT8)
+		res = []
+		for adj in adjacents
+			if (x=@x+adj.x) >= 0 && x < @pixbuf.picture_width &&
+			(y=@y+adj.y) >= 0 && y < @pixbuf.picture_height
+				res << @pixbuf[y][x]
+			end
+		end
+		res
+	end
+	
+	def adj8
+		self.adj
+	end
+	
+	def adj4
+		self.adj(ADJACENT4)
+	end
+	
+	def adj_cocolor(adjacents = ADJACENT8)
+		clr = self.color_id
+		res = []
+		adjacents.each { |adj| x, y = @x + adj.x, @y + adj.y
+			if x >= 0 && x < @pixbuf.picture_width && y >= 0 &&
+			y < @pixbuf.picture_height
+				pix = @pixbuf.get_pix(x, y)
+				res << pix if pix.color_id == clr
+			end
+		}
+		res
+	end
+	
+	def adj_cocolor8
+		self.adj_cocolor
+	end
+	
+	def adj_cocolor4
+		self.adj_cocolor(ADJACENT4)
+	end
+	
+	def adj_fuzzy_rgb_cocolor(adjacents=ADJACENT8, r_toler=10, g_toler=10,
+	b_toler=10)
+		r, g, b = *self.color_rgb
+		w = @pixbuf.picture_width; h = @pixbuf.picture_height
+		res = []
+		adjacents.each { |adj| x = @x + adj.x; y = @y + adj.y
+		  if x >= 0 && x < w && y >= 0 && y < h
+			ra, ga, ba = *(apix = @pixbuf.get_pix(x,y)).color_rgb
+			res << apix if (ra - r).abs <= r_toler &&
+				(ga - g).abs <= g_toler &&
+				(ba - b).abs <= b_toler
+		  end
+		}
+		res
+	end
+	
+	def adj_fuzzy_hsv_cocolor(adjacents=ADJACENT8, h_toler=0.1, s_toler=0.1,
+	v_toler=0.1)
+		h, s, v = *self.color_hsv
+		w = @pixbuf.picture_width; hgt = @pixbuf.picture_height
+		res = []
+		adjacents.each { |adj| x = @x + adj.x; y = @y + adj.y
+		  if x >= 0 && x < w && y >= 0 && y < hgt
+			ha, sa, va = *(apix = @pixbuf.get_pix(x,y)).color_hsv
+			res << apix if (ha - h).abs <= h_toler &&
+				(sa - s).abs <= s_toler &&
+				(va - v).abs <= v_toler
+		  end
+		}
+		res
+	end
+	
+	#cache_attr! :color_id, :color_rgb
+	#freeze_cache_attr! :border8?, :border4?, :adj8, :adj4, :adj_cocolor8,
+	#	:adj_cocolor4, :adj_border_cocolor8_4, :color_hsv
+	
+	def color_id=(val)
+		@pixbuf.set_pix(@x, @y, val)
+	end
+	
+	def hash
+		#@x.hash + @y.hash + @pixbuf.hash
+		#self.yx.hash
+		@y * @pixbuf.width + @x
+	end
+end
+
+class Pixbuf #< Gdk::Pixbuf
+	#include Sync_m
+	
+	attr_accessor :border_width, :ofs0, :picture_width, :picture_height
+	attr_reader :pix_length, :sample_length
+	
+	def initialize(*args)
+		unless args.length==1 && (@under=args[0]).kind_of?(Gdk::Pixbuf)
+			@under = Gdk::Pixbuf.new(*args)
+		end
+		@virtual_pix = {}
+		@sample_length = self.bits_per_sample / 8
+		@pix_length = self.n_channels * @sample_length
+		@picture_width = self.width
+		@picture_height = self.height
+		@border_width = 0
+		@ofs0 = 0
+	end
+	
+	def method_missing(id, *args, &block)
+		@under.send(id, *args, &block)
+	end
+	
+	def get_pix(x, y)
+		if x < 0 || y < 0 || x >= @picture_width || y >= @picture_height
+			tmp = @virtual_pix[[y, x]]
+			return tmp if tmp
+			return (@virtual_pix[[y, x]] = PixbufPix.new(self,x,y))
+		end
+	end
+	
+	def set_pix(x, y, clr)
+		if x < 0
+			if x < -self.width
+				return nil
+			else	x = self.width+x end
+		else
+			if x >= self.width
+				return nil
+			end
+		end
+		if y < 0
+			if y < -self.height
+				return nil
+			else	y = self.height+y end
+		else
+			if y >= self.height
+				return nil
+			end
+		end
+		ofs = y*@rowstride + x*@pix_length
+		self.synchronize {
+			self.changed( c = (@pixels[ofs,@pix_length]==
+				(@pixels[ofs,@pix_length]=clr)) )
+			if c
+			  self.notify_observers(self, "set_pix",[x,y,clr],nil)
+			  pix.update(self, "set_pix",[x,y,clr],nil) if
+			  	@scanlines[y] && (pix = @scanlines[y].pixels[x])
+			end
+		}
+	end
+	
+	def dup
+		Pixbuf.new(@pixels.dup, @width, @height, @n_channels,
+			@rowstride)
+	end
+	
+	def add_border(width)
+		res_pb = Gdk::Pixbuf.new(self.colorspace, self.has_alpha?,
+			self.bits_per_sample, self.width+2*width,
+			self.height+2*width)
+		res_pb.scale!(@under, width, width,
+			self.width+width, self.height+width, width, width,
+			1, 1, Gdk::Pixbuf::INTERP_NEAREST)
+		res_pb = Pixbuf.new(res_pb)
+		res_pb.picture_width = self.picture_width
+		res_pb.picture_height = self.picture_height
+		res_pb.border_width = self.border_width + width
+		res_pb
+	end
+	
+	def scaled(kx, ky, x, y, width, height)
+		res_pb = Gdk::Pixbuf.new(self.colorspace, self.has_alpha?,
+			self.bits_per_sample, width, height)
+		res_pb.scale!(@under, 0, 0, width, height, -x, -y, kx, ky,
+			Gdk::Pixbuf::INTERP_NEAREST)
+		res_pb
+	end
+	
+	def dup
+		res = Pixbuf.new(@under.dup)
+		res.picture_width = self.picture_width
+		res.picture_height = self.picture_height
+		res.ofs0 = self.ofs0
+		res.border_width = self.border_width
+		res
+	end
+	
+	def <=>(other)
+		return leg if (leg = @width <=> other.width) != 0
+		return leg if (leg = @height <=> other.height) != 0
+		return leg if (leg = @pix_length <=> other.pix_length) != 0
+		self.object_id <=> other.object_id
+		#@pixels <=> other.pixels
+	end
+	
+	#cache_attr! :pixels
+end
+
+end # module PPix
+
+end # require 'pav/pav'
+
+module PPix
+
+class Xy
+	include Comparable
+	
+	ADJ8_CCW_ORDER = [Xy.new(1,-1), Xy.new(0,-1), Xy.new(-1,-1),
+	  Xy.new(-1,0), Xy.new(-1,1), Xy.new(0,1), Xy.new(1,1), Xy.new(1,0)]
+	
+	ADJ4_CCW_ORDER = (0...4).collect {|i| ADJ8_CCW_ORDER[2*i+1] }
+	
+	def neighb8?(pix)
+		dx = (self.x - pix.x).abs; dy = (self.y - pix.y).abs
+		dx < 2 && dy < 2
+	end
+	
+	def neighb4?(pix)
+		dx = (self.x - pix.x).abs; dy = (self.y - pix.y).abs
+		(dx < 2 && dy == 0) || (dy < 2 && dx == 0)
+	end
+	
+	def self.path_to_s(path)
+		path.collect { |xy| xy.coords_to_s }.join(' ')
+	end
+	
+	def <=>(other)
+		self.yx <=> other.yx
+	end
+	
+	def hash
+		self.yx.hash
+	end
+	
+	def eql?(xy)
+		self.yx == xy.yx
+	end
+end
+
+module MPixbufPix
+	def adj_border_cocolor(adjacents = ADJACENT8, border_adj = ADJACENT4)
+		self.adj(adjacents).find_all { |pix| pix.border?(border_adj) }
+	end
+	
+	def adj_border_cocolor8_4
+		self.adj_border_cocolor
+	end
+	
+	def adj_border_cocolor4_8
+		self.adj_border_cocolor(ADJACENT4, ADJACENT8)
+	end
+	
+	def end_pt_excl_yx_set?(excl_set)
+		self.adj8.find_all { |pix| !excl_set.include?(pix.yx) }.length<2
+	end
+	
+	def end_pt_incl_set?(incl_set)
+		self.adj8.find_all { |pix| incl_set.include?(pix) }.length < 2
+	end
+	
+	#def to_s
+	#	self.class.name + self.coords_to_s 
+	#end
+end
+
+class Xy
+	def adj8_get_i(adj)
+		x = adj.x - self.x; y = adj.y - self.y
+		Xy::ADJ8_CCW_ORDER.each_with_index{ |a,i|
+			return i if a.y == y && a.x == x }
+		nil
+	end
+	
+	def self.adj8_xy_id(dx, dy)
+		((dy + 1) << 2) | (dx + 1)
+	end
+	
+	tmp1 = []
+	ADJ8_CCW_ORDER.each_with_index { |a,i| tmp1[self.adj8_xy_id(a.x,a.y)] = 
+		[a, i, 1<<i] }
+	tmp1[self.adj8_xy_id(0,0)] = [nil, 8, 0]
+	ADJ8_ID2SPEC = tmp1
+	
+	def adj8_situation_id(neighbs)
+		res = 0
+		for ngb in neighbs
+			res |= Xy::ADJ8_ID2SPEC.at(PixbufPix.adj8_xy_id(
+				ngb.x - self.x, ngb.y - self.y)).at(2)
+		end
+		res
+	end
+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