extract-curves 0.1.1-mswin32

data/ruby_libs/pav/patterns/yg_vrope_thin.xpm

@@ -0,0 +1,166 @@
+/* XPM */
+static char * yg_vrope_thin_xpm[] = {
+"5 41 122 2",
+"  	c None",
+". 	c #6EB880",
+"+ 	c #4FD7BB",
+"@ 	c #487C5F",
+"# 	c #808C50",
+"$ 	c #41C29E",
+"% 	c #4BA086",
+"& 	c #B49E5A",
+"* 	c #54A576",
+"= 	c #41A889",
+"- 	c #F7E9A5",
+"; 	c #C3B276",
+"> 	c #5A8F6E",
+", 	c #6DC59B",
+"' 	c #EEE7BA",
+") 	c #B7AC79",
+"! 	c #289D7B",
+"~ 	c #6E975E",
+"{ 	c #F0E6B8",
+"] 	c #657057",
+"^ 	c #35B69A",
+"/ 	c #2E764F",
+"( 	c #E8DFAB",
+"_ 	c #6D7157",
+": 	c #71EFDE",
+"< 	c #289B7E",
+"[ 	c #A0B284",
+"} 	c #67E7D1",
+"| 	c #3F977B",
+"1 	c #A8A55D",
+"2 	c #3CA579",
+"3 	c #5FD5BF",
+"4 	c #C6B067",
+"5 	c #548653",
+"6 	c #6DE2CE",
+"7 	c #C6B474",
+"8 	c #58AC8C",
+"9 	c #F2EAC0",
+"0 	c #A1A57E",
+"a 	c #30AF8F",
+"b 	c #719458",
+"c 	c #E1D8B0",
+"d 	c #32B297",
+"e 	c #378658",
+"f 	c #E5DDAF",
+"g 	c #78F0E1",
+"h 	c #2DAA8B",
+"i 	c #BCC69E",
+"j 	c #61E9D2",
+"k 	c #579E80",
+"l 	c #B4B870",
+"m 	c #48CAAB",
+"n 	c #67C7B0",
+"o 	c #B4A85D",
+"p 	c #399D71",
+"q 	c #8BE4D2",
+"r 	c #E6CD65",
+"s 	c #7BA16B",
+"t 	c #84D6C5",
+"u 	c #E2D988",
+"v 	c #EADA91",
+"w 	c #6D9474",
+"x 	c #48BD95",
+"y 	c #D7CF95",
+"z 	c #C5C2A0",
+"A 	c #37B495",
+"B 	c #749B5E",
+"C 	c #E1DBB8",
+"D 	c #62E3CF",
+"E 	c #509865",
+"F 	c #D7D3B0",
+"G 	c #6EEED9",
+"H 	c #49CEB2",
+"I 	c #92A37C",
+"J 	c #91C886",
+"K 	c #68E6D0",
+"L 	c #62AC91",
+"M 	c #B2B368",
+"N 	c #3DB491",
+"O 	c #88D7C2",
+"P 	c #D9CA7E",
+"Q 	c #3DA174",
+"R 	c #76D3BB",
+"S 	c #F8EEBF",
+"T 	c #BBCFA1",
+"U 	c #6AB697",
+"V 	c #C5E0B2",
+"W 	c #F4EBC1",
+"X 	c #869470",
+"Y 	c #46BA91",
+"Z 	c #C0BC79",
+"` 	c #BCBB92",
+" .	c #3EBD9E",
+"..	c #80A768",
+"+.	c #DBD6AE",
+"@.	c #6BEBD5",
+"#.	c #62C6A0",
+"$.	c #D1D1AF",
+"%.	c #68D4A8",
+"&.	c #7CEFDB",
+"*.	c #679879",
+"=.	c #BCC776",
+"-.	c #36AA88",
+";.	c #6EC5AB",
+">.	c #E0D47B",
+",.	c #35895E",
+"'.	c #4CB397",
+").	c #FAF2C6",
+"!.	c #ABC38E",
+"~.	c #4FB08E",
+"{.	c #D5DBA3",
+"].	c #FBF4D0",
+"^.	c #AFB68C",
+"/.	c #5FD8B7",
+"(.	c #C9C388",
+"_.	c #E5DEB7",
+":.	c #6EE4CF",
+"<.	c #5A975E",
+"[.	c #E0D7A8",
+"}.	c #8BF2E1",
+"|.	c #4CC19D",
+"1.	c #BCC08E",
+"  . + @   ",
+"  # $ %   ",
+"  & * =   ",
+"  - ; >   ",
+"  , ' )   ",
+"  ! ~ { ] ",
+"  ^ / ( _ ",
+"  : < [   ",
+"    } |   ",
+"  1 2 3   ",
+"  4 5 6   ",
+"    7 8   ",
+"    9 0   ",
+"  a b c   ",
+"  d e f   ",
+"  g h i   ",
+"    j k   ",
+"  l m n   ",
+"  o p q   ",
+"  r s t   ",
+"  u v w   ",
+"  x y z   ",
+"  A B C   ",
+"  D E F   ",
+"  G H I   ",
+"  J K L   ",
+"  M N O   ",
+"  P Q R   ",
+"  S T U   ",
+"  V W X   ",
+"  Y Z `   ",
+"   ...+.  ",
+"  @.#.$.  ",
+"  %.&.*.  ",
+"  =.-.;.  ",
+"  >.,.'.  ",
+"  ).!.~.  ",
+"  {.].^.  ",
+"  /.(._.  ",
+"  :.<.[.  ",
+"  }.|.1.  "};

data/ruby_libs/pav/pav_find.rb

@@ -0,0 +1,90 @@
+# From Ruby's Find module:
+module PavFind
+  def self.pfind_follow_symlinks(paths)
+    paths = paths.collect{|d| d.dup}
+    while file = paths.shift
+      catch(:prune) do
+        next unless File.exist? file
+	yield file.dup.taint
+	begin
+	  if File.directory?(file) then
+	    d = Dir.open(file)
+	    begin
+	      for f in d
+		next if f == "." or f == ".."
+		if File::ALT_SEPARATOR and
+		file =~ /^(?:[\/\\]|[A-Za-z]:[\/\\]?)$/ then
+		  f = file + f
+		elsif file == "/" then
+		  f = "/" + f
+		else
+		  f = File.join(file, f)
+		end
+		paths.unshift f.untaint
+	      end
+	    ensure
+	      d.close
+	    end
+	  end
+	rescue Errno::ENOENT, Errno::EACCES
+	end
+      end
+    end
+  end
+  
+  def self.pfind_no_follow_symlinks(paths)
+    paths = paths.collect{|d| d.dup}
+    while file = paths.shift
+      catch(:prune) do
+        next unless File.exist? file
+	yield file.dup.taint
+	begin
+	  if File.lstat(file).directory? then
+	    d = Dir.open(file)
+	    begin
+	      for f in d
+		next if f == "." or f == ".."
+		if File::ALT_SEPARATOR and
+		file =~ /^(?:[\/\\]|[A-Za-z]:[\/\\]?)$/ then
+		  f = file + f
+		elsif file == "/" then
+		  f = "/" + f
+		else
+		  f = File.join(file, f)
+		end
+		paths.unshift f.untaint
+	      end
+	    ensure
+	      d.close
+	    end
+	  end
+	rescue Errno::ENOENT, Errno::EACCES
+	end
+      end
+    end
+  end
+  
+  def self.pfind(paths, follow_symlinks=true, entry_visit_once=true, &block)
+  	if follow_symlinks
+	  if entry_visit_once
+		visited = {}
+		self.pfind_follow_symlinks(paths) { |path|
+			if visited.include?(path)
+				self.prune
+			else
+				yield(path)
+				visited[path] = true
+			end
+		}
+	  else
+		self.pfind_follow_symlinks(paths, &block)
+	  end
+	else
+		self.pfind_no_follow_symlinks(paths, &block)
+	end
+  end
+  
+  def self.prune
+	throw :prune
+  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