Resultado esperado:

El código de generación del mapfile será el mismo que en el  post de creación del mapfile “al vuelo”, tan solo habría que cambiar la forma de obtener los datos, para que en lugar de obtenerlos con una simple sentencia sql, llamar a una función que obtuviera las geometrías simplificadas a costa de perder nivel de detalle (inapreciable a la vista).

Cuando se trata de simplificar geometrías hay que tener en cuenta la dimensión del mapa que queremos obtener para en función de esta dimensión, poder obtener de alguna forma un coeficiente de simplificación que se adecue a la simplificación que pretendemos obtener (es decir, ni que no nos haga casi simplificación, ni que simplifique demasiado).

Para obtener este factor de simplificación, podemos hacer varias operaciones, en este caso realizaremos una operación como la siguiente, dividiremos el resultado de restar a la xmax la xmin de la entensión de la geometria entre el ancho del mapa que queremos obtener.

Es decir, obtenemos la extensión de la geometría que estamos analizando , sacamos al xmax y la xmin, las restamos y el resultado lo dividimos entre el ancho del mapa que queremos obtener:

(xmax(extent(geometria) )- xmin(extent(geometria)))/Ancho del mapa

Creamos una función en sql para obtener el factor de simplificación que deseamos:

create or replace function fs(float8) returns float8 AS $$
 select (xmax(extent(geometria))-xmin(extent(geometria)))/$1 from ine.municipios;
$$ LANGUAGE SQL;

Una vez que tenemos el factor de simplificación obtenido con la función anterior, ya podemos aplicar la simplificación con el factor de simplificación obtenido anteriormente.

Podemos hacer una comparativa del aumento de velocidad entre realizar una consulta sin simplificación y otra con la simplificación, por ejemplo para un mapa bastante grande de 4000px.

1ª consulta: “select geometria  from municipios2”

2ª consulta:”select st_simplify(geometria,factor_simplificacion) from municipios2”

En PostgreSQL, al ejecutar las dos sentencias podemos comparar y obtener:

1ª consulta

• Tiempo de ejecución de la consulta: 50,84 segundos
• Numero de vertices: 393666

2ª consulta

• Tiempo de ejecución de la consulta: 19,51 segundos
• Numero de vertices: 141610

De esta manera comprobamos que se produce un aumento en la velocidad a cambio de reducir el nivel de detalle, circunstancia que nos viene bien de cara a la publicación web, ya que no necesitamos un nivel de detalle elevado.

Para constaruir ahora la layer en MapScript, la sentencia SQL para obtener los datos sería como esta:

$name = $Layer2->set("name","Municipios");
$type = $Layer2->set("type",MS_LAYER_POLYGON);
$status = $Layer2->set("status",MS_ON);
//Conexión con nuestra base de datos que va as er de tipo POSTGIS
$Layer2->setConnectionType(MS_POSTGIS);
//Cadena de conexión a la base de datos donde tenemos nuestros datos

//En primer lugar, debemos obtener el factor de simplificación que obtenemos mediante consulta a postgresql desde php:
$conexion = pg_pconnect("host=localhost port=5432 dbname=demos user=postgres");

$sql="select fs(".$Map->width.")";
$resultado=pg_exec($conexion,$sql);
$factor=pg_result($resultado,0,0);

$Layer2->set("connection","user=postgres dbname=demos host=localhost");
//Filtro en sql que vamos a introducir para sacar nuestros datos a mostrar, aplicando el factor obtenido anteriormente
$data="geometria from (select st_simplify(geometria,".$factor.") as geometria, nombre,provincia,gid from municipios) as foo using SRID=23030, using unique gid";
$Layer2->set("data",$data);
//Una vez definida la estructura d ela capa procedemos a definir el estilo de nuestra capa número 1

Para la comparación de velocidad de creación de un mapfile con una única capa PostGIS utilizando una sentencia SQL normal y utilizando simplificación de geometrías, utilizando para ello varios test de medición de velocidad de carga, asumimos que vamos a crear un mapa bastante grande de una dimensión de 2000×2000 pixeles.

Sin simplificación de geometrías (tal y como se hizo en el artículo anterior, pero con una sola capa y de tamaño 2000×2000 píxeles)

Con simplificación de geometrías (utilizando la función que hemos programado anteriormente)

Para realizar la comparativa de cargas he utilizado la herramienta Speed-Test

El resultado que he obtenido es el siguiente:
(no se aprecia mucha diferencia, pero es debido a que se ha guardado en la caché y no es significativa la diferencia)
- Con la sentencia normal (sin simplificación)

- Utilizando el factor de simplificación y realizando una simplificación de las geometrías:

Lo que vamos a intentar conseguir es mostrar en una página web un fichero de mapa sin la necesidad de tener un fichero .map (MapFile) asociado y complejo de mantener, simplemente realizando modificaciones en nuestro código php.

Este es el resultado que queremos obtener:

Mapa de españa

Vamos a ponernos manos a la obra para conseguirlo.

En primer lugar, doy por supuesto que tenemos instalado MapServer y MapScript en nuestro servidor Linux (en mi caso CentOS)  y el Servidor de Bases de Datos PostgreSQL+PostGIS y con la extensión PHP/pgSQL.

Creamos un fichero .php

Lo primero que debemos hacer es cargar la librería PHPMapScript (php_mapscript.so)

dl('php_mapscript.so');

//Una vez cargada la librería ya se puede trabajar con las funciones propias de PHPMapScript
//Para empezar hay que crear el fichero mapa y definir las diferentes características que queremos que tenga el mapa (nombre, tamaño,

//Creamos un objeto llamado Map mediante el Constructor de MapObject

$Map=ms_newMapObj("");

//Le damos un nombre (p.e. mapa)
$Map->set("name","Mapa");

//La dimensión del mapa
$Map->setSize(600,600);

// La extensión del mapa (la podemos obtener de postgresql mediante la función de postgis st_extent
$Map->setExtent(626679.9375,4191059,815673.125,4519371);

// Se define el path de la imagen la temporal y la real que se mostrarán por web
$Map->web->set("imagepath","/tmp");
$Map->web->set("imageurl","/ms_tmp");

Una vez hemos definido las características de nuestro fichero de mapa, procedemos a incluir capas.
<pre>//Definimos una capa asociada a nuestro fichero de mapa anteriormente definido
// En este caso la primera capa, y que va a servir de fondo de nuestro mapa va a ser wms
// y del servicio wms que proporciona el <a href="http://www.idee.es/wms/PNOA/PNOA?Request=GetCapabilities&Service=WMS" target="_blank">PNOA</a></pre>
$Layer1=ms_newLayerObj($Map);

$Layer1->set("name","ortofoto");

//Tipo Raster

$Layer1->set("type",MS_LAYER_RASTER);

$Layer1->set("status",MS_ON);//El status de la Layer, esto nos permitirá definir layers y mantenerlas ocultas dependiendo de las necesidades que tengamos
$Layer1->setConnectionType(MS_WMS);
$Layer1->set("connection","http://www.idee.es/wms/PNOA/PNOA?");
//Definimos la proyección del wms junto con el nombre de la capa wms, la versión del servidor y el formato de la imagen
<pre>//El que esta capa se muestre o no, no depende de nosotros, depende de una fuente externa que proporciona la capa WMS, en este caso es la del PNOA</pre>
$Layer1->setProjection("init=epsg:23030");
$Layer1->setMetadata("wms_name","pnoa");
$Layer1->setMetadata("wms_server_version","1.1.1");
$Layer1->setMetadata("wms_format","image/png");

//Como segunda capa asociada a nuestro fichero de mapa anteriormente definido vamos a añadir una capa obtenida de nuestros datos en postgresql
$Layer2=ms_newLayerObj($Map);

//Vamos definiendo las características que va a tener esta nuestra primera capa
$name = $Layer2->set("name","Municipios");
$type = $Layer2->set("type",MS_LAYER_POLYGON);
$status = $Layer2->set("status",MS_ON);
//Conexión con nuestra base de datos que va as er de tipo POSTGIS
$Layer2->setConnectionType(MS_POSTGIS);
//Cadena de conexión a la base de datos donde tenemos nuestros datos
$Layer2->set("connection","user=postgres dbname=demos host=localhost");
//Filtro en sql que vamos a introducir para sacar nuestros datos a mostrar
// MUY IMPORTANTE es necesario incluir el unique gid y using srid=23030, si no no funcionará
$Layer2->set("data","geometria from ine.municipios using unique gid using srid=23030" );
//Una vez definida la estructura d ela capa procedemos a definir el estilo de nuestra capa número 1

$clase = ms_newClassObj($Layer2); //Definimos la clase
$estilo = ms_newStyleObj($clase); //El estilo asociado a dicha clase
$estilo->color->setRGB(10,150,190); //Los colores
$estilo->outlinecolor->setRGB(0,0,0); //El contorno

//Una vez hemos definido las capas tenemos que indicar que se dibuje el mapa
$Image=$Map->Draw();

//Muy importante que no se nos olviden estas 2 sentencias que vienen a continuación, si no ponemos que se almacene la imagen en el path que le hemos incluido o no la mostramos por pantalla con un echo, no va a mostarse nada, y caeremos en el desanimo ya que después de definir todo correctamente la página aparece en blanco.

$url_imagen=$Image->saveWebImage();
echo "<img src=".$url_imagen.">";

Y después de tener esto, solo hay que lanzar el navegador y et voilà!, tenemos nuestro primer mapfile utilizando PHPMapScript en nuestro navegador, puede que sea un poco lento a la hora de cargar, pero no depende tanto de nuestra capa en PostGIS sino del Servidor WMS que utilicemos como capa de fondo, que ya no depende de nosotros.

El resultado es este: http://www.gisandchips.org/demos/mapscript/index.php

]]> http://www.gisandchips.org/2009/11/02/creacion-de-un-mapfile-de-forma-dinamica-al-vuelo/feed/ 5 http://www.gisandchips.org/2009/10/23/openstreetmap-y-mapnik/ http://www.gisandchips.org/2009/10/23/openstreetmap-y-mapnik/#comments Fri, 23 Oct 2009 11:42:23 +0000 jose http://www.gisandchips.org/?p=420 Objetivo:
Siguiendo con la serie de artículos sobre OSM vamos a introducirnos en las posibilidades que nos ofrece Mapnik para renderizar datos de OSM contenidos en una geodatabase que hemos creado con “osm2pgsql” (ver artículo previo).
El objetivo final es crear un fichero de mapa (mapfile) en XML para utilizarlo con Python y los bindings de Mapnik. Una vez realizado este proceso podremos generar tanto imágenes como conjuntos de teselas (tiles)

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

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

Este es el contenido de la carpeta “mapnik”:

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

Descarga de shapefiles:

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

mkdir world_boundaries

Ahora descargamos los shapefiles y los descomprimimos

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

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

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

Configuración de Mapnik para OSM

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

Contenido del fichero “set_mapnik.env”

#!/bin/sh
# Nombre del mapfile
export MAPNIK_MAP_FILE=/home/<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