def read_settings(self):
"""Set the IF state from QSettings."""
extent = setting('user_extent', None, str)
if extent:
extent = QgsGeometry.fromWkt(extent)
if not extent.isGeosValid():
extent = None
crs = setting('user_extent_crs', None, str)
if crs:
crs = QgsCoordinateReferenceSystem(crs)
if not crs.isValid():
crs = None
mode = setting('analysis_extents_mode', HAZARD_EXPOSURE_VIEW)
if crs and extent and mode == HAZARD_EXPOSURE_BOUNDINGBOX:
self.extent.set_user_extent(extent, crs)
self.extent.show_rubber_bands = setting(
'showRubberBands', False, bool)
self.zoom_to_impact_flag = setting('setZoomToImpactFlag', True, bool)
# whether exposure layer should be hidden after model completes
self.hide_exposure_flag = setting('setHideExposureFlag', False, bool)
def selectProjection(self):
dialog = QgsProjectionSelectionDialog(self.widget)
current_crs = QgsCoordinateReferenceSystem(self.combo.currentText())
if current_crs.isValid():
dialog.setCrs(current_crs)
if dialog.exec_():
self.setValue(dialog.crs().authid())
def selectProjection(self):
dialog = QgsGenericProjectionSelector(self.widget)
current_crs = QgsCoordinateReferenceSystem(self.combo.currentText())
if current_crs.isValid():
dialog.setSelectedCrsId(current_crs.srsid())
if dialog.exec_():
self.setValue(dialog.selectedAuthId())
def processAlgorithm(self, feedback):
layers = self.getParameterValue(self.INPUT_DATASOURCES)
query = self.getParameterValue(self.INPUT_QUERY)
uid_field = self.getParameterValue(self.INPUT_UID_FIELD)
geometry_field = self.getParameterValue(self.INPUT_GEOMETRY_FIELD)
geometry_type = self.getParameterValue(self.INPUT_GEOMETRY_TYPE)
geometry_crs = self.getParameterValue(self.INPUT_GEOMETRY_CRS)
df = QgsVirtualLayerDefinition()
layerIdx = 1
if layers:
for layerSource in layers.split(';'):
layer = dataobjects.getObjectFromUri(layerSource)
if layer:
df.addSource('input{}'.format(layerIdx), layer.id())
layerIdx += 1
if query == '':
raise GeoAlgorithmExecutionException(
self.tr('Empty SQL. Please enter valid SQL expression and try again.'))
else:
df.setQuery(query)
if uid_field:
df.setUid(uid_field)
if geometry_type == 1: # no geometry
df.setGeometryWkbType(QgsWkbTypes.NullGeometry)
else:
if geometry_field:
df.setGeometryField(geometry_field)
if geometry_type > 1:
df.setGeometryWkbType(geometry_type - 1)
if geometry_crs:
crs = QgsCoordinateReferenceSystem(geometry_crs)
if crs.isValid():
df.setGeometrySrid(crs.postgisSrid())
vLayer = QgsVectorLayer(df.toString(), "temp_vlayer", "virtual")
if not vLayer.isValid():
raise GeoAlgorithmExecutionException(vLayer.dataProvider().error().message())
writer = self.getOutputFromName(self.OUTPUT_LAYER).getVectorWriter(
vLayer.fields().toList(),
# Create a point layer (without any points) if 'no geometry' is chosen
vLayer.wkbType() if geometry_type != 1 else 1,
vLayer.crs())
features = vector.features(vLayer)
total = 100.0 / len(features)
outFeat = QgsFeature()
for current, inFeat in enumerate(features):
outFeat.setAttributes(inFeat.attributes())
if geometry_type != 1:
outFeat.setGeometry(inFeat.geometry())
writer.addFeature(outFeat)
feedback.setProgress(int(current * total))
del writer
def processAlgorithm(self, feedback):
layers = self.getParameterValue(self.INPUT_DATASOURCES)
query = self.getParameterValue(self.INPUT_QUERY)
uid_field = self.getParameterValue(self.INPUT_UID_FIELD)
geometry_field = self.getParameterValue(self.INPUT_GEOMETRY_FIELD)
geometry_type = self.getParameterValue(self.INPUT_GEOMETRY_TYPE)
geometry_crs = self.getParameterValue(self.INPUT_GEOMETRY_CRS)
df = QgsVirtualLayerDefinition()
layerIdx = 1
if layers:
for layerSource in layers.split(';'):
layer = dataobjects.getLayerFromString(layerSource)
if layer:
df.addSource('input{}'.format(layerIdx), layer.id())
layerIdx += 1
if query == '':
raise GeoAlgorithmExecutionException(
self.tr('Empty SQL. Please enter valid SQL expression and try again.'))
else:
df.setQuery(query)
if uid_field:
df.setUid(uid_field)
if geometry_type == 1: # no geometry
df.setGeometryWkbType(QgsWkbTypes.NullGeometry)
else:
if geometry_field:
df.setGeometryField(geometry_field)
if geometry_type > 1:
df.setGeometryWkbType(geometry_type - 1)
if geometry_crs:
crs = QgsCoordinateReferenceSystem(geometry_crs)
if crs.isValid():
df.setGeometrySrid(crs.postgisSrid())
vLayer = QgsVectorLayer(df.toString(), "temp_vlayer", "virtual")
if not vLayer.isValid():
raise GeoAlgorithmExecutionException(vLayer.dataProvider().error().message())
writer = self.getOutputFromName(self.OUTPUT_LAYER).getVectorWriter(
vLayer.fields().toList(),
# Create a point layer (without any points) if 'no geometry' is chosen
vLayer.wkbType() if geometry_type != 1 else 1,
vLayer.crs())
features = vector.features(vLayer)
total = 100.0 / len(features)
outFeat = QgsFeature()
for current, inFeat in enumerate(features):
outFeat.setAttributes(inFeat.attributes())
if geometry_type != 1:
outFeat.setGeometry(inFeat.geometry())
writer.addFeature(outFeat)
feedback.setProgress(int(current * total))
del writer
def testCrsConversion(self):
self.assertFalse(
GdalUtils.gdal_crs_string(QgsCoordinateReferenceSystem()))
self.assertEqual(
GdalUtils.gdal_crs_string(
QgsCoordinateReferenceSystem('EPSG:3111')), 'EPSG:3111')
self.assertEqual(
GdalUtils.gdal_crs_string(
QgsCoordinateReferenceSystem('POSTGIS:3111')), 'EPSG:3111')
self.assertEqual(
GdalUtils.gdal_crs_string(
QgsCoordinateReferenceSystem(
'proj4: +proj=utm +zone=36 +south +a=6378249.145 +b=6356514.966398753 +towgs84=-143,-90,-294,0,0,0,0 +units=m +no_defs'
)), 'EPSG:20936')
crs = QgsCoordinateReferenceSystem()
crs.createFromProj(
'+proj=utm +zone=36 +south +a=600000 +b=70000 +towgs84=-143,-90,-294,0,0,0,0 +units=m +no_defs'
)
self.assertTrue(crs.isValid())
if QgsProjUtils.projVersionMajor() >= 6:
# proj 6, WKT should be used
self.assertEqual(
GdalUtils.gdal_crs_string(crs)[:40],
'BOUNDCRS[SOURCECRS[PROJCRS["unknown",BAS')
self.assertEqual(
GdalUtils.gdal_crs_string(
QgsCoordinateReferenceSystem('ESRI:102003')),
'ESRI:102003')
else:
self.assertEqual(
GdalUtils.gdal_crs_string(crs),
'+proj=utm +zone=36 +south +a=600000 +b=70000 +towgs84=-143,-90,-294,0,0,0,0 +units=m +no_defs'
)
# check that newlines are stripped
crs = QgsCoordinateReferenceSystem()
crs.createFromProj(
'+proj=utm +zone=36 +south\n +a=600000 +b=70000 \r\n +towgs84=-143,-90,-294,0,0,0,0 +units=m\n+no_defs'
)
self.assertTrue(crs.isValid())
self.assertEqual(
GdalUtils.gdal_crs_string(crs),
'+proj=utm +zone=36 +south +a=600000 +b=70000 +towgs84=-143,-90,-294,0,0,0,0 +units=m +no_defs'
)
def get_crs(projid=''):
crs = None
if projid:
crs = QgsCoordinateReferenceSystem(projid)
if crs is None or not crs.isValid():
crs = QgsCoordinateReferenceSystem("EPSG:4326")
return crs
def sameBaseCrs(self, crs1, crs2):
if crs1 == crs2: # it's the same!
return True
# remove towgs84, nadgrids and wktext from both and try again
proj4str1 = self.__removeFromProj4(
crs1.toProj4(), ['+towgs84', '+nadgrids', '+wktext'])
proj4str2 = self.__removeFromProj4(
crs2.toProj4(), ['+towgs84', '+nadgrids', '+wktext'])
newcrs1 = QgsCoordinateReferenceSystem()
newcrs2 = QgsCoordinateReferenceSystem()
if newcrs1.createFromProj4( proj4str1 ) and newcrs1.isValid() and \
newcrs2.createFromProj4( proj4str2 ) and newcrs2.isValid():
if newcrs1 == newcrs2:
return True
return False
def newVectorLayer(filename, fields, geometryType, crs, encoding="utf-8"):
'''
Creates a new vector layer
:param filename: The filename to store the file. The extensions determines the type of file.
If extension is not among the supported ones, a shapefile will be created and the file will
get an added '.shp' to its path.
If the filename is None, a memory layer will be created
:param fields: the fields to add to the layer. Accepts a QgsFields object or a list of tuples (field_name, field_type)
Accepted field types are basic Python types str, float, int and bool
:param geometryType: The type of geometry of the layer to create.
:param crs: The crs of the layer to create. Accepts a QgsCoordinateSystem object or a string with the CRS authId.
:param encoding: The layer encoding
'''
if isinstance(crs, basestring):
crs = QgsCoordinateReferenceSystem(crs)
if filename is None:
uri = GEOM_TYPE_MAP[geometryType]
if crs.isValid():
uri += '?crs=' + crs.authid() + '&'
fieldsdesc = ['field=' + f for f in fields]
fieldsstring = '&'.join(fieldsdesc)
uri += fieldsstring
layer = QgsVectorLayer(uri, "mem_layer", 'memory')
else:
formats = QgsVectorFileWriter.supportedFiltersAndFormats()
OGRCodes = {}
for (key, value) in formats.items():
extension = unicode(key)
extension = extension[extension.find('*.') + 2:]
extension = extension[:extension.find(' ')]
OGRCodes[extension] = value
extension = os.path.splitext(filename)[1][1:]
if extension not in OGRCodes:
extension = 'shp'
filename = filename + '.shp'
if isinstance(fields, QgsFields):
qgsfields = fields
else:
qgsfields = QgsFields()
for field in fields:
qgsfields.append(_toQgsField(field))
QgsVectorFileWriter(filename, encoding, qgsfields, geometryType, crs,
OGRCodes[extension])
layer = QgsVectorLayer(filename, os.path.basename(filename), 'ogr')
return layer
def processAlgorithm(self, parameters, context, feedback):
interpolationData = ParameterInterpolationData.parseValue(parameters[self.INTERPOLATION_DATA])
method = self.parameterAsEnum(parameters, self.METHOD, context)
columns = self.parameterAsInt(parameters, self.COLUMNS, context)
rows = self.parameterAsInt(parameters, self.ROWS, context)
bbox = self.parameterAsExtent(parameters, self.EXTENT, context)
output = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
if interpolationData is None:
raise QgsProcessingException(
self.tr('You need to specify at least one input layer.'))
layerData = []
layers = []
crs = QgsCoordinateReferenceSystem()
for row in interpolationData.split(';'):
v = row.split(',')
data = QgsInterpolator.LayerData()
# need to keep a reference until interpolation is complete
layer = QgsProcessingUtils.variantToSource(v[0], context)
data.source = layer
layers.append(layer)
if not crs.isValid():
crs = layer.sourceCrs()
data.valueSource = int(v[1])
data.interpolationAttribute = int(v[2])
if v[3] == '0':
data.sourceType = QgsInterpolator.SourcePoints
elif v[3] == '1':
data.sourceType = QgsInterpolator.SourceStructureLines
else:
data.sourceType = QgsInterpolator.SourceBreakLines
layerData.append(data)
if method == 0:
interpolationMethod = QgsTinInterpolator.Linear
else:
interpolationMethod = QgsTinInterpolator.CloughTocher
(triangulation_sink, triangulation_dest_id) = self.parameterAsSink(parameters, self.TRIANGULATION, context,
QgsTinInterpolator.triangulationFields(), QgsWkbTypes.LineString, crs)
interpolator = QgsTinInterpolator(layerData, interpolationMethod, feedback)
if triangulation_sink is not None:
interpolator.setTriangulationSink(triangulation_sink)
writer = QgsGridFileWriter(interpolator,
output,
bbox,
columns,
rows)
writer.writeFile(feedback)
return {self.OUTPUT: output, self.TRIANGULATION: triangulation_dest_id}
def processAlgorithm(self, parameters, context, feedback):
interpolationData = ParameterInterpolationData.parseValue(parameters[self.INTERPOLATION_DATA])
method = self.parameterAsEnum(parameters, self.METHOD, context)
columns = self.parameterAsInt(parameters, self.COLUMNS, context)
rows = self.parameterAsInt(parameters, self.ROWS, context)
bbox = self.parameterAsExtent(parameters, self.EXTENT, context)
output = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
if interpolationData is None:
raise QgsProcessingException(
self.tr('You need to specify at least one input layer.'))
layerData = []
layers = []
crs = QgsCoordinateReferenceSystem()
for row in interpolationData.split(';'):
v = row.split('::~::')
data = QgsInterpolator.LayerData()
# need to keep a reference until interpolation is complete
layer = QgsProcessingUtils.variantToSource(v[0], context)
data.source = layer
layers.append(layer)
if not crs.isValid():
crs = layer.sourceCrs()
data.valueSource = int(v[1])
data.interpolationAttribute = int(v[2])
if v[3] == '0':
data.sourceType = QgsInterpolator.SourcePoints
elif v[3] == '1':
data.sourceType = QgsInterpolator.SourceStructureLines
else:
data.sourceType = QgsInterpolator.SourceBreakLines
layerData.append(data)
if method == 0:
interpolationMethod = QgsTinInterpolator.Linear
else:
interpolationMethod = QgsTinInterpolator.CloughTocher
(triangulation_sink, triangulation_dest_id) = self.parameterAsSink(parameters, self.TRIANGULATION, context,
QgsTinInterpolator.triangulationFields(), QgsWkbTypes.LineString, crs)
interpolator = QgsTinInterpolator(layerData, interpolationMethod, feedback)
if triangulation_sink is not None:
interpolator.setTriangulationSink(triangulation_sink)
writer = QgsGridFileWriter(interpolator,
output,
bbox,
columns,
rows)
writer.writeFile(feedback)
return {self.OUTPUT: output, self.TRIANGULATION: triangulation_dest_id}
def get_crs_from_auth_and_code(auth, code):
"""
Get a CRS object from auth and code.
:param auth: SRS auth
:param code: SRS code
:return: QgsCoordinateReferenceSystem
"""
crs = QgsCoordinateReferenceSystem("{}:{}".format(auth, code))
return crs if crs.isValid() else get_ctm12_crs()
def checkIfCrsValid(crs):
try:
QgsCrs = QgsCoordinateReferenceSystem(crs)
if QgsCrs.isValid():
return True
else:
return False
except:
print(
"SCRIPT_ERROR An exception occurred while trying to check crs")
return False
def setUnitParameterValue(self, value):
units = QgsUnitTypes.DistanceUnknownUnit
layer = self.getLayerFromValue(value)
if isinstance(layer, QgsMapLayer):
units = layer.crs().mapUnits()
elif isinstance(value, QgsCoordinateReferenceSystem):
units = value.mapUnits()
elif isinstance(value, str):
crs = QgsCoordinateReferenceSystem(value)
if crs.isValid():
units = crs.mapUnits()
self.setUnits(units)
def setUnitParameterValue(self, value):
units = QgsUnitTypes.DistanceUnknownUnit
layer = self.getLayerFromValue(value)
if isinstance(layer, QgsMapLayer):
units = layer.crs().mapUnits()
elif isinstance(value, QgsCoordinateReferenceSystem):
units = value.mapUnits()
elif isinstance(value, str):
crs = QgsCoordinateReferenceSystem(value)
if crs.isValid():
units = crs.mapUnits()
self.setUnits(units)
def restore_configuration(self):
# takes settings from QSettings and provides it to the gui (not the configuration)
settings = QSettings()
srs_auth = settings.value("QgisModelBaker/ili2db/srs_auth", "EPSG")
srs_code = settings.value("QgisModelBaker/ili2db/srs_code", 2056, int)
crs = QgsCoordinateReferenceSystem("{}:{}".format(srs_auth, srs_code))
if not crs.isValid():
crs = QgsCoordinateReferenceSystem(srs_code) # Fallback
self.crs = crs
self._update_crs_info()
self._crs_changed()
self._fill_toml_file_info_label()
self._update_models_dependent_info()
def testCrsConversion(self):
self.assertFalse(GdalUtils.gdal_crs_string(QgsCoordinateReferenceSystem()))
self.assertEqual(GdalUtils.gdal_crs_string(QgsCoordinateReferenceSystem('EPSG:3111')), 'EPSG:3111')
self.assertEqual(GdalUtils.gdal_crs_string(QgsCoordinateReferenceSystem('POSTGIS:3111')), 'EPSG:3111')
self.assertEqual(GdalUtils.gdal_crs_string(QgsCoordinateReferenceSystem(
'proj4: +proj=utm +zone=36 +south +a=6378249.145 +b=6356514.966398753 +towgs84=-143,-90,-294,0,0,0,0 +units=m +no_defs')),
'EPSG:20936')
crs = QgsCoordinateReferenceSystem()
crs.createFromProj4(
'+proj=utm +zone=36 +south +a=600000 +b=70000 +towgs84=-143,-90,-294,0,0,0,0 +units=m +no_defs')
self.assertTrue(crs.isValid())
self.assertEqual(GdalUtils.gdal_crs_string(crs),
'+proj=utm +zone=36 +south +a=600000 +b=70000 +towgs84=-143,-90,-294,0,0,0,0 +units=m +no_defs')
def testCrsConversion(self):
self.assertFalse(GdalUtils.gdal_crs_string(QgsCoordinateReferenceSystem()))
self.assertEqual(GdalUtils.gdal_crs_string(QgsCoordinateReferenceSystem('EPSG:3111')), 'EPSG:3111')
self.assertEqual(GdalUtils.gdal_crs_string(QgsCoordinateReferenceSystem('POSTGIS:3111')), 'EPSG:3111')
self.assertEqual(GdalUtils.gdal_crs_string(QgsCoordinateReferenceSystem(
'proj4: +proj=utm +zone=36 +south +a=6378249.145 +b=6356514.966398753 +towgs84=-143,-90,-294,0,0,0,0 +units=m +no_defs')),
'EPSG:20936')
crs = QgsCoordinateReferenceSystem()
crs.createFromProj4(
'+proj=utm +zone=36 +south +a=600000 +b=70000 +towgs84=-143,-90,-294,0,0,0,0 +units=m +no_defs')
self.assertTrue(crs.isValid())
self.assertEqual(GdalUtils.gdal_crs_string(crs),
'+proj=utm +zone=36 +south +a=600000 +b=70000 +towgs84=-143,-90,-294,0,0,0,0 +units=m +no_defs')
def _load_crs_from_metaconfig(self, ili2db_metaconfig):
srs_auth = self.srs_auth
srs_code = self.srs_code
if "defaultSrsAuth" in ili2db_metaconfig:
srs_auth = ili2db_metaconfig.get("defaultSrsAuth")
if "defaultSrsCode" in ili2db_metaconfig:
srs_code = ili2db_metaconfig.get("defaultSrsCode")
crs = QgsCoordinateReferenceSystem("{}:{}".format(srs_auth, srs_code))
if not crs.isValid():
crs = QgsCoordinateReferenceSystem(srs_code) # Fallback
self.crs = crs
self._update_crs_info()
self._crs_changed()
def wkt_to_geometry(wkt: str) -> Geometry:
""" Convert wkt to qgis geometry
Handle CRS= prefix
"""
m = WKT_EXPR.match(wkt)
if m:
g = QgsGeometry.fromWkt(m.groups('')[1])
if not g.isNull():
crs = QgsCoordinateReferenceSystem(m.groups('')[0])
if crs.isValid():
g = QgsReferencedGeometry(g, crs)
return g
raise InvalidParameterValue("Invalid wkt format")
def exec_(self):
proj = QgsProject.instance()
self.outputDir.setFile(proj.readEntry("gmsh", "shp_directory", "")[0])
self.inputMsh.setFile(proj.readEntry("gmsh", "msh_file", "")[0])
self.importShpBox.setCheckState(Qt.Checked if proj.readBoolEntry(
"gmsh", "import_shp", True)[0] else Qt.Unchecked)
self.runLayout.setFocus()
projid = proj.readEntry("gmsh", "projection", "")[0]
crs = None
if projid:
crs = QgsCoordinateReferenceSystem(projid)
if crs is None or not crs.isValid():
crs = QgsCoordinateReferenceSystem("EPSG:4326")
self.projectionButton.setCrs(crs)
super(Dialog, self).exec_()
def crs(self, _crs: QgsCoordinateReferenceSystem) -> None:
"""
gets / sets the Reference System in QGIS format
:return: current coordinate reference system
:raises TypeError: if crs is an instance of QgsCoordinateReferenceSystem
"""
self.__validate()
if not isinstance(_crs, QgsCoordinateReferenceSystem):
raise TypeError(
"committed value is not of type QgsCoordinateReferenceSystem!")
if not _crs.isValid():
raise ValueError("committed reference system is not valid")
self.dockwidget.reference.setCrs(_crs)
def gml_to_geometry(gml: str) -> Geometry:
""" Handle json to qgis geometry
"""
# Lookup for srsName
geom = ogr.CreateGeometryFromGML(gml)
if not geom:
raise InvalidParameterValue("Invalid gml format")
geom = QgsGeometry.fromWkt(geom.ExportToWkt())
# Check for crs
m = SRSNAME_EXPR.search(gml)
if m:
crs = QgsCoordinateReferenceSystem(m.groups('')[0])
if crs.isValid():
geom = QgsReferencedGeometry(geom, crs)
return geom
def create_transforms(self):
# this should happen in the main thread
self.crs = self.settings.value('crs')
if self.crs == 'project':
map_crs = self.map_canvas.mapSettings().destinationCrs()
if map_crs.isValid():
self.crs = map_crs.authid().split(':')[1]
if self.crs not in AVAILABLE_CRS:
self.crs = '2056'
assert self.crs in AVAILABLE_CRS
src_crs_ch = QgsCoordinateReferenceSystem('EPSG:{}'.format(self.crs))
assert src_crs_ch.isValid()
dst_crs = self.map_canvas.mapSettings().destinationCrs()
self.transform_ch = QgsCoordinateTransform(src_crs_ch, dst_crs, QgsProject.instance())
src_crs_4326 = QgsCoordinateReferenceSystem('EPSG:4326')
self.transform_4326 = QgsCoordinateTransform(src_crs_4326, dst_crs, QgsProject.instance())
def json_to_geometry(data: str) -> Geometry:
""" Handle json to qgis geometry
"""
try:
data = json.loads(data)
crs = data.get('crs')
if crs:
crs = QgsCoordinateReferenceSystem(crs['properties']['name'])
data = data['geometry']
geom = ogr.CreateGeometryFromJson(json.dumps(data))
if geom:
geom = QgsGeometry.fromWkt(geom.ExportToWkt())
if crs and crs.isValid():
geom = QgsReferencedGeometry(geom, crs)
return geom
except (json.JSONDecodeError, KeyError) as err:
LOGGER.error("Error decoding json input: %s", err)
raise InvalidParameterValue("Invalid geojson format")
def read(self, layername, allow_empty=False, force_zip=False):
"""
Create a QGIS vector layer for a Cadastre layername. Derives the GML
filename from layername. Downloads the file if not is present. First try
to read the ZIP file, if fails try with the GML file.
Args:
layername (str): Short name of the Cadastre layer. Any of
'building', 'buildingpart', 'otherconstruction',
'cadastralparcel', 'cadastralzoning', 'address',
'thoroughfarename', 'postaldescriptor', 'adminunitname'
allow_empty (bool): If False (default), raise a exception for empty
layer, else returns None
force_zip (bool): Force to use ZIP file.
Returns:
QgsVectorLayer: Vector layer.
"""
(md_path, gml_path, zip_path, group) = self.get_layer_paths(layername)
url = setup.prov_url[group].format(code=self.prov_code)
if not os.path.exists(zip_path) and (not os.path.exists(gml_path)
or force_zip):
self.get_atom_file(url)
self.get_metadata(md_path, zip_path)
if self.is_empty(gml_path, zip_path):
if not allow_empty:
raise IOError(_("The layer '%s' is empty") % gml_path)
else:
log.info(_("The layer '%s' is empty"), gml_path)
return None
gml = self.get_gml_from_zip(gml_path, zip_path, group, layername)
if gml is None:
gml = layer.BaseLayer(gml_path, layername + '.gml', 'ogr')
if not gml.isValid():
raise IOError(_("Failed to load layer '%s'") % gml_path)
crs = QgsCoordinateReferenceSystem(self.crs_ref)
if not crs.isValid():
raise IOError(_("Could not determine the CRS of '%s'") % gml_path)
gml.setCrs(crs)
log.info(_("Read %d features in '%s'"), gml.featureCount(), gml_path)
gml.source_date = self.src_date
return gml
def reprojectToCrs(x, y, sourceCrs, destinationCrs=CH_CRS):
if isinstance(sourceCrs, str):
sourceCrs = QgsCoordinateReferenceSystem(sourceCrs)
if isinstance(destinationCrs, str):
destinationCrs = QgsCoordinateReferenceSystem(destinationCrs)
# Do not reproject if data is already in destinationCrs
if sourceCrs == destinationCrs or not destinationCrs.isValid():
return
transformer = QgsCoordinateTransform(sourceCrs, destinationCrs,
QgsProject.instance())
xnew = np.copy(x)
ynew = np.copy(y)
for i in range(len(x)):
point = QgsPoint(x[i], y[i])
point.transform(transformer)
xnew[i] = point.x()
ynew[i] = point.y()
return xnew, ynew
def transformCrs(self):
""" Transform the actual crs to EPSG:4326 if the actual crs is not EPSG:4326 itself """
# Get map canvas extent (W, E, N, S)
self.e = self.iface.mapCanvas().extent()
if self.dlg.system_box.currentText(
) == "EPSG:4326" and self.crs.authid() != "EPSG:4326":
crsSrc = QgsCoordinateReferenceSystem(str(self.crs.authid()))
if not crsSrc.isValid():
self.iface.messageBar().pushMessage(
self.tr(u"Error"),
self.tr(u"{} is not valid SRS.").format(self.crs.authid()),
level=QgsMessageBar.CRITICAL,
duration=3)
return
crsDest = QgsCoordinateReferenceSystem("EPSG:4326")
tr = QgsCoordinateTransform(crsSrc, crsDest)
self.e = tr.transform(self.e)
def features_to_geojson(self):
"""Converts a qgis Feature geometry to GeoJSON format."""
# Coordinate transform -> EPSG 4326
target_crs = QgsCoordinateReferenceSystem(
4326, QgsCoordinateReferenceSystem.EpsgCrsId)
if not target_crs.isValid():
QMessageBox.critical(self.dlg, 'Error',
u"Error creating target CRS.")
return False
xform = QgsCoordinateTransform(self.crs, target_crs)
geojson_features = []
for f in self.features:
geom = f.geometry()
""" Access relevant params. Could be useful in future.
self.perimeter = geom.length()
self.area = geom.area()
self.convex_hull_area = geom.convexHull().area()
# We can't calculate minimum bounding circle easily in QGIS.
# Can we maybe calculate largest distance from centroid to edge?
"""
if geom.transform(xform) != 0:
QMessageBox.critical(self.dlg, 'Error',
u"Error transforming CRS.")
return False
geojson_features.append({
'geometry':
json.loads(geom.exportToGeoJSON()),
'properties': {},
'type':
'Feature'
})
self.geojson = {
'type': 'FeatureCollection',
'features': geojson_features
}
return True
def reprojectToCrs(self, destinationCrs):
if isinstance(destinationCrs, str):
destinationCrs = QgsCoordinateReferenceSystem(destinationCrs)
if not destinationCrs:
destinationCrs = QgsCoordinateReferenceSystem(CH_CRS)
# Do not reproject if data is already in destinationCrs
if self.spatialRef == destinationCrs or not destinationCrs.isValid():
return
# If original spatial ref was not valid (empty), set the destination
# CRS as new spatial reference
if not self.spatialRef.isValid():
self.spatialRef = destinationCrs
return
xnew, ynew = reprojectToCrs(self.surveyPoints['x'],
self.surveyPoints['y'], self.spatialRef,
destinationCrs)
self.surveyPoints['x'] = xnew
self.surveyPoints['y'] = ynew
self.spatialRef = destinationCrs
self.projectOnLine()
def makeCoordinateReferenceSystem(latitude, utmZone):
"""
Creates a coordinate reference system, for instance for converting to this system.
Args:
param1: The WGS84 latitude.
param2: The UTM zone number.
Returns:
A valid QgsCoordinateReferenceSystem or None
>>> makeCoordinateReferenceSystem(13.41250188, 48) #doctest: +ELLIPSIS
<qgis._core.QgsCoordinateReferenceSystem object at 0x...>
>>> makeCoordinateReferenceSystem(13.41250188, 21442) is None
True
"""
crs = QgsCoordinateReferenceSystem()
proj4String = "+proj=utm +ellps=WGS84 +datum=WGS84 +units=m +zone=%s" % utmZone
if latitude < 0:
proj4String += " +south"
result = crs.createFromProj4(proj4String)
return crs if result and crs.isValid() else None
def create(self):
if self.__layer is None:
layer_name = self.alias or self.name
settings = QSettings()
# Take the "CRS for new layers" config, overwrite it while loading layers and...
old_proj_value = settings.value("/Projections/defaultBehaviour",
"prompt",
type=str)
settings.setValue("/Projections/defaultBehaviour", "useProject")
self.__layer = QgsVectorLayer(self.uri, layer_name, self.provider)
settings.setValue("/Projections/defaultBehavior", old_proj_value)
if (self.srid is not None and not self.__layer.crs().authid()
== "EPSG:{}".format(self.srid)):
crs = QgsCoordinateReferenceSystem().fromEpsgId(self.srid)
if not crs.isValid():
crs = QgsCoordinateReferenceSystem(self.srid) # Fallback
self.__layer.setCrs(crs)
if self.is_domain or self.is_dataset_table:
self.__layer.setReadOnly()
if self.display_expression:
self.__layer.setDisplayExpression(self.display_expression)
if self.coordinate_precision and self.coordinate_precision < 1:
self.__layer.geometryOptions().setGeometryPrecision(
self.coordinate_precision)
self.__layer.geometryOptions().setRemoveDuplicateNodes(True)
if self.model_topic_name:
QgsExpressionContextUtils.setLayerVariable(
self.__layer, "interlis_topic", self.model_topic_name)
for field in self.fields:
field.create(self)
return self.__layer
def area_crs(crs_id, feature, parent, context):
"""
<h4>Return</h4>Area using the CRS ID
<p><h4>Syntax</h4>area_crs(CRS ID)</p>
<p><h4>Argument</h4>CRS ID</p>
<p><h4>Example</h4>area_crs('EPSG:5671')</p>
"""
geom = QgsGeometry(feature.geometry())
if not isinstance(crs_id, str):
raise Exception("Enter with ID CRS with string type(Ex.: 'EPSG:4326')")
crsDest = QgsCoordinateReferenceSystem(crs_id)
if not crsDest.isValid():
msg = "ID EPSG '{}' is not valid".format(crs_id)
raise Exception(msg)
if crsDest.isGeographic():
msg = "ID CRS '{}' is Geographic".format(crs_id)
raise Exception(msg)
layer_id = context.variable('layer_id')
crsLayer = getCRSLayer(layer_id)
if not crsDest == crsLayer:
ct = QgsCoordinateTransform(crsLayer, crsDest,
QgsCoordinateTransformContext())
geom.transform(ct)
return geom.area()
def read_settings(self):
"""Set the IF state from QSettings."""
extent = setting('user_extent', None, str)
if extent:
extent = QgsGeometry.fromWkt(extent)
if not extent.isGeosValid():
extent = None
crs = setting('user_extent_crs', None, str)
if crs:
crs = QgsCoordinateReferenceSystem(crs)
if not crs.isValid():
crs = None
mode = setting('analysis_extents_mode', HAZARD_EXPOSURE_VIEW)
if crs and extent and mode == HAZARD_EXPOSURE_BOUNDINGBOX:
self.extent.set_user_extent(extent, crs)
self.extent.show_rubber_bands = setting('showRubberBands', False, bool)
self.zoom_to_impact_flag = setting('setZoomToImpactFlag', True, bool)
# whether exposure layer should be hidden after model completes
self.hide_exposure_flag = setting('setHideExposureFlag', False, bool)
def processAlgorithm(self, parameters, context, feedback):
interpolationData = ParameterInterpolationData.parseValue(parameters[self.INTERPOLATION_DATA])
method = self.parameterAsEnum(parameters, self.METHOD, context)
columns = self.parameterAsInt(parameters, self.COLUMNS, context)
rows = self.parameterAsInt(parameters, self.ROWS, context)
cellsizeX = self.parameterAsDouble(parameters, self.CELLSIZE_X, context)
cellsizeY = self.parameterAsDouble(parameters, self.CELLSIZE_Y, context)
bbox = self.parameterAsExtent(parameters, self.EXTENT, context)
output = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
if interpolationData is None:
raise QgsProcessingException(
self.tr('You need to specify at least one input layer.'))
if cellsizeX == 0.0 or cellsizeY == 0.0:
raise QgsProcessingException(
self.tr('Cellsize should be greater than 0.'))
layerData = []
layers = []
crs = QgsCoordinateReferenceSystem()
for row in interpolationData.split(';'):
v = row.split(',')
data = QgsInterpolator.LayerData()
# need to keep a reference until interpolation is complete
layer = QgsProcessingUtils.mapLayerFromString(v[0], context)
data.vectorLayer = layer
layers.append(layer)
if not crs.isValid():
crs = layer.crs()
data.zCoordInterpolation = bool(v[1])
data.interpolationAttribute = int(v[2])
if v[3] == '0':
data.mInputType = QgsInterpolator.POINTS
elif v[3] == '1':
data.mInputType = QgsInterpolator.STRUCTURE_LINES
else:
data.mInputType = QgsInterpolator.BREAK_LINES
layerData.append(data)
if method == 0:
interpolationMethod = QgsTINInterpolator.Linear
else:
interpolationMethod = QgsTINInterpolator.CloughTocher
(triangulation_sink, triangulation_dest_id) = self.parameterAsSink(parameters, self.TRIANGULATION, context,
QgsTINInterpolator.triangulationFields(), QgsWkbTypes.LineString, crs)
interpolator = QgsTINInterpolator(layerData, interpolationMethod, feedback)
if triangulation_sink is not None:
interpolator.setTriangulationSink(triangulation_sink)
writer = QgsGridFileWriter(interpolator,
output,
bbox,
columns,
rows,
cellsizeX,
cellsizeY)
writer.writeFile(feedback)
return {self.OUTPUT: output, self.TRIANGULATION: triangulation_dest_id}
def processAlgorithm(self, parameters, context, feedback):
interpolationData = ParameterInterpolationData.parseValue(parameters[self.INTERPOLATION_DATA])
method = self.parameterAsEnum(parameters, self.METHOD, context)
columns = self.parameterAsInt(parameters, self.COLUMNS, context)
rows = self.parameterAsInt(parameters, self.ROWS, context)
cellsizeX = self.parameterAsDouble(parameters, self.CELLSIZE_X, context)
cellsizeY = self.parameterAsDouble(parameters, self.CELLSIZE_Y, context)
bbox = self.parameterAsExtent(parameters, self.EXTENT, context)
output = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
if interpolationData is None:
raise QgsProcessingException(
self.tr('You need to specify at least one input layer.'))
if cellsizeX == 0.0 or cellsizeY == 0.0:
raise QgsProcessingException(
self.tr('Cellsize should be greater than 0.'))
layerData = []
layers = []
crs = QgsCoordinateReferenceSystem()
for row in interpolationData.split(';'):
v = row.split(',')
data = QgsInterpolator.LayerData()
# need to keep a reference until interpolation is complete
layer = QgsProcessingUtils.mapLayerFromString(v[0], context)
data.vectorLayer = layer
layers.append(layer)
if not crs.isValid():
crs = layer.crs()
data.zCoordInterpolation = bool(v[1])
data.interpolationAttribute = int(v[2])
if v[3] == '0':
data.mInputType = QgsInterpolator.POINTS
elif v[3] == '1':
data.mInputType = QgsInterpolator.STRUCTURE_LINES
else:
data.mInputType = QgsInterpolator.BREAK_LINES
layerData.append(data)
if method == 0:
interpolationMethod = QgsTINInterpolator.Linear
else:
interpolationMethod = QgsTINInterpolator.CloughTocher
(triangulation_sink, triangulation_dest_id) = self.parameterAsSink(parameters, self.TRIANGULATION, context,
QgsTINInterpolator.triangulationFields(), QgsWkbTypes.LineString, crs)
interpolator = QgsTINInterpolator(layerData, interpolationMethod, feedback)
if triangulation_sink is not None:
interpolator.setTriangulationSink(triangulation_sink)
writer = QgsGridFileWriter(interpolator,
output,
bbox,
columns,
rows,
cellsizeX,
cellsizeY)
writer.writeFile(feedback)
return {self.OUTPUT: output, self.TRIANGULATION: triangulation_dest_id}
""""
https://docs.qgis.org/2.18/en/docs/pyqgis_developer_cookbook/crs.html
"""
from qgis.core import QgsCoordinateReferenceSystem
from osgeo import osr
if __name__ == '__console__':
print("-----------------------------------------------\n\n")
# PostGIS SRID 4326 is allocated for WGS84
# If not specified otherwise in second parameter, PostGIS SRID is used by default.
crs = QgsCoordinateReferenceSystem(4326, QgsCoordinateReferenceSystem.PostgisCrsId)
print("Valid: ", crs.isValid())
print("QGIS CRS ID:", crs.srsid())
print("EPSG ID:", crs.authid())
print("Description:", crs.description())
print("Projection Acronym:", crs.projectionAcronym())
print("Ellipsoid Acronym:", crs.ellipsoidAcronym())
print("Proj4 String:", crs.toProj4())
# check whether it's geographic or projected coordinate system
print("Is geographic:", crs.geographicFlag())
# check type of map units in this CRS (values defined in QGis::units enum)
print("Map units:", crs.mapUnits())
print("-----------------------------------------------\n\n")
wkt = '''GEOGCS["WGS84", DATUM["WGS84", SPHEROID["WGS84", 6378137.0, 298.257223563]],
PRIMEM["Greenwich", 0.0],
UNIT["degree", 0.017453292519943295],
AXIS["Longitude", EAST], AXIS["Latitude", NORTH]]'''
crs = QgsCoordinateReferenceSystem(wkt)
print("Valid: ", crs.isValid())
def _init_qgis_map(self, crs_string):
crs = QgsCoordinateReferenceSystem(crs_string)
if not crs.isValid():
crs = QgsCoordinateReferenceSystem("EPSG:3857")
self.iface.mapCanvas().setDestinationCrs(crs)
