CAD4FE_mg_utils.cpp

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/
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//
//####//       CAD4FE_mg_utils.cpp
//####//
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//    COPYRIGHT 2000-2024
//####//  jeu 13 jun 2024 11:58:56 EDT
//####//------------------------------------------------------------
//####//------------------------------------------------------------
 
#include <set>
 
#pragma hdrstop
 
#include <vector>
using namespace std;
 
#include "gestionversion.h"
#include "CAD4FE_mg_utils.h"
#include "ot_algorithme_geometrique.h"
 
 
#pragma package(smart_init)
 
 
 
 
void MG_UTILS::MG_MAILLAGE_GetBoundingBox (MG_MAILLAGE * __mesh, double __bbox [6] )
{
        MG_NOEUD * node;
        double point[3];
 
        node = __mesh->get_mg_noeud(0);
        MG_UTILS::MG_NOEUD_GET_XYZ(node, point);
 
        for (int i=0; i<3; i++)
        {
                __bbox[i] = point[i];
                __bbox[i+3] = point[i];
        }
        LISTE_MG_NOEUD::iterator itNode;
        for (MG_NOEUD * node = __mesh->get_premier_noeud(itNode); node; node = __mesh->get_suivant_noeud(itNode))
        {
                        MG_UTILS::MG_NOEUD_GET_XYZ(node, point);
 
                        for (int i=0; i<3; i++)
                        {
                                if (point[i] < __bbox[i])
                                        __bbox[i+0] = point[i];
                                if (point[i] > __bbox[i+3])
                                        __bbox[i+3] = point[i];
                        }
        }
}
 
double
MG_UTILS::MG_MAILLAGE_GetVolume (MG_MAILLAGE * __mesh)
{
        double V;
        V = 0;
 
        MG_TRIANGLE * T;
        LISTE_MG_TRIANGLE::iterator itTriang;
        for (MG_TRIANGLE * T = __mesh->get_premier_triangle(itTriang); T; T = __mesh->get_suivant_triangle(itTriang))
        {
                MG_NOEUD * N [3];
                MG_TRIANGLE_GET_NOEUDS ( T, N);
                
                double x[3][3];
 
                for (unsigned it_node = 0; it_node < 3; it_node ++)
                {
                        MG_UTILS::MG_NOEUD_GET_XYZ( N[it_node] , x[it_node]);
                }
 
 
                double temp = 0;
                for (unsigned it_node = 0; it_node < 3; it_node ++)
                {
                        unsigned i = (it_node + 0)%3;
                        unsigned j = (it_node + 1)%3;
                        unsigned k = (it_node + 2)%3;
 
                        temp += x[i][0]*(x[j][1]-x[k][1]);
                }
                temp *= (x[0][2]+x[1][2]+x[2][2]);
 
                V += temp;
        }
 
        return V;
}
 
 
double
MG_UTILS::MG_MAILLAGE_GetSurface (MG_MAILLAGE * __mesh)
{
        double S;
        S = 0;
 
        MG_TRIANGLE * T;
        LISTE_MG_TRIANGLE::iterator itTriang;
        for (MG_TRIANGLE * T = __mesh->get_premier_triangle(itTriang); T; T = __mesh->get_suivant_triangle(itTriang))
        {
                MG_NOEUD * N [3];
                MG_TRIANGLE_GET_NOEUDS ( T, N);
 
                double x[3][3];
 
                for (unsigned it_node = 0; it_node < 3; it_node ++)
                {
                        MG_UTILS::MG_NOEUD_GET_XYZ( N[it_node] , x[it_node]);
                }
 
                double E[3][3];
                for (unsigned i=0; i<2; i++)
                {
                        unsigned j = (i + 1)%3;
 
                        for (unsigned k=0; k<3; k++)
                                E[i][k] = x[j][k]-x[i][k];
                }
                OT_ALGORITHME_GEOMETRIQUE::VEC3_CROSS_VEC3(E[0], E[1], E[2]);
 
                S += OT_ALGORITHME_GEOMETRIQUE::VEC3_NORM(E[2]);
        }
 
        return S;
 
}
 
void MG_UTILS::GetFEVCount(MG_VOLUME * __volume, int * __faceCount,int * __edgeCount,int * __vertexCount)
{
    std::set < MG_FACE * > lst_mg_faces;
    std::set < MG_ARETE * > lst_mg_edges;
    std::set < MG_SOMMET * > lst_mg_vertices;
    std::set < MG_COQUILLE * > lst_mg_shell;
    std::set < MG_BOUCLE * > lst_mg_loop;
 
    // initialize MC face, MC edge, MC loop, MC shell, and MC vertices lists
    unsigned nb_shells = __volume->get_nb_mg_coquille ();
    for (unsigned it_shells = 0; it_shells < nb_shells; it_shells++)
    {
            MG_COQUILLE * shell = __volume->get_mg_coquille(it_shells);
            lst_mg_shell.insert(shell);
            unsigned nb_coface = shell->get_nb_mg_coface();
            for (unsigned it_coface = 0; it_coface < nb_coface; it_coface++)
            {
                    MG_FACE * face = (MG_FACE *)shell->get_mg_coface(it_coface)->get_face();
                    lst_mg_faces.insert(face);
 
                    unsigned nb_loop = face->get_nb_mg_boucle();
                    for (unsigned it_loop = 0; it_loop < nb_loop; it_loop++)
                    {
                            MG_BOUCLE * loop = face->get_mg_boucle(it_loop);
                            lst_mg_loop.insert(loop);
                            unsigned nb_edge = loop->get_nb_mg_coarete();
 
                            for (unsigned it_edge = 0; it_edge < nb_edge; it_edge++)
                            {
                                    MG_ARETE * edge = (MG_ARETE*)loop->get_mg_coarete(it_edge)->get_arete();
                                    lst_mg_edges.insert(edge);
 
                                    lst_mg_vertices.insert ((MG_SOMMET*)edge->get_cosommet1()->get_sommet());
                                    lst_mg_vertices.insert ((MG_SOMMET*)edge->get_cosommet2()->get_sommet());
                            }
                    }
            }
    }
 
    *__faceCount = lst_mg_faces.size();
    *__edgeCount = lst_mg_edges.size();
    *__vertexCount = lst_mg_vertices.size();
}