En estos eventos es habitual el intercambio de tarjetas de presentación y como no teníamos una para darnos a conocer decidimos hacer una prueba en LaTeX, que no salió del todo mal. En este post compartimos esta primera versión para que la podáis personalizar o simplemente ver como se ha hecho.

Cara tarjeta G&C, generado con el fichero "G&C_businessCard_front.tex".

Características a considerar en el diseño

Hace mucho tiempo di un par de cursos para el diseño de marca. Ilustrator, Freehand y Photoshop para el diseño de tarjetas, trípticos, carteles, carátulas de cds, etc. Hay que reconocer que todo esto es una profesión en sí y hay muchos detalles por conocer. En tal caso, lo que hacemos nosotros aquí es un “apaño”, por lo que nadie espere grandes cosas

Las características más a tener en cuenta en el diseño son el tamaño de la tarjeta, el logo, el fondo y la gama de colores. Otra cuestión a tener en cuenta es la problemática vector-raster.

El tamaño de la tarjeta se puede determinar por una serie de estándares, supongo que según el tamaño de los billetes de cada país (la cartera donde guardamos las tarjetas también depende de esto). Nuestra tarjeta (90x45mm) no se ajusta a ninguno de estos estándares aunque la podríamos adaptar muy fácilmente. En http://en.wikipedia.org/wiki/Business_card encontramos los tamaños más utilizados.

El logo es el  que figura en el blog, diseñado por Miguel. No obstante, eliminamos el texto pues lo incluiremos entre los otros elementos de la tarjeta.

El fondo de la cara frontal es una nube de tags basada en la de esta página, después en Gimp le hemos añadido un degradado lineal de negro a blanco. El fondo del reverso es un mapa de http://www.openstreetmap.org/ que indica la ubicación de la sede. Para completar la ubicación se podría añadir la dirección en texto.

El nombre de la asociación, el lema y los datos de contacto (web y Email) aparecen en la cara frontal. El contraste blanco/negro es uno de los más recurridos y elegantes aunque esto dependerá del gusto de cada uno, además son los colores que aparecen en el blog.

Finalmente, la problemática raster-vector hace que no todos los programas sean igual de prácticos al combinar imágenes con texto en un marco tan pequeño. El texto podría verse mal al rasterizarse en Gimp o las imágenes verse mal por no estar bien escaladas al tamaño del papel. Para evitar problemas es recomendable preparar todos los componentes del diseño en un marco de 90x45mm. Además, conviene que el texto sea siempre vectorial.

Reverso de la tarjeta G&C, generado con el fichero "G&C_businessCard_back.tex".

¿Porqué LaTeX?

Seguramente, podríamos haber creado la tarjeta solamente con Gimp, Impress, Inkscape o cualquier otro software comercial… incluso en un editor de textos cualquiera. O con una máquina de escribir… No obstante, para crear la tarjeta hemos utilizado Gimp y LaTeX.

Básicamente, prefiero esta opción porqué es FOSS y estándar. No necesitamos conocer demasiados botones y LaTeX lleva una larga trayectoria de más de 20 años que hace pensar que la plantilla que creemos seguirá siendo funcional en el futuro. Además, ya utilizo LaTeX para hacer pósters, artículos, presentaciones, materiales docentes, el currículum y mi tesis. De este modo, la pregunta sería ¿porqué aprender otros programas?

Desgraciadamente, no puedo aquí hacer un tutorial de LaTeX para geógrafos pero, si necesitáis escribir un documento estructurado de grandes dimensiones (tesis) o muchos de otro tipo (informes) os animo a que le echéis un vistazo a este proyecto tan interesante pues a medio plazo os ahorrará muchos dolores de cabeza.

Como está hecha

Las plantillas que he encontrado en la web (buscando “Business card; LaTeX”) son más bien sosas con un estilo próximo al de la máquina de escribir y además son bastante complejas. Para evitar estos problemas hemos utilizado la clase “Beamer” de LaTeX, que permite entre otras cosas añadir una imagen de fondo y formatear el espacio de la tarjeta apropiadamente.

Primero, hemos utilizado Gimp para crear los fondos de la tarjeta como dos ficheros PNG. A continuación, LaTeX se ha utilizado para la composición, añadir textos y dibujos vectoriales (líneas). En el reverso de la tarjeta hemos añadido un mapa de http://www.openstreetmap.org/ para aportar una localización más detallada, aunque también se podría añadir la dirección postal.

La plantilla se compone de tres ficheros TeX, uno para cada cara de la tarjeta y, tras compilar las dos caras, el tercero para crear una composición de 12 tarjetas a dos caras.

Esta plantilla es altamente mejorable, es una versión 0.1 para salir del paso, pero os puede dar ideas. La idea de aprovechar OSM para la localización (idea de José) es interesante y evita tener que pensar en hacer un croquis como he visto en algunas tarjetas. Además, creo que los detalles de la tarjeta (la nube de tags como fondo, el mapa…) además de quedar bastante bien aportan información extra sobre nosotros si se saben leer.

Código en latex

Finalmente, os paso el código de los tres ficheros de LaTeX necesarios para crear esta tarjeta. Si leéis el código veréis donde podéis introducir vuestras propias imágenes de fondo o el logo que queráis. Espero que os sea de ayuda y os genere otras ideas.

G&C_businessCard_front.tex

% GIS&Chips nice business card
% By Benito M. Zaragozí
% Version 0.1 released 02/11/2011
% Further releases in: www.gisandchips.org
% This template is composed by three .tex files (businessCard.tex, businessCard_back.tex and businessCardx10.tex) for preparing a basic layout.

\documentclass{beamer}
\usepackage[utf8x]{inputenc}
\usepackage[spanish]{babel}
\usepackage{hyperref}
\usepackage[absolute,showboxes,verbose,overlay]{textpos}
\usepackage{geometry}
\geometry{paperwidth=90mm, paperheight=45mm, layoutwidth=90mm, layoutheight=45mm, left=0mm, top=0mm, right=0mm, bottom=0mm}

\usetheme{default}

\setbeamertemplate{navigation symbols}{}
\setbeamertemplate{background canvas}{\includegraphics[height=\paperheight]{background.png}}

\begin{document}

\frame{
\begin{columns}
	\begin{column}{35mm}
		\includegraphics[width=44mm]{gischips_logo.png}
	\end{column}

	\begin{column}{40mm}
		\color{white}{Asociación\\ \vspace{1mm} \huge{GIS \& Chips}}
		\normalsize
		\vspace{1mm}
		\line(1,0){80}
		\vspace{-1mm}
		\color{white}{Geografía útil para llevar}
	\end{column}
\end{columns}

\vspace{-1mm}
\normalsize
\color{black}{\hspace{5mm}\line(1,0){220}\\ \hspace{2mm} \url{www.gisandchips.org} \hspace{3mm} \url{info@gisandchips.org}}
}
\end{document}

G&C_businessCard_back.tex

% GIS&Chips nice business card
% By Benito M. Zaragozí
% Version 0.1 released 02/11/2011
% Further releases in: www.gisandchips.org
% This template is composed by three .tex files (businessCard.tex, businessCard_back.tex and businessCardx10.tex) for preparing a basic layout.

\documentclass{beamer}
\usepackage[utf8x]{inputenc}
\usepackage[spanish]{babel}
\usepackage{geometry}
\geometry{margin=2mm, paperwidth=90mm, paperheight=45mm}

\usetheme{default}
\setbeamertemplate{navigation symbols}{}
\setbeamertemplate{background canvas}{\hspace{2mm} \includegraphics[height=41.5mm]{mapbackground.png}}

\begin{document}
	\frame{
		\vspace{-1.5mm}
		\colorbox{white}{GIS\&Chips en la Universidad de Alicante}\\
		\vspace{31mm}
		\begin{flushright}
		\colorbox{white}{\tiny {\url{www.openstreetmap.org}}}
		\end{flushright}
	}
\end{document}

G&C_businessCard_x12.tex

% GIS&Chips nice business card
% By Benito M. Zaragozí
% Version 0.1 released 02/11/2011
% Further releases in: www.gisandchips.org
% This template is composed by three .tex files (businessCard.tex, businessCard_back.tex and businessCardx10.tex) for preparing a basic layout.

\documentclass[10pt,a4paper]{minimal}
\usepackage{graphicx}
\usepackage[margin=1cm]{geometry}

\begin{document}
\thispagestyle{empty}
\noindent

\begin{center}
\hspace{1mm}\includegraphics[scale=1]{businessCard.pdf} \includegraphics[scale=1]{businessCard.pdf} \vspace{1mm}

\hspace{1mm}\includegraphics[scale=1]{businessCard.pdf} \includegraphics[scale=1]{businessCard.pdf} \vspace{1mm}

\hspace{1mm}\includegraphics[scale=1]{businessCard.pdf} \includegraphics[scale=1]{businessCard.pdf} \vspace{1mm}

\hspace{1mm}\includegraphics[scale=1]{businessCard.pdf} \includegraphics[scale=1]{businessCard.pdf} \vspace{1mm}

\hspace{1mm}\includegraphics[scale=1]{businessCard.pdf} \includegraphics[scale=1]{businessCard.pdf} \vspace{1mm}

\hspace{1mm}\includegraphics[scale=1]{businessCard.pdf} \includegraphics[scale=1]{businessCard.pdf} \vspace{1mm}

\pagebreak
%%%%%%Back with map
\hspace{1mm}\includegraphics[scale=1]{businessCard_back.pdf} \includegraphics[scale=1]{businessCard_back.pdf} \vspace{1mm}

\hspace{1mm}\includegraphics[scale=1]{businessCard_back.pdf} \includegraphics[scale=1]{businessCard_back.pdf} \vspace{1mm}

\hspace{1mm}\includegraphics[scale=1]{businessCard_back.pdf} \includegraphics[scale=1]{businessCard_back.pdf} \vspace{1mm}

\hspace{1mm}\includegraphics[scale=1]{businessCard_back.pdf} \includegraphics[scale=1]{businessCard_back.pdf} \vspace{1mm}

\hspace{1mm}\includegraphics[scale=1]{businessCard_back.pdf} \includegraphics[scale=1]{businessCard_back.pdf} \vspace{1mm}

\hspace{1mm}\includegraphics[scale=1]{businessCard_back.pdf} \includegraphics[scale=1]{businessCard_back.pdf} \vspace{1mm}

\end{center}
\pagebreak
\end{document}

Ya aviso que, una vez que muestro todos los servicios en el mapa,  queda un mapa demasiado lleno de elementos, pero eso  es justo lo que pretendo con este visor, tener todos los elementos en el mismo mapa y que se visualicen tanto fotos, videos, artículos de la wikipedia,kml,… a la vez, permitiéndo incluso añadir muchos más elementos.

En primer lugar, para mostrar el mapa de Google Maps, necesito registrar la clave previamente para el sitio web en cuestion que voy a tratar.

Y una vez registrada la clave ya se puede realizar el visor,  la programación del visor sería la siguiente:

//Hojas de estilo de google maps
 <link rel="stylesheet" type="text/css" href="http://ajax.googleapis.com/ajax/libs/yui/2.7.0/build/reset-fonts-grids/reset-fonts-grids.css">
 <link rel="stylesheet" type="text/css" href="http://ajax.googleapis.com/ajax/libs/yui/2.7.0/build/base/base-min.css">
 <script type="text/javascript" src="http://maps.google.com/maps?file=api&amp;v=2&amp;key=clave_registrada_en_google"></script>

<script
type="text/javascript" charset="utf-8">
 google.load("maps", "2.x");

 function load()
 {
 if (!GBrowserIsCompatible())
 return;

 //definicion de variable de copyright del mapa
 var copyOSM = new GCopyrightCollection("GIS&Chips 2010");
 copyOSM.addCopyright(new GCopyright(1, new GLatLngBounds(new GLatLng(-90,-180), new GLatLng(90,180)), 0, " "));

 //definicion de las tiles de OpenStreetMap que iran por bajo del mapa
 var tilesMapnik     = new GTileLayer(copyOSM, 1, 17, {tileUrlTemplate: 'http://tile.openstreetmap.org/{Z}/{X}/{Y}.png'});
 var tilesOsmarender = new GTileLayer(copyOSM, 1, 17, {tileUrlTemplate: 'http://tah.openstreetmap.org/Tiles/tile/{Z}/{X}/{Y}.png'});
 var tilesCycle = new GTileLayer(copyOSM, 1, 17, {tileUrlTemplate: 'http://a.andy.sandbox.cloudmade.com/tiles/cycle/{Z}/{X}/{Y}.png'});

 var mapMapnik     = new GMapType([tilesMapnik],     G_NORMAL_MAP.getProjection(), "Mapnik");
 var mapOsmarender = new GMapType([tilesOsmarender], G_NORMAL_MAP.getProjection(), "Osmarend");
 var mapCycleMap = new GMapType([tilesCycle], G_NORMAL_MAP.getProjection(), "CycleMap");

 //definicion de mapa incluyendo los tres tiles de OpenStreetMap

 var map           = new GMap2(document.getElementById("map"), { mapTypes: [mapMapnik, mapOsmarender,mapCycleMap] });

 //se añaden los controles de mapa del API de Google Maps
 map.addControl(new GLargeMapControl()); //control de desplazamiento y acercamiento de gran tamaño empleado en  Google Maps.
 map.addControl(new GMapTypeControl());  //Permite alternar entre los diferentes tipos de mapas (en este caso las tres tiles)
 map.addControl(new GOverviewMapControl()); //Este control nos permite mostrar una ventana de vista rápida contraible

//Situado el centro, las coordenadas de la Universidad de Alicante
 map.setCenter( new GLatLng(38.38575, -0.51486), 16);

 map.enableScrollWheelZoom();
 map.enableContinuousZoom();

 //Se definen como GLayers los servicios georeferenciados que quiero incluir

 var wikipedia = new GLayer("org.wikipedia.es");
 var panoramio = new GLayer("com.panoramio.all");
 var youtube = new GLayer("com.youtube.all");
 var webcam = new GLayer("com.google.webcams");

 map.addOverlay(wikipedia);
 map.addOverlay(panoramio);
 map.addOverlay(youtube);
 map.addOverlay(webcam);

 //En este caso como los servicios son un xml se añaden como GGeoXML(tanto el api de flickr como cualquier KML que quiera incluir lo debo definir as�)
 var geoXmlFlickr;
 geoXmlFlickr = new GGeoXml("http://api.flickr.com/services/feeds/geo/?tags=universidad+alicante");
 map.addOverlay(geoXmlFlickr);

//Ejemplo de introducción de un KML
 var tram = new GGeoXml("http://www.sigua.ua.es/web/utils/acceso/kml/TRAM4.kml");
 map.addOverlay(tram);
 }

Aqui se puede ver como se muestra en el mapa el KML importado

 </script>

 </head>

 <body onload="load()" onunload="GUnload()">
 <div>
 <div role="main">
 <div>
 <div id="map" style="width: 100%; height: 600px;"></div>

 </div>
 </div>
 </div>

El visor completo con todos los datos estaría accesible desde la siguiente URL:
http://www.gisandchips.org/demos/pepe/osm/test.html

Como digo, este mapa incluye tantos elementos que a veces es un poco extraño, pero es justo lo que pretendía, incluir muchos servicios en un mismo mapa.

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:

1. Actualizar cada semana la base de datos con el último “planet osm”
2. Generar las imágenes de cada provincia (mediante un script en Python)
3. Colocarlas en el lugar adecuado de nuestro servidor web
4. 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/<user>/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/<tu_ruta>/

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 <ruta_directorio_volcado_bbdd_osm>
python ./<fichero python para generar miniaturas>
cp /home/mapnik/miniaturas /var/www/<tu_ruta>

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

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/<usuario>/mapnik/osm.xml

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

# carpeta de shapefiles
export MAPNIK_WORLD_BOUNDARIES_DIR=/home/<usuario>/mapnik/world_boundaries

# Carpeta donde se generarán las tiles
export MAPNIK_TILE_DIR=/home/<usuario>/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 <nombre>" 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:

     <Rule>
      <MaxScaleDenominator>100000</MaxScaleDenominator>
      <MinScaleDenominator>25000</MinScaleDenominator>
      <Filter>[railway]='station' and not [disused]='yes'</Filter>
      <PointSymbolizer file =  "%SYMBOLS_DIR%/station_small.png" type="png" width="6" height="6" />
    </Rule>

Por este otro

    <Rule>
      <MaxScaleDenominator>100000</MaxScaleDenominator>
      <MinScaleDenominator>25000</MinScaleDenominator>
      <Filter>[railway]='station' and not [disused]='yes'</Filter>
      <PointSymbolizer file =  "%SYMBOLS_DIR%/tram2.png" type="png" width="20" height="20" />
    </Rule>

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

    <Rule>
      <MaxScaleDenominator>1000000</MaxScaleDenominator>
      <MinScaleDenominator>1000</MinScaleDenominator>
      <Filter>[landuse] = 'residential'</Filter>
      <PolygonSymbolizer>
        <CssParameter name="fill">#F6CEE3</CssParameter>
      </PolygonSymbolizer>
    </Rule>

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:

1. Extensión de la imagen en grados decimales: xmin,ymin,xmax,ymax
2. Nivel de zoom: del 1 (mundo) al 18 (máximo de detalle)
3. 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

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:

1. Compilación de librerías necesarias (Mapnik y osm2pgsql)
2. Creación de una geodatabase con datos OSM utilizando Osm2Pgsql
3. Configuración de la plantilla de mapa (XML mapfile)
4. Pruebas de renderizado
5. Creación del TMS
6. 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:

<br>export EXPAT_INCLUDE=/usr/include<br>export EXPAT_LIBPATH=/usr/lib<br>

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<br>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/<usuario>/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<br>

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

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

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:

<br>chmod +x hola_mundo.py<br>

Y ahora lo ejecutamos:

<br>python hola_mundo.py<br>

Resultado:

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)

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE Map>
<Map bgcolor="steelblue" srs="+proj=latlong +datum=WGS84">
  <Style name="My Style">
    <Rule>
      <PolygonSymbolizer>
        <CssParameter name="fill">#f2eff9</CssParameter>
      </PolygonSymbolizer>
      <LineSymbolizer>
        <CssParameter name="stroke">rgb(50%,50%,50%)</CssParameter>
        <CssParameter name="stroke-width">0.1</CssParameter>
      </LineSymbolizer>
    </Rule>
  </Style><
  <Layer name="world" srs="+proj=latlong +datum=WGS84">
    <StyleName>My Style</StyleName>
    <Datasource>
      <Parameter name="type">shape</Parameter>
      <Parameter name="file"><ruta al shapefile, pero sin extensión .shp></Parameter>
    </Datasource>
  </Layer>
</Map>

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

<Layer name="provincias" status="on" srs="+proj=utm +zone=30 +ellps=intl +units=m +no_defs">
    <StyleName>mi estilo</StyleName>
    <Datasource>
      <Parameter name="type">postgis</Parameter>
      <Parameter name="host">localhost</Parameter>
      <Parameter name="user">postgres</Parameter>
      <Parameter name="password"></Parameter>
      <Parameter name="dbname">hispania</Parameter>
      <Parameter name="table">provincias</Parameter>
      <Parameter name="estimate_extent">false</Parameter>
      <Parameter name="extent">-510000.0,3800000.0,1200000.0,4900000.0</Parameter>
    </Datasource>
</Layer>

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

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE Map>
<Map bgcolor="steelblue" srs="+proj=utm +zone=30 +ellps=intl +units=m +no_defs">
  <Style name="mi estilo provincias">
    <Rule>
      <PolygonSymbolizer>
        <CssParameter name="fill">#f2eff9</CssParameter>
      </PolygonSymbolizer>
      <LineSymbolizer>
        <CssParameter name="stroke">rgb(50%,50%,50%)</CssParameter>
        <CssParameter name="stroke-width">0.1</CssParameter>
      </LineSymbolizer>
    </Rule>
  </Style>
  <Style name="mi estilo vias">
<!-- autopistas -->
    <Rule>
      <Filter>[level] = 41</Filter>
      <LineSymbolizer>
        <CssParameter name="stroke">#506077</CssParameter>
        <CssParameter name="stroke-width">4</CssParameter>
      </LineSymbolizer>
      <TextSymbolizer name="codigo" face_name="DejaVu Sans Book" size="11" fill="#000" halo_radius="1" spacing="400" placement="line" />
    </Rule>
<!-- nacionales -->
    <Rule>
      <Filter>[level] = 40</Filter>
      <LineSymbolizer>
        <CssParameter name="stroke">#a37b48</CssParameter>
        <CssParameter name="stroke-width">2</CssParameter>
       </LineSymbolizer>
    </Rule>
  </Style>
<Layer name="provincias" status="on" srs="+proj=utm +zone=30 +ellps=intl +units=m +no_defs">
    <StyleName>mi estilo provincias</StyleName>
    <Datasource>
      <Parameter name="type">postgis</Parameter>
      <Parameter name="host">localhost</Parameter>
      <Parameter name="user">postgres</Parameter>
      <Parameter name="password"></Parameter>
      <Parameter name="dbname">hispania</Parameter>
      <Parameter name="table">provincias</Parameter>
      <Parameter name="estimate_extent">false</Parameter>
      <Parameter name="extent">-510000.0,3800000.0,1200000.0,4900000.0</Parameter>
    </Datasource><br></Layer>
<Layer name="vias" status="on" srs="+proj=utm +zone=30 +ellps=intl +units=m +no_defs">
    <StyleName>mi estilo vias</StyleName>
    <Datasource>
      <Parameter name="type">postgis</Parameter>
      <Parameter name="host">localhost</Parameter>
      <Parameter name="user">postgres</Parameter>
      <Parameter name="password"></Parameter>
      <Parameter name="dbname">hispania</Parameter>
      <Parameter name="table">vias</Parameter>
      <Parameter name="estimate_extent">false</Parameter>
      <Parameter name="extent">-510000.0,3800000.0,1200000.0,4900000.0</Parameter>
    </Datasource>
</Layer>
</Map>

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

El objetivo de esta serie de artículos es proporcionar una metodología para crear servicios de enrutamiento (routing) en portales web utilizando datos de OpenStreetMap (http://www.openstreetmap.org) que serán añadidos a una geodatabase de PostgreSQL, con la extensión PostGIS y PgRouting.

Para llevar a cabo este servicio son necesarias las siguientes fases:

1. Instalación de las extensiones PostGIS y PgRouting
2. Importación de los datos de OSM
3. Conversión a una geodatabase de PostGIS en PostgreSQL
4. Explotación de una geodatabase con PgRouting.
5. Diseño de la interfaz de usuario. Contenedor HTML y Javascript (Openlayers)
6. Creación de lógica de enrutamiento en PHP

En la medida en que vaya finalizando los capítulos serán publicados en esta web. En este primer artículo se abordarán las tres primeras fases.

OBSERVACIONES:

Para la realización del presente documento me he basado en las referencias web de los portales de PgRouting (http://pgrouting.postlbs.org/) y OpenLayers (http://openlayers.org), así como en diferentes páginas encontradas en Internet. En la medida en que se utilice información de otra fuente será convenientemente citada, salvo olvido.

ÁMBITO DE APLICACIÓN

Todas las fases se han ensayado satisfactoriamente en los siguientes entornos: Ubuntu 9.04 y Centos 5.3. (clon de Red Hat Enterpise Linux). No obstante, las indicaciones y comandos utilizados en este artículo hacen referencia a este último sistema operativo.

Partimos de la base que tenemos un servidor Linux con el sistema operativo Centos 5.3 de 64 bits, con la base de datos PostgreSQL 8.3 ya instaladas. Por defecto, Centos dispone de PostgreSQL 8.1, si bien hemos preferido añadir los repositorios para la 8.3.7. Para información sobre la instalación ver este enlace: https://projects.commandprompt.com/public/pgcore

NOTA: La instalación de PostgreSQL desde este repositorio “oficial” de PostgreSQL no ha sido todo lo gratificante que esperaba. Hay problemas de dependencias con respecto a otras librerías del sistema Centos. Esto en cambio no ocurre con Ubuntu, que por defecto tiene en su paquetería las últimas versión de esta base de datos.

APLICACIONES UTILIZADAS

• PostgreSQL 8.3
• PostGIS 1.4
• OpenLayers 2.8
• PgRouting 1.03
• Osm2pgRouting
• Osmosis

INSTRUCCIONES Y RECOMENDACIONES GENERALES:

Las instrucciones para la instalación o compilación de programas se especifican mediante comandos de la consola Linux, sin tener que recurrir a ninguna herramienta gráfica. Esta forma de actuar puede ser útil para aquellos usuarios que disponen de acceso a un servidor remoto, donde sólo se tiene acceso mediante la consola.

Con el fin de facilitar las tareas conviene crear un directorio donde descargar, descomprimir y compilar las fuentes de los programas. Para ello, crea un directorio de compilación dentro del home del usuario

$ mkdir /home/<usuario>/compilar

$ cd /home/<usuario>/compilar


NOTA: El símbolo “$” es sólo el indicativo del prompt del sistema, no es necesario escribirlo.

Otra opción es crear un directorio de fuentes (por ejemplo “src” dentro de la carpeta “usr/local/”, y trabajar siempre como root. Yo particularmente prefiero la primera opción.

INSTALACIÓN DE POSTGIS

Aunque es posible utilizar la paquetería de PostGIS que aparece en el repositorio (yum info Postgis) he preferido compilar el paquete con el fin de tener la última versión estable de PostGIS

Sí no estás interesado en compilar PostGIS, puedes instalar el paquete oficial que viene con el repositorio de Postgres para Centos. Utiliza estos comandos

Y obtendrás esta información:

Luego, como superusuario:

Compilación de PostGIS 1.4

Por suerte, PostGIS es una extensión bastante utilizada, y por tanto su compilación está muy bien detallada en el portal de Reflaction Research (http://postgis.refractions.net/)

Esta extensión requiera para su compilación de dos librerías de las que depende (dependencias), por una parte PROJ y por otra GEOS. Ambas son bien conocidas y utilizadas en multitud de programas de SIG de código abierto. Ambas son opcionales, y no son necesarias para la compilación, pero sin ellas dejariamos a PostGIS huerfano de utilidades de reproyección y geoprocesamiento.

Instalación de la librería PROJ.4

PROJ.4 (http://trac.osgeo.org/proj/) es la librería más utilizada para las proyecciones cartográficas y permite, como no podía ser de otra manera realizar conversiones entre diferentes proyecciones cartográficas.

NOTA: En el blog de Geomaticblog.net hay un excelente post de como utlizar esta librería desde aplicaciones como GDAL/OGR o GvSIG. Particularmente, me ha resultado útil para transformar datos desde ED50 a WGS84. Enlace: http://geomaticblog.net/2009/01/23/2009-01-23-ogrs_y_rejillas_ntv2/

Pasos para la compilación:

1. Descargar la fuente

$ wget http://download.osgeo.org/proj/proj-4.7.0.tar.gz

2. Descomprimirla

$ tar xzvf proj-4.7.0.tar.gz

3. Cambio de directorio

$ cd proj-4.7.0

4. Configuración y puesta a punto. El siguiente comando prepara la compilación advirtiéndonos si falta algún que otro paquete

$ ./configure

NOTA: Es posible que en este paso aparezcan errores porque falta algún paquete. Tan sólo fíjate en que es lo que falta e instálalo (con “yum” o “apt” en el caso de Ubuntu). Habitualmente serán necesarias algunas herramienta propias de la compilación, como flex, bison, make, etc. En Ubuntu tienes un paquete específico para ello: “sudo apt-get install build-essential”.

5. Compilación

$ make

6. Colocar las librerias en su sitio como “root”

$ make install

Para “impersonarse” como superusuario sólo tienes que escribir: “su -”. En Ubuntu sólo tienes que anteceder la palabra “sudo” a cualquier comando que quieras ejecutar como root. En ambos casos te pedirá la clave de acceso del administrador del sistema.

7. Comprobación

$ proj

Obtendremos lo siguiente:

Instalación de GEOS (Geometry Engine Open Source)

GEOS (http://trac.osgeo.org/geos/) es una librería que proporciona a PostGIS la capacidad de realizar geoprocesamiento. Sin ella no podriamos realizar las típicas operaciones de unión, intersección, diferencia, buffer, etc, todas ellas correspondiente a la especificación SFA (Simple Feature Access) del OGC. GEOS es un porting de la librería JTS (Java Topology Suite) en el lenguaje C++, lo que le convierte en una máquina de geoprocesos bastante eficiente.

Pasos para la compilación

1. Descarga de la fuente

$ wget http://download.osgeo.org/geos/geos-3.1.1.tar.bz2

2.Descomprimir:

$ tar -xjvf geos-3.1.1.tar.bz2

3.Cambio de directorio

$ cd geos-3.1.1

4.Configuración

$ LDFLAGS=-lstdc++ ./configure

La directiva LDFLAGS tiene como objetivo enlazar expliciatamente PostgreSQL con el estándar C++

5. Compilar

$ make

El tiempo de compilación suele ser bastante largo (en torno a los 7-10 minutos)

6. Colocar librerías en su sitio (Como usuario root):

$ make install

7. Comprobación

$ geos-config –version

Devolverá:

3.1.1

Instalar PostGIS

Sí las dos librerías anteriores han sido instaladas correctamente deberás de tener los siguientes archivos en el directorio “/usr/local/lib”. Compruébalo:

Proceso de instalación:

1. Descarga de las fuentes:

$ wget http://postgis.refractions.net/download/postgis-1.4.0.tar.gz

2. Descomprimir:

$ tar xzvf postgis-1.4.0

3. Cambiar de directorio

$ cd postgis-1.4.0

4. Configurar

Es el paso que más atención debemos de prestar, puesto que al final del comando emitirá un informe con las dependencias satisfechas

$ ./configure

Sí todo va bien obtendremos un mensaje similar a este:

5.Compilación y colocación de las librerías

$ make

$ make install (como root)

Post-instalación de PostGIS

El siguiente paso es de vital importancia y nos puede ahorrar muchos problemas en el futuro. Por defecto las librerías se instalan en el directorio ya citado (”/usr/local/lib”), sin embargo, éste directorio no es reconocido por los programas de compilación como un directorio válido para instalar librerías, por lo que es necesario indicárselo de forma expresa. Para ello como root:

1. Edita el fichero “/etc/ld.so.conf” con tu editor preferido (vi, pico, nano, etc):

$ nano /etc/ld.so.conf

Y añade las siguientes líneas al final del documento

2. Finalmente ejecuta este comando

$ /sbin/ldconfig

INSTALACIÓN DE LA LIBRERÍA PgRouting

PgRouting (http://pgrouting.postlbs.org), al igual que PostGIS, es una extensión de PostgreSQL que permite trabajar con redes

A diferencia de PostGIS, aun no tenemos un paquete que instale PgRouting que satisfaga todas sus dependencias, por ello es necesario optar por la compilación de todas y cada una de las librerías utilizadas.

Librerías de las que depende:

• BOOST (http://www.boost.org ): Es la librería principal, y la única que es obligatoria. Se trata de un basto conjunto de utilidades, entre las que destacan las referidas al análisis y explotación de grafos.
• GAUL (Genetic Algorithm Utility Library): Esta librería sólo es necesario si deseamos dotar a PostgreSQL de la utilidad de cálculo del llamado “Problema del viajante”, conocida por sus signas en inglés, TSP (Traveling Salesman Problem), es decir, proporcionar la ruta óptima pasando por varios sitios. Enlace: http://gaul.sourceforge.net/
• CGAL (Computacional Geometric Algorithm Library): Librería especializada en el cálculo y procesamiento de estructuras geométricas en 2D y 3D. En el caso de PgRouting proporciona el algoritmo de cálculo conocido como Driving Distance.

NOTA: Adicionalmente compilaremos el compilador CMAKE

BOOST

Como ya se ha comentado se trata de una librería muy ambiciosa por la gran cantidad de utilidades que engloba, de ahí que se compilación sea muy pesada (en tiempo de compilación). En los repositorios, Centos dispone actualmente de la versión 1.33.1, bastante antigua, si pensamos que la última estable es la 1.4.0. No obstante, para este artículo utilizaré la 1.39.0 que es la que tenemos más ensayada.

Con todo, de esta líbrería sólo necesitamos las utilidades de grafos (graphs)

Para ver la versión de las fuentes boost del repositorio:

$ yum info boost-devel

Sí no queremos complicarnos la vida con la compilación añade el paquete con “yum”:

$ yum install boost-devel

En Ubuntu 9.04, la versión disponible es la 1.34, sería:

$ sudo apt-get install libboost-graph-dev

Compilación de las fuentes de boost 1.39

1. Descarga las fuentes:

wget http://sourceforge.net/projects/boost/files/boost/1.39.0/boost_1_39_0.tar.bz2/download

2. Descomprimir

$ tar –xjvf boost_1_39_0.tar.bz2

3. Cambiamos al usuario administrador

$ su -

4. Instalar dependencias:

$ yum install expat-devel

$ yum install python-devel

$ yum install freetype-devel

5. Cambio de directorio

$ cd /home/<usuario>/compilar/boost_1_39_0

6. Configuración

Para obtener ayuda sobre la configuración

$ ./bootstrap.sh –help

Configuración genérica: Instala todas las librerías en este directorio

$ ./bootstrap.sh –prefix=/usr/local/

Sí sólo necesitamos compilar la librería de cabezera (header library)

$ ./bootstrap.sh –prefix=/usr/local/ –with-libraries=graph

5. Compilar

$ ./bjam install

Es posible que tengas al inicio de la compilación algún mensaje relacionado con la librería EXPAT ques es utilizada por libGraph.  Para evitar este mensaje define estas variables:

$ export EXPAT_INCLUDE=/usr/include

$ export EXPAT_LIBPATH=/usr/lib

Y de nuevo ejecuta

$ ./bjam install

NOTA: Sí deseas compilar versiones anteriores, como la 1.36 y 1.37, la compilación es más sencilla. Usa los clásicos: ./configure, make, make install

GAUL

Instalación de Gaul (librería necesaria para el algoritmo TSP -Traveling Salesman Problem)

$ wget http://nfsi.dl.sourceforge.net/sourceforge/gaul/gaul-devel-0.1849-0.tar.gz

$ tar xzvf gaul-devel-0.1849-0.tar.gz

$ ./configure –disable-slang

Instalar CMAKE

Este compilador sólo se instalará para el usuario, y no estará disponible para todos (no hacer nunca “make install” como root)

$ wget http://www.cmake.org/files/v2.4/cmake-2.4.8.tar.gz

$ tar -zxvf cmake-2.4.8.tar.gz

$ cd cmake-2.4.8

$ ./configure

Como usuario (¡no como administrador¡)

$ gmake

CGAL

Librería necesaria para utilizar el algoritmo Driving Distance). La versión que vamos a compilar es la 3.3.1, aunque existe otra más moderna (3.4). Sin lugar a dudas es la libraría que más problemas ofrece.

$ wget ftp://ftp.mpi-sb.mpg.de/pub/outgoing/CGAL/CGAL-3.3.1.tar.gz

$ tar xzvf CGAL-3.3.1.tar.gz

$ cd CGAL-3.3.1

Compilar como root:

$ ./install_cgal –prefix=/usr/local –with-boost=n –without-autofind -ni /usr/bin/g++

Las librerías y los include se colocan en estos directorios:

/usr/local/lib/

/usr/local/include/

INSTALACIÓN DE LA LIBRERÍA PGROUTING

Una vez satisfechas todas las dependencias de librerías vamos a compilar PgRouting

1. Primero nos descargamos las fuentes desde el repositorio subversión. Recuerda que debes de tener instalada dicha utilidad (“yum install subversión”)

$ svn checkout http://pgrouting.postlbs.org/svn/pgrouting/trunk pgrouting

2. Nos cambiamos al directorio

$ cd pgrouting

3. Configuramos

Para ello utilizamos el compilador CMAKE que ya tenemos disponibles.

Compilar (no olvides el punto al final del comando)

La sintaxis de compilación es:

<ruta al ejecutable CMAKE) .

NOTA: No olvides el punto al final. Es para indicarle que compile el directorio actual

Con ello instalaremos la librería, pero apenas nos servirá de nada porque no hemos hecho referencia a que queremos los algoritmos “Driving Distance (DD)” y TSP.

Por ello cambia lo anterior por esto

# ../cmake-2.4.8/bin/cmake -DWITH_TSP=ON -DWITH_DD=ON .

Resultado del configure

4. Finalmente generamos la librería

# make

Resultado de la compilación

5. Por último colocamos los archivos en su sitio (como root):

$ make install

Resultados

Ya tenemos PgRouting disponible

OSM2PGROUTING

Descripción:

Se trata de una utilidad que permite convertir un fichero de OpenStreetMap, en formato OSM o XML, en una base de datos PostgreSQL que tenga instaladas las extensiones PostGIS y PgRouting.

Esta utilidad está específicamente diseñada para OSM, y realiza un especial tratamiento de los datos teniendo en cuenta los tags OSM, de forma tal que es capaz de generar un grafo adecuado para el ruteo. Bien es cierto que tenemos otras posibilidades, como descargar un shapefile de datos OSM de cualquiera de los servidores existentes (Geofabrik, CloudMade) y convertirlos a PostgreSQL con la utilidad “shp2pgsql” provista por PostGIS, sin embargo el resultado no será el mismo. Veamos un ejemplo

Fíjate en esta zona donde tenemos vías que aparecen a distinto nivel: http://www.openstreetmap.org/?lat=38.379259&lon=-0.452301&zoom=18&layers=B000FTF

Sí no utilizamos esta utilidad se generará un nodo por cada cruce de vías, independientemente de que si están o no a diferentes niveles. Osm2pgrouting entiende los tags de OSM y evita colocar nodos donde no le corresponde.

Nodos en OpenStreetMap. Las vías es azul contienen el tag bridge=yes, y por tanto están a diferente nivel

Compilar osm2pgrouting

$ svn checkout http://pgrouting.postlbs.org/svn/pgrouting/tools/osm2pgrouting/trunk osm2pgrouting

$ cd osm2pgrouting

$ make

Como administrador:

$ make install

CREAR UNA PLANTILLA DE GEODATABASE CON POSTGIS Y PGROUTING

Este es quizás el momento más excitante de todos, puesto que vamos a crear una base de datos con datos ya normalizados para ser explotado con las utilidades de PgRouting.

El proceso siempre es el mismo:

1. Crear la base de datos
2. Añadirle la funcionalidad de PostGIS
3. Añadirle la funcionalidad de PgRouting
4. Cargar datos desde OSM a la base de datos (osm2pgsql)
5. Crear topología
6. Explotar la base de datos

Creación de una plantilla de base de datos

Es una buena práctica tener creada una plantilla de base de datos con todas las extensiones ya incluidas para que podamos utilizarla en cualquier geodatabase que creemos.

Puesto que estamos intentando cargar datos desde OSM es conveniente utilizar una codificación de caracteres que albergue todas las posibilidades multilenguaje que se pueden dar (alfabetización árabe, cirílica, etc)

1. Sín más preámbulos creamos la base de datos

Sintaxis:

$ createdb –h <host> –U <user> -p <puerto> -E <código codificación <nombre base de datos>

En nuestro caso este es el resultado

$ createdb -U postgres -E UTF8 routing

1. PostGIS exige que la base de datos tenga cargado el lenguaje procedural Pl/PgSql. De hecho la gran mayoría de las funciones de PostGIS y PgRouting están en este lenguaje:

$ createlang -U postgres plpgsql <nombre base de datos>

$ createlang -U postgres plpgsql routing

1. Añadir la funcionalidad PostGIS

Ahora necesitamos saber donde ha instalado Postgis los ficheros SQL necesarios para crear la geodatabase. Recomendamos utilizar el comando find para encontrarlos

Para las versiones < 1.4

$ find /usr/ -name lwpostgis.sql

Para versiones >= 1.4

$ find /usr/ -name postgis.sql

/usr/share/lwpostgis.sql

Lo mismo para las referencias espacials

$ find /usr/ -name spatial_ref_sys.sql

/usr/share/spatial_ref_sys.sql

Ahora sólo queda cargar el fichero de funcionalidades en la base de datos:

Para la versión 1.3.x

$ psql -U postgres -f /usr/share/lwpostgis.sql routing

$ psql -U postgres -f /usr/share/spatial_ref_sys.sql routing

Para la version 1.4

$ psql -U postgres -f /usr/share/pgsql/contrib/postgis.sql routing

$ psql -U postgres -f /usr/share/pgsql/contrib/spatial_ref_sys.sql routing

1. Añadir la funcionalidad PgRouting

Más de lo mismo. Primero añadimos la funcionalidad básica:

$ psql -U postgres -f /usr/share/postlbs/routing_core.sql routing

$ psql -U postgres -f /usr/share/postlbs/routing_core_wrappers.sql routing

$ psql -U postgres -f /usr/share/postlbs/routing_topology.sql routing

1. Luego la funcionalidad para el algoritmo TSP (opcional)

$ psql -U postgres -f /usr/share/postlbs/routing_tsp.sql routing

$ psql -U postgres -f /usr/share/postlbs/routing_tsp_wrappers.sql routing

1. Por ultimo la funcionalidad para el algoritmo “Driving Distance”

$ psql -U postgres -f /usr/share/postlbs/routing_dd.sql routing

$ psql -U postgres -f /usr/share/postlbs/routing_dd_wrappers.sql routing

1. Vamos a comprobar que todo está bien.

Accedemos a la base de datos creada:

$ psql -U postgres routing

routing=# select postgis_full_version();

Devolverá:

1. Últimos retoques:

Con el objetivo de utilizar en el futuro OpenLayers, y con el fin de arbitrar un sistema de proyección que sea común para el uso de varios proveedores de datos (Google Maps, Yahoo Maps, Microsoft Live Maps, etc), vamos a incluir un nuevo registro en la tabla spatial_ref_sys, para añadir la denominada proyección esférica de Mercator, a veces conocida como “proyección Google”, por ser ésta la que se utiliza en en Google Maps. Lo interesante de esta proyección, a diferencia del sistema geodésico mundial con datum WGS84 es que las unidades están en metros, lo que facilita la compresión de los cálculos de distancias, en contraposición a la medición en grados decimales de arco de circunferencia. Más información aquí:

http://trac.openlayers.org/wiki/SphericalMercator

En este enlace tienes una imagen de gran formato de la tierra con esta proyección: http://designintelligences.files.wordpress.com/2009/03/mercator-projection1.jpg

En definitiva, sólo tenemos que añadir este registro:

La proyección esférica de Mercator tiene el código 900913, según el European Petroleum Survey Group (EPSG) mientras que OpenStreetMap utiliza como proyección global  predeterminada el geodésico mundial con datum WGS84, cuyo código es 4326.

Ya nos podemos salir de la consola de Postgresql

routing=# \q

1. Crear una geodatabase a partir de la plantilla creada

Bueno ya está hecho todo el trabajo de la plantilla, ahora el proceso de crear una nueva base de datos con todo ya preparado es sólo una línea;

createdb -U <usuario> -T <plantilla> <nueva bd>

En nuestro ejemplo sería

createdb -U postgres -T routing osmtest

Truco del día:

Sí tu servidor no tienes un sistema gráfico funcionando y necesitas llevar un fichero desde tu ordenador al servidor utiliza el comando “scp”. Es muy práctico

Sintaxis:

$ scp <fichero de tu ordenador>@<hostname o IP>:<directorio del servidor donde copiar el fichero>

Ejemplo:

$ scp OSM/alicante_30_09_2009.osm jose@www.gisandchips.org:/home/jose/compilar/osm2pgrouting

DESCARGAR DATOS DE OPENSTREETMAP

Esto ya va tomando color. Queda lo más bonito. ¡Paciencia!

Tenemos 2 opciones:

a)     Descargar un fichero OSM ya creado en cualquiera de los portales web que hay a tal efecto (Geofabrik (http://download.geofabrik.de/osm/) , CloudMade (http://downloads.cloudmade.com/) , etc)

Ejemplo:

Descargar OSM de España (69 Mb)

$ wget http://download.geofabrik.de/osm/europe/spain.osm.bz2

Descomprimir

$ tar -xjvf spain.osm.bz2

a)     Recortar una zona del planet.osm con Osmosis (http://wiki.openstreetmap.org/wiki/Osmosis)

$ wget http://dev.openstreetmap.org/~bretth/osmosis-build/osmosis-latest-bin.tar.gz

$ tar xzvf osmosis-latest-bin.tar.gz

$ cd osmosis-0.31/ bin/

La sintaxis básica es la siguiente:

$./osmosis –read-xml <fichero osm matriz> –bb left=<coord oeste> right<coord este> top=<coord norte> bottom=<coord sur> –write-xml <nombre fichero a crear extraido de matriz>

Por supuesto las coordenadas deben de estar en grados decimales del WGS84. Pero, ¿de dónde las saco?

Esta vez viene en nuestra ayuda el portal www.openstreetmap.org que viene con una utilidad (pestaña “Exportar”) para proporcionarnos información sobre la caja que estamos visualizando  en el mapa

Ejemplo práctico a un barrio de Alicante

$./osmosis –read-xml /home/jose/OSM/alicante_30_09_2009.osm –bb left=-0.4359 right=-0.42006 top=38.37225 bottom=38.36192 –write-xml mibarrio.osm

IMPORTAR UN OSM EN LA GEODATABASE

Después de este tortuoso camino, ya queda lo más fácil importar el OSM, utilizando “osm2pgrouting”. La sintaxis es la siguiente:

$ ./osm2pgrouting -file <fichero osm> -conf <fichero configuración>  -dbname <base de datos> -user <usuario>

Ló único extraño aquí es el fichero de configuración, que es un XML donde se incluyen las tipologías de la vías  que queremos cargar a la base de datos (según OSM: motorway, trunk, primary, secondary, tertiary, residential, etc.). En las fuentes aparece un XML de ejemplo que nos puede servir. Debemos de tener en cuenta que en función de nuestros objetivos utilizaremos unas vías u otras. Por ejemplo, sí sólo queremos las grandes vías nos quedaremos con motorway y trunks. Sí sólo nos interesa el tema caminos rurales y rutas ciclistas nos toca trabajar el XML.

Ejemplo:

./osm2pgrouting -file ./alicante_30_09_2009.osm -conf ./mapconfig.xml -dbname osmtest -user postgres

NOTA: Este proceso suele ser bastante largo, y estará en función del tamaño del OSM. Como ejemplo, el área metropolitana de Alicante tardó unos 5 minutos, en un ordenador bien dotado. Toda España nos llevaría unas cuantas horas.

Tras un periodo de tiempo verás este mensaje

Para comprobar que tablas se han creado:

Entramos en la base de datos

psql -U postgres osmtest

Listamos las tablas:

osmtest=# \d

La tabla que contiene la geometría es ways;

CREACIÓN DE TOPOLOGÍA DE RED

Si nos fijamos la tabla ways tiene vacíos los campos source y target, que son los identificadores de nodo. Es necesario crear topología. Para ello recurrimos a una función topológica de pgrouting: “assign_vertex_id”

Lo único que tenemos es un identificador de arco (gid)

Para el caso de datos procedentes de OSM, al estar los datos en grados decimales y la proyección en geodésica (4326) la tolerancia a aplicar es muy pequeña. 0.00001

SELECT assign_vertex_id(‘ways’, 0.00001, ‘the_geom’, ‘gid’);

Listado de tablas

Ahora la tabla ways está preparada para topología.

Con este extenso post queda por finalizada la primera parte sobre PgRouting con OpenStreetMap. Nos esperan dos nuevos artículos que espero sean de vuestro interés:

1. Explotación de una geodatabase con OpenStreetMap y PgRouting
2. Diseño de una interfaz web con OpenLayers para el análisis de redes.