`GDAL`__ se refiere a la Geospatial Data Abstraction Library, y es una verdadera «tijera suiza» de funcionalidades de datos GIS. Un subconjunto de GDAL es la `OGR`__ Simple Features Library, que se especializa en leer y escribir datos geográficos vectoriales en una variedad de formatos estándar.
GeoDjango proporciona una interfaz Python de alto nivel para algunas de las capacidades de OGR, incluyendo la lectura y transformación de coordenadas de datos espaciales vectoriales y un soporte mínimo para las características de GDAL con respecto a los datos raster (imagen).
Nota
Aunque el módulo se llama gdal, GeoDjango solo admite algunas de las capacidades de OGR y las características raster de GDAL en este momento.
Las herramientas GDAL/OGR descritas aquí están diseñadas para ayudarte a leer tus datos geoespaciales, ya que la mayoría de ellos son útiles si tienes algunos datos con los que trabajar. Si estás empezando y no tienes aún ningún dato propio con el que trabajar, los tests de GeoDjango contienen varios conjuntos de datos que puedes utilizar para probar. Puedes descargarlos aquí:
$ wget https://raw.githubusercontent.com/django/django/main/tests/gis_tests/data/cities/cities.{shp,prj,shx,dbf}
$ wget https://raw.githubusercontent.com/django/django/main/tests/gis_tests/data/rasters/raster.tif
DataSource¶DataSource es un envoltorio del objeto de fuente de datos OGR que admite la lectura de datos desde una variedad de formatos y fuentes geoespaciales de OGR admitidos utilizando una interfaz consistente. Cada fuente de datos se representa mediante un objeto DataSource que contiene uno o más capas de datos. Cada capa, representada por un objeto Layer, contiene algún número de características geográficas (Feature), información sobre el tipo de características contenidas en esa capa (por ejemplo, puntos, polígonos, etc.), así como los nombres y tipos de cualquier campo adicional (Field) de datos que puedan estar asociados con cada característica en esa capa.
El constructor para DataSource solo requiere un parámetro: la ruta del archivo que deseas leer. Sin embargo, OGR también admite una variedad de fuentes de datos más complejas, incluidos bases de datos, que pueden ser accedidas pasando una cadena de nombre especial en lugar de una ruta. Para obtener más información, consulta la documentación `OGR Vector Formats`__.
El parámetro opcional encoding te permite especificar una codificación no estándar de las cadenas en la fuente. Esto es típicamente útil cuando obtienes excepciones DjangoUnicodeDecodeError mientras se leen valores de campos.
Una vez que hayas creado tu objeto DataSource, puedes saber cuántas capas de datos contiene accediendo a la propiedad layer_count, o (equivalentemente) utilizando la función len(). Para obtener información sobre cómo acceder a las capas de datos en sí mismas, consulta el siguiente apartado:
>>> from django.contrib.gis.gdal import DataSource
>>> ds = DataSource("/path/to/your/cities.shp")
>>> ds.name
'/path/to/your/cities.shp'
>>> ds.layer_count # This file only contains one layer
1
Devuelve el número de capas en la fuente de datos.
Los textos traducidos son:
Capa¶Capa es un envoltorio para una capa de datos en un objeto FuenteDeDatos. Nunca creas un objeto Capa directamente. En su lugar, los recuperas desde un objeto DataSource, que esencialmente es un contenedor estándar de Python de objetos Capa. Por ejemplo, puedes acceder a una capa específica por su índice (por ejemplo, ds[0] para acceder a la primera capa), o puedes iterar sobre todas las capas en el contenedor en un bucle for. La Capa misma actúa como un contenedor de características geométricas.
Normalmente, todas las características de una capa dada tienen el mismo tipo de geometría. La propiedad geom_type de una capa es un OGRGeomType que identifica el tipo de característica. Puedes usarlo para imprimir información básica sobre cada capa en un objeto DataSource:
>>> for layer in ds:
... print('Layer "%s": %i %ss' % (layer.name, len(layer), layer.geom_type.name))
...
Layer "cities": 3 Points
El ejemplo de salida proviene de la fuente de datos de ciudades, cargada anteriormente, que evidentemente contiene una sola capa, llamada "ciudades", que contiene tres características de tipo punto. Por simplicidad, los ejemplos a continuación asumen que has almacenado esa capa en la variable layer:
>>> layer = ds[0]
Returns the name of this layer in the data source.
>>> layer.name
'cities'
Returns the number of features in the layer. Same as len(layer):
>>> layer.num_feat
3
Returns the geometry type of the layer, as an OGRGeomType object:
>>> layer.geom_type.name
'Point'
Returns the number of fields in the layer, i.e the number of fields of data associated with each feature in the layer:
>>> layer.num_fields
4
Returns a list of the names of each of the fields in this layer:
>>> layer.fields
['Name', 'Population', 'Density', 'Created']
Returns una lista de los tipos de datos de cada uno de los campos en esta capa. Estos son subclases de Field, discutidas a continuación:
>>> [ft.__name__ for ft in layer.field_types]
['OFTString', 'OFTReal', 'OFTReal', 'OFTDate']
Returns una lista de las anchuras máximas de campo para cada uno de los campos en esta capa:
>>> layer.field_widths
[80, 11, 24, 10]
Returns una lista de las precisiones numéricas para cada uno de los campos en esta capa. Esto es insignificante (y se establece en cero) para campos no numéricos:
>>> layer.field_precisions
[0, 0, 15, 0]
Returns el alcance espacial de esta capa, como un objeto Envelope :
>>> layer.extent.tuple
(-104.609252, 29.763374, -95.23506, 38.971823)
Propiedad que devuelve la referencia espacial asociada con esta capa:
>>> print(layer.srs)
GEOGCS["GCS_WGS_1984",
DATUM["WGS_1984",
SPHEROID["WGS_1984",6378137,298.257223563]],
PRIMEM["Greenwich",0],
UNIT["Degree",0.017453292519943295]]
Si la capa Layer no tiene información de referencia espacial asociada con ella, se devuelve None:
Propiedad que puede utilizarse para recuperar o establecer un filtro espacial para esta capa. Un filtro espacial solo se puede establecer con una instancia de OGRGeometry, un tupla de 4 elementos de alcance o None. Cuando se establece algo distinto a None, solo se devolverán las características que intersecten el filtro al iterar sobre la capa:
>>> print(layer.spatial_filter)
None
>>> print(len(layer))
3
>>> [feat.get("Name") for feat in layer]
['Pueblo', 'Lawrence', 'Houston']
>>> ks_extent = (-102.051, 36.99, -94.59, 40.00) # Extent for state of Kansas
>>> layer.spatial_filter = ks_extent
>>> len(layer)
1
>>> [feat.get("Name") for feat in layer]
['Lawrence']
>>> layer.spatial_filter = None
>>> len(layer)
3
Método que devuelve una lista de los valores de un campo dado para cada característica en la capa:
>>> layer.get_fields("Name")
['Pueblo', 'Lawrence', 'Houston']
Método que devuelve una lista conteniendo la geometría de cada característica en la capa. Si el argumento opcional geos se establece en True, las geometrías se convierten a objetos GEOSGeometry. De lo contrario, se devuelven como objetos OGRGeometry:
>>> [pt.tuple for pt in layer.get_geoms()]
[(-104.609252, 38.255001), (-95.23506, 38.971823), (-95.363151, 29.763374)]
Returns un booleano indicando si esta capa admite la capacidad dada (una cadena de caracteres). Ejemplos de cadenas de capacidad válidas incluyen: 'RandomRead', 'SequentialWrite', 'RandomWrite', 'FastSpatialFilter', 'FastFeatureCount', 'FastGetExtent', 'CreateField', 'Transactions', 'DeleteFeature' y 'FastSetNextByIndex'.
Característica¶Característica envuelve una característica OGR. Nunca creas un objeto Feature directamente. En su lugar, los recuperas de un objeto Layer. Cada característica consiste en una geometría y un conjunto de campos que contienen propiedades adicionales. La geometría de un campo es accesible a través de su propiedad geom, que devuelve un objeto OGRGeometry. Una Feature se comporta como un contenedor estándar de Python para sus campos, los cuales devuelve como objetos Field: puedes acceder a un campo directamente por su índice o nombre, o puedes iterar sobre los campos de una característica, p. ej., en un bucle for.
Devuelve la geometría para esta característica, como objeto OGRGeometry:
>>> city.geom.tuple
(-104.609252, 38.255001)
Un método que devuelve el valor del campo dado (especificado por nombre) para esta característica, no un objeto de envoltorio Field:
>>> city.get("Population")
102121
Devuelve el tipo de geometría para esta característica, como objeto OGRGeomType. Esto será lo mismo para todas las características en una capa dada y es equivalente a la propiedad Layer.geom_type del objeto Layer del que provino la característica.
Devuelve el número de campos de datos asociados con la característica. Esto será lo mismo para todas las características en una capa dada y es equivalente a la propiedad Layer.num_fields del objeto Layer del que provino la característica.
Devuelve una lista de los nombres de los campos de datos asociados con la característica. Esto será lo mismo para todas las características en una capa dada y es equivalente a la propiedad Layer.fields del objeto Layer del que provino la característica.
Devuelve el identificador de la característica dentro de la capa:
>>> city.fid
0
Devuelve el nombre del Layer del que provino la característica. Esto será lo mismo para todas las características en una capa dada:
>>> city.layer_name
'cities'
Un método que devuelve el índice del nombre del campo dado. Esto será lo mismo para todas las características en una capa dada:
>>> city.index("Population")
1
Campo¶Devuelve el nombre de este campo:
>>> city["Name"].name
'Name'
Devuelve el tipo OGR de este campo, como un entero. El diccionario FIELD_CLASSES mapea estos valores sobre subclases de Campo:
>>> city["Density"].type
2
Devuelve una cadena con el nombre del tipo de datos de este campo:
>>> city["Name"].type_name
'String'
Devuelve el valor de este campo. La clase Campo devuelve el valor como una cadena, pero cada subclase devuelve el valor en la forma más adecuada:
>>> city["Population"].value
102121
Devuelve el ancho de este campo:
>>> city["Name"].width
80
Devuelve la precisión numérica de este campo. Esto es insignificante (y se establece en cero) para campos no numéricos:
>>> city["Density"].precision
15
Devuelve el valor del campo como un doble (float):
>>> city["Density"].as_double()
874.7
Devuelve el valor del campo como un entero:
>>> city["Population"].as_int()
102121
Devuelve el valor del campo como una cadena:
>>> city["Name"].as_string()
'Pueblo'
Devuelve el valor del campo como tupla de componentes de fecha y hora:
>>> city["Created"].as_datetime()
(c_long(1999), c_long(5), c_long(23), c_long(0), c_long(0), c_long(0), c_long(0))
La clase Driver se utiliza internamente para envolver un conductor de datos OGR DataSource.
Devuelve el número de controladores de vectores OGR actualmente registrados.
Los objetos OGRGeometry comparten funcionalidades similares con los objetos GEOSGeometry y son envolturas delgadas alrededor de la representación interna de geometrías de OGR. Por lo tanto, permiten un acceso más eficiente a los datos cuando se utiliza DataSource. A diferencia de su homólogo GEOS, OGRGeometry admite sistemas de referencia espaciales y transformaciones de coordenadas:
>>> from django.contrib.gis.gdal import OGRGeometry
>>> polygon = OGRGeometry("POLYGON((0 0, 5 0, 5 5, 0 5))")
Este objeto es un envoltorio para la clase `OGR Geometry`__. Estos objetos se instancian directamente desde el parámetro geom_input dado, que puede ser una cadena conteniendo WKT, HEX, GeoJSON, un buffer conteniendo datos de WKB o un objeto OGRGeomType. Estos objetos también se devuelven desde la propiedad geom del objeto Feature, cuando se lee datos vectoriales desde Layer (que a su vez es parte de una DataSource).
Construye un objeto OGRGeometry a partir de la cadena de GML dada.
Construye un Polygon a partir de la caja de enfoque dada (un cuadrupla de 4 elementos).
Returns el número de puntos en una LineString, el número de anillos en un Polygon o el número de geometrías en un GeometryCollection. No es aplicable a otros tipos de geometría.
Itera sobre los puntos en una LineString, los anillos en un Polygon o las geometrías en un GeometryCollection. No es aplicable a otros tipos de geometría.
Returns el punto en la posición especificada para una LineString, el anillo interior en la posición especificada para un Polygon o la geometría en la posición especificada en un GeometryCollection. No es aplicable a otros tipos de geometría.
Returns el número de dimensiones coordinadas de la geometría, es decir 0 para puntos, 1 para líneas y así sucesivamente:
>>> polygon.dimension
2
Returns la dimensión de coordenada de esta geometría. Por ejemplo, el valor sería 2 para geometrías bidimensionales.
Obsoleto desde la versión 5.1: El setter coord_dim está descontinuado. Utilice set_3d() en su lugar.
Un booleano que indica si esta geometría tiene coordenadas Z.
Un método que agrega o elimina la dimensión de coordenada Z.
>>> p = OGRGeometry("POINT (1 2 3)")
>>> p.is_3d
True
>>> p.set_3d(False)
>>> p.wkt
"POINT (1 2)"
Un booleano que indica si esta geometría tiene coordenadas M.
Un método para agregar o eliminar la dimensión de coordenada M.
>>> p = OGRGeometry("POINT (1 2)")
>>> p.is_measured
False
>>> p.set_measured(True)
>>> p.wkt
"POINT M (1 2 0)"
Devuelve el número de elementos en esta geometría:
>>> polygon.geom_count
1
Un booleano que indica si esta geometría es o contiene una geometría de curva.
Devuelve una versión lineal de la geometría. Si no se puede realizar ninguna conversión, se devuelve la geometría original.
Devuelve una versión curva de la geometría. Si no se puede realizar ninguna conversión, se devuelve la geometría original.
Devuelve el número de puntos utilizados para describir esta geometría:
>>> polygon.point_count
4
Alias para point_count.
Alias para point_count.
Devuelve el tipo de esta geometría, como un objeto OGRGeomType.
Devuelve el nombre del tipo de geometría de este objeto.
>>> polygon.geom_name
'POLYGON'
Devuelve el área de esta geometría, o 0 para las geometrías que no contienen un área.
>>> polygon.area
25.0
Devuelve el envoltorio de esta geometría, como un objeto Envelope.
Regresa el envelope de esta geometría como un 4-tuple en lugar de como un objeto Envelope:
>>> point.extent
(0.0, 0.0, 5.0, 5.0)
Esta propiedad controla la referencia espacial para esta geometría, o None si no se ha asignado ningún sistema de referencias espaciales a ella. Si está asignada, acceder a esta propiedad devuelve un objeto SpatialReference. Puede establecerse con otro objeto SpatialReference o cualquier entrada que acepte SpatialReference. Ejemplo:
>>> city.geom.srs.name
'GCS_WGS_1984'
Regresa o establece el identificador de la referencia espacial correspondiente al objeto SpatialReference de esta geometría. Regresa None si no hay información de referencias espaciales asociada a esta geometría, o si no se puede determinar un SRID.
Regresa un objeto GEOSGeometry correspondiente a esta geometría.
Regresa una representación en cadena de esta geometría en formato GML:
>>> OGRGeometry("POINT(1 2)").gml
'<gml:Point><gml:coordinates>1,2</gml:coordinates></gml:Point>'
Regresa una representación en cadena de esta geometría en formato HEX WKB:
>>> OGRGeometry("POINT(1 2)").hex
'0101000000000000000000F03F0000000000000040'
Regresa una representación en cadena de esta geometría en formato JSON:
>>> OGRGeometry("POINT(1 2)").json
'{ "type": "Point", "coordinates": [ 1.000000, 2.000000 ] }'
Regresa una representación en cadena de esta geometría en formato KML.
Regresa el tamaño del buffer WKB necesario para contener una representación WKB de esta geometría:
>>> OGRGeometry("POINT(1 2)").wkb_size
21
Regresa un buffer que contiene una representación WKB de esta geometría.
Regresa una representación de cadena de esta geometría en formato WKT.
Devuelve la representación EWKT de esta geometría.
Devuelve una copia clonada nueva OGRGeometry de este objeto de geometría.
Si hay cualquier anillo dentro de esta geometría que no haya sido cerrado, esta rutina lo hará así añadiendo el punto inicial al final:
>>> triangle = OGRGeometry("LINEARRING (0 0,0 1,1 0)")
>>> triangle.close_rings()
>>> triangle.wkt
'LINEARRING (0 0,0 1,1 0,0 0)'
Transforma esta geometría a un sistema de referencia espacial diferente. Puede tomar un objeto CoordTransform, un objeto SpatialReference o cualquier otro input aceptado por SpatialReference (incluyendo cadenas WKT y PROJ de referencias espaciales, o un entero SRID).
Por defecto no se devuelve nada y la geometría se transforma en lugar. Sin embargo, si la palabra clave clone está configurada a True, entonces una copia clonada transformada de esta geometría se devuelve en su lugar.
Devuelve True si esta geometría intersecta al otro, de lo contrario devuelve False.
Devuelve True si esta geometría es equivalente a la otra, de lo contrario devuelve False.
Devuelve True si esta geometría está espacialmente disjunta (es decir, no intersecta) al otro, de lo contrario devuelve False.
Devuelve True si esta geometría toca a la otra, de lo contrario devuelve False.
Devuelvo las traducciones de los textos originales manteniendo todas sus etiquetas intactas.
Esta geometría está contenida dentro de la otra, devuelve True si es así, en caso contrario devuelve False.
Esta geometría contiene a la otra, devuelve True si es así, en caso contrario devuelve False.
Las geometrías se superponen si True, en caso contrario devuelve False.
La frontera de esta geometría, como un nuevo objeto OGRGeometry.
El polígono convexo más pequeño que contiene a esta geometría, como un nuevo objeto OGRGeometry.
Devuelve la región consistente en la diferencia de esta geometría y la otra, como un nuevo objeto OGRGeometry.
Devuelve la región consistente en la intersección de esta geometría y la otra, como un nuevo objeto OGRGeometry.
Devuelve la región consistente en la diferencia simétrica de esta geometría y la otra, como un nuevo objeto OGRGeometry.
Devuelve la región consistente en la unión de esta geometría y la otra, como un nuevo objeto OGRGeometry.
Regresa un objeto Punto que representa el centroide de esta geometría.
centroid se promovió desde una propiedad solo disponible en Polígono para estar disponible en todos los tipos de geometrías.
Devuelve las coordenadas de un punto geométrico como tupla, las coordenadas de una línea geométrica como tupla de tuplas, y así sucesivamente:
>>> OGRGeometry("POINT (1 2)").tuple
(1.0, 2.0)
>>> OGRGeometry("LINESTRING (1 2,3 4)").tuple
((1.0, 2.0), (3.0, 4.0))
Un alias para tupla.
Devuelve la coordenada X de este punto.
>>> OGRGeometry("POINT (1 2)").x
1.0
Devuelve la coordenada Y de este punto.
>>> OGRGeometry("POINT (1 2)").y
2.0
Devuelve la coordenada Z de este punto, o None si el punto no tiene una coordenada Z.
>>> OGRGeometry("POINT (1 2 3)").z
3.0
Devuelve la coordenada M de este punto, o None si el Punto no tiene una coordenada M.
>>> OGRGeometry("POINT ZM (1 2 3 4)").m
4.0
Devuelve una lista de coordenadas X en esta línea.
>>> OGRGeometry("LINESTRING (1 2,3 4)").x
[1.0, 3.0]
Devuelve una lista de coordenadas Y en esta línea.
>>> OGRGeometry("LINESTRING (1 2,3 4)").y
[2.0, 4.0]
Regresa una lista de coordenadas Z en esta línea, o None si la línea no tiene coordenadas Z:
>>> OGRGeometry("LINESTRING (1 2 3,4 5 6)").z
[3.0, 6.0]
Regresa una lista de coordenadas M en esta línea o None si la línea no tiene coordenadas M:
>>> OGRGeometry("LINESTRING(0 1 2 10, 1 2 3 11, 2 3 4 12)").m
[10.0, 11.0, 12.0]
Esta clase permite la representación de un tipo de geometría OGR de varias maneras:
>>> from django.contrib.gis.gdal import OGRGeomType
>>> gt1 = OGRGeomType(3) # Using an integer for the type
>>> gt2 = OGRGeomType("Polygon") # Using a string
>>> gt3 = OGRGeomType("POLYGON") # It's case-insensitive
>>> print(gt1 == 3, gt1 == "Polygon") # Equivalence works w/non-OGRGeomType objects
True True
Devuelve una forma de cadena corta del tipo de geometría OGR:
>>> gt1.name
'Polygon'
Regresa el número correspondiente al tipo de geometría OGR:
>>> gt1.num
3
Regresa el tipo de campo Django (una subclase de GeometryField) para almacenar este tipo OGR, o None si no hay un tipo Django apropiado:
>>> gt1.django
'PolygonField'
Envoltorio¶Representa una estructura OGR Envelope que contiene las coordenadas X y Y mínimas y máximas para un rectángulo de cuadro de encaje. El nombre de las variables es compatible con la estructura C OGR Envelope.
El valor de la coordenada X mínima.
El valor de la coordenada X máxima.
El valor de la coordenada Y mínima.
El valor de la coordenada Y máxima.
La coordenada superior-derecha, como tupla.
La coordenada inferior-izquierda, como tupla.
Una tupla que representa el envoltorio.
Una cadena que representa este envoltorio en formato WKT de polígono.
Los objetos de referencia espacial se inician con la entrada dada srs_input, que puede ser uno de los siguientes:
Texto conocido OGC (WKT) (una cadena)
Código EPSG (entero o cadena)
Cadena PROJ
Una cadena abreviada para estándares bien conocidos ('WGS84', 'WGS72', 'NAD27', 'NAD83')
Ejemplo:
>>> wgs84 = SpatialReference("WGS84") # shorthand string
>>> wgs84 = SpatialReference(4326) # EPSG code
>>> wgs84 = SpatialReference("EPSG:4326") # EPSG string
>>> proj = "+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs "
>>> wgs84 = SpatialReference(proj) # PROJ string
>>> wgs84 = SpatialReference("""GEOGCS["WGS 84",
... DATUM["WGS_1984",
... SPHEROID["WGS 84",6378137,298.257223563,
... AUTHORITY["EPSG","7030"]],
... AUTHORITY["EPSG","6326"]],
... PRIMEM["Greenwich",0,
... AUTHORITY["EPSG","8901"]],
... UNIT["degree",0.01745329251994328,
... AUTHORITY["EPSG","9122"]],
... AUTHORITY["EPSG","4326"]]""") # OGC WKT
Devuelve el valor de la nodo de atributo dado como cadena, None si el nodo no existe. También puede recibir un tupla como parámetro, (target, child), donde child es el índice del atributo en el WKT. Por ejemplo:
>>> wkt = 'GEOGCS["WGS 84", DATUM["WGS_1984, ... AUTHORITY["EPSG","4326"]]'
>>> srs = SpatialReference(wkt) # could also use 'WGS84', or 4326
>>> print(srs["GEOGCS"])
WGS 84
>>> print(srs["DATUM"])
WGS_1984
>>> print(srs["AUTHORITY"])
EPSG
>>> print(srs["AUTHORITY", 1]) # The authority value
4326
>>> print(srs["TOWGS84", 4]) # the fourth value in this wkt
0
>>> print(srs["UNIT|AUTHORITY"]) # For the units authority, have to use the pipe symbol.
EPSG
>>> print(srs["UNIT|AUTHORITY", 1]) # The authority value for the units
9122
El valor del atributo para el nodo objetivo dado (por ejemplo, 'PROJCS'). La palabra clave index especifica un índice del nodo hijo a devolver.
Devuelve el nombre de la autoridad para el nodo objetivo dado como cadena.
Devuelve el código de la autoridad para el nodo objetivo dado como cadena.
Devuelvo las traducciones de los textos originales manteniendo todas sus etiquetas intactas.
Este método inspecciona el WKT de este SpatialReference y agregará nodos de autoridad EPSG donde sea aplicable un identificador EPSG.
Transforma este SpatialReference desde el formato ESRI a EPSG
Transforma este SpatialReference al formato ESRI.
Verifica si la referencia espacial dada es válida, si no se levantará una excepción.
Importa la referencia espacial desde el código EPSG.
Importa la referencia espacial desde la cadena PROJ.
Importa la referencia espacial desde WKT.
Importa la referencia espacial desde XML.
Regresa el nombre de este Spatial Reference.
Devuelve la SRID de la autoridad de nivel superior, o None si no está definida.
Devuelve el nombre de las unidades lineales.
Devuelve el valor de las unidades lineales.
Devuelve el nombre de las unidades angulares.
Devuelve el valor de las unidades angulares.
Devuelve una tupla de 2 elementos con el valor de las unidades y el nombre de las unidades, y determina automáticamente si devolver las unidades lineales o angulares.
Devuelve una tupla de los parámetros del elipsoide para esta referencia espacial: (eje mayor semimayor, eje menor semiminor y inversa aplanamiento).
Devuelve el semieje mayor del elipsoide para esta referencia espacial.
Devuelve el eje semiminor del elipsoide para esta referencia espacial.
Devuelve la desinflación inversa del elipsoide para esta referencia espacial.
Returns Verdadero si esta referencia espacial es geográfica (el nodo raíz es GEOGCS).
Returns Verdadero si esta referencia espacial es local (el nodo raíz es LOCAL_CS).
Returns Verdadero si esta referencia espacial es un sistema de coordenadas proyectado (el nodo raíz es PROJCS).
Returns the WKT representation of this spatial reference.
Returns the “pretty” representation of the WKT.
Returns the PROJ representation for this spatial reference.
Alias for SpatialReference.proj.
Returns the XML representation of this spatial reference.
CoordTransform¶Representa una transformación de sistema de coordenadas. Se inicializa con dos SpatialReference, que representan los sistemas de coordenadas fuente y destino, respectivamente. Estos objetos deben usarse cuando se realiza la misma transformación de coordenadas en diferentes geometrías:
>>> ct = CoordTransform(SpatialReference("WGS84"), SpatialReference("NAD83"))
>>> for feat in layer:
... geom = feat.geom # getting clone of feature geometry
... geom.transform(ct) # transforming
...
GDALRaster es un envoltorio para el objeto de fuente raster GDAL que admite la lectura de datos desde una variedad de formatos de archivo geoespaciales y fuentes de datos soportados por GDAL mediante una interfaz consistente. Cada fuente de datos está representada por un objeto GDALRaster que contiene uno o más capas de datos denominadas bandas. Cada banda, representada por un objeto GDALBand, contiene datos de imagen georreferenciados. Por ejemplo, una imagen RGB se representa como tres bandas: una para el rojo, una para el verde y una para el azul.
Nota
Para los datos de raster no existe diferencia entre una instancia de raster y su fuente de datos. A diferencia de lo que ocurre con los objetos Geometry, los objetos GDALRaster siempre son una fuente de datos. Los rasters temporales se pueden instanciar en memoria utilizando el correspondiente driver, pero serán de la misma clase que las fuentes de raster basadas en archivos.
El constructor para GDALRaster acepta dos parámetros. El primer parámetro define la fuente del raster y el segundo parámetro define si un raster debe abrirse en modo de escritura. Para rasters recién creados, el segundo parámetro se ignora y siempre se crea el nuevo raster en modo de escritura.
El primer parámetro puede tomar tres formas: una cadena o Path que representa un camino de archivo (sistema de archivos o sistema de archivos virtual GDAL), un diccionario con valores que definen un nuevo rastro, o un objeto bytes que representa un archivo de rastro.
Si la entrada es un camino de archivo, el raster se abre desde allí. Si la entrada son datos brutos en un diccionario, los parámetros width, height y srid son necesarios. Si la entrada es un objeto bytes, se abrirá utilizando un sistema de archivos virtual GDAL.
Para una descripción detallada de cómo crear raster mediante entrada de diccionario, consulte Crear rasters desde datos. Para una descripción detallada de cómo crear rasters en el sistema de archivos virtual, consulte Utilizando la VFS (Virtual Filesystem) de GDAL.
El siguiente ejemplo muestra cómo se pueden crear raster desde diferentes fuentes de entrada (utilizando los datos de muestra del GeoDjango de pruebas; véase también la sección Datos de ejemplo).
>>> from django.contrib.gis.gdal import GDALRaster
>>> rst = GDALRaster("/path/to/your/raster.tif", write=False)
>>> rst.name
'/path/to/your/raster.tif'
>>> rst.width, rst.height # This file has 163 x 174 pixels
(163, 174)
>>> rst = GDALRaster(
... { # Creates an in-memory raster
... "srid": 4326,
... "width": 4,
... "height": 4,
... "datatype": 1,
... "bands": [
... {
... "data": (2, 3),
... "offset": (1, 1),
... "size": (2, 2),
... "shape": (2, 1),
... "nodata_value": 5,
... }
... ],
... }
... )
>>> rst.srs.srid
4326
>>> rst.width, rst.height
(4, 4)
>>> rst.bands[0].data()
array([[5, 5, 5, 5],
[5, 2, 3, 5],
[5, 2, 3, 5],
[5, 5, 5, 5]], dtype=uint8)
>>> rst_file = open("/path/to/your/raster.tif", "rb")
>>> rst_bytes = rst_file.read()
>>> rst = GDALRaster(rst_bytes)
>>> rst.is_vsi_based
True
>>> rst.name # Stored in a random path in the vsimem filesystem.
'/vsimem/da300bdb-129d-49a8-b336-e410a9428dad'
El nombre de la fuente equivalente al camino del archivo de entrada o el nombre proporcionado durante la instantiación.
>>> GDALRaster({"width": 10, "height": 10, "name": "myraster", "srid": 4326}).name
'myraster'
El nombre del driver GDAL utilizado para manejar el archivo de entrada. Para los rasters GDALRaster creados a partir de un archivo, se detecta automáticamente el tipo de driver. La creación de rasters desde cero es por defecto un raster en memoria ('MEM'), pero puede alterarse según sea necesario. Por ejemplo, utilice GTiff para un archivo GeoTiff. Para una lista de tipos de archivos, consulte también la `lista de formatos de raster GDAL`__.
Se crea un raster en memoria a través del siguiente ejemplo:
>>> GDALRaster({"width": 10, "height": 10, "srid": 4326}).driver.name
'MEM'
Se crea un raster basado en archivo GeoTiff a través del siguiente ejemplo:
>>> import tempfile
>>> rstfile = tempfile.NamedTemporaryFile(suffix=".tif")
>>> rst = GDALRaster(
... {
... "driver": "GTiff",
... "name": rstfile.name,
... "srid": 4326,
... "width": 255,
... "height": 255,
... "nr_of_bands": 1,
... }
... )
>>> rst.name
'/tmp/tmp7x9H4J.tif' # The exact filename will be different on your computer
>>> rst.driver.name
'GTiff'
Anchura del origen en píxeles (eje X).
>>> GDALRaster({"width": 10, "height": 20, "srid": 4326}).width
10
Altura del origen en píxeles (eje Y).
>>> GDALRaster({"width": 10, "height": 20, "srid": 4326}).height
20
Sistema de referencia espacial del raster, como instancia de la clase SpatialReference. El SRS puede cambiarse estableciéndolo a otra instancia de la clase SpatialReference o proporcionando cualquier entrada que se acepte en el constructor de la clase SpatialReference.
>>> rst = GDALRaster({"width": 10, "height": 20, "srid": 4326})
>>> rst.srs.srid
4326
>>> rst.srs = 3086
>>> rst.srs.srid
3086
Identificador del Sistema de Referencia Espacial (SRID) del raster. Esta propiedad es un atajo para obtener o establecer el SRID a través de la propiedad srs.
>>> rst = GDALRaster({"width": 10, "height": 20, "srid": 4326})
>>> rst.srid
4326
>>> rst.srid = 3086
>>> rst.srid
3086
>>> rst.srs.srid # This is equivalent
3086
La matriz de transformación afín utilizada para georeferenciar el origen, como tupla de seis coeficientes que mapean las coordenadas píxeles/linea en espacio georeferenciado utilizando la siguiente relación:
Xgeo = GT(0) + Xpixel * GT(1) + Yline * GT(2)
Ygeo = GT(3) + Xpixel * GT(4) + Yline * GT(5)
Los mismos valores se pueden recuperar accediendo a las propiedades origin (índices 0 y 3), scale (índices 1 y 5) y skew (índices 2 y 4).
El valor por defecto es [0.0, 1.0, 0.0, 0.0, 0.0, -1.0].
>>> rst = GDALRaster({"width": 10, "height": 20, "srid": 4326})
>>> rst.geotransform
[0.0, 1.0, 0.0, 0.0, 0.0, -1.0]
Coordenadas del origen superior izquierdo de la malla en el sistema de referencia espacial del origen, como un objeto punto con miembros x y y.
>>> rst = GDALRaster({"width": 10, "height": 20, "srid": 4326})
>>> rst.origin
[0.0, 0.0]
>>> rst.origin.x = 1
>>> rst.origin
[1.0, 0.0]
Anchura y altura de píxeles utilizados para georeferenciar la malla, como un objeto punto con miembros x y y. Consulte geotransform para obtener más información.
>>> rst = GDALRaster({"width": 10, "height": 20, "srid": 4326})
>>> rst.scale
[1.0, -1.0]
>>> rst.scale.x = 2
>>> rst.scale
[2.0, -1.0]
Coeficientes de torsión utilizados para georeferenciar la malla, como un objeto punto con miembros x y y. En el caso de imágenes orientadas hacia el norte, estos coeficientes son ambos 0.
>>> rst = GDALRaster({"width": 10, "height": 20, "srid": 4326})
>>> rst.skew
[0.0, 0.0]
>>> rst.skew.x = 3
>>> rst.skew
[3.0, 0.0]
Extensión (valores de límite) de la fuente de la malla, como una tupla de 4 elementos (xmin, ymin, xmax, ymax) en el sistema de referencia espacial del origen.
>>> rst = GDALRaster({"width": 10, "height": 20, "srid": 4326})
>>> rst.extent
(0.0, -20.0, 10.0, 0.0)
>>> rst.origin.x = 100
>>> rst.extent
(100.0, -20.0, 110.0, 0.0)
Lista de todas las bandas de la fuente, como instancias de GDALBand.
>>> rst = GDALRaster(
... {
... "width": 1,
... "height": 2,
... "srid": 4326,
... "bands": [{"data": [0, 1]}, {"data": [2, 3]}],
... }
... )
>>> len(rst.bands)
2
>>> rst.bands[1].data()
array([[ 2., 3.]], dtype=float32)
Devuelve una versión distorsionada de esta malla.
Los parámetros de distorsión pueden especificarse a través del argumento ds_input. El uso de ds_input es análogo al correspondiente argumento del constructor de la clase. Es un diccionario con las características de la malla objetivo. Los valores permitidos para los clave del diccionario son anchura, altura, SRID, origen, escala, torsión, tipo de dato, driver y nombre (nombre de archivo).
Por defecto, las funciones de distorsión mantienen la mayoría de los parámetros iguales a los valores de la fuente original, por lo que solo deben especificarse los parámetros que deban cambiar. Ten en cuenta que esto incluye el driver, por lo que para mallas basadas en archivos, la función de distorsión creará una nueva malla en disco.
El único parámetro que se establece diferente a la fuente original es el nombre. El valor predeterminado del nombre de la malla es el nombre de la fuente de la malla anexado con '_copy' + source_driver_name. Para las mallas basadas en archivos, se recomienda proporcionar la ruta del archivo de la malla objetivo.
El algoritmo de resampling utilizado para la distorsión puede especificarse con el argumento resampling. El valor predeterminado es NearestNeighbor, y los otros valores permitidos son Bilinear, Cubic, CubicSpline, Lanczos, Average y Mode.
El max_error argumento se puede utilizar para especificar el máximo error medido en píxeles de entrada que se permite al aproximar la transformación. El valor por defecto es 0.0 para cálculos exactos.
Para usuarios familiarizados con GDAL, esta función tiene una funcionalidad similar a la utilidad de línea de comandos gdalwarp.
Por ejemplo, la función warp se puede utilizar para agrupar un raster en la escala de píxeles original doblada:
>>> rst = GDALRaster(
... {
... "width": 6,
... "height": 6,
... "srid": 3086,
... "origin": [500000, 400000],
... "scale": [100, -100],
... "bands": [{"data": range(36), "nodata_value": 99}],
... }
... )
>>> target = rst.warp({"scale": [200, -200], "width": 3, "height": 3})
>>> target.bands[0].data()
array([[ 7., 9., 11.],
[ 19., 21., 23.],
[ 31., 33., 35.]], dtype=float32)
Transforma este raster a un sistema de referencia espacial diferente (srs), que puede ser un objeto SpatialReference o cualquier otro input aceptado por SpatialReference (incluyendo cadenas WKT y PROJ, o un entero SRID).
Calcula los límites y la escala del raster actual en el nuevo sistema de referencia espacial y warp el raster utilizando la función warp.
Por defecto, se utiliza el driver del raster fuente y el nombre del raster es el nombre original anexado con '_copy' + source_driver_name. Se puede especificar un driver o nombre diferente con los argumentos driver y name.
El algoritmo de resampling por defecto es NearestNeighbour pero se puede cambiar utilizando el argumento resampling. El máximo error permitido por defecto para la resampling es 0.0 y se puede cambiar utilizando el argumento max_error. Consulte la documentación de la función warp para detalles sobre esos argumentos.
>>> rst = GDALRaster(
... {
... "width": 6,
... "height": 6,
... "srid": 3086,
... "origin": [500000, 400000],
... "scale": [100, -100],
... "bands": [{"data": range(36), "nodata_value": 99}],
... }
... )
>>> target_srs = SpatialReference(4326)
>>> target = rst.transform(target_srs)
>>> target.origin
[-82.98492744885776, 27.601924753080144]
Devuelve una cadena con un resumen del raster. Esto es equivalente a la utilidad de línea de comandos gdalinfo__.
Los metadatos de este raster, representados como un diccionario anidado. La primera clave es el dominio de los metadatos y la segunda contiene los nombres e valores de los elementos de metadatos de cada dominio.
Para establecer o actualizar un elemento de metadatos, pasa el correspondiente elemento de metadatos a la función utilizando la estructura anidada descrita anteriormente. Solo se actualizan las claves que están en el diccionario especificado; el resto de los metadatos permanecen inalterados.
To remove a metadata item, use None as the metadata value.
>>> rst = GDALRaster({"width": 10, "height": 20, "srid": 4326})
>>> rst.metadata
{}
>>> rst.metadata = {"DEFAULT": {"OWNER": "Django", "VERSION": "1.0"}}
>>> rst.metadata
{'DEFAULT': {'OWNER': 'Django', 'VERSION': '1.0'}}
>>> rst.metadata = {"DEFAULT": {"OWNER": None, "VERSION": "2.0"}}
>>> rst.metadata
{'DEFAULT': {'VERSION': '2.0'}}
GDALBand¶Las instancias de GDALBand no se crean explícitamente, sino que se obtienen a partir de un objeto GDALRaster mediante su atributo bands. Los GDALBands contienen los valores reales de los píxeles del raster.
El nombre o descripción de la banda, si existe.
Anchura de la banda en píxeles (eje X).
Altura de la banda en píxeles (eje Y).
Número total de píxeles en esta banda. Es igual a anchura * altura.
Computa estadísticas sobre los valores de los píxeles de esta banda. El valor de retorno es una tupla con la siguiente estructura: (mínimo, máximo, media, desviación estándar).
Si el argumento approximate está establecido en True, las estadísticas pueden ser calculadas sobre vistas o una subconjunto de mosaicos de imagen.
Si el argumento refresh está establecido en True, las estadísticas se calcularán a partir de los datos directamente y el caché se actualizará con el resultado.
Si se encuentra un valor de caché persistente, ese valor se devuelve. Para formatos raster que utilizan servicios de metadatos auxiliares persistentes (PAM), las estadísticas pueden estar almacenadas en un archivo auxiliar. En algunos casos, este metadato puede no estar sincronizado con los valores de píxeles o causar que se devuelvan valores de una llamada anterior que no reflejan el valor del argumento approximate. En tales casos, utilice el argumento refresh para obtener valores actualizados y almacénelos en el caché.
Para bandas vacías (donde todos los valores de píxeles son «sin datos»), se devuelven todas las estadísticas como None.
Las estadísticas también pueden recuperarse directamente accediendo a las propiedades min, max, mean y std.
El valor mínimo de píxeles de la banda (excluyendo el valor «sin datos»).
El valor máximo de píxeles de la banda (excluyendo el valor «sin datos»).
La media de todos los valores de píxeles de la banda (excluyendo el valor «sin datos»).
La desviación estándar de todos los valores de píxeles de la banda (excluyendo el valor «sin datos»).
El valor «sin datos» para una banda es generalmente un valor marcador especial utilizado para marcar píxeles que no son datos válidos. Tales píxeles deben generalmente no ser mostrados ni contribuir a operaciones de análisis.
Para eliminar un valor de datos existente, establece esta propiedad en None.
El tipo de dato contenido en la banda, como una constante entera entre 0 (Desconocido) y 14. Si as_string es True, el tipo de dato se devuelve como cadena. Consulta la columna «Tipo de píxel GDAL» del tabla de valor de tipo de datos para valores posibles.
La interpretación de color para la banda, como un entero entre 0 y 16. Si as_string es True, el tipo de dato se devuelve como cadena con los siguientes valores posibles: GCI_Undefined, GCI_GrayIndex, GCI_PaletteIndex, GCI_RedBand, GCI_GreenBand, GCI_BlueBand, GCI_AlphaBand, GCI_HueBand, GCI_SaturationBand, GCI_LightnessBand, GCI_CyanBand, GCI_MagentaBand, GCI_YellowBand, GCI_BlackBand, GCI_YCbCr_YBand, GCI_YCbCr_CbBand y GCI_YCbCr_CrBand. GCI_YCbCr_CrBand también representa GCI_Max porque ambos corresponden al entero 16, pero solo GCI_YCbCr_CrBand se devuelve como cadena.
El acceso a los valores de píxel de la GDALBand. Se devuelve el conjunto completo de datos si no se proporcionan parámetros. Un subconjunto del array de píxeles se puede solicitar especificando un desplazamiento y tamaño de bloque como tuplas.
Si NumPy está disponible, los datos se devuelven como una matriz NumPy. Por razones de rendimiento, se recomienda ampliamente utilizar NumPy.
Los datos se escriben en la GDALBand si el parámetro data se proporciona. La entrada puede ser uno de los siguientes tipos - cadena empaquetada, buffer, lista, array y matriz NumPy. El número de elementos en la entrada debe corresponder normalmente al total de píxeles en la banda o a los píxeles para un bloque específico de valores de píxel si se proporcionan los parámetros offset y size.
Si el número de elementos en la entrada difiere del bloque de píxeles objetivo, debe especificarse el parámetro shape. La forma es una tupla que especifica el ancho y alto de los datos de entrada en píxeles. Los datos se repiten para actualizar los valores de píxel del bloque seleccionado. Esto es útil para llenar toda la banda con un valor único, por ejemplo.
Ejemplo:
>>> rst = GDALRaster(
... {"width": 4, "height": 4, "srid": 4326, "datatype": 1, "nr_of_bands": 1}
... )
>>> bnd = rst.bands[0]
>>> bnd.data(range(16))
>>> bnd.data()
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11],
[12, 13, 14, 15]], dtype=int8)
>>> bnd.data(offset=(1, 1), size=(2, 2))
array([[ 5, 6],
[ 9, 10]], dtype=int8)
>>> bnd.data(data=[-1, -2, -3, -4], offset=(1, 1), size=(2, 2))
>>> bnd.data()
array([[ 0, 1, 2, 3],
[ 4, -1, -2, 7],
[ 8, -3, -4, 11],
[12, 13, 14, 15]], dtype=int8)
>>> bnd.data(data="\x9d\xa8\xb3\xbe", offset=(1, 1), size=(2, 2))
>>> bnd.data()
array([[ 0, 1, 2, 3],
[ 4, -99, -88, 7],
[ 8, -77, -66, 11],
[ 12, 13, 14, 15]], dtype=int8)
>>> bnd.data([1], shape=(1, 1))
>>> bnd.data()
array([[1, 1, 1, 1],
[1, 1, 1, 1],
[1, 1, 1, 1],
[1, 1, 1, 1]], dtype=uint8)
>>> bnd.data(range(4), shape=(1, 4))
array([[0, 0, 0, 0],
[1, 1, 1, 1],
[2, 2, 2, 2],
[3, 3, 3, 3]], dtype=uint8)
Los metadatos de esta banda. La funcionalidad es idéntica a GDALRaster.metadata.
Esta sección describe cómo crear rasters desde cero utilizando el parámetro ds_input.
Un nuevo raster se crea cuando se pasa un dict al constructor de la clase GDALRaster. El diccionario contiene parámetros definitorios del nuevo raster, como el origen, tamaño o sistema de referencia espacial. El diccionario también puede contener datos de píxeles e información sobre el formato del nuevo raster. El raster resultante puede ser basado en archivo o memoria, dependiendo del controlador especificado.
No existe un estándar para describir datos de rasters en un diccionario o formato JSON. La definición del input de diccionario a la clase GDALRaster es por lo tanto específica de Django. Está inspirada en el formato geojson, pero el estándar geojson actualmente se limita a formatos vectoriales.
Puedes encontrar ejemplos del uso de las diferentes claves al crear rasters en la documentación de los atributos y métodos correspondientes de las clases GDALRaster y GDALBand.
ds_input¶Solo se requieren unas pocas claves en el diccionario ds_input para crear un raster: width, height y srid. Todos los otros parámetros tienen valores por defecto (ver la tabla a continuación). La lista de claves que se pueden pasar en el diccionario ds_input está estrechamente relacionada pero no idéntica con las propiedades de la clase GDALRaster. Muchos de los parámetros están mapeados directamente a esas propiedades; los otros se describen a continuación.
La siguiente tabla describe todas las claves que se pueden establecer en el diccionario ds_input.
Clave |
Valor por defecto |
Uso |
|---|---|---|
srid |
Requerido |
Mapeado a la |
|
Requerido |
Mapeado al |
|
Requerido |
Mapeado al |
|
|
Mapeado a la |
|
|
See below |
|
|
Mapeado a la |
|
|
Mapeado al |
|
|
Mapeado al |
|
|
See below |
|
|
See below |
|
|
See below |
|
|
See below |
Representa el nombre de la malla raster. Al crear una malla raster basada en archivos, este parámetro debe ser la ruta del archivo para la nueva malla raster. Si el nombre comienza con /vsimem/, la malla raster se crea en el sistema de archivos virtual de GDAL.
Entero que representa el tipo de dato para todas las bandas. Por defecto, es 6 (Float32). Todas las bandas de una nueva malla raster deben tener el mismo tipo de dato. La tabla de correspondencia es:
Valor |
Tipo de píxel GDAL |
Descripción |
|---|---|---|
1 |
GDT_Byte |
Entero sin signo de 8 bits |
2 |
Entendido. Aquí están las traducciones: |
Entero sin signo de 16 bits |
3 |
GDT_Int16 |
Entero de 16 bits |
4 |
GDT_UInt32 |
Entero sin signo de 32 bits |
5 |
GDT_Int32 |
Entero de 32 bits |
6 |
GDT_Float32 |
punto flotante de 32 bits |
7 |
GDT_Float64 |
punto flotante de 64 bits |
12 |
GDT_UInt64 |
entero sin signo de 64 bits (GDAL 3.5+) |
13 |
GDT_Int64 |
Entero de 64 bits firmado (GDAL 3.5+) |
14 |
GDT_Int8 |
Entero de 8 bits firmado (GDAL 3.7+) |
Un entero que representa el número de bandas del raster. Se puede crear un raster sin pasar los datos de las bandas al momento de la creación. Si no se especifica el número de bandas, se calcula automáticamente a partir de la longitud de la entrada bands. El número de bandas no se puede cambiar después de la creación.
Una lista de diccionarios band_input con datos de entrada de las bandas. Los índices de las bandas resultantes son los mismos que en la lista proporcionada. La definición del diccionario de entrada de la banda se da a continuación. Si no se proporcionan los datos de las bandas, los valores de las bandas del raster se instancian como un array de ceros y el valor «sin datos» se establece en None.
Un diccionario con opciones de creación del raster. Las pares clave-valor del diccionario de entrada se pasan al driver al crear el raster.
Las opciones disponibles son específicas del driver y se describen en la documentación de cada driver.
Los valores en el diccionario no son sensibles a mayúsculas/minúsculas y se convierten automáticamente al formato de cadena correcto al crear el raster.
El siguiente ejemplo utiliza algunas de las opciones disponibles para el `driver GTiff`__. El resultado es un raster comprimido con un esquema de tiling interno. Los tiles internos tienen un tamaño de bloque de 23 por 23:
>>> GDALRaster(
... {
... "driver": "GTiff",
... "name": "/path/to/new/file.tif",
... "srid": 4326,
... "width": 255,
... "height": 255,
... "nr_of_bands": 1,
... "papsz_options": {
... "compress": "packbits",
... "tiled": "yes",
... "blockxsize": 23,
... "blockysize": 23,
... },
... }
... )
band_input dictionary¶La clave bands en el diccionario ds_input es una lista de diccionarios band_input. Cada diccionario band_input puede contener valores de píxeles y el valor «sin datos» que se establecerá en las bandas del nuevo raster. La matriz de datos puede tener el tamaño completo del nuevo raster o ser menor. Para matrices que son menores que el raster completo, las claves size, shape y offset controlan los valores de píxeles. Las claves correspondientes se pasan al método data(). Su funcionalidad es la misma que establecer los datos de la banda con ese método. La siguiente tabla describe las claves que se pueden utilizar.
Clave |
Valor por defecto |
Uso |
|---|---|---|
|
|
Mapeado a la propiedad |
|
Igual que |
Pasado al método |
|
|
Pasado al método |
|
Lo mismo que el tamaño |
Pasado al método |
|
|
Pasado al método |
GDAL puede acceder a archivos almacenados en el sistema de archivos, pero también admite sistemas de archivos virtuales para abstractar el acceso a otros tipos de archivos, como archivos comprimidos, cifrados o remotos.
GDAL tiene un sistema de archivos interno basado en memoria, que permite tratar bloques de memoria como archivos. Puede utilizarse para leer y escribir objetos GDALRaster a partir de y hacia buffers de archivo binarios.
Esto es útil en contextos web donde los rasters pueden obtenerse como un buffer desde una almacenamiento remoto o devolverse desde una vista sin ser escritos en disco.
Raster de GDAL se crean en el sistema de archivos virtual cuando se proporciona un objeto bytes como entrada, o cuando la ruta del archivo comienza con /vsimem/.
La entrada proporcionada como bytes tiene que ser una representación binaria completa de un archivo. Por ejemplo:
# Read a raster as a file object from a remote source.
>>> from urllib.request import urlopen
>>> dat = urlopen("https://example.com/raster.tif").read()
# Instantiate a raster from the bytes object.
>>> rst = GDALRaster(dat)
# The name starts with /vsimem/, indicating that the raster lives in the
# virtual filesystem.
>>> rst.name
'/vsimem/da300bdb-129d-49a8-b336-e410a9428dad'
Para crear un nuevo raster basado en archivos virtuales desde cero, utilice la representación del diccionario ds_input y proporcione un argumento name que comience con /vsimem/ (para detalles sobre la representación del diccionario, consulte Crear rasters desde datos). Para rasters basados en archivos virtuales, el atributo vsi_buffer devuelve la representación bytes del raster.
Aquí está cómo crear un raster y devolverlo como archivo en una respuesta HTTP: HttpResponse.
>>> from django.http import HttpResponse
>>> rst = GDALRaster(
... {
... "name": "/vsimem/temporarymemfile",
... "driver": "tif",
... "width": 6,
... "height": 6,
... "srid": 3086,
... "origin": [500000, 400000],
... "scale": [100, -100],
... "bands": [{"data": range(36), "nodata_value": 99}],
... }
... )
>>> HttpResponse(rast.vsi_buffer, "image/tiff")
Dependiendo de la compilación local de GDAL, pueden estar disponibles otros sistemas de archivos virtuales. Puedes utilizarlos agregando el prefijo apropiado /vsi*/ a la ruta proporcionada. Consulte la documentación sobre sistemas de archivos virtuales de GDAL para obtener más detalles.
En lugar de descomprimir el archivo e instanciar el raster resultante, GDAL puede acceder directamente a los archivos comprimidos utilizando los sistemas de archivos virtuales /vsizip/, /vsigzip/ o /vsitar/.
>>> from django.contrib.gis.gdal import GDALRaster
>>> rst = GDALRaster("/vsizip/path/to/your/file.zip/path/to/raster.tif")
>>> rst = GDALRaster("/vsigzip/path/to/your/file.gz")
>>> rst = GDALRaster("/vsitar/path/to/your/file.tar/path/to/raster.tif")
GDAL puede admitir recursos y proveedores de almacenamiento en línea de manera transparente. Basta con que esté construido con dichas capacidades.
Para acceder a un archivo raster público sin autenticación, puedes utilizar /vsicurl/:
>>> from django.contrib.gis.gdal import GDALRaster
>>> rst = GDALRaster("/vsicurl/https://example.com/raster.tif")
>>> rst.name
'/vsicurl/https://example.com/raster.tif'
Para proveedores de almacenamiento comerciales (por ejemplo, /vsis3/) el sistema debe estar configurado previamente para la autenticación y posiblemente otras configuraciones (consultar la documentación del GDAL Virtual Filesystems para ver las opciones disponibles).
GDAL_LIBRARY_PATH¶Una cadena que especifica la ubicación de la biblioteca GDAL. Normalmente, esta configuración solo se utiliza si la biblioteca GDAL está en una ubicación no estándar (por ejemplo, /home/john/lib/libgdal.so).
may 31, 2026