Plane.h

Go to the documentation of this file.

// GMTL is (C) Copyright 2001-2010 by Allen Bierbaum
// Distributed under the GNU Lesser General Public License 2.1 with an
// addendum covering inlined code. (See accompanying files LICENSE and
// LICENSE.addendum or http://www.gnu.org/copyleft/lesser.txt)

#ifndef _GMTL_PLANE_H
#define _GMTL_PLANE_H

#include <gmtl/Vec.h>
#include <gmtl/Point.h>
#include <gmtl/VecOps.h>

namespace gmtl
{

template< class DATA_TYPE>
class Plane
{
public:
   Plane()
      : mOffset( 0 )
   {}

   Plane( const Point<DATA_TYPE, 3>& pt1, const Point<DATA_TYPE, 3>& pt2,
          const Point<DATA_TYPE, 3>& pt3)
   {
      Vec<DATA_TYPE, 3> vec12( pt2-pt1 );
      Vec<DATA_TYPE, 3> vec13( pt3-pt1 );

      cross( mNorm, vec12, vec13 );
      normalize( mNorm );

      mOffset = dot( static_cast< Vec<DATA_TYPE, 3> >(pt1), mNorm );  // Graphics Gems I: Page 390
   }

   Plane( const Vec<DATA_TYPE, 3>& norm, const Point<DATA_TYPE, 3>& pt )
      : mNorm( norm )
   {
      mOffset = dot( static_cast< Vec<DATA_TYPE, 3> >(pt), norm );
   }

   Plane( const Vec<DATA_TYPE, 3>& norm, const DATA_TYPE& dPlaneConst )
      : mNorm( norm ), mOffset( dPlaneConst )
   {}

   Plane( const Plane<DATA_TYPE>& plane )
      : mNorm( plane.mNorm ), mOffset( plane.mOffset )
   {}

   const Vec<DATA_TYPE, 3>& getNormal() const
   {
      return mNorm;
   }

   void setNormal( const Vec<DATA_TYPE, 3>& norm )
   {
      mNorm = norm;
   }

   const DATA_TYPE& getOffset() const
   {
      return mOffset;
   }

   void setOffset( const DATA_TYPE& offset )
   {
      mOffset = offset;
   }

public:
   // dot(Pt,mNorm) = mOffset
   Vec<DATA_TYPE, 3> mNorm;

   DATA_TYPE mOffset;
};

typedef Plane<float> Planef;
typedef Plane<double> Planed;

/*
#include <geomdist.h>


// Intersects the plane with a given segment.
// Returns TRUE if there is a hit (within the seg).
// Also returns the distance "down" the segment of the hit in t.
//
// PRE: seg.dir must be normalized
//
int sgPlane::isect(sgSeg& seg, float* t)
{
   // Graphic Gems I: Page 391
   float denom = normal.dot(seg.dir);
   if (SG_IS_ZERO(denom))     // No Hit
   {
      //: So now, it is just dist to plane tested against length
      sgVec3   hit_pt;
      float    hit_dist;      // Dist to hit
      
      hit_dist = findNearestPt(seg.pos, hit_pt);
      *t = hit_dist;       // Since dir is normalized

      if(seg.tValueOnSeg(*t))
         return 1;
      else
         return 0;
   }
   else
   {
      float numer = offset + normal.dot(seg.pos);
      (*t) = -1.0f * (numer/denom);
      
      if(seg.tValueOnSeg(*t))
         return 1;
      else
         return 0;
   }
}

 // Intersects the plane with the line defined
 // by the given segment
 //
 // seg - seg that represents the line to isect
 // t   - the t value of the isect
 //
int sgPlane::isectLine(const sgSeg& seg, float* t)
{
   // GGI: Pg 299
   // Lu = seg.pos;
   // Lv = seg.dir;
   // Jn = normal;
   // Jd = offset;
   
   float denom = normal.dot(seg.dir);
   if(denom == 0.0f)
      return 0;
   else
   {
      *t = - (offset+ normal.dot(seg.pos))/(denom);
      return 1;
   }
}
*/

} // namespace gmtl
#endif