rec_face_conique.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/
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//
//####//       rec_face_conique.cpp
//####//
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//    COPYRIGHT 2000-2024
//####//  jeu 13 jun 2024 11:58:56 EDT
//####//------------------------------------------------------------
//####//------------------------------------------------------------
#include "gestionversion.h"
 
#pragma hdrstop
 
#include "occ_fonction.h"
#include "rec_face_conique.h"
#include "tpl_map_entite.h"
#include "rec_contour.h"
#include "fem_noeud.h"
#include "fem_maillage.h"
#include "ot_mathematique.h"
 
 
#pragma package(smart_init)
 
 
 
 
 
 
 
REC_FACE_CONIQUE::REC_FACE_CONIQUE(FEM_MAILLAGE* fem_mai, int Idealise, OCC_FONCTION_RECONSTRUCTION& fonc, int test, int* faces): REC_FACE(fem_mai,Idealise, fonc, test, faces)
{
 
}
 
 
REC_FACE_CONIQUE::~REC_FACE_CONIQUE()
{
 
}
 
void REC_FACE_CONIQUE::Reconstruire(MG_FACE* face, double coef)
{
 
        MG_SURFACE* surface = face->get_surface();
        TPL_LISTE_ENTITE <double> Parametres;
        int type_surface = surface->get_type_geometrique(Parametres);
 
        double Pnt_Insersion[3];
        Pnt_Insersion[0]= Parametres.get(0);
        Pnt_Insersion[1]= Parametres.get(1);
        Pnt_Insersion[2]= Parametres.get(2);
 
        double Vecteur1[3];
        Vecteur1[0]= Parametres.get(3);
        Vecteur1[1]= Parametres.get(4);
        Vecteur1[2]= Parametres.get(5);
 
        double Vect_Directeur[3];
        Vect_Directeur[0]= Parametres.get(6);
        Vect_Directeur[1]= Parametres.get(7);
        Vect_Directeur[2]= Parametres.get(8);
        double Rayon = Parametres.get(9);
        double Angle = acos(Parametres.get(11));
 
        //OCC_FONCTION fonction;
 
 
        int nb_triangle = face->get_lien_fem_maillage()->get_nb();
        TPL_MAP_ENTITE<FEM_NOEUD*> liste_noeuds0;
 
        for (int j =0; j<nb_triangle;j++)
                {
                FEM_ELEMENT2* mgtri=(FEM_ELEMENT2*)face->get_lien_fem_maillage()->get(j);
                if (!fem_maillage->contient(mgtri)) continue;
                if (mgtri->get_nb_fem_noeud()==3)
                        {
                        FEM_NOEUD* noeud0=mgtri->get_fem_noeud(0);
                        FEM_NOEUD* noeud1=mgtri->get_fem_noeud(1);
                        FEM_NOEUD* noeud2=mgtri->get_fem_noeud(2);
                        liste_noeuds0.ajouter(noeud0);
                        liste_noeuds0.ajouter(noeud1);
                        liste_noeuds0.ajouter(noeud2);
                        }
                if (mgtri->get_nb_fem_noeud()==6)
                        {
                        FEM_NOEUD* noeud0=mgtri->get_fem_noeud(0);
                        FEM_NOEUD* noeud1=mgtri->get_fem_noeud(1);
                        FEM_NOEUD* noeud2=mgtri->get_fem_noeud(2);
                        FEM_NOEUD* noeud3=mgtri->get_fem_noeud(3);
                        FEM_NOEUD* noeud4=mgtri->get_fem_noeud(4);
                        FEM_NOEUD* noeud5=mgtri->get_fem_noeud(5);
                        liste_noeuds0.ajouter(noeud0);
                        liste_noeuds0.ajouter(noeud1);
                        liste_noeuds0.ajouter(noeud2);
                        liste_noeuds0.ajouter(noeud3);
                        liste_noeuds0.ajouter(noeud4);
                        liste_noeuds0.ajouter(noeud5);
                        }
                }
 
        for (int k =0; k < liste_noeuds0.get_nb();k++)
                {
                FEM_NOEUD* noeud=liste_noeuds0.get(k);
                fonction.Ajouter_Point_Array_Ideal(noeud->get_x(),noeud->get_y(),noeud->get_z(),k+1);
                }
        fonction.Determiner_Param_Boite(liste_noeuds0.get_nb());
 
        double x0 = fonction.Get_Param_Boite(1);
        double y0 = fonction.Get_Param_Boite(2);
        double z0 = fonction.Get_Param_Boite(3);
 
        OT_VECTEUR_3D Vect_Boite01 (fonction.Get_Param_Boite(4),fonction.Get_Param_Boite(5),fonction.Get_Param_Boite(6));
        OT_VECTEUR_3D Vect_Boite02 (fonction.Get_Param_Boite(7),fonction.Get_Param_Boite(8),fonction.Get_Param_Boite(9));
        OT_VECTEUR_3D Vect_Boite03 (fonction.Get_Param_Boite(10),fonction.Get_Param_Boite(11),fonction.Get_Param_Boite(12));
 
        Vect_Boite01.norme();
        Vect_Boite02.norme();
        Vect_Boite03.norme();
 
        OT_VECTEUR_3D Vect_Dirct0(Vect_Directeur[0],Vect_Directeur[1],Vect_Directeur[2]);
        OT_VECTEUR_3D Vect_Directeur_Boite0(Vect_Dirct0*Vect_Boite01,Vect_Dirct0*Vect_Boite02,Vect_Dirct0*Vect_Boite03);
 
        OT_VECTEUR_3D Vect1(Vecteur1[0],Vecteur1[1],Vecteur1[2]);
        OT_VECTEUR_3D Vect1_Boite0(Vect1*Vect_Boite01,Vect1*Vect_Boite02,Vect1*Vect_Boite03);
 
        OT_VECTEUR_3D Pnt_Inser0(Pnt_Insersion[0]-x0,Pnt_Insersion[1]-y0,Pnt_Insersion[2]-z0);
        OT_VECTEUR_3D Pnt_Insersion_Boite0(Pnt_Inser0*Vect_Boite01,Pnt_Inser0*Vect_Boite02,Pnt_Inser0*Vect_Boite03);
 
        TPL_MAP_ENTITE<FEM_NOEUD*> liste_noeuds1;
        for (int k =0; k < liste_noeuds0.get_nb();k++)
                {
                FEM_NOEUD* noeud=liste_noeuds0.get(k);
                for (int l =0; l < fem_maillage->get_nb_fem_noeud();l++)
                        {
                        FEM_NOEUD* noeud0=fem_maillage->get_fem_noeud(l);
                        if(noeud0 == noeud)
                                {
                                FEM_NOEUD* noeud1 = fem_maillage->get_fem_noeud(l);
                                fonction.Ajouter_Point_Array_Ideal(noeud1->get_x(coef),noeud1->get_y(coef),noeud1->get_z(coef),k+1);
                                liste_noeuds1.ajouter(noeud1);
                                }
                        }
 
                }
        fonction.Determiner_Param_Boite(liste_noeuds1.get_nb());
 
        double x1 = fonction.Get_Param_Boite(1);
        double y1 = fonction.Get_Param_Boite(2);
        double z1 = fonction.Get_Param_Boite(3);
 
        OT_VECTEUR_3D Vect_Boite11 (fonction.Get_Param_Boite(4),fonction.Get_Param_Boite(5),fonction.Get_Param_Boite(6));
        OT_VECTEUR_3D Vect_Boite12 (fonction.Get_Param_Boite(7),fonction.Get_Param_Boite(8),fonction.Get_Param_Boite(9));
        OT_VECTEUR_3D Vect_Boite13 (fonction.Get_Param_Boite(10),fonction.Get_Param_Boite(11),fonction.Get_Param_Boite(12));
 
        Vect_Boite11.norme();
        Vect_Boite12.norme();
        Vect_Boite13.norme();
 
        Vect_Directeur[0]= (Vect_Directeur_Boite0.get_x()*Vect_Boite11.get_x()+Vect_Directeur_Boite0.get_y()*Vect_Boite12.get_x()+Vect_Directeur_Boite0.get_z()*Vect_Boite13.get_x());
        Vect_Directeur[1]= (Vect_Directeur_Boite0.get_x()*Vect_Boite11.get_y()+Vect_Directeur_Boite0.get_y()*Vect_Boite12.get_y()+Vect_Directeur_Boite0.get_z()*Vect_Boite13.get_y());
        Vect_Directeur[2]= (Vect_Directeur_Boite0.get_x()*Vect_Boite11.get_z()+Vect_Directeur_Boite0.get_y()*Vect_Boite12.get_z()+Vect_Directeur_Boite0.get_z()*Vect_Boite13.get_z());
 
        Pnt_Insersion[0]= x1 + Pnt_Insersion_Boite0.get_x()*Vect_Boite11.get_x()+Pnt_Insersion_Boite0.get_y()*Vect_Boite12.get_x()+Pnt_Insersion_Boite0.get_z()*Vect_Boite13.get_x();
        Pnt_Insersion[1]= y1 + Pnt_Insersion_Boite0.get_x()*Vect_Boite11.get_y()+Pnt_Insersion_Boite0.get_y()*Vect_Boite12.get_y()+Pnt_Insersion_Boite0.get_z()*Vect_Boite13.get_y();;
        Pnt_Insersion[2]= z1 + Pnt_Insersion_Boite0.get_x()*Vect_Boite11.get_z()+Pnt_Insersion_Boite0.get_y()*Vect_Boite12.get_z()+Pnt_Insersion_Boite0.get_z()*Vect_Boite13.get_z();;
 
        //Vecteur1[0]= Vect1_Boite0.get_x()*Vect_Boite11.get_x()+Vect1_Boite0.get_y()*Vect_Boite12.get_x()+Vect1_Boite0.get_z()*Vect_Boite13.get_x();
        //Vecteur1[1]= Vect1_Boite0.get_x()*Vect_Boite11.get_y()+Vect1_Boite0.get_y()*Vect_Boite12.get_y()+Vect1_Boite0.get_z()*Vect_Boite13.get_y();
        //Vecteur1[2]= Vect1_Boite0.get_x()*Vect_Boite11.get_z()+Vect1_Boite0.get_y()*Vect_Boite12.get_z()+Vect1_Boite0.get_z()*Vect_Boite13.get_z();
 
 
        fonction.Ligne_Revolution(Pnt_Insersion,Vect_Directeur);
 
        double distance_min = 1E+308;
        double distance_max = -1E+308;
 
        double Proj_Ptmax[3];
        double Proj_Ptmin[3];
 
        for (int u =0; u<liste_noeuds1.get_nb();u++)
                {
                FEM_NOEUD* noeud = liste_noeuds1.get(u);
                double distance = fonction.Distance_Point_Curve(noeud->get_x(coef),noeud->get_y(coef),noeud->get_z(coef));
                fonction.Pt_Proj_Ligne();
                double xx = fonction.Pnt_Proj_Ligne(1);
                double yy = fonction.Pnt_Proj_Ligne(2);
                double zz = fonction.Pnt_Proj_Ligne(3);
                if(distance < distance_min)
                        {
                        distance_min = distance;
                        Proj_Ptmin[0] = fonction.Pnt_Proj_Ligne(1);
                        Proj_Ptmin[1] = fonction.Pnt_Proj_Ligne(2);
                        Proj_Ptmin[2] = fonction.Pnt_Proj_Ligne(3);
                        }
                if(distance > distance_max)
                        {
                        distance_max = distance;
                        Proj_Ptmax[0] = fonction.Pnt_Proj_Ligne(1);
                        Proj_Ptmax[1] = fonction.Pnt_Proj_Ligne(2);
                        Proj_Ptmax[2] = fonction.Pnt_Proj_Ligne(3);
                        }
                }
 
         Angle = atan((distance_max-distance_min) /OT_VECTEUR_3D(Proj_Ptmax[0]-Proj_Ptmin[0],Proj_Ptmax[1]-Proj_Ptmin[1],Proj_Ptmax[2]-Proj_Ptmin[2]).get_longueur());
 
 
        fonction.Creer_Surface_Conique(Pnt_Insersion,Vect_Directeur,Rayon, Angle);
 
        MG_GEOMETRIE* mggeom = fem_maillage->get_mg_geometrie();
        int num_faceid = 0;
        for (int l =0; l < mggeom->get_nb_mg_face();l++)
                {
                MG_FACE* F = mggeom->get_mg_face(l);
                if(faceso[l]==1) num_faceid = num_faceid+1;
                if(F == face )
                        {
                        //faceso[l] == 1;
                        fonction.Ajouter_Surface_liste_Ideal(num_faceid);
                        goto Face_Trouvee;
                        }
                }
        Face_Trouvee:
 
 
 
 
        for (int v =0; v<face->get_nb_mg_boucle();v++)
                {
                MG_BOUCLE* Boucle = face->get_mg_boucle(v);
                REC_CONTOUR Rec(fem_maillage, Idealiser, fonction, testo, faceso);
                Rec.Reconstruire(Boucle, coef);
 
                fonction.Ajouter_Contour_Face(v);
                }
}
 
void REC_FACE_CONIQUE::Enregistrer(char *path)
{
        //OCC_FONCTION fonction;
        //fonction.Enregistrer(path);
}