extract-curves 0.1.1

data/ruby_libs/pav/pix/node.rb

@@ -0,0 +1,159 @@
+require 'pav/pix'
+require 'pav/heap'
+require 'pav/pix/aapix'
+require 'pav/graph/node'
+require 'pav/graph/node_grp'
+
+module PPix
+
+include PGraph
+
+class PGraph::NodeLink
+	def expand_to_xy_path
+		self.node.conns[self.conn_k].path.expand_to_xy_path
+	end
+end
+
+class PGraph::NodePath
+	def expand_to_xy_path
+		return [] if self.empty?
+		res = self.first.expand_to_xy_path
+		1.upto(self.length-1) { |i|
+			res.concat(self.at(i).expand_to_xy_path) }
+		res
+	end
+end
+
+class XyPath < Array
+	def self.yx_path_to_s(path)
+		path.collect { |yx| "(#{yx[1]}, #{yx[0]})" }.join(" ")
+	end
+	
+	def get_length
+		self.length - 1
+	end
+	
+	alias_method :entry, :first
+	alias_method :exit, :last
+	
+	def to_s
+		self.collect { |pix| pix.to_s }.join(" ")
+	end
+	
+	def eql?(path2)
+		#$PDbgLog.sig_call(self.name + "#")
+		#$PDbgLog.puts_msg "path1: #{path1}; path2: #{path2}"
+		if self.length != path2.length
+		#	$PDbgLog.sig_return
+			return false
+		end
+		self.each_with_index { |pix, i|
+			return false if pix.y != path2[i].y ||
+				pix.x != path2[i].x
+		}
+		#$PDbgLog.sig_return
+		true
+	end
+	
+	def starts_with(pfx_path)
+		return false unless self.length >= pfx_path.length
+		pfx_path.each_with_index { |pix, i|
+			return false if pix.yx != self.at(i).yx }
+		true
+	end
+	
+	def ends_with(sfx_path)
+		return false unless (ofs = self.length - sfx_path.length) >= 0
+		0.upto(sfx_path.length-1) { |i|
+			return false if sfx_path.at(i).yx != self.at(ofs+i).yx }
+		true
+	end
+	
+	def a_eql?(path2)
+		#$PDbgLog.sig_call(self.name + "#")
+		#$PDbgLog.puts_msg "self: #{self}; path2: #{path2}"
+		if self.length != path2.length
+		#	$PDbgLog.sig_return
+			return false
+		end
+		self.each_with_index { |pix, i|
+			return false if !pix.a_eql?(path2.at(i)) }
+		#$PDbgLog.sig_return
+		true
+	end
+	
+	def node_eql?(path2)
+		#$PDbgLog.sig_call(self.name + "#")
+		#$PDbgLog.puts_msg "self: #{self}; path2: #{path2}"
+		if self.length != path2.length
+		#	$PDbgLog.sig_return
+			return false
+		end
+		self.each_with_index { |node, i|
+			return false if !node.a_eql?(path2.at(i)) }
+		#$PDbgLog.sig_return
+		true
+	end
+	
+	alias_method :==, :node_eql?
+	
+	def a_starts_with(pfx_path)
+		return false unless self.length >= spath.length
+		self.each_with_index { |pix, i|
+			return false if !pix.a_eql?(pfx_path.at(i)) }
+		true
+	end
+	
+	def a_ends_with(sfx_path)
+		return false unless (ofs = self.length - sfx_path.length) >= 0
+		0.upto(sfx_path.length-1) { |i|
+			return false if !sfx_path.at(i).a_eql?(self.at(ofs+i)) }
+		true
+	end
+	
+	def dup
+		XyPath.new(self)
+	end
+	
+	def concat(path)
+		super(path[1, path.length-1])
+		self
+	end
+	
+	def +(path)
+		self.dup.concat(path[1, path.length-1])
+	end
+	
+	alias_method :expand_to_xy_path, :dup
+	
+	def xy_nodes
+		self[1, self.length-1]
+	end
+end
+
+class AaXyNode < Node
+	def initialize(ax_axy, ay_conns, conns=nil)
+		if conns
+			super(AaXy.new(ax_axy, ay_conns), conns)
+		else
+			super(ax_axy, ay_conns)
+		end
+	end
+	
+	def to_s(how=0)
+		res = self.data.coords_to_s
+		return res if how < 1
+		res.concat('+conns: ')
+		self.conns.each_key_value { |conn_k, conn|
+			res.concat("[#{conn_k}]#{conn.to_s(how-1)}; ")
+		}
+		res[-2,2] = ''
+		res
+	end
+	
+	def method_missing(id, *args, &block)
+		self.data.send(id, *args, &block)
+	end
+end
+
+end

data/ruby_libs/pav/pix/shaved_core.rb

@@ -0,0 +1,697 @@
+require 'set'
+require 'pav/pix'
+require 'pav/pix/node'
+require 'pav/pix/curve'
+require 'pav/attr_cache'
+require 'pav/pix/contour'
+
+module PPix
+
+class ShavedCoreCalc
+	attr_accessor :shaved_core, :curve, :min_branch_len, :min_lp_len_min,
+		:visited, :node_map
+	
+	def initialize(shaved_core)
+		@shaved_core = shaved_core
+		@curve = @shaved_core.curve
+		@min_branch_len = @shaved_core.min_branch_len
+		@min_lp_len_min = @shaved_core.min_lp_len_min
+		@visited = {}
+		@use_progr = false
+		@dup_grps = []
+		@orig_grps = []
+		@node2gid = {}
+		@node_conn_depths = {}
+		@node_map = {}
+		@grps_shaven = []
+	end
+	
+	def node_dir_max_depth(node, to_parent_conn_keys, visited={})
+		#$PDbgLog.sig_call(self)
+		#$PDbgLog.print_msg "node#{node}, to_parent_conn_keys: #{
+		#  to_parent_conn_keys.inspect}: "
+		if visited.include?(node)
+			#$PDbgLog.sig_return(1.0/0.0)
+			return 1.0/0.0
+		end
+		visited[node] = true
+		max_depth = 0
+		node.conns.each_key_value { |conn_k, conn|
+			next if to_parent_conn_keys.include?(conn_k)
+			depth = self.node_conn_max_depth(node, conn_k, visited)
+			max_depth = depth if depth > max_depth
+		}
+		visited.delete(node)
+		#$PDbgLog.sig_return#("#{node}: #{max_depth}")
+		max_depth
+	end
+	
+	def node_conn_max_depth(node, conn_k, visited={})
+		#$PDbgLog.sig_call(self)
+		if (conn_depths = @node_conn_depths[node])
+			if (tmp = conn_depths[conn_k])
+				#$PDbgLog.sig_return
+				return tmp
+			end
+		else
+			conn_depths = @node_conn_depths[node] = []
+		end
+		exit = (conn = node.conns[conn_k]).exit
+		#$PDbgLog.print_msg "node#{node}, conn[#{conn_k}]: #{conn}: "
+		if (nd_gid = @node2gid[node]) && nd_gid == @node2gid[exit] &&
+		(path = conn.path).kind_of?(PPix::NodePath) &&
+		(nd_grp = @orig_grps[nd_gid]).include?(path.first)
+			rev_conn_keys = []
+			exit.conns.each_key_value { |r_conn_k, r_conn|
+			  rev_conn_keys << r_conn_k if
+				(r_path=r_conn.path).kind_of?(PPix::NodePath) &&
+				nd_grp.include?(r_path.first)
+			}
+		else
+			rev_conn_keys = [node.to_parent_conn_key(conn_k)]
+		end
+		res =
+		conn_depths[conn_k] = conn.length +
+			self.node_dir_max_depth(exit, rev_conn_keys, visited)
+		#$PDbgLog.sig_return("#{node},conn[#{conn_k}]: #{conn}: #{res}")
+		res
+	end
+	
+	def min_lp_get_grp(min_lp_path)
+		#$PDbgLog.sig_call(self)
+		#$PDbgLog.print_msg "min_lp_path: #{min_lp_path}: "
+		res = min_lp_path.undir_to_link_grp
+		tail = res.nodes_to_a
+		while !tail.empty?
+			node = tail.pop
+			node.conns.each_key_value { |conn_k, conn|
+			  if conn.length <= @min_lp_len_min &&
+			  !res.include?(link = PPix::NodeLink.new(node, conn_k))
+			    begin
+			  	excl_link = link.reverse
+			    rescue PGraph::NoReverseLinkError
+				res << link
+				next
+			    end
+			    #$PDbgLog.puts_msg "link(#{link.length}): #{link.
+			    #	to_s(1)}"
+			    node_calc = PPix::NodeCalc.new(conn.exit)
+			    node_calc.link_filter = proc {|lk| lk != excl_link }
+			    if (path =node_calc.find_shortest_path_to_node(node,
+			    @min_lp_len_min - conn.length))
+				#$PDbgLog.puts_msg "+=(#{path.get_length}) " +
+				#	path.to_s
+				res << link; res << excl_link
+				res.add_undir_path!(path)
+				path.each { |lk| tail.push(lk.node) }
+			    end
+			  end
+			}
+		end
+		#$PDbgLog.sig_return('= ' + res.to_s)
+		res
+	end
+	
+	def dup_node(node)
+		#$PDbgLog.sig_call(self)
+		if (tmp = @node_map[node])
+			#$PDbgLog.sig_return#(tmp.to_s + ' (cached).')
+			return tmp
+		end
+		#$PDbgLog.print_msg node.coords_to_s + ": "
+		#$PDbgLog.puts_msg "map: #{@node_map.to_s}, tmp=#{tmp.inspect}"
+		lp, len = *node.get_min_lp_n_len(@min_lp_len_min)
+		#$PDbgLog.print_msg "lp(#{len.inspect}): #{lp}: "
+		if lp
+			#$PDbgLog.puts_msg 'condensing group.'
+			grp = self.min_lp_get_grp(lp)
+			grp.each { |m|
+			  if @node_map.include?(m)
+				raise "BUG: Group member #{m} already in " +
+				  "visited: #{grp.node_cnt < 100 ?
+				  "m's grp.: " + grp.to_s + '. ' : ''}#{
+				  @node2gid.include?(m) ? (
+				  @dup_grps[@node2gid[m]].length<100 ?
+				  @dup_grps[@node2gid[m]].to_s : 'large') :
+				  ''}!" #'
+			  end
+			}
+			if (entries = grp.get_entries_grp).empty?
+				#$PDbgLog.puts_msg 'Whole graph is one group.'
+				entries = grp
+				l_len = @min_lp_len_min#Don't neglect grp.extent
+			else
+				#$PDbgLog.puts_msg 'Entries: ' + Xy.path_to_s(
+				#	entries.to_a.sort)
+			end
+			if (l_path = grp.get_a_longest_path)
+				l_len = l_path.get_length
+			else
+				#$PDbgLog.puts_msg 'A one-node loop group.'
+				l_len = -1 # Neglect group's extent.
+			end
+		#	$PDbgLog.print_msg "longest_path(#{l_len}): #{l_path}: "
+			if l_len < @min_lp_len_min
+			  #$PDbgLog.puts_msg 'group extent negligible.'
+			  gid = @dup_grps.length
+			  @dup_grps << (new_grp = PPix::NodeGrp.new)
+			  @orig_grps << grp
+			  entries.each_node { |m|
+			    raise "BUG: Group entry already duplicated: #{m
+			      }!" if @node_map[m]
+			    new_grp <<(@node_map[m]=AaXyNode.new(m.ax,m.ay,[]))}
+			  new_grp.each { |m| @node2gid[m] = gid }
+			  entries.each_node { |m| nd_conns = @node_map[m].conns
+				grp.get_node_paths_to_entries(m).each { |path|
+			  	  raise "BUG: Group entry not duplicated: #{
+				    path.exit}!" unless @node_map[path.exit]
+				  cn = PPix::NodeConn.new(@node_map[path.exit],
+					path.get_length)
+				  cn.path = path
+				  #$PDbgLog.puts_msg "path_to_exterior: #{
+				  #	path.to_s(2)}, conn.: #{cn}"
+				  nd_conns << cn
+				}
+				m.conns.each_key_value { |conn_k, conn|
+				  if !grp.include?(PPix::NodeLink.new(m,conn_k))
+					#$PDbgLog.puts_msg "link to exterior: #{
+					#PPix::NodeLink.new(m, conn_k).to_s(1)}"
+					cn = PPix::NodeConn.new(self.dup_node(
+						conn.exit), conn.length)
+					cn.path = conn.path
+					nd_conns << cn
+				  end
+				}
+			  }
+			  #dbg_nodes = entries.nodes_to_a
+			else
+			  #$PDbgLog.puts_msg "group's extent non-negligible."
+			  paths = [l_path]
+			  dyke = l_path.to_node_grp.get_vicinity_grp_in_set(
+			  	@min_lp_len_min/2, grp.as_node_set)
+			  #$PDbgLog.puts_msg "Dyke: #{Xy.path_to_s(dyke.to_a.
+			  #	sort)}"
+			  grps = grp.get_link_islands(dyke)
+			  #$PDbgLog.puts_msg "grps: #{grps.join("\n   --:")}"
+			  grps_left_idxs = (0...grps.length).to_a
+			  while !grps_left_idxs.empty?
+			    i = 0
+			    while i < grps_left_idxs.length
+				t_grp = grps[grps_left_idxs.at(i)]
+				l_path = t_grp.get_a_longest_path
+				l_len = l_path.get_length
+				#$PDbgLog.puts_msg "l_path(#{l_len}): #{l_path}"
+				if l_len < @min_lp_len_min
+				  grps_left_idxs.delete_at(i)
+				else
+				  paths << l_path
+				  dk = l_path.to_node_grp.get_vicinity(
+				  	@min_lp_len_min/2)
+				  dk.each { |m| dyke << m }
+				  islands = t_grp.get_link_islands(dyke)
+				  if islands.empty?
+				    grps_left_idxs.delete_at(i)
+				  else
+				    grps[grps_left_idxs.at(i)] = islands.first
+				    1.upto(islands.length-1).each { |j|
+				      grps_left_idxs << grps.length
+				      grps << islands[j]
+				    }
+				  end
+				end
+			    end
+			  end
+			  #$PDbgLog.puts_msg "grps: #{grps.join("\n   --:")}"
+			  paths.concat(grp.get_islands_min_span_paths(grps))
+			  paths_grp = PPix::NodeGrp.new
+			  paths.each { |path|
+			  	path.each { |link| paths_grp << link.node }
+				paths_grp << path.exit
+			  }
+			  entries.each { |m|
+			    unless paths_grp.include?(m)
+				node_calc = PPix::NodeCalc.new(m)
+			  	path =node_calc.find_first_path_to(proc{|nd,lev|
+					paths_grp.include?(nd) })
+				paths << path
+				#$PDbgLog.puts_msg "Path to an entry: path: #{
+				#	path}"
+			  	path.each { |link| paths_grp << link.node }
+				paths_grp << path.exit
+			    end
+			  }
+			  entries.each { |m| @node_map[m] =
+			  	AaXyNode.new(m.ax,m.ay,[]) }
+			  #dbg_nodes = entries.to_a
+			  paths.each { |path| path.each { |link| nd=link.node
+			  	  @node_map[nd] = AaXyNode.new(nd.ax,nd.ay,[]
+				  	) unless @node_map.include?(nd)
+				  #dbg_nodes << nd unless @node_map.include?(nd)
+				}
+				nd = path.exit
+				@node_map[nd] = AaXyNode.new(nd.ax, nd.ay, []
+					) unless @node_map.include?(nd)
+				#dbg_nodes << nd unless @node_map.include?(nd)
+			  }
+			  #$PDbgLog.print_msg "Adding links: "
+			  paths.each { |path| path.each { |link|
+			  	#$PDbgLog.print_msg "#{link.to_s(1)} "
+			  	conn = link.conn
+				cn = PPix::NodeConn.new(@node_map[conn.exit],
+					conn.length)
+				cn.path = conn.path
+				@node_map[link.node].conns << cn
+				conn = (link=link.reverse).conn #<-- reverse --
+				cn = PPix::NodeConn.new(@node_map[conn.exit],
+					conn.length)
+				cn.path = conn.path
+				@node_map[link.node].conns << cn
+			  } }
+			  #$PDbgLog.puts_msg '.'
+			  #$PDbgLog.puts_msg 'Adding conns.: '
+			  entries.each { |m| nd_conns = @node_map[m].conns
+				m.conns.each_key_value { |conn_k, conn|
+				  #$PDbgLog.print_msg "conn:#{conn.to_s(1)} "
+				  unless grp.include?(PPix::NodeLink.new(m,
+				  conn_k))
+					nd_conns << (cn=PPix::NodeConn.new(
+					  self.dup_node(conn.exit),conn.length))
+					cn.path = conn.path
+				  end
+				}
+			  }
+			  #$PDbgLog.puts_msg '.'
+			end
+		#	$PDbgLog.sig_return("#{node.to_s} done: "+dbg_nodes.
+		#	  sort.collect{|nd| @node_map[nd].to_s(1) }.join('. ') +
+		#	  ": #{@node_map[node]}")
+			@node_map[node]
+		else
+			#$PDbgLog.print_msg 'copying node: '
+			res = @node_map[node] =
+				AaXyNode.new(node.ax, node.ay, conns=[])
+			node.conns.each { |conn|
+				cn =PPix::NodeConn.new(self.dup_node(conn.exit),
+					conn.length)
+				cn.path = conn.path
+				conns << cn
+			}
+			#$PDbgLog.sig_return(res.to_s(1))
+			res
+		end
+	end
+	
+	def dup_graph(node)
+		self.dup_node(node)
+	end
+	
+	def expand_path(node, exit, path)
+		#$PDbgLog.sig_call(self)
+		#$PDbgLog.print_msg "node#{node}, exit#{exit}, path: #{path}: "
+		node.clear_rev_conns_cache
+		node.conns.each { |conn| conn.exit.clear_rev_conns_cache }
+		#exit.clear_rev_conns_cache
+		#exit.conns.each { |conn| conn.exit.clear_rev_conns_cache }
+		path.each { |link|
+		  unless @node_map.include?(l_nd = link.node)
+			@node_map[l_nd] = AaXyNode.new(l_nd.ax, l_nd.ay, [])
+		  end
+		}
+		for link in path
+		  l_exit = link.exit; l_len = link.length
+		  #$PDbgLog.print_msg "link: #{link}-#{l_exit},node:#{@node_map[
+		  #	link.node].to_s(2)} "
+		  unless (l_cns = @node_map[link.node].conns).detect_value {|cn|
+		  l_exit.node_eql?(cn.exit) && cn.length == l_len }
+		    l_cns << (new_conn = PPix::NodeConn.new(@node_map[l_exit],
+			l_len))
+		    new_conn.path = link.path
+		    #$PDbgLog.print_msg "new_conn: #{new_conn} "
+		  end
+		end
+		#$PDbgLog.sig_return('done.')
+	end
+	
+	def expand_proxy_paths
+		#$PDbgLog.sig_call(self)
+		@dup_grps.each { |grp|
+		  #$PDbgLog.print_msg "Group: #{grp}: "
+		  grp.each_node { |node|
+		    #$PDbgLog.print_msg "node#{node}: "
+		    conn_i = 0; conns = node.conns
+		    while conn_i < conns.length
+		  	conn = conns.at(conn_i)
+			#$PDbgLog.print_msg "conn: #{conn.to_s(1)} "
+			if (path = conn.path).kind_of?(PPix::NodePath) &&
+			grp.includes_node?(conn.exit)
+				#$PDbgLog.print_msg "node#{node.to_s(2)}: "
+				#$PDbgLog.print_msg " => expanding path #{conn_i
+				#	}: "
+				conns.delete_at(conn_i)
+				self.expand_path(node, conn.exit, path)
+				#$PDbgLog.puts_msg "node#{node.to_s(2)}: "
+			else
+				conn_i += 1
+			end
+		    end
+		  }
+		  #$PDbgLog.puts_msg '.'
+		}
+		#$PDbgLog.sig_return
+	end
+	
+	def expand_grp_paths
+		#$PDbgLog.sig_call(self)
+		@dup_grps.each { |grp|
+		  #$PDbgLog.print_msg "Group: #{grp}: "
+		  entries = PPix::NodeGrp.new
+		  grp.each { |nd|
+		    if nd.conns.detect {|conn| !(conn.path.kind_of?(
+		    PPix::NodePath) && grp.includes_node?(conn.exit)) }
+		  	entries << nd
+		    end
+		  }
+		  #$PDbgLog.print_msg "Entries: #{entries} "
+		  if entries.empty?
+		  	#$PDbgLog.puts_msg 'One-group graph.'
+			next
+		  end
+		  entries.each { |nd| conns = nd.conns
+		  	i = 0
+			while i < conns.length
+				if (conn = conns.at(i)).path.kind_of?(
+				PPix::NodePath) && grp.includes_node?(conn.exit
+				) && !entries.includes_node?(conn.exit)
+					conns.delete_at(i)
+				else
+					i += 1
+				end
+			end
+		  }
+		  spanned = Set.new
+		  tail = PMinHeap.new { |a,b| a.length <=> b.length }
+		  first_nd = nil
+		  entries.each_node { |first_nd| break }
+		  first_nd.each_link { |link|
+		  	tail.push(link) if link.path.kind_of?(PPix::NodePath) &&
+			  entries.includes_node?(link.exit) }
+		  spanned << first_nd
+		  rev_link = nil
+		  while spanned.length < entries.length
+			link = tail.pop
+			next if spanned.include?(link.exit)
+			expand_path(node=link.node, link.exit, link.path)
+			link.exit.each_link { |rev_link|
+			  break if node.node_eql?(rev_link.exit) &&
+				rev_link.path.kind_of?(PPix::NodePath) &&
+				grp.includes_node?(rev_link.node) }
+			expand_path(rev_link.node, rev_link.exit, rev_link.path)
+			spanned << link.exit
+			link.exit.each_link { |link|
+			  tail.push(link) if grp.include?(link) &&
+				entries.includes_node?(link.exit) &&
+				!spanned.include?(link.exit)
+			}
+		  end
+		  #$PDbgLog.puts_msg '.'
+		}
+		#$PDbgLog.sig_return
+	end
+	
+	def shave_node!(node)
+		#$PDbgLog.sig_call(self)
+		conns = node.conns
+		i1 = i2 = nil
+		i1_depth = i2_depth = 0
+		i = -1
+		while (i += 1) < conns.length
+			depth = self.node_conn_max_depth(node, i)
+			#$PDbgLog.print_msg node.to_s + ": --" +
+			#	"#{conns[i]}:#{depth}: "
+			if i2
+				if depth > i1_depth
+					i_min = i2; min_depth = i2_depth
+					i2 = i1; i2_depth = i1_depth
+					i1 = i; i1_depth = depth
+				elsif depth > i2_depth
+					i_min = i2; min_depth = i2_depth
+					i2 = i; i2_depth = depth
+				else
+					i_min = i; min_depth = depth
+				end
+				if min_depth < @min_branch_len
+					#$PDbgLog.print_msg "deleting at #{i_min
+					#  }/#{conns.length}: #{conns[i_min]}"
+					conns.delete_at(i_min)
+					if (c_depths = @node_conn_depths[node])
+						c_depths.delete_at(i_min)
+					end
+					i1 -= 1 if i1 > i_min
+					i2 -= 1 if i2 > i_min
+					i -= 1
+				end
+			elsif i1
+				if depth > i1_depth
+					i2 = i1; i2_depth = i1_depth
+					i1 = i; i1_depth = depth
+				else
+					i2 = i; i2_depth = depth
+				end
+			else
+				i1 = i; i1_depth = depth
+			end
+			#$PDbgLog.puts_msg "."
+		end
+		#$PDbgLog.sig_return
+	end
+	
+	def shave_grp!(node)
+		#$PDbgLog.sig_call(self)
+		if @grps_shaven[gid=@node2gid[node]]
+			#$PDbgLog.sig_return
+			return
+		end
+		@grps_shaven[gid] = true
+		entries = (grp=@dup_grps[gid])
+		nd1 = nd2 = nil
+		i1 = i2 = nil
+		i1_depth = i2_depth = 0
+		for node in entries
+		  i = -1
+		  conns = node.conns
+		  while (i += 1) < conns.length
+		  	conn = conns.at(i)
+			next if (path = conn.path).kind_of?(PPix::NodePath) &&
+				grp.includes_node?(conn.exit)
+			depth = self.node_conn_max_depth(node, i)
+			#$PDbgLog.print_msg node.to_s + ": --" +
+			#	"#{conns[i]}:#{depth}: "
+			if i2
+				if depth > i1_depth
+				  i_min = i2; min_depth = i2_depth; nd_min = nd2
+				  i2 = i1; i2_depth = i1_depth; nd2 = nd1
+				  i1 = i; i1_depth = depth; nd1 = node
+				elsif depth > i2_depth
+				  i_min = i2; min_depth = i2_depth; nd_min = nd2
+				  i2 = i; i2_depth = depth; nd2 = node
+				else
+				  i_min = i; min_depth = depth; nd_min = node
+				end
+				if min_depth < @min_branch_len
+				#	$PDbgLog.print_msg "deleting at #{i_min
+				#	  }/#{nd_min.conns.length}: #{nd_min} #{
+				#	  nd_min.conns[i_min]}"
+					nd_min.conns.delete_at(i_min)
+					if (c_depths=@node_conn_depths[nd_min])
+						c_depths.delete_at(i_min)
+					end
+					i1-=1 if nd1.equal?(nd_min) && i1>i_min
+					i2-=1 if nd2.equal?(nd_min) && i2>i_min
+					i -= 1 if node.equal?(nd_min)
+				end
+			elsif i1
+				if depth > i1_depth
+				  i2 = i1; i2_depth = i1_depth; nd2 = nd1
+				  i1 = i; i1_depth = depth; nd1 = node
+				else
+				  i2 = i; i2_depth = depth; nd2 = node
+				end
+			else
+				i1 = i; i1_depth = depth; nd1 = node
+			end
+			#$PDbgLog.puts_msg "."
+		  end
+		end
+		#$PDbgLog.sig_return
+	end
+	
+	def shave!(node)
+		#$PDbgLog.sig_call(self)
+		#$PDbgLog.print_msg node.coords_to_s + ", conns: #{node.conns.
+		#	join('; ')}: "
+		node.conns.each { |conn|
+			next if @visited.include?(conn.exit.a_yx)
+			if @node2gid[conn.exit]
+				self.shave_grp!(conn.exit)
+			else
+				self.shave_node!(conn.exit)
+			end
+			@visited[conn.exit.a_yx] = true
+			unless conn.exit.conns.detect { |cn|
+			cn.exit.node_eql?(node) }
+				#$PDbgLog.sig_return(node.coords_to_s + ": " +
+				#  (res = self.shave!(conn.last)).coords_to_s)
+				return self.shave!(conn.exit) #res
+			end
+			if !(tmp = self.shave!(conn.exit)).node_eql?(conn.exit)
+				#$PDbgLog.sig_return(node.coords_to_s + ": " +
+				#	tmp.coords_to_s)
+				return tmp
+			end
+		}
+		$PDbgLog.progr.progr_units = @visited.length if @use_progr
+		#$PDbgLog.sig_return(node.coords_to_s + ": " + node.coords_to_s)
+		node
+	end
+	
+	def shave_graph(node)
+		$PDbgLog.sig_call(self)
+		#$PDbgLog.print_msg "node#{node}: "
+		@node_map = {}
+		unless (wrk_node = self.dup_graph(node))
+			# node could have been a non-visitable node in a group.
+			@node_map.each_value { |wrk_node| break }
+		end
+		#$PDbgLog.print_msg "wrk_node#{wrk_node} "
+		$PDbgLog.new_progr
+		$PDbgLog.progr.total_progr_units = @node_map.length
+		$PDbgLog.progr.show_as = "/ node" + (@node_map.length == 1 ?
+			'' : 's')
+		@use_progr = true
+		#$PDbgLog.puts_msg "Duplicated graph: #{wrk_node.graph_to_s}"
+		res = self.shave!(wrk_node)
+		#$PDbgLog.puts_msg "Shaved graph: #{res.graph_to_s}"
+		self.expand_grp_paths
+		#$PDbgLog.print_msg "res#{res} "
+		@use_progr = false
+		$PDbgLog.sig_return
+		res
+	end
+end
+
+class Curve
+	def get_shaved_core(min_branch_len, min_lp_len_min)
+		ShavedCore.new(self, min_branch_len, min_lp_len_min)
+	end
+	
+	self.img_obj_add_meths(PGuiObj::PMethod.new(:get_shaved_core, [
+	  PGuiObj::Argument.new(Integer, OpenStruct.new('min'=>0), nil, 10,
+		'min. branch length',
+		"Branches of the curve of length less than this one will be shaved off for curve's shaved core.",
+		OpenStruct.new('page_step'=>100)),
+	  PGuiObj::Argument.new(Integer, OpenStruct.new('min'=>0), nil, 10,
+		'min. loop length',
+		"Shortest loops of the curve of length less than this one will be deloopified for curve's shaved core.",
+		OpenStruct.new('page_step'=>100))],
+		'shaved core'))
+	
+	def c_shaved_core(min_hair_len, min_lp_len)
+		return @c_shaved_core if @c_shaved_core
+		#$PDbgLog.sig_call(self)
+		#$PDbgLog.print_msg @shaved_core.inspect
+		@c_shaved_core = self.get_shaved_core(min_hair_len, min_lp_len)
+		#$PDbgLog.sig_return(@shaved_core.object_id)
+		#@c_shaved_core
+	end
+	
+	def c_delete_shaved_core
+		@c_shaved_core = nil
+	end
+end
+
+class ShavedCore < ImageObject
+	attr_reader :curve, :branches, :min_branch_len, :min_lp_len_min
+	
+	def initialize(curve, min_branch_len, min_lp_len_min)
+		@curve = curve
+		@branches = []
+		@min_branch_len = min_branch_len
+		@min_lp_len_min = min_lp_len_min
+		super()
+		self.pguiobj_config.name = "<Shaved core>"
+		self.rebuild
+	end
+	
+	def rebuild
+		self.clear
+		if @curve.length < 2
+			self.replace(@curve)
+			return
+		end
+		$PDbgLog.sig_call(self)
+		$PDbgLog.print_msg "@min_branch_len=#{@min_branch_len
+			}, @min_lp_len_min=#{@min_lp_len_min}; Shaving: "
+		calc = ShavedCoreCalc.new(self)
+		node = @curve.pix_node(@curve.first)
+		node = node.conns.first.exit unless node.conns.empty?
+		#$PDbgLog.puts_msg "Graph: #{node.graph_to_s}"
+		node = calc.shave_graph(node)
+		$PDbgLog.print_msg "done.  Traversing: "
+		@branches.clear
+		branch_start_i = 0
+		if node.conns.length < 2
+			self << AaPix.new(@curve.pixbuf, node.ax, node.ay)
+		else
+		  node.graph_each_node { |nd|
+			if nd.conns.length < 2
+				node = nd
+				self << AaPix.new(@curve.pixbuf,node.ax,node.ay)
+				break
+			end
+		  }
+		end
+		next_node = node
+		#$PDbgLog.puts_msg "node#{node}"
+		#$PDbgLog.puts_msg "Final graph: #{node.graph_to_s}"
+		branch_lims = []
+		node.graph_each_conn_k { |node, conn_k|
+			#$PDbgLog.puts_msg "node#{node},conn_k[#{conn_k}]: #{
+			#	node.conns[conn_k].to_s(2)}: #{node.
+			#	conns[conn_k].path.expand_to_xy_path.xy_nodes}"
+			if !next_node.node_eql?(node) || node.conns.length > 2
+				#@branches << ImageObject.new(self,
+				#	branch_start_i, self.length)
+				branch_lims << [branch_start_i, self.length]
+				#$PDbgLog.puts_msg "Branch #{@branches.length
+				#  }: #{Xy.path_to_s(@branches.last)}"
+				branch_start_i = self.length
+			end
+			conn = node.conns[conn_k]
+			self.concat(conn.path.expand_to_xy_path.xy_nodes)
+			next_node = conn.exit
+		}
+		$PDbgLog.print_msg "done; adding branches: "
+		branch_lims.each { |b|
+				@branches << ImageObject.new(self, b[0], b[1]) }
+		@branches << ImageObject.new(self, branch_start_i,
+			self.length) unless branch_start_i >= self.length
+		#$PDbgLog.print_msg "@branches.length=#{@branches.length
+		#	}; @branches: #{@branches} "
+		$PDbgLog.sig_return("done all.")
+	end
+	
+	def img_obj_branches
+		(res=self.branches).each{|b| b.pguiobj_config.destroy_btn=false
+			b.pguiobj_config.name = '<Branch>' }
+		res = ImageObject.create_array(res)
+		res.pguiobj_config.name = '[Branches]'
+		res.pguiobj_config.destroy_btn = false
+		res
+	end
+	
+	self.img_obj_add_meths(meth=PGuiObj::PMethod.new(:img_obj_branches, [],
+		'branches'))
+	PGuiObj::MethObserverCachedAttr.observe(meth)
+end
+
+end