SALOME - SMESH
Rn.h
Go to the documentation of this file.
1 // MEFISTO : library to compute 2D triangulation from segmented boundaries
2 //
3 // Copyright (C) 2006 Laboratoire J.-L. Lions UPMC Paris
4 //
5 // This library is free software; you can redistribute it and/or
6 // modify it under the terms of the GNU Lesser General Public
7 // License as published by the Free Software Foundation; either
8 // version 2.1 of the License.
9 //
10 // This library is distributed in the hope that it will be useful,
11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 // Lesser General Public License for more details.
14 //
15 // You should have received a copy of the GNU Lesser General Public
16 // License along with this library; if not, write to the Free Software
17 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 //
19 // See http://www.ann.jussieu.fr/~perronne or email Perronnet@ann.jussieu.fr
20 // or email Hecht@ann.jussieu.fr
21 //
22 //
23 // File : Rn.h
24 // Module : SMESH
25 // Authors: Frederic HECHT & Alain PERRONNET
26 // Date : 13 novembre 2006
27 
28 #ifndef Rn__h
29 #define Rn__h
30 
31 #include <gp_Pnt.hxx> //Dans OpenCascade
32 #include <gp_Vec.hxx> //Dans OpenCascade
33 #include <gp_Dir.hxx> //Dans OpenCascade
34 
35 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
36 // BUT: Definir les espaces affines R R2 R3 R4 soit Rn pour n=1,2,3,4
37 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
38 // AUTEUR : Frederic HECHT ANALYSE NUMERIQUE UPMC PARIS OCTOBRE 2000
39 // MODIFS : Alain PERRONNET ANALYSE NUMERIQUE UPMC PARIS NOVEMBRE 2000
40 //...............................................................................
41 #include <iostream>
42 #include <cmath>
43 
44 
45 template<class T> inline T Abs (const T &a){return a <0 ? -a : a;}
46 template<class T> inline void Echange (T& a,T& b) {T c=a;a=b;b=c;}
47 
48 template<class T> inline T Min (const T &a,const T &b) {return a < b ? a : b;}
49 template<class T> inline T Max (const T &a,const T & b) {return a > b ? a : b;}
50 
51 template<class T> inline T Max (const T &a,const T & b,const T & c){return Max(Max(a,b),c);}
52 template<class T> inline T Min (const T &a,const T & b,const T & c){return Min(Min(a,b),c);}
53 
54 template<class T> inline T Max (const T &a,const T & b,const T & c,const T & d)
55  {return Max(Max(a,b),Max(c,d));}
56 template<class T> inline T Min (const T &a,const T & b,const T & c,const T & d)
57  {return Min(Min(a,b),Min(c,d));}
58 
59 //le type Nom des entites geometriques P L S V O
60 //===========
61 typedef char Nom[1+24];
62 
63 //le type N des nombres entiers positifs
64 //=========
65 #ifndef PCLINUX64
66 typedef unsigned long int N;
67 #else
68 typedef unsigned int N;
69 #endif
70 
71 //le type Z des nombres entiers relatifs
72 //=========
73 #ifndef PCLINUX64
74 typedef long int Z;
75 #else
76 typedef int Z;
77 #endif
78 
79 //le type R des nombres "reels"
80 //=========
81 typedef double R;
82 
83 //le type XPoint des coordonnees d'un pixel dans une fenetre
84 //==============
85 //typedef struct { short int x,y } XPoint; //en fait ce type est defini dans X11-Window
86  // #include <X11/Xlib.h>
87 //la classe R2
88 //============
89 class R2
90 {
91  friend std::ostream& operator << (std::ostream& f, const R2 & P)
92  { f << P.x << ' ' << P.y ; return f; }
93  friend std::istream& operator >> (std::istream& f, R2 & P)
94  { f >> P.x >> P.y ; return f; }
95 
96  friend std::ostream& operator << (std::ostream& f, const R2 * P)
97  { f << P->x << ' ' << P->y ; return f; }
98  friend std::istream& operator >> (std::istream& f, R2 * P)
99  { f >> P->x >> P->y ; return f; }
100 
101 public:
102  R x,y; //les donnees
103 
104  R2 () :x(0),y(0) {} //les constructeurs
105  R2 (R a,R b) :x(a),y(b) {}
106  R2 (R2 A,R2 B) :x(B.x-A.x),y(B.y-A.y) {} //vecteur defini par 2 points
107 
108  R2 operator+(R2 P) const {return R2(x+P.x,y+P.y);} // Q+P possible
109  R2 operator+=(R2 P) {x += P.x;y += P.y; return *this;}// Q+=P;
110  R2 operator-(R2 P) const {return R2(x-P.x,y-P.y);} // Q-P
111  R2 operator-=(R2 P) {x -= P.x;y -= P.y; return *this;} // Q-=P;
112  R2 operator-()const {return R2(-x,-y);} // -Q
113  R2 operator+()const {return *this;} // +Q
114  R operator,(R2 P)const {return x*P.x+y*P.y;} // produit scalaire (Q,P)
115  R operator^(R2 P)const {return x*P.y-y*P.x;} // produit vectoriel Q^P
116  R2 operator*(R c)const {return R2(x*c,y*c);} // produit a droite P*c
117  R2 operator*=(R c) {x *= c; y *= c; return *this;}
118  R2 operator/(R c)const {return R2(x/c,y/c);} // division par un reel
119  R2 operator/=(R c) {x /= c; y /= c; return *this;}
120  R & operator[](int i) {return (&x)[i];} // la coordonnee i
121  R2 orthogonal() {return R2(-y,x);} //le vecteur orthogonal dans R2
122  friend R2 operator*(R c,R2 P) {return P*c;} // produit a gauche c*P
123 };
124 
125 
126 //la classe R3
127 //============
128 class R3
129 {
130  friend std::ostream& operator << (std::ostream& f, const R3 & P)
131  { f << P.x << ' ' << P.y << ' ' << P.z ; return f; }
132  friend std::istream& operator >> (std::istream& f, R3 & P)
133  { f >> P.x >> P.y >> P.z ; return f; }
134 
135  friend std::ostream& operator << (std::ostream& f, const R3 * P)
136  { f << P->x << ' ' << P->y << ' ' << P->z ; return f; }
137  friend std::istream& operator >> (std::istream& f, R3 * P)
138  { f >> P->x >> P->y >> P->z ; return f; }
139 
140 public:
141  R x,y,z; //les 3 coordonnees
142 
143  R3 () :x(0),y(0),z(0) {} //les constructeurs
144  R3 (R a,R b,R c):x(a),y(b),z(c) {} //Point ou Vecteur (a,b,c)
145  R3 (R3 A,R3 B):x(B.x-A.x),y(B.y-A.y),z(B.z-A.z) {} //Vecteur AB
146 
147  R3 (gp_Pnt P) : x(P.X()), y(P.Y()), z(P.Z()) {} //Point d'OpenCascade
148  R3 (gp_Vec V) : x(V.X()), y(V.Y()), z(V.Z()) {} //Vecteur d'OpenCascade
149  R3 (gp_Dir P) : x(P.X()), y(P.Y()), z(P.Z()) {} //Direction d'OpenCascade
150 
151  R3 operator+(R3 P)const {return R3(x+P.x,y+P.y,z+P.z);}
152  R3 operator+=(R3 P) {x += P.x; y += P.y; z += P.z; return *this;}
153  R3 operator-(R3 P)const {return R3(x-P.x,y-P.y,z-P.z);}
154  R3 operator-=(R3 P) {x -= P.x; y -= P.y; z -= P.z; return *this;}
155  R3 operator-()const {return R3(-x,-y,-z);}
156  R3 operator+()const {return *this;}
157  R operator,(R3 P)const {return x*P.x+y*P.y+z*P.z;} // produit scalaire
158  R3 operator^(R3 P)const {return R3(y*P.z-z*P.y ,P.x*z-x*P.z, x*P.y-y*P.x);} // produit vectoriel
159  R3 operator*(R c)const {return R3(x*c,y*c,z*c);}
160  R3 operator*=(R c) {x *= c; y *= c; z *= c; return *this;}
161  R3 operator/(R c)const {return R3(x/c,y/c,z/c);}
162  R3 operator/=(R c) {x /= c; y /= c; z /= c; return *this;}
163  R & operator[](int i) {return (&x)[i];}
164  friend R3 operator*(R c,R3 P) {return P*c;}
165 
166  R3 operator=(gp_Pnt P) {return R3(P.X(),P.Y(),P.Z());}
167  R3 operator=(gp_Dir P) {return R3(P.X(),P.Y(),P.Z());}
168 
169  friend gp_Pnt gp_pnt(R3 xyz) { return gp_Pnt(xyz.x,xyz.y,xyz.z); }
170  //friend gp_Pnt operator=() { return gp_Pnt(x,y,z); }
171  friend gp_Dir gp_dir(R3 xyz) { return gp_Dir(xyz.x,xyz.y,xyz.z); }
172 
173  bool DansPave( R3 & xyzMin, R3 & xyzMax )
174  { return xyzMin.x<=x && x<=xyzMax.x &&
175  xyzMin.y<=y && y<=xyzMax.y &&
176  xyzMin.z<=z && z<=xyzMax.z; }
177 };
178 
179 //la classe R4
180 //============
181 class R4: public R3
182 {
183  friend std::ostream& operator <<(std::ostream& f, const R4 & P )
184  { f << P.x << ' ' << P.y << ' ' << P.z << ' ' << P.omega; return f; }
185  friend istream& operator >>(istream& f, R4 & P)
186  { f >> P.x >> P.y >> P.z >> P.omega ; return f; }
187 
188  friend std::ostream& operator <<(std::ostream& f, const R4 * P )
189  { f << P->x << ' ' << P->y << ' ' << P->z << ' ' << P->omega; return f; }
190  friend istream& operator >>(istream& f, R4 * P)
191  { f >> P->x >> P->y >> P->z >> P->omega ; return f; }
192 
193 public:
194  R omega; //la donnee du poids supplementaire
195 
196  R4 () :omega(1.0) {} //les constructeurs
197  R4 (R a,R b,R c,R d):R3(a,b,c),omega(d) {}
198  R4 (R4 A,R4 B) :R3(B.x-A.x,B.y-A.y,B.z-A.z),omega(B.omega-A.omega) {}
199 
200  R4 operator+(R4 P)const {return R4(x+P.x,y+P.y,z+P.z,omega+P.omega);}
201  R4 operator+=(R4 P) {x += P.x;y += P.y;z += P.z;omega += P.omega;return *this;}
202  R4 operator-(R4 P)const {return R4(x-P.x,y-P.y,z-P.z,omega-P.omega);}
203  R4 operator-=(R4 P) {x -= P.x;y -= P.y;z -= P.z;omega -= P.omega;return *this;}
204  R4 operator-()const {return R4(-x,-y,-z,-omega);}
205  R4 operator+()const {return *this;}
206  R operator,(R4 P)const {return x*P.x+y*P.y+z*P.z+omega*P.omega;} // produit scalaire
207  R4 operator*(R c)const {return R4(x*c,y*c,z*c,omega*c);}
208  R4 operator*=(R c) {x *= c; y *= c; z *= c; omega *= c; return *this;}
209  R4 operator/(R c)const {return R4(x/c,y/c,z/c,omega/c);}
210  R4 operator/=(R c) {x /= c; y /= c; z /= c; omega /= c; return *this;}
211  R & operator[](int i) {return (&x)[i];}
212  friend R4 operator*(R c,R4 P) {return P*c;}
213 };
214 
215 //quelques fonctions supplementaires sur ces classes
216 //==================================================
217 inline R Aire2d(const R2 A,const R2 B,const R2 C){return (B-A)^(C-A);}
218 inline R Angle2d(R2 P){ return atan2(P.y,P.x);}
219 
220 inline R Norme2_2(const R2 & A){ return (A,A);}
221 inline R Norme2(const R2 & A){ return sqrt((A,A));}
222 inline R NormeInfinie(const R2 & A){return Max(Abs(A.x),Abs(A.y));}
223 
224 inline R Norme2_2(const R3 & A){ return (A,A);}
225 inline R Norme2(const R3 & A){ return sqrt((A,A));}
226 inline R NormeInfinie(const R3 & A){return Max(Abs(A.x),Abs(A.y),Abs(A.z));}
227 
228 inline R Norme2_2(const R4 & A){ return (A,A);}
229 inline R Norme2(const R4 & A){ return sqrt((A,A));}
230 inline R NormeInfinie(const R4 & A){return Max(Abs(A.x),Abs(A.y),Abs(A.z),Abs(A.omega));}
231 
232 inline R2 XY(R3 P) {return R2(P.x, P.y);} //restriction a R2 d'un R3 par perte de z
233 inline R3 Min(R3 P, R3 Q)
234 {return R3(P.x<Q.x ? P.x : Q.x, P.y<Q.y ? P.y : Q.y, P.z<Q.z ? P.z : Q.z);} //Pt de xyz Min
235 inline R3 Max(R3 P, R3 Q)
236 {return R3(P.x>Q.x ? P.x : Q.x, P.y>Q.y ? P.y : Q.y, P.z>Q.z ? P.z : Q.z);} //Pt de xyz Max
237 
238 #endif
R4 operator/(R c) const
Definition: Rn.h:209
R y
Definition: Rn.h:141
R4 operator-() const
Definition: Rn.h:204
R z
Definition: Rn.h:141
R & operator[](int i)
Definition: Rn.h:211
R2 operator+=(R2 P)
Definition: Rn.h:109
R2 operator/(R c) const
Definition: Rn.h:118
R4 operator*=(R c)
Definition: Rn.h:208
R2()
Definition: Rn.h:104
R4(R a, R b, R c, R d)
Definition: Rn.h:197
R3 operator*=(R c)
Definition: Rn.h:160
char Nom[1+24]
Definition: Rn.h:61
R4 operator-(R4 P) const
Definition: Rn.h:202
R Aire2d(const R2 A, const R2 B, const R2 C)
Definition: Rn.h:217
friend gp_Dir gp_dir(R3 xyz)
Definition: Rn.h:171
R3 operator=(gp_Dir P)
Definition: Rn.h:167
R2 operator/=(R c)
Definition: Rn.h:119
R x
Definition: Rn.h:141
R3 operator+=(R3 P)
Definition: Rn.h:152
R3 operator+() const
Definition: Rn.h:156
void Echange(T &a, T &b)
Definition: Rn.h:46
R3 operator=(gp_Pnt P)
Definition: Rn.h:166
R2 operator-(R2 P) const
Definition: Rn.h:110
R x
Definition: Rn.h:102
friend istream & operator>>(istream &f, R4 &P)
Definition: Rn.h:185
R2 orthogonal()
Definition: Rn.h:121
R4(R4 A, R4 B)
Definition: Rn.h:198
T Abs(const T &a)
Definition: Rn.h:45
R2(R2 A, R2 B)
Definition: Rn.h:106
friend R3 operator*(R c, R3 P)
Definition: Rn.h:164
R2 operator*=(R c)
Definition: Rn.h:117
R3(gp_Vec V)
Definition: Rn.h:148
friend std::ostream & operator<<(std::ostream &f, const R4 &P)
Definition: Rn.h:183
R operator,(R2 P) const
Definition: Rn.h:114
friend R4 operator*(R c, R4 P)
Definition: Rn.h:212
Definition: Rn.h:89
R2(R a, R b)
Definition: Rn.h:105
R y
Definition: Rn.h:102
R3(gp_Pnt P)
Definition: Rn.h:147
R Norme2(const R2 &A)
Definition: Rn.h:221
R3 operator/(R c) const
Definition: Rn.h:161
R3(gp_Dir P)
Definition: Rn.h:149
R4 operator*(R c) const
Definition: Rn.h:207
R2 XY(R3 P)
Definition: Rn.h:232
R2 operator+(R2 P) const
Definition: Rn.h:108
friend std::istream & operator>>(std::istream &f, R2 &P)
Definition: Rn.h:93
long int Z
Definition: Rn.h:74
R3()
Definition: Rn.h:143
friend gp_Pnt gp_pnt(R3 xyz)
Definition: Rn.h:169
R3 operator-() const
Definition: Rn.h:155
Definition: Rn.h:181
T Max(const T &a, const T &b)
Definition: Rn.h:49
R & operator[](int i)
Definition: Rn.h:163
R operator,(R3 P) const
Definition: Rn.h:157
R Norme2_2(const R2 &A)
Definition: Rn.h:220
R4()
Definition: Rn.h:196
R2 operator-() const
Definition: Rn.h:112
friend R2 operator*(R c, R2 P)
Definition: Rn.h:122
friend std::ostream & operator<<(std::ostream &f, const R2 &P)
Definition: Rn.h:91
bool DansPave(R3 &xyzMin, R3 &xyzMax)
Definition: Rn.h:173
friend std::istream & operator>>(std::istream &f, R3 &P)
Definition: Rn.h:132
R3 operator^(R3 P) const
Definition: Rn.h:158
R NormeInfinie(const R2 &A)
Definition: Rn.h:222
R operator,(R4 P) const
Definition: Rn.h:206
R2 operator+() const
Definition: Rn.h:113
Definition: Rn.h:128
friend std::ostream & operator<<(std::ostream &f, const R3 &P)
Definition: Rn.h:130
double R
Definition: Rn.h:81
R omega
Definition: Rn.h:194
R3 operator+(R3 P) const
Definition: Rn.h:151
R3 operator-(R3 P) const
Definition: Rn.h:153
R2 operator-=(R2 P)
Definition: Rn.h:111
R2 operator*(R c) const
Definition: Rn.h:116
R & operator[](int i)
Definition: Rn.h:120
R4 operator+(R4 P) const
Definition: Rn.h:200
R4 operator-=(R4 P)
Definition: Rn.h:203
R3 operator/=(R c)
Definition: Rn.h:162
R3(R a, R b, R c)
Definition: Rn.h:144
R4 operator+() const
Definition: Rn.h:205
unsigned long int N
Definition: Rn.h:66
R3(R3 A, R3 B)
Definition: Rn.h:145
R3 operator-=(R3 P)
Definition: Rn.h:154
T Min(const T &a, const T &b)
Definition: Rn.h:48
R3 operator*(R c) const
Definition: Rn.h:159
R operator^(R2 P) const
Definition: Rn.h:115
R4 operator+=(R4 P)
Definition: Rn.h:201
R4 operator/=(R c)
Definition: Rn.h:210
R Angle2d(R2 P)
Definition: Rn.h:218