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 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 pour vous familiariser avec Django.

Note

GeoDjango requiert des dépendances supplémentaires par rapport à Django, consultez la documentation d’installation 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. [1] Une partie du code de ce tutoriel est emprunté ou s’inspire du projet des applications de base GeoDjango. [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 :

Création d’un nouveau projet

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

$ django-admin startproject geodjango

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

$ cd geodjango
$ python 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 pour qu’il contienne django.contrib.admin, 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. 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 :

$ mkdir world/data
$ cd world/data
$ wget http://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, 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 :

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

$ 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
Geometry: Polygon
Feature Count: 246
Extent: (-180.000000, -90.000000) - (180.000000, 83.623596)
Layer SRS WKT:
GEOGCS["GCS_WGS_1984",
    DATUM["WGS_1984",
        SPHEROID["WGS_1984",6378137.0,298.257223563]],
    PRIMEM["Greenwich",0.0],
    UNIT["Degree",0.0174532925199433]]
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: Integer (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)
    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 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 :

$ python 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:

$ python manage.py sqlmigrate world 0001

Cette commande devrait produire le résultat suivant :

BEGIN;
--
-- Create model WorldBorder
--
CREATE TABLE "world_worldborder" (
    "id" serial NOT NULL PRIMARY KEY,
    "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 pour créer la table dans la base de données :

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

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

$ python manage.py shell

Si vous avez téléchargé les données Frontières mondiales précédemment dans ce tutoriel, vous pouvez déterminer son chemin en utilisant le module os intégré à Python :

>>> import os
>>> import world
>>> world_shp = os.path.abspath(os.path.join(os.path.dirname(world.__file__),
...                             'data', 'TM_WORLD_BORDERS-0.3.shp'))

Ouvrez maintenant le fichier shapefile des frontières mondiales en utilisant l’interface DataSource de GeoDjango :

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

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

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

Il est aussi possible qu’un système de référence spatial soit associé à l’objet Layer. Si c’est le cas, l’attribut srs renvoie un objet SpatialReference:

>>> srs = lyr.srs
>>> print(srs)
GEOGCS["GCS_WGS_1984",
    DATUM["WGS_1984",
        SPHEROID["WGS_1984",6378137.0,298.257223563]],
    PRIMEM["Greenwich",0.0],
    UNIT["Degree",0.0174532925199433]]
>>> srs.proj4 # PROJ.4 representation
'+proj=longlat +ellps=WGS84 +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', 'OFTInteger', '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()) :

>>> 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 peuvent être segmentés :

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

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

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

import os
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 = os.path.abspath(
    os.path.join(os.path.dirname(__file__), 'data', 'TM_WORLD_BORDERS-0.3.shp'),
)

def run(verbose=True):
    lm = LayerMapping(
        WorldBorder, world_shp, world_mapping,
        transform=False, encoding='iso-8859-1',
    )
    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).
  • Le paramètre encoding correspond au codage de caractères des valeurs textuelles du shapefile. Cela garantit que les valeurs textuelles sont lues et enregistrées correctement à partir de leur système de codage original.

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

$ python manage.py shell

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

>>> 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, il est possible d’automatiser davantage ce processus à l’aide de la commande de gestion ogrinspect. La commande 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 :

$ python 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 :

$ python 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.
  • L’option --multi est indiquée pour que le champ géographique utilise MultiPolygonField au lieu d’un simple 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 :

$ python manage.py shell

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

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

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

>>> 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 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, un système de coordonnées purement spécifique au Texas du Sud et en mètres, pas en degrés :

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

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

>>> 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, vous devez entourer vos champs géométriques afin que la valeur du champ soit reconnue par GEOS

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 exposant des fonctionnalités puissantes comme des propriétés de sérialisation pour des formats géospatiaux populaires :

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

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

Placement des données sur une carte

Interface d’administration géographique

GeoDjango étend l”application d’administration de Django avec la prise en charge de l’édition des champs géométriques.

Généralités

GeoDjango étend aussi l’administration de Django en permettant aux utilisateurs de créer et modifier des objets géométriques sur une carte active JavaScript (basée sur OpenLayers).

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

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

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

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

Créez un utilisateur administrateur :

$ python manage.py createsuperuser

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

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

OSMGeoAdmin

Avec OSMGeoAdmin, GeoDjango utilise une couche Open Street Map 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 GeoModelAdmin (qui utilise le jeu de données WMS Vector Map Level 0 hébergé sur OSGeo).

Les fichiers de projections PROJ.4 doivent être installés (voir les instructions d’installation de PROJ.4 pour plus de détails).

Si cette exigence est satisfaite, il suffit de remplacer la classe GeoModelAdmin par OSMGeoAdmin dans le fichier admin.py:

admin.site.register(WorldBorder, admin.OSMGeoAdmin)

Notes de bas de page

[1]Un merci particulier à Bjørn Sandvik de thematicmapping.org 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.
[4]Open Geospatial Consortium, Inc., OpenGIS Simple Feature Specification For SQL.
GeoDjango
Installation de GeoDjango
Back to Top