/*
* Add a point into a pointarray. Only adds as many dimensions as the
* pointarray supports.
*/
int
ptarray_insert_point(POINTARRAY *pa, const POINT4D *p, int where)
{
size_t point_size = ptarray_point_size(pa);
LWDEBUGF(5,"pa = %p; p = %p; where = %d", pa, p, where);
LWDEBUGF(5,"pa->npoints = %d; pa->maxpoints = %d", pa->npoints, pa->maxpoints);
if ( FLAGS_GET_READONLY(pa->flags) )
{
lwerror("ptarray_insert_point: called on read-only point array");
return LW_FAILURE;
}
/* Error on invalid offset value */
if ( where > pa->npoints || where < 0)
{
lwerror("ptarray_insert_point: offset out of range (%d)", where);
return LW_FAILURE;
}
/* If we have no storage, let's allocate some */
if( pa->maxpoints == 0 || ! pa->serialized_pointlist )
{
pa->maxpoints = 32;
pa->npoints = 0;
pa->serialized_pointlist = lwalloc(ptarray_point_size(pa) * pa->maxpoints);
}
/* Error out if we have a bad situation */
if ( pa->npoints > pa->maxpoints )
{
lwerror("npoints (%d) is greated than maxpoints (%d)", pa->npoints, pa->maxpoints);
return LW_FAILURE;
}
/* Check if we have enough storage, add more if necessary */
if( pa->npoints == pa->maxpoints )
{
pa->maxpoints *= 2;
pa->serialized_pointlist = lwrealloc(pa->serialized_pointlist, ptarray_point_size(pa) * pa->maxpoints);
}
/* Make space to insert the new point */
if( where < pa->npoints )
{
size_t copy_size = point_size * (pa->npoints - where);
memmove(getPoint_internal(pa, where+1), getPoint_internal(pa, where), copy_size);
LWDEBUGF(5,"copying %d bytes to start vertex %d from start vertex %d", copy_size, where+1, where);
}
/* We have one more point */
++pa->npoints;
/* Copy the new point into the gap */
ptarray_set_point4d(pa, where, p);
LWDEBUGF(5,"copying new point to start vertex %d", point_size, where);
return LW_SUCCESS;
}
void ptarray_free(POINTARRAY *pa)
{
if(pa)
{
if(pa->serialized_pointlist && ( ! FLAGS_GET_READONLY(pa->flags) ) )
lwfree(pa->serialized_pointlist);
lwfree(pa);
LWDEBUG(5,"Freeing a PointArray");
}
}
int
ptarray_append_ptarray(POINTARRAY *pa1, POINTARRAY *pa2, double gap_tolerance)
{
unsigned int poff = 0;
unsigned int npoints;
unsigned int ncap;
unsigned int ptsize;
/* Check for pathology */
if( ! pa1 || ! pa2 )
{
lwerror("ptarray_append_ptarray: null input");
return LW_FAILURE;
}
npoints = pa2->npoints;
if ( ! npoints ) return LW_SUCCESS; /* nothing more to do */
if( FLAGS_GET_READONLY(pa1->flags) )
{
lwerror("ptarray_append_ptarray: target pointarray is read-only");
return LW_FAILURE;
}
if( FLAGS_GET_ZM(pa1->flags) != FLAGS_GET_ZM(pa2->flags) )
{
lwerror("ptarray_append_ptarray: appending mixed dimensionality is not allowed");
return LW_FAILURE;
}
ptsize = ptarray_point_size(pa1);
/* Check for duplicate end point */
if ( pa1->npoints )
{
POINT2D tmp1, tmp2;
getPoint2d_p(pa1, pa1->npoints-1, &tmp1);
getPoint2d_p(pa2, 0, &tmp2);
/* If the end point and start point are the same, then don't copy start point */
if (p2d_same(&tmp1, &tmp2)) {
poff = 1;
--npoints;
}
else if ( gap_tolerance == 0 || ( gap_tolerance > 0 &&
distance2d_pt_pt(&tmp1, &tmp2) > gap_tolerance ) )
{
lwerror("Second line start point too far from first line end point");
return LW_FAILURE;
}
}
/* Check if we need extra space */
ncap = pa1->npoints + npoints;
if ( pa1->maxpoints < ncap )
{
pa1->maxpoints = ncap > pa1->maxpoints*2 ?
ncap : pa1->maxpoints*2;
pa1->serialized_pointlist = (uint8_t *)lwrealloc(pa1->serialized_pointlist, ptsize * pa1->maxpoints);
}
memcpy(getPoint_internal(pa1, pa1->npoints),
getPoint_internal(pa2, poff), ptsize * npoints);
pa1->npoints = ncap;
return LW_SUCCESS;
}
