Uso de “dissolve” con POSTGIS

Miguel — Thu, 17 Dec 2009 10:36:51 +0000

Uno de los problemas que tuve al manejar los datos geométricos del INE fue que la capa de municipios constaba de geometría de tipo POLYGON. Lo que necesitaba conseguir era agrupar esa geometría simple y convertirla en MULTIPOLYGON. Eso me dio la idea para el siguiente consejo práctico.

Para ello una simple ojeada a la documentación de POSTGIS y encontré la función que necesitaba, st_union. Esta función nos une la geometría en función de un atributo seleccionado.

Voy a mostrar un ejemplo sencillo, pero muy pedagógico. En este ejemplo partimos de tres polígonos simples, su geometría es de tipo POLYGON y quiero unirlos por un atributo común, en su caso el código.

Vemos en la imagen anterior los 3 polígonos, dos de los cuales tienen el mismo atributo (campo código).

La SQL quedaría de la siguiente manera:

select st_union(geometria) from poligonos group by codigo;

El problema viene con el resultado de esa consulta, y es la heterogeneidad del tipo de geometría:

Para que eso no ocurra, añadimos la función st_multi, y conseguimos una homogeneidad del tipo de geometría, convirtiendo todas las geometrías en MULTIPOLYGON:

select st_multi(st_union(geometria)) from poligonos group by codigo;

En caso de que los polígonos sean adyacentes, pasaría a ser un único polígono, es decir, elimina la frontera entre ambos.

Ahora comprobamos que al usar st_union, simplemente nos ha creado un polígono a partir de un atributo común, manteniendo la geometría de tipo POLYGON y en este caso ya no hace falta usar st_multi.

Creación de un mapa sensible utilizando Pl/PgSQL y PHP_Mapscript

Miguel — Fri, 06 Nov 2009 17:46:56 +0000

El objetivo no es otro que convertir nuestro mapa en algo más interactivo para el usuario, dando más información que la meramente visual. El siguiente artículo, muestra el camino para alcanzar nuestra meta, seguramente no sea la única ni la mejor, pero nos será útil para nuestro fín.

Obviaremos la construcción del mapfile, ya que fue abordado en otro artículo, pero trabajaremos a partir de ese código.

Lo primero que necesitamos hacer es preparar la función en lenguaje PL/pgSQL que nos devolverá las coordenadas de los vértices que componen cada uno de los polígonos a partir de un parámetro, que en nuestro caso será el código municipal, y posteriormente se hará la conversión de esos vértices de metros a pixel con PHP.

CREATE OR REPLACE FUNCTION gc_listvertices(cod_municipal character varying)
RETURNS SETOF record AS
$BODY$
DECLARE
countpol bigint;
polygon geometry;
perimeter geometry;
countpoints integer;
i integer;
j integer;
point record;
BEGIN
--Teniendo en cuenta que cada municipio puede estar compuesto de varios polígonos, primero hacemos un conteo de los polígonos de cada municipio
select into countpol count(*) from (select st_dump(geometria) from municipios where codmun= cod_municipal) foo;
for j in 1..countpol loop
--Por cada municipio, nos devolverá los polígonos descompuestos. La función st_dump, lo que nos devuelve es tantas filas como polígonos contiene el municipio en cuestión, es decir nos descompone el MULTIPOLYGON en un array que contiene un único POLYGON
select into polygon geom from (select (st_dump(geometria)).path, (st_dump(geometria)).geom from municipios where codmun = cod_municipal) foo where path[1] = j;
--La función st_exteriorring nos devuelve un LINESTRING, que representa el anillo exterior del polígono dado.
--ATENCIÓN: esta función no trabaja con MULTIPOLYGON, de ahí la descomposición anterior
select into perimeter st_exteriorring(polygon);
--Contamos el número de vértices que componen el POLYGON
select into countpoints st_npoints(polygon);
for i in 1..countpoints loop
--Por último, nos guardamos en una variable, la coordenada X y la coordenada Y de cada vértice.
--ATENCIÓN: puesto que nos devuelve indiscriminadamente las coordenadas de todos los vértices de todos los polígonos que componen el municipio, se ha añadido un campo booleano que nos devuelve true en caso de ser un vértice final.
select into point st_x(st_pointn(perimeter, i)), st_y(st_pointn(perimeter, i)), (i=countpoints) as tend;
return next point;
end loop;
end loop;
END;
$BODY$
LANGUAGE 'plpgsql' VOLATILE
COST 100
ROWS 1000;
ALTER FUNCTION gc_listvertices(character varying) OWNER TO postgres;

Ahora sólo queda hacer la conversión con PHP:




Ejemplo de mapa sensible





set("name","Mapa");
//Equivalencia en pixeles del tamaño del mapa
$Map->setSize(432,750);
//Extensión de la caja para los municipios de la Comunidad Valenciana
$Map->setExtent(626680,4191059,815673.125,4519371);
$Map->web->set("imagepath","/tmp");
$Map->web->set("imageurl","/ms_tmp");
$Layer2=ms_newLayerObj($Map);
$Layer2->set("name","Municipios");
$Layer2->set("type",MS_LAYER_POLYGON);
$status = $Layer2->set("status",MS_ON);
$Layer2->setConnectionType(MS_POSTGIS);
$Layer2->set("connection","user=****** dbname=demos host=localhost");
//La consulta ha sido modificada con respecto a la original, para mostrar sólo los municipios de la Comunidad Valenciana
$Layer2->set("data","geometria from (select geometria,gid from  ine.municipios where com = '10') as foo  using unique gid using srid=23030");
$clase = ms_newClassObj($Layer2);
$estilo = ms_newStyleObj($clase);
$estilo->color->setRGB(217,233,107);
$estilo->outlinecolor->setRGB(0,0,0);
$Image=$Map->Draw();
$url_imagen=$Image->saveWebImage();
//Añadimos que la imagen será usada como un mapa de html
echo "";
echo "";

//Lo siguiente, es conectarse a la base de datos para consultar los municipios que vamos a mostrar en el mapa
$conn = pg_connect("host=localhost port=5432 dbname=demos user=****** password=******");
$sqlmun= "select nombre04 as nombre,codmun as codmunicipal, area(geometria) as area from ine.municipios where com = '10'";
$poligono = pg_query($conn,$sqlmun);
$rowspol=pg_num_rows($poligono);
for ($h=0; $h<$rowspol; $h++)
{
        $arraypol=pg_fetch_array($poligono,$h);
        $nombre=$arraypol['nombre'];
        $codmun=$arraypol['codmunicipal'];
        $area=round(($arraypol['area']/1000000),2);

        $pxmin = 626680;
        $pymin = 4191059;
        $pxmax = 815673.125;
        $pymax = 4519371;

        //distancia en metros de los ejes
        $eqx=$pxmax-$pxmin;
        $eqy=$pymax-$pymin;
//Llegados a este punto ejecutamos la función anterior que creamos en la base de datos, para que nos devuelva las coordenadas de los vértices de cada uno de los polígonos
        $sqlpolcoords="select * from ine.gc_listvertices('$codmun') as foo(x float, y float,tend boolean)";
        $polcoords= pg_query($conn,$sqlpolcoords);
        $rowspolcoords=pg_num_rows($polcoords);
        for ($j=0; $j<$rowspolcoords; $j++)
        {
//Obtenemos los tres parámetros por separado que nos devuelve la función y hacemos la conversión de metros a pixel. Como he comentado anteriormente lo ideal es que esto se realice de manera automatizada, sin que introduzcamos nosotros la anchura y la altura del mapa
                $arraypolcoords=pg_fetch_array($polcoords,$j);
                $x=$arraypolcoords['x'];
                $y=$arraypolcoords['y'];
                $tend=$arraypolcoords['tend'];
                $xcal=$x-$pxmin;
                $ycal=$pymax-$y;

                $resx=round(((432*$xcal)/$eqx),0);
                $resy=round(((750*$ycal)/$eqy),0);
                $coordenadas.=$resx.",".$resy.",";
//Lo que va a hacer este parámetro es cortar cada polígono cada vez que devuelva true, de manera que en el caso de Alicante que son cuatro polígonos, los separa cada uno en un área distinta
                if($tend=='t')
                {
                        echo"\n";
//Para el ejemplo he creado una simple función en javascript que nos muestre el nombre y el área en un div cuando pasemos el ratón por encima de cualquier municipio.
                        $coordenadas="";
                }
        }
}
echo"";
?>

El resultado del ejemplo será este mapa sensible.

GIS & Chips » Miguel

Uso de “dissolve” con POSTGIS

Creación de un mapa sensible utilizando Pl/PgSQL y PHP_Mapscript