2006-05-30 08:47:00 +00:00
|
|
|
/**********************************************************************
|
2008-06-29 19:11:48 +00:00
|
|
|
* $Id: lwgeom.c 2797 2008-05-31 09:56:44Z mcayland $
|
2006-05-30 08:47:00 +00:00
|
|
|
*
|
|
|
|
* PostGIS - Spatial Types for PostgreSQL
|
|
|
|
* http://postgis.refractions.net
|
|
|
|
* Copyright 2001-2006 Refractions Research Inc.
|
|
|
|
*
|
|
|
|
* This is free software; you can redistribute and/or modify it under
|
|
|
|
* the terms of the GNU General Public Licence. See the COPYING file.
|
|
|
|
*
|
|
|
|
**********************************************************************/
|
|
|
|
|
2004-09-29 10:50:30 +00:00
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <stdarg.h>
|
|
|
|
|
2005-12-30 17:40:37 +00:00
|
|
|
/*#include "lwgeom_pg.h"*/
|
2004-09-29 10:50:30 +00:00
|
|
|
#include "liblwgeom.h"
|
2005-02-21 16:16:14 +00:00
|
|
|
#include "wktparse.h"
|
2004-09-29 10:50:30 +00:00
|
|
|
|
2004-10-03 15:52:23 +00:00
|
|
|
|
2004-09-29 10:50:30 +00:00
|
|
|
LWGEOM *
|
2005-02-10 10:52:53 +00:00
|
|
|
lwgeom_deserialize(uchar *srl)
|
2004-09-29 10:50:30 +00:00
|
|
|
{
|
|
|
|
int type = lwgeom_getType(srl[0]);
|
|
|
|
|
2008-05-31 09:56:44 +00:00
|
|
|
LWDEBUGF(2, "lwgeom_deserialize got %d - %s", type, lwgeom_typename(type));
|
2004-10-08 13:20:55 +00:00
|
|
|
|
2004-09-29 10:50:30 +00:00
|
|
|
switch (type)
|
|
|
|
{
|
|
|
|
case POINTTYPE:
|
2004-09-29 15:25:21 +00:00
|
|
|
return (LWGEOM *)lwpoint_deserialize(srl);
|
2004-09-29 10:50:30 +00:00
|
|
|
case LINETYPE:
|
2004-09-29 15:25:21 +00:00
|
|
|
return (LWGEOM *)lwline_deserialize(srl);
|
2006-12-01 22:16:44 +00:00
|
|
|
case CURVETYPE:
|
|
|
|
return (LWGEOM *)lwcurve_deserialize(srl);
|
2004-09-29 10:50:30 +00:00
|
|
|
case POLYGONTYPE:
|
2004-09-29 15:25:21 +00:00
|
|
|
return (LWGEOM *)lwpoly_deserialize(srl);
|
2004-09-29 10:50:30 +00:00
|
|
|
case MULTIPOINTTYPE:
|
2004-09-29 15:25:21 +00:00
|
|
|
return (LWGEOM *)lwmpoint_deserialize(srl);
|
2004-09-29 10:50:30 +00:00
|
|
|
case MULTILINETYPE:
|
2004-09-29 15:25:21 +00:00
|
|
|
return (LWGEOM *)lwmline_deserialize(srl);
|
2004-09-29 10:50:30 +00:00
|
|
|
case MULTIPOLYGONTYPE:
|
2004-09-29 15:25:21 +00:00
|
|
|
return (LWGEOM *)lwmpoly_deserialize(srl);
|
2004-09-29 10:50:30 +00:00
|
|
|
case COLLECTIONTYPE:
|
2004-09-29 15:25:21 +00:00
|
|
|
return (LWGEOM *)lwcollection_deserialize(srl);
|
2006-12-01 22:16:44 +00:00
|
|
|
case COMPOUNDTYPE:
|
|
|
|
return (LWGEOM *)lwcompound_deserialize(srl);
|
|
|
|
case CURVEPOLYTYPE:
|
|
|
|
return (LWGEOM *)lwcurvepoly_deserialize(srl);
|
|
|
|
case MULTICURVETYPE:
|
|
|
|
return (LWGEOM *)lwmcurve_deserialize(srl);
|
|
|
|
case MULTISURFACETYPE:
|
|
|
|
return (LWGEOM *)lwmsurface_deserialize(srl);
|
2004-09-29 10:50:30 +00:00
|
|
|
default:
|
|
|
|
lwerror("Unknown geometry type: %d", type);
|
2008-05-31 09:56:44 +00:00
|
|
|
|
2004-09-29 10:50:30 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2004-09-29 15:25:21 +00:00
|
|
|
size_t
|
|
|
|
lwgeom_serialize_size(LWGEOM *lwgeom)
|
2004-09-29 10:50:30 +00:00
|
|
|
{
|
2004-10-04 13:53:42 +00:00
|
|
|
int type = TYPE_GETTYPE(lwgeom->type);
|
2004-10-03 15:52:23 +00:00
|
|
|
|
2008-05-31 09:56:44 +00:00
|
|
|
LWDEBUGF(2, "lwgeom_serialize_size(%s) called", lwgeom_typename(type));
|
2004-09-29 10:50:30 +00:00
|
|
|
|
2004-09-29 15:25:21 +00:00
|
|
|
switch (type)
|
|
|
|
{
|
|
|
|
case POINTTYPE:
|
2004-10-03 15:52:23 +00:00
|
|
|
return lwpoint_serialize_size((LWPOINT *)lwgeom);
|
2004-09-29 15:25:21 +00:00
|
|
|
case LINETYPE:
|
2004-10-03 15:52:23 +00:00
|
|
|
return lwline_serialize_size((LWLINE *)lwgeom);
|
2004-09-29 15:25:21 +00:00
|
|
|
case POLYGONTYPE:
|
2004-10-03 15:52:23 +00:00
|
|
|
return lwpoly_serialize_size((LWPOLY *)lwgeom);
|
2006-12-01 22:16:44 +00:00
|
|
|
case CURVETYPE:
|
|
|
|
return lwcurve_serialize_size((LWCURVE *)lwgeom);
|
|
|
|
case CURVEPOLYTYPE:
|
|
|
|
case COMPOUNDTYPE:
|
2004-09-29 15:25:21 +00:00
|
|
|
case MULTIPOINTTYPE:
|
|
|
|
case MULTILINETYPE:
|
2006-12-01 22:16:44 +00:00
|
|
|
case MULTICURVETYPE:
|
2004-09-29 15:25:21 +00:00
|
|
|
case MULTIPOLYGONTYPE:
|
2006-12-01 22:16:44 +00:00
|
|
|
case MULTISURFACETYPE:
|
2004-09-29 15:25:21 +00:00
|
|
|
case COLLECTIONTYPE:
|
2004-10-03 15:52:23 +00:00
|
|
|
return lwcollection_serialize_size((LWCOLLECTION *)lwgeom);
|
2004-09-29 15:25:21 +00:00
|
|
|
default:
|
|
|
|
lwerror("Unknown geometry type: %d", type);
|
2008-05-31 09:56:44 +00:00
|
|
|
|
2004-09-29 15:25:21 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2004-09-29 10:50:30 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2005-02-10 10:52:53 +00:00
|
|
|
lwgeom_serialize_buf(LWGEOM *lwgeom, uchar *buf, size_t *retsize)
|
2004-09-29 10:50:30 +00:00
|
|
|
{
|
2004-10-04 13:53:42 +00:00
|
|
|
int type = TYPE_GETTYPE(lwgeom->type);
|
2004-09-29 10:50:30 +00:00
|
|
|
|
2008-05-31 09:56:44 +00:00
|
|
|
LWDEBUGF(2, "lwgeom_serialize_buf called with a %s",
|
2004-10-03 15:52:23 +00:00
|
|
|
lwgeom_typename(type));
|
2008-05-31 09:56:44 +00:00
|
|
|
|
2004-09-29 15:25:21 +00:00
|
|
|
switch (type)
|
2004-09-29 10:50:30 +00:00
|
|
|
{
|
2004-09-29 15:25:21 +00:00
|
|
|
case POINTTYPE:
|
2004-09-30 15:42:28 +00:00
|
|
|
lwpoint_serialize_buf((LWPOINT *)lwgeom, buf, retsize);
|
2004-09-29 15:25:21 +00:00
|
|
|
break;
|
|
|
|
case LINETYPE:
|
2004-09-30 15:42:28 +00:00
|
|
|
lwline_serialize_buf((LWLINE *)lwgeom, buf, retsize);
|
2004-09-29 15:25:21 +00:00
|
|
|
break;
|
|
|
|
case POLYGONTYPE:
|
2004-09-30 15:42:28 +00:00
|
|
|
lwpoly_serialize_buf((LWPOLY *)lwgeom, buf, retsize);
|
2004-09-29 15:25:21 +00:00
|
|
|
break;
|
2006-12-01 22:16:44 +00:00
|
|
|
case CURVETYPE:
|
|
|
|
lwcurve_serialize_buf((LWCURVE *)lwgeom, buf, retsize);
|
|
|
|
break;
|
|
|
|
case CURVEPOLYTYPE:
|
|
|
|
case COMPOUNDTYPE:
|
2004-09-29 15:25:21 +00:00
|
|
|
case MULTIPOINTTYPE:
|
|
|
|
case MULTILINETYPE:
|
2006-12-01 22:16:44 +00:00
|
|
|
case MULTICURVETYPE:
|
2004-09-29 15:25:21 +00:00
|
|
|
case MULTIPOLYGONTYPE:
|
2006-12-01 22:16:44 +00:00
|
|
|
case MULTISURFACETYPE:
|
2004-09-29 15:25:21 +00:00
|
|
|
case COLLECTIONTYPE:
|
2004-09-30 15:42:28 +00:00
|
|
|
lwcollection_serialize_buf((LWCOLLECTION *)lwgeom, buf,
|
|
|
|
retsize);
|
2004-09-29 15:25:21 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
lwerror("Unknown geometry type: %d", type);
|
|
|
|
return;
|
2004-09-29 10:50:30 +00:00
|
|
|
}
|
2004-09-29 15:25:21 +00:00
|
|
|
return;
|
2004-09-29 10:50:30 +00:00
|
|
|
}
|
|
|
|
|
2005-02-10 10:52:53 +00:00
|
|
|
uchar *
|
2004-09-30 15:42:28 +00:00
|
|
|
lwgeom_serialize(LWGEOM *lwgeom)
|
2004-09-29 10:50:30 +00:00
|
|
|
{
|
2004-09-29 15:25:21 +00:00
|
|
|
size_t size = lwgeom_serialize_size(lwgeom);
|
|
|
|
size_t retsize;
|
2005-02-10 10:52:53 +00:00
|
|
|
uchar *serialized = lwalloc(size);
|
2004-09-29 10:50:30 +00:00
|
|
|
|
2004-09-30 15:42:28 +00:00
|
|
|
lwgeom_serialize_buf(lwgeom, serialized, &retsize);
|
2004-09-29 15:25:21 +00:00
|
|
|
|
2008-05-31 09:56:44 +00:00
|
|
|
#if POSTGIS_DEBUG_LEVEL > 0
|
2004-09-29 15:25:21 +00:00
|
|
|
if ( retsize != size )
|
2004-09-29 10:50:30 +00:00
|
|
|
{
|
2004-09-29 15:25:21 +00:00
|
|
|
lwerror("lwgeom_serialize: computed size %d, returned size %d",
|
|
|
|
size, retsize);
|
2004-09-29 10:50:30 +00:00
|
|
|
}
|
2004-09-29 15:25:21 +00:00
|
|
|
#endif
|
2004-09-29 10:50:30 +00:00
|
|
|
|
2004-09-29 15:25:21 +00:00
|
|
|
return serialized;
|
2004-09-29 10:50:30 +00:00
|
|
|
}
|
|
|
|
|
2005-12-30 17:40:37 +00:00
|
|
|
/* Force Right-hand-rule on LWGEOM polygons */
|
2004-09-30 08:18:06 +00:00
|
|
|
void
|
|
|
|
lwgeom_forceRHR(LWGEOM *lwgeom)
|
|
|
|
{
|
|
|
|
LWCOLLECTION *coll;
|
|
|
|
int i;
|
|
|
|
|
2004-10-04 13:53:42 +00:00
|
|
|
switch (TYPE_GETTYPE(lwgeom->type))
|
2004-09-30 08:18:06 +00:00
|
|
|
{
|
|
|
|
case POLYGONTYPE:
|
2006-03-12 17:13:30 +00:00
|
|
|
lwpoly_forceRHR((LWPOLY *)lwgeom);
|
2004-09-30 08:18:06 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
case MULTIPOLYGONTYPE:
|
|
|
|
case COLLECTIONTYPE:
|
|
|
|
coll = (LWCOLLECTION *)lwgeom;
|
|
|
|
for (i=0; i<coll->ngeoms; i++)
|
|
|
|
lwgeom_forceRHR(coll->geoms[i]);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-12-30 17:40:37 +00:00
|
|
|
/* Reverse vertex order of LWGEOM */
|
2004-09-30 08:18:06 +00:00
|
|
|
void
|
|
|
|
lwgeom_reverse(LWGEOM *lwgeom)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
LWCOLLECTION *col;
|
|
|
|
|
2004-10-04 13:53:42 +00:00
|
|
|
switch (TYPE_GETTYPE(lwgeom->type))
|
2004-09-30 08:18:06 +00:00
|
|
|
{
|
|
|
|
case LINETYPE:
|
|
|
|
lwline_reverse((LWLINE *)lwgeom);
|
|
|
|
return;
|
|
|
|
case POLYGONTYPE:
|
|
|
|
lwpoly_reverse((LWPOLY *)lwgeom);
|
|
|
|
return;
|
|
|
|
case MULTILINETYPE:
|
|
|
|
case MULTIPOLYGONTYPE:
|
|
|
|
case COLLECTIONTYPE:
|
|
|
|
col = (LWCOLLECTION *)lwgeom;
|
|
|
|
for (i=0; i<col->ngeoms; i++)
|
|
|
|
lwgeom_reverse(col->geoms[i]);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-09-30 15:42:28 +00:00
|
|
|
int
|
2005-03-18 12:36:27 +00:00
|
|
|
lwgeom_compute_box2d_p(LWGEOM *lwgeom, BOX2DFLOAT4 *buf)
|
2004-09-30 15:42:28 +00:00
|
|
|
{
|
2008-05-31 09:56:44 +00:00
|
|
|
LWDEBUGF(2, "lwgeom_compute_box2d_p called of %p of type %d.", lwgeom, TYPE_GETTYPE(lwgeom->type));
|
|
|
|
|
2004-10-04 13:53:42 +00:00
|
|
|
switch(TYPE_GETTYPE(lwgeom->type))
|
2004-09-30 15:42:28 +00:00
|
|
|
{
|
|
|
|
case POINTTYPE:
|
2005-03-18 12:36:27 +00:00
|
|
|
return lwpoint_compute_box2d_p((LWPOINT *)lwgeom, buf);
|
2004-09-30 15:42:28 +00:00
|
|
|
case LINETYPE:
|
2005-03-18 12:36:27 +00:00
|
|
|
return lwline_compute_box2d_p((LWLINE *)lwgeom, buf);
|
2006-12-01 22:16:44 +00:00
|
|
|
case CURVETYPE:
|
|
|
|
return lwcurve_compute_box2d_p((LWCURVE *)lwgeom, buf);
|
2004-09-30 15:42:28 +00:00
|
|
|
case POLYGONTYPE:
|
2005-03-18 12:36:27 +00:00
|
|
|
return lwpoly_compute_box2d_p((LWPOLY *)lwgeom, buf);
|
2006-12-01 22:16:44 +00:00
|
|
|
case COMPOUNDTYPE:
|
|
|
|
case CURVEPOLYTYPE:
|
2004-09-30 15:42:28 +00:00
|
|
|
case MULTIPOINTTYPE:
|
|
|
|
case MULTILINETYPE:
|
2006-12-01 22:16:44 +00:00
|
|
|
case MULTICURVETYPE:
|
2004-09-30 15:42:28 +00:00
|
|
|
case MULTIPOLYGONTYPE:
|
2006-12-01 22:16:44 +00:00
|
|
|
case MULTISURFACETYPE:
|
2004-09-30 15:42:28 +00:00
|
|
|
case COLLECTIONTYPE:
|
2005-03-18 12:36:27 +00:00
|
|
|
return lwcollection_compute_box2d_p((LWCOLLECTION *)lwgeom, buf);
|
2004-09-30 15:42:28 +00:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-12-30 17:40:37 +00:00
|
|
|
/*
|
|
|
|
* dont forget to lwfree() result
|
|
|
|
*/
|
2004-09-30 15:42:28 +00:00
|
|
|
BOX2DFLOAT4 *
|
2005-03-18 12:36:27 +00:00
|
|
|
lwgeom_compute_box2d(LWGEOM *lwgeom)
|
2004-09-30 15:42:28 +00:00
|
|
|
{
|
|
|
|
BOX2DFLOAT4 *result = lwalloc(sizeof(BOX2DFLOAT4));
|
2005-03-18 12:36:27 +00:00
|
|
|
if ( lwgeom_compute_box2d_p(lwgeom, result) ) return result;
|
|
|
|
else {
|
|
|
|
lwfree(result);
|
|
|
|
return NULL;
|
|
|
|
}
|
2004-09-30 15:42:28 +00:00
|
|
|
}
|
2004-10-01 07:51:00 +00:00
|
|
|
|
|
|
|
LWPOINT *
|
|
|
|
lwgeom_as_lwpoint(LWGEOM *lwgeom)
|
|
|
|
{
|
2005-12-13 18:19:34 +00:00
|
|
|
if ( TYPE_GETTYPE(lwgeom->type) == POINTTYPE )
|
|
|
|
return (LWPOINT *)lwgeom;
|
2004-10-01 07:51:00 +00:00
|
|
|
else return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
LWLINE *
|
|
|
|
lwgeom_as_lwline(LWGEOM *lwgeom)
|
|
|
|
{
|
2005-12-13 18:19:34 +00:00
|
|
|
if ( TYPE_GETTYPE(lwgeom->type) == LINETYPE )
|
|
|
|
return (LWLINE *)lwgeom;
|
2004-10-01 07:51:00 +00:00
|
|
|
else return NULL;
|
|
|
|
}
|
|
|
|
|
2006-12-01 22:16:44 +00:00
|
|
|
LWCURVE *
|
|
|
|
lwgeom_as_lwcurve(LWGEOM *lwgeom)
|
|
|
|
{
|
|
|
|
if( TYPE_GETTYPE(lwgeom->type) == CURVETYPE )
|
|
|
|
return (LWCURVE *)lwgeom;
|
|
|
|
else return NULL;
|
|
|
|
}
|
|
|
|
|
2004-10-01 07:51:00 +00:00
|
|
|
LWPOLY *
|
|
|
|
lwgeom_as_lwpoly(LWGEOM *lwgeom)
|
|
|
|
{
|
2005-12-13 18:19:34 +00:00
|
|
|
if ( TYPE_GETTYPE(lwgeom->type) == POLYGONTYPE )
|
|
|
|
return (LWPOLY *)lwgeom;
|
2004-10-01 07:51:00 +00:00
|
|
|
else return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
LWCOLLECTION *
|
|
|
|
lwgeom_as_lwcollection(LWGEOM *lwgeom)
|
|
|
|
{
|
2006-12-01 22:16:44 +00:00
|
|
|
if ( TYPE_GETTYPE(lwgeom->type) >= MULTIPOINTTYPE
|
|
|
|
&& TYPE_GETTYPE(lwgeom->type) <= COLLECTIONTYPE)
|
2004-10-08 13:20:55 +00:00
|
|
|
return (LWCOLLECTION *)lwgeom;
|
2004-10-01 07:51:00 +00:00
|
|
|
else return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
LWMPOINT *
|
|
|
|
lwgeom_as_lwmpoint(LWGEOM *lwgeom)
|
|
|
|
{
|
2005-12-13 18:19:34 +00:00
|
|
|
if ( TYPE_GETTYPE(lwgeom->type) == MULTIPOINTTYPE )
|
|
|
|
return (LWMPOINT *)lwgeom;
|
2004-10-01 07:51:00 +00:00
|
|
|
else return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
LWMLINE *
|
|
|
|
lwgeom_as_lwmline(LWGEOM *lwgeom)
|
|
|
|
{
|
2005-12-13 18:19:34 +00:00
|
|
|
if ( TYPE_GETTYPE(lwgeom->type) == MULTILINETYPE )
|
|
|
|
return (LWMLINE *)lwgeom;
|
2004-10-01 07:51:00 +00:00
|
|
|
else return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
LWMPOLY *
|
|
|
|
lwgeom_as_lwmpoly(LWGEOM *lwgeom)
|
|
|
|
{
|
2005-12-13 18:19:34 +00:00
|
|
|
if ( TYPE_GETTYPE(lwgeom->type) == MULTIPOLYGONTYPE )
|
|
|
|
return (LWMPOLY *)lwgeom;
|
2004-10-01 07:51:00 +00:00
|
|
|
else return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
LWGEOM *lwmpoly_as_lwgeom(LWMPOLY *obj) { return (LWGEOM *)obj; }
|
|
|
|
LWGEOM *lwmline_as_lwgeom(LWMLINE *obj) { return (LWGEOM *)obj; }
|
|
|
|
LWGEOM *lwmpoint_as_lwgeom(LWMPOINT *obj) { return (LWGEOM *)obj; }
|
|
|
|
LWGEOM *lwcollection_as_lwgeom(LWCOLLECTION *obj) { return (LWGEOM *)obj; }
|
|
|
|
LWGEOM *lwpoly_as_lwgeom(LWPOLY *obj) { return (LWGEOM *)obj; }
|
|
|
|
LWGEOM *lwline_as_lwgeom(LWLINE *obj) { return (LWGEOM *)obj; }
|
|
|
|
LWGEOM *lwpoint_as_lwgeom(LWPOINT *obj) { return (LWGEOM *)obj; }
|
2004-10-01 14:49:34 +00:00
|
|
|
|
|
|
|
void
|
|
|
|
lwgeom_release(LWGEOM *lwgeom)
|
|
|
|
{
|
|
|
|
uint32 i;
|
|
|
|
LWCOLLECTION *col;
|
|
|
|
|
2004-10-08 13:20:55 +00:00
|
|
|
#ifdef INTEGRITY_CHECKS
|
|
|
|
if ( ! lwgeom )
|
|
|
|
lwerror("lwgeom_release: someone called on 0x0");
|
|
|
|
#endif
|
|
|
|
|
2005-12-30 17:40:37 +00:00
|
|
|
/* Drop bounding box (always a copy) */
|
2006-12-01 22:16:44 +00:00
|
|
|
if ( lwgeom->bbox ) {
|
2008-05-31 09:56:44 +00:00
|
|
|
LWDEBUG(3, "lwgeom_release: releasing bbox.");
|
|
|
|
|
2006-12-01 22:16:44 +00:00
|
|
|
lwfree(lwgeom->bbox);
|
|
|
|
}
|
2005-11-14 09:01:15 +00:00
|
|
|
|
2005-12-30 17:40:37 +00:00
|
|
|
/* Collection */
|
2004-10-01 14:49:34 +00:00
|
|
|
if ( (col=lwgeom_as_lwcollection(lwgeom)) )
|
|
|
|
{
|
2008-05-31 09:56:44 +00:00
|
|
|
LWDEBUG(3, "lwgeom_release: Releasing collection.");
|
2006-12-01 22:16:44 +00:00
|
|
|
|
2004-10-01 14:49:34 +00:00
|
|
|
for (i=0; i<col->ngeoms; i++)
|
|
|
|
{
|
|
|
|
lwgeom_release(col->geoms[i]);
|
|
|
|
}
|
|
|
|
lwfree(lwgeom);
|
|
|
|
}
|
|
|
|
|
2005-12-30 17:40:37 +00:00
|
|
|
/* Single element */
|
2004-10-01 14:49:34 +00:00
|
|
|
else lwfree(lwgeom);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2005-12-30 17:40:37 +00:00
|
|
|
/* Clone an LWGEOM object. POINTARRAY are not copied. */
|
2004-10-01 14:49:34 +00:00
|
|
|
LWGEOM *
|
|
|
|
lwgeom_clone(const LWGEOM *lwgeom)
|
|
|
|
{
|
2008-05-31 09:56:44 +00:00
|
|
|
LWDEBUGF(2, "lwgeom_clone called with %p, %d", lwgeom, TYPE_GETTYPE(lwgeom->type));
|
|
|
|
|
2004-10-04 13:53:42 +00:00
|
|
|
switch(TYPE_GETTYPE(lwgeom->type))
|
2004-10-01 14:49:34 +00:00
|
|
|
{
|
|
|
|
case POINTTYPE:
|
|
|
|
return (LWGEOM *)lwpoint_clone((LWPOINT *)lwgeom);
|
|
|
|
case LINETYPE:
|
|
|
|
return (LWGEOM *)lwline_clone((LWLINE *)lwgeom);
|
2007-05-28 15:34:04 +00:00
|
|
|
case CURVETYPE:
|
|
|
|
return (LWGEOM *)lwcurve_clone((LWCURVE *)lwgeom);
|
2004-10-01 14:49:34 +00:00
|
|
|
case POLYGONTYPE:
|
|
|
|
return (LWGEOM *)lwpoly_clone((LWPOLY *)lwgeom);
|
2007-05-28 15:34:04 +00:00
|
|
|
case COMPOUNDTYPE:
|
|
|
|
case CURVEPOLYTYPE:
|
2004-10-01 14:49:34 +00:00
|
|
|
case MULTIPOINTTYPE:
|
|
|
|
case MULTILINETYPE:
|
2007-05-28 15:34:04 +00:00
|
|
|
case MULTICURVETYPE:
|
2004-10-01 14:49:34 +00:00
|
|
|
case MULTIPOLYGONTYPE:
|
2007-05-28 15:34:04 +00:00
|
|
|
case MULTISURFACETYPE:
|
2004-10-01 14:49:34 +00:00
|
|
|
case COLLECTIONTYPE:
|
|
|
|
return (LWGEOM *)lwcollection_clone((LWCOLLECTION *)lwgeom);
|
|
|
|
default:
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-12-30 17:40:37 +00:00
|
|
|
/*
|
|
|
|
* Add 'what' to 'to' at position 'where'
|
|
|
|
*
|
|
|
|
* where=0 == prepend
|
|
|
|
* where=-1 == append
|
|
|
|
* Appended-to LWGEOM gets a new type based on new condition.
|
|
|
|
* Mix of dimensions is not allowed (TODO: allow it?).
|
|
|
|
*/
|
2004-10-01 14:49:34 +00:00
|
|
|
LWGEOM *
|
|
|
|
lwgeom_add(const LWGEOM *to, uint32 where, const LWGEOM *what)
|
|
|
|
{
|
2004-10-04 13:53:42 +00:00
|
|
|
if ( TYPE_NDIMS(what->type) != TYPE_NDIMS(to->type) )
|
2004-10-01 14:49:34 +00:00
|
|
|
{
|
|
|
|
lwerror("lwgeom_add: mixed dimensions not supported");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2008-05-31 09:56:44 +00:00
|
|
|
LWDEBUGF(2, "lwgeom_add(%s, %d, %s) called",
|
2004-10-11 09:32:44 +00:00
|
|
|
lwgeom_typename(TYPE_GETTYPE(to->type)),
|
|
|
|
where,
|
|
|
|
lwgeom_typename(TYPE_GETTYPE(what->type)));
|
|
|
|
|
2004-10-04 13:53:42 +00:00
|
|
|
switch(TYPE_GETTYPE(to->type))
|
2004-10-01 14:49:34 +00:00
|
|
|
{
|
|
|
|
case POINTTYPE:
|
|
|
|
return (LWGEOM *)lwpoint_add((const LWPOINT *)to, where, what);
|
|
|
|
case LINETYPE:
|
|
|
|
return (LWGEOM *)lwline_add((const LWLINE *)to, where, what);
|
2006-12-01 22:16:44 +00:00
|
|
|
|
|
|
|
case CURVETYPE:
|
|
|
|
return (LWGEOM *)lwcurve_add((const LWCURVE *)to, where, what);
|
|
|
|
|
2004-10-01 14:49:34 +00:00
|
|
|
case POLYGONTYPE:
|
|
|
|
return (LWGEOM *)lwpoly_add((const LWPOLY *)to, where, what);
|
|
|
|
|
2006-12-01 22:16:44 +00:00
|
|
|
case COMPOUNDTYPE:
|
|
|
|
return (LWGEOM *)lwcompound_add((const LWCOMPOUND *)to, where, what);
|
|
|
|
|
|
|
|
case CURVEPOLYTYPE:
|
|
|
|
return (LWGEOM *)lwcurvepoly_add((const LWCURVEPOLY *)to, where, what);
|
|
|
|
|
2004-10-01 14:49:34 +00:00
|
|
|
case MULTIPOINTTYPE:
|
2004-10-11 09:32:44 +00:00
|
|
|
return (LWGEOM *)lwmpoint_add((const LWMPOINT *)to,
|
|
|
|
where, what);
|
|
|
|
|
2004-10-01 14:49:34 +00:00
|
|
|
case MULTILINETYPE:
|
2004-10-11 09:32:44 +00:00
|
|
|
return (LWGEOM *)lwmline_add((const LWMLINE *)to,
|
|
|
|
where, what);
|
|
|
|
|
2006-12-01 22:16:44 +00:00
|
|
|
case MULTICURVETYPE:
|
|
|
|
return (LWGEOM *)lwmcurve_add((const LWMCURVE *)to,
|
|
|
|
where, what);
|
|
|
|
|
2004-10-01 14:49:34 +00:00
|
|
|
case MULTIPOLYGONTYPE:
|
2004-10-11 09:32:44 +00:00
|
|
|
return (LWGEOM *)lwmpoly_add((const LWMPOLY *)to,
|
|
|
|
where, what);
|
|
|
|
|
2006-12-01 22:16:44 +00:00
|
|
|
case MULTISURFACETYPE:
|
|
|
|
return (LWGEOM *)lwmsurface_add((const LWMSURFACE *)to,
|
|
|
|
where, what);
|
|
|
|
|
2004-10-11 09:32:44 +00:00
|
|
|
case COLLECTIONTYPE:
|
|
|
|
return (LWGEOM *)lwcollection_add(
|
|
|
|
(const LWCOLLECTION *)to, where, what);
|
|
|
|
|
2004-10-01 14:49:34 +00:00
|
|
|
default:
|
2004-10-11 09:32:44 +00:00
|
|
|
lwerror("lwgeom_add: unknown geometry type: %d",
|
|
|
|
TYPE_GETTYPE(to->type));
|
2004-10-01 14:49:34 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
}
|
2004-10-03 15:52:23 +00:00
|
|
|
|
2008-07-13 10:50:56 +00:00
|
|
|
|
2004-10-07 10:03:23 +00:00
|
|
|
/*
|
|
|
|
* Return an alloced string
|
|
|
|
*/
|
|
|
|
char *
|
2008-09-25 21:50:19 +00:00
|
|
|
lwgeom_to_ewkt(LWGEOM *lwgeom, int flags)
|
2004-10-07 10:03:23 +00:00
|
|
|
{
|
2008-09-28 19:48:17 +00:00
|
|
|
LWGEOM_UNPARSER_RESULT lwg_unparser_result;
|
2005-02-10 10:52:53 +00:00
|
|
|
uchar *serialized = lwgeom_serialize(lwgeom);
|
2008-09-28 19:48:17 +00:00
|
|
|
int result;
|
|
|
|
|
2004-10-07 10:03:23 +00:00
|
|
|
if ( ! serialized ) {
|
|
|
|
lwerror("Error serializing geom %p", lwgeom);
|
|
|
|
}
|
2008-09-28 19:48:17 +00:00
|
|
|
|
|
|
|
result = unparse_WKT(&lwg_unparser_result, serialized, lwalloc, lwfree, flags);
|
2004-10-07 10:03:23 +00:00
|
|
|
lwfree(serialized);
|
2008-09-28 19:48:17 +00:00
|
|
|
|
|
|
|
return lwg_unparser_result.wkoutput;
|
2004-10-07 10:03:23 +00:00
|
|
|
}
|
|
|
|
|
2004-10-11 14:03:33 +00:00
|
|
|
/*
|
|
|
|
* Return an alloced string
|
|
|
|
*/
|
|
|
|
char *
|
2008-09-25 21:50:19 +00:00
|
|
|
lwgeom_to_hexwkb(LWGEOM *lwgeom, int flags, unsigned int byteorder)
|
2004-10-11 14:03:33 +00:00
|
|
|
{
|
2008-09-28 19:48:17 +00:00
|
|
|
LWGEOM_UNPARSER_RESULT lwg_unparser_result;
|
2005-02-10 10:52:53 +00:00
|
|
|
uchar *serialized = lwgeom_serialize(lwgeom);
|
2008-09-28 19:48:17 +00:00
|
|
|
int result;
|
|
|
|
|
|
|
|
result = unparse_WKB(&lwg_unparser_result, serialized, lwalloc, lwfree, flags, byteorder,1);
|
|
|
|
|
2004-10-11 14:03:33 +00:00
|
|
|
lwfree(serialized);
|
2008-09-28 19:48:17 +00:00
|
|
|
return lwg_unparser_result.wkoutput;
|
2004-10-11 14:03:33 +00:00
|
|
|
}
|
|
|
|
|
2005-09-23 16:43:56 +00:00
|
|
|
/*
|
|
|
|
* Return an alloced string
|
|
|
|
*/
|
|
|
|
uchar *
|
2008-09-25 21:50:19 +00:00
|
|
|
lwgeom_to_ewkb(LWGEOM *lwgeom, int flags, char byteorder, size_t *outsize)
|
2005-09-23 16:43:56 +00:00
|
|
|
{
|
2008-09-28 19:48:17 +00:00
|
|
|
LWGEOM_UNPARSER_RESULT lwg_unparser_result;
|
2005-09-23 16:43:56 +00:00
|
|
|
uchar *serialized = lwgeom_serialize(lwgeom);
|
2008-09-28 19:48:17 +00:00
|
|
|
int result;
|
2005-12-30 17:40:37 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* We cast return to "unsigned" char as we are
|
|
|
|
* requesting a "binary" output, not HEX
|
|
|
|
* (last argument set to 0)
|
|
|
|
*/
|
2008-09-28 19:48:17 +00:00
|
|
|
result = unparse_WKB(&lwg_unparser_result, serialized, lwalloc, lwfree,
|
|
|
|
flags, byteorder, 0);
|
2005-09-23 16:43:56 +00:00
|
|
|
lwfree(serialized);
|
2008-09-28 19:48:17 +00:00
|
|
|
return (uchar *)lwg_unparser_result.wkoutput;
|
2005-09-23 16:43:56 +00:00
|
|
|
}
|
|
|
|
|
2005-12-30 17:40:37 +00:00
|
|
|
/*
|
|
|
|
* Make an LWGEOM object from a EWKB binary representation.
|
|
|
|
* Currently highly unoptimized as it:
|
|
|
|
* - convert EWKB to HEXEWKB
|
|
|
|
* - construct PG_LWGEOM
|
|
|
|
* - deserialize it
|
|
|
|
*/
|
2005-09-23 16:43:56 +00:00
|
|
|
LWGEOM *
|
2008-09-25 21:50:19 +00:00
|
|
|
lwgeom_from_ewkb(uchar *ewkb, int flags, size_t size)
|
2005-09-23 16:43:56 +00:00
|
|
|
{
|
2005-12-30 17:40:37 +00:00
|
|
|
size_t hexewkblen = size*2;
|
|
|
|
char *hexewkb;
|
|
|
|
long int i;
|
2008-09-28 15:32:46 +00:00
|
|
|
int result;
|
2005-12-30 17:40:37 +00:00
|
|
|
LWGEOM *ret;
|
2008-09-28 15:32:46 +00:00
|
|
|
LWGEOM_PARSER_RESULT lwg_parser_result;
|
2005-12-30 17:40:37 +00:00
|
|
|
|
|
|
|
/* "HEXify" the EWKB */
|
|
|
|
hexewkb = lwalloc(hexewkblen+1);
|
|
|
|
for (i=0; i<size; ++i) deparse_hex(ewkb[i], &hexewkb[i*2]);
|
|
|
|
hexewkb[hexewkblen] = '\0';
|
|
|
|
|
2007-05-31 13:18:04 +00:00
|
|
|
/* Rely on grammar parser to construct a LWGEOM */
|
2008-09-28 15:32:46 +00:00
|
|
|
result = serialized_lwgeom_from_ewkt(&lwg_parser_result, hexewkb, flags);
|
2005-12-30 17:40:37 +00:00
|
|
|
|
|
|
|
/* Free intermediate HEXified representation */
|
|
|
|
lwfree(hexewkb);
|
|
|
|
|
|
|
|
/* Deserialize */
|
2008-09-28 16:18:12 +00:00
|
|
|
ret = lwgeom_deserialize(lwg_parser_result.serialized_lwgeom);
|
2005-12-30 17:40:37 +00:00
|
|
|
|
2005-09-23 16:43:56 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-07-13 10:50:56 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Parser functions for working with serialized LWGEOMs. Useful for cases where
|
|
|
|
* the function input is already serialized, e.g. some input and output functions
|
|
|
|
*/
|
|
|
|
|
2008-09-07 11:02:05 +00:00
|
|
|
/*
|
|
|
|
* Make a serialzed LWGEOM object from a WKT input string
|
|
|
|
*/
|
2008-09-28 15:32:46 +00:00
|
|
|
int
|
|
|
|
serialized_lwgeom_from_ewkt(LWGEOM_PARSER_RESULT *lwg_parser_result, char *wkt_input, int flags)
|
2008-09-07 11:02:05 +00:00
|
|
|
{
|
|
|
|
|
2008-09-28 15:32:46 +00:00
|
|
|
int result = parse_lwg(lwg_parser_result, wkt_input, flags,
|
|
|
|
lwalloc, lwerror);
|
2008-09-07 11:02:05 +00:00
|
|
|
|
|
|
|
LWDEBUGF(2, "serialized_lwgeom_from_ewkt with %s",wkt_input);
|
|
|
|
|
2008-09-28 15:32:46 +00:00
|
|
|
return result;
|
2008-09-07 11:02:05 +00:00
|
|
|
}
|
|
|
|
|
2008-07-13 10:50:56 +00:00
|
|
|
/*
|
|
|
|
* Return an alloced string
|
|
|
|
*/
|
2008-09-28 19:48:17 +00:00
|
|
|
int
|
|
|
|
serialized_lwgeom_to_ewkt(LWGEOM_UNPARSER_RESULT *lwg_unparser_result, uchar *serialized, int flags)
|
2008-07-13 10:50:56 +00:00
|
|
|
{
|
2008-09-28 19:48:17 +00:00
|
|
|
int result;
|
|
|
|
|
|
|
|
result = unparse_WKT(lwg_unparser_result, serialized, lwalloc, lwfree, flags);
|
|
|
|
|
|
|
|
return result;
|
2008-07-13 10:50:56 +00:00
|
|
|
}
|
|
|
|
|
2008-10-31 10:41:37 +00:00
|
|
|
/*
|
|
|
|
* Return an alloced string
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
serialized_lwgeom_from_hexwkb(LWGEOM_PARSER_RESULT *lwg_parser_result, char *hexwkb_input, int flags)
|
|
|
|
{
|
|
|
|
/* NOTE: it is actually the same combined WKT/WKB parser that decodes HEXEWKB into LWGEOMs! */
|
|
|
|
int result = parse_lwg(lwg_parser_result, hexwkb_input, flags,
|
|
|
|
lwalloc, lwerror);
|
|
|
|
|
|
|
|
LWDEBUGF(2, "serialized_lwgeom_from_hexwkb with %s", hexwkb_input);
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2008-07-13 10:50:56 +00:00
|
|
|
/*
|
|
|
|
* Return an alloced string
|
|
|
|
*/
|
2008-09-28 19:48:17 +00:00
|
|
|
int
|
|
|
|
serialized_lwgeom_to_hexwkb(LWGEOM_UNPARSER_RESULT *lwg_unparser_result, uchar *serialized, int flags, unsigned int byteorder)
|
2008-07-13 10:50:56 +00:00
|
|
|
{
|
2008-09-28 19:48:17 +00:00
|
|
|
int result;
|
|
|
|
|
|
|
|
result = unparse_WKB(lwg_unparser_result, serialized, lwalloc, lwfree, flags, byteorder, 1);
|
|
|
|
|
|
|
|
return result;
|
2008-07-13 10:50:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Return an alloced string
|
|
|
|
*/
|
2008-09-28 19:48:17 +00:00
|
|
|
int
|
|
|
|
serialized_lwgeom_to_ewkb(LWGEOM_UNPARSER_RESULT *lwg_unparser_result, uchar *serialized, int flags, unsigned int byteorder)
|
2008-07-13 10:50:56 +00:00
|
|
|
{
|
2008-09-28 19:48:17 +00:00
|
|
|
int result;
|
|
|
|
|
|
|
|
result = unparse_WKB(lwg_unparser_result, serialized, lwalloc, lwfree, flags, byteorder, 0);
|
|
|
|
|
|
|
|
return result;
|
2008-07-13 10:50:56 +00:00
|
|
|
}
|
|
|
|
|
2005-12-30 17:40:37 +00:00
|
|
|
/*
|
|
|
|
* geom1 same as geom2
|
|
|
|
* iff
|
|
|
|
* + have same type
|
|
|
|
* + have same # objects
|
|
|
|
* + have same bvol
|
|
|
|
* + each object in geom1 has a corresponding object in geom2 (see above)
|
|
|
|
*/
|
2004-10-08 13:20:55 +00:00
|
|
|
char
|
2004-10-11 07:15:20 +00:00
|
|
|
lwgeom_same(const LWGEOM *lwgeom1, const LWGEOM *lwgeom2)
|
2004-10-08 13:20:55 +00:00
|
|
|
{
|
2008-05-31 09:56:44 +00:00
|
|
|
LWDEBUGF(2, "lwgeom_same(%s, %s) called",
|
|
|
|
lwgeom_typename(TYPE_GETTYPE(lwgeom1->type)),
|
|
|
|
lwgeom_typename(TYPE_GETTYPE(lwgeom2->type)));
|
2006-01-29 13:54:38 +00:00
|
|
|
|
2004-10-08 13:20:55 +00:00
|
|
|
if ( TYPE_GETTYPE(lwgeom1->type) != TYPE_GETTYPE(lwgeom2->type) )
|
2006-01-29 13:54:38 +00:00
|
|
|
{
|
2008-05-31 09:56:44 +00:00
|
|
|
LWDEBUG(3, " type differ");
|
|
|
|
|
2004-10-08 13:20:55 +00:00
|
|
|
return 0;
|
2006-01-29 13:54:38 +00:00
|
|
|
}
|
2004-10-08 13:20:55 +00:00
|
|
|
|
|
|
|
if ( TYPE_GETZM(lwgeom1->type) != TYPE_GETZM(lwgeom2->type) )
|
2006-01-29 13:54:38 +00:00
|
|
|
{
|
2008-05-31 09:56:44 +00:00
|
|
|
LWDEBUG(3, " ZM flags differ");
|
|
|
|
|
2004-10-08 13:20:55 +00:00
|
|
|
return 0;
|
2006-01-29 13:54:38 +00:00
|
|
|
}
|
2004-10-08 13:20:55 +00:00
|
|
|
|
2005-12-30 17:40:37 +00:00
|
|
|
/* Check boxes if both already computed */
|
2004-10-08 13:20:55 +00:00
|
|
|
if ( lwgeom1->bbox && lwgeom2->bbox )
|
|
|
|
{
|
2005-12-30 17:40:37 +00:00
|
|
|
/*lwnotice("bbox1:%p, bbox2:%p", lwgeom1->bbox, lwgeom2->bbox);*/
|
2006-01-29 13:54:38 +00:00
|
|
|
if ( ! box2d_same(lwgeom1->bbox, lwgeom2->bbox) )
|
|
|
|
{
|
2008-05-31 09:56:44 +00:00
|
|
|
LWDEBUG(3, " bounding boxes differ");
|
|
|
|
|
2006-01-29 13:54:38 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2004-10-08 13:20:55 +00:00
|
|
|
}
|
|
|
|
|
2005-12-30 17:40:37 +00:00
|
|
|
/* geoms have same type, invoke type-specific function */
|
2004-10-11 07:15:20 +00:00
|
|
|
switch(TYPE_GETTYPE(lwgeom1->type))
|
|
|
|
{
|
|
|
|
case POINTTYPE:
|
|
|
|
return lwpoint_same((LWPOINT *)lwgeom1,
|
|
|
|
(LWPOINT *)lwgeom2);
|
|
|
|
case LINETYPE:
|
|
|
|
return lwline_same((LWLINE *)lwgeom1,
|
|
|
|
(LWLINE *)lwgeom2);
|
|
|
|
case POLYGONTYPE:
|
|
|
|
return lwpoly_same((LWPOLY *)lwgeom1,
|
|
|
|
(LWPOLY *)lwgeom2);
|
|
|
|
case MULTIPOINTTYPE:
|
|
|
|
case MULTILINETYPE:
|
|
|
|
case MULTIPOLYGONTYPE:
|
|
|
|
case COLLECTIONTYPE:
|
|
|
|
return lwcollection_same((LWCOLLECTION *)lwgeom1,
|
|
|
|
(LWCOLLECTION *)lwgeom2);
|
|
|
|
default:
|
|
|
|
lwerror("lwgeom_same: unknown geometry type: %d",
|
|
|
|
TYPE_GETTYPE(lwgeom1->type));
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2004-10-08 13:20:55 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
lwgeom_changed(LWGEOM *lwgeom)
|
|
|
|
{
|
2005-11-14 09:01:15 +00:00
|
|
|
if ( lwgeom->bbox ) lwfree(lwgeom->bbox);
|
2004-10-08 13:20:55 +00:00
|
|
|
lwgeom->bbox = NULL;
|
|
|
|
TYPE_SETHASBBOX(lwgeom->type, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
lwgeom_dropBBOX(LWGEOM *lwgeom)
|
|
|
|
{
|
2005-11-14 09:01:15 +00:00
|
|
|
if ( lwgeom->bbox ) lwfree(lwgeom->bbox);
|
2004-10-08 13:20:55 +00:00
|
|
|
lwgeom->bbox = NULL;
|
2004-12-14 11:41:43 +00:00
|
|
|
TYPE_SETHASBBOX(lwgeom->type, 0);
|
2004-10-08 13:20:55 +00:00
|
|
|
}
|
|
|
|
|
2004-10-11 09:32:44 +00:00
|
|
|
/*
|
|
|
|
* Ensure there's a box in the LWGEOM.
|
|
|
|
* If the box is already there just return,
|
|
|
|
* else compute it.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
lwgeom_addBBOX(LWGEOM *lwgeom)
|
|
|
|
{
|
|
|
|
if ( lwgeom->bbox ) return;
|
2005-03-18 12:36:27 +00:00
|
|
|
lwgeom->bbox = lwgeom_compute_box2d(lwgeom);
|
2005-11-14 09:01:15 +00:00
|
|
|
TYPE_SETHASBBOX(lwgeom->type, 1);
|
2004-10-11 09:32:44 +00:00
|
|
|
}
|
|
|
|
|
2004-10-08 13:20:55 +00:00
|
|
|
void
|
|
|
|
lwgeom_dropSRID(LWGEOM *lwgeom)
|
|
|
|
{
|
|
|
|
TYPE_SETHASSRID(lwgeom->type, 0);
|
|
|
|
lwgeom->SRID = -1;
|
|
|
|
}
|
2004-10-10 20:31:23 +00:00
|
|
|
|
|
|
|
LWGEOM *
|
|
|
|
lwgeom_segmentize2d(LWGEOM *lwgeom, double dist)
|
|
|
|
{
|
|
|
|
switch(TYPE_GETTYPE(lwgeom->type))
|
|
|
|
{
|
|
|
|
case LINETYPE:
|
|
|
|
return (LWGEOM *)lwline_segmentize2d((LWLINE *)lwgeom,
|
|
|
|
dist);
|
|
|
|
case POLYGONTYPE:
|
|
|
|
return (LWGEOM *)lwpoly_segmentize2d((LWPOLY *)lwgeom,
|
|
|
|
dist);
|
|
|
|
case MULTILINETYPE:
|
|
|
|
case MULTIPOLYGONTYPE:
|
|
|
|
case COLLECTIONTYPE:
|
|
|
|
return (LWGEOM *)lwcollection_segmentize2d(
|
|
|
|
(LWCOLLECTION *)lwgeom, dist);
|
2005-12-01 13:53:14 +00:00
|
|
|
|
2004-10-10 20:31:23 +00:00
|
|
|
default:
|
2005-12-01 13:53:14 +00:00
|
|
|
return lwgeom_clone(lwgeom);
|
2004-10-10 20:31:23 +00:00
|
|
|
}
|
|
|
|
}
|
2005-10-25 11:38:28 +00:00
|
|
|
|
|
|
|
void
|
|
|
|
lwgeom_longitude_shift(LWGEOM *lwgeom)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
switch(TYPE_GETTYPE(lwgeom->type))
|
|
|
|
{
|
|
|
|
LWPOINT *point;
|
|
|
|
LWLINE *line;
|
|
|
|
LWPOLY *poly;
|
|
|
|
LWCOLLECTION *coll;
|
|
|
|
|
|
|
|
case POINTTYPE:
|
|
|
|
point = (LWPOINT *)lwgeom;
|
|
|
|
ptarray_longitude_shift(point->point);
|
|
|
|
return;
|
|
|
|
case LINETYPE:
|
|
|
|
line = (LWLINE *)lwgeom;
|
|
|
|
ptarray_longitude_shift(line->points);
|
|
|
|
return;
|
|
|
|
case POLYGONTYPE:
|
|
|
|
poly = (LWPOLY *)lwgeom;
|
|
|
|
for (i=0; i<poly->nrings; i++)
|
|
|
|
ptarray_longitude_shift(poly->rings[i]);
|
|
|
|
return;
|
|
|
|
case MULTILINETYPE:
|
|
|
|
case MULTIPOLYGONTYPE:
|
|
|
|
case COLLECTIONTYPE:
|
|
|
|
coll = (LWCOLLECTION *)lwgeom;
|
|
|
|
for (i=0; i<coll->ngeoms; i++)
|
|
|
|
lwgeom_longitude_shift(coll->geoms[i]);
|
|
|
|
return;
|
|
|
|
default:
|
|
|
|
lwerror("%s:%d: unknown geom type: %d",
|
|
|
|
__FILE__, __LINE__,
|
|
|
|
TYPE_GETTYPE(lwgeom->type));
|
|
|
|
}
|
|
|
|
}
|