ptarray_locate_point()

double ptarray_locate_point ( const POINTARRAY *  pa, const POINT4D *  pt, double *  dist, POINT4D *  p_located  )

extern

Definition at line 1518 of file ptarray.c.

{
        double mindist=DBL_MAX;
        double tlen, plen;
        uint32_t t, seg=0;
        POINT4D start4d, end4d, projtmp;
        POINT2D proj, p;
        const POINT2D *start = NULL, *end = NULL;
 
        /* Initialize our 2D copy of the input parameter */
        p.x = p4d->x;
        p.y = p4d->y;
 
        if ( ! proj4d ) proj4d = &projtmp;
 
        /* Check for special cases (length 0 and 1) */
        if ( pa->npoints <= 1 )
        {
                if ( pa->npoints == 1 )
                {
                        getPoint4d_p(pa, 0, proj4d);
                        if ( mindistout )
                                *mindistout = distance2d_pt_pt(&p, getPoint2d_cp(pa, 0));
                }
                return 0.0;
        }
 
        start = getPoint2d_cp(pa, 0);
        /* Loop through pointarray looking for nearest segment */
        for (t=1; t<pa->npoints; t++)
        {
                double dist_sqr;
                end = getPoint2d_cp(pa, t);
                dist_sqr = distance2d_sqr_pt_seg(&p, start, end);
 
                if (dist_sqr < mindist)
                {
                        mindist = dist_sqr;
                        seg=t-1;
                        if ( mindist == 0 )
                        {
                                LWDEBUG(3, "Breaking on mindist=0");
                                break;
                        }
                }
 
                start = end;
        }
        mindist = sqrt(mindist);
 
        if ( mindistout ) *mindistout = mindist;
 
        LWDEBUGF(3, "Closest segment: %d", seg);
        LWDEBUGF(3, "mindist: %g", mindist);
 
        /*
         * We need to project the
         * point on the closest segment.
         */
        getPoint4d_p(pa, seg, &start4d);
        getPoint4d_p(pa, seg+1, &end4d);
        closest_point_on_segment(p4d, &start4d, &end4d, proj4d);
 
        /* Copy 4D values into 2D holder */
        proj.x = proj4d->x;
        proj.y = proj4d->y;
 
        LWDEBUGF(3, "Closest segment:%d, npoints:%d", seg, pa->npoints);
 
        /* For robustness, force 1 when closest point == endpoint */
        if ( (seg >= (pa->npoints-2)) && p2d_same(&proj, end) )
        {
                return 1.0;
        }
 
        LWDEBUGF(3, "Closest point on segment: %g,%g", proj.x, proj.y);
 
        tlen = ptarray_length_2d(pa);
 
        LWDEBUGF(3, "tlen %g", tlen);
 
        /* Location of any point on a zero-length line is 0 */
        /* See http://trac.osgeo.org/postgis/ticket/1772#comment:2 */
        if ( tlen == 0 ) return 0;
 
        plen=0;
        start = getPoint2d_cp(pa, 0);
        for (t=0; t<seg; t++, start=end)
        {
                end = getPoint2d_cp(pa, t+1);
                plen += distance2d_pt_pt(start, end);
 
                LWDEBUGF(4, "Segment %d made plen %g", t, plen);
        }
 
        plen+=distance2d_pt_pt(&proj, start);
 
        LWDEBUGF(3, "plen %g, tlen %g", plen, tlen);
 
        /* Floating point arithmetic is not reliable, make sure we return values [0,1] */
        double result = plen / tlen;
        if ( result < 0.0 ) {
                result = 0.0;
        } else if ( result > 1.0 ) {
                result = 1.0;
        }
        return result;
}

References closest_point_on_segment(), distance2d_pt_pt(), distance2d_sqr_pt_seg(), getPoint2d_cp(), getPoint4d_p(), LWDEBUG, LWDEBUGF, POINTARRAY::npoints, p2d_same(), ptarray_length_2d(), result, POINT2D::x, POINT4D::x, POINT2D::y, and POINT4D::y.

Referenced by lwgeom_interpolate_point(), LWGEOM_line_locate_point(), and test_ptarray_locate_point().

Here is the call graph for this function:

Here is the caller graph for this function: