vector/diglib/line_dist.c

Go to the documentation of this file.

/*
 ****************************************************************************
 *
 * MODULE:       Vector library 
 *              
 * AUTHOR(S):    Original author CERL, probably Dave Gerdes.
 *               Update to GRASS 5.7 Radim Blazek.
 *
 * PURPOSE:      Lower level functions for reading/writing/manipulating vectors.
 *
 * COPYRIGHT:    (C) 2001 by the GRASS Development Team
 *
 *               This program is free software under the GNU General Public
 *              License (>=v2). Read the file COPYING that comes with GRASS
 *              for details.
 *
 *****************************************************************************/
#include    <math.h>

#define ZERO(x) ((x) < tolerance && (x) > -tolerance)
#define TOLERANCE 1.0e-10
static double tolerance = TOLERANCE;

int dig_set_distance_to_line_tolerance(double t)
{
    if (t <= 0.0)
        t = TOLERANCE;
    tolerance = t;

    return 0;
}

/*
 *   dig_distance2_point_to_line ()
 *   compute square of distance of point (x,y) to line segment (x1,y1 - x2,y2)
 *   ( works correctly for  x1==x2 && y1==y2 )
 *
 *   returns: square distance
 *   sets (if not NULL): *px, *py - nearest point on segment
 *                       *pdist - distance of px,py from segment start
 *                       *status = 0 if ok, -1 if t < 0  and 1 if t > 1
 *                                 (tells if point is w/in segment space, or past ends)
 */

double dig_distance2_point_to_line(double x, double y, double z,        /* point */
                                   double x1, double y1, double z1,     /* line segment */
                                   double x2, double y2, double z2, int with_z, /* use z coordinate, (3D calculation) */
                                   double *px, double *py, double *pz,  /* point on segment */
                                   double *pdist,       /* distance of point on segment from the first point of segment */
                                   int *status)
{
    register double dx, dy, dz;
    register double dpx, dpy, dpz;
    register double tpx, tpy, tpz;
    double t;
    int st;

    st = 0;

    if (!with_z) {
        z = 0;
        z1 = 0;
        z2 = 0;
    }

    dx = x2 - x1;
    dy = y2 - y1;
    dz = z2 - z1;

    if (ZERO(dx) && ZERO(dy) && ZERO(dz)) {     /* line is degenerate */
        dx = x1 - x;
        dy = y1 - y;
        dz = z1 - z;
        tpx = x1;
        tpy = y1;
        tpz = z1;
    }
    else {
        t = (dx * (x - x1) + dy * (y - y1) + dz * (z - z1)) / (dx * dx +
                                                               dy * dy +
                                                               dz * dz);

        if (t < 0.0) {          /* go to x1,y1,z1 */
            t = 0.0;
            st = -1;
        }
        else if (t > 1.0) {     /* go to x2,y2,z2 */
            t = 1.0;
            st = 1;
        }

        /* go t from x1,y1,z1 towards x2,y2,z2 */
        tpx = dx * t + x1;
        tpy = dy * t + y1;
        tpz = dz * t + z1;
        dx = tpx - x;
        dy = tpy - y;
        dz = tpz - z;
    }

    if (px)
        *px = tpx;
    if (py)
        *py = tpy;
    if (pz)
        *pz = tpz;
    if (status)
        *status = st;

    if (pdist) {
        dpx = tpx - x1;
        dpy = tpy - y1;
        dpz = tpz - z1;
        *pdist = sqrt(dpx * dpx + dpy * dpy + dpz * dpz);
    }

    return (dx * dx + dy * dy + dz * dz);
}