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.
\nGeoDjango implementerar en Python-wrapper på hög nivå för GEOS-biblioteket, med bland annat följande funktioner:
\nEtt 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.
Detta avsnitt innehåller en kort introduktion och handledning i hur man använder GEOSGeometry-objekt.
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\n>>> pnt = GEOSGeometry("POINT(5 23)") # WKT\n>>> pnt = GEOSGeometry("010100000000000000000014400000000000003740") # HEX\n>>> pnt = GEOSGeometry(\n... memoryview(\n... b"\\x01\\x01\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x14@\\x00\\x00\\x00\\x00\\x00\\x007@"\n... )\n... ) # WKB\n>>> pnt = GEOSGeometry(\n... '{ "type": "Point", "coordinates": [ 5.000000, 23.000000 ] }'\n... ) # GeoJSON\nEtt 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\n>>> pnt = Point(5, 23)\nAlla dessa konstruktörer tar nyckelordsargumentet srid. Till exempel:
>>> from django.contrib.gis.geos import GEOSGeometry, LineString, Point\n>>> print(GEOSGeometry("POINT (0 0)", srid=4326))\nSRID=4326;POINT (0 0)\n>>> print(LineString((0, 0), (1, 1), srid=4326))\nSRID=4326;LINESTRING (0 0, 1 1)\n>>> print(Point(0, 0, srid=32140))\nSRID=32140;POINT (0 0)\nSlutligen finns fabriksmetoden fromfile() som returnerar ett GEOSGeometry-objekt från en fil:
>>> from django.contrib.gis.geos import fromfile\n>>> pnt = fromfile("/path/to/pnt.wkt")\n>>> pnt = fromfile(open("/path/to/pnt.wkt"))\nGEOSGeometry-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)\n>>> [coord for coord in pnt]\n[5.0, 23.0]\nFör alla geometriobjekt kan egenskapen GEOSGeometry.coords användas för att få geometrikoordinaterna som en Python-tupel:
>>> pnt.coords\n(5.0, 23.0)\nDu 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\n>>> line = LineString((0, 0), (0, 50), (50, 50), (50, 0), (0, 0))\n>>> line[0]\n(0.0, 0.0)\n>>> line[-2]\n(50.0, 0.0)\nMedan indexering på en Polygon kommer att returnera ringen (ett LinearRing-objekt) som motsvarar indexet:
>>> from django.contrib.gis.geos import Polygon\n>>> poly = Polygon(((0.0, 0.0), (0.0, 50.0), (50.0, 50.0), (50.0, 0.0), (0.0, 0.0)))\n>>> poly[0]\n<LinearRing object at 0x1044395b0>\n>>> poly[0][-2] # second-to-last coordinate of external ring\n(50.0, 0.0)\nDessutom kan koordinater/komponenter i geometrin läggas till eller ändras, precis som i en Python-lista:
\n>>> line[0] = (1.0, 1.0)\n>>> line.pop()\n(0.0, 0.0)\n>>> line.append((1.0, 1.0))\n>>> line.coords\n((1.0, 1.0), (0.0, 50.0), (50.0, 50.0), (50.0, 0.0), (1.0, 1.0))\nGeometrier stöder set-liknande operatorer:
\n>>> from django.contrib.gis.geos import LineString\n>>> ls1 = LineString((0, 0), (2, 2))\n>>> ls2 = LineString((1, 1), (3, 3))\n>>> print(ls1 | ls2) # equivalent to `ls1.union(ls2)`\nMULTILINESTRING ((0 0, 1 1), (1 1, 2 2), (2 2, 3 3))\n>>> print(ls1 & ls2) # equivalent to `ls1.intersection(ls2)`\nLINESTRING (1 1, 2 2)\n>>> print(ls1 - ls2) # equivalent to `ls1.difference(ls2)`\nLINESTRING(0 0, 1 1)\n>>> print(ls1 ^ ls2) # equivalent to `ls1.sym_difference(ls2)`\nMULTILINESTRING ((0 0, 1 1), (2 2, 3 3))\nGEOSGeometriLink to this heading#geo_input – Inmatningsvärde för geometri (sträng eller memoryview)
srid (int) – identifierare för rumslig referens
max_geom_collections – maximum number of nested (WKT) or total (WKB)\ngeometry collections accepted before parsing is refused
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\n>>> GEOSGeometry("POINT EMPTY", srid=4326).ewkt\n'SRID=4326;POINT EMPTY'\n>>> GEOSGeometry("SRID=4326;POINT EMPTY", srid=4326).ewkt\n'SRID=4326;POINT EMPTY'\n>>> GEOSGeometry("SRID=1;POINT EMPTY", srid=4326)\nTraceback (most recent call last):\n...\nValueError: Input geometry already has SRID: 1.\nFöljande indataformat, tillsammans med motsvarande Python-typer, accepteras:
\nFormat | \nInmatning Typ | \n
|---|---|
WKT / EWKT | \n
| \n
HEX / HEXEWKB | \n
| \n
WKB / EWKB | \n
| \n
| \n |
| \n
För GeoJSON-formatet ställs SRID in baserat på medlemmen crs. Om crs inte anges är standardvärdet för SRID 4326.
Konstruerar en GEOSGeometry från den givna GML-strängen.
Returnerar geometrins koordinater som en tupel.
\nReturnerar geometrins dimension:
\n0 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
Returnerar om uppsättningen punkter i geometrin är tom eller inte.
\nReturnerar en sträng som motsvarar typen av geometri. Till exempel:
\n>>> pnt = GEOSGeometry("POINT(5 23)")\n>>> pnt.geom_type\n'Point'\nReturnerar identifikationsnumret för GEOS geometrityp. Följande tabell visar värdet för varje geometrityp:
\nGeometri | \nID | \n
|---|---|
| \n | 0 | \n
| \n | 1 | \n
| \n | 2 | \n
| \n | 3 | \n
| \n | 4 | \n
| \n | 5 | \n
| \n | 6 | \n
| \n | 7 | \n
Returnerar antalet koordinater i geometrin.
\nReturnerar antalet geometrier i denna geometri. Med andra ord, kommer att returnera 1 på allt utom geometrisamlingar.
\nReturnerar ett boolean som anger om geometrin är tredimensionell.
\nReturnerar en boolean som anger om geometrin är en LinearRing.
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.
Returnerar ett boolean som anger om geometrin är giltig.
\nReturnerar en sträng som beskriver orsaken till att en geometri är ogiltig.
\nEgenskap som kan användas för att hämta eller ställa in den SRID som är kopplad till geometrin. Till exempel:
\n>>> pnt = Point(5, 23)\n>>> print(pnt.srid)\nNone\n>>> pnt.srid = 4326\n>>> pnt.srid\n4326\nEgenskaperna 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.
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).
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).
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.
\nReturnerar 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.
Alias för GEOSGeometry.json.
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.
\nReturnerar ett OGRGeometry-objekt som motsvarar GEOS-geometrin.
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.
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.
\nReturnerar geometrins Well-Known Text (en OGC-standard).
\nAlla följande metoder för rumsliga predikat tar en annan GEOSGeometry-instans (other) som parameter och returnerar ett boolean.
Returnerar True om other.within(this) returnerar True.
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().
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).
Returnerar True om DE-9IM-intersektionsmatrisen för de två geometrierna är FF*FF****.
Returnerar True om DE-9IM-intersektionsmatrisen för de två geometrierna är T*F**FFF*.
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.
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.
Returnerar True om GEOSGeometry.disjoint() är False.
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).
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}.
Returnerar True om DE-9IM-intersektionsmatrisen för de två geometrierna är FT*******, F**T***** eller F***T****.
Returnerar True om DE-9IM-intersektionsmatrisen för de två geometrierna är T*F**F***.
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).
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.
Returnerar en GEOSGeometry som representerar de punkter som utgör denna geometri och som inte utgör någon annan.
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().
Returnerar en GEOSGeometry som representerar de punkter som delas av denna geometri och andra.
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().
Returnerar DE-9IM-intersektionsmatrisen (en sträng) som representerar det topologiska förhållandet mellan den här geometrin och den andra.
\nReturnerar 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.
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.
Returnerar en GEOSGeometry som representerar alla punkter i den här geometrin och den andra.
Returnerar gränsen som ett nyligen allokerat Geometry-objekt.
\nReturnerar ett Point-objekt som representerar geometrins geometriska mittpunkt. Det är inte garanterat att punkten ligger på geometrins insida.
Returnerar den minsta Polygon som innehåller alla punkter i geometrin.
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.
Beräknar och returnerar en Point som garanterat befinner sig på insidan av denna geometri.
Beräknar sammanslagningen av alla element i denna geometri.
\nResultatet följer följande kontrakt:
\nUnioning 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).
Denna egenskap returnerar geometrins area.
\nDen här egenskapen returnerar geometrins utsträckning som en 4-tupel, bestående av (xmin, ymin, xmax, ymax).
Den här metoden returnerar en GEOSGeometry som är en klon av originalet.
Returnerar avståndet mellan de närmaste punkterna på denna geometri och den givna geometrin (ett annat GEOSGeometry`-objekt).
Returnerar längden på denna geometri (t.ex. 0 för en Point, längden på en LineString eller omkretsen på en Polygon).
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.
Returnerar ett SpatialReference-objekt som motsvarar geometrins SRID eller None.
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.
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.
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))\n>>> print(g)\nMULTIPOINT (0 0, 2 2, 1 1)\n>>> g.normalize()\n>>> print(g)\nMULTIPOINT (2 2, 1 1, 0 0)\nPunktLink to this heading#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)\n>>> pnt = Point([5, 23])\nTomma Point objekt kan instansieras genom att skicka inga argument eller en tom sekvens. Följande är likvärdiga:
>>> pnt = Point()\n>>> pnt = Point([])\nLineStringLink to this heading#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))\n>>> ls = LineString(Point(0, 0), Point(1, 1))\nDessutom kan LineString-objekt också skapas genom att skicka in en enda sekvens av koordinat- eller Point-objekt:
>>> ls = LineString(((0, 0), (1, 1)))\n>>> ls = LineString([Point(0, 0), Point(1, 1)])\nTomma LineString-objekt kan instansieras genom att skicka inga argument eller en tom sekvens. Följande är likvärdiga:
>>> ls = LineString()\n>>> ls = LineString([])\nReturnerar om denna LineString är stängd eller inte.
LineärRingLink to this heading#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))\nObservera att (0, 0) är den första och sista koordinaten - om de inte var lika skulle ett fel uppstå.
Returnerar om denna LinearRing är motsols.
PolygonLink to this heading#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))\n>>> int_coords = ((0.4, 0.4), (0.4, 0.6), (0.6, 0.6), (0.6, 0.4), (0.4, 0.4))\n>>> poly = Polygon(ext_coords, int_coords)\n>>> poly = Polygon(LinearRing(ext_coords), LinearRing(int_coords))\nReturnerar ett polygonobjekt från den angivna bounding-boxen, en 4-tupel bestående av (xmin, ymin, xmax, ymax).
Returnerar antalet inre ringar i denna geometri.
\nMultiPointLink to this heading#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))\n>>> mp = MultiPoint((Point(0, 0), Point(1, 1)))\nMultiLineStringLink to this heading#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))\n>>> ls2 = LineString((2, 2), (3, 3))\n>>> mls = MultiLineString(ls1, ls2)\n>>> mls = MultiLineString([ls1, ls2])\nReturnerar en LineString som representerar linjesammanslagningen av alla komponenter i denna MultiLineString.
Returnerar True om och endast om alla element är stängda.
MultiPolygonLink to this heading#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)))\n>>> p2 = Polygon(((1, 1), (1, 2), (2, 2), (1, 1)))\n>>> mp = MultiPolygon(p1, p2)\n>>> mp = MultiPolygon([p1, p2])\nGeometryCollectionLink to this heading#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)))\n>>> gc = GeometryCollection(Point(0, 0), MultiPoint(Point(0, 0), Point(1, 1)), poly)\n>>> gc = GeometryCollection((Point(0, 0), MultiPoint(Point(0, 0), Point(1, 1)), poly))\nFö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:
\n>>> from django.contrib.gis.geos import Point, Polygon\n>>> poly = Polygon.from_bbox((0, 0, 5, 5))\n>>> prep_poly = poly.prepared\n>>> prep_poly.contains(Point(2.5, 2.5))\nTrue\nFörbereddGeometriLink to this heading#Alla metoder för PreparedGeometry tar ett other argument, som måste vara en GEOSGeometry-instans.
file_h (a Python file object or a string path to the file) – indatafil som innehåller rumsliga data
en GEOSGeometry som motsvarar de rumsliga data som finns i filen
Exempel:
\n>>> from django.contrib.gis.geos import fromfile\n>>> g = fromfile("/home/bob/geom.wkt")\nen GEOSGeometry som motsvarar de rumsliga data i strängen
fromstr(string, srid) är likvärdigt med GEOSGeometry(string, srid).
Exempel:
\n>>> from django.contrib.gis.geos import fromstr\n>>> pnt = fromstr("POINT(-90.5 29.5)", srid=4326)\nI/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.
Exempel:
\n>>> from django.contrib.gis.geos import WKBReader\n>>> wkb_r = WKBReader()\n>>> wkb_r.read("0101000000000000000000F03F000000000000F03F")\n<Point object at 0x103a88910>\nExempel:
\n>>> from django.contrib.gis.geos import WKTReader\n>>> wkt_r = WKTReader()\n>>> wkt_r.read("POINT(1 1)")\n<Point object at 0x103a88b50>\nAlla 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).
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.
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\n>>> pnt = Point(1, 1)\n>>> wkb_w = WKBWriter()\n>>> wkb_w.write(pnt)\n<read-only buffer for 0x103a898f0, size -1, offset 0 at 0x103a89930>\nReturnerar geometrins WKB i hexadecimal. Ett exempel:
\n>>> from django.contrib.gis.geos import Point, WKBWriter\n>>> pnt = Point(1, 1)\n>>> wkb_w = WKBWriter()\n>>> wkb_w.write_hex(pnt)\n'0101000000000000000000F03F000000000000F03F'\nDenna egenskap kan ställas in för att ändra byte-ordningen för geometrirepresentationen.
\nByteordning Värde | \nBeskrivning | \n
|---|---|
0 | \nBig Endian (t.ex. kompatibel med RISC-system) | \n
1 | \nLittle Endian (t.ex. kompatibel med x86-system) | \n
Exempel:
\n>>> from django.contrib.gis.geos import Point, WKBWriter\n>>> wkb_w = WKBWriter()\n>>> pnt = Point(1, 1)\n>>> wkb_w.write_hex(pnt)\n'0101000000000000000000F03F000000000000F03F'\n>>> wkb_w.byteorder = 0\n'00000000013FF00000000000003FF0000000000000'\nDenna 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.
\nOutdim värde | \nBeskrivning | \n
|---|---|
2 | \nStandard, utdata 2D WKB. | \n
3 | \nUtgång 3D WKB. | \n
Exempel:
\n>>> from django.contrib.gis.geos import Point, WKBWriter\n>>> wkb_w = WKBWriter()\n>>> wkb_w.outdim\n2\n>>> pnt = Point(1, 1, 1)\n>>> wkb_w.write_hex(pnt) # By default, no Z value included:\n'0101000000000000000000F03F000000000000F03F'\n>>> wkb_w.outdim = 3 # Tell writer to include Z values\n>>> wkb_w.write_hex(pnt)\n'0101000080000000000000F03F000000000000F03F000000000000F03F'\nAnge denna egenskap med ett boolean för att ange om geometrins SRID ska inkluderas i WKB-representationen. Exempel på detta:
\n>>> from django.contrib.gis.geos import Point, WKBWriter\n>>> wkb_w = WKBWriter()\n>>> pnt = Point(1, 1, srid=4326)\n>>> wkb_w.write_hex(pnt) # By default, no SRID included:\n'0101000000000000000000F03F000000000000F03F'\n>>> wkb_w.srid = True # Tell writer to include SRID\n>>> wkb_w.write_hex(pnt)\n'0101000020E6100000000000000000F03F000000000000F03F'\nDenna 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.
Returnerar WKT för den givna geometrin. Ett exempel:
\n>>> from django.contrib.gis.geos import Point, WKTWriter\n>>> pnt = Point(1, 1)\n>>> wkt_w = WKTWriter()\n>>> wkt_w.write(pnt)\n'POINT (1.0000000000000000 1.0000000000000000)'\nSe WKBWriter.outdim.
Denna egenskap används för att aktivera eller inaktivera trimning av onödiga decimaler.
\n>>> from django.contrib.gis.geos import Point, WKTWriter\n>>> pnt = Point(1, 1)\n>>> wkt_w = WKTWriter()\n>>> wkt_w.trim\nFalse\n>>> wkt_w.write(pnt)\n'POINT (1.0000000000000000 1.0000000000000000)'\n>>> wkt_w.trim = True\n>>> wkt_w.write(pnt)\n'POINT (1 1)'\nDenna egenskap styr koordinaternas avrundningsprecision; om den är inställd på ”Ingen” är avrundning inaktiverad.
\n>>> from django.contrib.gis.geos import Point, WKTWriter\n>>> pnt = Point(1.44, 1.66)\n>>> wkt_w = WKTWriter()\n>>> print(wkt_w.precision)\nNone\n>>> wkt_w.write(pnt)\n'POINT (1.4399999999999999 1.6599999999999999)'\n>>> wkt_w.precision = 0\n>>> wkt_w.write(pnt)\n'POINT (1 2)'\n>>> wkt_w.precision = 1\n>>> wkt_w.write(pnt)\n'POINT (1.4 1.7)'\nFotnoter
\n\nGEOS_BIBLIOTEK_ SÖKVÄGLink to this heading#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).
Base GEOS exception, indikerar ett GEOS-relaterat fel.
\n