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 2073 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;
                for (r=-1; r<=1; r +=2) /*because we are not iterating in the original point order we have to check the segment before and after every point*/
                {
                        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;
 
                                maxmeasure = sqrt(dl->distance*dl->distance + (dl->distance*dl->distance*k*k));/*here we "translate" the found mindistance so it can be compared to our "z"-values*/
                        }
                }
        }
 
        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: