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)