/
osm.py
371 lines (284 loc) · 25.7 KB
/
osm.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
"""The module contains functions for downloading OpenStreetMap data. It wraps the geometries module of the osmnx package
(see https://osmnx.readthedocs.io/en/stable/osmnx.html#module-osmnx.geometries). Credits to Geoff Boeing, the developer of the osmnx package.
Most functions for downloading OpenStreetMap data require tags of map features. The list of commonly used tags can be found at
https://wiki.openstreetmap.org/wiki/Map_features
"""
# *******************************************************************************#
# This module contains extra features of the geemap package. #
# The geemap community will maintain the extra features. #
# *******************************************************************************#
from .common import check_package
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 osm_shp_from_address(address, tags, filepath, dist=1000):
"""Download OSM entities within some distance N, S, E, W of address as a shapefile.
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.
filepath (str): File path to the output shapefile.
dist (int, optional): Distance in meters. Defaults to 1000.
"""
gdf = osm_gdf_from_address(address, tags, dist)
gdf.to_file(filepath)
def osm_geojson_from_address(address, tags, filepath=None, dist=1000):
"""Download OSM entities within some distance N, S, E, W of address as a GeoJSON.
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.
filepath (str, optional): File path to the output GeoJSON. Defaults to None.
dist (int, optional): Distance in meters. Defaults to 1000.
Returns:
dict: A GeoJSON dictionary of OSM entities.
"""
gdf = osm_gdf_from_address(address, tags, dist)
if filepath is not None:
gdf.to_file(filepath, driver="GeoJSON")
else:
return gdf.__geo_interface__
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 osm_shp_from_place(query, tags, filepath, which_result=None, buffer_dist=None):
"""Download OSM entities within boundaries of geocodable place(s) as a shapefile.
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.
filepath (str): File path to the output shapefile.
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.
"""
gdf = osm_gdf_from_place(query, tags, which_result, buffer_dist)
gdf.to_file(filepath)
def osm_geojson_from_place(
query, tags, filepath=None, which_result=None, buffer_dist=None
):
"""Download OSM entities within boundaries of geocodable place(s) as a GeoJSON.
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.
filepath (str): File path to the output shapefile.
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:
dict: A GeoJSON dictionary of OSM entities.
"""
gdf = osm_gdf_from_place(query, tags, which_result, buffer_dist)
if filepath is not None:
gdf.to_file(filepath, driver="GeoJSON")
else:
return gdf.__geo_interface__
def osm_gdf_from_point(center_point, tags, dist=1000):
"""Create GeoDataFrame of OSM entities within some distance N, S, E, W of a point.
Args:
center_point (tuple): The (lat, lng) center 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_point(center_point, tags, dist)
return gdf
def osm_shp_from_point(center_point, tags, filepath, dist=1000):
"""Download OSM entities within some distance N, S, E, W of point as a shapefile.
Args:
center_point (tuple): The (lat, lng) center 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.
filepath (str): File path to the output shapefile.
dist (int, optional): Distance in meters. Defaults to 1000.
"""
gdf = osm_gdf_from_point(center_point, tags, dist)
gdf.to_file(filepath)
def osm_geojson_from_point(center_point, tags, filepath=None, dist=1000):
"""Download OSM entities within some distance N, S, E, W of point as a GeoJSON.
Args:
center_point (tuple): The (lat, lng) center 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.
filepath (str): File path to the output shapefile.
dist (int, optional): Distance in meters. Defaults to 1000.
Returns:
dict: A GeoJSON dictionary of OSM entities.
"""
gdf = osm_gdf_from_point(center_point, tags, dist)
if filepath is not None:
gdf.to_file(filepath, driver="GeoJSON")
else:
return gdf.__geo_interface__
def osm_gdf_from_polygon(polygon, tags):
"""Create GeoDataFrame of OSM entities within boundaries of a (multi)polygon.
Args:
polygon (shapely.geometry.Polygon | shapely.geometry.MultiPolygon): Geographic boundaries to fetch geometries within
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_polygon(polygon, tags)
return gdf
def osm_shp_from_polygon(polygon, tags, filepath):
"""Download OSM entities within boundaries of a (multi)polygon as a shapefile.
Args:
polygon (shapely.geometry.Polygon | shapely.geometry.MultiPolygon): Geographic boundaries to fetch geometries within
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.
filepath (str): File path to the output shapefile.
"""
gdf = osm_gdf_from_polygon(polygon, tags)
gdf.to_file(filepath)
def osm_geojson_from_polygon(polygon, tags, filepath=None):
"""Download OSM entities within boundaries of a (multi)polygon as a GeoJSON.
Args:
polygon (shapely.geometry.Polygon | shapely.geometry.MultiPolygon): Geographic boundaries to fetch geometries within
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.
filepath (str, optional): File path to the output GeoJSON.
Returns:
dict: A GeoJSON dictionary of OSM entities.
"""
gdf = osm_gdf_from_polygon(polygon, tags)
if filepath is not None:
gdf.to_file(filepath, driver="GeoJSON")
else:
return gdf.__geo_interface__
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 osm_shp_from_bbox(north, south, east, west, tags, filepath):
"""Download OSM entities within a N, S, E, W bounding box as a shapefile.
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.
filepath (str): File path to the output shapefile.
"""
gdf = osm_gdf_from_bbox(north, south, east, west, tags)
gdf.to_file(filepath)
def osm_geojson_from_bbox(north, south, east, west, tags, filepath=None):
"""Download OSM entities within a N, S, E, W bounding box as a GeoJSON.
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.
filepath (str, optional): File path to the output GeoJSON.
Returns:
dict: A GeoJSON dictionary of OSM entities.
"""
gdf = osm_gdf_from_bbox(north, south, east, west, tags)
if filepath is not None:
gdf.to_file(filepath, driver="GeoJSON")
else:
return gdf.__geo_interface__
def osm_gdf_from_xml(filepath, polygon=None, tags=None):
"""Create a GeoDataFrame of OSM entities in an OSM-formatted XML file.
Args:
filepath (str): File path to file containing OSM XML data
polygon (shapely.geometry.Polygon, optional): Optional geographic boundary to filter objects. Defaults to None.
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_xml(filepath, polygon, tags)
return gdf
def osm_gdf_from_geocode(
query,
which_result=None,
by_osmid=False,
buffer_dist=None,
):
"""Retrieves place(s) by name or ID from the Nominatim API as a GeoDataFrame.
Args:
query (str | dict | list): Query string(s) or structured dict(s) to geocode.
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.
by_osmid (bool, optional): If True, handle query as an OSM ID for lookup rather than text search. Defaults to False.
buffer_dist (float, optional): Distance to buffer around the place geometry, in meters. Defaults to None.
Returns:
GeoDataFrame: A GeoPandas GeoDataFrame.
"""
check_package("osmnx", "https://osmnx.readthedocs.io/en/stable/")
import osmnx as ox
gdf = ox.geocode_to_gdf(query, which_result, by_osmid, buffer_dist)
return gdf
def osm_shp_from_geocode(
query,
filepath,
which_result=None,
by_osmid=False,
buffer_dist=None,
):
"""Download place(s) by name or ID from the Nominatim API as a shapefile.
Args:
query (str | dict | list): Query string(s) or structured dict(s) to geocode.
filepath (str): File path to the output shapefile.
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.
by_osmid (bool, optional): If True, handle query as an OSM ID for lookup rather than text search. Defaults to False.
buffer_dist (float, optional): Distance to buffer around the place geometry, in meters. Defaults to None.
"""
gdf = osm_gdf_from_geocode(query, which_result, by_osmid, buffer_dist)
gdf.to_file(filepath)
def osm_geojson_from_geocode(
query,
filepath=None,
which_result=None,
by_osmid=False,
buffer_dist=None,
):
"""Download place(s) by name or ID from the Nominatim API as a GeoJSON.
Args:
query (str | dict | list): Query string(s) or structured dict(s) to geocode.
filepath (str): File path to the output GeoJSON.
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.
by_osmid (bool, optional): If True, handle query as an OSM ID for lookup rather than text search. Defaults to False.
buffer_dist (float, optional): Distance to buffer around the place geometry, in meters. Defaults to None.
Returns:
dict: A GeoJSON dictionary of OSM entities.
"""
gdf = osm_gdf_from_geocode(query, which_result, by_osmid, buffer_dist)
if filepath is not None:
gdf.to_file(filepath, driver="GeoJSON")
else:
return gdf.__geo_interface__
def osm_tags_list():
"""Open a browser to see all tags of OSM features."""
import webbrowser
webbrowser.open_new_tab("https://wiki.openstreetmap.org/wiki/Map_features")