comparaison/src/vct_comparaison.cpp

//---------------------------------------------------------------------------
#include"gestionversion.h"

#pragma hdrstop

#include "vct_comparaison.h"
#include "vct_volume.h"
#include "vct_face.h"
#include "vct_surface.h"
#include <iomanip.h>
#include "vct_outils.h"
#include "constantegeo.h"

//---------------------------------------------------------------------------

#pragma package(smart_init)


VCT_COMPARAISON::VCT_COMPARAISON(MG_GESTIONNAIRE *gst1,MG_GEOMETRIE *mgeo1,MG_GESTIONNAIRE *gst2,MG_GEOMETRIE *mgeo2):mggeo1(mgeo1),mggeo2(mgeo2),gest1(gst1),gest2(gst2)
{
MG_VOLUME*vol1=mggeo1->get_mg_volume(0);
MG_VOLUME*vol2=mggeo2->get_mg_volume(0);
T1=vol1->get_vectorisation().get_matrice_transformation(2);
T2=vol2->get_vectorisation().get_matrice_transformation(1);

}

VCT_COMPARAISON::~VCT_COMPARAISON()
{
}


void VCT_COMPARAISON::compare_les_deux_geometries(int affiche_couleur)
   {
     int nb_face1=mggeo1->get_nb_mg_face();
     int nb_face2=mggeo2->get_nb_mg_face();

     for(int i=0;i<nb_face1; i++)
       {
            OT_VECTEUR_4DD Dv1,Dv2,G1,G2;
            OT_TENSEUR V1(4),V2(4);
            MG_FACE* face1=mggeo1->get_mg_face(i);
            MG_SURFACE*surf1=face1->get_surface();
            G1=surf1->get_vectorisation().calcule_barycentre(T1);
            G1=surf1->get_vectorisation().get_nouveau_pt(T1,G1);
            int id1=face1->get_id();
            OT_TENSEUR tns1_face(4),tns1_surf(4);
            OT_TENSEUR ttns1_face(4),ttns1_surf(4);
            int nb_top1_pts= face1->get_vectorisation().get_nb_points();
            int nb_geo1_pts= surf1->get_vectorisation().get_nb_points();

            face1->get_vectorisation().calcule_axes_dinertie(T1,Dv1,V1);
            tns1_face=face1->get_vectorisation().calcule_tenseur_metrique();
            tns1_surf=surf1->get_vectorisation().calcule_tenseur_metrique();

            ttns1_face=face1->get_vectorisation().calcule_tenseur_inertie_base_locale(T1);
            ttns1_surf=surf1->get_vectorisation().calcule_tenseur_inertie_base_locale(T1);
            vector<double2> ifac1; vector<double2>isurf1;
                 for(int r=0;r<4;r++)
                    {
                        ifac1.insert( ifac1.end(), ttns1_face(r,r));
                        isurf1.insert( isurf1.end(), ttns1_surf(r,r));
                    }
                        int cmpt=0;
                        for(int j=0;j<nb_face2;j++)
                                {
                                        MG_FACE* face2=mggeo2->get_mg_face(j);
                                        MG_SURFACE*surf2=face2->get_surface();
                                        G2=surf2->get_vectorisation().calcule_barycentre(T2);
                                        int id2=face2->get_id();
                                        OT_TENSEUR tns2_face(4),tns2_surf(4);
                                        OT_TENSEUR ttns2_face(4),ttns2_surf(4);
                                        int nb_top2_pts= face2->get_vectorisation().get_nb_points();
                                        int nb_geo2_pts= surf2->get_vectorisation().get_nb_points();

                                        face2->get_vectorisation().calcule_axes_dinertie(T2,Dv1,V1);
                                        tns2_face=face2->get_vectorisation().calcule_tenseur_metrique();
                                        tns2_surf=surf2->get_vectorisation().calcule_tenseur_metrique();

                                        ttns2_face=face2->get_vectorisation().calcule_tenseur_inertie_base_locale(T2);
                                        ttns2_surf=surf2->get_vectorisation().calcule_tenseur_inertie_base_locale(T2);
                                        vector<double2> ifac2; vector<double2> isurf2;
                                                for(int r=0;r<4;r++)
                                                   {
                                                        ifac2.insert( ifac2.end(), ttns2_face(r,r));
                                                        isurf2.insert( isurf2.end(), ttns2_surf(r,r));
                                                   }

                                                        if(nb_geo1_pts==nb_geo2_pts&&nb_top1_pts==nb_top2_pts)
                                                                {
                                                                        if(tns1_face.est_til_equivalent(tns2_face))
                                                                                {
                                                                                verifier_le_repere(V1,V2,ifac1,ifac2);
                                                                                        if(tns1_surf.est_til_equivalent(tns2_surf))
                                                                                                 {
                                                                                                        similarite.ajouter(id1);
                                                                                                        similarite.ajouter(id2);
                                                                                                        vector<unsigned int> indx1,indx2;
                                                                                                        if(ttns1_face.listes_equivalentes(isurf1,isurf2,indx2))
                                                                                                                        {
                                                                                                                        if(G1==G2)
                                                                                                                               {
                                                                                                                                surf_ident.ajouter(id1);
                                                                                                                                surf_ident.ajouter(id2);
                                                                                                                               }

                                                                                                                         if(ttns1_face.listes_equivalentes(ifac1,ifac2,indx1))
                                                                                                                                {
                                                                                                                                sim_double.ajouter(id1) ;
                                                                                                                                sim_double.ajouter(id2) ;
                                                                                                                                cmpt++;
                                                                                                                                }
                                                                                                                         }

                                                                                                 }
                                                                                }
                                                                 }
                                }

            nb_sim.ajouter(cmpt);
       }
       
     if(sim_double.get_nb()==0)
       {
         sim_double=surf_ident;
       }
     if (affiche_couleur) this->affecter_les_couleurs(23);
   }


void VCT_COMPARAISON::trouver_les_identites(int affiche_couleur)
{

 TPL_LISTE_ENTITE<int> lst_fin;
 TPL_LISTE_ENTITE<int> lst;
 this->compare_les_deux_geometries(0);
 int nb_face1=mggeo1->get_nb_mg_face();
 int nb_face2=mggeo2->get_nb_mg_face();


 this->trouve_face_de_reference(face_ref1,face_ref2);//,ls,lst_fin

         OT_VECTEUR_4DD Dv,Dv1,Dv2,G1ref,G2ref,g1g2;
         OT_TENSEUR V(4),V1(4),V2(4);
         OT_VECTEUR_4DD g1_ref,g2_ref;
         MG_FACE* face1_ref=mggeo1->get_mg_faceid(face_ref1);
         //MG_SURFACE* surf1_ref=face1_ref->get_surface();
         //G1ref=  surf1_ref->get_vectorisation().calcule_barycentre(T1);
         G1ref=  face1_ref->get_vectorisation().calcule_barycentre(T1);
         G1ref=  face1_ref->get_vectorisation().get_nouveau_pt(T1,G1ref);
         //face1_ref->get_vectorisation().calcule_axes_dinertie(T1,Dv1,V1);
                 /*
                    for(int r=0;r<4;r++) {
                      for(int s=0;s<4;s++) {
                         g1_ref[r]= g1_ref[r]+V1(s,r)*G1[s];
                        }
                     }
                   */

        MG_FACE* face2_ref=mggeo2->get_mg_faceid(face_ref2);
        //face2_ref->get_vectorisation().calcule_axes_dinertie(T2,Dv2,V2);
        //MG_SURFACE* surf2_ref=face2_ref->get_surface();
        //G2ref=  surf2_ref->get_vectorisation().calcule_barycentre(T2);
          G2ref=  face2_ref->get_vectorisation().calcule_barycentre(T2);
                     /*
                    for(int r=0;r<4;r++) {
                      for(int s=0;s<4;s++) {
                         g2_ref[r]= g2_ref[r]+V2(s,r)*G2[s];
                        }
                     }
                   */

OT_VECTEUR_4DD g1refg1,g2refg2;


 for(int i=0;i<nb_face1;i++)
   {

         OT_VECTEUR_4DD g1,G1;
         MG_FACE* face1=mggeo1->get_mg_face(i);
         int id1=face1->get_id();
         G1=  face1->get_vectorisation().calcule_barycentre(T1);
         G1=  face1->get_vectorisation().get_nouveau_pt(T1,G1);
         /*
                    for(int r=0;r<4;r++) {
                      for(int s=0;s<4;s++) {
                         g1[r]= g1[r]+V1(s,r)*G1[s];
                        }
                     }
                     */
       g1refg1=G1-G1ref;
       g1refg1=face1->get_vectorisation().get_nouveau_pt(T1,g1refg1);
       //g1refg1=g1-g1_ref;
       // num2=list.get(2*i+1);
      for(int j=0;j<nb_face2;j++)
       {

        OT_VECTEUR_4DD g2,G2,g12refg2;

        MG_FACE* face2=mggeo2->get_mg_face(j);
        int id2=face2->get_id();
        G2=  face2->get_vectorisation().calcule_barycentre(T2);

         /*           for(int r=0;r<4;r++) {
                      for(int s=0;s<4;s++) {
                         g2[r]= g2[r]+V2(s,r)*G2[s];
                        }
                     }
         */
       //OT_VECTEUR_4DD g2refg2=g2-g2_ref;
      // g12refg2=G2-G2ref;
       OT_VECTEUR_4DD g2refg2=G2-G2ref;
       //OT_VECTEUR_4DD dif= g1refg1-g2refg2;
       //double2 prec=1e-6;
      // if(dif[0].get_fabs()<=prec&&dif[1].get_fabs()<=prec&&dif[2].get_fabs()<=prec&&dif[3].get_fabs()<=prec)
         if(g2refg2==g1refg1)
           {
            identite.ajouter(id1);
            identite.ajouter(id2);

           break;
           }
       }
      }


if(affiche_couleur) this->affecter_les_couleurs(1);

}


void VCT_COMPARAISON::compare_les_deux_geometries_vectoriellement(int affiche_couleur)
{
int nb_face1=mggeo1->get_nb_mg_face();
int nb_face2=mggeo2->get_nb_mg_face();
similarite.vide();
     for(int i=0;i<nb_face1; i++)
       {
        MG_FACE* face1=mggeo1->get_mg_face(i);
        MG_SURFACE*surf1=face1->get_surface();
        int id1=face1->get_id();
        OT_TENSEUR tns1_face(4),tns1_surf(4);
        OT_TENSEUR ttns1_face(4),ttns1_surf(4);
        int nb_top1_pts= face1->get_vectorisation().get_nb_points();
        int nb_geo1_pts= surf1->get_vectorisation().get_nb_points();

        tns1_face=face1->get_vectorisation().calcule_tenseur_metrique();
        tns1_surf=surf1->get_vectorisation().calcule_tenseur_metrique();

        for(int j=0;j<nb_face2;j++)
            {
              MG_FACE* face2=mggeo2->get_mg_face(j);
              MG_SURFACE*surf2=face2->get_surface();
              int id2=face2->get_id();
              OT_TENSEUR tns2_face(4),tns2_surf(4);
              OT_TENSEUR ttns2_face(4),ttns2_surf(4);
              int nb_top2_pts= face2->get_vectorisation().get_nb_points();
              int nb_geo2_pts= surf2->get_vectorisation().get_nb_points();
              tns2_face=face2->get_vectorisation().calcule_tenseur_metrique();
              tns2_surf=surf2->get_vectorisation().calcule_tenseur_metrique();

               if(nb_geo1_pts==nb_geo2_pts&&nb_top1_pts==nb_top2_pts)
                   {
                    if(tns1_face.est_til_equivalent(tns2_face))
                       {
                       if(tns1_surf.est_til_equivalent(tns2_surf))
                          {
                            similarite.ajouter(id1);
                            similarite.ajouter(id2);
                          }
                        }
                     }
                }
            }
if (affiche_couleur)this->affecter_les_couleurs(21);

}

void VCT_COMPARAISON::compare_les_deux_geometries_inertiellement (int affiche_couleur)
{


int nb_face1=mggeo1->get_nb_mg_face();
int nb_face2=mggeo2->get_nb_mg_face();
ssimilarite.vide();
    for(int i=0;i<nb_face1; i++)
      {
       MG_FACE* face1=mggeo1->get_mg_face(i);
       MG_SURFACE*surf1=face1->get_surface();
       int id1=face1->get_id();
       OT_TENSEUR tns1_face(4),tns1_surf(4);
       int nb_top1_pts= face1->get_vectorisation().get_nb_points();
       int nb_geo1_pts= surf1->get_vectorisation().get_nb_points();

       tns1_face=face1->get_vectorisation().calcule_tenseur_inertie_base_locale(T1);
       tns1_surf=surf1->get_vectorisation().calcule_tenseur_inertie_base_locale(T1);
       vector<double2> ifac1; vector<double2>isurf1;
        for(int r=0;r<4;r++)
          {
         ifac1.insert( ifac1.end(), tns1_face(r,r));
         isurf1.insert( isurf1.end(), tns1_surf(r,r));
          }

        for(int j=0;j<nb_face2;j++)
          {

              MG_FACE* face2=mggeo2->get_mg_face(j);
              MG_SURFACE*surf2=face2->get_surface();
              int id2=face2->get_id();
              OT_TENSEUR tns2_face(4),tns2_surf(4);
              int nb_top2_pts= face2->get_vectorisation().get_nb_points();
              int nb_geo2_pts= surf2->get_vectorisation().get_nb_points();
              tns2_face=face2->get_vectorisation().calcule_tenseur_inertie_base_locale(T2);
              tns2_surf=surf2->get_vectorisation().calcule_tenseur_inertie_base_locale(T2);
              vector<double2> ifac2; vector<double2> isurf2;
              for(int r=0;r<4;r++)
               {
               ifac2.insert( ifac2.end(), tns2_face(r,r));
               isurf2.insert( isurf2.end(), tns2_surf(r,r));
               }

             if(nb_geo1_pts==nb_geo2_pts&&nb_top1_pts==nb_top2_pts)
                {
                vector<unsigned int> indx1,indx2;
                    if(tns1_face.listes_equivalentes(ifac1,ifac2,indx1))
                       {
                        if(tns1_face.listes_equivalentes(isurf1,isurf2,indx2))
                         {
                         ssimilarite.ajouter(id1);
                         ssimilarite.ajouter(id2);
                         }
                       }
                }

             }

         }

if (affiche_couleur)affecter_les_couleurs(22);
}

void VCT_COMPARAISON::compare_une_geometrie_inertiellement(int modele)
{


 TPL_LISTE_ENTITE<int> ssim_tmp;

MG_GESTIONNAIRE *gst1;
MG_GEOMETRIE *mgeo1  ;
int laquelle;

switch(modele)
{
 case 1:
 {
  gst1=gest1;
  mgeo1=mggeo1;
  laquelle=31;
  break;
 }
 case 2:
 {
  gst1=gest2;
  mgeo1=mggeo2;
  laquelle=32;
  break;
 }

}

int nb_face1=mgeo1->get_nb_mg_face();

    for(int i=0;i<nb_face1; i++)
      {
       MG_FACE* face1=mgeo1->get_mg_face(i);
       MG_SURFACE*surf1=face1->get_surface();
       int id1=face1->get_id();
       OT_TENSEUR tns1_face(4),tns1_surf(4);
       int nb_top1_pts= face1->get_vectorisation().get_nb_points();
       int nb_geo1_pts= surf1->get_vectorisation().get_nb_points();

       tns1_face=face1->get_vectorisation().calcule_tenseur_inertie_base_locale(T1);
       tns1_surf=surf1->get_vectorisation().calcule_tenseur_inertie_base_locale(T1);
       vector<double2> ifac1; vector<double2>isurf1;
        for(int r=0;r<4;r++)
          {
         ifac1.insert( ifac1.end(), tns1_face(r,r));
         isurf1.insert( isurf1.end(), tns1_surf(r,r));
          }

        for(int j=0;j<nb_face1;j++)
          {

              MG_FACE* face2=mgeo1->get_mg_face(j);
              MG_SURFACE*surf2=face2->get_surface();
              int id2=face2->get_id();
              OT_TENSEUR tns2_face(4),tns2_surf(4);
              int nb_top2_pts= face2->get_vectorisation().get_nb_points();
              int nb_geo2_pts= surf2->get_vectorisation().get_nb_points();
              tns2_face=face2->get_vectorisation().calcule_tenseur_inertie_base_locale(T1);
              tns2_surf=surf2->get_vectorisation().calcule_tenseur_inertie_base_locale(T1);
              vector<double2> ifac2; vector<double2> isurf2;
              for(int r=0;r<4;r++)
               {
               ifac2.insert( ifac2.end(), tns2_face(r,r));
               isurf2.insert( isurf2.end(), tns2_surf(r,r));
               }

             if(nb_geo1_pts==nb_geo2_pts&&nb_top1_pts==nb_top2_pts)
                {
                vector<unsigned int> indx1,indx2;
                    if(tns1_face.listes_equivalentes(ifac1,ifac2,indx1))
                       {
                        if(tns1_face.listes_equivalentes(isurf1,isurf2,indx2))
                         {
                         ssim_tmp.ajouter(id1);
                         ssim_tmp.ajouter(id2);
                         }
                       }
                }

             }

         }
if (modele==1) ssim1=ssim_tmp;
if (modele==2) ssim2=ssim_tmp;

affecter_les_couleurs(laquelle);
}


TPL_LISTE_ENTITE<int> VCT_COMPARAISON::get_liste_des_identitees()
{
  return identite;
}

TPL_LISTE_ENTITE<int> VCT_COMPARAISON::get_liste_des_simalarite_vectorielle(int type_comparais)
{
TPL_LISTE_ENTITE<int> lst_tmp;
 switch ( type_comparais)
  {
  case 12:  lst_tmp= similarite;
  case 1:   lst_tmp=  sim1;
  case 2:   lst_tmp=  sim2;
  }
  return lst_tmp;
}

TPL_LISTE_ENTITE<int> VCT_COMPARAISON::get_liste_des_simalarite_inertielle(int type_comparais)
{
TPL_LISTE_ENTITE<int> lst_tmp;
 switch ( type_comparais)
  {
  case 12:  lst_tmp= ssimilarite;
  case 1:   lst_tmp=  ssim1;
  case 2:   lst_tmp=  ssim2;
  }
  return lst_tmp;
}


void VCT_COMPARAISON::affecter_les_couleurs(int niveau)
{
       //randomize();
       int nb_face_ident=similarite.get_nb()/2;
       int nb_face_identt=ssimilarite.get_nb()/2;
       int nb_face_iden=identite.get_nb()/2;
double val;
TPL_LISTE_ENTITE<int> lst;
TPL_LISTE_ENTITE<double> lst_val;
int num1,num2,num1_avant ;
if (niveau==1)  //pour afficher les identites entre le deux mod�les
    {
for(int i=0;i< nb_face_iden;i++)
 {
  num1=identite.get(2*i) ;
  num2=identite.get(2*i+1) ;
  if(i>0) num1_avant= identite.get(2*(i-1));
  MG_FACE* face1=mggeo1->get_mg_faceid(num1);
  MG_FACE* face2=mggeo2->get_mg_faceid(num2);

  if(i==0)
   {
   choisir_une_couleur(val);
   while(lst_val.est_dans_la_liste(val))
     {
      choisir_une_couleur(val);
     }
   face1->ajouter_ccf("Cc",val);
   face2->ajouter_ccf("Cc",val);
   lst_val.ajouter(val);
   }

  if(i>0)
   {
    if(num1!=num1_avant)
       {
   choisir_une_couleur(val);
   while(lst_val.est_dans_la_liste(val))
     {
      choisir_une_couleur(val);
     }
   face1->ajouter_ccf("Cc",val);
   face2->ajouter_ccf("Cc",val);
   lst_val.ajouter(val);
       }
     else{
        face2->ajouter_ccf("Cc",val);
         }

   }
 }

}

if(niveau==21||niveau==22||niveau==23)  //pour afficher la similarite entre le deux mod�le vectoriellement ou inertiellement
 {
  TPL_LISTE_ENTITE<int>   simu;
  if(niveau==21)simu=similarite;
  if(niveau==22) simu=ssimilarite;
  if(niveau==23) simu=sim_double;
  TPL_LISTE_ENTITE<int> llst1;
  TPL_LISTE_ENTITE<int> llst2;
  int nb_face_sim=simu.get_nb()/2.;
  for(int i=0;i< nb_face_sim;i++)
     {
    TPL_LISTE_ENTITE<int> lst1;
    TPL_LISTE_ENTITE<int> lst2;
    TPL_LISTE_ENTITE<int> llst3;
    num1=simu.get(2*i) ;
    if(!llst1.est_dans_la_liste(num1))
    {
    num2=simu.get(2*i+1) ;
    lst1.ajouter(num1);
    lst2.ajouter(num2);
    llst1.ajouter(num1);
    llst2.ajouter(num2);
     for(int j=1;j< nb_face_sim;j++)
       {
      int Num1=simu.get(2*j) ;
      int Num2=simu.get(2*j+1) ;

        if(num1==Num1)
         {
          llst3.ajouter(Num2);
         }
        if(num2==Num2||llst3.est_dans_la_liste(Num2))
         {
           if(!lst1.est_dans_la_liste(Num1)) {
           lst1.ajouter(Num1);
           llst1.ajouter(Num1);              }
           if(!lst2.est_dans_la_liste(Num2)) {
           lst2.ajouter(Num2);
           llst2.ajouter(Num2);              }
         }

       }

    choisir_une_couleur(val);
    while(lst_val.est_dans_la_liste(val))
     {
      choisir_une_couleur(val);
     }
     lst_val.ajouter(val);
     int nb1=lst1.get_nb();
     int nb2=lst2.get_nb();
        for(int i=0;i<nb1;i++)
         {
         int n1=lst1.get(i);
         MG_FACE* face1=mggeo1->get_mg_faceid(n1);
         face1->ajouter_ccf("Cc",val);
         }
        for(int i=0;i<nb2;i++)
         {
         int n2=lst2.get(i);
         MG_FACE* face2=mggeo2->get_mg_faceid(n2);
         face2->ajouter_ccf("Cc",val);
         }
    
     }
    }


}

if(niveau== 31||niveau==32)  //pour afficher la similarite dans le premier mod�le  ou le second modele
   {

MG_GEOMETRIE *mgeo1  ;
int laquelle;

switch(niveau)
{
 case 31:
 {
  mgeo1=mggeo1;
  laquelle=31;
  break;
 }
 case 32:
 {
  mgeo1=mggeo2;
  laquelle=32;
  break;
 }

}


for(int i=0;i< nb_face_identt;i++)
 {
  num1=ssimilarite.get(2*i) ;
  num2=ssimilarite.get(2*i+1) ;

  if(i>0) num1_avant= ssimilarite.get(2*(i-1));
  MG_FACE* face1=mgeo1->get_mg_faceid(num1);
  MG_FACE* face2=mgeo1->get_mg_faceid(num2);
  if(!lst.est_dans_la_liste(num2))
    {
  if(i==0)
   {
   choisir_une_couleur(val);
   while(lst_val.est_dans_la_liste(val))
     {
      choisir_une_couleur(val);
     }
   face1->ajouter_ccf("Cc",val);
   if(num1!=num2)  face2->ajouter_ccf("Cc",val);  lst.ajouter(num2);
   lst_val.ajouter(val);
   }

  if(i>0)
   {
    if(num1!=num1_avant)
       {
   choisir_une_couleur(val);
   while(lst_val.est_dans_la_liste(val))
     {
      choisir_une_couleur(val);
     }
   face1->ajouter_ccf("Cc",val);
   if(num1!=num2)  face2->ajouter_ccf("Cc",val);   lst.ajouter(num2);
   lst_val.ajouter(val);
       }
     else{
         if(num1!=num2)   face2->ajouter_ccf("Cc",val);  lst.ajouter(num2);
         }

   }
  }
 }


}


}


void VCT_COMPARAISON::choisir_une_couleur(double& val)
{
       //randomize();

       unsigned char r=rand() % 255;
       unsigned char g=rand() % 255;
       unsigned char b=rand() % 255;
       val=0.;
       unsigned char* p =(unsigned char*)&val;

       *p=r;
       p++;*p=g;
       p++;*p=b;

}


void VCT_COMPARAISON::trouve_face_de_reference(int &face_ref1,int &face_ref2)// ,TPL_LISTE_ENTITE<int>& list
{

/*
int nb_simdble=sim_double.get_nb()/2 ;

int num1,num2 ;


  OT_VECTEUR_4DD Dv,Dv1,Dv2,G1,G2,g1g2;
  OT_TENSEUR V(4),V1(4),V2(4);


 int nbsim=nb_sim.get_nb();
 int *t=new int [nbsim];
 int *tt=new int [nbsim];
 for(int i=0;i<nbsim;i++)
  {
 // t[i]= nb_sim.get(i);
  t[i]= i;
  int nbre_faces_simil=nb_sim.get(i);
  tt[i]=nbre_faces_simil;

  }
 int pos_min,pos_max;
 int min,max;
 int trouve=0;

     for (int i=0;i<nbsim;i++)
       {

        for(int j=0;j<nbsim;j++)
         {
           if(tt[j]<tt[i])
            {
            int tmp= tt[i];

             tt[i]= tt[j];
             tt[j]= tmp;
             t[i]=j;
             t[j]=i;
            }
         }
       }


//pos_max=t[1];

if(tt[0]==1)
 {
   pos_min=t[0];
   MG_FACE* fref=mggeo1->get_mg_face(pos_min);
   face_ref1= fref->get_id();
   for(int i=0;i<nb_simdble;i++){
     if (sim_double.get(2*i)==face_ref1)
      face_ref2=sim_double.get(2*i+1);
      }
   return;
 }


  int pos1=0;
  int pos2=0;

int tr=0;
trouve=0;
while(trouve==0&&tr<nbsim-1)
{
pos_min=t[tr];
pos_max=t[tr+1];

         OT_VECTEUR_4DD g1_ref,g2_ref,G1_ref,G2_ref;
         MG_FACE* face1_ref=mggeo1->get_mg_face(pos_min);
         MG_SURFACE* surf1_ref=face1_ref->get_surface();
         int id1=face1_ref->get_id();
         face1_ref->get_vectorisation().calcule_axes_dinertie(T1,Dv1,V1);
         G1_ref=  face1_ref->get_vectorisation().calcule_barycentre(T1);
                  /*
                    for(int r=0;r<4;r++) {
                      for(int s=0;s<4;s++) {
                         g1_ref[r]= g1_ref[r]+V1(s,r)*G1_ref[s];
                        }
                     }
                    /
         g1_ref=face1_ref->get_vectorisation().get_nouveau_pt(T1,G1_ref);
            /*  OT_TENSEUR ttns1_face=face1_ref->get_vectorisation().calcule_tenseur_inertie_base_locale();
              vector<double2> ifac1;
              for(int r=0;r<4;r++)
               {
               ifac1.insert( ifac2.end(), ttns1_face(r,r));
               }  /

        MG_FACE* face12_ref=mggeo1->get_mg_face(pos_max);
        face12_ref->get_vectorisation().calcule_axes_dinertie(T2,Dv2,V2);
        int id2=face12_ref->get_id();
        G2_ref=  face12_ref->get_vectorisation().calcule_barycentre(T2);
        /*
                    for(int r=0;r<4;r++) {
                      for(int s=0;s<4;s++) {
                         g2_ref[r]= g2_ref[r]+V1(s,r)*G2_ref[s];
                        }
                     }
        /
        g2_ref=face12_ref->get_vectorisation().get_nouveau_pt(T1,G2_ref);

OT_VECTEUR_4DD g12_ref= g2_ref -g1_ref;


OT_VECTEUR_4DD g1refg1,g2refg2;
TPL_LISTE_ENTITE<int> lst1,lst2;
 for(int k=0;k<nb_simdble;k++)
  {
   if(sim_double.get(2*k)==id1)
     lst1.ajouter( sim_double.get(2*k+1));
   if(sim_double.get(2*k)==id2)
     lst2.ajouter(sim_double.get(2*k+1));
  }


 for(int i=0;i<lst1.get_nb();i++)
   {

         int num1=lst1.get(i);
         OT_VECTEUR_4DD g1,G1;
         MG_FACE* face1=mggeo2->get_mg_faceid(num1);
         face1->get_vectorisation().calcule_axes_dinertie(T2,Dv2,V2);
         G1=  face1->get_vectorisation().calcule_barycentre(T2);
         /*
                    for(int r=0;r<4;r++) {
                      for(int s=0;s<4;s++) {
                         g1[r]= g1[r]+V2(s,r)*G1[s];
                        }
                     }
          /
       // g1refg1=g1-g1_ref;
       // num2=list.get(2*i+1);
      for(int j=0;j<lst2.get_nb();j++)
       {
        int num2=lst2.get(j);
        OT_VECTEUR_4DD g2;
        MG_FACE* face2=mggeo2->get_mg_faceid(num2);
        G2=  face2->get_vectorisation().calcule_barycentre(T2);
        /*
                    for(int r=0;r<4;r++) {
                      for(int s=0;s<4;s++) {
                         g2[r]= g2[r]+V2(s,r)*G2[s];
                        }
                     }
          /
       //OT_VECTEUR_4DD g2g1=g2-g1;
       OT_VECTEUR_4DD g2g1=G2-G1;
        if(g2g1==g12_ref)
           {
//            lst_fin.ajouter(num1);
//            lst_fin.ajouter(num2);
           face_ref1=id1;
           face_ref2=num1;
           trouve=1;
           break;
           }
        }
        if(trouve) break;
      }
      tr++;
 }
delete [] t;
delete [] tt;
  */

 int p=0;
 int h=0;
 int not_trouve=0;
while(!not_trouve)
{
MG_FACE* face1Ref=mggeo1->get_mg_faceid(sim_double.get(p));
MG_SURFACE* surf1Ref=face1Ref->get_surface();
OT_VECTEUR_4DD G1=surf1Ref->get_vectorisation().calcule_barycentre(T1);
G1= surf1Ref->get_vectorisation().get_nouveau_pt(T1,G1);

int idRef1=face1Ref->get_id();

int k=0;
  while(idRef1==sim_double.get(2*k+h))
   {
    MG_FACE* face2Ref=mggeo2->get_mg_faceid(sim_double.get(2*k+1));
    int idRef2=face2Ref->get_id();
    MG_SURFACE* surf2Ref=face2Ref->get_surface();
    OT_VECTEUR_4DD G2=surf2Ref->get_vectorisation().calcule_barycentre(T2);
   //  if (G1==G2)
     if (surfaces_sont_elles_identiques(face1Ref,face2Ref))
       {
           face_ref1=idRef1;
           face_ref2=idRef2;
           not_trouve=1;
           break;
       }
       k++;
       p=p+2;
   }
   h=p;
}
}


void VCT_COMPARAISON::verifier_le_repere(OT_TENSEUR& rep1,OT_TENSEUR& rep2,vector<double2>& inert1,vector<double2>& inert2)
 {
 TPL_LISTE_ENTITE<int> lst;
   for(int i=0;i<4;i++)
      {
       double2 val1=inert1[i];
         for(int j=0;j<4;j++)
            {
            if(!lst.est_dans_la_liste(j+4))
              {
               double2 val2=inert2[j];
               if(val1==val2)
                 {
                 lst.ajouter(i);
                 lst.ajouter(j+4);
                 break;
                 }
              }
            }
      }


 }


int VCT_COMPARAISON::comparer_aretes_faces(MG_FACE* f_ref1,MG_FACE* f_ref2,MG_FACE* face1,MG_FACE* face2,TPL_LISTE_ENTITE<int>& aretes_ident,TPL_LISTE_ENTITE<int>& aretes_sim)
{


         int nb_boucle1=face1->get_nb_mg_boucle();
         int nb_boucle2=face2->get_nb_mg_boucle();
         TPL_LISTE_ENTITE<int> lst1_artes_delamemecourbe;
         TPL_LISTE_ENTITE<int> lst2_artes_delamemecourbe;
         TPL_LISTE_ENTITE<int> arte1_trouvee;
         TPL_LISTE_ENTITE<int> arte2_trouvee;
         OT_VECTEUR_4DD VZER(0.,0.,0.,0.);
//-----------------------------------------------------------------------------
         OT_VECTEUR_4DD Dv1,Dv2,G1,gf1,gf2,G2;
         OT_TENSEUR V1(4),V2(4);

         //f_ref1->get_vectorisation().calcule_axes_dinertie(T1,Dv1,V1);
         //G1=f_ref1->get_vectorisation().calcule_barycentre(T1);

         MG_SURFACE* surf1_ref=f_ref1->get_surface();
         G1=surf1_ref->get_vectorisation().calcule_barycentre(T1);
         G1=surf1_ref->get_vectorisation().get_nouveau_pt(T1,G1);
                 //   for(int r=0;r<4;r++) {
                 //     for(int s=0;s<4;s++) {
                 //        gf1[r]= gf1[r]+V1(s,r)*G1[s];
                 //       }
                 //    }

         //f_ref2->get_vectorisation().calcule_axes_dinertie(T2,Dv2,V2);
         //G2=f_ref2->get_vectorisation().calcule_barycentre(T2);
         MG_SURFACE* surf2_ref= f_ref2->get_surface();
         G2=surf1_ref->get_vectorisation().calcule_barycentre(T2);

                   // for(int r=0;r<4;r++) {
                   //   for(int s=0;s<4;s++) {
                   //      gf2[r]= gf2[r]+V2(s,r)*G2[s];
                   //     }
                   //  }

//---------------------------------------------------------------------------
   /*         for(int j1=0;j1<nb_boucle1;j1++)
               {
                 MG_BOUCLE* Boucle1 = face1->get_mg_boucle(j1);
                 int nbarete1 = Boucle1->get_nb_mg_coarete();
                     for (int w1 =0; w1<nbarete1;w1++)
                        {
                           double xyz1[3];
                           double xyz2[3];
                           vector<double2> viarte1,vicrbe1;
                           OT_TENSEUR tns_arete1(4),tns_courbe1(4);
                           OT_TENSEUR tm1_art(4),tm1_crb(4);
                           MG_COARETE* coArete1 = Boucle1->get_mg_coarete(w1);
                           MG_ARETE* arete1 = coArete1->get_arete();
                           int id_art1=arete1->get_id();
                           MG_COURBE* courbe1=arete1->get_courbe();
                           int nb_top1_pts= arete1->get_vectorisation().get_nb_points();
                           int nb_geo1_pts= courbe1->get_vectorisation().get_nb_points();
                           tm1_art=arete1->get_vectorisation().calcule_tenseur_metrique();
                           tm1_crb=courbe1->get_vectorisation().calcule_tenseur_metrique();
                           tns_arete1=arete1->get_vectorisation().calcule_tenseur_inertie_base_locale(T1);
                           tns_courbe1=courbe1->get_vectorisation().calcule_tenseur_inertie_base_locale(T1);

                            for(int r=0;r<4;r++)
                               {
                                   viarte1.insert( viarte1.end(), tns_arete1(r,r));
                                   vicrbe1.insert( vicrbe1.end(), tns_courbe1(r,r));
                               }
                           for(int j2=0;j2<nb_boucle2;j2++)
                                  {
                                       MG_BOUCLE* Boucle2 = face2->get_mg_boucle(j2);
                                       int nbarete2 = Boucle2->get_nb_mg_coarete();
                                                for (int w2 =0; w2<nbarete2;w2++)
                                                        {
                                                                double xyz1[3];
                                                                double xyz2[3];
                                                                vector<double2> viarte2,vicrbe2;
                                                                OT_TENSEUR tns_arete2(4),tns_courbe2(4);
                                                                OT_TENSEUR tm2_art(4),tm2_crb(4);
                                                                MG_COARETE* coArete2 = Boucle2->get_mg_coarete(w2);
                                                                MG_ARETE* arete2 = coArete2->get_arete();
                                                                int id_art2=arete2->get_id();
                                                                MG_COURBE* courbe2=arete2->get_courbe();
                                                                int nb_top2_pts= arete2->get_vectorisation().get_nb_points();
                                                                int nb_geo2_pts= courbe2->get_vectorisation().get_nb_points();
                                                                tm2_art=arete2->get_vectorisation().calcule_tenseur_metrique();
                                                                tm2_crb=courbe2->get_vectorisation().calcule_tenseur_metrique();
                                                                tns_arete2=arete2->get_vectorisation().calcule_tenseur_inertie_base_locale(T2);
                                                                tns_courbe2=courbe2->get_vectorisation().calcule_tenseur_inertie_base_locale(T2);

                                                                        for(int r=0;r<4;r++)
                                                                            {
                                                                                viarte2.insert( viarte2.end(), tns_arete1(r,r));
                                                                                vicrbe2.insert( vicrbe2.end(), tns_courbe1(r,r));
                                                                            }
                                                                                if((nb_geo1_pts==nb_geo2_pts)&&(nb_top1_pts==nb_top2_pts))
                                                                                         {
                                                                                                if(tm1_art.est_til_equivalent(tm2_art))
                                                                                                        {
                                                                                                                if(tm1_crb.est_til_equivalent(tm2_crb))
                                                                                                                        {
                                                                                                                            if(tns_courbe1==tns_courbe2)
                                                                                                                                {
                                                                                                                                lst1_artes_delamemecourbe.ajouter(id_art1);
                                                                                                                                lst2_artes_delamemecourbe.ajouter(id_art2);
                                                                                                                                }
                                                                                                                        }
                                                                                                        }


                                                                                           }


                                                               }
                        }
               }
}

vector<OT_VECTEUR_4DD> lst1_barycentre;
vector<OT_VECTEUR_4DD> lst2_barycentre;
TPL_LISTE_ENTITE<int> lst1,lst2;
for(int i1=0;i1<lst2_artes_delamemecourbe.get_nb();i1++)
  {
    int id21=lst2_artes_delamemecourbe.get(i1);
    MG_ARETE* art2=mggeo2->get_mg_areteid(id21);
    OT_VECTEUR_4DD G2=art2->get_vectorisation().calcule_barycentre(T2);
    if(!lst2.est_dans_la_liste(id21))
     {
    lst2_barycentre.insert(lst2_barycentre.end(),G2);
        for(int i2=0;i2<lst2_artes_delamemecourbe.get_nb();i2++)
           {
            int id22=lst2_artes_delamemecourbe.get(i2);
            int id1=lst1_artes_delamemecourbe.get(i2);
            if(!lst1.est_dans_la_liste(id1))
             {
                 if(id21==id22)
                   {
                   MG_ARETE* art1=mggeo1->get_mg_areteid(id1);
                   OT_VECTEUR_4DD G1=art1->get_vectorisation().calcule_barycentre(T1);
                   G1=art1->get_vectorisation().get_nouveau_pt(T1,G1);
                   lst1_barycentre.insert(lst1_barycentre.end(),G1);
                   lst1.ajouter(id1);
                   }
              }
           }
      lst2.ajouter(id21);
     }
  }

  
vector<double2> NOR1,NOR2;
vector<OT_VECTEUR_4DD> vi,vj;
OT_VECTEUR_4DD g1=lst1_barycentre[0];
for(int k=0;k<lst1_barycentre.size();k++)
  {
    OT_VECTEUR_4DD gigj_1=lst1_barycentre[k]-g1;

    double2 nor1=gigj_1.norme();
    OT_VECTEUR_4DD gigj_2=lst1_barycentre[k]-g1;
    double2 nor2=gigj_2.norme();
  }
for(int k=0;k<lst1_barycentre.size();k++)
  {
    OT_VECTEUR_4DD gigj_1=lst1_barycentre[k]-g1;
    vi.insert(vi.end(),gigj_1);
    double2 nor1=gigj_1.norme();
    NOR1.insert(NOR1.end(),nor1);
    OT_VECTEUR_4DD gigj_2=lst1_barycentre[k]-g1;
    vj.insert(vj.end(),gigj_2);
    double2 nor2=gigj_2.norme();
    NOR2.insert(NOR2.end(),nor2);
  }

double2 min1=NOR1[0];
double2 min2=NOR2[0];
int *t1=new int[lst1.get_nb()];
int *t2=new int[lst2.get_nb()];

for(int r=0;r<lst1.get_nb();r++)
 {
   t1[r]=lst1.get(r);
   t2[r]=lst2.get(r);
   for(int s=0;s<lst1.get_nb();s++)
     {
      if (NOR1[s]<NOR1[r])
         {
          double2 tmp1=NOR1[r];
          NOR1[r]=NOR1[s];
          NOR1[s]=tmp1;
          t1[r]=t1[s];
         }

      if (NOR2[s]<NOR2[r])
        {
         double2 tmp2=NOR2[r];
         NOR2[r]=NOR2[s];
         NOR2[s]=tmp2;
         t2[r]=t2[s];         
        }
     }
 }    */
//---------------------------------------------------------------------------
            int nb_aretes=0;
            for(int j1=0;j1<nb_boucle1;j1++)
               {
                MG_BOUCLE* Boucle1 = face1->get_mg_boucle(j1);
                int nbarete1 = Boucle1->get_nb_mg_coarete();
                nb_aretes+=nbarete1;
                for (int w1 =0; w1<nbarete1;w1++)
                        {
                       double xyz1[3];
                       double xyz2[3];
                       OT_TENSEUR tns_arete1(4),tns_courbe1(4);
                       OT_TENSEUR tm1_art(4),tm1_crb(4);
                       MG_COARETE* coArete1 = Boucle1->get_mg_coarete(w1);
                       MG_ARETE* arete1 = coArete1->get_arete();
                       int id_art1=arete1->get_id();

                       MG_COURBE* courbe1=arete1->get_courbe();

                       int nb_top1_pts= arete1->get_vectorisation().get_nb_points();
                       int nb_geo1_pts= courbe1->get_vectorisation().get_nb_points();

                       tm1_art=arete1->get_vectorisation().calcule_tenseur_metrique();
                       tm1_crb=courbe1->get_vectorisation().calcule_tenseur_metrique();

                       MG_COSOMMET* csomt1_art1= arete1->get_cosommet1();
                       MG_COSOMMET* csomt2_art1= arete1->get_cosommet2();
                       MG_SOMMET* som1_art1= csomt1_art1->get_sommet();
                       MG_SOMMET* som2_art1= csomt2_art1->get_sommet();
                       MG_POINT* pt1=som1_art1->get_point();
                       MG_POINT* pt2=som2_art1->get_point();
                       pt1->evaluer(xyz1);
                       OT_VECTEUR_4DD PT11(xyz1[0],xyz1[1],xyz1[2],0);
                       pt2->evaluer(xyz2);
                       OT_VECTEUR_4DD PT12(xyz2[0],xyz2[1],xyz2[2],0);
                       //----------------------------------------------------------------------
                                 OT_VECTEUR_4DD B1,g1;
                                 B1=courbe1->get_vectorisation().calcule_barycentre(T1);
                                 OT_VECTEUR_4DD G1S1=B1-PT11;

                                 B1=courbe1->get_vectorisation().get_nouveau_pt(T1,B1);
                                 G1S1=courbe1->get_vectorisation().get_nouveau_pt(T1,G1S1);
                                  // for(int r=0;r<4;r++) {
                                  //   for(int s=0;s<4;s++)
                                  //     g1[r]= g1[r]+V1(s,r)*B1[s];
                                  //   }
                       //----------------------------------------------------------------------

                       tns_arete1=arete1->get_vectorisation().calcule_tenseur_inertie_base_locale(T1);
                       tns_courbe1=courbe1->get_vectorisation().calcule_tenseur_inertie_base_locale(T1);
                       vector<double2> viarte1,vicrbe1;
                       for(int r=0;r<4;r++)
                        {
                        viarte1.insert( viarte1.end(), tns_arete1(r,r));
                        vicrbe1.insert( vicrbe1.end(), tns_courbe1(r,r));
                        }
                        int compt_aretes_modif=0;
                                   for(int j2=0;j2<nb_boucle2;j2++)
                                      {
                                       if(arte1_trouvee.est_dans_la_liste(id_art1)) break;
                                       MG_BOUCLE* Boucle2 = face2->get_mg_boucle(j2);
                                       int nbarete2 = Boucle2->get_nb_mg_coarete();
                                       for (int w2 =0; w2<nbarete2;w2++)
                                           {
                                            if(arte1_trouvee.est_dans_la_liste(id_art1)) break;
                                            OT_TENSEUR tns_arete2(4),tns_courbe2(4);
                                            OT_TENSEUR tm2_art(4),tm2_crb(4);
                                            MG_COARETE* coArete2 = Boucle2->get_mg_coarete(w2);
                                            MG_ARETE* arete2 = coArete2->get_arete();
                                            MG_COURBE* courbe2=arete2->get_courbe();
                                            int id_art2=arete2->get_id();
                                            MG_COSOMMET* csomt1_art2= arete2->get_cosommet1();
                                            MG_COSOMMET* csomt2_art2= arete2->get_cosommet2();
                                            MG_SOMMET* som1_art2= csomt1_art2->get_sommet();
                                            MG_SOMMET* som2_art2= csomt2_art2->get_sommet();
                                            MG_POINT* pt2=som1_art2->get_point();
                                            pt2->evaluer(xyz1);
                                            OT_VECTEUR_4DD PT21(xyz1[0],xyz1[1],xyz1[2],0);
                                            MG_POINT* pt3=som2_art2->get_point();
                                            pt3->evaluer(xyz2);
                                            OT_VECTEUR_4DD PT22(xyz2[0],xyz2[1],xyz2[2],0);
                                            //----------------------------------------------------------------------
                                            OT_VECTEUR_4DD B2,g2;
                                            B2=courbe2->get_vectorisation().calcule_barycentre(T2);
                                            OT_VECTEUR_4DD G2S2=B2-PT21;
                                            OT_VECTEUR_4DD G2S3=B2-PT22;
                                            OT_VECTEUR_4DD B1B2=B2-B1;
                                            OT_VECTEUR_4DD D1= G1S1^G2S2;
                                            OT_VECTEUR_4DD D2= G1S1^G2S3;
                                           // OT_VECTEUR_4DD D3= B1B2^G2S3;
                                           // for(int r=0;r<4;r++) {
                                           // for(int s=0;s<4;s++)
                                           // g2[r]= g2[r]+V2(s,r)*B2[s];
                                           // }
                                            //----------------------------------------------------------------------                                            MG_COURBE* courbe2=arete2->get_courbe();

                                            int nb_top2_pts= arete2->get_vectorisation().get_nb_points();
                                            int nb_geo2_pts= courbe2->get_vectorisation().get_nb_points();

                                            tm2_art=arete2->get_vectorisation().calcule_tenseur_metrique();
                                            tm2_crb=courbe2->get_vectorisation().calcule_tenseur_metrique();

                                            tns_arete2=arete2->get_vectorisation().calcule_tenseur_inertie_base_locale(T2);
                                            tns_courbe2=courbe2->get_vectorisation().calcule_tenseur_inertie_base_locale(T2);

                                                  vector<double2> viarte2,vicrbe2;
                                                  for(int r=0;r<4;r++)
                                                        {
                                                        viarte2.insert( viarte2.end(), tns_arete2(r,r));
                                                        vicrbe2.insert( vicrbe2.end(), tns_courbe2(r,r));
                                                        }

                                                        if(nb_geo1_pts==nb_geo2_pts&&nb_top1_pts==nb_top2_pts)
                                                          {
                                                           if(tm1_art.est_til_equivalent(tm2_art))
                                                            {
                                                             if(tm1_crb.est_til_equivalent(tm2_crb))
                                                              {
                                                             vector<unsigned int> indx1,indx2;
                                                             int identique=-1;
                                                             //if(tns_arete1==tns_arete2)//.listes_equivalentes(viarte1,viarte2,indx1))
                                                               //{
                                                               if(tns_courbe1==tns_courbe2)//tns_arete1.listes_equivalentes(vicrbe1,vicrbe2,indx2))
                                                                {
                                                                  OT_VECTEUR_4DD v1=B1-G1;
                                                                  OT_VECTEUR_4DD v2=B2-G2;
                                                                  //OT_VECTEUR_4DD v1=gf1-g1;
                                                                  //OT_VECTEUR_4DD v2=gf2-g2;
                                                                     //if(v1==v2||((D1==VZER||D2==VZER)))
                                                                      if(courbes_sont_elles_identiques(arete1,arete2))
                                                                         {
                                                                           if(!arte2_trouvee.est_dans_la_liste(id_art2))
                                                                            {
                                                                              aretes_ident.ajouter(j1) ;
                                                                              aretes_ident.ajouter(id_art1) ;
                                                                              aretes_ident.ajouter(j2) ;
                                                                              aretes_ident.ajouter(id_art2) ;
                                                                              arte1_trouvee.ajouter(id_art1);
                                                                              arte2_trouvee.ajouter(id_art2);
                                                                              identique=1;
                                                                            }


                                                                         }

                                                                  }
                                                                // }
                                                              if(identique>0) break;
                                                              if(identique<0)
                                                               {
                                                                aretes_sim.ajouter(j1) ;
                                                                aretes_sim.ajouter(id_art1) ;
                                                                aretes_sim.ajouter(j2) ;
                                                                aretes_sim.ajouter(id_art2) ;
                                                                identique=-1;
                                                               }
                                                              }
                                                            }
                                                } // aretes2

                                           }  //boucle2

                                      //  }//condition 1 //aretes_identiques
                                }

                         }
                }

if(nb_aretes==aretes_ident.get_nb()/2) return 1;
else return 0;

}

void VCT_COMPARAISON::identifier_aretes_face_modifiee(MG_FACE* face1,MG_FACE* face2,TPL_LISTE_ENTITE<int>& aretes_identiques,
TPL_LISTE_ENTITE<int>&aretes_simil,TPL_LISTE_ENTITE<int>&lst_corrsp_sommets,TPL_LISTE_ENTITE<int>& aret1_conservees,
TPL_LISTE_ENTITE<int>& aret1_disparues,TPL_LISTE_ENTITE<int>& aret2_conservees ,TPL_LISTE_ENTITE<int>& aret2_nouvelles ,
TPL_LISTE_ENTITE<int>& aret_partielles)
{

int nb_boucle1=face1->get_nb_mg_boucle();
int nb_boucle2=face2->get_nb_mg_boucle();


int cmpt_arete=0;

TPL_LISTE_ENTITE<int> boucle_face1;
TPL_LISTE_ENTITE<int> boucle_face2;

TPL_LISTE_ENTITE<int> aretes_ident_face1;
TPL_LISTE_ENTITE<int> aretes_ident_face2;
TPL_LISTE_ENTITE<int> aretes_face1;
TPL_LISTE_ENTITE<int> aretes_face2;
TPL_LISTE_ENTITE<int> aretes_dif_face2;
TPL_LISTE_ENTITE<int> aretes_sim_face1;
TPL_LISTE_ENTITE<int> aretes_sim_face2;
TPL_LISTE_ENTITE<int> lst_sommet1;
TPL_LISTE_ENTITE<int> lst_sommet2;

for(int b=0;b<lst_corrsp_sommets.get_nb()/2;b++)
 {
  lst_sommet1.ajouter( lst_corrsp_sommets.get(2*b));
  lst_sommet2.ajouter( lst_corrsp_sommets.get(2*b+1));
 }

for(int b=0;b<aretes_identiques.get_nb()/4;b++)
 {
 int b1=  aretes_identiques.get(4*b)  ;
 int b2=  aretes_identiques.get(4*b+2) ;
 int art1= aretes_identiques.get(4*b+1);
 int art2= aretes_identiques.get(4*b+3);
  boucle_face1.ajouter( aretes_identiques.get(4*b));
  boucle_face2.ajouter( aretes_identiques.get(4*b+2));
  aretes_ident_face1.ajouter(aretes_identiques.get(4*b+1));
  aretes_ident_face2.ajouter(aretes_identiques.get(4*b+3));
  aret1_conservees.ajouter(art1);
  aret2_conservees.ajouter(art2);

 }


 for(int j1=0;j1<nb_boucle1;j1++)
    {
       MG_BOUCLE* Boucle1 = face1->get_mg_boucle(j1);
       int nbarete1 = Boucle1->get_nb_mg_coarete();

            for (int w1=0; w1<nbarete1;w1++)
                {
                    MG_COARETE* coArete1 = Boucle1->get_mg_coarete(w1);
                    MG_ARETE* arete1 = coArete1->get_arete();
                    int id_art1=arete1->get_id();
                          if(!aretes_ident_face1.est_dans_la_liste(id_art1))
                               {
                                aret1_disparues.ajouter(id_art1);
                               }
                 }
     }

 for(int j2=0;j2<nb_boucle2;j2++)
    {
       MG_BOUCLE* Boucle2 = face2->get_mg_boucle(j2);
       int nbarete2 = Boucle2->get_nb_mg_coarete();
            for (int w2=0; w2<nbarete2;w2++)
                {
                    MG_COARETE* coArete2 = Boucle2->get_mg_coarete(w2);
                    MG_ARETE* arete2 = coArete2->get_arete();
                    int id_art2=arete2->get_id();
                          if(!aretes_ident_face2.est_dans_la_liste(id_art2))
                               {
                                aret2_nouvelles.ajouter(id_art2);
                               }

                 }
    }
 /*
for(int b=0;b<aretes_simil.get_nb()/4;b++)
 {
  aretes_sim_face1.ajouter(aretes_simil.get(4*b+1));
  aretes_sim_face2.ajouter(aretes_simil.get(4*b+3));
 }

MG_FACE* Face_ref1=mggeo1->get_mg_faceid(face_ref1) ;
MG_FACE* Face_ref2=mggeo2->get_mg_faceid(face_ref2) ;

for(int j1=0;j1<nb_boucle1;j1++)
{
 MG_BOUCLE* Boucle1 = face1->get_mg_boucle(j1);
 int nbarete1 = Boucle1->get_nb_mg_coarete();
 TPL_LISTE_ENTITE<int> lst_aret1_modif;
 TPL_LISTE_ENTITE<int> lst_aret2_modif;
 TPL_LISTE_ENTITE<int> lst_art1_partiel;
 TPL_LISTE_ENTITE<int> lst_art2_partiel;
 int compt1=0;
 int boucle;
 int start_boucle,end_boucle;
 int cmpt=0;
 TPL_LISTE_ENTITE<int> arete_boucle1;
 TPL_LISTE_ENTITE<int> arete_boucle2;

 if(boucle_face1.est_dans_la_liste(j1))
  {
    for(int k=0;k<boucle_face1.get_nb();k++)
     {
      if (j1==boucle_face1.get(k))
       {
       int art1=aretes_ident_face1.get(k);
       int art2= aretes_ident_face2.get(k);
        arete_boucle1.ajouter(aretes_ident_face1.get(k));
        arete_boucle2.ajouter(aretes_ident_face2.get(k));
        boucle=boucle_face2.get(k);
       }
     }
  }

     for (int w1=0; w1<nbarete1;w1++)
         {

        MG_COARETE* coArete1 = Boucle1->get_mg_coarete(w1);
        MG_ARETE* arete1 = coArete1->get_arete();
        int id_art=arete1->get_id();
        int trouv=-1;
        for (int w1=0; w1<arete_boucle1.get_nb();w1++)
         {
          int id_art1=arete_boucle1.get(w1);
          int id_art2=arete_boucle2.get(w1);

          if(id_art1==id_art)
            {
            aret1_conservees.ajouter(id_art1);
            aret2_conservees.ajouter(id_art2);
            trouv=1;
            break;
            }
          }
         if(trouv<0)
            {
            //if(!aretes_sim_face1.est_dans_la_liste(id_art1))
            aret1_disparues.ajouter(id_art);
            //lst_aret1_modif.ajouter(id_art1);
            }
 
        }

// for(int j2=0;j2<nb_boucle2;j2++)
// {
//  MG_BOUCLE* Boucle2 = face2->get_mg_boucle(j2);
   MG_BOUCLE* Boucle2 = face2->get_mg_boucle(boucle);
  int nbarete2 = Boucle2->get_nb_mg_coarete();

  for (int w2=0; w2<nbarete2;w2++)
     {
         MG_COARETE* coArete2 = Boucle2->get_mg_coarete(w2);
         MG_ARETE* arete2 = coArete2->get_arete();
         int id_art2=arete2->get_id();
           if(!arete_boucle2.est_dans_la_liste(id_art2))
            {
            aret2_nouvelles.ajouter(id_art2);
            //lst_aret2_modif.ajouter(id_art2);
            //for(int is=0;is<aretes_sim_face2.get_nb();is++)
             //{
             //if(aretes_sim_face2.get(is)==id_art2)
               // {
               // aret2_partielles.ajouter(id_art2);
               // }
           //  }

            }
          // else

          //  aret2_conservees.ajouter(id_art2);
       }

           //verifier parmi les deux listes des aretes modifiees
           //celles qui sont nouvelles ou partiellements modifees
            /*
           for(int m1=0;m1<lst_aret1_modif.get_nb();m1++)
            {
             int id_art1=lst_aret1_modif.get(m1);
             MG_ARETE* art1=mggeo1->get_mg_areteid(id_art1);

             OT_TENSEUR tm1_art(4),tm1_crb(4);
             MG_COURBE* courbe1=art1->get_courbe();
             tm1_art=art1->get_vectorisation().calcule_tenseur_metrique();
             tm1_crb=courbe1->get_vectorisation().calcule_tenseur_metrique();

            
             MG_COSOMMET* csomt1_art1= art1->get_cosommet1();
             MG_COSOMMET* csomt2_art1= art1->get_cosommet2();
             MG_SOMMET* som1_art1= csomt1_art1->get_sommet();
             MG_SOMMET* som2_art1= csomt2_art1->get_sommet();
             int id_som11= som1_art1->get_id();
             int id_som21= som2_art1->get_id();
             int s11_ou_s21;
             if(lst_sommet1.est_dans_la_liste(id_som11)) s11_ou_s21=1;
             if(lst_sommet1.est_dans_la_liste(id_som21)) s11_ou_s21=2;

             if(lst_sommet1.est_dans_la_liste(id_som11)||lst_sommet1.est_dans_la_liste(id_som21))
             {
               for(int m2=0;m2<lst_aret2_modif.get_nb();m2++)
                 {
                        int id_art2=lst_aret2_modif.get(m2);
                        MG_ARETE* art2=mggeo2->get_mg_areteid(id_art2);
                        OT_TENSEUR tm2_art(4),tm2_crb(4);
                        MG_COURBE* courbe2=art2->get_courbe();
                        tm2_art=art1->get_vectorisation().calcule_tenseur_metrique();
                        tm2_crb=courbe2->get_vectorisation().calcule_tenseur_metrique();

                        MG_COSOMMET* csomt1_art2= art2->get_cosommet1();
                        MG_COSOMMET* csomt2_art2= art2->get_cosommet2();
                        MG_SOMMET* som1_art2= csomt1_art2->get_sommet();
                        MG_SOMMET* som2_art2= csomt2_art2->get_sommet();
                        int id_som12= som1_art2->get_id();
                        int id_som22= som2_art2->get_id();
                        int s12_ou_s22;
                        if(lst_sommet2.est_dans_la_liste(id_som12)) s12_ou_s22=1;
                        if(lst_sommet2.est_dans_la_liste(id_som22)) s12_ou_s22=2;

                        //if(lst_sommet2.est_dans_la_liste(id_som12)||lst_sommet2.est_dans_la_liste(id_som22))
                              //  {
                                if(tm1_art.est_til_equivalent(tm2_art)&&tm1_crb.est_til_equivalent(tm2_crb))
                                        {
                                        aret_partielles.ajouter(id_art1);
                                        aret_partielles.ajouter(id_art2);
                                        lst_art1_partiel.ajouter(id_art1);
                                        lst_art2_partiel.ajouter(id_art2);
                                        if (s11_ou_s21==1&&s12_ou_s22==1)
                                        {
                                        aret_partielles.ajouter(id_som11);
                                        }
                                        if (s11_ou_s21==2&&s12_ou_s22==1)
                                        {
                                        aret_partielles.ajouter(id_som21);
                                        }
                                        if (s12_ou_s22==1&&s12_ou_s22==2)
                                        {
                                        aret_partielles.ajouter(id_som12);
                                        }
                                        if (s12_ou_s22==2&&s12_ou_s22==2)
                                        {
                                        aret_partielles.ajouter(id_som22);
                                        }

                                        }
                             //   }

                   }
                } 
            }  // for m1=
             

          for(int m1=0;m1<lst_aret1_modif.get_nb();m1++)
             {
             int id_art1=lst_aret1_modif.get(m1);
              if( !lst_art1_partiel.est_dans_la_liste(id_art1))
              aret1_disparues.ajouter(id_art1);
             }
           for(int m2=0;m2<lst_aret1_modif.get_nb();m2++)
             {
             int id_art2=lst_aret2_modif.get(m2);
              if( !lst_art2_partiel.est_dans_la_liste(id_art2))
              aret2_nouvelles.ajouter(id_art2);
             } /

} //boucle_face1


 for(int j2=0;j2<nb_boucle2;j2++)
 {
  MG_BOUCLE* Boucle2 = face2->get_mg_boucle(j2);

  if (!boucle_face2.est_dans_la_liste(j2))
  {
    int nbarete2 = Boucle2->get_nb_mg_coarete();
    for (int w2=0; w2<nbarete2;w2++)
     {
         MG_COARETE* coArete2 = Boucle2->get_mg_coarete(w2);
         MG_ARETE* arete2 = coArete2->get_arete();
         int id_art2=arete2->get_id();
         aret2_nouvelles.ajouter(id_art2);

     }
   }
  }//boucle j2
    */


   }


void VCT_COMPARAISON::identifier_les_modifications_appliquees(VCT_COMPARAISON_RESULTAT& Results)
{

 TPL_LISTE_ENTITE<int> face1_conservees;
 TPL_LISTE_ENTITE<int> face2_conservees;
 TPL_LISTE_ENTITE<int> faces_nouvelles;

 TPL_LISTE_ENTITE<int> aret_ident;
 TPL_LISTE_ENTITE<int> aret_modif;
 int nb_face1=mggeo1->get_nb_mg_face();
 int nb_face2=mggeo2->get_nb_mg_face();
 TPL_LISTE_ENTITE<int> lst_face1,lst_face2,lst_facloc1,lst_facloc2,dif1,dif2;


   TPL_LISTE_ENTITE<int> faces1_partiellement_modf;
   TPL_LISTE_ENTITE<int> faces2_partiellement_modf;
   TPL_LISTE_ENTITE<int> Aret1_conservees;
   TPL_LISTE_ENTITE<int> Aret1_disparues;
   TPL_LISTE_ENTITE<int> Aret2_conservees ;
   TPL_LISTE_ENTITE<int> Aret2_nouvelles ;
   TPL_LISTE_ENTITE<int> Aret2_partielles ;
   TPL_LISTE_ENTITE<int> face1_disparues;
 for(int i=0;i<nb_face1;i++)
    {
         OT_VECTEUR_4DD g1,G1;
         MG_FACE* face1=mggeo1->get_mg_face(i);
         int id1=face1->get_id();
         lst_face1.ajouter(id1);
    }

 for(int i=0;i<nb_face2;i++)
    {
         OT_VECTEUR_4DD g1,G1;
         MG_FACE* face2=mggeo2->get_mg_face(i);
         int id2=face2->get_id();
         lst_face2.ajouter(id2);
    }


 MG_FACE* Face_ref1=mggeo1->get_mg_faceid(face_ref1) ;
 MG_FACE* Face_ref2=mggeo2->get_mg_faceid(face_ref2) ;
 int nb_faces_identique=identite.get_nb()/2;
 for(int i=0;i<nb_faces_identique;i++)
    {
         CORRESPONDANCE CORRESP;
         int face1_id=identite.get(2*i);
         int face2_id=identite.get(2*i+1);
         MG_FACE* Face1=mggeo1->get_mg_faceid(face1_id);
         MG_FACE* Face2=mggeo2->get_mg_faceid(face2_id);
         face1_conservees.ajouter(face1_id);
         face2_conservees.ajouter(face2_id);
         Results.ajouter_liste_topologie(ORIGINE_CONSERVEE,Face1);
         Results.ajouter_liste_topologie(MODIFIE_CONSERVEE,Face2);
         CORRESP.eleorigine=Face1;
         CORRESP.elemodifie=Face2;
         Results.ajouter_liste_topologie(CORRESP);

         //----------------------------------------
         TPL_LISTE_ENTITE<int> aretes_identiques;
         TPL_LISTE_ENTITE<int> aretes_similaires;

        //------------------------------------------
         this->comparer_aretes_faces(Face_ref1,Face_ref2,Face1,Face2,aretes_identiques,aretes_similaires);

         int nb_aretes_trouvees=aretes_identiques.get_nb()/4;

         if(nb_aretes_trouvees)
           {
            CORRESPONDANCE  corsp;
              for(int i1=0;i1<nb_aretes_trouvees;i1++)
                {
                int art1_id=aretes_identiques.get(4*i1+1);
                MG_ARETE*art1_cons=mggeo1->get_mg_areteid(art1_id);
                Results.ajouter_liste_topologie(ORIGINE_CONSERVEE,art1_cons);
                int art2_id=aretes_identiques.get(4*i1+3);
                MG_ARETE*art2_cons=mggeo2->get_mg_areteid(art2_id);
                Results.ajouter_liste_topologie(MODIFIE_CONSERVEE,art2_cons);

                corsp.eleorigine=art1_cons;
                corsp.elemodifie=art2_cons;
                Results.ajouter_liste_topologie(corsp);
                 }
           }


    }

    TPL_LISTE_ENTITE<int> lst_corrsp_sommets;
    this->identifier_les_sommets(Face_ref1,Face_ref2,lst_corrsp_sommets,Results);


    for(int t=0;t<lst_face1.get_nb();t++)
    {
     if(!face1_conservees.est_dans_la_liste(lst_face1.get(t)) )
     dif1.ajouter(lst_face1.get(t));
    }
    for(int it=0;it<lst_face2.get_nb();it++)
    {
     if(!face2_conservees.est_dans_la_liste(lst_face2.get(it)))
     dif2.ajouter(lst_face2.get(it));
    }


   for(int i=0;i<dif1.get_nb();i++)
    {
    int Num1=dif1.get(i);
    MG_FACE* face1=mggeo1->get_mg_faceid(Num1);
    MG_SURFACE* surf1=face1->get_surface();
    OT_VECTEUR_4DD G1=face1->get_vectorisation().calcule_barycentre(T1);
    G1=surf1->get_vectorisation().get_nouveau_pt(T1,G1);
    for(int j=0;j<dif2.get_nb();j++)
     {
      int Num2=dif2.get(j);
      TPL_LISTE_ENTITE<int> aretes_identiques;
      TPL_LISTE_ENTITE<int> aretes_similaires;
      TPL_LISTE_ENTITE<int> aretes_conservees;
      TPL_LISTE_ENTITE<int> nouvelles_aretes ;
      TPL_LISTE_ENTITE<int> aret1_conservees;
      TPL_LISTE_ENTITE<int> aret1_disparues;
      TPL_LISTE_ENTITE<int> aret2_conservees ;
      TPL_LISTE_ENTITE<int> aret2_nouvelles ;
      TPL_LISTE_ENTITE<int> aret2_partielles ;

      MG_FACE* face2=mggeo2->get_mg_faceid(Num2);
      MG_SURFACE* surf2=face2->get_surface();
      OT_VECTEUR_4DD G2=face2->get_vectorisation().calcule_barycentre(T2);
 //  if(!faces1_partiellement_modf.est_dans_la_liste(Num1))
 //    {

    if(surfaces_sont_elles_identiques(face1,face2)) //G1==G2
      {
           comparer_aretes_faces(Face_ref1,Face_ref2,face1,face2,aretes_identiques,aretes_similaires);
           int nb_aretes_trouvees=aretes_identiques.get_nb()/2;
           if(nb_aretes_trouvees)
           identifier_aretes_face_modifiee(face1,face2,aretes_identiques,aretes_similaires,lst_corrsp_sommets,aret1_conservees,aret1_disparues,aret2_conservees ,aret2_nouvelles ,aret2_partielles);
           int id_face2=face2->get_id();

      if(nb_aretes_trouvees)
        {
         //  if (!face2_conservees.est_dans_la_liste(Num2))
          //  {
           CORRESPONDANCE CORRESP_FACE;
           Results.ajouter_liste_topologie(ORIGINE_CONSERVEE,face1);
           Results.ajouter_liste_topologie(MODIFIE_CONSERVEE,face2);
           CORRESP_FACE.eleorigine=face1;
           CORRESP_FACE.elemodifie=face2;
           Results.ajouter_liste_topologie(CORRESP_FACE);
           face1_conservees.ajouter(Num1);
           face2_conservees.ajouter(Num2);

                for(int i1=0;i1<aret1_conservees.get_nb();i1++)
                      {
                        int art1_id=aret1_conservees.get(i1);
                        Aret1_conservees.ajouter(art1_id);
                        MG_ARETE*art1_cons=mggeo1->get_mg_areteid(art1_id);
                        Results.ajouter_liste_topologie(ORIGINE_CONSERVEE,art1_cons);
                        int art2_id= aret2_conservees.get(i1)  ;
                        Aret2_conservees.ajouter(art2_id);
                        MG_ARETE*art2_cons=mggeo2->get_mg_areteid(art2_id);
                        Results.ajouter_liste_topologie(MODIFIE_CONSERVEE,art2_cons);
                        CORRESPONDANCE CORRESP;
                        CORRESP.eleorigine=art1_cons;
                        CORRESP.elemodifie=art2_cons;
                        Results.ajouter_liste_topologie(CORRESP);
                      }

                                for(int i1=0;i1<aret1_disparues.get_nb();i1++)
                                        {
                                        int art_dsp=aret1_disparues.get(i1) ;
                                        Aret1_disparues.ajouter(art_dsp);
                                        //MG_ARETE*art_disp=mggeo1->get_mg_areteid(art_dsp);
                                        //Results.ajouter_liste_topologie(ORIGINE_DISPARUE,art_disp);
                                        }

                                for(int i1=0;i1<aret2_nouvelles.get_nb();i1++)
                                        {
                                        int art_nv= aret2_nouvelles.get(i1) ;
                                        Aret2_nouvelles.ajouter(art_nv);
                                        //MG_ARETE*art_app=mggeo2->get_mg_areteid(art_nv);
                                        //Results.ajouter_liste_topologie(MODIFIE_APPARUE,art_app);
                                        }
                                        //for(int i1=0;i1<aret2_partielles.get_nb()/2;i1++){
                                        // int art1_prt=aret2_partielles.get(2*i1);
                                        // int art2_prt=aret2_partielles.get(2*i1+1);

                                        //il faut metttre les points des sous artes avec leurs correspondances;

                                        //Results.ajouter_liste_topologie(MODIFIE_APPARUE,art_app);

                                        // Aret2_partielles.ajouter(art1_prt);
                                        // }
                                        faces1_partiellement_modf.ajouter(Num1);
                                        faces2_partiellement_modf.ajouter(Num2);
             //    }//verid
           }// if()nb_aretes_trouvees

        } //if (G1==G2)
    // }
  }
 }


  for(int i=0;i<Aret2_nouvelles.get_nb();i++)
      {
         int art_nouv=Aret2_nouvelles.get(i);
         if(! Aret2_conservees.est_dans_la_liste(Aret2_nouvelles.get(i)))
            {
               MG_ARETE*art_app=mggeo2->get_mg_areteid(art_nouv);
               Results.ajouter_liste_topologie(MODIFIE_APPARUE,art_app);
            }
       }

  for(int i=0;i<Aret1_disparues.get_nb();i++)
     {
         int art_nouv=Aret1_disparues.get(i);
         if(! Aret1_conservees.est_dans_la_liste(Aret1_disparues.get(i)))
            {
               MG_ARETE*art_disp=mggeo1->get_mg_areteid(art_nouv);
               Results.ajouter_liste_topologie(ORIGINE_DISPARUE,art_disp);
            }
      }

   
    for(int j=0;j<dif2.get_nb();j++)
     {
      if(!face2_conservees.est_dans_la_liste(dif2.get(j)))
       {
       int nouv_face=dif2.get(j);
       faces_nouvelles.ajouter(nouv_face);
         MG_FACE* Face_Nouvelle=mggeo2->get_mg_faceid(nouv_face);
         Results.ajouter_liste_topologie(MODIFIE_APPARUE,Face_Nouvelle);
         int nb_boucle2=Face_Nouvelle->get_nb_mg_boucle();

         for(int j=0;j<nb_boucle2;j++)
            {
             MG_BOUCLE* Boucle2 = Face_Nouvelle->get_mg_boucle(j);
             int nbarete2 = Boucle2->get_nb_mg_coarete();
             for(int w2=0;w2<nbarete2;w2++)
               {
               MG_COARETE* coArete2 = Boucle2->get_mg_coarete(w2);
               MG_ARETE* arete_nouvelle = coArete2->get_arete();
               Results.ajouter_liste_topologie(MODIFIE_APPARUE,arete_nouvelle);
               MG_COSOMMET* cosommt1= arete_nouvelle->get_cosommet1();
               MG_COSOMMET* cosommt2= arete_nouvelle->get_cosommet2();
               MG_SOMMET* nouveau_sommet1= cosommt1->get_sommet();
               MG_SOMMET* nouveau_sommet2= cosommt2->get_sommet();
               Results.ajouter_liste_topologie(MODIFIE_APPARUE,nouveau_sommet1);
               Results.ajouter_liste_topologie(MODIFIE_APPARUE,nouveau_sommet2);
               }
             }
          }
        }

 for(int i1=0;i1<nb_face1;i1++)
      {
        MG_FACE*face1=mggeo1->get_mg_face(i1);
        int face1_id=face1->get_id();
        if(!face1_conservees.est_dans_la_liste(face1_id))
         {
          Results.ajouter_liste_topologie(ORIGINE_DISPARUE,face1);
          int nb_boucle1=face1->get_nb_mg_boucle();
             for(int j1=0;j1<nb_boucle1;j1++)
               {
                 MG_BOUCLE* Boucle1 = face1->get_mg_boucle(j1);
                 int nbarete1 = Boucle1->get_nb_mg_coarete();
                 for (int w1 =0; w1<nbarete1;w1++)
                       {
                         MG_COARETE* coArete1 = Boucle1->get_mg_coarete(w1);
                         MG_ARETE* arete1 = coArete1->get_arete();
                         int id_art1=arete1->get_id();
                         Results.ajouter_liste_topologie(ORIGINE_DISPARUE,arete1);

                       }
               }
         }
       }

 for(int i=0;i<nb_face1;i++)
    {
        MG_FACE* face1=mggeo1->get_mg_face(i);
        MG_SURFACE* surf1=face1->get_surface();
        int id1=face1->get_id();
        if(!face1_conservees.est_dans_la_liste(id1))
          {
             OT_TENSEUR tns1_surf(4),tns2_surf(4);
             tns1_surf=surf1->get_vectorisation().calcule_tenseur_inertie_base_locale(T1);
             vector<double2> isurf1;
             for(int r=0;r<4;r++)
                  {
                     isurf1.insert( isurf1.end(), tns1_surf(r,r));
                  }
                          for(int j=0;j<nb_face2;j++)
                                {
                                         MG_FACE* face2=mggeo2->get_mg_face(j);
                                         MG_SURFACE* surf2=face2->get_surface();
                                         int id2=face2->get_id();
                                         CORRESPONDANCE CORRESP_FACE;
                                         OT_VECTEUR_4DD G1=surf1->get_vectorisation().calcule_barycentre(T1);
                                         OT_VECTEUR_4DD G2=surf2->get_vectorisation().calcule_barycentre(T2);
                                         G1=surf1->get_vectorisation().get_nouveau_pt(T1,G1);
                                         tns2_surf=surf2->get_vectorisation().calcule_tenseur_inertie_base_locale(T1);
                                         vector<double2> isurf2;
                                                for(int r=0;r<4;r++)
                                                    {
                                                      isurf2.insert( isurf2.end(), tns1_surf(r,r));
                                                    }
                                         vector<unsigned int> indx1;
                                                        if(tns1_surf.listes_equivalentes(isurf1,isurf2,indx1))
                                                                {
                                                                        if(G1==G2)
                                                                                {
                                                                                        Results.ajouter_liste_topologie(ORIGINE_CONSERVEE,face1);
                                                                                        Results.ajouter_liste_topologie(MODIFIE_CONSERVEE,face2);
                                                                                        CORRESP_FACE.eleorigine=face1;
                                                                                        CORRESP_FACE.elemodifie=face2;
                                                                                        Results.ajouter_liste_topologie(CORRESP_FACE);

                                                                                }
                                                                 }
                                   }
          }
     }

identite.vide();
for(int i=0;i<face1_conservees.get_nb();i++)
 {
  identite.ajouter( face1_conservees.get(i));
  identite.ajouter( face2_conservees.get(i));
 }
this->affecter_les_couleurs(1);

}

int VCT_COMPARAISON::surfaces_sont_elles_identiques(MG_FACE* face1,MG_FACE* face2)
 {
    MG_SURFACE* surf1=face1->get_surface();
    MG_SURFACE* surf2=face2->get_surface();
    vector<double2> isurf1,isurf2;
    vector<unsigned int> indx1;
    TPL_LISTE_ENTITE<double> parm1,parm2;
    OT_VECTEUR_4DD Dv1,Dv2,axe3;
    OT_VECTEUR_4DD VNUL(0.,0.,0.,0.);
    double2 ZER=0.;
    OT_TENSEUR tm1_surf(4),tm2_surf(4),tns1_surf(4),tns2_surf(4),V1(4),V2(4);
    OT_VECTEUR_4DD G1=surf1->get_vectorisation().calcule_barycentre(T1);
    G1=surf1->get_vectorisation().get_nouveau_pt(T1,G1);
    tns1_surf=surf1->get_vectorisation().calcule_tenseur_inertie_base_locale(T1);
    OT_VECTEUR_4DD G2=surf2->get_vectorisation().calcule_barycentre(T2);
    tns2_surf=surf2->get_vectorisation().calcule_tenseur_inertie_base_locale(T2);
    tm1_surf=surf1->get_vectorisation().calcule_tenseur_metrique();
    tm2_surf=surf2->get_vectorisation().calcule_tenseur_metrique();

    surf1->get_vectorisation().calcule_axes_dinertie(T1,Dv1,V1);
    surf2->get_vectorisation().calcule_axes_dinertie(T2,Dv2,V2);

    for(int r=0;r<4;r++)
     {
       isurf1.insert( isurf1.end(), tns1_surf(r,r));
       isurf2.insert( isurf2.end(), tns2_surf(r,r));
     }

    if(surf2->get_type_geometrique(parm2)==MGCo_PLAN)
     {
     axe3[0]= parm2.get(3);
     axe3[1]= parm2.get(4);
     axe3[2]= parm2.get(5);
     axe3[3]= 0;
     G1=face1->get_vectorisation().calcule_barycentre(T1);
     G2=face2->get_vectorisation().calcule_barycentre(T2);

     }
    if(surf2->get_type_geometrique(parm1)==MGCo_CYLINDRE||surf2->get_type_geometrique(parm2)==MGCo_CONE)
     {
     axe3[0]= parm2.get(3);
     axe3[1]= parm2.get(4);
     axe3[2]= parm2.get(5);
     axe3[3]= 0;
     }
   //axe3=surf1->get_vectorisation().get_nouveau_pt(T1,axe3);
   double2 d1=axe3[0]*G1[0]+axe3[1]*G1[1]+axe3[2]*G1[3];
   double2 d2=axe3[0]*G2[0]+axe3[1]*G2[1]+axe3[2]*G2[3];

    if(tm1_surf.est_til_equivalent(tm2_surf))
      {
        if (tns1_surf.listes_equivalentes(isurf1,isurf2,indx1))
          {
          OT_VECTEUR_4DD G1G2= G1-G2;
          double2 mm=G1G2*axe3;
            if(ZER==mm)
            {
            return 1;
            }
          }
      }
  return 0;
 }


int VCT_COMPARAISON::courbes_sont_elles_identiques(MG_ARETE* arete1,MG_ARETE* arete2)
 {
    MG_COURBE* courb1=arete1->get_courbe();
    MG_COURBE* courb2=arete2->get_courbe();
    vector<double2> icourb1,icourb2;
    vector<unsigned int> indx1;
    TPL_LISTE_ENTITE<double> parm1,parm2;
    OT_VECTEUR_4DD Dv1,Dv2,axe3;
    OT_VECTEUR_4DD VNUL(0.,0.,0.,0.);
    double2 ZER=0.;
    OT_TENSEUR tm1_surf(4),tm2_surf(4),tns1_surf(4),tns2_surf(4),V1(4),V2(4);
    OT_VECTEUR_4DD G1=courb1->get_vectorisation().calcule_barycentre(T1);
    G1=courb1->get_vectorisation().get_nouveau_pt(T1,G1);
    tns1_surf=courb1->get_vectorisation().calcule_tenseur_inertie_base_locale(T1);
    OT_VECTEUR_4DD G2=courb2->get_vectorisation().calcule_barycentre(T2);
    tns2_surf=courb2->get_vectorisation().calcule_tenseur_inertie_base_locale(T2);
    tm1_surf=courb1->get_vectorisation().calcule_tenseur_metrique();
    tm2_surf=courb2->get_vectorisation().calcule_tenseur_metrique();

    courb1->get_vectorisation().calcule_axes_dinertie(T1,Dv1,V1);
    courb2->get_vectorisation().calcule_axes_dinertie(T2,Dv2,V2);

    for(int r=0;r<4;r++)
     {
       icourb1.insert( icourb1.end(), tns1_surf(r,r));
       icourb2.insert( icourb2.end(), tns2_surf(r,r));
     }

    if(courb2->get_type_geometrique(parm2)==MGCo_LINE)
     {
     axe3[0]= parm2.get(3);
     axe3[1]= parm2.get(4);
     axe3[2]= parm2.get(5);
     axe3[3]= 0;
     G1=arete1->get_vectorisation().calcule_barycentre(T1);
     G2=arete2->get_vectorisation().calcule_barycentre(T2);

     }
    if(courb2->get_type_geometrique(parm1)==MGCo_CIRCLE||courb2->get_type_geometrique(parm2)==MGCo_ELLIPSE)
     {
     axe3[0]= parm2.get(3);
     axe3[1]= parm2.get(4);
     axe3[2]= parm2.get(5);
     axe3[3]= 0;
     }

    if(tm1_surf.est_til_equivalent(tm2_surf))
      {
        if (tns1_surf.listes_equivalentes(icourb1,icourb2,indx1))
          {
          OT_VECTEUR_4DD G1G2= G1-G2;
          OT_VECTEUR_4DD mm=G1G2^axe3;
            if(VNUL==mm)
            {
            return 1;
            }
          }
      }
  return 0;


 }


void VCT_COMPARAISON::identifier_les_sommets(MG_FACE* face1_ref,MG_FACE* face2_ref,TPL_LISTE_ENTITE<int>& lst_corrsp_sommets,VCT_COMPARAISON_RESULTAT& Results)
{

         OT_VECTEUR_4DD Dv1,Dv2,G1,gf1,gf2,G2;
         OT_TENSEUR V1(4),V2(4);
         TPL_LISTE_ENTITE<int> lst1_som_trouve;
         TPL_LISTE_ENTITE<int> lst2_som_trouve;
         face1_ref->get_vectorisation().calcule_axes_dinertie(T1,Dv1,V1);
         G1=face1_ref->get_vectorisation().calcule_barycentre(T1);

                    /*
                    for(int r=0;r<4;r++) {
                      for(int s=0;s<4;s++) {
                         gf1[r]= gf1[r]+V1(s,r)*G1[s];
                        }
                     }   */

         face2_ref->get_vectorisation().calcule_axes_dinertie(T2,Dv2,V2);
         G2=face2_ref->get_vectorisation().calcule_barycentre(T2);
                        /*
                    for(int r=0;r<4;r++) {
                      for(int s=0;s<4;s++) {
                         gf2[r]= gf2[r]+V2(s,r)*G2[s];
                        }
                     } */

  int nb_sommet1= mggeo1->get_nb_mg_sommet();
  int nb_sommet2= mggeo2->get_nb_mg_sommet();


  for(int i=0;i<nb_sommet1;i++)
   {
    double xyz1[3];
    OT_VECTEUR_4DD S1,s1, G1G1REF;
    MG_SOMMET *som1=mggeo1->get_mg_sommet(i);
    MG_POINT* pt1=som1->get_point();
    int som1_id=som1->get_id();
    pt1->evaluer(xyz1);
    for(int t=0;t<3;t++)  s1[t]=xyz1[t];
    G1G1REF=s1-G1;
    G1G1REF=face1_ref->get_vectorisation().get_nouveau_pt(T1,G1G1REF);
                        /*
                   for(int r=0;r<4;r++) {
                      for(int s=0;s<4;s++) {
                         S1[r]= S1[r]+V1(s,r)*s1[s];
                        }
                     }    */


    for(int j=0;j<nb_sommet2;j++)
     {
      double xyz2[3];
      OT_VECTEUR_4DD S2,s2,G2G2REF;
      MG_SOMMET *som2=mggeo2->get_mg_sommet(j);
      MG_POINT* pt2=som2->get_point();
      int som2_id=som2->get_id();
      if( lst1_som_trouve.est_dans_la_liste(som1_id)) break;

      pt2->evaluer(xyz2);
      for(int t=0;t<3;t++)  s2[t]=xyz2[t];
      G2G2REF=s2-G2;
                         /*
                   for(int r=0;r<4;r++) {
                      for(int s=0;s<4;s++) {
                         S2[r]= S2[r]+V2(s,r)*s2[s];
                        }
                     }    */

    if (G1G1REF==G2G2REF)
       {
         Results.ajouter_liste_topologie(ORIGINE_CONSERVEE,som1);
         Results.ajouter_liste_topologie(MODIFIE_CONSERVEE,som2);
         CORRESPONDANCE CORRESP;
         CORRESP.eleorigine=som1;
         CORRESP.elemodifie=som2;
         Results.ajouter_liste_topologie(CORRESP);
         lst_corrsp_sommets.ajouter(som1_id);
         lst_corrsp_sommets.ajouter(som2_id);
         lst1_som_trouve.ajouter(som1_id);
         lst2_som_trouve.ajouter(som2_id);
      }

  }


  }


  for(int i=0;i<nb_sommet1;i++)
   {
      MG_SOMMET *som=mggeo1->get_mg_sommet(i);
      int som_id=som->get_id();
       if(! lst1_som_trouve.est_dans_la_liste(som_id))
         {

         Results.ajouter_liste_topologie(ORIGINE_DISPARUE,som);

         }

   }

  for(int i=0;i<nb_sommet2;i++)
   {
      MG_SOMMET *som=mggeo2->get_mg_sommet(i);
      int som_id=som->get_id();
       if(! lst2_som_trouve.est_dans_la_liste(som_id))
         {

         Results.ajouter_liste_topologie(MODIFIE_APPARUE,som);

         }

   }

}


void VCT_COMPARAISON::get_syteme_daxes_globale()
{

  OT_VECTEUR_4DD Dv1,Dv2,Dw,G1,G2,G1G2;
  OT_TENSEUR p(4),q(4),pT,qT;
  int nb_face1=mggeo1->get_nb_mg_face();
  int nb_face2=mggeo1->get_nb_mg_face();
  OT_VECTEUR_4DD VNul(0.,0.,0.,0.);
  double2 cof=-1;
  int plan=-1;
   for(int i=3;i<nb_face1;i++)
    {
       OT_TENSEUR  inertie_face1(4);
       vector<double2> iface1;
       MG_FACE* face1=mggeo1->get_mg_face(i);
       int id_face1=face1->get_id();
       face1->get_vectorisation().calcule_axes_dinertie(T1,Dv1,p);
       pT=p.transpose();
       G1=  face1->get_vectorisation().calcule_barycentre(T1);
       inertie_face1=face1->get_vectorisation().calcule_tenseur_inertie_base_locale(T1);
       vector<OT_VECTEUR_4DD>& list_points1=face1->get_vectorisation().get_points_controle();
       vector<OT_VECTEUR_4DD>& list_vecteurs1=face1->get_vectorisation().get_vecteurs();
       OT_VECTEUR_4DD Normal1(0.,0.,0.,0.),N1;
       OT_VECTEUR_4DD axe11,axe12,axe13;
        int cmpt=0;

        OT_VECTEUR_4DD v11= list_vecteurs1[0];
        int nb_vecteur1=list_vecteurs1.size();
        for(unsigned int pi=0;pi<nb_vecteur1-1;pi++)
           {

             OT_VECTEUR_4DD v2= list_vecteurs1[pi+1];
               if(pi==0)
                  Normal1=v11^v2;
               if (pi>0)
                  N1=v11^v2;
             OT_VECTEUR_4DD colineaire= Normal1^N1;
               if(colineaire==VNul)
                  {
                  cmpt++;
                  }
           }
         vector<OT_VECTEUR_4DD> axes1;
       if ( cmpt== list_vecteurs1.size()-1)
         {
          plan=1;
          axe11=list_vecteurs1[0];
          axe12=Normal1^axe11;
          axe13=Normal1;
          axes1.insert(axes1.end(),axe11);
          axes1.insert(axes1.end(),axe12);
          axes1.insert(axes1.end(),axe13);
         }

         VCT_OUTILS VOUTIL(4);
         OT_MATRICE_3D  sys_axes1=VOUTIL.get_system_axes(G1,axes1,list_points1) ;

       for(int r=0;r<4;r++)
          {
             iface1.insert( iface1.end(), inertie_face1(r,r));
          }

               for(int j=4;j<nb_face2;j++)
                  {
                        OT_TENSEUR  inertie_face2(4);
                        vector<double2> iface2;
                        MG_FACE* face2=mggeo2->get_mg_face(j);
                        int id_face2=face2->get_id();
                        face2->get_vectorisation().calcule_axes_dinertie(T2,Dv2,q);
                        G2=  face2->get_vectorisation().calcule_barycentre(T2);
                        qT=q.transpose();
                        inertie_face2=face2->get_vectorisation().calcule_tenseur_inertie_base_locale(T2);
                        vector<OT_VECTEUR_4DD>& list_points2=face2->get_vectorisation().get_points_controle();
                        vector<OT_VECTEUR_4DD>& list_vecteurs2=face2->get_vectorisation().get_vecteurs();
                        OT_VECTEUR_4DD Normal2(0.,0.,0.,0.),N1;
                        OT_VECTEUR_4DD axe21,axe22,axe23;
                        int cmpt=0;
                        OT_VECTEUR_4DD v21= list_vecteurs2[0];
                        int nb_vecteur2=list_vecteurs2.size();
                                for(unsigned int pj=0;pj<nb_vecteur2-1;pj++)
                                        {
                                              OT_VECTEUR_4DD v2= list_vecteurs2[pj+1];
                                              if(pj==0)
                                              Normal2=v21^v2;
                                              if (pj>0)
                                              N1=v21^v2;
                                              OT_VECTEUR_4DD colineaire= Normal2^N1;
                                              if(colineaire==VNul)
                                                 {
                                                   cmpt++;
                                                 }
                                        }
                        vector<OT_VECTEUR_4DD> axes2;
                        if ( cmpt== list_vecteurs2.size()-1)
                           {
                                 plan=1;
                                 axe21=list_vecteurs2[0];
                                 axe22=Normal2^axe21;
                                 axe23=Normal2;
                                 axes2.insert(axes2.end(),axe21);
                                 axes2.insert(axes2.end(),axe22);
                                 axes2.insert(axes2.end(),axe23);
                           }

                        VCT_OUTILS VOUTIL(4);
                        OT_MATRICE_3D  sys_axes2=VOUTIL.get_system_axes(G2,axes2,list_points2) ;

                        OT_MATRICE_3D T= sys_axes2*sys_axes1.transpose();


         /*
            for(int r=0;r<4;r++)
               {
                 iface2.insert( iface2.end(), inertie_face2(r,r));
               }
            vector<unsigned int> indx1,indx2;
            OT_TENSEUR T=q*pT;

            if(inertie_face2.listes_equivalentes(iface1,iface2,indx1))
               {

                 for(int ii=0;ii<list_points1.size();ii++)
                    {
                    OT_VECTEUR_4DD pt1= list_points1[ii];
                    OT_VECTEUR_4DD pt11;

                    for(int r=0;r<4;r++)
                        {
                        for(int s=0;s<4;s++)
                           pt11[r]=pt11[r]+T(r,s)*G1[s];
                        }

                        for(int jj=0;jj<list_points2.size();jj++)
                           {
                             OT_VECTEUR_4DD pt2= list_points2[jj];
                             OT_VECTEUR_4DD pt22;
                                for(int r=0;r<4;r++)
                                   {
                                     for(int s=0;s<4;s++)
                                     pt22[r]=pt22[r]+T(r,s)*G2[s];
                                   }
                                if(pt11==G2)
                                   {
                                  int g=0;
                                   }


                           }


                    }  


               }  */
                  

          }
    }


}


std::ostream& operator <<(std::ostream& os,VCT_COMPARAISON& vct_cmp)
 {
 vct_cmp.enregistrer(os) ;
 return os;
 }


void VCT_COMPARAISON::enregistrer(ostream& os)
 {
 os<<"COMPARAISON VECTORIELLE DE DEUX GEOMETRIES"<<endl;
 int nb_cl=2;
 int nb_lg=similarite.get_nb()/2;
   os<<"FACES_PREMIERE_GEOMETRIE : ";
    for(int j=0;j<nb_lg;j++)
    os<<setw(5)<<similarite.get(j*nb_cl+0);
    os<<endl;
   os<<"FACES_SECONDE_GEOMETRIE  : ";
    for(int j=0;j<nb_lg;j++)
      os<<setw(5)<<similarite.get(j*nb_cl+1);
    os<<endl;

//affecter_une_couleur();


 }


int VCT_COMPARAISON::modele_a_change_de_repere()
 {
  int nb_sommet1= mggeo1->get_nb_mg_sommet();
  int nb_sommet2= mggeo2->get_nb_mg_sommet();

  int trouve=0;
  int cmt=0;
  for(int i=0;i<nb_sommet1;i++)
   {
    double xyz1[3];
    OT_VECTEUR_4DD S1,s1;
    MG_SOMMET *som1=
    mggeo1->get_mg_sommet(i);
    MG_POINT* pt1=som1->get_point();
    int som1_id=som1->get_id();
    pt1->evaluer(xyz1);
    for(int t=0;t<3;t++)  s1[t]=xyz1[t];


    for(int j=0;j<nb_sommet2;j++)
     {
      double xyz2[3];
      OT_VECTEUR_4DD S2,s2;
      MG_SOMMET *som2=mggeo2->get_mg_sommet(j);
      MG_POINT* pt2=som2->get_point();
      int som2_id=som2->get_id();
      pt2->evaluer(xyz2);
      for(int t=0;t<3;t++)  s2[t]=xyz2[t];


    if (s1==s2)
       {
       trouve=1;
       break;
       }
   
  }
  if (trouve==-1) return trouve;
  }


 return trouve;

 }

Revision:	162
Committed:	Tue Sep 23 17:42:23 2008 UTC (16 years, 7 months ago) by souaissa
Original Path:	*magic/lib/vectorisation/vectorisation/src/vct_comparaison.cpp*
File size:	93873 byte(s)
Log Message:	changement du critere de compraison de deux surfaces au lieu de comparer les barycentre maitenet la comparaison est basee sur des propriteesgeometriques exprimee par des produit vectoriels et scalaires