geometry_inout.c

Go to the documentation of this file.

/**********************************************************************
 *
 * PostGIS - Spatial Types for PostgreSQL
 * http://postgis.net
 *
 * PostGIS is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 2 of the License, or
 * (at your option) any later version.
 *
 * PostGIS is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with PostGIS.  If not, see <http://www.gnu.org/licenses/>.
 *
 **********************************************************************
 *
 * ^copyright^
 *
 **********************************************************************/
 
#include "postgres.h"
#include "utils/geo_decls.h"
 
#include "../postgis_config.h"
 
#include "liblwgeom.h"         /* For standard geometry types. */
#include "lwgeom_pg.h"       /* For debugging macros. */
 
 
Datum geometry_to_point(PG_FUNCTION_ARGS);
Datum point_to_geometry(PG_FUNCTION_ARGS);
Datum geometry_to_path(PG_FUNCTION_ARGS);
Datum path_to_geometry(PG_FUNCTION_ARGS);
Datum geometry_to_polygon(PG_FUNCTION_ARGS);
Datum polygon_to_geometry(PG_FUNCTION_ARGS);
 
PG_FUNCTION_INFO_V1(point_to_geometry);
Datum point_to_geometry(PG_FUNCTION_ARGS)
{
        Point *point;
        LWPOINT *lwpoint;
        GSERIALIZED *geom;
 
        POSTGIS_DEBUG(2, "point_to_geometry called");
 
        if ( PG_ARGISNULL(0) )
                PG_RETURN_NULL();
 
        point = PG_GETARG_POINT_P(0);
 
        if ( ! point )
                PG_RETURN_NULL();
 
        lwpoint = lwpoint_make2d(SRID_UNKNOWN, point->x, point->y);
        geom = geometry_serialize(lwpoint_as_lwgeom(lwpoint));
        lwpoint_free(lwpoint);
 
        PG_RETURN_POINTER(geom);
}
 
PG_FUNCTION_INFO_V1(geometry_to_point);
Datum geometry_to_point(PG_FUNCTION_ARGS)
{
        Point *point;
        LWGEOM *lwgeom;
        LWPOINT *lwpoint;
        GSERIALIZED *geom;
 
        POSTGIS_DEBUG(2, "geometry_to_point called");
 
        if ( PG_ARGISNULL(0) )
                PG_RETURN_NULL();
 
        geom = PG_GETARG_GSERIALIZED_P(0);
 
        if ( gserialized_get_type(geom) != POINTTYPE )
                elog(ERROR, "geometry_to_point only accepts Points");
 
        lwgeom = lwgeom_from_gserialized(geom);
 
        if ( lwgeom_is_empty(lwgeom) )
                PG_RETURN_NULL();
 
        lwpoint = lwgeom_as_lwpoint(lwgeom);
 
        point = (Point*)palloc(sizeof(Point));
        point->x = lwpoint_get_x(lwpoint);
        point->y = lwpoint_get_y(lwpoint);
 
        lwpoint_free(lwpoint);
        PG_FREE_IF_COPY(geom,0);
 
        PG_RETURN_POINT_P(point);
}
 
PG_FUNCTION_INFO_V1(geometry_to_path);
Datum geometry_to_path(PG_FUNCTION_ARGS)
{
        PATH *path;
        LWLINE *lwline;
        LWGEOM *lwgeom;
        GSERIALIZED *geom;
        POINTARRAY *pa;
        uint32_t i;
        const POINT2D *pt;
        size_t size;
 
        POSTGIS_DEBUG(2, "geometry_to_path called");
 
        if ( PG_ARGISNULL(0) )
                PG_RETURN_NULL();
 
        geom = PG_GETARG_GSERIALIZED_P(0);
 
        if ( gserialized_get_type(geom) != LINETYPE )
                elog(ERROR, "geometry_to_path only accepts LineStrings");
 
        lwgeom = lwgeom_from_gserialized(geom);
        if ( lwgeom_is_empty(lwgeom) )
                PG_RETURN_NULL();
        lwline = lwgeom_as_lwline(lwgeom);
 
        pa = lwline->points;
    size = offsetof(PATH, p[0]) + sizeof(path->p[0]) * pa->npoints;
    path = (PATH*)palloc(size);
        SET_VARSIZE(path, size);
        path->npts = pa->npoints;
        path->closed = 0;
        path->dummy = 0;
 
        for ( i = 0; i < pa->npoints; i++ )
        {
                pt = getPoint2d_cp(pa, i);
                (path->p[i]).x = pt->x;
                (path->p[i]).y = pt->y;
        }
 
        lwgeom_free(lwgeom);
        PG_FREE_IF_COPY(geom,0);
 
        PG_RETURN_PATH_P(path);
}
 
 
PG_FUNCTION_INFO_V1(path_to_geometry);
Datum path_to_geometry(PG_FUNCTION_ARGS)
{
        PATH *path;
        LWLINE *lwline;
        POINTARRAY *pa;
        GSERIALIZED *geom;
        POINT4D pt;
        Point p;
        int i;
 
        POSTGIS_DEBUG(2, "path_to_geometry called");
 
        if ( PG_ARGISNULL(0) )
                PG_RETURN_NULL();
 
        path = PG_GETARG_PATH_P(0);
 
        if ( ! path )
                PG_RETURN_NULL();
 
        pa = ptarray_construct_empty(0, 0, path->npts);
        for ( i = 0; i < path->npts; i++ )
        {
                p = path->p[i];
                pt.x = p.x;
                pt.y = p.y;
                ptarray_append_point(pa, &pt, LW_FALSE);
        }
        lwline = lwline_construct(SRID_UNKNOWN, NULL, pa);
        geom = geometry_serialize(lwline_as_lwgeom(lwline));
        lwline_free(lwline);
 
        PG_RETURN_POINTER(geom);
}
 
PG_FUNCTION_INFO_V1(geometry_to_polygon);
Datum geometry_to_polygon(PG_FUNCTION_ARGS)
{
        POLYGON *polygon;
        LWPOLY *lwpoly;
        LWGEOM *lwgeom;
        GSERIALIZED *geom;
        POINTARRAY *pa;
        GBOX gbox;
        uint32_t i;
        size_t size;
 
        POSTGIS_DEBUG(2, "geometry_to_polygon called");
 
        if ( PG_ARGISNULL(0) )
                PG_RETURN_NULL();
 
        geom = PG_GETARG_GSERIALIZED_P(0);
 
        if ( gserialized_get_type(geom) != POLYGONTYPE )
                elog(ERROR, "geometry_to_polygon only accepts Polygons");
 
        lwgeom = lwgeom_from_gserialized(geom);
        if ( lwgeom_is_empty(lwgeom) )
                PG_RETURN_NULL();
        lwpoly = lwgeom_as_lwpoly(lwgeom);
 
        pa = lwpoly->rings[0];
 
        size = offsetof(POLYGON, p[0]) + sizeof(polygon->p[0]) * pa->npoints;
        polygon = (POLYGON*)palloc0(size); /* zero any holes */
        SET_VARSIZE(polygon, size);
 
        polygon->npts = pa->npoints;
 
        lwgeom_calculate_gbox(lwgeom, &gbox);
        polygon->boundbox.low.x = gbox.xmin;
        polygon->boundbox.low.y = gbox.ymin;
        polygon->boundbox.high.x = gbox.xmax;
        polygon->boundbox.high.y = gbox.ymax;
 
        for ( i = 0; i < pa->npoints; i++ )
        {
                const POINT2D *pt = getPoint2d_cp(pa, i);
                (polygon->p[i]).x = pt->x;
                (polygon->p[i]).y = pt->y;
        }
 
        lwgeom_free(lwgeom);
        PG_FREE_IF_COPY(geom,0);
 
        PG_RETURN_POLYGON_P(polygon);
}
 
 
PG_FUNCTION_INFO_V1(polygon_to_geometry);
Datum polygon_to_geometry(PG_FUNCTION_ARGS)
{
        POLYGON *polygon;
        LWPOLY *lwpoly;
        POINTARRAY *pa;
        POINTARRAY **ppa;
        GSERIALIZED *geom;
        Point p;
        int i = 0, unclosed = 0;
 
        POSTGIS_DEBUG(2, "polygon_to_geometry called");
 
        if ( PG_ARGISNULL(0) )
                PG_RETURN_NULL();
 
        polygon = PG_GETARG_POLYGON_P(0);
 
        if ( ! polygon )
                PG_RETURN_NULL();
 
        /* Are first and last points different? If so we need to close this ring */
        if ( memcmp( polygon->p, polygon->p + polygon->npts - 1, sizeof(Point) ) )
        {
                unclosed = 1;
        }
 
        pa = ptarray_construct_empty(0, 0, polygon->npts + unclosed);
 
        for ( i = 0; i < (polygon->npts+unclosed); i++ )
        {
                POINT4D pt;
                p = polygon->p[i % polygon->npts];
                pt.x = p.x;
                pt.y = p.y;
                ptarray_append_point(pa, &pt, LW_FALSE);
        }
 
        ppa = palloc(sizeof(POINTARRAY*));
        ppa[0] = pa;
        lwpoly = lwpoly_construct(SRID_UNKNOWN, NULL, 1, ppa);
        geom = geometry_serialize(lwpoly_as_lwgeom(lwpoly));
        lwpoly_free(lwpoly);
 
        PG_RETURN_POINTER(geom);
}