mg_face.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/
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//
//####//       mg_face.cpp
//####//
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//    COPYRIGHT 2000-2024
//####//  jeu 13 jun 2024 11:58:54 EDT
//####//------------------------------------------------------------
//####//------------------------------------------------------------
 
 
#include "gestionversion.h"
#include <math.h>
#include "mg_face.h"
#include "vct_face.h"
#include "mg_definition.h"
#include "ot_mathematique.h"
 
MG_FACE::MG_FACE(std::string idori,unsigned long num,MG_SURFACE* srf,int sens):MG_ELEMENT_TOPOLOGIQUE(num,idori),surface(srf),orientation(sens),vect(NULL),nb_pole(-1)
{
}
 
MG_FACE::MG_FACE(std::string idori,MG_SURFACE* srf,int sens):MG_ELEMENT_TOPOLOGIQUE(idori),surface(srf),orientation(sens),vect(NULL),nb_pole(-1)
{
}
 
MG_FACE::MG_FACE(MG_FACE& mdd):MG_ELEMENT_TOPOLOGIQUE(mdd),lst_boucle(mdd.lst_boucle),surface(mdd.surface),orientation(mdd.orientation),vect(NULL),nb_pole(mdd.nb_pole)
{
}
 
MG_FACE::~MG_FACE()
{
    if (vect!=NULL) delete vect;
}
 
void MG_FACE::ajouter_mg_boucle(class MG_BOUCLE* mgbou)
{
    lst_boucle.insert(lst_boucle.end(),mgbou);
}
 
void MG_FACE::supprimer_mg_boucle(class MG_BOUCLE* mgbou)
{
    std::vector<MG_BOUCLE*>::iterator i;
    for (i=lst_boucle.begin();i!=lst_boucle.end();i++)
    {
        if ((*i)==mgbou)
        {
            lst_boucle.erase(i);
            return;
        }
    }
}
 
 
int MG_FACE::get_nb_mg_boucle(void)
{
    return lst_boucle.size();
}
 
MG_BOUCLE* MG_FACE::get_mg_boucle(int num)
{
    return lst_boucle[num];
}
 
 
void  MG_FACE::ajouter_mg_coface(class MG_COFACE* coface)
{
    lst_coface.insert(lst_coface.end(),coface);
}
 
int  MG_FACE::get_nb_mg_coface(void)
{
    return lst_coface.size();
}
 
 
void  MG_FACE::supprimer_mg_coface(class MG_COFACE* coface)
{
    std::vector<MG_COFACE*>::iterator i;
    for (i=lst_coface.begin();i!=lst_coface.end();i++)
    {
        if ((*i)==coface)
        {
            lst_coface.erase(i);
            return;
        }
    }
}
 
 
 
MG_COFACE*  MG_FACE::get_mg_coface(int num)
{
    return lst_coface[num];
}
 
MG_SURFACE*  MG_FACE::get_surface(void)
{
    return surface;
}
 
void MG_FACE::get_topologie_sousjacente(TPL_MAP_ENTITE<MG_ELEMENT_TOPOLOGIQUE*> *lst)
{
    int nb=lst_boucle.size();
    for (int i=0;i<nb;i++)
    {
        MG_BOUCLE* bou=lst_boucle[i];
        int nb2=bou->get_nb_mg_coarete();
        for (int j=0;j<nb2;j++)
        {
            MG_ARETE* are=bou->get_mg_coarete(j)->get_arete();
            lst->ajouter(are);
            are->get_topologie_sousjacente(lst);
        }
    }
}
 
int MG_FACE::get_dimension(void)
{
    return 2;
}
 
int MG_FACE::get_type(void)
{
  return TYPE_ELEMENT_TOPOLOGIQUE::FACE;
}
 
int  MG_FACE::get_orientation(void)
{
    return orientation;
}
 
bool MG_FACE::est_une_topo_element(void)
{
return false;
}
 
int MG_FACE::valide_parametre_u(double& u)
{
    if (surface->est_periodique_u()) return 1;
    double param=u;
    if (orientation!=MEME_SENS) param=surface->get_umin()+surface->get_umax()-param;
    double param_min,param_max;
    param_min=surface->get_umin();
    param_max=surface->get_umax();
    if (param<param_min)
    {
        u=param_min;
        if (orientation!=MEME_SENS) u=surface->get_umin()+surface->get_umax()-u;
        return 0;
    }
    if (param>param_max)
    {
        u=param_max;
        if (orientation!=MEME_SENS) u=surface->get_umin()+surface->get_umax()-u;
        return 0;
    }
    return 1;
}
int MG_FACE::valide_parametre_v(double& v)
{
    if (surface->est_periodique_v()) return 1;
    double param=v;
    double param_min,param_max;
    param_min=surface->get_vmin();
    param_max=surface->get_vmax();
    if (param<param_min)
    {
        v=param_min;
        return 0;
    }
    if (param>param_max)
    {
        v=param_max;
        return 0;
    }
    return 1;
}
 
void  MG_FACE::evaluer(double *uv,double *xyz)
{
    double param[2]={uv[0],uv[1]};
    if (orientation!=MEME_SENS) param[0]=surface->get_umin()+surface->get_umax()-param[0];
    surface->evaluer(param,xyz);
}
 
void  MG_FACE::deriver(double *uv,double *xyzdu, double *xyzdv)
{
    double param[2]={uv[0],uv[1]};
    if (orientation!=MEME_SENS) param[0]=surface->get_umin()+surface->get_umax()-param[0];
    surface->deriver(param,xyzdu,xyzdv);
    if (orientation!=MEME_SENS)
    {
        xyzdu[0]=-xyzdu[0];
        xyzdu[1]=-xyzdu[1];
        xyzdu[2]=-xyzdu[2];
    }
}
 
void  MG_FACE::deriver_seconde(double *uv,double* xyzduu,double* xyzduv,double* xyzdvv,double *xyz , double *xyzdu, double *xyzdv)
{
    double param[2]={uv[0],uv[1]};
    if (orientation!=MEME_SENS) param[0]=surface->get_umin()+surface->get_umax()-param[0];
    surface->deriver_seconde(param,xyzduu,xyzduv,xyzdvv,xyz,xyzdu,xyzdv);
    if (orientation!=MEME_SENS)
    {
        xyzdu[0]=-xyzdu[0];
        xyzdu[1]=-xyzdu[1];
        xyzdu[2]=-xyzdu[2];
        xyzduv[0]=-xyzduv[0];
        xyzduv[1]=-xyzduv[1];
        xyzduv[2]=-xyzduv[2];
    }
}
 
void  MG_FACE::inverser(double *uv,double *xyz,double precision)
{
    surface->inverser(uv,xyz,precision);
    if (orientation!=MEME_SENS) uv[0]=surface->get_umin()+surface->get_umax()-uv[0];
}
 
void  MG_FACE::calcul_normale(double *uv,double *normale)
{
    double xyzdu[3];
    double xyzdv[3];
 
    deriver(uv,xyzdu,xyzdv);
    OT_VECTEUR_3D xu(xyzdu);
    OT_VECTEUR_3D xv(xyzdv);
    OT_VECTEUR_3D n=xu&xv;
    normale[0]=n.get_x();
    normale[1]=n.get_y();
    normale[2]=n.get_z();
}
 
void  MG_FACE::calcul_normale_unitaire(double *uv,double *normale)
{
    double xyzdu[3];
    double xyzdv[3];
 
    deriver(uv,xyzdu,xyzdv);
    OT_VECTEUR_3D xu(xyzdu);
    OT_VECTEUR_3D xv(xyzdv);
    OT_VECTEUR_3D n=xu&xv;
    n.norme();
    normale[0]=n.get_x();
    normale[1]=n.get_y();
    normale[2]=n.get_z();
}
 
 
void MG_FACE::get_EFG(double *uv,double& E,double& F,double& G)
{
    double xyzdu[3];
    double xyzdv[3];
    deriver(uv,xyzdu,xyzdv);
    E=xyzdu[0]*xyzdu[0]+xyzdu[1]*xyzdu[1]+xyzdu[2]*xyzdu[2];
    F=xyzdu[0]*xyzdv[0]+xyzdu[1]*xyzdv[1]+xyzdu[2]*xyzdv[2];
    G=xyzdv[0]*xyzdv[0]+xyzdv[1]*xyzdv[1]+xyzdv[2]*xyzdv[2];
}
 
void MG_FACE::get_M(double *uv,double& M1,double& M2,double& M3)
{
    double E,F,G;
    double xyz[3],xyzdu[3],xyzdv[3],xyzduu[3],xyzduv[3],xyzdvv[3];
 
    deriver_seconde(uv,xyzduu,xyzduv,xyzdvv,xyz,xyzdu,xyzdv);
    E=xyzdu[0]*xyzdu[0]+xyzdu[1]*xyzdu[1]+xyzdu[2]*xyzdu[2];
    G=xyzdv[0]*xyzdv[0]+xyzdv[1]*xyzdv[1]+xyzdv[2]*xyzdv[2];
    double Edu=2.*(xyzdu[0]*xyzduu[0]+xyzdu[1]*xyzduu[1]+xyzdu[2]*xyzduu[2]);
    double Gdv=2.*(xyzdv[0]*xyzdvv[0]+xyzdv[1]*xyzdvv[1]+xyzdv[2]*xyzdvv[2]);
    double Edv=2.*(xyzdu[0]*xyzduv[0]+xyzdu[1]*xyzduv[1]+xyzdu[2]*xyzduv[2]);
    double Gdu=2.*(xyzdv[0]*xyzduv[0]+xyzdv[1]*xyzduv[1]+xyzdv[2]*xyzduv[2]);
    double m1[3],m2[3],m3[3];
    m1[0]=xyzduu[0]/E-0.5*Edu*xyzdu[0]/E/E;
    m1[1]=xyzduu[1]/E-0.5*Edu*xyzdu[1]/E/E;
    m1[2]=xyzduu[2]/E-0.5*Edu*xyzdu[2]/E/E;
    m2[0]=xyzduv[0]/sqrt(E*G)-0.5*xyzdu[0]*Edv/E/sqrt(E*G)-0.5*xyzdv[0]*Gdu/G/sqrt(E*G);
    m2[1]=xyzduv[1]/sqrt(E*G)-0.5*xyzdu[1]*Edv/E/sqrt(E*G)-0.5*xyzdv[1]*Gdu/G/sqrt(E*G);
    m2[2]=xyzduv[2]/sqrt(E*G)-0.5*xyzdu[2]*Edv/E/sqrt(E*G)-0.5*xyzdv[2]*Gdu/G/sqrt(E*G);
    m3[0]=xyzdvv[0]/G-0.5*Gdv*xyzdv[0]/G/G;
    m3[1]=xyzdvv[1]/G-0.5*Gdv*xyzdv[1]/G/G;
    m3[2]=xyzdvv[2]/G-0.5*Gdv*xyzdv[2]/G/G;
    M1=sqrt(m1[0]*m1[0]+m1[1]*m1[1]+m1[2]*m1[2]);
    M2=sqrt(m2[0]*m2[0]+m2[1]*m2[1]+m2[2]*m2[2]);
    M3=sqrt(m3[0]*m3[0]+m3[1]*m3[1]+m3[2]*m3[2]);
}
 
void MG_FACE::get_LMN(double *uv,double& L,double& M,double &N)
{
 
    double xyz[3],xyzdu[3],xyzdv[3],xyzduu[3],xyzduv[3],xyzdvv[3],normal[3];
    deriver_seconde(uv,xyzduu,xyzduv,xyzdvv,xyz,xyzdu,xyzdv);
    calcul_normale_unitaire(uv,normal);
    L=xyzduu[0]*normal[0]+xyzduu[1]*normal[1]+xyzduu[2]*normal[2];
    M=xyzduv[0]*normal[0]+xyzduv[1]*normal[1]+xyzduv[2]*normal[2];
    N=xyzdvv[0]*normal[0]+xyzdvv[1]*normal[1]+xyzdvv[2]*normal[2];
}
 
 
void MG_FACE::get_courbure(double *uv,double& cmax,double& cmin)
{
    double E,F,G,L,M,N;
    get_EFG(uv,E,F,G);
    get_LMN(uv,L,M,N);
    double a=E*G-F*F;
    double b=-E*N-G*L+2*F*M;
    double c=L*N-M*M;
    double delta=b*b-4*a*c;
    if (delta<0.00000001) delta=0.;
    double x1=(-b+sqrt(delta))/2./a;
    double x2=(-b-sqrt(delta))/2./a;
    if (fabs(x1)>fabs(x2)) {
        cmax=x1;
        cmin=x2;
    } else {
        cmax=x2;
        cmin=x1;
    }
}
 
 
 
BOITE_3D MG_FACE::get_boite_3D(void)
{
double xmin=1e308,ymin=1e308,zmin=1e308;
double xmax=-1e308,ymax=-1e308,zmax=-1e308;
double umin=1e308,vmin=1e308;
double umax=-1e308,vmax=-1e308;
int nb_boucle=get_nb_mg_boucle();
if (surface->est_periodique_u())
        {
        umin=0.;
        umax=surface->get_periode_u();
        }
if (surface->est_periodique_v())
        {
        vmin=0.;
        vmax=surface->get_periode_v();
        }
for (int i=0;i<nb_boucle;i++)
  {
  MG_BOUCLE* bou=get_mg_boucle(i);
  int nb_arete=bou->get_nb_mg_coarete();      
  for (int j=0;j<nb_arete;j++)
        {
            MG_ARETE* arete=bou->get_mg_coarete(j)->get_arete();
            double tmin=arete->get_tmin();
            double tmax=arete->get_tmax();
            double tdemi=0.5*(tmax+tmin);
            double xyz1[3],xyz2[3];
            for (int k=0;k<pas_echantillon+1;k++)
                {
                double t=tmin+1.0*k/pas_echantillon*(tmax-tmin);
                double xyz[3];
                arete->evaluer(t,xyz);
                if (xyz[0]<xmin) xmin=xyz[0];
                if (xyz[0]>xmax) xmax=xyz[0];
                if (xyz[1]<ymin) ymin=xyz[1];
                if (xyz[1]>ymax) ymax=xyz[1];
                if (xyz[2]<zmin) zmin=xyz[2];
                if (xyz[2]>zmax) zmax=xyz[2];
                double uv[2];
                inverser(uv,xyz);
                if (uv[0]>umax) umax=uv[0];
                if (uv[0]<umin) umin=uv[0];
                if (uv[1]>vmax) vmax=uv[1];
                if (uv[1]<vmin) vmin=uv[1];
                }
         }
    std::vector<double> lstpoint;
    get_echantillonnage(pas_echantillon*pas_echantillon,lstpoint);
    if (lstpoint.size()<1)
    {
    for (int k=0;k<pas_echantillon+1;k++)
        for (int l=0;l<pas_echantillon+1;l++)
                 {
                  double uv[2];
                  uv[0]=umin+1.0*k/pas_echantillon*(umax-umin);
                  uv[1]=vmin+1.0*l/pas_echantillon*(vmax-vmin);
                  double xyz[3];
                  evaluer(uv,xyz);
                  if (xyz[0]<xmin) xmin=xyz[0];
                  if (xyz[1]<ymin) ymin=xyz[1];
                  if (xyz[2]<zmin) zmin=xyz[2];
                  if (xyz[0]>xmax) xmax=xyz[0];
                  if (xyz[1]>ymax) ymax=xyz[1];
                  if (xyz[2]>zmax) zmax=xyz[2];
                  }
    }
    else
        for (int k=0;k<lstpoint.size()/5;k++)
            {
            double xyz[3]={lstpoint[5*k],lstpoint[5*k+1],lstpoint[5*k+2]};
            if (xyz[0]<xmin) xmin=xyz[0];
            if (xyz[1]<ymin) ymin=xyz[1];
            if (xyz[2]<zmin) zmin=xyz[2];
            if (xyz[0]>xmax) xmax=xyz[0];
            if (xyz[1]>ymax) ymax=xyz[1];
            if (xyz[2]>zmax) zmax=xyz[2];
            }
        }
    BOITE_3D boite(xmin,ymin,zmin,xmax,ymax,zmax);
    return boite;
  
}
 
 
int MG_FACE::get_nb_pole(void)
{
  return nb_pole;
}
 
 
void MG_FACE::get_liste_pole_uv(std::vector<double> *liste_pole_uv,double eps)
{
  surface->get_liste_pole(liste_pole_uv,eps);
  nb_pole = liste_pole_uv->size()/2;
}
 
void MG_FACE::get_xyz_min_max(double* xyzmin, double* xyzmax)
{
  /*xyzmin[0] = std::numeric_limits<double>::max();
  xyzmin[1] = std::numeric_limits<double>::max();
  xyzmin[2] = std::numeric_limits<double>::max();
  xyzmax[0] = std::numeric_limits<double>::min();
  xyzmax[1] = std::numeric_limits<double>::min();
  xyzmax[2] = std::numeric_limits<double>::min();
  double umin = get_surface()->get_umin();
  double umax = get_surface()->get_umax();
  if(get_surface()->est_periodique_u())
  {
    umin=0.0;
    umax=get_surface()->get_periode_u();
  }
  double pas_u = (umax-umin)/(double)nb_pas;
  double vmin = get_surface()->get_vmin();
  double vmax = get_surface()->get_vmax();
  if(get_surface()->est_periodique_v())
  {
    vmin=0.0;
    vmax=get_surface()->get_periode_v();
  }
  double pas_v = (vmax-vmin)/(double)nb_pas;
  double uv[2];
  for(int i=0;i<nb_pas;i++)
  {
    uv[0] = umin+pas_u*i;
    for(int j=0;j<nb_pas;j++)
    {
      uv[1] = vmin+j*pas_v;
      double xyz[3];
      evaluer(uv,xyz);
      if(xyz[0]>xyzmax[0]) xyzmax[0]=xyz[0];
      else if(xyz[0]<xyzmin[0]) xyzmin[0]=xyz[0];
      if(xyz[1]>xyzmax[1]) xyzmax[1]=xyz[1];
      else if(xyz[1]<xyzmin[1]) xyzmin[1]=xyz[1];
      if(xyz[2]>xyzmax[2]) xyzmax[2]=xyz[2];
      else if(xyz[2]<xyzmin[2]) xyzmin[2]=xyz[2];
    }
  }*/
  BOITE_3D boite=get_boite_3D();
  xyzmin[0] = boite.get_xmin();
  xyzmin[1] = boite.get_ymin();
  xyzmin[2] = boite.get_zmin();
  xyzmax[0] = boite.get_xmax();
  xyzmax[1] = boite.get_ymax();
  xyzmax[2] = boite.get_zmax();
  
}
 
void MG_FACE::get_echantillonnage(int numechantillon, std::vector<double> &tab)
{
surface->get_echantillonnage(numechantillon,tab,epsilon_echantillon,angle_dev_echantillon);
    
}
 
 
void MG_FACE::change_nb_pole(int val)
{
  nb_pole=val;
}
 
VCT& MG_FACE::get_vectorisation(void)
{
    if (vect==NULL) vect=new VCT_FACE(this);
    return *vect;
}
 
void MG_FACE::enregistrer(std::ostream& o,double version)
{
    o << "%" << get_id() << "=FACE("<< get_idoriginal() << ",$" << surface->get_id() << ",(";
    for (unsigned int i=0;i<lst_boucle.size();i++)
    {
        o << "$" << lst_boucle[i]->get_id();
        if (i!=lst_boucle.size()-1) o << ",";
        else o << ")";
    }
    int nb=get_nb_ccf();
    o << "," << orientation << "," << nb_pole << ",";
    if (version<2)
    {
      o << nb;
      if (nb!=0)
      {
        o << ",(";
        for (int i=0;i<nb;i++)
        {
            char nom[3];
            get_type_ccf(i,nom);
            o << "(" <<  nom << "," << get_valeur_ccf(i) << ")";
            if (i!=nb-1) o << "," ;
        }
        o << ")";
      
      }
    }
    else
    enregistrer_ccf(o,version);  
    o <<   ");" << std::endl;
}