extract_curves 0.0.1

data/ruby_libs/pav/pix/CVS/Entries

@@ -0,0 +1,11 @@
+/aapix.rb/1.1.1.1/Tue Nov 15 17:32:14 2005//
+/blob.rb/1.1.1.1/Tue Nov 15 17:32:14 2005//
+/circle.rb/1.1.1.1/Tue Nov 15 17:32:14 2005//
+/contour.rb/1.1.1.1/Tue Nov 15 17:32:16 2005//
+/curve.rb/1.1.1.1/Tue Nov 15 17:32:15 2005//
+/img_obj.rb/1.1.1.1/Tue Nov 15 17:32:14 2005//
+/node.rb/1.1.1.1/Tue Nov 15 17:32:16 2005//
+/node_grp.rb/1.1.1.1/Tue Nov 15 17:32:13 2005//
+/shaved_core.rb/1.1.1.1/Tue Nov 15 17:32:13 2005//
+/subpix.rb/1.1.1.1/Tue Nov 15 17:32:16 2005//
+D/contour////

data/ruby_libs/pav/pix/CVS/Repository

@@ -0,0 +1 @@
+extract-curves/ruby_libs/pav/pix

data/ruby_libs/pav/pix/CVS/Root

@@ -0,0 +1 @@
+:ext:pavpen@rubyforge.org:/var/cvs/extract-curves

data/ruby_libs/pav/pix/aapix.rb

@@ -0,0 +1,378 @@
+require 'pav/pix'
+require 'pav/numeric/ext'
+
+module PPix
+
+class Xy
+	def a_eql?(pix, eps=2e-10)
+		(self.ay - pix.ay).abs < eps && (self.ax - pix.ax).abs < eps
+	end
+	
+	alias_method :ax, :x
+	alias_method :ay, :y
+	alias_method :eql?, :a_eql?
+	
+	def a_neighb8?(pix, eps=2e-10)
+		dx = (self.ax - pix.ax).abs; dy = (self.ay - pix.ay).abs
+		dx <= 1.0+eps && dy <= 1.0+eps
+	end
+	
+	def a_neighb4?(pix, eps=2e-10)
+		dx = (self.ax - pix.ax).abs; dy = (self.ay - pix.ay).abs
+		(dx <= 1.0+eps && dy < eps) || (dy <= 1.0+eps && dx < eps)
+	end
+	
+	def a_close_neighb?(pix, eps=2e-10)
+		dx = (self.ax - pix.ax).abs; dy = (self.ay - pix.ay).abs
+		(dx <= 0.5+eps && dy <= 0.5+eps)
+	end
+	
+	def semi_neighb8?(pix, eps=2e-10)
+		dx = (self.ax - pix.ax).abs; dy = (self.ay - pix.ay).abs
+		dx <= 1.5+eps && dy <= 1.5+eps
+	end
+	
+	def semi_neighb4?(pix, eps=2e-10)
+		dx = (self.ax - pix.ax).abs; dy = (self.ay - pix.ay).abs
+		(dx <= 1.5+eps && dy < eps) || (dy <= 1.5+eps && dx < eps)
+	end
+	
+	def semi_close_neighb?(pix, eps=2e-10)
+		dx = (self.ax - pix.ax).abs; dy = (self.ay - pix.ay).abs
+		(dx <= 0.5-eps && dy <= 0.5-eps)
+	end
+	
+	def a_yx(eps=1e-10)
+		[self.ay.scaled_round(eps), self.ax.scaled_round(eps)]
+	end
+	
+	def a_leg(pix)
+		leg = (self.ay <=> pix.ay)
+		return leg if leg != 0
+		self.ax <=> pix.ax
+	end
+end
+
+class AaXy < Xy
+	attr_reader :ax, :ay
+	
+	def self.a_yx(x, y, eps=1e-10)
+		[y.scaled_round(eps), x.scaled_round(eps)]
+	end
+	
+	def initialize(ax, ay)
+		@ax = ax; @ay = ay
+		super(@ax.round, @ay.round)
+	end
+	
+	def a_eql?(pix, eps=1e-10)
+		(@ay - pix.ay).abs < eps && (@ax - pix.ax).abs < eps
+	end
+	
+	def hash
+		self.a_yx.hash
+	end
+	
+	alias_method :eql?, :a_eql?
+	
+	def to_s
+		"(#{@ax}, #{@ay})"
+	end
+	
+	alias_method :coords_to_s, :to_s
+end
+
+class AaPix < AaXy
+	include MPixbufPix
+	
+	def initialize(pixbuf, ax, ay)
+		@pixbuf = pixbuf
+		super(ax, ay)
+	end
+	
+	def dup_aapix
+		AaPix.new(@pixbuf, self.ax, self.ay)
+	end
+end
+
+class AaXyCancelI < AaXy
+	attr_accessor :cancel, :semi_adj8_i, :semi_adj8_idxs
+	
+	def initialize(ax, ay, cancel, semi_adj8_i, semi_adj8_idxs)
+		@cancel = cancel
+		@semi_adj8_i = semi_adj8_i
+		@semi_adj8_idxs = semi_adj8_idxs
+		super(ax, ay)
+	end
+end
+
+class AaXy
+	ADJ8_SEMI_ADJ8_SPEC = [
+	 AaXyCancelI.new(   0,-0.5, [ 1,17,18], 3, [15,0, 1, 2, 3, 4, 5, 6, 7]),
+	 AaXyCancelI.new(   0,  -1,         [], 3, [1, 2, 3, 4, 5]),
+	 AaXyCancelI.new(-0.5,   0, [ 3,19,20], 7, [3, 4, 5, 6, 7, 8, 9,10,11]),
+	 AaXyCancelI.new(  -1,   0,         [], 7, [5, 6, 7, 8, 9]),
+	 AaXyCancelI.new(   0, 0.5, [ 5,21,22],11, [7, 8, 9,10,11,12,13,14,15]),
+	 AaXyCancelI.new(   0,   1,         [],11, [9,10,11,12,13]),
+	 AaXyCancelI.new( 0.5,   0, [ 7,23,16],15, [11,12,13,14,15,0, 1, 2, 3]),
+	 AaXyCancelI.new(   1,   0,         [],15, [13,14,15,0, 1]),
+	 AaXyCancelI.new( 0.5,-0.5, [ 9,16,17], 1, [15,0, 1, 2, 3]),
+	 AaXyCancelI.new(   1,  -1,         [], 1, [0, 1, 2]),
+	 AaXyCancelI.new(-0.5,-0.5, [11,18,19], 5, [3, 4, 5, 6, 7]),
+	 AaXyCancelI.new(  -1,  -1,         [], 5, [4, 5, 6]),
+	 AaXyCancelI.new(-0.5, 0.5, [13,20,21], 9, [7, 8, 9,10,11]),
+	 AaXyCancelI.new(  -1,   1,         [], 9, [8, 9,10]),
+	 AaXyCancelI.new( 0.5, 0.5, [15,22,23],13, [11,12,13,14,15]),
+	 AaXyCancelI.new(   1,   1,         [],13, [12,13,14]),
+	 AaXyCancelI.new(   1,-0.5,         [], 0, [15,0, 1, 2]),
+	 AaXyCancelI.new( 0.5,  -1,         [], 2, [0, 1, 2, 3]),
+	 AaXyCancelI.new(-0.5,  -1,         [], 4, [3, 4, 5, 6]),
+	 AaXyCancelI.new(  -1,-0.5,         [], 6, [4, 5, 6, 7]),
+	 AaXyCancelI.new(  -1, 0.5,         [], 8, [7, 8, 9,10]),
+	 AaXyCancelI.new(-0.5,   1,         [],10, [8, 9,10,11]),
+	 AaXyCancelI.new( 0.5,   1,         [],12, [11,12,13,14]),
+	 AaXyCancelI.new(   1, 0.5,         [],14, [12,13,14,15]),
+	]
+	
+	tmp1 = []; 16.times { tmp1 << [] }
+	ADJ8_SEMI_ADJ8_SPEC.each { |a| tmp1[a.semi_adj8_i] << a }
+	tmp2 = []
+	tmp1.each { |m| tmp2 << m.first }; tmp1.each { |m| tmp2 << m.last }
+	SEMI_ADJ8 = tmp2
+	
+	def self.semi_neighbs8_contig_arr_get_segs(arr)
+		#$PDbgLog.sig_call(self)
+		#$PDbgLog.print_msg "ngbs: #{(0...arr.length).find_all { |i|
+		#  arr[i]}.join(" ")}: "
+		end_i = -1
+		while !arr[end_i]
+			end_i -= 1
+			if end_i < -15
+				#$PDbgLog.sig_return('Empty.')
+				return []
+			end
+		end
+		end_i += 17
+		#$PDbgLog.print_msg "end_i=#{end_i} "
+		start_p = 0
+		start_p += 1 while !arr[start_p]
+		#$PDbgLog.print_msg "start_p=#{start_p} "
+		if start_p >= end_i
+			#$PDbgLog.sig_return("[[#{start_p}, #{start_p+1}]]")
+		  	return [[start_p, start_p+1]]
+		end
+		res = []
+		i = start_p + 1
+		loop do
+			i += 1 while arr[i]
+			res << [start_p, i]
+			break if i >= end_i
+			i += 1 while !arr[i]
+			start_p = i
+		end
+		if res.length > 1 && res[0][0] % 16 == res.last[1] % 16
+			len = res.last[1] - res.last[0]
+			res[0][0] -= len
+			res.pop
+		end
+		#$PDbgLog.sig_return(res.inspect)
+		res
+	end
+	
+	def self.semi_neighbs8_arr_get_segs(ngbs)
+		#$PDbgLog.sig_call(self)
+		#$PDbgLog.print_msg "ngbs: #{(0...ngbs.length).find_all { |i|
+		#	ngbs[i]}.join(" ")}: "
+		end_p = start_p = -1
+		if ngbs[start_p]
+			while ngbs[end_p += 1] || end_p % 4 < 3
+				if end_p + 1 >= 16
+					#$PDbgLog.sig_return('whole circle.')
+					return [[0, 0]]
+				end
+			end
+			while ngbs[start_p-=1] || start_p % 4 < 3
+			end
+			end_i = 16 + start_p
+			start_p += 1
+			start_p += 1 while !ngbs[start_p]
+			end_p -= 1 while !ngbs[end_p-1]
+			res = [[start_p, end_p]]
+		else
+			res = []
+			end_i = 15
+		end
+		loop do
+			start_p = end_p + 1
+			while !ngbs[start_p]
+				start_p += 1
+				if start_p >= end_i
+					#$PDbgLog.sig_return(res.inspect)
+					return res
+				end
+			end
+			end_p = start_p + 1
+			end_p += 1 while (ngbs[end_p] || end_p % 4 < 3) &&
+				end_p < end_i
+			end_p -= 1 while !ngbs[end_p-1]
+			res << [start_p, end_p]
+		end
+	end
+	
+	def self.semi_neighbs8_with_arr_get_segs(arr, ngbs)
+		$PDbgLog.sig_call(self)
+		$PDbgLog.print_msg "ngbs: #{(0...arr.length).find_all { |i|
+		  arr[i]}.collect{|i|ngbs[arr[i]].coords_to_s+"[#{i}]"}.join(" "
+		  )}: "	#"
+		end_i = -1
+		while !arr[end_i]
+			end_i -= 1
+			if end_i < -15
+				$PDbgLog.sig_return('Empty.')
+				return []
+			end
+		end
+		end_i += 16
+		$PDbgLog.print_msg "end_i=#{end_i} "
+		start_p = 0
+		start_p += 1 while !arr[start_p]
+		$PDbgLog.print_msg "start_p=#{start_p} "
+		if start_p >= end_i
+			$PDbgLog.sig_return("[[#{start_p}, #{start_p+1}]]")
+		  	return [[start_p, start_p+1]]
+		end
+		last_pix = ngbs[arr[start_p]]
+		res = []
+		end_p = i = start_p
+		loop do
+			i += 1
+			i += 1 while !arr[i]
+			$PDbgLog.print_msg "i=#{i} "
+			if last_pix.a_neighb8?(ngbs[arr[i]])
+				if (end_p = i) >= end_i
+				  if res.empty?
+				#    if arr.compact.length > 2 && ngbs[arr[
+				#    start_p]].a_neighb8?(ngbs[arr[i]])
+				#	$PDbgLog.print_msg("Full circle ")
+				#	res << [0, 0]
+				#    else
+					res << [start_p, end_p+1]
+				#    end
+				  elsif ngbs[arr[res[0][0]]].a_neighb8?(
+				  ngbs[arr[i]])
+					res[0][0] = start_p - 16
+				  else
+				  	res << [start_p, end_p+1]
+				  end
+				  $PDbgLog.sig_return(res.inspect)
+				  return res
+				end
+			else
+			  $PDbgLog.puts_msg "seg[#{start_p},#{end_p+1})"
+			  res << [start_p, end_p+1]
+			  if i >= end_i
+				if ngbs[arr[res[0][0]]].neighb8?(ngbs[arr[i]])
+					res[0][0] = i - 16
+				else
+					res << [i, i+1]
+				end
+				$PDbgLog.sig_return(res.inspect)
+				return res
+			  end
+			  start_p = i
+			  last_pix = ngbs[arr[start_p]]
+			end
+			last_pix = ngbs[arr[i]]
+		end
+	end
+end
+
+class Xy
+	def semi_neighbs8_arr(neighbs)
+		#$PDbgLog.sig_call(self)
+		#$PDbgLog.print_msg self.coords_to_s + ", neighbs: #{PixbufPix.
+		#	path_to_s(neighbs)}: "
+		warn("#{self.class.name}.semi_neighbs8_arr: " +
+		  "Non-neighbors given to #{self.coords_to_s}: #{PixbufPix.
+		  path_to_s(neighbs)}") if neighbs.detect { |a|
+			!a.a_neighb8?(self) }
+		res = Array.new(16)
+		ranks = Array.new(16, 100)
+		neighbs.each_with_index { |ngb, ngb_i|
+			ax = (ngb.ax - self.ax).scaled_round(0.5)
+			ay = (ngb.ay - self.ay).scaled_round(0.5)
+			AaXy::ADJ8_SEMI_ADJ8_SPEC.each_with_index{|spec,rk|
+				if ay == spec.ay && ax == spec.ax
+				  if ranks[spec.semi_adj8_i] > rk
+					res[spec.semi_adj8_i] = ngb_i
+					ranks[spec.semi_adj8_i] = rk
+				  end
+				  break
+				end
+			}
+		}
+		#$PDbgLog.sig_return(res.inspect)
+		res
+	end
+	
+	def semi_neighbs8_contig_arr(neighbs)
+		#$PDbgLog.sig_call(self)
+		#$PDbgLog.print_msg self.coords_to_s + ", neighbs: #{Xy.
+		#	path_to_s(neighbs)}: "
+		warn("#{self.class.name}.semi_neighbs8_contig_arr: " +
+		  "Non-neighbors given to #{self.coords_to_s}: #{PixbufPix.
+		  path_to_s(neighbs)}") if neighbs.detect { |a|
+			!a.semi_neighb8?(self) }
+		res = Array.new(16)
+		ranks = Array.new(16, 100)
+		neighbs.each_with_index { |ngb, ngb_i|
+			ax = (ngb.ax - self.ax).scaled_round(0.5)
+			ay = (ngb.ay - self.ay).scaled_round(0.5)
+			AaXy::ADJ8_SEMI_ADJ8_SPEC.each_with_index{|spec,rk|
+			  if ay == spec.ay && ax == spec.ax
+			    spec.semi_adj8_idxs.each { |semi_adj8_i|
+			      if ranks[semi_adj8_i] > rk
+				res[semi_adj8_i] = ngb_i
+				ranks[semi_adj8_i] = rk
+			      end
+			    }
+			    break
+			  end
+			}
+		}
+		#$PDbgLog.sig_return(res.inspect)
+		res
+	end
+end
+
+module MPixbufPix
+	def adj8_semi_adj8_each
+		#$PDbgLog.sig_call(self)
+		pixbuf = self.pixbuf; ax = self.ax; ay = self.ay
+		#$PDbgLog.print_msg self.to_s + ",ax=#{ax},ay=#{ay}: "
+		cancelled = []
+		AaXy::ADJ8_SEMI_ADJ8_SPEC.each_with_index { |a, ai|
+			next if cancelled[ai]
+			if yield(AaPix.new(pixbuf, ax+a.ax, ay+a.ay))
+				a.cancel.each { |cnc| cancelled[cnc] = true }
+			end
+		}
+		#$PDbgLog.sig_return('done.')
+	end
+	
+	def semi_adj8_incl_set_each(incl_set)
+		i = -1
+		self.adj8_semi_adj8_each { |ngb|
+			i += 1
+			if incl_set.include?(ngb)
+				yield(ngb, AaXy::ADJ8_SEMI_ADJ8_SPEC.at(i).
+					semi_adj8_i)
+				true
+			else
+				false
+			end
+		}
+	end
+end
+
+end

data/ruby_libs/pav/pix/blob.rb

@@ -0,0 +1,543 @@
+require 'set'
+require 'pav/pix'
+require 'pav/cache'
+require 'pav/search'
+require 'pav/attr_cache'
+require 'pav/pix/circle'
+require 'pav/pix/contour'
+require 'pav/pix/img_obj'
+require 'pav/string/bits'
+
+module PPix
+
+class Pixbuf
+	def blob_id_arr
+		if !@blob_id_arr
+			#@blob_id_arr = IntBitPlaneArr.new(
+			#	"", self.width * self.height)
+			@blob_id_arr = Array.new(self.picture_width *
+				self.picture_height, 0)
+		end
+		@blob_id_arr
+	end
+	
+	def blob_id_max
+		@blob_id_max = 0 if !@blob_id_max
+		@blob_id_max
+	end
+	
+	def blob_free_ids
+		@blob_free_ids = [] if !@blob_free_ids
+		@blob_free_ids
+	end
+	
+	def blob_id2ref_arr
+		@blob_id2ref_arr = [] if !@blob_id2ref_arr
+		@blob_id2ref_arr
+	end
+	
+	def set_blob_id(x, y, id)
+		@blob_id_max = id if id > self.blob_id_max
+		self.blob_id_arr[y * self.picture_width + x] = id
+	end
+	
+	def add_blob(blob)
+		#$PDbgLog.sig_call(self)
+		if self.blob_free_ids.empty?
+			#$PDbgLog.print_msg "Using blob_id_max: "
+			@blob_id_max = id = self.blob_id_max + 1
+			self.blob_id2ref_arr << blob
+		else
+			#$PDbgLog.print_msg "Using free id: "
+			#$PDbgLog.print_msg "#{self.blob_id2ref_arr.collect{|bl|
+			#	bl.blob_id}.inspect}: "
+			id = self.blob_free_ids.shift
+			self.blob_id2ref_arr[id-1,0] = [blob]
+			#$PDbgLog.print_msg "#{self.blob_id2ref_arr.collect{|bl|
+			#	bl.blob_id}.inspect}: "
+		end
+		#$PDbgLog.sig_return(id)
+		return id
+	end
+	
+	def unregister_blob_id(id)
+		return if id == 0
+		if id == self.blob_id_max
+			#@bpc = self.blob_id_arr.bit_planes_cnt
+			#if self.blob_id_max & (self.blob_id_max-1) == 0
+			#	bpc -= 1
+			#end
+			self.blob_id2ref_arr.pop
+			@blob_id_max = self.blob_id_max-1
+			while self.blob_free_ids.last == self.blob_id_max
+				#if self.blob_id_max & (self.blob_id_max-1) == 0
+				#	bpc -= 1
+				#end
+				@blob_id_max -= self.blob_id_max-1
+				self.blob_free_ids.pop
+				self.blob_id2ref_arr.pop
+			end
+			#self.blob_id_arr.bit_planes_cnt = bpc
+		else
+			if (pos = PSearch.bsearch(self.blob_free_ids, id)) >= 0
+				return # blob ID not currently registered
+			end
+			self.blob_free_ids[-pos-1,0] = id
+			self.blob_id2ref_arr[id+pos,1] = nil
+		end
+	end
+	
+	def blob_id_at(x, y)
+		self.blob_id_arr.at(y * self.picture_width + x)
+	end
+	
+	def blob_id_at?(x, y, id)
+		#self.blob_id_arr.at?(y * self.width + x, id)
+		self.blob_id_arr.at(y * self.picture_width + x) == id
+	end
+	
+	def blob_at(x, y)
+		return nil if (id=self.blob_id_arr[y*self.picture_width+x]) == 0
+		self.blob_id2ref_arr[id+PSearch.bsearch(self.blob_free_ids,id)]
+	end
+	
+	def blob_by_id(id)
+		return nil if id < 1
+		return nil if (j = PSearch.bsearch(self.blob_free_ids,id)) >= 0
+		self.blob_id2ref_arr[id + j]
+	end
+	
+	def delete_blob(spec)
+		if spec.kind_of?(Integer)
+			blob = self.get_blob_by_id(spec)
+		else
+			blob = spec
+		end
+		return unless blob
+		blob.each { |pix| self.set_blob_id(pix.x, pix.y, 0) }
+		self.unregister_blob_id(blob.blob_id)
+	end
+end
+
+class PixbufPix
+	def blob(contour_geometry=8, external_contours=true,
+	incorp_subblob_max_size=0, min_outer_lp_length=0, &get_neighbs)
+		b = self.pixbuf.blob_at(self.x, self.y)
+		return b if b
+		$PDbgLog.sig_call(self)
+		#$PDbgLog.print_msg "Creating blob for #{self.coords_to_s}: "
+		id = self.pixbuf.add_blob(b = Blob.new(self.pixbuf,
+			contour_geometry, external_contours,
+			min_outer_lp_length, &get_neighbs))
+		b.blob_id = id
+		b.rebuild(self, incorp_subblob_max_size)
+		#$PDbgLog.puts_msg "done."
+		$PDbgLog.sig_return
+		b
+	end
+end
+
+class BlobYxSet
+	attr_reader :blob, :blob_id, :pixbuf
+	
+	def initialize(blob)
+		@blob = blob
+		@blob_id = @blob.blob_id
+		@pixbuf = @blob.pixbuf
+	end
+	
+	def include?(yx)
+		@pixbuf.blob_id_at?(yx.at(1), yx.at(0), @blob_id)
+	end
+	
+	alias_method :member?, :include?
+	
+	def length
+		@blob.length
+	end
+end
+
+class Blob < ImageObject
+	def Blob.local_top_left(start_pix, diag_conn=true)
+		moved, clr = true, start_pix.color_id
+		pixbuf, x, y = start_pix.pixbuf, start_pix.x, start_pix.y
+		while moved
+			moved = false
+			while x > 0 && pixbuf[y][x-1].color_id == clr
+				x -= 1
+				moved = true
+			end
+			while y > 0 && pixbuf[y-1][x].color_id == clr
+				y -= 1
+				moved = true
+			end
+			while diag_conn && x > 0 && y > 0 &&
+			pixbuf[y-1][x-1].color_id == clr
+				x -= 1
+				y -= 1
+				moved = true
+			end
+		end
+		return pixbuf[y][x]
+	end
+	
+	def self.mk_rgb_get_neighbs_proc(cmp_pix_to, toler_r, toler_g, toler_b)
+		case cmp_pix_to.downcase
+                  when "blob 8 neighbors' colors"
+                    #get_neighbs_proc =
+		    proc { |pix|
+			pix.adj_fuzzy_rgb_cocolor(PPix::PixbufPix::ADJACENT8,
+				toler_r, toler_g, toler_b).
+			find_all { |p| p.pixbuf.blob_id_at?(p.x, p.y, 0) }
+                    }
+		  when "blob 4 neighbors' colors"
+                    #get_neighbs_proc =
+		    proc { |pix|
+			pix.adj_fuzzy_rgb_cocolor(PPix::PixbufPix::ADJACENT4,
+				toler_r, toler_g, toler_b).
+			find_all { |p| p.pixbuf.blob_id_at?(p.x, p.y, 0) }
+                    }
+                  when "blob mean color"
+                    tot_r = tot_g = tot_b = blen = 0
+                    #get_neighbs_proc =
+		    proc { |pix|
+			pix.adj8.find_all { |p| r,g,b = *p.color_rgb
+			  if p.pixbuf.blob_id_at?(p.x, p.y, 0) &&
+			  (tot_r - r*blen).abs <= toler_r*blen &&
+			  (tot_g - g*blen).abs <= toler_g*blen &&
+			  (tot_b - b*blen).abs <= toler_b*blen
+			        tot_r += r; tot_g += g; tot_b += b; blen += 1
+			        true
+			  else
+			        false
+			  end
+			}
+		    }
+		  else
+		    if cmp_pix_to.kind_of?(Array) && cmp_pix_to.length == 2 &&
+		    cmp_pix_to[0] == "mean blob color in a circle" &&
+		    (rad = cmp_pix_to[1]).kind_of?(Numeric)
+                      #get_neighbs_proc =
+		      proc { |pix|
+			pix.adj8.find_all { |p| mr = mg = mb = mlen = 0
+			  p.pixbuf.blob_id_at?(p.x, p.y, 0) &&
+			  (PPix::AFilledCircle(p.x, p.y, rad) { |x,y|
+			    pp = p.pixbuf.get_pix(x,y)
+			    unless pp.virtual?
+				r, g, b = *pp.color_rgb
+				mr += r; mg += g; mb += b; mlen += 1
+			    end
+			  }
+			  r,g,b = *p.color_rgb
+			  (mr - r*mlen).abs <= toler_r*mlen &&
+			  (mg - g*mlen).abs <= toler_g*mlen &&
+			  (mb - b*mlen).abs <= toler_b*mlen)
+			}
+                      }
+		    else
+			raise ArgumentError, "Invalid cmp_pix_to argument: #{
+				cmp_pix_to.inspect}!"
+		    end
+		end
+	end
+	
+	def self.mk_hsv_get_neighbs_proc(cmp_pix_to, toler_h, toler_s, toler_v)
+		case cmp_pix_to.downcase
+                  when "blob 8 neighbors' colors"
+		    #get_neighbs_proc =
+		    proc { |pix|
+			pix.adj_fuzzy_hsv_cocolor(PPix::PixbufPix::ADJACENT8,
+				toler_h, toler_s, toler_v).
+			find_all { |p| p.pixbuf.blob_id_at?(p.x, p.y, 0) }
+		    }
+                  when "blob 4 neighbors' colors"
+		    #get_neighbs_proc =
+		    proc { |pix|
+			pix.adj_fuzzy_hsv_cocolor(PPix::PixbufPix::ADJACENT4,
+				toler_h, toler_s, toler_v).
+			find_all { |p| p.pixbuf.blob_id_at?(p.x, p.y, 0) }
+		    }
+                  when "blob mean color"
+		    tot_h = tot_s = tot_v = blen = 0
+		    #get_neighbs_proc =
+		    proc { |pix|
+		      pix.adj8.find_all { |p| h,s,v = *p.color_hsv
+			if p.pixbuf.blob_id_at?(p.x, p.y, 0) &&
+			(tot_h - h*blen).abs <= toler_h*blen &&
+			(tot_s - s*blen).abs <= toler_s*blen &&
+			(tot_v - v*blen).abs <= toler_v*blen
+				tot_h += h; tot_s += s; tot_v += v; blen += 1
+				true
+			else
+				false
+			end
+		     }
+		   }
+                  else
+		    if cmp_pix_to.kind_of?(Array) && cmp_pix_to.length == 2 &&
+		    cmp_pix_to[0] == "mean blob color in a circle" &&
+		    (rad = cmp_pix_to[1]).kind_of?(Numeric)
+		      #get_neighbs_proc =
+		      proc { |pix|
+		        pix.adj8.find_all { |p| mh = ms = mv = mlen = 0
+			  p.pixbuf.blob_id_at?(p.x, p.y, 0) &&
+			  (PPix::AFilledCircle(p.x, p.y, rad) { |x,y|
+			    pp = p.pixbuf.get_pix(x,y)
+			    unless pp.virtual?
+			      h, s, v = *pp.color_hsv
+			      mh += h; ms += s; mv += v; mlen += 1
+			    end
+			  }
+			  h,s,v = *p.color_hsv
+			  (mh - h*mlen).abs <= toler_h*mlen &&
+			  (ms - s*mlen).abs <= toler_s*mlen &&
+			  (mv - v*mlen).abs <= toler_v*mlen)
+		        }
+		      }
+		    else
+			raise ArgumentError, "Invalid cmp_pix_to argument: #{
+				cmp_pix_to.inspect}!"
+		    end
+		end
+	end
+	
+	def self.mk_get_neighbs_proc(clr_scheme, cmp_pix_to, toler_1, toler_2,
+	toler_3)
+		case clr_scheme.downcase
+		  when 'rgb'
+			self.mk_rgb_get_neighbs_proc(cmp_pix_to, toler_1,
+				toler_2, toler_3)
+		  when 'hsv'
+			self.mk_hsv_get_neighbs_proc(cmp_pix_to, toler_1,
+				toler_2, toler_3)
+		  else
+			raise ArgumentError, "Invalid clr_scheme, must be " +
+			  "'rgb' or 'hsv': #{clr_scheme}!"
+		end
+	end
+	
+	attr_accessor :blob_id
+	attr_reader :pixbuf, :top_left_pix, :get_neighbs,
+		:external_contours, :min_outer_lp_length, :contour_geometry
+	
+	self.img_obj_add_sub_obj :contour_carpets
+	
+	def initialize(pixbuf, contour_geometry=8, external_contours=true,
+	min_outer_lp_length=0, &get_neighbs)
+		@blob_id = nil
+		@pixbuf = pixbuf
+		@contour_geometry = contour_geometry
+		@external_contours = external_contours
+		@min_outer_lp_length = min_outer_lp_length
+		@pix_neighbs_cache = PCache.new
+		if block_given?
+			@get_neighbs = get_neighbs
+		else
+			@get_neighbs = proc { |pix| pix.adj_cocolor8.find_all {
+				|px| px.pixbuf.blob_id_at?(px.x, px.y, 0) }}
+		end
+		@contour_carpets = nil
+		super()
+	end
+	
+	def add(bpix)
+		self << bpix
+		if @top_left_pix
+			@top_left_pix = bpix if bpix.y < @top_left_pix.y ||
+				(bpix.y == @top_left_pix.y &&
+				 bpix.x <  @top_left_pix.x)
+		else
+			@top_left_pix = bpix
+		end
+		@pixbuf.set_blob_id(bpix.x, bpix.y, @blob_id)
+	end
+	
+	def rebuild(start_pix, incorp_subblob_max_size)
+		$PDbgLog.sig_call(self)
+		@top_left_pix = start_pix
+		$PDbgLog.print_msg "id=#{@blob_id}, start pix#{@top_left_pix.
+			coords_to_s}: "
+		self.clear
+		self << @top_left_pix
+		@pixbuf.set_blob_id(@top_left_pix.x, @top_left_pix.y, @blob_id)
+		tail = []
+		self.pix_known_neighbs(@top_left_pix).each { |p|
+			next unless @pixbuf.blob_id_at(p.x, p.y) == 0
+			@pixbuf.set_blob_id(p.x, p.y, @blob_id)
+			@top_left_pix = p if p.y < @top_left_pix.y ||
+				(p.y == @top_left_pix.y &&
+				 p.x <  @top_left_pix.x)
+			tail.push(p)
+			self << p
+		}
+		if tail.empty?
+			$PDbgLog.sig_return
+			return
+		end
+		$PDbgLog.new_progr
+		$PDbgLog.progr.show_as = "/ pixels"
+		while !tail.empty?
+		  500.times { # Don't update the progress bar for every pixel
+		  	break if tail.empty?
+			pix = tail.shift
+			self.pix_known_neighbs(pix).each { |p|
+				next unless @pixbuf.blob_id_at(p.x, p.y) == 0
+				@pixbuf.set_blob_id(p.x, p.y, @blob_id)
+				@top_left_pix = p if p.y < @top_left_pix.y ||
+					(p.y == @top_left_pix.y &&
+					 p.x <  @top_left_pix.x)
+				tail.push(p)
+				self << p
+			}
+		  }
+		  $PDbgLog.progr.progr_units = self.length
+		end
+		if incorp_subblob_max_size > 0
+			#$PDbgLog.print_msg "Incorporating subblobs: "
+			# Skip the outer contour carpet which is first:
+			i = 0
+			carps = self.contour_carpets
+			while (i += 1) < carps.length
+				ctr = carps[i]
+				#$PDbgLog.print_msg "Carpet #{ctr.length} pix "
+				next if ctr.length > incorp_subblob_max_size ||
+					ctr.loop_carpet.internal_blob.length >
+						incorp_subblob_max_size
+				ctr.loop_carpet.internal_blob.each { |p|
+				  next unless @pixbuf.blob_id_at(p.x, p.y) == 0
+				  @pixbuf.set_blob_id(p.x, p.y, @blob_id)
+				  self << p
+				}
+				$PDbgLog.progr.progr_units = self.length
+				carps.delete_at(i)
+				i -= 1
+			end
+		end
+		$PDbgLog.sig_return(".")
+	end
+	
+	def pix_known_neighbs(pix)
+		self.get_neighbs.call(pix)
+	end
+	
+	def pix_neighbs(pix)
+		if (tmp = @pix_neighbs_cache[pix.yx])
+			return tmp
+		end
+		@pix_neighbs_cache[pix.yx] = pix.adj8.find_all { |ngb|
+			pix.pixbuf.blob_id_at?(ngb.x, ngb.y, self.blob_id) }
+	end
+	
+	def contour_carpets
+		return @contour_carpets if @contour_carpets
+		$PDbgLog.sig_call(self)
+		@contour_carpets = []
+		excl_set = {}
+		# Ensure the first contour carpet is the outer one.
+		if @external_contours
+		  if @contour_geometry == 8
+		    cneighbs_proc = proc { |cngb_pix|
+			nres = []
+			Xy::ADJACENT8.each { |cngb_adj|
+			    x = cngb_pix.x + cngb_adj.x
+			    y = cngb_pix.y + cngb_adj.y
+			    next unless (x < 0 || x >= @pixbuf.picture_width ||
+			    y < 0 || y >= @pixbuf.picture_height ||
+			    !@pixbuf.blob_id_at?(x, y, @blob_id)) &&
+			    Xy::ADJACENT4.detect { |cngb_ad|
+			      (x1=x+cngb_ad.x) >= 0 &&
+			      x1 < @pixbuf.picture_width &&
+			      (y1=y+cngb_ad.y) >= 0 &&
+			      y1 < @pixbuf.picture_height &&
+			      @pixbuf.blob_id_at?(x1, y1, @blob_id)
+			    }
+			    nres << @pixbuf.get_pix(x,y)
+			}
+			nres
+		    }
+		  else
+		    cneighbs_proc = proc { |px|
+			nres = []
+			Xy::ADJACENT4.each { |adj|
+			    x = px.x + adj.x; y = px.y + adj.y
+			    next unless (x < 0 || x >= @pixbuf.picture_width ||
+			    y < 0 || y >= @pixbuf.picture_height ||
+			    !@pixbuf.blob_id_at?(x, y, @blob_id)) &&
+			    PixbufPix::ADJACENT8.detect { |ad|
+			      (x1=x+ad.x) >= 0 && x1 < @pixbuf.picture_width &&
+			      (y1=y+ad.y) >= 0 && y1 < @pixbuf.picture_height &&
+			      @pixbuf.blob_id_at?(x1, y1, @blob_id)
+			    }
+			    nres << @pixbuf.get_pix(x,y)
+			}
+			nres
+		    }
+		  end
+		  @contour_carpets << ContourCarpet.new(
+		  	@pixbuf.get_pix(@top_left_pix.x,@top_left_pix.y-1),self,
+			@contour_geometry, @external_contours,
+			@min_outer_lp_length, &cneighbs_proc)
+		  @contour_carpets.last.each{|p| excl_set[p.yx] = true}
+		  self.each { |pix|
+			Xy::ADJACENT4.each { |adj|
+				x = pix.x + adj.x; y = pix.y + adj.y
+				if (x < 0 || x >= @pixbuf.picture_width ||
+				y < 0 || y >= @pixbuf.picture_height ||
+				!@pixbuf.blob_id_at?(x, y, @blob_id)) &&
+				!excl_set.include?([y, x])
+					@contour_carpets << ContourCarpet.new(
+					  @pixbuf.get_pix(x, y), self,
+					  @contour_geometry, @external_contours,
+					  &cneighbs_proc)
+					@contour_carpets.last.each { |p|
+						excl_set[p.yx] = true }
+				end
+		  	}
+		  }
+		else
+		  @contour_carpets << ContourCarpet.new(@top_left_pix, self,
+		  	@contour_geometry, @external_contours,
+			@min_outer_lp_length)
+		  @contour_carpets.last.each{|p| excl_set[p.yx] = true}
+		  self.each { |pix|
+			#$PDbgLog.print_msg "pix#{pix.coords_to_s}.border4?=#{
+			#	pix.border4?} "
+			if !excl_set.include?(pix.yx) && (
+			(adj4 = pix.adj4).length < 4 || adj4.detect { |a|
+			!a.pixbuf.blob_id_at?(a.x, a.y, self.blob_id) })
+				#$PDbgLog.puts_msg "ContourCarpet"
+				@contour_carpets << ContourCarpet.new(pix, self,
+				  @contour_geometry, @external_contours)
+				@contour_carpets.last.each { |p|
+					excl_set[p.yx] = true }
+			end
+		  }
+		end
+		$PDbgLog.sig_return
+		@contour_carpets
+	end
+	
+	def delete_contour_carpets
+		@contour_carpets = nil
+	end
+	
+	def to_s
+		"<Blob:%x: " % self.object_id + "pixbuf:#{@pixbuf}, @blob_id=#{
+		@blob_id}, @top_left_pix#{@top_left_pix.coords_to_s
+		}, @get_neighbs:#{@get_neighbs}>"
+	end
+	
+	alias_method :inspect, :to_s
+	
+	def img_obj_yx_set
+		BlobYxSet.new(self)
+	end
+	
+	def clear_cache
+		@pix_neighbs_cache.clear
+	end
+	
+	cache_attr! :img_obj_yx_set
+end
+
+end