mg_maillage_outils.h

Aller à la documentation de ce fichier.

//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//  MAGiC
//####//  Jean Christophe Cuilliere et Vincent FRANCOIS
//####//  Departement de Genie Mecanique - UQTR
//####//------------------------------------------------------------
//####//  MAGIC est un projet de recherche de l equipe ERICCA
//####//  du departement de genie mecanique de l Universite du Quebec a Trois Rivieres
//####//  http://www.uqtr.ca/ericca
//####//  http://www.uqtr.ca/
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//
//####//       mg_maillage_outils.h
//####//
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//    COPYRIGHT 2000-2024
//####//  jeu 13 jun 2024 11:58:54 EDT
//####//------------------------------------------------------------
//####//------------------------------------------------------------
#ifndef mg_maillage_outilsh
#define mg_maillage_outilsh
 
 
 
#include <set>
#include <vector>
#include <mg_maillage.h>
#include "mg_gestionnaire.h"
#include "ot_mathematique.h"
class MG_SEGMENT;
class MG_NOEUD;
class MG_FACE;
class MG_ARETE;
class MG_SOMMET;
class MG_MAILLAGE;
class MG_GEOMETRIE;
class MG_ELEMENT_TOPOLOGIQUE;
 
 
 
class  MG_MAILLAGE_OUTILS :public OPERATEUR
{
public:
MG_MAILLAGE_OUTILS ();  
MG_MAILLAGE_OUTILS (MG_MAILLAGE *maitmp);
MG_MAILLAGE_OUTILS (MG_MAILLAGE_OUTILS & mdd);
~MG_MAILLAGE_OUTILS ();
 
void calcul_courbure_face_arete_sommet(MG_NOEUD *noeud,double& kmin1, double& kmax1,double& kmin2,double& kmax2,std::map<std::string,double> &liste_kmin,std::map<std::string,double> &liste_kmax,std::map<std::string,double> &liste_gau,std::map<std::string,double> &liste_courburemax1,std::map<std::string,double> &liste_courburemax2,std::map<std::string,double> &liste_courburemax3,std::map<std::string,double> &liste_courburemax4,std::map<std::string,double> &liste_courburemax5,int opensurafece);
void calcul_courbure_discrete(class MG_GESTIONNAIRE& gest,char *nom,int nummai,char* outputgestnom,int opensurafece);
void calcul_courbure(class MG_GESTIONNAIRE& gest,char* solnom,int nummai,int numgeo,char* outputgestnom);
 
 
void calcul_courbure_face(MG_NOEUD *noeud,double& kmin, double& kmax, std::map<std::string,double> &liste_kmin,std::map<std::string,double> &liste_kmax,std::map<std::string,double> &liste_gau,std::map<std::string,double> &liste_courburemax1,std::map<std::string,double> &liste_courburemax2,std::map<std::string,double> &liste_courburemax3,std::map<std::string,double> &liste_courburemax4,std::map<std::string,double> &liste_courburemax5 );
 
  
    static void inserer_noeud_segment(class MG_MAILLAGE * __mesh, class MG_NOEUD * __node, class MG_SEGMENT * __splitSeg, MG_SEGMENT * __segs[2], bool __deleteOriginalSeg = true);
 
    static void change_lien_maillage(class MG_ELEMENT_TOPOLOGIQUE * __old_topo, MG_ELEMENT_TOPOLOGIQUE * __new_topo, MG_MAILLAGE * __mesh = 0);
    static void SplitEdgeInMesh(MG_MAILLAGE * __mesh, class MG_ARETE * __origEdge, class MG_SOMMET * __splitVertex, class MG_ARETE * __arete_gauche, MG_ARETE * __arete_droite, MG_SEGMENT **__origSegment, MG_NOEUD ** __splitNode, MG_SEGMENT * __splitSegments[2]);
 
    static void classe_elements_dimension1__trouver_prochains_elements(std::set <MG_SEGMENT*> & __unvisitedSegs, std::vector<MG_SEGMENT*> & __visitedSegs, std::vector<MG_NOEUD*>& __visitedNodes, MG_NOEUD * & __nextNode, MG_SEGMENT * & __nextSeg);
 
 
    static MG_NOEUD * classe_elements_dimension1__trouver_noeud_dimension0(const std::set<MG_SEGMENT*> & __unvisitedSegs);
 
 
    /*
 
    Cette fonction classe une liste de segments attach�s � un tpologie de dimension 1
    (ar�teMG_NOEUD* noeud1=ele1->get_noeud1();
    MG_NOEUD* noeud2=ele1->get_noeud2();
    MG_NOEUD* noeud3=ele1->get_noeud3();
    MG_NOEUD* noeud4=ele2->get_noeud1();
    MG_NOEUD* noeud5=ele2->get_noeud2();
    MG_NOEUD* noeud6=ele2->get_noeud3();
    return get_angle_par_noeud<MG_NOEUD*>(noeud1,noeud2,noeud3,noeud4,noeud5,noeud6);) et g�n�re 2 listes :
 
    * __visitedSegs : la liste des segments plac�s entre 2 noeuds li�s � une topologie
      de dimension 0 (noeuds de sommets). Les premier et dernier segments
      de la liste sont adjacent � un sommet de la topologie.
      La liste de segments est ordonn�e par adjacence et forment une polyligne.
 
    * __visitedNodes : la liste des noeuds ordonn�s par ordre d'adjacence,
      en partant du noeud d'extr�mit� du premier segment, et en finissant
      par le noeud d'extremit� du dernier segment.
 
      __visitedNodes[i] et __visitedNodes[i+1] sont les extr�mit�s du segment __visitedSegs[i]
 
      Algorithme utilis� :
 
      * Trouver le premier noeud tel que la dimension de la topologie soit �gale � 0
 
      * Faire :
 
           * (seg^i+1, N^i+1) = Trouver les prochains segments et noeuds ((segs), (visited_seg), (visited_N))
 
      * Tant que dernier(visited_N) a une dimension non �gale � 0
 
    */
    static void classe_elements_dimension1(std::set<MG_SEGMENT*> & __unvisitedSegs, std::vector<MG_SEGMENT*> & __visitedSegs, std::vector<MG_NOEUD*> & __visitedNodes );
    static void IdentifyEdge1(std::set <MG_SOMMET *> __vertices, std::set<class MG_FACE *> & __adjacentFaces, std::set <MG_ARETE * > & __edge);
    static void IdentifyEdge2(std::set <MG_SOMMET *> __vertices, std::set<MG_FACE *> & __adjacentFaces, std::set<MG_ARETE *> & __lst_edge, std::vector<MG_NOEUD*> & __nodes);
    static void IdentifyEdge3(std::set <MG_SOMMET *> __vertices, std::set<MG_ARETE *> & __lst_edge, std::vector<MG_NOEUD*> & __nodes, MG_ARETE ** __edge);
    MG_GEOMETRIE* importer(class MG_GESTIONNAIRE& gest,char *path);
    static void IdentifyEdge4(std::set <MG_SOMMET *> __vertices, std::set<MG_ARETE *> & __lst_edge, std::vector<MG_NOEUD*> & __nodes, std::vector<MG_SEGMENT*> & __segments, MG_ARETE ** __edge);
    static void IdentifyEdge5(const std::set <MG_SOMMET *> __vertices, const std::set<MG_ARETE *> & __lst_edge, const std::vector<MG_NOEUD*> & __nodes, const std::vector<MG_SEGMENT*> & __segs, MG_ARETE ** __edge);
    static void FindCommonEdgesOfFaces(std::set< MG_FACE * > & __faces, std::set<MG_ARETE*> & __commonEdges);
    static void _FilterSegmentsAndEdgeAdjacentToSameFaces( std::vector<MG_SEGMENT*> & __segments, std::set<MG_ARETE *> & __lst_edge);
    static double TestDistanceEdgeNode(MG_ARETE* candidate_edge, MG_NOEUD* test_node);
    static void Conformity_CloseSurfaceMesh(MG_MAILLAGE * __tess, double __tolerance);
    static double TestDistanceEdge(MG_ARETE* candidate_edge, double* xyz_node);
    
    void projetedansletriangle(MG_TRIANGLE *tri,double x,double y, double z,double &xx,double &yy,double &zz);
    int estdansletriangle(MG_TRIANGLE *tri,double x,double y, double z) ; 
    int projeteestdansletriangle(MG_TRIANGLE *tri,double x,double y, double z) ; 
    int estdansletetra(class MG_TETRA *tet,double x,double y, double z);
    int compare_etat_tetra(int etat,int valeur);
    int compare_etat_triangle(int etat,int valeur);
    
    int est_delaunay_generalise(double *xyz,MG_TRIANGLE* tri);
    
    double get_angle(class MG_TRIANGLE* ele1,class MG_TRIANGLE* ele2);
    
    
    void get_noeud_voisin(MG_NOEUD* no,TPL_MAP_ENTITE<MG_NOEUD*> &liste,int niveau);
    double get_volume(MG_MAILLAGE* mai);
    
private:
   MG_MAILLAGE * mai;
   int nummai;
   double calcul_gaussienne_face(MG_NOEUD *noeud);
   double calcul_moyenne_face(MG_NOEUD *noeud);
   double calcul_surface_triangle_face(MG_NOEUD *noeud);
 
    double calcul_surface_lsttriangle(MG_NOEUD * noeud,MG_TRIANGLE * tr1);
    double calcul_angle_lsttriangle(MG_NOEUD * noeud,MG_TRIANGLE * tr1);
    double calcul_angle_lstsegment(MG_NOEUD * noeud,MG_SEGMENT * se1);
 
    void calcul_courbure_arete_virtuelle(MG_NOEUD *noeud,double& kmin, double& kmax, std::map<std::string,double> &liste_kmin,std::map<std::string,double> &liste_kmax );
    void calcul_courbure_arete_nonvirtuelle(MG_NOEUD *noeud,double& kmin1, double& kmax1,double& kmin2,double& kmax2, std::map<std::string,double> &liste_kmin,std::map<std::string,double> &liste_kmax );
    void calcul_courbure_arete(MG_NOEUD *noeud,double& kmin1, double& kmax1,double& kmin2,double& kmax2, std::map<std::string,double> &liste_kmin,std::map<std::string,double> &liste_kmax);
 
    void calcul_courbure_sommet(MG_NOEUD *noeud,double& kmin1, double& kmax1,double& kmin2,double& kmax2, std::map<std::string,double> &liste_kmin,std::map<std::string,double> &liste_kmax); 
    void calcul_courbure_sommet_arete_virtuelle(MG_SOMMET *sommet,MG_NOEUD *noeud,double& kmin1, double& kmax1,double& kmin2,double& kmax2, std::map<std::string,double> &liste_kmin,std::map<std::string,double> &liste_kmax );
    void calcul_courbure_sommet_arete_nonvirtuelle(MG_SOMMET *sommet,MG_NOEUD *noeud,double& kmin1, double& kmax1,double& kmin2,double& kmax2, std::map<std::string,double> &liste_kmin,std::map<std::string,double> &liste_kmax );
 
  
    static void _FilterGeometricTolerance(const std::vector<MG_NOEUD*> & __nodes, std::set<MG_ARETE*> & __lst_edge);
    static void _FilterGeometricTolerance5(const std::vector<MG_NOEUD*> & __nodes, const std::vector<MG_SEGMENT*> & __segs, std::set<MG_ARETE*> & __lst_edge);
};
 
#endif