lw_dist2d_pt_seg()

int lw_dist2d_pt_seg	(	const POINT2D *	p,
		const POINT2D *	A,
		const POINT2D *	B,
		DISTPTS *	dl
	)

lw_dist2d_comp from p to line A->B This one is now sending every occasion to lw_dist2d_pt_pt Before it was handling occasions where r was between 0 and 1 internally and just returning the distance without identifying the points.

To get this points it was necessary to change and it also showed to be about 10faster.

Definition at line 2316 of file measures.c.

{
        double r;
 
        LWDEBUG(2, "lw_dist2d_pt_seg called");
 
        /*if start==end, then use pt distance */
        if ((A->x == B->x) && (A->y == B->y))
        {
                LWDEBUG(2, "lw_dist2d_pt_seg found first and last segment points being the same");
                return lw_dist2d_pt_pt(p, A, dl);
        }
 
 
        /*
         * otherwise, we use comp.graphics.algorithms
         * Frequently Asked Questions method
         *
         *  (1)        AC dot AB
         *         r = ---------
         *              ||AB||^2
         *      r has the following meaning:
         *      r=0 P = A
         *      r=1 P = B
         *      r<0 P is on the backward extension of AB
         *      r>1 P is on the forward extension of AB
         *      0<r<1 P is interior to AB
         */
 
        r = ((p->x - A->x) * (B->x - A->x) + (p->y - A->y) * (B->y - A->y)) /
            ((B->x - A->x) * (B->x - A->x) + (B->y - A->y) * (B->y - A->y));
 
        LWDEBUGF(2, "lw_dist2d_pt_seg found r = %.15g", r);
 
        /*This is for finding the maxdistance.
        the maxdistance have to be between two vertexes, compared to mindistance which can be between two vertexes.*/
        if (dl->mode == DIST_MAX)
        {
                if (r >= 0.5)
                        return lw_dist2d_pt_pt(p, A, dl);
                else /* (r < 0.5) */
                        return lw_dist2d_pt_pt(p, B, dl);
        }
 
        if (r < 0) /*If p projected on the line is outside point A*/
                return lw_dist2d_pt_pt(p, A, dl);
        if (r >= 1) /*If p projected on the line is outside point B or on point B*/
                return lw_dist2d_pt_pt(p, B, dl);
 
        /*If the point p is on the segment this is a more robust way to find out that*/
        if ((((A->y - p->y) * (B->x - A->x) == (A->x - p->x) * (B->y - A->y))) && (dl->mode == DIST_MIN))
        {
                dl->distance = 0.0;
                dl->p1 = *p;
                dl->p2 = *p;
        }
 
 
        /*
                (2)
                                  (Ay-Cy)(Bx-Ax)-(Ax-Cx)(By-Ay)
                        s = -----------------------------
                    L^2
 
                        Then the distance from C to P = |s|*L.
        */
 
        double s = ((A->y - p->y) * (B->x - A->x) - (A->x - p->x) * (B->y - A->y)) /
                   ((B->x - A->x) * (B->x - A->x) + (B->y - A->y) * (B->y - A->y));
 
        double dist = fabs(s) * sqrt(((B->x - A->x) * (B->x - A->x) + (B->y - A->y) * (B->y - A->y)));
        if ( dist < dl->distance )
        {
                dl->distance = dist;
                {
                        POINT2D c;
                        c.x = A->x + r * (B->x - A->x);
                        c.y = A->y + r * (B->y - A->y);
                        if (dl->twisted > 0)
                        {
                                dl->p1 = *p;
                                dl->p2 = c;
                        }
                        else
                        {
                                dl->p1 = c;
                                dl->p2 = *p;
                        }
                }
        }
 
        return LW_TRUE;
}

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

Referenced by lw_dist2d_pt_arc(), lw_dist2d_pt_ptarray(), lw_dist2d_seg_arc(), lw_dist2d_seg_seg(), lw_dist2d_selected_seg_seg(), rect_leaf_node_distance(), and rect_leaf_node_intersects().

Here is the call graph for this function:

Here is the caller graph for this function: