def run(self): while self.heap.size > 0: min = self.heap.removeMin() # checks if the vertices of the removed edge have already been put into the tree try1 = [x for x in self.verticesInTree if x.id is min.v1.id] try2 = [x for x in self.verticesInTree if x.id is min.v2.id] v1 = Vertex(min.v1.id) if len(try1) is 0 else try1[0] v2 = Vertex(min.v2.id) if len(try2) is 0 else try2[0] edge = Edge(v1, v2, min.weight) edge2 = Edge(v2, v1, min.weight) # check to see if the two vertices are connected in the graph # if they are, then we do not add this edge if self.verticesAreConnected(v1, v2) and self.nodes[v1.id] < 2 and self.nodes[v2.id] < 2: self.edgesInTree.append(edge) self.edgesInTree.append(edge2) v1.addEdgeFrom(edge) v1.addEdgeTo(edge2) v2.addEdgeFrom(edge2) v2.addEdgeTo(edge) if len(try1) is 0: self.verticesInTree.append(v1) if len(try2) is 0: self.verticesInTree.append(v2) self.nodes[v1.id] += 1 self.nodes[v2.id] += 1 return self.edgesInTree
def test_contract(self): test_case = Graph() test_node1 = Node(node_id=1) test_node2 = Node(node_id=2) test_node3 = Node(node_id=3) test_edge_1_3 = Edge(test_node1,test_node3) test_edge_1_2 = Edge(test_node1,test_node2) test_edge_2_3 = Edge(test_node2,test_node3) test_case.add_node(test_node1) test_case.add_node(test_node2) test_case.add_node(test_node3) test_case.add_undirected_edges([test_edge_1_3,test_edge_1_2,test_edge_2_3]) result_node = test_case.contract(test_edge_1_2) test_result_node_edges = test_case.get_node_edges(result_node) test_node3_edges = test_case.get_node_edges(test_node3) self.assertTrue(len(test_result_node_edges) == 2) self.assertTrue(len(test_node3_edges) == 2) self.assertTrue(len(result_node.nodes_contracted) ==2)
def construct_graph(image, image_seed): graph = construct_nodes(image, image_seed) mean, variance = stats(graph) gauss = multivariate_normal(mean=mean, cov=variance) fg_node = Node((-1, -1), None, "fg") bg_node = Node((-2, -2), None, "bg") for pos, node in graph.iteritems(): adj_position = [(x[0] + y[0], x[1] + y[1]) for x, y in zip(constants.MOVES, [pos] * 4)] neighbors = [graph[x] for x in adj_position if x in graph] fg_weight = calc_fg_weight(node, gauss) bg_weight = calc_bg_weight(node, gauss) fg_edge = Edge(node, fg_node, fg_weight) bg_edge = Edge(node, bg_node, bg_weight) edges = [Edge(node, x, calc_weight(node, x)) for x in neighbors] graph[fg_node.coord] = fg_node graph[bg_node.coord] = bg_node return graph, fg_node, bg_node
def test_reassign_edge(self): test_case = Graph() test_node1 = Node(node_id=1) test_node2 = Node(node_id=2) test_node3 = Node(node_id=3) test_edge_1_3 = Edge(test_node1,test_node3) test_edge_2_3 = Edge(test_node2,test_node3) test_case.add_node(test_node1) test_case.add_node(test_node2) test_case.add_node(test_node3) test_case.add_undirected_edge(test_edge_1_3) test_case.add_undirected_edge(test_edge_2_3) test_super_node = Node() test_case.add_node(test_super_node) test_case.reassign_edges([test_node1,test_node2],test_super_node) test_super_node_edges = test_case.get_node_edges(test_super_node) test_node1_edges = test_case.get_node_edges(test_node1) test_node2_edges = test_case.get_node_edges(test_node2) test_node3_edges = test_case.get_node_edges(test_node3) self.assertTrue(len(test_super_node_edges) == 2) self.assertTrue(len(test_node1_edges) == 0) self.assertTrue(len(test_node2_edges) == 0) self.assertTrue(len(test_node3_edges) == 2)
def select(self): self._selected = True self._photoviewer.add_selected_polygon(self) first_node = Node(self) first_node.setPos(self.polygon_points[0] + self.pos()) self._nodes = [first_node] self._edges = [] self._scene.addItem(first_node) for idx in range(1, len(self.polygon_points)): new_node = Node(self) new_node.setPos(self.polygon_points[idx] + self.pos()) self._scene.addItem(new_node) new_edge = Edge(self._nodes[idx - 1], new_node, self) self._scene.addItem(new_edge) self._nodes.append(new_node) self._edges.append(new_edge) # connect last edge to first new_edge = Edge(self._nodes[len(self._nodes) - 1], self._nodes[0], self) self._scene.addItem(new_edge) self._edges.append(new_edge)
def create_edges_from_navitia(response, graph): journey = response['journeys'][0] edges = [] # add edges for section in journey["sections"]: # like with nodes, we do not take care of waiting sections. Transfer sections are treated after if section['type'] != "waiting" and section['type'] != "transfer": src = calculate_node_coord_from_navitia(section['from']) dest = calculate_node_coord_from_navitia(section['to']) # we verify that both of the nodes are in the graph if graph.find_node_from_coord(src.coord) and graph.find_node_from_coord(dest.coord): # adding the edge to the node edge = Edge(graph.find_node_from_coord(src.coord), graph.find_node_from_coord(dest.coord), section['duration'], section['duration']) set_edge_info(section, edge) edges.append(edge) # todo add else -> throw error # if the section is of type transfer, we only verify that source and destination are different to add the edge to the graph elif section['type'] == "transfer": if section['from']['name'] != section['to']['name']: src = calculate_node_coord_from_navitia(section['from']) dest = calculate_node_coord_from_navitia(section['to']) if graph.find_node_from_coord(src.coord) and graph.find_node_from_coord(dest.coord): edge = Edge(graph.find_node_from_coord(src.coord), graph.find_node_from_coord(dest.coord), section['duration'], section['duration']) set_edge_info(section, edge) edges.append(edge) return edges
def scan_triangle(self, min_y_vert, mid_y_vert, max_y_vert, handedness, colour, fill): """Draw triangle scan lines""" top_to_bottom = Edge(min_y_vert, max_y_vert) top_to_middle = Edge(min_y_vert, mid_y_vert) middle_to_bottom = Edge(mid_y_vert, max_y_vert) left = top_to_bottom right = top_to_middle if handedness: left, right = right, left y_start = top_to_middle.y_start y_end = top_to_middle.y_end for j in xrange(y_start, y_end): self.draw_scan_line(left, right, j, colour, fill) left.step() right.step() left = top_to_bottom right = middle_to_bottom if handedness: left, right = right, left y_start = middle_to_bottom.y_start y_end = middle_to_bottom.y_end for j in xrange(y_start, y_end): self.draw_scan_line(left, right, j, colour, fill) left.step() right.step()
def test_good_constructor_args(self): route = Route("AB1", Edge(i='B', f='C', d=1), Edge(i='C', f='D', d=2), Edge(i='D', f='A', d=3)) with self.assertRaises(AttributeError): _ = route.magnitude _ = route.stops self.assertEqual(route.end_vertex, 'A')
def find_nodes_and_edges(self): ''' Taking all of the paths/roads in the given area, this breaks up those paths/roads into edges and stores in a list.''' self.edge_list = [] for way in self.ways: breakpoints = [] for i in range(len(way.nodes)): if way.nodes[i] in self.intersections: breakpoints.append(i) if breakpoints == []: new_edge = Edge() new_edge.set_start_node(way.nodes[0]) new_edge.set_end_node(way.nodes[-1]) if len(way.nodes) > 2: new_edge.add_multiple_nodes(way.nodes[1:-1]) new_edge.update_distance() self.edge_list.append(new_edge) else: new_ways = [] for point in range(len(breakpoints) - 1): new_ways.append( way.nodes[breakpoints[point]:breakpoints[point + 1] + 1]) for edge_way in new_ways: new_edge = Edge() new_edge.set_start_node(edge_way[0]) new_edge.set_end_node(edge_way[-1]) if len(edge_way) > 2: new_edge.add_multiple_nodes(edge_way[1:-1]) new_edge.update_distance() self.edge_list.append(new_edge)
def init_grid(self): self.node_grid = [] node = None for y in range(self.node_height): self.node_grid.append([]) for x in range(self.node_width): node = Node( str(x) + " " + str(y), [], (x - 1) * Node.node_size // 2, (y) * Node.node_height, x % 2 == y % 2) self.node_grid[y].append(node) Node.node_list.append(node) # Create connections grid = self.node_grid for i in range(len(grid)): for j in range(len(grid[i])): if j != len(grid[i]) - 1: grid[i][j].connections.append( Edge(grid[i][j], grid[i][j + 1])) if j != 0: grid[i][j].connections.append( Edge(grid[i][j], grid[i][j - 1])) if grid[i][j].flipped and i > 0: grid[i][j].connections.append( Edge(grid[i][j], grid[i - 1][j])) if not grid[i][j].flipped and i < len(grid) - 1: grid[i][j].connections.append( Edge(grid[i][j], grid[i + 1][j])) Edge.edge_list.extend(grid[i][j].connections)
def test_topological_sort(self): graph = Graph() test_nodes = [ Node(node_id=0), Node(node_id=1), Node(node_id=2), Node(node_id=3) ] graph.add_nodes(test_nodes) graph.add_direct_edge(test_nodes[0], Edge(test_nodes[0], test_nodes[1])) graph.add_direct_edge(test_nodes[0], Edge(test_nodes[0], test_nodes[2])) graph.add_direct_edge(test_nodes[1], Edge(test_nodes[1], test_nodes[3])) graph.add_direct_edge(test_nodes[2], Edge(test_nodes[2], test_nodes[3])) topological_sort(graph) self.assertEqual(1, test_nodes[0].get_distance()) self.assertEqual(4, test_nodes[3].get_distance()) self.assertTrue(test_nodes[2].get_distance() == 2 or test_nodes[2].get_distance() == 3) self.assertTrue(test_nodes[1].get_distance() == 2 or test_nodes[1].get_distance() == 3)
def parse(self, words: 'list[str]'): self.initParse(len(words)) for k, word in enumerate(words + ['END']): #print(word) it = 0 while it < len(self.edges[k]): e = self.edges[k][it] dot_idx = e.deps.index('*') if dot_idx+1 < len(e.deps): # no more tokens, should only complete if k == len(words): it+= 1 continue token = e.deps[dot_idx+1] if isNonterminal(token): for prod in self.prods[token]: self.addEdge(k, Edge(token, ['*']+prod, k, Ast(token, prod))) else: if token == word and token in [ts[0] for ts in self.prods[e.head]]: self.addEdge(k+1, Edge(e.head, [token, '*'], e.start, Ast(e.head, [token]))) else: for oe in self.edges[e.start]: if oe.getAfterDot() == e.head: newDeps = [d for d in oe.deps] idx = newDeps.index('*') newDeps[idx] = newDeps[idx+1] newDeps[idx+1] = '*' ne = Edge(oe.head, newDeps, oe.start, oe.ast.replaceLeaf(idx, e.ast)) self.addEdge(k, ne) if ne.start == 0 and k == len(words): yield ne.ast it+=1
def __create_edges(self): if self.__indexes is None: return None dist = set() dup = set() for i in range(0, len(self.indexes), 3): a = Edge(self.indexes[i + 0], self.indexes[i + 1]) b = Edge(self.indexes[i + 1], self.indexes[i + 2]) c = Edge(self.indexes[i + 2], self.indexes[i + 0]) if a in dist: dup.add(a) else: dist.add(a) if b in dist: dup.add(b) else: dist.add(b) if c in dist: dup.add(c) else: dist.add(c) dist = dist.difference(dup) dist = list(dist) self.__edges = dist
def getInputChain(inputValues, uniqNameStr): inputChain = Graph() outNode = Node('{}_out'.format(uniqNameStr)) inputChain.addNode(outNode) lastNode = outNode for idx, val in enumerate(inputValues): nameSuffix = '{}_t{}'.format(uniqNameStr, idx) if val == 1: newNode = Node('Inverter_{}'.format(nameSuffix)) inputChain.addNode(newNode) inputChain.addEdge(Edge(newNode, lastNode)) lastNode = newNode elif val != 0: print( 'ERROR: buildInputChain - unkown value = {}. should be 0 or 1.' .format(val)) exit() if idx == len(inputValues) - 1: continue newNode = Node('LatchIn_{}'.format(nameSuffix)) inputChain.addNode(newNode) inputChain.addEdge(Edge(newNode, lastNode)) lastNode = newNode inpNode = Node('chainInp_{}'.format(nameSuffix)) inputChain.addNode(inpNode) inputChain.addEdge(Edge(inpNode, lastNode)) inputChain.defineOutput(outNode) inputChain.defineInput(inpNode) return inputChain
def scan_triangle(self, minYVert, midYVert, maxYVert, handedness): edge_top_to_bottom = Edge(minYVert, maxYVert) edge_top_to_middle = Edge(minYVert, midYVert) edge_middle_to_bottom = Edge(midYVert, maxYVert) self.scan_edges(edge_top_to_bottom, edge_top_to_middle, handedness) self.scan_edges(edge_top_to_bottom, edge_middle_to_bottom, handedness)
def addEdge(self, orig, dest, w): newEdge = Edge(orig, dest, w) newTranspEdge = Edge(dest, orig, w) newKey = orig.getName() + ' ' + dest.getName() newTranspKey = dest.getName() + ' ' + orig.getName() self.__E[newKey] = newEdge self.__ET[newTranspKey] = newTranspEdge
def initialize_edges_niid(num_edges, clients, args, client_class_dis): """ This function is specially designed for partiion for 10*L users, 1-class per user, but the distribution among edges is iid, 10 clients per edge, each edge have 5 classes :param num_edges: L :param clients: :param args: :return: """ #only assign first (num_edges - 1), neglect the last 1, choose the left edges = [] p_clients = [0.0] * num_edges label_ranges = [[0,1,2,3,4],[1,2,3,4,5],[5,6,7,8,9],[6,7,8,9,0]] for eid in range(num_edges): if eid == num_edges - 1: break assigned_clients_idxes = [] label_range = label_ranges[eid] for i in range(2): for label in label_range: # 5 labels in total if len(client_class_dis[label]) > 0: assigned_client_idx = np.random.choice(client_class_dis[label], 1, replace=False) client_class_dis[label] = list(set(client_class_dis[label]) - set(assigned_client_idx)) else: label_backup = 2 assigned_client_idx = np.random.choice(client_class_dis[label_backup],1, replace=False) client_class_dis[label_backup] = list(set(client_class_dis[label_backup]) - set(assigned_client_idx)) for idx in assigned_client_idx: assigned_clients_idxes.append(idx) edges.append(Edge(id = eid, cids=assigned_clients_idxes, shared_layers=copy.deepcopy(clients[0].model.shared_layers))) [edges[eid].client_register(clients[client]) for client in assigned_clients_idxes] edges[eid].all_trainsample_num = sum(edges[eid].sample_registration.values()) p_clients[eid] = [sample / float(edges[eid].all_trainsample_num) for sample in list(edges[eid].sample_registration.values())] edges[eid].refresh_edgeserver() #And the last one, eid == num_edges -1 #Find the last available labels eid = num_edges - 1 assigned_clients_idxes = [] for label in range(10): if not client_class_dis[label]: print("label{} is empty".format(label)) else: assigned_client_idx = client_class_dis[label] for idx in assigned_client_idx: assigned_clients_idxes.append(idx) client_class_dis[label] = list(set(client_class_dis[label]) - set(assigned_client_idx)) edges.append(Edge(id=eid, cids=assigned_clients_idxes, shared_layers=copy.deepcopy(clients[0].model.shared_layers))) [edges[eid].client_register(clients[client]) for client in assigned_clients_idxes] edges[eid].all_trainsample_num = sum(edges[eid].sample_registration.values()) p_clients[eid] = [sample / float(edges[eid].all_trainsample_num) for sample in list(edges[eid].sample_registration.values())] edges[eid].refresh_edgeserver() return edges, p_clients
def test_str(self): self.spanning_tree.addEdge(Edge(0, 1)) self.spanning_tree.addEdge(Edge(1, 2)) self.spanning_tree.addEdge(Edge(1, 3)) expected = "(0, 1), (1, 2), (1, 3)" actual = self.spanning_tree.__str__() self.assertEqual(expected, actual)
def substitutes(self, data): graph = nx.Graph() for data_y in range(0, len(data)): for data_x in range(0, len(data[data_y])): orig_x = data_x orig_y = data_y ov_y = 0 ov_x = 0 matched = True while True == matched and ov_y < len(self.__overlay): if None != self.__overlay[ov_y][ov_x]: if not re.match(str(self.__overlay[ov_y][ov_x]), str(data[orig_y][orig_x]), re.UNICODE): matched = False if ov_x < len(self.__overlay[ov_y]) - 1: ov_x = ov_x + 1 orig_x = orig_x + 1 if orig_x >= len(data[orig_y]): matched = False else: ov_x = 0 orig_x = data_x ov_y = ov_y + 1 orig_y = orig_y + 1 if orig_y >= len(data) and ov_y < len(self.__overlay): matched = False if True == matched: for obj in self.__substitutes: if isinstance(obj, Edge): edge = obj start = edge.start() + (data_x, data_y) end = edge.end() + (data_x, data_y) _above = None _below = None z_order = None if edge.above() != None: above_start = edge.above().start() + (data_x, data_y) above_end = edge.above().end() + (data_x, data_y) _above = Edge(above_start, above_end) if edge.below() != None: below_start = edge.below().start() + (data_x, data_y) below_end = edge.below().end() + (data_x, data_y) _below = Edge(below_start, below_end) graph.add_node(start, options=self.__options) graph.add_node(end, options=self.__options) graph.add_edge(start, end, above=_above, below=_below, z_order=edge.z_order()) elif isinstance(obj, Node): start = obj + (data_x, data_y) graph.add_node(start, options=self.__options) return graph
def addEdge(self, source, sink, capacity): newEdge = Edge(source, sink, capacity) newReverseEdge = Edge(sink, source, capacity) if self.directed == False else Edge( sink, source, 0) newEdge.reverseEdge = newReverseEdge newReverseEdge.reverseEdge = newEdge self.graph[source].append(newEdge) self.graph[sink].append(newReverseEdge)
def _generate_back(self): a = self._l_t + Point3D(z=self._step_count * self._step_height) b = a + Point3D(self._width) self.triangles.append(Triangle(a, b, self._r_t)) self.triangles.append(Triangle(a, self._l_t, self._r_t)) self.edges.append(Edge(a, self._l_t)) self.edges.append(Edge(b, self._r_t))
def catmull(self): self.meshMemory.append( Mesh(self.vertexTable, self.edgeTable, self.faceTable)) newFaceTablePositions = [] vertexTable = [] faceTable = [] edgeTable = [] for faceObj in self.faceTable: new_faces = self.findNewFacesFromFace(faceObj) #position list for facePos in new_faces: v1 = Vertex(facePos[0]) v2 = Vertex(facePos[1]) v3 = Vertex(facePos[2]) v4 = Vertex(facePos[3]) vertexTable.extend([v1, v2, v3, v4]) v1 = self.getVertexFromTheTable(v1, vertexTable) v2 = self.getVertexFromTheTable(v2, vertexTable) v3 = self.getVertexFromTheTable(v3, vertexTable) v4 = self.getVertexFromTheTable(v4, vertexTable) face = Face([v1, v2, v3, v4]) v1.addFace(face) v2.addFace(face) v3.addFace(face) v4.addFace(face) edge1 = Edge(v1, v2) edge2 = Edge(v2, v3) edge3 = Edge(v3, v4) edge4 = Edge(v1, v4) v1.addEdge(edge1, edge4) v2.addEdge(edge1, edge2) v3.addEdge(edge2, edge3) v4.addEdge(edge3, edge4) faceTable.append(face) edgeTable.append(edge1) edgeTable.append(edge2) edgeTable.append(edge3) edgeTable.append(edge4) newFaceTablePositions.extend(new_faces) self.faceTable = faceTable self.edgeTable = edgeTable self.vertexTable = vertexTable return newFaceTablePositions
def main(args): V = [Vertex("A"), Vertex("B"), Vertex("C"), Vertex("D"), Vertex("E")] E = [Edge(9,V[0],V[1]), Edge(5,V[0],V[2]), Edge(10,V[0],V[4]), Edge(1,V[1],V[3]), Edge(11,V[2],V[3])] G = Graph(V, E) MST = kruskal(G) print "================= Original Graph ======================" print G print "================= MST ======================" print MST
def test_adjacentEdges(self): self.graph.addEdge(0, 1) self.graph.addEdge(0, 3) self.graph.addEdge(1, 4) adj_0 = self.graph.adjacentEdges(0) adj_1 = self.graph.adjacentEdges(1) self.assertEqual([Edge(0, 1), Edge(0, 3)], adj_0) self.assertEqual([Edge(0, 1), Edge(1, 4)], adj_1)
def _get_edge_intersection_points(polygon1, polygon2): intersection_points = list() for i in range(len(polygon1)): edge1 = Edge(polygon1[i - 1], polygon1[i]) for j in range(len(polygon2)): edge2 = Edge(polygon2[j - 1], polygon2[j]) intersection_point = edge1.get_intersection_point(edge2) if intersection_point is not None: intersection_points.append(intersection_point) return intersection_points
def replaceNodeWithNewInp(g, v): fanout = g.fanout(v) newInp = Node('Input_new_{}'.format(v.getName())) g.addNode(newInp) g.defineInput(newInp) for u in fanout: eToRem = Edge(v, u) g.removeEdge(eToRem) eToAdd = Edge(newInp, u) g.addEdge(eToAdd)
def __one_hop_graph(self, entity_items, relation_items, threshold=None, number_of_entities=1): top_uri = 1 total = self.count_combinations(entity_items, relation_items, number_of_entities, top_uri) if threshold is not None: while total > threshold: top_uri -= 0.1 total = self.count_combinations(entity_items, relation_items, number_of_entities, top_uri) with tqdm(total=total, disable=self.logger.level >= 10) as pbar: for relation_item in relation_items: for relation_uri in relation_item.top_uris(top_uri): for entity_uris in itertools.product( * [items.top_uris(top_uri) for items in entity_items]): for entity_uri in itertools.combinations( entity_uris, number_of_entities): pbar.update(1) result = self.kb.one_hop_graph( entity_uri[0], relation_uri, entity_uri[1] if len(entity_uri) > 1 else None) if result is not None: for item in result: m = int(item["m"]["value"]) uri = entity_uri[1] if len( entity_uri) > 1 else 0 if m == 0: n_s = self.create_or_get_node( uri, True) n_d = self.create_or_get_node( entity_uri[0]) e = Edge(n_s, relation_uri, n_d) self.add_edge(e) elif m == 1: n_s = self.create_or_get_node( entity_uri[0]) n_d = self.create_or_get_node( uri, True) e = Edge(n_s, relation_uri, n_d) self.add_edge(e) elif m == 2: n_s = self.create_or_get_node(uri) n_d = self.create_or_get_node( relation_uri) e = Edge( n_s, Uri(self.kb.type_uri, self.kb.parse_uri), n_d) self.add_edge(e)
def _initialize_edge(self, row, col): here = self._point(row, col) # edge creation to right if col < self.ncol: down = self._point(row, col + 1) self.edges.append(Edge(source=here, dest=down)) # edge creation to bottom if row < self.nrow: right = self._point(row + 1, col) self.edges.append(Edge(source=here, dest=right))
def test_eq_ne(self): self.assertTrue(self.edge == self.edge2) self.assertFalse(self.edge != self.edge2) edge3 = Edge(1, 2) self.assertTrue(self.edge == edge3) self.assertFalse(self.edge != edge3) edge4 = Edge(1, 3) self.assertFalse(edge3 == edge4) self.assertTrue(edge3 != edge4)
def create_edges(self, max_x, max_y): edges = [] for (x, y) in self.nodes: me = self.nodes.get((x, y)) if x < max_x: right = self.nodes.get(((x + 1), y)) edges.append(Edge(me, right)) if y < max_y: down = self.nodes.get((x, (y + 1))) edges.append(Edge(me, down)) return edges