plane3.h

Go to the documentation of this file.

/****************************************************************************
* VCGLib                                                            o o     *
* Visual and Computer Graphics Library                            o     o   *
*                                                                _   O  _   *
* Copyright(C) 2004                                                \/)\/    *
* Visual Computing Lab                                            /\/|      *
* ISTI - Italian National Research Council                           |      *
*                                                                    \      *
* All rights reserved.                                                      *
*                                                                           *
* This program 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 (http://www.gnu.org/licenses/gpl.txt)          *
* for more details.                                                         *
*                                                                           *
****************************************************************************/

#ifndef VCG_PLANE3_H
#define VCG_PLANE3_H

#include <vcg/space/point3.h>

namespace vcg {

template <class T, bool NORM=true> class Plane3 {
public: 
  typedef T ScalarType;
        typedef Point3<T> PointType;

private:
  ScalarType _offset;
  PointType _dir;

public:


  Plane3() {}
  Plane3(const ScalarType &dist, const PointType &dir) { Set(dist, dir); }

        template <class Q>
        inline void Import( const Plane3<Q,false> & b )
        {
                _offset = ScalarType(b.Offset());
                _dir = Point3<T>::Construct(b.Direction());
        }


  const ScalarType &Offset() const { return _offset; } 
  ScalarType &Offset() { return _offset; } 
        void SetOffset( const ScalarType &o ) { _offset=o; }
        
  const PointType &Direction() const { return _dir; } 
        void SetDirection( const PointType & dir)       {       
    _dir=dir; 
    if (NORM) _dir.Normalize();  
  }
        void Set( const ScalarType & off, const PointType & dir ) {
                if (NORM) {
                        const ScalarType normFactor = dir.Norm();
                        this->_dir = dir / normFactor;
                        this->_offset = off / normFactor;
                }
                else {
                        this->_offset = off;
                        this->_dir = dir;
                }
  }
  void Set( const PointType & dir, const ScalarType & off) {Set(off,dir);}
        
        bool operator==(Plane3 const &p) const  {       
    return _offset == p._offset && _dir == p._dir; 
  }
        bool operator!=(Plane3 const &p) const  {       
    return _offset != p._offset || _dir != p._dir; 
  }
        
  PointType Projection(const PointType &p) const        {
                ScalarType k = p.dot(_dir) - _offset;
                return p - _dir * k;
        }

  PointType Mirror(const PointType &p) const    {
     PointType mirr=Projection(p);
     mirr+=mirr-p;
     return mirr;
  }

  void Normalize() {
          _dir.Normalize();
  }

  void Init(const PointType &p0, const PointType &p1, const PointType &p2) {
    _dir = (p2 - p0) ^ (p1 - p0);
    if(NORM) Normalize();
    _offset = p0.dot(_dir);
  }

  inline void Init(const PointType &p0, const PointType &norm) {
          _dir = norm;
          if(NORM) Normalize();
          _offset = p0.dot(_dir);
  }
};      // end class Plane3

typedef Plane3<float>  Plane3f;
typedef Plane3<double> Plane3d;

template<class T> T SignedDistancePlanePoint(const Plane3<T,true> & plane, const Point3<T> & point)
{
        return plane.Direction().dot(point) - plane.Offset();
}


template<class T> T SignedDistancePointPlane(const Point3<T> & point, const Plane3<T,true> & plane)
{
        return SignedDistancePlanePoint(plane, point);
}

} // end namespace


#endif