extract_curves 0.0.1

data/ruby_libs/pav/pix/node_grp.rb

@@ -0,0 +1,853 @@
+require 'set'
+require 'pav/pix'
+require 'pav/pix/node'
+require 'pav/pix/aapix'
+require 'pav/attr_cache'
+require 'pav/pix/img_obj'
+
+module PPix
+
+class GrpNodeConnProxyToExterior < NodeConn
+	def reverse(conn_0)
+		link = self.path.last
+		link.conn.reverse(link.node)
+	end
+end
+
+class NodeGrp < Set
+	def initialize(*args)
+		super(*args)
+		@cache_get_node_paths_to_exterior = {}
+		@cache_get_node_shortest_paths_to_exterior = {}
+		@cache_get_node_paths_to_entries = {}
+		@link_filter = proc { |link| self.include?(link.exit) }
+	end
+	
+	alias_method :includes_node?, :include?
+	alias_method :nodes_to_a, :to_a
+	alias_method :node_cnt, :length
+	alias_method :each_node, :each
+	
+	cache_get_lm! :get_node_paths_to_exterior,
+		:get_node_shortest_paths_to_exterior, :get_node_paths_to_entries
+	
+	def get_all_links_to(node)
+		res = []
+		self.each { |m| m.conns.each_with_index { |cn,cn_i|
+			res << NodeLink.new(m,cn_i) if node.node_eql?(cn.exit)}}
+		res
+	end
+	
+	def get_entries_grp
+		res = NodeGrp.new
+		self.each { |m|
+		  if m.conns.detect { |conn| !self.include?(conn.exit) }
+			res << m
+		  end
+		}
+		res
+	end
+	
+	def get_terminals
+		known = {}
+		self.each { |m| known[m] = true }
+		terminals = []
+		self.each { |m| m.conns.each { |cn|
+			unless known.include?(cn.exit)
+				terminals << cn.exit
+				known[cn.exit] = true
+			end
+		}}
+		terminals
+	end
+	
+	def get_vicinity_grp(max_distc)
+		res = NodeGrp.new(self)
+		tail = []
+		self.each { |m| tail.push([m, 0]) }
+		while !tail.empty?
+			nd, lev = *tail.pop
+			nd.conns.each { |cn|
+			  if (n_lev = lev + cn.length) <= max_distc &&
+			  !res.include?(cn.exit)
+				res << cn.exit
+				tail.push([cn.exit, n_lev])
+			  end
+			}
+		end
+		res
+	end
+	
+	def get_vicinity_grp_in_set(max_distc, incl_set)
+		res = NodeGrp.new(self)
+		tail = []
+		self.each { |m| tail.push([m, 0]) if incl_set.include?(m) }
+		while !tail.empty?
+			nd, lev = *tail.pop
+			nd.conns.each { |cn|
+			  if (n_lev = lev + cn.length) <= max_distc &&
+			  !res.include?(cn.exit) && incl_set.include?(cn.exit)
+				res << cn.exit
+				tail.push([cn.exit, n_lev])
+			  end
+			}
+		end
+		res
+	end
+	
+	cache_get! :get_entries_grp, :get_terminals
+	
+	def get_node_paths_to_exterior(node, node_calc=nil)
+		node_calc = NodeCalc.new(node) unless node_calc
+		node_calc.link_filter = @link_filter
+		paths = []
+		self.each { |m|
+			path = node_calc.find_shortest_path_to_node(m)
+			m.conns.each_with_index { |conn, conn_i|
+				next if self.include?(conn.exit)
+				paths << path + [NodeLink.new(m, conn_i)]
+			}
+		}
+		paths
+	end
+	
+	def get_node_shortest_paths_to_exterior(node, node_calc=nil)
+		#$PDbgLog.sig_call(self)
+		node_calc = NodeCalc.new(node) unless node_calc
+		node_calc.link_filter = @link_filter
+		paths = {}
+		self.each { |m|
+			path = node_calc.find_shortest_path_to_node(m)
+			path_len = path.get_length
+			m.conns.each_with_index { |conn, conn_i|
+				next if self.include?(conn.exit)
+				len = path_len + conn.length
+				next if paths.include?(conn.exit) &&
+					paths[conn.exit][1] <= len
+				paths[conn.exit] =
+					[path+[NodeLink.new(m,conn_i)], len]
+			}
+		}
+		res = []
+		paths.each_value { |p_spec| res << p_spec[0] }
+		#$PDbgLog.sig_return(res.inspect)
+		res
+	end
+	
+	def get_node_paths_to_entries(node, node_calc=nil)
+		#$PDbgLog.sig_call(self)
+		node_calc = NodeCalc.new(node) unless node_calc
+		node_calc.link_filter = @link_filter
+		paths = []
+		self.each { |m| next if m.node_eql?(node)
+		  if m.conns.detect { |conn| !self.include?(conn.exit) }
+			#$PDbgLog.print_msg "Entry #{m.coords_to_s}: "
+			paths << node_calc.find_shortest_path_to_node(m)
+			#$PDbgLog.puts_msg paths.last.to_s + '.'
+		  end
+		}
+		#$PDbgLog.sig_return
+		paths
+	end
+	
+	def self.get_node_vicinity_grp(node, max_distc)
+		res = NodeGrp.new
+		res << node
+		tail = [node, 0]
+		while !tail.empty?
+			nd, lev = *tail.pop
+			nd.conns.each { |cn|
+			  if (n_lev = lev + cn.length) <= max_distc &&
+			  !res.include?(cn.exit)
+				res << cn.exit
+				tail.push([cn.exit, n_lev])
+			  end
+			}
+		end
+		res
+	end
+	
+	def get_a_longest_path
+		#$PDbgLog.sig_call(self)
+		max_path = nil
+		max_path_len = -1
+		self.each { |m_0|
+		  node_calc = NodeCalc.new(m_0)
+		  node_calc.link_filter = @link_filter
+		  self.each { |m_end| next if m_end.a_eql?(m_0)
+		#	$PDbgLog.print_msg "m_0#{m_0.coords_to_s}, m_end#{m_end.
+		#		coords_to_s}: "
+			path = node_calc.find_shortest_path_to_node(m_end)
+			#$PDbgLog.puts_msg path.to_s
+			if (len = path.get_length) > max_path_len
+				max_path = path; max_path_len = len
+			end
+		  }
+		}
+		#$PDbgLog.sig_return
+		max_path
+	end
+	
+	cache_get! :get_a_longest_path
+	
+	def get_node_islands(dyke_set)
+		assigned = Set.new(dyke_set)
+		islands = []
+		dyke_set.each { |m| m.conns.each { |conn|
+		  if self.include?(conn.exit) &&
+		  !assigned.include?(conn.exit)
+			island = NodeGrp.new; island << conn.exit
+			tail = [conn.exit]
+			while !tail.empty?
+				node = tail.pop
+				node.conns.each { |cn|
+				  if self.include?(cn.exit) &&
+				  !assigned.include?(cn.exit)
+					island << cn.exit
+					assigned << cn.exit
+					tail.push(cn.exit)
+				  end
+				}
+			end
+		  end
+		} }
+		islands
+	end
+	
+	def find_first_path_to(dest, max_distc=1.0/0.0)
+		return nil if max_distc < 0
+		if dest.kind_of?(Proc)
+			dest_proc = dest
+		else
+			dest_proc = proc { |nd| dest.node_eql?(nd) }
+		end
+		c_paths = {}
+		tail = PMinHeap.new { |a,b| a[1] <=> b[1] }
+		self.each { |m| c_paths[m] = [0, nil]; tail.push([m, 0]) }
+		while !tail.empty?
+			node, lev = *tail.pop
+			if dest_proc.call(node)
+			  return NodeCalc.path_cache_get_path(node, c_paths)
+			end
+			next if c_paths.include?(node) && c_paths[node][0] <=lev
+			node.conns.each_with_index { |conn, conn_i|
+				if (c_lev = lev + conn.length) <= max_distc &&
+				!c_paths.include?(conn.exit) ||
+				c_paths[conn.exit][0] > c_lev
+					c_paths[conn.exit] = [c_lev, NodeLink.
+					  new(node, conn_i)]
+					tail.push([conn.exit, c_lev])
+				end
+			}
+		end
+		nil
+	end
+	
+	def get_islands_min_span_grp(islands)
+		return nil if islands.empty?
+		node2grp = {}
+		islands.each { |isl| isl.each { |m| node2grp[m] = isl } }
+		res = NodeGrp.new(islands.first)
+		tail = PMinHeap.new { |a,b| a[1] <=> b[1] }
+		c_paths = {}
+		res.each { |m| tail.push([m, 0]); c_paths[m] = [0, nil] }
+		grps_left = islands.length - 1
+		while grps_left > 0
+			lev, node = *tail.pop
+			node.conns.each_with_index { |conn, conn_i|
+			  c_lev = lev + conn.length
+			  if !c_paths.include?(conn.exit) ||
+			  c_paths[conn.exit][0] > c_lev
+				if (grp = node2grp[conn.exit]) &&
+				grp.object_id != res.object_id
+					grp.each{|m| res << m; node2grp[m]=res
+					  c_paths[m] = [0, nil]
+					  tail.push([m, 0])
+					}
+					grps_left -= 1
+					to_link = c_paths[node][1]
+					while to_link
+						res << to_link.node
+						node2grp[to_link.node] = res
+						to_link=c_paths[to_link.node][1]
+					end
+				end
+			  else
+				c_paths[conn.exit] =
+					[c_lev, NodeLink.new(node, conn_i)]
+				tail.push([c_lev, conn.exit])
+			  end
+			}
+		end
+		res
+	end
+	
+	def get_islands_min_span_paths(islands)
+		res = []
+		return res if islands.empty?
+		node2grp = {}
+		islands.each { |isl| isl.each { |m| node2grp[m] = isl } }
+		grp0 = NodeGrp.new(islands.first)
+		tail = PMinHeap.new { |a,b| a[1] <=> b[1] }
+		c_paths = {}
+		grp0.each { |m| tail.push([m, 0]); c_paths[m] = [0, nil] }
+		grps_left = islands.length - 1
+		while grps_left > 0
+			lev, node = *tail.pop
+			node.conns.each_with_index { |conn, conn_i|
+			  next unless self.include?(conn.exit)
+			  c_lev = lev + conn.length
+			  if !c_paths.include?(conn.exit) ||
+			  c_paths[conn.exit][0] > c_lev
+				if (grp = node2grp[conn.exit]) &&
+				grp.object_id != res.object_id
+					grp.each{|m| node2grp[m]=grp0
+					  c_paths[m] = [0, nil]
+					  tail.push([m, 0])
+					}
+					grps_left -= 1
+					path = NodePath.new
+					to_link = c_paths[node][1]
+					while to_link
+						path << to_link
+						node2grp[to_link.node] = grp0
+						to_link=c_paths[to_link.node][1]
+					end
+					path.reverse_links!
+					res << path
+				end
+			  else
+				c_paths[conn.exit] =
+					[c_lev, NodeLink.new(node, conn_i)]
+				tail.push([c_lev, conn.exit])
+			  end
+			}
+		end
+		res
+	end
+	
+	def to_s
+		arr = self.to_a; arr.sort!
+		'{' + arr.join(', ') + '}'
+	end
+end
+
+class LinkGrpAsNodeSet
+	attr_reader :link_grp
+	
+	def initialize(link_grp)
+		@link_grp = link_grp
+	end
+	
+	def include?(node)
+		@link_grp.includes_node?(node)
+	end
+end
+
+class LinkGrp
+	def initialize
+		super()
+		@cache_get_node_paths_to_exterior = {}
+		@cache_get_node_paths_to_external_nodes = {}
+		@cache_get_node_shortest_paths_to_exterior = {}
+		@cache_get_node_shortest_paths_to_external_nodes = {}
+		@cache_get_node_paths_to_border = {}
+		@cache_get_node_paths_to_entries = {}
+		@node2links = {}
+		@link_filter = self.method('include?').to_proc
+	end
+	
+	def add(link)
+		unless (links = @node2links[link.node])
+			links = @node2links[link.node] = []
+		end
+		links[link.conn_i] = link
+	end
+	
+	def <<(link)
+		unless (links = @node2links[link.node])
+			links = @node2links[link.node] = []
+		end
+		links[link.conn_i] = link
+		self
+	end
+	
+	def include?(link)
+		(links = @node2links[link.node]) && links[link.conn_i]
+	end
+	
+	alias_method :member?, :include?
+	
+	def includes_node?(node)
+		@node2links.include?(node)
+	end
+	
+	alias_method :include_node?, :includes_node?
+	
+	def each
+		@node2links.each_pair { |node, links|
+			links.each { |link| yield(link) if link } }
+	end
+	
+	def each_node(&block)
+		@node2links.each_key(&block)
+	end
+	
+	def to_a
+		res = []
+		self.each { |link| res << link }
+		res
+	end
+	
+	def nodes_to_a
+		@node2links.keys
+	end
+	
+	def nodes_to_node_grp
+		res = NodeGrp.new
+		self.each_node { |node| res << node }
+		res
+	end
+	
+	def as_node_set
+		LinkGrpAsNodeSet.new(self)
+	end
+	
+	def to_s
+		nodes = @node2links.keys; nodes.sort!
+		res = '{'
+		nodes.each { |node| res << node.to_s << ':'
+		  @node2links[node].each_with_index { |link,link_i|
+			res << " #{link_i}" if link }
+		  res << '; '
+		}
+		res[-2] ? res[-2,2] = '}' : res << '}'
+		res
+	end
+	
+	def node_cnt
+		@node2links.length
+	end
+	
+	def add_undir_path!(path)
+		path.each { |link| self << link
+			begin
+				self << link.reverse
+			rescue NoReverseLinkError
+			end
+		}
+	end
+	
+	alias_method :add_undir_path, :add_undir_path!
+	
+	cache_get_lm! :get_node_paths_to_exterior,
+		:get_node_paths_to_external_nodes,
+		:get_node_shortest_paths_to_exterior,
+		:get_node_shortest_paths_to_external_nodes,
+		:get_node_paths_to_border, :get_node_paths_to_entries
+	
+	def get_all_links_to(node)
+		res = []
+		self.each { |m| res << m if node.node_eql?(node) }
+		res
+	end
+	
+	def get_entries_grp
+		res = NodeGrp.new
+		@node2links.each_pair { |node, links|
+		  node.conns.each_index { |conn_i|
+		    unless links[conn_i]
+		  	res << node; break
+		    end
+		  }
+		}
+		res
+	end
+	
+	def get_border_grp
+		res = NodeGrp.new
+		self.each_node { |node|
+			res << node if node.conns.detect { |conn|
+				!self.includes_node?(conn.exit) }
+		}
+		res
+	end
+	
+	def get_terminals
+		known = {}
+		self.each_node { |node| known[node] = true }
+		terminals = []
+		self.each_node { |node| node.conns.each { |cn|
+			unless known.include?(cn.exit)
+				terminals << cn.exit
+				known[cn.exit] = true
+			end
+		}}
+		terminals
+	end
+	
+	def get_vicinity_grp(max_distc)
+		res = NodeGrp.new(self)
+		tail = []
+		self.each_node { |node| tail.push([node, 0]) }
+		while !tail.empty?
+			nd, lev = *tail.pop
+			nd.conns.each { |cn|
+			  if (n_lev = lev + cn.length) <= max_distc &&
+			  !res.include?(cn.exit)
+				res << cn.exit
+				tail.push([cn.exit, n_lev])
+			  end
+			}
+		end
+		res
+	end
+	
+	cache_get! :get_entries_grp, :get_border_grp, :get_terminals
+	
+	def get_node_paths_to_external_nodes(node, node_calc=nil)
+		node_calc = NodeCalc.new(node) unless node_calc
+		node_calc.link_filter = @link_filter
+		paths = []
+		self.each_node { |node|
+			path = node_calc.find_shortest_path_to_node(node)
+			node.conns.each_with_index { |conn, conn_i|
+				next if self.includes_node?(conn.exit)
+				paths << path + [NodeLink.new(node, conn_i)]
+			}
+		}
+		paths
+	end
+	
+	def get_node_paths_to_exterior(node, node_calc=nil)
+		node_calc = NodeCalc.new(node) unless node_calc
+		node_calc.link_filter = @link_filter
+		paths = []
+		self.each_node { |node|
+			path = node_calc.find_shortest_path_to_node(node)
+			links = @node2links[node]
+			node.conns.each_with_index { |conn, conn_i|
+				next if links[conn_i]
+				paths << path + [NodeLink.new(node, conn_i)]
+			}
+		}
+		paths
+	end
+	
+	def get_node_shortest_paths_to_external_nodes(node, node_calc=nil)
+		#$PDbgLog.sig_call(self)
+		node_calc = NodeCalc.new(node) unless node_calc
+		node_calc.link_filter = @link_filter
+		paths = {}
+		self.each_node { |node|
+			path = node_calc.find_shortest_path_to_node(node)
+			path_len = path.get_length
+			node.conns.each_with_index { |conn, conn_i|
+				next if self.includes_node?(conn.exit)
+				len = path_len + conn.length
+				next if paths.include?(conn.exit) &&
+					paths[conn.exit][1] <= len
+				paths[conn.exit] =
+					[path+[NodeLink.new(node,conn_i)], len]
+			}
+		}
+		res = []
+		paths.each_value { |p_spec| res << p_spec[0] }
+		#$PDbgLog.sig_return(res.inspect)
+		res
+	end
+	
+	def get_node_shortest_paths_to_exterior(node, node_calc=nil)
+		#$PDbgLog.sig_call(self)
+		node_calc = NodeCalc.new(node) unless node_calc
+		node_calc.link_filter = @link_filter
+		paths = {}
+		self.each_node { |node|
+			path = node_calc.find_shortest_path_to_node(node)
+			path_len = path.get_length
+			links = @node2links[node]
+			node.conns.each_with_index { |conn, conn_i|
+				next if links[conn_i]
+				len = path_len + conn.length
+				link = NodeLink.new(node, conn_i)
+				next if paths.include?(link) &&
+					paths[link][1] <= len
+				paths[link] = [path + [link], len]
+			}
+		}
+		res = []
+		paths.each_value { |p_spec| res << p_spec[0] }
+		#$PDbgLog.sig_return(res.inspect)
+		res
+	end
+	
+	def get_node_paths_to_border(node, node_calc=nil)
+		node_calc = NodeCalc.new(node) unless node_calc
+		node_calc.link_filter = @link_filter
+		paths = []
+		self.each_node { |nd| next if nd.node_eql?(node)
+		  if nd.conns.detect { |conn| !self.includes_node?(conn.exit) }
+			path = node_calc.find_shortest_path_to_node(nd)
+			paths << path
+		  end
+		}
+		paths
+	end
+	
+	def get_node_paths_to_entries(node, node_calc=nil)
+		node_calc = NodeCalc.new(node) unless node_calc
+		node_calc.link_filter = @link_filter
+		paths = []
+		self.each_node { |nd| next if nd.node_eql?(node)
+		  links = @node2links[nd]
+		  nd.conns.each_index { |conn_i|
+		    unless links[conn_i]
+			path = node_calc.find_shortest_path_to_node(nd)
+			paths << path
+			break
+		    end
+		  }
+		}
+		paths
+	end
+	
+	def get_a_longest_path
+		#$PDbgLog.sig_call(self)
+		max_path = nil
+		max_path_len = 0
+		node_grp = self.nodes_to_node_grp
+		end_nodes = {}
+		self.each_node { |node| nd_end_nodes = node_grp.dup
+			nd_end_nodes.delete(node); end_nodes[node]=nd_end_nodes}
+		self.each_node { |start_node|
+		  node_calc = NodeCalc.new(start_node)
+		  node_calc.link_filter = @link_filter
+		  end_nodes[start_node].each_node { |end_node|
+			#$PDbgLog.puts_msg "start_node#{start_node},end_node#{
+			#	end_node}"
+			path = node_calc.find_shortest_path_to_node(end_node)
+			if (len = path.get_length) > max_path_len
+				max_path = path; max_path_len = len
+			end
+			node_calc.path_cache_each_path { |iter|
+			  if (nd1 = iter.pop)
+				nd1 = nd1.node
+				while (nd2 = iter.pop)
+					end_nodes[nd1].delete(nd2=nd2.node)
+					end_nodes[nd2].delete(nd1)
+				end
+			  end
+			}
+		  }
+		}
+		#$PDbgLog.sig_return("max_path(#{max_path_len.inspect}): #{
+		#	max_path ? max_path.to_s(1) : max_path.inspect}")
+		max_path
+	end
+	
+	cache_get! :get_a_longest_path
+	
+	def get_node_islands(dyke_set)
+		#$PDbgLog.sig_call(self)
+		#$PDbgLog.puts_msg self.to_s
+		#$PDbgLog.puts_msg 'Dyke set: ' + dyke_set.to_s
+		assigned = Set.new(dyke_set)
+		islands = []
+		dyke_set.each { |m|
+		  #$PDbgLog.print_msg "m#{m} "
+		  links = @node2links[m]
+		  m.conns.each_with_index { |conn, conn_i|
+		    if links[conn_i] && !assigned.include?(conn.exit)
+			island = NodeGrp.new; island << conn.exit
+			tail = [conn.exit]
+			while !tail.empty?
+				node = tail.pop
+				lks = @node2links[node]
+				node.conns.each_with_index { |cn, cn_i|
+				  if lks[cn_i] && !assigned.include?(cn.exit)
+					island << cn.exit
+					assigned << cn.exit
+					tail.push(cn.exit)
+				  end
+				}
+			end
+		    end
+		  }
+		}
+		#$PDbgLog.sig_return
+		islands
+	end
+	
+	def get_link_islands(dyke_set)
+		#$PDbgLog.sig_call(self)
+		#$PDbgLog.puts_msg self.to_s
+		#$PDbgLog.puts_msg 'Dyke set: ' + dyke_set.to_s
+		assigned = Set.new(dyke_set)
+		islands = []
+		dyke_set.each { |m|
+		  #$PDbgLog.print_msg "m#{m} "
+		  links = @node2links[m]
+		  m.conns.each_with_index { |conn, conn_i|
+		    if links[conn_i] && !assigned.include?(conn.exit)
+			island = LinkGrp.new
+			tail = [conn.exit]
+			while !tail.empty?
+				node = tail.pop
+				lks = @node2links[node]
+				node.conns.each_with_index { |cn, cn_i|
+				  if lks[cn_i] && !dyke_set.include?(cn.exit)
+					islands << NodeLink.new(node, cn_i)
+					tail.push(cn.exit) unless
+						assigned.include?(cn.exit)
+				  end
+				}
+				assigned << node
+			end
+		    end
+		  }
+		}
+		#$PDbgLog.sig_return
+		islands
+	end
+	
+	def find_first_path_to(dest, max_distc=1.0/0.0)
+		return nil if max_distc < 0
+		if dest.kind_of?(Proc)
+			dest_proc = dest
+		else
+			dest_proc = proc { |nd| dest.node_eql?(nd) }
+		end
+		c_paths = {}
+		tail = PMinHeap.new { |a,b| a[1] <=> b[1] }
+		self.each_node { |m| c_paths[m] = [0, nil]; tail.push([m, 0]) }
+		while !tail.empty?
+			node, lev = *tail.pop
+			if dest_proc.call(node)
+			  return NodeCalc.path_cache_get_path(node, c_paths)
+			end
+			next if c_paths.include?(node) && c_paths[node][0] <=lev
+			node.conns.each_with_index { |conn, conn_i|
+				if (c_lev = lev + conn.length) <= max_distc &&
+				!c_paths.include?(conn.exit) ||
+				c_paths[conn.exit][0] > c_lev
+					c_paths[conn.exit] = [c_lev, NodeLink.
+					  new(node, conn_i)]
+					tail.push([conn.exit, c_lev])
+				end
+			}
+		end
+		nil
+	end
+	
+	def get_islands_min_span_grp(islands)
+		return nil if islands.empty?
+		node2grp = {}
+		islands.each { |isl| isl.each { |m| node2grp[m] = isl } }
+		res = NodeGrp.new(islands.first)
+		tail = PMinHeap.new { |a,b| a[1] <=> b[1] }
+		c_paths = {}
+		res.each { |m| tail.push([m, 0]); c_paths[m] = [0, nil] }
+		grps_left = islands.length - 1
+		while grps_left > 0
+			lev, node = *tail.pop
+			node.conns.each_with_index { |conn, conn_i|
+			  c_lev = lev + conn.length
+			  if !c_paths.include?(conn.exit) ||
+			  c_paths[conn.exit][0] > c_lev
+				if (grp = node2grp[conn.exit]) &&
+				grp.object_id != res.object_id
+					grp.each{|m| res << m; node2grp[m]=res
+					  c_paths[m] = [0, nil]
+					  tail.push([m, 0])
+					}
+					grps_left -= 1
+					to_link = c_paths[node][1]
+					while to_link
+						res << to_link.node
+						node2grp[to_link.node] = res
+						to_link=c_paths[to_link.node][1]
+					end
+				end
+			  else
+				c_paths[conn.exit] =
+					[c_lev, NodeLink.new(node, conn_i)]
+				tail.push([c_lev, conn.exit])
+			  end
+			}
+		end
+		res
+	end
+	
+	def get_islands_min_span_paths(islands)
+		res = []
+		return res if islands.empty?
+		node2grp = {}
+		islands.each { |isl| isl.each_node { |m| node2grp[m] = isl } }
+		grp0 = NodeGrp.new(islands.first)
+		tail = PMinHeap.new { |a,b| a[1] <=> b[1] }
+		c_paths = {}
+		grp0.each_node { |m| tail.push([m, 0]); c_paths[m] = [0, nil] }
+		grps_left = islands.length - 1
+		while grps_left > 0
+			lev, node = *tail.pop
+			links = @node2links[node]
+			node.conns.each_with_index { |conn, conn_i|
+			  next unless links[conn_i]
+			  c_lev = lev + conn.length
+			  if !c_paths.include?(conn.exit) ||
+			  c_paths[conn.exit][0] > c_lev
+				if (grp = node2grp[conn.exit]) &&
+				grp.object_id != res.object_id
+					grp.each{|m| node2grp[m]=grp0
+					  c_paths[m] = [0, nil]
+					  tail.push([m, 0])
+					}
+					grps_left -= 1
+					path = NodePath.new
+					to_link = c_paths[node][1]
+					while to_link
+						path << to_link
+						node2grp[to_link.node] = grp0
+						to_link=c_paths[to_link.node][1]
+					end
+					path.reverse_links!
+					res << path
+				end
+			  else
+				c_paths[conn.exit] =
+					[c_lev, NodeLink.new(node, conn_i)]
+				tail.push([c_lev, conn.exit])
+			  end
+			}
+		end
+		res
+	end
+end
+
+class NodePath
+	def to_node_grp
+		res = NodeGrp.new
+		self.each { |link| res << link.node }
+		res << self.exit
+		res
+	end
+	
+	def to_link_grp
+		res = LinkGrp.new
+		self.each { |link| res << link }
+		res
+	end
+	
+	def undir_to_link_grp
+		res = LinkGrp.new
+		self.each { |link| res << link
+			begin
+				res << link.reverse
+			rescue NoReverseLinkError
+			end
+		}
+		res
+	end
+end
+
+end