def get_shortest_path(g, initial, target):
reset_shortest_path(g)
print 'Origin: ', initial, 'Target: ', target
dj.dijkstra(g, g.get_vertex(initial), g.get_vertex(target))
target = g.get_vertex(target)
path = [target]
dj.shortest(target, path)
return list(reversed(path))
def bi_directional_dijstra(g, start_key, end_key=None):
Ds, Dt = {}, {}
g1 = copy.deepcopy(g)
g2 = copy.deepcopy(g)
forward = idijkstra(g1, start_key)
backward = idijkstra(g2, end_key)
dirs = (Ds, Dt, forward), (Dt, Ds, backward)
try:
for D, other, step in cycle(dirs):
v = next(step)
D[v.key] = v.distance
if v.key in other:
break
except StopIteration:
return float('inf')
intermediate_node = None
cost = float('Inf')
for u_key in Ds:
u = g1.get_vertex(u_key)
if u:
for v in u.get_connections():
if v.key not in Dt:
continue
if cost > Ds[u.key] + u.get_weight(v) + Dt[v.key]:
cost = min(cost, Ds[u.key] + u.get_weight(v) + Dt[v.key])
# record the meeting node with lowest distance
intermediate_node = u
#print(intermediate_node.key, v.key, cost)
print(f'Forward and Backward meet at node:{intermediate_node.key}!')
# shortest path in forward list part(including the intermediate node)
forward_path = []
node = g1.get_vertex(intermediate_node.key)
forward_path.append(node)
shortest(node, forward_path)
forward_path.reverse()
print(f'forward path:{[i.key for i in forward_path]}')
# skip the intermediate_node since it's already in forward list
backward_path = []
node = g2.get_vertex(intermediate_node.key)
shortest(node, backward_path)
print(f'backward path:{[i.key for i in backward_path]}')
forward_path.extend(backward_path)
return forward_path, cost
def single_timed_test(g, u, v, structure):
'''runs a single instance of the Dijkstra algorithm on a graph g with starting
node u and ending node v. structure refers to the type data structure used'''
t0 = time()
dijkstra.dijkstra(g, g.get_vertex(u), structure)
target = g.get_vertex(v)
path = [target.get_id()]
dijkstra.shortest(target, path)
t1 = time()
return t1 - t0
def main():
G = get_random_graph()
from dijkstra import shortest
print "Test Dijkstra", shortest, '-'*20
print 'NetworkX =>', nx.shortest_path(G, 0, 50, 'weight')
print 'Dijkstra =>', shortest(G, 0, 50)
from floyd_warshall import shortest
print "Test Floyd-Warshall", shortest, '-'*20
print 'NetworkX =>', nx.shortest_path(G, 0, 50, 'weight')
print 'Floyd-Warshall =>', shortest(G, 0, 50)
pass
def judge(num, tuples, tgt):
print(tuples)
edge_dict = defaultdict(int)
for i, j, v in tuples:
edge_dict[(i, j)] = v
edge_dict[(j, i)] = v
result = shortest(num, tuples)
if result[0] != tgt:
return False
total_length = 0
for idx in range(len(result[1]) - 1):
l, r = result[1][idx], result[1][idx + 1]
total_length += edge_dict[(l, r)]
if total_length != tgt:
return False
return True
def getCollection():
mapName = request.args.get('map')
origin = request.args.get('origin') #Ponto de origem
destiny = request.args.get('destiny') #Ponto final (chegada)
price = request.args.get('price')
autonomy = request.args.get('autonomy')
steps = [] # Lista que ira ser preenchida com todos os passos do caminho
dictPaths = {} # Dicionario com o valor de todos as rotas
graph = dijkstra.Graph(
) # Lib que faz o grafico de vertex para calcular o dijkstra
vertex = [] # Lista de vertex
try:
map = collection.find_one({'title': mapName})
except:
response = jsonify(
{'response': 'Application could not use the DB especifield'})
response.status_code = 500
return response
# Fazendo a iteração para preencher uma lista
# de vertex que serão usado na lib Graph()
for vert in map['routes']:
vertex.append(vert['origin'])
vertex.append(vert['destiny'])
# Iterando nos vertex setando para que nao se repitam
for i in list(set(vertex)):
graph.add_vertex(i)
# Adicionando os vertexa lib Graph
for vert in map['routes']:
dictPaths[vert['origin'] + vert['destiny']] = vert['distance']
graph.add_edge(vert['origin'], vert['destiny'], vert['distance'])
# Verificando se os pontos existem
if origin not in vertex:
response = jsonify({
'response':
'The parameter origin does not contain on map %s' % mapName
})
response.status_code = 400
return response
if destiny not in vertex:
response = jsonify({
'response':
'The parameter destiny does not contain on map %s' % mapName
})
response.status_code = 400
return response
dijkstra.dijkstra(graph, graph.get_vertex(origin),
graph.get_vertex(destiny))
target = graph.get_vertex(destiny)
path = [target.get_id()]
dijkstra.shortest(target, path)
a = 0
while a < (len(path[::-1]) - 1):
steps.append(path[::-1][a] + path[::-1][a + 1])
a = a + 1
total = 0
for i in steps:
total = total + dictPaths[i]
# Apenas formatando a lista para utf-8
pathList = []
for i in path[::-1]:
pathList.append(i.encode('utf-8'))
# Fazendo o calculo do custo nessa rota de menor distancia
cost = float(total) / float(autonomy) * float(price)
response = []
response.append({'Path': '%s' % pathList})
response.append({'Total KM': '%.2f' % total})
response.append({'Cost': '%.2f' % cost})
return jsonify(data=response)
def getCollection():
mapName = request.args.get('map')
origin = request.args.get('origin') #Ponto de origem
destiny = request.args.get('destiny') #Ponto final (chegada)
price = request.args.get('price')
autonomy = request.args.get('autonomy')
steps = [] # Lista que ira ser preenchida com todos os passos do caminho
dictPaths = {} # Dicionario com o valor de todos as rotas
graph = dijkstra.Graph() # Lib que faz o grafico de vertex para calcular o dijkstra
vertex = [] # Lista de vertex
try:
map = collection.find_one({'title':mapName})
except:
response = jsonify({'response':'Application could not use the DB especifield'})
response.status_code = 500
return response
# Fazendo a iteração para preencher uma lista
# de vertex que serão usado na lib Graph()
for vert in map['routes']:
vertex.append(vert['origin'])
vertex.append(vert['destiny'])
# Iterando nos vertex setando para que nao se repitam
for i in list(set(vertex)):
graph.add_vertex(i)
# Adicionando os vertexa lib Graph
for vert in map['routes']:
dictPaths[vert['origin']+vert['destiny']] = vert['distance']
graph.add_edge(vert['origin'],vert['destiny'],vert['distance'])
# Verificando se os pontos existem
if origin not in vertex :
response = jsonify({'response': 'The parameter origin does not contain on map %s'
% mapName})
response.status_code = 400
return response
if destiny not in vertex :
response = jsonify({'response': 'The parameter destiny does not contain on map %s'
% mapName})
response.status_code = 400
return response
dijkstra.dijkstra(graph, graph.get_vertex(origin), graph.get_vertex(destiny))
target = graph.get_vertex(destiny)
path = [target.get_id()]
dijkstra.shortest(target, path)
a = 0
while a < (len(path[::-1])-1):
steps.append(path[::-1][a]+path[::-1][a+1])
a=a+1
total = 0
for i in steps:
total = total + dictPaths[i]
# Apenas formatando a lista para utf-8
pathList = []
for i in path[::-1]:
pathList.append(i.encode('utf-8'))
# Fazendo o calculo do custo nessa rota de menor distancia
cost = float(total) / float(autonomy) * float(price)
response = []
response.append({'Path': '%s' % pathList})
response.append({'Total KM' : '%.2f' % total})
response.append({'Cost' : '%.2f' % cost})
return jsonify(data=response)
g.add_edge('c', 'f', 2)
g.add_edge('d', 'e', 6)
g.add_edge('e', 'f', 9)
print('Graph data:')
for v in g:
for w in v.get_connections():
vid = v.get_id()
wid = w.get_id()
print(vid, wid, v.get_weight(w))
dijkstra.dijkstra(g, g.get_vertex('a'), g.get_vertex('e'))
target = g.get_vertex('e')
path = [target.get_id()]
dijkstra.shortest(target, path)
print('The shortest path:', path[::-1])
break
elif (while_input == 'f' or while_input == 'F'):
file = open("cities.txt", "r")
for line in file:
args = line.split()
src = args[0]
dest = args[1]
weight = int(args[2])
g.add_edge(src, dest, weight)
print_yesno = input("Print the list of all cities? y or n: ")
if (print_yesno == 'y'):
rt = region_type(x, y)
tools = allowed_tools[rt]
t1, t2 = tools
graph.add_edge(Region(x, y, t1), Region(x, y, t2), 7)
for n in ((x + 1, y), (x, y + 1)):
rt_n = region_type(*n)
if rt == rt_n:
graph.add_edge(Region(x, y, t1), Region(*n, t1), 1)
graph.add_edge(Region(x, y, t2), Region(*n, t2), 1)
else:
overlap = tools.intersection(allowed_tools[rt_n]).pop()
graph.add_edge(Region(x, y, overlap), Region(*n, overlap), 1)
start = Region(0, 0, Tool.TORCH)
end = Region(target_x, target_y, Tool.TORCH)
dijkstra(graph, graph.get_vertex(start), graph.get_vertex(end))
target = graph.get_vertex(end)
path = [target.get_id()]
shortest(target, path)
# print("The shortest path : %s" % (path[::-1]))
s = 0
for v, w in zip(path[:-1], path[1:]):
if v.tool == w.tool:
s += 1
else:
s += 7
print(s)
def graph_path(frm, to, res):
start_time = datetime.now()
g = d.Graph()
filename = os.getcwd() + "/data/data" + str(res) + ".csv"
with open(filename, "r") as file:
count = 0
for line in file.readlines():
val = line.split("\t")
g.add_vertex(count, float(val[1]), float(val[0]), float(val[2]))
count += 1
g.add_edge(0, 1, cost(g.get_vertex(0), g.get_vertex(1)))
for node in xrange(res ** 2 - 1):
if node >= res ** 2 - res:
g.add_edge(node, node + 1, cost(g.get_vertex(node), g.get_vertex(node + 1)))
else:
g.add_edge(node, node + res, cost(g.get_vertex(node), g.get_vertex(node + res)))
if node % res != (res - 1):
g.add_edge(node, node + 1, cost(g.get_vertex(node), g.get_vertex(node + 1)))
start = frm
stop = to
# origin = g.get_vertex(start)
target = g.get_vertex(stop)
d.dijkstra(g, g.get_vertex(start))
path = [target.get_id()]
d.shortest(target, path)
print "The shortest path : %s" % (path[::-1])
print "total cost: " + str(target.distance)
elapsed = datetime.now() - start_time
print elapsed
x = []
y = []
z = []
with open(filename, "r") as file:
for line in file.readlines():
val = line.split("\t")
x.append(float(val[0]))
y.append(float(val[1]))
z.append(float(val[2]))
x = np.array(x)
y = np.array(y)
z = np.array(z)
xi, yi = np.linspace(x.min(), x.max(), 100), np.linspace(y.min(), y.max(), 100)
xi, yi = np.meshgrid(xi, yi)
rbf = scipy.interpolate.Rbf(x, y, z, function="linear")
zi = rbf(xi, yi)
xs = [g.get_vertex(v).lon for v in path]
ys = [g.get_vertex(v).lat for v in path]
plt.gcf().canvas.set_window_title("Dijkstra shortest path")
plt.imshow(
zi, vmin=z.min(), vmax=z.max(), origin="lower", extent=[x.min(), x.max(), y.min(), y.max()], cmap="terrain"
)
plt.plot(xs, ys)
plt.plot(xs[-1], ys[-1], "g^")
plt.plot(xs[0], ys[0], "rs")
plt.colorbar()
text = "path cost: " + str(target.distance) + "\n" + "time: " + str(elapsed)
plt.suptitle(text, fontsize=14, fontweight="bold")
plt.savefig("graph_path.png")
plt.close()
# plt.show()
return [(g.get_vertex(v).lon, g.get_vertex(v).lat) for v in reversed(path)]
