def run(self):
self.update_widget.setVisible(True)
self.resize(280, 300)
if self.choose_canvas.isChecked():
self.report.append(
reporter('Chose to download network for canvas area'))
e = self.iface.mapCanvas().extent()
bbox = [e.xMinimum(), e.yMinimum(), e.xMaximum(), e.yMaximum()]
else:
self.progress_label.setText('Establishing area for download')
self.report.append(reporter('Chose to download network for place'))
bbox, r = placegetter(self.place.text())
self.report.extend(r)
if bbox is None:
self.leave()
return
west, south, east, north = bbox[0], bbox[1], bbox[2], bbox[3]
self.report.append(
reporter(
'Downloading network for bounding box ({} {}, {}, {})'.format(
west, south, east, north)))
self.bbox = bbox
surveybox = QgsRectangle(QgsPointXY(west, south),
QgsPointXY(east, north))
geom = QgsGeometry().fromRect(surveybox)
conv = QgsDistanceArea()
area = conv.convertAreaMeasurement(conv.measureArea(geom),
QgsUnitTypes.AreaSquareMeters)
self.report.append(
reporter(
'Area for which we will download a network: {:,} km.sq'.format(
area / 1000000)))
if area <= max_query_area_size:
geometries = [[west, south, east, north]]
else:
parts = math.ceil(area / max_query_area_size)
horizontal = math.ceil(math.sqrt(parts))
vertical = math.ceil(parts / horizontal)
dx = east - west
dy = north - south
geometries = []
for i in range(horizontal):
xmin = west + i * dx
xmax = west + (i + 1) * dx
for j in range(vertical):
ymin = south + j * dy
ymax = south + (j + 1) * dy
box = [xmin, ymin, xmax, ymax]
geometries.append(box)
p = Parameters().parameters
modes = [list(k.keys())[0] for k in p['network']['modes']]
self.progress_label.setText('Downloading data')
self.downloader = OSMDownloader(geometries, modes)
self.run_download_thread()
def test_placegetter(self):
thresh = 0.05
if os.environ.get('GITHUB_WORKFLOW', 'ERROR') == 'Code coverage':
thresh = 1.01
if random() < thresh:
place, report = placegetter("Vatican City")
place = [round(x, 1) for x in place]
if place != [12.4, 41.9, 12.5, 41.9]:
self.fail("Returned the wrong boundingbox for Vatican City")
place, report = placegetter(
"Just a random place with no bear in reality")
if place is not None:
self.fail(
"Returned a bounding box for a place that does not exist")
else:
print('Skipped check to not load OSM servers')
def create_from_osm(
self,
west: float = None,
south: float = None,
east: float = None,
north: float = None,
place_name: str = None,
modes=["car", "transit", "bicycle", "walk"],
spatial_index=False,
) -> None:
if self._check_if_exists():
raise FileExistsError("You can only import an OSM network into a brand new model file")
self.create_empty_tables()
curr = self.conn.cursor()
curr.execute("""ALTER TABLE links ADD COLUMN osm_id integer""")
curr.execute("""ALTER TABLE nodes ADD COLUMN osm_id integer""")
self.conn.commit()
if isinstance(modes, (tuple, list)):
modes = list(modes)
elif isinstance(modes, str):
modes = [modes]
else:
raise ValueError("'modes' needs to be string or list/tuple of string")
if place_name is None:
if min(east, west) < -180 or max(east, west) > 180 or min(north, south) < -90 or max(north, south) > 90:
raise ValueError("Coordinates out of bounds")
bbox = [west, south, east, north]
else:
bbox, report = placegetter(place_name)
west, south, east, north = bbox
if bbox is None:
msg = f'We could not find a reference for place name "{place_name}"'
warn(msg)
logger.warn(msg)
return
for i in report:
if "PLACE FOUND" in i:
logger.info(i)
# Need to compute the size of the bounding box to not exceed it too much
height = haversine((east + west) / 2, south, (east + west) / 2, north)
width = haversine(east, (north + south) / 2, west, (north + south) / 2)
area = height * width
if area < max_query_area_size:
polygons = [bbox]
else:
polygons = []
parts = math.ceil(area / max_query_area_size)
horizontal = math.ceil(math.sqrt(parts))
vertical = math.ceil(parts / horizontal)
dx = east - west
dy = north - south
for i in range(horizontal):
xmin = max(-180, west + i * dx)
xmax = min(180, west + (i + 1) * dx)
for j in range(vertical):
ymin = max(-90, south + j * dy)
ymax = min(90, south + (j + 1) * dy)
box = [xmin, ymin, xmax, ymax]
polygons.append(box)
logger.info("Downloading data")
self.downloader = OSMDownloader(polygons, modes)
self.downloader.doWork()
logger.info("Building Network")
self.builder = OSMBuilder(self.downloader.json, self.conn)
self.builder.doWork()
if spatial_index:
logger.info("Adding spatial indices")
self.add_spatial_index()
self.add_triggers()
logger.info("Network built successfully")
def create_from_osm(
self,
west: float = None,
south: float = None,
east: float = None,
north: float = None,
place_name: str = None,
modes=["car", "transit", "bicycle", "walk"],
) -> None:
"""
Downloads the network from Open-Street Maps
Args:
*west* (:obj:`float`, Optional): West most coordinate of the download bounding box
*south* (:obj:`float`, Optional): South most coordinate of the download bounding box
*east* (:obj:`float`, Optional): East most coordinate of the download bounding box
*place_name* (:obj:`str`, Optional): If not downloading with East-West-North-South boundingbox, this is
required
*modes* (:obj:`list`, Optional): List of all modes to be downloaded. Defaults to the modes in the parameter
file
p = Project()
p.new(nm)
::
from aequilibrae import Project, Parameters
p = Project()
p.new('path/to/project')
# We now choose a different overpass endpoint (say a deployment in your local network)
par = Parameters()
par.parameters['osm']['overpass_endpoint'] = "http://192.168.1.234:5678/api"
# Because we have our own server, we can set a bigger area for download (in M2)
par.parameters['osm']['max_query_area_size'] = 10000000000
# And have no pause between successive queries
par.parameters['osm']['sleeptime'] = 0
# Save the parameters to disk
par.write_back()
# And do the import
p.network.create_from_osm(place_name=my_beautiful_hometown)
p.close()
"""
if self.count_links() > 0:
raise FileExistsError(
"You can only import an OSM network into a brand new model file"
)
curr = self.conn.cursor()
curr.execute("""ALTER TABLE links ADD COLUMN osm_id integer""")
curr.execute("""ALTER TABLE nodes ADD COLUMN osm_id integer""")
self.conn.commit()
if isinstance(modes, (tuple, list)):
modes = list(modes)
elif isinstance(modes, str):
modes = [modes]
else:
raise ValueError(
"'modes' needs to be string or list/tuple of string")
if place_name is None:
if min(east, west) < -180 or max(east, west) > 180 or min(
north, south) < -90 or max(north, south) > 90:
raise ValueError("Coordinates out of bounds")
bbox = [west, south, east, north]
else:
bbox, report = placegetter(place_name)
west, south, east, north = bbox
if bbox is None:
msg = f'We could not find a reference for place name "{place_name}"'
warn(msg)
logger.warning(msg)
return
for i in report:
if "PLACE FOUND" in i:
logger.info(i)
# Need to compute the size of the bounding box to not exceed it too much
height = haversine((east + west) / 2, south, (east + west) / 2, north)
width = haversine(east, (north + south) / 2, west, (north + south) / 2)
area = height * width
par = Parameters().parameters["osm"]
max_query_area_size = par["max_query_area_size"]
if area < max_query_area_size:
polygons = [bbox]
else:
polygons = []
parts = math.ceil(area / max_query_area_size)
horizontal = math.ceil(math.sqrt(parts))
vertical = math.ceil(parts / horizontal)
dx = (east - west) / horizontal
dy = (north - south) / vertical
for i in range(horizontal):
xmin = max(-180, west + i * dx)
xmax = min(180, west + (i + 1) * dx)
for j in range(vertical):
ymin = max(-90, south + j * dy)
ymax = min(90, south + (j + 1) * dy)
box = [xmin, ymin, xmax, ymax]
polygons.append(box)
logger.info("Downloading data")
self.downloader = OSMDownloader(polygons, modes)
self.downloader.doWork()
logger.info("Building Network")
self.builder = OSMBuilder(self.downloader.json, self.source)
self.builder.doWork()
logger.info("Network built successfully")