---
title: "GEOS API"
version: 5.2
locale: sv
source: https://docs.djangoproject.com/sv/5.2/ref/contrib/gis/geos/
canonical: https://djangodocs.dev/sv/5.2/ref/contrib/gis/geos/
---
# 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  rumsliga predikatfunktioner och rumsliga operatorer. GEOS, som nu är ett OSGeo-projekt, utvecklades och underhålls ursprungligen av  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`](#django.contrib.gis.geos.GEOSGeometry)-objekt användas utanför ett Django-projekt/applikation.  Med andra ord behöver du inte ha [`DJANGO_SETTINGS_MODULE`](/sv/5.2/topics/settings/#envvar-DJANGO_SETTINGS_MODULE) inställd eller använda en databas, etc.
- Ändringsbarhet: [`GEOSGeometry`](#django.contrib.gis.geos.GEOSGeometry)-objekt kan ändras.
- Testad på flera plattformar.

## Handledning

Detta avsnitt innehåller en kort introduktion och handledning i hur man använder [`GEOSGeometry`](#django.contrib.gis.geos.GEOSGeometry)-objekt.

### Skapa en geometri

[`GEOSGeometry`](#django.contrib.gis.geos.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:

```pycon
>>> 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`](#django.contrib.gis.geos.Point)-objekt skapas genom att X- och Y-koordinaterna anges i dess konstruktor:

```pycon
>>> from django.contrib.gis.geos import Point
>>> pnt = Point(5, 23)
```

Alla dessa konstruktörer tar nyckelordsargumentet `srid`. Till exempel:

```pycon
>>> 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()`](#django.contrib.gis.geos.fromfile) som returnerar ett [`GEOSGeometry`](#django.contrib.gis.geos.GEOSGeometry)-objekt från en fil:

```pycon
>>> 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`](#django.contrib.gis.geos.GEOSGeometry)-objekt i det lokala omfånget av dina funktioner/metoder.

### Geometrier är pytoniska

[`GEOSGeometry`](#django.contrib.gis.geos.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`](#django.contrib.gis.geos.Point):

```pycon
>>> pnt = Point(5, 23)
>>> [coord for coord in pnt]
[5.0, 23.0]
```

För alla geometriobjekt kan egenskapen [`GEOSGeometry.coords`](#django.contrib.gis.geos.GEOSGeometry.coords) användas för att få geometrikoordinaterna som en Python-tupel:

```pycon
>>> 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`](#django.contrib.gis.geos.LineString) returnerar en koordinattupel:

```pycon
>>> 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`](#django.contrib.gis.geos.Polygon) kommer att returnera ringen (ett [`LinearRing`](#django.contrib.gis.geos.LinearRing)-objekt) som motsvarar indexet:

```pycon
>>> 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:

```pycon
>>> 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:

```pycon
>>> 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`](#django.contrib.gis.geos.GEOSGeometry) använder [`equals_exact()`](#django.contrib.gis.geos.GEOSGeometry.equals_exact), inte [`equals()`](#django.contrib.gis.geos.GEOSGeometry.equals), dvs. den kräver att de jämförda geometrierna har samma koordinater i samma positioner med samma SRID:
>
> ```pycon
> >>> 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, * (Keyword-only parameters separator (PEP 3102)), max_geom_collections=198)`

**Parametrar:** - `geo_input` – Inmatningsvärde för geometri (sträng eller [`memoryview`](https://docs.python.org/3/library/stdtypes.html#memoryview))
- `srid` ([`int`](https://docs.python.org/3/library/functions.html#int)) – identifierare för rumslig referens
- `max_geom_collections` – maximum number of nested (WKT) or total (WKB)
  geometry 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`](#django.contrib.gis.geos.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`:

```pycon
>>> 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**](https://datatracker.ietf.org/doc/html/rfc7946.html) | `str` |

För GeoJSON-formatet ställs SRID in baserat på medlemmen `crs`. Om `crs` inte anges är standardvärdet för SRID 4326.

> **Changed in Django 5.2.17**
>
> The `max_geom_collections` parameter was added.

#### `classmethod GEOSGeometry.from_gml(gml_string)`

Konstruerar en [`GEOSGeometry`](#django.contrib.gis.geos.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`](#django.contrib.gis.geos.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:

```pycon
>>> 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 |
| --- | --- |
| [`Point`](#django.contrib.gis.geos.Point) | 0 |
| [`LineString`](#django.contrib.gis.geos.LineString) | 1 |
| [`LinearRing`](#django.contrib.gis.geos.LinearRing) | 2 |
| [`Polygon`](#django.contrib.gis.geos.Polygon) | 3 |
| [`MultiPoint`](#django.contrib.gis.geos.MultiPoint) | 4 |
| [`MultiLineString`](#django.contrib.gis.geos.MultiLineString) | 5 |
| [`MultiPolygon`](#django.contrib.gis.geos.MultiPolygon) | 6 |
| [`GeometryCollection`](#django.contrib.gis.geos.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`](#django.contrib.gis.geos.LineString)-objekt är t.ex. inte enkelt om det skär sig självt. Objekten [`LinearRing`](#django.contrib.gis.geos.LinearRing) och [`Polygon`](#django.contrib.gis.geos.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:

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

#### Egenskaper för utdata

Egenskaperna i detta avsnitt exporterar [`GEOSGeometry`](#django.contrib.gis.geos.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)`.

> **Note**
>
> 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`](#django.contrib.gis.geos.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](/sv/5.2/ref/contrib/gis/serializers/).

#### `GEOSGeometry.geojson`

Alias för [`GEOSGeometry.json`](#django.contrib.gis.geos.GEOSGeometry.json).

#### `GEOSGeometry.kml`

Returnerar en  (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`](/sv/5.2/ref/contrib/gis/gdal/#django.contrib.gis.gdal.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`](#django.contrib.gis.geos.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`](#django.contrib.gis.geos.GEOSGeometry)-instans (`other`) som parameter och returnerar ett boolean.

#### `GEOSGeometry.contains(other)`

Returnerar `True` om [`other.within(this)`](#django.contrib.gis.geos.GEOSGeometry.within) 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](https://en.wikipedia.org/wiki/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()`](#django.contrib.gis.geos.GEOSGeometry.contains), men är mer inkluderande (d.v.s. returnerar `True` för fler fall). I synnerhet, till skillnad från [`contains()`](#django.contrib.gis.geos.GEOSGeometry.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()`](#django.contrib.gis.geos.GEOSGeometry.contains). Som en extra fördel är `covers()` mer mottaglig för optimering och bör därför överträffa [`contains()`](#django.contrib.gis.geos.GEOSGeometry.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()`](#django.contrib.gis.geos.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`](#django.contrib.gis.geos.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()`](#django.contrib.gis.geos.GEOSGeometry.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`](#django.contrib.gis.geos.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`](#django.contrib.gis.geos.LineString) eller [`MultiLineString`](#django.contrib.gis.geos.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()`](#django.contrib.gis.geos.GEOSGeometry.project).

#### `GEOSGeometry.intersection(other)`

Returnerar en [`GEOSGeometry`](#django.contrib.gis.geos.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`](#django.contrib.gis.geos.LineString) eller [`MultiLineString`](#django.contrib.gis.geos.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()`](#django.contrib.gis.geos.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`](#django.contrib.gis.geos.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`](#django.contrib.gis.geos.Polygon)-objekt delas upp, kollapsas till linjer eller försvinna. [`Polygon`](#django.contrib.gis.geos.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`](#django.contrib.gis.geos.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`](#django.contrib.gis.geos.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`](#django.contrib.gis.geos.Point)-objekt som representerar geometrins geometriska mittpunkt.  Det är inte garanterat att punkten ligger på geometrins insida.

#### `GEOSGeometry.convex_hull`

Returnerar den minsta [`Polygon`](#django.contrib.gis.geos.Polygon) som innehåller alla punkter i geometrin.

#### `GEOSGeometry.envelope`

Returnerar en [`Polygon`](#django.contrib.gis.geos.Polygon) som representerar den avgränsande omslutningen av denna geometri. Observera att den också kan returnera en [`Point`](#django.contrib.gis.geos.Point) om indatageometrin är en punkt.

#### `GEOSGeometry.point_on_surface`

Beräknar och returnerar en [`Point`](#django.contrib.gis.geos.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`](#django.contrib.gis.geos.Polygon) kommer alltid att returnera en [`Polygon`](#django.contrib.gis.geos.Polygon) eller [`MultiPolygon`](#django.contrib.gis.geos.MultiPolygon) geometri (till skillnad från [`GEOSGeometry.union()`](#django.contrib.gis.geos.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`](#django.contrib.gis.geos.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).

> **Note**
>
> 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`](#django.contrib.gis.geos.Point), längden på en [`LineString`](#django.contrib.gis.geos.LineString) eller omkretsen på en [`Polygon`](#django.contrib.gis.geos.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](#prepared-geometries) för mer information.

#### `GEOSGeometry.srs`

Returnerar ett [`SpatialReference`](/sv/5.2/ref/contrib/gis/gdal/#django.contrib.gis.gdal.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`](/sv/5.2/ref/contrib/gis/gdal/#django.contrib.gis.gdal.SpatialReference)-objekt eller ett [`CoordTransform`](/sv/5.2/ref/contrib/gis/gdal/#django.contrib.gis.gdal.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.

> **Note**
>
> Utlöser [`GEOSException`](#django.contrib.gis.geos.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`](/sv/5.2/ref/contrib/gis/gdal/#django.contrib.gis.gdal.CoordTransform)-objekt.

#### `GEOSGeometry.make_valid()`

Returnerar en giltig [`GEOSGeometry`](#django.contrib.gis.geos.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`](/sv/5.2/ref/contrib/gis/functions/#django.contrib.gis.db.models.functions.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:

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

`Point`-objekt instansieras med argument som representerar punktens komponentkoordinater eller med en enda koordinatsekvens. Till exempel: är följande likvärdiga:

```pycon
>>> 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:

```pycon
>>> pnt = Point()
>>> pnt = Point([])
```

### `LineString`

#### `class LineString(*args, **kwargs)`

`LineString`-objekt instansieras med hjälp av argument som antingen är en sekvens av koordinater eller [`Point`](#django.contrib.gis.geos.Point)-objekt. Till exempel: är följande likvärdiga:

```pycon
>>> 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`](#django.contrib.gis.geos.Point)-objekt:

```pycon
>>> 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:

```pycon
>>> ls = LineString()
>>> ls = LineString([])
```

#### `closed`

Returnerar om denna `LineString` är stängd eller inte.

### `LineärRing`

#### `class LinearRing(*args, **kwargs)`

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

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

Returnerar om denna `LinearRing` är motsols.

### `Polygon`

#### `class Polygon(*args, **kwargs)`

objekt av typen `Polygon` kan instansieras genom att man skickar in parametrar som representerar ringarna i polygonen.  Parametrarna måste antingen vara [`LinearRing`](#django.contrib.gis.geos.LinearRing)-instanser eller en sekvens som kan användas för att konstruera en [`LinearRing`](#django.contrib.gis.geos.LinearRing):

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

Returnerar ett polygonobjekt från den angivna bounding-boxen, en 4-tupel bestående av `(xmin, ymin, xmax, ymax)`.

#### `num_interior_rings`

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`](#django.contrib.gis.geos.LineString) betyder det inte så mycket (men det är konsekvent och snabbt). Du kan alltid tvinga fram jämförelsen med egenskapen [`area`](#django.contrib.gis.geos.GEOSGeometry.area):
>
> ```pycon
> >>> if poly_1.area > poly_2.area:
> ...     pass
> ...
> ```

## Geometri Samlingar

### `MultiPoint`

#### `class MultiPoint(*args, **kwargs)`

`MultiPoint`-objekt kan instansieras genom att skicka in [`Point`](#django.contrib.gis.geos.Point)-objekt som argument, eller en enda sekvens av [`Point`](#django.contrib.gis.geos.Point)-objekt:

```pycon
>>> mp = MultiPoint(Point(0, 0), Point(1, 1))
>>> mp = MultiPoint((Point(0, 0), Point(1, 1)))
```

### `MultiLineString`

#### `class MultiLineString(*args, **kwargs)`

`MultiLineString`-objekt kan instansieras genom att skicka in [`LineString`](#django.contrib.gis.geos.LineString)-objekt som argument, eller en enda sekvens av [`LineString`](#django.contrib.gis.geos.LineString)-objekt:

```pycon
>>> ls1 = LineString((0, 0), (1, 1))
>>> ls2 = LineString((2, 2), (3, 3))
>>> mls = MultiLineString(ls1, ls2)
>>> mls = MultiLineString([ls1, ls2])
```

#### `merged`

Returnerar en [`LineString`](#django.contrib.gis.geos.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)`

`MultiPolygon`-objekt kan instansieras genom att skicka [`Polygon`](#django.contrib.gis.geos.Polygon)-objekt som argument, eller en enda sekvens av [`Polygon`](#django.contrib.gis.geos.Polygon)-objekt:

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

`GeometryCollection`-objekt kan instansieras genom att skicka in andra `` GEOSGeometry` `` som argument, eller en enda sekvens av `` GEOSGeometry` ``-objekt:

```pycon
>>> 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`](#django.contrib.gis.geos.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](https://trac.osgeo.org/geos/wiki/PreparedGeometry).

Till exempel:

```pycon
>>> 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`](#django.contrib.gis.geos.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)`

**Parametrar:** `file_h` (a Python `file` object or a string path to the file) – indatafil som innehåller rumsliga data

**Returtyp:** en [`GEOSGeometry`](#django.contrib.gis.geos.GEOSGeometry) som motsvarar de rumsliga data som finns i filen

Exempel:

```pycon
>>> from django.contrib.gis.geos import fromfile
>>> g = fromfile("/home/bob/geom.wkt")
```

#### `fromstr(string, srid=None)`

**Parametrar:** - `string` ([`str`](https://docs.python.org/3/library/stdtypes.html#str)) – sträng som innehåller rumsliga data
- `srid` ([`int`](https://docs.python.org/3/library/functions.html#int)) – identifierare för rumslig referens

**Returtyp:** en [`GEOSGeometry`](#django.contrib.gis.geos.GEOSGeometry) som motsvarar de rumsliga data i strängen

`fromstr(string, srid)` är likvärdigt med [`GEOSGeometry(string, srid)`](#django.contrib.gis.geos.GEOSGeometry).

Exempel:

```pycon
>>> 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`](#django.contrib.gis.geos.GEOSGeometry)-instans från WKB- och/eller WKT-ingången som ges till deras `read(geom)`-metod.

#### `class WKBReader`

Exempel:

```pycon
>>> from django.contrib.gis.geos import WKBReader
>>> wkb_r = WKBReader()
>>> wkb_r.read("0101000000000000000000F03F000000000000F03F")
<Point object at 0x103a88910>
```

#### `class WKTReader`

Exempel:

```pycon
>>> 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`](#django.contrib.gis.geos.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)`

`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`](#django.contrib.gis.geos.WKBWriter.outdim)-dokumentationen för mer information om `dim`-argumentet.

#### `write(geom)`

Returnerar WKB för den angivna geometrin som ett Python-objekt i form av en `buffer`. Ett exempel:

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

Returnerar geometrins WKB i hexadecimal.  Ett exempel:

```pycon
>>> 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:

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

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:

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

Ange denna egenskap med ett boolean för att ange om geometrins SRID ska inkluderas i WKB-representationen.  Exempel på detta:

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

Denna klass gör det möjligt att skriva ut WKT-representationen av en geometri. Se attributen [`WKBWriter.outdim`](#django.contrib.gis.geos.WKBWriter.outdim), [`trim`](#django.contrib.gis.geos.WKTWriter.trim) och [`precision`](#django.contrib.gis.geos.WKTWriter.precision) för detaljer om konstruktörens argument.

#### `write(geom)`

Returnerar WKT för den givna geometrin. Ett exempel:

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

Se [`WKBWriter.outdim`](#django.contrib.gis.geos.WKBWriter.outdim).

#### `trim`

Denna egenskap används för att aktivera eller inaktivera trimning av onödiga decimaler.

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

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](https://postgis.net/docs/using_postgis_dbmanagement.html#EWKB_EWKT), 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`).

> **Note**
>
> 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`

Base GEOS exception, indikerar ett GEOS-relaterat fel.