extract_curves 0.0.1-i586-linux

data/ruby_libs/pav/pix/shaved_core.rb

@@ -0,0 +1,534 @@
+require 'set'
+require 'pav/pix'
+require 'pav/pix/node'
+require 'pav/pix/curve'
+require 'pav/attr_cache'
+require 'pav/pix/contour'
+require 'pav/pix/node_grp'
+
+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 = {}
+	end
+	
+	def node_dir_max_depth(node, to_parent_conn_is, visited={})
+		#$PDbgLog.sig_call(self)
+		#$PDbgLog.print_msg "node#{node}, to_parent_conn_is: #{
+		#  to_parent_conn_is.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_with_index { |conn, conn_i|
+			next if to_parent_conn_is.include?(conn_i)
+			depth = self.node_conn_max_depth(node, conn_i, 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_i, visited={})
+		#$PDbgLog.sig_call(self)
+		if (conn_depths = @node_conn_depths[node])
+			if (tmp = conn_depths[conn_i])
+				#$PDbgLog.sig_return
+				return tmp
+			end
+		else
+			conn_depths = @node_conn_depths[node] = []
+		end
+		exit = (conn = node.conns[conn_i]).exit
+		#$PDbgLog.print_msg "node#{node}, conn[#{conn_i}]: #{conn}: "
+		if (nd_gid = @node2gid[node]) && nd_gid == @node2gid[exit] &&
+		(path = conn.path).kind_of?(NodePath) &&
+		(nd_grp = @orig_grps[nd_gid]).include?(path.first)
+			rev_conn_is = []
+			exit.conns.each_with_index { |r_conn, r_conn_i|
+			  rev_conn_is << r_conn_i if
+				(r_path = r_conn.path).kind_of?(NodePath) &&
+				nd_grp.include?(r_path.first)
+			}
+		else
+			rev_conn_is = [node.to_parent_conn_idx(conn_i)]
+		end
+		res =
+		conn_depths[conn_i] = conn.length +
+			self.node_dir_max_depth(exit, rev_conn_is, visited)
+		#$PDbgLog.sig_return("#{node},conn[#{conn_i}]: #{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_with_index { |conn, conn_i|
+			  if conn.length <= @min_lp_len_min &&
+			  !res.include?(link = NodeLink.new(node, conn_i))
+			    begin
+			  	excl_link = link.reverse
+			    rescue NoReverseLinkError
+				res << link
+				next
+			    end
+			    #$PDbgLog.puts_msg "link(#{link.length}): #{link.
+			    #	to_s(1)}"
+			    node_calc = 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 = 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 = 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_with_index { |conn, conn_i|
+				  if !grp.include?(NodeLink.new(m, conn_i))
+					#$PDbgLog.puts_msg "link to exterior: #{
+					#  NodeLink.new(m, conn_i).to_s(1)}"
+					cn = 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 = 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 = 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 = 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 = 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_with_index { |conn, conn_i|
+				  #$PDbgLog.print_msg "conn:#{conn.to_s(1)} "
+				  unless grp.include?(NodeLink.new(m, conn_i))
+					nd_conns << (cn=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 = 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(path)
+		(node = path.first.node).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
+		  unless (l_cns = @node_map[link.node].conns).detect { |cn|
+		  l_exit.node_eql?(cn.exit) && cn.length == l_len }
+		    l_cns << (new_conn = NodeConn.new(@node_map[l_exit], l_len))
+		    new_conn.path = link.path
+		  end
+		end
+	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
+		    while conn_i < (conns = node.conns).length
+		  	conn = conns.at(conn_i)
+			#$PDbgLog.print_msg "conn: #{conn.to_s(1)} "
+			if (path = conn.path).kind_of?(NodePath) &&
+			grp.includes_node?(conn.exit)
+			  #$PDbgLog.print_msg " => expanding path: "
+			  conns.delete_at(conn_i)
+			  self.expand_path(path)
+			else
+				conn_i += 1
+			end
+		    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[used_conn_is[i]].last.coords_to_s +
+			#	",#{used_conn_is[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
+					#	}"
+					node.delete_conn(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!(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)
+			self.shave_node!(conn.exit)
+			@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_proxy_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
+	
+	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
+	
+	self.img_obj_add_sub_obj :branches
+	
+	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.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}"
+		node.graph_each_conn_i { |node, conn_i|
+			#$PDbgLog.puts_msg "node#{node},conn_i[#{conn_i}]: #{
+			#	node.conns[conn_i].to_s(2)}: #{node.
+			#	conns[conn_i].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)
+				#$PDbgLog.puts_msg "Branch: #{Xy.path_to_s(
+				#	@branches.last)}"
+				branch_start_i = self.length
+			end
+			conn = node.conns[conn_i]
+			self.concat(conn.path.expand_to_xy_path.xy_nodes)
+			next_node = conn.exit
+		}
+		@branches << ImageObject.new(self, branch_start_i,
+			self.length) unless branch_start_i >= self.length
+		#$PDbgLog.print_msg "@branches.length=#{@branches.length
+		#	}; @branches: #{@branches.inspect} "
+		$PDbgLog.sig_return("done all.")
+	end
+end
+
+end