self-hosted/postgis
self-hosted/postgis
1
0
Fork 0
mirror of https://git.osgeo.org/gitea/postgis/postgis synced 2024-10-25 01:22:47 +00:00
Code Issues Packages Projects Releases Wiki Activity
postgis/liblwgeom/lwgeom_api.c
Regina Obe 089c55720d fix commenting style so function descriptions are picked up by doxygen 
git-svn-id: http://svn.osgeo.org/postgis/trunk@4210 b70326c6-7e19-0410-871a-916f4a2858ee
2009-06-25 03:03:42 +00:00

2220 lines
44 KiB
C
Raw Blame History

#include <math.h>
#include <float.h>
#include <string.h>
#include <stdio.h>
#include <errno.h>
#include "liblwgeom.h"
#include "wktparse.h"
/*
* Lower this to reduce integrity checks
*/
#define PARANOIA_LEVEL 1
/**********************************************************************
* BOX routines
*
* returns the float thats very close to the input, but <=
* handles the funny differences in float4 and float8 reps.
**********************************************************************/
/*
* These are taken from glibc
* some machines do *not* have these functions defined, so we give
* an implementation of them here.
*/
typedef int int32_tt;
typedef unsigned int u_int32_tt;
typedef union
{
float value;
u_int32_tt word;
} ieee_float_shape_type;
#define GET_FLOAT_WORD(i,d) \
do { \
ieee_float_shape_type gf_u; \
gf_u.value = (d); \
(i) = gf_u.word; \
} while (0)
#define SET_FLOAT_WORD(d,i) \
do { \
ieee_float_shape_type sf_u; \
sf_u.word = (i); \
(d) = sf_u.value; \
} while (0)
/*
* Returns the next smaller or next larger float
* from x (in direction of y).
*/
float
nextafterf_custom(float x, float y)
{
int32_tt hx,hy,ix,iy;
GET_FLOAT_WORD(hx,x);
GET_FLOAT_WORD(hy,y);
ix = hx&0x7fffffff; /* |x| */
iy = hy&0x7fffffff; /* |y| */
if ((ix>0x7f800000) || /* x is nan */
(iy>0x7f800000)) /* y is nan */
return x+y;
if (x==y) return y; /* x=y, return y */
if (ix==0)
{ /* x == 0 */
SET_FLOAT_WORD(x,(hy&0x80000000)|1);/* return +-minsubnormal */
y = x*x;
if (y==x) return y;
else return x; /* raise underflow flag */
}
if (hx>=0)
{ /* x > 0 */
if (hx>hy)
{ /* x > y, x -= ulp */
hx -= 1;
}
else
{ /* x < y, x += ulp */
hx += 1;
}
}
else
{ /* x < 0 */
if (hy>=0||hx>hy)
{ /* x < y, x -= ulp */
hx -= 1;
}
else
{ /* x > y, x += ulp */
hx += 1;
}
}
hy = hx&0x7f800000;
if (hy>=0x7f800000) return x+x; /* overflow */
if (hy<0x00800000)
{ /* underflow */
y = x*x;
if (y!=x)
{ /* raise underflow flag */
SET_FLOAT_WORD(y,hx);
return y;
}
}
SET_FLOAT_WORD(x,hx);
return x;
}
float nextDown_f(double d)
{
float result = d;
if ( ((double) result) <=d)
return result;
return nextafterf_custom(result, result - 1000000);
}
/*
* Returns the float thats very close to the input, but >=.
* handles the funny differences in float4 and float8 reps.
*/
float
nextUp_f(double d)
{
float result = d;
if ( ((double) result) >=d)
return result;
return nextafterf_custom(result, result + 1000000);
}
/*
* Returns the double thats very close to the input, but <.
* handles the funny differences in float4 and float8 reps.
*/
double
nextDown_d(float d)
{
double result = d;
if ( result < d)
return result;
return nextafterf_custom(result, result - 1000000);
}
/*
* Returns the double thats very close to the input, but >
* handles the funny differences in float4 and float8 reps.
*/
double
nextUp_d(float d)
{
double result = d;
if ( result > d)
return result;
return nextafterf_custom(result, result + 1000000);
}
/*
* Convert BOX3D to BOX2D
* returned box2d is allocated with 'lwalloc'
*/
BOX2DFLOAT4 *
box3d_to_box2df(BOX3D *box)
{
BOX2DFLOAT4 *result = (BOX2DFLOAT4*) lwalloc(sizeof(BOX2DFLOAT4));
#if PARANOIA_LEVEL > 0
if (box == NULL)
{
lwerror("box3d_to_box2df got NUL box");
return NULL;
}
#endif
result->xmin = nextDown_f(box->xmin);
result->ymin = nextDown_f(box->ymin);
result->xmax = nextUp_f(box->xmax);
result->ymax = nextUp_f(box->ymax);
return result;
}
/*
* Convert BOX3D to BOX2D using pre-allocated BOX2D
* returned box2d is allocated with 'lwalloc'
* return 0 on error (NULL input box)
*/
int
box3d_to_box2df_p(BOX3D *box, BOX2DFLOAT4 *result)
{
#if PARANOIA_LEVEL > 0
if (box == NULL)
{
lwerror("box3d_to_box2df got NUL box");
return 0;
}
#endif
result->xmin = nextDown_f(box->xmin);
result->ymin = nextDown_f(box->ymin);
result->xmax = nextUp_f(box->xmax);
result->ymax = nextUp_f(box->ymax);
return 1;
}
/*
* Convert BOX2D to BOX3D
* zmin and zmax are set to NO_Z_VALUE
*/
BOX3D
box2df_to_box3d(BOX2DFLOAT4 *box)
{
BOX3D result;
#if PARANOIA_LEVEL > 0
if (box == NULL)
lwerror("box2df_to_box3d got NULL box");
#endif
result.xmin = box->xmin;
result.ymin = box->ymin;
result.xmax = box->xmax;
result.ymax = box->ymax;
result.zmin = result.zmax = NO_Z_VALUE;
return result;
}
/*
* Convert BOX2D to BOX3D, using pre-allocated BOX3D as output
* Z values are set to NO_Z_VALUE.
*/
void
box2df_to_box3d_p(BOX2DFLOAT4 *box, BOX3D *out)
{
if (box == NULL) return;
out->xmin = box->xmin;
out->ymin = box->ymin;
out->xmax = box->xmax;
out->ymax = box->ymax;
out->zmin = out->zmax = NO_Z_VALUE;
}
/*
* Returns a BOX3D that encloses b1 and b2
* box3d_union(NULL,A) --> A
* box3d_union(A,NULL) --> A
* box3d_union(A,B) --> A union B
*/
BOX3D *
box3d_union(BOX3D *b1, BOX3D *b2)
{
BOX3D *result;
result = lwalloc(sizeof(BOX3D));
if ( (b1 == NULL) && (b2 == NULL) )
{
return NULL;
}
if (b1 == NULL)
{
/*return b2 */
memcpy(result, b2, sizeof(BOX3D));
return result;
}
if (b2 == NULL)
{
/*return b1 */
memcpy(result, b1, sizeof(BOX3D));
return result;
}
if (b1->xmin < b2->xmin)
result->xmin = b1->xmin;
else
result->xmin = b2->xmin;
if (b1->ymin < b2->ymin)
result->ymin = b1->ymin;
else
result->ymin = b2->ymin;
if (b1->xmax > b2->xmax)
result->xmax = b1->xmax;
else
result->xmax = b2->xmax;
if (b1->ymax > b2->ymax)
result->ymax = b1->ymax;
else
result->ymax = b2->ymax;
if (b1->zmax > b2->zmax)
result->zmax = b1->zmax;
else
result->zmax = b2->zmax;
if (b1->zmin > b2->zmin)
result->zmin = b1->zmin;
else
result->zmin = b2->zmin;
return result;
}
/* Make given ubox a union of b1 and b2 */
int
box3d_union_p(BOX3D *b1, BOX3D *b2, BOX3D *ubox)
{
LWDEBUG(2, "box3d_union_p called: (xmin, xmax), (ymin, ymax), (zmin, zmax)");
LWDEBUGF(4, "b1: (%.16f, %.16f),(%.16f, %.16f),(%.16f, %.16f)", b1->xmin, b1->xmax, b1->ymin, b1->ymax, b1->zmin, b1->zmax);
LWDEBUGF(4, "b2: (%.16f, %.16f),(%.16f, %.16f),(%.16f, %.16f)", b2->xmin, b2->xmax, b2->ymin, b2->ymax, b2->zmin, b2->zmax);
if ( (b1 == NULL) && (b2 == NULL) )
{
return 0;
}
if (b1 == NULL)
{
memcpy(ubox, b2, sizeof(BOX3D));
return 1;
}
if (b2 == NULL)
{
memcpy(ubox, b1, sizeof(BOX3D));
return 1;
}
if (b1->xmin < b2->xmin)
ubox->xmin = b1->xmin;
else
ubox->xmin = b2->xmin;
if (b1->ymin < b2->ymin)
ubox->ymin = b1->ymin;
else
ubox->ymin = b2->ymin;
if (b1->xmax > b2->xmax)
ubox->xmax = b1->xmax;
else
ubox->xmax = b2->xmax;
if (b1->ymax > b2->ymax)
ubox->ymax = b1->ymax;
else
ubox->ymax = b2->ymax;
if (b1->zmax > b2->zmax)
ubox->zmax = b1->zmax;
else
ubox->zmax = b2->zmax;
if (b1->zmin < b2->zmin)
ubox->zmin = b1->zmin;
else
ubox->zmin = b2->zmin;
return 1;
}
#if 0 /* UNUSED */
/*
* Returns a pointer to internal storage, or NULL
* if the serialized form does not have a BBOX.
*/
BOX2DFLOAT4 *
getbox2d_internal(uchar *srl)
{
if (TYPE_HASBBOX(srl[0])) return (BOX2DFLOAT4 *)(srl+1);
else return NULL;
}
#endif /* UNUSED */
/*
* Same as getbox2d, but modifies box instead of returning result on the stack
*/
int
getbox2d_p(uchar *srl, BOX2DFLOAT4 *box)
{
uchar type = srl[0];
uchar *loc;
BOX3D box3d;
LWDEBUG(2, "getbox2d_p call");
loc = srl+1;
if (lwgeom_hasBBOX(type))
{
/*woot - this is easy */
LWDEBUG(4, "getbox2d_p: has box");
memcpy(box, loc, sizeof(BOX2DFLOAT4));
return 1;
}
LWDEBUG(4, "getbox2d_p: has no box - computing");
/* We have to actually compute it! */
if ( ! compute_serialized_box3d_p(srl, &box3d) ) return 0;
LWDEBUGF(4, "getbox2d_p: compute_serialized_box3d returned %p", box3d);
if ( ! box3d_to_box2df_p(&box3d, box) ) return 0;
LWDEBUG(4, "getbox2d_p: box3d converted to box2d");
return 1;
}
/************************************************************************
* POINTARRAY support functions
*
* TODO: should be moved to ptarray.c probably
*
************************************************************************/
/*
* Copies a point from the point array into the parameter point
* will set point's z=NO_Z_VALUE if pa is 2d
* will set point's m=NO_M_VALUE if pa is 3d or 2d
*
* NOTE: point is a real POINT3D *not* a pointer
*/
POINT4D
getPoint4d(const POINTARRAY *pa, int n)
{
POINT4D result;
getPoint4d_p(pa, n, &result);
return result;
}
/*
* Copies a point from the point array into the parameter point
* will set point's z=NO_Z_VALUE if pa is 2d
* will set point's m=NO_M_VALUE if pa is 3d or 2d
*
* NOTE: this will modify the point4d pointed to by 'point'.
*/
int
getPoint4d_p(const POINTARRAY *pa, int n, POINT4D *op)
{
uchar *ptr;
int zmflag;
#if PARANOIA_LEVEL > 0
if ( ! pa ) lwerror("getPoint4d_p: NULL pointarray");
if ( (n<0) || (n>=pa->npoints))
{
lwerror("getPoint4d_p: point offset out of range");
}
#endif
LWDEBUG(4, "getPoint4d_p called.");
/* Get a pointer to nth point offset and zmflag */
ptr=getPoint_internal(pa, n);
zmflag=TYPE_GETZM(pa->dims);
LWDEBUGF(4, "ptr %p, zmflag %d", ptr, zmflag);
switch (zmflag)
{
case 0: /* 2d */
memcpy(op, ptr, sizeof(POINT2D));
op->m=NO_M_VALUE;
op->z=NO_Z_VALUE;
break;
case 3: /* ZM */
memcpy(op, ptr, sizeof(POINT4D));
break;
case 2: /* Z */
memcpy(op, ptr, sizeof(POINT3DZ));
op->m=NO_M_VALUE;
break;
case 1: /* M */
memcpy(op, ptr, sizeof(POINT3DM));
op->m=op->z; /* we use Z as temporary storage */
op->z=NO_Z_VALUE;
break;
default:
lwerror("Unknown ZM flag ??");
}
return 1;
}
/*
* Copy a point from the point array into the parameter point
* will set point's z=NO_Z_VALUE if pa is 2d
* NOTE: point is a real POINT3DZ *not* a pointer
*/
POINT3DZ
getPoint3dz(const POINTARRAY *pa, int n)
{
POINT3DZ result;
getPoint3dz_p(pa, n, &result);
return result;
}
/*
* Copy a point from the point array into the parameter point
* will set point's z=NO_Z_VALUE if pa is 2d
*
* NOTE: point is a real POINT3DZ *not* a pointer
*/
POINT3DM
getPoint3dm(const POINTARRAY *pa, int n)
{
POINT3DM result;
getPoint3dm_p(pa, n, &result);
return result;
}
/*
* Copy a point from the point array into the parameter point
* will set point's z=NO_Z_VALUE if pa is 2d
*
* NOTE: this will modify the point3dz pointed to by 'point'.
*/
int
getPoint3dz_p(const POINTARRAY *pa, int n, POINT3DZ *op)
{
uchar *ptr;
#if PARANOIA_LEVEL > 0
if ( ! pa ) return 0;
if ( (n<0) || (n>=pa->npoints))
{
LWDEBUGF(4, "%d out of numpoint range (%d)", n, pa->npoints);
return 0; /*error */
}
#endif
LWDEBUGF(2, "getPoint3dz_p called on array of %d-dimensions / %u pts",
TYPE_NDIMS(pa->dims), pa->npoints);
/* Get a pointer to nth point offset */
ptr=getPoint_internal(pa, n);
/*
* if input POINTARRAY has the Z, it is always
* at third position so make a single copy
*/
if ( TYPE_HASZ(pa->dims) )
{
memcpy(op, ptr, sizeof(POINT3DZ));
}
/*
* Otherwise copy the 2d part and initialize
* Z to NO_Z_VALUE
*/
else
{
memcpy(op, ptr, sizeof(POINT2D));
op->z=NO_Z_VALUE;
}
return 1;
}
/*
* Copy a point from the point array into the parameter point
* will set point's m=NO_Z_VALUE if pa has no M
*
* NOTE: this will modify the point3dm pointed to by 'point'.
*/
int
getPoint3dm_p(const POINTARRAY *pa, int n, POINT3DM *op)
{
uchar *ptr;
int zmflag;
#if PARANOIA_LEVEL > 0
if ( ! pa ) return 0;
if ( (n<0) || (n>=pa->npoints))
{
lwerror("%d out of numpoint range (%d)", n, pa->npoints);
return 0; /*error */
}
#endif
LWDEBUGF(2, "getPoint3dm_p(%d) called on array of %d-dimensions / %u pts",
n, TYPE_NDIMS(pa->dims), pa->npoints);
/* Get a pointer to nth point offset and zmflag */
ptr=getPoint_internal(pa, n);
zmflag=TYPE_GETZM(pa->dims);
/*
* if input POINTARRAY has the M and NO Z,
* we can issue a single memcpy
*/
if ( zmflag == 1 )
{
memcpy(op, ptr, sizeof(POINT3DM));
return 1;
}
/*
* Otherwise copy the 2d part and
* initialize M to NO_M_VALUE
*/
memcpy(op, ptr, sizeof(POINT2D));
/*
* Then, if input has Z skip it and
* copy next double, otherwise initialize
* M to NO_M_VALUE
*/
if ( zmflag == 3 )
{
ptr+=sizeof(POINT3DZ);
memcpy(&(op->m), ptr, sizeof(double));
}
else
{
op->m=NO_M_VALUE;
}
return 1;
}
/*
* Copy a point from the point array into the parameter point
* z value (if present) is not returned.
*
* NOTE: point is a real POINT2D *not* a pointer
*/
POINT2D
getPoint2d(const POINTARRAY *pa, int n)
{
POINT2D result;
getPoint2d_p(pa, n, &result);
return result;
}
/*
* Copy a point from the point array into the parameter point
* z value (if present) is not returned.
*
* NOTE: this will modify the point2d pointed to by 'point'.
*/
int
getPoint2d_p(const POINTARRAY *pa, int n, POINT2D *point)
{
#if PARANOIA_LEVEL > 0
if ( ! pa ) return 0;
if ( (n<0) || (n>=pa->npoints))
{
lwerror("getPoint2d_p: point offset out of range");
return 0; /*error */
}
#endif
/* this does x,y */
memcpy(point, getPoint_internal(pa, n), sizeof(POINT2D));
return 1;
}
/*
* set point N to the given value
* NOTE that the pointarray can be of any
* dimension, the appropriate ordinate values
* will be extracted from it
*
*/
void
setPoint4d(POINTARRAY *pa, int n, POINT4D *p4d)
{
uchar *ptr=getPoint_internal(pa, n);
switch ( TYPE_GETZM(pa->dims) )
{
case 3:
memcpy(ptr, p4d, sizeof(POINT4D));
break;
case 2:
memcpy(ptr, p4d, sizeof(POINT3DZ));
break;
case 1:
memcpy(ptr, p4d, sizeof(POINT2D));
ptr+=sizeof(POINT2D);
memcpy(ptr, &(p4d->m), sizeof(double));
break;
case 0:
memcpy(ptr, p4d, sizeof(POINT2D));
break;
}
}
/*
* Get a pointer to nth point of a POINTARRAY.
* You cannot safely cast this to a real POINT, due to memory alignment
* constraints. Use getPoint*_p for that.
*/
uchar *
getPoint_internal(const POINTARRAY *pa, int n)
{
int size;
#if PARANOIA_LEVEL > 0
if ( pa == NULL )
{
lwerror("getPoint got NULL pointarray");
return NULL;
}
if ( (n<0) || (n>=pa->npoints))
{
return NULL; /*error */
}
#endif
size = pointArray_ptsize(pa);
return &(pa->serialized_pointlist[size*n]);
}
/*
* Constructs a POINTARRAY.
*
* NOTE: points is *not* copied, so be careful about modification
* (can be aligned/missaligned).
*
* NOTE: ndims is descriptive - it describes what type of data 'points'
* points to. No data conversion is done.
*/
POINTARRAY *
pointArray_construct(uchar *points, char hasz, char hasm, uint32 npoints)
{
POINTARRAY *pa;
LWDEBUG(2, "pointArray_construct called.");
pa = (POINTARRAY*)lwalloc(sizeof(POINTARRAY));
pa->dims = 0;
TYPE_SETZM(pa->dims, hasz?1:0, hasm?1:0);
pa->npoints = npoints;
pa->serialized_pointlist = points;
LWDEBUGF(4, "pointArray_construct returning %p", pa);
return pa;
}
/*
* Size of point represeneted in the POINTARRAY
* 16 for 2d, 24 for 3d, 32 for 4d
*/
int
pointArray_ptsize(const POINTARRAY *pa)
{
LWDEBUGF(2, "pointArray_ptsize: TYPE_NDIMS(pa->dims)=%x",TYPE_NDIMS(pa->dims));
return sizeof(double)*TYPE_NDIMS(pa->dims);
}
/***************************************************************************
* Basic type handling
***************************************************************************/
/* Returns true if this type says it has an SRID (S bit set) */
char
lwgeom_hasSRID(uchar type)
{
return TYPE_HASSRID(type);
}
/* Returns either 2,3, or 4 -- 2=2D, 3=3D, 4=4D */
int
lwgeom_ndims(uchar type)
{
return TYPE_NDIMS(type);
}
/* has M ? */
int lwgeom_hasM(uchar type)
{
return ( (type & 0x10) >>4);
}
/* has Z ? */
int lwgeom_hasZ(uchar type)
{
return ( (type & 0x20) >>5);
}
/* get base type (ie. POLYGONTYPE) */
int
lwgeom_getType(uchar type)
{
LWDEBUGF(2, "lwgeom_getType %d", type);
return (type & 0x0F);
}
/* Construct a type (hasBOX=false) */
uchar
lwgeom_makeType(char hasz, char hasm, char hasSRID, int type)
{
return lwgeom_makeType_full(hasz, hasm, hasSRID, type, 0);
}
/*
* Construct a type
* TODO: needs to be expanded to accept explicit MZ type
*/
uchar
lwgeom_makeType_full(char hasz, char hasm, char hasSRID, int type, char hasBBOX)
{
uchar result = (char)type;
TYPE_SETZM(result, hasz, hasm);
TYPE_SETHASSRID(result, hasSRID);
TYPE_SETHASBBOX(result, hasBBOX);
return result;
}
/* Returns true if there's a bbox in this LWGEOM (B bit set) */
char
lwgeom_hasBBOX(uchar type)
{
return TYPE_HASBBOX(type);
}
/*****************************************************************************
* Basic sub-geometry types
*****************************************************************************/
/* handle missaligned unsigned int32 data */
uint32
lw_get_uint32(const uchar *loc)
{
uint32 result;
memcpy(&result, loc, sizeof(uint32));
return result;
}
/* handle missaligned signed int32 data */
int32
lw_get_int32(const uchar *loc)
{
int32 result;
memcpy(&result,loc, sizeof(int32));
return result;
}
/*************************************************************************
*
* Multi-geometry support
*
* Note - for a simple type (ie. point), this will have
* sub_geom[0] = serialized_form.
*
* For multi-geomtries sub_geom[0] will be a few bytes
* into the serialized form.
*
* This function just computes the length of each sub-object and
* pre-caches this info.
*
* For a geometry collection of multi* geometries, you can inspect
* the sub-components
* as well.
*/
LWGEOM_INSPECTED *
lwgeom_inspect(const uchar *serialized_form)
{
LWGEOM_INSPECTED *result = lwalloc(sizeof(LWGEOM_INSPECTED));
uchar typefl = (uchar)serialized_form[0];
uchar type;
uchar **sub_geoms;
const uchar *loc;
int t;
LWDEBUGF(2, "lwgeom_inspect: serialized@%p", serialized_form);
if (serialized_form == NULL)
return NULL;
result->serialized_form = serialized_form;
result->type = (uchar) serialized_form[0];
result->SRID = -1; /* assume */
type = lwgeom_getType(typefl);
loc = serialized_form+1;
if ( lwgeom_hasBBOX(typefl) )
{
loc += sizeof(BOX2DFLOAT4);
}
if ( lwgeom_hasSRID(typefl) )
{
result->SRID = lw_get_int32(loc);
loc += 4;
}
if ( (type==POINTTYPE) || (type==LINETYPE) || (type==POLYGONTYPE) || (type == CIRCSTRINGTYPE))
{
/* simple geometry (point/line/polygon/circstring)-- not multi! */
result->ngeometries = 1;
sub_geoms = (uchar**) lwalloc(sizeof(char*));
sub_geoms[0] = (uchar *)serialized_form;
result->sub_geoms = (uchar **)sub_geoms;
return result;
}
/* its a GeometryCollection or multi* geometry */
result->ngeometries = lw_get_uint32(loc);
loc +=4;
LWDEBUGF(3, "lwgeom_inspect: geometry is a collection of %d elements",
result->ngeometries);
if ( ! result->ngeometries ) return result;
sub_geoms = lwalloc(sizeof(uchar*) * result->ngeometries );
result->sub_geoms = sub_geoms;
sub_geoms[0] = (uchar *)loc;
LWDEBUGF(3, "subgeom[0] @ %p (+%d)", sub_geoms[0], sub_geoms[0]-serialized_form);
for (t=1;t<result->ngeometries; t++)
{
/* -1 = entire object */
int sub_length = lwgeom_size_subgeom(sub_geoms[t-1], -1);
sub_geoms[t] = sub_geoms[t-1] + sub_length;
LWDEBUGF(3, "subgeom[%d] @ %p (+%d)",
t, sub_geoms[t], sub_geoms[0]-serialized_form);
}
return result;
}
/*
* 1st geometry has geom_number = 0
* if the actual sub-geometry isnt a POINT, null is returned (see _gettype()).
* if there arent enough geometries, return null.
* this is fine to call on a point (with geom_num=0),
* multipoint or geometrycollection
*/
LWPOINT *
lwgeom_getpoint(uchar *serialized_form, int geom_number)
{
int type = lwgeom_getType((uchar)serialized_form[0]);
uchar *sub_geom;
if ((type == POINTTYPE) && (geom_number == 0))
{
/* Be nice and do as they want instead of what they say */
return lwpoint_deserialize(serialized_form);
}
if ((type != MULTIPOINTTYPE) && (type != COLLECTIONTYPE) )
return NULL;
sub_geom = lwgeom_getsubgeometry(serialized_form, geom_number);
if (sub_geom == NULL)
return NULL;
type = lwgeom_getType(sub_geom[0]);
if (type != POINTTYPE)
return NULL;
return lwpoint_deserialize(sub_geom);
}
/*
* 1st geometry has geom_number = 0
* if the actual sub-geometry isnt a POINT, null is returned (see _gettype()).
* if there arent enough geometries, return null.
* this is fine to call on a point (with geom_num=0), multipoint
* or geometrycollection
*/
LWPOINT *lwgeom_getpoint_inspected(LWGEOM_INSPECTED *inspected, int geom_number)
{
uchar *sub_geom;
uchar type;
sub_geom = lwgeom_getsubgeometry_inspected(inspected, geom_number);
if (sub_geom == NULL) return NULL;
type = lwgeom_getType(sub_geom[0]);
if (type != POINTTYPE) return NULL;
return lwpoint_deserialize(sub_geom);
}
/*
* 1st geometry has geom_number = 0
* if the actual geometry isnt a LINE, null is returned (see _gettype()).
* if there arent enough geometries, return null.
* this is fine to call on a line, multiline or geometrycollection
*/
LWLINE *
lwgeom_getline(uchar *serialized_form, int geom_number)
{
uchar type = lwgeom_getType( (uchar) serialized_form[0]);
uchar *sub_geom;
if ((type == LINETYPE) && (geom_number == 0))
{
/* be nice and do as they want instead of what they say */
return lwline_deserialize(serialized_form);
}
if ((type != MULTILINETYPE) && (type != COLLECTIONTYPE) )
return NULL;
sub_geom = lwgeom_getsubgeometry(serialized_form, geom_number);
if (sub_geom == NULL) return NULL;
type = lwgeom_getType((uchar) sub_geom[0]);
if (type != LINETYPE) return NULL;
return lwline_deserialize(sub_geom);
}
/*
* 1st geometry has geom_number = 0
* if the actual geometry isnt a LINE, null is returned (see _gettype()).
* if there arent enough geometries, return null.
* this is fine to call on a line, multiline or geometrycollection
*/
LWLINE *
lwgeom_getline_inspected(LWGEOM_INSPECTED *inspected, int geom_number)
{
uchar *sub_geom;
uchar type;
sub_geom = lwgeom_getsubgeometry_inspected(inspected, geom_number);
if (sub_geom == NULL) return NULL;
type = lwgeom_getType((uchar) sub_geom[0]);
if (type != LINETYPE) return NULL;
return lwline_deserialize(sub_geom);
}
/*
* 1st geometry has geom_number = 0
* if the actual geometry isnt a POLYGON, null is returned (see _gettype()).
* if there arent enough geometries, return null.
* this is fine to call on a polygon, multipolygon or geometrycollection
*/
LWPOLY *
lwgeom_getpoly(uchar *serialized_form, int geom_number)
{
uchar type = lwgeom_getType((uchar)serialized_form[0]);
uchar *sub_geom;
if ((type == POLYGONTYPE) && (geom_number == 0))
{
/* Be nice and do as they want instead of what they say */
return lwpoly_deserialize(serialized_form);
}
if ((type != MULTIPOLYGONTYPE) && (type != COLLECTIONTYPE) )
return NULL;
sub_geom = lwgeom_getsubgeometry(serialized_form, geom_number);
if (sub_geom == NULL) return NULL;
type = lwgeom_getType(sub_geom[0]);
if (type != POLYGONTYPE) return NULL;
return lwpoly_deserialize(sub_geom);
}
/*
* 1st geometry has geom_number = 0
* if the actual geometry isnt a POLYGON, null is returned (see _gettype()).
* if there arent enough geometries, return null.
* this is fine to call on a polygon, multipolygon or geometrycollection
*/
LWPOLY *
lwgeom_getpoly_inspected(LWGEOM_INSPECTED *inspected, int geom_number)
{
uchar *sub_geom;
uchar type;
sub_geom = lwgeom_getsubgeometry_inspected(inspected, geom_number);
if (sub_geom == NULL) return NULL;
type = lwgeom_getType(sub_geom[0]);
if (type != POLYGONTYPE) return NULL;
return lwpoly_deserialize(sub_geom);
}
/*
* 1st geometry has geom_number = 0
* if the actual geometry isnt a CIRCULARSTRING, null is returned (see _gettype()).
* if there arent enough geometries, return null.
* this is fine to call on a circularstring
*/
LWCIRCSTRING *
lwgeom_getcircstring_inspected(LWGEOM_INSPECTED *inspected, int geom_number)
{
uchar *sub_geom;
uchar type;
sub_geom = lwgeom_getsubgeometry_inspected(inspected, geom_number);
if (sub_geom == NULL) return NULL;
type = lwgeom_getType(sub_geom[0]);
if (type != CIRCSTRINGTYPE) return NULL;
return lwcircstring_deserialize(sub_geom);
}
/*
* 1st geometry has geom_number = 0
* if there arent enough geometries, return null.
*/
LWGEOM *lwgeom_getgeom_inspected(LWGEOM_INSPECTED *inspected, int geom_number)
{
uchar *sub_geom;
uchar type;
sub_geom = lwgeom_getsubgeometry_inspected(inspected, geom_number);
if (sub_geom == NULL) return NULL;
type = lwgeom_getType(sub_geom[0]);
return lwgeom_deserialize(sub_geom);
}
/*
* This gets the serialized form of a sub-geometry
*
* 1st geometry has geom_number = 0
* if this isnt a multi* geometry, and geom_number ==0 then it returns
* itself.
*
* Returns null on problems.
*
* In the future this is how you would access a muli* portion of a
* geometry collection.
* GEOMETRYCOLLECTION(MULTIPOINT(0 0, 1 1), LINESTRING(0 0, 1 1))
* ie. lwgeom_getpoint( lwgeom_getsubgeometry( serialized, 0), 1)
* --> POINT(1 1)
*
* You can inspect the sub-geometry as well if you wish.
*
*/
uchar *
lwgeom_getsubgeometry(const uchar *serialized_form, int geom_number)
{
uchar *result;
/*major cheat!! */
LWGEOM_INSPECTED *inspected = lwgeom_inspect(serialized_form);
result = lwgeom_getsubgeometry_inspected(inspected, geom_number);
lwinspected_release(inspected);
return result;
}
uchar *
lwgeom_getsubgeometry_inspected(LWGEOM_INSPECTED *inspected, int geom_number)
{
if ((geom_number <0) || (geom_number >= inspected->ngeometries) )
{
lwerror("lwgeom_getsubgeometry_inspected: geom_number out of range");
return NULL;
}
return inspected->sub_geoms[geom_number];
}
/*
* 1st geometry has geom_number = 0
* use geom_number = -1 to find the actual type of the serialized form.
* ie lwgeom_gettype( <'MULTIPOINT(0 0, 1 1)'>, -1)
* --> multipoint
* ie lwgeom_gettype( <'MULTIPOINT(0 0, 1 1)'>, 0)
* --> point
* gets the 8bit type of the geometry at location geom_number
*/
uchar
lwgeom_getsubtype(uchar *serialized_form, int geom_number)
{
char result;
/*major cheat!! */
LWGEOM_INSPECTED *inspected = lwgeom_inspect(serialized_form);
result = lwgeom_getsubtype_inspected(inspected, geom_number);
lwinspected_release(inspected);
return result;
}
uchar
lwgeom_getsubtype_inspected(LWGEOM_INSPECTED *inspected, int geom_number)
{
if ((geom_number <0) || (geom_number >= inspected->ngeometries) )
return 99;
return inspected->sub_geoms[geom_number][0]; /* 1st byte is type */
}
/*
* How many sub-geometries are there?
* for point,line,polygon will return 1.
*/
int
lwgeom_getnumgeometries(uchar *serialized_form)
{
uchar type = lwgeom_getType((uchar)serialized_form[0]);
uchar *loc;
if ( (type==POINTTYPE) || (type==LINETYPE) || (type==POLYGONTYPE) ||
(type==CIRCSTRINGTYPE) || (type==COMPOUNDTYPE) || (type==CURVEPOLYTYPE) )
{
return 1;
}
loc = serialized_form+1;
if (lwgeom_hasBBOX((uchar) serialized_form[0]))
{
loc += sizeof(BOX2DFLOAT4);
}
if (lwgeom_hasSRID((uchar) serialized_form[0]) )
{
loc += 4;
}
/* its a GeometryCollection or multi* geometry */
return lw_get_uint32(loc);
}
/*
* How many sub-geometries are there?
* for point,line,polygon will return 1.
*/
int
lwgeom_getnumgeometries_inspected(LWGEOM_INSPECTED *inspected)
{
return inspected->ngeometries;
}
/*
* Set finalType to COLLECTIONTYPE or 0 (0 means choose a best type)
* (ie. give it 2 points and ask it to be a multipoint)
* use SRID=-1 for unknown SRID (will have 8bit type's S = 0)
* all subgeometries must have the same SRID
* if you want to construct an inspected, call this then inspect the result...
*/
uchar *
lwgeom_serialized_construct(int SRID, int finalType, char hasz, char hasm,
int nsubgeometries, uchar **serialized_subs)
{
uint32 *lengths;
int t;
int total_length = 0;
char type = (char)-1;
char this_type = -1;
uchar *result;
uchar *loc;
if (nsubgeometries == 0)
return lwgeom_constructempty(SRID, hasz, hasm);
lengths = lwalloc(sizeof(int32) * nsubgeometries);
for (t=0;t<nsubgeometries;t++)
{
lengths[t] = lwgeom_size_subgeom(serialized_subs[t],-1);
total_length += lengths[t];
this_type = lwgeom_getType((uchar) (serialized_subs[t][0]));
if (type == (char)-1)
{
type = this_type;
}
else if (type == COLLECTIONTYPE)
{
/* still a collection type... */
}
else
{
if ( (this_type == MULTIPOINTTYPE) || (this_type == MULTILINETYPE) || (this_type == MULTIPOLYGONTYPE) || (this_type == COLLECTIONTYPE) )
{
type = COLLECTIONTYPE;
}
else
{
if ( (this_type == POINTTYPE) && (type==POINTTYPE) )
type=MULTIPOINTTYPE;
else if ( (this_type == LINETYPE) && (type==LINETYPE) )
type=MULTILINETYPE;
else if ( (this_type == POLYGONTYPE) && (type==POLYGONTYPE) )
type=MULTIPOLYGONTYPE;
else if ( (this_type == POLYGONTYPE) && (type==MULTIPOLYGONTYPE) )
; /* nop */
else if ( (this_type == LINETYPE) && (type==MULTILINETYPE) )
; /* nop */
else if ( (this_type == POINTTYPE) && (type==MULTIPOINTTYPE) )
; /* nop */
else
type = COLLECTIONTYPE;
}
}
}
if (type == POINTTYPE)
type = MULTIPOINTTYPE;
if (type == LINETYPE)
type = MULTILINETYPE;
if (type == POINTTYPE)
type = MULTIPOINTTYPE;
if (finalType == COLLECTIONTYPE)
type = COLLECTIONTYPE;
/* now we have a multi* or GEOMETRYCOLLECTION, let's serialize it */
if (SRID != -1)
total_length +=4; /* space for SRID */
total_length +=1 ; /* main type; */
total_length +=4 ; /* nsubgeometries */
result = lwalloc(total_length);
result[0] = (uchar) lwgeom_makeType(hasz, hasm, SRID != -1, type);
if (SRID != -1)
{
memcpy(&result[1],&SRID,4);
loc = result+5;
}
else
loc = result+1;
memcpy(loc,&nsubgeometries,4);
loc +=4;
for (t=0;t<nsubgeometries;t++)
{
memcpy(loc, serialized_subs[t], lengths[t] );
loc += lengths[t] ;
}
lwfree(lengths);
return result;
}
/*
* Construct the empty geometry (GEOMETRYCOLLECTION(EMPTY)).
*
* Returns serialized form
*/
uchar *
lwgeom_constructempty(int SRID, char hasz, char hasm)
{
int size = 0;
uchar *result;
int ngeoms = 0;
uchar *loc;
if (SRID != -1)
size +=4;
size += 5;
result = lwalloc(size);
result[0] = lwgeom_makeType(hasz, hasm, SRID != -1, COLLECTIONTYPE);
if (SRID != -1)
{
memcpy(&result[1],&SRID,4);
loc = result+5;
}
else
loc = result+1;
memcpy(loc,&ngeoms,4);
return result;
}
size_t
lwgeom_empty_length(int SRID)
{
int size = 5;
if ( SRID != 1 ) size += 4;
return size;
}
/**
* Construct the empty geometry (GEOMETRYCOLLECTION(EMPTY))
* writing it into the provided buffer.
*/
void
lwgeom_constructempty_buf(int SRID, char hasz, char hasm,
uchar *buf, size_t *retsize)
{
int ngeoms = 0;
buf[0] =(uchar) lwgeom_makeType( hasz, hasm, SRID != -1, COLLECTIONTYPE);
if (SRID != -1)
{
memcpy(&buf[1],&SRID,4);
buf += 5;
}
else
buf += 1;
memcpy(buf, &ngeoms, 4);
if (retsize) *retsize = lwgeom_empty_length(SRID);
}
/**
* helper function (not for general use)
* find the size a geometry (or a sub-geometry)
* 1st geometry has geom_number = 0
* use geom_number = -1 to find the actual type of the serialized form.
* ie lwgeom_gettype( <'MULTIPOINT(0 0, 1 1)'>, -1)
* --> size of the multipoint
* ie lwgeom_gettype( <'MULTIPOINT(0 0, 1 1)'>, 0)
* --> size of the point
* take a geometry, and find its length
*/
size_t
lwgeom_size(const uchar *serialized_form)
{
uchar type = lwgeom_getType((uchar) serialized_form[0]);
int t;
const uchar *loc;
uint32 ngeoms;
int sub_size;
int result = 1; /* type */
LWDEBUG(2, "lwgeom_size called");
if (type == POINTTYPE)
{
LWDEBUG(3, "lwgeom_size: is a point");
return lwgeom_size_point(serialized_form);
}
else if (type == LINETYPE)
{
LWDEBUG(3, "lwgeom_size: is a line");
return lwgeom_size_line(serialized_form);
}
else if (type == CIRCSTRINGTYPE)
{
LWDEBUG(3, "lwgeom_size: is a circularstring");
return lwgeom_size_circstring(serialized_form);
}
else if (type == POLYGONTYPE)
{
LWDEBUG(3, "lwgeom_size: is a polygon");
return lwgeom_size_poly(serialized_form);
}
else if (type == COMPOUNDTYPE)
{
LWDEBUG(3, "lwgeom_size: is a compound curve");
}
if ( type == 0 )
{
lwerror("lwgeom_size called with unknown-typed serialized geometry");
return 0;
}
/*
* Handle all the multi* and geometrycollections the same
*
* NOTE: for a geometry collection of GC of GC of GC we will
* be recursing...
*/
LWDEBUGF(3, "lwgeom_size called on a geoemtry with type %d", type);
loc = serialized_form+1;
if (lwgeom_hasBBOX((uchar) serialized_form[0]))
{
LWDEBUG(3, "lwgeom_size: has bbox");
loc += sizeof(BOX2DFLOAT4);
result +=sizeof(BOX2DFLOAT4);
}
if (lwgeom_hasSRID( (uchar) serialized_form[0]) )
{
LWDEBUG(3, "lwgeom_size: has srid");
result +=4;
loc +=4;
}
ngeoms = lw_get_uint32(loc);
loc +=4;
result += 4; /* numgeoms */
LWDEBUGF(3, "lwgeom_size called on a geoemtry with %d elems (result so far: %d)", ngeoms, result);
for (t=0;t<ngeoms;t++)
{
sub_size = lwgeom_size(loc);
LWDEBUGF(3, " subsize %d", sub_size);
loc += sub_size;
result += sub_size;
}
LWDEBUGF(3, "lwgeom_size returning %d", result);
return result;
}
size_t
lwgeom_size_subgeom(const uchar *serialized_form, int geom_number)
{
if (geom_number == -1)
{
return lwgeom_size(serialized_form);
}
return lwgeom_size( lwgeom_getsubgeometry(serialized_form,geom_number));
}
int
lwgeom_size_inspected(const LWGEOM_INSPECTED *inspected, int geom_number)
{
return lwgeom_size(inspected->sub_geoms[geom_number]);
}
int
compute_serialized_box3d_p(uchar *srl, BOX3D *out)
{
BOX3D *box = compute_serialized_box3d(srl);
if ( ! box ) return 0;
out->xmin = box->xmin;
out->ymin = box->ymin;
out->zmin = box->zmin;
out->xmax = box->xmax;
out->ymax = box->ymax;
out->zmax = box->zmax;
lwfree(box);
return 1;
}
/**
* Compute bounding box of a serialized LWGEOM, even if it is
* already cached. The computed BOX2DFLOAT4 is stored at
* the given location, the function returns 0 is the geometry
* does not have a bounding box (EMPTY GEOM)
*/
int
compute_serialized_box2d_p(uchar *srl, BOX2DFLOAT4 *out)
{
BOX3D *result = compute_serialized_box3d(srl);
if ( ! result ) return 0;
out->xmin = result->xmin;
out->xmax = result->xmax;
out->ymin = result->ymin;
out->ymax = result->ymax;
lwfree(result);
return 1;
}
/**
* Don't forget to lwfree() result !
*/
BOX3D *
compute_serialized_box3d(uchar *srl)
{
int type = lwgeom_getType(srl[0]);
int t;
uchar *loc = srl;
uint32 nelems;
BOX3D *result;
BOX3D b1;
int sub_size;
char nboxes=0;
LWDEBUGF(2, "compute_serialized_box3d called on type %d", type);
loc += 1; /* Move past the 'type' byte. */
if (lwgeom_hasBBOX(srl[0]))
{
loc += sizeof(BOX2DFLOAT4); /* Move past the bbox */
}
if (lwgeom_hasSRID(srl[0]) )
{
loc +=4; /* Move past the SRID */
}
if (type == POINTTYPE)
{
LWPOINT *pt = lwpoint_deserialize(srl);
LWDEBUG(3, "compute_serialized_box3d: lwpoint deserialized");
result = lwpoint_compute_box3d(pt);
LWDEBUG(3, "compute_serialized_box3d: bbox found");
lwpoint_free(pt);
return result;
}
/*
** For items that have elements (everything except points),
** nelems == 0 => EMPTY geometry
*/
nelems = lw_get_uint32(loc);
if ( nelems == 0 ) return NULL;
if (type == LINETYPE)
{
LWLINE *line = lwline_deserialize(srl);
result = lwline_compute_box3d(line);
lwline_free(line);
return result;
}
else if (type == CIRCSTRINGTYPE)
{
LWCIRCSTRING *curve = lwcircstring_deserialize(srl);
result = lwcircstring_compute_box3d(curve);
lwcircstring_free(curve);
return result;
}
else if (type == POLYGONTYPE)
{
LWPOLY *poly = lwpoly_deserialize(srl);
result = lwpoly_compute_box3d(poly);
lwpoly_free(poly);
return result;
}
if ( ! ( type == MULTIPOINTTYPE || type == MULTILINETYPE ||
type == MULTIPOLYGONTYPE || type == COLLECTIONTYPE ||
type == COMPOUNDTYPE || type == CURVEPOLYTYPE ||
type == MULTICURVETYPE || type == MULTISURFACETYPE) )
{
lwnotice("compute_serialized_box3d called on unknown type %d", type);
return NULL;
}
loc += 4;
/* each sub-type */
result = NULL;
for (t=0; t<nelems; t++)
{
if ( compute_serialized_box3d_p(loc, &b1) )
{
LWDEBUG(3, "Geom %d have box:");
#if POSTGIS_DEBUG_LEVEL >= 3
printBOX3D(&b1);
#endif
if (result)
{
nboxes += box3d_union_p(result, &b1, result);
}
else
{
result = lwalloc(sizeof(BOX3D));
memcpy(result, &b1, sizeof(BOX3D));
}
}
sub_size = lwgeom_size(loc);
loc += sub_size;
}
return result;
}
/****************************************************************
* memory management
*
* these only delete the memory associated
* directly with the structure - NOT the stuff pointing into
* the original de-serialized info
*
****************************************************************/
void
lwinspected_release(LWGEOM_INSPECTED *inspected)
{
if ( inspected->ngeometries )
lwfree(inspected->sub_geoms);
lwfree(inspected);
}
/************************************************
* debugging routines
************************************************/
void printBOX3D(BOX3D *box)
{
lwnotice("BOX3D: %g %g, %g %g", box->xmin, box->ymin,
box->xmax, box->ymax);
}
void printPA(POINTARRAY *pa)
{
int t;
POINT4D pt;
char *mflag;
if ( TYPE_HASM(pa->dims) ) mflag = "M";
else mflag = "";
lwnotice(" POINTARRAY%s{", mflag);
lwnotice(" ndims=%i, ptsize=%i",
TYPE_NDIMS(pa->dims), pointArray_ptsize(pa));
lwnotice(" npoints = %i", pa->npoints);
for (t =0; t<pa->npoints;t++)
{
getPoint4d_p(pa, t, &pt);
if (TYPE_NDIMS(pa->dims) == 2)
{
lwnotice(" %i : %lf,%lf",t,pt.x,pt.y);
}
if (TYPE_NDIMS(pa->dims) == 3)
{
lwnotice(" %i : %lf,%lf,%lf",t,pt.x,pt.y,pt.z);
}
if (TYPE_NDIMS(pa->dims) == 4)
{
lwnotice(" %i : %lf,%lf,%lf,%lf",t,pt.x,pt.y,pt.z,pt.m);
}
}
lwnotice(" }");
}
void printBYTES(uchar *a, int n)
{
int t;
char buff[3];
buff[2] = 0; /* null terminate */
lwnotice(" BYTE ARRAY (n=%i) IN HEX: {", n);
for (t=0;t<n;t++)
{
deparse_hex(a[t], buff);
lwnotice(" %i : %s", t,buff );
}
lwnotice(" }");
}
void
printMULTI(uchar *serialized)
{
LWGEOM_INSPECTED *inspected = lwgeom_inspect(serialized);
LWLINE *line;
LWPOINT *point;
LWPOLY *poly;
int t;
lwnotice("MULTI* geometry (type = %i), with %i sub-geoms",lwgeom_getType((uchar)serialized[0]), inspected->ngeometries);
for (t=0;t<inspected->ngeometries;t++)
{
lwnotice(" sub-geometry %i:", t);
line = NULL;
point = NULL;
poly = NULL;
line = lwgeom_getline_inspected(inspected,t);
if (line !=NULL)
{
printLWLINE(line);
}
poly = lwgeom_getpoly_inspected(inspected,t);
if (poly !=NULL)
{
printLWPOLY(poly);
}
point = lwgeom_getpoint_inspected(inspected,t);
if (point !=NULL)
{
printPA(point->point);
}
}
lwnotice("end multi*");
lwinspected_release(inspected);
}
void
printType(uchar type)
{
lwnotice("type 0x%x ==> hasBBOX=%i, hasSRID=%i, ndims=%i, type=%i",(unsigned int) type, lwgeom_hasBBOX(type), lwgeom_hasSRID(type),lwgeom_ndims(type), lwgeom_getType(type));
}
/**
* Get the SRID from the LWGEOM.
* None present => -1
*/
int
lwgeom_getsrid(uchar *serialized)
{
uchar type = serialized[0];
uchar *loc = serialized+1;
if ( ! lwgeom_hasSRID(type)) return -1;
if (lwgeom_hasBBOX(type))
{
loc += sizeof(BOX2DFLOAT4);
}
return lw_get_int32(loc);
}
char
ptarray_isccw(const POINTARRAY *pa)
{
int i;
double area = 0;
POINT2D p1, p2;
for (i=0; i<pa->npoints-1; i++)
{
getPoint2d_p(pa, i, &p1);
getPoint2d_p(pa, i+1, &p2);
area += (p1.y * p2.x) - (p1.x * p2.y);
}
if ( area > 0 ) return 0;
else return 1;
}
/**
* Returns a BOX2DFLOAT4 that encloses b1 and b2
*
* box2d_union(NULL,A) --> A
* box2d_union(A,NULL) --> A
* box2d_union(A,B) --> A union B
*/
BOX2DFLOAT4 *
box2d_union(BOX2DFLOAT4 *b1, BOX2DFLOAT4 *b2)
{
BOX2DFLOAT4 *result;
if ( (b1 == NULL) && (b2 == NULL) )
{
return NULL;
}
result = lwalloc(sizeof(BOX2DFLOAT4));
if (b1 == NULL)
{
memcpy(result, b2, sizeof(BOX2DFLOAT4));
return result;
}
if (b2 == NULL)
{
memcpy(result, b1, sizeof(BOX2DFLOAT4));
return result;
}
if (b1->xmin < b2->xmin) result->xmin = b1->xmin;
else result->xmin = b2->xmin;
if (b1->ymin < b2->ymin) result->ymin = b1->ymin;
else result->ymin = b2->ymin;
if (b1->xmax > b2->xmax) result->xmax = b1->xmax;
else result->xmax = b2->xmax;
if (b1->ymax > b2->ymax) result->ymax = b1->ymax;
else result->ymax = b2->ymax;
return result;
}
/**
* ubox may be one of the two args...
* return 1 if done something to ubox, 0 otherwise.
*/
int
box2d_union_p(BOX2DFLOAT4 *b1, BOX2DFLOAT4 *b2, BOX2DFLOAT4 *ubox)
{
if ( (b1 == NULL) && (b2 == NULL) )
{
return 0;
}
if (b1 == NULL)
{
memcpy(ubox, b2, sizeof(BOX2DFLOAT4));
return 1;
}
if (b2 == NULL)
{
memcpy(ubox, b1, sizeof(BOX2DFLOAT4));
return 1;
}
if (b1->xmin < b2->xmin) ubox->xmin = b1->xmin;
else ubox->xmin = b2->xmin;
if (b1->ymin < b2->ymin) ubox->ymin = b1->ymin;
else ubox->ymin = b2->ymin;
if (b1->xmax > b2->xmax) ubox->xmax = b1->xmax;
else ubox->xmax = b2->xmax;
if (b1->ymax > b2->ymax) ubox->ymax = b1->ymax;
else ubox->ymax = b2->ymax;
return 1;
}
const char *
lwgeom_typeflags(uchar type)
{
static char flags[5];
int flagno=0;
if ( TYPE_HASZ(type) ) flags[flagno++] = 'Z';
if ( TYPE_HASM(type) ) flags[flagno++] = 'M';
if ( TYPE_HASBBOX(type) ) flags[flagno++] = 'B';
if ( TYPE_HASSRID(type) ) flags[flagno++] = 'S';
flags[flagno] = '\0';
LWDEBUGF(4, "Flags: %s - returning %p", flags, flags);
return flags;
}
/**
* Given a string with at least 2 chars in it, convert them to
* a byte value. No error checking done!
*/
uchar
parse_hex(char *str)
{
/* do this a little brute force to make it faster */
uchar result_high = 0;
uchar result_low = 0;
switch (str[0])
{
case '0' :
result_high = 0;
break;
case '1' :
result_high = 1;
break;
case '2' :
result_high = 2;
break;
case '3' :
result_high = 3;
break;
case '4' :
result_high = 4;
break;
case '5' :
result_high = 5;
break;
case '6' :
result_high = 6;
break;
case '7' :
result_high = 7;
break;
case '8' :
result_high = 8;
break;
case '9' :
result_high = 9;
break;
case 'A' :
case 'a' :
result_high = 10;
break;
case 'B' :
case 'b' :
result_high = 11;
break;
case 'C' :
case 'c' :
result_high = 12;
break;
case 'D' :
case 'd' :
result_high = 13;
break;
case 'E' :
case 'e' :
result_high = 14;
break;
case 'F' :
case 'f' :
result_high = 15;
break;
}
switch (str[1])
{
case '0' :
result_low = 0;
break;
case '1' :
result_low = 1;
break;
case '2' :
result_low = 2;
break;
case '3' :
result_low = 3;
break;
case '4' :
result_low = 4;
break;
case '5' :
result_low = 5;
break;
case '6' :
result_low = 6;
break;
case '7' :
result_low = 7;
break;
case '8' :
result_low = 8;
break;
case '9' :
result_low = 9;
break;
case 'A' :
case 'a' :
result_low = 10;
break;
case 'B' :
case 'b' :
result_low = 11;
break;
case 'C' :
case 'c' :
result_low = 12;
break;
case 'D' :
case 'd' :
result_low = 13;
break;
case 'E' :
case 'e' :
result_low = 14;
break;
case 'F' :
case 'f' :
result_low = 15;
break;
}
return (uchar) ((result_high<<4) + result_low);
}
/**
* Given one byte, populate result with two byte representing
* the hex number.
*
* Ie. deparse_hex( 255, mystr)
* -> mystr[0] = 'F' and mystr[1] = 'F'
*
* No error checking done
*/
void
deparse_hex(uchar str, char *result)
{
int input_high;
int input_low;
static char outchr[]=
{"0123456789ABCDEF"
};
input_high = (str>>4);
input_low = (str & 0x0F);
result[0] = outchr[input_high];
result[1] = outchr[input_low];
}
/**
* Find interpolation point I
* between point A and point B
* so that the len(AI) == len(AB)*F
* and I falls on AB segment.
*
* Example:
*
* F=0.5 : A----I----B
* F=1 : A---------B==I
* F=0 : A==I---------B
* F=.2 : A-I-------B
*/
void
interpolate_point4d(POINT4D *A, POINT4D *B, POINT4D *I, double F)
{
#if PARANOIA_LEVEL > 0
double absF=fabs(F);
if ( absF < 0 || absF > 1 )
{
lwerror("interpolate_point4d: invalid F (%g)", F);
}
#endif
I->x=A->x+((B->x-A->x)*F);
I->y=A->y+((B->y-A->y)*F);
I->z=A->z+((B->z-A->z)*F);
I->m=A->m+((B->m-A->m)*F);
}
Reference in a new issue View git blame Copy permalink