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 query_overpass(area_id, query_statement, element_type='node'):
# Query Overpass based on area
overpass = Overpass()
query = overpassQueryBuilder(area=area_id,
elementType=element_type,
selector=query_statement)
return overpass.query(query)
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 obtain_map(city):
overpass = Overpass()
result = overpass.query(('''area[name="{}"];
way(area)[highway=motorway];
out body geom;
''').format(city),
timeout=500)
return result
def fetchFeatures(areaId, osmkey, osmtype):
overpass = Overpass()
query = overpassQueryBuilder(area=areaId,
elementType=['node', 'way', 'relation'],
selector='"' + osmkey + '"="' + osmtype + '"',
includeGeometry=True,
out='center meta')
logging.debug("OSM query: %s", query)
return overpass.query(query, timeout=60)
def getOsmGeoObjects(self, areaId, selector, elementType:OsmType):
"""
sends overpass-query and return the elements from the json response
"""
overpass = Overpass()
# out='geom' also leads to geometry key (list of coordinates for each object)
query = overpassQueryBuilder(
area=areaId, elementType=elementType.value, selector=selector, out='geom')
return overpass.query(query).toJSON()["elements"]
def obtain_square_portion(corner1, corner3, corner2, corner4):
overpass = Overpass()
query = overpassQueryBuilder(bbox=[corner1, corner2, corner3, corner4],
elementType='way',
selector='"junction"',
out="body geom")
result = overpass.query(query)
road_coords = []
for element in result.elements():
road_coords.append(element.geometry()['coordinates'])
return road_coords
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 boundbox(Key, Value, box):
#nominatim = Nominatim()
print(box)
overpass = Overpass()
query = overpassQueryBuilder(bbox=box,
elementType=['node', 'way', 'relation'],
selector=f'"{Key}"="{Value}"',
includeGeometry=True)
print(query)
result = overpass.query(query, timeout=250)
result = result.toJSON()
return result
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 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 GetOSMWaysData(box):
overpass = Overpass()
query = overpassQueryBuilder(
bbox=[box.latMin, box.lonMin, box.latMax, box.lonMax],
elementType='way',
out='body')
try:
ways = overpass.query(query)
except:
Log.logging.error("In OSMPythonToolsHandler.py, GetOSMWaysData",
exc_info=True)
return False
if ways._json['elements'] == []:
box.lonMin -= 0.5
box.latMin -= 0.5
box.lonMax += 0.5
box.latMax += 0.5
GetOSMWaysData(box)
else:
StoreWaysData(ways._json['elements'])
return True
def assertForQueryResult(minElements=100, overpassKwargs={}, **kwargs):
print(kwargs)
overpass = Overpass()
y = overpass.query(overpassQueryBuilder(**kwargs), **overpassKwargs)
assert y.isValid()
assert len(y.elements()) > minElements
assert len(y.elements()) == y.countElements()
assert len(y.nodes()) >= 0
assert len(y.nodes()) == y.countNodes()
assert len(y.ways()) >= 0
assert len(y.ways()) == y.countWays()
assert len(y.relations()) >= 0
assert len(y.relations()) == y.countRelations()
assert len(y.areas()) >= 0
assert len(y.areas()) == y.countAreas()
assert y.countNodes() + y.countWays() + y.countRelations() + y.countAreas(
) == y.countElements()
assert y.toJSON()
assert y.version() > 0
assert y.generator()
assert y.timestamp_osm_base()
assert y.copyright()
return y
from OSMPythonTools.api import Api
from OSMPythonTools.overpass import Overpass
from mediawiki import MediaWiki
api = Api()
op = Overpass()
result = op.query('''
area(3600421007)->.searchArea;
rel["leisure"="park"](area.searchArea);
out body;''')
raw_parks = result._json['elements']
print(raw_parks[0])
for park in raw_parks:
if 'tags' in park:
# if 'wikipedia'
return fabs(sum/2)
"""
from OSMPythonTools.nominatim import Nominatim
nominatim = Nominatim()
nyc = nominatim.query('Perm')
print(nyc.toJSON())"""
#query = overpassQueryBuilder(bbox=[58.0065792, 56.2248863, 58.0103644, 56.2305674], elementType=['way','node'], selector='building', out='body',includeGeometry=True)
#query = overpassQueryBuilder(area=nominatim.query('Perm').areaId(), elementType=['way','node'], selector=['building','"name"="Ленинский район"'], out='body',includeGeometry=True)
#query = overpassQueryBuilder(area=nominatim.query('Perm, Свердловский район').areaId(), elementType=['way','node'], selector=['building'], out='body',includeGeometry=True)
query = overpassQueryBuilder(area=nominatim.query('Perm, Свердловский район').areaId(), elementType=['way','node'], selector=['building'], out='body',includeGeometry=True)
overpass = Overpass()
huh = overpass.query(query)
#print(huh.ways())
print(huh.countElements())
print(huh.countWays())
living_houses_w_levels = ['yes','apartments','dormitory','residential']
living_houses_wo_levels = ['house','bungalow','detached']
unliving_houses = ['roof', 'university', 'kindergarten', 'school', 'retail', 'commercial', 'office', 'church',
'hotel', 'garages', 'construction', 'train_station', 'cathedral', 'supermarket', 'service', 'offices',
'mosque', 'hospital', 'college', 'garage', 'warehouse', 'industrial', 'kiosk']
check_build=[]
people = 0
max = 0
for n in huh.ways():
#print(n.tag("building"))
#print(n.tags())
#print(n.id())
class CityMap:
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 __getattr__(self, feature: str) -> list[tuple[float, float]]:
"""Returns a list of features. Too check the available features, try using the features attribute
Returns:
list[tuple[float, float]]: list of relative positions
"""
if feature in self._normalized_dict:
return self._normalized_dict[feature]
return []
@property
def features(self) -> list[str]:
"""Returns all loaded and normalized features
Returns:
list[str]
"""
return [f for f in self._normalized_dict]
@property
def circular_features(self) -> dict[list[tuple[float, float]]]:
"""Returns all features that can must drawn as circles
Returns:
dict[list[tuple[float, float]]]
"""
return {
k: v
for k, v in self._normalized_dict.items()
if any("node" in x["topology"] and x["name"] == k
for x in self._features_list)
}
@property
def polygonal_features(self) -> dict[list[tuple[float, float]]]:
"""Returns all features that can must drawn as polygons
Returns:
dict[list[tuple[float, float]]]
"""
return {
k: v
for k, v in self._normalized_dict.items() if any(
any(y in x["topology"]
for y in {"way", "area"}) and x["name"] == k
for x in self._features_list)
}
def loadCity(self) -> None:
"""Loads city area id and bounding box (both in xy and coordinates forms)"""
city_query = self._nominatim.query(
self._city,
timeout=self._timeout,
)
# city area id
self._area_id = city_query.areaId()
# bounding box
raw_bbox = city_query.toJSON()[0]["boundingbox"]
self._bbox = (
float(raw_bbox[0]),
float(raw_bbox[2]),
float(raw_bbox[1]),
float(raw_bbox[3]),
)
def _coordsToXY(self, lat: float, lon: float) -> tuple[float, float]:
"""Calculates points x and y coordinates according to its latitude and longitude
Args:
lat (float)
lon (float)
Returns:
tuple[float, float]: x, y coordinates
"""
x = (lat - self._bbox[0]) / (self._bbox[2] - self._bbox[0])
y = (lon - self._bbox[1]) / (self._bbox[3] - self._bbox[1])
return x, y
def _isPositionValid(self, *_) -> bool:
"""Is the provided position valid?
Let's just say that the position is valid. The actual check is delegated to the subclasses.
Returns:
bool:
"""
return True
def _queryOSM(self, **kwargs) -> None:
"""Query OSM and load data into self._elements_dict
Keyword args:
name (str): Element type.
tag (str): Element tag.
topology (str): Element topology.
"""
if not self._bbox:
raise ValueError("Bounding Box not loaded.")
self._elements_dict[kwargs["name"]] = []
for t in kwargs["tag"]:
query = overpassQueryBuilder(
bbox=self._bbox,
selector=t,
elementType=kwargs["topology"],
includeGeometry=True,
)
while True:
try:
results = self._overpass.query(
query,
timeout=self._timeout,
)
break
except Exception as _:
# OFC they couldn't raise proper exceptions.
# this exceptions is a "generic" exception.
logging.error(
f"Trying again in {self._try_again} seconds...")
sleep(self._try_again)
if not results.elements():
continue
if "node" in kwargs["topology"]:
self._elements_dict[kwargs["name"]].extend(results.nodes())
elif any(t in ["way", "area"] for t in kwargs["topology"]):
self._elements_dict[kwargs["name"]].extend(results.ways())
def _rotateCoordinates(self,
coords: list[tuple[float, float]],
angle: float = -90):
"""Rotates each coordinates around its center
Args:
coords (list[tuple[float, float]]): List of normalized coordinates
angle (float, optional): Rotation angle. Defaults to -90.
Returns:
[type]: [description]
"""
c = cos(radians(angle))
s = sin(radians(angle))
translated = [tuple(s - 0.5 for s in t) for t in coords]
rotated = [(x * c - y * s, x * s + y * c) for x, y in translated]
return [tuple(s + 0.5 for s in t) for t in rotated]
def _normalizeElements(self, **kwargs) -> None:
"""Creates an entry in self._normalized_dict for a set of positions in self._elements_dict.
The resulting coordinates are a list of (x, y) tuples in range [0, 1]x[0, 1], relative to
the bounding box of the coordinates themselves.
Keyword args:
name (str): Element type.
tag (str): Element tag.
topology (str): Element topology.
"""
if "node" in kwargs["topology"]:
coords = [
self._coordsToXY(e.lat(), e.lon())
for e in self._elements_dict[kwargs["name"]]
if self._isPositionValid(e.lat(), e.lon())
]
if not coords:
return
# rotate coordinates
rotated = self._rotateCoordinates(coords)
# add to dictionary
self._normalized_dict[kwargs["name"]] = rotated
elif any(t in ["way", "area"] for t in kwargs["topology"]):
self._normalized_dict[kwargs["name"]] = []
for element in self._elements_dict[kwargs["name"]]:
for shape in element.geometry()["coordinates"]:
# sometimes shape are just an element
if len(shape) == 1:
shape = shape[0]
# filter coords and convert to xy
# sometimes coords are not lists? I don't understand why
coords = [
self._coordsToXY(*s[::-1]) for s in shape
if isinstance(s, list) and self._isPositionValid(
*s[::-1])
]
# sometimes the coords list might be empty
if len(coords) < 3:
continue
# rotate coordinates
rotated = self._rotateCoordinates(coords)
# add to dictionary
self._normalized_dict[kwargs["name"]].append(rotated)
def loadFeatures(self) -> None:
"""Loads and normalize all features."""
for feature in self._features_list:
self._queryOSM(**feature)
self._normalizeElements(**feature)
from OSMPythonTools.api import Api
api = Api()
way = api.query('way/5887599')
print('building: %s' % way.tag('building'))
print('historic %s' % way.tag('historic'))
print('architect: %s' % way.tag('architect'))
print('website: %s' % way.tag('website'))
print('=' * 6, 'Example 2', '=' * 6)
from OSMPythonTools.overpass import Overpass
overpass = Overpass()
result = overpass.query('way["name"="Stephansdom"]; out body;')
stephansdom = result.elements()[0]
print('name:en: %s' % stephansdom.tag('name:en'))
print('address: %s %s, %s %s' %
(stephansdom.tag('addr:street'), stephansdom.tag('addr:housenumber'),
stephansdom.tag('addr:postcode'), stephansdom.tag('addr:city')))
print('building: %s' % stephansdom.tag('building'))
print('denomination: %s' % stephansdom.tag('denomination'))
print('=' * 6, 'Example 3', '=' * 6)
from OSMPythonTools.nominatim import Nominatim
nominatim = Nominatim()
areaId = nominatim.query('Vienna').areaId()
from OSMPythonTools.overpass import overpassQueryBuilder
def maparea(area_name, lat=None, lon=None):
clean_name = str(re.sub(r'[^a-zA-Z\d]', '', area_name))
nominatim = Nominatim()
if area_name.isdigit():
areaId = int(area_name)
else:
areaId = nominatim.query(area_name).areaId()
overpass = Overpass()
query = overpassQueryBuilder(area=areaId,
elementType='way',
selector='"landuse"="residential"',
out='geom')
residential_areas = overpass.query(query).ways() or []
query = overpassQueryBuilder(area=areaId,
elementType='way',
selector='"highway"="footway"',
out='geom')
roads_footway = overpass.query(query).ways() or []
query = overpassQueryBuilder(
area=areaId,
elementType='way',
selector=['"highway"="service"', '"service"!="parking_aisle"'],
out='geom')
roads_cycleway = overpass.query(query).ways() or []
query = overpassQueryBuilder(area=areaId,
elementType='way',
selector='"highway"="residential"',
out='geom')
roads_residential = overpass.query(query).ways() or []
query = overpassQueryBuilder(area=areaId,
elementType='way',
selector='"highway"="tertiary"',
out='geom')
roads_tertiary = overpass.query(query).ways() or []
query = overpassQueryBuilder(area=areaId,
elementType='way',
selector='"highway"="secondary"',
out='geom')
roads_secondary = overpass.query(query).ways() or []
query = overpassQueryBuilder(area=areaId,
elementType='way',
selector='"highway"="primary"',
out='geom')
roads_primary = overpass.query(query).ways() or []
query = overpassQueryBuilder(area=areaId,
elementType='way',
selector='"highway"="motorway"',
out='geom')
roads_motorway = overpass.query(query).ways() or []
query = overpassQueryBuilder(area=areaId,
elementType='way',
selector='"highway"="trunk"',
out='geom')
roads_trunk = overpass.query(query).ways() or []
query = overpassQueryBuilder(area=areaId,
elementType='way',
selector='"highway"="trunk_link"',
out='geom')
roads_trunk_link = overpass.query(query).ways() or []
query = overpassQueryBuilder(area=areaId,
elementType='way',
selector='"highway"="unclassified"',
out='geom')
roads_unclassified = overpass.query(query).ways() or []
#print (result.countElements())
#ax = plt.axes(projection=ccrs.PlateCarree(globe=ccrs.Globe(datum='WGS84',
# ellipse='WGS84')))
#print(bbx)
request = cimgt.OSM()
terrain = cimgt.MapboxTiles(
'pk.eyJ1IjoiZWVzYWhlIiwiYSI6ImNqdGFjMTI1ODA1ZGc0NHRmN28wcG5ybnEifQ.ZBSMcdbWkjfjRgDVQLjfnw',
'terrain-rgb')
plt.style.use('dark_background')
fig, ax = plt.subplots(num=1,
figsize=(10, 10),
subplot_kw=dict(projection=request.crs,
facecolor='#000000'))
#print("trying to save debug terrain img")
#plt.savefig("terrain.png")
#print("saved")
#ax.set_extent([26.6561, 22.6589, 59.611, 60.8409])
#ax.add_image(request, 10, zorder=0)
roads = roads_residential + roads_tertiary + roads_secondary + roads_primary + roads_unclassified + roads_trunk + roads_trunk_link
def roads_in_bbox(bbox):
ret = []
for road in roads:
if road._json['bounds']['minlat'] < bbox['maxlat'] and road._json[
'bounds']['maxlat'] > bbox['minlat'] and road._json[
'bounds']['minlon'] < bbox['maxlon'] and road._json[
'bounds']['maxlon'] > bbox['minlon']:
ret.append(road)
return ret
# find areas completely enclosed inside a bounding box (not partially)
def residential_areas_enclosed_in_bbox(bbox):
ret = []
for area in residential_areas:
if area._json['bounds']['maxlat'] < bbox['maxlat'] and area._json[
'bounds']['minlat'] > bbox['minlat'] and area._json[
'bounds']['maxlon'] < bbox['maxlon'] and area._json[
'bounds']['minlon'] > bbox['minlon']:
ret.append(area)
return ret
cll = []
bbx = None
'''
processed = 0
roads = roads_residential + roads_tertiary + roads_secondary + roads_primary + roads_unclassified + roads_trunk + roads_trunk_link
print("processing total " + str(len(roads)) + " roads")
for area in (roads_residential + roads_tertiary + roads_secondary + roads_primary + roads_unclassified + roads_trunk + roads_trunk_link):
if(processed % 500 == 0):
print("processing number " + str(processed))
geometry = area._json['geometry']
lons = []
lats = []
for point in geometry:
lons.append(point['lon'])
lats.append(point['lat'])
#mycoords.append( (point['lat'], ) )
xs = np.array(lons)
ys = np.array(lats)
xynps=ax.projection.transform_points(ccrs.Geodetic(), xs, ys)
#print(xynps)
#break
ax.plot(xynps[:,0], xynps[:,1], "r", zorder=11, color='green', marker='o',linewidth=0.2, markersize=0, antialiased=False)
processed+=1
'''
print("Found " + str(len(residential_areas)) + " residential areas in " +
area_name)
# What are we exactly doing here??
'''
for area in residential_areas:
#print(vars(area))
geometry = area._json['geometry']
bbx = area._json['bounds']
lons = []
lats = []
for point in geometry:
lons.append(point['lon'])
lats.append(point['lat'])
#mycoords.append( (point['lat'], ) )
xs = np.array(lons)
ys = np.array(lats)
xynps=ax.projection.transform_points(ccrs.Geodetic(), xs, ys)
#print(xynps)
#break
plt.figure(1)
ax.fill(xynps[:,0], xynps[:,1], "b", zorder=10, antialiased=False)
cll.append( (lons,lats) )
#print(len(cll))
#ax.axis('off')
'''
counter = 0
for area in residential_areas:
#if(lat is not None):
# bbx['minlon'] = lon
# bbx['maxlon'] = lon
# bbx['minlat'] = lat
# bbx['maxlat'] = lat
# width = 0
# height = 0
#else:
bbx = area._json['bounds']
width = bbx['maxlon'] - bbx['minlon']
height = bbx['maxlat'] - bbx['minlat']
if (width < 0.0008 or height < 0.0008):
print("area too small, skipping")
continue
#print(width)
#print(height)
zoom = 0.7
conv_factor = (2.0 * math.pi) / 360.0
lat = bbx['minlat']
lat = lat * conv_factor
m1 = 111132.92
# latitude calculation term 1
m2 = -559.82
# latitude calculation term 2
m3 = 1.175
# latitude calculation term 3
m4 = -0.0023
# latitude calculation term 4
p1 = 111412.84
# longitude calculation term 1
p2 = -93.5
# longitude calculation term 2
p3 = 0.118
# longitude calculation term 3
# Calculate the length of a degree of latitude and longitude in meters
latlen = m1 + (m2 * math.cos(2 * lat)) + (m3 * math.cos(4 * lat)) + \
(m4 * math.cos(6 * lat))
longlen = (p1 * math.cos(lat)) + (p2 * math.cos(3 * lat)) + \
(p3 * math.cos(5 * lat))
#print("lat len " + str(latlen))
#print("lon len " + str(longlen))
targetWidth = 2500
targetHeight = 2500
currentWidth = longlen * width
currentHeight = latlen * height
offset_w_meters = (targetWidth - currentWidth) / 2
offset_h_meters = (targetHeight - currentHeight) / 2
offset_w_angles = offset_w_meters / longlen
offset_h_angles = offset_h_meters / latlen
#print("currentWidth " + str(currentWidth))
#print("currentHeight " + str(currentHeight))
#print("offsetAngleW " + str(offset_w_angles))
#print("offsetAngleH " + str(offset_h_angles))
offsetW = offset_w_angles
offsetH = offset_h_angles
#my_cos=math.cos(rad)
#print("my cos " + str(my_cos))
#test = 0.1 * abs(math.cos(abs(bbx['minlat'])))
#print("test " + str(test))
#print("trying to make it " + str(zoom*test) + " degrees wide")
#print("testOffsetW" + str(testOffsetW))
#offsetW = ((zoom*0.051122172576223) - width) / 2
#print("realoffsetW" + str(offsetW))
#offsetH = ((zoom*0.038) - height) / 2
#print("offsetH" + str(offsetH))
if offsetW < 0 or offsetH < 0:
print("area too big, skipping")
continue
test_savename = outdir + "/" + clean_name + "_" + str(counter) + ".png"
# continue if we already created this file
if os.path.isfile(test_savename):
counter += 1
continue
#print(bbx)
new_bbx = bbx.copy()
try:
new_bbx['minlon'] = bbx['minlon'] - offsetW
new_bbx['maxlon'] = bbx['maxlon'] + offsetW
new_bbx['minlat'] = bbx['minlat'] - offsetH
new_bbx['maxlat'] = bbx['maxlat'] + offsetH
except:
print("FAILED, BBX: " + str(bbx))
pprint(area._json)
# get population density
ring = [[new_bbx['minlon'], new_bbx['minlat']],
[new_bbx['minlon'], new_bbx['maxlat']],
[new_bbx['maxlon'], new_bbx['maxlat']],
[new_bbx['maxlon'], new_bbx['minlat']],
[new_bbx['minlon'], new_bbx['minlat']]]
ring_string = json.dumps(ring)
if (lon is None):
r = requests.post("http://sedac.ciesin.columbia.edu/arcgis/rest/services/sedac/geoprocessing/GPServer/pes-v1/execute", \
data={'Input_Feature_Set': '{ "geometryType": "esriGeometryPolygon","fields": [{"name": "id","type": "esriFieldTypeInteger"}],"spatialReference": {"wkid": 4326},"features": [{"geometry": {"rings": [ \
' + ring_string + ' \
],"spatialReference": {"wkid": 4326}},"attributes": {"id": 1}}]}' , 'f': 'json'})
json_result = json.loads(r.text)
attributes = json_result['results'][0]['value']['features'][0][
'attributes']
pop = attributes['POPULATION05']
area = attributes['LANDAREA']
density = pop / area
if (density < 1000):
print("density too small")
continue
#print(new_bbx)
#exit()
#print("bbx height " + str(new_bbx['maxlat'] - new_bbx['minlat']))
#red_fill = ax.fill(xynps[:,0], xynps[:,1], "r", zorder=10, antialiased=False)
plt.figure("terrain")
fig_terrain, ax_terrain = plt.subplots(figsize=(10, 10),
subplot_kw=dict(
projection=request.crs,
facecolor='#000000'))
try:
ax_terrain.set_extent([
new_bbx['minlon'], new_bbx['maxlon'], new_bbx['minlat'],
new_bbx['maxlat']
])
except Exception:
print(traceback.format_exc())
print(sys.exc_info()[0])
continue
ax_terrain.add_image(terrain, 13)
savename = "osm/" + str(re.sub(r'[^a-zA-Z\d]', '',
area_name)) + str(counter) + "_t.png"
plt.savefig(savename,
dpi=_dpi,
transparent=True,
bbox_inches='tight',
pad_inches=0,
frameon=None)
terrain_raster_261 = cv2.imread(savename)
terrain_raster_256_b = terrain_raster_261[3:259, 3:259, 0]
terrain_raster_256_g = terrain_raster_261[3:259, 3:259, 1]
terrain_raster_256_r = terrain_raster_261[3:259, 3:259, 2]
plt.figure(2)
fig2, ax2 = plt.subplots(figsize=(10, 10),
subplot_kw=dict(projection=request.crs,
facecolor='#000000'))
xynps = ax.projection.transform_points(
ccrs.Geodetic(), np.asarray([new_bbx['minlon'],
new_bbx['maxlon']]),
np.asarray([new_bbx['minlat'], new_bbx['maxlat']]))
#max_lonlat=ax.projection.transform_points(ccrs.Geodetic(), new_bbx['maxlon'], new_bbx['maxlat'])
#ax2.set_extent([new_bbx['minlon'], new_bbx['maxlon'], new_bbx['minlat'], new_bbx['maxlat']])
ax2.set_extent([
new_bbx['minlon'], new_bbx['maxlon'], new_bbx['minlat'],
new_bbx['maxlat']
],
crs=ccrs.Geodetic())
roads_current = roads_in_bbox(new_bbx)
all_areas = residential_areas_enclosed_in_bbox(new_bbx)
#print(str(len(all_areas)) + " areas in bbox")
red_fills = []
for current_residential_area in (all_areas):
bbx = current_residential_area._json['bounds']
width = bbx['maxlon'] - bbx['minlon']
height = bbx['maxlat'] - bbx['minlat']
if (width < 0.001 or height < 0.001):
#print("area too small, skipping")
continue
geometry = current_residential_area._json['geometry']
lons = []
lats = []
for point in geometry:
lons.append(point['lon'])
lats.append(point['lat'])
#mycoords.append( (point['lat'], ) )
xs = np.array(lons)
ys = np.array(lats)
xynps = ax.projection.transform_points(ccrs.Geodetic(), xs, ys)
#print("area " + str(current_residential_area))
red_fill2 = ax2.fill(xynps[:, 0],
xynps[:, 1],
"k",
zorder=11,
antialiased=False)
red_fills.append(red_fill2)
road_refs = []
savename = "osm/" + str(re.sub(r'[^a-zA-Z\d]', '',
area_name)) + str(counter) + "_2.png"
#print("trying to save file called " +savename)
plt.savefig(savename,
dpi=_dpi,
facecolor='0.0',
edgecolor='0.0',
transparent=True,
bbox_inches='tight',
pad_inches=0,
frameon=None)
#exit()
mask_261 = cv2.imread(savename, 0)
mask_256 = mask_261[3:259, 3:259]
#print("shape:" + str(mask.shape))
#exit()
mask_256 = cv2.threshold(mask_256, 127, 255,
cv2.THRESH_BINARY_INV)[1] # ensure binary
#kernel = np.ones((3,3), np.uint8)
kernel = cv2.getStructuringElement(cv2.MORPH_CROSS, (3, 3))
mask_dilated_256 = cv2.dilate(mask_256, kernel, iterations=2)
savename = "osm/" + str(re.sub(r'[^a-zA-Z\d]', '',
area_name)) + str(counter) + "_3.png"
cv2.imwrite(savename, mask_256)
#for road_ref in (road_refs):
# l = road_ref.pop(0)
# wl = weakref.ref(l)
# l.remove()
# del l
plt.figure(1)
ax.set_extent([
new_bbx['minlon'], new_bbx['maxlon'], new_bbx['minlat'],
new_bbx['maxlat']
])
#print("fetch roads")
#print("got " + str(len(roads))+ " roads ")
#exit()
#query = overpassQueryBuilder(bbox=[new_bbx['minlat'], new_bbx['minlon'], new_bbx['maxlat'], new_bbx['maxlon']], elementType='way', selector=['"highway"="residential"', '"highway"="tertiary"', '"highway"="secondary"', '"highway"="primary"', '"highway"="unclassified"', '"highway"="trunk"', '"highway"="trunk_link"'], out='geom')
#roads_current = overpass.query(query).ways()
#print("got num roads:")
if len(roads_current) > 0:
#print(len(roads_current))
processed = 0
for area in (roads_current):
_type = area._json['tags']['highway']
#print(_type)
if _type not in ['primary', 'secondary', 'highway', 'trunk']:
continue
geometry = area._json['geometry']
lons = []
lats = []
for point in geometry:
lons.append(point['lon'])
lats.append(point['lat'])
#mycoords.append( (point['lat'], ) )
xs = np.array(lons)
ys = np.array(lats)
xynps = ax.projection.transform_points(ccrs.Geodetic(), xs, ys)
#print(xynps)
#break
plt.figure(1)
road_ref = ax.plot(xynps[:, 0],
xynps[:, 1],
zorder=11,
color='#000000',
marker='o',
linewidth=0.05,
markersize=0,
antialiased=False)
road_refs.append(road_ref)
processed += 1
savename = "osm/" + str(re.sub(r'[^a-zA-Z\d]', '',
area_name)) + str(counter) + "_0.png"
plt.savefig(savename,
dpi=_dpi,
facecolor='0.0',
edgecolor='1.0',
transparent=True,
bbox_inches='tight',
pad_inches=0,
frameon=None)
roads_primary_secondary_raster_261 = cv2.imread(savename, 0)
roads_primary_secondary_raster_256 = roads_primary_secondary_raster_261[
3:259, 3:259]
roads_primary_secondary_raster_256 = cv2.threshold(
roads_primary_secondary_raster_256, 127, 255,
cv2.THRESH_BINARY_INV)[1]
if len(roads_current) > 0:
#print(len(roads_current))
processed = 0
for area in (roads_current):
#if(processed % 500 == 0):
#print("processing number " + str(processed))
geometry = area._json['geometry']
lons = []
lats = []
for point in geometry:
lons.append(point['lon'])
lats.append(point['lat'])
#mycoords.append( (point['lat'], ) )
xs = np.array(lons)
ys = np.array(lats)
xynps = ax.projection.transform_points(ccrs.Geodetic(), xs, ys)
#print(xynps)
#break
plt.figure(1)
road_ref = ax.plot(xynps[:, 0],
xynps[:, 1],
zorder=11,
color='#000000',
marker='o',
linewidth=0.05,
markersize=0,
antialiased=False)
road_refs.append(road_ref)
processed += 1
savename = "osm/" + str(re.sub(r'[^a-zA-Z\d]', '',
area_name)) + str(counter) + "_1.png"
plt.savefig(savename,
dpi=_dpi,
facecolor='0.0',
edgecolor='1.0',
transparent=True,
bbox_inches='tight',
pad_inches=0,
frameon=None)
# FINISHED ALL MATPLOTLIB EXPORTS AT THIS POINT
roads_raster_261 = cv2.imread(savename, 0)
roads_raster_256 = roads_raster_261[3:259, 3:259]
#b,g,r = cv2.split(masked_roads)''
roads_raster_256 = cv2.threshold(
roads_raster_256, 127, 255,
cv2.THRESH_BINARY_INV)[1] # ensure binary
# This one will only display the roads that are behind residential areas for the SECOND image
masked_roads_256 = cv2.bitwise_and(roads_raster_256,
roads_raster_256,
mask=mask_dilated_256)
#masked_roads = cv2.threshold(mask, 127, 255, cv2.THRESH_BINARY_INV)[1] # ensure binary
#savename = outdir + str(re.sub(r'[^a-zA-Z\d]', '', area_name)) + str(counter) + "_4.png"
#cv2.imwrite(savename, masked_roads)
# This one will only show the roads behind residential areas
roads_raster_256 = cv2.bitwise_and(roads_raster_256,
roads_raster_256,
mask=(255 - mask_256))
roads_raster_256 = cv2.bitwise_or(roads_raster_256,
roads_primary_secondary_raster_256)
__width = mask_256.shape[1]
__height = mask_256.shape[0]
empty = np.zeros((__height, __width), dtype=np.uint8)
#print(str(roads_raster.shape))
#print(str(mask.shape))
#print(str(empty.shape))
out = cv2.merge((roads_raster_256, empty, mask_256))
height = out.shape[0]
width = out.shape[1]
#print("width")
#print(width)
if width > 256:
out = out[0:height, 0:256]
masked_roads = masked_roads[0:height, 0:256]
width = 256
if height > 256:
out = out[0:256, 0:width]
masked_roads = masked_roads[0:256, 0:width]
height = 256
if width < 256 or height < 256:
width_diff = 256 - width
height_diff = 256 - height
out = cv2.copyMakeBorder(out,
height_diff,
0,
width_diff,
0,
cv2.BORDER_CONSTANT,
value=[0, 0, 0])
masked_roads = cv2.copyMakeBorder(masked_roads,
height_diff,
0,
width_diff,
0,
cv2.BORDER_CONSTANT,
value=[0, 0, 0])
height = out.shape[0]
width = out.shape[1]
#savename = outdir + str(re.sub(r'[^a-zA-Z\d]', '', area_name)) + str(counter) + "_5.png"
#cv2.imwrite(savename, out)
combined_r = np.zeros((256, 512), dtype=np.uint8)
combined_r[0:256, 0:256] = out[:, :, 0]
combined_r[0:256, 256:512] = masked_roads_256
combined_g = np.zeros((256, 512), dtype=np.uint8)
#combined_g[0:256, 0:256] = terrain_combined_256
#combined_g[0:256, 256:512] = masked_roads
combined_b = np.zeros((256, 512), dtype=np.uint8)
combined_b[0:256, 0:256] = out[:, :, 2]
#combined_b[0:256, 256:512] = masked_roads
#b,g,r = cv2.split(terrain_raster)
terrain_combined_256 = -10000 + (
(terrain_raster_256_r * 256 * 256 + terrain_raster_256_g * 256 +
terrain_raster_256_b) * 0.1)
#water = cv2.inRange(terrain_combined_256, 0, 24467)
smallest = terrain_combined_256.min() #terrain_combined_256.min()
biggest = smallest + 100 # terrain_combined_256.max()
#biggest = terrain_combined_256.max()
_range = biggest - smallest
#print ("biggest " + str(biggest))
#print ("range " + str(_range))
terrain_combined_256 = terrain_combined_256 - smallest
print("smallest " + str(terrain_combined_256.min()))
print("biggest " + str(terrain_combined_256.max()))
terrain_combined_256 = (terrain_combined_256 / _range) * 255
#ret,terrain_combined_256 = cv2.threshold(terrain_combined_256,2,255,cv2.THRESH_BINARY)
#terrain_combined_256 = cv2.bitwise_not(terrain_combined_256,terrain_combined_256, mask = water)
combined_g[0:256, 0:256] = terrain_combined_256
combined_g[0:256, 0:256] = np.clip(terrain_combined_256,
a_min=0,
a_max=255)
#terrain_debug_savename = outdir + "/" + clean_name + "_" + str(counter) + "_" + str(int(density)) + "_tdbg.png"
#cv2.imwrite(terrain_debug_savename,terrain_new)
savename = outdir + "/" + clean_name + "_" + str(counter) + "_" + str(
int(density)) + ".png"
out = cv2.merge((combined_r, combined_g, combined_b))
print("writing out file " + savename)
cv2.imwrite(savename, out)
for cur_red_fill in (red_fills):
l = cur_red_fill.pop(0)
wl = weakref.ref(l)
l.remove()
del l
#red_fill2 = ax.fill(xynps[:,0], xynps[:,1], "r", zorder=15, antialiased=False)
#savename = "osm/" + str(re.sub(r'[^a-zA-Z\d]', '', area_name)) + str(counter) + "_2.png"
#plt.savefig(savename, dpi=128, facecolor='0.0', edgecolor='0.0', transparent=False, bbox_inches='tight', pad_inches=0, frameon=None)
counter += 1
#l = red_fill.pop(0)
#wl = weakref.ref(l)
#l.remove()
#del l
#counter +=1
#l = red_fill2.pop(0)
#wl = weakref.ref(l)
#l.remove()
#del l
for road_ref in (road_refs):
l = road_ref.pop(0)
wl = weakref.ref(l)
l.remove()
del l
#ax.fill(xynps[:,0], xynps[:,1], "b", zorder=10, antialiased=False)
#ax.set_extent([bbx['minlat'], bbx['maxlat'], bbx['minlon'], bbx['maxlon']])
'''
from OSMPythonTools.api import Api
from OSMPythonTools.overpass import Overpass
from pprint import pprint
overpass = Overpass()
around = 100 #around in meters
loc = [41.3735485, 2.1215157]
result = overpass.query('node["amenity"](around:' + str(around) + ',' +
str(loc[0]) + ',' + str(loc[1]) + '); out;')
print(result.toJSON())
for n in result.toJSON()["elements"]:
#print(n.tags())
elem = {"id": n["id"], "type": n["tags"]["amenity"]}
if "name" in n["tags"]:
elem["name"] = n["tags"]["name"]
else:
elem["name"] = None
elem["loc"] = [n["lat"], n["lon"]]
#print(," - ",n["tags"]["name"],n["lat"])
print(elem)
#mas info sobre el objeto result https://github.com/mocnik-science/osm-python-tools/blob/master/docs/overpass.md
"""
api = Api()
overpass_query = 'node(57.7,11.9,57.8,12.0)[amenity=bar];out;'
loc = api.query(overpass_query )
print(loc)
"""
def calculate_distance_view(request):
# initial values
nominatim = Nominatim()
global castle_ide
#areaId = nominatim.query('poland').areaId()
overpass = Overpass()
api = Api()
name = None
review = None
state = None
country = nominatim.query('germany')
locator = Photon() # (user_agent='martin_jr8')
areaId = country.areaId()
names_query = country.toJSON()
country_details = names_query[0]
country_coor_lat = country_details["lat"]
country_coor_lon = country_details["lon"]
# castles location query
castle_query = overpassQueryBuilder(area=areaId,
elementType='node',
selector='castle_type',
out='body')
castle_objects = overpass.query(castle_query)
castle_list = castle_objects.elements()
# castle_infos = []
# for castle in castle_list:
# castle_infos.append(castle.tags())
# initail folium map
m = folium.Map(location=[country_coor_lat, country_coor_lon], zoom_start=6)
for castle_loc in castle_list:
info_dict = castle_loc.tags()
castle_id = castle_loc.id()
castle_name = info_dict.get('name')
if castle_name == None:
continue
else:
folium.Marker(
[castle_loc.lat(), castle_loc.lon()],
tooltip=castle_name,
popup=folium.Popup(popup_box(info_dict.get('name'), castle_id),
max_width=500),
icon=folium.Icon(color='purple',
icon='fort-awesome',
prefix='fa')).add_to(m)
if request.user.is_authenticated:
user = Profile.objects.get(user=request.user)
loc = user.location
location = locator.geocode(loc)
l_lat = location.latitude
l_lon = location.longitude
loc_point = (l_lat, l_lon)
folium.Marker([l_lat, l_lon],
tooltip='Your Location',
popup=location,
icon=folium.Icon(color='blue', icon='home',
prefix='fa')).add_to(m)
if request.method == 'GET' and request.is_ajax():
castle_ide = request.GET.get('castle_id')
castle_data = api.query(f'node/{castle_ide}')
castle_details = castle_data.tags()
# if request.user.is_authenticated and user.location != None:
# castle_lat = castle_data.lat()
# castle_lon = castle_data.lon()
# castle_point = (castle_lat, castle_lon)
# distance = round(geodesic(loc_point, castle_point).km, 2)
# castle_details["distance"] = distance
# line = folium.PolyLine(locations=[loc_point, castle_point], weight=2, color='blue')
# m.add_child(line)
# m = m._repr_html_()
return HttpResponse(json.dumps(castle_details),
content_type="application/json")
if request.user.is_authenticated and request.method == 'POST' and request.is_ajax(
):
castleName = request.POST.get('castleName')
review = request.POST.get('review')
state = request.POST.get('state')
user = request.user
ide = castle_ide
form = LocationsModelForm()
form.save(user, castleName, review, state, ide)
folium.Marker([52.352, 6.22],
tooltip='Your Location',
popup=location,
icon=folium.Icon(color='green', icon='home',
prefix='fa')).add_to(m)
messages.info(request, 'success. Review saved')
# m = m._repr_html_()
# return redirect('/')
# return HttpResponseRedirect('measurements/main.html')
# return render(request, 'measurements/main.html', {'map': m})
# return render(request, 'measurements/main.html')
# return HttpResponse(request)
m = m._repr_html_()
context = {
# 'name': name,
# 'review': review,
# 'state': state,
# 'map': m,
# 'castles': country_coor_lat,
# 'ops' : border_objects
# 'name': requested_id
}
return render(request, 'measurements/main.html', {'map': m})
import overpy
from OSMPythonTools.api import Api
from OSMPythonTools.overpass import Overpass
api = Api()
op = Overpass()
way = api.query('way/290083775')
res = op.query('way(id:29008377);')
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")
# loop over postcodes and get list of supermarkets
plzIdx = 0
for plz in plzList:
plzIdx += 1
if plzIdx % 100 == 0:
print(plzIdx, '/', len(plzList))
areaId = nominatim.query(plz).areaId()
if areaId is None:
continue
query = overpassQueryBuilder(area=areaId,
elementType='node',
selector='"shop"="supermarket"',
out='body') # includeGeometry=True,
result = overpass.query(query, timeout=60)
if result.countElements() <= 0:
continue
for item in result.elements():
if item is None:
continue
if item.tag('addr:street') == None or item.tag(
'addr:postcode') == None or item.tag('name') == None:
continue
#add row to output
writer.writerow({
'postcode':
str(item.tag('addr:postcode')),
'name':
item.tag('name'),
