Mesh.h

Aller à la documentation de ce fichier.
00001 /*
00002  * Mesh.h : Maillage (considere des maillages triangulaires)
00003  * Copyright (C) 2007 Florence Zara, LIRIS
00004  *               florence.zara@liris.univ-lyon1.fr
00005  *               http://liris.cnrs.fr/florence.zara/
00006  *
00007  *
00008  * This program is free software; you can redistribute it and/or modify
00009  * it under the terms of the GNU Lesser General Public License as published
00010  * by the Free Software Foundation; either version 2.1 of the License, or
00011  * (at your option) any later version.
00012  *
00013  * This program is distributed in the hope that it will be useful,
00014  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00015  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00016  * GNU Lesser General Public License for more details.
00017  *
00018  * You should have received a copy of the GNU Lesser General Public License
00019  * along with this program; if not, write to the Free Software
00020  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
00021  */
00022 
00027 #ifndef MESH_H
00028 #define MESH_H
00029 
00031 #include <stdio.h>
00032 #include <vector>
00033 #include <string.h>
00034 
00035 
00036 #include "Donnees.h"
00037 #include "Noeuds.h"
00038 
00039 
00040 
00041 
00046 struct FacetTriangle 
00047 {
00049         int fi;
00050         
00052         int fj;
00053         
00055         int fk;
00056         
00057 };
00058 
00059 
00065 class Particule;
00066 
00067 
00073 class Spring
00074 {
00075 public:
00076         
00078         Spring() : _Raideur(0.0), _Nu(0.0), _L0(0.0), _Amorti(0.0) {}
00079         
00081         Spring(const Spring & R) : 
00082         _Raideur(R._Raideur), _Nu(R._Nu), _L0(R._L0), _Amorti(R._Amorti) {}
00083         
00085         inline Spring &operator=(const Spring & R)
00086         {
00087                 _Raideur = R._Raideur;
00088                 _Nu = R._Nu;
00089                 _L0 = R._L0;
00090                 _Amorti = R._Amorti;
00091                 
00092                 return *this; 
00093         }
00094         
00096         inline void SetFactAmorti()
00097         {
00098                 if (_Raideur != 0)
00099                         _Amorti = _Nu / _Raideur;
00100                 else
00101                         _Amorti = 1000;
00102         }
00103         
00104         
00105 public:
00106         
00108         float _Raideur;    
00109         
00111         float _Nu;
00112         
00114         float _L0;
00115         
00117         float _Amorti;
00118         
00119 };
00120 
00121 
00127 class Ressort
00128 {
00129 public:
00130         
00132         inline Ressort() 
00133     {
00134                 _ParticuleA = NULL; 
00135                 _ParticuleB = NULL;
00136     }
00137         
00139         Ressort(Particule *p1, Particule *p2, Spring *R)
00140     {
00141                 // Particules connectees par le ressort
00142                 _ParticuleA = p1; 
00143                 _ParticuleB = p2; 
00144                 
00145                 // R : nu, raideur, amortissement
00146                 _Spring = R;
00147                 
00148                 // Calcul de la longueur au repos du ressort
00149                 SetLrepos();
00150     }
00151         
00153         Ressort(Ressort &R)
00154     {
00155                 _ParticuleA = R.GetParticuleA();
00156                 _ParticuleB = R.GetParticuleB(); 
00157                 _Spring = R.GetSpring();
00158     }
00159         
00161         inline int GetId() {return _Id;}
00162         
00164         inline Particule * GetParticuleA() {return _ParticuleA;}
00165         
00167         inline Particule * GetParticuleB() {return _ParticuleB;}
00168         
00170         inline Spring * GetSpring() {return _Spring;}
00171         
00173         inline float GetRaideur() {return _Spring->_Raideur;}
00174         
00176         inline float GetAmortissement() {return _Spring->_Nu;}
00177         
00179         inline float GetFactAmorti() {return _Spring->_Amorti;}
00180         
00182         inline float GetLrepos() {return _Spring->_L0;}
00183         
00184         
00186         inline void SetId(int id) {_Id = id;}
00187         
00189         inline void SetAmortiss(float nu) {_Spring->_Nu = nu;}
00190         
00192         inline void SetRaideur(float raideur) {_Spring->_Raideur = raideur;}
00193         
00195         inline void SetFactAmorti() {_Spring->SetFactAmorti();}
00196         
00198         void SetLrepos();
00199         
00200         
00201 public:
00202         
00204         int _Id; 
00205         
00207         Particule *_ParticuleA;
00208         
00210         Particule *_ParticuleB;
00211         
00213         Spring *_Spring;
00214         
00215 };
00216 
00217 
00223 class Particule
00224 {
00225 public:
00226         
00228         inline Particule(const Coord &C) {_Id = 0; _Pos = C;}  
00229         
00231         Particule() {}
00232         
00234         Particule(Particule &Part)
00235     {
00236                 _Id = Part.GetId(); 
00237                 _RessortList = Part.GetRessortList(); 
00238                 _Pos = Part.GetPosition(); 
00239     }
00240         
00242         inline int GetId() {return _Id;}
00243         
00245         inline std::vector<Ressort *> &GetRessortList() {return _RessortList;}
00246         
00248         inline const Coord& GetPosition() const {return _Pos;}
00249         
00251         inline int GetNbVoisins() {return _RessortList.size();}
00252         
00254         inline void SetId(int id) {_Id = id;}
00255         
00257         inline void SetPosition(const Coord &C) {_Pos = C;}  
00258         
00260         inline void AddRessort(Ressort *R) {_RessortList.push_back(R);}
00261         
00262         
00263 public:
00264         
00266         int _Id;      
00267         
00269         std::vector<Ressort *> _RessortList;
00270         
00272         Coord _Pos;    
00273         
00274 };
00275 
00276 
00281 class Mesh
00282 {
00283 public:
00284         
00286         inline Mesh() {};
00287         
00289         inline ~Mesh();
00290         
00291         
00297         inline Particule* GetParticule(int id) {return _ParticuleList[id];}
00298         
00300         inline int GetNbParticule() const {return _ParticuleList.size(); }
00301         
00303         inline std::vector<Particule *> &GetPartList() {return _ParticuleList;}
00304         
00306         inline std::vector<Ressort *> &GetRessortList() {return _RessortList;}
00307         
00309         inline const std::vector<Particule *> &GetPartListConst() const 
00310         {return _ParticuleList;}
00311         
00313         inline const std::vector<Ressort *> &GetRessortListConst() const 
00314         {return _RessortList;}
00315                 
00317         inline int GetNbRessort() const {return _RessortList.size();}
00318                 
00320         inline void setVISize(int size) {_VISize = size;}
00321         
00323         inline const unsigned int numFaces() const {return _NFacets;}           
00324         
00326         inline const unsigned int visize() const {return _VISize;}
00327         
00328         
00334         inline void AddParticule(Particule *P) {_ParticuleList.push_back(P);}
00335         
00337         inline void AddRessort(Ressort *R) {_RessortList.push_back(R);}
00338         
00340         void MakeFace(Particule *p1, Particule *p2, Particule *p3, Spring *R);
00341         
00343         void MakeEdge(Particule *p1, Particule *p2, Spring *R);
00344         
00345         
00346         
00352         void AfficheMesh();
00353                                 
00355         inline void setNumFaces(int size) {_NFacets = size;}
00356         
00357         
00358         
00359 public:
00360                                 
00361         
00363         std::vector<int> _VIndices;
00364                 
00366         unsigned int _VISize;
00367         
00369         unsigned int _NFacets;
00370         
00372         std::vector<Particule *> _ParticuleList;
00373         
00375         std::vector<Ressort *> _RessortList;
00376 
00377 };
00378 
00379 
00383 Mesh::~Mesh()
00384 {
00385         // Destruction des particules du maillage
00386         _ParticuleList.~vector<Particule *>();
00387         
00388         // Destruction des ressorts du maillage
00389         _RessortList.~vector<Ressort *>();
00390 
00391 }
00392 
00393 #endif

Généré le Thu Jan 24 19:11:42 2008 pour Animation 3D par  doxygen 1.5.1