extract_curves 0.0.1-i586-linux

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

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/CVS/Entries

@@ -0,0 +1,5 @@
+/calc_situations.rb/1.1.1.1/Tue Nov 15 17:32:16 2005//
+/carp_calc.rb/1.1.1.1/Tue Nov 15 17:32:40 2005//
+/situations.dmp/1.1.1.1/Tue Nov 15 17:32:40 2005//
+/situations.rb/1.1.1.1/Tue Nov 15 17:32:40 2005//
+D

data/ruby_libs/pav/pix/contour/CVS/Repository

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

data/ruby_libs/pav/pix/contour/CVS/Root

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

data/ruby_libs/pav/pix/contour/calc_situations.rb

@@ -0,0 +1,9 @@
+#!/usr/bin/ruby
+require 'pav/pix/contour/carp_calc'
+
+c_plms = {}
+situations = [	PPix::ContourCarpetCalc.get_id2lm(PPix::Subpix8, true, c_plms),
+		PPix::ContourCarpetCalc.get_id2lm(PPix::Subpix8, false,c_plms),
+		PPix::ContourCarpetCalc.get_id2lm(PPix::Subpix4, true, c_plms),
+		PPix::ContourCarpetCalc.get_id2lm(PPix::Subpix4, false,c_plms)]
+open('situations.dmp', 'w') { |file| Marshal.dump(situations, file) }