SALOME - SMESH
Rn.h
Go to the documentation of this file.
00001 //  MEFISTO :  library to compute 2D triangulation from segmented boundaries
00002 //
00003 //  Copyright (C) 2006  Laboratoire J.-L. Lions UPMC Paris
00004 // 
00005 //  This library is free software; you can redistribute it and/or 
00006 //  modify it under the terms of the GNU Lesser General Public 
00007 //  License as published by the Free Software Foundation; either 
00008 //  version 2.1 of the License. 
00009 // 
00010 //  This library is distributed in the hope that it will be useful, 
00011 //  but WITHOUT ANY WARRANTY; without even the implied warranty of 
00012 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
00013 //  Lesser General Public License for more details. 
00014 // 
00015 //  You should have received a copy of the GNU Lesser General Public 
00016 //  License along with this library; if not, write to the Free Software 
00017 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA 
00018 // 
00019 //  See http://www.ann.jussieu.fr/~perronne or email Perronnet@ann.jussieu.fr
00020 //                                          or email Hecht@ann.jussieu.fr
00021 //
00022 //
00023 //  File   : Rn.h
00024 //  Module : SMESH
00025 //  Authors: Frederic HECHT & Alain PERRONNET
00026 //  Date   : 13 novembre 2006
00027 
00028 #ifndef Rn__h
00029 #define Rn__h
00030 
00031 #include <gp_Pnt.hxx>      //Dans OpenCascade
00032 #include <gp_Vec.hxx>      //Dans OpenCascade
00033 #include <gp_Dir.hxx>      //Dans OpenCascade
00034 
00035 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
00036 // BUT:   Definir les espaces affines R R2 R3 R4 soit Rn pour n=1,2,3,4
00037 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
00038 // AUTEUR : Frederic HECHT      ANALYSE NUMERIQUE UPMC  PARIS   OCTOBRE   2000
00039 // MODIFS : Alain    PERRONNET  ANALYSE NUMERIQUE UPMC  PARIS   NOVEMBRE  2000
00040 //...............................................................................
00041 #include <iostream>
00042 #include <cmath>
00043 
00044 
00045 template<class T> inline T Abs (const T &a){return a <0 ? -a : a;}
00046 template<class T> inline void Echange (T& a,T& b) {T c=a;a=b;b=c;}
00047 
00048 template<class T> inline T Min (const T &a,const T &b)  {return a < b ? a : b;}
00049 template<class T> inline T Max (const T &a,const T & b) {return a > b ? a : b;}
00050 
00051 template<class T> inline T Max (const T &a,const T & b,const T & c){return Max(Max(a,b),c);}
00052 template<class T> inline T Min (const T &a,const T & b,const T & c){return Min(Min(a,b),c);}
00053 
00054 template<class T> inline T Max (const T &a,const T & b,const T & c,const T & d)
00055  {return Max(Max(a,b),Max(c,d));}
00056 template<class T> inline T Min (const T &a,const T & b,const T & c,const T & d)
00057  {return Min(Min(a,b),Min(c,d));}
00058 
00059 //le type Nom des entites geometriques P L S V O
00060 //===========
00061 typedef char Nom[1+24];
00062 
00063 //le type N des nombres entiers positifs
00064 //=========
00065 #ifndef PCLINUX64
00066 typedef unsigned long int N;
00067 #else 
00068 typedef unsigned int N;
00069 #endif
00070 
00071 //le type Z des nombres entiers relatifs
00072 //=========
00073 #ifndef PCLINUX64
00074 typedef long int Z;
00075 #else
00076 typedef int Z;
00077 #endif
00078 
00079 //le type R des nombres "reels"
00080 //=========
00081 typedef double R;
00082 
00083 //le type XPoint  des coordonnees d'un pixel dans une fenetre
00084 //==============
00085 //typedef struct { short int x,y } XPoint;  //en fait ce type est defini dans X11-Window
00086                                             // #include <X11/Xlib.h>
00087 //la classe R2
00088 //============
00089 class R2 
00090 {
00091   friend std::ostream& operator << (std::ostream& f, const R2 & P)
00092   { f << P.x << ' ' << P.y ; return f; }
00093   friend std::istream& operator >> (std::istream& f, R2 & P)
00094   { f >> P.x >> P.y ; return f; }
00095 
00096   friend std::ostream& operator << (std::ostream& f, const R2 * P)
00097   { f << P->x << ' ' << P->y ; return f; }
00098   friend std::istream& operator >> (std::istream& f, R2 * P)
00099   { f >> P->x >> P->y ; return f; }
00100 
00101 public:
00102   R x,y;  //les donnees
00103 
00104   R2 () :x(0),y(0) {}              //les constructeurs
00105   R2 (R a,R b)   :x(a),y(b)  {}
00106   R2 (R2 A,R2 B) :x(B.x-A.x),y(B.y-A.y)  {} //vecteur defini par 2 points
00107 
00108   R2  operator+(R2 P) const {return R2(x+P.x,y+P.y);}     // Q+P possible
00109   R2  operator+=(R2 P)  {x += P.x;y += P.y; return *this;}// Q+=P;
00110   R2  operator-(R2 P) const {return R2(x-P.x,y-P.y);}     // Q-P
00111   R2  operator-=(R2 P) {x -= P.x;y -= P.y; return *this;} // Q-=P;
00112   R2  operator-()const  {return R2(-x,-y);}               // -Q
00113   R2  operator+()const  {return *this;}                   // +Q
00114   R   operator,(R2 P)const {return x*P.x+y*P.y;} // produit scalaire (Q,P)
00115   R   operator^(R2 P)const {return x*P.y-y*P.x;} // produit vectoriel Q^P
00116   R2  operator*(R c)const {return R2(x*c,y*c);}  // produit a droite  P*c
00117   R2  operator*=(R c)  {x *= c; y *= c; return *this;}
00118   R2  operator/(R c)const {return R2(x/c,y/c);}  // division par un reel
00119   R2  operator/=(R c)  {x /= c; y /= c; return *this;}
00120   R & operator[](int i) {return (&x)[i];}        // la coordonnee i
00121   R2  orthogonal() {return R2(-y,x);}    //le vecteur orthogonal dans R2
00122   friend R2 operator*(R c,R2 P) {return P*c;}    // produit a gauche c*P
00123 };
00124 
00125 
00126 //la classe R3
00127 //============
00128 class R3
00129 {
00130   friend std::ostream& operator << (std::ostream& f, const R3 & P)
00131   { f << P.x << ' ' << P.y << ' ' << P.z ; return f; }
00132   friend std::istream& operator >> (std::istream& f, R3 & P)
00133   { f >> P.x >> P.y >> P.z ; return f; }
00134 
00135   friend std::ostream& operator << (std::ostream& f, const R3 * P)
00136   { f << P->x << ' ' << P->y << ' ' << P->z ; return f; }
00137   friend std::istream& operator >> (std::istream& f, R3 * P)
00138   { f >> P->x >> P->y >> P->z ; return f; }
00139 
00140 public:  
00141   R  x,y,z;  //les 3 coordonnees
00142  
00143   R3 () :x(0),y(0),z(0) {}  //les constructeurs
00144   R3 (R a,R b,R c):x(a),y(b),z(c)  {}                  //Point ou Vecteur (a,b,c)
00145   R3 (R3 A,R3 B):x(B.x-A.x),y(B.y-A.y),z(B.z-A.z)  {}  //Vecteur AB
00146 
00147   R3 (gp_Pnt P) : x(P.X()), y(P.Y()), z(P.Z()) {}      //Point     d'OpenCascade
00148   R3 (gp_Vec V) : x(V.X()), y(V.Y()), z(V.Z()) {}      //Vecteur   d'OpenCascade
00149   R3 (gp_Dir P) : x(P.X()), y(P.Y()), z(P.Z()) {}      //Direction d'OpenCascade
00150 
00151   R3   operator+(R3 P)const  {return R3(x+P.x,y+P.y,z+P.z);}
00152   R3   operator+=(R3 P)  {x += P.x; y += P.y; z += P.z; return *this;}
00153   R3   operator-(R3 P)const  {return R3(x-P.x,y-P.y,z-P.z);}
00154   R3   operator-=(R3 P)  {x -= P.x; y -= P.y; z -= P.z; return *this;}
00155   R3   operator-()const  {return R3(-x,-y,-z);}
00156   R3   operator+()const  {return *this;}
00157   R    operator,(R3 P)const {return  x*P.x+y*P.y+z*P.z;} // produit scalaire
00158   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
00159   R3   operator*(R c)const {return R3(x*c,y*c,z*c);}
00160   R3   operator*=(R c)  {x *= c; y *= c; z *= c; return *this;}
00161   R3   operator/(R c)const {return R3(x/c,y/c,z/c);}
00162   R3   operator/=(R c)  {x /= c; y /= c; z /= c; return *this;}
00163   R  & operator[](int i) {return (&x)[i];}
00164   friend R3 operator*(R c,R3 P) {return P*c;}
00165 
00166   R3   operator=(gp_Pnt P) {return R3(P.X(),P.Y(),P.Z());}
00167   R3   operator=(gp_Dir P) {return R3(P.X(),P.Y(),P.Z());}
00168 
00169   friend gp_Pnt gp_pnt(R3 xyz) { return gp_Pnt(xyz.x,xyz.y,xyz.z); }
00170   //friend gp_Pnt operator=() { return gp_Pnt(x,y,z); }
00171   friend gp_Dir gp_dir(R3 xyz) { return gp_Dir(xyz.x,xyz.y,xyz.z); }
00172 
00173   bool  DansPave( R3 & xyzMin, R3 & xyzMax )
00174     { return xyzMin.x<=x && x<=xyzMax.x &&
00175                xyzMin.y<=y && y<=xyzMax.y &&
00176           xyzMin.z<=z && z<=xyzMax.z; }
00177 };
00178 
00179 //la classe R4
00180 //============
00181 class R4: public R3
00182 {
00183   friend std::ostream& operator <<(std::ostream& f, const R4 & P )
00184   { f << P.x << ' ' << P.y << ' ' << P.z << ' ' << P.omega; return f; }
00185   friend istream& operator >>(istream& f,  R4 & P)
00186   { f >> P.x >>  P.y >>  P.z >> P.omega ; return f; }
00187 
00188   friend std::ostream& operator <<(std::ostream& f, const R4 * P )
00189   { f << P->x << ' ' << P->y << ' ' << P->z << ' ' << P->omega; return f; }
00190   friend istream& operator >>(istream& f,  R4 * P)
00191   { f >> P->x >>  P->y >>  P->z >> P->omega ; return f; }
00192 
00193 public:  
00194   R  omega;  //la donnee du poids supplementaire
00195  
00196   R4 () :omega(1.0) {}  //les constructeurs
00197   R4 (R a,R b,R c,R d):R3(a,b,c),omega(d) {}
00198   R4 (R4 A,R4 B) :R3(B.x-A.x,B.y-A.y,B.z-A.z),omega(B.omega-A.omega) {}
00199 
00200   R4   operator+(R4 P)const  {return R4(x+P.x,y+P.y,z+P.z,omega+P.omega);}
00201   R4   operator+=(R4 P)  {x += P.x;y += P.y;z += P.z;omega += P.omega;return *this;}
00202   R4   operator-(R4 P)const  {return R4(x-P.x,y-P.y,z-P.z,omega-P.omega);}
00203   R4   operator-=(R4 P) {x -= P.x;y -= P.y;z -= P.z;omega -= P.omega;return *this;}
00204   R4   operator-()const  {return R4(-x,-y,-z,-omega);}
00205   R4   operator+()const  {return *this;}
00206   R    operator,(R4 P)const {return  x*P.x+y*P.y+z*P.z+omega*P.omega;} // produit scalaire
00207   R4   operator*(R c)const {return R4(x*c,y*c,z*c,omega*c);}
00208   R4   operator*=(R c)  {x *= c; y *= c; z *= c; omega *= c; return *this;}
00209   R4   operator/(R c)const {return R4(x/c,y/c,z/c,omega/c);}
00210   R4   operator/=(R c)  {x /= c; y /= c; z /= c; omega /= c; return *this;}
00211   R  & operator[](int i) {return (&x)[i];}
00212   friend R4 operator*(R c,R4 P) {return P*c;}
00213 };
00214 
00215 //quelques fonctions supplementaires sur ces classes
00216 //==================================================
00217 inline R Aire2d(const R2 A,const R2 B,const R2 C){return (B-A)^(C-A);} 
00218 inline R Angle2d(R2 P){ return atan2(P.y,P.x);}
00219 
00220 inline R Norme2_2(const R2 & A){ return (A,A);}
00221 inline R Norme2(const R2 & A){ return sqrt((A,A));}
00222 inline R NormeInfinie(const R2 & A){return Max(Abs(A.x),Abs(A.y));}
00223 
00224 inline R Norme2_2(const R3 & A){ return (A,A);}
00225 inline R Norme2(const R3 & A){ return sqrt((A,A));}
00226 inline R NormeInfinie(const R3 & A){return Max(Abs(A.x),Abs(A.y),Abs(A.z));}
00227 
00228 inline R Norme2_2(const R4 & A){ return (A,A);}
00229 inline R Norme2(const R4 & A){ return sqrt((A,A));}
00230 inline R NormeInfinie(const R4 & A){return Max(Abs(A.x),Abs(A.y),Abs(A.z),Abs(A.omega));}
00231 
00232 inline R2 XY(R3 P) {return R2(P.x, P.y);}  //restriction a R2 d'un R3 par perte de z
00233 inline R3 Min(R3 P, R3 Q) 
00234 {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
00235 inline R3 Max(R3 P, R3 Q) 
00236 {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
00237 
00238 #endif
 All Data Structures Files Functions Variables Typedefs Enumerations Enumerator Friends Defines