ptarray_append_ptarray()

int ptarray_append_ptarray ( POINTARRAY *  pa1, POINTARRAY *  pa2, double  gap_tolerance  )

extern

Append a POINTARRAY, pa2 to the end of an existing POINTARRAY, pa1.

If gap_tolerance is >= 0 then the end point of pa1 will be checked for being within gap_tolerance 2d distance from start point of pa2 or an error will be raised and LW_FAILURE returned. A gap_tolerance < 0 disables the check.

If end point of pa1 and start point of pa2 are 2d-equal, then pa2 first point will not be appended.

Definition at line 177 of file ptarray.c.

{
        unsigned int poff = 0;
        unsigned int npoints;
        unsigned int ncap;
        unsigned int ptsize;
 
        /* Check for pathology */
        if( ! pa1 || ! pa2 )
        {
                lwerror("%s: null input", __func__);
                return LW_FAILURE;
        }
 
        npoints = pa2->npoints;
 
        if ( ! npoints ) return LW_SUCCESS; /* nothing more to do */
 
        if( FLAGS_GET_READONLY(pa1->flags) )
        {
                lwerror("%s: target pointarray is read-only", __func__);
                return LW_FAILURE;
        }
 
        if( FLAGS_GET_ZM(pa1->flags) != FLAGS_GET_ZM(pa2->flags) )
        {
                lwerror("%s: appending mixed dimensionality is not allowed", __func__);
                return LW_FAILURE;
        }
 
        ptsize = ptarray_point_size(pa1);
 
        /* Check for duplicate end point */
        if ( pa1->npoints )
        {
                const POINT2D *tmp1, *tmp2;
                tmp1 = getPoint2d_cp(pa1, pa1->npoints-1);
                tmp2 = getPoint2d_cp(pa2, 0);
 
                /* 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 )
        {
                if ( pa1->maxpoints )
                {
                        pa1->maxpoints = ncap > pa1->maxpoints*2 ?
                                                                                         ncap : pa1->maxpoints*2;
                        pa1->serialized_pointlist = lwrealloc(pa1->serialized_pointlist, (size_t)ptsize * pa1->maxpoints);
                }
                else
                {
                        pa1->maxpoints = ncap;
                        pa1->serialized_pointlist = lwalloc((size_t)ptsize * pa1->maxpoints);
                }
        }
 
        memcpy(getPoint_internal(pa1, pa1->npoints),
               getPoint_internal(pa2, poff), (size_t)ptsize * npoints);
 
        pa1->npoints = ncap;
 
        return LW_SUCCESS;
}

References distance2d_pt_pt(), POINTARRAY::flags, FLAGS_GET_READONLY, FLAGS_GET_ZM, getPoint2d_cp(), getPoint_internal(), LW_FAILURE, LW_SUCCESS, lwalloc(), lwerror(), lwrealloc(), POINTARRAY::maxpoints, POINTARRAY::npoints, p2d_same(), ptarray_point_size(), and POINTARRAY::serialized_pointlist.

Referenced by _lwt_HealEdges(), _lwt_MakeRingShell(), _lwt_SnapEdge_checkMotion(), lwline_extend(), lwline_from_lwgeom_array(), and test_ptarray_append_ptarray().

Here is the call graph for this function:

Here is the caller graph for this function: