GIS QuerySet API-referensLink to this heading

Rumsliga uppslagningarLink to this heading

De rumsliga uppslagningarna i detta avsnitt är tillgängliga för GeometryField och RasterField.

For an introduction, see the spatial lookups introduction. For an overview of what lookups are compatible with a particular spatial backend, refer to the spatial lookup compatibility table.

Uppslagningar med rasterLink to this heading

Alla exempel i referensen nedan ges för geometriska fält och inmatningar, men uppslagningarna kan användas på samma sätt med raster på båda sidor. När en lookup inte stöder rasterinmatning konverteras inmatningen automatiskt till en geometri där så behövs med hjälp av funktionen ST_Polygon. Se även introduktion till rasteruppslagningar.

De databasoperatörer som används vid uppslagningarna kan delas in i tre kategorier:

Native raster support N: operatören accepterar raster på båda sidor av lookupen och rasterdata kan blandas med geometridata.
Bilateralt rasterstöd B: operatören stöder raster endast om båda sidor av uppslagningen får rasterdata. Rasterdata konverteras automatiskt till geometrier för blandade uppslagningar.
Stöd för geometriomvandling C. Lookupen har inget inbyggt stöd för raster, alla rasterdata konverteras automatiskt till geometrier.

Exemplen nedan visar SQL-motsvarigheten för uppslagningarna i de olika typerna av rasterstöd. Samma mönster gäller för alla spatiala uppslagningar.

Case	Uppslag	SQL-ekvivalent
N, B	`rast__innehåller=rst`	`ST_Contains(rast, rst)`
N, B	`rast__1__contains=(rst, 2)`	`ST_Contains(rast, 1, rst, 2)`
B, C	`rast__innehåller=geom`	`ST_Contains(ST_Polygon(rast), geom)`
B, C	`rast__1__innehåller=geom`	`ST_Contains(ST_Polygon(rast, 1), geom)`
B, C	`poly__innehåller=rst`	`ST_Contains(poly, ST_Polygon(rst))`
B, C	`poly__contains=(rst, 1)`	`ST_Contains(poly, ST_Polygon(rst, 1))`
C	`rast__korsningar=rst`	`ST_Crosses(ST_Polygon(rast), ST_Polygon(rst))`
C	`rast__1__korsningar=(rst, 2)`	`ST_Crosses(ST_Polygon(rast, 1), ST_Polygon(rst, 2))`
C	`rast__korsningar=geom`	`ST_Crosses(ST_Polygon(rast), geom)`
C	`poly__kors=rst`	`ST_Crosses(poly, ST_Polygon(rst))`

Rumsliga uppslagningar med raster stöds endast för PostGIS-backends (benämns som PGRaster i detta avsnitt).

`bbcontains`Link to this heading

Tillgänglighet: PostGIS, MariaDB, MySQL, SpatiaLite, PGRaster (inbyggd)

Testar om geometrins eller rasterfältets begränsningsbox helt och hållet innehåller uppslagsgeometrins begränsningsbox.

Exempel:

Code

Zipcode.objects.filter(poly__bbcontains=geom)

Backend	SQL-ekvivalent
PostGIS	`poly ~ geom`
MariaDB	`MBRContains(poly, geom)`
MySQL	`MBRContains(poly, geom)`
SpatiaLite	`MbrInnehåller(poly, geom)`

`bboverlaps`Link to this heading

Tillgänglighet: PostGIS, MariaDB, MySQL, SpatiaLite, PGRaster (inbyggd)

Testar om geometrifältets avgränsningsbox överlappar uppslagsgeometrins avgränsningsbox.

Exempel:

Code

Zipcode.objects.filter(poly__bboverlaps=geom)

Backend	SQL-ekvivalent
PostGIS	`poly && geom`
MariaDB	`MBROverlaps(poly, geom)`
MySQL	`MBROverlaps(poly, geom)`
SpatiaLite	`MbrOverlaps(poly, geom)`

`innehållen`Link to this heading

Tillgänglighet: PostGIS, MariaDB, MySQL, SpatiaLite, PGRaster (inbyggd)

Testar om geometrifältets avgränsningsbox är helt innesluten i uppslagsgeometrins avgränsningsbox.

Exempel:

Code

Zipcode.objects.filter(poly__contained=geom)

Backend	SQL-ekvivalent
PostGIS	`poly @ geom`
MariaDB	`MBRInom(poly, geom)`
MySQL	`MBRInom(poly, geom)`
SpatiaLite	`MbrInom(poly, geom)`

`innehåller`Link to this heading

Tillgänglighet: PostGIS, Oracle, MariaDB, MySQL, SpatiaLite, PGRaster (Bilateral)

Testar om geometrifältet rumsligt innehåller uppslagsgeometrin.

Exempel:

Code

Zipcode.objects.filter(poly__contains=geom)

Backend	SQL-ekvivalent
PostGIS	`ST_Contains(poly, geom)`
Oracle	`SDO_CONTAINS(poly, geom)`
MariaDB	`ST_Contains(poly, geom)`
MySQL	`ST_Contains(poly, geom)`
SpatiaLite	`Innehåller(poly, geom)`

`innehåller_riktigt`Link to this heading

Tillgänglighet: PostGIS, PGRaster (Bilateral)

Returnerar true om uppslagsgeometrin skär geometrins insida, men inte dess gräns (eller utsida).

Exempel:

Code

Zipcode.objects.filter(poly__contains_properly=geom)

Backend	SQL-ekvivalent
PostGIS	`ST_ContainsProperly(poly, geom)`

”täckt avLink to this heading

Availability: PostGIS, Oracle, MariaDB, MySQL, PGRaster (Bilateral), SpatiaLite

Testar om ingen punkt i geometrifältet ligger utanför lookup-geometrin. [3] _

Exempel:

Code

Zipcode.objects.filter(poly__coveredby=geom)

Backend	SQL-ekvivalent
PostGIS	`ST_CoveredBy(poly, geom)`
Oracle	`SDO_COVEREDBY(poly, geom)`
MariaDB	`MBRCoveredBy(poly, geom)`
MySQL	`MBRCoveredBy(poly, geom)`
SpatiaLite	`CoveredBy(poly, geom)`

`överdrag`Link to this heading

Tillgänglighet: PostGIS, Oracle, MySQL, PGRaster (Bilateral), SpatiaLite

Testar om ingen punkt i uppslagsgeometrin ligger utanför geometrifältet. [3] _

Exempel:

Code

Zipcode.objects.filter(poly__covers=geom)

Backend	SQL-ekvivalent
PostGIS	`ST_Covers(poly, geom)`
Oracle	`SDO_COVERS(poly, geom)`
MySQL	`MBRCovers(poly, geom)`
SpatiaLite	`Täckningar(poly, geom)`

`korsningar`Link to this heading

Tillgänglighet: postGIS <https://postgis.net/docs/ST_Crosses.html>`__, MariaDB, MySQL, SpatiaLite, PGRaster (konvertering)

Testar om geometrifältet rumsligt korsar lookup-geometrin.

Exempel:

Code

Zipcode.objects.filter(poly__crosses=geom)

Backend	SQL-ekvivalent
PostGIS	`ST_Crosses(poly, geom)`
MariaDB	`ST_Crosses(poly, geom)`
MySQL	`ST_Crosses(poly, geom)`
SpatiaLite	`Korsningar(poly, geom)`

`disjunkt`Link to this heading

Tillgänglighet: PostGIS, Oracle, MariaDB, MySQL, SpatiaLite, PGRaster (Bilateral)

Testar om geometrifältet är rumsligt åtskilt från uppslagsgeometrin.

Exempel:

Code

Zipcode.objects.filter(poly__disjoint=geom)

Backend	SQL-ekvivalent
PostGIS	`ST_Disjoint(poly, geom)`
Oracle	`SDO_GEOM.RELATE(poly, 'DISJOINT', geom, 0,05)`
MariaDB	`ST_Disjoint(poly, geom)`
MySQL	`ST_Disjoint(poly, geom)`
SpatiaLite	`Disjoint(poly, geom)`

`likvärdiga`Link to this heading

Tillgänglighet: PostGIS, Oracle, MariaDB, MySQL, SpatiaLite, PGRaster (Konvertering)

Testar om geometrifältet är rumsligt lika med uppslagsgeometrin.

Exempel:

Code

Zipcode.objects.filter(poly__equals=geom)

Backend	SQL-ekvivalent
PostGIS	`ST_Equals(poly, geom)`
Oracle	`SDO_EQUAL(poly, geom)`
MariaDB	`ST_Equals(poly, geom)`
MySQL	`ST_Equals(poly, geom)`
SpatiaLite	`Equals(poly, geom)`

`exact`, `same_as`Link to this heading

Tillgänglighet: PostGIS, Oracle, MariaDB, MySQL, SpatiaLite, PGRaster (Bilateral)

Testar om geometrifältet är ”lika” med uppslagsgeometrin. På Oracle, MySQL och SpatiaLite testar det rumslig likhet, medan det på PostGIS testar likhet mellan begränsningsrutor.

Exempel:

Code

Zipcode.objects.filter(poly=geom)

Backend	SQL-ekvivalent
PostGIS	`poly ~= geom`
Oracle	`SDO_EQUAL(poly, geom)`
MariaDB	`ST_Equals(poly, geom)`
MySQL	`ST_Equals(poly, geom)`
SpatiaLite	`Equals(poly, geom)`

`skärningspunkter`Link to this heading

Tillgänglighet: PostGIS, Oracle, MariaDB, MySQL, SpatiaLite, PGRaster (Bilateral)

Testar om geometrifältet rumsligt korsar uppslagsgeometrin.

Exempel:

Code

Zipcode.objects.filter(poly__intersects=geom)

Backend	SQL-ekvivalent
PostGIS	`ST_Intersects(poly, geom)`
Oracle	`SDO_OVERLAPBDYINTERSECT(poly, geom)`
MariaDB	`ST_Intersects(poly, geom)`
MySQL	`ST_Intersects(poly, geom)`
SpatiaLite	`Intersekter(poly, geom)`

`isempty`Link to this heading

Tillgänglighet: PostGIS

Testar om geometrin är tom.

Exempel:

Code

Zipcode.objects.filter(poly__isempty=True)

`isvalid`Link to this heading

Availability: MariaDB, MySQL, PostGIS, Oracle, SpatiaLite

Testar om geometrin är giltig.

Exempel:

Code

Zipcode.objects.filter(poly__isvalid=True)

Backend	SQL-ekvivalent
MariaDB, MySQL, PostGIS, SpatiaLite	`ST_IsValid(poly)`
Oracle	`SDO_GEOM.VALIDATE_GEOMETRY_WITH_CONTEXT(poly, 0.05) = 'TRUE'`

`geom_typ`Link to this heading

Availability: PostGIS, Oracle 23c+, MariaDB, MySQL, SpatiaLite

Returns the geometry type of the geometry field.

Exempel:

Code

Zipcode.objects.filter(poly__geom_type="POLYGON")

Backend	SQL-ekvivalent
PostGIS	`GeometryType(geom)`
MariaDB	`ST_GeometryType(geom)`
MySQL	`ST_GeometryType(geom)`
Oracle	`SDO_GEOMETRY.GET_GTYPE(geom)`
SpatiaLite	`GeometryType(geom)`

`överlappar`Link to this heading

Tillgänglighet: PostGIS, Oracle, MariaDB, MySQL, SpatiaLite, PGRaster (Bilateral)

Testar om geometrifältet spatialt överlappar lookup-geometrin.

Backend	SQL-ekvivalent
PostGIS	`ST_Overlaps(poly, geom)`
Oracle	`SDO_OVERLAPS(poly, geom)`
MariaDB	`ST_Overlaps(poly, geom)`
MySQL	`ST_Overlaps(poly, geom)`
SpatiaLite	`Överlappningar(poly, geom)`

`förhållande`Link to this heading

Tillgänglighet: PostGIS, MariaDB, Oracle, SpatiaLite, PGRaster (Konvertering)

Tests if the geometry field is spatially related to the lookup geometry by the values given in the given pattern. This lookup requires a tuple parameter, (geom, pattern); the form of pattern will depend on the spatial backend:

MariaDB, PostGIS och SpatiaLiteLink to this heading

On these spatial backends the intersection pattern is a string comprising nine characters, which define intersections between the interior, boundary, and exterior of the geometry field and the lookup geometry. The intersection pattern matrix may only use the following characters: 1, 2, T, F, or *. This lookup type allows users to ”fine tune” a specific geometric relationship consistent with the DE-9IM model. [1]

Geometri exempel:

Code

# A tuple lookup parameter is used to specify the geometry and
# the intersection pattern (the pattern here is for 'contains').
Zipcode.objects.filter(poly__relate=(geom, "T*T***FF*"))

PostGIS och MariaDB SQL motsvarande:

SQL

SELECT ... WHERE ST_Relate(poly, geom, 'T*T***FF*')

SpatiaLite SQL-ekvivalent:

SQL

SELECT ... WHERE Relate(poly, geom, 'T*T***FF*')

Rasterexempel:

Code

Zipcode.objects.filter(poly__relate=(rast, 1, "T*T***FF*"))
Zipcode.objects.filter(rast__2__relate=(rast, 1, "T*T***FF*"))

PostGIS SQL-ekvivalent:

SQL

SELECT ... WHERE ST_Relate(poly, ST_Polygon(rast, 1), 'T*T***FF*')
SELECT ... WHERE ST_Relate(ST_Polygon(rast, 2), ST_Polygon(rast, 1), 'T*T***FF*')

OracleLink to this heading

Here the relation pattern is comprised of at least one of the nine relation strings: TOUCH, OVERLAPBDYDISJOINT, OVERLAPBDYINTERSECT, EQUAL, INSIDE, COVEREDBY, CONTAINS, COVERS, ON, and ANYINTERACT. Multiple strings may be combined with the logical Boolean operator OR, for example, 'inside+touch'. [2] The relation strings are case-insensitive.

Exempel:

Code

Zipcode.objects.filter(poly__relate=(geom, "anyinteract"))

Oracle SQL motsvarande:

SQL

SELECT ... WHERE SDO_RELATE(poly, geom, 'anyinteract')

`touches`Link to this heading

Tillgänglighet: PostGIS, Oracle, MariaDB, MySQL, SpatiaLite

Testar om geometrifältet rumsligt berör uppslagsgeometrin.

Exempel:

Code

Zipcode.objects.filter(poly__touches=geom)

Backend	SQL-ekvivalent
PostGIS	`ST_Touches(poly, geom)`
MariaDB	`ST_Touches(poly, geom)`
MySQL	`ST_Touches(poly, geom)`
Oracle	`SDO_TOUCH(poly, geom)`
SpatiaLite	`Touches(poly, geom)`

`inom`Link to this heading

Tillgänglighet: PostGIS, Oracle, MariaDB, MySQL, SpatiaLite, PGRaster (Bilateral)

Testar om geometrifältet är rumsligt inom lookup-geometrin.

Exempel:

Code

Zipcode.objects.filter(poly__within=geom)

Backend	SQL-ekvivalent
PostGIS	`ST_Within(poly, geom)`
MariaDB	`ST_Within(poly, geom)`
MySQL	`ST_Within(poly, geom)`
Oracle	`SDO_INSIDE(poly, geom)`
SpatiaLite	`Inom(poly, geom)`

`vänster`Link to this heading

Tillgänglighet: PostGIS, PGRaster (Konvertering)

Testar om geometrifältets avgränsningsbox ligger strikt till vänster om uppslagsgeometrins avgränsningsbox.

Exempel:

Code

Zipcode.objects.filter(poly__left=geom)

PostGIS-ekvivalent:

SQL

SELECT ... WHERE poly << geom

`höger`Link to this heading

Tillgänglighet: PostGIS, PGRaster (Konvertering)

Testar om geometrifältets avgränsningsbox ligger strikt till höger om uppslagsgeometrins avgränsningsbox.

Exempel:

Code

Zipcode.objects.filter(poly__right=geom)

PostGIS-ekvivalent:

SQL

SELECT ... WHERE poly >> geom

`överlappar_vänster`Link to this heading

Tillgänglighet: PostGIS, PGRaster (Bilateral)

Testar om geometrifältets avgränsningsbox överlappar eller är till vänster om uppslagsgeometrins avgränsningsbox.

Exempel:

Code

Zipcode.objects.filter(poly__overlaps_left=geom)

PostGIS-ekvivalent:

SQL

SELECT ... WHERE poly &< geom

`överlappar_höger`Link to this heading

Tillgänglighet: PostGIS, PGRaster (Bilateral)

Testar om geometrifältets avgränsningsbox överlappar eller är till höger om uppslagsgeometrins avgränsningsbox.

Exempel:

Code

Zipcode.objects.filter(poly__overlaps_right=geom)

PostGIS-ekvivalent:

SQL

SELECT ... WHERE poly &> geom

`överlappningar_över`Link to this heading

Tillgänglighet: PostGIS, PGRaster (Konvertering)

Testar om geometrifältets avgränsningsbox överlappar eller ligger ovanför uppslagsgeometrins avgränsningsbox.

Exempel:

Code

Zipcode.objects.filter(poly__overlaps_above=geom)

PostGIS-ekvivalent:

SQL

SELECT ... WHERE poly |&> geom

`överlappningar_under`Link to this heading

Tillgänglighet: PostGIS, PGRaster (Konvertering)

Testar om geometrifältets avgränsningsbox överlappar eller ligger under uppslagsgeometrins avgränsningsbox.

Exempel:

Code

Zipcode.objects.filter(poly__overlaps_below=geom)

PostGIS-ekvivalent:

SQL

SELECT ... WHERE poly &<| geom

”strikt ovanLink to this heading

Tillgänglighet: PostGIS, PGRaster (Konvertering)

Testar om geometrifältets begränsningsbox är strikt ovanför uppslagsgeometrins begränsningsbox.

Exempel:

Code

Zipcode.objects.filter(poly__strictly_above=geom)

PostGIS-ekvivalent:

SQL

SELECT ... WHERE poly |>> geom

`strikt_under`Link to this heading

Tillgänglighet: PostGIS, PGRaster (Konvertering)

Testar om geometrifältets avgränsningsbox är strikt under uppslagsgeometrins avgränsningsbox.

Exempel:

Code

Zipcode.objects.filter(poly__strictly_below=geom)

PostGIS-ekvivalent:

SQL

SELECT ... WHERE poly <<| geom

Uppslagning av avståndLink to this heading

Tillgänglighet: PostGIS, Oracle, MariaDB, MySQL, SpatiaLite, PGRaster (inbyggd)

För en översikt över hur du utför avståndsfrågor, se introduktion till avståndsfrågor.

Distansuppslagningar har följande form:

Text

<field>__<distance lookup>=(<geometry/raster>, <distance value>[, "spheroid"])
<field>__<distance lookup>=(<raster>, <band_index>, <distance value>[, "spheroid"])
<field>__<band_index>__<distance lookup>=(<raster>, <band_index>, <distance value>[, "spheroid"])

Värdet som skickas till en avståndsuppslagning är en tupel; de två första värdena är obligatoriska och är geometrin att beräkna avstånd till och ett avståndsvärde (antingen ett tal i fältets enheter, ett Distance-objekt eller ett query expression). Om du vill skicka ett bandindex till uppslagningen använder du en 3-tupel där den andra posten är bandindexet.

För varje avståndsuppslagning utom dwithin kan ett valfritt element, 'spheroid', inkluderas för att använda de mer exakta funktionerna för beräkning av sfäroidavstånd på fält med ett geodetiskt koordinatsystem.

På PostgreSQL använder alternativet 'spheroid' ST_DistanceSpheroid istället för ST_DistanceSphere. Den enklare funktionen ST_Distance används med projicerade koordinatsystem. Rasters konverteras till geometrier för sfäroidbaserade uppslagningar.

`avstånd_gt`Link to this heading

Returnerar modeller där avståndet till geometrifältet från uppslagsgeometrin är större än det angivna avståndsvärdet.

Exempel:

Code

Zipcode.objects.filter(poly__distance_gt=(geom, D(m=5)))

Backend	SQL-ekvivalent
PostGIS	`ST_Distance/ST_Distance_Sphere(poly, geom) > 5`
MariaDB	`ST_Distance(poly, geom) > 5`
MySQL	`ST_Distance(poly, geom) > 5`
Oracle	`SDO_GEOM.SDO_DISTANCE(poly, geom, 0.05) > 5`
SpatiaLite	`Distans(poly, geom) > 5`

`avstånd_gte`Link to this heading

Returnerar modeller där avståndet till geometrifältet från uppslagsgeometrin är större än eller lika med det angivna avståndsvärdet.

Exempel:

Code

Zipcode.objects.filter(poly__distance_gte=(geom, D(m=5)))

Backend	SQL-ekvivalent
PostGIS	`ST_Distance/ST_Distance_Sphere(poly, geom) >= 5`
MariaDB	`ST_Distance(poly, geom) >= 5`
MySQL	`ST_Distance(poly, geom) >= 5`
Oracle	`SDO_GEOM.SDO_DISTANCE(poly, geom, 0.05) >= 5`
SpatiaLite	`Distans(poly, geom) >= 5`

`avstånd_lt`Link to this heading

Returnerar modeller där avståndet till geometrifältet från uppslagsgeometrin är mindre än det angivna avståndsvärdet.

Exempel:

Code

Zipcode.objects.filter(poly__distance_lt=(geom, D(m=5)))

Backend	SQL-ekvivalent
PostGIS	`ST_Distance/ST_Distance_Sphere(poly, geom) < 5`
MariaDB	`ST_Distance(poly, geom) < 5`
MySQL	`ST_Distance(poly, geom) < 5`
Oracle	`SDO_GEOM.SDO_DISTANCE(poly, geom, 0.05) < 5`
SpatiaLite	`Distans(poly, geom) < 5`

`avstånd_lte`Link to this heading

Returnerar modeller där avståndet till geometrifältet från uppslagsgeometrin är mindre än eller lika med det angivna avståndsvärdet.

Exempel:

Code

Zipcode.objects.filter(poly__distance_lte=(geom, D(m=5)))

Backend	SQL-ekvivalent
PostGIS	`ST_Distance/ST_Distance_Sphere(poly, geom) <= 5`
MariaDB	`ST_Distance(poly, geom) <= 5`
MySQL	`ST_Distance(poly, geom) <= 5`
Oracle	`SDO_GEOM.SDO_DISTANCE(poly, geom, 0.05) <= 5`
SpatiaLite	`Distans(poly, geom) <= 5`

`inom`Link to this heading

Returnerar modeller där avståndet till geometrifältet från uppslagsgeometrin ligger inom det angivna avståndet från varandra. Observera att du endast kan tillhandahålla Distance-objekt om de riktade geometrierna är i ett projicerat system. För geografiska geometrier bör du använda enheter i geometrifältet (t.ex. grader för WGS84) .

Exempel:

Code

Zipcode.objects.filter(poly__dwithin=(geom, D(m=5)))

Backend	SQL-ekvivalent
PostGIS	`ST_DWithin(poly, geom, 5)`
Oracle	`SDO_WITHIN_DISTANCE(poly, geom, 5)`
SpatiaLite	`PtDistWithin(poly, geom, 5)`

Aggregerade funktionerLink to this heading

Django tillhandahåller några GIS-specifika aggregeringsfunktioner. För detaljer om hur du använder dessa aggregeringsfunktioner, se ämnesguiden om aggregering.

Sökord Argument	Beskrivning
”Tolerans	This keyword is for Oracle only. It is for the tolerance value used by the `SDOAGGRTYPE` procedure; the Oracle documentation has more details.

Exempel:

Python console

>>> from django.contrib.gis.db.models import Extent, Union
>>> WorldBorder.objects.aggregate(Extent("mpoly"), Union("mpoly"))

`Samla in`Link to this heading

class Collect(geo_field, filter=None)Link to this definition

Availability: PostGIS, MariaDB, MySQL, SpatiaLite

Returnerar en GEOMETRYCOLLECTION eller ett MULTI geometriobjekt från geometrikolumnen. Detta är analogt med en förenklad version av aggregatet Union, förutom att det kan vara flera storleksordningar snabbare än att utföra en union eftersom det rullar upp geometrier till en samling eller ett multiobjekt, utan att bry sig om att lösa upp gränser.

`Extent`Link to this heading

class Extent(geo_field, filter=None)Link to this definition

Tillgänglighet: PostGIS, Oracle, SpatiaLite

Returnerar omfattningen av alla geo_field i QuerySet som en 4-tupel, bestående av den nedre vänstra koordinaten och den övre högra koordinaten.

Exempel:

Python console

>>> qs = City.objects.filter(name__in=("Houston", "Dallas")).aggregate(Extent("poly"))
>>> print(qs["poly__extent"])
(-96.8016128540039, 29.7633724212646, -95.3631439208984, 32.782058715820)

`Extent3D`Link to this heading

class Extent3D(geo_field, filter=None)Link to this definition

Tillgänglighet: PostGIS

Returnerar 3D-utbredningen av alla geo_field i QuerySet som en 6-tupel, bestående av den nedre vänstra koordinaten och den övre högra koordinaten (var och en med x-, y- och z-koordinater).

Exempel:

Python console

>>> qs = City.objects.filter(name__in=("Houston", "Dallas")).aggregate(Extent3D("poly"))
>>> print(qs["poly__extent3d"])
(-96.8016128540039, 29.7633724212646, 0, -95.3631439208984, 32.782058715820, 0)

`MakeLine`Link to this heading

class MakeLine(geo_field, filter=None)Link to this definition

Tillgänglighet: PostGIS, SpatiaLite

Returnerar en LineString som konstruerats från punktfältsgeometrierna i QuerySet. För närvarande har det ingen effekt att beställa frågeuppsättningen.

Exempel:

Python console

>>> qs = City.objects.filter(name__in=("Houston", "Dallas")).aggregate(MakeLine("poly"))
>>> print(qs["poly__makeline"])
LINESTRING (-95.3631510000000020 29.7633739999999989, -96.8016109999999941 32.7820570000000018)

`Union`Link to this heading

class Union(geo_field, filter=None)Link to this definition

Tillgänglighet: PostGIS, Oracle, SpatiaLite

Denna metod returnerar ett GEOSGeometry-objekt som består av en sammanslagning av alla geometrier i frågeuppsättningen. Observera att användningen av Union är processorkrävande och kan ta lång tid på stora frågeuppsättningar.

Exempel:

Python console

>>> u = Zipcode.objects.aggregate(Union(poly))  # This may take a long time.
>>> u = Zipcode.objects.filter(poly__within=bbox).aggregate(
...     Union(poly)
... )  # A more sensible approach.

Fotnoter

GIS QuerySet API-referensLink to this heading#

Rumsliga uppslagningarLink to this heading#

Uppslagningar med rasterLink to this heading#

bbcontainsLink to this heading#

bboverlapsLink to this heading#

innehållenLink to this heading#

innehållerLink to this heading#

innehåller_riktigtLink to this heading#

”täckt avLink to this heading#

överdragLink to this heading#

korsningarLink to this heading#

disjunktLink to this heading#

likvärdigaLink to this heading#

exact, same_asLink to this heading#

skärningspunkterLink to this heading#

isemptyLink to this heading#

isvalidLink to this heading#

geom_typLink to this heading#

överlapparLink to this heading#

förhållandeLink to this heading#

MariaDB, PostGIS och SpatiaLiteLink to this heading#

OracleLink to this heading#

touchesLink to this heading#

inomLink to this heading#

vänsterLink to this heading#

högerLink to this heading#

överlappar_vänsterLink to this heading#

överlappar_högerLink to this heading#

överlappningar_överLink to this heading#

överlappningar_underLink to this heading#

”strikt ovanLink to this heading#

strikt_underLink to this heading#

Uppslagning av avståndLink to this heading#

avstånd_gtLink to this heading#

avstånd_gteLink to this heading#

avstånd_ltLink to this heading#

avstånd_lteLink to this heading#

inomLink to this heading#

Aggregerade funktionerLink to this heading#

Samla inLink to this heading#

ExtentLink to this heading#

Extent3DLink to this heading#

MakeLineLink to this heading#

UnionLink to this heading#

GIS QuerySet API-referensLink to this heading

Rumsliga uppslagningarLink to this heading

Uppslagningar med rasterLink to this heading

`bbcontains`Link to this heading

`bboverlaps`Link to this heading

`innehållen`Link to this heading

`innehåller`Link to this heading

`innehåller_riktigt`Link to this heading

”täckt avLink to this heading

`överdrag`Link to this heading

`korsningar`Link to this heading

`disjunkt`Link to this heading

`likvärdiga`Link to this heading

`exact`, `same_as`Link to this heading

`skärningspunkter`Link to this heading

`isempty`Link to this heading

`isvalid`Link to this heading

`geom_typ`Link to this heading

`överlappar`Link to this heading

`förhållande`Link to this heading

MariaDB, PostGIS och SpatiaLiteLink to this heading

OracleLink to this heading

`touches`Link to this heading

`inom`Link to this heading

`vänster`Link to this heading

`höger`Link to this heading

`överlappar_vänster`Link to this heading

`överlappar_höger`Link to this heading

`överlappningar_över`Link to this heading

`överlappningar_under`Link to this heading

”strikt ovanLink to this heading

`strikt_under`Link to this heading

Uppslagning av avståndLink to this heading

`avstånd_gt`Link to this heading

`avstånd_gte`Link to this heading

`avstånd_lt`Link to this heading

`avstånd_lte`Link to this heading

`inom`Link to this heading

Aggregerade funktionerLink to this heading

`Samla in`Link to this heading

`Extent`Link to this heading

`Extent3D`Link to this heading

`MakeLine`Link to this heading

`Union`Link to this heading