def max_degree_sample(graph: Graph, num_vertices: int, prev_state: DegreeWeightedSampleState, args: argparse.Namespace) -> SampleState: """Max-degree sampling. Simply samples the highest-degree vertices. Parameters ---------- graph : Graph the filtered graph from which to sample vertices num_vertices : int number of vertices in the unfiltered graph prev_state : UniformRandomSampleState the state of the previous sample in the stack. If there is no previous sample, an empty SampleState object should be passed in here. args : argparse.Namespace the command-line arguments provided by the user Returns ------- state : SampleState the sample state with the sampled vertex ids (Note: these ids correspond to the filtered graph, and have to be mapped back to the unfiltered graph) """ state = MaxDegreeSampleState(graph.num_vertices(), prev_state) sample_num = int( (num_vertices * (args.sample_size / 100)) / args.sample_iterations) vertex_degrees = graph.get_total_degrees( np.arange(graph.num_vertices())) vertex_degrees[state.sample_idx] = 0 top_indices = np.argpartition(vertex_degrees, -sample_num)[-sample_num:] state.sample_idx = np.concatenate((state.sample_idx, top_indices)) return state
def gen_cascade(g, p, source=None, stop_fraction=0.5): if source is None: source = random.choice(np.arange(g.num_vertices())) infected = {source} infection_times = np.ones(g.num_vertices()) * -1 infection_times[source] = 0 time = 0 edges = [] while np.count_nonzero(infection_times != -1) / g.num_vertices() <= stop_fraction: infected_nodes_until_t = copy(infected) time += 1 for i in infected_nodes_until_t: for j in g.vertex(i).all_neighbours(): j = int(j) if j not in infected and random.random() <= p: infected.add(j) infection_times[j] = time edges.append((i, j)) tree = Graph(directed=True) for _ in range(g.num_vertices()): tree.add_vertex() for u, v in edges: tree.add_edge(u, v) return source, infection_times, tree
def random_walk_sample(graph: Graph, num_vertices: int, prev_state: RandomWalkSampleState, args: argparse.Namespace) -> SampleState: """Random walk sampling. Start from a vertex and walk along the edges, sampling every vertex that is a part of the walk. With a probability of 0.15, restart the walk from the original vertex. To prevent getting stuck, after making N attempts, where N = the target number of vertices in the sample, change the starting vertex to a random vertex. Parameters ---------- graph : Graph the filtered graph from which to sample vertices num_vertices : int number of vertices in the unfiltered graph prev_state : RandomWalkSampleState the state of the previous sample in the stack. If there is no previous sample, an empty SampleState object should be passed in here. args : argparse.Namespace the command-line arguments provided by the user Returns ------- state : SampleState the sample state with the sampled vertex ids (Note: these ids correspond to the filtered graph, and have to be mapped back to the unfiltered graph) """ state = RandomWalkSampleState(graph.num_vertices(), prev_state) sample_num = int( (num_vertices * (args.sample_size / 100)) / args.sample_iterations) sample_num += len(state.sample_idx) num_tries = 0 start = np.random.randint(sample_num) # start with a random vertex vertex = start while len(state.index_set) == 0 or len( state.index_set) % sample_num != 0: num_tries += 1 if not state.sampled_marker[vertex]: state.index_set.append(vertex) state.sampled_marker[vertex] = True if num_tries % sample_num == 0: # If the number of tries is large, restart from new random vertex start = np.random.randint(sample_num) vertex = start num_tries = 0 elif np.random.random( ) < 0.15: # With a probability of 0.15, restart at original node vertex = start elif len( graph.get_out_neighbors(vertex) ) > 0: # If the vertex has out neighbors, go to one of them vertex = np.random.choice(graph.get_out_neighbors(vertex)) else: # Otherwise, restart from the original vertex if len( graph.get_out_neighbors(start) ) == 0: # if original vertex has no out neighbors, change it start = np.random.randint(sample_num) vertex = start state.sample_idx = np.asarray(state.index_set) return state
def golang_graph_to_graphtool_graph(edge_data): g = golang_graph_to_graph(edge_data) G = Graph(directed=False) handles = [G.add_vertex() for _ in g.nodes()] for u, v in g.edges(): G.add_edge(handles[u], handles[v]) return G
def __init__(self, protocol): self._protocol = protocol self._graph = Graph(directed=True) self._vertices = {} self._leaves = set() self._speed = Speed.ZERO self._construct_tree()
def __init__(self, name, edges, object_ids, weights, hidden_graph=None): """ Params: name (str): unique string to name this dataset (for pickling and unpickling) edges (numpy.ndarray): numpy array of shape [num_edges, 2] containing the indices of nodes in all edges objects (List[str]): string object ids for all nodes weights (numpy.ndarray): numpy array of shape [num_edges] containing edge weights hidden_graph (GraphDataset): Graph data that should be excluded but not considered as negative edges. (i.e. train edges should not be in eval dataset but they shouldn't be counted as negatives either) """ self.name = name self.edges = edges self.object_ids = np.asarray(object_ids) self.weights = weights self.hidden_graph = hidden_graph self.graph = Graph(directed=False) self.graph.add_vertex(len(object_ids)) edge_weights = [[edge[0], edge[1], weight] for edge, weight in zip(self.edges, self.weights)] self.weight_property = self.graph.new_edge_property("float") eprops = [self.weight_property] self.graph.add_edge_list(edge_weights, eprops=eprops) self.manifold_nns = None
def init2(self, emacs_var_dict): self.emacs_var_dict = emacs_var_dict self.link_str = self.emacs_var_dict['links'] self.g = Graph() self.label_ep = self.g.new_edge_property("string") self.links = self.link_str.split(";") link_tpls = [i.split(" -- ") for i in self.links] dumper([str(i) for i in link_tpls]) self.g_id = self.g.add_edge_list(link_tpls, hashed=True, string_vals=True, eprops=[self.label_ep]) self.adj = np.array([(int(i.source()), int(i.target())) for i in self.g.edges()]) self.node_names = [self.g_id[i] for i in self.g.vertices()] self.vd = {} for i in self.g.vertices(): self.vd[self.g_id[i]] = int(i) # self.pos_vp = sfdp_layout(self.g, K=0.5) self.pos_vp = fruchterman_reingold_layout(self.g) self.base_pos_ar = self.pos_vp.get_2d_array((0, 1)).T self.qt_coords = self.nolz_pos_ar(self.base_pos_ar) dumper([str(self.qt_coords)])
def split_gt(): g = GTGraph() g.add_edge_list(adjacency) component_labels = label_components(g, directed=False)[0].a components = group(component_labels) result = mesh.submesh(components, only_watertight=only_watertight) return result
def spc_querying_naive(g : graph_tool.Graph, paths, y, trust_own_predictions=True, weight=None, closed_interval=False): ''' :param g: :param paths: list of paths :param y: ground truth :param weight: :return: ''' known_labels = -np.ones(g.num_vertices())*np.inf budget = np.zeros(g.num_vertices()) for i, path in enumerate(paths): if not trust_own_predictions or known_labels[path[0]] == -np.inf: budget[i] += 1 known_labels[path[0]] = y[path[0]] if not trust_own_predictions or known_labels[path[-1]] == -np.inf: budget[i] += 1 known_labels[path[-1]] = y[path[-1]] if known_labels[path[0]] == known_labels[path[-1]]: known_labels[path] = known_labels[path[0]] else: label_budget, new_labels = binarySearch(y[path], 0, len(path)-1, known_labels[path[0]], known_labels[path]) known_labels[path] = new_labels budget[i] += label_budget if closed_interval: p =closure.compute_hull(g, np.where(known_labels==np.unique(y)[0])[0], weight, compute_closure=False) n = closure.compute_hull(g, np.where(known_labels==np.unique(y)[1])[0], weight, compute_closure=False) known_labels[p] = np.unique(y)[0] known_labels[n] = np.unique(y)[1] return known_labels, budget
def build_graph_from_edges(edges): """returns Graph (a new one) """ g = Graph() for u, v in edges: g.add_edge(u, v) return g
def __init__(self): self.g = Graph() self.dvertex_index = dict() self.vertex_label = self.g.new_vertex_property("string") self.g.vertex_properties["label"] = self.vertex_label self.edge_weight = self.g.new_edge_property("int") self.g.edge_properties["weight"] = self.edge_weight
def save(self, file_name, fmt="auto"): """ overload Graph.save to make output dotfiles pretty. This is entirely cosmetic. """ u = self # add some properties to prettify dot output if fmt is "dot" or fmt is "auto" and file_name.endswith(".dot"): u = GraphView(self) # add shape property according to vertex owners shape = u.new_vertex_property("string") for v in u.vertices(): if u.vp.owner[v] == 1: shape[v] = "box" else: shape[v] = "diamond" u.vp.shape = shape # add label property according to priorities #u.vertex_properties['label'] = u.vertex_properties['priority'] label = u.new_vertex_property("string") for v in u.vertices(): prio = u.vertex_properties['priority'][v] name = u.vertex_index[v] label[v] = "%d (%d)" % (name, prio) u.vp.label = label Graph.save(u, file_name, fmt)
def compute_shadow(g: gt.Graph, A, B, weight=None, dist_map=None, comps=None, hist=None, B_hulls=None): A_closed = compute_hull(g, A, weight, dist_map, comps, hist) #B_closed = compute_hull(g, B, weight, dist_map, comps, hist) B_closed = np.zeros(g.num_vertices(), dtype=np.bool) B_closed[B] = True shadow = A_closed.copy() for x in range(g.num_vertices()): if A_closed[x] or B_closed[x]: continue if B_hulls is None: if np.any( compute_hull(g, np.append(B, x), weight, dist_map, comps, hist, True) & A_closed): shadow[x] = True else: if np.any(B_hulls[x] & A_closed): shadow[x] = True return shadow
def uniform_random_sample(graph: Graph, num_vertices: int, prev_state: UniformRandomSampleState, args: argparse.Namespace) -> SampleState: """Uniform random sampling. All vertices are selected with the same probability. Parameters ---------- graph : Graph the filtered graph from which to sample vertices num_vertices : int number of vertices in the unfiltered graph prev_state : UniformRandomSampleState the state of the previous sample in the stack. If there is no previous sample, an empty SampleState object should be passed in here. args : argparse.Namespace the command-line arguments provided by the user Returns ------- state : SampleState the sample state with the sampled vertex ids (Note: these ids correspond to the filtered graph, and have to be mapped back to the unfiltered graph) """ state = UniformRandomSampleState(graph.num_vertices(), prev_state) sample_num = int( (num_vertices * (args.sample_size / 100)) / args.sample_iterations) choices = np.setdiff1d(np.asarray(range(graph.num_vertices())), state.sample_idx) state.sample_idx = np.concatenate( (state.sample_idx, np.random.choice(choices, sample_num, replace=False)), axis=None) return state
def build_closure(g, terminals, debug=False, verbose=False): terminals = list(terminals) # build closure gc = Graph(directed=False) gc.add_vertex(g.num_vertices()) edges_with_weight = set() r2pred = {} for r in terminals: if debug: print('root {}'.format(r)) vis = init_visitor(g, r) pbfs_search(g, source=r, terminals=terminals, visitor=vis) new_edges = set(get_edges(vis.dist, r, terminals)) if debug: print('new edges {}'.format(new_edges)) edges_with_weight |= new_edges r2pred[r] = vis.pred for u, v, c in edges_with_weight: gc.add_edge(u, v) eweight = gc.new_edge_property('int') weights = np.array([c for _, _, c in edges_with_weight]) eweight.set_2d_array(weights) vfilt = gc.new_vertex_property('bool') vfilt.a = False for v in terminals: vfilt[v] = True gc.set_vertex_filter(vfilt) return gc, eweight, r2pred
def load(self, data): data = [x.strip() for x in data] # Create a new undirectedgraph self.graph = Graph(directed=False) # Label everything so I'm not going back and forth between hashes v_name = self.graph.new_vertex_property('string') self.graph.vertex_properties["name"] = v_name self.planets = dict() # Create all the vertexes first, so that creating the edges (orbits) # is easier for item in data: # Add vertexes, as needed src, dest = item.split(")") if src not in self.planets: v_src = self.graph.add_vertex() v_name[v_src] = src self.planets[src] = v_src if dest not in self.planets: v_dest = self.graph.add_vertex() v_name[v_dest] = dest self.planets[dest] = v_dest # Add edge self.graph.add_edge(self.planets[src], self.planets[dest])
def spc_querying_naive_multiclass(g : graph_tool.Graph, paths, y, trust_own_predictions=True, weight=None): ''' :param g: :param paths: list of paths :param y: ground truth :param weight: :return: ''' known_labels = -np.ones(g.num_vertices())*np.inf budget = np.zeros(g.num_vertices()) for i, path in enumerate(paths): if not trust_own_predictions or known_labels[path[0]] == -np.inf: budget[i] += 1 known_labels[path[0]] = y[path[0]] if not trust_own_predictions or known_labels[path[-1]] == -np.inf: budget[i] += 1 known_labels[path[-1]] = y[path[-1]] if known_labels[path[0]] == known_labels[path[-1]]: known_labels[path] = known_labels[path[0]] else: mid, label_budget = binarySearch(y[path], 0, len(path)-1, known_labels[path[0]], known_labels[path]) budget[i] += label_budget known_labels[path[0:mid+1]] = known_labels[path[0]] known_labels[path[mid+1:]] = known_labels[path[-1]] return known_labels, budget
def diagram_to_graph(diagram): '''Convert specified chord diagram to the equivalent graph. Construct the graph with a vertex for each diagram chord, and an edge from the vertex for each node to the next greater node as though manually drawing the planar diagram from the chord diagram, such that edges go from nodes (1 -> 2), (2 -> 3),..., (n-1 -> n), (n -> 1). Arguments: diagram: A list of chords, where each chord is a node tuple. Returns: Returns the graph corresponding to the input diagram. Raises: None ''' graph = Graph() # Create a vertex for each chord - same vertex stored for each node of chord vertex_by_node = {} for chord in diagram: vertex = graph.add_vertex() vertex_by_node[chord[0]] = vertex vertex_by_node[chord[1]] = vertex # As though drawing the planar diagram from the chord diagram by hand, # add an edge from 1st node to 2nd, 2nd to 3rd, and so on, until closing # the loop back to the 1st node. nodes = vertex_by_node.keys() n_nodes = len(nodes) for i in range(0, len(nodes)): j = (i + 1) % n_nodes graph.add_edge(vertex_by_node[nodes[i]], vertex_by_node[nodes[j]]) return graph
def find_cycles2(args, wires): # implemented with graph-tools g = Graph() t_a = datetime.now() lst = [] for i in range(0, len(wires)): lst.append(g.add_vertex()) for i in range(0, len(wires)): if wires[i].type != "inp": for j in range(len(wires[i].operands)): g.add_edge(lst[wires[i].operands[j].index], lst[wires[i].index]) cycles = [] for c in all_circuits(g): if len(cycles) > 100000: logging.info("number of cycles is limited.") break cycles.append(c.tolist()) t_b = datetime.now() logging.info("time of finding cycles: " + diff(t_a, t_b)) logging.info("there are" + str(len(cycles)) + "cycles") if args.p: logging.info("list of cycles:") for cycle in cycles: tmp = "" for i in range(len(cycle)): tmp += wires[cycle[i]].name + " " logging.info(tmp) print() return cycles
def s2(g: gt.Graph, weight_prop: gt.EdgePropertyMap, labels, budget=20): L = set() n = g.num_vertices() known_labels = -np.ones(n) * np.inf W = gt.topology.shortest_distance(g, weights=weight_prop).get_2d_array( range(n)) #original distance map x = np.random.choice(list(set(range(n)).difference(L))) while budget > 0: known_labels[x] = labels[x] L.add(x) if len(L) == n: break budget -= 1 to_remove = [] for e in g.get_out_edges(x): if known_labels[e[1]] >= 0 and known_labels[ e[1]] != known_labels[x]: to_remove.append(e) for e in to_remove: g.remove_edge(g.edge(e[0], e[1])) #mid_point = mssp(g, weight_prop, L, known_labels) if False: x = int(mid_point) else: x = np.random.choice(list(set(range(n)).difference(L))) return label_propagation(W, known_labels, np.unique(labels))
def save_degree_distribution(args: argparse.Namespace, graph: Graph): """Saves the in and out degrees of all vertices in the graph. Parameters ---------- args : argparse.Namespace the command-line arguments provided graph : Graph the graph object """ write_header = False if not os.path.isfile(args.csv + ".csv"): directory = os.path.dirname(args.csv + ".csv") if directory not in [".", ""]: os.makedirs(directory, exist_ok=True) write_header = True num_vertices = [i for i in range(graph.num_vertices())] out_degrees = [v.out_degree() for v in graph.vertices()] in_degrees = [v.in_degree() for v in graph.vertices()] with open(args.csv + ".csv", "a") as details_file: writer = csv.writer(details_file) if write_header: writer.writerow(["Num Vertices", "In/Out", "Degree"]) for degree in out_degrees: writer.writerow([num_vertices, "Out", degree]) for degree in in_degrees: writer.writerow([num_vertices, "In", degree]) exit()
def __init__( self, seed_str, name, file_extension='gml', vertex_schema={ 'gene': 'vector<bool>', 'gen': 'int', 'fitness': 'vector<long>', 'score': 'long' }, edge_schema={ 'label': 'string', 'gen': 'int' }): self.seed = seed_str self.name = name self.file_extension = file_extension self.graph = Graph() # Create graph properties self.graph.gp.labels = self.graph.new_gp('vector<string>') self.graph.gp.labels = [seed_str] self.graph.gp.name = self.graph.new_gp('string') self.graph.gp.name = self.name # Create vertex properties for key in vertex_schema: self.graph.vp[key] = self.graph.new_vp(vertex_schema[key]) # Create edge properties for key in edge_schema: self.graph.ep[key] = self.graph.new_ep(edge_schema[key])
def __init__(self): """ Constructor of the abstract SegmentationGraph object. Returns: None """ self.graph = Graph(directed=False) """graph_tool.Graph: a graph object storing the segmentation graph topology, geometry and properties (initially empty). """ # Add "internal property maps" to the graph. # vertex property for storing the xyz coordinates of the corresponding # vertex: self.graph.vp.xyz = self.graph.new_vertex_property("vector<float>") # edge property for storing the distance between the connected vertices: self.graph.ep.distance = self.graph.new_edge_property("float") self.coordinates_to_vertex_index = {} """dict: a dictionary mapping the vertex coordinates (x, y, z) to the vertex index. """ self.coordinates_pair_connected = set() """set: a set storing pairs of vertex coordinates that are
def spc_querying_experiments(g: gt.Graph, weight_prop: gt.EdgePropertyMap, spc, labels): print("correct labels: ", labels) print("================naive=================") a, b = spc_querying_naive(g, spc, labels) print("pred: ", a) print("queries: ", b, np.sum(b)) print("correct: ", np.sum(a == labels), np.sum(a == labels) / g.num_vertices()) print("================interval================") a, b = spc_querying_with_closure(g, spc, weight_prop, labels, False) print("pred: ", a) print("queries: ", b, np.sum(b)) print("correct: ", np.sum(a == labels), np.sum(a == labels) / g.num_vertices()) print("================closure================") #a, b = spc_querying_with_closure(g, spc, weight_prop, labels) #print("pred: ", a) #print("queries: ", b, np.sum(b)) #print("correct: ", np.sum(a == labels), np.sum(a == labels) / g.num_vertices()) #print("================s2================") new_labels = np.zeros(g.num_vertices()) new_labels[labels == np.unique(labels)[1]] = 1 s2_labelling = shortest_shortest_path_querying.s2(g, weight_prop, labels, int(np.sum(b))) print("accuracy s2 after label_prop: ", np.sum(s2_labelling == new_labels) / g.num_vertices())
def edges2graph(g, edges): tree = Graph(directed=True) for _ in range(g.num_vertices()): tree.add_vertex() for u, v in edges: tree.add_edge(int(u), int(v)) return filter_nodes_by_edges(tree, edges)
def avg_shortest_path(g: GT.Graph): if g.num_vertices() < 10_000: d = GT.topology.shortest_distance( g) #NB: allocate memory, isn't an iterator! return sum((max(_d, key=lambda x: x if x != INF_INT else -1) for _d in d)) / (g.num_vertices()) else: return None #TODO
def is_planar(self): """ See the following library: https://graph-tool.skewed.de/static/doc/topology.html """ edges = self.obtain_edge_list() graph = Graph().add_vertex(len(self.adj_matrix)).add_edge_list(edges) return graph.is_planar()
def __init__(self, mapfile): self._mapfile = mapfile self.DIRECTION_index = 6 self.PATHCLASS_index = 20 self.g = Graph() self.g.edge_properties["length"] = self.g.new_edge_property("double") self.g.edge_properties["level"] = self.g.new_edge_property("int") self.g.vertex_properties["pos"] = self.g.new_vertex_property("vector<double>") self.cross_pos_index = {}
class Network: def __init__(self): self.g = Graph(directed=True) self.player_id_to_vertex = {} self.pairs = {} self.g.vertex_properties['player_id'] = self.g.new_vertex_property("string") self.g.vertex_properties['player_coords'] = self.g.new_vertex_property("vector<float>")
def components_graphtool(): g = GTGraph() # make sure all the nodes are in the graph if min_len <= 1: g.add_vertex(node_count) g.add_edge_list(edges) component_labels = label_components(g, directed=False)[0].a components = grouping.group(component_labels, min_len=min_len) return components
def build_closure(g, terminals, p=None, debug=False, verbose=False): """build the transitive closure on terminals""" def get_edges(dist, root, terminals): """get adjacent edges to root with weight""" return {(root, t, dist[t]) for t in terminals if dist[t] != -1 and t != root} terminals = list(terminals) gc = Graph(directed=False) gc.add_vertex(g.num_vertices()) edges_with_weight = set() r2pred = {} # root to predecessor map (from bfs) # shortest path to all other nodes for r in terminals: if debug: print('root {}'.format(r)) targets = list(set(terminals) - {r}) dist_map, pred_map = shortest_distance(g, source=r, target=targets, weights=p, pred_map=True) dist_map = dict(zip(targets, dist_map)) # print(dist_map) # print(pred_map) new_edges = get_edges(dist_map, r, targets) # if p is None: # vis = init_visitor(g, r) # bfs_search(g, source=r, visitor=vis) # new_edges = set(get_edges(vis.dist, r, terminals)) # else: # print('weighted graph') if debug: print('new edges {}'.format(new_edges)) edges_with_weight |= new_edges # r2pred[r] = vis.pred r2pred[r] = pred_map for u, v, c in edges_with_weight: gc.add_edge(u, v) # edge weights eweight = gc.new_edge_property('int') weights = np.array([c for _, _, c in edges_with_weight]) eweight.set_2d_array(weights) vfilt = gc.new_vertex_property('bool') vfilt.a = False for v in terminals: vfilt[v] = True gc.set_vertex_filter(vfilt) return gc, eweight, r2pred
def copy_edge_attributes(g_to: gt.Graph, edge_to: gt.Edge, g_from: gt.Graph, edge_from: gt.Edge): for p_type, ep_name in g_from.ep.properties: if p_type != 'e': continue old_ep = g_from.ep[ep_name] if ep_name not in g_to.ep: g_to.ep[ep_name] = g_to.new_ep(old_ep.value_type()) new_ep = g_to.ep[ep_name] new_ep[edge_to] = deepcopy(old_ep[edge_from])
def copy_node_attributes(g_to: gt.Graph, node_to: gt.Vertex, g_from: gt.Graph, node_from: gt.Vertex): for p_type, vp_name in g_from.vp.properties: if p_type != 'v': continue old_vp = g_from.vp[vp_name] if vp_name not in g_to.vp: g_to.vp[vp_name] = g_to.new_vp(old_vp.value_type()) new_vp = g_to.vp[vp_name] new_vp[node_to] = deepcopy(old_vp[node_from])
def build_minimum_tree(g, root, terminals, edges, directed=True): """remove redundant edges from `edges` so that root can reach each node in terminals """ # build the tree t = Graph(directed=directed) for _ in range(g.num_vertices()): t.add_vertex() for (u, v) in edges: t.add_edge(u, v) # mask out redundant edges vis = init_visitor(t, root) pbfs_search(t, source=root, terminals=list(terminals), visitor=vis) minimum_edges = {e for u in terminals for e in extract_edges_from_pred(t, root, u, vis.pred)} # print(minimum_edges) efilt = t.new_edge_property('bool') efilt.a = False for u, v in minimum_edges: efilt[u, v] = True t.set_edge_filter(efilt) return filter_nodes_by_edges(t, minimum_edges)
class RoadMap(object): def __init__(self, mapfile): self._mapfile = mapfile self.DIRECTION_index = 6 self.PATHCLASS_index = 20 self.g = Graph() self.g.edge_properties["length"] = self.g.new_edge_property("double") self.g.edge_properties["level"] = self.g.new_edge_property("int") self.g.vertex_properties["pos"] = self.g.new_vertex_property("vector<double>") self.cross_pos_index = {} def load(self): if self._mapfile[-3:] != 'shp': self.g = load_graph(self._mapfile) return try: sf = shapefile.Reader(self._mapfile) except Exception as e: print(str(e)) return False roads_records = sf.shapeRecords() # 获取路段信息' for road_record in roads_records: cross_s_index = self.add_cross(road_record.shape.points[0]) cross_e_index = self.add_cross(road_record.shape.points[-1]) self.add_road_edge(cross_s_index, cross_e_index, road_record) if int(road_record.record[self.DIRECTION_index]) == 0: # 若路段是双向车道 self.add_road_edge(cross_e_index, cross_s_index, road_record) return True def has_edge(self, s_vertex, e_vertex): if self.g.num_vertices() >= max(s_vertex, e_vertex): return self.g.edge(s_vertex, e_vertex) else: return None def add_cross(self, cross_pos): if cross_pos in self.cross_pos_index: return self.cross_pos_index.get(cross_pos) else: cross_index = self.g.add_vertex() self.g.vp.pos[cross_index] = cross_pos self.cross_pos_index[cross_pos] = cross_index return cross_index def add_road_edge(self, s_vertex, e_vertex, road): if self.has_edge(s_vertex, e_vertex): return self.g.edge(s_vertex, e_vertex) else: edge = self.g.add_edge(s_vertex, e_vertex) self.g.ep.level[edge] = int(road.record[self.PATHCLASS_index]) self.g.ep.length[edge] = self.road_length(road) return edge @staticmethod def road_length(road): length = 0 for sub_road in zip(road.shape.points[:-1], road.shape.points[1:]): length += distance.euclidean(sub_road[0], sub_road[1]) return length
def to_directed(g, t, root): new_t = Graph(directed=True) all_edges = set() leaves = [v for v in t.vertices() if (v.out_degree() + v.in_degree()) == 1 and t != root] for target in leaves: path = shortest_path(t, source=root, target=target)[0] edges = set(zip(path[:-1], path[1:])) all_edges |= edges for _ in range(g.num_vertices()): new_t.add_vertex() for u, v in all_edges: new_t.add_edge(int(u), int(v)) return new_t
def _parse_data(self): """ extract interal points(degree>2) and endpoints(degree=1) extract segments """ if self.verts == None or self.edges == None: print 'please first call read_skel_file function' else: self.verts = np.array(self.verts, dtype=np.float) self.edges = np.array(self.edges, dtype=np.int) terminal_index = [] junction_index = [] self.skel_graph = Graph(directed=False) self.skel_graph.add_vertex(len(self.verts)) for edge in self.edges : self.skel_graph.add_edge(self.skel_graph.vertex(edge[0]), self.skel_graph.vertex(edge[1])) for v in self.skel_graph.vertices(): if v.out_degree() == 2 : continue elif v.out_degree() == 1 : terminal_index.append(int(v)) elif v.out_degree() > 2 : junction_index.append(int(v)) self.terminal = self.verts[terminal_index] self.junction = self.verts[junction_index] self.terminal_index = terminal_index self.junction_index = junction_index self.feature_node_index = junction_index + terminal_index self.feature_node = self.verts[self.feature_node_index] """
def facets_gt(mesh): ''' Returns lists of facets of a mesh. Facets are defined as groups of faces which are both adjacent and parallel facets returned reference indices in mesh.faces If return_area is True, both the list of facets and their area are returned. ''' face_idx = mesh.face_adjacency() normal_pairs = mesh.face_normals[[face_idx]] parallel = np.abs(np.sum(normal_pairs[:,0,:] * normal_pairs[:,1,:], axis=1) - 1) < TOL_PLANAR graph_parallel = GTGraph() graph_parallel.add_edge_list(face_idx[parallel]) connected = label_components(graph_parallel, directed=False)[0].a facets_idx = group(connected, min_length=2) return facets_idx
def load_graph(infile): inmatrix = np.loadtxt(infile, dtype=np.dtype('uint32'), delimiter=" ") numv = np.amax(inmatrix[:,0:2]) #print numv, inmatrix[:,0:2] g = Graph(directed=False) edge_weights = g.new_edge_property("double") g.edge_properties["weights"] = edge_weights vlist = list(g.add_vertex(numv)) for i in inmatrix: edge = g.add_edge(vlist[i[0]-1], vlist[i[1]-1]) # need to convert from 1-based index in file to 0-based edge_weights[edge] = i[2] remove_parallel_edges(g) return g
def test_sredni_wspolczynnik_klasteryzacji_na_sztywno_graf_pelny(self): # self.assertEqual(7. / 15, self.stat.sredni_wspolczynnik_klasteryzacji_moj()) # print self.stat.sredni_wspolczynnik_klasteryzacji_moj() g = Graph(directed=False) v0 = g.add_vertex() v1 = g.add_vertex() v2 = g.add_vertex() v3 = g.add_vertex() g.add_edge(v0, v1) g.add_edge(v0, v2) g.add_edge(v0, v3) g.add_edge(v1, v2) g.add_edge(v1, v3) g.add_edge(v2, v3) lc = local_clustering(g, undirected=True) self.assertEqual(1.0, vertex_average(g, lc)[0])
def split_gt(mesh, check_watertight=True, only_count=False): g = GTGraph() g.add_edge_list(mesh.face_adjacency()) component_labels = label_components(g, directed=False)[0].a if check_watertight: degree = g.degree_property_map('total').a meshes = deque() components = group(component_labels) if only_count: return len(components) for i, current in enumerate(components): fill_holes = False if check_watertight: degree_3 = degree[current] == 3 degree_2 = degree[current] == 2 if not degree_3.all(): if np.logical_or(degree_3, degree_2).all(): fill_holes = True else: continue # these faces have the original vertex indices faces_original = mesh.faces[current] face_normals = mesh.face_normals[current] # we find the unique vertex indices, so we can reindex from zero unique_vert = np.unique(faces_original) vertices = mesh.vertices[unique_vert] replacement = np.zeros(unique_vert.max()+1, dtype=np.int) replacement[unique_vert] = np.arange(len(unique_vert)) faces = replacement[faces_original] new_mesh = mesh.__class__(faces = faces, face_normals = face_normals, vertices = vertices) new_meta = deepcopy(mesh.metadata) if 'name' in new_meta: new_meta['name'] = new_meta['name'] + '_' + str(i) new_mesh.metadata.update(new_meta) if fill_holes: try: new_mesh.fill_holes(raise_watertight=True) except MeshError: continue meshes.append(new_mesh) return list(meshes)
def __init__(self, number_of_vertices, graph_type): super().__init__(number_of_vertices, graph_type) # Graph tool creates directed multigraph by default. self._graph = Graph() self._graph.add_vertex(number_of_vertices) self._graph.vertex_properties["cell"] = self._graph.new_vertex_property( "object", number_of_vertices * [BoardCell()] ) self._graph.edge_properties["direction" ] = self._graph.new_edge_property("object") self._graph.edge_properties["weight" ] = self._graph.new_edge_property("int")
def components_graphtool(): """ Find connected components using graphtool """ g = GTGraph() # make sure all the nodes are in the graph g.add_vertex(node_count) # add the edge list g.add_edge_list(edges) labels = np.array(label_components(g, directed=False)[0].a, dtype=np.int64)[:node_count] # we have to remove results that contain nodes outside # of the specified node set and reindex contained = np.zeros(node_count, dtype=np.bool) contained[nodes] = True index = np.arange(node_count, dtype=np.int64)[contained] components = grouping.group(labels[contained], min_len=min_len) components = np.array([index[c] for c in components]) return components
def user_network(storage, track, session): g = Graph() users = defaultdict(g.add_vertex) g.graph_properties["track"] = g.new_graph_property("string", track) g.graph_properties["session"] = g.new_graph_property("string", session) g.edge_properties["created_at"] = g.new_edge_property("int64_t") for tweet in storage: tweeter_id = tweet["user__id_str"] origin_id = tweet["retweeted_status__user__id_str"] created_at = arrow.get(tweet["created_at"], DATE_FORMAT).timestamp if origin_id: edge = g.add_edge(users[tweeter_id], users[origin_id]) g.edge_properties["created_at"][edge] = created_at return g
def graph_from_dataframes(vertex_df, edge_df): '''Re-creates a Graph object with PropertyMaps taken from the vertex_df and edge_df DataFrames Paramters: ========== verex_df: a DataFrame with an index named 'vertex_index' edge_df: a DataFrame with a multi-index named ('source', 'target') Returns: ======== graph: a grah-tool Graph with PropertyMaps copied from the columns of the input DataFrames ''' graph = Graph(directed=True) vertex_index = vertex_df.index.get_level_values(level='vertex_index') vertices = graph.add_vertex(n=vertex_index.shape[0]) for col in vertex_df.columns: in_type = vertex_df[col].dtype.name try: dtype = ALIASES[in_type] except KeyError: log.info('Data type {} not supported'.format(in_type)) continue prop = graph.new_vertex_property(dtype) prop.fa = vertex_df[col] graph.vertex_properties[col] = prop src = edge_df.index.names.index('source') trgt = edge_df.index.names.index('target') ### TODO: use the list edge creation for tup in edge_df.index: source, target = tup[src], tup[trgt] try: edge = graph.add_edge(source, target) except ValueError: log.info('Invalid vertex in (source: {}, target: {})'.format(source, target)) for col in edge_df.columns: in_type = edge_df[col].dtype.name try: dtype = ALIASES[in_type] except KeyError: log.info('Data type {} not supported'.format(in_type)) continue prop = graph.new_edge_property(dtype) prop.fa = edge_df[col] graph.edge_properties[col] = prop return graph
def create_graph(cls, edges, is_directed=True): """Create a graph-tool type graph from a list of edges""" g = Graph() g.set_directed(is_directed) label2index = dict() label = g.new_vertex_property('int32_t') g.vertex_properties['label'] = label for v1_label, v2_label in edges: cls.add_vertex(v1_label, label2index, g) cls.add_vertex(v2_label, label2index, g) v1, v2 = label2index[v1_label], label2index[v2_label] g.add_edge(v1, v2) return g, label2index
def build_closure(g, terminals, debug=False, verbose=False): terminals = list(terminals) # build closure gc = Graph(directed=False) for _ in range(g.num_vertices()): gc.add_vertex() edges_with_weight = set() r2pred = {} for r in terminals: if debug: print('root {}'.format(r)) vis = init_visitor(g, r) pbfs_search(g, source=r, terminals=terminals, visitor=vis) new_edges = set(get_edges(vis.dist, r, terminals)) if debug: print('new edges {}'.format(new_edges)) edges_with_weight |= new_edges r2pred[r] = vis.pred for u, v, c in edges_with_weight: gc.add_edge(u, v) eweight = gc.new_edge_property('int') weights = np.array([c for _, _, c in edges_with_weight]) eweight.set_2d_array(weights) vfilt = gc.new_vertex_property('bool') vfilt.a = False for v in terminals: vfilt[v] = True gc.set_vertex_filter(vfilt) return gc, eweight, r2pred
def __init__(self, skel1, skel2, centricity=.5, length=.5, distorted=20.): if skel1 is not None and skel2 is not None : self.skel1 = skel1 self.skel2 = skel2 self.centricity_threhold = centricity self.length_threhold = length self.distorted_threhold = distorted self.skel1.calc_skel_properties() self.skel2.calc_skel_properties() # use index instead of real value skel1_index = np.arange(len(self.skel1.feature_node_index)) skel2_index = np.arange(len(self.skel2.feature_node_index)) junc1_num = len(skel1.junction_index) junc2_num = len(skel2.junction_index) #print 'skel1 normalized_verts\n', skel1.normalized_feature_verts #print 'skel2 normalized_verts\n', skel2.normalized_feature_verts #candidate matched pairs junction_pairs = [] junc_term_pairs = [] terminal_pairs = [] for i, j in itertools.product(skel1_index, skel2_index): if self.test_node_centricity(c1=i, c2=j): if i < junc1_num and j < junc2_num: # only junction nodes junction_pairs.append([i,j]) elif i >= junc1_num and j >= junc2_num: # only terminal nodes terminal_pairs.append([i,j]) else: junc_term_pairs.append([i,j]) self.junction_pairs = np.array(junction_pairs) self.terminal_pairs = np.array(terminal_pairs) self.junc_term_pairs = np.array(junc_term_pairs) #self.all_junc_pairs = np.vstack((self.junction_pairs, self.junc_term_pairs)) self.vote_tree = Graph(directed=False) self.node_pair = self.vote_tree.new_vertex_property("vector<short>") self._construct_voting_tree() else: print 'need input two skeleton to match'
def __init__ (self, dicProp={"Name": "Graph", "Type": "None", "Weighted": False}, graph=None): ''' init from properties ''' self.dicProperties = deepcopy(dicProp) self.dicGetProp = { "Reciprocity": get_reciprocity, "Clustering": get_clustering, "Assortativity": get_assortativity, "Diameter": get_diameter, "SCC": get_num_scc, #"Spectral radius": get_spectral_radius, "WCC": get_num_wcc, "InhibFrac": get_inhib_frac } self.dicGenGraph = { "Erdos-Renyi": gen_er, "Free-scale": gen_fs, "EDR": gen_edr } # create a graph if graph != None: # use the one furnished self.__graph = graph self.update_prop() self.bPropToDate = True elif dicProp["Type"] == "None": # create an empty graph self.__graph = Graph() self.bPropToDate = False else: # generate a graph of the requested type self.__graph = self.dicGenGraph[dicProp["Type"]](self.dicProperties) self.update_prop() self.set_name() self.bPropToDate = True
def graph_from_dataframes(vertex_df, edge_df): '''Re-creates a Graph object with PropertyMaps taken from the vertex_df and edge_df DataFrames Paramters: ========== verex_df: a DataFrame with an index named 'vertex_index' edge_df: a DataFrame with a multi-index named ('source', 'target') Returns: ======== graph: a grah-tool Graph with PropertyMaps copied from the columns of the input DataFrames ''' graph = Graph(directed=True) vertex_index = vertex_df.index.get_level_values(level='vertex_index') vertices = graph.add_vertex(n=vertex_index.shape[0]) for col in vertex_df.columns: dtype = ALIASES[vertex_df[col].dtype.name] prop = graph.new_vertex_property(dtype) prop.a = vertex_df[col] graph.vertex_properties[col] = prop src = edge_df.index.names.index('source') trgt = edge_df.index.names.index('target') ### TODO: use the list edge creation for tup in edge_df.index: source, target = tup[src], tup[trgt] edge = graph.add_edge(source, target) for col in edge_df.columns: dtype = ALIASES[edge_df[col].dtype.name] prop = graph.new_edge_property(dtype) prop.a = edge_df[col] graph.edge_properties[col] = prop return graph
def parse_graph_from_string(self, graphML_string): dom = minidom.parseString(graphML_string) root = dom.getElementsByTagName("graphml")[0] graph = root.getElementsByTagName("graph")[0] name = graph.getAttribute('id') g = Graph(directed=False) vpos=g.new_vertex_property("vector<double>") for node in graph.getElementsByTagName("node"): id=node.getAttribute('id') n = g.add_vertex() g.vertex_index[id] #right now only the positions are available for attr in node.getElementsByTagName("data"): if attr.firstChild: key=attr.getAttribute("key") #n[key] = attr.firstChild.data if(key=="x"): x=attr.firstChild.data elif(key=="y"): y=attr.firstChild.data vpos[id]=(x,y) g.vertex_properties["pos"]=vpos #have to workaround the directed graph written by the server for edge in graph.getElementsByTagName("edge"): source = edge.getAttribute('source') dest = edge.getAttribute('target') edge=g.edge(dest,source) if(edge==None): e = g.add_edge(source, dest) return g
def _filter_short_branch(self, filter=False, short=30): """ filter out very short branches: do this maybe not right for some models, for models with flat part, it is right I will test how this effect the final matching results need to delete nodes, switch with the last one then delete last """ if filter == False: self.verts = self.verts_init self.edges = self.edges_init else: init_graph = Graph(directed=False) init_graph.add_vertex(len(self.verts_init)) for edge in self.edges_init: init_graph.add_edge(init_graph.vertex(edge[0]), init_graph.vertex(edge[1])) terminal_node = [] for v in init_graph.vertices(): if v.out_degree() == 1: terminal_node.append(v) visitor = DepthVisitor() short_nodes = [] for tn in terminal_node: search.dfs_search(init_graph, tn, visitor) tmp_node = visitor.get_short_branch(min_length=short) visitor.reset() for n in tmp_node: short_nodes.append(n) ## get edges on the short paths short_nodes = list(set(short_nodes)) short_edges = [] temp_verts = self.verts_init[:] v_num = len(self.verts_init) if len(short_nodes): for v in reversed(sorted(short_nodes)): for ve in init_graph.vertex(v).out_edges(): short_edges.append(ve) ## delete edges first, then vertex short_edges = list(set(short_edges)) for e in short_edges: init_graph.remove_edge(e) print 'deleting vertex', for v in reversed(sorted(short_nodes)): print v, temp_verts[int(v)] = temp_verts[v_num-1] init_graph.remove_vertex(v, fast=True) v_num -= 1 print '\ndeleting related edges' # already done above, just info user else: print 'no short branches' ######## new vertices and edges ######## self.verts = temp_verts[:v_num] self.edges = [] for e in init_graph.edges(): self.edges.append([int(e.source()), int(e.target())])
class SkeletonData(object): """ class to store and process skeleton data, like generated from starlab mean curvature skeleton """ def __init__(self, fname=None, mesh_name=None, filter_sb=False): """ @param filter_sb: if filter out Short Branch """ if fname != None: self.skel_name = fname self.read_skel_file(fname) self._filter_short_branch(filter=filter_sb, short=10) self._parse_data() self.mesh_name = mesh_name self.vert_radius = None def calc_skel_properties(self): """ calc all properties needed for matching """ self.calc_node_centricity() self.calc_skel_radius() self.calc_path_length_ratio() self.calc_path_radius_ratio() self.normalize_skeleton() def read_skel_file(self, fname, dim=3): if fname == None: print 'please input skeleton file name' sys.exit(0) elif os.path.isfile(fname): self.verts_init = [] self.edges_init = [] with open(fname) as sf: for line in sf: line = line.strip('\n') line = line.split(' ') if line[0] == '#': continue elif line[0] == 'v': self.verts_init.append([x for x in line[1:(dim+1)]]) #### attention!! verts of edge start from 1 in files #### elif line[0] == 'e': self.edges_init.append([int(x)-1 for x in line[1:3]]) else: print 'not support this format' sys.exit(0) else: print 'no such flie', fname sys.exit(0) def _filter_short_branch(self, filter=False, short=30): """ filter out very short branches: do this maybe not right for some models, for models with flat part, it is right I will test how this effect the final matching results need to delete nodes, switch with the last one then delete last """ if filter == False: self.verts = self.verts_init self.edges = self.edges_init else: init_graph = Graph(directed=False) init_graph.add_vertex(len(self.verts_init)) for edge in self.edges_init: init_graph.add_edge(init_graph.vertex(edge[0]), init_graph.vertex(edge[1])) terminal_node = [] for v in init_graph.vertices(): if v.out_degree() == 1: terminal_node.append(v) visitor = DepthVisitor() short_nodes = [] for tn in terminal_node: search.dfs_search(init_graph, tn, visitor) tmp_node = visitor.get_short_branch(min_length=short) visitor.reset() for n in tmp_node: short_nodes.append(n) ## get edges on the short paths short_nodes = list(set(short_nodes)) short_edges = [] temp_verts = self.verts_init[:] v_num = len(self.verts_init) if len(short_nodes): for v in reversed(sorted(short_nodes)): for ve in init_graph.vertex(v).out_edges(): short_edges.append(ve) ## delete edges first, then vertex short_edges = list(set(short_edges)) for e in short_edges: init_graph.remove_edge(e) print 'deleting vertex', for v in reversed(sorted(short_nodes)): print v, temp_verts[int(v)] = temp_verts[v_num-1] init_graph.remove_vertex(v, fast=True) v_num -= 1 print '\ndeleting related edges' # already done above, just info user else: print 'no short branches' ######## new vertices and edges ######## self.verts = temp_verts[:v_num] self.edges = [] for e in init_graph.edges(): self.edges.append([int(e.source()), int(e.target())]) def create_virtual_node(self): """ I am planning use this function to make virtual nodes for those feature nodes """ pass def _parse_data(self): """ extract interal points(degree>2) and endpoints(degree=1) extract segments """ if self.verts == None or self.edges == None: print 'please first call read_skel_file function' else: self.verts = np.array(self.verts, dtype=np.float) self.edges = np.array(self.edges, dtype=np.int) terminal_index = [] junction_index = [] self.skel_graph = Graph(directed=False) self.skel_graph.add_vertex(len(self.verts)) for edge in self.edges : self.skel_graph.add_edge(self.skel_graph.vertex(edge[0]), self.skel_graph.vertex(edge[1])) for v in self.skel_graph.vertices(): if v.out_degree() == 2 : continue elif v.out_degree() == 1 : terminal_index.append(int(v)) elif v.out_degree() > 2 : junction_index.append(int(v)) self.terminal = self.verts[terminal_index] self.junction = self.verts[junction_index] self.terminal_index = terminal_index self.junction_index = junction_index self.feature_node_index = junction_index + terminal_index self.feature_node = self.verts[self.feature_node_index] """ edge_vert_index = self.edges.flatten() print 'edge vertex index dtype', edge_vert_index.dtype if 0 in edge_vert_index: print 'vertex start from 0' else: print 'vertex start from 1' print 'skeleton vertex num', self.skel_graph.num_vertices() print 'skeleton edge num', self.skel_graph.num_edges() """ def _calc_edge_length(self): """ calc edge length and make it edge property map in graph-tool """ vec = self.verts[self.edges[:,0]] - self.verts[self.edges[:,1]] edge_length = np.sqrt(np.sum(vec**2, axis=-1)) self.edge_length_map = self.skel_graph.new_edge_property("double") self.edge_length_map.a = edge_length def calc_node_centricity(self): """ calc node centricity of feature nodes(terminal and junction nodes) T1 in Oscar's EG 2010 paper """ self._calc_edge_length() node_centricity = [] for n_idx in self.feature_node_index: dist = topology.shortest_distance(self.skel_graph, source=self.skel_graph.vertex(n_idx), weights=self.edge_length_map) node_centricity.append(dist.a.mean()) node_centricity = np.array(node_centricity) self.node_centricity = node_centricity / np.max(node_centricity) def calc_skel_radius(self, mesh_name=None, dim=3): """ calc nearest mesh vertex of skeleton vertex """ if mesh_name != None: self.mesh_name = mesh_name if self.mesh_name == None: print 'please set mesh_name before calc_skel_radius' elif os.path.isfile(self.mesh_name): mesh = om.TriMesh() assert om.read_mesh(mesh, self.mesh_name) mesh_vertices = np.zeros((mesh.n_vertices(), dim), dtype=float) for n, vh in enumerate(mesh.vertices()): for i in xrange(3): mesh_vertices[n, i] = mesh.point(vh)[i] nbrs = NearestNeighbors(n_neighbors=1, algorithm='ball_tree').fit(mesh_vertices) self.vert_radius, indices = nbrs.kneighbors(self.verts) else: print 'cannot find mesh file', self.mesh_name sys.exit(0) def calc_path_radius(self, start, end): """ utile function for other function calc skeleton **mean** vertex radius along some segment """ if self.vert_radius == None: print 'please call calc_skel_radius function first' return None elif start in self.feature_node_index and end in self.feature_node_index: v_list, e_list = topology.shortest_path(self.skel_graph, self.skel_graph.vertex(start), self.skel_graph.vertex(end), weights=self.edge_length_map) v_idx_list = [] for v in v_list: v_idx_list.append(int(v)) v_radius = self.vert_radius[v_idx_list] return v_radius.mean() else: print 'input vertex index is not feature node index' return None def calc_path_length_ratio(self): """ for each feature node pair segment, calculate path length ratio normalized, to make it scale invariant """ path_length = np.zeros((len(self.feature_node_index), len(self.feature_node_index)), dtype=float) for i, n_idx in enumerate(self.feature_node_index): for j, m_idx in enumerate(self.feature_node_index[i+1:], start=i+1): length = topology.shortest_distance(self.skel_graph, self.skel_graph.vertex(n_idx), self.skel_graph.vertex(m_idx), weights=self.edge_length_map) if length != None : path_length[i,j] = path_length[j,i] = length else: print 'compute path length ratio error' return None ### extract path length from each feature node to junction nodes ### ### Careful!! path_length MUST start from junction node self.path_to_junction = path_length[:,:len(self.junction_index)] self.path_length_ratio = path_length / path_length.max() return self.path_length_ratio def calc_path_radius_ratio(self): """ for each feature node pair segment, calculate path radius ratio normalized, to make it scale invariant """ path_radius = np.zeros((len(self.feature_node_index), len(self.feature_node_index)), dtype=float) for i, n_idx in enumerate(self.feature_node_index): for j, m_idx in enumerate(self.feature_node_index[i+1:], start=i+1): radius = self.calc_path_radius(n_idx, m_idx) if radius != None : path_radius[i, j] = path_radius[j, i] = radius else: print 'comptue path radius error' return None self.path_radius_ratio = path_radius / path_radius.max() return self.path_radius_ratio def normalize_skeleton(self): """ calc the pose-normalized skeleton to distinguish symmetric nodes using multidimensional scaling method(MDS) """ v_num = len(self.verts) geodesic_dist = np.zeros((v_num, v_num)) geodesic_dist_map = topology.shortest_distance(self.skel_graph, weights=self.edge_length_map) for i in xrange(v_num): geodesic_dist[i] = geodesic_dist_map[self.skel_graph.vertex(i)].a mds = manifold.MDS(n_components=3, max_iter=500, eps=1e-10, dissimilarity="precomputed", n_jobs=-2, n_init=1) verts_mean = self.verts - self.verts.mean(axis=0) normalized_verts = mds.fit(geodesic_dist, init=verts_mean).embedding_ #scale = np.sqrt((verts_mean ** 2).sum()) / np.sqrt((normalized_verts ** 2).sum()) #normalized_verts *= scale self.normalized_verts = normalized_verts self.normalized_feature_verts = normalized_verts[self.feature_node_index] return self.normalized_verts def write_file(self, file_path='./'): """ maybe need to save file after filter same as starlab mean curvature skeleton """ file_name = os.path.basename(self.skel_name) full_name = file_path + file_name v_num = len(self.verts) e_num = len(self.edges) first_line = '# D:3 ' + 'NV:' + str(v_num) + ' NE:' + str(e_num) + '\n' with open(full_name, 'w') as f: f.write(first_line) for v in self.verts: line = 'v ' + str(v[0]) + ' ' + str(v[1]) + ' ' + str(v[2]) + '\n' f.write(line) for e in self.edges: line = 'e ' + str(e[0]+1) + ' ' + str(e[1]+1) + '\n' f.write(line)
from random import randint from Stack import Stack from AllConstants import * from main import number_requests #number_requests = 10 all_child_graphs = [] output = open(str(number_frequency_bands) + "_Channels_" + str(simulated_on_network) + "_Network_Blockings_log_BK.txt","a") if simulated_on_network == 1: ## Network is USIP ## ########### Creating as many layered graphs as there are channels ########### for i in range(number_frequency_bands): child_graph = Graph(); vertices_set = child_graph.add_vertex(24) ''' e01 = child_graph.add_edge(child_graph.vertex_index[0], child_graph.vertex_index[1]) e02 = child_graph.add_edge(child_graph.vertex_index[0], child_graph.vertex_index[2]) e12 = child_graph.add_edge(child_graph.vertex_index[1], child_graph.vertex_index[2]) e13 = child_graph.add_edge(child_graph.vertex_index[1], child_graph.vertex_index[3]) e24 = child_graph.add_edge(child_graph.vertex_index[2], child_graph.vertex_index[4]) e34 = child_graph.add_edge(child_graph.vertex_index[3], child_graph.vertex_index[4]) e35 = child_graph.add_edge(child_graph.vertex_index[3], child_graph.vertex_index[5]) e45 = child_graph.add_edge(child_graph.vertex_index[4], child_graph.vertex_index[5]) e10 = child_graph.add_edge(child_graph.vertex_index[1], child_graph.vertex_index[0]) e20 = child_graph.add_edge(child_graph.vertex_index[2], child_graph.vertex_index[0]) e21 = child_graph.add_edge(child_graph.vertex_index[2], child_graph.vertex_index[1]) e31 = child_graph.add_edge(child_graph.vertex_index[3], child_graph.vertex_index[1])
def facets_gt(): graph_parallel = GTGraph() graph_parallel.add_edge_list(face_idx[parallel]) connected = label_components(graph_parallel, directed=False)[0].a facets_idx = group(connected, min_len=2) return facets_idx
class GraphClass: #------------# # Initialize # #------------# def __init__ (self, dicProp={"Name": "Graph", "Type": "None", "Weighted": False}, graph=None): ''' init from properties ''' self.dicProperties = deepcopy(dicProp) self.dicGetProp = { "Reciprocity": get_reciprocity, "Clustering": get_clustering, "Assortativity": get_assortativity, "Diameter": get_diameter, "SCC": get_num_scc, #"Spectral radius": get_spectral_radius, "WCC": get_num_wcc, "InhibFrac": get_inhib_frac } self.dicGenGraph = { "Erdos-Renyi": gen_er, "Free-scale": gen_fs, "EDR": gen_edr } # create a graph if graph != None: # use the one furnished self.__graph = graph self.update_prop() self.bPropToDate = True elif dicProp["Type"] == "None": # create an empty graph self.__graph = Graph() self.bPropToDate = False else: # generate a graph of the requested type self.__graph = self.dicGenGraph[dicProp["Type"]](self.dicProperties) self.update_prop() self.set_name() self.bPropToDate = True @classmethod def from_graph_class(cls, graphToCopy): ''' create new GraphClass instance as a deepcopy of another ''' dicProperties = deepcopy(graphToCopy.get_dict_properties()) gtGraph = graphToCopy.get_graph().copy() # create graphClass = cls(dicProperties, gtGraph) # set state of properties bPropToDate = deepcopy(graphToCopy.bPropToDate) bBetwToDate = deepcopy(graphToCopy.bBetwToDate) graphClass.bPropToDate = bPropToDate graphClass.bBetwToDate = bBetwToDate return graphClass def copy(self): ''' returns a deepcopy of the graphClass instance ''' graphCopy = GraphClass() graphCopy.set_graph(self.__graph.copy()) graphCopy.update_prop() graphCopy.set_name(self.dicProperties["Name"]+'_copy') return graphCopy #---------------------------# # Manipulating the gt graph # #---------------------------# def set_graph(self, gtGraph): ''' acquire a graph_tool graph as its own ''' if gtGraph.__class__ == Graph: self.__graph = gtGraph else: raise TypeError("The object passed to 'copy_gt_graph' is not a < class 'graph_tool.Graph' > but a {}".format(gtGraph.__class__)) def inhibitory_subgraph(self): ''' create a GraphClass instance which graph contains only the inhibitory connections of the current instance's graph ''' graph = self.graph.copy() epropType = graph.new_edge_property("bool",-graph.edge_properties["type"].a+1) graph.set_edge_filter(epropType) inhibGraph = GraphClass() inhibGraph.set_graph(Graph(graph,prune=True)) inhibGraph.set_prop("Weighted", True) return inhibGraph def excitatory_subgraph(self): ''' create a GraphClass instance which graph contains only the excitatory connections of the current instance's graph ''' graph = self.graph.copy() epropType = graph.new_edge_property("bool",graph.edge_properties["type"].a+1) graph.set_edge_filter(epropType) excGraph = GraphClass() excGraph.set_graph(Graph(graph,prune=True)) excGraph.set_prop("Weighted", True) return excGraph #-------------------------# # Set or update functions # #-------------------------# def set_name(self,name=""): ''' set graph name ''' if name != "": self.dicProperties["Name"] = name else: strName = self.dicProperties["Type"] tplUse = ("Nodes", "Edges", "Distribution") for key,value in self.dicProperties.items(): if key in tplUse and (value.__class__ != dict): strName += '_' + key[0] + str(value) if key == "Clustering": strName += '_' + key[0] + str(around(value,4)) self.dicProperties["Name"] = strName print(self.dicProperties["Name"]) def update_prop(self, lstProp=[]): ''' update part or all of the graph properties ''' if lstProp: for strPropName in lstProp: if strPropName in self.dicGetProp.keys(): self.dicProperties[strPropName] = self.dicGetProp[strPropName](self.__graph) else: print("Ignoring unknown property '{}'".format(strPropName)) else: self.dicProperties.update({ strPropName: self.dicGetProp[strPropName](self.__graph) for strPropName in self.dicGetProp.keys() }) self.bPropToDate = True #---------------# # Get functions # #---------------# ## basic properties def get_name(self): return self.dicProperties["Name"] def num_vertices(self): return self.__graph.num_vertices() def num_edges(self): return self.__graph.num_edges() def get_density(self): return self.__graph.num_edges()/float(self.__graph.num_vertices()**2) def is_weighted(self): return self.dicProperties["Weighted"] ## graph and adjacency matrix def get_graph(self): self.bPropToDate = False self.bBetwToDate = False self.wBetweeness = False return self.__graph def get_mat_adjacency(self): return adjacency(self.__graph, self.get_weights()) ## complex properties def get_prop(self, strPropName): if strPropName in self.dicProperties.keys(): if not self.bPropToDate: self.dicProperties[strPropName] = self.dicGetProp[strPropName](self.__graph) return self.dicProperties[strPropName] else: print("Ignoring request for unknown property '{}'".format(strPropName)) def get_dict_properties(self): return self.dicProperties def get_degrees(self, strType="total", bWeights=True): lstValidTypes = ["in", "out", "total"] if strType in lstValidTypes: return degree_list(self.__graph, strType, bWeights) else: print("Ignoring invalid degree type '{}'".format(strType)) return None def get_betweenness(self, bWeights=True): if bWeights: if not self.bWBetwToDate: self.wBetweeness = betweenness_list(self.__graph, bWeights) self.wBetweeness = True return self.wBetweeness if not self.bBetwToDate and not bWeights: self.betweenness = betweenness_list(self.__graph, bWeights) self.bBetwToDate = True return self.betweenness def get_types(self): if "type" in self.graph.edge_properties.keys(): return self.__graph.edge_properties["type"].a else: return repeat(1, self.__graph.num_edges()) def get_weights(self): if self.dicProperties["Weighted"]: epropW = self.__graph.edge_properties["weight"].copy() epropW.a = multiply(epropW.a, self.__graph.edge_properties["type"].a) return epropW else: return self.__graph.edge_properties["type"].copy()
def is_watertight_gt(mesh): g = GTGraph() g.add_edge_list(mesh.face_adjacency()) degree = g.degree_property_map('total').a watertight = np.equal(degree, 3).all() return watertight
def main(): conn = serial_interface.connect() cur_track = track.init_tracka() g = Graph() g.add_vertex(len(cur_track)) for (vi, node) in enumerate(cur_track): node.i = vi n_title = g.new_vertex_property("string") n_color = g.new_vertex_property("string") n_pos = g.new_vertex_property("vector<double>") e_title = g.new_edge_property("string") e_dist = g.new_edge_property("double") for node in cur_track: v = g.vertex(node.i) n_title[v] = node.name if node.typ == track.NODE_EXIT: # Invert points to match our ASCII display. n_pos[v] = (-node.reverse.coord_x, -node.reverse.coord_y) else: n_pos[v] = (-node.coord_x, -node.coord_y) e = g.add_edge(g.vertex(node.i), g.vertex(node.reverse.i)) if node.typ == track.NODE_SENSOR: n_color[v] = "blue" elif node.typ == track.NODE_BRANCH: n_color[v] = "orange" elif node.typ == track.NODE_MERGE: n_color[v] = "yellow" elif node.typ == track.NODE_ENTER: n_color[v] = "green" elif node.typ == track.NODE_EXIT: n_color[v] = "red" else: n_color[v] = "white" for edge in node.edge: if edge.src is None: continue e = g.add_edge(g.vertex(edge.src.i), g.vertex(edge.dest.i)) e_dist[e] = edge.dist e_title[e] = "%.2f" % (edge.dist) win = graph_tool.draw.GraphWindow(g, n_pos, (640, 480), edge_text=e_title, vertex_fill_color=n_color, vertex_text=n_title) win.show_all() def destroy_callback(*args, **kwargs): win.destroy() Gtk.main_quit() def set_switch(sw, d): for node in cur_track: if node.typ == track.NODE_BRANCH and node.num == sw: node.switch_direction = d return print "WARN: Could not find switch %d" % sw class Train(): num = -1 vel = 0. speed = 0. edge = cur_track[0].edge[0] edge_dist = 0 SPEEDX = 1. def __init__(self, num): self.num = num def update(self): # Super shitty deacceleration model self.vel = self.vel + (0.018/self.SPEEDX)*(self.speed - self.vel) self.edge_dist += self.vel while True: e = self.e() if self.edge_dist < e_dist[e]: break if self.edge.dest.typ == track.NODE_SENSOR: conn.set_sensor_tripped(self.edge.dest.num) self.edge = self.edge.dest.edge[self.edge.dest.switch_direction] self.edge_dist -= e_dist[e] def draw(self, n_pos, da, cr): e = self.e() start, end = np.array(n_pos[e.source()]), np.array(n_pos[e.target()]) alpha = self.edge_dist / e_dist[e] pos = start + alpha*(end - start) dp = win.graph.pos_to_device(pos) # dp: device position cr.rectangle(dp[0]-10, dp[1]-10, 20, 20) cr.set_source_rgb(102. / 256, 102. / 256, 102. / 256) cr.fill() cr.move_to(dp[0]-10, dp[1] + 10 - 12./2) cr.set_source_rgb(1., 1., 1.) cr.set_font_size(12) cr.show_text("%d" % self.num) cr.fill() def e(self): return g.edge(self.edge.src.i, self.edge.dest.i) def set_speed(self, speed): self.speed = speed/self.SPEEDX def toggle_reverse(self): self.edge = self.edge.reverse self.edge_dist = e_dist[self.e()] - self.edge_dist def find_train(train_number): for train in trains: if train.num == train_number: return train train = Train(train_number) trains.append(train) return train trains = [Train(12)] startup_time = time.time() accumulated_error = [0.] last_time = [time.time()] last_sensor_poll = [0] FPS = 30. def my_draw(da, cr): (typ, a1, a2) = conn.next_cmd() if typ is None: pass elif typ == 'set_speed': find_train(a1).set_speed(a2) elif typ == 'toggle_reverse': find_train(a1).toggle_reverse() elif typ == 'switch': set_switch(a1, a2) elif typ == 'sensor': last_sensor_poll[0] = round((time.time() - startup_time) * 1000)/1000 else: print "Ignoring command %s" % typ cur_time = time.time() dt = cur_time - last_time[0] + accumulated_error[0] num_steps = int(dt*FPS) accumulated_error[0] = dt - num_steps/FPS for train in trains: for _ in range(0, num_steps): train.update() train.draw(n_pos, da, cr) cr.move_to(10., 10.) cr.set_source_rgb(0., 0., 0.) cr.set_font_size(12) cr.show_text("Last polled at %.3f" % last_sensor_poll[0]) da.queue_draw() last_time[0] = cur_time win.connect("delete_event", destroy_callback) win.graph.connect("draw", my_draw) Gtk.main()