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 to 0.

Definition at line 415 of file ptarray.c.

References distance2d_pt_pt(), POINTARRAY::flags, FLAGS_GET_M, FLAGS_GET_Z, getPoint4d_p(), LW_FALSE, LW_ON_INTERRUPT, LW_TRUE, 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().

{
        double  segdist;
        POINT4D p1, p2;
        POINT4D pbuf;
        POINTARRAY *opa;
        int ipoff=0; /* input point offset */
        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, ipoff, &p1);
        ptarray_append_point(opa, &p1, LW_FALSE);

        ipoff++;

        while (ipoff<ipa->npoints)
        {
                /*
                 * 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;

                getPoint4d_p(ipa, ipoff, &p2);

                segdist = distance2d_pt_pt((POINT2D *)p1ptr, (POINT2D *)p2ptr);

                if (segdist > dist) /* add an intermediate point */
                {
                        pbuf.x = p1.x + (p2.x-p1.x)/segdist * dist;
                        pbuf.y = p1.y + (p2.y-p1.y)/segdist * dist;
                        if( hasz )
                                pbuf.z = p1.z + (p2.z-p1.z)/segdist * dist;
                        if( hasm )
                                pbuf.m = p1.m + (p2.m-p1.m)/segdist * dist;
                        ptarray_append_point(opa, &pbuf, LW_FALSE);
                        p1 = pbuf;
                }
                else /* copy second point */
                {
                        ptarray_append_point(opa, &p2, (ipa->npoints==2)?LW_TRUE:LW_FALSE);
                        p1 = p2;
                        ipoff++;
                }

                LW_ON_INTERRUPT(ptarray_free(opa); return NULL);
        }

        return opa;
}

Here is the call graph for this function:

Here is the caller graph for this function: