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 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 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)])
