def _get_city_data_from_address(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_address(self.address,
network_type='drive',
dist=self.distance)
if self.city_dict['water'] is True:
self.water = ox.geometries_from_address(self.address,
tags=self.water_tags,
dist=self.distance)
if self.city_dict['green'] is True:
self.green = ox.geometries_from_address(self.address,
tags=self.green_tags,
dist=self.distance)
if self.city_dict['buildings'] is True:
self.buildings = ox.geometries_from_address(self.address,
tags={
"building":
True,
'landuse':
'construction'
},
dist=self.distance)
if self.city_dict['railways'] is True:
self.railways = ox.geometries_from_address(self.address,
tags=self.railway_tags,
dist=self.distance)
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 _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_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 osm_gdf_from_address(address, tags, dist=1000):
"""Create GeoDataFrame of OSM entities within some distance N, S, E, W of address.
Args:
address (str): The address to geocode and use as the central point around which to get the geometries.
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.
dist (int, optional): Distance in meters. Defaults to 1000.
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_address(address, tags, dist)
return gdf
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
