ptarray_substring()

POINTARRAY* ptarray_substring	(	POINTARRAY *	pa,
		double	d1,
		double	d2,
		double	tolerance
	)

start location (distance from start / total distance) end location (distance from start / total distance)

Parameters

tolerance

snap to vertices at locations < tolerance away from given ones

Definition at line 1061 of file ptarray.c.

References distance2d_pt_pt(), POINTARRAY::flags, FLAGS_GET_M, FLAGS_GET_Z, getPoint4d_p(), interpolate_point4d(), LW_FALSE, LWDEBUG, LWDEBUGF, POINT4D::m, POINTARRAY::npoints, ptarray_append_point(), ptarray_construct_empty(), ptarray_length_2d(), POINT4D::x, POINT4D::y, and POINT4D::z.

Referenced by LWGEOM_line_substring().

{
        POINTARRAY *dpa;
        POINT4D pt;
        POINT4D p1, p2;
        POINT4D *p1ptr=&p1; /* don't break strict-aliasing rule */
        POINT4D *p2ptr=&p2;
        int nsegs, i;
        double length, slength, tlength;
        int state = 0; /* 0=before, 1=inside */

        /*
         * Create a dynamic pointarray with an initial capacity
         * equal to full copy of input points
         */
        dpa = ptarray_construct_empty(FLAGS_GET_Z(ipa->flags), FLAGS_GET_M(ipa->flags), ipa->npoints);

        /* Compute total line length */
        length = ptarray_length_2d(ipa);


        LWDEBUGF(3, "Total length: %g", length);


        /* Get 'from' and 'to' lengths */
        from = length*from;
        to = length*to;


        LWDEBUGF(3, "From/To: %g/%g", from, to);


        tlength = 0;
        getPoint4d_p(ipa, 0, &p1);
        nsegs = ipa->npoints - 1;
        for ( i = 0; i < nsegs; i++ )
        {
                double dseg;

                getPoint4d_p(ipa, i+1, &p2);


                LWDEBUGF(3 ,"Segment %d: (%g,%g,%g,%g)-(%g,%g,%g,%g)",
                         i, p1.x, p1.y, p1.z, p1.m, p2.x, p2.y, p2.z, p2.m);


                /* Find the length of this segment */
                slength = distance2d_pt_pt((POINT2D *)p1ptr, (POINT2D *)p2ptr);

                /*
                 * We are before requested start.
                 */
                if ( state == 0 ) /* before */
                {

                        LWDEBUG(3, " Before start");

                        if ( fabs ( from - ( tlength + slength ) ) <= tolerance )
                        {

                                LWDEBUG(3, "  Second point is our start");

                                /*
                                 * Second point is our start
                                 */
                                ptarray_append_point(dpa, &p2, LW_FALSE);
                                state=1; /* we're inside now */
                                goto END;
                        }

                        else if ( fabs(from - tlength) <= tolerance )
                        {

                                LWDEBUG(3, "  First point is our start");

                                /*
                                 * First point is our start
                                 */
                                ptarray_append_point(dpa, &p1, LW_FALSE);

                                /*
                                 * We're inside now, but will check
                                 * 'to' point as well
                                 */
                                state=1;
                        }

                        /*
                         * Didn't reach the 'from' point,
                         * nothing to do
                         */
                        else if ( from > tlength + slength ) goto END;

                        else  /* tlength < from < tlength+slength */
                        {

                                LWDEBUG(3, "  Seg contains first point");

                                /*
                                 * Our start is between first and
                                 * second point
                                 */
                                dseg = (from - tlength) / slength;

                                interpolate_point4d(&p1, &p2, &pt, dseg);

                                ptarray_append_point(dpa, &pt, LW_FALSE);

                                /*
                                 * We're inside now, but will check
                                 * 'to' point as well
                                 */
                                state=1;
                        }
                }

                if ( state == 1 ) /* inside */
                {

                        LWDEBUG(3, " Inside");

                        /*
                         * 'to' point is our second point.
                         */
                        if ( fabs(to - ( tlength + slength ) ) <= tolerance )
                        {

                                LWDEBUG(3, " Second point is our end");

                                ptarray_append_point(dpa, &p2, LW_FALSE);
                                break; /* substring complete */
                        }

                        /*
                         * 'to' point is our first point.
                         * (should only happen if 'to' is 0)
                         */
                        else if ( fabs(to - tlength) <= tolerance )
                        {

                                LWDEBUG(3, " First point is our end");

                                ptarray_append_point(dpa, &p1, LW_FALSE);

                                break; /* substring complete */
                        }

                        /*
                         * Didn't reach the 'end' point,
                         * just copy second point
                         */
                        else if ( to > tlength + slength )
                        {
                                ptarray_append_point(dpa, &p2, LW_FALSE);
                                goto END;
                        }

                        /*
                         * 'to' point falls on this segment
                         * Interpolate and break.
                         */
                        else if ( to < tlength + slength )
                        {

                                LWDEBUG(3, " Seg contains our end");

                                dseg = (to - tlength) / slength;
                                interpolate_point4d(&p1, &p2, &pt, dseg);

                                ptarray_append_point(dpa, &pt, LW_FALSE);

                                break;
                        }

                        else
                        {
                                LWDEBUG(3, "Unhandled case");
                        }
                }


END:

                tlength += slength;
                memcpy(&p1, &p2, sizeof(POINT4D));
        }

        LWDEBUGF(3, "Out of loop, ptarray has %d points", dpa->npoints);

        return dpa;
}

Here is the call graph for this function:

Here is the caller graph for this function: