def test_geometries(): # geometries_from_bbox - bounding box query to return empty GeoDataFrame gdf = ox.geometries_from_bbox(0.009, -0.009, 0.009, -0.009, tags={"building": True}) # geometries_from_bbox - successful north, south, east, west = ox.utils_geo.bbox_from_point(location_point, dist=500) tags = {"landuse": True, "building": True, "highway": True} gdf = ox.geometries_from_bbox(north, south, east, west, tags=tags) fig, ax = ox.plot_footprints(gdf) # geometries_from_point - tests multipolygon creation gdf = ox.geometries_from_point((48.15, 10.02), tags={"landuse": True}, dist=2000) # geometries_from_place - includes test of list of places tags = {"amenity": True, "landuse": ["retail", "commercial"], "highway": "bus_stop"} gdf = ox.geometries_from_place(place1, tags=tags) gdf = ox.geometries_from_place([place1], tags=tags) # geometries_from_address - includes testing overpass settings and snapshot from 2019 ox.settings.overpass_settings = '[out:json][timeout:200][date:"2019-10-28T19:20:00Z"]' gdf = ox.geometries_from_address(address, tags=tags) # geometries_from_xml - tests error handling of clipped XMLs with incomplete geometry gdf = ox.geometries_from_xml("tests/input_data/planet_10.068,48.135_10.071,48.137.osm") # test loading a geodataframe from a local .osm xml file with bz2.BZ2File("tests/input_data/West-Oakland.osm.bz2") as f: handle, temp_filename = tempfile.mkstemp(suffix=".osm") os.write(handle, f.read()) os.close(handle) for filename in ("tests/input_data/West-Oakland.osm.bz2", temp_filename): gdf = ox.geometries_from_xml(filename) assert "Willow Street" in gdf["name"].values os.remove(temp_filename)
def _download_geometries(place, download_method, tags, crs, distance = 500.0): """ The function downloads certain geometries from OSM, by means of OSMNX functions. It returns a GeoDataFrame, that could be empty when no geometries are found, with the provided tags. Parameters ---------- place: string name of cities or areas in OSM: when using "OSMpolygon" please provide the name of a "relation" in OSM as an argument of "place"; when using "distance_from_address" provide an existing OSM address; when using "OSMplace" provide an OSM place name download_method: string {"polygon", "distance_from_address", "OSMplace"} it indicates the method that should be used for downloading the data. tag: dict the desired OSMN tags crs: string the coordinate system of the case study area Returns ------- geometries_gdf: GeoDataFrame the resulting GeoDataFrame """ if download_method == 'distance_from_address': geometries_gdf = ox.geometries_from_address(place, tags = tags, dist = distance) elif download_method == 'OSMplace': geometries_gdf = ox.geometries_from_place(place, tags = tags) else: geometries_gdf = ox.geometries_from_polygon(place, tags = tags) geometries_gdf = geometries_gdf.to_crs(crs) return geometries_gdf
def get_pois(selected_poi): """ Returns a GeoDataFrame containing all the POI categories in select_poi. This function takes a list of POIs as input and returns a GeoDataFrame containing all inputted types. If a POI input is not already existing in the POIs folder, the function queries OSM and creates the file in the expected folder.""" poi_filenames = [poi + '.csv' for poi in selected_poi] poi_paths = [ data_folder / 'POIs' / poi_filename for poi_filename in poi_filenames ] place = 'Canton de Genève, Switzerland' print('get_pois is running') for poi, path, filename in zip(selected_poi, poi_paths, poi_filenames): if os.path.exists(path): print(path, 'File existed') else: print(path, 'Querying OSM for the missing tag') if 'bakery' in filename: type_poi = 'shop' elif 'tree' in filename: type_poi = 'natural' else: type_poi = 'amenity' tags = {type_poi: poi} print(tags) gdf = ox.geometries_from_place(place, tags) gdf.index = gdf.index.map(int) gdf['id'] = gdf.index if 'element_type' in gdf.columns: gdf = gdf[gdf.element_type == 'node'] gdf['lon'] = gdf.geometry.x gdf['lat'] = gdf.geometry.y gdf.to_csv(path, index=False) df_poi = pd.concat( (pd.read_csv(f) for f in poi_paths)).reset_index(drop=True) df_poi['category'] = 'Unhealthy' if 'natural' in df_poi.columns: df_poi.loc[df_poi.natural == 'tree', 'category'] = 'Healthy' df_poi.loc[df_poi.natural == 'tree', 'poi_category'] = df_poi.natural else: df_poi['natural'] = np.NaN if 'shop' in df_poi.columns: df_poi.loc[(df_poi.shop.isnull() == False), 'poi_category'] = df_poi.shop else: df_poi['shop'] = np.NaN if 'amenity' in df_poi.columns: df_poi.loc[(df_poi.amenity.isnull() == False), 'poi_category'] = df_poi.amenity else: df_poi['amenity'] = np.NaN geometry = [Point(xy) for xy in zip(df_poi.lon, df_poi.lat)] crs = 'epsg:4326' df_poi = gpd.GeoDataFrame(df_poi, crs=crs, geometry=geometry) df_poi = df_poi.to_crs('epsg:2056') return df_poi
def getOSMFootprints(bbox=[], place='', save=True, fileName='', workDir='tmp', overwrite=False): """Function for downloading a building footprints. Args: place (str): Name of the city or county. save (bool): Save file locally. fileName (str): Path of the file. Returns: allFootprints (geopandas dataframe): Footprints fileName (str): Path to the footprint file. """ if fileName == '': if len(bbox) > 0: fileName = Path( f'{workDir}/{bbox[0]}_{bbox[1]}_{bbox[2]}_{bbox[3]}_footprints.geojson' ) else: fileName = Path( f'{workDir}/{place}_footprints_OSM.geojson'.replace( ' ', '_').replace(',', '_')) if os.path.exists(fileName) and not overwrite: print('{} already exists.'.format(fileName)) allFootprints = gpd.read_file(fileName) else: if len(bbox) > 0: allFootprints = ox.geometries_from_bbox( bbox[0], bbox[2], bbox[3], bbox[1], tags={ 'building': True }) # (north,west,south,east)->(north, south, east, west, tags) else: allFootprints = ox.geometries_from_place(place, tags={'building': True}) allFootprints = allFootprints[['geometry']] allFootprints = allFootprints[allFootprints['geometry'].type == 'Polygon'] # save if allFootprints.shape[0] < 1: print('Didn\'t find footprints for this region.') else: allFootprints.to_file(fileName, driver='GeoJSON') print('Footprint saved at {}'.format(fileName)) return allFootprints, fileName
def setup_osm(place_name): graph = ox.graph_from_place(place_name) buildings = ox.geometries_from_place(place_name, tags={'building': True}) buildings_dict = {} for index, row in buildings.iterrows(): if row['name'] not in buildings_dict: buildings_dict[row['name']] = {} buildings_dict[row['name']]['x'] = float( '-' + str(row['geometry']).split('-')[1].split(' ')[0]) buildings_dict[row['name']]['y'] = float( str(row['geometry']).split('-')[1].split(' ')[1].split(',')[0] [:-1]) return graph, buildings_dict
def get_urban_rail_fromOSM(place, download_method, epsg, distance=7000): """ The function downloads and creates a simplified OSMNx graph for a selected area's urban rail network. Afterwards, GeoDataFrames for nodes and edges are created, assigning new nodeID and edgeID identifiers. Parameters ---------- place: string name of cities or areas in OSM: when using "OSMpolygon" please provide the name of a "relation" in OSM as an argument of "place"; when using "distance_from_address" provide an existing OSM address; when using "OSMplace" provide an OSM place name download_method: string {"polygon", "distance_from_address", "OSMplace"} it indicates the method that should be used for downloading the data. When 'polygon' the shape to get network data within. coordinates should be in unprojected latitude-longitude degrees (EPSG:4326). epsg: int epsg of the area considered; if None OSMNx is used for the projection distance: float it is used only if download_method == "distance from address" Returns ------- nodes_gdf, edges_gdf: Tuple of GeoDataFrames the nodes and edges GeoDataFrames """ crs = 'EPSG:' + str(epsg) tag = {'railway': True} if download_method == 'distance_from_address': railways_gdf = ox.geometries_from_address(place, tags=tag, dist=distance) elif download_method == 'OSMplace': railways_gdf = ox.geometries_from_place(place, tags=tag) else: railways_gdf = ox.geometries_from_polygon(place, tags=tag) print(railways_gdf.columns) railways_gdf = railways_gdf.to_crs(crs) to_keep = ["rail", "light_rail", "subway"] railways_gdf = railways_gdf[railways_gdf.railway.isin(to_keep)] railways_gdf['type'] = railways_gdf['railway'] railways_gdf['length'] = railways_gdf.geometry.length railways_gdf = railways_gdf[[ "geometry", "length", "name", "type", "bridge", "tunnel" ]] railways_gdf.reset_index(inplace=True, drop=True) railways_gdf['edgeID'] = railways_gdf.index.values.astype(int) railways_gdf.index.name = None return railways_gdf
def _get_city_data_within_city_limits(self): if self.city_dict['cycleways'] is True: self.cycleways = self._get_cycleways() if self.city_dict['roads'] is True: self.roads = ox.graph_from_place(self.city_name, network_type='drive') if self.city_dict['water'] is True: self.water = ox.geometries_from_polygon(self.city_area.unary_union, tags=self.water_tags) if self.city_dict['green'] is True: self.green = ox.geometries_from_polygon(self.city_area.unary_union, tags=self.green_tags) if self.city_dict['buildings'] is True: self.buildings = ox.geometries_from_place(self.city_name, tags={ "building": True, 'landuse': 'construction' }) if self.city_dict['railways'] is True: self.railways = ox.geometries_from_place(self.city_name, tags=self.railway_tags)
def cityBoundary(locality): locality = locality + ", Australia" tags = {"boundary": "administrative"} boundaryOSM = ox.geometries_from_place(locality, tags) boundary_gdf = gpd.GeoDataFrame(boundaryOSM) #extract useful columns boundary_gdf = boundary_gdf.iloc[:, 0:10:9] #explode multypoligons in polygons boundary_gdf=explode(boundary_gdf) #searching for boundaries referring to PA query_search ='short_name == "Cairns"' city_boundaries = boundary_gdf.query(query_search) city_boundaries = city_boundaries.reset_index(drop=True) return city_boundaries
def set_up(self): def name(names): if not names: return '' elif isinstance(names, str): return names else: return ' '.join(names) tags = {'amenity': "vending_maching", "vending": "parking_tickets"} self.vending_machines_gdf = ox.geometries_from_place(self.place, tags) G = ox.graph_from_place(self.place, network_type='drive', retain_all = True, simplify=True) nearest_edges = ox.get_nearest_edges(G, self.vending_machines_gdf['geometry'].x, self.vending_machines_gdf['geometry'].y , method='balltree') self.vending_machines_gdf['street'] = [*map(lambda x: name(G.edges[(x[0], x[1], x[2])].get("name")).lower(), nearest_edges)]
def osm_gdf_from_place(query, tags, which_result=None, buffer_dist=None): """Create GeoDataFrame of OSM entities within boundaries of geocodable place(s). Args: query (str | dict | list): Query string(s) or structured dict(s) to geocode. tags (dict): Dict of tags used for finding objects in the selected area. Results returned are the union, not intersection of each individual tag. Each result matches at least one given tag. The dict keys should be OSM tags, (e.g., building, landuse, highway, etc) and the dict values should be either True to retrieve all items with the given tag, or a string to get a single tag-value combination, or a list of strings to get multiple values for the given tag. For example, tags = {‘building’: True} would return all building footprints in the area. tags = {‘amenity’:True, ‘landuse’:[‘retail’,’commercial’], ‘highway’:’bus_stop’} would return all amenities, landuse=retail, landuse=commercial, and highway=bus_stop. which_result (int, optional): Which geocoding result to use. if None, auto-select the first (Multi)Polygon or raise an error if OSM doesn't return one. to get the top match regardless of geometry type, set which_result=1. Defaults to None. buffer_dist (float, optional): Distance to buffer around the place geometry, in meters. Defaults to None. Returns: GeoDataFrame: A GeoDataFrame of OSM entities. """ check_package("osmnx", "https://osmnx.readthedocs.io/en/stable/#installation") import osmnx as ox ox.config(use_cache=True, log_console=True) gdf = ox.geometries_from_place(query, tags, which_result, buffer_dist) return gdf
def binsTable(locality): #call this function in registration if it is made correctly bin_table(municipality) locality = locality + ", Australia" tags = {'amenity': 'waste_basket'} binsOSM = ox.geometries_from_place(locality, tags) bins_gdf = gpd.GeoDataFrame(binsOSM) # create the columns of longitude and latitude from the geometry attribute bins_gdf['lon'] = bins_gdf['geometry'].x bins_gdf['lat'] = bins_gdf['geometry'].y # create the columns of datetime and set it bins_gdf['date'] = datetime.datetime(2018, 5, 1) bins_gdf['buffer'] = None #adding buffer attribute for i, row in bins_gdf.iterrows(): bins_gdf.loc[i, 'buffer'] = geodesic_point_buffer(bins_gdf.loc[i, 'lat'], bins_gdf.loc[i, 'lon'], 200.0) #setup db connection engine = customized_engine() #import in PostgreSQL bins_gdf.to_postgis('bins_temp', engine, if_exists = 'replace', index=False) #add data to DB bins table using the temporary table conn = get_dbConn() cur = conn.cursor() cur.execute( 'INSERT INTO bins (lon,lat,geom,bin_date,buffer) SELECT lon,lat,geometry,date,buffer FROM bins_temp' ) cur.execute( 'DROP TABLE IF EXISTS bins_temp' ) cur.close() conn.commit() conn.close() return
def add_edge_nearest_POIs(road_network, region, radius): ### POIs ### food_amenities = ['pub', 'bar', 'restaurant', 'cafe', 'food_court' ] # https://wiki.openstreetmap.org/wiki/Key:amenity education_amenities = [ 'college', 'kindergarten', 'library', 'school', 'university' ] service_amenities = [ 'bank', 'clinic', 'hospital', 'pharmacy', 'marketplace', 'post_office' ] shops = ['department_store', 'mall', 'supermarket'] # https://wiki.openstreetmap.org/wiki/Key:shop leisure = ['stadium', 'park'] # https://wiki.openstreetmap.org/wiki/Key:leisure railway = ['station'] # https://wiki.openstreetmap.org/wiki/Key:railway aeroway = ['aerodrome'] # https://wiki.openstreetmap.org/wiki/Key:aeroway highway = ['traffic_signals', 'stop', 'crossing'] # https://wiki.openstreetmap.org/wiki/Key:highway map__poi_type__poi = { 'amenity': food_amenities + education_amenities + service_amenities, 'leisure': leisure, 'shop': shops, 'railway': railway, 'aeroway': aeroway, 'highway': highway } map__poi__poi_category = { 'pub': 'food', 'bar': 'food', 'restaurant': 'food', 'cafe': 'food', 'food_court': 'food', 'college': 'education', 'kindergarten': 'education', 'library': 'education', 'school': 'education', 'university': 'education', 'bank': 'service', 'clinic': 'service', 'hospital': 'service', 'pharmacy': 'service', 'marketplace': 'service', 'post_office': 'service', 'stadium': 'leisure', 'park': 'leisure', 'department_store': 'retail', 'mall': 'retail', 'supermarket': 'retail', 'station': 'transport', 'aerodrome': 'transport', 'traffic_signals': 'signage', 'stop': 'signage', 'crossing': 'signage' } ### #start_time = time.time() # querying all the POIs of certain types in the region gdf_pois = ox.geometries_from_place(region, map__poi_type__poi) # gdf_pois = ox.geometries_from_bbox(north, south, east, west, map__poi_type__poi) set_edges_missing_geometry = set() for u, v, key, edge_data in road_network.edges(keys=True, data=True): # taking the centroid of the road try: road_centroid = edge_data['geometry'].centroid except KeyError: set_edges_missing_geometry.add((u, v, key)) # adding as attributes to the edge with None for poi_cat in set(map__poi__poi_category.values()): edge_data[poi_cat] = None continue # taking all the POIs in the gdf that are distant no more than radius from the centroid gdf_pois['dist'] = list( map( lambda k: ox.distance.great_circle_vec( gdf_pois.loc[k]['geometry'].centroid.y, gdf_pois.loc[k] ['geometry'].centroid.x, road_centroid.y, road_centroid.x), gdf_pois.index)) gdf_nearest_pois = gdf_pois[gdf_pois['dist'] <= radius] # creating dictionary with categories of POIs and counts map__poi_cat__num_of_poi = { 'food': 0, 'education': 0, 'service': 0, 'leisure': 0, 'retail': 0, 'transport': 0, 'signage': 0 } for poi_type, poi_list in map__poi_type__poi.items(): if poi_type in gdf_nearest_pois.columns: c_df = getattr(gdf_nearest_pois, poi_type).value_counts() for poi in [poi for poi in c_df.index if poi in poi_list]: poi_category = map__poi__poi_category[poi] # if poi_category not in map__poi_cat__num_of_poi: # map__poi_cat__num_of_poi[poi_category] = 0 map__poi_cat__num_of_poi[poi_category] += c_df[poi] # adding as attributes to the edge for poi_cat, num_of_poi in map__poi_cat__num_of_poi.items(): edge_data[poi_cat] = num_of_poi #runtime = time.time() - start_time #print('runtime: ', time.time() - start_time) #print('') print( '> There were %s out of %s total edges with missing geometry attribute.' % (len(set_edges_missing_geometry), road_network.size())) return road_network
from scripts.utils import pixel2poly # Plotting defaults plt.style.use('ggplot') px.defaults.height = 400; px.defaults.width = 620 plt.rcParams.update({'font.size': 16, 'axes.labelweight': 'bold', 'figure.figsize': (6, 6), 'axes.grid': False}) ## 1. Spatial visualization <hr> ### 1.1. Geopandas We saw last chapter how to easily plot geospatial data using the `geopandas` method `.plot()`. This workflow is useful for making quick plots, exploring your data, and easily layering geometries. Let's import some data of UBC buildings using `osmnx` (our Python API for accessing OpenStreetMap data) and make a quick plot: ubc = (ox.geometries_from_place("University of British Columbia, Canada", tags={'building':True}) .loc[:, ["geometry"]] # just keep the geometry column for now .query("geometry.type == 'Polygon'") # only what polygons (buidling footprints) .assign(Label="Building Footprints") # assign a label for later use .reset_index(drop=True) # reset to 0 integer indexing ) ubc.head() Recall that we can make a plot using the `.plot()` method on a `GeoDataFrame`: ax = ubc.plot(figsize=(8, 8), column="Label", legend=True, edgecolor="0.2", markersize=200, cmap="rainbow") plt.title("UBC"); Say I know the "point" location of my office but I want to locate the building footprint (a "polygon"). That's easily done with `geopandas`! First, I'll use `shapely` (the Python geometry library `geopandas` is built on) to make my office point, but you could also use the `geopandas` function `gpd.points_from_xy()` like we did last chapter:
def get_historical_buildings_fromOSM(place, download_method, epsg=None, distance=1000): """ The function downloads and cleans buildings footprint geometries and create a buildings GeoDataFrames for the area of interest. The function exploits OSMNx functions for downloading the data as well as for projecting it. The land use classification for each building is extracted. Only relevant columns are kept. Parameters ---------- place: string, tuple name of cities or areas in OSM: when using "from point" please provide a (lat, lon) tuple to create the bounding box around it; when using "distance_from_address" provide an existing OSM address; when using "OSMplace" provide an OSM place name download_method: string, {"from_point", "distance_from_address", "OSMplace"} it indicates the method that should be used for downloading the data. epsg: int epsg of the area considered; if None OSMNx is used for the projection distance: float Specify distance from address or point Returns ------- GeoDataFrames """ columns = ['geometry', 'historic'] if download_method == "distance_from_address": historic_buildings = ox.geometries_from_address( address=place, dist=distance, tags={"building": True}) elif download_method == "OSMplace": historic_buildings = ox.geometries_from_place(place, tags={"building": True}) elif download_method == "from_point": historic_buildings = ox.geometries_from_point(center_point=place, dist=distance, tags={"building": True}) else: raise downloadError( 'Provide a download method amongst {"from_point", "distance_from_address", "OSMplace"}' ) if 'heritage' in historic_buildings: columns.append('heritage') historic_buildings = historic_buildings[columns] if 'heritage' in historic_buildings: historic_buildings = historic_buildings[~( historic_buildings.historic.isnull() & historic_buildings.heritage.isnull())] else: historic_buildings = historic_buildings[~historic_buildings.historic. isnull()] if epsg is None: historic_buildings = ox.projection.project_gdf(historic_buildings) else: crs = 'EPSG:' + str(epsg) historic_buildings = historic_buildings.to_crs(crs) historic_buildings["historic"] = 1 historic_buildings["historic"][historic_buildings["historic"] != 0] = 1 historic_buildings = historic_buildings[['geometry', 'historic']] historic_buildings['area'] = historic_buildings.geometry.area return historic_buildings
def get_buildings_fromOSM(place, download_method, epsg=None, distance=1000): """ The function downloads and cleans buildings footprint geometries and create a buildings GeoDataFrames for the area of interest. The function exploits OSMNx functions for downloading the data as well as for projecting it. The land use classification for each building is extracted. Only relevant columns are kept. Parameters ---------- place: string, tuple name of cities or areas in OSM: when using "from point" please provide a (lat, lon) tuple to create the bounding box around it; when using "distance_from_address" provide an existing OSM address; when using "OSMplace" provide an OSM place name download_method: string, {"from_point", "distance_from_address", "OSMplace"} it indicates the method that should be used for downloading the data. epsg: int epsg of the area considered; if None OSMNx is used for the projection distance: float Specify distance from address or point Returns ------- buildings_gdf: Polygon GeoDataFrame the buildings GeoDataFrame """ columns_to_keep = [ 'amenity', 'building', 'geometry', 'historic', 'land_use_raw' ] if download_method == "distance_from_address": buildings_gdf = ox.geometries_from_address(address=place, dist=distance, tags={"building": True}) elif download_method == "OSMplace": buildings_gdf = ox.geometries_from_place(place, tags={"building": True}) elif download_method == "from_point": buildings_gdf = ox.geometries_from_point(center_point=place, dist=distance, tags={"building": True}) elif download_method == "OSMpolygon": buildings_gdf = ox.geometries_from_polygon(place, tags={"building": True}) else: raise downloadError( 'Provide a download method amongst {"from_point", "distance_from_address", "OSMplace", "OSMpolygon}' ) if epsg is None: buildings_gdf = ox.projection.project_gdf(buildings_gdf) else: crs = 'EPSG:' + str(epsg) buildings_gdf = buildings_gdf.to_crs(crs) buildings_gdf['land_use_raw'] = None for column in buildings_gdf.columns: if column.startswith('building:use:'): buildings_gdf.loc[pd.notnull(buildings_gdf[column]), 'land_use_raw'] = column[13:] if column not in columns_to_keep: buildings_gdf.drop(column, axis=1, inplace=True) buildings_gdf = buildings_gdf[~buildings_gdf['geometry'].is_empty] buildings_gdf['building'].replace('yes', np.nan, inplace=True) buildings_gdf['building'][ buildings_gdf['building'].isnull()] = buildings_gdf['amenity'] buildings_gdf['land_use_raw'][ buildings_gdf['land_use_raw'].isnull()] = buildings_gdf['building'] buildings_gdf['land_use_raw'][ buildings_gdf['land_use_raw'].isnull()] = 'residential' buildings_gdf = buildings_gdf[['geometry', 'historic', 'land_use_raw']] buildings_gdf['area'] = buildings_gdf.geometry.area buildings_gdf = buildings_gdf[buildings_gdf['area'] >= 50] # reset index buildings_gdf = buildings_gdf.reset_index(drop=True) buildings_gdf['buildingID'] = buildings_gdf.index.values.astype('int') return buildings_gdf
def setup_osm(place_name): graph = ox.graph_from_place(place_name) buildings = ox.geometries_from_place(place_name, tags={'building': True}) area = ox.geocode_to_gdf(place_name) nodes, edges = ox.graph_to_gdfs(graph) return graph, buildings, area, edges
simplify=True) graph = nx.compose(graph, graph2) # gráfok egyesítése - networkx.compose # A hálózat megjelenítése fig1, ax = ox.plot_graph(graph, bgcolor='white', node_color='red', node_edgecolor='black', edge_color='blue') # Befoglaló terület area = ox.geocode_to_gdf(place_name) #area.plot() # Point of Interest lekérdezés a területen belül poi = ox.geometries_from_place( place_name, tags={'building': ['university', 'college', 'transportation']}) # Hálózat GeoDataFrame (gdf) konverziója # gráf csúcsai (nodes) és élei (edges) nodes, edges = ox.graph_to_gdfs(graph) # GDF plot # Élek és POI-k megjelenítése fig2, ax = plt.subplots() edges.plot(ax=ax) poi.plot(ax=ax, facecolor='red') # Hálózat vetítése HD72 rendszerbe graph_proj = ox.project_graph(graph, to_crs=23700) # Élek és csúcsok leválogatása