GEOS API

Bakgrund

Vad är GEOS?

GEOS står för Geometry Engine - Open Source och är ett C++-bibliotek, porterat från Java Topology Suite. GEOS implementerar OpenGIS funktioner för spatiala predikat och spatiala operatorer i Simple Features for SQL. GEOS, numera ett OSGeo-projekt, utvecklades och underhölls ursprungligen av Refractions Research i Victoria, Kanada.

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.

• Löst kopplad till GeoDjango. Till exempel kan GEOSGeometry-objekt användas utanför ett Django-projekt eller -program. Med andra ord behöver DJANGO_SETTINGS_MODULE inte vara inställd och någon databas behöver inte användas osv.

• Ä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-objekt kan skapas på några sätt. Det första är att helt enkelt instansiera objektet med spatial indata – följande exempel skapar samma geometri från WKT, HEX, WKB och 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

Ett annat alternativ är att använda konstruktorn för den specifika geometrityp som du vill skapa. Till exempel kan ett Point-objekt skapas genom att skicka X- och Y-koordinaterna till dess konstruktor:

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

Du kan hämta/ange geometrikomponenter med standardtekniker för Python-indexering. Vad som returneras beror dock på objektets geometrityp. Indexering av en LineString returnerar till exempel en koordinattuppel:

>>> 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, *, max_geom_collections=198)[source]

Parametrar:

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

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

• max_geom_collections – maximalt antal nästlade (WKT) eller totala (WKB) geometrisamlingar som accepteras innan tolkningen nekas

Detta är basklassen för alla GEOS-geometriobjekt. Den initieras med det angivna argumentet geo_input och antar sedan lämplig underklass för geometri (t.ex. skapar GEOSGeometry('POINT(1 1)') ett Point-objekt).

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

Returnerar en sträng som motsvarar geometritypen. Till exempel:

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

GEOSGeometry.geom_typeid

Returnerar GEOS identifieringsnummer för geometrityp. Följande tabell visar värdet för varje geometrityp:

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

Returnerar antalet geometrier i denna geometri. Med andra ord returneras 1 för allt utom geometrisamlingar.

GEOSGeometry.hasz

Returnerar ett booleskt värde som anger om geometrin har Z-dimensionen.

GEOSGeometry.hasm

New in Django 6.0.

Returnerar ett booleskt värde som anger om geometrin har M-dimensionen. Kräver GEOS 3.12.

GEOSGeometry.ring

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

GEOSGeometry.simple

Returnerar ett booleskt värde som anger om geometrin är ”enkel”. En geometri är enkel om och endast om den inte skär sig själv (utom vid gränspunkter). Ett LineString-objekt är till exempel inte enkelt om det skär sig självt. Därför är LinearRing- och Polygon-objekt alltid enkla eftersom de per definition inte kan skära sig själva.

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

Egenskap som kan användas för att hämta eller ange det SRID som är kopplat till geometrin. Till exempel:

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

Egenskaper för utdata

Egenskaperna i detta avsnitt exporterar GEOSGeometry-objektet till ett annat format. Utdata kan vara i form av en sträng, buffert eller till och med ett annat objekt.

GEOSGeometry.ewkt

Returnerar geometriens ”utökade” Well-Known Text. Denna representation är specifik för PostGIS och är en utvidgning av OGC WKT-standarden. [1] I huvudsak läggs SRID framför WKT-representationen, till exempel 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

Returnerar denna geometris WKB i hexadecimal form. Observera att SRID-värdet inte ingår i denna representation eftersom det inte är en del av OGC-specifikationen (använd egenskapen GEOSGeometry.hexewkb i stället).

GEOSGeometry.hexewkb

Returnerar denna geometris EWKB i hexadecimal form. Detta är en utvidgning av WKB-specifikationen som inkluderar det SRID-värde som är en del av denna geometri.

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

Returnerar en KML-representation (Keyhole Markup Language) av geometrin. Detta bör endast användas för geometrier med SRID 4326 (WGS84), men begränsningen upprätthålls inte.

GEOSGeometry.ogr

Returnerar ett OGRGeometry-objekt som motsvarar GEOS-geometrin.

GEOSGeometry.wkb

Returnerar WKB-representationen (Well-Known Binary) av denna geometri som en Python-buffert. SRID-värdet ingår inte; använd egenskapen GEOSGeometry.ewkb i stället.

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)

Returnerar sant om de två geometrierna är exakt lika, med en angiven tolerans. Värdet tolerance ska vara ett flyttal som representerar feltoleransen i jämförelsen; exempelvis jämför poly1.equals_exact(poly2, 0.001) likheten inom en tusendels enhet.

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

Returnerar ett Point-objekt som representerar geometriens geometriska centrum. Punkten garanteras inte ligga i geometriens inre.

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 motsvarande giltig GEOSGeometry och försöker att inte förlora någon av indatans hörnpunkter. Om geometrin redan är giltig returneras den orörd. Detta liknar databasfunktionen MakeValid.

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-objekt kan instansieras genom att skicka parametrar som representerar polygonens ringar. Parametrarna måste antingen vara instanser av LinearRing eller en sekvens som kan användas för att skapa en 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

För att erhålla en förberedd geometri öppnar du egenskapen GEOSGeometry.prepared. När du har en instans av PreparedGeometry kan dess metoder för spatiala predikat, som listas nedan, användas med andra GEOSGeometry-objekt. En operation med en förberedd geometri kan vara storleksordningar snabbare – ju mer komplex den förberedda geometrin är, desto större blir prestandavinsten. Mer information finns på GEOS-wikisidan om förberedda geometrier.

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

Alla skrivarobjekt har en metod write(geom) som returnerar antingen WKB eller WKT för den angivna geometrin. Dessutom har WKBWriter-objekt egenskaper som kan användas för att ändra byteordningen och/eller inkludera SRID-värdet (med andra ord EWKB).

class WKBWriter(dim=2)[source]

WKBWriter ger mest kontroll över sina utdata. Som standard returnerar den OGC-kompatibel WKB när metoden write anropas. Den har dock egenskaper som tillåter att EWKB skapas, en utvidgning av WKB-standarden som innehåller ytterligare information. Mer information om argumentet dim finns i dokumentationen för WKBWriter.outdim.

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]

Returnerar geometriens WKB i hexadecimal form. Exempel:

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

Den här egenskapen kan anges för att ändra utdatadimensionen för geometrirepresentationen. Med andra ord, om du har en 3D-geometri anger du 3 så att Z-värdet inkluderas i 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]

Ange denna egenskap till ett booleskt värde för att indikera om geometriens SRID ska inkluderas i WKB-representationen. Exempel:

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

En sträng som anger var C-biblioteket GEOS finns. Vanligen används denna inställning endast om C-biblioteket GEOS ligger på en plats som inte är standard (t.ex. /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.