extract_curves 0.0.1

data/ruby_libs/pav/pix/circle.rb

@@ -0,0 +1,73 @@
+module PPix
+
+def self.AFilledCircle(x0, y0, r)
+	r2 = r*r
+	yield(x0, y0)
+	1.upto(r) { |dx|
+		yield(x0 + dx, y0)
+		yield(x0 - dx, y0)
+	}
+	1.upto(r) { |dy|
+		dy2 = dy*dy
+		yield(x0, y0+dy)
+		yield(x0, y0-dy)
+		dx = 1
+		while dx*dx + dy2 <= r2
+			yield(x0 + dx, y0+dy)
+			yield(x0 - dx, y0+dy)
+			yield(x0 + dx, y0-dy)
+			yield(x0 - dx, y0-dy)
+			dx += 1
+		end
+	}
+end
+
+=begin
+def AaFilledCircle(x0, y0, r)
+	r2 = r*r
+	if r2 > 0.5
+		yield(x0, y0, 1.0)
+	else
+	  if r <= 0.5
+		yield(x0, y0, Math::PI*r2)
+	  else
+		phi = Math.acos(1.0 / r)
+		yield(x0, y0, (Math::PI-4.0*phi)*r2 + 4.0*Math.sqrt(r2-1.0))
+	  end
+	  return
+	end
+	dy = r.round
+	if r2 < (dy - 0.5)*(dy - 0.5) + 0.25
+		phi = Math.acos((dy-0.5) / r)
+		yield(x0, y+dy, f=phi*r2 - (dy-0.5)*r*Math.sin(phi))
+		yield(x0, y-dy, f)
+		dy -= 1
+		phi_0 = Math.atan2(dy-0.5, 0.5)
+		yield(x0, y+dy, f=r*(r*Math::PI/2.0 -
+			(dy-0.5)*2.0*Math.cos(phi_0)) - f)
+		yield(x0, y-dy, f)
+		dy -= 1
+	elsif r2 < (dy+0.5)*(dy+0.5) + 0.25
+		phi_0 = Math.atan2(dy-0.5, 0.5)
+		yield(x0, y+dy, f=r*(r*Math::PI/2.0 -
+			(dy-0.5)*2.0*Math.cos(phi_0)))
+		yield(x0, y-dy, f)
+		dy -= 1
+	end
+	1.upto(r) { |dy|
+		dy2 = dy*dy
+		yield(x0, y0+dy)
+		yield(x0, y0-dy)
+		dx = 1
+		while dx*dx + dy2 < r2
+			yield(x0 + dx, y+dy)
+			yield(x0 - dx, y+dy)
+			yield(x0 + dx, y-dy)
+			yield(x0 - dx, y-dy)
+			dx += 1
+		end
+	}
+end
+=end
+
+end

data/ruby_libs/pav/pix/contour.rb

@@ -0,0 +1,644 @@
+require 'set'
+require 'pav/pix'
+require 'pav/cache'
+require 'pav/dbg_log'
+require 'pav/pix/blob'
+require 'pav/attr_cache'
+require 'pav/pix/subpix'
+require 'pav/pix/img_obj'
+require 'pav/pix/contour/situations'
+
+module PPix
+
+class ContourLoop < ImageObject
+	attr_accessor :external, :contour_carpet, :vparities, :blob
+	
+	self.img_obj_add_sub_obj :internal_blob
+	
+	def initialize(contour_carpet=nil, external=nil)
+		@contour_carpet = contour_carpet
+		if external.nil?
+			@external = @contour_carpet.external if @contour_carpet
+		else
+			@external = external
+		end
+		@vparities = {}
+		super()
+	end
+	
+	def merge_debris!(debris)
+		#$PDbgLog.sig_call(self)
+		debris.each { |pix|
+			ngbs = @contour_carpet.pix_neighbs(pix)
+			ngbs.each { |ngb|
+			  if self.img_obj_yx_set.include?(ngb.yx)
+			    j = self.index(ngb)
+			    if ngbs.include?(self[i=j-1]) ||
+			    ngbs.include?(self[((i=j)+1) % self.length])
+				#$PDbgLog.print_msg pix.coords_to_s+" @ #{i+1} "
+				#$PDbgLog.puts_msg PixbufPix.path_to_s(self)
+				self[i+1,0] = [pix]
+				self.img_obj_yx_set << pix.yx
+				#$PDbgLog.puts_msg PixbufPix.path_to_s(self)
+				break
+			    end
+			  end
+			}
+		}
+		#$PDbgLog.sig_return
+	end
+	
+	def add(subpix)
+		if subpix.vertical?
+			if @vparities.include?(subpix.img_pix.yx)
+				@vparities.delete(subpix.img_pix.yx)
+			else
+				@vparities[subpix.img_pix.yx] = true
+			end
+		end
+		self << subpix.img_pix unless self[-1].yx==subpix.img_pix.yx
+	end
+	
+	def add_pix(pix, horiz_cnt, vert_cnt)
+		if vert_cnt & 1 == 1
+			if @vparities.include?(pix.yx)
+				@vparities.delete(pix.yx)
+			else
+				@vparities[pix.yx] = true
+			end
+		end
+		self << pix
+	end
+	
+	def internal_blob_each
+		return if self.empty?
+		#$PDbgLog.sig_call(self)
+		pix_scan = self.sort; pix_scan.uniq!
+		pixbuf = self.first.pixbuf
+		yield(pix_scan[0])
+		x0 = x = pix_scan[0].x
+		prev_y = y = pix_scan[0].y
+		parity = @vparities.include?(pix_scan[0].yx)
+		#$PDbgLog.puts_msg "pix_scan: #{PixbufPix.path_to_s(pix_scan)}"
+		#$PDbgLog.puts_msg "@vparities: " + PixbufPix.yx_path_to_s(
+		#	@vparities.keys.to_a.sort)
+		if (i = 1) >= pix_scan.length
+			#$PDbgLog.sig_return
+			return
+		end
+		loop do
+			#$PDbgLog.print_msg "i=#{i}, x0=#{x0}, x=#{x}, y=#{y}: "
+			while pix_scan[i].y == y && pix_scan[i].x == x+1
+				#$PDbgLog.print_msg "."
+				x = pix_scan[i].x
+				parity ^= @vparities.include?(pix_scan[i].yx)
+				yield(pix_scan[i])
+				if (i += 1) >= pix_scan.length
+					#$PDbgLog.sig_return
+					return
+				end
+			end
+			#$PDbgLog.print_msg "; "
+			if pix_scan[i].y==y && parity
+				#$PDbgLog.print_msg "#{x}.upto(#{pix_scan[i].x
+				#	}); "
+				(x+1).upto(pix_scan[i].x-1) { |tmp_x|
+					yield(pixbuf.get_pix(tmp_x, y)) }
+			end
+			x0 = x = pix_scan[i].x
+			y = pix_scan[i].y
+			parity ^= @vparities.include?(pix_scan[i].yx)
+			yield(pix_scan[i])
+			if (i += 1) >= pix_scan.length
+				#$PDbgLog.sig_return
+				return
+			end
+		end
+		#$PDbgLog.sig_return("Insanity!")
+	end
+	
+	def internal_blob
+		$PDbgLog.sig_call(self)
+		res = ImageObject.new
+		self.internal_blob_each { |pix| res << pix }
+		$PDbgLog.sig_return
+		res.img_obj_freeze
+		res
+	end
+	
+	def dup
+		res = self.class.new(contour_carpet, external)
+		res.replace(self)
+		res
+	end
+	
+	cache_attr! :internal_blob
+end
+
+class ContourLoopCarpet < ContourLoop
+	self.img_obj_add_sub_obj()
+	
+	def merge_new_loop!(lp)
+		if self.empty?
+			lp.each { |pix| self.img_obj_yx_set.add(pix.yx) }
+			self.replace(lp)
+			self.vparities.replace(lp.vparities)
+			return true
+		end
+		common_pix = common_pix_i = nil
+		lp.each_with_index { |pix, common_pix_i|
+			if self.img_obj_yx_set.include?(pix.yx)
+				common_pix = pix
+				break
+			end
+		}
+		if common_pix
+			lp.each { |pix| self.img_obj_yx_set.add(pix.yx) }
+			self[self.index(common_pix)+1,0] = lp[common_pix_i+
+				1...lp.length] + lp[0..common_pix_i]
+			lp.vparities.each_key { |k|
+				if self.vparities.include?(k)
+					self.vparities.delete(k)
+				else	self.vparities[k] = true; end }
+			return true
+		end
+		ngb = pix_i = nil
+		lp.each_with_index { |pix, pix_i|
+			self.contour_carpet.pix_neighbs(pix).each { |pngb|
+				if self.img_obj_yx_set.include?(pngb.yx)
+					ngb = pngb
+					break
+				end
+			}
+			break if ngb
+		}
+		return false unless ngb
+		lp.each { |pix| self.img_obj_yx_set.add(pix.yx) }
+		self[self.index(ngb)+1,0] = lp[pix_i...lp.length] +
+			lp[0..pix_i] + [ngb]
+		lp.vparities.each_key { |k|
+			if self.vparities.include?(k)
+				self.vparities.delete(k)
+			else	self.vparities[k] = true; end }
+	end
+end
+
+class PixbufPix
+	attr_accessor :border_dirs8_id, :subpix_path_dir
+end
+
+class ContourCarpetCalc
+	attr_reader :contour_carpet, :geometry, :external, :block, :cpix,
+		:start_pix
+	
+	def initialize(contour_carpet, geometry=8, external=nil, &block)
+		@contour_carpet = contour_carpet
+		@geometry = geometry
+		if external.nil?
+			@external = contour_carpet.external
+		else	@external = external; end
+		if block_given?
+			@block = block
+		else
+			@block = nil
+		end
+		@start_pix = @contour_carpet.start_pix
+		@visited = {}
+		@pix_calcs = {}
+	end
+	
+	def each_cpix(&block)
+		block = @block unless block_given?
+		block.call(@contour_carpet.start_pix)
+		@visited = { @contour_carpet.start_pix.yx => true }
+		@cpix = @contour_carpet.start_pix
+		tail = [@cpix]
+		while !tail.empty?
+			@contour_carpet.pix_neighbs(tail.pop).each { |cpix|
+				next if @visited.include?(cpix.yx)
+				block.call(cpix)
+				@visited[cpix.yx] = true
+				tail.push(cpix)
+			}
+		end
+	end
+	
+	def loop_indexes(pix)
+		res = []
+		@loop.each_with_index { |p, i|
+			res << i if p.y == pix.y && p.x == pix.x }
+		res
+	end
+	
+	def get_calc
+		@pix_calcs[@cpix.yx] = ImageObjectPixCalc.new(@cpix) unless
+			@pix_calcs.include?(@cpix.yx)
+		@pix_calcs[@cpix.yx]
+	end
+	
+	def next_loop(start_subpix, id2lm, external)
+		#$PDbgLog.sig_call(self)
+		i_res = []
+		pix = start_subpix.img_pix
+		lm = id2lm.at(ContourCarpetCalc.subpix_situ8_pack(
+		  @contour_carpet.pix_situ8_arr_into(pix, i_res))).at(
+		  start_subpix.sub_n)
+		pix.border_dirs8_id = lm.border_dirs8_id
+		lp = ContourLoop.new(@contour_carpet, external)
+		lp.add_pix(pix, lm.path_horiz_cnt, lm.path_vert_cnt)
+		#$PDbgLog.puts_msg "start_subpix#{start_subpix}, external=#{
+		#	external}, lm=#{lm.inspect}"
+		if external
+			next_lm = lm.entry
+			pix.subpix_path_dir = -1
+		else
+			next_lm = lm.exit
+			pix.subpix_path_dir = +1
+		end
+		if @visited.include?([pix.y, pix.x, lm.border_dirs8_id]) ||
+		!next_lm
+			#$PDbgLog.sig_return('debris.')
+			return lp
+		end
+		@visited[[pix.y,pix.x,lm.border_dirs8_id]] = true
+		pixbuf = pix.pixbuf
+		pix = pixbuf.get_pix(pix.x + next_lm.x, pix.y + next_lm.y)
+		lm = id2lm.at(ContourCarpetCalc.subpix_situ8_pack(
+		  @contour_carpet.pix_situ8_arr_into(pix, i_res))).
+		  at(next_lm.sub_n)
+		pix.border_dirs8_id = lm.border_dirs8_id
+		#$PDbgLog.new_progr
+		#$PDbgLog.progr.show_as = "/ visited"
+		while !@visited.include?([pix.y, pix.x, lm.border_dirs8_id])
+			#$PDbgLog.puts_msg "#{pix.coords_to_s}" +
+			#   ",lm=#{lm} "
+			#  ",dirs_id=#{"%b" % lm.border_dirs8_id}"
+			lp.add_pix(pix, lm.path_horiz_cnt, lm.path_vert_cnt)
+			@visited[[pix.y,pix.x,lm.border_dirs8_id]] = true
+			p_entry = pixbuf.get_pix(pix.x + lm.entry.x,
+				pix.y + lm.entry.y)
+			lm_entry = id2lm.at(ContourCarpetCalc.subpix_situ8_pack(
+			  @contour_carpet.pix_situ8_arr_into(p_entry, i_res))).
+			  at(lm.entry.sub_n)
+			p_exit = pixbuf.get_pix(pix.x + lm.exit.x,
+				pix.y + lm.exit.y)
+			lm_exit = id2lm.at(ContourCarpetCalc.subpix_situ8_pack(
+			  @contour_carpet.pix_situ8_arr_into(p_exit, i_res))).
+			  at(lm.exit.sub_n)
+			if @visited.include?([p_entry.y, p_entry.x,
+			lm_entry.border_dirs8_id])
+				pix.subpix_path_dir = +1
+				#$PDbgLog.print_msg ",next sub_n=#{lm.exit.sub_n
+				#	}"
+				pix = p_exit; lm = lm_exit
+			else
+			#	$PDbgLog.print_msg ",next sub_n=#{lm.entry.sub_n
+			#		}"
+				pix.subpix_path_dir = -1
+				pix = p_entry; lm = lm_entry
+			end
+			#$PDbgLog.print_msg ",subpix_path_dir=" +
+			#	lp.last.subpix_path_dir.inspect + " "
+			pix.border_dirs8_id = lm.border_dirs8_id
+			#$PDbgLog.progr.progr_units = @visited.length
+		end
+		#$PDbgLog.sig_return(".")
+		lp
+	end
+	
+	def get_loops
+		return [ContourLoop.new(@contour_carpet).
+			replace(@contour_carpet)] if @contour_carpet.length < 3
+		#$PDbgLog.sig_call(self)
+		loops = []
+		@visited.clear
+		unvis_neighbs = []
+		vis_pix = {}
+		debris = Set.new
+		start_cpix = @contour_carpet.first
+		if @external
+		  if @geometry == 8
+		    get_start_subpix_proc = proc{|cpix| cpix.subpix8(16)}
+		    id2lm = ContourCarpetCalc::CONTOUR_PATH_EXTERNAL_SITU8_ID2LM
+		  else
+		    get_start_subpix_proc = proc{|cpix| cpix.subpix4(8)}
+		    id2lm = ContourCarpetCalc::CONTOUR_PATH_EXTERNAL_SITU4_ID2LM
+		  end
+		else
+		  if @geometry == 8
+		    get_start_subpix_proc = proc{|cpix| cpix.subpix8(16)}
+		    id2lm = ContourCarpetCalc::CONTOUR_PATH_INTERNAL_SITU8_ID2LM
+		  else
+		    get_start_subpix_proc = proc{|cpix| cpix.subpix4(8)}
+		    id2lm = ContourCarpetCalc::CONTOUR_PATH_INTERNAL_SITU4_ID2LM
+		  end
+		end
+		#$PDbgLog.print_msg "@external=#{@external.inspect} "
+		while start_cpix
+			#$PDbgLog.print_msg "start_cpix: #{start_cpix}: "
+			lp = self.next_loop(get_start_subpix_proc.call(
+				start_cpix), id2lm, @external)
+			#$PDbgLog.print_msg PixbufPix.path_to_s(lp) + " "
+			#$PDbgLog.puts_msg lp.inspect
+			#$PDbgLog.puts_msg "#{lp.length} pix "
+			if lp.length > 1
+				loops << lp
+			else
+				debris << start_cpix
+			end
+			lp.each { |pix| vis_pix[pix.yx] = true }
+			lp.each{|pix|@contour_carpet.pix_neighbs(pix).each{|ngb|
+			  unvis_neighbs << ngb unless vis_pix.include?(ngb.yx)||
+			  	debris.include?(ngb) }}
+			start_cpix = unvis_neighbs.pop
+			while start_cpix && (vis_pix.include?(start_cpix.yx) ||
+			debris.include?(start_cpix))
+				start_cpix = unvis_neighbs.pop
+			end
+		end
+		loops.each { |lp| lp.merge_debris!(debris) }
+		#$PDbgLog.sig_return(".")
+		loops
+	end
+end
+
+class ContourCarpet < ImageObject
+	attr_reader :start_pix, :pix_neighbs_proc, :geometry, :external, :blob,
+		:min_loop_length, :subpix_class, :pix_neighbs_cache
+	 
+	self.img_obj_add_sub_obj :loops, :loop_carpet
+	
+	def initialize(pix, blob, geometry=8, external=true, min_loop_length=0)
+		raise ArgumentError, "geometry must be 8 or 4" unless
+			[8, 4].include?(@geometry = geometry)
+		@external = external
+		@blob = blob
+		@min_loop_length = min_loop_length
+		@subpix_class = [Subpix4,Subpix8].at(@geometry/4 - 1)
+		@loops = nil
+		@loop_carpet = nil
+		if block_given?
+			@pix_neighbs_proc = Proc.new
+		else
+		  if geometry == 8
+			@pix_neighbs_proc = proc{|ppix| ppix.adj8.find_all{|pix|
+			  @blob.pixbuf.blob_id_at?(pix.x,pix.y,@blob.blob_id)&&
+			  ((adj4 = pix.adj4).length < 4 ||
+			    adj4.detect { |p|
+			      !@blob.pixbuf.blob_id_at?(p.x,p.y,@blob.blob_id)})
+			}}
+		  else
+			@pix_neighbs_proc = proc{|ppix| ppix.adj4.find_all{|pix|
+			  @blob.pixbuf.blob_id_at?(pix.x,pix.y,@blob.blob_id)&&
+			  ((adj8 = pix.adj8).length < 8 ||
+			    adj8.detect { |p|
+			      !@blob.pixbuf.blob_id_at?(p.x,p.y,@blob.blob_id)})
+			}}
+		  end
+		end
+		super()
+		@start_pix = pix
+		@pix_rev_conn_idxs = {}
+		@pix_neighbs_cache = PCache.new
+		self.rebuild
+	end
+	
+	def rebuild
+		$PDbgLog.sig_call(self)
+		self.clear
+		@loops = @loop_carpet = nil
+		$PDbgLog.print_msg "Getting #{@external ? "external": "internal"
+			} contour carpet from #{@start_pix.coords_to_s}: "
+		ContourCarpetCalc.new(self, @geometry, @external).each_cpix {
+			|cpix| self << cpix }
+		@pix_neighbs_cache.clear
+		$PDbgLog.sig_return("#{self.length} pixel#{self.length==1 ? "" :
+			"s"}.\n")
+	end
+	
+	def loops
+		return @loops if @loops
+		@loops = ContourCarpetCalc.new(self, @geometry, @external).
+			get_loops.delete_if{ |lp| lp.length < @min_loop_length }
+		@loops.each { |lp| lp.blob = @blob }
+		@pix_neighbs_cache.clear
+		@loops
+	end
+	
+	def loop_carpet
+		return @loop_carpet if @loop_carpet
+		$PDbgLog.sig_call(self)
+		$PDbgLog.print_msg "Getting #{@external ? "external": "internal"
+			} loop carpet: "
+		@loop_carpet = ContourLoopCarpet.new(self)
+		self.loops.each { |lp| @loop_carpet.merge_new_loop!(lp) }
+		@loop_carpet.blob = @blob
+		#$PDbgLog.print_msg PixbufPix.path_to_s(@loop_carpet) + ": "
+		@loop_carpet.img_obj_freeze
+		$PDbgLog.sig_return("#{@loop_carpet.length} pixel#{@loop_carpet.
+			length == 1 ? "" : "s"}.\n")
+		@loop_carpet
+	end
+	
+	def to_s
+		"<PPix::ContourCarpet start_pix#{@start_pix.coords_to_s
+			}, geometry=#{@geometry} in pixbuf: #{@start_pix.pixbuf
+			}>"
+	end
+	
+	alias_method :inspect, :to_s
+end
+
+class ContourCarpet
+	def pix_neighbs(pix)
+		if (tmp = @pix_neighbs_cache[pix.yx])
+			return tmp
+		end
+		@pix_neighbs_cache[pix.yx] = self.pix_neighbs_proc.call(pix)
+	end
+	
+	def pix_connections(pix)
+		pix.connections { |cpix| self.pix_neighbs(cpix) }
+	end
+	
+	def pix_rev_conn_idx(pix, conn_i)
+		#$PDbgLog.sig_call(self)
+		#$PDbgLog.puts_msg "(#{conn_i}) from (#{self.x}, #{self.y})."
+		if (rci = @pix_rev_conn_idxs[pix.yx])
+			return rci[conn_i] if rci[conn_i]
+		else
+			rci = @pix_rev_conn_idxs[pix.yx] = []
+		end
+		conns = self.pix_connections(pix)
+		#$PDbgLog.sig_return
+		rci[conn_i] = pix.rev_conn_idx(conns, conn_i,
+			self.pix_connections(conns[conn_i].last))
+	end
+	
+	def pix_node?(pix)
+		self.pix_neighbs(pix).length > 2
+	end
+	
+	def pix_transit_point?(pix)
+		self.pix_neighbs(pix).length == 2
+	end
+	
+	def pix_end_point?(pix)
+		self.pix_neighbs(pix).length < 2
+	end
+	
+	def pix_has_node_neighb?(pix)
+		self.pix_neighbs(pix).each { |neighb|
+			return true if self.pix_node?(neighb) }
+		false
+	end
+	
+	def pix_has_nonnode_neighb?(pix)
+		self.pix_neighbs(pix).each { |neighb|
+			return true if !self.pix_node?(neighb) }
+		false
+	end
+	
+	def pix_in_node_grp?(pix)
+		self.pix_node?(pix) && !self.pix_has_nonnode_neighb?(pix)
+	end
+end
+
+class ContourCarpet
+	def subpix_internal_neighbs(subpix)
+		#$PDbgLog.sig_call(self)
+		incl_yx=self.pix_neighbs(subpix.img_pix).collect{|cpix| cpix.yx}
+		incl_yx << subpix.img_pix.yx
+		yx_set = self.img_obj_yx_set
+		pixbuf = self.blob.pixbuf
+		blob_id = self.blob.blob_id
+		#$PDbgLog.puts_msg "yx_set: " + PixbufPix.yx_path_to_s(
+		#	yx_set.to_a.sort)
+		#res =
+		subpix.neighbs.find_all { |ngb|
+			#$PDbgLog.print_msg ngb.to_s + " "
+			incl_yx.include?(ngb.img_pix.yx) &&
+			ngb.border.detect { |nn|
+				!yx_set.include?(nn.img_pix.yx) && (
+				nn.img_pix.virtual? ||
+				!pixbuf.blob_id_at?(nn.img_pix.x, nn.img_pix.y,
+					blob_id) )
+			}
+		}
+		#$PDbgLog.print_msg ". "
+		#$PDbgLog.sig_return(subpix.to_s + ": " + Subpix.path_to_s(res))
+		#res
+	end
+	
+	def subpix_external_neighbs(subpix)
+		#$PDbgLog.sig_call(self)
+		incl_yx =self.pix_neighbs(subpix.img_pix).collect{|cpix|cpix.yx}
+		incl_yx << subpix.img_pix.yx
+		yx_set = self.img_obj_yx_set
+		pixbuf = self.blob.pixbuf
+		blob_id = self.blob.blob_id
+		#$PDbgLog.puts_msg "yx_set: " + PixbufPix.yx_path_to_s(
+		#	yx_set.to_a.sort)
+		#res =
+		subpix.neighbs.find_all { |ngb|
+			#$PDbgLog.print_msg ngb.to_s + " "
+			incl_yx.include?(ngb.img_pix.yx) &&
+			ngb.border.detect { |nn|
+				!yx_set.include?(nn.img_pix.yx) && (
+				!nn.img_pix.virtual? &&
+				pixbuf.blob_id_at?(nn.img_pix.x, nn.img_pix.y,
+					blob_id) )
+			}
+		}
+		#$PDbgLog.print_msg ". "
+		#$PDbgLog.sig_return(subpix.to_s + ": " + Subpix.path_to_s(res))
+		#res
+	end
+	
+	def subpix_internal_neighbs_into(subpix, res=[], incl_yx=[], neighbs=[],
+	bordr=[])
+		#$PDbgLog.sig_call(self)
+		incl_yx.clear
+		self.pix_neighbs(subpix.img_pix).each{|cpix| incl_yx << cpix.yx}
+		incl_yx << subpix.img_pix.yx
+		yx_set = self.img_obj_yx_set
+		pixbuf = self.blob.pixbuf
+		blob_id = self.blob.blob_id
+		#$PDbgLog.puts_msg "yx_set: " + PixbufPix.yx_path_to_s(
+		#	yx_set.to_a.sort)
+		res.clear
+		subpix.neighbs_into(neighbs).each { |ngb|
+			#$PDbgLog.print_msg ngb.to_s + " "
+			if incl_yx.include?(ngb.img_pix.yx) &&
+			ngb.border_into(bordr).detect { |nn|
+				!yx_set.include?(nn.img_pix.yx) && (
+				nn.img_pix.virtual? ||
+				!pixbuf.blob_id_at?(nn.img_pix.x, nn.img_pix.y,
+					blob_id) )
+			}
+				res << ngb
+			end
+		}
+		#$PDbgLog.print_msg ". "
+		#$PDbgLog.sig_return(subpix.to_s + ": " + Subpix.path_to_s(res))
+		res
+	end
+	
+	def subpix_external_neighbs_into(subpix, res=[], incl_yx=[], neighbs=[],
+	bordr=[])
+		#$PDbgLog.sig_call(self)
+		incl_yx.clear
+		self.pix_neighbs(subpix.img_pix).each{|cpix|incl_yx << cpix.yx}
+		incl_yx << subpix.img_pix.yx
+		yx_set = self.img_obj_yx_set
+		pixbuf = self.blob.pixbuf
+		blob_id = self.blob.blob_id
+		#$PDbgLog.puts_msg "yx_set: " + PixbufPix.yx_path_to_s(
+		#	yx_set.to_a.sort)
+		res.clear
+		subpix.neighbs_into(neighbs).each { |ngb|
+			#$PDbgLog.print_msg ngb.to_s + " "
+			if incl_yx.include?(ngb.img_pix.yx) &&
+			ngb.border_into(bordr).detect { |nn|
+				!yx_set.include?(nn.img_pix.yx) && (
+				!nn.img_pix.virtual? &&
+				pixbuf.blob_id_at?(nn.img_pix.x, nn.img_pix.y,
+					blob_id) )
+			}
+				res << ngb
+			end
+		}
+		#$PDbgLog.print_msg ". "
+		#$PDbgLog.sig_return(subpix.to_s + ": " + Subpix.path_to_s(res))
+		res
+	end
+	
+	def subpix_neighbs(subpix, external=true)
+		external ? self.subpix_external_neighbs(subpix) :
+			self.subpix_internal_neighbs(subpix)
+	end
+end
+
+class ContourCarpet
+	def pix_situ8_arr_into(pix, res=[])
+		res.clear
+		self.pix_neighbs(pix).each { |px| res[PixbufPix::ADJ8_ID2SPEC.
+		  at(PixbufPix.adj8_xy_id(px.x-pix.x, px.y-pix.y)).at(1)] = 1 }
+		pixbuf = pix.pixbuf
+		blob_id = self.blob.blob_id
+		width = pixbuf.picture_width; height = pixbuf.picture_height
+		PixbufPix::ADJ8_CCW_ORDER.each_with_index { |a,a_i|
+			next if res.at(a_i)
+			x = pix.x + a.x; y = pix.y + a.y
+			if y >= 0 && y < height && x >= 0 && x < width &&
+			pixbuf.blob_id_at?(x, y, blob_id)
+				res[a_i] = 2
+			else
+				res[a_i] = 0
+			end
+		}
+		res
+	end
+end
+
+end