def newEdge(self, origin, destiny, weight): originAux = self.findVertex(origin) destinyAux = self.findVertex(destiny) if (originAux is not None) and (destinyAux is not None): self.listEdge.append(Edge(originAux, destinyAux, weight)) if self.directed == False: self.listEdge.append(Edge(destinyAux, originAux, weight))
def persist_graph(request, graph_id): import pygraphviz as P import networkx as N graph = Graph.objects.get(pk=graph_id) dot_path = graph.dot_file.storage.location + '/' + graph.dot_file.name G = P.AGraph() # init empty graph try: G.read(dot_path) #read file nodes = G.nodes() edges = G.edges() Node.objects.filter(graph__id=graph_id).delete() Edge.objects.filter(graph__id=graph_id).delete() for node in nodes: new_node = Node() new_node.graph = graph new_node.name = node new_node.label = node.attr['label'] new_node.save() for edge in edges: new_edge = Edge() new_edge.graph = graph new_edge.name = edge new_edge.save() except: return False return HttpResponse(pygraphviz_graph(request, G)) #response
def create_model_edge(arg, devices_list, eval=False): from models import Edge edge = Edge() if arg.cuda: edge = edge.cuda(device=devices_list[0]) return edge
def _arrange_top_left_corner_tile(tile_db: TileDB, corner: Tile): lone_edges = corner.lone_edges(tile_db) times = 0 while lone_edges not in [(Edge.U, Edge.L), (Edge.L, Edge.U)]: times += 1 lone_edges = tuple([Edge((edge.value + 1) % 4) for edge in lone_edges]) corner.rotate(times=times)
def creatNet(G,net): # G = snap.LoadEdgeList(snap.PUNGraph,"d:\\networkdata\\show\\facebook.txt",0,1) # for NI in G.Nodes(): # print "node: %d, out-degree %d, in-degree %d" % ( NI.GetId(), NI.GetOutDeg(), NI.GetInDeg()) nodeIDs = set() nodes = [] edges = [] for EI in G.Edges(): # print "edge (%d, %d)" % (EI.GetSrcNId(), EI.GetDstNId()) id = EI.GetDstNId() if id not in nodeIDs: nodeIDs.append(id) inNode = Node(nodeId=id,net=net) nodes.append(inNode) id = EI.GetSrcNId() if id not in nodeIDs: nodeIDs.append(id) outNode = Node(nodeId=id,net=net) nodes.append(outNode) edge = Edge(nodeIn=inNode,nodeOut=outNode) edges.append(edge) # edge.save() # for NI in G.Nodes(): # for Id in NI.GetOutEdges(): # print "edge (%d %d)" % (NI.GetId(), Id) Node.objects.bulk_create(nodes) Edge.objects.bulk_create(edges)
def create_network(self, data): goals = data['goals'] policies = data['policies'] id_mapping = {} links = [] network = Network() for policy in policies: p = Policy(id=policy['id']) update_node_from_dict(p, policy) id_mapping[policy['id']] = p network.policies[p.id] = p for conn in policy['connections']: i = conn['id'] a = conn['from_id'] b = conn['to_id'] w = conn['weight'] links.append((i, a, b, w)) for goal in goals: g = Goal(id=goal['id']) update_node_from_dict(g, goal) id_mapping[goal['id']] = g network.goals[g.id] = g for conn in goal['connections']: i = conn['id'] a = conn['from_id'] b = conn['to_id'] w = conn['weight'] links.append((i, a, b, w)) for i, a, b, w in links: a = id_mapping[a] b = id_mapping[b] l = Edge(id=i) l.init(a, b, w) network.edges[l.id] = l network.rank() self.network = network
def updateEdge(self, n1, n2, conversation_id): edge = db.GqlQuery( "SELECT * FROM Edge " + "WHERE node1 = :1 AND " + "node2 = :2 AND " + "edge_id = :3", n1, n2, conversation_id).get() if not edge: edge = Edge(node1=n1.lower(), node2=n2.lower(), edge_id=conversation_id).put() return edge
def find_edge(v1, v2, edges): for edge in edges: if edge.start == v1 and edge.end == v2: return edge if edge.start == v2 and edge.end == v1: return edge edge = Edge(v1, v2, None) return edge
def setUp(self): new_york = Node(name='new york', coordinates=Point(40, 73)) austin = Node(name='austin', coordinates=Point(30, 97)) san_fran = Node(name='san fran', coordinates=Point(37, 122)) chicago = Node(name='chicago', coordinates=Point(41, 87)) new_york.save() austin.save() san_fran.save() chicago.save() Edge(node_src=new_york, node_sink=chicago).save() Edge(node_src=chicago, node_sink=san_fran).save() Edge(node_src=new_york, node_sink=austin).save() Edge(node_src=austin, node_sink=san_fran).save() Edge(node_src=san_fran, node_sink=new_york).save()
def makeEdge(): if request.method=='GET': return render_template('makeEdge.html') else: edgeNum = request.form.get('edge') edgeOb = Edge(edge=edgeNum) db.session.add(edgeOb) db.session.commit() contexts = { 'products': Product.query.all(), 'edgeOb': Edge.query.filter(Edge.id!=-1).order_by(Edge.id.desc()).first() } return render_template('manager.html',**contexts)
def parse(self, _): """ Weight all edges naiively - Query edges by meta-nodes, where each meta-node is a domain - Create new edges between meta-nodes where the "weight" is the number of multi-edges in the associated multi-graph. """ for v in self.graph.vertices: print('Computing edge weights for "%s"' % v.domain) for u in self.graph.vertices: weight = Link.query().join( HTML, Link.from_html==HTML.id).filter( HTML.domain == u.domain).count() # print('Edge (%s, %s): %d' % (v.domain, u.domain, weight)) edge = Edge.get_or_create( graph_id=self.graph.id, from_id=u.id, to_id=v.id).update(weight=weight).save()
row.frequency.sat = bool(int(calendar[6])) row.frequency.sun = bool(int(calendar[7])) # TABLE graph # (1) stop_times.txt graph_table = [] previous = None with open("../{0}/stop_times.txt".format(GTFS_FOLDER)) as stop_times_file: stop_times = csv.reader(stop_times_file) for current in stop_times: if current[0] != "trip_id" and previous[0] == current[0]: time_delta = datetime.datetime.strptime( current[3], '%H:%M:%S') - datetime.datetime.strptime( previous[4], '%H:%M:%S') graph_table.append(Edge( session.query(Stop).filter( Stop.stop_id == previous[2]).first(), session.query(Stop).filter( Stop.stop_id == current[2]).first(), session.query(Route).filter( Route.trip_id == current[0]).first(), int(previous[1]), int(time_delta.total_seconds()) )) previous = current session.add_all(graph_table) # Close connection session.commit() session.close()
def main_algorithm(problem): logger = logging.getLogger('main_logger') logger.critical('Problem %i' % problem.question_number) # pb = problems[no] graph = Graph(problem) graph.sort_edges() solution_edges = set() logger.info('Generating Dijkstra Routes') pb_robots = copy.deepcopy(problem.robots) sol_robots = list() print(len(pb_robots)) # Special for the first robot r_f = pb_robots.pop(0) r_f.awaken = True pb_robots = sorted( pb_robots, key=lambda robot: Edge(r_f.vertices, robot.vertices, None).weight) v = list() v.append(pb_robots[0].vertices) edges = dijkstra_path(v_1=r_f.vertices, v_2=pb_robots[0].vertices, vertices=graph.vertices, edges=graph.edges) r_f.track.extend(edges) sol_robots.append(r_f) solution_edges = solution_edges.union(set(edges)) r_p = r_f # Previous Robot pb_robots[0].awaken = True awake = 2 while len(pb_robots) > 0: logger.info('Generating Dijkstra, remaining: %i' % len(pb_robots)) r_i = pb_robots.pop(0) dist, prev = find_path(v_1=r_i.vertices, vertices=graph.vertices, edges=graph.edges) pb_robots = sorted(pb_robots, key=lambda robot: dist[robot.vertices]) robots = list() # Select Destination robots that have not been reached. They should not be a destination. for i in range(0, len(pb_robots)): if pb_robots[i].awaken: continue robots.append(pb_robots[i]) if len(robots) is 2: break for r in robots: edges = set( dijkstra_path(r_i.vertices, r.vertices, graph.vertices, graph.edges, dist, prev)) # Generated by Dijkstra found = False for edge in edges: for sol_edge in solution_edges: if edge.start == sol_edge.start and edge.end == sol_edge.end: found = True break if edge.start == sol_edge.end and edge.end == sol_edge.start: found = True break if found: r.awaken = False continue if r_i not in sol_robots: sol_robots.append(r_i) r_i.track.extend(edges) else: # Second Path r_p.track.extend(edges) solution_edges = solution_edges.union(edges) r.awaken = True awake += 1 r_p = r_i # Previous Robot # logger.info('Generating Dijkstra Routes Complete') # logger.info('Visualizing the solution') for robot in sol_robots: robot.sort_track() # print("Robot: %s" % (robot.vertices,)) # for t in robot.track: # print('%s -> %s' % (t.start, t.end)) solution = Solution(question_number=problem.question_number, robots=sol_robots) logger.critical('Finished Writing Solution for %i') logger.info('%i Robots Awake' % awake) writer.write_solution([solution]) print(solution.list_of_coordinates) # Visualize is using process (non blocking) Process(target=visualization.draw( problem, mst_edges=list(solution_edges), edges=graph.edges)).start()
def search_down(cls, self, entity): queryset = Edge().objects.filter(entity0 = entity AND name = cls.name)
def connect(cls,entity0,entity1): edge = Edge(entity0, entity1, name=cls.name) edge.save()
name = 'brainstore' class Relations: @classmethod def connect(cls,entity0,entity1): edge = Edge(entity0, entity1, name=cls.name) edge.save() @classmethod def search_down(cls, self, entity): queryset = Edge().objects.filter(entity0 = entity AND name = cls.name) @classmethod def search_up(cls, self, entity) queryset = Edge().objects.filter(entity1 = entity AND name = cls.name) class ConsturctRelation(Relations): name = "_construct" class ClassfiyRelation(Relations): name = "_classfiy" class Entity: @classmethod def define(cls): Node.objects.create(name = cls.name) @classmethod def search(cls):
def add_link(self, a, b, weight): l = Edge.new(a, b, weight) self.network.edges[l.id] = l self.network.rank() return l
def test_stripe(self): p1 = Vertex(Point(7, 0)) p2 = Vertex(Point(2, 2.5)) p3 = Vertex(Point(12, 3)) p4 = Vertex(Point(8, 5)) p5 = Vertex(Point(0, 7)) p6 = Vertex(Point(13, 8)) p7 = Vertex(Point(6, 11)) g = Graph() g.add_vertex(p1) g.add_vertex(p2) g.add_vertex(p3) g.add_vertex(p4) g.add_vertex(p5) g.add_vertex(p6) g.add_vertex(p7) g.add_edge(p1, p2) g.add_edge(p1, p3) g.add_edge(p2, p3) g.add_edge(p7, p6) g.add_edge(p3, p6) g.add_edge(p4, p6) g.add_edge(p4, p5) g.add_edge(p4, p7) g.add_edge(p5, p7) g.add_edge(p2, p5) dot = Point(11.5, 5.5) ans = list(stripe(g, dot)) self.assertEqual( ans[0], [ (-math.inf, 0.0), (0.0, 2.5), (2.5, 3.0), (3.0, 5.0), (5.0, 7.0), (7.0, 8.0), (8.0, 11.0), (11.0, math.inf), ], ) self.assertTrue( TestAlgorithms.fragmentation_eq( ans[1], { (-math.inf, 0.0): [], (0.0, 2.5): [Edge(p1, p2), Edge(p1, p3)], (2.5, 3.0): [Edge(p1, p3), Edge(p2, p3), Edge(p2, p5)], (3.0, 5.0): [Edge(p2, p5), Edge(p3, p6)], (5.0, 7.0): [ Edge(p2, p5), Edge(p4, p5), Edge(p4, p7), Edge(p4, p6), Edge(p3, p6), ], (7.0, 8.0): [ Edge(p5, p7), Edge(p4, p7), Edge(p4, p6), Edge(p3, p6), ], (8.0, 11.0): [Edge(p5, p7), Edge(p4, p7), Edge(p7, p6)], (11.0, math.inf): [], }, )) self.assertEqual(ans[2], (5.0, 7.0)) self.assertEqual(ans[3], [Edge(p4, p6), Edge(p3, p6)])