GEOS se refiere a Motor de Geometrías - Fuente Abierta, y es una biblioteca en C++, portada desde la Java Topology Suite. GEOS implementa las funciones y operadores espaciales del predicado espacial simple de OpenGIS Simple Features for SQL . GEOS, ahora un proyecto de OSGeo, fue inicialmente desarrollado y mantenido por Refractions Research de Victoria, Canadá.
GeoDjango implementa una capa de abstracción en Python para la biblioteca GEOS, sus características incluyen:
Una interfaz bajo licencia BSD a las rutinas geométricas de GEOS, implementadas puramente en Python utilizando ctypes.
Conexión suelta con GeoDjango. Por ejemplo, objetos GEOSGeometry pueden ser utilizados fuera de un proyecto o aplicación Django. En otras palabras, no es necesario tener establecida la variable de entorno DJANGO_SETTINGS_MODULE ni utilizar una base de datos, etc.
Mutabilidad: los objetos GEOSGeometry pueden ser modificados.
Cross-platform probado.
Esta sección contiene una breve introducción y tutorial sobre el uso de objetos GEOSGeometry.
Los objetos GEOSGeometry pueden crearse de varias maneras. La primera es simplemente instanciar el objeto en algún input espacial – los siguientes son ejemplos de crear la misma geometría a partir de WKT, HEX, WKB y GeoJSON:
>>> from django.contrib.gis.geos import GEOSGeometry
>>> pnt = GEOSGeometry("POINT(5 23)") # WKT
>>> pnt = GEOSGeometry("010100000000000000000014400000000000003740") # HEX
>>> pnt = GEOSGeometry(
... memoryview(
... b"\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14@\x00\x00\x00\x00\x00\x007@"
... )
... ) # WKB
>>> pnt = GEOSGeometry(
... '{ "type": "Point", "coordinates": [ 5.000000, 23.000000 ] }'
... ) # GeoJSON
Otra opción es utilizar el constructor para el tipo específico de geometría que deseas crear. Por ejemplo, un objeto Point se puede crear pasando las coordenadas X e Y en su constructor:
>>> from django.contrib.gis.geos import Point
>>> pnt = Point(5, 23)
Todos estos constructores aceptan la argumento clave srid. Por ejemplo:
>>> from django.contrib.gis.geos import GEOSGeometry, LineString, Point
>>> print(GEOSGeometry("POINT (0 0)", srid=4326))
SRID=4326;POINT (0 0)
>>> print(LineString((0, 0), (1, 1), srid=4326))
SRID=4326;LINESTRING (0 0, 1 1)
>>> print(Point(0, 0, srid=32140))
SRID=32140;POINT (0 0)
Finalmente, hay el método de fábrica fromfile() que devuelve un objeto GEOSGeometry a partir de un archivo:
>>> from django.contrib.gis.geos import fromfile
>>> pnt = fromfile("/path/to/pnt.wkt")
>>> pnt = fromfile(open("/path/to/pnt.wkt"))
Los objetos GEOSGeometry son “Pythonicos”, es decir, los componentes pueden ser accedidos, modificados y recorridos utilizando convenciones estándar de Python. Por ejemplo, puedes recorrer las coordenadas en un Point:
>>> pnt = Point(5, 23)
>>> [coord for coord in pnt]
[5.0, 23.0]
Con cualquier objeto de geometría, la propiedad GEOSGeometry.coords se puede utilizar para obtener las coordenadas de la geometría como una tupla de Python:
>>> pnt.coords
(5.0, 23.0)
Puedes obtener/establecer los componentes de la geometría utilizando técnicas estándar de indexación de Python. Sin embargo, lo que se devuelve depende del tipo de geometría del objeto. Por ejemplo, la indexación en un LineString devuelve una tupla de coordenadas:
>>> from django.contrib.gis.geos import LineString
>>> line = LineString((0, 0), (0, 50), (50, 50), (50, 0), (0, 0))
>>> line[0]
(0.0, 0.0)
>>> line[-2]
(50.0, 0.0)
Mientras que la indexación en un Polygon devolverá el anillo (un objeto LinearRing) correspondiente al índice:
>>> from django.contrib.gis.geos import Polygon
>>> poly = Polygon(((0.0, 0.0), (0.0, 50.0), (50.0, 50.0), (50.0, 0.0), (0.0, 0.0)))
>>> poly[0]
<LinearRing object at 0x1044395b0>
>>> poly[0][-2] # second-to-last coordinate of external ring
(50.0, 0.0)
Además, las coordenadas/componentes de la geometría pueden agregarse o modificarse, exactamente como una lista de Python:
>>> line[0] = (1.0, 1.0)
>>> line.pop()
(0.0, 0.0)
>>> line.append((1.0, 1.0))
>>> line.coords
((1.0, 1.0), (0.0, 50.0), (50.0, 50.0), (50.0, 0.0), (1.0, 1.0))
Las geometrías admiten operadores set-like:
>>> from django.contrib.gis.geos import LineString
>>> ls1 = LineString((0, 0), (2, 2))
>>> ls2 = LineString((1, 1), (3, 3))
>>> print(ls1 | ls2) # equivalent to `ls1.union(ls2)`
MULTILINESTRING ((0 0, 1 1), (1 1, 2 2), (2 2, 3 3))
>>> print(ls1 & ls2) # equivalent to `ls1.intersection(ls2)`
LINESTRING (1 1, 2 2)
>>> print(ls1 - ls2) # equivalent to `ls1.difference(ls2)`
LINESTRING(0 0, 1 1)
>>> print(ls1 ^ ls2) # equivalent to `ls1.sym_difference(ls2)`
MULTILINESTRING ((0 0, 1 1), (2 2, 3 3))
El operador de igualdad no verifica la igualdad espacial
El operador de igualdad GEOSGeometry utiliza el método equals_exact(), no el método equals(), es decir, requiere que las geometrías comparadas tengan las mismas coordenadas en las mismas posiciones con los mismos SRIDs:
>>> from django.contrib.gis.geos import LineString
>>> ls1 = LineString((0, 0), (1, 1))
>>> ls2 = LineString((1, 1), (0, 0))
>>> ls3 = LineString((1, 1), (0, 0), srid=4326)
>>> ls1.equals(ls2)
True
>>> ls1 == ls2
False
>>> ls3 == ls2 # different SRIDs
False
GEOSGeometry¶geo_input – Valor de entrada geométrica (cadena o memoryview)
srid (int) – identificador de referencia espacial
Esta es la clase base para todos los objetos de geometría GEOS. Se inicializa con el argumento geo_input dado, y luego asume la clase de geometría adecuada (por ejemplo, GEOSGeometry('POINT(1 1)') creará un objeto Point).
El parámetro srid, si se proporciona, se establece como el SRID de la geometría creada si geo_input no tiene un SRID. Si se proporcionan diferentes SRIDs a través de los parámetros geo_input y srid, se levanta una ValueError:
>>> from django.contrib.gis.geos import GEOSGeometry
>>> GEOSGeometry("POINT EMPTY", srid=4326).ewkt
'SRID=4326;POINT EMPTY'
>>> GEOSGeometry("SRID=4326;POINT EMPTY", srid=4326).ewkt
'SRID=4326;POINT EMPTY'
>>> GEOSGeometry("SRID=1;POINT EMPTY", srid=4326)
Traceback (most recent call last):
...
ValueError: Input geometry already has SRID: 1.
Los siguientes formatos de entrada, junto con sus tipos de Python correspondientes, son aceptados:
Formato |
Tipo de entrada |
|---|---|
WKT / EWKT |
|
HEX / HEXEWKB |
|
WKB / EWKB |
memoryview |
|
Para el formato GeoJSON, se establece la SRID según el miembro crs. Si no se proporciona crs, la SRID predeterminada es 4326.
Construye un GEOSGeometry a partir de la cadena GML dada.
Devuelve las coordenadas de la geometría como tupla.
Devuelve el dimensionamiento de la geometría:
0 para los Points y MultiPoints
1 para LineStrings y MultiLineStrings
2 para Polygons y MultiPolygons
-1 para colecciones de geometrías vacías
el máximo número de dimensiones de sus elementos para colecciones de geometrías no vacías
Devuelve si el conjunto de puntos en la geometría está vacío.
Devuelve una cadena correspondiente al tipo de geometría. Por ejemplo:
>>> pnt = GEOSGeometry("POINT(5 23)")
>>> pnt.geom_type
'Point'
Devuelve el número de identificación del tipo de geometría GEOS. La siguiente tabla muestra el valor para cada tipo de geometría:
Geometría |
ID |
|---|---|
0 |
|
1 |
|
2 |
|
3 |
|
4 |
|
5 |
|
6 |
|
7 |
Devuelve el número de coordenadas en la geometría.
Devuelve el número de geometrías en esta geometría. En otras palabras, devolverá 1 en cualquier cosa excepto colecciones de geometrías.
Returns a boolean indicando si la geometría es tridimensional.
Returns a boolean indicando si la geometría es un LinearRing.
Returns a boolean indicando si la geometría es “simple”. Una geometría es simple si y sólo si no se interseca consigo misma (excepto en puntos de frontera). Por ejemplo, un objeto LineString no es simple si se interseca consigo mismo. Por lo tanto, los objetos LinearRing y Polygon siempre son simples porque no pueden intersecarse entre sí, por definición.
Returns a boolean indicando si la geometría es válida.
Returns una cadena que describe el motivo por el cual la geometría es inválida.
Propiedad que puede usarse para recuperar o establecer el SRID asociado con la geometría. Por ejemplo:
>>> pnt = Point(5, 23)
>>> print(pnt.srid)
None
>>> pnt.srid = 4326
>>> pnt.srid
4326
Las propiedades en esta sección exportan el objeto GEOSGeometry a un formato diferente. Esta salida puede ser una cadena, un buffer o incluso otro objeto.
Returns la «extensa» Well-Known Text de la geometría. Esta representación es específica de PostGIS y es un superset del estándar OGC WKT. [1] Esencialmente, el SRID se prefiere a la representación WKT, por ejemplo SRID=4326;POINT(5 23).
Nota
La salida de esta propiedad no incluye la información 3dm, 3dz y 4d que PostGIS soporta en sus representaciones EWKT.
Returns the WKB of this Geometry in hexadecimal form. Please note
that the SRID value is not included in this representation
because it is not a part of the OGC specification (use the
GEOSGeometry.hexewkb property instead).
Returns the EWKB of this Geometry in hexadecimal form. This is an extension of the WKB specification that includes the SRID value that are a part of this geometry.
Returns the GeoJSON representation of the geometry. Note that the result is
not a complete GeoJSON structure but only the geometry key content of a
GeoJSON structure. See also Serializador GeoJSON.
Alias for GEOSGeometry.json.
Returns a KML (Keyhole Markup Language) representation of the geometry. This should only be used for geometries with an SRID of 4326 (WGS84), but this restriction is not enforced.
Returns an OGRGeometry object
corresponding to the GEOS geometry.
Returns the WKB (Well-Known Binary) representation of this Geometry
as a Python buffer. SRID value is not included, use the
GEOSGeometry.ewkb property instead.
Return the EWKB representation of this Geometry as a Python buffer. This is an extension of the WKB specification that includes any SRID value that are a part of this geometry.
Returns the Well-Known Text of the geometry (an OGC standard).
Todos los métodos de predicados espaciales siguientes toman otra instancia de GEOSGeometry (other) como parámetro, y devuelven un booleano.
Devuelve True si other.within(this) devuelve True.
Devuelve True si esta geometría cubre la geometría especificada.
El predicado covers tiene las siguientes definiciones equivalentes:
Cada punto de la otra geometría es un punto de esta geometría.
La Matriz de Intersección DE-9IM para las dos geometrías es T*****FF*, *T****FF*, ***T**FF*, o ****T*FF*.
Si alguna de las geometrías está vacía, devuelve False.
Este predicado es similar a GEOSGeometry.contains(), pero es más inclusivo (es decir, devuelve True en más casos). En particular, a diferencia de contains() no distingue entre puntos en la frontera y en el interior de las geometrías. Para la mayoría de situaciones, covers() debería preferirse a contains(). Como beneficio adicional, covers() es más susceptible de optimización y por lo tanto debería superar a contains() en rendimiento.
Devuelve True si la matriz de intersección DE-9IM para las dos Geometrías es T*T****** (para un punto y una curva, un punto y una área o una línea y una área) 0******** (para dos curvas).
Devuelve True si la matriz de intersección DE-9IM para las dos geometrías es FF*FF****.
Devuelvo las traducciones de los textos originales.
Devuelve True si las dos geometrías son exactamente iguales, hasta una tolerancia especificada. El valor de tolerance debe ser un número flotante que represente la tolerancia de error en la comparación, por ejemplo, poly1.equals_exact(poly2, 0.001) comparará la igualdad con una precisión de una milésima de unidad.
Devuelve True si las dos geometrías son equivalentes punto a punto al verificar que la estructura, el orden y los valores de todos los vértices sean idénticos en todas las dimensiones. Los valores NaN se consideran iguales a otros valores NaN. Requiere GEOS 3.12.
Devuelve True si GEOSGeometry.disjoint() es False.
Devuelve True si la matriz de intersección DE-9IM para las dos geometrías es T*T***T** (para dos puntos o dos superficies) 1*T***T** (para dos curvas).
Devuelve True si los elementos en la matriz de intersección DE-9IM para esta geometría y el otro coinciden con el patrón dado – una cadena de nueve caracteres del alfabeto: {T, F, *, 0}.
Devuelve True si la matriz de intersección DE-9IM para las dos geometrías es FT*******, F**T***** o F***T****.
Devuelve True si la matriz de intersección DE-9IM para las dos geometrías es T*F**F***.
Devuelve una GEOSGeometry que representa todos los puntos cuya distancia desde esta geometría es menor o igual a la dada width. La palabra clave opcional quadsegs establece el número de segmentos utilizados para aproximar un cuarto de círculo (por defecto es 8).
Same como buffer(), pero permite personalizar el estilo del buffer.
end_cap_style puede ser redondo (1), plano (2) o cuadrado (3).
join_style puede ser redondo (1), mitra (2) o codo (3).
La relación de mitra limita solo el estilo de unión mitrada.
Devuelve una GEOSGeometry que representa los puntos que componen esta geometría y no componen otras.
Dado una distancia (float), devuelve el punto (o el punto más cercano) dentro de la geometría (LineString o MultiLineString) en esa distancia. La versión normalizada toma la distancia como un float entre 0 (origen) y 1 (punto final).
Inversa de GEOSGeometry.project().
Devuelve una GEOSGeometry que representa los puntos compartidos por esta geometría y otras.
Devuelve la distancia (float) desde el origen de la geometría (LineString o MultiLineString) al punto proyectado en la geometría (es decir, a un punto de la línea más cercano al punto dado). La versión normalizada devuelve la distancia como un float entre 0 (origen) y 1 (punto final).
Inversa de GEOSGeometry.interpolate().
Los textos traducidos son:
Devuelve una nueva GEOSGeometry, simplificada al especificado con tolerancia utilizando el algoritmo Douglas-Peucker. Un valor de tolerancia más alto implica menos puntos en la salida. Si no se proporciona ninguna tolerancia, es 0 por defecto.
Por defecto, esta función no preserva la topología. Por ejemplo, los objetos Polygon pueden ser divididos, colapsados en líneas o desaparecer. Los agujeros de los polígonos Polygon pueden crearse o desaparecer, y las líneas pueden cruzar. Al especificar preserve_topology=True, el resultado tendrá la misma dimensión y número de componentes que la entrada; esto es significativamente más lento, sin embargo.
Devuelve una GEOSGeometry combinando los puntos en esta geometría no en otros, y los puntos en otros no en esta geometría.
Devuelve una GEOSGeometry que representa todos los puntos en esta geometría y la otra.
Devuelve la frontera como un objeto Geometry recién asignado.
Devuelve un objeto Point que representa el centro geométrico de la geometría. El punto no está garantizado para estar en el interior de la geometría.
Devuelve el polígono más pequeño que contiene todos los puntos en la geometría.
Devuelve un Polygon que representa el envoltorio de contorno de esta geometría. Tenga en cuenta que también puede devolver un Point si la geometría de entrada es un punto.
Calcula y devuelve un Punto garantizado que se encuentra en el interior de esta geometría.
Calcula la unión de todos los elementos de esta geometría.
El resultado obedece al siguiente contrato:
Unión de un conjunto de LineString tiene el efecto de noder completamente y disolver la línea.
La unión de un conjunto de Polygons siempre devuelve una geometría de tipo Polygon o MultiPolygon (a diferencia de la función GEOSGeometry.union(), que puede devolver geometrías de menor dimensión si ocurre una colapsación topológica).
Esta propiedad devuelve el área de la Geometría.
Esta propiedad devuelve la extensión de esta geometría como un 4-tupla, compuesta por (xmin, ymin, xmax, ymax).
Este método devuelve un GEOSGeometry que es una copia del original.
Devuelve la distancia entre los puntos más cercanos en esta geometría y el dado geom (otro objeto de geometría GEOSGeometry).
Nota
Los cálculos de distancia GEOS son lineales – en otras palabras, GEOS no realiza un cálculo esférico aunque el SRID especifique un sistema de coordenadas geográficas.
Devuelve la longitud de esta geometría (por ejemplo, 0 para un Point, la longitud de un LineString o la circunferencia de un Polygon).
Devuelve una GEOS PreparedGeometry para el contenido de esta geometría. Los objetos PreparedGeometry están optimizados para las operaciones contiene, intersecta, cubre, cruza, es disjointo, superpone y toca. Consulte la documentación sobre geometrías preparadas para obtener más información.
Devuelve un objeto de referencia espacial SpatialReference correspondiente al SRID de la geometría o None.
Transforma la geometría según el parámetro de transformación de coordenadas dado (ct), que puede ser un número entero SRID, una cadena WKT de referencia espacial, una cadena PROJ, un objeto SpatialReference o un objeto CoordTransform. Por defecto, la geometría se transforma en lugar y no se devuelve nada. Sin embargo, si el parámetro clone está establecido, entonces la geometría no se modifica y se devuelve una copia transformada de la geometría en lugar.
Nota
Lanza GEOSException si GDAL no está disponible o si el SRID de la geometría es None o menor que 0. No impone ninguna restricción sobre el SRID de la geometría si se llama con un objeto CoordTransform.
Devuelve una geometría equivalente válida GEOSGeometry, intentando no perder ninguno de los vértices de entrada. Si la geometría ya es válida, se devuelve sin cambios. Esto es similar a la función de base de datos MakeValid. Requiere GEOS 3.8.
Convierte esta geometría en forma canónica. Si el parámetro clone está establecido, entonces la geometría no se modifica y se devuelve una copia normalizada de la geometría en lugar:
>>> g = MultiPoint(Point(0, 0), Point(2, 2), Point(1, 1))
>>> print(g)
MULTIPOINT (0 0, 2 2, 1 1)
>>> g.normalize()
>>> print(g)
MULTIPOINT (2 2, 1 1, 0 0)
Point¶Los objetos Point se instancian utilizando argumentos que representan las coordenadas componentes del punto o con una sola secuencia de coordenadas. Por ejemplo, los siguientes son equivalentes:
>>> pnt = Point(5, 23)
>>> pnt = Point([5, 23])
Objetos vacíos Point pueden ser instanciados pasando ningún argumento o una secuencia vacía. Los siguientes son equivalentes:
>>> pnt = Point()
>>> pnt = Point([])
LineString¶Los objetos LineString se instancian utilizando argumentos que son una secuencia de coordenadas o objetos Point. Por ejemplo, los siguientes son equivalentes:
>>> ls = LineString((0, 0), (1, 1))
>>> ls = LineString(Point(0, 0), Point(1, 1))
Además, los objetos LineString también pueden ser creados pasando una sola secuencia de coordenadas o objetos Point.
>>> ls = LineString(((0, 0), (1, 1)))
>>> ls = LineString([Point(0, 0), Point(1, 1)])
Los objetos vacíos LineString pueden ser instanciados pasando ningún argumento o una secuencia vacía. Los siguientes son equivalentes:
>>> ls = LineString()
>>> ls = LineString([])
Devuelve si este LineString está cerrado.
LinearRing¶Los objetos LinearRing se construyen de la misma manera exacta que los objetos LineString, sin embargo las coordenadas deben ser cerradas, es decir, la primera coordenada debe ser igual a la última coordenada. Por ejemplo:
>>> ls = LinearRing((0, 0), (0, 1), (1, 1), (0, 0))
Nota que (0, 0) es la primera y última coordenada – si no fueran iguales, se levantarían una excepción.
Polygon¶Los objetos Polygon pueden ser instanciados pasando parámetros que representen los anillos del polígono. Los parámetros deben ser instancias de LinearRing o una secuencia que se puede utilizar para construir un LinearRing:
>>> ext_coords = ((0, 0), (0, 1), (1, 1), (1, 0), (0, 0))
>>> int_coords = ((0.4, 0.4), (0.4, 0.6), (0.6, 0.6), (0.6, 0.4), (0.4, 0.4))
>>> poly = Polygon(ext_coords, int_coords)
>>> poly = Polygon(LinearRing(ext_coords), LinearRing(int_coords))
Comparación de Polígonos
Ten en cuenta que es posible comparar directamente objetos Polygon con < o >, pero como la comparación se hace a través del LineString de Polygon, no significa mucho (pero es consistente y rápido). Siempre puedes forzar la comparación utilizando la propiedad area.
>>> if poly_1.area > poly_2.area:
... pass
...
MultiPoint¶MultiLineString¶Los objetos MultiLineString pueden ser instanciados pasando en LineString objetos como argumentos, o una secuencia única de LineString objetos:
>>> ls1 = LineString((0, 0), (1, 1))
>>> ls2 = LineString((2, 2), (3, 3))
>>> mls = MultiLineString(ls1, ls2)
>>> mls = MultiLineString([ls1, ls2])
Devuelve un objeto LineString que representa la fusión de líneas de todos los componentes de este MultiLineString.
Devuelve True si y sólo si todos los elementos están cerrados.
MultiPolygon¶Los objetos MultiPolygon pueden ser instanciados pasando Polygon objetos como argumentos, o una secuencia única de Polygon objetos:
>>> p1 = Polygon(((0, 0), (0, 1), (1, 1), (0, 0)))
>>> p2 = Polygon(((1, 1), (1, 2), (2, 2), (1, 1)))
>>> mp = MultiPolygon(p1, p2)
>>> mp = MultiPolygon([p1, p2])
GeometryCollection¶Los objetos GeometryCollection pueden ser instanciados pasando otros GEOSGeometry como argumentos, o una secuencia única de GEOSGeometry objetos:
>>> poly = Polygon(((0, 0), (0, 1), (1, 1), (0, 0)))
>>> gc = GeometryCollection(Point(0, 0), MultiPoint(Point(0, 0), Point(1, 1)), poly)
>>> gc = GeometryCollection((Point(0, 0), MultiPoint(Point(0, 0), Point(1, 1)), poly))
Para obtener una geometría preparada, accede a la propiedad GEOSGeometry.prepared. Una vez que tengas un objeto PreparedGeometry su métodos predicados espaciales, listados a continuación, pueden ser utilizados con otros objetos GEOSGeometry. Una operación con una geometría preparada puede ser orders de magnitud más rápida – cuanto más compleja sea la geometría que se prepare, mayor será el aumento en velocidad de la operación. Para obtener más información, por favor consulta la página del wiki GEOS sobre geometrías preparadas <https://trac.osgeo.org/geos/wiki/PreparedGeometry>.
Ejemplo:
>>> from django.contrib.gis.geos import Point, Polygon
>>> poly = Polygon.from_bbox((0, 0, 5, 5))
>>> prep_poly = poly.prepared
>>> prep_poly.contains(Point(2.5, 2.5))
True
PreparedGeometry¶Todas las geometrías de PreparedGeometry tienen un método que requiere un argumento other, el cual debe ser una instancia de GEOSGeometry.
file_h (a Python file object or a string path to the file) – archivo de entrada que contiene datos espaciales
una geometría GEOSGeometry correspondiente a los datos espaciales en el archivo
Ejemplo:
>>> from django.contrib.gis.geos import fromfile
>>> g = fromfile("/home/bob/geom.wkt")
una geometría GEOSGeometry correspondiente a los datos espaciales en la cadena
fromstr(string, srid) es equivalente a GEOSGeometry(string, srid).
Ejemplo:
>>> from django.contrib.gis.geos import fromstr
>>> pnt = fromstr("POINT(-90.5 29.5)", srid=4326)
Los lectores de I/O devuelven una instancia de GEOSGeometry a partir del WKB y/o WKT de entrada dado a su método read(geom).
Todos los objetos escritores tienen un método write(geom) que devuelve el WKB o WKT de la geometría dada. Además, los objetos WKBWriter también tienen propiedades que se pueden utilizar para cambiar el orden de bytes y/o incluir el valor SRID (en otras palabras, EWKB).
WKBWriter proporciona el control más completo sobre su salida. Por defecto devuelve WKB OGC-compliant cuando se llama a su método write. Sin embargo, tiene propiedades que permiten la creación de EWKB, un superset del estándar WKB que incluye información adicional. Consulte la documentación de la propiedad WKBWriter.outdim para obtener más detalles sobre el argumento dim.
Devuelve el WKB de la geometría dada como objeto buffer de Python. Ejemplo:
>>> from django.contrib.gis.geos import Point, WKBWriter
>>> pnt = Point(1, 1)
>>> wkb_w = WKBWriter()
>>> wkb_w.write(pnt)
<read-only buffer for 0x103a898f0, size -1, offset 0 at 0x103a89930>
Devuelve el WKB de la geometría en hexadecimal. Ejemplo:
>>> from django.contrib.gis.geos import Point, WKBWriter
>>> pnt = Point(1, 1)
>>> wkb_w = WKBWriter()
>>> wkb_w.write_hex(pnt)
'0101000000000000000000F03F000000000000F03F'
Esta propiedad se puede establecer para cambiar el orden de bytes de la representación geométrica.
Valor del byteorder |
Descripción |
|---|---|
0 |
Endiano grande (por ejemplo, compatible con sistemas RISC) |
1 |
Endiano pequeño (por ejemplo, compatible con sistemas x86) |
Ejemplo:
>>> from django.contrib.gis.geos import Point, WKBWriter
>>> wkb_w = WKBWriter()
>>> pnt = Point(1, 1)
>>> wkb_w.write_hex(pnt)
'0101000000000000000000F03F000000000000F03F'
>>> wkb_w.byteorder = 0
'00000000013FF00000000000003FF0000000000000'
Esta propiedad puede establecerse para cambiar la dimensión de salida de la representación geométrica. En otras palabras, si tienes una geometría en 3D, establece a 3 para que el valor Z esté incluido en el WKB.
Valor de Outdim |
Descripción |
|---|---|
2 |
La configuración por defecto es la salida de WKB en 2D. |
3 |
Salida de WKB en 3D. |
Ejemplo:
>>> from django.contrib.gis.geos import Point, WKBWriter
>>> wkb_w = WKBWriter()
>>> wkb_w.outdim
2
>>> pnt = Point(1, 1, 1)
>>> wkb_w.write_hex(pnt) # By default, no Z value included:
'0101000000000000000000F03F000000000000F03F'
>>> wkb_w.outdim = 3 # Tell writer to include Z values
>>> wkb_w.write_hex(pnt)
'0101000080000000000000F03F000000000000F03F000000000000F03F'
Establece esta propiedad con un booleano para indicar si el SRID de la geometría debe incluirse con la representación WKB. Ejemplo:
>>> from django.contrib.gis.geos import Point, WKBWriter
>>> wkb_w = WKBWriter()
>>> pnt = Point(1, 1, srid=4326)
>>> wkb_w.write_hex(pnt) # By default, no SRID included:
'0101000000000000000000F03F000000000000F03F'
>>> wkb_w.srid = True # Tell writer to include SRID
>>> wkb_w.write_hex(pnt)
'0101000020E6100000000000000000F03F000000000000F03F'
Esta clase permite la salida de la representación WKT de una geometría. Consulte los atributos WKBWriter.outdim, trim y precision para obtener detalles sobre los argumentos del constructor.
Devuelve el WKT de la geometría dada. Ejemplo:
>>> from django.contrib.gis.geos import Point, WKTWriter
>>> pnt = Point(1, 1)
>>> wkt_w = WKTWriter()
>>> wkt_w.write(pnt)
'POINT (1.0000000000000000 1.0000000000000000)'
Consulte WKBWriter.outdim.
Esta propiedad se utiliza para habilitar o deshabilitar la eliminación de decimales innecesarios.
>>> from django.contrib.gis.geos import Point, WKTWriter
>>> pnt = Point(1, 1)
>>> wkt_w = WKTWriter()
>>> wkt_w.trim
False
>>> wkt_w.write(pnt)
'POINT (1.0000000000000000 1.0000000000000000)'
>>> wkt_w.trim = True
>>> wkt_w.write(pnt)
'POINT (1 1)'
Esta propiedad controla la precisión de redondeo de coordenadas; si se establece en None el redondeo está deshabilitado.
>>> from django.contrib.gis.geos import Point, WKTWriter
>>> pnt = Point(1.44, 1.66)
>>> wkt_w = WKTWriter()
>>> print(wkt_w.precision)
None
>>> wkt_w.write(pnt)
'POINT (1.4399999999999999 1.6599999999999999)'
>>> wkt_w.precision = 0
>>> wkt_w.write(pnt)
'POINT (1 2)'
>>> wkt_w.precision = 1
>>> wkt_w.write(pnt)
'POINT (1.4 1.7)'
Notas al pie
GEOS_LIBRARY_PATH¶Una cadena que especifica la ubicación de la biblioteca C GEOS. Normalmente, esta configuración solo se utiliza si la biblioteca C GEOS está en una ubicación no estándar (por ejemplo, /home/bob/lib/libgeos_c.so).
Nota
La configuración debe ser el path completo a la biblioteca compartida de C; es decir, quieres utilizar libgeos_c.so, no libgeos.so.
may 31, 2026