Version 95 (modified by jbronn, 11 years ago) (diff)

deleted install docs, since its been refactored to GeoDjangoInstall


TOC(GeoDjangoBackground, GeoDjango, GeoDjangoInstall, GeoDjangoModelAPI, GeoDjangoDatabaseAPI, GEOSGeometry)? The GIS branch intends to be a world-class geographic web framework. Our goal is to make it as easy as possible to build GIS web applications and harness the power of spatially enabled data.

News: The project has been accepted to FOSS4G 2007, thanks for your support!

Note: The documentation has been re-factored into several pages. See the table of contents on the right for a complete listing of topics. Other GeoDjango pages include:


Note: In order to minimize confusion, please don't modify the official roadmap below. If you have a suggestion, place it in the suggestion section or ask your question in the FAQ. If your request is urgent, submit a ticket requesting your feature or bugfix (make sure to specify the component as 'GIS'). Thanks for your cooperation!

Phase 1

  • Create Geometry-enabled fields and manager. Status: complete as of r4788.
  • Allow for Geometry-enabled queries. Status: complete as of r4788.

Phase 2

  • Pending
    • Distance queries, calculations, and related utilities.
    • Support for a mapping framework (e.g. Google Maps/Earth, Yahoo Maps, MS Live, etc.)
      • Admin fields and forms (WKT field currently as of r4884, but we want widgets to view and manipulate geographic objects).
    • WMS views.
    • Add as much from the PostGIS API as possible.
  • Complete
    • PostGIS indexing capability.
    • As of r5008, added a ctypes interface for GEOS in [source:django/branches/gis/django/contrib/gis/gdal django.contrib.gis.geos].
      • GEOSGeometry: Wraps GEOS geometries; all accessed geometry fields are returned as GEOSGeometry instances.
    • As of r5397, added a ctypes interface for GDAL/OGR in [source:django/branches/gis/django/contrib/gis/gdal django.contrib.gis.gdal].
      • OGRGeometry: Wraps OGR geometries, may be accessed with an extra instance method (e.g., z.get_poly_ogr()).
      • SpatialReference: Wraps OGR Spatial Reference objects, may be used to transform OGR geometries.
      • DataSource: Wraps OGR Data Source objects, may be used to explore GDAL-supported data sources
    • As of r5529, there are utilities for importing vector data (e.g., SHP files) directly into GeoDjango models.
      • The [source:django/branches/gis/django/contrib/gis/utils/ LayerMapping] class will import vector data from GDAL-supported data sources. This is still 'beta', and requires installation of the GDAL library.
    • As of r5657, "Lazy-Geometry" support was added (courtesy of Robert Coup's excellent patch in #4322) -- deprecating most of the extra instance methods.

Phase 3

  • Support additional spatial databases:
    • MySQL
    • DB2
    • Oracle Spatial (I (jbronn) would need access to a license to make this happen)
  • Geocoding framework.


Design Issues

  • Client JS/Flash framework, i.e., do we want to support OpenLayers, the Google Maps API, the Yahoo API?
    • So far, Google Maps looks the most promising for being supported first (people are familiar with it, and it's more stable than open layers).
    • Yahoo! has a really slick flash interface, I'd like to support this eventually.
    • OpenLayers supports WMS/WFS/tiles as well as Google, MSVE, and Yahoo layers. It is very flexible and open(!!). (Rob Coup)
  • Mapping Framework (generating custom tiles, layers, labels, etc.)
    • Mapnik is modern, but very early on in development and completely lacks documentation. However, the code is elegant and clean, and it was designed for integration with Python -- we're leaning towards this right now.
    • Mapserver has been around for a while, strong backing in the community (e.g. native support in QGIS). Even with documentation, the code looks less inviting than Mapnik (all in C); also has archaic text-based configuration files (pre-dating markup languages).
  • WMS Server
    • I'm not satisfied with any of the current WMS/WFS implementations. One implemented in Django would be desirable, e.g., django.contrib.gis.wms. Thoughts anyone? (OWSLib looks good, see below)


  • PCL (Python Cartographic Library), now part of GIS Python, has done a lot of good work already. Let's apply the DRY principle. Strong opportunities for collaboration with regards to:
    • Mapping framework
    • WMS/WMF Framework -- OWSLib looks excellent for this (BSD licensed and has unit tests!)
    • Utilities
    • Database representation ideas
    • GEOS support, Sean Gillies (of PCL) was the maintainer of the old SWIG bindings, and is working on ShapeLy, a GeoDjango-inspired GEOS ctypes interface.
  • CoordinatesField.
    • Jannis Leidel has already come up with a way to manipulate points in the admin interface, BSD licensed.
  • geopy
    • Brian Beck has written a good foundation for geocoding and distance calculations, BSD licensed.


  • Decide what to do about "invalid" shape files, for example, float SHP field with ' ' value.
  • Geo field introspection.


  • Place your questions here.
  • Q: When dealing with points (say, degrees) from, do they need to be converted to be useful on the back-end data, assuming -that- data is in degrees? Is it enough to have the same datum and origin? (Reading the intro above is likely to answer the question.)
    • My (JDunck) reading indicates yes. Given the same coordinate system (i.e. datum, origin, and axes), degrees are useful without conversion.
  • Q: Can this implementation work with MySQL spatial-extensions. If not, it's planned?
    • No. It is (now) planned, see Phase 3 below. From the last time I (jbronn) checked, MySQL's spatial capabilities have improved. However, we're going to focus our efforts on PostGIS until things are worked out a bit more. As a spatial database PostGIS it is more standards compliant (OpenGIS consortium), more widely used, and has more features (e.g. coordinate transformation, geometry_columns and spatial_ref_sys tables). It is definitely something I would want to implement in the future since I do like MySQL.
  • Q: Is this going to be a WMS Server/WMS Client/Both? OWSLib is just a WMS Client from what I have seen (from ruckc)
    • WMS Server first, client capability a possibility in certain situations (i.e. you want to cache data from another WMS server). Yes, OWSLib is a client, but it contains code for validating the correct parameters to send to a WMS server, thus it can be adapted into a Django view that validates whether the proper WMS parameters were given. Mapnik has an ogcserver module that can parse the correct parameters for WMS 1.1.1 and 1.3.0, however since it is licensed under the LGPL it cannot be easily incorporated into this branch (unlike OWSLib).
  • Q: Per this discussion in django-developers, "I can do spatial queries if they are directly between two models with polygon fields but I can't seem to get at the spatial queries through foreign keys."
    • Geographic queries require GeoManager, even if the model does not have a geographic field itself (in the case of a foreign key to a geo-field). The reply in the discussion gives detail into why.
  • Q: Why are the OGRGeometry methods transform and transform_to separate?
    • Because these map to the separate OGR routines OGR_G_Transform and OGR_G_TransformTo. Specifically, the transform routine takes a CoordTransform object as a parameter, whereas the transform_to routine takes a SpatialReference object. The transform_to "function requires internal creation and initialization of [a CoordTransform] object [and] it is significantly more expensive to use this function to transform many geometries than it is to create the [CoordTransform object] in advance, and call transform() with that transformation. This function exists primarily for convenience when only transforming a single geometry."


Geographic Models

Here is an example of how the model API currently works (assume this example is in geoapp/

from django.contrib.gis.db import models

class District(models.Model, models.GeoMixin):
    name = models.CharField(maxlength=35)
    num  = models.IntegerField()
    poly = models.PolygonField()

    objects = models.GeoManager()

class School(models.Model, models.GeoMixin):
    name  = models.CharField(maxlength=35)
    point = models.PointField()

    objects = models.GeoManager()

Notes: The GeoMixin class allows for extra instance methods. By default, a GiST index will be created for the School PointFields fields. This behavior can be turned off by using models.PointField(index=False).

Using syncdb

Both commands sqlall and syncdb work on geographic models:

$ python sqlall geoapp
CREATE TABLE "geoapp_school" (
    "id" serial NOT NULL PRIMARY KEY,
    "name" varchar(35) NOT NULL
CREATE TABLE "geoapp_district" (
    "id" serial NOT NULL PRIMARY KEY,
    "name" varchar(35) NOT NULL,
    "num" integer NOT NULL
SELECT AddGeometryColumn('geoapp_school', 'point', 4326, 'POINT', 2);
ALTER TABLE "geoapp_school" ALTER "point" SET NOT NULL;
CREATE INDEX "geoapp_school_point_id" ON "geoapp_school" USING GIST ( "point" GIST_GEOMETRY_OPS );
SELECT AddGeometryColumn('geoapp_district', 'poly', 4326, 'POLYGON', 2);
ALTER TABLE "geoapp_district" ALTER "poly" SET NOT NULL;
CREATE INDEX "geoapp_district_poly_id" ON "geoapp_district" USING GIST ( "poly" GIST_GEOMETRY_OPS );
$ python syncdb geoapp

Note: The geometry columns are created outside of the CREATE TABLE statements by the AddGeometryColumn. This is done according to the OpenGIS specfication.

Spatial Queries

After a geographic model has been created, the PostGIS additions to the API may be used. Geographic queries are done normally by using filter() and exclude() on geometry-enabled models using geographic lookup types (see the Database API for lookup types). In the following example, the bbcontains lookup type is used which is the same as the PostGIS && operator. It looks to see if the bounding box of the polygon contains the specific point. The next example uses the PostGIS Contains() function, which calls GEOS library to test if the polygon actually contains the specific point, not just the bounding box.

>>> from geoapp.models import District, School
>>> qs1 = District.objects.filter(poly__bbcontains='POINT(-95.362293 29.756539)') 
>>> qs2 = District.objects.filter(poly__contains='POINT(-95.362293 29.756539)') 

Both spatial queries and normal queries using filter() may be used in the same query. For example, the following query set will only show school districts that have 'Houston' in their name and contain the given point within their polygon boundary:

>>> qs = District.objects.filter(name__contains='Houston').filter(poly__contains='POINT(-95.362293 29.756539)')

Or combine both the bounding box routines (less accurate, fast) with the GEOS routines (most accurate, slower) to get a query that is both fast and accurate:

>>> qs = District.objects.filter(poly__bbcontains='POINT(-95.362293 29.756539)').filter(poly__contains='POINT(-95.362293 29.756539)')


Geographic fields on models are proxies to GEOS Geometry objects, allowing for many interesting possibilities:

>>> from django.contrib.gis.geos import fromstr
>>> pnt = fromstr('POINT(-95.362293 29.756539)', srid=4326)
>>> hisd = District.objects.get(name='Houston ISD')
>>> hisd.poly.contains(pnt)
>>> hisd.poly.within(pnt)
Back to Top