He probado diferentes métodos (sin transformación, transformación EPSG) y el resultado es muy dispar. Sólo un de los métodos funciona bien, aquel cuya transformación utiliza la rejilla en formato NTv2 del IGN, que fue creado precisamente para la transformación de datos desde ED50.

ogr2ogr -s_srs "EPSG:23030" -t_srs epsg_destino destino origen

Este comando tampoco solucionaría los problemas para ED50, por lo que habría que retocar el comando de esta forma para que utilice la rejilla del IGN:

ogr2ogr -s_srs '+init=epsg:23030 +nadgrids=./peninsula.gsb +wktext' -t_srs epsg_destino origen destino

Coincidiréis conmigo que este comando con todas sus opciones no es muy intuitivo para recordar. Por esta razón he decidido utilizar un interfaz gráfico para el terminal (sí, no habéis oído mal) que permite lanzar los típicos formularios gráficos para rellenar los datos. En definitiva, no se hace nada más que encapsular dicho comando con cuadros de diálogo que se lanzan al X-windows. Hay algunas utilidades para ello: Xdialog (x-windows), dialog (para el terminal), kdialog (para KDE). Yo voy a utilizar uno llamado “Zenity”, que está en todas las distribuciones linux.
Finalmente he creado un script BASH que empotra las peticiones (selección del EPSG, de ficheros, alertas, comprobaciones, etc.) en diálogos hechos con Zenity.
Este es el codigo:

#!/bin/sh
zenity --info --text="OGR2OGR Dialog \n
Autor: José Manuel Mira \n
GISandCHIPS 2011 \n
Aplicación basada en OGR2OGR para convertir \n
shapefile proyectado en UTM con datum ED50 en huso 30 (EPSG:23030) a  \n
Geodésica mundial con datum WGS84 (epsg:4326) o \n
UTM ETRS89 (epsg:25830) utilizando GDAL. \n
NOTA: Esta utilidad necesita la rejilla del IGN \n
descargable en: \n

http://www.gisandchips.org/demos/j3m/ogr/peninsula.gsb"

# Comprobar que está instalado OGR2OGR
if which ogr2ogr > /dev/null; then
echo "GDAL está instalado"
else
echo "No está instalado GDAL" | zenity --error --text="No está instalado GDAL. Salir \n ¿Ubuntu? sudo apt-get install gdal-bin"
exit
fi
#Comprobamos que tienes la rejilla instalada en el directorio del script
if [ -f ./peninsula.gsb ]
then
  echo "OK, tienes la rejilla" | zenity --info --text="OK, tienes la rejilla"
else
  echo "Descargando rejilla ..."
  wget http://www.gisandchips.org/demos/j3m/ogr/peninsula.gsb 2>=1 | sed -u 's/.*\ \([0-9]\+%\)\ \+\([0-9.]\+\ [KMB\/s]\+\)$/\1\n# Downloading \2/' | zenity --progress --title="Descargando rejilla IGN ..."
fi

origen=$(zenity --file-selection --title="Selecciona un shapefile en proyección ED50")
case $? in
  0)
    echo "\"$origen\" selected.";;
  1)
    exit;;
   -1)
    exit;;
esac

# obtener extensión del fichero
ext=${origen#*.}
echo $ext
if [ $ext != 'shp' ]
then
   echo "No es un shapefile. Salir" | zenity --error --text="NO es un shapefile. Salir"
   exit
fi

destino=$(zenity --entry --text "Nombre del Shapefile de salida (sin .shp)?" --entry-text "destino"); echo $destino
if [ $? = 1 ]
then
 exit
else
 echo $?
fi

epsg=$(zenity  --list  --text "Selecciona la proyección de salida" --radiolist  --column "Sel" --column "EPSG" --column "Nombre" TRUE 4326 "Geodésica WGS84" FALSE 25830 "UTM ETS89 HUSO 30"  FALSE 25831 "UTM ETS89 HUSO 31"  FALSE 25829 "UTM ETS89 HUSO 29"); 

echo "ogr2ogr -s_srs '+init=epsg:23030 +nadgrids=./peninsula.gsb +wktext' -t_srs EPSG:"${epsg} ${destino}-${epsg}.shp $origen
ogr2ogr -s_srs '+init=epsg:23030 +nadgrids=./peninsula.gsb +wktext' -t_srs EPSG:${epsg} ${destino}-${epsg}.shp $origen
zenity --info --text "Shapefile ${destino}-${epsg}.shp creado satisfactoriamente"

Guardamos el script como conversor.sh, le damos permisos de ejecución y lo lanzamos con

sh ./conversor.sh

Estos son algunos de los diálogos que aparecen:




Sí, ya se lo que estáis pensando (tanto rollo para una sola línea de comando). Es cierto, pero resulta útil y sencillo para aquellos que no se quieren complicar la vida. Además, con ligeras modificaciones lo puedo hacer extensible a las islas, otros husos, escribir un log con comandos para reutilizarlos en el futuro en modo BATCH, etc)
He realizado algunas pruebas para comprobar la validez de los datos reproyectados utilizando coordenadas de vértices geodésicos y visualizadas sobre un fondo con el WMS del PNOA. El resultado salta a la vista: “lo ha cuadrado”

Sí deseas probar el script aquí tienes unas shapes de prueba (vértices geodésicos en 23030) de la Comunidad Valenciana)

Estos son los ingredientes para la receta:

• capas geográficas almacenadas en tablas PostgreSQL/PostGIS
• servicio de mapas WFS-T con GeoServer
• Diseño web con OpenLayers

Digitalizacion WFS-T

Tengo que reconocer que en un primer momento intenté realizar este juego con un servidor WFS-T poco conocido, pero muy ligero (funciona como CGI, al igual que MapServer), y trabaja con PostGIS, con lo que me las prometía felices, pero las pruebas fueron satisfactorias sólo mientras  modificase o crease geometría, pero en ningún momento pude subir o modificar atributos. Para los estudiosos este motor se llama TinyOWS . Seguro que más de uno lo habrá usado satisfactoriamente, con lo que se agradecerían comentarios de como hacerlo . Me gustaba porque la instalación era muy sencilla (colocar el ejecutable en el directorio donde se ejecutan los scripts CGI, generalmente en “cgi-bin”, sin necesidad de tener instaladas otras herramientas. En este enlace tienes un precioso ejemplo de esta implementación: http://dev4.mapgears.com/bdga/bdgaWFS-T.html

Ante este dilema opté por instalar GeoServer (versión 2.0.1) cuya experiencia está más que demostrada para tener servicios de mapa interoperables. Sí quieres ver las características de nuestro servicio consúltalas aquí

http://www.gisandchips.org:8080/geoserver/wfs?service=wfs&VERSION=1.1.1&REQUEST=GetCapabilities

De esta manera me propuse crear un servicio WFS-T sobre tres capas, cada una de una tipología distinta ( puntos, polígonos y líneas), almacenadas en sus correspondientes tablas de PostGIS:

• tabla “golf” para puntos de campos de golf. Ver características.
• tabla “municipios” para polígonos de términos municipales Ver características.
• tabla “vias” para línea de una red de carreteras Ver características.

Para ver su potencial desarrollé tres páginas web para cada uno de los tipos de digitalización

• demo 1: Digitalización de Campos de golf
• demo2: Digitalización de municipios
• demo 3: Digitalización de vías

NOTA: Puedes probar sin miedo cualquiera de estas demos. Los datos se vuelven a cargar cada día. No te desesperes si es un poco lento el servidor web. No da más de sí.

En cada una de las demos he querido incorporar una barra de iconos para hacer uso de las siguientes herramientas:

panel digitalización

• Consulta y edición de atributos
• Digitalización
• Mover elementos (o vértices en el caso de municipios y vías)
• Borrar elementos
• Guardar las transacciones
• Navegación en modo Pan-zoom

El código está implementado de tal forma que la digitalización forma parte de una sesión, y sólo se validan los cambios (transacción) cuando hacemos clic en el botón “salvar”. De esta forma tengo recogido todo el abanico de posibilidades de la digitalización.

OPENLAYERS
Este framework, de sobra conocido es el responsable de articular todos los flujos entre el cliente y la base de datos utilizando WFS-T servido por GeoServer. El código fuente de cada ejemplo lo puedes obtener del propio navegador, por lo que me centraré en desmenuzar las partes:

ESTILO HTML PARA MENÚS
Estilo para la barra de iconos

    <style>
        .customEditingToolbar {
            float: right;
            right: 0px;
            height: 30px;
            width: 220px;
        }
        .customEditingToolbar div {
            float: right;
            margin: 5px;
            width: 24px;
            height: 24px;
        }
        .olControlNavigationItemActive {
            background-image: url("../../js/OpenLayers-2.8/theme/default/img/editing_tool_bar.png");
            background-repeat: no-repeat;
            background-position: -103px -23px;
        }
        .olControlNavigationItemInactive {
            background-image: url("../../js/OpenLayers-2.8/theme/default/img/editing_tool_bar.png");
            background-repeat: no-repeat;
            background-position: -103px -0px;
        }
        .olControlDrawFeaturePointItemInactive {
            background-image: url("../../js/OpenLayers-2.8/theme/default/img/editing_tool_bar.png");
            background-repeat: no-repeat;
            background-position: -77px 0px;
        }
        .olControlDrawFeaturePointItemActive {
            background-image: url("../../js/OpenLayers-2.8/theme/default/img/editing_tool_bar.png");
            background-repeat: no-repeat;
            background-position: -77px -23px ;
        }
        .olControlModifyFeatureItemActive {
            background-image: url(../../js/OpenLayers-2.8/theme/default/img/move_feature_on.png);
            background-repeat: no-repeat;
            background-position: 0px 1px;
        }
        .olControlModifyFeatureItemInactive {
            background-image: url(../../js/OpenLayers-2.8/theme/default/img/move_feature_off.png);
            background-repeat: no-repeat;
            background-position: 0px 1px;
        }
        .olControlDeleteFeatureItemActive {
            background-image: url(../../js/OpenLayers-2.8/theme/default/img/remove_point_on.png);
            background-repeat: no-repeat;
            background-position: 0px 1px;
        }
        .olControlDeleteFeatureItemInactive {
            background-image: url(../../js/OpenLayers-2.8/theme/default/img/remove_point_off.png);
            background-repeat: no-repeat;
            background-position: 0px 1px;
        }
        .olControlSelectFeatureItemInactive {
            background-image: url("../../js/OpenLayers-2.8/theme/default/img/info_off.png");
            background-repeat: no-repeat;
            background-position: 0px 1px;
        }
        .olControlSelectFeatureItemActive {
            background-image: url("../../js/OpenLayers-2.8/theme/default/img/info_on.png");
            background-repeat: no-repeat;
            background-position: 0px 1px;
        }

    </style>

Aplico en el código de OpenLayers los estilos que tendrá la capa WFS que vamos a cargar

	    // Styles
            var styles = new OpenLayers.StyleMap({
                "default": new OpenLayers.Style(null, {
                    rules: [
                        new OpenLayers.Rule({
                            symbolizer: {
                                "Point": {
                                    pointRadius: 5,
                                    graphicName: "square",
                                    fillColor: "red",
                                    fillOpacity: 0.25,
                                    strokeWidth: 1,
                                    strokeOpacity: 1,
                                    strokeColor: "#333333"
                                }
                            }
                        })
                    ]
                }),
                "select": new OpenLayers.Style({
                    strokeColor: "#00ccff",
                    strokeWidth: 4
                }),
                "temporary": new OpenLayers.Style(null, {
                    rules: [
                        new OpenLayers.Rule({
                            symbolizer: {
                                "Point": {
                                    pointRadius: 5,
                                    graphicName: "square",
                                    fillColor: "white",
                                    fillOpacity: 0.25,
                                    strokeWidth: 1,
                                    strokeOpacity: 1,
                                    strokeColor: "#333333"
                                }

                            }
                        })
                    ]
                })
            });

En definitivo asigno un estilo para el elemento geométrico, y su comportamiento cuando es seleccionado, cuando está temporal (digitalización), o su valor por defecto.

CAPA WFS
Definimos una capa WFS con Strategy (para indicar que conjunto de datos deben de ser cargados -ej. todos los datos, por BBOX, en clusters, por página, por filtro-)

// Definimos una capa WFS con St
           var saveStrategy = new OpenLayers.Strategy.Save();

           wfs = new OpenLayers.Layer.Vector("golf", {
               //isBaseLayer:true,
               strategies: [new OpenLayers.Strategy.BBOX(), saveStrategy],
               projection: new OpenLayers.Projection("EPSG:23030"),
               styleMap: styles,
               protocol: new OpenLayers.Protocol.WFS({
                   version: "1.0.0",
                   srsName: "EPSG:23030",
                   url: "http://www.gisandchips.org:8080/geoserver/wfs",
                   featureType: "golf",
                   featureNS: "http://www.opengeospatial.net/cite",
                   geometryName: "geometria",
                   schema: "http://www.gisandchips.org:8080/geoserver/wfs?service=WFS&version=1.0.0&request=DescribeFeatureType&TypeName=cite:golf",
               })
            });
 // Añadimos la capa anterior y los WMS que queramos de fondo
            map.addLayers([tiled,wfs]);

RESALTADO DE ELEMENTOS

El siguiente código controla el resaltado de los elementos cuando se lanzan eventos del ratón (mouseover, selección)

		/* HIGHLIGHT */

	    // inicio highlight mouseover
            var report = function(e) {
                OpenLayers.Console.log(e.type, e.feature.id);
            };

            var highlightCtrl = new OpenLayers.Control.SelectFeature(wfs, {
                hover: true,
                highlightOnly: true,
                renderIntent: "temporary",
                eventListeners: {
                    beforefeaturehighlighted: report,
                    featurehighlighted: report,
                    featureunhighlighted: report
                }
            });

            var selectCtrl = new OpenLayers.Control.SelectFeature(wfs,
                {clickout: true}
            );

            map.addControl(highlightCtrl);
            map.addControl(selectCtrl);

            highlightCtrl.activate();
            selectCtrl.activate();

	    /* END HIGHLIGHT */

SNAP O TOLERANCIAS DE CAZADO Y SPLIT (CORTES)

En ocasiones puede ser útil que la digitalización no sea a mano alzada (donde hagamos clic con el ratón), sino que tenga establecidas tolerancias de cazado para que cuando nos acerquemos a una línea o un polígono pueda pillar el nodo, vértice o eje. En este enlace verás un ejemplo más completo de este tema.
En el caso del Split sólo tiene sentido cuando los elementos son polígonos o líneas. Esto nos permite por ejemplo crear una ruta (R1) desde cualquier punto de otra ruta existente (R2), y mientras con el snapping obtenemos la sujección al vértice o eje, la ruta ya existente (R2) se parte en dos partes.

		/* SNAPPING */
            // Configuración del Snapping
            var snap = new OpenLayers.Control.Snapping({layer: wfs});
            map.addControl(snap);
            snap.activate();

            // Configuración del Split
            var split = new OpenLayers.Control.Split({
                layer: wfs,
                source: wfs,
                tolerance: 1000,
                deferDelete: true,
                eventListeners: {
                    aftersplit: function(event) {
                        var msg = "Split resulted in " + event.features.length + " features.";
                        flashFeatures(event.features);
                    }
                }
            });
            map.addControl(split);
            split.activate();

PANEL Y CONTROLES

Como ya hemos comentado es preferible tener los iconos a mano en el mapa en vez de los típicos radio button, ya que resultan más elegantes.

/* PANEL */
// crear un panel y añadirle iconos con funcionalidad
var panel = new OpenLayers.Control.Panel(
    {displayClass: 'customEditingToolbar'}
);

// Control para digitalizar puntos (draw)
var draw = new OpenLayers.Control.DrawFeature(
    wfs, OpenLayers.Handler.Point,
    {
        title: "Draw Feature",
        displayClass: "olControlDrawFeaturePoint",
        handlerOptions: {freehand: false, multi: false},
        // Muy importante: Si la capa postGIS es POINT poner multi:false.
        // Si es MULTIPOINT poner multi:true
        featureAdded: onFeatureInsert,
        //onFeatureInsert es el método que se ejecuta una vez que hemos terminado de digitalizar
    }
);

/*
En el caso de digitalizar polígonos este sería el código
            var draw = new OpenLayers.Control.DrawFeature(
                wfs, OpenLayers.Handler.Polygon,
                {
                    title: "Draw Feature",
                    displayClass: "olControlDrawFeaturePolygon",
                    handlerOptions: {multi: true},
                    featureAdded: onFeatureInsert,
                }
            );
*/

// Control para modificar elementos. En el caso de puntos sólo se pueden desplazar
// a otra posición
modify = new OpenLayers.Control.ModifyFeature(
    wfs, {displayClass: "olControlModifyFeature", title: "Modify Feature"}
);

// Control para borrar elementos
var del = new DeleteFeature(wfs, {title: "Delete Feature"});

// Control para salvar la sesión de digitalización
var save = new OpenLayers.Control.Button({
    title: "Save Changes",
    trigger: function() {
        if(modify.feature) {
            modify.selectControl.unselectAll();
        }
        saveStrategy.save();
    },
    displayClass: "olControlSaveFeatures"
});

/*
Control de Información. Es el típico control que una vez que seleccionas un elementos obtenemos los atributos, en este caso englobado en un popUp. Aquí hemos pensado reutilizar este formulario para actualizar datos de cada elemento (UPDATE de atributos).
*/
 selectControl = new OpenLayers.Control.SelectFeature(wfs,
 {
   onSelect: onFeatureInsert,
   onUnselect: onFeatureUnselect,
   displayClass: "olControlSelectFeature",
   title: "Info",
});

// Añadimos los controles al panel
panel.addControls([
    new OpenLayers.Control.Navigation({title: "Pan and zoom"}),
    save, del, modify, draw, selectControl
]);

// Definimos el control de navegación como el activo por defecto
panel.defaultControl = panel.controls[0];
map.addControl(panel);

FUNCIONES DE CADA CONTROL
Borrar elementos

 var DeleteFeature = OpenLayers.Class(OpenLayers.Control, {
      initialize: function(layer, options) {
          OpenLayers.Control.prototype.initialize.apply(this, [options]);
          this.layer = layer;
          this.handler = new OpenLayers.Handler.Feature(
              this, layer, {click: this.clickFeature}
          );
      },
      clickFeature: function(feature) {
          // sí no tiene fid eliminarlo
          if(feature.fid == undefined) {
              this.layer.destroyFeatures([feature]);
          } else {
              feature.state = OpenLayers.State.DELETE;
              this.layer.events.triggerEvent("afterfeaturemodified",
                                             {feature: feature});
              feature.renderIntent = "select";
              this.layer.drawFeature(feature);
          }
      },
      setMap: function(map) {
          this.handler.setMap(map);
          OpenLayers.Control.prototype.setMap.apply(this, arguments);
      },
      CLASS_NAME: "OpenLayers.Control.DeleteFeature"
  });

Información de los elementos, actualización de atributos e inserción de nuevos elementos (geometría + atributos):

// Funciones para cerrar el popUp
  function onPopupClose(evt) {
      selectControl.unselect(selectedFeature);
  }

// Función para cuando se quita la selección
 function onFeatureUnselect(feature) {
      map.removePopup(feature.popup);
      feature.popup.destroy();
      feature.popup = null;
  }

Función para insertar un nuevo elemento o actualizar atributos en uno ya existente

// PopUp para insert/update
  function onFeatureInsert(feature)
  {
  		selectedFeature = feature;
                // mapeo de los atributos
		var fid = selectedFeature.id;
     	        var nombre = selectedFeature.attributes['nombre'];
     	        var municipio = selectedFeature.attributes['municipio'];
		var codive = selectedFeature.attributes['codive'];
		var hoyos = selectedFeature.attributes['hoyos'];
                // Compruebo si existe un valor para el atributo nombre.
                // Sí no tiene atributos es un "INSERT" y muestro el formulario para cumplimentar
		if (nombre == null)
		{
 			// formulario
	            htmlForm = "<div style='font-size:.8em'>"+
	            "<H2><b>A&Ntilde;ADIR CAMPO DE GOLF</b></h2>\n" +
	            "FID: "+ fid + "<br/>\n" +
	            "<input type='hidden' name='fid' id='fid' value='"+ fid +"'>" +
	            //"GEOMETRIA: "+ feature.geometry + "<br/>\n" +
	            "UBICACION: "+ feature.geometry + "<br/>\n" +
	            "Rellene los siguientes datos: <br/> \n" +
	            "NOMBRE:<input type='text' name='nombre' id='nombre' value='Test Campo de Golf' size=20 style='background-color: #E6E6FA; color: #7F7F7F; font-style: italic;' > <br/>\n" +
	            "HOYOS:<input type='text' name='hoyos' id='hoyos' value='18' size=2 style='background-color: #E6E6FA; color: #7F7F7F; font-style: italic;' > <br/>\n" +
	            "MUNICIPIO:<input type='text' name='municipio' id='municipio' value='Test Municipio' size=20 style='background-color: #E6E6FA; color: #7F7F7F; font-style: italic;' > <br/>\n" +
		    "IVE:<input type='text' name='codive' id='codive' value='12345' size=5 style='background-color: #E6E6FA; color: #7F7F7F; font-style: italic;' > <br/>\n" +
	            "<button onclick='onTriggerInsertar()'>A&ntilde;adir</button>" +
	            "<button onclick='onTriggerDelNewPoint()'>Eliminar</button></div>";
             }
/* Sí nombre tiene valor ofrezco los atributos en el formulario para modificarlos, añadiendo al popUp
    un botón para "Actualizar" el registro.
*/
                 else
            {
	         htmlForm = "<div style='font-size:.8em'>"+
	         "<H2><b>ACTUALIZAR CAMPO DE GOLF</b></h2>\n" +
	         "FID: "+ fid + "<br/>\n" +
	         "<input type='hidden' name='fid' id='fid' value='"+ fid +"'>" +
	         "Rellene los siguientes datos: <br/> \n" +
	         "NOMBRE:<input type='text' name='nombre' id='nombre' value='"+ nombre + "' size=20 style='background-color: #E6E6FA;color: #7F7F7F; font-style: italic;' > <br/>\n" +
	         "HOYOS:<input type='text' name='hoyos' id='hoyos' value='" + hoyos + "' size=2 style='background-color: #E6E6FA; color:#7F7F7F; font-style: italic;' > <br/>\n" +
	         "MUNICIPIO:<input type='text' name='municipio' id='municipio' value='" + municipio +"' size=20 style='background-color:#E6E6FA; color: #7F7F7F; font-style: italic;' > <br/>\n" +
		 "IVE:<input type='text' name='codive' id='codive' value='" + codive +"' size=5 style='background-color:#E6E6FA; color: #7F7F7F; font-style: italic;' > <br/>\n" +
	         "<button onclick='onTriggerUpdate()'>Actualizar</button></div>";
      }
// Defino el objeto popUp
      popup = new OpenLayers.Popup.FramedCloud("info",
    		feature.geometry.getBounds().getCenterLonLat(),
         null,
         htmlForm,
         null,
         true,
         onPopupClose);

      feature.popup = popup;
      map.addPopup(popup);

  }

   // Trigger y función para pasar atributos del formulario
	var btnInsert = new OpenLayers.Control.Button({trigger: onTriggerInsertar});

	function onTriggerInsertar(fid)
	// se le pasa el fid como parametro para seleccionarlo mediante getFeatureById
	{
      //alert("has llegado a trigger insertar");
      var fid =  OpenLayers.Util.getElement('fid').value;// recojo el fid del formulario
      var miFeature = wfs.getFeatureById(fid);// hago la selección de la feature a partir del fid del form
      //alert(miFeature.id);
      // Paso atributos del formulario al elemento
		miFeature.attributes.nombre = OpenLayers.Util.getElement('nombre').value;
		miFeature.attributes.municipio = OpenLayers.Util.getElement('municipio').value;
		miFeature.attributes.hoyos = OpenLayers.Util.getElement('hoyos').value;
		miFeature.attributes.codive = OpenLayers.Util.getElement('codive').value;
		// elimina el popup
		onFeatureUnselect(miFeature);
	}
	// fin trigger insert

   // Trigger y función para pasar atributos del formulario en el update
	var btnUpdate = new OpenLayers.Control.Button({trigger: onTriggerUpdate});

	function onTriggerUpdate()
	{
      // defino miFeature como el array de elementos seleccionados, miFeature[0] será el único elemento del array
      miFeature = [selectedFeature]; //alert(miFeature.length);
      // Paso atributos del formulario al elemento
                var fid =  OpenLayers.Util.getElement('fid').value;
                miFeature[0].id = fid;
		miFeature[0].attributes.nombre = OpenLayers.Util.getElement('nombre').value;
		miFeature[0].attributes.municipio = OpenLayers.Util.getElement('municipio').value;
		miFeature[0].attributes.hoyos = OpenLayers.Util.getElement('hoyos').value;
		miFeature[0].attributes.codive = OpenLayers.Util.getElement('codive').value;
		// comprobar que se le pasan los atributos al feature. Descomentar para comprobación
		/*alert (  miFeature[0].id + "," +
				   miFeature[0].attributes.nombre + "," +
					miFeature[0].attributes.municipio  + "," +
					miFeature[0].attributes.hoyos  + "," +
					miFeature[0].attributes.codive );
               */

		miFeature[0].state = OpenLayers.State.UPDATE;
		// elimina el popup
		map.removePopup(miFeature[0].popup);
                selectControl.unselectAll();
                miFeature[0].popup = null;
	}
	// fin trigger

Faltan algunos elementos más, pero en esencia aquí está la lógica de la digitalización. Observa cada caso, puntos, polígonos y líneas para ver las diferencias existentes.

CONCLUSIÓN:
Quizás lo más relevante de este tema es que con un sólo fichero HTML hemos abordado la complejidad de la digitalización, utilizando siempre servicios y tecnologías estándar y abiertas. Con este tipo de soluciones tan sencillas podemos acercar a un número mayor de usuarios, menos especializados quizás, pero que de otra forma se hubieran visto imposibilitados de actuar por razones técnicas, económicas o de formación.

Openlayers con Panoramio

A la hora de “copiar” el ejemplo descrito en dicho post para OpenLayer, no he planteado integrar todos los geoservicios, entre otras cosas porque algunos de ellos forman parte de la API casi desde su inicio, y no supone un gran esfuerzo incorporarlo, salvo el de YouTube, que no tuve tiempo de ver, aunque tampoco creo que haya muchos videos geoposicionados. Ejemplos de integración de KML en OL hay muchos en la red, al igual que de GML, GeoJSON o GeoRSS, y también de Flickr, que en el fondo es acceder a un documento XML. Para más información consultas los ejemplos on-line del portal Openlayers.org

De todos los geoservicios, al que más atención ha prestado ha sido al de Panoramio, entre otras cosas por la ingente cantidad de fotografías georreferenciadas que integra, lo que lo hace muy atractivo para el webmaster. Como muchos sabéis este portal dispone de un servicio REST público que nos permite ejecutar una URL con ciertos parámetros, que finalmente nos devuelve un documento estructurado en formato JSON

{
"count": 110,
"photos": [
{
"upload_date": "20 May 2007",
"owner_name": "Carlos Sieiro del Nido",
"photo_id": 2313090,
"longitude": -0.516679,
"height": 75,
"width": 100,
"photo_title": "UNIVERSIDAD DE ALICANTE-Campus de San Vicente del Raspeig.",
"latitude": 38.386611000000002,
"owner_url": "http://www.panoramio.com/user/134716",
"owner_id": 134716,
"photo_file_url": "http://mw2.google.com/mw-panoramio/photos/thumbnail/2313090.jpg",
"photo_url": "http://www.panoramio.com/photo/2313090"
},
{
"upload_date": "16 January 2007",
"owner_name": "\u00a9 www.fotoseb.es - Sebastien Pigneur Jans",
"photo_id": 453228,
"longitude": -0.51438300000000003,
"height": 66,
"width": 100,
"photo_title": "Foto Aerea Universidad Alicante 2 (Foto_Seb)",
"latitude": 38.381700000000002,
"owner_url": "http://www.panoramio.com/user/55833",
"owner_id": 55833,
"photo_file_url": "http://mw2.google.com/mw-panoramio/photos/thumbnail/453228.jpg",
"photo_url": "http://www.panoramio.com/photo/453228"
}]

}

Como podéis ver por cada foto disponemos de un array con los datos que nos interesan, y de forma particular los siguientes:

• owner_name: autor
• photo_title: título
• latitude y longitude: coordenadas geográficas de geoposicionamiento en datum WGS 84
• photo_id: identificador de foto
• photo_file_url: URL de la imagen
• photo_url: URL del recurso en la web de Panoramio

Integrar Panoramio en OpenLayers no resulta tan elegante como en GM, donde sólo hay que escribir 2 líneas, pero con un poco de esfuerzo y el apoyo de la comunidad seguro que alguien es capaz de escribir una clase derivada de JSON que facilite las cosas. Por ahora me limitaré a desmenuzar el código de forma secuencial para que se entienda el proceso

Lo primero que debemos de hacer es preparar nuestro proxy para que admita peticiones al host de Panoramio. En este enlace explica como hacerlo

OpenLayers.ProxyHost= "/cgi-bin/proxy.cgi?url=";

Posteriormente creamos un par de variables con la URL del servicio REST y los parámetros

url = "http://www.panoramio.com/map/get_panoramas.php";
parametros = {
   order:'popularity',
   set:'full',
   from:0,
   to:20,
   minx: minx,
   miny: miny,
   maxx: maxx,
   maxy: maxy,
   size:'thumbnail'
}

Consulta la documentación de la API de Panoramio para más información. Por ahora los parámetros que más nos interesan son:

• “to”: indica el nº de fotografías que queremos cargar. Máximo 50
• “minx”,”miny”,”maxx”,”maxy”: coordenadas de la BBOX donde buscará fotos. Debén de estar en coordenadas geográficas (EPSG: 4326). En mi caso los he obtenido utilizando este código:

// Obtener extensiones.
ext = map.getExtent();
var minx = ext.left;
var miny = ext.bottom;
var maxx = ext.right;
var maxy = ext.top; //alert (minx + " " + miny + " " + maxx + " " + maxy);

Por último sólo nos queda invocar a un HttpRequest de AJAX que ejecute la URL con los parámetros y los envíe a nuestra función: mostrarfotos

OpenLayers.loadURL(url, parametros, this, mostrarfotos);

Función mostrarfotos
Es la encargada de procesar el documento JSON que recibe como argumento

function mostrarfotos(response) {

El documento JSON, que todavía es una cadena de texto es parseada con OpenLayers.Format.JSON, que la convierte en un objeto que ya podemos tratar:

var json = new OpenLayers.Format.JSON();
var panoramio = json.read(response.responseText);

Creamos un array de featutes con el total de fotos (panoramio.photos.length)

var features = new Array(panoramio.photos.length);

Aplicamos un bucle “for” para recorrer cada fotografía.

for (var i = 0; i < panoramio.photos.length; i++)
{

Declaramos y almacenamos cada dato de la foto en una variable para recorrerla con comodidad.

var upload_date = panoramio.photos[i].upload_date;
var owner_name = panoramio.photos[i].owner_name;
var photo_id = panoramio.photos[i].photo_id;
var longitude =panoramio.photos[i].longitude;
var latitude = panoramio.photos[i].latitude;
var pheight = panoramio.photos[i].height;
var pwidth = panoramio.photos[i].width;
var photo_title = panoramio.photos[i].photo_title;/
var owner_url = panoramio.photos[i].owner_url;
var owner_id = panoramio.photos[i].owner_id;
var photo_file_url = panoramio.photos[i].photo_file_url;
var photo_url = panoramio.photos[i].photo_url;

Opcionalmente podemos recoger todas las fotografías en código HTML para ser ubicadas en el BODY con un DIV, en forma de “galería de fotos”

OpenLayers.Util.getElement('galeria').innerHTML +=
     "<a href='"+ photo_url +
     "'><img src='"+photo_file_url+"' title='"+
     photo_title +"' /></a>&nbsp;";

Posteriormente en el BODY para representar esta galería sólo hay que escribir:

<div id="galeria"></div>

Creamos un objeto point con las coordenadas de la foto

var fpoint = new OpenLayers.Geometry.Point(longitude,latitude);

Creo un array de atributos

var atributos = {
   'upload_date' : upload_date,
   'owner_name':owner_name,
   'photo_id':photo_id,
   'longitude':longitude,
   'latitude':latitude,
   'pheight':pheight,
   'pwidth':pwidth,
   'pheight':pheight,
   'photo_title':photo_title,
   'owner_url':owner_url,
   'owner_id':owner_id,
   'photo_file_url':photo_file_url,
   'photo_url':photo_url
}

Por cada foto creo un elemento (feature) que contiene su posición y sus atributos

features[i] = new OpenLayers.Feature.Vector(fpoint,atributos);

Terminamos el bucle

}

Fuera del bucle, todavía en la función mostrar foto nos queda:

Definir el estilo para representar la foto. Tenemos dos opciones
a) Crear un icono único para cada fotografía

// estilo punto
var panoramio_style1 = new OpenLayers.StyleMap(OpenLayers.Util.applyDefaults({
   pointRadius: 15,
   fillColor: "red",
   fillOpacity: 1,
   strokeColor: "black",
   externalGraphic: "${photo_file_url}"
}, OpenLayers.Feature.Vector.style["default"]));

b) Por cada posición añadimos una miniatura de la foto.

var panoramio_style2 = new OpenLayers.StyleMap(OpenLayers.Util.applyDefaults({
   pointRadius: 7,
   fillColor: "red",
   fillOpacity: 1,
   strokeColor: "black",
   externalGraphic: "panoramio-marker.png"
}, OpenLayers.Feature.Vector.style["default"]));

Imagen: Ejemplos de estilos

Estilos para Panoramio

Ahora creamos la vector layer asignándole el estilo escogido

var vectorPano = new OpenLayers.Layer.Vector("Panoramio fotos", {
   styleMap: panoramio_style2
});

Añadimos los elementos:

vectorPano.addFeatures(features);

Añadimos la layer al mapa

map.addLayer(vectorPano);

Definimos para terminar la función el comportamiento del evento que se desencadenará cuando seleccionemos ( click con el ratón) cada fotografía

selectControl = new OpenLayers.Control.SelectFeature(vectorPano,
   {onSelect: onFeatureSelect, onUnselect: onFeatureUnselect});
map.addControl(selectControl);
selectControl.activate();
}

Como ves, se ejecutará la función “onFeatureSelect” cada vez que se selecciona un feature, y “onFeatureUnselect” cuando no hay nada seleccionado.

Con este código tenemos toda la lógica para obtener un vector layer con su posición y atributos. Ahora sólo nos queda definir el comportamiento de los eventos. En este caso vamos a crear un “popup” por cada elemento.

// popups
function onPopupClose(evt) {
   selectControl.unselect(selectedFeature);
}
function onFeatureSelect(feature) {
   selectedFeature = feature;

   // HTML del PopUp
      mensaje = "<a href='http://www.panoramio.com'><img src='./panoramio_header-logo.png' alt='Panoramio' width='146' height='27' /></a><br>"+
	      "<h2>"+ feature.attributes.photo_title + "</h2><p>" +
	      "<a href='"+ feature.attributes.photo_url+
		  "'><img src='http://mw2.google.com/mw-panoramio/photos/small/" +
		  feature.attributes.photo_id + ".jpg' border='0' alt=''></a><br>" +
	      "autor: <a href='"+ feature.attributes.owner_url+"'>"+feature.attributes.owner_name +"</a>";

   popup = new OpenLayers.Popup.FramedCloud("chicken",
      feature.geometry.getBounds().getCenterLonLat(),
      null,
      mensaje,
      null, true, onPopupClose);
   feature.popup = popup;
   map.addPopup(popup);
}
function onFeatureUnselect(feature) {
   map.removePopup(feature.popup);
   feature.popup.destroy();
   feature.popup = null;
}

Ya lo tenemos todo listo. Sólo nos queda verlo en un navegador. ¿A que esperas?

Ver demo en proyección Mercator con fondo de OpenStreetMap
Ver demo en WGS84

Nota de interés:

Por último nos gustaría hacer una consideración de especial relevancia. Este código tiene sentido cuando todas las layers (WMS y vector layer de Panoramio) se encuentran en la misma proyección, en este caso se utiliza el datum WGS84 en coordenadas geográficas (EPSG: 4326). En el caso de que utilices en el mapa otra proyección debes de recordar que has de pasarle a la URL de Panoramio los parámetros de caja en WGS84, y lo mismo ocurre cuando el servicio te devuelve los puntos de cada foto, que ahora debes de hacer lo contrario, es decir, convertirla de EPSG:4326 a la proyección que estés utilizando.

Población por municipios de Madrid (2008)

Como ya vimos en la primera parte de esta mini-serie dedicada a la cartografía temática, hasta ahora sólo tenemos resuelta una parte, la asignación de paletas de colores para nuestros mapas o semiología cartográfica, pero queda otra parte por resolver, la lógica estadística, es decir, calcular cuales serán los valores de cada uno de los intervalos de clase que intervienen en una distribución numérica.

Como ya es habitual en www.gisandchips.org tenemos una especial predilección por almacenar nuestra fuente de datos en tablas espaciales contenidas en una base de datos PostgreSQL-PostGIS, y esta vez no va a ser menos.

Generalmente, el cálculo de los puntos de ruptura de una distribución ha sido tratado habitualmente desde el punto de vista del cliente (gvSIG, Quantum GIS, ArcGIS, etc), descargándose a la aplicación los datos oportunos (shapefiles, PostGIS, etc) para escoger posteriormente algún método de agrupamiento o clustering. Esta solución resulta apropiada cuando los datos a representar proceden de diferentes fuentes, cambios de geometría constantes realizamos muchos temáticos distintos, o cualquier otra variable a considerar. Pero sin embargo, cuando necesitamos representar la misma realidad espacial (municipios, provincias, comunidades autónomas, continentes, etc) desde diferentes aspectos (demografía, economía, agriculturas, etc) no resulta tán cómodo delegar esta función a la aplicación cliente.

Pongamos un ejemplo para clarificar el tema: Imaginemos que disponemos de datos de población agregados a nivel de municipios, donde existen tantas columnas como censos de población se hayan hecho, y deseamos generar en un portal de Internet mapas temáticos a requerimiento del usuario (año del censo, nº de clases, método de agrupamiento o clustering y paleta de colores). Crear un mapa coroplético de la población lleva implícito un conocimiento de la distribución de los datos (valores mínimos y máximos de la serie, media), y sobre todo las medidas de dispersión o de variabilidad: desviación típica, varianza, co-varianza, coeficiente de correlación de Pearson. Con estos parámetros estamos en condiciones de definir cual será el método de cálculo de intervalo de clase más apropiado para nuestra distribución, para posteriormente asignar la paleta de colores acorde al fenómeno a representar (este último aspecto ya lo tenemos solucionado con nuestra clase PHPcolorBrewer). Con una aplicación de GIS de escritorio sólo podemos realizar un mapa para visualizarlo en pantalla o imprimirlo, pero en un ambiente web(GIS) este forma de actuar carece de lógica, pues estamos limitando al usuario la posibilidad de elegir estos parámetros (método de clustering, número de clases y paleta de colores), ya que es muy complicado obtener datos de un GIS y realizar los cálculos de los intervalos de clases en la própia página web (JavaScript, PHP).

Flujo cartografía temática

En este artículo vamos a solucionar esta cuestión proponiendo un método que nos permita desde el servidor, es decir, desde el gestor de base de datos, calcular los intervalos de clase. Para ello no nos queda más remedio que recurrir a la creación de funciones o procedimientos almacenados que contemplen dicha lógica. Realizarlo con PLPg/SQL es una solución, pero programar estas funciones requiere de mucho esfuerzo al no formar parte de las funciones nativas del servidor (por ejemplo, no existe una función que calcule la desviación típica). ¿Por qué no utilizamos un lenguaje especializado en el manejo estadístico? En este sentido, PL/R reúne todas las condiciones para convertirse en el lenguaje de programación elegido. Una prueba de la potencia de este lenguaje, en este caso R lo podemos ver con este ejemplo.

Implementación en R
Tenemos la población activa (valores en miles) de todas las provincias españolas, obtenidas del INE, en el año 1996, disponibles en un objeto vector:

En una sesión de R se crearía de esta manera

Y se podría ver simplemente escribiendo:

poblacion.1996

Resultado

Para ver un sumario estadístico básico de dicho objeto escribimos:

summary(poblacion.1996)

Con este resultado:

Entrando ya en materia, vamos a calcular 5 clases distribuidas por el método de intervalos iguales, es decir, (valor máximo- valor mínimo) / nº intervalos:

seq(min(poblacion.1996),max(poblacion.1996),length.out=(5+1))

Resultado

Es decir, las clases quedarían agrupadas de esta forma:

• clase 1: 36.30 – 465.18
• clase 2: 465.18 – 894.06
• clase 3: 894.06 – 1322.94
• clase 4: 1322.94 – 1751.82
• clase 5: 1751.82 – 2180.70

Este método, aunque sencillo de implementar (incluso desde la parte cliente) ofrece una clasificación muy distorsionada cuando los valores son muy dispares, por lo que necesitamos recurrir a otros métodos más eficientes, como son los cuantiles. En R este cálculo queda reducido a la mínima expressión:

quantile(poblacion.1996)

Resultado:

Esta sería nuestra clasificación

• 1º quantil: 36.3 – 139.8
• 2º quantil: 139.8 – 207.8
• 3º quantil: 207.8 – 342.5
• 4º quantil: 342.5 – 2180.7

¡Más sencillo imposible!

El problema de trabajar directamente en R estriba en la dificultad para obtener datos desde otras fuentes, aunque siempre podemos recurrir a paquetes externos para traer los datos de shapefiles o tablas de PostgreSQL a R

Implementación en PostgreSQL

Como ya hemos visto en anteriores artículos sobre PL/R, esta lenguaje procedural es muy sencillo de utilizar. Sólo hay que copiar el código de R y realizar pequeños cambios para adaptarlo a la sintaxis de PL/R.

Un aspecto que debemos tener muy claro es que casi todos los cálculos en R de una distribución deben de estar dispuestos en forma de un vector. Como es lógico, PostgreSQL no soporta este tipo de dato, pero el lenguaje PL/R si que nos permite una conversión hacia el tipo de datos “array”, ofreciéndonos además una función que realiza todo el trabajo (array_accum)

Por ejemplo, si queremos obtener un array con los datos de la poblacion activa en 1996 (columna t1996t1) de la tabla ine.poblacion_activa, esta es la forma de conseguirlo con SQL:

SELECT array_accum(t1996t1) FROM ine.poblacion_activa;

Y este el resultado:

Con esta pequeña aclaración ya podemos utilizar cualquier columna con datos numéricos para realizar funciones de clustering. Las siguientes funciones de PL/R reproducen los cálculos realizados anteriormente con R:

Función para el método de intervalos iguales:

CREATE OR REPLACE FUNCTION r_equal(double precision[], integer)
RETURNS double precision[] AS
$BODY$
sort(seq(min(arg1),max(arg1),length.out=(arg2+1)))

$BODY$
LANGUAGE 'plr' VOLATILE STRICT
COST 100;

Vamos a analizar esta función.

Tiene dos parámetros de entrada:

• double precision[]: El array con los datos de entrada que queremos utilizar para calcular los intervalos, utilizando la función array_accum
• integer: el nº de intervalos de clase que deseamos obtener

El resultado (RETURNS) será siempre una estructura de tipo array.
El cuerpo de la función se reduciría a una sola línea que recibe los dos argumentos de la función (arg1 y arg2):
sort(seq(min(arg1),max(arg1),length.out=(arg2+1)))

El uso de esta función es muy sencillo:

SELECT r_equal( array_accum(t1996t1), 5 ) FROM ine.poblacion_activa;

Nos devolverá el siguiente array:

Para aquellos más versados en PLPg/SQL habrán advertido que realizar la función en este lenguaje requiere de algunas líneas más de código, que pueden ser bastantes más si queremos utilizar otros métodos, como el de cuantiles, que reproducimos a continuación.

CREATE OR REPLACE FUNCTION r_quantile(double precision[], integer)
RETURNS double precision[] AS
$BODY$
quantile(arg1,probs = seq(0, 1, 1/arg2))
$BODY$
LANGUAGE 'plr' VOLATILE STRICT
COST 100;

Ejemplo de uso para 5 intervalos de clase:

SELECT r_quantile(array_accum(t1996t1),5) FROM ine.poblacion_activa;

Devuelve:

Ahora que tenemos implementado un método para calcular los intervalos de clase ya estamos en condiciones de desarrollar un auténtico motor de cartografía temática (corológica) en un ambiente web que combine la capacidad de cálculo de PL/R con la semiología cartográfica implementada en PHPcolorBrewer que sea capaz de “pintar” geometrias de una tabla espacial de PostGIS. El resultado de esta coctelera explosiva lo podeis ver en las siguientes demostraciones on-line:

EJEMPLOS

Test 1: Distribución de la población activa por provincias (valores en miles de personas)
Este sencillo ejemplo nos permite ver las posibilidades de integración de varias piezas de software (PostGIS, PL/R. PHP MapScripts y PHPcolorBrewer). Los cálculos de los intervalos de clase utilizan el método “Kmeans”, y el usuario tiene la posibilidad de cambiar la paleta de colores y el nº de clases, así como el año que desea consultar.

Test 2: Distribución de la tasa de ocupación/desempleo por Comunidades Autónomas(valores en miles de personas)
Similar al anterior, pero aplicado a CC.AA. Ofrece la posibilidad de múltiples consultas (número de ocupados/desempleados diferenciando hombre, mujeres y total)

Test 3: Distribución de la población activa por provincias (valores en miles de personas) según diferentes métodos de clustering
Este ejemplo es similar al primero, pero hemos añadido la posibilidad de que el usuario selecciones el método de cálculo de intervalos de clase desea. Es sin duda, un buen ejemplo de la potencia que tiene PL/R al permitirnos elegir hasta 8 métodos diferentes:

• quantile
• equal
• kmeans
• hclust.complete
• hclust.single
• bclust
• fisher
• jenks

Test 4: Varios mapas temáticos en una sóla página con todos los métodos anteriores
El objeto de este ejemplo es demostrar de una sóla vez como se representa un mismo fenómeno desde diferentes métodos de clustering, para ver cual es el que mejor se adapta a nuestras necesidades.

Test 5: Mapa temático municipal sensible con HTML dinámico
Se trata del ejemplo más completo de todos, que nos permite seleccionar una provincia y ver la distribución de la población (total, hombres o mujeres) por municipio. También permite seleccionar todos los métodos indicados, así como la paleta de colores y nº de intervalos.

Test 6: Todas las paletas PHPcolorBrewer aplicadas a un mapa temático
El objetivo de este ejemplo es demostrar en una sóla página como un mismo fenómeno es representado con todas las paleta de PHPcolorBrewer, para que el usuario seleccione la que más le convenga.

PHPcolorBrewer palettes

NOTA: La segunda parte de este artículo lo puede consultar en: Cartografía temática II: Cálculo de intervalos de clase con Pl/R

Sobre este tipo de cartografía siempre han circulado muchos tópicos del tipo: “la mejor manera de representar los datos es con un mapa”, con una clara alusión al uso de mapas en detrimento de largos listados o tablas cuya lectura resulta menos intuitiva que un mapa con colores degradados. También encontramos declaraciones con una percepción negativa sobre los mapas temáticos, “la mejor forma de ocultar datos es con un mapa”, aludiendo esta vez al hecho incuestionable de que un fenómeno dado puede dar diferentes lecturas en función del mayor o menor acierto en la elección de los intervalos de clase, en el sentido de que muchos intervalos dificultan la lectura y pocos generalizan demasiado los datos.

Cuando trabajamos con aplicaciones de escritorio GIS nuestra labor se reduce a indicar el fenómeno a representar, el número de intervalos y como mucho elegir una de las gamas de paletas, para finalmente obtener una distribución más o menos aceptable donde es raro que el usuario intervenga en el proceso estadístico que implica decidir las rupturas de clase. De igual forma ocurre con la gama de colores, donde solemos aceptar los predefinidos, o como mucho definimos una degradación de colores.

Quizás sea por deformación profesional, pero suelo advertir una cierta dejadez del usuario respecto al tratamiento de los colores que intervienen en una distribución normalizada en mucha de la cartografía coroplética existente, utilizando, en la mayoría de los casos, los valores que por defecto nos proporciona la aplicación. Para cualquiera que haya estudiado cartografía, sabe que la simbolización del color es uno de los temás más complejos, que muchas veces delegamos en la aplicación de escritorio, en la que intervienen factores tales como la representatividad de los colores, legibilidad, idoneidad en función de su uso (por ejemplo en un mapa pensado para su impresión no todos los colores son imprimibles), adecuación del número de intervalos al fenómeno estudiado, capacidad del usuario para distinguir colores, y por supuesto la elección de un sistema de agrupamiento (clustering) adecuado.

La doctora Cynthia A. Brewer, profesora del Departamento de Geografía en la universidad estatal de Pennsylvania (http://www.personal.psu.edu/cab38/) ha dedicado su faceta profesional al estudio del color en la cartografía coroplética, dejando como legado una serie de paletas de colores adecuadas para la representación cartográfica que han sido bautizadas con su nombre y utilizadas en muchas publicaciones de renombre, como el Census Atlas of the United States (http://www.census.gov/population/www/cen2000/censusatlas/) e implementadas en muchas otras aplicaciones de GIS (ArcGIS)

Basándonos en su trabajo hemos elaborado una sencilla clase en PHP que nos permite hacer uso de dichas paletas de una manera sencilla para el usuario, susceptibles de ser utilizadas en la elaboración de cartografía coroplética.

Descargar PHPcolorBrewer

Esta utilidad está sujeta a la Apache License 2.0

Esta clase consta de los siguientes métodos:

• listColors: Listar colores de una paleta y un nº de intervalos o clases
• getPalettes: Obtiene un array de paletas
• getPaletteIntervals: Obtiene un array de intervalos de una paleta. Los valores siempre estarán entre de 3 a 9
• getPalIntColors: Obtiene un array de intervalos de una paletas. Siempre será de 3 a 9
• getColor: Obtiene un array con el color de una paleta, un intervalo y un número.

Dada la vocación web de esta clase se han creado estos métodos:

• comboPalettes: Utilidad HTML para listar paletas en forma de combo
• comboNumInt: Utilidad HTML para listado del nº de intervalos de una paleta en forma de combo
• rgb2html: Convierte un color en formato RGB a hexadecimal para su uso en web.
• tableColor: Crea una tabla HTML dada una paleta y un intervalo (de 3 a 9)

Con el objeto de facilitar al usuario su implementación se han añadido dos scripts con ejemplos de uso:
1. Listado de todas las paletas de colores: examples.palettes.colorBrewer.php
2. Ejemplos de uso: examples.colorBrewer.php

Finalmente, y como ejemplo de cartografía temática les mostramos algunas demostraciones que utilizan esta utilidad, incluidos en el siguiente post: Cartografía temática II: Cálculos de intervalos de clase con PL/R

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.