lw_dist2d_pre_seg_seg()

int lw_dist2d_pre_seg_seg	(	POINTARRAY *	l1,
		POINTARRAY *	l2,
		LISTSTRUCT *	list1,
		LISTSTRUCT *	list2,
		double	k,
		DISTPTS *	dl
	)

preparation before lw_dist2d_seg_seg.

Definition at line 2104 of file measures.c.

{
        const POINT2D *p1, *p2, *p3, *p4, *p01, *p02;
        int pnr1, pnr2, pnr3, pnr4, n1, n2, i, u, r, twist;
        double maxmeasure;
        n1 = l1->npoints;
        n2 = l2->npoints;
 
        LWDEBUG(2, "lw_dist2d_pre_seg_seg is called");
 
        p1 = getPoint2d_cp(l1, list1[0].pnr);
        p3 = getPoint2d_cp(l2, list2[0].pnr);
        lw_dist2d_pt_pt(p1, p3, dl);
        maxmeasure = sqrt(dl->distance * dl->distance + (dl->distance * dl->distance * k * k));
        twist = dl->twisted; /*to keep the incoming order between iterations*/
        for (i = (n1 - 1); i >= 0; --i)
        {
                /*we break this iteration when we have checked every point closer to our perpendicular "checkline" than
                 * our shortest found distance*/
                if (((list2[0].themeasure - list1[i].themeasure)) > maxmeasure)
                        break;
                /*because we are not iterating in the original point order we have to check the segment before and after
                 * every point*/
                for (r = -1; r <= 1; r += 2)
                {
                        pnr1 = list1[i].pnr;
                        p1 = getPoint2d_cp(l1, pnr1);
                        if (pnr1 + r < 0)
                        {
                                p01 = getPoint2d_cp(l1, (n1 - 1));
                                if ((p1->x == p01->x) && (p1->y == p01->y))
                                        pnr2 = (n1 - 1);
                                else
                                        pnr2 = pnr1; /* if it is a line and the last and first point is not the same we
                                                        avoid the edge between start and end this way*/
                        }
 
                        else if (pnr1 + r > (n1 - 1))
                        {
                                p01 = getPoint2d_cp(l1, 0);
                                if ((p1->x == p01->x) && (p1->y == p01->y))
                                        pnr2 = 0;
                                else
                                        pnr2 = pnr1; /* if it is a line and the last and first point is not the same we
                                                        avoid the edge between start and end this way*/
                        }
                        else
                                pnr2 = pnr1 + r;
 
                        p2 = getPoint2d_cp(l1, pnr2);
                        for (u = 0; u < n2; ++u)
                        {
                                if (((list2[u].themeasure - list1[i].themeasure)) >= maxmeasure)
                                        break;
                                pnr3 = list2[u].pnr;
                                p3 = getPoint2d_cp(l2, pnr3);
                                if (pnr3 == 0)
                                {
                                        p02 = getPoint2d_cp(l2, (n2 - 1));
                                        if ((p3->x == p02->x) && (p3->y == p02->y))
                                                pnr4 = (n2 - 1);
                                        else
                                                pnr4 = pnr3; /* if it is a line and the last and first point is not the
                                                                same we avoid the edge between start and end this way*/
                                }
                                else
                                        pnr4 = pnr3 - 1;
 
                                p4 = getPoint2d_cp(l2, pnr4);
                                dl->twisted = twist;
                                if (!lw_dist2d_selected_seg_seg(p1, p2, p3, p4, dl))
                                        return LW_FALSE;
 
                                if (pnr3 >= (n2 - 1))
                                {
                                        p02 = getPoint2d_cp(l2, 0);
                                        if ((p3->x == p02->x) && (p3->y == p02->y))
                                                pnr4 = 0;
                                        else
                                                pnr4 = pnr3; /* if it is a line and the last and first point is not the
                                                                same we avoid the edge between start and end this way*/
                                }
 
                                else
                                        pnr4 = pnr3 + 1;
 
                                p4 = getPoint2d_cp(l2, pnr4);
                                dl->twisted = twist; /*we reset the "twist" for each iteration*/
                                if (!lw_dist2d_selected_seg_seg(p1, p2, p3, p4, dl))
                                        return LW_FALSE;
                                /*here we "translate" the found mindistance so it can be compared to our "z"-values*/
                                maxmeasure = sqrt(dl->distance * dl->distance + (dl->distance * dl->distance * k * k));
                        }
                }
        }
 
        return LW_TRUE;
}

References DISTPTS::distance, getPoint2d_cp(), lw_dist2d_pt_pt(), lw_dist2d_selected_seg_seg(), LW_FALSE, LW_TRUE, LWDEBUG, POINTARRAY::npoints, LISTSTRUCT::pnr, r, DISTPTS::twisted, POINT2D::x, and POINT2D::y.

Referenced by lw_dist2d_fast_ptarray_ptarray().

Here is the call graph for this function:

Here is the caller graph for this function: