def read_graphs(self, source, destination, textFileRead, xmlFileRead):
vertexReader = TextfileReader(textFileRead)
xmlread = XMLReader(xmlFileRead)
trace = Graph()
xmlread.read()
nodes = vertexReader.read()
print 'Text File Data:', nodes
edges = xmlread.get_edges()
print 'XML file Data:', edges
for n in nodes:
trace.add_vertex(n)
for e in edges:
segment = e.split('-')
trace.add_edge(segment[0], segment[1], int(segment[2]))
print '\nGraph data:'
for v in trace:
for w in v.get_connections():
vid = v.get_id()
wid = w.get_id()
print '( %s, %s, %3d)' % (vid, wid, v.get_weight(w))
dijkstra(trace, trace.get_vertex(source),
trace.get_vertex(destination))
target = trace.get_vertex(destination)
path = [target.get_id()]
shortest(target, path)
print '\nThe shortest path : %s' % (path[::-1])
def cal():
path = list()
final_path = list()
start = start_station.get()
#print(type(start))
destination = get_des.get()
#print(type(destination))
parent_dict,distance_dict = dijkstra(start)
path.append(destination)
flag = True
#防止出现错误
try:
final_path = serach_path(start,parent_dict,destination,path)
except KeyError:
start, destination = destination, start
parent_dict, distance_dict = dijkstra(start)
final_path.clear()
final_path = serach_path(start, parent_dict, destination, path)
final_path[len(final_path)-1] = destination
price_list = []
for i in road:
for k in road[i]:
price_list.append(k.get_name() + " " + str(cal_ticket(distance_dict[k.get_name()])) + "元")
for item in price_list:
ticket_price_list.insert('end', item)
dis = distance_dict[destination]
price = cal_ticket(dis)
ticket_price.set(str(price) + '元')
how_long.set(str(dis) + '公里')
if str(route).strip() == '':
route.insert('insert', final_path)
else:
route.delete('1.0', tk.END)
route.insert('insert', final_path)
flag = False
if flag == True:
final_path.reverse()
price_list = []
for i in road:
for k in road[i]:
price_list.append(k.get_name()+" "+str(cal_ticket(distance_dict[k.get_name()]))+"元")
for item in price_list:
ticket_price_list.insert('end',item)
dis = distance_dict[destination]
price = cal_ticket(dis)
ticket_price.set(str(price)+'元')
how_long.set(str(dis)+'公里')
if str(route).strip()=='':
route.insert('insert',final_path)
else:
route.delete('1.0',tk.END)
route.insert('insert', final_path)
with open('Route.txt','r+') as f:
f.seek(0)
f.truncate()
for station in final_path:
f.write(station+'\n')
def main():
grafo = Grafo()
grafo.mostrarNodos()
nodosIngresados = grafo.tomarNodosPorConsola()
#dijkstra(grafo, grafo.grafoNodos[1].nodoIndice-1)
dijkstra(grafo, nodosIngresados[0].nodoIndice - 1)
grafo.resetear()
#dijkstra(grafo, grafo.grafoNodos[3].nodoIndice-1)
dijkstra(grafo, nodosIngresados[1].nodoIndice - 1)
def test_bfs(self): connections= [[1,2],[3],[1,3,4],[],[3]] weights= [[5,3],[3],[2,5,6],[],[1]] self.assertEqual(dijkstra(connections,weights,0),[0, 5, 3, 8, 9]) self.assertEqual(dijkstra(connections,weights,1),[math.inf, 0, math.inf, 3, math.inf]) self.assertEqual(dijkstra(connections,weights,2),[math.inf, 2, 0, 5, 6]) self.assertEqual(dijkstra(connections,weights,3),[math.inf, math.inf, math.inf, 0, math.inf]) self.assertEqual(dijkstra(connections,weights,4),[math.inf, math.inf, math.inf, 1, 0])
def test_dijkstra01(self):
g = {
'0': {
'1': 10,
'2': 5
},
'1': {
'2': 2,
'3': 1
},
'2': {
'1': 3,
'3': 9,
'4': 2
},
'3': {
'4': 4
},
'4': {
'0': 7,
'3': 6
}
}
visited = dijkstra(g, '0')
self.assertEqual(visited, [('0', 0), ('2', 5), ('4', 7), ('1', 8),
('3', 9)])
def test_dijkstra():
from Dijkstra import dijkstra
graph = {}
graph["book"] = {}
graph["disk"] = {}
graph["poster"] = {}
graph["drum"] = {}
graph["bas-guitar"] = {}
graph["book"]["poster"] = 0
graph["book"]["disk"] = 5
graph["disk"]["bas-guitar"] = 15
graph["disk"]["drum"] = 30
graph["poster"]["bas-guitar"] = 30
graph["poster"]["drum"] = 35
graph["bas-guitar"]["piano"] = 20
graph["drum"]["piano"] = 10
cost = {}
cost[("book", "disk")] = 5
cost["book", "poster"] = 0
cost["disk", "bas-guitar"] = 15
cost["disk", "drum"] = 30
cost["poster", "bas-guitar"] = 30
cost["poster", "drum"] = 35
cost["bas-guitar", "piano"] = 20
cost["drum", "piano"] = 10
result = dijkstra(graph, cost, "book")
def getroute(graph, car, source, target, roads, crowd_roads_list):
# 根据道路限速和车辆速度初始化权值
for i in range(len(roads)):
if roads[i][6] == 1:
if car[3] == roads[i][2]:
graph[roads[i][4]-1][roads[i][5]-1] *= M_1
graph[roads[i][5]-1][roads[i][4]-1] *= M_1
elif (car[3] - roads[i][2] >= 2) or (roads[i][2] - car[3] >= 2):
graph[roads[i][4]-1][roads[i][5]-1] *= M_2
graph[roads[i][5]-1][roads[i][4]-1] *= M_2
else:
if car[3] == roads[i][2]:
graph[roads[i][4]-1][roads[i][5]-1] *= M_1
elif (car[3] - roads[i][2] >= 2) or (roads[i][2] - car[3] >= 2):
graph[roads[i][4]-1][roads[i][5]-1] *= M_2
# 根据道路拥挤状况调整图权值
for i in range(len(crowd_roads_list)):
road_from = crowd_roads_list[i].split('-')[0]
road_to = crowd_roads_list[i].split('-')[1]
# 当前拥挤道路的权值调整为inf
graph[road_from-1][road_to-1] = float('inf')
distance, path = dijkstra(graph, source)
dist = {}
for key, value in path.items():
pd = {}
for k, v in value.items():
pd[k] = {}
pd[k]['path'] = v
dist[key] = pd
return dist[source][target]['path']
def getroute(graph, car, source, target, roads):
for i in range(len(roads)):
if roads[i][6] == 1:
if car[3] == roads[i][2]:
graph[roads[i][4] - 1][roads[i][5] - 1] *= M_1
graph[roads[i][5] - 1][roads[i][4] - 1] *= M_1
elif (car[3] - roads[i][2] >= 2) or (roads[i][2] - car[3] >= 2):
graph[roads[i][4] - 1][roads[i][5] - 1] *= M_2
graph[roads[i][5] - 1][roads[i][4] - 1] *= M_2
else:
if car[3] == roads[i][2]:
graph[roads[i][4] - 1][roads[i][5] - 1] *= M_1
elif (car[3] - roads[i][2] >= 2) or (roads[i][2] - car[3] >= 2):
graph[roads[i][4] - 1][roads[i][5] - 1] *= M_2
distance, path = dijkstra(graph, source)
dist = {}
for key, value in path.items():
pd = {}
for k, v in value.items():
pd[k] = {}
pd[k]['path'] = v
dist[key] = pd
return dist[source][target]['path']
def inital_graph():
lon_s = []
lat_s = []
stations = []
with open('location.txt', 'r') as f:
for i in f:
hang = i.split(' ')
x = hang[0].split(',')
stations.append(x)
y = hang[1].split(',')
lon_s.append(float(y[0]))
lat_s.append(float(str(y[1])))
path = list()
final_path = list()
start = start_station.get()
destination = get_des.get()
parent_dict, distance_dict = dijkstra(start)
path.append(destination)
final_path = serach_path(start, parent_dict, destination, path)
final_lon_s = []
final_lat_s = []
point = []
for item in final_path:
i = 0
for a in stations:
if a[0] == item:
final_lon_s.append(lon_s[i])
final_lat_s.append(lat_s[i])
point.append(i)
i = 0
break
else:
i = i + 1
draw_pic_final(lon_s, lat_s, final_lon_s, final_lat_s, point)
def sure_1():
try:
src = int(ex_1.entry.get())
ter = int(ex_2.entry.get())
except:
lx_e.lab["text"] = "输入错误"
lx_e.lab["bg"] = "red"
dis, ret = dijkstra(graph, n, m, src)
lx_3.lab["text"] = "最短路权值:"
if (ret[ter] != 0):
lx_4.lab["text"] = str(dis[ter])
ss = "%d" % ter
def rout(x, trip):
if x == ret[x]:
trip = ("%d" % x) + "->" + trip
return trip
else:
trip = ("%d" % x) + "->" + trip
return rout(ret[x], trip)
ss = rout(ret[ter], ss)
lx_5.lab["text"] = "路径:"
lx_6.lab["text"] = ss
else:
lx_4.lab["text"] = "∞"
def Steiner(given, tab2):
#nodes = given.nodesIndex
graps = []
grap = given
ints = len(tab2) - 1
for x in range(0, ints):
new = dijkstra(grap, {'start': tab2[x], 'goal': tab2[x + 1]})
graps.append(new)
return graps
def test_astar_dijkstra(graph, start_node, end_node, list_path=False):
print("Running Dijkstra from node {} to node {}".format(start_node.label, end_node.label))
start_time = time.time()
dijkstra(graph, start_node, end_node)
elapsed = time.time() - start_time
print("Done, time elapsed: {} s".format(elapsed))
print("Distance from {} to {}: {}".format(start_node.label, end_node.label, end_node.dist))
print("Running A* from node {} to node {}".format(start_node.label, end_node.label))
start_time = time.time()
astar(graph, start_node, end_node)
elapsed = time.time() - start_time
print("Done, time elapsed: {} s".format(elapsed))
print("Distance from {} to {}: {}\n".format(start_node.label, end_node.label, end_node.dist))
if list_path and end_node.dist != math.inf:
node = end_node
while node is not None:
print("{},{}".format(node.lat, node.long))
node = node.predecessor
def cal_min_dist_path(crosses, distance_graph):
min_dist_dict = {}
for i in range(len(crosses)):
graph_temp = copy.deepcopy(distance_graph)
dist = {}
start_cross = i
distance, path = dijkstra(graph_temp, start_cross)
for key, value in path[i].items():
mes = {}
mes['path'] = value
mes['distance'] = distance[key]
dist[key] = mes
min_dist_dict[start_cross] = dist
#print(min_dist_dict)
return min_dist_dict
def main() -> None:
n: int = 0
try:
n = int(stdin.readline())
except ValueError:
print("Wrong \'n\' input format")
return
G: Graph = Graph(n, directed=True)
m: int = 0
try:
m = int(stdin.readline())
except ValueError:
print("Wrong \'m\' input format")
return
try:
for _ in range(m):
line = stdin.readline()
u, v, w = getEdge(line)
edge = Edge(u, v, w)
G.add_edge(edge)
except ValueError:
print("Wrong \'u v w\' input format")
return
src: int = 0
try:
src = int(stdin.readline())
except ValueError:
print("Wrong \'src\' input format")
return
t0 = time.perf_counter()
d, prev = dijkstra(G, src)
for v in range(1, n + 1):
path = get_path(G, prev, v)
print("{:d} {:.2f}".format(v, d[v]))
print(path, file=stderr)
t1 = time.perf_counter()
print("Time: {:.2f}".format((t1 - t0) * 1000), file=stderr)
def getroute(graph, car, source, target, roads, last_path_list):
if len(last_path_list) == 0:
pass
else:
last_path_set = set(last_path_list)
road_name = [road[0] for road in roads]
for i in last_path_set:
last_path_weight = B * last_path_list.count(i)
index_road = road_name.index(i)
road_from = roads[index_road][4]
road_to = roads[index_road][5]
road_double = roads[index_road][6]
if road_double == 1:
graph[road_from - 1][road_to - 1] *= last_path_weight
graph[road_to - 1][road_from - 1] *= last_path_weight
else:
graph[road_from - 1][road_to - 1] *= last_path_weight
for i in range(len(roads)):
if roads[i][6] == 1:
if car[3] == roads[i][2]:
graph[roads[i][4] - 1][roads[i][5] - 1] *= M_1
graph[roads[i][5] - 1][roads[i][4] - 1] *= M_1
elif (car[3] - roads[i][2] >= 2) or (roads[i][2] - car[3] >= 2):
graph[roads[i][4] - 1][roads[i][5] - 1] *= M_2
graph[roads[i][5] - 1][roads[i][4] - 1] *= M_2
else:
if car[3] == roads[i][2]:
graph[roads[i][4] - 1][roads[i][5] - 1] *= M_1
elif (car[3] - roads[i][2] >= 2) or (roads[i][2] - car[3] >= 2):
graph[roads[i][4] - 1][roads[i][5] - 1] *= M_2
#print(len(graph))
distance, path = dijkstra(graph, source)
dist = {}
for key, value in path.items():
pd = {}
for k, v in value.items():
pd[k] = {}
pd[k]['path'] = v
dist[key] = pd
return dist[source][target]['path']
def test():
right = 0
count = 0
d_better = 0
a_better = 0
for i in range(1, 200):
d = dijkstra(0, i)
a = astar(0, i)
print(d, '----', a)
if a == d:
right += 1
elif a > d:
d_better += 1
elif a < d:
a_better += 1
count += 1
accuracy = right / count
print(accuracy, '--', a_better, '--', d_better)
def test_dijkstra(self):
for _ in range(10000):
nxg = nx.fast_gnp_random_graph(randint(1, 10), randint(1, 9) / 10, directed=True)
print(sorted(nxg.nodes))
print(sorted(nxg.edges))
src = 0
g = gx.Digraph()
g.add_vertices_from(nxg.nodes)
g.add_edges_from(nxg.edges)
print(sorted(g.vertices))
print(sorted(g.edges))
pred1, dist1 = nx.dijkstra_predecessor_and_distance(nxg, src)
print(pred1)
print(dist1)
pred2, dist2 = dijkstra(g, src)
print(pred2)
print(dist2)
self.assertEqual(dist1, {k: v for k, v in dist2.items() if v != sys.maxsize})
def test_dijkstra(self):
# Arrange
edges = [[
Edge(0, 1, 7),
Edge(0, 2, 9),
Edge(0, 5, 14),
], [
Edge(1, 0, 7),
Edge(1, 2, 10),
Edge(1, 3, 15),
], [
Edge(2, 0, 9),
Edge(2, 1, 10),
Edge(2, 3, 11),
Edge(2, 5, 2),
], [
Edge(3, 1, 15),
Edge(3, 2, 11),
Edge(3, 4, 6),
], [
Edge(4, 3, 6),
Edge(4, 5, 9),
], [
Edge(5, 0, 14),
Edge(5, 2, 2),
Edge(5, 4, 9),
]]
# Act
actual = dijkstra(
[[1, 2, 5], [0, 2, 3], [0, 1, 3], [1, 2, 4], [3, 5], [0, 2, 4]],
edges)
# Assert
self.assertEqual(7, actual[1]['weight'])
self.assertEqual(9, actual[2]['weight'])
self.assertEqual(20, actual[3]['weight'])
self.assertEqual(20, actual[4]['weight'])
self.assertEqual(11, actual[5]['weight'])
def main():
n_cities, n_roads = [int(i) for i in sys.stdin.readline().split()]
prices = [int(i) for i in sys.stdin.readline().split()]
neighbors = {}
for i in range(n_cities):
for j in range(100):
neighbors[(i, j)] = [(i, j + 1)]
neighbors[i, 100] = []
for i in range(n_roads):
start, end, weight = [int(i) for i in sys.stdin.readline().split()]
for j in range(weight, 101):
neighbors[(start, j)].append((end, j - weight))
neighbors[(end, j)].append((start, j - weight))
for i in range(int(sys.stdin.readline())):
capacity, origin, dest = [int(i) for i in sys.stdin.readline().split()]
parents, distances = dijkstra(n_cities * (capacity + 1), prices,
neighbors, capacity, (origin, 0), dest)
print distances[(dest, 0)] if distances.get(
(dest, 0)) is not None else 'impossible'
'''
def tracar_menor_caminho(Grafo, origem, destino):
origem, destino = origem - 1, destino - 1
if not cidades[origem]:
return ('A Origem {} não existe no roteiro!'.format(origem + 1))
elif not cidades[destino]:
return ('O Destino {} não existe no roteiro!'.format(destino + 1))
else:
print('Origem: {}'.format(cidades[origem]))
print('Destino: {}'.format(cidades[destino]))
caminho = list()
caminho.append(destino)
atual = destino
distancias, antecessores = dijkstra(Grafo, origem)
while caminho[-1] != origem:
atual = antecessores[atual]
caminho.append(atual)
caminho = caminho[::-1]
rota = [cidades[i] for i in caminho]
if distancias[destino] == float("+infinity"):
#print('Não existe translado de {} para {}.'.format(cidades[origem], cidades[destino]))
return False
#print('O melhor trajeto com Origem em {} e Destino em {} é:\n{} \nDistância total: {} Km.'.format(origem+1, destino+1, rota, distancias[destino]))
return True
def johnson(graph):
result = []
n = len(graph)
source = 0
new_graph = copy.deepcopy(graph)
for edge in range(n):
new_graph[source][edge] = min(0, new_graph[source][edge])
node_weight = bellman_ford(graph=new_graph, source=source)
print(node_weight)
# graph weight change
print(graph)
for i in range(n):
for j in range(n):
graph[i][j] = graph[i][j] + node_weight[i] - node_weight[j]
print(graph)
for k in range(n):
out = dijkstra(graph=graph, source=k)
result.append(out)
return result
return path
while (True):
first_line = sys.stdin.readline().split()
edges = {}
neighbors = {}
if (int(first_line[0]) == 0): break
for i in range(int(first_line[1])):
edge = sys.stdin.readline().split()
o_edge = int(edge[0])
d_edge = int(edge[1])
weight = int(edge[2])
sides = (o_edge, d_edge)
if (o_edge != d_edge):
if edges.get(sides) is None or weight < edges[sides]:
edges[sides] = weight
if neighbors.get(o_edge) is None:
neighbors[o_edge] = [d_edge]
else:
neighbors[o_edge].append(d_edge)
parents, distances = dijkstra(
Graph(int(first_line[0]), edges, neighbors, int(first_line[3])))
for i in range(int(first_line[2])):
d_node = int(sys.stdin.readline())
print distances[d_node] if distances.get(
d_node) is not None else 'Impossible'
#print getPath(d_node)
print ''
def test_dijkstra(self):
g = {'0': {'1': 1, '2': 3}, '1': {'2': 1}, '2': {}}
visited = dijkstra(g, '0')
self.assertEqual(visited, [('0', 0), ('1', 1), ('2', 2)])
"""
reuters.findNeighbours()
reuters.generateDistances()
print(reuters.distances.values)
print("Distances complete: " + str(datetime.datetime.now()))
"""
edge_list = []
for edge in reuters.lattice:
if edge[0] != 0 and edge[1] != 0:
edge_list.append((edge[0], edge[1], 1))
edge_list.append((edge[1], edge[0], 1))
test_nodes = random.sample(reuters.concepts, 50)
for i in test_nodes:
for j in test_nodes:
print dijkstra(edge_list, i, j)
"""
input = "../DataEngineering/CleanTrainingData/clean_reuters_tdm.csv"
f = open(input)
vocab = f.readline()
f.close()
vocab = vocab[:-1]
vocab = vocab.split(',')
vocab_leng = len(vocab)
prox_seed = [[0.0 for i in range(vocab_leng)] for i in range(vocab_leng)]
proximity_matrix = np.array(prox_seed)
max_sd = reuters.distances.values.max()
print("Maximum distance: ", max_sd)
for i in range(vocab_leng):
node_i = reuters.attribute_labels[vocab[i]]
def __init__(self, model='Multiple'):
# 链路信息
self.Bandwidth = 1e7
self.Noise = 1e-9
self.ChannelGain = 1e-3
self.gamma = 1e-26
# self.a_dim = NODE_NUM + 1
self.s_dim = n_features
self.node_list = node_list # 创建节点列表
self.net_map = create_topology() # 创建网络拓扑图（表示连接关系的邻接矩阵）
self.netstate_scale = [] # 网络节点浮动范围
self.SWING_RANGE = CPT_SWING_RANGE # 网络变化幅度
self.delta = delta # 正态分布相关参数
self.destination = destination # 任务池中目的地集合，用于最短路算法
self.CPT_SCALE = TASK_CPT_SCALE # 计算资源上下限二元组（min， max）
# self.SCALE = CPT_SCALE
self.task_list = create_taskpool(TASK_NUM=2000) # 创建任务集合
self.test_task_list = create_taskpool(TASK_NUM=500)
self.observation = None # 记录当前的状态
self.iniOffloadDistribution() # 记录节点卸载情况（卸载任务数量，平均卸载比例）
# self.cpt_v = np.random.choice(range(1, 4), size=len(node_list), p=[0.2, 0.6, 0.2]) #计算速率
self.trans_v = np.random.randint(20, 30, size=len(node_list)) * 10
self.net_states = np.array(np.random.randint(int(END_NODE_CPT_SCALE[0]), int(END_NODE_CPT_SCALE[1]), 10).tolist() + \
np.random.randint(int(NODE_CPT_SCALE[0]), int(NODE_CPT_SCALE[1]), size=len(node_list)-20).tolist() + \
np.random.randint(int(END_NODE_CPT_SCALE[0]), int(END_NODE_CPT_SCALE[1]), 10).tolist()) / 10
# self.net_states[0] = 0
# self.net_states[-1] = 0
self.distance_to_ap = np.random.randint(DISTANCE_SCALE[0],
DISTANCE_SCALE[1],
size=len(node_list))
# 正态分布的均方差
for each in range(len(self.node_list)):
tmp_cpt_scale = np.array([i for i in range(-self.SWING_RANGE, self.SWING_RANGE + 1)]) + \
self.net_states[each]
self.netstate_scale.append(tmp_cpt_scale)
# self.netstate_scale = [[net_state - 1, net_state, net_state + 1] for net_state in net_states]
# self.netstate_transfer_prob = np.zeros([net_map.shape[0], 3])
self.netstate_transfer_prob = []
for each_node in range(len(self.node_list)):
scales = self.netstate_scale[each_node]
probes = 1 / (math.sqrt(2 * math.pi * self.delta)) * \
np.exp(-(np.square(scales - self.net_states[each_node])) / 2 * pow(self.delta, 2))
sum_ = np.sum(probes)
if sum_ > 1:
max_idx = np.argmax(probes)
probes[max_idx] + 1 - sum_
else:
probes[0] = (1 - sum_) / 2 + probes[0]
probes[-1] = (1 - sum_) / 2 + probes[-1]
self.netstate_transfer_prob.append(probes)
distance_map = np.copy(self.net_map)
for i in node_list:
for j in range(i + 1, node_list[-1] + 1):
if distance_map[i, j] == 1:
distance_map[i,
j] = random.randint(DISTANCE_SCALE[0],
DISTANCE_SCALE[1])
distance_map[j, i] = distance_map[i, j]
self.distance_map = distance_map
self.path_list = []
self.d_distance_list = []
for each in self.destination:
tmp_dis, tmp_path = dijkstra(distance_map, each)
self.path_list.append(tmp_path)
self.d_distance_list.append(tmp_dis)
self.neighbor_list = []
# 创建邻接节点列表
for each in node_list:
tmp_neighbors = []
for i in range(len(node_list)):
if self.net_map[each][i] != 0:
tmp_neighbors.append(i)
self.neighbor_list.append(tmp_neighbors)
if model == 'Multiple':
self.iniTimeLine(n=3)
self.TP = 0
self.accumlatedTS = 0
next(reader)
for row in reader:
s = str(int(float(row[0])))
e = str(int(float(row[1])))
if s not in ['264', '265'] and e not in ['264', '265'] and s != e:
taxi_time[s, e] = float(row[2])
multi_time = {}
count_bike = {}
graph = build_graph()
print('original graph nodes:' + str(len(graph.nodes)))
print('original graph edges:' + str(len(graph.distances)))
with open('data/multimodal.csv', 'w') as file:
file.write('origin,destination,time\n')
for id1 in range(1, 264):
origin = 'taxi_' + str(id1)
length, path, route = dijkstra(graph, origin)
for id2 in range(1, 264):
if id1 != id2 and (str(id1), str(id2)) in taxi_time:
dest = 'taxi_' + str(id2)
time = length[dest]
file.write(str(id1) + ',' + str(id2) + ',' + str(time) + '\n')
print(str(id1) + ',' + str(id2) + ',' + str(time))
# x = str(id2)
# shortest_path = [x]
# route_time = []
# route_type = []
# while x != str(id1):
# shortest_path.append(path[x])
# route_time.append(graph.distances[path[x],x])
# if x=='132' and route[x]=='walk':
# route_type.append('airtrain')
G('J25', 'F11')
G('J25', 'J23')
G('J25', 'J24')
G('J24', 'J26')
G('J24', 'F9')
G('J24', 'F8')
G('J24', 'J23')
G('J23', 'F7')
G('J23', 'J22')
G('J22', 'F4')
G('J22', 'F5')
G('J22', 'F6')
G('J22', 'J21')
G('J21', 'F1')
G('J21', 'F2')
G('J21', 'F3')
G('J21', 'J13')
G('J21', 'J14')
initG()
dijkstra(RoadMatrix) # create path and distance json
with open('./Path.txt', 'r') as f:
json_path = f.read()
with open('./Distance.txt', 'r') as f:
json_distance = f.read()
path = json.loads(json_path)
print path['D1']['D2']
def lis2graph(layer):
"""Maakt Graph met LIS-netwerk en bepaalt onderbemalingen.
Vult [ONTV_VAN] en [X_OBEMAL].
Gebruikt [LOOST_OP] en [VAN_KNOOPN] als edge (relation) en VAN_KNOOPN als node"""
# graph aanmaken
graph = Graph()
graph_rev = Graph()
d_K_ONTV_VAN = {} # alle onderliggende gemalen
d_K_ONTV_VAN_n1 = {
} # alle onderliggende gemalen op 1 niveau diep ivm optellen overcapaciteit
print_log("netwerk opslaan als graph...", "i")
for feature in layer.getFeatures(): # .getFeatures()
VAN_KNOOPN = feature["VAN_KNOOPN"]
LOOST_OP = feature["K_LOOST_OP"]
graph.add_node(VAN_KNOOPN)
graph_rev.add_node(VAN_KNOOPN)
if LOOST_OP != None:
graph.add_edge(VAN_KNOOPN, LOOST_OP,
1) # richting behouden voor bovenliggende gebied
graph_rev.add_edge(
LOOST_OP, VAN_KNOOPN,
1) # richting omdraaien voor onderliggende gebied
edges_as_tuple = list(
graph.distances) # lijst met tuples: [('A', 'B'), ('C', 'B')]
print_log("onderbemaling bepalen voor rioolgemalen en zuiveringen...", "i")
where_clause = "Join_Count > 0"
layer.startEditing()
for i, feature in enumerate(layer.getFeatures()): # .getFeatures()
if not feature["count"] >= 1: continue
VAN_KNOOPN = feature["VAN_KNOOPN"]
nodes = dijkstra(graph, VAN_KNOOPN)[0]
print_log("nodes for {}: {}".format(VAN_KNOOPN, nodes), 'd')
K_KNP_EIND, X_OPPOMP = [(key, value) for key, value in sorted(
nodes.iteritems(), key=lambda (k, v): (v, k))][-1]
print_log(
"endnode for {}: {},{}".format(VAN_KNOOPN, K_KNP_EIND, X_OPPOMP),
'd')
d_edges = dijkstra(graph_rev,
VAN_KNOOPN)[1] # {'B': 'A', 'C': 'B', 'D': 'C'}
l_onderliggende_gemalen = str(list(d_edges)) # [u'ZRE-123',u'ZRE-234']
l_onderliggende_gemalen = l_onderliggende_gemalen.replace(
"u'", "'").replace("[", "").replace("]", "")
layer.changeAttributeValue(
feature.id(), layer.fieldNameIndex("K_ONTV_VAN"),
l_onderliggende_gemalen) # K_ONTV_VAN = 'ZRE-1','ZRE-2'
layer.changeAttributeValue(
feature.id(), layer.fieldNameIndex("X_OBEMAL"),
len(list(d_edges))) # X_OBEMAL = 2 (aantal onderbemalingen)
layer.changeAttributeValue(
feature.id(), layer.fieldNameIndex("X_OPPOMP"), X_OPPOMP + 1
) # X_OPPOMP = 1 (aantal keer oppompen tot rwzi) met shortestPath ('RWZI','ZRE-4')
layer.changeAttributeValue(
feature.id(), layer.fieldNameIndex("K_KNP_EIND"), K_KNP_EIND
) # eindbemalingsgebied / overnamepunt. bepaald uit netwerk.
d_K_ONTV_VAN[VAN_KNOOPN] = l_onderliggende_gemalen
# onderbemalingen 1 niveau diep
l_onderliggende_gemalen_n1 = [
start for start, end in edges_as_tuple if end == VAN_KNOOPN
] # dus start['A', 'C'] uit tuples[('A', 'B'),('C', 'B')] als end == 'B'
d_K_ONTV_VAN_n1[VAN_KNOOPN] = str(l_onderliggende_gemalen_n1).replace(
"u'", "'").replace("[", "").replace(
"]", "") # naar str() en verwijder u'tjes en haken
layer.commitChanges()
return [d_K_ONTV_VAN, d_K_ONTV_VAN_n1]
# next(reader)
# for row in reader:
# old_multi_time[row[0],row[1]] = float(row[2])
bike_ids = set()
with open('data/bikeStation_coordinates.csv') as f:
reader = csv.reader(f)
next(reader)
for row in reader:
bike_ids.add('bike_' + row[0])
graph = build_graph()
dest = set()
for (id1, id2), ti in taxi_time.items():
if id1 == '132':
dest.add(id2)
new_multi_time = {}
original_graph = deepcopy(graph)
import glob
exist = set(glob.glob("data/ebike/*.csv"))
for b_id in bike_ids:
modify_edges(graph, b_id)
filename = 'data/ebike/' + b_id + '.csv'
if filename not in exist:
with open(filename, 'w') as file:
dist, path, route = dijkstra(graph, '132')
for id2 in dest:
print(b_id, '132', id2, dist[id2])
file.write('132' + ',' + id2 + ',' + str(dist[id2]) + ',' +
str(taxi_time['132', id2]) + '\n')
graph = original_graph
from Dijkstra import dijkstra
from WeightedGraph import import_weighted_graph
names = {}
print("Reading names file...")
with open("C:\L7Skandinavia-navn", "r", encoding="utf-8") as name_file:
name_file.readline() # Skip første linje med antall
for raw_line in name_file:
parts = raw_line.rstrip().split()
names[int(parts[0])] = parts[2][1:-1]
graph = import_weighted_graph("C:\\vgSkandinavia", names)
start_node = graph.nodes[37774] # 37774 er Kalvskinnet
end_node = graph.nodes[18058] # 18058 er Moholt
print("Running Dijkstra from node {} to node {}".format(
start_node.label, end_node.label))
start_time = time.time()
dijkstra(graph, start_node, end_node)
elapsed = time.time() - start_time
print("Done, time elapsed: {} s".format(elapsed))
if end_node.dist != math.inf:
print("Distance from {} to {}: {}".format(start_node.label, end_node.label,
end_node.dist))
node = end_node
while node is not None:
print(node.label)
node = node.predecessor
next(reader)
for row in reader:
s = str(int(float(row[0])))
e = str(int(float(row[1])))
if s not in ['264', '265'] and e not in ['264', '265'] and s != e:
taxi_time[s, e] = float(row[2])
multi_time = {}
count_bike = {}
graph = build_graph()
print('nodes:' + str(len(graph.nodes)))
print('edges:' + str(len(graph.distances)))
bike_pair = {}
with open('data/bike_pair_times.csv', 'w') as file:
file.write('origin,destination,number_of_appearance\n')
for id1 in range(1, 264):
length, path, route = dijkstra(graph, str(id1))
for id2 in range(1, 264):
if id1 != id2 and (str(id1), str(id2)) in taxi_time:
print(str(id1) + ',' + str(id2))
x = str(id2)
route_type = []
while x != str(id1):
if x[:4] == 'bike' and path[x][:4] == 'bike':
d = x[5:]
o = path[x][5:]
if (o, d) in bike_pair:
bike_pair[o, d] += 1
else:
bike_pair[o, d] = 1
x = path[x]
for (o, d), t in bike_pair.items():
