Încărcarea Straturilor

The code snippets on this page needs the following imports:

import os # This is is needed in the pyqgis console also
from qgis.core import (

Haideți să deschidem mai multe straturi cu date. QGIS recunoaște straturile vectoriale și pe cele de tip raster. În plus, sunt disponibile și tipurile de straturi personalizate, dar pe acestea nu le vom discuta aici.

Straturile Vectoriale

To create a vector layer instance, specify layer’s data source identifier, name for the layer and provider’s name:

# get the path to the shapefile e.g. /home/project/data/ports.shp
path_to_ports_layer = os.path.join(QgsProject.instance().homePath(), "data", "ports", "ports.shp")

# The format is:
# vlayer = QgsVectorLayer(data_source, layer_name, provider_name)

vlayer = QgsVectorLayer(path_to_ports_layer, "Ports layer", "ogr")
if not vlayer.isValid():
    print("Layer failed to load!")

Identificatorul sursei de date reprezintă un șir specific pentru fiecare furnizor de date vectoriale în parte. Numele stratului se va afișa în lista straturilor. Este important să se verifice dacă stratul a fost încărcat cu succes. În cazul neîncărcării cu succes, va fi returnată o instanță de strat nevalid.

For a geopackage vector layer:

# get the path to a geopackage  e.g. /home/project/data/data.gpkg
path_to_gpkg = os.path.join(QgsProject.instance().homePath(), "data", "data.gpkg")
# append the layername part
gpkg_places_layer = path_to_gpkg + "|layername=places"
# e.g. gpkg_places_layer = "/home/project/data/data.gpkg|layername=places"
vlayer = QgsVectorLayer(gpkg_places_layer, "Places layer", "ogr")
if not vlayer.isValid():
    print("Layer failed to load!")

The quickest way to open and display a vector layer in QGIS is the addVectorLayer() method of the QgisInterface:

vlayer = iface.addVectorLayer(path_to_ports_layer, "Ports layer", "ogr")
if not vlayer:
  print("Layer failed to load!")

This creates a new layer and adds it to the current QGIS project (making it appear in the layer list) in one step. The function returns the layer instance or None if the layer couldn’t be loaded.

Lista de mai jos arată modul de accesare a diverselor surse de date, cu ajutorul furnizorilor de date vectoriale:

  • OGR library (Shapefile and many other file formats) — data source is the path to the file:

    • for Shapefile:

      vlayer = QgsVectorLayer("/path/to/shapefile/file.shp", "layer_name_you_like", "ogr")
    • for dxf (note the internal options in data source uri):

      uri = "/path/to/dxffile/file.dxf|layername=entities|geometrytype=Point"
      vlayer = QgsVectorLayer(uri, "layer_name_you_like", "ogr")
  • PostGIS database - data source is a string with all information needed to create a connection to PostgreSQL database.

    QgsDataSourceUri class can generate this string for you. Note that QGIS has to be compiled with Postgres support, otherwise this provider isn’t available:

    uri = QgsDataSourceUri()
    # set host name, port, database name, username and password
    uri.setConnection("localhost", "5432", "dbname", "johny", "xxx")
    # set database schema, table name, geometry column and optionally
    # subset (WHERE clause)
    uri.setDataSource("public", "roads", "the_geom", "cityid = 2643")
    vlayer = QgsVectorLayer(uri.uri(False), "layer name you like", "postgres")


    The False argument passed to uri.uri(False) prevents the expansion of the authentication configuration parameters, if you are not using any authentication configuration this argument does not make any difference.

  • CSV or other delimited text files — to open a file with a semicolon as a delimiter, with field „x” for X coordinate and field „y” for Y coordinate you would use something like this:

    uri = "/some/path/file.csv?delimiter={}&xField={}&yField={}".format(";", "x", "y")
    vlayer = QgsVectorLayer(uri, "layer name you like", "delimitedtext")


    The provider string is structured as a URL, so the path must be prefixed with file://. Also it allows WKT (well known text) formatted geometries as an alternative to x and y fields, and allows the coordinate reference system to be specified. For example:

    uri = "file:///some/path/file.csv?delimiter={}&crs=epsg:4723&wktField={}".format(";", "shape")
  • Fișiere GPX — furnizorul de date „gpx” citește urme, rute și puncte de referință din fișiere gpx. Pentru a deschide un fișier, tipul (urmă/traseu/punct de referință) trebuie să fie specificat ca parte a url-ului:

    uri = "path/to/gpx/file.gpx?type=track"
    vlayer = QgsVectorLayer(uri, "layer name you like", "gpx")
  • SpatiaLite database — Similarly to PostGIS databases, QgsDataSourceUri can be used for generation of data source identifier:

    uri = QgsDataSourceUri()
    schema = ''
    table = 'Towns'
    geom_column = 'Geometry'
    uri.setDataSource(schema, table, geom_column)
    display_name = 'Towns'
    vlayer = QgsVectorLayer(uri.uri(), display_name, 'spatialite')
  • Geometrii MySQL bazate pe WKB, prin OGR — sursa de date o reprezintă șirul de conectare la tabelă:

    uri = "MySQL:dbname,host=localhost,port=3306,user=root,password=xxx|layername=my_table"
    vlayer = QgsVectorLayer( uri, "my table", "ogr" )
  • Conexiune WFS:. conexiunea este definită cu un URI și cu ajutorul furnizorului WFS:

    uri = "http://localhost:8080/geoserver/wfs?srsname=EPSG:23030&typename=union&version=1.0.0&request=GetFeature&service=WFS",
    vlayer = QgsVectorLayer(uri, "my wfs layer", "WFS")

    Identificatorul URI poate fi creat folosindu-se biblioteca standard urllib:

    params = {
        'service': 'WFS',
        'version': '1.0.0',
        'request': 'GetFeature',
        'typename': 'union',
        'srsname': "EPSG:23030"
    uri = 'http://localhost:8080/geoserver/wfs?' + urllib.unquote(urllib.urlencode(params))


You can change the data source of an existing layer by calling setDataSource() on a QgsVectorLayer instance, as in the following example:

# vlayer is a vector layer, uri is a QgsDataSourceUri instance
vlayer.setDataSource(uri.uri(), "layer name you like", "postgres")

Straturile Raster

For accessing raster files, GDAL library is used. It supports a wide range of file formats. In case you have troubles with opening some files, check whether your GDAL has support for the particular format (not all formats are available by default). To load a raster from a file, specify its filename and display name:

# get the path to a tif file  e.g. /home/project/data/srtm.tif
path_to_tif = os.path.join(QgsProject.instance().homePath(), "data", "srtm.tif")
rlayer = QgsRasterLayer(path_to_tif, "SRTM layer name")
if not rlayer.isValid():
    print("Layer failed to load!")

To load a raster from a geopackage:

# get the path to a geopackage  e.g. /home/project/data/data.gpkg
path_to_gpkg = os.path.join(QgsProject.instance().homePath(), "data", "data.gpkg")
# gpkg_raster_layer = "GPKG:/home/project/data/data.gpkg:srtm"
gpkg_raster_layer = "GPKG:" + path_to_gpkg + ":srtm"

rlayer = QgsRasterLayer(gpkg_raster_layer, "layer name you like", "gdal")

if not rlayer.isValid():
    print("Layer failed to load!")

Similarly to vector layers, raster layers can be loaded using the addRasterLayer function of the QgisInterface object:

iface.addRasterLayer("/path/to/raster/file.tif", "layer name you like")

This creates a new layer and adds it to the current project (making it appear in the layer list) in one step.

Straturile raster pot fi, de asemenea, create dintr-un serviciu WCS:

layer_name = 'modis'
uri = QgsDataSourceUri()
uri.setParam('url', 'http://demo.mapserver.org/cgi-bin/wcs')
uri.setParam("identifier", layer_name)
rlayer = QgsRasterLayer(str(uri.encodedUri()), 'my wcs layer', 'wcs')

Here is a description of the parameters that the WCS URI can contain:

WCS URI is composed of key=value pairs separated by &. It is the same format like query string in URL, encoded the same way. QgsDataSourceUri should be used to construct the URI to ensure that special characters are encoded properly.

  • url (required) : WCS Server URL. Do not use VERSION in URL, because each version of WCS is using different parameter name for GetCapabilities version, see param version.

  • identifier (required) : Coverage name

  • time (optional) : time position or time period (beginPosition/endPosition[/timeResolution])

  • format (optional) : Supported format name. Default is the first supported format with tif in name or the first supported format.

  • crs (optional) : CRS in form AUTHORITY:ID, e.g. EPSG:4326. Default is EPSG:4326 if supported or the first supported CRS.

  • username (optional) : Username for basic authentication.

  • password (optional) : Password for basic authentication.

  • IgnoreGetMapUrl (optional, hack) : If specified (set to 1), ignore GetCoverage URL advertised by GetCapabilities. May be necessary if a server is not configured properly.

  • InvertAxisOrientation (optional, hack) : If specified (set to 1), switch axis in GetCoverage request. May be necessary for geographic CRS if a server is using wrong axis order.

  • IgnoreAxisOrientation (optional, hack) : If specified (set to 1), do not invert axis orientation according to WCS standard for geographic CRS.

  • cache (optional) : cache load control, as described in QNetworkRequest::CacheLoadControl, but request is resend as PreferCache if failed with AlwaysCache. Allowed values: AlwaysCache, PreferCache, PreferNetwork, AlwaysNetwork. Default is AlwaysCache.

Alternativ, puteți încărca un strat raster de pe un server WMS. Cu toate acestea, în prezent, nu este posibilă accesarea din API a răspunsului GetCapabilities — trebuie să cunoșteți straturile dorite:

urlWithParams = 'url=http://irs.gis-lab.info/?layers=landsat&styles=&format=image/jpeg&crs=EPSG:4326'
rlayer = QgsRasterLayer(urlWithParams, 'some layer name', 'wms')
if not rlayer.isValid():
  print("Layer failed to load!")

QgsProject instance

If you would like to use the opened layers for rendering, do not forget to add them to the QgsProject instance. The QgsProject instance takes ownership of layers and they can be later accessed from any part of the application by their unique ID. When the layer is removed from the project, it gets deleted, too. Layers can be removed by the user in the QGIS interface, or via Python using the removeMapLayer() method.

Adding a layer to the current project is done using the addMapLayer() method:


To add a layer at an absolute position:

# first add the layer without showing it
QgsProject.instance().addMapLayer(rlayer, False)
# obtain the layer tree of the top-level group in the project
layerTree = iface.layerTreeCanvasBridge().rootGroup()
# the position is a number starting from 0, with -1 an alias for the end
layerTree.insertChildNode(-1, QgsLayerTreeLayer(rlayer))

If you want to delete the layer use the removeMapLayer() method:

# QgsProject.instance().removeMapLayer(layer_id)

In the above code, the layer id is passed (you can get it calling the id() method of the layer), but you can also pass the layer object itself.

For a list of loaded layers and layer ids, use the mapLayers() method: