def test_routing_folium():
G = ox.graph_from_address(address=address,
dist=500,
dist_type="bbox",
network_type="bike")
# give each node a random elevation then calculate edge grades
randm = np.random.random(size=len(G))
elevs = {n: e for n, e in zip(G.nodes(), randm)}
nx.set_node_attributes(G, name="elevation", values=elevs)
G = ox.add_edge_grades(G, add_absolute=True)
# give each edge speed and travel time attributes
G = ox.add_edge_speeds(G)
G = ox.add_edge_travel_times(G)
orig_node = list(G.nodes())[5]
dest_node = list(G.nodes())[-5]
orig_pt = (G.nodes[orig_node]["y"], G.nodes[orig_node]["x"])
dest_pt = (G.nodes[dest_node]["y"], G.nodes[dest_node]["x"])
route = nx.shortest_path(G, orig_node, dest_node, weight="travel_time")
attributes = ox.utils_graph.get_route_edge_attributes(
G, route, "travel_time")
fig, ax = ox.plot_graph_route(G,
route,
save=True,
filename="route",
file_format="png")
fig, ax = ox.plot_graph_route(
G,
route,
origin_point=orig_pt,
destination_point=dest_pt,
save=True,
filename="route",
file_format="png",
)
# test multiple routes
fig, ax = ox.plot_graph_routes(G, [route, route])
# test folium
gm = ox.plot_graph_folium(G, popup_attribute="name")
rm = ox.plot_route_folium(G, route)
# test calling folium plotters with FeatureGroup instead of Map, and extra kwargs
fg = folium.FeatureGroup(name="legend name", show=True)
gm = ox.plot_graph_folium(G, graph_map=fg)
assert isinstance(gm, folium.FeatureGroup)
rm = ox.plot_route_folium(G,
route,
route_color="g",
route_map=fg,
tooltip="x")
assert isinstance(rm, folium.FeatureGroup)
def test_routing_folium():
# calculate shortest path and plot as static image and leaflet web map
import networkx as nx
G = ox.graph_from_address('398 N. Sicily Pl., Chandler, Arizona',
distance=800,
network_type='drive')
origin = (33.307792, -111.894940)
destination = (33.312994, -111.894998)
origin_node = ox.get_nearest_node(G, origin)
destination_node = ox.get_nearest_node(G, destination, method='euclidean')
route = nx.shortest_path(G, origin_node, destination_node)
attributes = ox.get_route_edge_attributes(G, route, 'length')
fig, ax = ox.plot_graph_route(G,
route,
save=True,
filename='route',
file_format='png')
fig, ax = ox.plot_graph_route(G,
route,
origin_point=origin,
destination_point=destination,
save=True,
filename='route',
file_format='png')
graph_map = ox.plot_graph_folium(G, popup_attribute='name')
route_map = ox.plot_route_folium(G, route)
def create_route(coords, dist_goal, name):
"""
Creates list of routes
Parameters:
coords (tuple): (latitude,longitude)
dist_goal (int): desired length in km
Returns:
paths (list): list of lists, each sublist is a path (list of osmid's)
"""
graph = ox.core.graph_from_point(coords,
distance=dist_goal * 700,
simplify=False)
start = ox.get_nearest_node(graph, coords)
nodes, _ = ox.graph_to_gdfs(graph)
pivots = get_pivots(graph, start, dist_goal)
#print(start)
paths = []
for piv in pivots:
try:
test = make_loop(graph, piv, start, dist_goal)
paths.append(test)
ox.plot_graph_route(graph, test)
except Exception as exception:
print("Error in loop generation")
print(exception)
return paths, nodes
def test_routing_folium():
import networkx as nx
G = ox.graph_from_address('N. Sicily Pl., Chandler, Arizona',
distance=800,
network_type='drive')
origin = (33.307792, -111.894940)
destination = (33.312994, -111.894998)
origin_node = ox.get_nearest_node(G, origin)
destination_node = ox.get_nearest_node(G, destination)
route = nx.shortest_path(G, origin_node, destination_node)
fig, ax = ox.plot_graph_route(G,
route,
save=True,
filename='route',
file_format='png')
fig, ax = ox.plot_graph_route(G,
route,
origin_point=origin,
destination_point=destination,
save=True,
filename='route',
file_format='png')
graph_map = ox.plot_graph_folium(G, popup_attribute='name')
route_map = ox.plot_route_folium(G, route)
def task6(to_show):
marks_for_part = 0
G_iit, origin_node, final_node = get_problem('iit')
actual_route = [668478124, 668672699, 4348259295, 668672574, 245674992, 668672700, 3215340463, 667357325, 5366445105]
problem = MapSearchProblem(G_iit, origin_node, final_node)
route_astar_iit = AStar_search(problem, heuristic)
if route_astar_iit == actual_route and problem.nodes_expanded < 25:
marks_for_part += 1
print "Number of nodes expanded for IIT: %d" % problem.nodes_expanded
G_mumbai, origin_node, final_node = get_problem('mumbai')
actual_route = [5280438428, 4348259324, 5280437314, 5280437313, 668672574, 245674992, 668672700, 3215340463, 667357325, 668699249, 667357311, 668660552, 1879817556, 245673500, 3708892000, 667395479, 667395482, 667395474, 667395468, 2246662857, 2246662767, 1855812188, 667395460, 2055634531, 4759328799, 4759328802, 1366901332, 4759328760, 5456498950, 5456509646, 5456509636, 5456509634, 2245075822, 1366901213, 1366901212, 2245075777, 1366901170, 5456500624, 5456509624, 2245075731, 1366901143, 2245075698, 1366901132, 2244962270, 2244962262, 2244962226, 2244962231, 2244962200, 2244962171, 1366900900, 4366100155, 2246661216, 2246661194, 3245621937, 2246661136, 2246661130, 2246661132, 2246661074, 623889405, 5477703669, 5477703667, 5477703671, 5758624138, 2622177356, 2244961487, 1644086520, 623889400, 4264598038, 4264598040, 4264598033, 4264598029, 4264598395, 1640287824, 1640287806, 1454672572, 245668721, 1454673995, 1643047708, 245668490, 2246472636, 1643047703, 2246472590, 2246472543, 2246472486, 2246472465, 1643035298, 1643035294, 2246472375, 1643031073, 245667692, 2146269450, 2163935132, 2146273510, 1232644012, 4264598321, 2146273513, 5913464524, 2439252028, 5865538271, 1366938254, 5865538272, 1232644986, 1642951891, 1642951846, 1642951818, 245664866, 1642951755, 1642951748, 1642954393, 1179340118, 1179340221, 245664141, 245663296, 1179314459, 245663089, 4362786418, 1643134423, 2258304514, 2258304493, 2258304484, 1179089888, 1179257896, 1179273129, 245660324, 2258304455, 245660183, 1179221113, 1179221116, 1179221118, 5921458181, 2258304438, 245659911, 245659814, 1165320838, 5848596597, 245659701, 2258304421, 245659569, 245659514, 245659478, 245659392, 2258304411, 674906578, 2258304349, 2258304338, 5637109060, 1375482657, 245657044, 245657005, 620382315, 2258304310, 245656839, 4443807473, 861155618, 861155314, 861155306, 2246157812, 245656050, 861155655, 861190736, 620393213, 245655857, 245655720, 245655652, 2246157809, 245655525, 245655412, 245655339, 620403338, 245655305, 2184321321, 245655223, 5510030709, 245655072, 620408597, 620404556, 245654969, 245654863, 2248513091, 2244632754, 1643210517, 245654715, 1643210514, 485953796, 485953814, 485953784, 356168287, 1643210508, 6215526121, 1127766407, 4568979756, 4568979754]
problem = MapSearchProblem(G_mumbai, origin_node, final_node)
route_astar_mumbai = AStar_search(problem, heuristic)
if route_astar_mumbai == actual_route and problem.nodes_expanded < 15000:
marks_for_part += 1
print "Number of nodes expanded for Mumbai: %d" % problem.nodes_expanded
if to_show:
try:
ox.plot_graph_route(G_iit, route_astar_iit, node_size=1)
except:
print "The route returned is not possible for IIT"
try:
ox.plot_graph_route(G_mumbai, route_astar_mumbai, node_size=1)
except:
print "The route returned is not possible for Mumbai"
return marks_for_part, 2
def test_routing_folium():
import networkx as nx
with httmock.HTTMock(
get_mock_response_content('overpass-response-3.json.gz')):
G = ox.graph_from_address('398 N. Sicily Pl., Chandler, Arizona',
distance=800,
network_type='drive')
origin = (33.307792, -111.894940)
destination = (33.312994, -111.894998)
origin_node = ox.get_nearest_node(G, origin)
destination_node = ox.get_nearest_node(G, destination)
route = nx.shortest_path(G, origin_node, destination_node)
attributes = ox.get_route_edge_attributes(G, route, 'length')
fig, ax = ox.plot_graph_route(G,
route,
save=True,
filename='route',
file_format='png')
fig, ax = ox.plot_graph_route(G,
route,
origin_point=origin,
destination_point=destination,
save=True,
filename='route',
file_format='png')
graph_map = ox.plot_graph_folium(G, popup_attribute='name')
route_map = ox.plot_route_folium(G, route)
def plot_graph_route_over_cost(self, path_converted, filename=None):
ec = ox.get_edge_colors_by_attr(self.planner.graph, 'cost', cmap='plasma', num_bins=100)
fig, ax = ox.plot_graph(self.kalman.env.graph, fig_height=6, edge_color=ec, node_zorder=2,
use_geom=True)
if filename:
fig, ax = ox.plot_graph_route(self.planner.graph, path_converted, edge_color=ec, route_alpha=0.3, save=True, filename=filename, )
else:
fig, ax = ox.plot_graph_route(self.planner.graph, path_converted, edge_color=ec, route_alpha=0.3)
def plot_path (self, route):
"""
This method plot the path found.
:param route: The list of visited nodes
:return: None
"""
ox.plot_graph_route(self.graph, route)
def lab_2():
np.random.seed(int(time()))
G = ox.load_graphml('data/BUPT.graphml')
print(len(G.nodes)) # 2164
print(len(G.edges)) # 5226
src = np.random.choice(G.nodes)
dst = np.random.choice(G.nodes)
route = nx.dijkstra_path(G, src, dst, weight='length')
ox.plot_graph_route(G, route, figsize=(20, 20))
def test_routing():
G = ox.graph_from_address(address=address,
dist=500,
dist_type="bbox",
network_type="bike")
# give each node a random elevation then calculate edge grades
randm = np.random.random(size=len(G))
elevs = {n: e for n, e in zip(G.nodes(), randm)}
nx.set_node_attributes(G, name="elevation", values=elevs)
G = ox.add_edge_grades(G, add_absolute=True)
# give each edge speed and travel time attributes
G = ox.add_edge_speeds(G)
G = ox.add_edge_speeds(G, hwy_speeds={"motorway": 100})
G = ox.add_edge_travel_times(G)
orig_node = list(G.nodes())[5]
dest_node = list(G.nodes())[-5]
orig_pt = (G.nodes[orig_node]["y"], G.nodes[orig_node]["x"])
dest_pt = (G.nodes[dest_node]["y"], G.nodes[dest_node]["x"])
route = ox.shortest_path(G, orig_node, dest_node, weight="travel_time")
attributes = ox.utils_graph.get_route_edge_attributes(G, route)
attributes = ox.utils_graph.get_route_edge_attributes(
G, route, "travel_time")
fig, ax = ox.plot_graph_route(G, route, save=True)
fig, ax = ox.plot_graph_route(G, route, save=True)
# test multiple routes
routes = ox.k_shortest_paths(G,
orig_node,
dest_node,
k=2,
weight="travel_time")
fig, ax = ox.plot_graph_routes(G, list(routes))
# test folium with keyword arguments to pass to folium.PolyLine
gm = ox.plot_graph_folium(G,
popup_attribute="name",
color="#333333",
weight=5,
opacity=0.7)
rm = ox.plot_route_folium(G, route, color="#cc0000", weight=5, opacity=0.7)
# test calling folium plotters with FeatureGroup instead of Map, and extra kwargs
fg = folium.FeatureGroup(name="legend name", show=True)
gm = ox.plot_graph_folium(G, graph_map=fg)
assert isinstance(gm, folium.FeatureGroup)
rm = ox.plot_route_folium(G, route, route_map=fg, tooltip="x")
assert isinstance(rm, folium.FeatureGroup)
def plot_route(self, graph, route):
if self._ax is None:
raise Exception('Need to plot the map first before the route.')
ox.plot_graph_route(graph,
route,
ax=self._ax,
route_colors=self.COLOR_ROUTE,
alpha=1,
orig_dest_size=250,
route_linewidth=4,
show=False,
close=False)
def test_routing():
G = ox.graph_from_address(address=address,
dist=500,
dist_type="bbox",
network_type="bike")
# give each edge speed and travel time attributes
G = ox.add_edge_speeds(G)
G = ox.add_edge_speeds(G, hwy_speeds={"motorway": 100})
G = ox.add_edge_travel_times(G)
orig_x = np.array([-122.404771])
dest_x = np.array([-122.401429])
orig_y = np.array([37.794302])
dest_y = np.array([37.794987])
orig_node = ox.distance.nearest_nodes(G, orig_x, orig_y)[0]
dest_node = ox.distance.nearest_nodes(G, dest_x, dest_y)[0]
route = ox.shortest_path(G, orig_node, dest_node, weight="travel_time")
attributes = ox.utils_graph.get_route_edge_attributes(G, route)
attributes = ox.utils_graph.get_route_edge_attributes(
G, route, "travel_time")
fig, ax = ox.plot_graph_route(G, route, save=True)
fig, ax = ox.plot_graph_route(G, route, save=True)
# test multiple routes
routes = ox.k_shortest_paths(G,
orig_node,
dest_node,
k=2,
weight="travel_time")
fig, ax = ox.plot_graph_routes(G, list(routes))
# test folium with keyword arguments to pass to folium.PolyLine
gm = ox.plot_graph_folium(G,
popup_attribute="name",
color="#333333",
weight=5,
opacity=0.7)
rm = ox.plot_route_folium(G, route, color="#cc0000", weight=5, opacity=0.7)
# test calling folium plotters with FeatureGroup instead of Map, and extra kwargs
fg = folium.FeatureGroup(name="legend name", show=True)
gm = ox.plot_graph_folium(G, graph_map=fg)
assert isinstance(gm, folium.FeatureGroup)
rm = ox.plot_route_folium(G, route, route_map=fg, tooltip="x")
assert isinstance(rm, folium.FeatureGroup)
def plot_graph_route(self, path, filename=None):
fig, ax = ox.plot_graph(self.kalman.env.graph,
fig_height=6,
node_zorder=2,
use_geom=True)
if filename:
fig, ax = ox.plot_graph_route(self.planner.graph,
path,
route_alpha=0.3,
save=True,
filename=filename)
else:
fig, ax = ox.plot_graph_route(self.planner.graph,
path,
route_alpha=0.3)
def carrinheiro(id_user, date):
user_carrinheiro = User.get_user(id_user, DATABASE_DIRECTORY)
path = Path.Path(user_carrinheiro, date, DATABASE_DIRECTORY)
stop_points = scenario_stop_points(path)
# download the osm file (scenario)
file_name_osm = OpenSteetMap.file_osm(MAPS_DIRECTORY, stop_points)
# download the GeoTiff file (scenario)
geotiff_name = GeoTiff.geotiff(MAPS_DIRECTORY, stop_points)
G, nodes_coordinates, nodes_mass_increment = graph_scenario(
stop_points, geotiff_name, path.material_weights, file_name_osm)
H = Graph_Collect.create_graph_route(nodes_coordinates,
nodes_mass_increment)
index_coordinate_start = list(nodes_coordinates.values()).index(
path.start_point)
node_source = list(nodes_coordinates.keys())[index_coordinate_start]
index_coordinate_end = list(nodes_coordinates.values()).index(
path.end_point)
node_target = list(nodes_coordinates.keys())[index_coordinate_end]
cost_total, paths = closest_insertion_path(G, H, node_source, node_target)
for i in paths:
fig, ax = ox.plot_graph_route(G,
i,
route_linewidth=6,
node_size=0,
bgcolor='w')
return paths
def showShortest(G, start_node=246539610, end_node=59768831):
edge_color = "black" # colorEdges(G)
route = nx.shortest_path(G, start_node, end_node, weight='weight')
fig, ax = ox.plot_graph_route(G,
route=route,
edge_color=edge_color,
node_color='none')
def get_robo_route(start=(41.814884, -87.664603), chicago_path="chicago.xml", pothole_path="potholes.xml"):
"""
This function will compute the optimal route for
a robot to take to fill potholes.
Input:
start: The location where the robot starts and ends at (the facility)
chicago_path: The location of the graph of Chicago located locally
pothole_path: The location of the graph of the pothole data located locally
Return:
An ordered list of nodes representing the route the robot will take
"""
#Acquire the graph of Chicago
print("Opening Chicago")
Chicago = open_chicago_graph(chicago_path)
Cpp = CppGraph(Chicago)
Cpp.set_start(start)
#Acquire the set of all potholes that need to be filled
print("Opening Potholes")
potholes = open_potholes(pothole_path)
#Get the shortest paths connecting the potholes and the robot facility
print("Adding potholes to Chicago")
short_pathN(Chicago, Cpp, potholes)
#Find the optimal way to traverse the graph starting from the robot's facility
print("Finding the route")
route = Cpp.solve()
#Save the route the robot will take as an image
fig, ax = ox.plot_graph_route(G, route, save=True, filename="graph")
return route
def type_transport(transport):
"""This function plot the shortest path for different type of transport from La Maison du Lez, Montpellier, France
to Place to Eugène Bataillon, Montpellier, France.
Parameters
----------
transport : string, type of transport to choose to plot his path.
Returns
-------
a map showing the shortest path.
"""
# download the map as a graph object
G = ox.graph_from_place(
'Montpellier, Hérault, France', network_type=transport)
# define origin and desination locations
origin_point = ox.geo_utils.geocode('Maison du Lez, Montpellier, France')
destination_point = ox.geo_utils.geocode(
'Place Eugène Bataillon, Montpellier, France')
# get the nearest nodes to the locations
origin_node = ox.get_nearest_node(G, origin_point)
destination_node = ox.get_nearest_node(G, destination_point)
# finding the shortest path
route = nx.shortest_path(G, origin_node, destination_node)
# plot the map graph
fig, ax = ox.plot_graph_route(G, route, origin_point=origin_point, destination_point=destination_point, route_linewidth=2)
plt.show
return()
def shortestPathNavigation(userLoc, destinLoc):
"""
:type userLoc: List[float] of size 2
:type destinLoc: List[float] of size 2
"""
G = ox.graph_from_point(userLoc, distance = 2000, distance_type = 'network', network_type = 'walk')
Gnodes = G.nodes()
# Get the nearest node in the system of the given location
origin_node = ox.get_nearest_node(G, userLoc)
destin_node = ox.get_nearest_node(G, destinLoc)
# Get the lat&lng of the approximated location
origin_point, destin_point = [[Gnodes[i]['y'],Gnodes[i]['x']] for i in [origin_node, destin_node]]
# Get the shortest route's nodes' indices
route = nx.shortest_path(G, origin_node,destin_node, weight = 'length')
fig,ax = ox.plot_graph_route(G,route,origin_point = origin_point, destination_point = destin_point)
# Get the shortest route's lat&lng
the_route = [[G.nodes()[i]['y'],G.nodes()[i]['x']] for i in route]
# Create map and add markers of origin&destin to the map
m = folium.Map(location = userLoc, zoom_start = 13)
marker_cluster = folium.MarkerCluster().add_to(m)
folium.Marker(origin_point, popup = 'Origin').add_to(marker_cluster)
folium.Marker(destin_point, popup = 'Dest').add_to(marker_cluster)
# Add the shortest path to the map
shortest_path = folium.PolyLine(the_route).add_to(m) # More parameters: #weight=15,#color='#8EE9FF'
# Show the map
return m
def show_route(edges):
route = []
route.append(edges[0][0])
previous_node = edges[0][1]
for edge in edges[1:]:
go_node = edge[0]
r = nx.shortest_path(G_lisbon, previous_node, go_node, weight='length')
if False and len(r) <= 1:
print 'strange... => previus_node:' + str(
previous_node) + ' go_node:' + str(go_node)
print r
route.extend(r)
previous_node = edge[1]
print 'route with ' + str(len(route)) + ' nodes'
ox.plot_graph_route(G_lisbon, route, route_linewidth=2)
def test_mocked_path_creation(self):
mongo_resource = MongoResourceImpl()
track_statistics_repository = TrackStatisticsRepositoryImpl(
mongo_resource)
graph_information = GraphInformationRepositoryImpl(mongo_resource)
bellver_graph = Graph(39.5713, 39.5573, 2.6257, 2.6023)
gpx_resource = GPXResourceImpl()
pyplot_resource = PyplotResourceImpl()
try:
k.start()
data = graph_information.read_graph_information_dataframe(
os.environ.get('LAST_VERSION_GRAPH'))
k.stop()
except IndexError:
logging.warning("NOT found in MongoDB")
return
simulate_track = SimulateTrackImpl(bellver_graph, 4, gpx_resource,
pyplot_resource,
track_statistics_repository)
# Graph information load
bellver_graph.load_graph_analysis_statistics(data)
simulator = TrackSimulatorPipeline(simulate_track)
path = simulator.run(1248507104, 10000)
a = [x[0] for x in path]
print(path)
fig, ax = osmnx.plot_graph_route(bellver_graph.graph,
a,
bgcolor='k',
node_color='black',
edge_linewidth=1.5,
edge_alpha=1,
node_zorder=3)
plt.show()
def main():
map_graph = ox.graph_from_place('Berkley, California',
network_type='drive')
origin = ox.get_nearest_node(map_graph, (37.8743, -122.277))
destination = list(map_graph.nodes())[-1]
shortest_path = nx.shortest_path(map_graph,
origin,
destination,
weight='length')
fig, ax = ox.plot_graph_route(map_graph, shortest_path)
path = dijkstras_search(origin, destination, map_graph)
fig, ax = ox.plot_graph_route(map_graph, path)
path = a_star_search(origin, destination, map_graph)
fig, ax = ox.plot_graph_route(map_graph, path)
def show_route(self, end_node):
"""
Show map and render route from start to end_node
:param end_node: Node id of current location
:return: Matplotlib figure
"""
route = nx.shortest_path(self.G, end_node, end_node, weight='length')
ox.plot_graph_route(self.G,
route,
node_size=0,
show=False,
save=True,
filename="output",
file_format="png")
fig = cv2.imread("data/plot/output.png")
return fig
def ShortestPath(orig_address, dest_address):
"""
This function takes a two addresses in as an input (origin and destination). The addresses should be strings. Then it calculates he quickest route from origin to destination by driving and presents that on a map. Please note that the function only works in Helsinki because the network data is heavy, that's why it might be slow.
"""
#retrieve the driving network from Helsinki. I first did this with bike network data but none of the nodes I tried were connected to biking network so I changed that to driving for the sake of convenience.
place_name = "Helsinki, Finland"
graph = ox.graph_from_place(place_name, network_type="drive")
#project the graph
graph_proj = ox.project_graph(graph)
#access projected nodes and edges
nodes_proj, edges_proj = ox.graph_to_gdfs(graph_proj,
nodes=True,
edges=True)
#create a dataframe with the addresses as an input
d = {"id": [1, 2], "addr": [orig_address, dest_address]}
data = pd.DataFrame(data=d)
#geocode addresses so the dataframe becomes a geodataframe (with location information extracted by geocoding)
geo = geocode(data["addr"],
provider="nominatim",
user_agent="SK",
timeout=4)
#check CRS systems, they are different
CRS(geo.crs).to_epsg()
CRS(edges_proj.crs).to_epsg()
#convert geo to same CRS system with projected network
geo = geo.to_crs(epsg=32635)
#make a tuple of the x and y coordinates by retrieving them from dataframe. Y is first because it is latitude infomation
orig_xy = [geo["geometry"][0].y, geo["geometry"][0].x]
dest_xy = [geo["geometry"][1].y, geo["geometry"][1].x]
#find the nearest node to the origin and target point coordinates with euclidean distance
orig_node = ox.get_nearest_node(graph_proj, orig_xy, method='euclidean')
target_node = ox.get_nearest_node(graph_proj, dest_xy, method='euclidean')
# Calculate the shortest path (using Djikstra's algorithm)
route = nx.shortest_path(G=graph_proj,
source=orig_node,
target=target_node,
weight='time')
# Plot the shortest path
fig, ax = ox.plot_graph_route(graph_proj,
route,
origin_point=orig_xy,
destination_point=dest_xy)
#save and return figure
output_fig = "outputs/shortest_path_from_" + orig_address + "_to_" + dest_address + ".png"
plt.savefig(output_fig)
return fig
def show_route(self, graph_projection, route, bbox):
print("Showing route")
# lat_long_list = []
# gmap = gmplot.GoogleMapPlotter(37.7749295, -122.4194155, 13)
# #gmap = self.from_geocode("San Francisco", apikey = 'AIzaSyDU_zAP8D2D9c54N9G5nMPYF52H5VZ_T4o')
# for i in range(0, len(route)):
# sum += route[i]
# lat_long_list.append(tuple((graph_projection.node[route[i]]['y'], graph_projection.node[route[i]]['x'])))
# top_attraction_lats, top_attraction_lons = zip(*lat_long_list)
# gmap.scatter(top_attraction_lats, top_attraction_lons, '#3B0B39', size = 40, marker = False)
# # Marker
# hidden_gem_lat, hidden_gem_lon = 37.77, -122.426
# gmap.marker(hidden_gem_lat, hidden_gem_lon, 'cornflowerblue')
# hidden_gem_lat_2, hidden_gem_lon_2 = 37.773, -122.441
# gmap.marker(hidden_gem_lat_2, hidden_gem_lon_2, 'cornflowerblue')
# # Draw
# gmap.draw("my_map1.html")
ox.plot_graph_route(graph_projection, route, bbox=bbox, node_size=0)
def plot_route(G, route_list, color):
return ox.plot_graph_route(G,
bgcolor='white',
node_size=1.0,
node_color='gray',
edge_color='gray',
route=route_list,
route_color=color,
dpi=300,
figsize=(15, 15))
def plot_shortest_route(self):
# Calculates the shortest route from start point to end point taking only the length of the edges as the weight
# and plots the route on the reduced graph using the boundary box
orig_node = ox.get_nearest_node(self.G, self.start)
dest_node = ox.get_nearest_node(self.G, self.end)
route = nx.shortest_path(self.G, orig_node, dest_node, weight='length')
#print('Path Length:',nx.shortest_path_length(self.G, orig_node, dest_node, weight='length'))
fig, ax = ox.plot_graph_route(self.G,
route,
bbox=self.bbox,
node_size=0,
fig_height=15)
plt.show()
def short_path(graph, origin, destination):
"""This function plot the shortest path in the graph and calculate his length.
Returns
-------
a networkx graph showing the shortest path.
"""
origin_node = ox.get_nearest_node(graph, origin)
destination_node = ox.get_nearest_node(graph, destination)
route = nx.shortest_path(graph, origin_node, destination_node)
route_lentgh = nx.shortest_path_length(graph, origin_node, destination_node)
chemin = ox.plot_graph_route(graph, route)
return chemin, route_lentgh
def test_routing_folium():
# calculate shortest path and plot as static image and leaflet web map
import networkx as nx
G = ox.graph_from_address('398 N. Sicily Pl., Chandler, Arizona', distance=800, network_type='drive')
origin = (33.307792, -111.894940)
destination = (33.312994, -111.894998)
origin_node = ox.get_nearest_node(G, origin)
destination_node = ox.get_nearest_node(G, destination, method='euclidean')
route = nx.shortest_path(G, origin_node, destination_node)
attributes = ox.get_route_edge_attributes(G, route, 'length')
fig, ax = ox.plot_graph_route(G, route, save=True, filename='route', file_format='png')
fig, ax = ox.plot_graph_route(G, route, origin_point=origin, destination_point=destination,
save=True, filename='route', file_format='png')
# test multiple routes
fig, ax = ox.plot_graph_routes(G, [route, route])
graph_map = ox.plot_graph_folium(G, popup_attribute='name')
route_map = ox.plot_route_folium(G, route)
def safest_way(origin, destination): # select safest route
route = ox.shortest_path(G, origin, destination, weight='danger_weight')
fig, ax = ox.plot_graph_route(G,
route,
route_color='y',
route_linewidth=6,
node_size=0) # plot the safest road
route_risk = int(
sum(ox.utils_graph.get_route_edge_attributes(
G, route, 'danger_weight'))) # print the risk on this road
txt1 = 'The risk on this Route is '
txt2 = ' accidents per year'
return fig, txt1, txt2, route_risk
def plot_shortest_path(self, destination_id, truncate=True):
"""
Plots shortest path between two stations as determined by osmnx
:param destination_id: int
destination id for destination station
:param truncate: boolean, optional, default True
whether to truncate the graph to the smallest box enclosing the path or keep the path
embedded in the entire location_graph
:return: None
"""
path = self.shortest_path(destination_id)
if truncate:
path_coords_x = [self.bike_service_instance.location_graph.node[node]['x'] for node in path]
path_coords_y = [self.bike_service_instance.location_graph.node[node]['y'] for node in path]
north = max(path_coords_y)
south = min(path_coords_y)
east = max(path_coords_x)
west = min(path_coords_x)
temp_graph = ox.truncate_graph_bbox(
G=self.bike_service_instance.location_graph,
north=north,
south=south,
east=east,
west=west)
else:
temp_graph = self.bike_service_instance.location_graph
ox.plot_graph_route(
temp_graph,
path,
fig_height=30,
node_size=0)
return None
def run_optimality_evaluation(G):
start_node_id = np.random.choice(G.nodes)
goal_node_id = np.random.choice(G.nodes)
truth_route = nx.shortest_path(G,
start_node_id,
goal_node_id,
weight='best_travel_time')
curr_node_id = start_node_id
ml_route = []
visited = collections.deque(maxlen=7)
# Start node
ml_route.append(curr_node_id)
use_random_actions = False
history = collections.deque(maxlen=5)
while curr_node_id != goal_node_id:
curr_node_id = predict_next_node_id(G,
curr_node_id,
goal_node_id,
model,
randomness=0.1)
ml_route.append(curr_node_id)
gt_duration = get_route_duration(truth_route, G)
ml_duration = get_route_duration(ml_route, G)
print("------ METRICS ------")
print("GT duration: ", gt_duration, ". ML duration: ", ml_duration,
". Abs Diff: ", ml_duration - gt_duration, ". Ratio: ",
gt_duration / ml_duration)
print("---------------------")
###### PLOT GT AND ML PATHS ######
ox.plot_graph_route(G, truth_route)
ox.plot_graph_route(G, ml_route)
