---

plane.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_INCPLANE_H

#define AMOD_MATH_LIB_INCPLANE_H
// DESCRIPTION:
//
// Declaration of a class plane, keeping a definition of an oriented plane in 
// 3D. The plane is defined by its (unit) normal vector and parameter 'd', 
// which is the signed distance of the plane from the origin of the coordinate 
// system.
//
// For all points on the plane holds:
//
//   normal * point + d = 0
//
// The plane parameters are accessed via public data members 'normal' and 'd'.
//
// If the plane is invalid (cannot be constructed), the plane normal is set to 
// a null vector.
//

#include "point2d.H"
#include "point3d.H"
#include "line3d.H"

template <class PLANE, class P, class V, class L>
class _plane
{
protected:
    V       _normal;
    Greal  _d;

public:

    _plane()                     :                        _d(0) {}
    _plane(const V &n, Greal d) : _normal(n.normalize()),_d(d) {}
    _plane(const P &p, const V&n): _normal(n.normalize()),_d((P()-p)*_normal) {}
    _plane(const P &p1,  const P&p2, const P&p3)  
           { *this = _plane<PLANE,P,V,L>(p1, cross(p3-p1, p2-p1)); }
    _plane(const P &,  const V&, const V&);

    // Create plane from a polygon of vertices (n >=3). All polygon vertices
    // are used to calculate the plane coefficients to make the formula
    // symetrical.
    //
    _plane(const P plg[], int n);

    // The plane normal is given, just calculate the 'd' parameter from all 
    // polygon vertices.
    //
    _plane(const P plg[], int n, const V& normal);

    PLANE    operator -()          const { return PLANE(-_normal, -_d); }
    Greal   dist      (const P &p)const { return (p-P())*_normal+_d; }
    P        project   (const P & )const;
    V        project   (const V & )const;
    L        project   (const L & )const;

    P        operator* (const L & )const;

          V &normal    ()                { return _normal; }
    const V &normal    ()          const { return _normal; }
    Greal  &d         ()                { return _d; }
    Greal   d         ()          const { return _d; }
    P        origin    ()          const { return P()-_normal*_d; }

    bool     isParallel(const PLANE &p) const { return _normal.isEqual(p._normal)||
                                                       _normal.isEqual(-p._normal); }
    bool     isEqual   (const PLANE &p) const { return (_d*_normal).isEqual(
                                                        p._d*p._normal);  }
    bool     isValid   ()          const { return fabs(_normal.length() - 1) <
                                   epsNorMath(); }

    void     orthoplane(int& i1, int& i2)          const;
    void     orthoplane(int& i1, int& i2, int& i3) const;

    P        intersect(const L &l) const { return plane_intersect(l.point(), 
                                            l.vector(), origin(), _normal); }

}; // class _plane

template <class P, class V> 
inline
P        
plane_intersect(
   const P &pt, 
   const V &D, 
   const P &O, 
   const V &N)
{
   Greal t = (fabs(D*N) > 0.000001) ? ((O-pt) * N) / (D*N) : -1; 

   return pt + t * D; 
}

template <class P, class V> 
inline
Greal
axis_ang( 
   const P &p1, 
   const P &p2, 
   const P &axispt, 
   const V &axis)
{
   V v1 = (p1 - axispt).normalize();
   V v2 = (p2 - axispt).normalize();
   const Greal negone = -1.0;
   const Greal one    =  1.0;
   Greal ang = acos(clamp(v1*v2, negone, one));
   if (cross(v1,v2) * axis < 0)
      ang = -ang;
   return ang;
}

#ifdef GLUE_NEEDS_TEMPLATES_IN_H_FILE
#include "plane.C"
#endif
#endif

---