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():