vcglib/vcg/space/plane3.h

166 lines
5.5 KiB
C
Raw Normal View History

2004-04-01 00:19:24 +02:00
/****************************************************************************
* 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 {
/** \addtogroup space */
/*@{*/
/**
Templated class for 2D planes in 3D spaces.
2004-04-01 00:19:24 +02:00
This is the class for infinite planes in 3D space. A Plane is stored just as a Point3 and a scalar:
* a direction (not necessarily normalized),
* an offset from the origin
Just to be clear, given a point P on a plane it always holds:
plane.Direction().dot(P) == plane.Offset()
2004-04-01 00:19:24 +02:00
@param T (template parameter) Specifies the type of scalar used to represent coords.
@param NORM: if on, the direction is always Normalized
*/
template <class T, bool NORM=true> class Plane3 {
public:
typedef T ScalarType;
typedef Point3<T> PointType;
private:
/// Distance
ScalarType _offset;
///Direction (not necessarily normalized unless NORM is true)
PointType _dir;
public:
//@{
/** @name Constructors
**/
/// The empty constructor
Plane3() {}
/// The (distance, direction) constructor
Plane3(const ScalarType &dist, const PointType &dir) { Set(dist, dir); }
2009-08-26 02:10:32 +02:00
template <class Q>
inline void Import( const Plane3<Q,false> & b )
{
_offset = ScalarType(b.Offset());
_dir = Point3<T>::Construct(b.Direction());
}
2004-04-01 00:19:24 +02:00
//@{
/** @name Members to access the distance or direction
Direction() cannot be assigned directly.
2004-05-05 10:20:47 +02:00
Use SetDirection() or Set() instead. This is mandatory to make possible the automatic autonormalization template mechanism.
Note that if you have to set both direction and offset it can be more efficient to set them toghether
2004-04-01 00:19:24 +02:00
**/
const ScalarType &Offset() const { return _offset; }
ScalarType &Offset() { return _offset; }
/// sets the origin
void SetOffset( const ScalarType &o ) { _offset=o; }
const PointType &Direction() const { return _dir; }
/// sets the direction
void SetDirection( const PointType & dir) {
_dir=dir;
if (NORM) _dir.Normalize();
}
/// sets origin and direction.
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;
}
2004-04-01 00:19:24 +02:00
}
2004-05-05 10:20:47 +02:00
void Set( const PointType & dir, const ScalarType & off) {Set(off,dir);}
2004-04-01 00:19:24 +02:00
/// Operator to compare two lines
bool operator==(Plane3 const &p) const {
return _offset == p._offset && _dir == p._dir;
}
/// Operator to dispare two lines
bool operator!=(Plane3 const &p) const {
return _offset != p._offset || _dir != p._dir;
}
///Project a point on the plane
PointType Projection(const PointType &p) const {
ScalarType k = p.dot(_dir) - _offset;
2004-04-01 00:19:24 +02:00
return p - _dir * k;
}
2014-04-07 08:29:32 +02:00
///Mirror the point wrt the plane
PointType Mirror(const PointType &p) const {
PointType mirr=Projection(p);
mirr+=mirr-p;
return mirr;
}
2004-04-01 00:19:24 +02:00
/// Function to normalize direction
void Normalize() {
_dir.Normalize();
}
/// Calculates the plane passing through three points (Rename this method)
void Init(const PointType &p0, const PointType &p1, const PointType &p2) {
2004-10-09 15:48:02 +02:00
_dir = (p2 - p0) ^ (p1 - p0);
2004-04-01 00:19:24 +02:00
if(NORM) Normalize();
_offset = p0.dot(_dir);
2004-04-01 00:19:24 +02:00
}
/// Calculates the plane passing through a point and the normal (Rename this method
inline void Init(const PointType &p0, const PointType &norm) {
_dir = norm;
if(NORM) Normalize();
_offset = p0.dot(_dir);
2004-04-01 00:19:24 +02:00
}
}; // end class Plane3
typedef Plane3<float> Plane3f;
typedef Plane3<double> Plane3d;
///Distance plane - point and vv. (Move these function to somewhere else)
template<class T> T SignedDistancePlanePoint(const Plane3<T,true> & plane, const Point3<T> & point)
{
return plane.Direction().dot(point) - plane.Offset();
2004-04-01 00:19:24 +02:00
}
template<class T> T SignedDistancePointPlane(const Point3<T> & point, const Plane3<T,true> & plane)
{
return SignedDistancePlanePoint(plane, point);
2004-04-01 00:19:24 +02:00
}
} // end namespace
2004-05-10 15:15:54 +02:00
#endif