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) # 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 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 download_osm(args): bbox_coord = tuple(args.bbox) filename = args.outfile # test coordinates: north, south, east, west = 30.33622 ,30.34384,78.03883,78.05268 north, south, east, west = bbox_coord[0], bbox_coord[1], bbox_coord[ 2], bbox_coord[3] print("Downloading: " + args.tags) if args.tags == "roads": tags = {'highway': True} elif args.tags == "buildings": tags = {'building': True} gdf = ox.geometries_from_bbox(north, south, east, west, tags) gdf = gdf.apply(lambda c: c.astype(str) if c.name != 'geometry' else c, axis=0) gdf.to_file(filename, driver='GeoJSON') print("Data downloaded and saved in " + filename)
def osm_gdf_from_bbox(north, south, east, west, tags): """Create a GeoDataFrame of OSM entities within a N, S, E, W bounding box. Args: north (float): Northern latitude of bounding box. south (float): Southern latitude of bounding box. east (float): Eastern longitude of bounding box. west (float): Western longitude of bounding box. 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. Returns: GeoDataFrame: A GeoDataFrame of OSM entities. """ check_package("osmnx", "https://osmnx.readthedocs.io/en/stable/#installation") import osmnx as ox gdf = ox.geometries_from_bbox(north, south, east, west, tags) return gdf
def _get_city_data_within_rectangle(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_bbox(self.north, self.south, self.east, self.west, network_type='drive') if self.city_dict['water'] is True: self.water = ox.geometries.geometries_from_bbox( self.north, self.south, self.east, self.west, tags=self.water_tags) if self.city_dict['green'] is True: self.green = ox.geometries.geometries_from_bbox( self.north, self.south, self.east, self.west, tags=self.green_tags) if self.city_dict['buildings'] is True: self.buildings = ox.geometries.geometries_from_bbox( self.north, self.south, self.east, self.west, tags={ "building": True, 'landuse': 'construction' }) if self.city_dict['railways'] is True: self.railways = ox.geometries_from_bbox(self.north, self.south, self.east, self.west, tags=self.railway_tags)
for node_id in rou: x = projected_graph.nodes[node_id]['x'] y = projected_graph.nodes[node_id]['y'] points.append([x, y]) route_coorindates.append(points) n_routes = len(route_coorindates) print("Extracted routes: ", n_routes) max_route_len = max([len(x) for x in route_coorindates]) # Prepare the layout gdf = ox.geometries_from_bbox(1.3763, 1.3007, 103.6492, 103.7840, tags={"building": True}) gdf_proj = ox.project_gdf(gdf, to_crs="EPSG:3395") fig, ax = ox.plot_graph(projected_graph, node_size=0, edge_linewidth=1.5, edge_color='#2C2E2C', show=False, close=False, bgcolor='#12830E') #figsize=(12,8) for larger plots gdf_proj.plot(ax=ax, linewidth=1, alpha=0.8, color='#F5F5DC') scatter_list = []
def download_osm_buildings( output_dir, polygon=None, bbox=None, data_crs=None, keep_fields=["osmid", "building", "name", "geometry"], suffix="", overwrite=False ): """ Uses an Overpass query to fetch the OSM building polygons within a specified bounding box or the bounding box of a provided shapefile. Args: output_dir (str): Path to output directory. polygon (str): path to a shapefile or geojson object readable by geopandas bbox (dict): default=None; A dictionary with keys 'south', 'west', 'north', and 'east' of EPSG:4326-style coordinates, defining a bounding box for the area from which to fetch OSM features. Only required when `study_area_polygon_path` is not provided. See module notes for performance and suggestions on usage. data_crs (int): integer value representing an EPSG code keep_fields (list): list of fields to keep in output dataset suffix (str): string value to be added to the end of the output folder overwrite (bool): if set to True, delete the existing copy of buildings Returns: buildings_gdf (gpd.GeoDataFrame): A gdf of OSM building features. By default, the CRS of the gdf will be EPSG:4326 unless a tranformation is specified using `transfor_epsg` or a shape file with a differnt CRS is provided as `study_area_polygon_path`. Notes: OSM building polygons features will automatically be saved in the `output_dir`s `OSM_Buildings_{YYYYMMDDHHMMSS}.shp` where `YYYYMMDDHHMMSS` is the date and time at which the Overpass query was pushed. This is done for record keeping purposes. """ # Validation of inputs # TODO: separate polygon and bbox validation bounding_box = validate_inputs( study_area_poly=polygon, bbox=bbox, data_crs=data_crs ) # - Output location output_dir = validate_directory(make_path(output_dir, f"buildings_{suffix}")) # Data read in and setup ------------------------------------------------- print("...Pulling building data from Overpass API...") buildings_gdf = ox.geometries_from_bbox( north=bounding_box["north"], south=bounding_box["south"], east=bounding_box["east"], west=bounding_box["west"], tags={"building": True}, ) # drop non-polygon features and subset fields print("...Dropping non-polygon features and unneeded fields") buildings_gdf = buildings_gdf[ buildings_gdf.geom_type.isin(["MultiPolygon", "Polygon"]) ] drop_cols = [col for col in buildings_gdf.columns if col not in keep_fields] buildings_gdf.drop(labels=drop_cols, axis=1, inplace=True) buildings_gdf.reset_index() # Saving ----------------------------------------------------------------- print("...Saving...") dt = datetime.now().strftime("%Y%m%d") file_name = "OSM_Buildings_{}.shp".format(dt) save_path = make_path(output_dir, file_name) check_overwrite_path(output=save_path, overwrite=overwrite) buildings_gdf.to_file(save_path) print("-- saved to: " + save_path) return buildings_gdf
def create_map_from_osm(outfile: str, c_osm: int, north: float, south: float, west: float, east: float): dpi = 200 default_width = 6 network_type = 'drive' fp = f'./images/{outfile}-osm-{c_osm}.png' tag_building = TagTypes.building tag_nature = TagTypes.nature tag_water = TagTypes.water ax = None G = ox.graph_from_bbox(north, south, east, west, network_type=network_type, truncate_by_edge=True, retain_all=True, clean_periphery=False) gdf_building = ox.geometries_from_bbox(north, south, east, west, tags=tag_building) gdf_nature = ox.geometries_from_bbox(north, south, east, west, tags=tag_nature) gdf_water = ox.geometries_from_bbox(north, south, east, west, tags=tag_water) fig, ax = ox.plot_figure_ground(G, default_width=default_width, dpi=dpi, filepath=fp, show=False) if not gdf_nature.empty: fig, ax = ox.plot_footprints(gdf_nature, ax=ax, color='green', filepath=fp, dpi=dpi, save=True) if not gdf_water.empty: fig, ax = ox.plot_footprints(gdf_water, ax=ax, color='blue', filepath=fp, dpi=dpi, save=True) if not gdf_building.empty: fig, ax = ox.plot_footprints(gdf_building, ax=ax, filepath=fp, dpi=dpi, save=True)