GEOS stands for Geometry Engine - Open Source,\nand is a C++ library, ported from the Java Topology Suite. GEOS\nimplements the OpenGIS Simple Features for SQL spatial predicate functions\nand spatial operators. GEOS, now an OSGeo project, was initially developed and\nmaintained by Refractions Research of Victoria, Canada.
\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.
Loosely-coupled to GeoDjango. For example, GEOSGeometry objects\nmay be used outside of a Django project/application. In other words,\nno need to have DJANGO_SETTINGS_MODULE set or use a database, 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 objects may be created in a few ways. The first is\nto simply instantiate the object on some spatial input – the following\nare examples of creating the same geometry from WKT, HEX, WKB, and 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\nAnother option is to use the constructor for the specific geometry type\nthat you wish to create. For example, a Point object may be\ncreated by passing in the X and Y coordinates into its constructor:
>>> 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)\nYou can get/set geometry components using standard Python indexing\ntechniques. However, what is returned depends on the geometry type\nof the object. For example, indexing on a LineString\nreturns a coordinate tuple:
>>> 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
This is the base class for all GEOS geometry objects. It initializes on the\ngiven geo_input argument, and then assumes the proper geometry subclass\n(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\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.
\nReturns a string corresponding to the type of geometry. For example:
\n>>> pnt = GEOSGeometry("POINT(5 23)")\n>>> pnt.geom_type\n'Point'\nReturns the GEOS geometry type identification number. The following table\nshows the value for each geometry type:
\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.
\nReturns the number of geometries in this geometry. In other words, will\nreturn 1 on anything but geometry collections.
\nReturns a boolean indicating whether the geometry has the Z dimension.
\nReturns a boolean indicating whether the geometry has the M dimension.\nRequires GEOS 3.12.
\nReturnerar en boolean som anger om geometrin är en LinearRing.
Returns a boolean indicating whether the geometry is ’simple’. A geometry\nis simple if and only if it does not intersect itself (except at boundary\npoints). For example, a LineString object is not simple if it\nintersects itself. Thus, LinearRing and Polygon objects\nare always simple because they cannot intersect themselves, by definition.
Returnerar ett boolean som anger om geometrin är giltig.
\nReturnerar en sträng som beskriver orsaken till att en geometri är ogiltig.
\nProperty that may be used to retrieve or set the SRID associated with the\ngeometry. For example:
\n>>> pnt = Point(5, 23)\n>>> print(pnt.srid)\nNone\n>>> pnt.srid = 4326\n>>> pnt.srid\n4326\nThe properties in this section export the GEOSGeometry object into\na different. This output may be in the form of a string, buffer, or even\nanother object.
Returns the ”extended” Well-Known Text of the geometry. This representation\nis specific to PostGIS and is a superset of the OGC WKT standard. [1]\nEssentially the SRID is prepended to the WKT representation, for example\nSRID=4326;POINT(5 23).
Returns the WKB of this Geometry in hexadecimal form. Please note\nthat the SRID value is not included in this representation\nbecause it is not a part of the OGC specification (use the\nGEOSGeometry.hexewkb property instead).
Returns the EWKB of this Geometry in hexadecimal form. This is an\nextension of the WKB specification that includes the SRID value\nthat are a part of this geometry.
\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.
Returns a KML (Keyhole Markup Language) representation of the\ngeometry. This should only be used for geometries with an SRID of\n4326 (WGS84), but this restriction is not enforced.
\nReturnerar ett OGRGeometry-objekt som motsvarar GEOS-geometrin.
Returns the WKB (Well-Known Binary) representation of this Geometry\nas a Python buffer. SRID value is not included, use the\nGEOSGeometry.ewkb property instead.
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*.
Returns true if the two geometries are exactly equal, up to a\nspecified tolerance. The tolerance value should be a floating\npoint number representing the error tolerance in the comparison, e.g.,\npoly1.equals_exact(poly2, 0.001) will compare equality to within\none thousandth of a unit.
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.
\nReturns a Point object representing the geometric center of\nthe geometry. The point is not guaranteed to be on the interior\nof the geometry.
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.
Returns a valid GEOSGeometry equivalent, trying not to lose any of\nthe input vertices. If the geometry is already valid, it is returned\nuntouched. This is similar to the\nMakeValid database\nfunction.
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#Polygon objects may be instantiated by passing in parameters that\nrepresent the rings of the polygon. The parameters must either be\nLinearRing instances, or a sequence that may be used to construct\na 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))\nIn order to obtain a prepared geometry, access the\nGEOSGeometry.prepared property. Once you have a PreparedGeometry\ninstance its spatial predicate methods, listed below, may be used with other\nGEOSGeometry objects. An operation with a prepared geometry can be orders\nof magnitude faster – the more complex the geometry that is prepared, the\nlarger the speedup in the operation. For more information, please consult the\nGEOS wiki page on prepared geometries.
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>\nAll writer objects have a write(geom) method that returns either the\nWKB or WKT of the given geometry. In addition, WKBWriter objects\nalso have properties that may be used to change the byte order, and or\ninclude the SRID value (in other words, EWKB).
WKBWriter provides the most control over its output. By default it\nreturns OGC-compliant WKB when its write method is called. However,\nit has properties that allow for the creation of EWKB, a superset of the\nWKB standard that includes additional information. See the\nWKBWriter.outdim documentation for more details about the dim\nargument.
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>\nReturns WKB of the geometry in hexadecimal. Example:
\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'\nThis property may be set to change the output dimension of the geometry\nrepresentation. In other words, if you have a 3D geometry then set to 3\nso that the Z value is included in the 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'\nSet this property with a boolean to indicate whether the SRID of the\ngeometry should be included with the WKB representation. Example:
\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#A string specifying the location of the GEOS C library. Typically,\nthis setting is only used if the GEOS C library is in a non-standard\nlocation (e.g., /home/bob/lib/libgeos_c.so).
Base GEOS exception, indikerar ett GEOS-relaterat fel.
\n