GEOS API

Bakgrund

Vad är GEOS?

gEOS står för Geometry Engine - Open Source och är ett C++-bibliotek som har överförts från Java Topology Suite. GEOS implementerar OpenGIS `Simple Features for SQL`__ rumsliga predikatfunktioner och rumsliga operatorer. GEOS, som nu är 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/applikation. Med andra ord behöver du inte ha DJANGO_SETTINGS_MODULE inställd eller använda en databas, 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-objekt kan skapas på flera olika sätt. Det första är att helt enkelt instansiera objektet på någon rumslig indata - följande är exempel på hur man 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 konstruktören för den specifika geometrityp som du vill skapa. Till exempel: kan ett Point-objekt skapas genom att X- och Y-koordinaterna anges i 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/ställa in geometrikomponenter med hjälp av Pythons vanliga indexeringstekniker. Vad som returneras beror dock på objektets geometrityp. Till exempel:, indexering på en LineString returnerar en koordinattupel:

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

Detta är basklassen för alla GEOS geometriobjekt. Den initialiseras på det givna geo_input-argumentet och antar sedan rätt geometriunderklass (t.ex. kommer GEOSGeometry('POINT(1 1)'') att skapa 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 typen av geometri. Till exempel:

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

GEOSGeometry.geom_typeid

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

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

GEOSGeometry.num_coords

Returnerar antalet koordinater i geometrin.

GEOSGeometry.num_geom

Returnerar antalet geometrier i denna geometri. Med andra ord, kommer att returnera 1 på allt utom geometrisamlingar.

GEOSGeometry.hasz

Returnerar ett boolean som anger om geometrin är tredimensionell.

GEOSGeometry.ring

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

GEOSGeometry.simple

Returnerar ett boolean som anger om geometrin är ”enkel”. En geometri är enkel om och endast om den inte skär sig själv (utom i gränspunkter). Ett LineString-objekt är t.ex. inte enkelt om det skär sig självt. Objekten LinearRing och Polygon är således 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 ställa in den SRID som är kopplad 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. Denna utdata kan vara i form av en sträng, buffert eller till och med ett annat objekt.

GEOSGeometry.ewkt

Returnerar den ”utökade” Well-Known Text för geometrin. Denna representation är specifik för PostGIS och är en överuppsättning av OGC WKT-standarden. [1] I huvudsak läggs SRID till 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 WKB för denna geometri 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 istället).

GEOSGeometry.hexewkb

Returnerar EWKB för denna geometri i hexadecimal form. Detta är en utvidgning av WKB-specifikationen som inkluderar SRID-värdet 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`__ (Keyhole Markup Language) representation av geometrin. Detta bör endast användas för geometrier med en SRID på 4326 (WGS84), men denna begränsning tillämpas 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 istället egenskapen GEOSGeometry.ewkb.

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, upp till en angiven tolerans. Värdet tolerans ska vara ett flyttal som representerar feltoleransen i jämförelsen, t.ex. poly1.equals_exact(poly2, 0.001) kommer att jämföra likhet 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 geometrins geometriska mittpunkt. Det är inte garanterat att punkten ligger på geometrins insida.

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]

objekt av typen Polygon kan instansieras genom att man skickar in parametrar som representerar ringarna i polygonen. Parametrarna måste antingen vara LinearRing-instanser eller en sekvens som kan användas för att konstruera 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, få tillgång till egenskapen GEOSGeometry.prepared. När du har en PreparedGeometry-instans kan dess spatiala predikatmetoder, som listas nedan, användas med andra GEOSGeometry-objekt. En operation med en förberedd geometri kan vara flera storleksordningar snabbare - ju mer komplex geometrin som är förberedd är, desto större är hastighetsökningen i operationen. Mer information finns på GEOS wikisida 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 writer-objekt har en write(geom)-metod som returnerar antingen WKB eller WKT för den givna geometrin. Dessutom har WKBWriter-objekten också 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 dess utdata. Som standard returnerar den OGC-kompatibla WKB när dess write-metod anropas. Den har dock egenskaper som gör det möjligt att skapa EWKB, en överuppsättning av WKB-standarden som innehåller ytterligare information. Se WKBWriter.outdim-dokumentationen för mer information om dim-argumentet.

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 geometrins WKB i hexadecimal. Ett 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]

Denna egenskap kan ställas in för att ändra geometrirepresentationens utdatadimension. Med andra ord, om du har en 3D-geometri ska du ange 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 med ett boolean för att ange om geometrins SRID ska inkluderas i WKB-representationen. Exempel på detta:

>>> 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 platsen för GEOS C-biblioteket. Vanligtvis används denna inställning endast om GEOS C-biblioteket finns 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.