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 aquí os ofrecemos es una herramienta que, dada una determinada entidad PostgreSQL/PostGIS, permite explorar rápidamente cuál es la relación entre tamaño de imagen, extensión del mapa, degradación visual y tiempo de proceso para un máximo de 4 valores de tolerancia designados por el usuario. Se trata de una aplicación sencilla, escrita en C#, en la que el área de trabajo se divide en cuatro paneles. En cada panel podemos asignar una tolerancia, visualizar la geometría simplificada resultante, echar un vistazo a la sentencia SQL ejecutada en PostgreSQL y comprobar el tiempo de proceso transcurrido en realizar la transacción en el servidor y generar la imagen resultante en el cliente. Además, en todo momento conocemos cuál es la dimensión en píxeles de la imagen y el ancho del mapa. La instantánea inferior muestra una sesión de Simplify Workbench en la que se compara la geometría simplificada de los municipios de España procedentes de la Base de Datos de Líneas Límite a escala 1:1.000.000 del IDEE. Se puede observar cómo el tiempo de proceso del panel C es casi 4 veces menor que el del panel A, mientras que el impacto en la visualización es casi inapreciable. Por el contrario, la reducción del tiempo de proceso en el panel D conlleva una degradación visual que, para la resolución de la imagen, no es aceptable.

Geometría simplificada de los municipios de España en Simplify Workbench. Fuente de datos: IDEE

Podéis disponer del código fuente de Simplify Workbench bajo licencia GPL haciendo un checkout del siguiente repositorio Subversion de GIS&Chips:

svn co http://www.gisandchips.org/svn/simplifyworkbench

Para los que queráis probarlo de inmediato, tened en cuenta que los datos de conexión a PostgreSQL y entidad PostGIS se configuran en el fichero XML app.config que acompaña al ejecutable. Por defecto, os proporcionamos una conexión al servidor PostgreSQL de GIS & Chips para que podáis hacer tests con los municipios del IDEE. Si vais a realizar pruebas con vuestros propios datos tened en cuenta que la función de simplificación de PostGIS (simplify o st_simplify) no opera sobre geometrías en coordenadas geográficas (e.g. SRID = 4326), por lo que la aplicación no realizará el tratamiento esperado. Tampoco opera sobre entidades con sistema de referencia espacial indeterminado en la tabla geometry_columns (i.e. SRID = -1).

Si eres desarrollador y te vas a ‘zambullir’ en el código seguramente te interesará conocer que Simplify Workbench no es más que una extensión de SharpMap con un interfaz gráfico en Windows.Forms. Formalmente es una solución desarrollada en el IDE de código abierto SharpDevelop, escrita en C# sobre el framework 2.0 de .NET. Integra tres proyectos:  SharpMap (versión 0.9), SharpMapSimplifyExtension y Simplify.

Seguramente alguno de vosotros ya conozca SharpMap. Desde que Morten Nielsen, su creador, publicó allá por 2005-2006  este versátil renderizador de cartografía basado en GDI+, una pequeña revolución se ha producido en el ámbito de los clientes GIS libres sobre plataforma .NET y de hecho el proyecto no sólo continúa muy activo sino que ha conseguido integrar un equipo consolidado de desarrolladores en torno a un ecosistema de proyectos interrelacionados. El proyecto SharpMap de Simplify Workbench corresponde a los fuentes de la versión 0.9, la versión estable, aunque observaréis que el namespace SharpMap.Data.Providers incluye el proveedor de PostGIS (PostGIS.cs) y una referencia a Npgsql, la librería de acceso a datos de PostgreSQL en su versión 2.0.4.

El proyecto SharpMapSimplifyExtension consta de dos clases: PostGISSimplify y VectorSimplifiedLayer. La primera es una derivación de la clase SharpMap.Data.Providers.PostGIS que modifica el método GetGeometriesInView de forma que la sentencia SQL subyacente invoque la función simplify de PostGIS con la tolerancia de entrada. También añade un delegado que permite recuperar mediante un evento tanto la sentencia SQL final como el ancho del bounding box. La segunda deriva de la clase SharpMap.Layers.VectorLayer, sobrecarga el constructor para instanciar capas vectoriales especificando una tolerancia de simplificación y modifica el método Render. Con estas dos simples extensiones podemos definir  una capa vectorial que muestre geometría simplificada de PostGIS sin variar sustancialmente la lógica habitual de trabajo con SharpMap, tal y como se muestra en este ejemplo:

//
//
//
string cnstr = "Server=your.pgsql.server;Port=5432;User Id=user;Password=secret;Database=yourDB";
string tableName = "yourPolygons";
string geomFieldName = "geometry";
string oidFieldName = "oid";
//Instance of data provider for PostGIS simplified geometry
PostGISSimplify src = new PostGISSimplify(cnstr, tableName, geomFieldName, oidFieldName);
//Instance of vector layer to hold simplified PostGIS geometry
//Third parameter is an integer corresponding to tolerance in Douglas-Peucker vertex reduction algorithm
VectorSimplifiedLayer lyr = new VectorSimplifiedLayer("SIMPLIFIED_LAYER", src, 1000);
lyr.Style.EnableOutline = true;
lyr.Style.Fill = Brushes.Transparent;
//Map object, the layer container and rendering logic construct in SharpMap
Map m = new Map(new System.Drawing.Size(350, 275));
m.BackColor = Color.White;
m.Layers.Add(lyr);
//Zoom to extents internally invokes the modified GetGeometriesInView method in PostGISSimplify class
m.ZoomToExtents();
//Retrieve map image
System.Drawing.Image img = m.GetMap();
//

El proyecto Simplify incluye el formulario estructurado en cuatro paneles comentado más arriba y una clase de conveniencia, MapRenderer, que encapsula la lógica de lectura del fichero app.config, definición de layer, obtención de la imagen, recuperación de la sentencia SQL y cálculo del tiempo de proceso. En el directorio de este proyecto encontraréis también el fichero de solución de SharpDevelop (Simplify.sln).

Para terminar, y puesto que muchos de nosotros aquí en GIS & Chips somos fans del framework de código abierto Mono, os animamos a que probéis a compilar usando esta plataforma. Sabemos positivamente que SharpMap 0.9, con pequeñas modificaciones, es compilable sobre Mono. Creemos, aunque no lo hemos comprobado, que el código de Simplify Workbench también lo es. Si alguno lo consigue nos alegrará que nos lo comente.

¡Disfrutad con Simplify Workbench!