---

line3d.H

Go to the documentation of this file.

/*
 * Copyright 2000, Brown University, Providence, RI.
 * 
 *                         All Rights Reserved
 * 
 * Permission to use, copy, modify, and distribute this software and its
 * documentation for any purpose other than its incorporation into a
 * commercial product is hereby granted without fee, provided that the
 * above copyright notice appear in all copies and that both that
 * copyright notice and this permission notice appear in supporting
 * documentation, and that the name of Brown University not be used in
 * advertising or publicity pertaining to distribution of the software
 * without specific, written prior permission.
 * 
 * BROWN UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR ANY
 * PARTICULAR PURPOSE.  IN NO EVENT SHALL BROWN UNIVERSITY BE LIABLE FOR
 * ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
#ifndef AMOD_MATH_LIB_INCLINE3D_H
#define AMOD_MATH_LIB_INCLINE3D_H

// DESCRIPTION:
//
// Declaration of class line keeping a definition of an oriented line and/or 
// an axis. The line class keeps a point3d and a vec3d. For the line 
// object to be valid, the vector must not be null.
//
// The parameters of the line class are accessed via public data members
// 'point' and 'vector'.
//

#include "point3d.H"

template <class L, class P, class V>
class _line
{
protected : 
    P  _point;
    V  _vector;

public:
    _line()                                                       {}
    _line(const P&  p, const V& v)  : _point ( p), _vector(v)     {}
    _line(const P& p1, const P& p2) : _point (p1), _vector(p2-p1) {}

    P        project(const P&p)  const { V vn(_vector.normalize()); 
                                         return _point + ((p-_point)*vn) *vn; }
    Greal   dist   (const P&p)  const { if (!isValid()){cerr<<"Invalid line\n";
                                                      return _point.dist(p);}
                                         return project(p).dist(p); }

    const P &point ()               const  { return _point; }
    P       &point ()                      { return _point; }
    const V &vector()               const  { return _vector; }
    V       &vector()                      { return _vector; }

    bool    isValid()               const  { return !_vector.isNull(); }

    P       intersect(const L &l)   const  { // this returns the closest pt
            const P &A = point();            // on "this"'s line to the 
            const P &B = l.point();          // passed in line, l.
            const V  Y = vector().normalize();
            const V  W = l.vector().normalize();
            const V BA = B-A;
            const Greal vv = Y*Y;
            const Greal ww = W*W;
            const Greal vw = Y*W;
            const Greal vba= Y*BA;
            const Greal wba= W*BA;
            const Greal det = vw*vw-vv*ww;

        if (det == 0)
           return project(A + (B-A) * .5);

        const Greal as = (vw*wba-ww*vba)/det;
        const P      AP = A+as*Y;

        return AP;
    }
    int operator==(const _line<L,P,V> &l) const {
       return l._point == _point && l._vector == _vector;
    }
};  // class _line



template <class L, class P, class V>
ostream &operator<<(ostream &os, const _line<L,P,V>  &l) 
                   { return os << "Line("<<l.point()<<","<<l.vector()<<")"; }


#endif

---