def test_graph():
G = Graph()
G.add_edge(1, 2, 3)
G.add_edge(1, 3, 2)
assert G.get_edge_weight(1, 2) == 3
assert G.get_edge_weight(1, 3) == 2
assert G.get_adjacent_nodes(1) == {2, 3}
def SPLIT(Distancias, Demandas, permutacion, capacidad, orden):
NODOS = [i for i in range(len(permutacion) + 1)]
GRAFO = []
RUTAS = []
for i in range(len(NODOS)):
for j in range(i + 1, len(NODOS)):
r = [0]
acum = 0
for k in range(j, i, -1):
r.append(permutacion[k - 1])
acum = acum + Demandas[permutacion[k - 1]]
r.append(0)
r.reverse()
if (acum <= capacidad):
d = calcularDistancia(r, Distancias, orden)
arco = (i, j, round(d, 2))
GRAFO.append(arco)
RUTAS.append(r)
print("GRAFO:")
for i in range(len(GRAFO)):
print(GRAFO[i], ":", RUTAS[i])
sec = list(Graph(GRAFO).dijkstra(NODOS[0], NODOS[-1]))
print("Secuencia: ", sec)
PETALOS, FO = obtenerPetalos(GRAFO, RUTAS, sec)
print("PETALOS PERMUTACIÓN:")
print(PETALOS, FO, sum(FO))
return (PETALOS, FO, sum(FO))
def test_dijkstra():
nodes = ("S", "T", "A", "B", "C", "D", "E", "F", "G")
S, T, A, B, C, D, E, F, G = nodes
graph = Graph()
graph.add_edge(S, A, 4)
graph.add_edge(S, B, 3)
graph.add_edge(S, D, 7)
graph.add_edge(A, C, 1)
graph.add_edge(B, S, 3)
graph.add_edge(B, D, 4)
graph.add_edge(C, E, 1)
graph.add_edge(C, D, 3)
graph.add_edge(D, E, 1)
graph.add_edge(D, T, 3)
graph.add_edge(D, F, 5)
graph.add_edge(E, G, 2)
graph.add_edge(G, E, 2)
graph.add_edge(G, T, 3)
graph.add_edge(T, F, 5)
dijkstra = DijkstraSPF(graph, S)
for v in nodes:
print("%3s %3s" % (v, dijkstra.get_distance(v)))
assert dijkstra.get_distance(T) == 10
assert dijkstra.get_path(T) == ["S", "D", "T"]
def get_itinerary(start, destination):
# We check if the starting and ending point begins by B1 or B3
if not start.startswith('B3') and not start.startswith('B1'):
raise ValueError(
f'Start name should start with either B1 or B3. Got {start}')
if not destination.startswith('B3') and not destination.startswith('B1'):
raise ValueError(
f'Start name should start with either B1 or B3. Got {destination}')
# We get all the rooms saved in the database
rooms = query_db("SELECT name, linked_to FROM points")
graph = Graph()
for room in rooms:
# We convert each room into a dictionary and we get the current room name
room = dict(room)
room_name = room.get("name", "")
if room_name:
# For each room connected to our current room
for room_connected_and_distance in room.get("linked_to",
"").split("|"):
# On the connected room we get the name of the room and the distance
room_connected, distance = room_connected_and_distance.split(
";")
# We add the connection in our graph
graph.add_edge(room_name, room_connected, int(distance))
# We generate our dijkstra and we search ou path
dijkstra = DijkstraSPF(graph, start)
itinerary_list = dijkstra.get_path(destination)
return itinerary_list
def CalculoRota(request):
parametros = JSONParser().parse(request)
if not checkRequestValido(parametros):
return JsonResponse({'mensagem': 'Parametros invalidos'}, status=status.HTTP_400_BAD_REQUEST)
#obter rotas
rotas = Rota.objects.all()
rotas = rotas.filter(mapa__nome__icontains= parametros['mapa'])
#checar se os objetos existem no banco
if not rotas.exists():
return JsonResponse({'mensagem': 'Mapa nao encontrado'}, status=status.HTTP_404_NOT_FOUND)
if not rotas.filter(origem__icontains= parametros['origem']):
return JsonResponse({'mensagem': 'Origem nao encontrada no mapa'}, status=status.HTTP_404_NOT_FOUND)
if not rotas.filter(destino__icontains= parametros['destino']):
return JsonResponse({'mensagem': 'Destino nao encontrado no mapa'}, status=status.HTTP_404_NOT_FOUND)
graph = Graph()
for rota in rotas:
graph.add_edge(rota.origem, rota.destino, rota.distancia)
dijkstra = DijkstraSPF(graph, parametros['origem'])
caminho = dijkstra.get_path(parametros['destino'])
gasto = dijkstra.get_distance(parametros['destino'])/parametros['autonomia']*parametros['valorLitro']
return JsonResponse({'origem': parametros['origem'],'destino': parametros['destino'],'gasto': gasto,'rota': caminho}, status=status.HTTP_200_OK)
def __init__(self, source_file=None):
with open(source_file) as f:
maze = [list(line.strip('\r\n')) for line in f]
self.width = max([len(row) for row in maze])
self.height = len(maze)
self.loc_warp = dict()
self.warp_loc = defaultdict(set)
self.graph = Graph()
self.interior = set()
self.exterior = set()
# Copy the file to the local dict:
self.maze = self.copy_to_dict(maze)
# Identify all the wormhole tokens:
self.parse_warps()
# Populate graph:
self.build_graph()
# Start/finish for the maze:
self.source = self.warp_loc['AA'].pop()
self.target = self.warp_loc['ZZ'].pop()
# Part 2:
self.scores = dict()
def create_vis_graph(vertices: List[List[float]],
holes: List[List[List[float]]] = None) -> Graph:
"""
Create a visibility graph based on the vertices of the polygon
:param vertices: List[List[float]]
:return: Graph object
"""
graph = Graph()
for i in range(len(vertices)):
for j in range(i + 1, len(vertices)):
vis = True
for k in range(len(vertices)):
k1 = k
k2 = (k + 1) % (len(vertices))
if (k1 == i) and (k2 == j):
vis = True
break
if not diagonal(i, j, vertices) and (
(i + 1) % len(vertices)) != j and (
(j + 1) % len(vertices)) != i:
vis = False
break
if intersectProp(vertices[i], vertices[j], vertices[k1],
vertices[k2]):
vis = False
break
if vis:
d = l2_dist(vertices[i], vertices[j])
graph.add_edge(i, j, d)
graph.add_edge(j, i, d)
return graph
def create_graph(number_of_elements):
global graph
graph = Graph(number_of_elements)
for i in range(1, number_of_elements):
for j in range(i, number_of_elements + 1):
if i % 2 == 1:
if max(i - j, j - i) <= 3 and i != j:
graph.add_edge(i, j)
else:
if max(i - j, j - i) <= 2 and i != j:
graph.add_edge(i, j)
start = time.time()
(path_output,
weight_output) = graph.dijkstra_shortest_path(int(from_entry.get()),
int(to_entry.get()))
end = time.time()
visualize_shortest_path(path_output)
print("output ", path_output[::-1])
print("time ", end - start)
running_time.set("Running Time:" +
str("{0:.2f}".format(round((end - start) * 1000, 2))) +
"ms")
string = "Path: "
for i in range(len(path_output[::-1]) - 1):
string += str(path_output[::-1][i]) + " -> "
path_var.set(string + str(path_output[::-1][len(path_output) - 1]))
weight_var.set("Total Weight: " + str(weight_output))
print(graph.dijkstra_shortest_path_distances(int(to_entry.get())))
def test_abstract_dijkstra_spf():
graph = Graph()
with pytest.raises(NotImplementedError):
AbstractDijkstraSPF.get_adjacent_nodes(graph, 0)
with pytest.raises(NotImplementedError):
AbstractDijkstraSPF.get_edge_weight(graph, 0, 1)
def createGraph():
graph = Graph()
f = open("p1_graph.txt", "r")
for line in f:
line = line.strip()
path_values = line.split(",")
graph.add_edge(int(path_values[0]),int(path_values[1]),int(path_values[2]))
return graph
def test_floyd_negative(self):
inf = float("inf")
g = Graph(4)
g.edges = [[0, inf, -2, inf],
[4, 0, 3, inf],
[inf, inf, 0, 2],
[inf, -1, inf, 0]]
expected = [[0, -1, -2, 0], [4, 0, 2, 4], [5, 1, 0, 2], [3, -1, 1, 0]]
self.assertEqual(floyd(g), expected)
def build_dijkstra_graph(stations: list) -> Graph:
g = Graph()
# Build the graph edges
for s in stations:
for n in s.neighbours:
g.add_edge(s.id, n.station.id, n.get_wtt())
return g
def findPathBetweenTwoStationInSameLayer(id1, id2, layerName):
if id1 == id2:
return [id1]
layer = mapNameToLayer[layerName]
graph = mapNameToGraph[layerName]
#
listFakeId = convertFakeId([id1, id2], layer)
g = Graph()
route = g.dijkstra(graph, listFakeId[0], listFakeId[1])
return convertToTrustId(route, layer)
def main(condition, threshold, co, experiment,
rounds): # coalition = 10: psfa, others: baseline
for t in range(experiment):
dynamic_change(stream_rates, traffic_condition[condition])
i_nodes = copy.deepcopy(nodes)
i_edges = copy.deepcopy(edges)
i_stream_rate = copy.deepcopy(stream_rates)
graph = Graph(i_nodes, i_edges, i_stream_rate)
if co == 10:
coalitions = dk.coalition(graph, i_stream_rate, threshold)
else:
coalitions = adapt_baseline(
form_baseline(baseline_groups[co - 1], i_stream_rate),
i_stream_rate)
group_lanes = [e[0] for e in coalitions]
group_streams = [e[1] for e in coalitions]
#print('group_streams = ', group_streams)
interval_times = interval_time(group_streams, total_duration,
minimum_waiting_time)
streams = {lane: stream_rates[lane] for lane in nodes}
prob_car = {lane: stream_rates[lane] / 100 for lane in nodes} #0.25
total_number = 0
pass_cars = 0
accident = 0
pre_acc = 0
for i in range(rounds):
for c in range(len(coalitions)):
group = coalitions[c][0]
for j in range(int(interval_times[c])): #every 10 seconds
all_cars = []
for lane in group:
all_cars = all_cars + lane_list[lane].car_list
accident_analysis = current_accident(all_cars)
accident = accident + accident_analysis[0]
remove_crash_cars(accident_analysis[1], all_cars)
pre_acc = pre_acc + tellCollapse(all_cars)
pre_acc = pre_acc + tellCollapse(all_cars)
for lane in group:
pass_cars = pass_cars + lane_list[lane].move_all()
if random.uniform(0, 1) < prob_car[lane]:
lane_list[lane].car_list.append(
Car(lane, lane + str(i) + str(j)))
stat_pass_cars.append(pass_cars / rounds)
stat_accident.append(accident / rounds)
stat_pred_accident.append(pre_acc / rounds)
return stat_pass_cars, stat_accident, stat_pred_accident
def check_solution(adj_matrix):
from dijkstra import Graph, DijkstraSPF
n = len(adj_matrix)
node_names = [str(i) for i in adj_matrix]
graph = Graph()
for i in range(n):
for j in range(n):
graph.add_edge(node_names[i], node_names[j], adj_matrix[i, j])
solution = DijkstraSPF(graph, node_names[0])
result = [solution.get_distance(i) for i in node_names]
return result
def generate_random_graph(nodes, edges_per_node, max_weight):
graph = Graph()
for node_index in range(1, nodes + 1):
for edge_index in range(edges_per_node):
weight = randint(1, max_weight)
neighbour = node_index
while neighbour == node_index:
neighbour = randint(0, nodes)
graph.add_edge_with_cost(node_index, neighbour, weight)
return graph
def find_shortest_traversal(matrix, node_list):
"""
Given a matrix and a list of nodes, this function will output the shortest traversal visiting the nodes in that order.
:param matrix: The matrix
:param node_list: The list of nodes
:return: List with path
"""
path = [node_list[0]]
graph = Graph()
for i in range(len(node_list[:-1])):
path.extend(graph.dijkstra(graph=matrix, src=node_list[i])[node_list[i+1]+1][1:])
return path
def from_file():
instance = Graph()
path = os.path.join(os.path.dirname(__file__), 'dijkstraData.txt')
testfile = open(path, 'r')
while testfile:
line = testfile.readline().rstrip()
if not line:
break
values = line.split('\t')
head = int(values.pop(0))
for pair in values:
tail, weight = map(int, pair.split(','))
instance.add_edge(head, tail, weight)
return instance
def create_new_nodeset_graph_and_paint(screen, num_of_nodes,
connections_per_node):
global nodes, g
#nodes = generate_list_of_connected_nodes(260, 5)
nodes = generate_list_of_connected_nodes(num_of_nodes,
connections_per_node)
#nodes = generate_list_of_connected_nodes(160, 2)
g = Graph()
generate_graph_from_node_list(g, nodes)
screen.fill((0, 0, 0))
draw_node_list(screen, nodes)
return g
def get_distance_dict(adj_mat):
"""
Returns a dictionary of the shortest distances from all node to all others in the parameter adjacency matrix.
:param adj_mat: A adjacency matrix (mxn array) for the graph to calculate distances from
:return: A dictionary with shortest distances from all nodes to all others
"""
distances = {}
graph = Graph()
for i in range(len(adj_mat)):
distances[i] = {}
for i in range(len(adj_mat)):
for j in range(len(adj_mat)):
distances[i][j] = graph.dijkstra(adj_mat, i)[0][j]
return distances
def get_shortest_path(src, dst, link_costs, ROUTER_ID_MAPPING):
if src == dst: return 0, int(ROUTER_ID_MAPPING[src])
# Make link_costs symmetrical
symm_link_costs = []
for link in link_costs:
symm_link_costs.append(link)
symm_link_costs.append((link[1], link[0], link[2]))
network = Graph(symm_link_costs)
try:
shortest_path = network.dijkstra(src, dst)
except: return 65535, 65535
path_cost = 0
for hop in range(len(shortest_path)-1):
path_cost += utils.get_link_cost(shortest_path[hop], shortest_path[hop+1], symm_link_costs)
return path_cost, int(ROUTER_ID_MAPPING[shortest_path[1]])
def main():
count = 0
input = open('dij10.txt', 'r')
x = input.read()
tamanhoMatriz = 0
#leitura do arquivo da matriz de adjacencia
for row, line in enumerate(x.split('\n')):
for col, val in enumerate(line.split(' ')):
if (count == 0):
tamanhoMatriz = int(val)
count += 1
break
break
count = 0
matriz = np.zeros((tamanhoMatriz, tamanhoMatriz))
matrizFinal = np.zeros((tamanhoMatriz, tamanhoMatriz))
for row, line in enumerate(x.split('\n')):
for col, val in enumerate(line.split(' ')):
if (count == 0):
tamanhoMatriz = int(val)
count += 1
break
else:
count += 2
matriz[int(row - 1)][int(col)] = int(val)
for i in range(0, tamanhoMatriz):
for j in range(i, tamanhoMatriz):
if i == j:
continue
else:
matrizFinal[i][j] = matriz[i][j - i - 1]
matrizFinal[j][i] = matriz[i][j - i - 1]
print('Matriz de adjacencias: \n')
print(matrizFinal)
g = Graph(tamanhoMatriz)
g.graph = matrizFinal
g.dijkstra(2)
count -= 1
def get_distance_list_fast(self, adj_mat):
"""
Returns a list of the shortest distances from all node to all others in the parameter adjacency matrix.
index corresponds to node, value correponds to distances.
:param adj_mat: An adjacency matrix (mxn array) for the graph to calculate distances from
:return: A list with shortest distances from all nodes to all others
"""
distances = [0 for j in range(len(adj_mat))]
dijkstras = [0 for j in range(len(adj_mat))]
graph = Graph()
for i in range(len(adj_mat)):
distances[i] = [0 for j in range(len(adj_mat))]
dijkstras[i] = graph.dijkstra(adj_mat, i)[0]
for i in range(len(adj_mat)):
for j in range(len(adj_mat)):
distances[i][j] = dijkstras[i][j]
return distances
def compute_graphs(self, data, my_coords: Coords):
graphs = list()
# Crea tots els ordres possibles de recorregut
used_orders = set()
for i, key_order in enumerate(permutations(data.keys(), len(data)), start=1):
if key_order in used_orders:
continue
used_orders.add(key_order)
used_orders.add(key_order[::-1]) # Only one direction is enough
init = time()
ordered_shops = list()
ordered_shops.append([Shop(identifier='A', coords=my_coords)])
ordered_shops.extend([data[key] for key in key_order])
ordered_shops.append([Shop(identifier='B', coords=my_coords)])
graph = Graph(self.compute_edges(ordered_shops))
graphs.append(graph)
print(f'Computed subgraph {i} in {time() - init:.2f}s')
return graphs
def get_path_dict(adj_mat):
"""
Returns a dictionary where the key values are node-indexes and the values are a new dict.
The keys in this new dict are all nodes in graph. The values for these keys are shortest paths from original
node to key node.
:param adj_mat:
:return:
"""
paths = {}
graph = Graph()
for i in range(len(adj_mat)):
paths[i] = {}
for i in range(len(adj_mat)):
for j in range(len(adj_mat)):
if i == j:
paths[i][j] = [i]
else:
paths[i][j] = graph.dijkstra(adj_mat, i)[j+1]
return paths
def calculate_cluster_distances(ad_mat, indexes):
"""
Calculate the distances between the given list of indexes in the given adjacency matrix, using dijkstra.
:param ad_mat: The adjacency matrix representing the graph
:param indexes: The indexes you want to calculate distances for
:return: A dict {node: {other_node: distance}}
"""
distances = {}
graph = Graph()
# Each node maintains a list with nodes distances to itself
for i in indexes:
for j in indexes:
distances[i] = {j:0}
for i in indexes:
for j in indexes:
try:
distances[i][j] = graph.dijkstra(ad_mat, i)[0][j]
except:
distances[i][j] = 0
return distances
def delivery_process(request):
if request.method == 'POST':
body_unicode = request.body.decode('utf-8')
body = json.loads(body_unicode)
map_name = body['map_name']
origin = body['origin']
destination = body['destination']
truck_range = body['truck_range']
fuel_cost = body['fuel_cost']
if map_name == "" or map_name == "[]" or map_name is None:
return JsonResponse("Invalid Parameters",
status=status.HTTP_400_BAD_REQUEST,
safe=False)
deliveries = Delivery.objects.all()
deliveries = deliveries.filter(map_name__icontains=map_name)
if deliveries.count() == 0:
return JsonResponse("Invalid Parameters: map name not found",
status=status.HTTP_400_BAD_REQUEST,
safe=False)
deliveries_serializer = DeliverySerializer(deliveries, many=True)
deliveries = dict(deliveries_serializer.data[0])['routes']
nodes = set([origin, destination])
g = Graph()
for delivery in deliveries:
route = list(delivery.items())
nodes.add(route[0][1])
nodes.add(route[1][1])
g.add_edge(route[0][1], route[1][1], route[2][1])
dijkstra = DijkstraSPF(g, origin)
shortest_distance = dijkstra.get_distance(destination)
path = " -> ".join(dijkstra.get_path(destination))
cost = (shortest_distance / truck_range) * fuel_cost
return JsonResponse({"route": path, "cost": cost}, safe=False)
def output_path(ad_mat):
# Create a graph
graph = Graph()
visited = [0] # Start at node 0
home_drops = []
path = [0]
while len(visited) != len(ad_mat):
remaining = []
for node in range(len(ad_mat)):
if node not in visited:
remaining.append(node)
best = remaining[0]
for j in remaining[1:]:
if graph.dijkstra(ad_mat, visited[-1])[0][j] < graph.dijkstra(
ad_mat, visited[-1])[0][best]:
best = j
path.extend(graph.dijkstra(ad_mat, visited[-1])[best + 1][1:])
visited.append(best)
# Route from end node to start node
path.extend(graph.dijkstra(ad_mat, visited[-1])[1][1:])
return path
from configure import configure
from dijkstra import Graph
import numpy as np
if __name__ == '__main__':
conf = configure()
graph = Graph(graph=conf.dis)
num = graph.VertexNum
table = np.zeros(shape=[num, num], dtype=int)
for i in range(num):
for j in range(num):
dist, path = graph.Dijkstra(i, j)
Path = []
for t in range(len(path)):
Path.append(graph.labels[path[len(path) - 1 - t]])
if (len(Path) > 1):
table[i][j] = Path[1]
else:
table[i][j] = Path[0]
print('从节点{}到节点{}的最短路径为：\n{}\n最短路径长度为：{}'.format(i, j, Path, dist))
# print(table)
for i in range(num):
print('节点{}的路由表为：'.format(i))
print('-------------------------------------------------------')
for j in range(num):
if i == j:
continue
else:
print('到节点{}\t转发给节点{}'.format(j, table[i][j]))
print('-------------------------------------------------------')
plotter2 = Plotter()
plotter2.add_obstacles(workspace_obstacles)
plotter2.add_c_space_obstacles(c_space_obstacles)
plotter2.add_visibility_graph(lines)
plotter2.add_robot(source, dist)
plotter2.show_graph()
# step 3:
with open(query, 'r') as f:
dest = tuple(map(float, f.readline().split(',')))
lines = get_visibility_graph(c_space_obstacles, source, dest)
# TODO: fill in the next line
graph = Graph()
for l in lines:
graph.add_node(l.coords[0])
graph.add_node(l.coords[1])
graph.add_edge(l.coords[0], l.coords[1], l.length)
graph.add_edge(l.coords[1], l.coords[0], l.length)
visited, path = dijsktra(graph, source)
shortest_path = []
curr = dest
while True:
shortest_path.insert(0, curr)
if curr == source:
break
curr = path[curr]
cost = visited[dest]