ptarray_segmentize2d()

POINTARRAY* ptarray_segmentize2d	(	const POINTARRAY *	ipa,
		double	dist
	)

Returns a modified POINTARRAY so that no segment is longer than the given distance (computed using 2d).

Every input point is kept. Z and M values for added points (if needed) are set proportionally.

Definition at line 405 of file ptarray.c.

{
        double segdist;
        POINT4D p1, p2;
        POINT4D pbuf;
        POINTARRAY *opa;
        uint32_t i, j, nseg;
        int hasz = FLAGS_GET_Z(ipa->flags);
        int hasm = FLAGS_GET_M(ipa->flags);
 
        pbuf.x = pbuf.y = pbuf.z = pbuf.m = 0;
 
        /* Initial storage */
        opa = ptarray_construct_empty(hasz, hasm, ipa->npoints);
 
        /* Add first point */
        getPoint4d_p(ipa, 0, &p1);
        ptarray_append_point(opa, &p1, LW_FALSE);
 
        /* Loop on all other input points */
        for (i = 1; i < ipa->npoints; i++)
        {
                /*
                 * We use these pointers to avoid
                 * "strict-aliasing rules break" warning raised
                 * by gcc (3.3 and up).
                 *
                 * It looks that casting a variable address (also
                 * referred to as "type-punned pointer")
                 * breaks those "strict" rules.
                 */
                POINT4D *p1ptr=&p1, *p2ptr=&p2;
                double segments;
 
                getPoint4d_p(ipa, i, &p2);
 
                segdist = distance2d_pt_pt((POINT2D *)p1ptr, (POINT2D *)p2ptr);
                /* Split input segment into shorter even chunks */
                segments = ceil(segdist / dist);
 
                /* Uses INT32_MAX instead of UINT32_MAX to be safe that it fits */
                if (segments >= INT32_MAX)
                {
                        lwnotice("%s:%d - %s: Too many segments required (%e)",
                                __FILE__, __LINE__,__func__, segments);
                        ptarray_free(opa);
                        return NULL;
                }
                nseg = segments;
 
                for (j = 1; j < nseg; j++)
                {
                        pbuf.x = p1.x + (p2.x - p1.x) * j / nseg;
                        pbuf.y = p1.y + (p2.y - p1.y) * j / nseg;
                        if (hasz)
                                pbuf.z = p1.z + (p2.z - p1.z) * j / nseg;
                        if (hasm)
                                pbuf.m = p1.m + (p2.m - p1.m) * j / nseg;
                        ptarray_append_point(opa, &pbuf, LW_FALSE);
                        LW_ON_INTERRUPT(ptarray_free(opa); return NULL);
                }
 
                ptarray_append_point(opa, &p2, (ipa->npoints == 2) ? LW_TRUE : LW_FALSE);
                p1 = p2;
                LW_ON_INTERRUPT(ptarray_free(opa); return NULL);
        }
 
        return opa;
}

References distance2d_pt_pt(), POINTARRAY::flags, FLAGS_GET_M, FLAGS_GET_Z, getPoint4d_p(), INT32_MAX, LW_FALSE, LW_ON_INTERRUPT, LW_TRUE, lwnotice(), POINT4D::m, POINTARRAY::npoints, ptarray_append_point(), ptarray_construct_empty(), ptarray_free(), POINT4D::x, POINT4D::y, and POINT4D::z.

Referenced by lwline_segmentize2d(), and lwpoly_segmentize2d().

Here is the call graph for this function:

Here is the caller graph for this function: