def test_placeWkt():
nominatim = Nominatim()
x = nominatim.query('Heidelberg', wkt=True)
assert x.areaId() == 3600285864
assert len(x.toJSON()) > 0
assert len(x.wkt()) > 0
assert x.toJSON()
def test_queryAreaIDSelector():
nominatim = Nominatim()
x = nominatim.query('Dublin')
assertForQueryResult(minElements=5,
area=x.areaId(),
elementType=['node', 'way'],
selector=['"name"~"Tesco"', 'opening_hours'])
def extract_lat_long_from_nominatim(address):
"""
Query OSM Nominatim API for the latitude and longitude coordinates of address
:param address: String
:return: lat, lng
"""
lat, lng = None, None
nominatim = Nominatim()
area = nominatim.query(address)
if area is None:
return None, None
try:
"""
Try block in case any inputs are invalid
"""
osm_json = area.toJSON()
json_item = None
for item in osm_json:
if "Donegal" in item["display_name"]:
json_item = item
break
lat = json_item["lat"]
lng = json_item["lon"]
except:
pass
return lat, lng
def main(area, path, loglevel):
logging.basicConfig(format='%(asctime)s, %(message)s',
datefmt='%Y-%m-%d %H:%M:%S')
logging.getLogger().setLevel(loglevel)
nominatim = Nominatim()
areaId = nominatim.query(area).areaId()
logging.info("area: %s, id: %s", area, areaId)
selectors = {'power': ['plant', 'generator']}
df = pd.DataFrame()
for osmkey, osmvalues in selectors.items():
for osmval in osmvalues:
logging.info("fetching %s = %s", osmkey, osmval)
data = fetchFeatures(areaId, osmkey, osmval)
logging.info("Number of Elements: %s", data.countElements())
for i in range(0, data.countElements()):
e = data.elements()[i]
if (e.tag('type') == 'site'):
continue
# id, lat, lon, timestamp, tags
df = addFeaturetoGDF(df, e)
#if getfirstrev:
# if (data.elements()[i].version() > 1):
# ne = fetchFeatureVersion(e.id(), 1)
gdf = gpd.GeoDataFrame(df, geometry=gpd.points_from_xy(df.Lon, df.Lat))
gdf.crs = {'init': 'epsg:4326'}
saveData(df, gdf, path, area)
def test_queryBbox():
nominatim = Nominatim()
x = nominatim.query('Enschede')
assertForQueryResult(bbox=[52.1, 6.7, 52.3, 6.9],
elementType='node',
selector='"highway"="bus_stop"',
out='body')
def main():
"""Main function to create the output file"""
nominatim = Nominatim()
overpass = Overpass()
config = configparser.ConfigParser()
config.read('configuration')
area_id = nominatim.query('Italia').areaId()
html_string = ""
for operator in ast.literal_eval(config.get("MAPPING", "operators")):
#create folders for needed saving operations later
if not os.path.exists("./home_to_destination/{}".format(operator)):
os.mkdir("./home_to_destination/{}".format(operator))
if not os.path.exists("./routes/{}".format(operator)):
os.mkdir("./routes/{}".format(operator))
operator_parameter = '"operator" = "{}"'.format(operator)
query = overpassQueryBuilder(area=area_id,
elementType='rel',
selector=operator_parameter,
out='body')
result = overpass.query(query, timeout=600)
html_string += HTML.main_output_generation(
config['MAPPING']['address'], result, operator)
html_file = open("output.html", "w")
html_file.write(html_string)
html_file.close()
def get_geolocation_mapping(query=None):
"""
Returns a list of dicts with 'lat' and 'lon' as keys
Parameters
----------
query : str
The name of entity to be mapped (default is None)
Raises
------
ValueError
If no queries or an empty query has been passed in as a parameter
"""
if query is None or not query:
raise ValueError("Query must not be empty!")
unneeded_classes = [
'highway', 'place', 'tourism', 'boundary', 'railway', 'aeroway'
]
unneeded_types = ['parking', 'yes', 'brownfield']
nominatim = Nominatim()
result = nominatim.query(query).toJSON()
df = pd.DataFrame.from_records(result)
df = df[df['class'].isin(unneeded_classes) == False]
df = df[df['type'].isin(unneeded_types) == False]
df = df.filter(items=['lat', 'lon'])
return df.to_dict('records')
def test_queryAreaID():
nominatim = Nominatim()
x = nominatim.query('Enschede')
assertForQueryResult(area=x.areaId(),
elementType='node',
selector='"highway"="bus_stop"',
out='body')
def test_place():
nominatim = Nominatim()
x = nominatim.query('Heidelberg')
assert x.isReverse() == False
assert x.displayName().startswith('Heidelberg')
assert x.areaId() == 3600285864
assert len(x.toJSON()) > 0
assert x.toJSON()
def get_OSM():
nominatim = Nominatim()
overpass = Overpass()
areaId = nominatim.query('Le Plateau Mont Royal').areaId()
query = overpassQueryBuilder(area=areaId, elementType=['way'])
result = overpass.query(query)
db = db_from_OSM(result)
return db
def obj2_knowing_every_trees(list_tree, way_id, new_geom, result1, result2):
true_list = []
for tree in list_tree:
way = Nominatim().query(tree[0], tree[1], reverse=True, zoom=17)
id = way.toJSON()[0]["osm_id"]
if id == way_id:
true_list.append(tree)
obj2_knowing_trees_of_way(true_list, new_geom, result1, result2)
def test_queryAreaIDWithCondition2():
nominatim = Nominatim()
x = nominatim.query('Enschede')
assertForQueryResult(area=x.areaId(),
elementType='node',
selector='"highway"="bus_stop"',
conditions=['count_tags() > 2', 'count_tags() > 1'],
out='body')
def test_queryAreaIDTimeout():
nominatim = Nominatim()
x = nominatim.query('Enschede')
assertForQueryResult(area=x.areaId(),
elementType='node',
selector='"highway"="bus_stop"',
out='body',
overpassKwargs={'date': '2017-01-01T00:00:00Z'})
def random_destino(origen):
nominatim = Nominatim()
establecimiento = establecimientos[random.randint(0,len(establecimientos)-1)]
data = nominatim.query(str(establecimiento) + " " + "redondela" + " galicia").toJSON() # TODO cambiar "redondela" por municipio de origen
destino = {"latitud": data[0]["lat"], "longitud": data[0]["lon"]}
print("[Usuario random_destino] " + "establecimiento: " + str(establecimiento) + " , en Redondela , name: " + str(data[0]["display_name"]))
#print(origen)
return destino
def __init__(self):
self.nominatim = Nominatim()
self.nominatimQueryParams = {
'countrycodes': 'ID',
'polygon_geojson': '1',
'addressdetails': '1'
}
self.gmaps = googlemaps.Client(
key='AIzaSyC5Q7dmBU_Qaw6ahgr21mHOvX44o78Jvx0')
def test_queryBboxGeometry():
nominatim = Nominatim()
x = nominatim.query('Enschede')
y = assertForQueryResult(bbox=[52.1, 6.7, 52.3, 6.9],
elementType='node',
selector='"highway"="bus_stop"',
out='body')
assert (y.nodes()[0].lat() - 52.2) < .5
assert (y.nodes()[0].lon() - 6.8) < .5
def query_construction(search_area):
nominatim_query=Nominatim().query(search_area)
query_01=overpassQueryBuilder(area=nominatim_query.areaId(),elementType=['node','way','relation'], selector=["military"],includeGeometry=True)
query_02=overpassQueryBuilder(area=nominatim_query.areaId(),elementType=['node','way','relation'], selector='"landuse"="military"',includeGeometry=True)
result_01=Overpass().query(query_01)
result_02=Overpass().query(query_02)
print("Pronađeno ukupno "+str(result_01.countElements())+" 'military' objekta")
print("Pronađeno ukupno "+str(result_02.countElements())+" 'landuse=military' objekta")
results=[result_01,result_02]
return results
def test_queryAreaIDGeometry():
nominatim = Nominatim()
x = nominatim.query('Enschede')
y = assertForQueryResult(area=x.areaId(),
elementType='node',
selector='"highway"="bus_stop"',
out='body',
includeGeometry=True)
assert (y.nodes()[0].lat() - 52.2) < .5
assert (y.nodes()[0].lon() - 6.8) < .5
def query(Key, Value, Location):
nominatim = Nominatim()
areaId = nominatim.query(f'{Location}').areaId()
overpass = Overpass()
query = overpassQueryBuilder(area=areaId,
elementType=['node', 'way', 'relation'],
selector=f'"{Key}"="{Value}"',
includeGeometry=True)
print("querying OSM")
result = overpass.query(query, timeout=250)
result = result.toJSON()
return result
def obj2_knowing_every_trees(list_tree, way_id, new_geom, result1, result2):
"""
Used if we have the list of EVERY TREES of a city and not only of our road.
It's not the case here so this is basically useless.
"""
true_list = []
for tree in list_tree:
way = Nominatim().query(tree[0], tree[1], reverse=True, zoom=17)
id = way.toJSON()[0]["osm_id"]
if id == way_id:
true_list.append(tree)
obj2_knowing_trees_of_way(true_list, new_geom, result1, result2)
def get_OSM():
nominatim = Nominatim()
overpass = Overpass()
areaId = nominatim.query('Montreal, Canada').areaId()
query = overpassQueryBuilder(
area=areaId, elementType='node',
selector=['shop']) + overpassQueryBuilder(
area=areaId, elementType='node', selector='amenity')
result = overpass.query(query)
db = db_from_OSM(result)
db_tags = list_tags(db)
return db, db_tags
def test_coordinatesCountry():
nominatim = Nominatim()
x = nominatim.query(49.4093582, 8.694724, reverse=True, zoom=3)
assert x.isReverse() == True
assert x.displayName().startswith('Deutschland')
assert x.areaId() == 3600051477
assert x.address() == {
'country': 'Deutschland',
'country_code': 'de',
}
assert len(x.toJSON()) > 0
assert x.toJSON()
def test_coordinates():
nominatim = Nominatim()
x = nominatim.query(49.4093582, 8.694724, reverse=True, zoom=10)
assert x.isReverse() == True
assert x.displayName() == 'Heidelberg, Baden-Württemberg, Deutschland'
print(x.toJSON())
assert x.areaId() == 3600285864
assert x.address() == {
'city': 'Heidelberg',
'state': 'Baden-Württemberg',
'country': 'Deutschland',
'country_code': 'de',
}
assert len(x.toJSON()) > 0
assert x.toJSON()
def test_data():
dimensions = OrderedDict([
('year', dictRangeYears(2015, 2016.5, 1)),
(
'city',
OrderedDict({
# 'manhattan': 'Manhattan, New York',
# 'vienna': 'Vienna, Austria',
'enschede': 'Enschede, Netherlands',
'vienna': 'Vienna, Austria',
})),
('typeOfShop',
OrderedDict({
'supermarket': 'supermarket',
'coffee': 'coffee',
})),
])
nominatim = Nominatim()
overpass = Overpass()
def fetch(year, city, typeOfShop):
areaId = nominatim.query(city).areaId()
query = overpassQueryBuilder(area=areaId,
elementType='way',
selector='"shop"="' + typeOfShop + '"',
out='count')
x = overpass.query(query, date=year, timeout=30).countElements()
assert x >= 0
return x
data = Data(fetch, dimensions)
def geo_to_way_info(lat, long):
"""
Return some information corresponding to the way in wich the point is: bbox, id, name
"""
way = Nominatim().query(lat, long, reverse=True, zoom=17)
JSON = way.toJSON()[0]
name = JSON['address']['road']
bbox = JSON["boundingbox"]
id = JSON["osm_id"]
realbbox = [
float(bbox[0]),
float(bbox[2]),
float(bbox[1]) + 0.005,
float(bbox[3]) + 0.005
]
return realbbox, id, name
def download_osm(area_name):
""" Given an area name, download corresponding OSM elements """
# Get area id
nomanatim = Nominatim()
area_id = nomanatim.query(area_name).areaId()
# Form and ask query
overpass = Overpass()
query = overpassQueryBuilder(area=area_id, elementType=['way', 'node'], out='body')
osm_data = overpass.query(query, timeout=600)
# Display results
utils.display_results(osm_data)
# Keep elements (ways and nodes) in JSON format
elements = osm_data.toJSON()['elements']
return elements
def __init__(self, city: str) -> None:
"""Create city map
Args:
city (str): City name
radius (float, optional): City radius, in meters. Defaults to 3000.
"""
self._city = city
self._elements_dict = {}
self._normalized_dict = {}
self._features_list = []
# request timing
self._timeout = 300
self._try_again = 30
# initialize instances
self._nominatim = Nominatim()
self._overpass = Overpass()
def __init__(self,
areaName: str,
elementsToUse: OsmObjectType = OsmObjectType.NODE):
assert (self.osmSelector)
areaId = Nominatim().query(areaName).areaId()
query = overpassQueryBuilder(area=areaId,
elementType=elementsToUse.value,
selector=self.osmSelector,
out='geom')
osmObjects = Overpass().query(query).toJSON()["elements"]
self.dataSource = osmObjectsToGeoJSON(osmObjects,
polygonize=True)["features"]
shapeGeoms = []
for loc in self.dataSource:
shapeGeom = shape(loc["geometry"])
shapeGeom.properties = loc["properties"]
shapeGeoms.append(shapeGeom)
self.shapeIndex = STRtree(shapeGeoms)
import json
from OSMPythonTools.nominatim import Nominatim
import folium
from folium.plugins.measure_control import MeasureControl
from matplotlib import cm
import sys, os
sys.path.insert(1, os.path.abspath('..'))
from helper.geoJsonHelper import groupBy
from helper.geoJsonToFolium import generateFeatureCollectionForGroups, styleFunction, cmMapColorToHex
from helper.overPassHelper import OverPassHelper
# postfix for f.i. file_names
areaName = "pieschen"
# area to query
pieschen = Nominatim().query('Pieschen, Dresden, Germany')
osmDataFiles = OverPassHelper().fetch(pieschen.areaId(),
areaName,
overrideFiles=False)
pieschenCoord = pieschen.toJSON()[0]
map = folium.Map(location=[pieschenCoord["lat"], pieschenCoord["lon"]],
tiles='Stamen Toner',
zoom_start=15)
# matplotlib colormap names
colormaps = ["hsv", "BrBG", "coolwarm"]
objectTypeTagMapping = {
"streets": "highway",
"buildings": "building",
from OSMPythonTools.nominatim import Nominatim
from OSMPythonTools.overpass import overpassQueryBuilder, Overpass
from shapely.geometry import Point, Polygon, MultiPolygon
import pandas as pd, geopandas as gpd
if __name__ == "__main__":
nominatim = Nominatim()
areaId = nominatim.query('Bogota, Colombia').areaId()
overpass = Overpass()
query = overpassQueryBuilder(area=areaId,
elementType=['way'],
selector='"amenity"="hospital"',
includeGeometry=True)
result = overpass.query(query)
result = [{
'tags': x.tags(),
'geometry': x.geometry()
} for x in result.elements()]
#to pandas for cleaning tags
df_hosps = pd.io.json.json_normalize(result)
#to geopandas
gdf_hosps = gpd.GeoDataFrame(df_hosps)
#
#gdf_hosps['geometry']=gdf_hosps['geometry.coordinates'].apply(lambda x: Polygon(x[0]))
gdf_hosps['geometry.point'] = gdf_hosps['geometry.coordinates'].apply(
lambda x: x[0][0]).apply(Point)
gdf_hosps = gdf_hosps.set_geometry(col='geometry.point')
#gdf_hosps.plot().get_figure().savefig('hospitals_points.png')
gdf_hosps.drop(columns=['geometry.coordinates']).to_file(
driver='GeoJSON', filename="bogota_hospitales.geojson")
