def testSaveFields(self): # Create a new memory layer with no fields myMemoryLayer = QgsVectorLayer(('Point?crs=epsg:4326&index=yes'), 'test', 'memory') # Add some fields to the layer myFields = [ QgsField('TestInt', QVariant.Int, 'integer', 2, 0), QgsField('TestDbl', QVariant.Double, 'double', 8, 6), QgsField('TestString', QVariant.String, 'string', 50, 0), QgsField('TestDate', QVariant.Date, 'date'), QgsField('TestTime', QVariant.Time, 'time'), QgsField('TestDateTime', QVariant.DateTime, 'datetime') ] assert myMemoryLayer.startEditing() for f in myFields: assert myMemoryLayer.addAttribute(f) assert myMemoryLayer.commitChanges() myMemoryLayer.updateFields() # Export the layer to a layer-definition-XML qlr = QgsMapLayer.asLayerDefinition([myMemoryLayer]) assert qlr is not None # Import the layer from the layer-definition-XML layers = QgsMapLayer.fromLayerDefinition(qlr) assert layers is not None myImportedLayer = layers[0] assert myImportedLayer is not None # Check for the presence of the fields importedFields = myImportedLayer.fields() assert importedFields is not None for f in myFields: assert f == importedFields.field(f.name())
def add_layer(layer: QgsMapLayer, name: str = None, index: int = -1, color: typing.Tuple[int, int, int] = None, size: float = None, file: str = None, parent: QgsLayerTreeNode = None, show_feature_count: bool = True) -> None: if name: layer.setName(name) if isinstance(layer, QgsVectorLayer): if color or size or file: update_symbology(layer, color=color, size=size, file=file) elif isinstance(layer, QgsRasterLayer): # TODO update symbology pass instance = QgsProject.instance() instance.addMapLayer(layer, False) layerTreeNode = QgsLayerTreeLayer(layer) layerTreeNode.setCustomProperty('showFeatureCount', show_feature_count) parent = parent if parent else instance.layerTreeRoot() parent.insertChildNode(index, layerTreeNode)
def testSaveFields(self): # Create a new memory layer with no fields myMemoryLayer = QgsVectorLayer( ('Point?crs=epsg:4326&index=yes'), 'test', 'memory') # Add some fields to the layer myFields = [QgsField('TestInt', QVariant.Int, 'integer', 2, 0), QgsField('TestDbl', QVariant.Double, 'double', 8, 6), QgsField('TestString', QVariant.String, 'string', 50, 0), QgsField('TestDate', QVariant.Date, 'date'), QgsField('TestTime', QVariant.Time, 'time'), QgsField('TestDateTime', QVariant.DateTime, 'datetime')] assert myMemoryLayer.startEditing() for f in myFields: assert myMemoryLayer.addAttribute(f) assert myMemoryLayer.commitChanges() myMemoryLayer.updateFields() # Export the layer to a layer-definition-XML qlr = QgsMapLayer.asLayerDefinition([myMemoryLayer]) assert qlr is not None # Import the layer from the layer-definition-XML layers = QgsMapLayer.fromLayerDefinition(qlr) assert layers is not None myImportedLayer = layers[0] assert myImportedLayer is not None # Check for the presence of the fields importedFields = myImportedLayer.fields() assert importedFields is not None for f in myFields: assert f == importedFields.field(f.name())
def startConvert(self, layer: QgsMapLayer): layerName = layer.name() nodeCoorDict = OrderedDict() graph = nx.Graph() if layerName: features = layer.getFeatures() count = 0 for feature in features: if count > 10: break geom = feature.geometry() geomSingleType = QgsWkbTypes.isSingleType(geom.wkbType()) if geom.type() == QgsWkbTypes.PolygonGeometry: if geomSingleType: polygon = geom.asPolygon() else: multiPolygon = geom.asMultiPolygon() for polygon in multiPolygon: nodeCoorDict = self.parsePolygon2Network( polygon, nodeCoorDict, graph) count = count + 1 ''' plt.subplot(121) nx.draw(graph, with_labels=True, font_weight='bold') plt.show() ''' return nodeCoorDict
def testSaveFields(self): # Create a new memory layer with no fields myMemoryLayer = QgsVectorLayer(("Point?crs=epsg:4326&index=yes"), "test", "memory") # Add some fields to the layer myFields = [ QgsField("TestInt", QVariant.Int, "integer", 2, 0), QgsField("TestLong", QVariant.LongLong, "long", -1, 0), QgsField("TestDbl", QVariant.Double, "double", 8, 6), QgsField("TestString", QVariant.String, "string", 50, 0), QgsField("TestDate", QVariant.Date, "date"), QgsField("TestTime", QVariant.Time, "time"), QgsField("TestDateTime", QVariant.DateTime, "datetime"), ] assert myMemoryLayer.startEditing() for f in myFields: assert myMemoryLayer.addAttribute(f) assert myMemoryLayer.commitChanges() myMemoryLayer.updateFields() # Export the layer to a layer-definition-XML qlr = QgsMapLayer.asLayerDefinition([myMemoryLayer]) assert qlr is not None # Import the layer from the layer-definition-XML layers = QgsMapLayer.fromLayerDefinition(qlr) assert layers is not None myImportedLayer = layers[0] assert myImportedLayer is not None # Check for the presence of the fields importedFields = myImportedLayer.fields() assert importedFields is not None for f in myFields: assert f == importedFields.field(f.name())
def get_centroid_from_polygon(layerName): """Getting centroid from the polygon.""" layerName = "INTERIOR" layer = QgsMapLayer.instance().mapLayersByName(layerName)[0] print("layer.name---->", layer.name()) epsg = layer.crs().postgisSrid() uri = "Point?crs=epsg:" + str(epsg) + "&field=id:integer" "&index=yes" mem_layer = QgsVectorLayer(uri, 'point', 'memory') prov = mem_layer.dataProvider() i = 0 for f in layer.getFeatures(): feat = QgsFeature() pt = f.geometry().centroid().asPoint() print("pt---->", pt) feat.setAttributes([i]) feat.setGeometry(QgsGeometry.fromPoint(pt)) prov.addFeatures([feat]) i += 1 QgsMapLayer.instance().addMapLayer(mem_layer)
def fetch_and_apply_style(layer: QgsMapLayer, url: str, style_attr: str = '') -> Optional[str]: """ Fetches a QML style from the specified URL, and applies it to a layer. @param layer: target layer to apply style to @param url: URL for QML content @param style_attr: optional str specifying name of existing field in layer to automatically update classified references to @return: Returns a str if an error occurred, or None if the fetch and apply was successful """ request = QgsBlockingNetworkRequest() if request.get(QNetworkRequest( QUrl(url))) != QgsBlockingNetworkRequest.NoError: return 'Error while fetching QML style: {}'.format( request.errorMessage()) reply = request.reply().content() tmp_file = QTemporaryFile('{}/XXXXXX.qml'.format(QDir.tempPath())) tmp_file.open() tmp_file_name = tmp_file.fileName() tmp_file.close() with open(tmp_file_name, 'wt', encoding='utf8') as f: f.write(reply.data().decode()) layer.loadNamedStyle(tmp_file_name) if style_attr: StyleUtils.update_class_attribute(layer, style_attr) layer.triggerRepaint() return None
def __init__(self, level: Level, feedback_result: FeedbackResult, layer: QgsMapLayer = None) -> None: self.level = level self.message = feedback_result.message self.layer_id = layer.id() if layer else None self.layer_name = layer.name() if layer else None
def layer_summary(layer_id: str, layer: QgsMapLayer): return dict( id=layer_id, name=layer.name(), source=layer.publicSource(), crs=layer.crs().userFriendlyIdentifier(), valid=layer.isValid(), spatial=layer.isSpatial(), )
def is_compatible_with_layer(self, layer: QgsMapLayer, is_editable: bool): if layer is None: return False if layer.type() != QgsMapLayerType.VectorLayer: return False return layer.geometryType( ) == QgsWkbTypes.PointGeometry and is_editable
def add_report_to_layer(report: typing.Dict, layer: QgsMapLayer): history_msg = (f'{report["generated"]} - Validation report: ' f'{"Valid" if report["dataset_is_valid"] else "Invalid"}') abstract_msg = utils.serialize_report_to_plain_text(report) metadata: QgsLayerMetadata = layer.metadata() history: typing.List = metadata.history() history.append(history_msg) abstract: str = metadata.abstract() abstract = "\n\n---\n\n".join((abstract, abstract_msg)) metadata.setAbstract(abstract) metadata.setHistory(history) layer.setMetadata(metadata)
def layer_name_source(layer: QgsMapLayer) -> Tuple[str, str]: """ Returns the name and the source path of the layer. :param layer: the layer from which to extract name and source. :type layer: QgsMapLayer. :return: the layer name and source. :rtype: tuple of two strings. Examples: """ return layer.name(), layer.source()
def startConvert(self,layer:QgsMapLayer): layerName = layer.name() nodeCoorDict = OrderedDict() graph = nx.Graph() if layerName: features_forCounts = layer.getFeatures() # type:QgsFeatureIterator # 记录当前处理的polygon id编号 plyId = 0 count = 0 feaNums = sum(1 for _ in features_forCounts) #此时已经迭代过了 features = layer.getFeatures() # type:QgsFeatureIterator pbar = self.dlg.progressBar # type:QProgressBar pbar.setRange(0, feaNums) print(feaNums) for feature in features: #if count >= 10: # break geom = feature.geometry() geomSingleType = QgsWkbTypes.isSingleType(geom.wkbType()) if geom.type() == QgsWkbTypes.PolygonGeometry: if geomSingleType: polygon = geom.asPolygon() nodeCoorDict, graph = self.parsePolygon2Network(polygon, nodeCoorDict, graph, plyId=plyId) plyId = plyId + 1 else: multiPolygon = geom.asMultiPolygon() for polygon in multiPolygon: nodeCoorDict,graph = self.parsePolygon2Network(polygon,nodeCoorDict,graph,plyId=plyId) plyId = plyId + 1 pbar.setValue(count) count = count + 1 #print("complete!") #plt.subplot(121) #print(nodeCoorDict) ''' # 每个节点坐标,绘制带坐标的图 pos = list(nodeCoorDict.values()) #nx.draw(graph,pos, with_labels=True) nx.draw(graph, pos,node_size=20) nx.fruchterman_reingold_layout(graph) plt.show() ''' print('all complete') pbar.setValue(feaNums) return nodeCoorDict,graph,True
def on_current_layer_changed(self, map_layer: QgsMapLayer) -> None: """ slot for checking selection changes :param map_layer: :return: Nothing """ if self.__active_layer is not None: try: self.__active_layer.geometryChanged.disconnect( self.on_geometry_changed) self.__active_layer.selectionChanged.disconnect( self.on_active_layer_selection_changed) except AttributeError: pass except TypeError: pass if (map_layer is None) or (map_layer.type() != QgsMapLayer.VectorLayer): self.__active_layer = None else: self.__active_layer = map_layer self.__active_layer.geometryChanged.connect( self.on_geometry_changed) self.__active_layer.selectionChanged.connect( self.on_active_layer_selection_changed) self._parse_selection()
def enable_actions_for_layer(self, layer: QgsMapLayer, forced_edit_state=None): """ Toggles whether actions should be enabled for the specified layer """ is_editable = forced_edit_state if is_editable is None: if isinstance(layer, QgsVectorLayer): is_editable = layer.isEditable() else: is_editable = False for action in self.actions: if sip.isdeleted(action): continue if self.tools.get(action.data()): tool = self.tools[action.data()] action.setEnabled( tool.is_compatible_with_layer(layer, is_editable)) if tool == self.active_tool and not action.isEnabled(): self.iface.mapCanvas().unsetMapTool(tool) self.iface.actionPan().trigger()
def update_symbology(layer: QgsMapLayer, color: typing.Tuple[int, int, int] = None, size: float = None, file: str = None) -> None: assert layer, 'Layer is not defined' if file: assert isinstance(file, str) (msg, noError) = layer.loadNamedStyle(file) if not noError: raise Exception(msg) renderer = layer.renderer() symbol = None if isinstance(renderer, QgsSingleSymbolRenderer): symbol = renderer.symbol() elif isinstance(renderer, QgsGraduatedSymbolRenderer): symbol = renderer.sourceSymbol() else: raise Exception('Unknown renderer!') if color: assert isinstance( color, collections.abc.Sequence ), 'Color should be a iteratable of three numbers for Red, Green, Blue; Each of them between 0 and 255' assert len(color) in ( 3, 4 ), 'There should be three numbers passed for Red, Green, Blue; Each of them between 0 and 255' symbol.setColor(QColor.fromRgb(*color)) if size: # For lines if type(symbol) == QgsLineSymbol: symbol.setWidth(size) # For points if type(symbol) == QgsMarkerSymbol: symbol.setSize(size) layer.triggerRepaint() iface.layerTreeView().refreshLayerSymbology(layer.id())
def print_layer_name(self, layer: QgsMapLayer): try: LOGGER.info(tr("Printing layer name"), extra=bar_msg(tr("Layer name is {}", layer.name()))) except: raise QgsPluginException("Error occured", bar_msg("Select layer first!"))
def check_layer_is_geopackage(layer: QgsMapLayer) -> Tuple[bool, str]: if not layer: return False, 'La couche est invalide' testing = os.environ.get('TESTING_MERCICOR', '') if testing == 'True': return True, '' uri = QgsProviderRegistry.instance().decodeUri('ogr', layer.source()) if not uri['path'].lower().endswith('.gpkg') or not uri['layerName']: message = ( 'La couche doit être le geopackage de la zone d\'étude et non pas {}' .format(layer.source())) return False, message return True, ''
def addLayers(self, layers): """Handle layers being added to the registry so they show up in canvas. :param layers: list<QgsMapLayer> list of map layers that were added .. note:: The QgsInterface api does not include this method, it is added here as a helper to facilitate testing. """ #LOGGER.debug('addLayers called on qgis_interface') #LOGGER.debug('Number of layers being added: %s' % len(layers)) #LOGGER.debug('Layer Count Before: %s' % len(self.canvas.layers())) current_layers = self.canvas.layers() final_layers = [] for layer in current_layers: final_layers.append(QgsMapLayer(layer)) for layer in layers: final_layers.append(QgsMapLayer(layer)) self.canvas.setLayerSet(final_layers)
def getConnectionParameterFromDbLayer(layer: QgsMapLayer) -> Dict[str,str]: ''' Get connection parameters from the layer datasource ''' connectionParams = None if layer.providerType() == 'postgres': dbType = 'postgis' else: dbType = 'spatialite' src = layer.source() try: uri = QgsDataSourceUri(src) except: uri = QgsDataSourceURI(src) # TODO Use immutable namedtuple connectionParams = { 'service' : uri.service(), 'dbname' : uri.database(), 'host' : uri.host(), 'port': uri.port(), 'user' : uri.username(), 'password': uri.password(), 'sslmode' : uri.sslMode(), 'key': uri.keyColumn(), 'estimatedmetadata' : str(uri.useEstimatedMetadata()), 'checkPrimaryKeyUnicity' : '', 'srid' : uri.srid(), 'type': uri.wkbType(), 'schema': uri.schema(), 'table' : uri.table(), 'geocol' : uri.geometryColumn(), 'sql' : uri.sql(), 'dbType': dbType } return connectionParams
def layer_from_source(source_uri, name): """Return QgsMapLayer from a given source uri. :param source_uri: A source URI :type source_uri: basestring :param name: Designated layer name :type name: basestring :return: QgsMapLayer :rtype: qgis.core.QgsMapLayer """ vector_extensions = ('shp', 'geojson') raster_extensions = ('asc', 'tiff', 'tif', 'geotiff', 'geotif') qlr_extensions = ('qlr', ) qgis_layer = None if is_file_path(source_uri): # sanitize source_uri sanitized_uri = urllib.unquote(source_uri).decode('utf-8') sanitized_uri.replace('file://', '') if source_uri.endswith(vector_extensions): qgis_layer = QgsVectorLayer(sanitized_uri, name, 'ogr') elif source_uri.endswith(raster_extensions): qgis_layer = QgsRasterLayer(sanitized_uri, name) elif source_uri.endswith(qlr_extensions): qgis_layer = QgsMapLayer.fromLayerDefinitionFile(sanitized_uri) if qgis_layer: qgis_layer = qgis_layer[0] qgis_layer.setName(name) elif is_tile_path(source_uri): # sanitize source_uri sanitized_uri = urllib.unquote(source_uri).decode('utf-8') # Check if it is only a url if sanitized_uri.startswith(('http://', 'https://')): # Then it is probably a tile xyz url sanitized_uri = 'type=xyz&url={0}'.format(sanitized_uri) # It might be in the form of query string query_params = urlparse.parse_qs(sanitized_uri) driver = query_params.get('driver', 'wms') qgis_layer = QgsRasterLayer(sanitized_uri, name, driver) return qgis_layer
def _set_output_layer_style(layerName: str, layer: QgsMapLayer, alg: QgsProcessingAlgorithm, details: 'QgsProcessingContext::LayerDetails', context: QgsProcessingContext, parameters) -> None: """ Set layer style Original code is from python/plugins/processing/gui/Postprocessing.py """ '''If running a model, the execution will arrive here when an algorithm that is part of that model is executed. We check if its output is a final otuput of the model, and adapt the output name accordingly''' outputName = details.outputName if parameters: expcontext = QgsExpressionContext() scope = QgsExpressionContextScope() expcontext.appendScope(scope) for out in alg.outputDefinitions(): if out.name() not in parameters: continue outValue = parameters[out.name()] if hasattr(outValue, "sink"): outValue = outValue.sink.valueAsString(expcontext)[0] else: outValue = str(outValue) if outValue == layerName: outputName = out.name() break style = None if outputName: # If a style with the same name as the outputName exists # in workdir then use it style = os.path.join(context.workdir, outputName + '.qml') if not os.path.exists(style): style = RenderingStyles.getStyle(alg.id(), outputName) LOGGER.debug("Getting style for %s: %s <%s>", alg.id(), outputName, style) # Get defaults styles if style is None: if layer.type() == QgsMapLayer.RasterLayer: style = ProcessingConfig.getSetting(ProcessingConfig.RASTER_STYLE) else: if layer.geometryType() == QgsWkbTypes.PointGeometry: style = ProcessingConfig.getSetting( ProcessingConfig.VECTOR_POINT_STYLE) elif layer.geometryType() == QgsWkbTypes.LineGeometry: style = ProcessingConfig.getSetting( ProcessingConfig.VECTOR_LINE_STYLE) else: style = ProcessingConfig.getSetting( ProcessingConfig.VECTOR_POLYGON_STYLE) if style: LOGGER.debug("Adding style '%s' to layer %s (outputName %s)", style, details.name, outputName) layer.loadNamedStyle(style) LOGGER.debug("Layer name set to %s <details name: %s>", layer.name(), details.name)
def create_default_project(available_maps, visible_maps, project_template, authcfg=None): """Create a default project from a template and return it as a string""" layers = [] for m in available_maps: connstring = u'type=xyz&url=%(url)s' if authcfg is not None: connstring = u'authcfg=%(authcfg)s&' + connstring layer = QgsRasterLayer(connstring % { 'url': quote(m['endpoint']), 'authcfg': authcfg, }, m['name'], 'wms') # I've no idea why the following is required even if the crs is specified # in the layer definition layer.setCrs(QgsCoordinateReferenceSystem('EPSG:3857')) layers.append(layer) if len(layers): xml = QgsMapLayer.asLayerDefinition(layers) maplayers = "\n".join(xml.toString().split("\n")[3:-3]) layer_tree_layer = "" custom_order = "" legend_layer = "" layer_coordinate_transform = "" for layer in layers: is_visible = layer.name() in visible_maps values = {'name': layer.name(), 'id': layer.id(), 'visible': ('1' if is_visible else '0'), 'checked': ('Qt::Checked' if is_visible else 'Qt::Unchecked')} custom_order += "<item>%s</item>" % layer.id() layer_tree_layer += """ <layer-tree-layer expanded="1" checked="%(checked)s" id="%(id)s" name="%(name)s"> <customproperties/> </layer-tree-layer>""" % values legend_layer += """ <legendlayer drawingOrder="-1" open="true" checked="%(checked)s" name="%(name)s" showFeatureCount="0"> <filegroup open="true" hidden="false"> <legendlayerfile isInOverview="0" layerid="%(id)s" visible="%(visible)s"/> </filegroup> </legendlayer>""" % values layer_coordinate_transform += '<layer_coordinate_transform destAuthId="EPSG:3857" srcAuthId="EPSG:3857" srcDatumTransform="-1" destDatumTransform="-1" layerid="%s"/>' % layer.id() tpl = "" with open(project_template, 'rb') as f: tpl = f.read() for tag in ['custom_order', 'layer_tree_layer', 'legend_layer', 'layer_coordinate_transform', 'maplayers']: tpl = tpl.replace("#%s#" % tag.upper(), locals()[tag]) return tpl else: return None
def createDefaultProject(available_maps, visible_maps, project_template, authcfg=None): """Create a default project from a template and return it as a string""" layers = [] for m in available_maps: connstring = u'type=xyz&url={url}' if authcfg is not None: connstring = u'authcfg={authcfg}&' + connstring layer = QgsRasterLayer(connstring.format(url=urllib2.quote("{}?version={}".format(m['endpoint'], pluginSetting("apiVersion"))), authcfg=authcfg), m['name'], "wms") # I've no idea why the following is required even if the crs is specified # in the layer definition layer.setCrs(QgsCoordinateReferenceSystem('EPSG:3857')) layers.append(layer) if len(layers): xml = QgsMapLayer.asLayerDefinition(layers) maplayers = "\n".join(xml.toString().split("\n")[3:-3]) layer_tree_layer = "" custom_order = "" legend_layer = "" layer_coordinate_transform = "" for layer in layers: is_visible = layer.name() in visible_maps values = {'name': layer.name(), 'id': layer.id(), 'visible': ('1' if is_visible else '0'), 'checked': ('Qt::Checked' if is_visible else 'Qt::Unchecked')} custom_order += "<item>%s</item>" % layer.id() layer_tree_layer += """ <layer-tree-layer expanded="1" checked="%(checked)s" id="%(id)s" name="%(name)s"> <customproperties/> </layer-tree-layer>""" % values legend_layer += """ <legendlayer drawingOrder="-1" open="true" checked="%(checked)s" name="%(name)s" showFeatureCount="0"> <filegroup open="true" hidden="false"> <legendlayerfile isInOverview="0" layerid="%(id)s" visible="%(visible)s"/> </filegroup> </legendlayer>""" % values layer_coordinate_transform += '<layer_coordinate_transform destAuthId="EPSG:3857" srcAuthId="EPSG:3857" srcDatumTransform="-1" destDatumTransform="-1" layerid="%s"/>' % layer.id() tpl = "" with open(project_template, 'rb') as f: tpl = f.read() for tag in ['custom_order', 'layer_tree_layer', 'legend_layer', 'layer_coordinate_transform', 'maplayers']: tpl = tpl.replace("#%s#" % tag.upper(), locals()[tag]) return tpl else: return None
def __add_layer_definition_file(self, file_name, root_group): """ shamelessly copied from https://github.com/qgis/QGIS/blob/master/src/core/qgslayerdefinition.cpp """ qfile = QFile(file_name) if not qfile.open(QIODevice.ReadOnly): return None doc = QDomDocument() if not doc.setContent(qfile): return None file_info = QFileInfo(qfile) QDir.setCurrent(file_info.absoluteDir().path()) root = QgsLayerTreeGroup() ids = doc.elementsByTagName('id') for i in range(0, ids.size()): id_node = ids.at(i) id_elem = id_node.toElement() old_id = id_elem.text() layer_name = old_id[:-17] date_time = QDateTime.currentDateTime() new_id = layer_name + date_time.toString('yyyyMMddhhmmsszzz') id_elem.firstChild().setNodeValue(new_id) tree_layer_nodes = doc.elementsByTagName('layer-tree-layer') for j in range(0, tree_layer_nodes.count()): layer_node = tree_layer_nodes.at(j) layer_elem = layer_node.toElement() if old_id == layer_elem.attribute('id'): layer_node.toElement().setAttribute('id', new_id) layer_tree_elem = doc.documentElement().firstChildElement( 'layer-tree-group') load_in_legend = True if not layer_tree_elem.isNull(): root.readChildrenFromXML(layer_tree_elem) load_in_legend = False layers = QgsMapLayer.fromLayerDefinition(doc) QgsProject.instance().addMapLayers(layers, load_in_legend) nodes = root.children() for node in nodes: root.takeChild(node) del root root_group.insertChildNodes(-1, nodes) return None
def add_layer_metadata(map_layer: qgc.QgsMapLayer, layer_cfg: Layer) -> None: """Add layer metadata. Renders a jinja template to a temporary file location as a valid QGIS qmd metadata file. This metadata then gets associated with the `map_layer` using its `loadNamedMetadata` method. This metadata gets written to the project file when the layer is added to the `project`. """ qmd_template = load_template('metadata.jinja') # Set the layer's tooltip tooltip = _build_layer_tooltip(layer_cfg) map_layer.setAbstract(tooltip) # Render the qmd template. abstract = escape(build_layer_metadata(layer_cfg)) layer_extent = map_layer.extent() layer_crs = map_layer.crs() if layer_cfg.steps: provenance_list = [escape(step.provenance) for step in layer_cfg.steps] else: provenance_list = [] rendered_qmd = qmd_template.render( provenance_list=provenance_list, abstract=abstract, title=layer_cfg.title, crs_proj4_str=layer_crs.toProj4(), crs_srsid=layer_crs.srsid(), crs_postgres_srid=layer_crs.postgisSrid(), crs_authid=layer_crs.authid(), crs_description=layer_crs.description(), crs_projection_acronym=layer_crs.projectionAcronym(), crs_ellipsoid_acronym=layer_crs.ellipsoidAcronym(), minx=layer_extent.xMinimum(), miny=layer_extent.yMinimum(), maxx=layer_extent.xMaximum(), maxy=layer_extent.yMaximum(), ) # Write the rendered tempalte to a temporary file # location. `map_layer.loadNamedMetadata` expects a string URI corresponding # to a file on disk. with tempfile.NamedTemporaryFile('w') as temp_file: temp_file.write(rendered_qmd) temp_file.flush() map_layer.loadNamedMetadata(temp_file.name)
def load_layers(iface): # Load a dictionary of layerId:layer pairs layer_dic = QgsProject.instance().layerStore().mapLayers() # Filter the vector layers (LayerType(0)) vec_dic = dict() for l in layer_dic: if layer_dic[l].type() == QgsMapLayer.LayerType(0): vec_dic[l] = layer_dic[l] # Further filter those polygon layers (geometryType(2)) which have # at least 1 feature and add them to the drop down menu. poly_geom = QgsWkbTypes.GeometryType(2) poly_dic = dict() poly_ind = [] # Indices are saved here for l in vec_dic: if vec_dic[l].geometryType() == poly_geom and vec_dic[l].featureCount( ) and vec_dic[l].crs().authid() == 'EPSG:31287': poly_dic[l] = vec_dic[l] poly_ind.append(l) return poly_dic, poly_ind
def __getCrs(self, layer: QgsMapLayer = None) -> QgsCoordinateReferenceSystem: if layer: return layer.sourceCrs() return self.project.crs()
def loadQlrs(qlrList): for qlr in qlrList: lyrs = QgsMapLayer.fromLayerDefinitionFile(qlr) QgsMapLayerRegistry.instance().addMapLayers(lyrs)
def addToDefaultProject(maps, visibleMaps, authcfg=None): """Add basemaps to the existing default project""" layers = [] for m in maps: connstring = u'type=xyz&url={url}' if authcfg is not None: connstring = u'authcfg={authcfg}&' + connstring layer = QgsRasterLayer(connstring.format(url=urllib2.quote("{}?version={}".format(m['endpoint'], pluginSetting("apiVersion"))), authcfg=authcfg), m['name'], 'wms') # I've no idea why the following is required even if the crs is specified # in the layer definition layer.setCrs(QgsCoordinateReferenceSystem('EPSG:3857')) layers.append(layer) if os.path.isfile(defaultProjectPath()): backup = defaultProjectPath().replace( '.qgs', '-%s.qgs' % datetime.now().strftime('%Y-%m-%d-%H_%M_%S')) shutil.copy2(defaultProjectPath(), backup) # open default project with open(defaultProjectPath()) as f: content = f.read() doc = QDomDocument() setOk, errorString, errorLine, errorColumn = doc.setContent(content) if not setOk: return False root = doc.documentElement() for layer in layers: is_visible = layer.name() in visibleMaps xml = QgsMapLayer.asLayerDefinition([layer]) r = xml.documentElement() mapLayerElement = r.firstChildElement("maplayers").firstChildElement("maplayer") layerTreeLayerElement = doc.createElement("layer-tree-layer") layerTreeLayerElement.setAttribute("expanded", "1") layerTreeLayerElement.setAttribute("checked", "Qt::Checked" if is_visible else "Qt::Unchecked") layerTreeLayerElement.setAttribute("id", layer.id()) layerTreeLayerElement.setAttribute("name", layer.name()) customPropertiesElement = doc.createElement("customproperties") layerTreeLayerElement.appendChild(customPropertiesElement) legendLayerElement = doc.createElement("legendlayer") legendLayerElement.setAttribute("drawingOrder", "-1") legendLayerElement.setAttribute("open", "true") legendLayerElement.setAttribute("checked", "Qt::Checked" if is_visible else "Qt::Unchecked") legendLayerElement.setAttribute("name", layer.name()) legendLayerElement.setAttribute("showFeatureCount", "0") filegroupElement = doc.createElement("filegroup") filegroupElement.setAttribute("open", "true") filegroupElement.setAttribute("hidden", "false") legendlayerfileElement = doc.createElement("legendlayerfile") legendlayerfileElement.setAttribute("isInOverview", "0") legendlayerfileElement.setAttribute("layerid", layer.id()) legendlayerfileElement.setAttribute("visible", "1" if is_visible else "0") filegroupElement.appendChild(legendlayerfileElement) legendLayerElement.appendChild(filegroupElement) crsElement = doc.createElement("layer_coordinate_transform") crsElement.setAttribute("destAuthId", "EPSG:3857") crsElement.setAttribute("srcAuthId", "EPSG:3857") crsElement.setAttribute("srcDatumTransform", "-1") crsElement.setAttribute("destDatumTransform", "-1") crsElement.setAttribute("layerid", layer.id()) itemElement = doc.createElement("item") text = doc.createTextNode(layer.id()) itemElement.appendChild(text) e = root.firstChildElement("layer-tree-group") e.appendChild(layerTreeLayerElement) e = root.firstChildElement("mapcanvas").firstChildElement("layer_coordinate_transform_info") e.appendChild(crsElement) e = root.firstChildElement("layer-tree-canvas").firstChildElement("custom-order") e.appendChild(itemElement) e = root.firstChildElement("legend") e.appendChild(legendLayerElement) e = root.firstChildElement("projectlayers") e.appendChild(mapLayerElement) with open(defaultProjectPath(), "wb+") as f: f.write(doc.toString(2)) settings = QSettings() settings.setValue('/qgis/newProjectDefault', True) return True
def _allowed_layer(lyr: QgsMapLayer) -> bool: return AllowedValue(value=lyr.name(), allowed_type=ALLOWEDVALUETYPE.LAYER)
def _load_qml_style(map_layer: qgc.QgsMapLayer, style_path: Path) -> None: msg, status = map_layer.loadNamedStyle(str(style_path)) if not status: raise RuntimeError(f"Problem loading '{style_path}': '{msg}'")
def tag_layer_as_stdm_layer(layer: QgsMapLayer): """ Tags a map layer as a STDM sourced layer """ layer.setCustomProperty(LayerUtils.IS_STDM_LAYER_KEY, True)
def is_layer_stdm_layer(layer: QgsMapLayer) -> bool: """ Returns True if the layer is a STDM sourced layer """ return bool(layer.customProperty(LayerUtils.IS_STDM_LAYER_KEY))
def add_layer_to_project(layer: QgsMapLayer): project = QgsProject.instance() layer_candidates = project.mapLayersByName(layer.name()) if len(layer_candidates) > 0: project.removeMapLayers(layer_candidates) project.addMapLayer(layer)