GEOS API

Bakgrund

Vad är GEOS?

GEOS stands for Geometry Engine - Open Source, and is a C++ library, ported from the Java Topology Suite. GEOS implements the OpenGIS Simple Features for SQL spatial predicate functions and spatial operators. GEOS, now an OSGeo project, was initially developed and maintained by Refractions Research of Victoria, Canada.

Funktioner

GeoDjango implementerar en Python-wrapper på hög nivå för GEOS-biblioteket, med bland annat följande funktioner:

• Ett BSD-licensierat gränssnitt till GEOS geometrirutiner, implementerat enbart i Python med hjälp av ctypes.

• Loosely-coupled to GeoDjango. For example, GEOSGeometry objects may be used outside of a Django project/application. In other words, no need to have DJANGO_SETTINGS_MODULE set or use a database, etc.

• Ändringsbarhet: GEOSGeometry-objekt kan ändras.

• Testad på flera plattformar.

Handledning

Detta avsnitt innehåller en kort introduktion och handledning i hur man använder GEOSGeometry-objekt.

Skapa en geometri

GEOSGeometry objects may be created in a few ways. The first is to simply instantiate the object on some spatial input – the following are examples of creating the same geometry from WKT, HEX, WKB, and 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

Another option is to use the constructor for the specific geometry type that you wish to create. For example, a Point object may be created by passing in the X and Y coordinates into its constructor:

>>> from django.contrib.gis.geos import Point
>>> pnt = Point(5, 23)

Alla dessa konstruktörer tar nyckelordsargumentet srid. Till exempel:

>>> 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)

Slutligen finns fabriksmetoden fromfile() som returnerar ett GEOSGeometry-objekt från en fil:

>>> from django.contrib.gis.geos import fromfile
>>> pnt = fromfile("/path/to/pnt.wkt")
>>> pnt = fromfile(open("/path/to/pnt.wkt"))

Mina loggar är fulla av GEOS-relaterade fel

Du hittar många TypeError eller AttributeError undantag som fyller din webbservers loggfiler. Detta innebär i allmänhet att du skapar GEOS-objekt på toppnivån i några av dina Python-moduler. Sedan, på grund av ett tävlingsförhållande i skräpsamlaren, samlas din modul in före GEOS-objektet. För att förhindra detta, skapa GEOSGeometry-objekt i det lokala omfånget av dina funktioner/metoder.

Geometrier är pytoniska

GEOSGeometry-objekt är ”pythoniska”, med andra ord kan komponenterna nås, modifieras och itereras över med hjälp av Pythons standardkonventioner. Du kan till exempel iterera över koordinaterna i en Point:

>>> pnt = Point(5, 23)
>>> [coord for coord in pnt]
[5.0, 23.0]

För alla geometriobjekt kan egenskapen GEOSGeometry.coords användas för att få geometrikoordinaterna som en Python-tupel:

>>> pnt.coords
(5.0, 23.0)

You can get/set geometry components using standard Python indexing techniques. However, what is returned depends on the geometry type of the object. For example, indexing on a LineString returns a coordinate tuple:

>>> 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)

Medan indexering på en Polygon kommer att returnera ringen (ett LinearRing-objekt) som motsvarar indexet:

>>> 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)

Dessutom kan koordinater/komponenter i geometrin läggas till eller ändras, precis som i en Python-lista:

>>> 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))

Geometrier stöder set-liknande operatorer:

>>> 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))

Equality-operatorn kontrollerar inte rumslig likhet

Jämlikhetsoperatorn GEOSGeometry använder equals_exact(), inte equals(), dvs. den kräver att de jämförda geometrierna har samma koordinater i samma positioner med samma SRID:

>>> 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

Geometriobjekt

GEOSGeometri

class GEOSGeometry(geo_input, srid=None)[source]

Parametrar:

• geo_input – Inmatningsvärde för geometri (sträng eller memoryview)

• srid (int) – identifierare för rumslig referens

This is the base class for all GEOS geometry objects. It initializes on the given geo_input argument, and then assumes the proper geometry subclass (e.g., GEOSGeometry('POINT(1 1)') will create a Point object).

Parametern srid, om den anges, sätts som SRID för den skapade geometrin om geo_input inte har någon SRID. Om olika SRIDs tillhandahålls genom parametrarna geo_input och srid, uppstår 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.

Följande indataformat, tillsammans med motsvarande Python-typer, accepteras:

Format	Inmatning Typ
WKT / EWKT	str
HEX / HEXEWKB	str
WKB / EWKB	minnesvy
GeoJSON	str

För GeoJSON-formatet ställs SRID in baserat på medlemmen crs. Om crs inte anges är standardvärdet för SRID 4326.

classmethod GEOSGeometry.from_gml(gml_string)

Konstruerar en GEOSGeometry från den givna GML-strängen.

Egenskaper

GEOSGeometry.coords

Returnerar geometrins koordinater som en tupel.

GEOSGeometry.dims

Returnerar geometrins dimension:

• 0 för Point` och MultiPoint`

• 1 för LineString och MultiLineString`

• 2 för Polygon` och MultiPolygon`

• -1 för tom :class:`GeometryCollection``s

• den maximala dimensionen av dess element för icke-tomma :class:`GeometryCollection`s

GEOSGeometry.empty

Returnerar om uppsättningen punkter i geometrin är tom eller inte.

GEOSGeometry.geom_type

Returns a string corresponding to the type of geometry. For example:

>>> pnt = GEOSGeometry("POINT(5 23)")
>>> pnt.geom_type
'Point'

GEOSGeometry.geom_typeid

Returns the GEOS geometry type identification number. The following table shows the value for each geometry type:

Geometri	ID
Point	0
LineString	1
LinearRing	2
Polygon	3
MultiPoint	4
MultiLineString	5
MultiPolygon	6
GeometryCollection	7

GEOSGeometry.num_coords

Returnerar antalet koordinater i geometrin.

GEOSGeometry.num_geom

Returns the number of geometries in this geometry. In other words, will return 1 on anything but geometry collections.

GEOSGeometry.hasz

Returns a boolean indicating whether the geometry has the Z dimension.

GEOSGeometry.hasm

New in Django 6.0.

Returns a boolean indicating whether the geometry has the M dimension. Requires GEOS 3.12.

GEOSGeometry.ring

Returnerar en boolean som anger om geometrin är en LinearRing.

GEOSGeometry.simple

Returns a boolean indicating whether the geometry is ’simple’. A geometry is simple if and only if it does not intersect itself (except at boundary points). For example, a LineString object is not simple if it intersects itself. Thus, LinearRing and Polygon objects are always simple because they cannot intersect themselves, by definition.

GEOSGeometry.valid

Returnerar ett boolean som anger om geometrin är giltig.

GEOSGeometry.valid_reason

Returnerar en sträng som beskriver orsaken till att en geometri är ogiltig.

GEOSGeometry.srid

Property that may be used to retrieve or set the SRID associated with the geometry. For example:

>>> pnt = Point(5, 23)
>>> print(pnt.srid)
None
>>> pnt.srid = 4326
>>> pnt.srid
4326

Egenskaper för utdata

The properties in this section export the GEOSGeometry object into a different. This output may be in the form of a string, buffer, or even another object.

GEOSGeometry.ewkt

Returns the ”extended” Well-Known Text of the geometry. This representation is specific to PostGIS and is a superset of the OGC WKT standard. [1] Essentially the SRID is prepended to the WKT representation, for example SRID=4326;POINT(5 23).

Observera

Utdata från den här egenskapen innehåller inte 3dm-, 3dz- och 4d-information som PostGIS stöder i sina EWKT-representationer.

GEOSGeometry.hex

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).

GEOSGeometry.hexewkb

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.

GEOSGeometry.json

Returnerar GeoJSON-representationen av geometrin. Observera att resultatet inte är en komplett GeoJSON-struktur utan endast nyckelinnehållet geometry i en GeoJSON-struktur. Se även GeoJSON Serializer.

GEOSGeometry.geojson

Alias för GEOSGeometry.json.

GEOSGeometry.kml

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.

GEOSGeometry.ogr

Returnerar ett OGRGeometry-objekt som motsvarar GEOS-geometrin.

GEOSGeometry.wkb

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.

GEOSGeometry.ewkb

Returnerar EWKB-representationen av denna geometri som en Python-buffert. Detta är en utvidgning av WKB-specifikationen som inkluderar alla SRID-värden som är en del av denna geometri.

GEOSGeometry.wkt

Returnerar geometrins Well-Known Text (en OGC-standard).

Rumsliga predikatmetoder

Alla följande metoder för rumsliga predikat tar en annan GEOSGeometry-instans (other) som parameter och returnerar ett boolean.

GEOSGeometry.contains(other)

Returnerar True om other.within(this) returnerar True.

GEOSGeometry.covers(other)

Returnerar True om denna geometri täcker den angivna geometrin.

Predikatet covers har följande likvärdiga definitioner:

• Varje punkt i den andra geometrin är en punkt i den här geometrin.

• Skärningsmatrisen DE-9IM för de två geometrierna är T*****FF*, *T****FF*, ***T**FF*, eller ****T*FF*.

Om någon av geometrierna är tom returneras False.

Detta predikat liknar GEOSGeometry.contains(), men är mer inkluderande (d.v.s. returnerar True för fler fall). I synnerhet, till skillnad från contains() skiljer det inte mellan punkter i geometrins gräns och i dess inre. För de flesta situationer bör covers() föredras framför contains(). Som en extra fördel är covers() mer mottaglig för optimering och bör därför överträffa contains().

GEOSGeometry.crosses(other)

Returnerar True om DE-9IM-intersektionsmatrisen för de två geometrierna är T*T****** (för en punkt och en kurva, en punkt och en yta eller en linje och en yta) 0******** (för två kurvor).

GEOSGeometry.disjoint(other)

Returnerar True om DE-9IM-intersektionsmatrisen för de två geometrierna är FF*FF****.

GEOSGeometry.equals(other)

Returnerar True om DE-9IM-intersektionsmatrisen för de två geometrierna är T*F**FFF*.

GEOSGeometry.equals_exact(other, tolerance=0)

Returns true if the two geometries are exactly equal, up to a specified tolerance. The tolerance value should be a floating point number representing the error tolerance in the comparison, e.g., poly1.equals_exact(poly2, 0.001) will compare equality to within one thousandth of a unit.

GEOSGeometry.equals_identical(other)

Returnerar True om de två geometrierna är punktvis ekvivalenta genom att kontrollera att strukturen, ordningsföljden och värdena för alla hörn är identiska i alla dimensioner. NaN-värden anses vara lika med andra NaN-värden. Kräver GEOS 3.12.

GEOSGeometry.intersects(other)

Returnerar True om GEOSGeometry.disjoint() är False.

GEOSGeometry.overlaps(other)

Returnerar true om DE-9IM-intersektionsmatrisen för de två geometrierna är T*T***T** (för två punkter eller två ytor) 1*T***T** (för två kurvor).

GEOSGeometry.relate_pattern(other, pattern)

Returnerar True om elementen i DE-9IM-intersektionsmatrisen för denna geometri och den andra matchar det givna mönstret - en sträng med nio tecken från alfabetet: {T, F, *, 0}.

GEOSGeometry.touches(other)

Returnerar True om DE-9IM-intersektionsmatrisen för de två geometrierna är FT*******, F**T***** eller F***T****.

GEOSGeometry.within(other)

Returnerar True om DE-9IM-intersektionsmatrisen för de två geometrierna är T*F**F***.

Topologiska metoder

GEOSGeometry.buffer(width, quadsegs=8)

Returnerar en GEOSGeometry som representerar alla punkter vars avstånd från denna geometri är mindre än eller lika med den givna width. Det valfria nyckelordet quadsegs anger antalet segment som används för att approximera en kvartscirkel (standard är 8).

GEOSGeometry.buffer_with_style(width, quadsegs=8, end_cap_style=1, join_style=1, mitre_limit=5.0)

Samma som buffer(), men gör det möjligt att anpassa buffertens stil.

• end_cap_style kan vara rund (1), platt (2) eller fyrkantig (3).

• join_style kan vara rund (1), gering (2) eller fasad (3).

• Begränsning av mitterförhållande (mitre_limit) påverkar endast mitterfogningsstilen.

GEOSGeometry.difference(other)

Returnerar en GEOSGeometry som representerar de punkter som utgör denna geometri och som inte utgör någon annan.

GEOSGeometry.interpolate(distance)

GEOSGeometry.interpolate_normalized(distance)

Givet ett avstånd (float), returnerar punkten (eller närmaste punkten) inom geometrin (LineString eller MultiLineString) på det avståndet. Den normaliserade versionen tar avståndet som en float mellan 0 (ursprung) och 1 (slutpunkt).

Omvänd av GEOSGeometry.project().

GEOSGeometry.intersection(other)

Returnerar en GEOSGeometry som representerar de punkter som delas av denna geometri och andra.

GEOSGeometry.project(point)

GEOSGeometry.project_normalized(point)

Returnerar avståndet (float) från geometrins ursprung (LineString eller MultiLineString) till den punkt som projiceras på geometrin (dvs. till den punkt på linjen som ligger närmast den angivna punkten). Den normaliserade versionen returnerar avståndet som en flottör mellan 0 (ursprung) och 1 (slutpunkt).

Omvänd av GEOSGeometry.interpolate().

GEOSGeometry.relate(other)

Returnerar DE-9IM-intersektionsmatrisen (en sträng) som representerar det topologiska förhållandet mellan den här geometrin och den andra.

GEOSGeometry.simplify(tolerance=0.0, preserve_topology=False)

Returnerar en ny GEOSGeometry, förenklad till den angivna toleransen med hjälp av Douglas-Peucker-algoritmen. Ett högre toleransvärde innebär färre punkter i utdata. Om ingen tolerans anges är standardvärdet 0.

Som standard bevarar denna funktion inte topologin. Exempelvis kan Polygon-objekt delas upp, kollapsas till linjer eller försvinna. Polygon-hål kan skapas eller försvinna och linjer kan korsas. Genom att ange preserve_topology=True kommer resultatet att ha samma dimension och antal komponenter som indata; detta är dock betydligt långsammare.

GEOSGeometry.sym_difference(other)

Returnerar en GEOSGeometry som kombinerar punkterna i den här geometrin som inte finns i den andra, och punkterna i den andra som inte finns i den här geometrin.

GEOSGeometry.union(other)

Returnerar en GEOSGeometry som representerar alla punkter i den här geometrin och den andra.

Topologiska egenskaper

GEOSGeometry.boundary

Returnerar gränsen som ett nyligen allokerat Geometry-objekt.

GEOSGeometry.centroid

Returns a Point object representing the geometric center of the geometry. The point is not guaranteed to be on the interior of the geometry.

GEOSGeometry.convex_hull

Returnerar den minsta Polygon som innehåller alla punkter i geometrin.

GEOSGeometry.envelope

Returnerar en Polygon som representerar den avgränsande omslutningen av denna geometri. Observera att den också kan returnera en Point om indatageometrin är en punkt.

GEOSGeometry.point_on_surface

Beräknar och returnerar en Point som garanterat befinner sig på insidan av denna geometri.

GEOSGeometry.unary_union

Beräknar sammanslagningen av alla element i denna geometri.

Resultatet följer följande kontrakt:

• Unioning av en uppsättning :class:`LineString`s har effekten av fullständig noding och upplösning av linework.

• Union av en uppsättning Polygon kommer alltid att returnera en Polygon eller MultiPolygon geometri (till skillnad från GEOSGeometry.union(), som kan returnera geometrier av lägre dimension om en topologisk kollaps inträffar).

Andra egenskaper och metoder

GEOSGeometry.area

Denna egenskap returnerar geometrins area.

GEOSGeometry.extent

Den här egenskapen returnerar geometrins utsträckning som en 4-tupel, bestående av (xmin, ymin, xmax, ymax).

GEOSGeometry.clone()

Den här metoden returnerar en GEOSGeometry som är en klon av originalet.

GEOSGeometry.distance(geom)

Returnerar avståndet mellan de närmaste punkterna på denna geometri och den givna geometrin (ett annat GEOSGeometry`-objekt).

Observera

GEOS avståndsberäkningar är linjära - med andra ord utför GEOS inte en sfärisk beräkning även om SRID:en anger ett geografiskt koordinatsystem.

GEOSGeometry.length

Returnerar längden på denna geometri (t.ex. 0 för en Point, längden på en LineString eller omkretsen på en Polygon).

GEOSGeometry.prepared

Returnerar en GEOS PreparedGeometry för innehållet i denna geometri. PreparedGeometry-objekt är optimerade för operationerna contains, intersects, covers, crosses, disjoint, overlaps, touches och within. Se dokumentationen Förberedda geometrier för mer information.

GEOSGeometry.srs

Returnerar ett SpatialReference-objekt som motsvarar geometrins SRID eller None.

GEOSGeometry.transform(ct, clone=False)

Transformerar geometrin enligt den angivna parametern för koordinattransformation (ct), som kan vara ett heltal SRID, en rumslig referens WKT-sträng, en PROJ-sträng, ett SpatialReference-objekt eller ett CoordTransform-objekt. Som standard transformeras geometrin på plats och ingenting returneras. Men om nyckelordet clone är angivet, modifieras inte geometrin och en transformerad klon av geometrin returneras istället.

Observera

Utlöser GEOSException om GDAL inte är tillgängligt eller om geometrins SRID är None eller mindre än 0. Den lägger inte några begränsningar på geometrins SRID om den anropas med ett CoordTransform-objekt.

GEOSGeometry.make_valid()

Returnerar en giltig GEOSGeometry-ekvivalent, som försöker att inte förlora någon av de ingående hörnen. Om geometrin redan är giltig returneras den orörd. Detta liknar databasfunktionen MakeValid. Kräver GEOS 3.8.

GEOSGeometry.normalize(clone=False)

Konverterar denna geometri till kanonisk form. Om nyckelordet clone är angivet, modifieras inte geometrin och en normaliserad klon av geometrin returneras istället:

>>> 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)

Punkt

class Point(x=None, y=None, z=None, srid=None)[source]

Point-objekt instansieras med argument som representerar punktens komponentkoordinater eller med en enda koordinatsekvens. Till exempel: är följande likvärdiga:

>>> pnt = Point(5, 23)
>>> pnt = Point([5, 23])

Tomma Point objekt kan instansieras genom att skicka inga argument eller en tom sekvens. Följande är likvärdiga:

>>> pnt = Point()
>>> pnt = Point([])

LineString

class LineString(*args, **kwargs)[source]

LineString-objekt instansieras med hjälp av argument som antingen är en sekvens av koordinater eller Point-objekt. Till exempel: är följande likvärdiga:

>>> ls = LineString((0, 0), (1, 1))
>>> ls = LineString(Point(0, 0), Point(1, 1))

Dessutom kan LineString-objekt också skapas genom att skicka in en enda sekvens av koordinat- eller Point-objekt:

>>> ls = LineString(((0, 0), (1, 1)))
>>> ls = LineString([Point(0, 0), Point(1, 1)])

Tomma LineString-objekt kan instansieras genom att skicka inga argument eller en tom sekvens. Följande är likvärdiga:

>>> ls = LineString()
>>> ls = LineString([])

closed

Returnerar om denna LineString är stängd eller inte.

LineärRing

class LinearRing(*args, **kwargs)[source]

LinearRing-objekt konstrueras på exakt samma sätt som LineString`-objekt, men koordinaterna måste vara slutna, med andra ord måste de första koordinaterna vara desamma som de sista koordinaterna. Exempelvis:

>>> ls = LinearRing((0, 0), (0, 1), (1, 1), (0, 0))

Observera att (0, 0) är den första och sista koordinaten - om de inte var lika skulle ett fel uppstå.

is_counterclockwise[source]

Returnerar om denna LinearRing är motsols.

Polygon

class Polygon(*args, **kwargs)[source]

Polygon objects may be instantiated by passing in parameters that represent the rings of the polygon. The parameters must either be LinearRing instances, or a sequence that may be used to construct a 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))

classmethod from_bbox(bbox)[source]

Returnerar ett polygonobjekt från den angivna bounding-boxen, en 4-tupel bestående av (xmin, ymin, xmax, ymax).

num_interior_rings[source]

Returnerar antalet inre ringar i denna geometri.

Jämföra polygoner

Observera att det är möjligt att jämföra Polygon-objekt direkt med < eller >, men eftersom jämförelsen görs genom Polygons LineString betyder det inte så mycket (men det är konsekvent och snabbt). Du kan alltid tvinga fram jämförelsen med egenskapen area:

>>> if poly_1.area > poly_2.area:
...     pass
...

Geometri Samlingar

MultiPoint

class MultiPoint(*args, **kwargs)[source]

MultiPoint-objekt kan instansieras genom att skicka in Point-objekt som argument, eller en enda sekvens av Point-objekt:

>>> mp = MultiPoint(Point(0, 0), Point(1, 1))
>>> mp = MultiPoint((Point(0, 0), Point(1, 1)))

MultiLineString

class MultiLineString(*args, **kwargs)[source]

MultiLineString-objekt kan instansieras genom att skicka in LineString-objekt som argument, eller en enda sekvens av LineString-objekt:

>>> ls1 = LineString((0, 0), (1, 1))
>>> ls2 = LineString((2, 2), (3, 3))
>>> mls = MultiLineString(ls1, ls2)
>>> mls = MultiLineString([ls1, ls2])

merged

Returnerar en LineString som representerar linjesammanslagningen av alla komponenter i denna MultiLineString.

closed

Returnerar True om och endast om alla element är stängda.

MultiPolygon

class MultiPolygon(*args, **kwargs)[source]

MultiPolygon-objekt kan instansieras genom att skicka Polygon-objekt som argument, eller en enda sekvens av Polygon-objekt:

>>> 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

class GeometryCollection(*args, **kwargs)[source]

GeometryCollection-objekt kan instansieras genom att skicka in andra GEOSGeometry` som argument, eller en enda sekvens av GEOSGeometry`-objekt:

>>> 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))

Förberedda geometrier

In order to obtain a prepared geometry, access the GEOSGeometry.prepared property. Once you have a PreparedGeometry instance its spatial predicate methods, listed below, may be used with other GEOSGeometry objects. An operation with a prepared geometry can be orders of magnitude faster – the more complex the geometry that is prepared, the larger the speedup in the operation. For more information, please consult the GEOS wiki page on prepared geometries.

Till exempel:

>>> 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

FörbereddGeometri

class PreparedGeometry

Alla metoder för PreparedGeometry tar ett other argument, som måste vara en GEOSGeometry-instans.

contains(other)

contains_properly(other)

covers(other)

crosses(other)

disjoint(other)

intersects(other)

overlaps(other)

touches(other)

within(other)

Geometri-fabriker

fromfile(file_h)[source]

Parametrar:

file_h (a Python file object or a string path to the file) – indatafil som innehåller rumsliga data

Returtyp:

en GEOSGeometry som motsvarar de rumsliga data som finns i filen

Exempel:

>>> from django.contrib.gis.geos import fromfile
>>> g = fromfile("/home/bob/geom.wkt")

fromstr(string, srid=None)[source]

Parametrar:

• string (str) – sträng som innehåller rumsliga data

• srid (int) – identifierare för rumslig referens

Returtyp:

en GEOSGeometry som motsvarar de rumsliga data i strängen

fromstr(string, srid) är likvärdigt med GEOSGeometry(string, srid).

Exempel:

>>> from django.contrib.gis.geos import fromstr
>>> pnt = fromstr("POINT(-90.5 29.5)", srid=4326)

I/O-objekt

Läsobjekt

I/O-klasserna för läsare returnerar en GEOSGeometry-instans från WKB- och/eller WKT-ingången som ges till deras read(geom)-metod.

class WKBReader[source]

Exempel:

>>> from django.contrib.gis.geos import WKBReader
>>> wkb_r = WKBReader()
>>> wkb_r.read("0101000000000000000000F03F000000000000F03F")
<Point object at 0x103a88910>

class WKTReader[source]

Exempel:

>>> from django.contrib.gis.geos import WKTReader
>>> wkt_r = WKTReader()
>>> wkt_r.read("POINT(1 1)")
<Point object at 0x103a88b50>

Författarens objekt

All writer objects have a write(geom) method that returns either the WKB or WKT of the given geometry. In addition, WKBWriter objects also have properties that may be used to change the byte order, and or include the SRID value (in other words, EWKB).

class WKBWriter(dim=2)[source]

WKBWriter provides the most control over its output. By default it returns OGC-compliant WKB when its write method is called. However, it has properties that allow for the creation of EWKB, a superset of the WKB standard that includes additional information. See the WKBWriter.outdim documentation for more details about the dim argument.

write(geom)[source]

Returnerar WKB för den angivna geometrin som ett Python-objekt i form av en buffer. Ett exempel:

>>> 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>

write_hex(geom)[source]

Returns WKB of the geometry in hexadecimal. Example:

>>> from django.contrib.gis.geos import Point, WKBWriter
>>> pnt = Point(1, 1)
>>> wkb_w = WKBWriter()
>>> wkb_w.write_hex(pnt)
'0101000000000000000000F03F000000000000F03F'

byteorder

Denna egenskap kan ställas in för att ändra byte-ordningen för geometrirepresentationen.

Byteordning Värde	Beskrivning
0	Big Endian (t.ex. kompatibel med RISC-system)
1	Little Endian (t.ex. kompatibel med x86-system)

Exempel:

>>> 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'

outdim[source]

This property may be set to change the output dimension of the geometry representation. In other words, if you have a 3D geometry then set to 3 so that the Z value is included in the WKB.

Outdim värde	Beskrivning
2	Standard, utdata 2D WKB.
3	Utgång 3D WKB.

Exempel:

>>> 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'

srid[source]

Set this property with a boolean to indicate whether the SRID of the geometry should be included with the WKB representation. Example:

>>> 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'

class WKTWriter(dim=2, trim=False, precision=None)[source]

Denna klass gör det möjligt att skriva ut WKT-representationen av en geometri. Se attributen WKBWriter.outdim, trim och precision för detaljer om konstruktörens argument.

write(geom)[source]

Returnerar WKT för den givna geometrin. Ett exempel:

>>> from django.contrib.gis.geos import Point, WKTWriter
>>> pnt = Point(1, 1)
>>> wkt_w = WKTWriter()
>>> wkt_w.write(pnt)
'POINT (1.0000000000000000 1.0000000000000000)'

outdim[source]

Se WKBWriter.outdim.

trim[source]

Denna egenskap används för att aktivera eller inaktivera trimning av onödiga decimaler.

>>> 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)'

precision[source]

Denna egenskap styr koordinaternas avrundningsprecision; om den är inställd på ”Ingen” är avrundning inaktiverad.

>>> 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)'

Fotnoter

[1]

Se PostGIS EWKB, EWKT and Canonical Forms, PostGIS dokumentation på Ch. 4.1.2.

Inställningar

GEOS_BIBLIOTEK_ SÖKVÄG

A string specifying the location of the GEOS C library. Typically, this setting is only used if the GEOS C library is in a non-standard location (e.g., /home/bob/lib/libgeos_c.so).

Observera

Inställningen måste vara den fullständiga sökvägen till det delade C-biblioteket; med andra ord vill du använda libgeos_c.so, inte libgeos.so.

Undantag

exception GEOSException[source]

Base GEOS exception, indikerar ett GEOS-relaterat fel.