lw_dist2d_seg_seg()

int lw_dist2d_seg_seg	(	const POINT2D *	A,
		const POINT2D *	B,
		const POINT2D *	C,
		const POINT2D *	D,
		DISTPTS *	dl
	)

Finds the shortest distance between two segments.

This function is changed so it is not doing any comparison of distance but just sending every possible combination further to lw_dist2d_pt_seg

Definition at line 1821 of file measures.c.

{
        double  s_top, s_bot,s;
        double  r_top, r_bot,r;
 
        LWDEBUGF(2, "lw_dist2d_seg_seg [%g,%g]->[%g,%g] by [%g,%g]->[%g,%g]",
                 A->x,A->y,B->x,B->y, C->x,C->y, D->x, D->y);
 
        /*A and B are the same point */
        if (  ( A->x == B->x) && (A->y == B->y) )
        {
                return lw_dist2d_pt_seg(A,C,D,dl);
        }
        /*U and V are the same point */
 
        if (  ( C->x == D->x) && (C->y == D->y) )
        {
                dl->twisted= ((dl->twisted) * (-1));
                return lw_dist2d_pt_seg(D,A,B,dl);
        }
        /* AB and CD are line segments */
        /* from comp.graphics.algo
 
        Solving the above for r and s yields
                                (Ay-Cy)(Dx-Cx)-(Ax-Cx)(Dy-Cy)
                   r = ----------------------------- (eqn 1)
                                (Bx-Ax)(Dy-Cy)-(By-Ay)(Dx-Cx)
 
                        (Ay-Cy)(Bx-Ax)-(Ax-Cx)(By-Ay)
                s = ----------------------------- (eqn 2)
                        (Bx-Ax)(Dy-Cy)-(By-Ay)(Dx-Cx)
        Let P be the position vector of the intersection point, then
                P=A+r(B-A) or
                Px=Ax+r(Bx-Ax)
                Py=Ay+r(By-Ay)
        By examining the values of r & s, you can also determine some other limiting conditions:
                If 0<=r<=1 & 0<=s<=1, intersection exists
                r<0 or r>1 or s<0 or s>1 line segments do not intersect
                If the denominator in eqn 1 is zero, AB & CD are parallel
                If the numerator in eqn 1 is also zero, AB & CD are collinear.
 
        */
        r_top = (A->y-C->y)*(D->x-C->x) - (A->x-C->x)*(D->y-C->y);
        r_bot = (B->x-A->x)*(D->y-C->y) - (B->y-A->y)*(D->x-C->x);
 
        s_top = (A->y-C->y)*(B->x-A->x) - (A->x-C->x)*(B->y-A->y);
        s_bot = (B->x-A->x)*(D->y-C->y) - (B->y-A->y)*(D->x-C->x);
 
        if  ( (r_bot==0) || (s_bot == 0) )
        {
                if ((lw_dist2d_pt_seg(A,C,D,dl)) && (lw_dist2d_pt_seg(B,C,D,dl)))
                {
                        dl->twisted= ((dl->twisted) * (-1));  /*here we change the order of inputted geometries and that we  notice by changing sign on dl->twisted*/
                        return ((lw_dist2d_pt_seg(C,A,B,dl)) && (lw_dist2d_pt_seg(D,A,B,dl))); /*if all is successful we return true*/
                }
                else
                {
                        return LW_FALSE; /* if any of the calls to lw_dist2d_pt_seg goes wrong we return false*/
                }
        }
 
        s = s_top/s_bot;
        r=  r_top/r_bot;
 
        if (((r<0) || (r>1) || (s<0) || (s>1)) || (dl->mode == DIST_MAX))
        {
                if ((lw_dist2d_pt_seg(A,C,D,dl)) && (lw_dist2d_pt_seg(B,C,D,dl)))
                {
                        dl->twisted= ((dl->twisted) * (-1));  /*here we change the order of inputted geometries and that we  notice by changing sign on dl->twisted*/
                        return ((lw_dist2d_pt_seg(C,A,B,dl)) && (lw_dist2d_pt_seg(D,A,B,dl))); /*if all is successful we return true*/
                }
                else
                {
                        return LW_FALSE; /* if any of the calls to lw_dist2d_pt_seg goes wrong we return false*/
                }
        }
        else
        {
                if (dl->mode == DIST_MIN)       /*If there is intersection we identify the intersection point and return it but only if we are looking for mindistance*/
                {
                        POINT2D theP;
 
                        if (((A->x==C->x)&&(A->y==C->y))||((A->x==D->x)&&(A->y==D->y)))
                        {
                                theP.x = A->x;
                                theP.y = A->y;
                        }
                        else if (((B->x==C->x)&&(B->y==C->y))||((B->x==D->x)&&(B->y==D->y)))
                        {
                                theP.x = B->x;
                                theP.y = B->y;
                        }
                        else
                        {
                                theP.x = A->x+r*(B->x-A->x);
                                theP.y = A->y+r*(B->y-A->y);
                        }
                        dl->distance=0.0;
                        dl->p1=theP;
                        dl->p2=theP;
                }
                return LW_TRUE;
        }
}

References DIST_MAX, DIST_MIN, DISTPTS::distance, lw_dist2d_pt_seg(), LW_FALSE, LW_TRUE, LWDEBUGF, DISTPTS::mode, DISTPTS::p1, DISTPTS::p2, r, s, DISTPTS::twisted, POINT2D::x, and POINT2D::y.

Referenced by lw_dist2d_arc_arc(), lw_dist2d_ptarray_ptarray(), lw_dist2d_seg_arc(), and rect_leaf_node_distance().

Here is the call graph for this function:

Here is the caller graph for this function: