# Documentation Django 5.2.8

# Référence des API QuerySet GIS

## Recherches spatiales

Les requêtes spatiales de cette section sont disponibles à la fois pour `GeometryField` et `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.

### Requêtes avec matrices

Tous les exemples dans la référence ci-dessous sont donnés pour des champs et des entrées géométriques, mais ces requêtes peuvent très bien être utilisées avec des objets matriciels des deux côtés. Chaque fois qu’une requête ne prend pas en charge les entrées matricielles, l’entrée est automatiquement convertie en objet géométrique quand c’est nécessaire en utilisant la fonction ST_Polygon. Voir aussi l’introduction aux requêtes matricielles.

Les opérateurs de base de données utilisés par les requêtes peuvent être divisés en trois catégories :

- Prise en charge matricielle native `N`: l’opérateur accepte nativement les objets matriciels des deux côtés de la requête et les entrées matricielles peuvent être mélangées avec des entrées géométriques.

- Prise en charge matricielle bilatérale `B`: l’opérateur ne prend en charge les objets matriciels seulement si les deux côtés de la requête reçoivent des entrées matricielles. Les données matricielles sont automatiquement converties en objets géométriques en cas de requêtes mixtes.

- Prise en charge par conversion géométrique `C`. La requête ne prend pas en charge nativement les objets matriciels, toutes les données matricielles sont automatiquement converties en objets géométriques.

Les exemples ci-dessous montrent le code SQL équivalent pour les requêtes dans les différents types de prise en charge matricielle. Le même schéma s’applique pour toutes les requêtes spatiales.

Cas | Requête | Équivalent SQL
--- | --- | ---
N, B | `rast__contains=rst` | `ST_Contains(rast, rst)`
N, B | `rast__1__contains=(rst, 2)` | `ST_Contains(rast, 1, rst, 2)`
B, C | `rast__contains=geom` | `ST_Contains(ST_Polygon(rast), geom)`
B, C | `rast__1__contains=geom` | `ST_Contains(ST_Polygon(rast, 1), geom)`
B, C | `poly__contains=rst` | `ST_Contains(poly, ST_Polygon(rst))`
B, C | `poly__contains=(rst, 1)` | `ST_Contains(poly, ST_Polygon(rst, 1))`
C | `rast__crosses=rst` | `ST_Crosses(ST_Polygon(rast), ST_Polygon(rst))`
C | `rast__1__crosses=(rst, 2)` | `ST_Crosses(ST_Polygon(rast, 1), ST_Polygon(rst, 2))`
C | `rast__crosses=geom` | `ST_Crosses(ST_Polygon(rast), geom)`
C | `poly__crosses=rst` | `ST_Crosses(poly, ST_Polygon(rst))`

Les requêtes spatiales avec des objets matriciels ne sont prises en charge que pour le moteur PostGIS (désigné par PGRaster dans cette section).

### `bbcontains`

Disponibilité : PostGIS, MariaDB, MySQL, SpatiaLite, PGRaster (natif)

Teste si le rectangle englobant du champ géométrique ou matriciel contient complètement le rectangle englobant de la recherche géométrique.

Exemple :

    Zipcode.objects.filter(poly__bbcontains=geom)

Moteur | Équivalent SQL
--- | ---
PostGIS | `poly ~ geom`
MariaDB | `MBRContains(poly, geom)`
MySQL | `MBRContains(poly, geom)`
SpatiaLite | `MbrContains(poly, geom)`

### `bboverlaps`

Disponibilité : PostGIS, MariaDB, MySQL, SpatiaLite, PGRaster (natif)

Teste si le rectangle englobant du champ géométrique recouvre partiellement le rectangle englobant de la recherche géométrique.

Exemple :

    Zipcode.objects.filter(poly__bboverlaps=geom)

Moteur | Équivalent SQL
--- | ---
PostGIS | `poly && geom`
MariaDB | `MBROverlaps(poly, geom)`
MySQL | `MBROverlaps(poly, geom)`
SpatiaLite | `MbrOverlaps(poly, geom)`

### `contained`

Disponibilité : PostGIS, MariaDB, MySQL, SpatiaLite, PGRaster (natif)

Teste si le rectangle englobant du champ géométrique est complètement contenu dans le rectangle englobant de la recherche géométrique.

Exemple :

    Zipcode.objects.filter(poly__contained=geom)

Moteur | Équivalent SQL
--- | ---
PostGIS | `poly @ geom`
MariaDB | `MBRWithin(poly, geom)`
MySQL | `MBRWithin(poly, geom)`
SpatiaLite | `MbrWithin(poly, geom)`

### `contains`

Disponibilité : PostGIS, Oracle, MariaDB, MySQL, SpatiaLite, PGRaster (bilatéral)

Teste si le champ géométrique contient spatialement l’objet géométrique de la recherche.

Exemple :

    Zipcode.objects.filter(poly__contains=geom)

Moteur | Équivalent SQL
--- | ---
PostGIS | `ST_Contains(poly, geom)`
Oracle | `SDO_CONTAINS(poly, geom)`
MariaDB | `ST_Contains(poly, geom)`
MySQL | `ST_Contains(poly, geom)`
SpatiaLite | `Contains(poly, geom)`

### `contains_properly`

Disponibilité : PostGIS, PGRaster (bilatéral)

Renvoie `True` si l’objet géométrique de la recherche a une intersection avec l’intérieur du champ géométrique, mais pas avec ses limites (ou extérieur).

Exemple :

    Zipcode.objects.filter(poly__contains_properly=geom)

Moteur | Équivalent SQL
--- | ---
PostGIS | `ST_ContainsProperly(poly, geom)`

### `coveredby`

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

Teste si aucun point du champ géométrique n’est en dehors de l’objet géométrique de la recherche. [3]

Exemple :

    Zipcode.objects.filter(poly__coveredby=geom)

Moteur | Équivalent SQL
--- | ---
PostGIS | `ST_CoveredBy(poly, geom)`
Oracle | `SDO_COVEREDBY(poly, geom)`
MariaDB | `MBRCoveredBy(poly, geom)`
MySQL | `MBRCoveredBy(poly, geom)`
SpatiaLite | `CoveredBy(poly, geom)`

Changed in Django 5.2:

La prise en charge de MySQL a été ajoutée.

Changed in Django 6.0:

MariaDB 12.0.1+ support was added.

### `covers`

Disponibilité: PostGIS, Oracle, MySQL, PGRaster (bilatéral), SpatiaLite

Teste si aucun point de l’objet géométrique de la recherche n’est en dehors du champ géométrique. [3]

Exemple :

    Zipcode.objects.filter(poly__covers=geom)

Moteur | Équivalent SQL
--- | ---
PostGIS | `ST_Covers(poly, geom)`
Oracle | `SDO_COVERS(poly, geom)`
MySQL | `MBRCovers(poly, geom)`
SpatiaLite | `Covers(poly, geom)`

Changed in Django 5.2:

La prise en charge de MySQL a été ajoutée.

### `crosses`

Disponibilité : PostGIS, MariaDB, MySQL, SpatiaLite, PGRaster (conversion)

Teste si le champ géométrique se croise spatialement avec l’objet géométrique de la recherche.

Exemple :

    Zipcode.objects.filter(poly__crosses=geom)

Moteur | Équivalent SQL
--- | ---
PostGIS | `ST_Crosses(poly, geom)`
MariaDB | `ST_Crosses(poly, geom)`
MySQL | `ST_Crosses(poly, geom)`
SpatiaLite | `Crosses(poly, geom)`

### `disjoint`

Disponibilité : PostGIS, Oracle, MariaDB, MySQL, SpatiaLite, PGRaster (bilatéral)

Teste si le champ géométrique est spatialement distinct de l’objet géométrique de la recherche.

Exemple :

    Zipcode.objects.filter(poly__disjoint=geom)

Moteur | Équivalent SQL
--- | ---
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)`

### `equals`

Disponibilité : PostGIS, Oracle, MariaDB, MySQL, SpatiaLite, PGRaster (conversion)

Teste si le champ géométrique est spatialement égal à l’objet géométrique de la recherche.

Exemple :

    Zipcode.objects.filter(poly__equals=geom)

Moteur | Équivalent SQL
--- | ---
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`

Disponibilité : PostGIS, Oracle, MariaDB, MySQL, SpatiaLite, PGRaster (bilatéral)

Teste si le champ géométrique est « égal » à l’objet géométrique donné. Avec Oracle, MySQL et Spatialite, le test se fait sur l’égalité spatiale, alors qu’avec PostGIS, le test compare l’égalité des boîtes englobantes.

Exemple :

    Zipcode.objects.filter(poly=geom)

Moteur | Équivalent SQL
--- | ---
PostGIS | `poly ~= geom`
Oracle | `SDO_EQUAL(poly, geom)`
MariaDB | `ST_Equals(poly, geom)`
MySQL | `ST_Equals(poly, geom)`
SpatiaLite | `Equals(poly, geom)`

### `intersects`

Disponibilité: PostGIS, Oracle, MariaDB, MySQL, SpatiaLite, PGRaster (bilatéral)

Teste si le champ géométrique possède une intersection spatiale avec l’objet géométrique de la recherche.

Exemple :

    Zipcode.objects.filter(poly__intersects=geom)

Moteur | Équivalent SQL
--- | ---
PostGIS | `ST_Intersects(poly, geom)`
Oracle | `SDO_OVERLAPBDYINTERSECT(poly, geom)`
MariaDB | `ST_Intersects(poly, geom)`
MySQL | `ST_Intersects(poly, geom)`
SpatiaLite | `Intersects(poly, geom)`

### `isempty`

Disponibilité : PostGIS

Teste si l’objet géométrique est vide.

Exemple :

    Zipcode.objects.filter(poly__isempty=True)

### `isvalid`

Availability: MariaDB, MySQL, PostGIS, Oracle, SpatiaLite

Teste si l’objet géométrique est valide.

Exemple :

    Zipcode.objects.filter(poly__isvalid=True)

Moteur | Équivalent SQL
--- | ---
MariaDB, MySQL, PostGIS, SpatiaLite | `ST_IsValid(poly)`
Oracle | `SDO_GEOM.VALIDATE_GEOMETRY_WITH_CONTEXT(poly, 0.05) = 'TRUE'`

Changed in Django 6.0:

MariaDB 12.0.1+ support was added.

### `geom_type`

New in Django 6.0.

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

Returns the geometry type of the geometry field.

Exemple :

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

Moteur | Équivalent SQL
--- | ---
PostGIS | `GeometryType(geom)`
MariaDB | `ST_GeometryType(geom)`
MySQL | `ST_GeometryType(geom)`
Oracle | `SDO_GEOMETRY.GET_GTYPE(geom)`
SpatiaLite | `GeometryType(geom)`

### `overlaps`

Disponibilité : PostGIS, Oracle, MariaDB, MySQL, SpatiaLite, PGRaster (bilatéral)

Teste si le champ géométrique chevauche l’objet géométrique de la recherche.

Moteur | Équivalent SQL
--- | ---
PostGIS | `ST_Overlaps(poly, geom)`
Oracle | `SDO_OVERLAPS(poly, geom)`
MariaDB | `ST_Overlaps(poly, geom)`
MySQL | `ST_Overlaps(poly, geom)`
SpatiaLite | `Overlaps(poly, geom)`

### `relate`

Disponibilité : PostGIS, MariaDB, Oracle, SpatiaLite, PGRaster (conversion)

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 et SpatiaLite

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]

Exemple géométrique :

    # 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*"))

Équivalent SQL PostGIS et MariaDB :

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

Équivalent SQL SpatiaLite :

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

Exemple matriciel :

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

Équivalent SQL PostGIS :

    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*')

#### Oracle

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.

Exemple :

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

Équivalent SQL Oracle :

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

### `touches`

Disponibilité : PostGIS, Oracle, MariaDB, MySQL, SpatiaLite

Teste si le champ géométrique touche spatialement l’objet géométrique de la recherche.

Exemple :

    Zipcode.objects.filter(poly__touches=geom)

Moteur | Équivalent SQL
--- | ---
PostGIS | `ST_Touches(poly, geom)`
MariaDB | `ST_Touches(poly, geom)`
MySQL | `ST_Touches(poly, geom)`
Oracle | `SDO_TOUCH(poly, geom)`
SpatiaLite | `Touches(poly, geom)`

### `within`

Disponibilité : PostGIS, Oracle, MariaDB, MySQL, SpatiaLite, PGRaster (bilatéral)

Teste si le champ géométrique est spatialement à l’intérieur de l’objet géométrique de la recherche.

Exemple :

    Zipcode.objects.filter(poly__within=geom)

Moteur | Équivalent SQL
--- | ---
PostGIS | `ST_Within(poly, geom)`
MariaDB | `ST_Within(poly, geom)`
MySQL | `ST_Within(poly, geom)`
Oracle | `SDO_INSIDE(poly, geom)`
SpatiaLite | `Within(poly, geom)`

### `left`

Disponibilité : PostGIS, PGRaster (conversion)

Teste si le rectangle englobant du champ géométrique est strictement à gauche du rectangle englobant de la recherche géométrique.

Exemple :

    Zipcode.objects.filter(poly__left=geom)

Équivalent PostGIS :

    SELECT ... WHERE poly << geom

### `right`

Disponibilité : PostGIS, PGRaster (conversion)

Teste si le rectangle englobant du champ géométrique est strictement à droite du rectangle englobant de la recherche géométrique.

Exemple :

    Zipcode.objects.filter(poly__right=geom)

Équivalent PostGIS :

    SELECT ... WHERE poly >> geom

### `overlaps_left`

Disponibilité : PostGIS, PGRaster (bilatéral)

Teste si le rectangle englobant du champ géométrique recouvre ou est à gauche du rectangle englobant de la recherche géométrique.

Exemple :

    Zipcode.objects.filter(poly__overlaps_left=geom)

Équivalent PostGIS :

    SELECT ... WHERE poly &< geom

### `overlaps_right`

Disponibilité : PostGIS, PGRaster (bilatéral)

Teste si le rectangle englobant du champ géométrique recouvre ou est à droite du rectangle englobant de la recherche géométrique.

Exemple :

    Zipcode.objects.filter(poly__overlaps_right=geom)

Équivalent PostGIS :

    SELECT ... WHERE poly &> geom

### `overlaps_above`

Disponibilité : PostGIS, PGRaster (conversion)

Teste si le rectangle englobant du champ géométrique recouvre ou est au-dessus du rectangle englobant de la recherche géométrique.

Exemple :

    Zipcode.objects.filter(poly__overlaps_above=geom)

Équivalent PostGIS :

    SELECT ... WHERE poly |&> geom

### `overlaps_below`

Disponibilité : PostGIS, PGRaster (conversion)

Teste si le rectangle englobant du champ géométrique recouvre ou est au-dessous du rectangle englobant de la recherche géométrique.

Exemple :

    Zipcode.objects.filter(poly__overlaps_below=geom)

Équivalent PostGIS :

    SELECT ... WHERE poly &<| geom

### `strictly_above`

Disponibilité : PostGIS, PGRaster (conversion)

Teste si le rectangle englobant du champ géométrique est strictement au-dessus du rectangle englobant de la recherche géométrique.

Exemple :

    Zipcode.objects.filter(poly__strictly_above=geom)

Équivalent PostGIS :

    SELECT ... WHERE poly |>> geom

### `strictly_below`

Disponibilité : PostGIS, PGRaster (conversion)

Teste si le rectangle englobant du champ géométrique est strictement au-dessous du rectangle englobant de la recherche géométrique.

Exemple :

    Zipcode.objects.filter(poly__strictly_below=geom)

Équivalent PostGIS :

    SELECT ... WHERE poly <<| geom

## Recherches de distance

Disponibilité : PostGIS, Oracle, MariaDB, MySQL, SpatiaLite, PGRaster (natif)

Pour un aperçu sur la construction de requêtes de distance, référez-vous à l’introduction sur les requêtes de distance.

Les requêtes de distance se font sous la forme suivante :

    <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"])

La valeur transmise à une requête de distance est un tuple ; les deux premières valeurs sont obligatoires et représentent respectivement l’objet géométrique vers lequel la distance doit être calculée et la valeur de distance (soit un nombre dans l’unité du champ, un objet `Distance` ou une expression de requête). Pour transmettre un indice de bande à la requête, utilisez un tuple à 3 éléments où le deuxième est l’indice de bande.

Pour toutes les recherches de distance à l’exception de `dwithin`, une valeur facultative, `'spheroid'`, peut être ajoutée pour utiliser les fonctions de calcul de distance sphéroïde pour les champs ayant un système de coordonnées géodétique.

Avec PostgreSQL, l’option `'spheroid'` utilise ST_DistanceSpheroid au lieu de ST_DistanceSphere. La fonction plus simple ST_Distance est utilisée avec les systèmes de coordonnées projetées. Les matrices sont converties en géométries pour les requêtes basées sur la sphéroïde.

### `distance_gt`

Renvoie les objets pour lesquels la distance entre le champ géométrique et l’objet géométrique de recherche est plus grande que la valeur de distance donnée.

Exemple :

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

Moteur | Équivalent SQL
--- | ---
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 | `Distance(poly, geom) > 5`

### `distance_gte`

Renvoie les objets pour lesquels la distance entre le champ géométrique et l’objet géométrique de recherche est plus grande ou égale à la valeur de distance donnée.

Exemple :

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

Moteur | Équivalent SQL
--- | ---
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 | `Distance(poly, geom) >= 5`

### `distance_lt`

Renvoie les objets pour lesquels la distance entre le champ géométrique et l’objet géométrique de recherche est plus petite que la valeur de distance donnée.

Exemple :

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

Moteur | Équivalent SQL
--- | ---
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 | `Distance(poly, geom) < 5`

### `distance_lte`

Renvoie les objets pour lesquels la distance entre le champ géométrique et l’objet géométrique de recherche est plus petite ou égale à la valeur de distance donnée.

Exemple :

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

Moteur | Équivalent SQL
--- | ---
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 | `Distance(poly, geom) <= 5`

### `dwithin`

Renvoie les objets pour lesquels la distance entre le champ géométrique et l’objet géométrique de recherche ne dépasse pas la valeur de distance donnée. Notez que vous ne pouvez fournir des objets `Distance` que si les objets géométriques concernés sont dans un système de coordonnées projeté. Pour des objets géométriques de type géographique, il faut utiliser l’unité du champ géométrique (par exemple des degrés pour `WGS84`).

Exemple :

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

Moteur | Équivalent SQL
--- | ---
PostGIS | `ST_DWithin(poly, geom, 5)`
Oracle | `SDO_WITHIN_DISTANCE(poly, geom, 5)`
SpatiaLite | `PtDistWithin(poly, geom, 5)`

### Fonctions d’agrégation

Django fournit quelques fonctions d’agrégation spécifiques aux données géographiques. Pour plus de détails sur l’usage de ces fonctions, consultez le guide thématique sur l’agrégation.

Paramètre nommé | Description
--- | ---
`tolerance` | This keyword is for Oracle only. It is for the tolerance value used by the `SDOAGGRTYPE` procedure; the Oracle documentation has more details.

Exemple :

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

#### `Collect`

class Collect(geo_field, filter=None)

Availability: PostGIS, MariaDB, MySQL, SpatiaLite

Renvoie un objet géométrique `GEOMETRYCOLLECTION` ou `MULTI` à partir de la colonne géométrique. C’est un peu comme une version simplifiée de l’agrégation `Union`, sauf qu’elle peut être vraiment plus rapide qu’une union car elle accumule les objets géométriques dans une collection ou une géométrie multiple sans se préoccuper de fusionner les objets.

Changed in Django 6.0:

MariaDB 12.0.1+ support was added.

#### `Extent`

class Extent(geo_field, filter=None)

Disponibilité : PostGIS, Oracle, SpatiaLite

Renvoie l’étendue de tous les champs `geo_field` du `QuerySet` sous forme de tuple à 4 éléments formé des coordonnées inférieure gauche et supérieure droite.

Exemple :

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

#### `Extent3D`

class Extent3D(geo_field, filter=None)

Disponibilité : PostGIS

Renvoie l’étendue 3D de tous les champs `geo_field` du `QuerySet` sous forme de tuple à 6 éléments formé des coordonnées inférieure gauche et supérieure droite (chaque fois avec les coordonnées x, y et z).

Exemple :

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

class MakeLine(geo_field, filter=None)

Disponibilité : PostGIS, SpatiaLite

Renvoie une ligne `LineString` construite à partir des champs de type point du `QuerySet`. Actuellement, le tri du jeu de requête n’a pas d’effet.

Exemple :

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

class Union(geo_field, filter=None)

Disponibilité : PostGIS, Oracle, SpatiaLite

Cette méthode renvoie un objet `GEOSGeometry` formé de l’union de tous les objets géométriques du jeu de requête. Sachez que l’emploi de `Union` est très consommateur de ressources et peut prendre un temps considérable pour de gros jeux de requête.

Note

Si le temps de calcul lors de l’utilisation de cette méthode est trop important, envisagez d’utiliser plutôt `Collect`.

Exemple :

    >>> 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.

Notes de bas de page

[1]

Voir `OpenGIS Simple Feature Specification For SQL `_, chap. 2.1.13.2, p. 2-13 (The Dimensionally Extended Nine-Intersection Model).

[2]

Voir la documentation de SDO_RELATE dans le guide de développement spatial et graphique d’Oracle.

[3] (1,2)

Pour une explication de cette routine, lisez Quirks of the « Contains » Spatial Predicate par Martin Davis (un développeur PostGIS).