GIS & Chips » Mapnik

Thumbnails con Mapnik y OpenStreetMap

jose — Wed, 04 Nov 2009 20:12:13 +0000

¿Alguna vez te has visto en la tesitura de conocer el estado en OpenStreetMap de una determinada provincia, municipio, comunidad autónoma, región etc. en una fecha concreta? Pues bien, en este artículo intentaremos afrontar esta cuestión desde una perspectiva más pedagógica que profesional

Objetivo:
Crear thumbnails (imágenes reducidas) de cada provincia que serán generadas cada semana para ver la evolución histórica de las aportaciones de usuarios a OpenStreetMap. Cada imagen tendrá como nombre la fecha de su creación, y se almacenarán cada una en su carpeta de provincia correspondiente. Estas imágenes serán visibles en un servicio web para su consulta pública.

Fases:

Para llevar a cabo este objetivo precisamos de:

Actualizar cada semana la base de datos con el último “planet osm”
Generar las imágenes de cada provincia (mediante un script en Python)
Colocarlas en el lugar adecuado de nuestro servidor web
Programar la tarea para que se ejecute de forma automática cada semana, sin intervención del usuario.

Figura: Ejemplo del renderizado de una imagen de la provincia de Alicante

Tile de Alicante el 3 de noviembre de 2009

Descripción:
A lo largo de este pequeño artículo mostraremos las posibilidades conjuntas de OSM, PostGIS y Mapnik para que, con muy pocas líneas de código, seamos capaces de generar un repositorio de imágenes de cada provincia (en nuestro caso, aunque se puede adaptar a comunidades autónomas, municipios, etc.) que serán generadas por un script en python programado para ejecutarse una vez a la semana. Dicho script utilizará los módulos de Mapnik para generar imágenes a partir de un mapfile, y PsycoPg para llamar a sentencias SQL de PostgreSQL.

Punto de partida:
Tenemos instalado un servidor con las siguientes aplicaciones instaladas y configuradas:

Python
PostgreSQL y PostGIS
Mapnik y utilidad Mapnik de OSM
Una tabla de PostGIS con las provincias
Un servidor web para mostrar los resultados

Actualizar la base de datos de OSM cada semana

Para realizar esta fase necesitamos un script que automatice todas las funciones:

Borrar la bbdd existente
Descarga del planet
Creación de la bbdd con PostGIS
Carga de datos con osm2pgsql

Script Bash para recargar la base de datos de OSM

#!/bin/sh
echo "Borrando spain.osm.bz2"
rm spain.osm.bz2
echo "Descargando fichero osm de Spain desde Cloudmade.com"
wget http://downloads.cloudmade.com/europe/spain/spain.osm.bz2
echo "Descomprimiendo"
bzip2 -d spain.osm.bz2
echo "Borrando bbdd osm"
dropdb -h localhost -U postgres osm
echo "Creando bbdd osm"
createdb -U postgres -E UTF8 osm
echo "Instalar lenguaje pl/pgsql y Postgis en bbdd osm"
createlang -U postgres plpgsql osm
psql -U postgres -f /usr/share/pgsql/contrib/postgis.sql osm
psql -U postgres -f /usr/share/pgsql/contrib/spatial_ref_sys.sql osm
echo "Añadir datos d espain.osm a la bbdd osm"
echo "Tiempo aproximado: 11 minutos"
/home//compilar/osm2pgsql/osm2pgsql --slim -H localhost -U postgres -d osm ./spain.osm
echo "fin"
exit 0

Programar tarea con CRONTAB
Como ya sabes, los “crones” son tareas (deaemon) que se programan para ejecutarse en el momento (tiempo) que decidamos. Sí deseas más información aquí tienes un buen enlace: http://dns.bdat.net/documentos/cron/x50.html

Generar el árbol de directorios.
Creamos un script bash para generar las carpetas de cada provincia. Vamos a utilizar el código de cada provincia por cuestión de comodidad

#!/bin/bash
# Crear directorios para provincias.

for provincias in 01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52
do
  echo $provincias
  mkdir -p $provincias
done

exit 0

Este sencillo script, que seguro podrás mejorar, debemos de ejecutarlo en el directorio de nuestro website donde se alojarán el servicio para ver la evolución de OSM

Generar imágenes de OSM por provincia
Este script en Python hace uso de los módulos de Mapnik para generar la imagen, y de Psycopg para ejecutar sentencias SQL. Fíjate que la clave consiste en calcular por cada provincia las columnas con los valores de la extensión (xmin, ymin, xmax, ymax). Opcionalmente puedes añadirle una tolerancia para que el límite no se circunscriba a la caja de la provincia, sino que sea como una especie de buffer.
En nuestro caso, la tabla “provincias” está en la proyección UTM-ED50 del uso 30 (epsg: 23030), por lo que para utilizarlo con los datos de OSM necesitamos proyectar los valores de la extensión a Mercator (EPSG: 900913)

NOTA: Si no tienes instalago psycopg (o psycopg2 según la distro) lo puedes instalar con

yum install python-psycopg2.x86_64

Script de Python

#!/usr/bin/env python
## DNS de la bbdd que contiene las provincias
DSN = 'host=localhost user=postgres dbname=demos'

import sys, psycopg, mapnik
## Nota: Si obtienes algun error aqui, cambia psycopg por psycopg2
from datetime import date

## mapnik
mapfile = 'osm.xml'
## tamaño de la imagen
m = mapnik.Map(400, 400)

if len(sys.argv) > 1:
    DSN = sys.argv[1]

print 'Abrir conexion usando dns', DSN
conn = psycopg.connect(DSN)
## Nota: Si obtienes algun error aqui, cambia psycopg por psycopg2
curs = conn.cursor()

curs.execute('select codigo, st_xmin(st_extent(st_transform(geometria,900913))) as xmin, st_ymin(st_extent(st_transform(geometria,900913))) as ymin, st_xmax(st_extent(st_transform(geometria,900913))) as xmax, st_ymax(st_extent(st_transform(geometria,900913))) as ymax from ine.provincias group by codigo')

row = curs.fetchone()

rows = curs.fetchall()
print 'Creando imagenes...';
for row in rows:
    now = date.today()
    ## A cada imagen le asignamos como nombre la fecha de creación de la imagen
    map_output = 'miniaturas/'+row[0]+'/'+now.strftime("%Y-%m-%d&")+'.png'
    mapnik.load_map(m, mapfile)
    bbox = mapnik.Envelope(mapnik.Coord(row[1],row[2]), mapnik.Coord(row[3],row[4]))
    m.zoom_to_box(bbox)
    mapnik.render_to_file(m, map_output)

conn.commit()

Ejecutamos el script

python miniatura_provincias.py

Por último sólo nos queda hacer visible a nuestro servidor web las tiles. Para ello tenemos dos opciones:

a) Copiamos el directorio miniaturas a nuestra carpeta de publicación web

cp /home/mapnik/miniaturas /var/www//

b) Crear un enlace rígido en nuestra web que apunte al directorio “miniaturas”

ln -d /home/mapnik/miniaturas /var/www/<tu_ruta>/miniaturas

Este segundo método es más recomendable, puesto que nos permite aislar la lógica de nuestra aplicación del servicio web.

Test
Probamos el ejemplo
http://www.gisandchips.org/demos/j3m/miniaturas/

Automatización:

Sí queremos automatizar estas tareas, de forma que cada semana obtengamos una nueva imagen, cuyo nombre de imagen es la fecha en que se lanza el cron, debemos de lanzar un script que, como root, realice estos pasos. A modo de ejemplo, este sería el Bash:

#!/bin/sh
cd 
python ./
cp /home/mapnik/miniaturas /var/www/

Este artículo es el tercero de una serie formada por:

Renderizado con Mapnik
Mapnik y OpenStreetMap
Thumbnails con Mapnik y OpenStreetMap (este post)
Uso de TMS de OpenStreetMap con OpenLayers
TMS de OpenStreetMap con Mod_tile

OpenStreetMap y Mapnik

jose — Fri, 23 Oct 2009 11:42:23 +0000

Objetivo:
Siguiendo con la serie de artículos sobre OSM vamos a introducirnos en las posibilidades que nos ofrece Mapnik para renderizar datos de OSM contenidos en una geodatabase que hemos creado con “osm2pgsql” (ver artículo previo).
El objetivo final es crear un fichero de mapa (mapfile) en XML para utilizarlo con Python y los bindings de Mapnik. Una vez realizado este proceso podremos generar tanto imágenes como conjuntos de teselas (tiles)

Descarga de utilidades OSM para Mapnik
En el repositorio subversion de OSM tenemos todo lo necesario para montar nuestro propio motor de renderizado de imágenes y conjuntos de tiles.
Para descargar estas utilidades nos situamos en la raíz de nuestro “home” y procedemos a la descarga:

svn co http://svn.openstreetmap.org/applications/rendering/mapnik/ mapnik
cd mapnik

Este es el contenido de la carpeta “mapnik”:

symbols: carpeta con los iconos utilizados “oficialmente” en el “slippy map” de www.openstreetmap.org
osm_template.xml: plantilla por defecto para generar un mapfile de OSM
set_mapnik.env: script de configuración de directorios, datasources, etc.
generate_image.py: script para generar una imagen
generate_tiles.py: script para generar tiles
otros archivos

Descarga de shapefiles:

OSM necesita una serie de shapefiles para poder renderizar aspectos como la costa, paises, masas de agua, etc.
Lo ideal es que dentro del directorio “mapnik” creemos una carpeta donde almacenarlos

mkdir world_boundaries

Ahora descargamos los shapefiles y los descomprimimos

echo "Tamaño 50 Mb"
wget http://tile.openstreetmap.org/world_boundaries-spherical.tgz
echo "processed_p: Tamaño 227 Mb"
wget http://tile.openstreetmap.org/processed_p.tar.bz2
echo "shoreline_300: Tamaño 46 Mb"
$ wget http://tile.openstreetmap.org/shoreline_300.tar.bz2
cd world_boundaries
echo "Descomprimir"
tar -xvzf world_boundaries-spherical.tgz
tar jxvf processed_p.tar.bz2
tar jxvf shoreline_300.tar.bz2

De todas las shapes de estos archivos nos interesan fundamentalmente tres:

shoreline_300 : polígonos con los contienentes y en cuadrículas, utilizado para el renderizado de la costa. El detalle es muy tosco, por lo que se utiliza para escalas superiores a 1/600.000
processed_p: polígonos con los contienentes y en cuadrículas, utilizado para el renderizado de la costa. Tienen gran detalle, por lo que se utiliza para escalas inferiores a 1/600.000
builtup_area: polígonos con masas de agua continentales (lagos)

Configuración de Mapnik para OSM

El siguiente paso es configurar el fichero “set_mapnik.env” donde especificaremos las rutas a las carpetas de símbolos, shapefiles y conexiones a PostGIS.
Este fichero será utilizado por la plantilla de OSM (“osm_template.xml”) para sustituir las variables contenidas entre “%”, como por ejemplo “%HOST%”, por nuestros valores personalizados.

Contenido del fichero “set_mapnik.env”

#!/bin/sh
# Nombre del mapfile
export MAPNIK_MAP_FILE=/home//mapnik/osm.xml

# carpeta de símbolos
export MAPNIK_SYMBOLS_DIR=/home//mapnik/symbols

# carpeta de shapefiles
export MAPNIK_WORLD_BOUNDARIES_DIR=/home//mapnik/world_boundaries

# Carpeta donde se generarán las tiles
export MAPNIK_TILE_DIR=/home//mapnik/tiles/

# Host de PostgreSQL
export MAPNIK_DBHOST='localhost';

# Puerto de PostgreSQL
export MAPNIK_DBPORT=''

# Nombre de la base de datos del planet OSM
export MAPNIK_DBNAME='osm'

# Nombre del usuario de Postgres con derechos sobre la base de datos OSM
export MAPNIK_DBUSER='postgres'

# Password del usuario de PostgreSQL
export MAPNIK_DBPASS='';

# Prefijo utilizado en las tablas. Este prefijo es generado si se utiliza
# el parámetro "-p " en la utilidad "osm2pgsql". Si no lo utilizamos
# se entiende que será "planet_";
export MAPNIK_PREFIX=''
$*
#-----------------------------------------------------------------------------

NOTA: En el script sustituye “” por tu nombre de usuario.

Configuración de la plantilla de OSM

Como ya hemos indicado, entre los ficheros proporcionados en la carpeta “mapnik”, tenemos uno muy especial, “osm_template.xml”. Como habeis deducido se trata de la plantilla que utiliza Mapnik para generar el mapfile (“osm.xml”). Sí no tocamos nada de este archivo obtendremos un renderizado de imágenes o tiles igual que el utilizado por el “slippy map” de www.openstreetmap.org. Es aquí, por tanto, donde debemos de agudizar nuestro ingenio para establecer una simbología acorde con nuestros intereses: cambiar colores, retocar las SQL de las layers, añadir o cambiar iconos, etc.

En lo referente a este artículo, sólo vamos a realizar pequeños cambios.

1. Vamos a resaltar las paradas del tranvía para que aparezca el logotipo “oficial” por el que se conoce en Alicante a este medio de transporte (TRAM)

En el documento cambiamos este texto:

     
      100000
      25000
      [railway]='station' and not [disused]='yes'

Por este otro

    
      100000
      25000
      [railway]='station' and not [disused]='yes'

2. Por otra parte vamos a cambiar el color de fondo para las áreas residenciales
Color: ♦♦♦♦♦

    
      1000000
      1000
      [landuse] = 'residential'
      
        #F6CEE3

Crear imágenes

Una vez configurado nuestro mapfile (“osm.xml”) pasamos a generar imágenes utilizando el script “generate_image.py”. Te recomendamos que hagas una copia de ese archivo para no trabajar con el original. Con un editor de textos tienes que modificar los siguientes parámetros:

#!/bin/sh
# ... resto de código
    mapfile = "osm.xml"
    map_uri = "image.png"

    #---------------------------------------------------
    #  Change this to the bounding box you want
    #
    # Área metropolitana de Alicante
    ll = (-0.5534, 38.3245, -0.4267, 38.4071)
    #---------------------------------------------------
    z = 18
    imgx = 50 * z
    imgy = 50 * z
# ... resto de código

Cómo ves sólo es necesario modificar tres aspectos:

Extensión de la imagen en grados decimales: xmin,ymin,xmax,ymax
Nivel de zoom: del 1 (mundo) al 18 (máximo de detalle)
Dimensiones de la imagen en píxeles

NOTA:

Para evitar resultados desagradables intenta ajustar el BBOX y las dimensiones de la imagen.

Por último debemos de realizar los siguientes pasos para generar la imagen

1. Leer las variables que hemos definido en “set_mapnik.env”

source set-mapnik-env

2. Utilizar la plantilla “osm-template.xml” para generar el fichero “oxm.xml”

./customize-mapnik-map >$MAPNIK_MAP_FILE

3. Lanzar el script:

python mi_genera_imagen.py

Este es el resultado:

Zoom 14

Zoom 18 (fíjate en el renderizado de las estaciones del TRAM)

Crear las tiles

Esta es la parte de Mapnik que tiene más interés para nosotros, puesto que nos permitirá generar nuestro propio TMS para ser utilizado con independencia del “Slippy map” de OpenStreetMap.

1. Creamos el directorio donde se guardarán las tiles creadas:

mkdir -p $MAPNIK_TILE_DIR

2. Editamos el fichero “generate_tiles.py” para definir las zonas a renderizar

#!/usr/bin/python
# resto de código
# directorio donde se almacenan las imágenes
        tile_dir = home + "/osm/tiles/"

    #-------------------------------------------------------------------------
    #
    # Change the following for different bounding boxes and zoom levels
    #
    # Start with an overview
    # World
    bbox = (-180.0,-90.0, 180.0,90.0)

    render_tiles(bbox, mapfile, tile_dir, 0, 5, "World")

    # Europa
    minZoom = 6
    maxZoom = 8
    bbox = (1.0,10.0, 20.6,50.0)
    render_tiles(bbox, mapfile, tile_dir, minZoom, maxZoom)

    # Provincia de Alicante
    bbox = (-1.498,37.622,0.529,38.946)
    render_tiles(bbox, mapfile, tile_dir, 9, 11 , "Europe+")

    # Área metropolitana de la ciudad de Alicante
    bbox = (-0.6171,38.295,-0.3637,38.4602)
    render_tiles(bbox, mapfile, tile_dir, 12, 18 , "Alicante")

Cómo habrás podido deducir vamos a generar tiles en cuatro intervalos de escala:

Escalas pequeñas: Zoom del 1 al 5
Escalas medias: 6 al 8
Escalas grandes (más detalles): 9 al 11
Escalas de máximo detalle): 12 al 18

3. Ejecutamos el script

python ./mi_genera_tiles.py

4. Comprobación:
Fíjate que en la carpeta “tiles” tendremos una carpeta por cada nivel de zoom. En los niveles superiores es donde habrán más imágenes (las de mayor detalle)

ls tiles

Por fin, ya hemos creado nuestro directorio de tiles listo para ser utilizado por OpenLayers como un TMS.

Esto es todo. Espero que os haya gustado. Comentarios y críticas serán bien recibidas

Este artículo es el segundo de una serie formada por:

Renderizado con Mapnik
Mapnik y OpenStreetMap (este post)
Thumbnails con Mapnik y OpenStreetMap
Uso de TMS de OpenStreetMap con OpenLayers
TMS de OpenStreetMap con Mod_tile

Renderizado con Mapnik

jose — Thu, 22 Oct 2009 08:43:27 +0000

En el planteamiento que presenté en el primer artículo sobre OSM y PgRouting no estaba incluido el tema del renderizado, pero tras indagar el tema de Mapnik me he dado cuenta de las magníficas posibilidades que ofrece este renderizador, de ahí que haga un inciso para introducir esta cuestión.

Mapnik es un toolkit en C++ para renderizar varios orígenes de datos, que tiene bindings para Python. La calidad de este paquete, a mi juicio, está por encima de otros renderizadores como Osmarender o Kosmos. Profundizar en él me ha permitido aprender algo de Python, que nunca viene mal y sumergirme en las entrañas de la edición cartográfica. En cualquiera de los casos, los resultados estarán limitados a nuestra destreza para la composición de mapas, pero nunca a las limitaciones del programa.

Mapnik entiende los siguientes orígenes de datos:

Shapefiles
PostGIS
Raster (generalmente TIFF, aunque si se compila Mapnik con GDAL podemos ampliar el espectro de formatos)

OBJETIVO:

En muchas de nuestras aplicaciones web incluimos una layer del proveedor OSM, utilizando OpenLayers, Mapfish u otras. El resultado es fácil de implementar, pero tiene el problema de depender del estado de salud del servidor oficial de www.openstreetmap.org. Además, puede que en un momento dado nos planteemos utilizar nuestra propia simbolización, cambiando los colores de las vias, o añadiendo unos iconos diferentes a los oficiales Aquí nos planteamos crear un TMS (Tile Map Service), o lo que es lo mismo, un conjunto de imágenes de mapa (tiles) de reducido tamaño (256 * 256) , personalizadas con nuestros criterios de simbolización gráfica, que están ordenadas en carpetas, cada una de las cuales recibe el nombre del nivel de zoom utilizado, que oscila entre 1 y 18, siguiendo la estructura del “mapnik slippy map“, que es una forma de ordenar las tiles en función de la proyección utilizada (Mercator).

REFERENCIAS WEB:

http://weait.com/content/build-your-own-openstreetmap-server Interesante portal con artículos sobre OSM y Mapnik. Os lo recomiendo para instalar Mapnik y realizar pruebas

DESARROLLO:

Compilación de librerías necesarias (Mapnik y osm2pgsql)
Creación de una geodatabase con datos OSM utilizando Osm2Pgsql
Configuración de la plantilla de mapa (XML mapfile)
Pruebas de renderizado
Creación del TMS
Implementación del TMS en OpenLayers

COMPILACIÓN DE LIBRERÍAS:

Entrando en faena vamos a compilar el paquete Mapnik, que como no podía ser de otra manera tiene una dependencia insalvable, BOOST, que ya vimos en el anterior artículo. No obstante indico rápidamente su compilación:

COMPILACIÓN DE BOOST

1. Añadir dependencias. Según la distro necesitaremos una u otra (python-devel, freetype-devel, etc). En este paso vamos a incluir una librería que me ha dado varios quebraderos de cabeza: EXPAT. No sólo es necesaria instalarla, sino que además debemos de indicar algunas variables de configuración. Empezamos por su instalación desde la paquetería

Ubuntu: $ sudo apt-get install libexpat1-dev

$ sudo apt-get install libltdl7-dev libpng12-dev libtiff4-dev libicu-dev libboost-regex-dev libboost-iostreams-dev libboost-filesystem-dev libboost-thread-dev libboost-python1.34.1 libboost-python-dev libfreetype6-dev libcairo2-dev libcairomm-1.0-dev libboost-program-options-dev python-cairo-dev libboost-serialization-dev imagemagick

Centos: $ yum install expat expat-devel.x86_64

NOTA: Fíjate que para expat le indico específicamente la plataformas de 64 bits. Es importante indicarla. Si ponemos “yum install expat-devel” instalará las dos, y nos proporcionará problemas en el futuro (por ejemplo compilando nuestra querida GDAL). Indícale cual es tu plataforma (x86_64 / i386)

2. Define variables para expat:


export EXPAT_INCLUDE=/usr/include
export EXPAT_LIBPATH=/usr/lib

3. Descargar la version 1.39 y descomprimir en /usr/local/

mkdir /usr/local/include/boost
wget http://downloads.sourceforge.net/project/boost/boost/1.39.0/boost_1_39_0.tar.bz2
tar -xjvf boost_1_39_0.tar.bz2
cd boost_1_39_0

4. Compilar:

./bootstrap.sh --prefix=/usr/local/
./bjam install --includedir=/usr/local/include/boost/

Como root:

/sbin/ldconfig

Este comando es mano de santo para que los compiladores encuentren las librerías.
COMPILAR MAPNIK
Para compilar en Ubuntu os recomiendo seguir las indicaciones de este enlace. Para Centos estos son los pasos a seguir:

cd /home//compilar

1. Descargar y descomprimir la fuente de Mapnik (versión 0.6.1)

wget http://download.berlios.de/mapnik/mapnik-0.6.1.tar.bz2
tar -xjvf mapnik-0.6.1.tar.bz2
cd mapnik-0.6.1

2. Compilar:

python scons/scons.py configure
python scons/scons.py BOOST_INCLUDES=/usr/local/include/boost/boost-1_39/ BOOST_LIBS=/usr/local/lib BOOST_TOOLKIT=gcc41

Como root:

python scons/scons.py BOOST_INCLUDES=/usr/local/include/boost/boost-1_39/ BOOST_LIBS=/usr/local/lib BOOST_TOOLKIT=gcc41 install

3. Actualizar rutas de librerías (como root):

/sbin/ldconfig

4. Comprobación de la instalación:

Las fuentes contienen una demo para comprobar la instalación. Se trata de un script en Python que tras su ejecución llama a algunos shapefiles y genera unas imágenes en PNG. También lo hará en otros formatos (PDF, PS, etc.) sí has compilado Mapnik con Cairo y PyCairo. En Ubuntu es muy fácil ya que estas librerías se encuentran en el repositorio, pero en Centos he sido incapaz de utilizarlas (si alguno lo consigue su comentario será de agradecer).

Mapnik utiliza la librería AGG para crear las imágenes, siendo ésta la librería de uso por defecto, aunque también puede utilizar Cairo.
1. Cambia al directorio de pruebas

cd /demo/python
python rundemo.py

Obtendrás este mensaje:

Skipping cairo examples as Pycairo not available
3 maps have been rendered in the current directory:
- demo.png
- demo256.png
- demo.jpg
Have a look!

Bueno, pues ya está. Si las imágenes se han generado Mapnik funciona. Sí te da algun error es que te falta alguna librería. Otra manera de ver que errores hay es utilizando la propia consola de python. Escribe lo que está en negrita:

jose@jose:~/compilar$ python

Python 2.6.2 (release26-maint, Apr 19 2009, 01:56:41)

[GCC 4.3.3] on linux2Type “help”, “copyright”, “credits” or “license” for more information.
>>> import mapnik
>>> exit()

Sí tras escribir “import mapnik” obtienes algunas líneas de error es que algo te falta. De lo contrario el intérprete de Python entiende que la llamada a la librería funciona y no devuelve nada.
CREACIÓN DE UNA GEODATABASE CON EL PLANET DE OSM

Nuestro objetivo es ahora crear una geodatabase de PostGIS con datos procedente de un planet.osm. Con ello, conseguiremos tener un repositorio de datos cuyo único fin es ser utilizado por Mapnik para renderizar tiles, y no para otras funciones como la de routing. Por esta razón utilizamos “osm2pgsql”. Esta herramienta suele formar parte de los repositorios de las distros, por lo que sólo necesitas:

Ubuntu: sudo apt-get install osm2pgsql
Centos: yum install osm2pgsql

Compilación de osm2pgsql:


svn co http://svn.openstreetmap.org/applications/utils/export/osm2pgsql/
cd osm2pgsql
make

Crear una geodatabase con datos de OSM es una labor sencilla, pero ten en cuenta que OSM cambia constantemente, por lo que la validez de tus datos tienen una caducidad. Por esta razón es importante que articulemos algún sistema para que cada cierto tiempo la base de datos de OSM se actualice sólo. Por ello te recomiendo que personalices el siguiente script en bash que te facilitará la labor:

#!/bin/sh
echo "Script en Bash para actualizar un planet.osm en una base de datos OSM con Postgis v. 1.4."
echo "Borrando spain.osm.bz2"
rm spain.osm.bz2
echo "Descargando fichero osm de Spain desde Cloudmade.com"
wget http://downloads.cloudmade.com/europe/spain/spain.osm.bz2
echo "Descomprimiendo"
bzip2 -d spain.osm.bz2
echo "Borrando bbdd osm"
dropdb -h localhost -U postgres osm
echo "Creando bbdd osm"
createdb -U postgres -E UTF8 osm
echo "Instalar lenguaje pl/pgsql y Postgis en bbdd osm"
createlang -U postgres plpgsql osm
psql -U postgres -f /usr/share/pgsql/contrib/postgis.sql osm
psql -U postgres -f /usr/share/pgsql/contrib/spatial_ref_sys.sql osm
echo "Añadir datos de spain.osm a la bbdd osm"
echo "Tiempo aproximado: 11 minutos"
osm2pgsql --slim -H localhost -U postgres -d osm ./spain.osm
echo "fin"

NOTA: Es muy importante utilizar el parámetro “slim” en osm2pgsql, puesto que permite introducir datos directamente a la base de datos, lo que resulta muy útil con planet.osm de mucho peso. Si no se usa, cargará en memoria todo el osm hasta que ocupe toda la memoria de tu ordenador. Contenido de la geodatabase

psql -h localhost -U postgres osm
Welcome to psql 8.3.8 (server 8.3.7), the PostgreSQL interactive terminal.

Type:  \copyright for distribution terms
       \h for help with SQL commands
       \? for help with psql commands
       \g or terminate with semicolon to execute query
       \q to quit

osm=# \d
                     List of relations
 Schema |            Name            |   Type   |  Owner
--------+----------------------------+----------+----------
 public | geometry_columns           | table    | postgres
 public | planet_osm_line            | table    | postgres
 public | planet_osm_line_pid_seq    | sequence | postgres
 public | planet_osm_nodes           | table    | postgres
 public | planet_osm_point           | table    | postgres
 public | planet_osm_point_pid_seq   | sequence | postgres
 public | planet_osm_polygon         | table    | postgres
 public | planet_osm_polygon_pid_seq | sequence | postgres
 public | planet_osm_rels            | table    | postgres
 public | planet_osm_roads           | table    | postgres
 public | planet_osm_roads_pid_seq   | sequence | postgres
 public | planet_osm_ways            | table    | postgres
 public | spatial_ref_sys            | table    | postgres
(13 rows)

INTRODUCCIÓN A MAPNIK CON PYTHON
Como ya he dicho, no soy un especialista en este lenguaje, aunque su sintaxis me parece muy clara para entenderla sin problemas.
Lo primero que debemos de tener en cuenta es que el diagrama de flujo de Mapnik exige para su uso de un script en Python (o desde la misma consola de Python) donde se aprecien las siguientes fases:

1. Cargar los paquetes (bindings) de Mapnik para Python
2. Indicar la fuente de datos (datasource) de cada layer a representar
3. Definir la simbología de cada layer
4. Indicar los parámetros de la imagen a crear: tamaño, nombre del fichero

Veamos el ejemplo más sencillo: Crear una imagen a partir de un shapefile

#!/usr/bin/env python
# Fichero: hola_mundo.py
# Cargamos los bindings de mapnik
import mapnik
# Definimos un objeto mapa, con un tamaño (en píxeles) y una proyección según PROJ4
m = mapnik.Map(600,300,'+proj=latlong +datum=WGS84')
# Indicamos el color de fondo
m.background = mapnik.Color('steelblue')
# Creamos un estilo. Un estilo es un tipo de objeto que puede almacenar una o varias reglas (rules)
# para la representación cartográfica
s = mapnik.Style()
# Creamos un objeto rule
r=mapnik.Rule()
# Aplicamos parámetros a esa regla. En este caso:
# 1. relleno del polígono
# 2. simbología de la línea (outline)
r.symbols.append(mapnik.PolygonSymbolizer(mapnik.Color('#f2eff9')))
r.symbols.append(mapnik.LineSymbolizer(mapnik.Color('rgb(50%,50%,50%)'),0.1))
# asociamos la "rule" (r) al estilo (s)
s.rules.append(r)
# Asignamos un nombre al estilo
m.append_style('My Style',s)
# Creamos un objeto layer de mapnik: un nombre y una projección. En este caso la geodésica mundial EPSG:4326
lyr = mapnik.Layer('world','+proj=latlong +datum=WGS84')
# Definimos el origen de datos
lyr.datasource = mapnik.Shapefile(file='/Users/path/to/your/data/world_borders')
# Asociamos a la layer el estilo que hemos creado
lyr.styles.append('My Style')
# Asociamos la layer al objeto mapa (m)
m.layers.append(lyr)
# Indicamos que se renderizará el total de la extensión del shapefile
m.zoom_to_box(lyr.envelope())
# Renderizamos la imagen: indicando el objeto mapa (m) y el nombre del fichero de imagen a crear
mapnik.render_to_file(m,'world.png', 'png')
# Si queremos que los parámetros indicados en el objeto mapa sean serializados a un fichero
# mapfile (XML) sólo tenemos que añadir esta linea
mapnik.save_map(m,'mi_mapfile.xml')

Fíjate en la línea que hace referencia a la proyección a utilizar. ¿De donde saco estos parámetros? En esta página puedes encontrar los parámetros necesarios: http://spatialreference.org/ref/epsg/. Veamos algunos ejemplos:

EPSG 4326: +proj=latlong +datum=WGS84 (http://spatialreference.org/ref/epsg/4326/proj4/)
EPSG 900913: +proj=merc +lon_0=0 +k=1 +x_0=0 +y_0=0 +ellps=WGS84 +datum=WGS84 +units=m +no_defs (http://spatialreference.org/ref/sr-org/6627/proj4/)
EPSG 23030: +proj=utm +zone=30 +ellps=intl +units=m +no_defs (http://spatialreference.org/ref/epsg/23030/proj4/)

Para ejecutar este script sólo tienes que indicarle que es un ejecutable:


chmod +x hola_mundo.py

Y ahora lo ejecutamos:


python hola_mundo.py

Resultado:

: hola mundo con Mapnik

Mapfile de Mapnik
Como ves, con muy pocas líneas tenemos una imagen creada con Mapnik, pero, ¿porque no separamos la lógica de representación y los orígenes de datos en un fichero de mapa (mapfile)? Posiblemente este nos recuerda a más de uno los famosos “mapfile” de MapServer, y realmente bastante se parecen a ellos, pero esta vez la lógica está en un fichero XML. Manos a la obra. Primero generamos el script de Python sin referencia alguna a la simbología y los datasources:

#!/usr/bin/env python
import mapnik
mapfile = 'hola_mundo.xml'
map_output = 'hola_mundo.png'
m = mapnik.Map(600, 300)
mapnik.load_map(m, mapfile)
bbox = mapnik.Envelope(mapnik.Coord(-180.0, -90.0), mapnik.Coord(180.0, 90.0))
m.zoom_to_box(bbox)
mapnik.render_to_file(m, map_output)

Fíjate que en la tercera línea llamamos a un fichero de mapa. Se trata de un fichero XML con una estructura definida, donde se indican los datasources (layers) y su representación (styles y rules dentro de ella)




  <
  
    My Style
    
      shape

En resumen tenemos:
- Fondo de mapa
- Style –> Rule –> Simbología
- Layer –> Proyección –> DataSource –> Style

Estos dos ejemplos utilizan shapefile. Para indicar un datasource PostGIS hay que especificar estas líneas

a) En el caso del fichero Python sin XML

# proyección UTM ED-50 (España) --> EPSG 23030
lyr = mapnik.Layer('spain','+proj=utm +zone=30 +ellps=intl +units=m +no_defs')
lyr = mapnik.Layer('Layer de PostGIS')
lyr.datasource = mapnik.PostGIS(host='localhost',user='postgres',password='',dbname='hispania',table='provincias')
lyr.styles.append('Mi estilo')

b) En el caso de un XML este sería el contenido de la parte referente a la layer


    mi estilo
    
      postgis
      localhost
      postgres
      
      hispania
      provincias
      false
      -510000.0,3800000.0,1200000.0,4900000.0

El parámetro table (provincias) podemos sustituir el nombre de una tabla geométrica por una consulta SQL encerrada entre paréntesis:
(select * from provincias)

Resultado:

Enlazando con lo último, en el momento en que definimos en una “layer” un “datasource”, sea un shapefile o PostGIS, con su correspondiente “style”, tenemos a disposición de las “rules” todas las columnas o campos del datasource, que pueden ser utilizados como filtros, lo que resulta muy util para la edición de cartografía temática.
Fichero: mapa_spain_xml2.py

#!/usr/bin/env python
import mapnik
mapfile = 'provincias2.xml'
map_output = 'hola_spain_xml2.png'
m = mapnik.Map(600, 600)
mapnik.load_map(m, mapfile)
bbox = mapnik.Envelope(mapnik.Coord(-510000.0, 3800000.0), mapnik.Coord(1200000.0, 4900000.0))
m.zoom_to_box(bbox)
mapnik.render_to_file(m, map_output)

Ahora el fichero
Fichero provincias2.xml




  
  

    mi estilo provincias
    
      postgis
      localhost
      postgres
      
      hispania
      provincias
      false
      -510000.0,3800000.0,1200000.0,4900000.0
    


    mi estilo vias
    
      postgis
      localhost
      postgres
      
      hispania
      vias
      false
      -510000.0,3800000.0,1200000.0,4900000.0

Este mapfile consta de:
- 2 datasources
- provincias –> asociado al style “mi estilo provincias”
- vias –> asociado al style “mi estilo vias”
- 2 styles
- “mi estilo provincias” –> con una sola “rule”
- “mi estilo vias” –> con 2 “rules”
–> Autopistas: Filtro: “[level] = 40″, Texto: ver TextSymbolizer
–> Nacionales: [level] = 40

Resultado:

Este artículo es el primero de una serie formada por:

Renderizado con Mapnik (este post)
Mapnik y OpenStreetMap
Thumbnails con Mapnik y OpenStreetMap
Uso de TMS de OpenStreetMap con OpenLayers
TMS de OpenStreetMap con Mod_tile