1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
|
/****************************************************************************
* VCGLib o o *
* Visual and Computer Graphics Library o o *
* _ O _ *
* Copyright(C) 2004-2016 \/)\/ *
* 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.
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()
@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); }
template <class Q>
inline void Import( const Plane3<Q,false> & b )
{
_offset = ScalarType(b.Offset());
_dir = Point3<T>::Construct(b.Direction());
}
//@{
/** @name Members to access the distance or direction
Direction() cannot be assigned directly.
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
**/
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;
}
}
void Set( const PointType & dir, const ScalarType & off) {Set(off,dir);}
/// 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;
return p - _dir * k;
}
///Mirror the point wrt the plane
PointType Mirror(const PointType &p) const {
PointType mirr=Projection(p);
mirr+=mirr-p;
return mirr;
}
/// 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) {
_dir = (p2 - p0) ^ (p1 - p0);
if(NORM) Normalize();
_offset = p0.dot(_dir);
}
/// 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);
}
}; // 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();
}
template<class T> T SignedDistancePointPlane(const Point3<T> & point, const Plane3<T,true> & plane)
{
return SignedDistancePlanePoint(plane, point);
}
} // end namespace
#endif
|
