SALOME - SMESH
Main Page
Data Structures
Files
File List
Globals
All
Data Structures
Namespaces
Files
Functions
Variables
Typedefs
Enumerations
Enumerator
Friends
Macros
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
inc
Rn.h
Generated by
1.8.2