Outdated version of the documentation. Find the latest one here.

Cargar capas

Vamos a abrir algunas capas con datos. QGIS reconoce capas vectoriales y ráster. Además, están disponibles tipos de capas personalizadas, pero no se va a discutir de ellas aquí.

Capas Vectoriales

Para cargar una capa vectorial, especificar el identificador de la fuente de datos de la capa, nombre y nombre del proveedor:

layer = QgsVectorLayer(data_source, layer_name, provider_name)
if not layer.isValid():
  print "Layer failed to load!"

El identificador de la fuente de datos es una cadena y se especifica a cada proveedor de datos vectoriales. El nombre de la capa se utiliza en el widget de la lista de capa. Es importante validar si la capa se ha cargado satisfactoriamente. Si no fue así, se devuelve una instancia de capa no válida.

La manera más rápida para abrir y desplegar una capa vectorial en QGIS es la función addVectorLayer del QgisInterface:

layer = iface.addVectorLayer("/path/to/shapefile/file.shp", "layer name you like", "ogr")
if not layer:
  print "Layer failed to load!"

Esto crea una nueva capa y lo añade al registro de capa de mapa (haciendolo aparecer en la lista de capas) en un paso. La función regresa la instancia de la capa o Nada si la capa no puede cargarse.

La siguiente lista muestra cómo acceder a varias fuentes de datos utilizando los proveedores de datos vectoriales:

  • La librería OGR (archivos shape y muchos otros formatos de archivo) — la fuente de datos es la ruta del archivo.

    • para archivos shape:

      vlayer = QgsVectorLayer("/path/to/shapefile/file.shp", "layer_name_you_like", "ogr")
      
    • para dxf (Observe las opciones internas en la fuente de datos uri):

      uri = "/path/to/dxffile/file.dxf|layername=entities|geometrytype=Point"
      vlayer = QgsVectorLayer(uri, "layer_name_you_like", "ogr")
      
  • La base de datos PostGIS — la fuente de datos es una cadena con toda la información necesaria para crear una conexión a la base de datos PostgreSQL. La clase QgsDataSourceURI puede generar esta cadena para usted. Tenga en cuenta que QGIS tiene que ser compilado con la ayuda de Postgres, de lo contrario este proveedor no esta disponible:

    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(), "layer name you like", "postgres")
    
  • CSV u otro archivo de texto delimitado — para abrir un archivo con un punto y coma como delimitador, con campo “x” para la coordenada x y un campo “y” para la coordenada y se usaría algo como esto.

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

    Nota: desde la versión 1.7 de QGIS la cadena de proveedor esta estructurada como una URL, así la ruta debe estar prefijado con file://. También permite formatear geometrías WKT (well known text) como una alternativa a los campos “x” y “y”, y permite especificar el sistema de referencia de coordenadas. Por ejemplo:

    uri = "file:///some/path/file.csv?delimiter=%s&crs=epsg:4723&wktField=%s" % (";", "shape")
    
  • Los archivos GPX — el proveedor de datos “gpx” lee los caminos, rutas y puntos de interés desde archivos GPX. Para abrir un archivo, el tipo (caminos/ruta/punto de interés) se debe especificar como parte de la url:

    uri = "path/to/gpx/file.gpx?type=track"
    vlayer = QgsVectorLayer(uri, "layer name you like", "gpx")
    
  • La base de datos Spatialite — implementado desde QGIS v1.1. Similar a la base de datos PostGIS, QgsDataSourceURI se puede utilizar para la generación del identificador de fuente de datos.

    uri = QgsDataSourceURI()
    uri.setDatabase('/home/martin/test-2.3.sqlite')
    schema = ''
    table = 'Towns'
    geom_column = 'Geometry'
    uri.setDataSource(schema, table, geom_column)
    
    display_name = 'Towns'
    vlayer = QgsVectorLayer(uri.uri(), display_name, 'spatialite')
    
  • Las geometrias basadas en WKB de MySQL, a través de OGR — la fuente de datos es la cadena de conexión a la tabla:

    uri = "MySQL:dbname,host=localhost,port=3306,user=root,password=xxx|layername=my_table"
    vlayer = QgsVectorLayer( uri, "my table", "ogr" )
    
  • Conexión WFS:. se define con un URI y utiliza el proveedor 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")
    

    La uri se puede crear utilizando la librería estándar 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))
    

Nota

Puede cambiar la fuente de datos de una capa existente al llamar setDataSource() en una instancia QgsVectorLayer, como en el siguiente ejemplo:

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

Capas ráster

Para acceder a los archivos ráster, se utiliza la librería GDAL. Es compatible con una amplia gama de formatos de archivo. En caso que tenga problemas al abrir algunos archivos, compruebe si su GDAL tiene implementado un formato en particular (no todos los formatos están disponibles por defecto). Para cargar un ráster desde un archivo, especificar su nombre de archivo y nombre base:

fileName = "/path/to/raster/file.tif"
fileInfo = QFileInfo(fileName)
baseName = fileInfo.baseName()
rlayer = QgsRasterLayer(fileName, baseName)
if not rlayer.isValid():
  print "Layer failed to load!"

De manera similar que las capas vectoriales, ráster se pueden cargar utilizando la función addRasterLayer de la QgisInterface:

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

Esto crea una capa y lo agrega al registro de capa de mapa (haciendolo aparecer en la lista de capas) en un paso.

Las capas ráster también se pueden crear desde el servicio 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')

Ajustes del URI detallado se pueden encontrar en documentación de proveedor

Como alternativa se puede cargar una capa ráster desde un servidor WMS. Sin embargo actualmente no es posible acceder a las respuestas de GetCapabilities desde el API — se debe saber que capas desea:

urlWithParams = 'url=http://wms.jpl.nasa.gov/wms.cgi&layers=global_mosaic&styles=pseudo&format=image/jpeg&crs=EPSG:4326'
rlayer = QgsRasterLayer(urlWithParams, 'some layer name', 'wms')
if not rlayer.isValid():
  print "Layer failed to load!"

Registro de capa de mapa

Si desea utilizar las capas abiertas para la representación, no olvide de añadirlos al registro de capa de mapa. El registro capa de mapa asume la propiedad de las capas y se puede acceder más tarde desde cualquier parte de la aplicación por su ID único. Cuando se retira la capa de registro capa de mapa, que se elimina, también.

Añadir una capa al registro:

QgsMapLayerRegistry.instance().addMapLayer(layer)

Las capas se destruyen de forma automática en la salida, por eso si se desea eliminar la capa de forma explícita, utilice:

QgsMapLayerRegistry.instance().removeMapLayer(layer_id)

Para una lista de capas cargadas e identificadores de capas, utilice:

QgsMapLayerRegistry.instance().mapLayers()