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 implements a high-level Python wrapper for the GEOS library, its\nfeatures include:
\nA BSD-licensed interface to the GEOS geometry routines, implemented purely\nin Python using 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.
Mutability: GEOSGeometry objects may be modified.
Cross-platform and tested; compatible with Windows, Linux, Solaris, and\nmacOS platforms.
This section contains a brief introduction and tutorial to using\nGEOSGeometry objects.
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(memoryview(b'\\x01\\x01\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x14@\\x00\\x00\\x00\\x00\\x00\\x007@')) # WKB\n>>> pnt = GEOSGeometry('{ "type": "Point", "coordinates": [ 5.000000, 23.000000 ] }') # 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)\nAll these constructors take the keyword argument srid. For example:
>>> 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)\nFinally, there is the fromfile() factory method which returns a\nGEOSGeometry object from a file:
>>> from django.contrib.gis.geos import fromfile\n>>> pnt = fromfile('/path/to/pnt.wkt')\n>>> pnt = fromfile(open('/path/to/pnt.wkt'))\nGEOSGeometry objects are ‘Pythonic’, in other words components may\nbe accessed, modified, and iterated over using standard Python conventions.\nFor example, you can iterate over the coordinates in a Point:
>>> pnt = Point(5, 23)\n>>> [coord for coord in pnt]\n[5.0, 23.0]\nWith any geometry object, the GEOSGeometry.coords property\nmay be used to get the geometry coordinates as a Python tuple:
>>> 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)\nWhereas indexing on a Polygon will return the ring\n(a LinearRing object) corresponding to the index:
>>> 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)\nIn addition, coordinates/components of the geometry may added or modified,\njust like a Python list:
\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))\nGeometries support set-like operators:
\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))\nGEOSGeometryLink to this heading#geo_input – Geometry input value (string or buffer)
srid (int) – spatial reference identifier
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).
The srid parameter, if given, is set as the SRID of the created geometry if\ngeo_input doesn’t have an SRID. If different SRIDs are provided through the\ngeo_input and srid parameters, ValueError is raised:
>>> 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.\nThe following input formats, along with their corresponding Python types,\nare accepted:
\nFormat | \nInput Type | \n
|---|---|
WKT / EWKT | \n
| \n
HEX / HEXEWKB | \n
| \n
WKB / EWKB | \n
| \n
| \n |
| \n
For the GeoJSON format, the SRID is set based on the crs member. If crs\nisn’t provided, the SRID defaults to 4326.
Constructs a GEOSGeometry from the given GML string.
Returns the coordinates of the geometry as a tuple.
\nReturns the dimension of the geometry:
\n0 for Points and MultiPoints
1 for LineStrings and MultiLineStrings
2 for Polygons and MultiPolygons
-1 for empty GeometryCollections
the maximum dimension of its elements for non-empty\nGeometryCollections
Returns whether or not the set of points in the geometry is empty.
\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:
\nGeometry | \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
Returns the number of coordinates in the geometry.
\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 is three-dimensional.
\nReturns a boolean indicating whether the geometry is a 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 do cannot intersect themselves, by\ndefinition.
Returns a boolean indicating whether the geometry is valid.
\nReturns a string describing the reason why a geometry is invalid.
\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.
\nReturns the GeoJSON representation of the geometry. Note that the result is\nnot a complete GeoJSON structure but only the geometry key content of a\nGeoJSON structure. See also GeoJSON Serializer.
Alias for 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.
\nReturns an OGRGeometry object\ncorresponding to the GEOS geometry.
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.
Return the EWKB representation of this Geometry as a Python buffer.\nThis is an extension of the WKB specification that includes any SRID\nvalue that are a part of this geometry.
\nReturns the Well-Known Text of the geometry (an OGC standard).
\nAll of the following spatial predicate methods take another\nGEOSGeometry instance (other) as a parameter, and\nreturn a boolean.
Returns True if other.within(this) returns\nTrue.
Returns True if this geometry covers the specified geometry.
The covers predicate has the following equivalent definitions:
Every point of the other geometry is a point of this geometry.
The DE-9IM Intersection Matrix for the two geometries is\nT*****FF*, *T****FF*, ***T**FF*, or ****T*FF*.
If either geometry is empty, returns False.
This predicate is similar to GEOSGeometry.contains(), but is more\ninclusive (i.e. returns True for more cases). In particular, unlike\ncontains() it does not distinguish between points in the\nboundary and in the interior of geometries. For most situations,\ncovers() should be preferred to contains(). As an\nadded benefit, covers() is more amenable to optimization and hence\nshould outperform contains().
Returns True if the DE-9IM intersection matrix for the two Geometries\nis T*T****** (for a point and a curve,a point and an area or a line\nand an area) 0******** (for two curves).
Returns True if the DE-9IM intersection matrix for the two geometries\nis FF*FF****.
Returns True if the DE-9IM intersection matrix for the two geometries\nis 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.
Returns True if GEOSGeometry.disjoint() is False.
Returns true if the DE-9IM intersection matrix for the two geometries\nis T*T***T** (for two points or two surfaces) 1*T***T**\n(for two curves).
Returns True if the elements in the DE-9IM intersection matrix\nfor this geometry and the other matches the given pattern –\na string of nine characters from the alphabet: {T, F, *, 0}.
Returns True if the DE-9IM intersection matrix for the two geometries\nis FT*******, F**T***** or F***T****.
Returns True if the DE-9IM intersection matrix for the two geometries\nis T*F**F***.
Returns a GEOSGeometry that represents all points whose distance\nfrom this geometry is less than or equal to the given width. The\noptional quadsegs keyword sets the number of segments used to\napproximate a quarter circle (defaults is 8).
Same as buffer(), but allows customizing the style of the buffer.
end_cap_style can be round (1), flat (2), or square (3).
join_style can be round (1), mitre (2), or bevel (3).
Mitre ratio limit (mitre_limit) only affects mitered join style.
Returns a GEOSGeometry representing the points making up this\ngeometry that do not make up other.
Given a distance (float), returns the point (or closest point) within the\ngeometry (LineString or MultiLineString) at that distance.\nThe normalized version takes the distance as a float between 0 (origin) and\n1 (endpoint).
Reverse of GEOSGeometry.project().
Returns a GEOSGeometry representing the points shared by this\ngeometry and other.
Returns the distance (float) from the origin of the geometry\n(LineString or MultiLineString) to the point projected on\nthe geometry (that is to a point of the line the closest to the given\npoint). The normalized version returns the distance as a float between 0\n(origin) and 1 (endpoint).
Reverse of GEOSGeometry.interpolate().
Returns the DE-9IM intersection matrix (a string) representing the\ntopological relationship between this geometry and the other.
\nReturns a new GEOSGeometry, simplified to the specified tolerance\nusing the Douglas-Peucker algorithm. A higher tolerance value implies\nfewer points in the output. If no tolerance is provided, it defaults to 0.
By default, this function does not preserve topology. For example,\nPolygon objects can be split, be collapsed into lines, or\ndisappear. Polygon holes can be created or disappear, and lines may\ncross. By specifying preserve_topology=True, the result will have the\nsame dimension and number of components as the input; this is significantly\nslower, however.
Returns a GEOSGeometry combining the points in this geometry\nnot in other, and the points in other not in this geometry.
Returns a GEOSGeometry representing all the points in this\ngeometry and the other.
Returns the boundary as a newly allocated Geometry object.
\nReturns a Point object representing the geometric center of\nthe geometry. The point is not guaranteed to be on the interior\nof the geometry.
Returns the smallest Polygon that contains all the points in\nthe geometry.
Returns a Polygon that represents the bounding envelope of\nthis geometry. Note that it can also return a Point if the input\ngeometry is a point.
Computes and returns a Point guaranteed to be on the interior\nof this geometry.
Computes the union of all the elements of this geometry.
\nThe result obeys the following contract:
\nUnioning a set of LineStrings has the effect of fully noding and\ndissolving the linework.
Unioning a set of Polygons will always return a Polygon\nor MultiPolygon geometry (unlike GEOSGeometry.union(),\nwhich may return geometries of lower dimension if a topology collapse\noccurs).
This property returns the area of the Geometry.
\nThis property returns the extent of this geometry as a 4-tuple,\nconsisting of (xmin, ymin, xmax, ymax).
This method returns a GEOSGeometry that is a clone of the original.
Returns the distance between the closest points on this geometry and the\ngiven geom (another GEOSGeometry object).
Returns the length of this geometry (e.g., 0 for a Point,\nthe length of a LineString, or the circumference of\na Polygon).
Returns a GEOS PreparedGeometry for the contents of this geometry.\nPreparedGeometry objects are optimized for the contains, intersects,\ncovers, crosses, disjoint, overlaps, touches and within operations. Refer to\nthe Prepared Geometries documentation for more information.
Returns a SpatialReference object\ncorresponding to the SRID of the geometry or None.
Transforms the geometry according to the given coordinate transformation\nparameter (ct), which may be an integer SRID, spatial reference WKT\nstring, a PROJ string, a SpatialReference\nobject, or a CoordTransform object. By\ndefault, the geometry is transformed in-place and nothing is returned.\nHowever if the clone keyword is set, then the geometry is not modified\nand a transformed clone of the geometry is returned instead.
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. Requires GEOS 3.8.
Converts this geometry to canonical form. If the clone keyword is set,\nthen the geometry is not modified and a normalized clone of the geometry is\nreturned instead:
>>> 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)\nPointLink to this heading#Point objects are instantiated using arguments that represent the\ncomponent coordinates of the point or with a single sequence coordinates.\nFor example, the following are equivalent:
>>> pnt = Point(5, 23)\n>>> pnt = Point([5, 23])\nEmpty Point objects may be instantiated by passing no arguments or an\nempty sequence. The following are equivalent:
>>> pnt = Point()\n>>> pnt = Point([])\nLineStringLink to this heading#LineString objects are instantiated using arguments that are either a\nsequence of coordinates or Point objects. For example, the\nfollowing are equivalent:
>>> ls = LineString((0, 0), (1, 1))\n>>> ls = LineString(Point(0, 0), Point(1, 1))\nIn addition, LineString objects may also be created by passing in a\nsingle sequence of coordinate or Point objects:
>>> ls = LineString( ((0, 0), (1, 1)) )\n>>> ls = LineString( [Point(0, 0), Point(1, 1)] )\nEmpty LineString objects may be instantiated by passing no arguments\nor an empty sequence. The following are equivalent:
>>> ls = LineString()\n>>> ls = LineString([])\nReturns whether or not this LineString is closed.
LinearRingLink to this heading#LinearRing objects are constructed in the exact same way as\nLineString objects, however the coordinates must be closed, in\nother words, the first coordinates must be the same as the last\ncoordinates. For example:
>>> ls = LinearRing((0, 0), (0, 1), (1, 1), (0, 0))\nNotice that (0, 0) is the first and last coordinate – if they were not\nequal, an error would be raised.
Returns whether this LinearRing is counterclockwise.
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 a\nLinearRing:
>>> 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))\nReturns a polygon object from the given bounding-box, a 4-tuple\ncomprising (xmin, ymin, xmax, ymax).
Returns the number of interior rings in this geometry.
\nMultiPointLink to this heading#MultiPoint objects may be instantiated by passing in Point\nobjects as arguments, or a single sequence of Point objects:
>>> mp = MultiPoint(Point(0, 0), Point(1, 1))\n>>> mp = MultiPoint( (Point(0, 0), Point(1, 1)) )\nMultiLineStringLink to this heading#MultiLineString objects may be instantiated by passing in\nLineString objects as arguments, or a single sequence of\nLineString objects:
>>> ls1 = LineString((0, 0), (1, 1))\n>>> ls2 = LineString((2, 2), (3, 3))\n>>> mls = MultiLineString(ls1, ls2)\n>>> mls = MultiLineString([ls1, ls2])\nReturns a LineString representing the line merge of\nall the components in this MultiLineString.
Returns True if and only if all elements are closed.
MultiPolygonLink to this heading#MultiPolygon objects may be instantiated by passing Polygon\nobjects as arguments, or a single sequence of Polygon objects:
>>> 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 objects may be instantiated by passing in other\nGEOSGeometry as arguments, or a single sequence of\nGEOSGeometry objects:
>>> 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\nPreparedGeometry instance its spatial predicate methods, listed below,\nmay be used with other GEOSGeometry objects. An operation with a prepared\ngeometry can be orders of magnitude faster – the more complex the geometry\nthat is prepared, the larger the speedup in the operation. For more information,\nplease consult the GEOS wiki page on prepared geometries.
For example:
\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\nPreparedGeometryLink to this heading#All methods on PreparedGeometry take an other argument, which\nmust be a GEOSGeometry instance.
file_h (a Python file object or a string path to the file) – input file that contains spatial data
a GEOSGeometry corresponding to the spatial data in the file
Example:
\n>>> from django.contrib.gis.geos import fromfile\n>>> g = fromfile('/home/bob/geom.wkt')\na GEOSGeometry corresponding to the spatial data in the string
fromstr(string, srid) is equivalent to\nGEOSGeometry(string, srid).
Example:
\n>>> from django.contrib.gis.geos import fromstr\n>>> pnt = fromstr('POINT(-90.5 29.5)', srid=4326)\nThe reader I/O classes return a GEOSGeometry instance from the WKB\nand/or WKT input given to their read(geom) method.
Example:
\n>>> from django.contrib.gis.geos import WKBReader\n>>> wkb_r = WKBReader()\n>>> wkb_r.read('0101000000000000000000F03F000000000000F03F')\n<Point object at 0x103a88910>\nExample:
\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.
Returns the WKB of the given geometry as a Python buffer object.\nExample:
>>> 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'\nThis property may be set to change the byte-order of the geometry\nrepresentation.
\nByteorder Value | \nDescription | \n
|---|---|
0 | \nBig Endian (e.g., compatible with RISC systems) | \n
1 | \nLittle Endian (e.g., compatible with x86 systems) | \n
Example:
\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 Value | \nDescription | \n
|---|---|
2 | \nThe default, output 2D WKB. | \n
3 | \nOutput 3D WKB. | \n
Example:
\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'\nThis class allows outputting the WKT representation of a geometry. See the\nWKBWriter.outdim, trim, and precision attributes for\ndetails about the constructor arguments.
Returns the WKT of the given geometry. Example:
\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)'\nSee WKBWriter.outdim.
This property is used to enable or disable trimming of\nunnecessary decimals.
\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)'\nThis property controls the rounding precision of coordinates;\nif set to None rounding is disabled.
>>> 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)'\nFootnotes
\n\nGEOS_LIBRARY_PATHLink 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).
The base GEOS exception, indicates a GEOS-related error.
\n