def __init__(self, map_path, start_node=-137971): self.G = ox.graph_from_file(map_path, name="Map", retain_all=True, simplify=False) ox.config(imgs_folder="data/plot") self.start = start_node
def convert_to_graph(osm_file=config.osm_file): graph = ox.graph_from_file(osm_file, simplify=False, retain_all=True, name='Chel') largest_component = list( max(nx.strongly_connected_components(graph), key=len)) return graph, largest_component
def main(): grafo = object try: # grafo - MultiDiGraph print('>>\tCarregando grafo de arquivo .OSM') grafo = ox.graph_from_file(simplify=True, retain_all=False, filename=NOME_ARQUIVO_OSM + ".osm", name=NOME_ARQUIVO_OSM) except IOError as e: print('!!\tO grafo não pôde ser carregado.\n\nErro:\n', e) print('OK\tGrafo OSM carregado.\n') r = input(">>\tGerar arquivo graphml e grafos em formato de texto? (s/n)") if r == 's': #grafo = ox.graph_from_file(network_type='all', simplify=True, retain_all=False, filename=NOME_ARQUIVO_OSM + ".osm", name=NOME_ARQUIVO_OSM) #Salvando grafo gerado como arquivo .graphml em disco local ox.save_load.save_graphml(grafo, filename="grafo("+NOME_ARQUIVO_OSM+").graphml", folder=CAMINHO_ARQUIVOS ) print('OK\tGrafo graphml gerado.\n') print('>>\tGerando grafo com nós padrão e grafo indexado no formato de arquivo texto.') # como é preciso que os grafos txt sejam gerados e que o número de nós seja # conhecido, a opção de gerar grafo agora é obrigatória ao usuário. O grafo # é carregado a partir de arquivo .graphml grafo = ox.save_load.load_graphml("grafo(" + NOME_ARQUIVO_OSM + ").graphml", folder=CAMINHO_ARQUIVOS) salva_grafo_txt(grafo, NOME_ARQUIVO_OSM) print('OK\tGrafos de texto gerados.\n') r = input('>>\tGerar instância (s/n)?') if r == 's': gera_instancia_uhga() print('OK\tInstância gerada.\n') r = input(">>\tGerar arquivo '.graphml' modificado? (s/n)") if r == 's': # recebe o grafo com valores de nós padronizados # e retorna um grafo modificado com valores de nós menores (indexados) para ser desenhado try: arquivo_grafo = open(CAMINHO_ARQUIVOS + 'grafo('+NOME_ARQUIVO_OSM+').graphml', 'r', encoding='utf-8') recursos.modificador_grafo.modifica_valores_no_grafo(CAMINHO_ARQUIVOS, arquivo_grafo, NOME_ARQUIVO_OSM) except IOError as e: print (e) print('OK\tGrafo modificado gerado.\n') grafoml = ox.save_load.load_graphml("grafomod(" + NOME_ARQUIVO_OSM + ").graphml", CAMINHO_ARQUIVOS) r = input('>>\tMostrar rotas no Grafo? (s/n)') if r == 's': mostra_rotas(grafoml)
def _osm_net_from_osmnx(self, boundary, osm_file=None): """ Submits an Overpass API query and returns a geodataframe of results Parameters ---------- boundary : shapely geometry object shapely geometry representing the boundary for pulling the network osm_file : str, optional an OSM XML file to use instead of downloading data from the network """ # https://osmnx.readthedocs.io/en/stable/osmnx.html#osmnx.save_load.graph_to_gdfs node_tags = [ "access", "amenity", "bicycle", "bridge", "button_operated", "crossing", "flashing_lights", "foot", "highway", "junction", "leisure", "motorcar", "name", "oneway", "oneway:bicycle", "operator", "public_transport", "railway", "segregated", "shop", "stop", "surface", "traffic_sign", "traffic_signals", "tunnel", "width" ] way_tags = [ "access", "bridge", "bicycle", "button_operated", "crossing", "cycleway", "cycleway:left", "cycleway:right", "cycleway:both", "cycleway:buffer", "cycleway:left:buffer", "cycleway:right:buffer", "cycleway:both:buffer", "cycleway:width", "cycleway:left:width", "cycleway:right:width", "cycleway:both:width", "flashing_lights", "foot", "footway", "highway", "junction", "landuse", "lanes", "lanes:forward", "lanes:backward", "lanes:both_ways", "leisure", "maxspeed", "motorcar", "name", "oneway", "oneway:bicycle", "operator", "parking", "parking:lane", "parking:lane:right", "parking:lane:left", "parking:lane:both", "parking:lane:width", "parking:lane:right:width", "parking:lane:left:width", "parking:lane:both:width", "public_transport", "railway", "segregated", "service", "shop", "stop", "surface", "tracktype", "traffic_sign", "traffic_signals:direction", "tunnel", "turn:lanes", "turn:lanes:both_ways", "turn:lanes:backward", "turn:lanes:forward", "width", "width:lanes", "width:lanes:forward", "width:lanes:backward" ] ox.config(useful_tags_node=node_tags, useful_tags_path=way_tags) if osm_file: G = ox.graph_from_file(osm_file, simplify=True, retain_all=False) else: G = ox.graph_from_polygon(boundary, network_type='all', simplify=True, retain_all=False, truncate_by_edge=False, timeout=180, clean_periphery=True, custom_filter=None) G = ox.get_undirected(G) gdfs = ox.graph_to_gdfs(G) return gdfs[1], gdfs[0]
def __init__(self, height=50, width=50, num_bikes=10, num_riders=100, place='Boston, Massachusetts, USA'): # Set parameters self.height = height self.width = width self.num_bikes = num_bikes self.num_riders = num_riders self.place = place self.cur_time = "10/01/19 0:00:00" # hard coded for now self.schedule = TimedActivation(self, "10/01/19 0:00:00", "10/02/19 14:00:00") if 'Quincy' in place: self.G = ox.graph_from_file('data/quincy.osm') elif 'Boston' in place: self.G = ox.graph_from_file('data/boston.osm') else: self.G = ox.graph_from_place(place, network_type='bike') # self.G = self.G.to_directed() self.grid = NetworkGrid(self.G) self.datacollector = DataCollector({ "Rider": lambda m: m.schedule.get_breed_count(Rider), "Missed Rides": lambda m: m.missed_rides }) self.stations = {} self.missed_rides = 0 # Create stations self.createStations() # Create riders: self.createRiders() # Create bikes: self.createBikes() self.running = True self.datacollector.collect(self)
def extract_full_graph_from_osm(osm_path, osm_data_name="external"): """ Extracts graph from a pre-downloaded OSM file (either xml or pbf format). Typically useful if using older data and thus latest OSM map might be too up to date. You can download old OSM files from http://download.geofabrik.de/ e.g. http://download.geofabrik.de/europe/portugal.html -> raw directory index - > *.osm.pbf If OSM file, this function requires osmconvert, which can be installed with: Linux: apt install osmctools Mac OS: brew install interline-io/planetutils/osmctools :param osm_path: path of OSM pbf or xml file :param osm_data_name: name of data (i.e. location and data) :return: networkx graph, pruned but not simplified or projected """ # Source data paths _, process_data_path = data.utils.source_data() # Check extension of data if osm_path[-3:] == 'pbf': # Convert pbf to xml _, process_data_path = data.utils.source_data() convert_path = process_data_path + '/graphs/' + os.path.basename( osm_path)[:-3] + 'xml' # Use osmconvert to convert osmconvert_cmd = "osmconvert " + osm_path \ + " -b={},{},{},{}".format(bbox_ll[3], bbox_ll[1], bbox_ll[2], bbox_ll[0]) \ + "--drop-broken-refs --complete-ways" \ + " -o=" + convert_path os.system(osmconvert_cmd) elif osm_path[-3:] == 'xml': convert_path = osm_path else: raise ValueError('OSM file must be either .xml or .pbf') graph_full = ox.graph_from_file(convert_path, name=osm_data_name, simplify=False) graph_full = ox.truncate_graph_bbox(graph_full, bbox_ll[0], bbox_ll[1], bbox_ll[2], bbox_ll[3]) graph_full = prune_non_highways(graph_full) return graph_full
def buildHTMLWithQuery(query): writeXMLResponse(query) try: if os.stat(responsePath).st_size >= 2097152: logging.warning( "Response is too big. Maybe the map will not work properly but you can use the option " "'Open netedit'.") G = ox.graph_from_file(responsePath, retain_all=True) except (ValueError, KeyError): raise OsmnxException( "Probably there are elements without all its nodes or the response is empty. " "It is not possible to show the results but you can use the option 'Open netedit'." ) logging.info("Network built.") return buildHTMLWithNetworkx(G)
def query_OSM(directory, boundary, graph_pickle_file, query='drive_main'): """ Query OpenStreetMap and save it as a pickle file. Parameters ---------- directory : directory path where inputs and outputs should be boundary : Boundary for road network which can be either polygon boundary file or bounding box coordinates [north, south, west, east] network_type : string {'walk', 'bike', 'drive_all', 'drive_main', 'drive_main_links_included', 'drive_service', 'all', 'all_private', 'none'} what type of street or other network to get """ mainG = ox.graph_from_file(input_osm_file, network_type=query, simplify=False, retain_all=True) # mainG = ox.graph_from_xml(input_osm_file, simplify=False, retain_all=True) nx.write_gpickle(mainG, graph_pickle_file)
def test_graph_from_file(): # test loading a graph from a local .osm file node_id = 53098262 neighbor_ids = 53092170, 53060438, 53027353, 667744075 with bz2.BZ2File("tests/input_data/West-Oakland.osm.bz2") as input: handle, temp_filename = tempfile.mkstemp(suffix=".osm") os.write(handle, input.read()) os.close(handle) for filename in ("tests/input_data/West-Oakland.osm.bz2", temp_filename): G = ox.graph_from_file(filename) assert node_id in G.nodes for neighbor_id in neighbor_ids: edge_key = (node_id, neighbor_id, 0) assert neighbor_id in G.nodes assert edge_key in G.edges assert G.edges[edge_key]["name"] in ("8th Street", "Willow Street") os.remove(temp_filename)
def test_graph_from_file(): node_id = 53098262 neighbor_ids = 53092170, 53060438, 53027353, 667744075 with bz2.BZ2File('tests/input_data/West-Oakland.osm.bz2') as input: handle, temp_filename = tempfile.mkstemp(suffix='.osm') os.write(handle, input.read()) os.close(handle) for filename in ('tests/input_data/West-Oakland.osm.bz2', temp_filename): G = ox.graph_from_file(filename) assert node_id in G.nodes for neighbor_id in neighbor_ids: edge_key = (node_id, neighbor_id, 0) assert neighbor_id in G.nodes assert edge_key in G.edges assert G.edges[edge_key]['name'] in ('8th Street', 'Willow Street') os.remove(temp_filename)
def test_graph_from_file(): # test loading a graph from a local .osm file import bz2, tempfile node_id = 53098262 neighbor_ids = 53092170, 53060438, 53027353, 667744075 with bz2.BZ2File('tests/input_data/West-Oakland.osm.bz2') as input: handle, temp_filename = tempfile.mkstemp(suffix='.osm') os.write(handle, input.read()) os.close(handle) for filename in ('tests/input_data/West-Oakland.osm.bz2', temp_filename): G = ox.graph_from_file(filename) assert node_id in G.nodes for neighbor_id in neighbor_ids: edge_key = (node_id, neighbor_id, 0) assert neighbor_id in G.nodes assert edge_key in G.edges assert G.edges[edge_key]['name'] in ('8th Street', 'Willow Street') os.remove(temp_filename)
def load_graph(): while True: text = input('Import a graph? (y|n)') if text == 'y' or text == 'Y' or text == "Yes" or text == "yes": path = input('Enter graph path') graph = ox.graph_from_file(path, network_type='drive', simplify=True, retain_all=True, name='unnamed') G_projected = ox.project_graph(graph) ox.plot_graph(G_projected) return graph text = input("Create new graph? (y|n)") if text == 'y' or text == 'Y' or text == "Yes" or text == "yes": while True: # west = float(input("Top left coordinate latitude (west bounding)")) # north = float(input("Top left coordinate longitude (north bounding)")) # east = float(input("Bottom right coordinate latitude (east bounding)")) # south = float(input("Bottom right coordinate longitude (south bounding)")) north, south, east, west = 37.79, 37.78, -122.41, -122.43 graph = ox.graph_from_bbox(north, south, east, west, network_type='drive', truncate_by_edge=True, simplify=True) # G_projected = ox.project_graph(graph) # ox.plot_graph(G_projected) text = input("Does this look correct?") if text == 'y' or text == 'Y' or text == "Yes" or text == "yes": text = str(input("Name the graph file")) ox.save_graphml(graph, filename=text + '.graphml') return graph
returndict = 0 print('返回结果') print(returndict) returnjson = json.dumps(returndict) returnjson = make_response(returnjson) returnjson.headers['Access-Control-Allow-Origin'] = '*' return returnjson else: return '只接受post请求!' if __name__ == '__main__': # 获取路网信息 print("开始路网匹配") huangpu = ox.graph_from_file("D:\Anaconda\data\huangpu\huangpu.osm", network_type="drive") nodes, edges = ox.graph_to_gdfs(huangpu) edges["name"].fillna("nan", inplace=True) def list_perform(x): if type(x) == type([]): return x[0] else: return x edges['name'] = edges['name'].apply(lambda x: list_perform(x)) huangpu_edges = edges huangpu_edges = huangpu_edges[huangpu_edges['name'] != "nan"]
import osmnx as ox G = ox.graph_from_file("amk_copy.osm", name="test") ox.plot_graph(G) #test = ox.graph_to_gdfs(G) #ox.plot_shape(ox.project_gdf(test))
import osmnx as ox import networkx as nx # Read map G = ox.graph_from_file("data/map.osm", name="Kaart", retain_all=True) nodes = [-126565, -126574, -126583, -126592, -126601, -126610, -126619] start = ox.get_nearest_node(G, (50.13554168794, 8.64772690044)) for node in nodes: route = nx.shortest_path(G, start, node, weight='length') fig, ax = ox.plot_graph_route(G, route, node_size=0, show=False) fig.show()
import numpy as np import networkx as nx #G = osmnx.graph_from_file('/home/user/MiniTaxiFleets/AnuStart/mini_centraal_sac_town.osm', network_type='drive',simplify=True) #G = osmnx.graph_from_file('/home/user/MiniTaxiFleets/road_network_osm_files/cologne_centraal_ish_8km2.osm', network_type='drive',simplify=True) #all on c207 path_to_osm_files = '/home/user/Downloads/osm_city_road_maps/' SF_central_filename = 'SF_central_64km2_-122.479,37.733_-122.388,37.805.osm' Roma_centrale_filename = 'roma_centrale_64km2_12.442,41.856_12.5387,41.928.osm' Birmingham_central_filename = 'Birmingham_central_64km2_-1.971,52.447_-1.825,52.508.osm' G1 = osmnx.graph_from_file(path_to_osm_files + SF_central_filename, network_type='drive', simplify=True) G2 = osmnx.graph_from_file(path_to_osm_files + Roma_centrale_filename, network_type='drive', simplify=True) G3 = osmnx.graph_from_file(path_to_osm_files + Birmingham_central_filename, network_type='drive', simplify=True) G1b = osmnx.core.add_edge_lengths(G1) G2b = osmnx.core.add_edge_lengths(G2) G3b = osmnx.core.add_edge_lengths(G3) #nx.write_gpickle(G2, "Cologne_Centraal_Road_Network.gpickle", protocol=2)
def load_map(): return ox.graph_from_file( f'{OSM_OUTPUT_DIR}/{OSM_OUTPUT_FILENAME}.osm')
import json import matplotlib.pyplot as plt import networkx as nx import osmnx as ox G = ox.graph_from_file("map.osm") # nodes, _ = ox.graph_to_gdfs(G) library = (31.242, 121.433) museum = (31.235, 121.45) closest_node_to_lib = ox.get_nearest_node(G, library, method='haversine') closest_node_to_museum = ox.get_nearest_node(G, museum, method='haversine') route = nx.shortest_path(G, closest_node_to_lib, closest_node_to_museum) print(route) total_line = [] for i in range(len(route) - 1): # 当前node node_id = route[i] # 下一node next_node_id = route[i + 1] segment = G[node_id][next_node_id][0] # 两个node之间为直线时, edge中不包含geometry, 用node的坐标连线即可 # 两个node之间为折线时, edge会有geometry(LineString) if 'geometry' in segment: line = segment['geometry'] if i == 0:
# Find nodes closest to the specified coordinates node_start = ox.utils.get_nearest_node(area_graph, startpoint) node_stop = ox.utils.get_nearest_node(area_graph, endpoint) #Calculate the shortest network distance between the nodes via the edges length try: distance = round(nx.shortest_path_length(area_graph, node_start, node_stop, weight="length"),0) # return NA if no path exists except nx.NetworkXNoPath: distance = "NA" return distance print("Downloading Dublin maps from OpenStreetMap API...") # Load map from OpenStreetMap API G = ox.graph_from_place('Dublin, Ireland', network_type='drive') ox.save_graph_osm(G, filename='mynetwork.osm') E = ox.graph_from_file(filename='data\mynetwork.osm', bidirectional = False) # Settings for Streetnetwork-Download map_file = 'data\mynetwork.osm' force_creat = False #Checks if the Streetnetwork File exists (or creation is overwritten) if (not os.path.isfile(map_file))or force_creat: area_graph = ox.graph_from_place('Dublin, Ireland', network_type='drive') ox.save_graph_osm(area_graph, filename=map_file) else: area_graph = ox.graph_from_file(filename = map_file, bidirectional = False) print("Map download complete") # input lat long from position file
def index(request): try: if request.method == 'POST': retrieveForm = AddressForm(request.POST) if retrieveForm.is_valid(): # punggol, singapore org_var = retrieveForm.cleaned_data['var_org'] # blk 128B, punggol, singapore dst_var = retrieveForm.cleaned_data['var_dst'] type_var = retrieveForm.cleaned_data['var_type'] geolocator = Nominatim(user_agent="test") org_addr = geolocator.geocode(org_var) dst_addr = geolocator.geocode(dst_var) org = (org_addr.latitude, org_addr.longitude) dest = (dst_addr.latitude, dst_addr.longitude) if type_var == 'Bus': graph = ox.graph_from_file(JSON_FOLDER + "punggol.osm", bidirectional=True, simplify=True, retain_all=False) start = ox.geocode(org_var) end = ox.geocode(dst_var) print("Found a starting node", start) print("Found a ending node", end) start_node = ox.get_nearest_node(graph, start) end_node = ox.get_nearest_node(graph, end) nodes, edges = ox.graph_to_gdfs(graph) # TO CREATE BUS ROUTING pathcheck = bus(busGraph, graph, start, end, start_node, end_node) # IF BUS ROUTE IS AVAILABLE if pathcheck[1] == 0: startStopCoords = pathcheck[2] endStopCoords = pathcheck[3] print(startStopCoords) print(endStopCoords) start_Bus = ox.get_nearest_node(graph, startStopCoords) end_Bus = ox.get_nearest_node(graph, endStopCoords) pathToBusstop = astar_path(graph, start_node, start_Bus) pathFromBusstop = astar_path(graph, end_Bus, end_node) latlontobus = [] latlonfrombus = [] # walk from start to bus start startbuscoord = (graph.nodes[start_Bus]['y'], graph.nodes[start_Bus]['x']) prev = None splice = None ptr = 0 temp = float("Infinity") for item in pathToBusstop: if prev is None: prev = item else: try: line = graph[prev][item][0]["geometry"] for point in list(line.coords): if splice is None: splice = ptr temp = geopy.distance.distance( startbuscoord, (point[1], point[0])).km elif geopy.distance.distance( startbuscoord, (point[1], point[0])).km < temp: splice = ptr temp = geopy.distance.distance( startbuscoord, (point[1], point[0])).km latlontobus.append( (point[1], point[0])) ptr += 1 except: pass finally: prev = item latlontobus = latlontobus[:splice + 1] # walk for bus end to dst endbuscoord = (graph.nodes[end_Bus]['y'], graph.nodes[end_Bus]['x']) prev = None splice = None ptr = 0 temp = float("Infinity") for item in pathFromBusstop: if prev is None: prev = item else: try: line = graph[prev][item][0]["geometry"] for point in list(line.coords): if splice is None: splice = ptr temp = geopy.distance.distance( endbuscoord, (point[1], point[0])).km elif geopy.distance.distance( endbuscoord, (point[1], point[0])).km < temp: splice = ptr temp = geopy.distance.distance( endbuscoord, (point[1], point[0])).km latlonfrombus.append( (point[1], point[0])) ptr += 1 except: pass finally: prev = item latlonfrombus = latlonfrombus[:splice + 1] path = pathcheck[0] indexing = 0 line = [] prevService = None prevIndex = None i = 0 markers = [] routing = None while i < len(path): stopCode, service = path[i] # in the case of first stop, no bus service stated, take next if service is None: service = path[i + 1][1] if service != prevService: indexing = 0 prevIndex = 0 qlat = bus_stop_code_map[stopCode]["Latitude"] qlon = bus_stop_code_map[stopCode]["Longitude"] # get routes for respective direction if service[1] == 1: routing = busRoute0[service[0]]["coordinates"] else: routing = busRoute1[service[0]]["coordinates"] while indexing < len(routing): clon, clat = routing[indexing] u = (qlat, qlon) v = (clat, clon) # stop found in range of 30 meters, latlong accuracy difference from # two sources if geopy.distance.distance(u, v).km < 0.03: # first bus stop if prevService is None: line.append(v) else: if prevService == service: print("ALWAYS COME HERE?", prevIndex, indexing) for x, y in routing[ prevIndex:indexing + 1]: line.append((y, x)) else: print( "ENTER ELSE ---------------------------------" ) prevLatLong = line[-1] tempIndex = 0 while tempIndex < len(routing): plon, plat = routing[tempIndex] p = (plat, plon) if geopy.distance.distance( prevLatLong, p).km < 0.03: for x, y in routing[ tempIndex: indexing + 1]: line.append((y, x)) break tempIndex += 1 prevIndex = indexing prevService = service markers.append((v, stopCode)) break indexing += 1 i += 1 # TO CREATE ROUTING WITH BUS nodepath = astar_path(graph, start_node, end_node) m = ox.plot_route_folium(graph, nodepath, tiles='openstreetmap', route_color='green', route_opacity=0) folium.Marker(location=(start[0], start[1]), popup='START', icon=folium.Icon(color='red', icon='flag')).add_to(m) folium.Marker(location=(end[0], end[1]), popup='END', icon=folium.Icon(color='blue', icon='flag')).add_to(m) for loc, code in markers: folium.Marker(location=loc, popup='Bus stop number:' + str(code), icon=folium.Icon( color='green', icon='bus', prefix='fa')).add_to(m) folium.PolyLine(line, color="red", weight=2.5, opacity=1).add_to(m) # start point to start busstop folium.PolyLine([start, latlontobus[0]], color="blue", weight=2.5, opacity=1, dasharray="4").add_to(m) folium.PolyLine(latlontobus, color="green", weight=2.5, opacity=1).add_to(m) folium.PolyLine([latlontobus[-1], line[0]], color="blue", weight=2.5, opacity=1, dasharray="4").add_to(m) # End bus stop to end point folium.PolyLine([line[-1], latlonfrombus[0]], color="blue", weight=2.5, opacity=1, dasharray="4").add_to(m) folium.PolyLine(latlonfrombus, color="green", weight=2.5, opacity=1, dasharray="4").add_to(m) folium.PolyLine([latlonfrombus[-1], end], color="blue", weight=2.5, opacity=1, dasharray="4").add_to(m) m.save(ROUTE_FOLDER + 'bus_routing.html') # IF BUS ROUTE NOT FOUND, RUN WALK ROUTE if pathcheck[1] == 1: nodepath = pathcheck[0] m = ox.plot_route_folium(graph, nodepath, tiles='openstreetmap', route_color='green') folium.Marker(location=(start[0], start[1]), popup='START', icon=folium.Icon(color='red', icon='flag')).add_to(m) folium.Marker(location=(end[0], end[1]), popup='END', icon=folium.Icon(color='blue', icon='flag')).add_to(m) m.save(ROUTE_FOLDER + 'bus_routing.html') print("bus_routing.html created!") speedBus = 40 stopsBus = getStops() distanceBus = round(getDistance(), 3) timeBus = math.ceil((getDistance() / speedBus) * 60) timeBus = timeBus + stopsBus if distanceBus <= 3.2: costBus = 0.92 elif distanceBus <= 4.2: costBus = 1.02 elif distanceBus <= 5.2: costBus = 1.12 elif distanceBus <= 6.2: costBus = 1.22 elif distanceBus <= 7.2: costBus = 1.31 elif distanceBus <= 8.2: costBus = 1.38 elif distanceBus <= 9.2: costBus = 1.44 else: costBus = 2 busRoute = getBus().split(',') contentDict = { "org_addr": org_addr.address, "dst_addr": dst_addr.address, "mode_var": type_var, "distance": distanceBus, "stops": getStops(), "bus": busRoute, "time": timeBus, "cost": costBus } return render(request, "bus.html", contentDict) elif type_var == 'LRT': print("Loading OSM") graph = ox.graph_from_file(JSON_FOLDER + "punggol.osm", bidirectional=True, simplify=True, retain_all=False) start = ox.geocode(org_var) end = ox.geocode(dst_var) print("Found a starting node", start) print("Found a ending node", end) start_node = ox.get_nearest_node(graph, start) end_node = ox.get_nearest_node(graph, end) nodes, edges = ox.graph_to_gdfs(graph) # TO CREATE ROUTE TO AND FROM LRT path_to_Lrt = findNearestLrt(graph, start, end, start_node, end_node) # LRT ROUTING lrtline = [] lrtMarkers = [] if path_to_Lrt is not None: # if LRT path is found if path_to_Lrt[1] == 0: pathDict = path_to_Lrt[0] for path in pathDict: indexing = 0 prevService = None prevIndex = None i = 0 for item in path: direction = item[0][4] stationName = item[0][1] loop = item[0][-1] if direction == 1: print("D 1 \n") routing = LrtRoute0[loop]["coordinates"] else: print("D 2 \n") routing = LrtRoute1[loop]["coordinates"] while i < len(path[item]): qlat = path[item][i][2] qlon = path[item][i][3] while indexing < len(routing): clon, clat = routing[indexing] u = (qlat, qlon) v = (clat, clon) if geopy.distance.distance( u, v).km < 0.03: if prevService is None: lrtline.append(v) else: prevLatLong = lrtline[-1] tempIndex = 0 while tempIndex < len(routing): plon, plat = routing[ tempIndex] p = (plat, plon) if geopy.distance.distance( prevLatLong, p).km < 0.01: for x, y in routing[ tempIndex: indexing + 1]: lrtline.append( (y, x)) break tempIndex += 1 prevIndex = indexing prevService = path[item] lrtMarkers.append( (v, path[item][i][1], path[item][i][-1], path[item][i][-2])) break indexing += 1 i += 1 nearestStartStop = path_to_Lrt[2] nearestEndStop = path_to_Lrt[3] start_Lrt = ox.get_nearest_node( graph, nearestStartStop) end_Lrt = ox.get_nearest_node( graph, nearestEndStop) pathToLrtStop = astar_path(graph, start_node, start_Lrt) pathFromLrtStop = astar_path( graph, end_Lrt, end_node) latlontolrt = [] latlonfromlrt = [] # walk from start to lrt start startlrtcoord = (graph.nodes[start_Lrt]['y'], graph.nodes[start_Lrt]['x']) prev = None splice = None ptr = 0 temp = float("Infinity") for item in pathToLrtStop: if prev is None: prev = item else: try: line = graph[prev][item][0]["geometry"] for point in list(line.coords): if splice is None: splice = ptr temp = geopy.distance.distance( startlrtcoord, (point[1], point[0])).km elif geopy.distance.distance( startlrtcoord, (point[1], point[0])).km < temp: splice = ptr temp = geopy.distance.distance( startlrtcoord, (point[1], point[0])).km latlontolrt.append( (point[1], point[0])) ptr += 1 except: pass finally: prev = item if splice is not None: latlontolrt = latlontolrt[:splice + 1] # walk from lrt end to end endlrtcoord = (graph.nodes[end_Lrt]['y'], graph.nodes[end_Lrt]['x']) prev = None splice = None ptr = 0 temp = float("Infinity") for item in pathFromLrtStop: if prev is None: prev = item else: try: line = graph[prev][item][0]["geometry"] for point in list(line.coords): if splice is None: splice = ptr temp = geopy.distance.distance( endlrtcoord, (point[1], point[0])).km elif geopy.distance.distance( endlrtcoord, (point[1], point[0])).km < temp: splice = ptr temp = geopy.distance.distance( endlrtcoord, (point[1], point[0])).km latlonfromlrt.append( (point[1], point[0])) ptr += 1 except: pass finally: prev = item if splice is not None: latlonfromlrt = latlonfromlrt[:splice + 1] else: print("LRT route unable to be established") # default route nodepath = astar_path(graph, start_node, end_node) if path_to_Lrt[1] == 0: # INIT m = ox.plot_route_folium(graph, nodepath, tiles='openstreetmap', route_color='green', route_opacity=0) # LRT LINE folium.PolyLine(lrtline, color="black", weight=2.5, opacity=1).add_to(m) # Variables for Display strStation = '' stationCount = 0 # LRT Markers for loc, station, loop, direction in lrtMarkers: folium.Marker( location=loc, popup='<b>Station Name:</b> ' + str(station) + '<br><b>Lat:</b> ' + str(loc[0]) + '<br><b>Lon:</b> ' + str(loc[1]) + '<br><b>Loop:</b> ' + str(loop) + '<br><b>Direction: </b>' + str(direction), icon=folium.Icon(color='black', icon='train', prefix='fa')).add_to(m) strStation = strStation + str(station) + ',' stationCount = stationCount + 1 strStation = strStation + 'End' # START AND END MARKERS folium.Marker(location=(start[0], start[1]), popup='START', icon=folium.Icon(color='red', icon='flag')).add_to(m) folium.Marker(location=(end[0], end[1]), popup='END', icon=folium.Icon(color='blue', icon='flag')).add_to(m) if len(latlontolrt) > 0: # start point to start lRT folium.PolyLine([start, latlontolrt[0]], color="blue", weight=2.5, opacity=1, dasharray="4").add_to(m) folium.PolyLine(latlontolrt, color="green", weight=2.5, opacity=1).add_to(m) folium.PolyLine([latlontolrt[-1], lrtline[0]], color="blue", weight=2.5, opacity=1, dasharray="4").add_to(m) if len(latlonfromlrt) > 0: # End LRT stop to end point folium.PolyLine([lrtline[-1], latlonfromlrt[0]], color="blue", weight=2.5, opacity=1, dasharray="4").add_to(m) folium.PolyLine(latlonfromlrt, color="green", weight=2.5, opacity=1, dasharray="4").add_to(m) folium.PolyLine([latlonfromlrt[-1], end], color="blue", weight=2.5, opacity=1, dasharray="4").add_to(m) m.save(ROUTE_FOLDER + 'lrt_routing.html') print("LRT_Routing.html created!") # IF LRT ROUTE NOT FOUND, RUN WALK ROUTE if path_to_Lrt[1] == 1: # INIT m = ox.plot_route_folium(graph, nodepath, tiles='openstreetmap', route_color='green') folium.Marker(location=(start[0], start[1]), popup='START', icon=folium.Icon(color='red', icon='flag')).add_to(m) folium.Marker(location=(end[0], end[1]), popup='END', icon=folium.Icon(color='blue', icon='flag')).add_to(m) m.save(ROUTE_FOLDER + 'lrt_routing.html') print("LRT_Routing.html created!") strStation = strStation.split(',') timeTrain = 2 * stationCount if getDistanceLRT() <= 3.2: costLRT = 0.92 elif getDistanceLRT() <= 4.2: costLRT = 1.02 elif getDistanceLRT() <= 5.2: costLRT = 1.12 elif getDistanceLRT() <= 6.2: costLRT = 1.22 elif getDistanceLRT() <= 7.2: costLRT = 1.31 elif getDistanceLRT() <= 8.2: costLRT = 1.38 elif getDistanceLRT() <= 9.2: costLRT = 1.44 else: costLRT = 2 contentDict = { "org_addr": org_addr.address, "dst_addr": dst_addr.address, "mode_var": type_var, "count": stationCount, "route": strStation, "time": timeTrain, "cost": costLRT } return render(request, "lrt.html", contentDict) else: if type_var == 'Walk': if org: graph = ox.graph_from_point(org, distance=2000, network_type='walk') else: (graph, org) = ox.graph_from_address(address, distance=5000, network_type='walk', return_coords=True) elif type_var == 'Drive': if org: graph = ox.graph_from_point(org, distance=2000, network_type='drive') else: graph = ox.graph_from_address(address, distance=5000, network_type='drive') # get cloest node to the point of search global target_node orig_node = ox.get_nearest_node(graph, org) target_node = ox.get_nearest_node(graph, dest) nodes, edges = ox.graph_to_gdfs(graph) node_data = get_nodes(edges) ourRoute3 = list( creator3(nodes, node_data, orig_node, target_node)) # usage of folium to create interactive web map astar_map = ox.plot_route_folium(graph, ourRoute3, popup_attribute='name', tiles='openstreetmap', route_color='blue') folium.Marker( location=org, popup=org_addr.address, icon=folium.Icon(color='red')).add_to(astar_map) folium.Marker( location=dest, popup=dst_addr.address, icon=folium.Icon(color='blue')).add_to(astar_map) filepath3 = ROUTE_FOLDER + 'astar_route.html' astar_map.save(filepath3) distanceAstar = round( getDistanceTravelled(nodes, node_data, ourRoute3), 3) if type_var == 'Walk': estSpeed = 5 else: estSpeed = 50 timeAstar = math.ceil((distanceAstar / estSpeed) * 60) contentDict = { "org_addr": org_addr.address, "dst_addr": dst_addr.address, "dist_astar": distanceAstar, "mode_var": type_var, "time": timeAstar, "estSpeed": estSpeed } return render(request, "main.html", contentDict) else: inputForm = AddressForm() return render(request, "index.html", {'form': inputForm}) except: inputForm = AddressForm() return render(request, "error.html", {'form': inputForm})
punggol = (1.403948, 103.909048) #G = ox.graph_from_point(punggol, distance=1200, truncate_by_edge=True, network_type="walk") # ========================================================= # PLACE IN INIT # ========================================================= take_bus_distance = 150 # in meters. this value is for lrt+bus+walk # if destination falls within this distance, user wont take a bus punggol = (1.4053828, 103.9022239) # punggol MRT station, change according to whatever coordinates you are using G = ox.graph_from_point(punggol, distance=1200, truncate_by_edge=True, network_type="walk",infrastructure='way["highway"]') G = ox.remove_isolated_nodes(G) lrt_east = ox.graph_from_file(filename="data\lrt_pg_east.osm", retain_all="true") # retain all is essential lrt_west = ox.graph_from_file(filename="data\lrt_pg_west.osm", retain_all="true") lrt_exits = ox.graph_from_file(filename="data\lrt_bridges.osm", retain_all="true") lrt_stations = nx.compose(lrt_east, lrt_west) # ========================================================= # END OF "PLACE IN INIT" requirements # ========================================================= @app.route("/") @app.route("/home", methods=['GET', 'POST']) def home():
def buildOSMnx(file): G = ox.graph_from_file(file, simplify=False) return G
import osmnx as ox import networkx as nx import folium import os path = os.path.dirname(os.path.abspath(__file__)) + "\\" path = path[:-5] G = ox.graph_from_file(path + "maps\\bremm.osm") K = ox.graph_from_place('Amersfoort,NL', network_type='drive') Z = ox.graph_from_place('NL', network_type='drive') H = ox.graph_from_place('Bremm,GER', network_type='drive') # origin = ox.geo_utils.geocode('KROAST,Amersfoort, NL') # destination = ox.geo_utils.geocode('krakelingtunnel,Almere, NL') # orig = ox.get_nearest_node(Z, origin) # dest = ox.get_nearest_node(Z, destination) # route = nx.shortest_path(Z,orig, dest) # ox.plot_graph_route(Z, route) #ox.plot_graph(G)\ #ox.plot_graph(ox.project_graph(H)); print("test") place = {'city': 'Amersfoort', 'state': 'Utrecht', 'country': 'NL'} kaas = ox.graph_from_place(place, network_type='drive') fig, ax = ox.plot_graph(kaas, fig_height=12, node_size=0, edge_linewidth=0.5)
def generateGraphML(osmFile,filePathML): multiGraph = ox.graph_from_file(osmFile,True,True,True) ox.save_graphml(multiGraph, filePathML)
def get_graph_from_osm(filename): ox.config(use_cache=True, log_console=False) G_nx = ox.graph_from_file(filename) G_nx = nx.relabel.convert_node_labels_to_integers(G_nx) return G_nx
#!/usr/bin/env python # coding: utf-8 # Import required libraries # In[59]: import osmnx as ox import networkx as nx import queue import math import priority_dict # Import OSM map of VNIT and apply A* for mission planning map_graph = ox.graph_from_file( '/home/aniket/autonomous-delivery-robot/Planning/Vnit_map/CollegeMap.osm', simplify=True) origin = ox.get_nearest_node(map_graph, (21.122, 79.045)) destination = list(map_graph.nodes())[15] #fig, ax = ox.plot_graph(map_graph) # This function follows the predecessor # backpointers and generates the equivalent path from the # origin as a list of vertex keys. def get_path(origin_key, goal_key, predecessors): key = goal_key path = [goal_key] while (key != origin_key):
def osm_to_graphml(osm_file, graphml_file): G = ox.graph_from_file(place,network_type="drive") ox.save_load.save_graphml(G, graphml_file)
def load_geofabrik(self, polygon): path = self._filter_geofabrik(polygon) return ox.graph_from_file(path, retain_all=True, simplify=False)
local_volume_data = False if options.gen_costs: gen_cost_arg_dict = {'on': True, 'off': False} gen_costs_on = gen_cost_arg_dict[options.gen_costs] assert ox.settings.all_oneway # 1. LOAD OSM DATA logger.info('Loading OSM data...') # load from disk if osm_mode == 'local': osm_path = os.path.join(data_dir, osm_fname) try: G = ox.graph_from_file(osm_path, simplify=False, retain_all=True) except OSError: raise OSError("Couldn't find file {0}. Make sure it is in " "the data directory ({1}).".format( osm_fname, data_dir)) # or pull it from the web "on-the-fly" elif osm_mode == 'otf': G = ox.graph_from_place(place, network_type='all', simplify=False, retain_all=True) else: raise ValueError('Must specify a valid OSM mode. See --help ' 'for more details.')
import datetime import networkx as nx import osmnx as ox import utm from shapely.geometry import box start_time = datetime.datetime.now() graph = ox.graph_from_file("map.osm", network_type="drive") # graph = ox.graph_from_place("Kamppi, Helsinki, Finland", network_type="drive") end_time = datetime.datetime.now() print("Load graph: " + str((end_time - start_time).seconds) + "s") edges = ox.graph_to_gdfs(graph, nodes=False, edges=True) start_time = datetime.datetime.now() graph_proj = ox.project_graph(graph) end_time = datetime.datetime.now() print("Project graph:" + str((end_time - start_time).seconds) + "s") # fig, ax = ox.plot_graph(graph_proj) # plt.tight_layout() nodes_proj, edges_proj = ox.graph_to_gdfs(graph_proj, nodes=True, edges=True) print("Coordinate system:", edges_proj.crs) bbox = box(*edges_proj.unary_union.bounds) print(bbox) orig_point = bbox.centroid print(orig_point) orig_point_utm = utm.from_latlon(longitude=121.43741, latitude=31.239888)