def main(input_filepath: str,
output_filepath: str,
overpass_server: str = DEFAULT_OVERPASS_SERVER) -> None:
print('Opening query:', input_filepath)
with open(input_filepath, 'r', encoding='utf-8') as f:
query = f.read()
response = None
try:
response = requests.post(overpass_server, data={'data': query})
except:
logging.error('Error for query:', input_filepath)
if response:
if response.ok:
data = response.json()
geojson = osm2geojson.json2geojson(data,
filter_used_refs=False,
log_level='INFO')
print('Saving file:', output_filepath)
with open(output_filepath, 'w', encoding='utf-8') as o:
json.dump(geojson, o)
else:
print('Request was not successful.')
print(response.status_code)
print(response.text)
def _get_places_overpy(self, query):
try:
result = requests.get("http://overpass-api.de/api/interpreter",
data={
"data": query
}).json()
return osm2geojson.json2geojson(result)
except:
return {"features": [], "type": "FeatureCollection"}
def convertGeoJson(in_path, out_path):
with codecs.open(in_path, 'r', encoding='utf-8') as data:
js = data.read()
geojson = osm2geojson.json2geojson(js)
s = json.dumps(geojson)
s = s.encode()
with open(out_path, 'wb') as f:
f.write(s)
f.close()
return {"status": True, "message": "GeoJson Convert Successful"}
def get_border(id):
file = os.path.join(GEOMETRY_DIR, f"border_{id}.geojson")
if os.path.exists(file):
with open(file, encoding='utf-8') as d:
return json.load(d)['features'][0]
data = cached_overpass_call(f"""
[out:json];
rel({id});
out geom;
""")
geojson_data = json2geojson(data)
border = None
for f in geojson_data['features']:
if f['properties']['tags']['type'] == 'boundary':
border = f
if border is not None:
geojson_data['features'] = [border]
save_data(geojson_data, file)
return border
def getGeojsonFromOverpass(self):
tagValue = self.filters["objectTags"]
tagValues = [
[i.strip() for i in t.split("=")] # remove leading and ending spaces
for t in tagValue.split(",")
if len(t.split("=")) == 2
]
areaQuery = ""
overPassTagQuery = ""
areas = self.filters["filterArea"]
splittedAreas = areas.split(",")
for area in splittedAreas:
area = area.strip()
searchArea = area.replace("ü", "u").replace("ä", "a").replace("ö", "o").replace(" ", "_")
areaQuery += 'area[name="{areaName}"]->.search{searchArea};\n'.format(
areaName=area, searchArea=searchArea
)
for tag in tagValues:
overPassTagQuery += (
'nwr["{key}"="{value}"](area.search{searchArea});\n'.format(
key=tag[0], value=tag[1], areaName=area, searchArea=searchArea
)
)
overpass_url = settings.OVERPASS_URL
overpass_query = (
"[out:json];\n{0}(\n{1}\n);\nout body;\n>;\nout skel qt;".format(
areaQuery, overPassTagQuery
)
)
response = requests.get(overpass_url, params={"data": overpass_query})
if response.status_code != 200 or not response.json()["elements"]:
return None
newObjectTagArea = response.json()
return json2geojson(newObjectTagArea)
def get_outdoor_seating_nodes(id):
file = os.path.join(GEOMETRY_DIR, f"seatings_{id}.geojson")
if os.path.exists(file):
with open(file, encoding='utf-8') as f:
return json.load(f)
border = get_border(id)
border_shape = geometry.shape(border['geometry'])
minlon, minlat, maxlon, maxlat = border_shape.bounds
bbox = f"({minlat}, {minlon}, {maxlat}, {maxlon})"
amenities = ['restaurant', 'pub', 'bar', 'cafe', 'fast_food', 'bbq', 'biergarten', 'food_court']
data = cached_overpass_call(f"""
[out:json];
node[outdoor_seating=yes][amenity~"^{'$|^'.join(amenities)}$"]{bbox};
out geom;
""")
geojson_data = json2geojson(data, filter_used_refs=False)
geojson_data = get_features_inside_shape(geojson_data, border_shape)
for feature in geojson_data['features']:
feature['properties']['name'] = feature['properties']['tags'].get('name', 'noname')
save_data(geojson_data, file)
return geojson_data
def import_outline(body: Body, gemeindeschluessel: Optional[str] = None):
gemeindeschluessel = gemeindeschluessel or body.ags
assert gemeindeschluessel is not None
logger.info("Importing outline from {}".format(gemeindeschluessel))
if not body.outline:
outline = Location()
outline.name = "Outline of " + body.name
outline.short_name = body.short_name
outline.is_official = False
else:
outline = body.outline
query = query_template_outline.format(gemeindeschluessel)
response = requests.post(overpass_api, data={"data": query})
response.raise_for_status()
geojson = osm2geojson.json2geojson(response.text)
outline.geometry = geojson
outline.save()
body.outline = outline
body.save()
def test_issue_9(self):
(data, saved_geojson) = get_json_and_geojson_data('issue-9')
all_geojson = json.loads(read_data_file('issue-9-all.geojson'))
self.assertDictEqual(saved_geojson, json2geojson(data))
self.assertDictEqual(all_geojson,
json2geojson(data, filter_used_refs=False))
def test_issue_7(self):
(data, saved_geojson) = get_json_and_geojson_data('issue-7')
self.assertDictEqual(saved_geojson, json2geojson(data))
response = requests.get(overpass_url, params={'data': overpass_query})
osmjson = response.json()
with open(cache_file, 'w', encoding='utf8') as json_file:
json.dump(osmjson, json_file, ensure_ascii=False)
print("fetching from overpass done")
else:
print("reading from cache")
with open(cache_file, 'r') as myfile:
osmjson = json.load(myfile)
print("reading from cache done")
#convert overpass json to geojson
import osm2geojson
print("converting to geojson")
osmdata = osm2geojson.json2geojson(osmjson)
print("conversion done")
#print(osmdata["features"][0])
matches = set()
print("Searching for matches within 100m")
# loop through the list
for osmfeature in osmdata["features"]:
osmfeature_count += 1
# debug break out
# if (osmfeature_count == 5):
# break
osmid = osmfeature["properties"]["id"]
lat = osmfeature["geometry"]["coordinates"][1]
lon = osmfeature["geometry"]["coordinates"][0]
osmcoord = (lat, lon)
import shapely.wkb
drs, shapefile_name, boundsfile_name = sys.argv[1:]
overpass_url = "http://overpass-api.de/api/interpreter"
overpass_query = """
[out:json];
area["ISO3166-1"="DE"];
rel["de:regionalschluessel"="%s"](area);
out geom;
""" % drs
# 059130000000 Regionalschl. Dortmund
response = requests.get(overpass_url, params={'data': overpass_query})
try:
data = response.json()
except:
print(response.content)
raise
geos = osm2geojson.json2geojson(data)
print(geos)
fullgeom = shapely.ops.unary_union(
[shapely.geometry.shape(geo['geometry']) for geo in geos['features']])
print(fullgeom)
with open(shapefile_name, 'wb') as shapefile:
shapefile.write(shapely.wkb.dumps(fullgeom))
with open(boundsfile_name, 'w') as boundsfile:
boundsfile.write(' '.join(str(x) for x in fullgeom.bounds))
def _as_geojson(self, response):
return osm2geojson.json2geojson(response)
def test_center_feature(self):
(data, saved_geojson) = get_json_and_geojson_data('center-feature')
self.assertDictEqual(saved_geojson, json2geojson(data))
def overpass_to_geojson(
output_file: str,
area_id: int,
out: str = "center", # center, body, geom
response_type: str = "json",
overpass_endpoint: list[str] = OVERPASS_ENDPOINTS[0],
force_download=False,
**kwargs,
):
today = date.today()
output_file_path = Path(output_file)
tags_to_download = "".join(f'["{key}"="{value}"]'
for key, value in kwargs.items())
if response_type not in ["json", "xml"]:
return None
try:
file_last_mod_date = datetime.fromtimestamp(
output_file_path.stat().st_mtime).date()
except FileNotFoundError:
file_last_mod_date = date(1900, 1, 1)
if (output_file_path.is_file() and file_last_mod_date == today
and force_download is False):
logging.info(
f"Finish: File is up to date. (generated: {file_last_mod_date})")
return None
# 2. Step 2 - connecting and getting data from Overpass
else:
logging.info(
f"Info: Export .geojson file last modification date: {file_last_mod_date}"
)
# Overpass Query
compact_query = f"[out:{response_type}][timeout:20005];area({area_id})->.searchArea;(node{tags_to_download}(area.searchArea);way{tags_to_download}(area.searchArea);relation{tags_to_download}(area.searchArea););out {out};"
query = overpass_endpoint + "?data=" + compact_query
logging.info(
f"Start: Connecting to Overpass server: {overpass_endpoint}")
try:
response = requests.get(query)
response.raise_for_status()
pass
except requests.exceptions.HTTPError as err:
raise SystemExit(err)
if response.status_code != 200:
logging.error("End: Server response other than 200")
return None
try:
logging.info(
"Start: Getting data and extracting to .geojson object..")
if response_type == "json":
geojson_response = json2geojson(response.text,
log_level="ERROR")
else:
geojson_response = xml2geojson(response.text,
log_level="ERROR")
except:
logging.error(
"Finish: Error when converting response .json to .geojson")
return None
with open(output_file_path, mode="w", encoding="utf-8") as f:
geojson.dump(geojson_response, f)
logging.info(
"Finish: GeoJSON object successfully dumped to .geojson file")
return True
import json
from os import path, rename
from osm2geojson import json2geojson, overpass_call
import pycountry
import time
admin_level = 2
for c in pycountry.countries:
filename = f'{c.alpha_3}.geojson'
if path.exists(f'data/2/{filename}') or path.exists(
f'data/3/{filename}') or path.exists(
f'data/4/{filename}') or path.exists(f'data/6/{filename}'):
continue
print(c)
# alternatively: don't filter for admin_level, but check if it's 2 (country) or 3 (overseas something)
# filter out boundary=claimed_administrative
# land masses or boundary=claimed_administrative areas are sometimes also tagged with the ISO codes, so best to ask for admin_level explicitly AND set type != land_area
r = json.loads(
overpass_call(
f'[out:json];(rel["ISO3166-1:alpha2"={c.alpha_2}];rel["ISO3166-1:alpha3"={c.alpha_3}];)->.a;rel.a[boundary=administrative][admin_level={admin_level}][type!=land_area];out geom;'
))
if len(r['elements']) == 0:
print('empty result!')
continue
filename = f'data/{r["elements"][0]["tags"]["admin_level"]}/{filename}'
print(f'writing to {filename}')
with open(filename, 'w') as f:
json.dump(json2geojson(r), f)
def get_data_from_overpass(query):
endpoint = "https://overpass-api.de/api/interpreter"
response = requests.get(endpoint, params={'data': query})
overpass_json_data = response.json()
geojson_data = json2geojson(overpass_json_data)
return geojson_data
def test_meta_tags(self):
(data, saved_geojson) = get_json_and_geojson_data('meta')
self.assertDictEqual(saved_geojson, json2geojson(data))
