lwline_covers_lwline()

int lwline_covers_lwline	(	const LWLINE *	lwline1,
		const LWLINE *	lwline2
	)

Check if first and last point of line2 are covered by line1 and then each point in between has to be one line1 in the exact same order return LW_TRUE if all edge points of line2 are on line1.

Definition at line 2769 of file lwgeodetic.c.

References edge_contains_point(), GEOGRAPHIC_EDGE::end, geographic_point_init(), getPoint2d_cp(), LW_FALSE, LW_TRUE, LWDEBUG, lwline_covers_lwpoint(), lwline_get_lwpoint(), POINTARRAY::npoints, LWLINE::points, GEOGRAPHIC_EDGE::start, POINT2D::x, and POINT2D::y.

Referenced by lwgeom_covers_lwgeom_sphere().

{
        int i, j;
        GEOGRAPHIC_EDGE e1, e2;
        GEOGRAPHIC_POINT p1, p2;
        int start = LW_FALSE;
        int changed = LW_FALSE;

        /* first point on line */
        if ( ! lwline_covers_lwpoint(lwline1, lwline_get_lwpoint(lwline2, 0)))
        {
                LWDEBUG(4,"returning false, first point of line2 is not covered by line1");
                return LW_FALSE;
        }

        /* last point on line */
        if ( ! lwline_covers_lwpoint(lwline1, lwline_get_lwpoint(lwline2, lwline2->points->npoints - 1)))
        {
                LWDEBUG(4,"returning false, last point of line2 is not covered by line1");
                return LW_FALSE;
        }

        j = 0;
        i = 0;
        while (i < lwline1->points->npoints - 1 && j < lwline2->points->npoints - 1)
        {
                changed = LW_FALSE;
                const POINT2D* a1 = getPoint2d_cp(lwline1->points, i);
                const POINT2D* a2 = getPoint2d_cp(lwline1->points, i+1);
                const POINT2D* b1 = getPoint2d_cp(lwline2->points, j);
                const POINT2D* b2 = getPoint2d_cp(lwline2->points, j+1);

                geographic_point_init(a1->x, a1->y, &(e1.start));
                geographic_point_init(a2->x, a2->y, &(e1.end));
                geographic_point_init(b1->x, b1->y, &p2);

                /* we already know, that the last point is on line1, so we're done */
                if ( j == lwline2->points->npoints - 1)
                {
                        return LW_TRUE;
                }
                else if (start == LW_TRUE)
                {
                        /* point is on current line1 edge, check next point in line2 */
                        if ( edge_contains_point(&e1, &p2)) {
                                j++;
                                changed = LW_TRUE;
                        }

                        geographic_point_init(a1->x, a1->y, &(e2.start));
                        geographic_point_init(a2->x, b2->y, &(e2.end));
                        geographic_point_init(a1->x, a1->y, &p1);

                        /* point is on current line2 edge, check next point in line1 */
                        if ( edge_contains_point(&e2, &p1)) {
                                i++;
                                changed = LW_TRUE;
                        }

                        /* no edge progressed -> point left one line */
                        if ( changed == LW_FALSE )
                        {
                                LWDEBUG(4,"returning false, found point not covered by both lines");
                                return LW_FALSE;
                        }
                        else
                        {
                                continue;
                        }
                }

                /* find first edge to cover line2 */
                if (edge_contains_point(&e1, &p2))
                {
                        start = LW_TRUE;
                }

                /* next line1 edge */
                i++;
        }

        /* no uncovered point found */
        return LW_TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function: