gfx/Plane

Go to the documentation of this file.

/****************************************************************************
  Copyright (C)1996 David Jung <opensim@pobox.com>

  This program/file is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2 of the License, or
  (at your option) any later version.
  
  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details. (http://www.gnu.org)
  
  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  
  $Id: Plane 1030 2004-02-11 20:46:17Z jungd $
  $Revision: 1.3 $
  $Date: 2004-02-11 15:46:17 -0500 (Wed, 11 Feb 2004) $
  $Author: jungd $
 
****************************************************************************/

#ifndef _GFX_PLANE_
#define _GFX_PLANE_

#include <gfx/gfx>
#include <base/Point3>
#include <base/Vector3>
#include <gfx/Triangle3>

#include <iostream>


namespace gfx {

// Plane in 3D with Hession normal form: normal . x = -p
class Plane
{

public:
  Plane() {}
  
  Plane(const Vector3& normal, Real p)
    : normal(normal), p(p) { this->normal.normalize(); }
  
  Plane(Real a, Real b, Real c, Real d)
   : normal(a,b,c)
  { p = d/normal.length(); normal.normalize();  }
     
  Plane(const Point3& p1, const Point3& p2, const Point3& p3)
  {
    normal = cross(p1-p2,p3-p2); normal.normalize();
    p = -dot(normal,p1);
  }
  
  Plane(const Triangle3& t)
  {
    normal = cross(t.p1()-t.p2(),t.p3()-t.p2()); normal.normalize(); 
    p = -dot(normal,t.p1()); 
  }
  
  virtual ~Plane() {}
        
  Real distanceTo(const Point3& pt) const
  { return Math::abs(dot(normal,pt) + p); }
  
  bool contains(const Point3& p) const 
  { return Math::equals(distanceTo(p),0); }
        
  Real classify(const Vector3& v) const
  { return dot(normal,v) + p; }

  Vector3 normal;
  Real    p;
};


// Operations

inline std::ostream& operator<<(std::ostream& out, const Plane& p) // Output
{ return out << "(" << p.normal << "," << p.p << ")"; }


} // gfx

#endif

---