---
title: "Référence des API GeoQuerySet"
version: 1.9
locale: fr
source: https://docs.djangoproject.com/fr/1.9/ref/contrib/gis/geoquerysets/
canonical: https://djangodocs.dev/fr/1.9/ref/contrib/gis/geoquerysets/
---
# Référence des API GeoQuerySet

#### `class GeoQuerySet(model=None)`

## Recherches spatiales

The spatial lookups in this section are available for [`GeometryField`](/fr/1.9/ref/contrib/gis/model-api/#django.contrib.gis.db.models.GeometryField).

Pour une vue générale, consultez l”[introduction sur les recherches spatiales](/fr/1.9/ref/contrib/gis/db-api/#spatial-lookups-intro). Pour un aperçu sur la compatibilité des diverses requêtes en fonction du moteur spatial utilisé, référez-vous au [tableau de compatibilité des recherches spatiales](/fr/1.9/ref/contrib/gis/db-api/#spatial-lookup-compatibility).

### `bbcontains`

*Disponibilité* : PostGIS, MySQL, SpatiaLite

Teste si le rectangle englobant du champ géométrique 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` |
| MySQL | `MBRContains(poly, geom)` |
| SpatiaLite | `MbrContains(poly, geom)` |

### `bboverlaps`

*Disponibilité* : PostGIS, MySQL, SpatiaLite

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` |
| MySQL | `MBROverlaps(poly, geom)` |
| SpatiaLite | `MbrOverlaps(poly, geom)` |

### `contained`

*Disponibilité* : PostGIS, MySQL, SpatiaLite

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` |
| MySQL | `MBRWithin(poly, geom)` |
| SpatiaLite | `MbrWithin(poly, geom)` |

### `contains`

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

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)` |
| MySQL | `MBRContains(poly, geom)` |
| SpatiaLite | `Contains(poly, geom)` |

### `contains_properly`

*Disponibilité* : PostGIS

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). [^4]

Exemple :

```
Zipcode.objects.filter(poly__contains_properly=geom)
```

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

### `coveredby`

*Disponibilité* : PostGIS, Oracle

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

### `covers`

*Disponibilité* : PostGIS, Oracle

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

### `crosses`

*Disponibilité* : PostGIS, SpatiaLite

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)` |
| SpatiaLite | `Crosses(poly, geom)` |

### `disjoint`

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

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)` |
| MySQL | `MBRDisjoint(poly, geom)` |
| SpatiaLite | `Disjoint(poly, geom)` |

### `equals`

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

### `exact`, `same_as`

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

### `intersects`

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

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)` |
| MySQL | `MBRIntersects(poly, geom)` |
| SpatiaLite | `Intersects(poly, geom)` |

### `overlaps`

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

### `relate`

*Disponibilité* : PostGIS, Oracle, SpatiaLite

Teste si le champ géométrique possède une liaison spatiale avec l’objet géométrique de la recherche en fonction des valeurs indiquées dans le motif donné. Cette recherche nécessite un paramètre sous forme de tuple `(géom, motif)`; la forme de `motif` dépend du moteur spatial :

#### PostGIS et SpatiaLite

Pour ces moteurs spatiaux, le motif d’intersection est une chaîne de neuf caractères qui définissent les intersections entre l’intérieur, les limites et l’extérieur du champ géométrique et de l’objet géométrique de la recherche. La matrice d’intersection ne peut utiliser que les caractères suivants : `1`, `2`, `T`, `F` ou `*`. Ce type de recherche permet d’affiner une relation géométrique spécifique en cohérence avec le modèle DE-9IM. [^1]

Exemple :

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

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

Équivalent SQL SpatiaLite :

```
SELECT ... WHERE Relate(poly, geom, '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, 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)` |
| MySQL | `MBRTouches(poly, geom)` |
| Oracle | `SDO_TOUCH(poly, geom)` |
| SpatiaLite | `Touches(poly, geom)` |

### `within`

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

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)` |
| MySQL | `MBRWithin(poly, geom)` |
| Oracle | `SDO_INSIDE(poly, geom)` |
| SpatiaLite | `Within(poly, geom)` |

### `left`

*Disponibilité* : PostGIS

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

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

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

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

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

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

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

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

Pour un aperçu sur la construction de requêtes de distance, référez-vous à l”[introduction sur les requêtes de distance](/fr/1.9/ref/contrib/gis/db-api/#distance-queries).

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

```
<field>__<distance lookup>=(<geometry>, <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 en nombre dans l’unité du champ ou un objet  [`Distance`](/fr/1.9/ref/contrib/gis/measure/#django.contrib.gis.measure.Distance)). Pour toutes les recherches de distance à l’exception de [`dwithin`](#std-fieldlookup-dwithin), une troisième valeur facultative, `'spheroid'`, peut être ajoutée pour dire à GeoDjango d’utiliser les fonctions de calcul de distance sphéroïde pour les champs ayant un système de coordonnées géodétique (par ex. `ST_Distance_Spheroid` serait utilisé à la place de `ST_Distance_Sphere` ). Dans le cas d’un système de coordonnées projeté, c’est la fonction plus simple `ST_Distance` qui sera utilisée.

### `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` |
| 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` |
| 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` |
| 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` |
| 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`](/fr/1.9/ref/contrib/gis/measure/#django.contrib.gis.measure.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)` |

> **Note**
>
> Cette recherche n’est pas disponible pour SpatiaLite.

## Méthodes `GeoQuerySet`

> **Deprecated since Django 1.9**
>
> Obsolète depuis la version 1.9: L’utilisation des méthodes `GeoQuerySet` est dorénavant obsolète et doit être remplacée par les nouvelles [Fonctions de base de données géographiques](/fr/1.9/ref/contrib/gis/functions/). Bien qu’un peu moins concises, elles sont beaucoup plus puissantes dans la manière de les combiner pour construire des requêtes plus complexes.

Les méthodes de `GeoQuerySet` appliquent une opération spatiale sur chaque champ géographique du jeu de requête et stockent le résultat dans un nouvel attribut du modèle (qui correspond généralement au nom de la méthode `GeoQuerySet`).

Il existe également des méthodes `GeoQuerySet` d’agrégation qui renvoient une valeur unique au lieu d’un jeu de requête. Cette section documente l’API et la disponibilité de chaque méthode de `GeoQuerySet` dans GeoDjango.

> **Note**
>
> Les méthodes disponibles dépendent du moteur spatial utilisé. Consultez le [tableau de compatibilité](/fr/1.9/ref/contrib/gis/db-api/#database-functions-compatibility) pour plus de détails.

À quelques exceptions près, les paramètres nommés suivants peuvent être utilisés avec toutes les méthodes de `GeoQuerySet`:

| Paramètre nommé | Description |
| --- | --- |
| `field_name` | Par défaut, les méthodes de `GeoQuerySet` utilisent le premier champ géométrique défini dans un modèle. Ce paramètre peut être utilisé pour désigner un autre champ géométrique (par ex. `field_name='point2'`) lorsqu’un modèle possède plusieurs champs géométriques.<br><br>Avec PostGIS, le paramètre `field_name` peut aussi contenir des champs géométriques provenant de modèles liés par une relation `ForeignKey` (par ex. `field_name='champfk__point'`). |
| `model_att` | Par défaut, les méthodes de `GeoQuerySet` ajoutent typiquement leur résultat dans un attribut du même nom que la méthode elle-même. Ce comportement par défaut peut être modifié en définissant ce paramètre avec un nom d’attribut différent. Par exemple, `qs = Zipcode.objects.centroid(model_att='c')` ajoute le centroïde (barycentre) du champ géométrique de `Zipcode` dans un attribut `c` de chaque modèle, plutôt que dans un attribut `centroid`.<br><br>Ce paramètre est obligatoire quand un nom de modèle entre en conflit avec une méthode `GeoQuerySet` existante ; par exemple si vous utilisez la méthode `area()` avec un modèle contenant un champ `PolygonField` nommé `area`. |

### Mesures

*Disponibilité* : PostGIS, Oracle, SpatiaLite

#### `area`

#### `GeoQuerySet.area(**kwargs)`

> **Deprecated since Django 1.9**
>
> Obsolète depuis la version 1.9: Utilisez à la place la fonction [`Area`](/fr/1.9/ref/contrib/gis/functions/#django.contrib.gis.db.models.functions.Area).

Écrit l’aire du champ géométrique dans un attribut `area` de chaque élément du `GeoQuerySet`.

#### `distance`

#### `GeoQuerySet.distance(geom, **kwargs)`

> **Deprecated since Django 1.9**
>
> Obsolète depuis la version 1.9: Utilisez à la place la fonction [`Distance`](/fr/1.9/ref/contrib/gis/functions/#django.contrib.gis.db.models.functions.Distance).

Cette méthode accepte un objet géométrique en paramètre et ajoute un attribut `distance` à chaque modèle du jeu de requête, attribut contenant la distance entre le champ concerné du modèle et l’objet géométrique donné (sous forme d’objet [`Distance`](/fr/1.9/ref/contrib/gis/measure/#django.contrib.gis.measure.Distance)).

Dans l’exemple suivant (tiré des [tests de distance de GeoDjango](https://github.com/django/django/blob/master/tests/gis_tests/distapp/models.py)), on calcule la distance entre la ville [tasmanienne](https://en.wikipedia.org/wiki/Tasmania) de Hobart vers tous les autres champs [`PointField`](/fr/1.9/ref/contrib/gis/model-api/#django.contrib.gis.db.models.PointField) du jeu de requête `AustraliaCity`:

```
>>> pnt = AustraliaCity.objects.get(name='Hobart').point
>>> for city in AustraliaCity.objects.distance(pnt): print(city.name, city.distance)
Wollongong 990071.220408 m
Shellharbour 972804.613941 m
Thirroul 1002334.36351 m
Mittagong 975691.632637 m
Batemans Bay 834342.185561 m
Canberra 598140.268959 m
Melbourne 575337.765042 m
Sydney 1056978.87363 m
Hobart 0.0 m
Adelaide 1162031.83522 m
Hillsdale 1049200.46122 m
```

> **Note**
>
> Comme l’attribut `distance` est un objet [`Distance`](/fr/1.9/ref/contrib/gis/measure/#django.contrib.gis.measure.Distance), il est facile d’exprimer cette valeur dans l’unité de son choix. Par exemple, `city.distance.mi` est la valeur de distance en milles et `city.distance.km` est la valeur de distance en kilomètres. Consultez [Objets de mesure](/fr/1.9/ref/contrib/gis/measure/) pour des détails d’utilisation et la liste des [Unités prises en charge](/fr/1.9/ref/contrib/gis/measure/#supported-units).

#### `length`

#### `GeoQuerySet.length(**kwargs)`

> **Deprecated since Django 1.9**
>
> Obsolète depuis la version 1.9: Utilisez à la place la fonction [`Length`](/fr/1.9/ref/contrib/gis/functions/#django.contrib.gis.db.models.functions.Length).

Écrit la longueur du champ géométrique dans un attribut `length` de chaque élément du jeu de requête (un objet [`Distance`](/fr/1.9/ref/contrib/gis/measure/#django.contrib.gis.measure.Distance)).

#### `perimeter`

#### `GeoQuerySet.perimeter(**kwargs)`

> **Deprecated since Django 1.9**
>
> Obsolète depuis la version 1.9: Utilisez à la place la fonction [`Perimeter`](/fr/1.9/ref/contrib/gis/functions/#django.contrib.gis.db.models.functions.Perimeter).

Écrit le périmètre du champ géométrique dans un attribut `perimeter` de chaque élément du jeu de requête (un objet [`Distance`](/fr/1.9/ref/contrib/gis/measure/#django.contrib.gis.measure.Distance)).

### Relations géométriques

Les méthodes suivantes ne demandent aucun paramètre et ajoutent un objet géométrique à chaque élément du jeu de requête [`GeoQuerySet`](#django.contrib.gis.db.models.GeoQuerySet) , objet qui est le résultat d’une fonction de relation évaluée sur le champ géométrique.

#### `centroid`

#### `GeoQuerySet.centroid(**kwargs)`

> **Deprecated since Django 1.9**
>
> Obsolète depuis la version 1.9: Utilisez à la place la fonction [`Centroid`](/fr/1.9/ref/contrib/gis/functions/#django.contrib.gis.db.models.functions.Centroid).

*Disponibilité* : PostGIS, Oracle, SpatiaLite

Écrit la valeur de centroïde du champ géométrique dans un attribut `centroid` de chaque élément du `GeoQuerySet`.

#### `envelope`

#### `GeoQuerySet.envelope(**kwargs)`

> **Deprecated since Django 1.9**
>
> Obsolète depuis la version 1.9: Utilisez à la place la fonction [`Envelope`](/fr/1.9/ref/contrib/gis/functions/#django.contrib.gis.db.models.functions.Envelope).

*Disponibilité* : PostGIS, SpatiaLite

Écrit un objet géométrique représentant le rectangle englobant du champ géométrique dans un attribut `envelope` de chaque élément du `GeoQuerySet`.

#### `point_on_surface`

#### `GeoQuerySet.point_on_surface(**kwargs)`

> **Deprecated since Django 1.9**
>
> Obsolète depuis la version 1.9: Utilisez à la place la fonction [`PointOnSurface`](/fr/1.9/ref/contrib/gis/functions/#django.contrib.gis.db.models.functions.PointOnSurface).

*Disponibilité* : PostGIS, Oracle, SpatiaLite

Écrit un objet géométrique `Point` se trouvant de manière certaine dans la surface du champ géométrique dans un attribut `point_on_surface` de chaque élément du jeu de requête.

### Éditeurs géométriques

#### `force_rhr`

#### `GeoQuerySet.force_rhr(**kwargs)`

> **Deprecated since Django 1.9**
>
> Obsolète depuis la version 1.9: Utilisez à la place la fonction [`ForceRHR`](/fr/1.9/ref/contrib/gis/functions/#django.contrib.gis.db.models.functions.ForceRHR).

*Disponibilité* : PostGIS

Calcule une version modifiée du (multi)polygone pour lequel toutes les arêtes suivent la « règle de la main droite » et place cet objet dans un attribut `force_rhr` pour chaque élément du jeu de requête.

#### `reverse_geom`

#### `GeoQuerySet.reverse_geom(**kwargs)`

> **Deprecated since Django 1.9**
>
> Obsolète depuis la version 1.9: Utilisez à la place la fonction [`Reverse`](/fr/1.9/ref/contrib/gis/functions/#django.contrib.gis.db.models.functions.Reverse).

*Disponibilité* : PostGIS, Oracle

Inverse l’ordre des coordonnées du champ géométrique et place l’objet résultant dans un attribut `reverse` pour chaque élément du jeu de requête.

#### `scale`

#### `GeoQuerySet.scale(x, y, z=0.0, **kwargs)`

> **Deprecated since Django 1.9**
>
> Obsolète depuis la version 1.9: Utilisez à la place la fonction [`Scale`](/fr/1.9/ref/contrib/gis/functions/#django.contrib.gis.db.models.functions.Scale).

*Disponibilité* : PostGIS, SpatiaLite

#### `snap_to_grid`

#### `GeoQuerySet.snap_to_grid(*args, **kwargs)`

> **Deprecated since Django 1.9**
>
> Obsolète depuis la version 1.9: Utilisez à la place la fonction [`SnapToGrid`](/fr/1.9/ref/contrib/gis/functions/#django.contrib.gis.db.models.functions.SnapToGrid).

Fait glisser tous les points du champ géométrique selon une grille. La manière d’ajuster l’objet géométrique à la grille dépend du nombre de paramètres numériques fournis (des nombres à virgule, entiers ou entiers longs).

| Nombre de paramètres | Description |
| --- | --- |
| 1 | Une seule taille de cellule de grille (à la fois pour la taille X et Y). |
| 2 | Tailles X et Y de cellule de grille. |
| 4 | Tailles de cellule X et Y ainsi que coordonnées X et Y de l’origine de la grille. |

#### `transform`

#### `GeoQuerySet.transform(srid=4326, **kwargs)`

> **Deprecated since Django 1.9**
>
> Obsolète depuis la version 1.9: Utilisez à la place la fonction [`Transform`](/fr/1.9/ref/contrib/gis/functions/#django.contrib.gis.db.models.functions.Transform).

*Disponibilité* : PostGIS, Oracle, SpatiaLite

La méthode `transform` transforme le champ géométrique d’un modèle dans le système de référence spatiale indiqué par le paramètre `srid`. Si ce paramètre est absent, c’est le SRID 4326 (WGS84) qui est utilisé par défaut.

> **Note**
>
> Au contraire des autres méthodes `GeoQuerySet`, `transform` effectue son travail sur l’objet lui-même. En d’autres termes, l’objet géométrique transformé n’est pas placé dans un nouvel attribut des modèles.

> **Note**
>
> La correspondance entre les numéros de SRID et les systèmes de référence spatiale peut dépendre du moteur spatial utilisé. Par exemple, les numéros SRID utilisés par Oracle ne sont pas forcément les mêmes que ceux utilisés par PostGIS.

Exemple :

```
>>> qs = Zipcode.objects.all().transform() # Transforms to WGS84
>>> qs = Zipcode.objects.all().transform(32140) # Transforming to "NAD83 / Texas South Central"
>>> print(qs[0].poly.srid)
32140
>>> print(qs[0].poly)
POLYGON ((234055.1698884720099159 4937796.9232223574072123 ...
```

#### `translate`

#### `GeoQuerySet.translate(x, y, z=0.0, **kwargs)`

> **Deprecated since Django 1.9**
>
> Obsolète depuis la version 1.9: Utilisez à la place la fonction [`Translate`](/fr/1.9/ref/contrib/gis/functions/#django.contrib.gis.db.models.functions.Translate).

*Disponibilité* : PostGIS, SpatiaLite

Effectue une translation du champ géométrique vers un nouvel emplacement en utilisant les paramètres numériques donnés comme vecteurs.

### Opérations géométriques

*Disponibilité* : PostGIS, Oracle, SpatiaLite

Les méthodes suivantes demandent toutes un objet géométrique en paramètre et ajoutent un objet géométrique à chaque élément du jeu de requête [`GeoQuerySet`](#django.contrib.gis.db.models.GeoQuerySet) résultant de l’opération.

#### `difference`

#### `GeoQuerySet.difference(geom)`

> **Deprecated since Django 1.9**
>
> Obsolète depuis la version 1.9: Utilisez à la place la fonction [`Difference`](/fr/1.9/ref/contrib/gis/functions/#django.contrib.gis.db.models.functions.Difference).

Effectue la différence spatiale entre le champ géométrique et l’objet géométrique donné et écrit le résultat dans un attribut `difference` de chaque élément du `GeoQuerySet`.

#### `intersection`

#### `GeoQuerySet.intersection(geom)`

> **Deprecated since Django 1.9**
>
> Obsolète depuis la version 1.9: Utilisez à la place la fonction [`Intersection`](/fr/1.9/ref/contrib/gis/functions/#django.contrib.gis.db.models.functions.Intersection).

Effectue l’intersection spatiale entre le champ géométrique et l’objet géométrique donné et écrit le résultat dans un attribut `intersection` de chaque élément du `GeoQuerySet`.

#### `sym_difference`

#### `GeoQuerySet.sym_difference(geom)`

> **Deprecated since Django 1.9**
>
> Obsolète depuis la version 1.9: Utilisez à la place la fonction [`SymDifference`](/fr/1.9/ref/contrib/gis/functions/#django.contrib.gis.db.models.functions.SymDifference).

Effectue la différence symétrique entre le champ géométrique et l’objet géométrique donné et écrit le résultat dans un attribut `sym_difference` de chaque élément du `GeoQuerySet`.

#### `union`

#### `GeoQuerySet.union(geom)`

> **Deprecated since Django 1.9**
>
> Obsolète depuis la version 1.9: Utilisez à la place la fonction [`Union`](/fr/1.9/ref/contrib/gis/functions/#django.contrib.gis.db.models.functions.Union).

Effectue l’union du champ géométrique avec l’objet géométrique donné et écrit le résultat dans un attribut `union` de chaque élément du `GeoQuerySet`.

### Sorties géométriques

Les méthodes `GeoQuerySet` suivantes créent pour chaque modèle un nouvel attribut contenant la valeur du champ géométrique converti dans le format de sortie demandé.

#### `geohash`

#### `GeoQuerySet.geohash(precision=20, **kwargs)`

> **Deprecated since Django 1.9**
>
> Obsolète depuis la version 1.9: Utilisez à la place la fonction [`GeoHash`](/fr/1.9/ref/contrib/gis/functions/#django.contrib.gis.db.models.functions.GeoHash).

Ajoute pour chaque modèle du jeu de requête un attribut `geohash` contenant la représentation [GeoHash](http://geohash.org/) du champ géométrique.

#### `geojson`

#### `GeoQuerySet.geojson(**kwargs)`

> **Deprecated since Django 1.9**
>
> Obsolète depuis la version 1.9: Utilisez à la place la fonction [`AsGeoJSON`](/fr/1.9/ref/contrib/gis/functions/#django.contrib.gis.db.models.functions.AsGeoJSON).

*Disponibilité* : PostGIS, SpatiaLite

Ajoute pour chaque modèle du jeu de requête un attribut `geojson` contenant la représentation [GeoJSON](http://geojson.org/) du champ géométrique.

| Paramètre nommé | Description |
| --- | --- |
| `precision` | Peut être utilisé pour indiquer le nombre de chiffres significatifs des coordonnées de la représentation GeoJSON, la valeur par défaut étant 8. |
| `crs` | À définir à `True` pour que le système de référence de coordonnées soit inclus dans le format GeoJSON renvoyé. |
| `bbox` | À définir à `True` pour que le rectangle englobant soit inclus dans le contenu GeoJSON renvoyé. |

#### `gml`

#### `GeoQuerySet.gml(**kwargs)`

> **Deprecated since Django 1.9**
>
> Obsolète depuis la version 1.9: Utilisez à la place la fonction [`AsGML`](/fr/1.9/ref/contrib/gis/functions/#django.contrib.gis.db.models.functions.AsGML).

*Disponibilité* : PostGIS, Oracle, SpatiaLite

Ajoute pour chaque modèle du jeu de requête un attribut `gml` contenant la représentation [Geographic Markup Language (GML)](https://en.wikipedia.org/wiki/Geography_Markup_Language) du champ géométrique.

Exemple :

```
>>> qs = Zipcode.objects.all().gml()
>>> print(qs[0].gml)
<gml:Polygon srsName="EPSG:4326"><gml:OuterBoundaryIs>-147.78711,70.245363 ...  -147.78711,70.245363</gml:OuterBoundaryIs></gml:Polygon>
```

| Paramètre nommé | Description |
| --- | --- |
| `precision` | Ce paramètre n’est valable que pour PostGIS. Il peut être utilisé pour indiquer le nombre de chiffres significatifs des coordonnées de la représentation GML, la valeur par défaut étant 8. |
| `version` | Ce paramètre n’est valable que pour PostGIS. Il peut être utilisé pour indiquer la version GML utilisée (2 ou 3). La valeur par défaut est 2. |

#### `kml`

#### `GeoQuerySet.kml(**kwargs)`

> **Deprecated since Django 1.9**
>
> Obsolète depuis la version 1.9: Utilisez à la place la fonction [`AsKML`](/fr/1.9/ref/contrib/gis/functions/#django.contrib.gis.db.models.functions.AsKML).

*Disponibilité* : PostGIS, SpatiaLite

Ajoute pour chaque modèle du jeu de requête un attribut `kml` contenant la représentation [Keyhole Markup Language (KML)](https://developers.google.com/kml/documentation/) du champ géométrique. Il faut relever que le contenu KML est transformé en WGS84 si nécessaire.

Exemple :

```
>>> qs = Zipcode.objects.all().kml()
>>> print(qs[0].kml)
<Polygon><outerBoundaryIs><LinearRing><coordinates>-103.04135,36.217596,0 ... -103.04135,36.217596,0</coordinates></LinearRing></outerBoundaryIs></Polygon>
```

| Paramètre nommé | Description |
| --- | --- |
| `precision` | Ce paramètre peut être utilisé pour indiquer le nombre de chiffres significatifs des coordonnées de la représentation KML, la valeur par défaut étant 8. |

#### `svg`

#### `GeoQuerySet.svg(**kwargs)`

> **Deprecated since Django 1.9**
>
> Obsolète depuis la version 1.9: Utilisez à la place la fonction [`AsSVG`](/fr/1.9/ref/contrib/gis/functions/#django.contrib.gis.db.models.functions.AsSVG).

*Disponibilité* : PostGIS, SpatiaLite

Ajoute pour chaque modèle du jeu de requête un attribut `svg` contenant les données de chemin [Scalable Vector Graphics (SVG)](http://www.w3.org/Graphics/SVG/) du champ géométrique.

| Paramètre nommé | Description |
| --- | --- |
| `relative` | Si défini à `True`, les données de chemin sont représentées en termes de déplacements relatifs. La valeur par défaut est `False` ce qui signifie que ce sont les déplacements absolus qui sont utilisés. |
| `precision` | Ce paramètre peut être utilisé pour indiquer le nombre de chiffres significatifs des coordonnées de la représentation SVG, la valeur par défaut étant 8. |

### Divers

#### `mem_size`

#### `GeoQuerySet.mem_size(**kwargs)`

> **Deprecated since Django 1.9**
>
> Obsolète depuis la version 1.9: Utilisez à la place la fonction [`MemSize`](/fr/1.9/ref/contrib/gis/functions/#django.contrib.gis.db.models.functions.MemSize).

*Disponibilité* : PostGIS

Calcule la taille mémoire (nombre d’octets) consommée par le champ géométrique et écrit le résultat dans un attribut `mem_size` de chaque élément du `GeoQuerySet`.

#### `num_geom`

#### `GeoQuerySet.num_geom(**kwargs)`

> **Deprecated since Django 1.9**
>
> Obsolète depuis la version 1.9: Utilisez à la place la fonction [`NumGeometries`](/fr/1.9/ref/contrib/gis/functions/#django.contrib.gis.db.models.functions.NumGeometries).

*Disponibilité* : PostGIS, Oracle, SpatiaLite

Écrit le nombre d’éléments géométriques dans un attribut `num_geom` de chaque élément du `GeoQuerySet`, pour autant que le champ géométrique soit une collection (par ex. un champ `GEOMETRYCOLLECTION` ou `MULTI*`) ; sinon, l’attribut contiendra `None`.

#### `num_points`

#### `GeoQuerySet.num_points(**kwargs)`

> **Deprecated since Django 1.9**
>
> Obsolète depuis la version 1.9: Utilisez à la place la fonction [`NumPoints`](/fr/1.9/ref/contrib/gis/functions/#django.contrib.gis.db.models.functions.NumPoints).

*Disponibilité* : PostGIS, Oracle, SpatiaLite

Calcule le nombre de points du premier élément ligne (linestring) du champ géométrique et écrit le résultat dans un attribut `num_points` de chaque élément du `GeoQuerySet`. L’attribut contiendra `None` s’il n’y a pas de ligne.

## Agrégations spatiales

### Méthodes d’agrégation

> **Deprecated since Django 1.8**
>
> Obsolète depuis la version 1.8: Les méthodes d’agrégation sont dorénavant obsolètes. Préférez l’utilisation des équivalents basés sur les fonctions.

#### `collect`

#### `GeoQuerySet.collect(**kwargs)`

> **Deprecated since Django 1.8**
>
> Obsolète depuis la version 1.8: Utilisez l’agrégation [`Collect`](#django.contrib.gis.db.models.Collect) à la place.

Raccourci pour `aggregate(Collect(<champ>))`.

#### `extent`

#### `GeoQuerySet.extent(**kwargs)`

> **Deprecated since Django 1.8**
>
> Obsolète depuis la version 1.8: Utilisez l’agrégation [`Extent`](#django.contrib.gis.db.models.Extent) à la place.

Raccourci pour `aggregate(Extent(<champ>))`.

#### `extent3d`

#### `GeoQuerySet.extent3d(**kwargs)`

> **Deprecated since Django 1.8**
>
> Obsolète depuis la version 1.8: Utilisez l’agrégation [`Extent`](#django.contrib.gis.db.models.Extent) à la place.

Raccourci pour `aggregate(Extent3D(<champ>))`.

#### `make_line`

#### `GeoQuerySet.make_line(**kwargs)`

> **Deprecated since Django 1.8**
>
> Obsolète depuis la version 1.8: Utilisez l’agrégation [`MakeLine`](#django.contrib.gis.db.models.MakeLine) à la place.

Raccourci pour `aggregate(MakeLine(<champ>))`.

#### `unionagg`

#### `GeoQuerySet.unionagg(**kwargs)`

> **Deprecated since Django 1.8**
>
> Obsolète depuis la version 1.8: Utilisez l’agrégation [`Union`](#django.contrib.gis.db.models.Union) à la place.

Raccourci pour `aggregate(Union(<champ>))`.

### 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](/fr/1.9/topics/db/aggregation/).

| Paramètre nommé | Description |
| --- | --- |
| `tolerance` | Ce paramètre n’est valable que pour Oracle. Il s’agit de la valeur de tolérance utilisée par la procédure `SDOAGGRTYPE`; la [documentation Oracle](https://docs.oracle.com/html/B14255_01/sdo_intro.htm#sthref150) contient plus de détails. |

Exemple :

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

#### `Collect`

#### `class Collect(geo_field)`

*Disponibilité* : PostGIS, SpatiaLite (≥3.0)

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`](#django.contrib.gis.db.models.Union), sauf qu’elle peut être vraiment plus rapide qu’une union car elle ne fait qu’accumuler les objets géométriques dans une collection ou une géométrie multiple sans se préoccuper de fusionner les objets.

#### `Extent`

#### `class Extent(geo_field)`

*Disponibilité* : PostGIS, Oracle, SpatiaLite (≥3.0)

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

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

*Disponibilité* : PostGIS

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 :

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

#### `Union`

#### `class Union(geo_field)`

*Disponibilité* : PostGIS, Oracle, SpatiaLite

Cette méthode renvoie un objet [`GEOSGeometry`](/fr/1.9/ref/contrib/gis/geos/#django.contrib.gis.geos.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`](#django.contrib.gis.db.models.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](http://www.opengis.org/docs/99-049.pdf), chap. 2.1.13.2, p. 2-13 (The Dimensionally Extended Nine-Intersection Model).

[^2]: *Voir* la [documentation de SDO\_RELATE](https://docs.oracle.com/cd/B19306_01/appdev.102/b14255/sdo_operat.htm#sthref845), chapitre 11 du manuel et guide d’utilisation Oracle Spatial.

[^3]: Pour une explication de cette routine, lisez [Quirks of the « Contains » Spatial Predicate](http://lin-ear-th-inking.blogspot.com/2007/06/subtleties-of-ogc-covers-spatial.html) par Martin Davis (un développeur PostGIS).

[^4]: Référez-vous à la [documentation](http://postgis.net/docs/manual-1.5/ST_ContainsProperly.html) de `ST_ContainsProperly` pour plus de détails.