---
title: "Tutoriel GeoDjango"
version: 5.1
locale: fr
source: https://docs.djangoproject.com/fr/5.1/ref/contrib/gis/tutorial/
canonical: https://djangodocs.dev/fr/5.1/ref/contrib/gis/tutorial/
---
# Tutoriel GeoDjango

## Introduction

GeoDjango est un module contribué de Django qui le transforme en un système géographique web de grande envergure. L’objectif de GeoDjango est de faciliter le plus possible la création d’applications web géographiques telles que des services basés sur la géolocalisation. Ses fonctionnalités comprennent :

- Des champs de modèle Django pour les objets géométriques [OGC](https://www.ogc.org/) rz les données matricielles.
- Des extensions de l’ORM de Django pour les requêtes et les manipulations des données spatiales.
- Des interfaces Python faiblement liées et de haut niveau pour les opérations géométriques SIG et matricielles et la manipulation de données dans divers formats.
- L’édition de champs géométriques dans l’interface d’administration.

Ce tutoriel part du principe que Django vous est familier ; si donc vous débutez avec Django, commencez par lire le [tutoriel normal](/fr/5.1/intro/tutorial01/) pour vous familiariser avec Django.

> **Note**
>
> GeoDjango requiert des dépendances supplémentaires par rapport à Django, consultez la [documentation d’installation](/fr/5.1/ref/contrib/gis/install/) pour plus de détails.

Ce tutoriel va vous guider dans les création d’une application web géographique pour visualiser les [frontières mondiales](#id3). [^1] Une partie du code de ce tutoriel est emprunté ou s’inspire du projet des [applications de base GeoDjango](https://web.archive.org/web/20240123190237/https://thematicmapping.org/downloads/world_borders.php). [^2]

> **Note**
>
> Suivez dans l’ordre les sections de ce tutoriel afin d’obtenir des instructions pas à pas.

## Mise en route

### Création d’une base de données spatiale

En règle générale, aucune configuration spéciale n’est requise, ce qui fait que vous pouvez créer une base de données comme pour n’importe quel autre projet. Nous fournissons quelques astuces pour des bases de données précises :

- [Installation de PostGIS](/fr/5.1/ref/contrib/gis/install/postgis/)
- [Installation de SpatiaLite](/fr/5.1/ref/contrib/gis/install/spatialite/)

### Création d’un nouveau projet

Utilisez le script standard `django-admin` pour créer un projet nommé `geodjango`:

```console
$ django-admin startproject geodjango
```

*Windows*

```doscon
...\> django-admin startproject geodjango
```

Ceci va initialiser un nouveau projet. Créez maintenant une application Django `world` à l’intérieur du projet `geodjango`:

```console
$ cd geodjango
$ python manage.py startapp world
```

*Windows*

```doscon
...\> cd geodjango
...\> py manage.py startapp world
```

### Configuration de `settings.py`

Les réglages du projet `geodjango` sont dans le fichier `geodjango/settings.py`. Modifiez les réglages de la connexion de base de données pour qu’ils correspondent à votre configuration :

```
DATABASES = {
    "default": {
        "ENGINE": "django.contrib.gis.db.backends.postgis",
        "NAME": "geodjango",
        "USER": "geo",
    },
}
```

De plus, modifiez le réglage [`INSTALLED_APPS`](/fr/5.1/ref/settings/#std-setting-INSTALLED_APPS) pour qu’il contienne [`django.contrib.admin`](/fr/5.1/ref/contrib/admin/#module-django.contrib.admin), [`django.contrib.gis`](/fr/5.1/ref/contrib/gis/#module-django.contrib.gis) et `world` (l’application que vous venez de créer) :

```
INSTALLED_APPS = [
    "django.contrib.admin",
    "django.contrib.auth",
    "django.contrib.contenttypes",
    "django.contrib.sessions",
    "django.contrib.messages",
    "django.contrib.staticfiles",
    "django.contrib.gis",
    "world",
]
```

## Données géographiques

### Frontières mondiales

Les données des frontières mondiales sont disponibles dans ce [fichier zip](https://web.archive.org/web/20231220150759/https://thematicmapping.org/downloads/TM_WORLD_BORDERS-0.3.zip). Créez un répertoire `data` dans l’application `world`, téléchargez les données des frontières mondiales et décompressez le fichier. Sur les plates-formes GNU/Linux, utilisez les commandes suivantes :

```console
$ mkdir world/data
$ cd world/data
$ wget https://web.archive.org/web/20231220150759/https://thematicmapping.org/downloads/TM_WORLD_BORDERS-0.3.zip
$ unzip TM_WORLD_BORDERS-0.3.zip
$ cd ../..
```

*Windows*

```doscon
...\> mkdir world\data
...\> cd world\data
...\> wget https://web.archive.org/web/20231220150759/https://thematicmapping.org/downloads/TM_WORLD_BORDERS-0.3.zip
...\> unzip TM_WORLD_BORDERS-0.3.zip
...\> cd ..\..
```

Le fichier ZIP des frontières mondiales contient un ensemble de fichiers de données formant ensemble ce qu’on appelle un [Shapefile ESRI](https://en.wikipedia.org/wiki/Shapefile), l’un des formats de données géospatiales les plus utilisés. Après décompression, le jeu de données des frontières mondiales contient des fichiers avec les extensions suivantes :

- `.shp`: contient les données vectorielles des objets géométriques des frontières mondiales.
- `.shx`: fichier d’index spatial des objets géométriques stockés dans les fichiers
- `.dbf`: fichier de base de données contenant les données d’attributs non géométriques (par ex. des champs de nombres entiers ou de texte).
- `.prj`: contient les informations de référence spatiale pour les données géographiques stockées dans le shapefile.

### Utilisation de `ogrinfo` pour examiner les données spatiales

L’utilitaire GDAL `ogrinfo` permet d’examiner les métadonnées des shapefiles ou d’autres sources de données vectorielles :

```console
$ ogrinfo world/data/TM_WORLD_BORDERS-0.3.shp
INFO: Open of `world/data/TM_WORLD_BORDERS-0.3.shp'
      using driver `ESRI Shapefile' successful.
1: TM_WORLD_BORDERS-0.3 (Polygon)
```

*Windows*

```doscon
...\> ogrinfo world\data\TM_WORLD_BORDERS-0.3.shp
INFO: Open of `world/data/TM_WORLD_BORDERS-0.3.shp'
      using driver `ESRI Shapefile' successful.
1: TM_WORLD_BORDERS-0.3 (Polygon)
```

`ogrinfo` nous indique que le shapefile possède une couche et que celle-ci contient des données de type polygone. Pour en savoir plus, nous indiquons le nom de la couche et nous utilisons l’option `-so` pour n’afficher que le résumé des informations importantes :

```console
$ ogrinfo -so world/data/TM_WORLD_BORDERS-0.3.shp TM_WORLD_BORDERS-0.3
INFO: Open of `world/data/TM_WORLD_BORDERS-0.3.shp'
      using driver `ESRI Shapefile' successful.

Layer name: TM_WORLD_BORDERS-0.3
Metadata:
  DBF_DATE_LAST_UPDATE=2008-07-30
Geometry: Polygon
Feature Count: 246
Extent: (-180.000000, -90.000000) - (180.000000, 83.623596)
Layer SRS WKT:
GEOGCRS["WGS 84",
    DATUM["World Geodetic System 1984",
        ELLIPSOID["WGS 84",6378137,298.257223563,
            LENGTHUNIT["metre",1]]],
    PRIMEM["Greenwich",0,
        ANGLEUNIT["degree",0.0174532925199433]],
    CS[ellipsoidal,2],
        AXIS["latitude",north,
            ORDER[1],
            ANGLEUNIT["degree",0.0174532925199433]],
        AXIS["longitude",east,
            ORDER[2],
            ANGLEUNIT["degree",0.0174532925199433]],
    ID["EPSG",4326]]
Data axis to CRS axis mapping: 2,1
FIPS: String (2.0)
ISO2: String (2.0)
ISO3: String (3.0)
UN: Integer (3.0)
NAME: String (50.0)
AREA: Integer (7.0)
POP2005: Integer64 (10.0)
REGION: Integer (3.0)
SUBREGION: Integer (3.0)
LON: Real (8.3)
LAT: Real (7.3)
```

*Windows*

```doscon
...\> ogrinfo -so world\data\TM_WORLD_BORDERS-0.3.shp TM_WORLD_BORDERS-0.3
INFO: Open of `world/data/TM_WORLD_BORDERS-0.3.shp'
      using driver `ESRI Shapefile' successful.

Layer name: TM_WORLD_BORDERS-0.3
Metadata:
  DBF_DATE_LAST_UPDATE=2008-07-30
Geometry: Polygon
Feature Count: 246
Extent: (-180.000000, -90.000000) - (180.000000, 83.623596)
Layer SRS WKT:
GEOGCRS["WGS 84",
    DATUM["World Geodetic System 1984",
        ELLIPSOID["WGS 84",6378137,298.257223563,
            LENGTHUNIT["metre",1]]],
    PRIMEM["Greenwich",0,
        ANGLEUNIT["degree",0.0174532925199433]],
    CS[ellipsoidal,2],
        AXIS["latitude",north,
            ORDER[1],
            ANGLEUNIT["degree",0.0174532925199433]],
        AXIS["longitude",east,
            ORDER[2],
            ANGLEUNIT["degree",0.0174532925199433]],
    ID["EPSG",4326]]
Data axis to CRS axis mapping: 2,1
FIPS: String (2.0)
ISO2: String (2.0)
ISO3: String (3.0)
UN: Integer (3.0)
NAME: String (50.0)
AREA: Integer (7.0)
POP2005: Integer64 (10.0)
REGION: Integer (3.0)
SUBREGION: Integer (3.0)
LON: Real (8.3)
LAT: Real (7.3)
```

Ce résumé d’informations détaillé nous indique le nombre d’objets dans la couche (246), les limites géographiques des données, le système de référence spatial (« SRS WKT ») ainsi que le type d’information de chaque champ d’attribut. Par exemple, `FIPS: String (2.0)` indique que la longueur maximale du champ textuel `FIPS` est de 2 caractères. De même, `LON: Real (8.3)` correspond à un champ nombre en virgule flottante contenant un maximum de 8 chiffres avant la virgule et 3 après.

## Modèles géographiques

### Définition d’un modèle géographique

Après avoir examiné le jeu de données à l’aide de `ogrinfo`, créez un modèle GeoDjango pour représenter ces données :

```
from django.contrib.gis.db import models

class WorldBorder(models.Model):
    # Regular Django fields corresponding to the attributes in the
    # world borders shapefile.
    name = models.CharField(max_length=50)
    area = models.IntegerField()
    pop2005 = models.IntegerField("Population 2005")
    fips = models.CharField("FIPS Code", max_length=2, null=True)
    iso2 = models.CharField("2 Digit ISO", max_length=2)
    iso3 = models.CharField("3 Digit ISO", max_length=3)
    un = models.IntegerField("United Nations Code")
    region = models.IntegerField("Region Code")
    subregion = models.IntegerField("Sub-Region Code")
    lon = models.FloatField()
    lat = models.FloatField()

    # GeoDjango-specific: a geometry field (MultiPolygonField)
    mpoly = models.MultiPolygonField()

    # Returns the string representation of the model.
    def __str__(self):
        return self.name
```

Notez que le module `models` est importé à partir de `django.contrib.gis.db`.

Le système de référence spatial par défaut des champs géométriques est WGS84 (ce qui implique une valeur de [SRID](https://en.wikipedia.org/wiki/SRID) de 4326) ; en d’autres termes, les coordonnées du champ sont des couples longitude/latitude en degrés. Pour utiliser un système de coordonnées différent, définissez le SRID du champ géométrique avec le paramètre `srid`. Utilisez un nombre entier représentant le code EPSG du système de coordonnées.

### Exécutez `migrate`

Après avoir défini le modèle, vous devez le synchroniser avec la base de données. Créez tout d’abord une migration de base de données :

```console
$ python manage.py makemigrations
Migrations for 'world':
  world/migrations/0001_initial.py:
    + Create model WorldBorder
```

*Windows*

```doscon
...\> py manage.py makemigrations
Migrations for 'world':
  world/migrations/0001_initial.py:
    + Create model WorldBorder
```

Examinons le code SQL qui générera la table du modèle `WorldBorder`:

```console
$ python manage.py sqlmigrate world 0001
```

*Windows*

```doscon
...\> py manage.py sqlmigrate world 0001
```

Cette commande devrait produire le résultat suivant :

```sql
BEGIN;
--
-- Create model WorldBorder
--
CREATE TABLE "world_worldborder" (
    "id" bigint NOT NULL PRIMARY KEY GENERATED BY DEFAULT AS IDENTITY,
    "name" varchar(50) NOT NULL,
    "area" integer NOT NULL,
    "pop2005" integer NOT NULL,
    "fips" varchar(2) NOT NULL,
    "iso2" varchar(2) NOT NULL,
    "iso3" varchar(3) NOT NULL,
    "un" integer NOT NULL,
    "region" integer NOT NULL,
    "subregion" integer NOT NULL,
    "lon" double precision NOT NULL,
    "lat" double precision NOT NULL
    "mpoly" geometry(MULTIPOLYGON,4326) NOT NULL
)
;
CREATE INDEX "world_worldborder_mpoly_id" ON "world_worldborder" USING GIST ("mpoly");
COMMIT;
```

Si cela vous semble correct, exécutez [`migrate`](/fr/5.1/ref/django-admin/#django-admin-migrate) pour créer la table dans la base de données :

```console
$ python manage.py migrate
Operations to perform:
  Apply all migrations: admin, auth, contenttypes, sessions, world
Running migrations:
  ...
  Applying world.0001_initial... OK
```

*Windows*

```doscon
...\> py manage.py migrate
Operations to perform:
  Apply all migrations: admin, auth, contenttypes, sessions, world
Running migrations:
  ...
  Applying world.0001_initial... OK
```

## Importation de données spatiales

Cette section présente la manière d’importer le fichier des frontières mondiales dans une base de données via les modèles GeoDjango en utilisant l’[Utilitaire d’importation de données LayerMapping](/fr/5.1/ref/contrib/gis/layermapping/).

Il existe plusieurs façons d’importer des données dans une base de données spatiale ; en plus des outils inclus avec GeoDjango, il est aussi possible d’utiliser :

- [ogr2ogr](https://gdal.org/programs/ogr2ogr.html): un utilitaire en ligne de commande inclus dans GDAL et qui peut importer de nombreux formats de données vectorielles dans des bases de données PostGIS, MySQL et Oracle.
- [shp2pgsql](https://postgis.net/docs/using_postgis_dbmanagement.html#shp2pgsql_usage): cet utilitaire inclus dans PostGIS importe des shapefiles ESRI dans PostGIS.

### Interface GDAL

Vous avez précédemment utilisé `ogrinfo` pour examiner le contenu du fichier des frontières mondiales. GeoDjango contient également une interface Python vers la puissante bibliothèque OGR de GDAL qui est capable de traiter toutes les sources de données vectorielles prises en charge par OGR.

Premièrement, lancez le shell Django :

```console
$ python manage.py shell
```

*Windows*

```doscon
...\> py manage.py shell
```

Si vous avez téléchargé les données [Frontières mondiales](#worldborders) précédemment dans ce tutoriel, vous pouvez déterminer son chemin en utilisant [`pathlib.Path`](https://docs.python.org/3/library/pathlib.html#pathlib.Path) de Python :

```pycon
>>> from pathlib import Path
>>> import world
>>> world_shp = Path(world.__file__).resolve().parent / "data" / "TM_WORLD_BORDERS-0.3.shp"
```

Ouvrez maintenant le fichier shapefile des frontières mondiales en utilisant l’interface [`DataSource`](/fr/5.1/ref/contrib/gis/gdal/#django.contrib.gis.gdal.DataSource) de GeoDjango :

```pycon
>>> from django.contrib.gis.gdal import DataSource
>>> ds = DataSource(world_shp)
>>> print(ds)
/ ... /geodjango/world/data/TM_WORLD_BORDERS-0.3.shp (ESRI Shapefile)
```

Les objets des sources de données peuvent posséder plusieurs couches de contenu géospatial ; cependant, les fichiers shapefile ne peuvent contenir qu’une seule couche :

```pycon
>>> print(len(ds))
1
>>> lyr = ds[0]
>>> print(lyr)
TM_WORLD_BORDERS-0.3
```

Vous pouvez voir le type géométrique de la couche ainsi que le nombre d’objets qu’elle contient :

```pycon
>>> print(lyr.geom_type)
Polygon
>>> print(len(lyr))
246
```

> **Note**
>
> Malheureusement, le format de données shapefile ne permet pas de plus grande précision concernant le type géométrique. Ce fichier shapefile, comme beaucoup d’autres, contient en réalité des objets géométriques `MultiPolygon`, et non pas des `Polygon`. Il est important d’utiliser un type de champ plus général dans les modèles : un champ `MultiPolygonField` de GeoDjango acceptera un objet `Polygon`, mais un champ `PolygonField` n’acceptera pas un objet géométrique de type `MultiPolygon`. C’est pourquoi le modèle `WorldBorder` défini ci-dessus utilise un champ `MultiPolygonField`.

Il est aussi possible qu’un système de référence spatial soit associé à l’objet [`Layer`](/fr/5.1/ref/contrib/gis/gdal/#django.contrib.gis.gdal.Layer). Si c’est le cas, l’attribut `srs` renvoie un objet [`SpatialReference`](/fr/5.1/ref/contrib/gis/gdal/#django.contrib.gis.gdal.SpatialReference):

```pycon
>>> srs = lyr.srs
>>> print(srs)
GEOGCS["WGS 84",
DATUM["WGS_1984",
    SPHEROID["WGS 84",6378137,298.257223563,
        AUTHORITY["EPSG","7030"]],
    AUTHORITY["EPSG","6326"]],
PRIMEM["Greenwich",0,
    AUTHORITY["EPSG","8901"]],
UNIT["degree",0.0174532925199433,
    AUTHORITY["EPSG","9122"]],
AXIS["Latitude",NORTH],
AXIS["Longitude",EAST],
AUTHORITY["EPSG","4326"]]
>>> srs.proj  # PROJ representation
'+proj=longlat +datum=WGS84 +no_defs'
```

Ce fichier shapefile utilise le système de référence spatial bien connu WGS84 ; en d’autres termes, les données sont représentées par des couples longitude/latitude en degrés.

De plus, les fichiers shapefile peuvent aussi contenir des champs d’attributs comportant des données supplémentaires. Voici ces champs pour la couche `World Borders`:

```
>>> print(lyr.fields)
['FIPS', 'ISO2', 'ISO3', 'UN', 'NAME', 'AREA', 'POP2005', 'REGION', 'SUBREGION', 'LON', 'LAT']
```

Le code suivant permet d’examiner le type OGR (par ex. nombre entier ou chaîne de caractères) associé à chaque champ :

```
>>> [fld.__name__ for fld in lyr.field_types]
['OFTString', 'OFTString', 'OFTString', 'OFTInteger', 'OFTString', 'OFTInteger', 'OFTInteger64', 'OFTInteger', 'OFTInteger', 'OFTReal', 'OFTReal']
```

Il est possible de parcourir chaque objet de la couche et d’extraire des informations à la fois de la géométrie des objets (accessible par l’attribut `geom`) et des champs d’attribut des objets (dont les **valeurs** sont accessibles par la méthode `get()`) :

```pycon
>>> for feat in lyr:
...     print(feat.get("NAME"), feat.geom.num_points)
...
Guernsey 18
Jersey 26
South Georgia South Sandwich Islands 338
Taiwan 363
```

Les objets [`Layer`](/fr/5.1/ref/contrib/gis/gdal/#django.contrib.gis.gdal.Layer) peuvent être segmentés :

```pycon
>>> lyr[0:2]
[<django.contrib.gis.gdal.feature.Feature object at 0x2f47690>, <django.contrib.gis.gdal.feature.Feature object at 0x2f47650>]
```

Et des objets individuels peuvent être récupérés par leur identifiant d’objet :

```pycon
>>> feat = lyr[234]
>>> print(feat.get("NAME"))
San Marino
```

Les objets géométriques des frontières peuvent être exportés en tant que WKT ou GeoJSON :

```pycon
>>> geom = feat.geom
>>> print(geom.wkt)
POLYGON ((12.415798 43.957954,12.450554 ...
>>> print(geom.json)
{ "type": "Polygon", "coordinates": [ [ [ 12.415798, 43.957954 ], [ 12.450554, 43.979721 ], ...
```

### Cartographie des couches (`LayerMapping`)

Pour importer les données, utilisez un objet `LayerMapping` dans un script Python. Créez un fichier nommé `load.py` dans l’application `world` et insérez-y le code suivant :

```
from pathlib import Path
from django.contrib.gis.utils import LayerMapping
from .models import WorldBorder

world_mapping = {
    "fips": "FIPS",
    "iso2": "ISO2",
    "iso3": "ISO3",
    "un": "UN",
    "name": "NAME",
    "area": "AREA",
    "pop2005": "POP2005",
    "region": "REGION",
    "subregion": "SUBREGION",
    "lon": "LON",
    "lat": "LAT",
    "mpoly": "MULTIPOLYGON",
}

world_shp = Path(__file__).resolve().parent / "data" / "TM_WORLD_BORDERS-0.3.shp"

def run(verbose=True):
    lm = LayerMapping(WorldBorder, world_shp, world_mapping, transform=False)
    lm.save(strict=True, verbose=verbose)
```

Quelques notes au sujet du procédé :

- Chaque clé du dictionnaire `world_mapping` correspond à un champ du modèle `WorldBorder`. La valeur est le nom du champ du shapefile duquel les données seront chargées.
- La clé `mpoly` du champ géométrique est `MULTIPOLYGON`, le type géométrique que GeoDjango utilisera pour importer le champ. Même de simples polygones dans le fichier shapefile seront automatiquement convertis en collections avant leur insertion dans la base de données.
- Le chemin vers le fichier shapefile n’est pas absolu ; en d’autres termes, si vous déplacez l’application `world` (contenant le sous-répertoire `data`) vers un autre emplacement, le script fonctionne toujours.
- Le paramètre `transform` est défini à `False` car les données du fichier shapefile ne doivent pas être converties, elles sont déjà au format WGS84 (SRID=4326).

Après cela, appelez le shell Django à partir du répertoire de projet `geodjango`:

```console
$ python manage.py shell
```

*Windows*

```doscon
...\> py manage.py shell
```

Puis, importez le module `load`, appelez la routine `run` et observez `LayerMapping` effectuant tout le travail :

```pycon
>>> from world import load
>>> load.run()
```

### Utilisation de `ogrinspect`

Maintenant que vous avez vu comment définir des modèles géographiques et importer des données avec l’[Utilitaire d’importation de données LayerMapping](/fr/5.1/ref/contrib/gis/layermapping/), il est possible d’automatiser davantage ce processus à l’aide de la commande de gestion [`ogrinspect`](/fr/5.1/ref/contrib/gis/commands/#django-admin-ogrinspect). La commande [`ogrinspect`](/fr/5.1/ref/contrib/gis/commands/#django-admin-ogrinspect) inspecte une source de données vectorielle prise en charge par GDAL (par ex. un shapefile) et génère automatiquement une définition de modèle ainsi qu’un dictionnaire `LayerMapping`.

L’utilisation générale de la commande correspond à ceci :

```console
$ python manage.py ogrinspect [options] <data_source> <model_name> [options]
```

*Windows*

```doscon
...\> py manage.py ogrinspect [options] <data_source> <model_name> [options]
```

`data_source` est le chemin vers la source de données prise en charge par GDAL et `model_name` est le nom à utiliser pour le modèle. Les options en ligne de commande peuvent être utilisées pour définir plus finement la manière dont le modèle doit être généré.

Par exemple, la commande suivante reproduit presque le modèle `WorldBorder` et le dictionnaire de correspondance créés ci-dessus, de façon automatique :

```console
$ python manage.py ogrinspect world/data/TM_WORLD_BORDERS-0.3.shp WorldBorder \
    --srid=4326 --mapping --multi
```

*Windows*

```doscon
...\> py manage.py ogrinspect world\data\TM_WORLD_BORDERS-0.3.shp WorldBorder \
    --srid=4326 --mapping --multi
```

Quelques notes sur les options de ligne de commande indiquées ci-dessus :

- L’option `--srid=4326` définit le SRID du champ géographique.
- L’option `--mapping` indique à `ogrinspect` de générer aussi un dictionnaire de correspondance à l’usage de [`LayerMapping`](/fr/5.1/ref/contrib/gis/layermapping/#django.contrib.gis.utils.LayerMapping).
- L’option `--multi` est indiquée pour que le champ géographique utilise [`MultiPolygonField`](/fr/5.1/ref/contrib/gis/model-api/#django.contrib.gis.db.models.MultiPolygonField) au lieu d’un simple [`PolygonField`](/fr/5.1/ref/contrib/gis/model-api/#django.contrib.gis.db.models.PolygonField).

La commande produit le résultat suivant, qui peut être directement copié dans un fichier `models.py` d’une application GeoDjango :

```
# This is an auto-generated Django model module created by ogrinspect.
from django.contrib.gis.db import models

class WorldBorder(models.Model):
    fips = models.CharField(max_length=2)
    iso2 = models.CharField(max_length=2)
    iso3 = models.CharField(max_length=3)
    un = models.IntegerField()
    name = models.CharField(max_length=50)
    area = models.IntegerField()
    pop2005 = models.IntegerField()
    region = models.IntegerField()
    subregion = models.IntegerField()
    lon = models.FloatField()
    lat = models.FloatField()
    geom = models.MultiPolygonField(srid=4326)

# Auto-generated `LayerMapping` dictionary for WorldBorder model
worldborders_mapping = {
    "fips": "FIPS",
    "iso2": "ISO2",
    "iso3": "ISO3",
    "un": "UN",
    "name": "NAME",
    "area": "AREA",
    "pop2005": "POP2005",
    "region": "REGION",
    "subregion": "SUBREGION",
    "lon": "LON",
    "lat": "LAT",
    "geom": "MULTIPOLYGON",
}
```

## Requêtes spatiales

### Recherches spatiales

GeoDjango ajoute des recherches spatiales à l’ORM de Django. Par exemple, vous pouvez chercher le pays de la table `WorldBorder` qui contient un point particulier. Commencez par lancer un shell de commande :

```console
$ python manage.py shell
```

*Windows*

```doscon
...\> py manage.py shell
```

Définissez maintenant un point d’intérêt [^3]:

```pycon
>>> pnt_wkt = "POINT(-95.3385 29.7245)"
```

La chaîne `pnt_wkt` représente le point situé à la longitude -95.3385 degrés et la latitude 29.7245 degrés. La syntaxe géométrique est dans un format connu sous le nom de Well Known Text (WKT), un standard émis par le consortium Open Geospatial (OGC). [^4] Importez le modèle `WorldBorder` et lancez une recherche `contains` avec `pnt_wkt` en paramètre :

```pycon
>>> from world.models import WorldBorder
>>> WorldBorder.objects.filter(mpoly__contains=pnt_wkt)
<QuerySet [<WorldBorder: United States>]>
```

Vous venez d’obtenir un `QuerySet` contenant un seul modèle : la frontière des États-Unis (exactement ce que l’on espérait).

De la même façon, vous pouvez aussi utiliser un [objet géométrique GEOS](/fr/5.1/ref/contrib/gis/geos/). Ici, vous pouvez combiner une requête spatiale `intersects` avec la méthode `get` pour obtenir la seule instance de Saint-Marin au lieu d’un queryset :

```pycon
>>> from django.contrib.gis.geos import Point
>>> pnt = Point(12.4604, 43.9420)
>>> WorldBorder.objects.get(mpoly__intersects=pnt)
<WorldBorder: San Marino>
```

Les recherches `contains` et `intersects` ne sont qu’un sous-ensemble des recherches possibles, consultez la documentation [API de base de données GeoDjango](/fr/5.1/ref/contrib/gis/db-api/) pour plus de détails.

### Transformations spatiales automatiques

Lors de l’exécution de requêtes spatiales, GeoDjango transforme automatiquement les objets géométriques s’ils sont dans un système de coordonnées différent. Dans l’exemple suivant, les coordonnées seront exprimées en [SRID EPSG 32140](https://spatialreference.org/ref/epsg/32140/), un système de coordonnées **purement** spécifique au Texas du Sud et en mètres, pas en degrés :

```pycon
>>> from django.contrib.gis.geos import GEOSGeometry, Point
>>> pnt = Point(954158.1, 4215137.1, srid=32140)
```

Notez que `pnt` peut aussi être construit avec EWKT, une forme « étendue » de WKT qui contient le SRID :

```pycon
>>> pnt = GEOSGeometry("SRID=32140;POINT(954158.1 4215137.1)")
```

L’ORM de GeoDjango adapte automatiquement les valeurs géométriques dans le code de transformation SQL adéquat, permettant au développeur de travailler à un haut niveau d’abstraction :

```pycon
>>> qs = WorldBorder.objects.filter(mpoly__intersects=pnt)
>>> print(qs.query)  # Generating the SQL
SELECT "world_worldborder"."id", "world_worldborder"."name", "world_worldborder"."area",
"world_worldborder"."pop2005", "world_worldborder"."fips", "world_worldborder"."iso2",
"world_worldborder"."iso3", "world_worldborder"."un", "world_worldborder"."region",
"world_worldborder"."subregion", "world_worldborder"."lon", "world_worldborder"."lat",
"world_worldborder"."mpoly" FROM "world_worldborder"
WHERE ST_Intersects("world_worldborder"."mpoly", ST_Transform(%s, 4326))
>>> qs  # printing evaluates the queryset
<QuerySet [<WorldBorder: United States>]>
```

> **Requêtes brutes**
>
> Lors de l’utilisation de [requêtes brutes](/fr/5.1/topics/db/sql/), vous devez entourer vos champs géométriques afin que la valeur du champ soit reconnue par GEOS :
>
> ```pycon
> >>> from django.db import connection
> >>> # or if you're querying a non-default database:
> >>> from django.db import connections
> >>> connection = connections["your_gis_db_alias"]
> >>> City.objects.raw(
> ...     "SELECT id, name, %s as point from myapp_city" % (connection.ops.select % "point")
> ... )
> ```
>
> Les requêtes brutes ne devraient être utilisées que lorsque l’on sait exactement ce que l’on fait.

### Objets géométriques différés

GeoDjango charge les objets géométriques dans une représentation textuelle standardisée. Lors du premier accès au champ géométrique, GeoDjango crée un objet [`GEOSGeometry`](/fr/5.1/ref/contrib/gis/geos/#django.contrib.gis.geos.GEOSGeometry) exposant des fonctionnalités puissantes comme des propriétés de sérialisation pour des formats géospatiaux populaires :

```pycon
>>> sm = WorldBorder.objects.get(name="San Marino")
>>> sm.mpoly
<MultiPolygon object at 0x24c6798>
>>> sm.mpoly.wkt  # WKT
MULTIPOLYGON (((12.4157980000000006 43.9579540000000009, 12.4505540000000003 43.9797209999999978, ...
>>> sm.mpoly.wkb  # WKB (as Python binary buffer)
<read-only buffer for 0x1fe2c70, size -1, offset 0 at 0x2564c40>
>>> sm.mpoly.geojson  # GeoJSON
'{ "type": "MultiPolygon", "coordinates": [ [ [ [ 12.415798, 43.957954 ], [ 12.450554, 43.979721 ], ...
```

Cela comprend aussi l’accès à toutes les opérations géométriques avancées fournies par la bibliothèque GEOS :

```pycon
>>> pnt = Point(12.4604, 43.9420)
>>> sm.mpoly.contains(pnt)
True
>>> pnt.contains(sm.mpoly)
False
```

### Annotations géographiques

GeoDjango propose également un ensemble d’annotations géographiques pour calculer les distances et diverses autres opérations (intersection, différence, etc.). Voir la documentation [Fonctions de base de données géographiques](/fr/5.1/ref/contrib/gis/functions/).

## Placement des données sur une carte

### Interface d’administration géographique

L’[application d’administration de Django](/fr/5.1/ref/contrib/admin/) prend en charge l’édition des champs géométriques.

#### Généralités

L’administration de Django permet aux utilisateurs de créer et modifier des objets géométriques sur une carte active JavaScript (basée sur [OpenLayers](https://openlayers.org/)).

Mettons-nous au travail. Créez un fichier nommé `admin.py` dans l’application `world` et placez-y le code suivant :

```
from django.contrib.gis import admin
from .models import WorldBorder

admin.site.register(WorldBorder, admin.ModelAdmin)
```

Puis, modifiez `urls.py` dans le dossier d’application `geodjango` comme ceci :

```
from django.contrib import admin
from django.urls import include, path

urlpatterns = [
    path("admin/", admin.site.urls),
]
```

Créez un utilisateur administrateur :

```console
$ python manage.py createsuperuser
```

*Windows*

```doscon
...\> py manage.py createsuperuser
```

Puis, démarrez le serveur de développement Django :

```console
$ python manage.py runserver
```

*Windows*

```doscon
...\> py manage.py runserver
```

Pour terminer, allez à l’adresse `http://localhost:8000/admin/` et connectez-vous avec l’utilisateur que vous venez de créer. Parcourez l’un des objets `WorldBorder` et constatez que les frontières peuvent être modifiées en cliquant sur un polygone et en faisant glisser ses arêtes à la position souhaitée.

#### `GISModelAdmin`

Avec [`GISModelAdmin`](/fr/5.1/ref/contrib/gis/admin/#django.contrib.gis.admin.GISModelAdmin), GeoDjango utilise une couche [OpenStreetMap](https://www.openstreetmap.org/) dans l’interface d’administration. Cela donne plus de contexte (y compris les détails des rues et des voies de communication) que l’interface disponible avec  [`ModelAdmin`](/fr/5.1/ref/contrib/admin/#django.contrib.admin.ModelAdmin) (qui utilise le jeu de données WMS [Vector Map Level 0](http://web.archive.org/web/20201024202709/https://earth-info.nga.mil/publications/vmap0.html) hébergé sur [OSGeo](https://www.osgeo.org/)).

Les fichiers de projections PROJ doivent être installés (voir les [instructions d’installation de PROJ](/fr/5.1/ref/contrib/gis/install/geolibs/#proj4) pour plus de détails).

Si cette exigence est satisfaite, vous pouvez utiliser la classe `GISModelAdmin` dans le fichier `admin.py`:

```
admin.site.register(WorldBorder, admin.GISModelAdmin)
```

**Notes de bas de page**

[^1]: Un merci particulier à Bjørn Sandvik de mastermaps.net \<<https://mastermaps.net/>\>\`\_ pour la mise à disposition et la maintenance de ce jeu de données.

[^2]: Les applications GeoDjango de base ont été écrites par Dane Springmeyer, Josh Livni et Christopher Schmidt.

[^3]: Ce point correspond à [University of Houston Law Center](https://www.law.uh.edu/).

[^4]: Open Geospatial Consortium, Inc., OpenGIS Simple Feature Specification For SQL \_.