def _run(self):
properties = self.gather_values()
if properties['load_only']:
# Legacy, waiting to remove the OsmParser for QGIS >= 3.6
# Change in osm_file_dialog.py L131 too
output_geom_legacy = [
layer.value.lower() for layer in properties['outputs']
]
osm_parser = OsmParser(properties['osm_file'],
load_only=True,
osm_conf=properties['osm_conf'],
layers=output_geom_legacy)
layers = osm_parser.parse()
for item in layers.values():
# noinspection PyArgumentList
QgsProject.instance().addMapLayer(item)
else:
open_file(dialog=self.dialog,
osm_file=properties['osm_file'],
output_geom_types=properties['outputs'],
output_dir=properties['output_directory'],
prefix_file=properties['prefix_file'])
self.dialog.display_message_bar(tr('Successful query'),
level=Qgis.Success,
duration=5)
def open_file(self):
"""Open the osm file with the osmconf."""
try:
self._start_process()
p = self.gather_values()
if p['load_only']:
# Legacy, waiting to remove the OsmParser for QGIS >= 3.6
# Change in osm_file_dialog.py L131 too
output_geom_legacy = [l.value.lower() for l in p['outputs']]
osm_parser = OsmParser(p['osm_file'],
load_only=True,
osm_conf=p['osm_conf'],
layers=output_geom_legacy)
layers = osm_parser.parse()
for item in layers.values():
QgsProject.instance().addMapLayer(item)
else:
open_file(dialog=self,
osm_file=p['osm_file'],
output_geom_types=p['outputs'],
output_dir=p['output_directory'],
prefix_file=p['prefix_file'])
self.display_message_bar(tr('Successful query'),
level=Qgis.Success,
duration=5)
except QuickOsmException as e:
self.display_geo_algorithm_exception(e)
except Exception as e:
self.display_exception(e)
finally:
self._end_process()
def open_file(self):
"""
Open the osm file with the osmconf
"""
QApplication.setOverrideCursor(Qt.WaitCursor)
self.start_process()
QApplication.processEvents()
# Get fields
osm_file = self.lineEdit_osmFile.text()
osm_conf = self.lineEdit_osmConf.text()
output_directory = self.lineEdit_browseDir.text()
prefix_file = self.lineEdit_filePrefix.text()
load_only = self.radioButton_osmConf.isChecked()
# Which geometry at the end ?
output_geometry_types = self.get_output_geometry_types()
try:
if not output_geometry_types:
raise OutPutGeomTypesException
if not isfile(osm_file):
raise FileDoesntExistException(suffix="*.osm or *.pbf")
if load_only:
if not isfile(osm_conf):
raise FileDoesntExistException(suffix="*.ini")
if output_directory and not isdir(output_directory):
raise DirectoryOutPutException
# Check OGR
if not is_ogr_version_ok():
raise GDALVersion
if not is_osm_driver_enabled():
raise OsmDriverNotFound
if load_only:
osm_parser = OsmParser(osm_file,
load_only=True,
osm_conf=osm_conf,
layers=output_geometry_types)
layers = osm_parser.parse()
for item in layers.values():
QgsMapLayerRegistry.instance().addMapLayer(item)
else:
open_file(dialog=self,
osm_file=osm_file,
output_geom_types=output_geometry_types,
output_dir=output_directory,
prefix_file=prefix_file)
except QuickOsmException, e:
self.display_geo_algorithm_exception(e)
def open_file(self):
"""
Open the osm file with the osmconf
"""
QApplication.setOverrideCursor(Qt.WaitCursor)
self.start_process()
QApplication.processEvents()
# Get fields
osm_file = self.lineEdit_osmFile.text()
osm_conf = self.lineEdit_osmConf.text()
output_directory = self.lineEdit_browseDir.text()
prefix_file = self.lineEdit_filePrefix.text()
load_only = self.radioButton_osmConf.isChecked()
# Which geometry at the end ?
output_geometry_types = self.get_output_geometry_types()
try:
if not output_geometry_types:
raise OutPutGeomTypesException
if not isfile(osm_file):
raise FileDoesntExistException(suffix="*.osm or *.pbf")
if load_only:
if not isfile(osm_conf):
raise FileDoesntExistException(suffix="*.ini")
if output_directory and not isdir(output_directory):
raise DirectoryOutPutException
# Check OGR
if not is_osm_driver_enabled():
raise OsmDriver
if load_only:
osm_parser = OsmParser(
osm_file,
load_only=True,
osm_conf=osm_conf,
layers=output_geometry_types)
layers = osm_parser.parse()
for item in layers.values():
QgsMapLayerRegistry.instance().addMapLayer(item)
else:
open_file(
dialog=self,
osm_file=osm_file,
output_geom_types=output_geometry_types,
output_dir=output_directory,
prefix_file=prefix_file)
except QuickOsmException, e:
self.display_geo_algorithm_exception(e)
def processAlgorithm(self, progress):
self.progress = progress
self.progress.setPercentage(0)
file_path = self.getParameterValue(self.FILE)
# Creating the dict for columns
white_list_values = {}
for layer in self.LAYERS:
value = self.getParameterValue(self.WHITE_LIST[layer])
# Delete space and tabs in OSM keys
# Processing return a 'None' value as unicode
value = re.sub('\s', '', value)
if value == '' or value == 'None':
value = None
if value:
if value != ',':
white_list_values[layer] = value.split(',')
else:
white_list_values[layer] = ','
else:
white_list_values[layer] = None
# Call the OSM Parser and connect signals
parser = OsmParser(file_path, self.LAYERS, white_list_values)
parser.signalText.connect(self.set_info)
parser.signalPercentage.connect(self.set_percentage)
# Start to parse
layers = parser.parse()
layers_outputs = {}
for key, values in layers.iteritems():
layer = QgsVectorLayer(values['geojsonFile'], "test", "ogr")
output_parameter = self.getOutputValue(self.OUTPUT_LAYERS[key])
layers_outputs[key] = QgsVectorFileWriter(
output_parameter,
'UTF-8',
layer.pendingFields(),
values['geomType'],
layer.crs())
for feature in layer.getFeatures():
layers_outputs[key].addFeature(feature)
def processAlgorithm(self, progress):
self.progress = progress
self.progress.setPercentage(0)
file_path = self.getParameterValue(self.FILE)
# Creating the dict for columns
white_list_values = {}
for layer in self.LAYERS:
value = self.getParameterValue(self.WHITE_LIST[layer])
# Delete space and tabs in OSM keys
# Processing return a 'None' value as unicode
value = re.sub('\s', '', value)
if value == '' or value == 'None':
value = None
if value:
if value != ',':
white_list_values[layer] = value.split(',')
else:
white_list_values[layer] = ','
else:
white_list_values[layer] = None
# Call the OSM Parser and connect signals
parser = OsmParser(file_path, self.LAYERS, white_list_values)
parser.signalText.connect(self.set_info)
parser.signalPercentage.connect(self.set_percentage)
# Start to parse
layers = parser.parse()
layers_outputs = {}
for key, values in layers.iteritems():
layer = QgsVectorLayer(values['geojsonFile'], "test", "ogr")
output_parameter = self.getOutputValue(self.OUTPUT_LAYERS[key])
layers_outputs[key] = QgsVectorFileWriter(output_parameter,
'UTF-8',
layer.pendingFields(),
values['geomType'],
layer.crs())
for feature in layer.getFeatures():
layers_outputs[key].addFeature(feature)
def open_file(
dialog=None,
osm_file=None,
output_geom_types=None,
white_list_column=None,
layer_name="OsmFile",
config_outputs=None,
output_dir=None,
final_query=None,
prefix_file=None):
"""
Open an osm file.
Memory layer if no output directory is set, or Geojson in the output directory.
:param final_query: The query where the file comes from. Might be empty if
it's a local OSM file.
:type final_query: basestring
"""
outputs = {}
if output_dir:
for layer in ['points', 'lines', 'multilinestrings', 'multipolygons']:
if not prefix_file:
prefix_file = layer_name
outputs[layer] = join(
output_dir, prefix_file + "_" + layer + ".geojson")
if isfile(outputs[layer]):
raise FileOutPutException(suffix='(' + outputs[layer] + ')')
# Legacy, waiting to remove the OsmParser for QGIS >= 3.6
# Change in osm_file_dialog.py L131 too
output_geom_legacy = [l.value.lower() for l in output_geom_types]
if not white_list_column:
white_list_column = {}
white_list_legacy = (
{l.value.lower(): csv for l, csv in white_list_column.items()}
)
LOGGER.info('The OSM file is: {}'.format(osm_file))
# Parsing the file
osm_parser = OsmParser(
osm_file=osm_file,
layers=output_geom_legacy,
white_list_column=white_list_legacy)
osm_parser.signalText.connect(dialog.set_progress_text)
osm_parser.signalPercentage.connect(dialog.set_progress_percentage)
start_time = time.time()
layers = osm_parser.parse()
elapsed_time = time.time() - start_time
parser_time = time.strftime("%Hh %Mm %Ss", time.gmtime(elapsed_time))
LOGGER.info('The OSM parser took: {}'.format(parser_time))
# Finishing the process with geojson or memory layer
num_layers = 0
for i, (layer, item) in enumerate(layers.items()):
dialog.set_progress_percentage(i / len(layers) * 100)
QApplication.processEvents()
if item['featureCount'] and LayerType(layer.capitalize()) in output_geom_types:
final_layer_name = layer_name
# If configOutputs is not None (from My Queries)
if config_outputs:
if config_outputs[layer]['namelayer']:
final_layer_name = config_outputs[layer]['namelayer']
if output_dir:
dialog.set_progress_text(tr('From memory to GeoJSON: ' + layer))
# Transforming the vector file
osm_geometries = {
'points': QgsWkbTypes.Point,
'lines': QgsWkbTypes.LineString,
'multilinestrings': QgsWkbTypes.MultiLineString,
'multipolygons': QgsWkbTypes.MultiPolygon}
memory_layer = item['vector_layer']
encoding = get_default_encoding()
writer = QgsVectorFileWriter(
outputs[layer],
encoding,
memory_layer.fields(),
osm_geometries[layer],
memory_layer.crs(),
"GeoJSON")
for f in memory_layer.getFeatures():
writer.addFeature(f)
del writer
# Loading the final vector file
new_layer = QgsVectorLayer(outputs[layer], final_layer_name, "ogr")
else:
new_layer = item['vector_layer']
new_layer.setName(final_layer_name)
# Try to set styling if defined
if config_outputs and config_outputs[layer]['style']:
new_layer.loadNamedStyle(config_outputs[layer]['style'])
else:
# Loading default styles
if layer == "multilinestrings" or layer == "lines":
if "colour" in item['tags']:
new_layer.loadNamedStyle(
join(dirname(dirname(abspath(__file__))),
"styles",
layer + "_colour.qml"))
# Add action about OpenStreetMap
add_actions(new_layer, item['tags'])
if final_query:
QgsExpressionContextUtils.setLayerVariable(
new_layer, 'quickosm_query', final_query)
QgsProject.instance().addMapLayer(new_layer)
num_layers += 1
return num_layers
def open_file(dialog=None,
osm_file=None,
output_geom_types=None,
white_list_column=None,
output_format=None,
layer_name="OsmFile",
config_outputs=None,
output_dir=None,
prefix_file=None):
"""
open an osm file
"""
outputs = get_outputs(output_dir, output_format, prefix_file, layer_name)
# Parsing the file
osm_parser = OsmParser(osm_file=osm_file,
layers=output_geom_types,
white_list_column=white_list_column)
osm_parser.signalText.connect(dialog.set_progress_text)
osm_parser.signalPercentage.connect(dialog.set_progress_percentage)
layers = osm_parser.parse()
# Finishing the process with geojson or shapefile
num_layers = 0
if output_format == "shape":
dialog.set_progress_text(tr("QuickOSM", u"From GeoJSON to Shapefile"))
for i, (layer, item) in enumerate(layers.iteritems()):
dialog.set_progress_percentage(i / len(layers) * 100)
QApplication.processEvents()
if item['featureCount'] and layer in output_geom_types:
final_layer_name = layer_name
# If configOutputs is not None (from My Queries)
if config_outputs:
if config_outputs[layer]['namelayer']:
final_layer_name = config_outputs[layer]['namelayer']
# Transforming the vector file
osm_geometries = {
'points': QGis.WKBPoint,
'lines': QGis.WKBLineString,
'multilinestrings': QGis.WKBMultiLineString,
'multipolygons': QGis.WKBMultiPolygon
}
geojson_layer = QgsVectorLayer(item['geojsonFile'], "temp", "ogr")
encoding = get_default_encoding()
if output_format == "shape":
writer = QgsVectorFileWriter(outputs[layer], encoding,
geojson_layer.pendingFields(),
osm_geometries[layer],
geojson_layer.crs(),
"ESRI Shapefile")
else:
writer = QgsVectorFileWriter(outputs[layer], encoding,
geojson_layer.pendingFields(),
osm_geometries[layer],
geojson_layer.crs(), "GeoJSON")
for f in geojson_layer.getFeatures():
writer.addFeature(f)
del writer
# Loading the final vector file
new_layer = QgsVectorLayer(outputs[layer], final_layer_name, "ogr")
# Try to set styling if defined
if config_outputs and config_outputs[layer]['style']:
new_layer.loadNamedStyle(config_outputs[layer]['style'])
else:
# Loading default styles
if layer == "multilinestrings" or layer == "lines":
if "colour" in item['tags']:
new_layer.loadNamedStyle(
join(dirname(dirname(abspath(__file__))), "styles",
layer + "_colour.qml"))
# Add action about OpenStreetMap
actions = new_layer.actions()
actions.addAction(
QgsAction.OpenUrl, "OpenStreetMap Browser",
'http://www.openstreetmap.org/browse/'
'[% "osm_type" %]/[% "osm_id" %]', False)
actions.addAction(
QgsAction.GenericPython, 'JOSM',
'from QuickOSM.CoreQuickOSM.Actions import Actions;'
'Actions.run("josm","[% "full_id" %]")', False)
actions.addAction(
QgsAction.OpenUrl, "User default editor",
'http://www.openstreetmap.org/edit?'
'[% "osm_type" %]=[% "osm_id" %]', False)
for link in ['url', 'website', 'wikipedia', 'ref:UAI']:
if link in item['tags']:
link = link.replace(":", "_")
actions.addAction(
QgsAction.GenericPython, link,
'from QuickOSM.core.actions import Actions;'
'Actions.run("' + link + '","[% "' + link + '" %]")',
False)
if 'network' in item['tags'] and 'ref' in item['tags']:
actions.addAction(
QgsAction.GenericPython, "Sketchline",
'from QuickOSM.core.actions import Actions;'
'Actions.run_sketch_line("[% "network" %]","[% "ref" %]")',
False)
# Add index if possible
if output_format == "shape":
new_layer.dataProvider().createSpatialIndex()
QgsMapLayerRegistry.instance().addMapLayer(new_layer)
num_layers += 1
return num_layers
def open_file(
dialog=None,
osm_file=None,
output_geom_types=None,
white_list_column=None,
output_format=None,
layer_name="OsmFile",
config_outputs=None,
output_dir=None,
prefix_file=None):
"""
open an osm file
"""
outputs = get_outputs(output_dir, output_format, prefix_file, layer_name)
# Parsing the file
osm_parser = OsmParser(
osm_file=osm_file,
layers=output_geom_types,
white_list_column=white_list_column)
osm_parser.signalText.connect(dialog.set_progress_text)
osm_parser.signalPercentage.connect(dialog.set_progress_percentage)
layers = osm_parser.parse()
# Finishing the process with geojson or shapefile
num_layers = 0
if output_format == "shape":
dialog.set_progress_text(tr("QuickOSM", u"From GeoJSON to Shapefile"))
if output_format == "spatialite":
dialog.set_progress_text(tr("QuickOSM", u"From GeoJSON to SpatiaLite"))
# create spatialite DB
conn = sqlitedb.connect(outputs['file'])
cur = conn.cursor()
cur.execute("SELECT initSpatialMetadata(1)")
conn.close()
for i, (layer, item) in enumerate(layers.iteritems()):
dialog.set_progress_percentage(i / len(layers) * 100)
QApplication.processEvents()
if item['featureCount'] and layer in output_geom_types:
final_layer_name = layer_name
# If configOutputs is not None (from My Queries)
if config_outputs:
if config_outputs[layer]['namelayer']:
final_layer_name = config_outputs[layer]['namelayer']
# Transforming the vector file
osm_geometries = {
'points': QGis.WKBPoint,
'lines': QGis.WKBLineString,
'multilinestrings': QGis.WKBMultiLineString,
'multipolygons': QGis.WKBMultiPolygon}
geojson_layer = QgsVectorLayer(item['geojsonFile'], "temp", "ogr")
encoding = get_default_encoding()
if output_format == "shape":
provider = "ESRI Shapefile"
elif output_format == "geojson":
provider = "GeoJSON"
if output_format == "spatialite":
uri = QgsDataSourceURI()
uri.setDatabase(outputs['file'])
uri.setDataSource('', outputs[layer], 'geom')
layer_source = uri.uri()
layer_provider = 'spatialite'
writer = QgsVectorLayerImport(
layer_source,
layer_provider,
geojson_layer.pendingFields(),
osm_geometries[layer],
geojson_layer.crs())
else:
layer_source = outputs[layer]
layer_provider = 'ogr'
writer = QgsVectorFileWriter(
layer_source,
encoding,
geojson_layer.pendingFields(),
osm_geometries[layer],
geojson_layer.crs(),
provider)
for f in geojson_layer.getFeatures():
writer.addFeature(f)
del writer
# Loading the final vector file
new_layer = QgsVectorLayer(layer_source, final_layer_name, layer_provider)
# Try to set styling if defined
if config_outputs and config_outputs[layer]['style']:
new_layer.loadNamedStyle(config_outputs[layer]['style'])
else:
# Loading default styles
if layer == "multilinestrings" or layer == "lines":
if "colour" in item['tags']:
new_layer.loadNamedStyle(
join(dirname(dirname(abspath(__file__))),
"styles",
layer + "_colour.qml"))
# Add action about OpenStreetMap
actions = new_layer.actions()
actions.addAction(
QgsAction.OpenUrl,
"OpenStreetMap Browser",
'http://www.openstreetmap.org/browse/'
'[% "osm_type" %]/[% "osm_id" %]',
False)
actions.addAction(
QgsAction.GenericPython,
'JOSM',
'from QuickOSM.CoreQuickOSM.Actions import Actions;'
'Actions.run("josm","[% "full_id" %]")',
False)
actions.addAction(
QgsAction.OpenUrl,
"User default editor",
'http://www.openstreetmap.org/edit?'
'[% "osm_type" %]=[% "osm_id" %]',
False)
for link in ['url', 'website', 'wikipedia', 'ref:UAI']:
if link in item['tags']:
link = link.replace(":", "_")
actions.addAction(
QgsAction.GenericPython,
link,
'from QuickOSM.core.actions import Actions;'
'Actions.run("' + link + '","[% "' + link + '" %]")',
False)
if 'network' in item['tags'] and 'ref' in item['tags']:
actions.addAction(
QgsAction.GenericPython,
"Sketchline",
'from QuickOSM.core.actions import Actions;'
'Actions.run_sketch_line("[% "network" %]","[% "ref" %]")',
False)
# Add index if possible
if output_format == "shape" or output_format == "spatialite":
new_layer.dataProvider().createSpatialIndex()
QgsMapLayerRegistry.instance().addMapLayer(new_layer)
num_layers += 1
return num_layers
def open_file(
dialog=None,
osm_file=None,
output_geom_types=None,
white_list_column=None,
output_format=None,
layer_name="OsmFile",
config_outputs=None,
output_dir=None,
prefix_file=None,
):
"""
open an osm file
"""
outputs = get_outputs(output_dir, output_format, prefix_file, layer_name)
# Parsing the file
osm_parser = OsmParser(osm_file=osm_file, layers=output_geom_types, white_list_column=white_list_column)
osm_parser.signalText.connect(dialog.set_progress_text)
osm_parser.signalPercentage.connect(dialog.set_progress_percentage)
layers = osm_parser.parse()
# Finishing the process with geojson or shapefile
num_layers = 0
if output_format == "shape":
dialog.set_progress_text(tr("QuickOSM", u"From GeoJSON to Shapefile"))
for i, (layer, item) in enumerate(layers.iteritems()):
dialog.set_progress_percentage(i / len(layers) * 100)
QApplication.processEvents()
if item["featureCount"] and layer in output_geom_types:
final_layer_name = layer_name
# If configOutputs is not None (from My Queries)
if config_outputs:
if config_outputs[layer]["namelayer"]:
final_layer_name = config_outputs[layer]["namelayer"]
# Transforming the vector file
osm_geometries = {
"points": QGis.WKBPoint,
"lines": QGis.WKBLineString,
"multilinestrings": QGis.WKBMultiLineString,
"multipolygons": QGis.WKBMultiPolygon,
}
geojson_layer = QgsVectorLayer(item["geojsonFile"], "temp", "ogr")
encoding = get_default_encoding()
if output_format == "shape":
writer = QgsVectorFileWriter(
outputs[layer],
encoding,
geojson_layer.pendingFields(),
osm_geometries[layer],
geojson_layer.crs(),
"ESRI Shapefile",
)
else:
writer = QgsVectorFileWriter(
outputs[layer],
encoding,
geojson_layer.pendingFields(),
osm_geometries[layer],
geojson_layer.crs(),
"GeoJSON",
)
for f in geojson_layer.getFeatures():
writer.addFeature(f)
del writer
# Loading the final vector file
new_layer = QgsVectorLayer(outputs[layer], final_layer_name, "ogr")
# Try to set styling if defined
if config_outputs and config_outputs[layer]["style"]:
new_layer.loadNamedStyle(config_outputs[layer]["style"])
else:
# Loading default styles
if layer == "multilinestrings" or layer == "lines":
if "colour" in item["tags"]:
new_layer.loadNamedStyle(
join(dirname(dirname(abspath(__file__))), "styles", layer + "_colour.qml")
)
# Add action about OpenStreetMap
actions = new_layer.actions()
actions.addAction(
QgsAction.OpenUrl,
"OpenStreetMap Browser",
"http://www.openstreetmap.org/browse/" '[% "osm_type" %]/[% "osm_id" %]',
False,
)
actions.addAction(
QgsAction.GenericPython,
"JOSM",
"from QuickOSM.CoreQuickOSM.Actions import Actions;" 'Actions.run("josm","[% "full_id" %]")',
False,
)
actions.addAction(
QgsAction.OpenUrl,
"User default editor",
"http://www.openstreetmap.org/edit?" '[% "osm_type" %]=[% "osm_id" %]',
False,
)
for link in ["url", "website", "wikipedia", "ref:UAI"]:
if link in item["tags"]:
link = link.replace(":", "_")
actions.addAction(
QgsAction.GenericPython,
link,
"from QuickOSM.core.actions import Actions;"
'Actions.run("' + link + '","[% "' + link + '" %]")',
False,
)
if "network" in item["tags"] and "ref" in item["tags"]:
actions.addAction(
QgsAction.GenericPython,
"Sketchline",
"from QuickOSM.core.actions import Actions;"
'Actions.run_sketch_line("[% "network" %]","[% "ref" %]")',
False,
)
# Add index if possible
if output_format == "shape":
new_layer.dataProvider().createSpatialIndex()
QgsMapLayerRegistry.instance().addMapLayer(new_layer)
num_layers += 1
return num_layers
def open_file(self):
"""
Open the osm file with the osmconf
"""
QApplication.setOverrideCursor(Qt.WaitCursor)
self.start_process()
QApplication.processEvents()
# Get fields
osm_file = self.osm_file.filePath()
osm_conf = self.osm_conf.filePath()
output_directory = self.output_directory.filePath()
prefix_file = self.lineEdit_filePrefix.text()
load_only = self.radioButton_osmConf.isChecked()
# Which geometry at the end ?
output_geometry_types = self.get_output_geometry_types()
try:
if not output_geometry_types:
raise OutPutGeomTypesException
if not isfile(osm_file):
raise FileDoesntExistException(suffix="*.osm or *.pbf")
if load_only:
if not isfile(osm_conf):
raise FileDoesntExistException(suffix="*.ini")
if output_directory and not isdir(output_directory):
raise DirectoryOutPutException
if load_only:
osm_parser = OsmParser(osm_file,
load_only=True,
osm_conf=osm_conf,
layers=output_geometry_types)
layers = osm_parser.parse()
for item in list(layers.values()):
QgsProject.instance().addMapLayer(item)
else:
open_file(dialog=self,
osm_file=osm_file,
output_geom_types=output_geometry_types,
output_dir=output_directory,
prefix_file=prefix_file)
display_message_bar(tr('QuickOSM', u'Successful query !'),
level=Qgis.Success,
duration=5)
except QuickOsmException as e:
self.display_geo_algorithm_exception(e)
except Exception as e: # pylint: disable=broad-except
self.display_exception(e)
finally:
QApplication.restoreOverrideCursor()
self.end_process()
QApplication.processEvents()
def open_file(self):
"""
Open the osm file with the osmconf
"""
QApplication.setOverrideCursor(Qt.WaitCursor)
self.start_process()
QApplication.processEvents()
# Get fields
osm_file = self.osm_file.filePath()
osm_conf = self.osm_conf.filePath()
output_directory = self.output_directory.filePath()
prefix_file = self.lineEdit_filePrefix.text()
load_only = self.radioButton_osmConf.isChecked()
# Which geometry at the end ?
output_geometry_types = self.get_output_geometry_types()
try:
if not output_geometry_types:
raise OutPutGeomTypesException
if not isfile(osm_file):
raise FileDoesntExistException(suffix="*.osm or *.pbf")
if load_only:
if not isfile(osm_conf):
raise FileDoesntExistException(suffix="*.ini")
if output_directory and not isdir(output_directory):
raise DirectoryOutPutException
if load_only:
# Legacy, waiting to remove the OsmParser for QGIS >= 3.6
# Change in osm_file_dialog.py L131 too
output_geom_legacy = [
l.value.lower() for l in output_geometry_types]
osm_parser = OsmParser(
osm_file,
load_only=True,
osm_conf=osm_conf,
layers=output_geom_legacy)
layers = osm_parser.parse()
for item in list(layers.values()):
QgsProject.instance().addMapLayer(item)
else:
open_file(
dialog=self,
osm_file=osm_file,
output_geom_types=output_geometry_types,
output_dir=output_directory,
prefix_file=prefix_file)
display_message_bar(
tr('Successful query'),
level=Qgis.Success,
duration=5)
except QuickOsmException as e:
self.display_geo_algorithm_exception(e)
except Exception as e: # pylint: disable=broad-except
self.display_exception(e)
finally:
QApplication.restoreOverrideCursor()
self.end_process()
QApplication.processEvents()
def process_road(self, context, url):
"""Major step of the process"""
if self.feedback.isCanceled():
self.feedback.reportError(
'The algorithm has been canceled during the building of the url.'
)
return self.OUTPUT_CANCEL
self.feedback.setCurrentStep(1)
self.feedback.pushInfo('Downloading data and OSM file.')
connexion_overpass_api = ConnexionOAPI(url)
osm_file = connexion_overpass_api.run()
if self.feedback.isCanceled():
self.feedback.reportError(
'The algorithm has been canceled during the download.')
return self.OUTPUT_CANCEL
self.feedback.setCurrentStep(2)
self.feedback.pushInfo('Processing downloaded file.')
out_dir = dirname(self.file) if self.file else None
out_file = basename(self.file)[:-5] if self.file else None
osm_parser = OsmParser(osm_file=osm_file,
output_format=Format.GeoPackage,
output_dir=out_dir,
prefix_file=out_file,
feedback_alg=True,
feedback=self.feedback)
layers = osm_parser.processing_parse()
if self.feedback.isCanceled():
self.feedback.reportError(
'The algorithm has been canceled during the parsing.')
return self.OUTPUT_CANCEL
self.feedback.setCurrentStep(7)
self.feedback.pushInfo('Decorating the requested layers.')
layer_output = []
OUTPUT = {
'points': self.OUTPUT_POINTS,
'lines': self.OUTPUT_LINES,
'multilinestrings': self.OUTPUT_MULTILINESTRINGS,
'multipolygons': self.OUTPUT_MULTIPOLYGONS
}
for layer in layers:
layers[layer]['layer_decorated'] = processing.run(
"quickosm:decoratelayer",
{'LAYER': layers[layer]['vector_layer']},
feedback=self.feedback)
context.temporaryLayerStore().addMapLayer(
layers[layer]['vector_layer'])
layer_output.append(
QgsProcessingUtils.mapLayerFromString(
layers[layer]['vector_layer'].id(), context, True))
if 'tags' in layers[layer]:
layer_details = QgsProcessingContext.LayerDetails(
'OSMQuery_' + layer, context.project(), OUTPUT[layer])
if 'colour' in layers[layer]['tags']:
layer_details.setPostProcessor(
SetColoringPostProcessor.create(layers[layer]['tags']))
context.addLayerToLoadOnCompletion(
layers[layer]['vector_layer'].id(), layer_details)
if self.feedback.isCanceled():
self.feedback.reportError(
'The algorithm has been canceled during the post processing.')
return self.OUTPUT_CANCEL
outputs = {
self.OUTPUT_POINTS: layer_output[0].id(),
self.OUTPUT_LINES: layer_output[1].id(),
self.OUTPUT_MULTILINESTRINGS: layer_output[2].id(),
self.OUTPUT_MULTIPOLYGONS: layer_output[3].id(),
}
return outputs
def open_file(dialog=None,
osm_file=None,
output_geom_types=None,
white_list_column=None,
layer_name="OsmFile",
config_outputs=None,
output_dir=None,
prefix_file=None):
"""
Open an osm file.
Memory layer if no output directory is set, or Geojson in the output directory.
"""
outputs = {}
if output_dir:
for layer in ['points', 'lines', 'multilinestrings', 'multipolygons']:
if not prefix_file:
prefix_file = layer_name
outputs[layer] = join(output_dir,
prefix_file + "_" + layer + ".geojson")
if isfile(outputs[layer]):
raise FileOutPutException(suffix='(' + outputs[layer] + ')')
# Parsing the file
osm_parser = OsmParser(osm_file=osm_file,
layers=output_geom_types,
white_list_column=white_list_column)
osm_parser.signalText.connect(dialog.set_progress_text)
osm_parser.signalPercentage.connect(dialog.set_progress_percentage)
start_time = time.time()
layers = osm_parser.parse()
elapsed_time = time.time() - start_time
parser_time = time.strftime("%Hh %Mm %Ss", time.gmtime(elapsed_time))
LOGGER.info('The OSM parser took: {}'.format(parser_time))
# Finishing the process with geojson or memory layer
num_layers = 0
for i, (layer, item) in enumerate(layers.items()):
dialog.set_progress_percentage(i / len(layers) * 100)
QApplication.processEvents()
if item['featureCount'] and layer in output_geom_types:
final_layer_name = layer_name
# If configOutputs is not None (from My Queries)
if config_outputs:
if config_outputs[layer]['namelayer']:
final_layer_name = config_outputs[layer]['namelayer']
if output_dir:
dialog.set_progress_text(tr('From memory to GeoJSON: ' +
layer))
# Transforming the vector file
osm_geometries = {
'points': QgsWkbTypes.Point,
'lines': QgsWkbTypes.LineString,
'multilinestrings': QgsWkbTypes.MultiLineString,
'multipolygons': QgsWkbTypes.MultiPolygon
}
memory_layer = item['vector_layer']
encoding = get_default_encoding()
writer = QgsVectorFileWriter(outputs[layer], encoding,
memory_layer.fields(),
osm_geometries[layer],
memory_layer.crs(), "GeoJSON")
for f in memory_layer.getFeatures():
writer.addFeature(f)
del writer
# Loading the final vector file
new_layer = QgsVectorLayer(outputs[layer], final_layer_name,
"ogr")
else:
new_layer = item['vector_layer']
new_layer.setName(final_layer_name)
# Try to set styling if defined
if config_outputs and config_outputs[layer]['style']:
new_layer.loadNamedStyle(config_outputs[layer]['style'])
else:
# Loading default styles
if layer == "multilinestrings" or layer == "lines":
if "colour" in item['tags']:
new_layer.loadNamedStyle(
join(dirname(dirname(abspath(__file__))), "styles",
layer + "_colour.qml"))
# Add action about OpenStreetMap
add_actions(new_layer, item['tags'])
QgsProject.instance().addMapLayer(new_layer)
num_layers += 1
return num_layers
def open_file(dialog=None,
osm_file=None,
output_geom_types=None,
white_list_column=None,
layer_name="OsmFile",
config_outputs=None,
output_dir=None,
prefix_file=None):
"""
Open an osm file.
Memory layer if no output directory is set, or Geojson in the output directory.
"""
outputs = {}
if output_dir:
for layer in ['points', 'lines', 'multilinestrings', 'multipolygons']:
if not prefix_file:
prefix_file = layer_name
outputs[layer] = join(output_dir,
prefix_file + "_" + layer + ".geojson")
if isfile(outputs[layer]):
raise FileOutPutException(suffix='(' + outputs[layer] + ')')
# Parsing the file
osm_parser = OsmParser(osm_file=osm_file,
layers=output_geom_types,
white_list_column=white_list_column)
osm_parser.signalText.connect(dialog.set_progress_text)
osm_parser.signalPercentage.connect(dialog.set_progress_percentage)
layers = osm_parser.parse()
# Finishing the process with geojson or memory layer
num_layers = 0
for i, (layer, item) in enumerate(layers.items()):
dialog.set_progress_percentage(i / len(layers) * 100)
QApplication.processEvents()
if item['featureCount'] and layer in output_geom_types:
final_layer_name = layer_name
# If configOutputs is not None (from My Queries)
if config_outputs:
if config_outputs[layer]['namelayer']:
final_layer_name = config_outputs[layer]['namelayer']
if output_dir:
dialog.set_progress_text(
tr("QuickOSM", u"From memory to GeoJSON: " + layer))
# Transforming the vector file
osm_geometries = {
'points': QgsWkbTypes.Point,
'lines': QgsWkbTypes.LineString,
'multilinestrings': QgsWkbTypes.MultiLineString,
'multipolygons': QgsWkbTypes.MultiPolygon
}
memory_layer = item['vector_layer']
encoding = get_default_encoding()
writer = QgsVectorFileWriter(outputs[layer], encoding,
memory_layer.fields(),
osm_geometries[layer],
memory_layer.crs(), "GeoJSON")
for f in memory_layer.getFeatures():
writer.addFeature(f)
del writer
# Loading the final vector file
new_layer = QgsVectorLayer(outputs[layer], final_layer_name,
"ogr")
else:
new_layer = item['vector_layer']
new_layer.setName(final_layer_name)
# Try to set styling if defined
if config_outputs and config_outputs[layer]['style']:
new_layer.loadNamedStyle(config_outputs[layer]['style'])
else:
# Loading default styles
if layer == "multilinestrings" or layer == "lines":
if "colour" in item['tags']:
new_layer.loadNamedStyle(
join(dirname(dirname(abspath(__file__))), "styles",
layer + "_colour.qml"))
# Add action about OpenStreetMap
actions = new_layer.actions()
actions.addAction(
QgsAction.OpenUrl, "OpenStreetMap Browser",
'http://www.openstreetmap.org/browse/'
'[% "osm_type" %]/[% "osm_id" %]', False)
actions.addAction(
QgsAction.GenericPython, 'JOSM',
'from QuickOSM.CoreQuickOSM.Actions import Actions;'
'Actions.run("josm","[% "full_id" %]")', False)
actions.addAction(
QgsAction.OpenUrl, "User default editor",
'http://www.openstreetmap.org/edit?'
'[% "osm_type" %]=[% "osm_id" %]', False)
for link in ['url', 'website', 'wikipedia', 'ref:UAI']:
if link in item['tags']:
link = link.replace(":", "_")
actions.addAction(
QgsAction.GenericPython, link,
'from QuickOSM.core.actions import Actions;'
'Actions.run("' + link + '","[% "' + link + '" %]")',
False)
if 'network' in item['tags'] and 'ref' in item['tags']:
actions.addAction(
QgsAction.GenericPython, "Sketchline",
'from QuickOSM.core.actions import Actions;'
'Actions.run_sketch_line("[% "network" %]","[% "ref" %]")',
False)
QgsProject.instance().addMapLayer(new_layer)
num_layers += 1
return num_layers
def open_file(dialog: QDialog = None,
osm_file: str = None,
output_geom_types: list = None,
white_list_column: dict = None,
key: Union[str, List[str]] = None,
layer_name: str = "OsmFile",
config_outputs: dict = None,
output_dir: str = None,
output_format: Format = None,
final_query: str = None,
prefix_file: str = None,
subset: bool = False,
subset_query: str = None,
feedback: QgsFeedback = None) -> int:
"""
Open an osm file.
Memory layer if no output directory is set, or Geojson in the output
directory.
:param final_query: The query where the file comes from. Might be empty if
it's a local OSM file.
:type final_query: basestring
"""
if output_geom_types is None:
output_geom_types = OSM_LAYERS
# Legacy, waiting to remove the OsmParser for QGIS >= 3.6
# Change in osm_file_dialog.py L131 too
output_geom_legacy = [geom.value.lower() for geom in output_geom_types]
if not white_list_column:
white_list_column = None
LOGGER.info('The OSM file is: {}'.format(osm_file))
if feedback:
if feedback.isCanceled():
return None
# Parsing the file
osm_parser = OsmParser(osm_file=osm_file,
layers=output_geom_legacy,
output_format=output_format,
output_dir=output_dir,
prefix_file=prefix_file,
layer_name=layer_name,
key=key,
white_list_column=white_list_column,
subset=subset,
subset_query=subset_query,
feedback=feedback)
if dialog:
osm_parser.signalText.connect(dialog.set_progress_text)
osm_parser.signalPercentage.connect(dialog.set_progress_percentage)
start_time = time.time()
layers = osm_parser.processing_parse()
elapsed_time = time.time() - start_time
parser_time = time.strftime("%Hh %Mm %Ss", time.gmtime(elapsed_time))
LOGGER.info('The OSM parser took: {}'.format(parser_time))
if feedback:
if feedback.isCanceled():
return None
# Finishing the process with an output format or memory layer
num_layers = 0
for i, (layer, item) in enumerate(layers.items()):
if dialog:
dialog.set_progress_percentage(i / len(layers) * 100)
QApplication.processEvents()
if item['featureCount'] and (LayerType(layer.capitalize())
in output_geom_types):
final_layer_name = layer_name
# If configOutputs is not None (from My Queries)
if config_outputs:
if config_outputs[layer]['namelayer']:
final_layer_name = config_outputs[layer]['namelayer']
new_layer = item['vector_layer']
new_layer.setName(final_layer_name)
# Try to set styling if defined
if config_outputs and config_outputs[layer]['style']:
new_layer.loadNamedStyle(config_outputs[layer]['style'])
else:
if "colour" in item['tags']:
index = item['tags'].index('colour')
colors = new_layer.uniqueValues(index)
categories = []
for value in colors:
if str(value) == 'None':
value = ''
if layer in ['lines', 'multilinestrings']:
symbol = QgsSymbol.defaultSymbol(
QgsWkbTypes.LineGeometry)
elif layer == "points":
symbol = QgsSymbol.defaultSymbol(
QgsWkbTypes.PointGeometry)
elif layer == "multipolygons":
symbol = QgsSymbol.defaultSymbol(
QgsWkbTypes.PolygonGeometry)
symbol.setColor(QColor(value))
category = QgsRendererCategory(str(value), symbol,
str(value))
categories.append(category)
renderer = QgsCategorizedSymbolRenderer(
"colour", categories)
new_layer.setRenderer(renderer)
# Add action about OpenStreetMap
actions.add_actions(new_layer, item['tags'])
QgsProject.instance().addMapLayer(new_layer)
if final_query:
QgsExpressionContextUtils.setLayerVariable(
new_layer, 'quickosm_query', final_query)
actions.add_relaunch_action(new_layer, final_layer_name)
if dialog:
dialog.iface.addCustomActionForLayer(
dialog.reload_action, new_layer)
metadata = QgsLayerMetadata()
metadata.setRights([tr("© OpenStreetMap contributors")])
metadata.setLicenses(['https://openstreetmap.org/copyright'])
new_layer.setMetadata(metadata)
num_layers += 1
return num_layers
