comparaison/src/vct_comparaison.cpp

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

#pragma hdrstop
#include <string.h>
#include "vct_comparaison.h"
#include "vct_volume.h"
#include "vct_face.h"
#include "vct_surface.h"
#include <iomanip>
#include "vct_outils.h"
#include "constantegeo.h"
#include "mg_geometrie_outils.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);
eps=mggeo1->get_valeur_precision();
}

VCT_COMPARAISON::~VCT_COMPARAISON()
{
}
void VCT_COMPARAISON::compare(VCT_COMPARAISON_RESULTAT &cmp,MG_VOLUME* vol1,MG_VOLUME* vol2)
{
if (vol1==NULL) vol1=mggeo1->get_mg_volume(0);
if (vol2==NULL) vol2=mggeo2->get_mg_volume(0);
trouve_similarite();
trouve_identite();
trouve_localise(cmp);
affecter_les_couleurs(localise);
identifie_correspondance(cmp);
trouve_modification_partielle(cmp);
}

void VCT_COMPARAISON::trouve_similarite(void)
{
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 nb_top1_pts= face1->get_vectorisation().get_nb_points();
        int nb_geo1_pts= surf1->get_vectorisation().get_nb_points();

        OT_TENSEUR *tns1_face=face1->get_vectorisation().get_tenseur_metrique();
        OT_TENSEUR *tns1_surf=surf1->get_vectorisation().get_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 nb_top2_pts= face2->get_vectorisation().get_nb_points();
              int nb_geo2_pts= surf2->get_vectorisation().get_nb_points();
              OT_TENSEUR* tns2_face=face2->get_vectorisation().get_tenseur_metrique();
              OT_TENSEUR* tns2_surf=surf2->get_vectorisation().get_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(face1->get_id());
                            similarite.ajouter(face2->get_id());
                          }
                        }
                     }
                }
            }
}

void VCT_COMPARAISON::trouve_identite(void)
{
identite.vide();
int nbpaire=similarite.get_nb()/2;
for (int i=0;i<nbpaire;i++)        
        {
        MG_FACE* face1=mggeo1->get_mg_faceid(similarite.get(2*i));
        MG_SURFACE*surf1=face1->get_surface();
        MG_FACE* face2=mggeo2->get_mg_faceid(similarite.get(2*i+1));
        MG_SURFACE*surf2=face1->get_surface();
        OT_TENSEUR *tns1_face=face1->get_vectorisation().get_tenseur_inertie_base_locale_4d();
        OT_TENSEUR *tns1_surf=surf1->get_vectorisation().get_tenseur_inertie_base_locale_4d();
        OT_TENSEUR *tns2_face=face2->get_vectorisation().get_tenseur_inertie_base_locale_4d();
        OT_TENSEUR *tns2_surf=surf2->get_vectorisation().get_tenseur_inertie_base_locale_4d();
        if(tns1_face->est_til_equivalent(*tns2_face))
                if(tns1_surf->est_til_equivalent(*tns2_surf))
                        {
                        identite.ajouter(face1->get_id());
                        identite.ajouter(face2->get_id());
                        }
        }
}
void VCT_COMPARAISON::trouve_localise(VCT_COMPARAISON_RESULTAT &cmp)
{

localise.vide();
TPL_LISTE_ENTITE<int> localisetmp;
int nbpaire=identite.get_nb()/2.;
int *paire=new int[nbpaire];
for (int i=0;i<nbpaire;i++)
        paire[i]=0;
for (int ident=0;ident<nbpaire;ident++)
        {
        if (paire[ident]==1) continue;
        MG_FACE* faceref1=mggeo1->get_mg_faceid(identite.get(2*ident));
        MG_FACE* faceref2=mggeo2->get_mg_faceid(identite.get(2*ident+1));
        OT_TENSEUR tnsref1(3,3);
        OT_TENSEUR tnsref2(3,3);
        std::vector<OT_TENSEUR> list;
        recale_repere_reference(faceref1,faceref2,list);
        int nbessai=list.size()/2;
        for (int essai=0;essai<nbessai;essai++)
                {
                localisetmp.vide();
                int *pairetmp=new int[nbpaire];
                for (int i=0;i<nbpaire;i++)
                        pairetmp[i]=0;
                OT_VECTEUR_3DD *baryref1=faceref1->get_vectorisation().get_barycentre_3d();
                OT_VECTEUR_3DD *baryref2=faceref2->get_vectorisation().get_barycentre_3d();
                OT_TENSEUR tnsref1=list[essai*2];
                OT_TENSEUR tnsref2=list[essai*2+1];
                OT_TENSEUR tnsrefinv1=tnsref1.transpose();
                OT_TENSEUR tnsrefinv2=tnsref2.transpose();
                for (int i=0;i<nbpaire;i++)        
                        {
                        MG_FACE* face1=mggeo1->get_mg_faceid(identite.get(2*i));
                        MG_FACE* face2=mggeo2->get_mg_faceid(identite.get(2*i+1));
                        OT_TENSEUR *tns1=face1->get_vectorisation().get_base_locale_3d();
                        OT_TENSEUR trans1=tns1->transpose();
                        trans1=trans1*tnsref1;
                        OT_TENSEUR tns2=trans1.transpose();
                        tns2=tnsref2*tns2;
                        OT_TENSEUR *iner2=face2->get_vectorisation().get_tenseur_inertie_3d();
                        OT_TENSEUR *inerloc2=face2->get_vectorisation().get_tenseur_inertie_base_locale_3d();
                        OT_TENSEUR inerloc2prime=tns2.transpose();
                        inerloc2prime=inerloc2prime*(*iner2);
                        inerloc2prime=inerloc2prime*tns2;
                        OT_VECTEUR_3DD *bary1=face1->get_vectorisation().get_barycentre_3d();
                        OT_VECTEUR_3DD baryloc1=(*bary1)-(*baryref1);
                        baryloc1=tnsrefinv1*baryloc1;
                        OT_VECTEUR_3DD *bary2=face2->get_vectorisation().get_barycentre_3d();
                        OT_VECTEUR_3DD baryloc2=(*bary2)-(*baryref2);
                        baryloc2=tnsrefinv2*baryloc2;
                        if (inerloc2prime.est_til_equivalent(*inerloc2))
                        if (baryloc1==baryloc2)
                                {       
                                localisetmp.ajouter(face1->get_id());
                                localisetmp.ajouter(face2->get_id());
                                pairetmp[i]=1;
                                }       
                        }
                if (localisetmp.get_nb()>localise.get_nb())
                        {
                        int n=localisetmp.get_nb();
                        localise.vide();
                        for (int i=0;i<n;i++)
                                localise.ajouter(localisetmp.get(i));
                        for (int i=0;i<nbpaire;i++)
                                paire[i]=pairetmp[i];
                        ident=0;
                        transformation=calcul_transformation(*baryref1,*baryref2,tnsref1,tnsref2);
                        }
                delete [] pairetmp;
                }
        }
delete [] paire;
transformation_inverse=transformation.inverse_homogene();
OT_VECTEUR_3D vec1(transformation(0,0).get_x(),transformation(1,0).get_x(),transformation(2,0).get_x());
OT_VECTEUR_3D vec2(transformation(0,1).get_x(),transformation(1,1).get_x(),transformation(2,1).get_x());
OT_VECTEUR_3D vec3(transformation(0,2).get_x(),transformation(1,2).get_x(),transformation(2,2).get_x());
OT_VECTEUR_3D vec4(transformation(0,3).get_x(),transformation(1,3).get_x(),transformation(2,3).get_x());
cmp.initialise_changement_repere(vec1,vec2,vec3,vec4);

}
void VCT_COMPARAISON::identifie_correspondance(VCT_COMPARAISON_RESULTAT &cmp)
{
int nbpaire=localise.get_nb()/2.;
for (int i=0;i<nbpaire;i++)
        {
        MG_FACE* face1=mggeo1->get_mg_faceid(localise.get(2*i));
        MG_FACE* face2=mggeo2->get_mg_faceid(localise.get(2*i+1));
        CORRESPONDANCE cor(face1,face2,CORRESPONDANCE::PARFAITE);
        cmp.ajouter_liste_topologie(cor);
        cmp.ajouter_liste_topologie(VCT_COMPARAISON_RESULTAT::ORIGINE_CONSERVEE,face1);
        cmp.ajouter_liste_topologie(VCT_COMPARAISON_RESULTAT::MODIFIE_CONSERVEE,face2);
        identifie_topologie_sous_jacente(cmp,face1,face2);
        }
}

void VCT_COMPARAISON::identifie_topologie_sous_jacente(VCT_COMPARAISON_RESULTAT &cmp,MG_FACE* face1,MG_FACE* face2)
{
double2 UN(1.0);
std::map<OT_VECTEUR_3DD,MG_SOMMET*,lessOT_VECTEUR_3DD > tabsom1;
std::map<OT_VECTEUR_3DD,MG_SOMMET*,lessOT_VECTEUR_3DD > tabsom2;
std::multimap<OT_VECTEUR_3DD,MG_ARETE*,lessOT_VECTEUR_3DD > tabare1;
std::multimap<OT_VECTEUR_3DD,MG_ARETE*,lessOT_VECTEUR_3DD > tabare2;

int nb_boucle=face1->get_nb_mg_boucle();
for (int i=0;i<nb_boucle;i++)
        {
        MG_BOUCLE* bou1=face1->get_mg_boucle(i);
        int nb_arete=bou1->get_nb_mg_coarete();
        for (int j=0;j<nb_arete;j++)
                {
                MG_ARETE *are=bou1->get_mg_coarete(j)->get_arete();
                OT_VECTEUR_3DD *bary=are->get_vectorisation().get_barycentre_3d();
                std::pair<OT_VECTEUR_3DD,MG_ARETE*> tmp(*bary,are);
                tabare1.insert(tmp);
                MG_SOMMET *som1=are->get_cosommet1()->get_sommet();
                double xyz[3];
                som1->get_point()->evaluer(xyz);
                OT_VECTEUR_3DD vec(xyz[0],xyz[1],xyz[2]);
                std::pair<OT_VECTEUR_3DD,MG_SOMMET*> tmp2(vec,som1);
                tabsom1.insert(tmp2);
                MG_SOMMET *som2=are->get_cosommet2()->get_sommet();
                som2->get_point()->evaluer(xyz);
                OT_VECTEUR_3DD vec2(xyz[0],xyz[1],xyz[2]);
                std::pair<OT_VECTEUR_3DD,MG_SOMMET*> tmp3(vec2,som2);
                tabsom1.insert(tmp3);
                }
        MG_BOUCLE* bou2=face2->get_mg_boucle(i);
        nb_arete=bou1->get_nb_mg_coarete();
        for (int j=0;j<nb_arete;j++)
                {
                MG_ARETE *are=bou2->get_mg_coarete(j)->get_arete();
                OT_VECTEUR_3DD *bary=are->get_vectorisation().get_barycentre_3d();
                OT_VECTEUR_4DD baryhomo(bary->get_x(),bary->get_y(),bary->get_z(),UN);
                OT_VECTEUR_4DD barytranshomo=transformation_inverse*baryhomo;
                OT_VECTEUR_3DD barytrans(barytranshomo.get_x(),barytranshomo.get_y(),barytranshomo.get_z()); 
                double2 w=UN/barytranshomo.get_w();
                barytrans=barytrans*w;
                std::pair<OT_VECTEUR_3DD,MG_ARETE*> tmp(barytrans,are);
                tabare2.insert(tmp);
                MG_SOMMET *som1=are->get_cosommet1()->get_sommet();
                double xyz[3];
                som1->get_point()->evaluer(xyz);
                OT_VECTEUR_4DD vechomo(xyz[0],xyz[1],xyz[2],1.);
                OT_VECTEUR_4DD vectranshomo=transformation_inverse*vechomo;
                OT_VECTEUR_3DD vectrans(vectranshomo.get_x(),vectranshomo.get_y(),vectranshomo.get_z()); 
                 w=UN/vectranshomo.get_w();
                vectrans=vectrans*w;
                std::pair<OT_VECTEUR_3DD,MG_SOMMET*> tmp2(vectrans,som1);
                tabsom2.insert(tmp2);
                MG_SOMMET *som2=are->get_cosommet2()->get_sommet();
                som2->get_point()->evaluer(xyz);
                OT_VECTEUR_4DD vechomo2(xyz[0],xyz[1],xyz[2],1.);
                OT_VECTEUR_4DD vectranshomo2=transformation_inverse*vechomo2;
                OT_VECTEUR_3DD vectrans2(vectranshomo2.get_x(),vectranshomo2.get_y(),vectranshomo2.get_z()); 
                 w=UN/vectranshomo2.get_w();
                vectrans2=vectrans2*w;
                std::pair<OT_VECTEUR_3DD,MG_SOMMET*> tmp3(vectrans2,som2);
                tabsom2.insert(tmp3);
                }
        //arete
        std::multimap<OT_VECTEUR_3DD,MG_ARETE*,lessOT_VECTEUR_3DD >::iterator it1;
        std::multimap<OT_VECTEUR_3DD,MG_ARETE*,lessOT_VECTEUR_3DD >::iterator it2;
        it1=tabare1.begin();
        int ok=0;
        if (it1==tabare1.end()) ok=1;
        while (ok==0)
                {
                MG_ARETE* are1=(*it1).second;
                OT_VECTEUR_3DD bary1=(*it1).first;
                int nb_top1_pts= are1->get_vectorisation().get_nb_points();
                int nb_geo1_pts= are1->get_courbe()->get_vectorisation().get_nb_points();
                OT_TENSEUR *tns1_metrique_are=are1->get_vectorisation().get_tenseur_metrique();
                OT_TENSEUR *tns1_metrique_crb=are1->get_courbe()->get_vectorisation().get_tenseur_metrique();
                OT_TENSEUR *tns1_inertie_are=are1->get_vectorisation().get_tenseur_inertie_base_locale_4d();
                OT_TENSEUR *tns1_inertie_crb=are1->get_courbe()->get_vectorisation().get_tenseur_inertie_base_locale_4d();
                it2=tabare2.find(bary1);
                int ok2=0;
                do
                        {
                        if (it2==tabare2.end()) ok2=1;
                        else
                                {
                                MG_ARETE* are2=(*it2).second;
                                OT_VECTEUR_3DD bary2=(*it2).first;
                                if (!(bary2==bary1)) ok2=1;
                                else
                                        {
                                        int nb_top2_pts= are2->get_vectorisation().get_nb_points();
                                        int nb_geo2_pts= are2->get_courbe()->get_vectorisation().get_nb_points();
                                        OT_TENSEUR *tns2_metrique_are=are2->get_vectorisation().get_tenseur_metrique();
                                        OT_TENSEUR *tns2_metrique_crb=are2->get_courbe()->get_vectorisation().get_tenseur_metrique();
                                        OT_TENSEUR *tns2_inertie_are=are2->get_vectorisation().get_tenseur_inertie_base_locale_4d();
                                        OT_TENSEUR *tns2_inertie_crb=are2->get_courbe()->get_vectorisation().get_tenseur_inertie_base_locale_4d();
                                        if (nb_top1_pts==nb_top2_pts)
                                                if (nb_geo1_pts==nb_geo2_pts)
                                                        if (tns1_metrique_are->est_til_equivalent(*tns2_metrique_are))
                                                                if (tns1_metrique_crb->est_til_equivalent(*tns2_metrique_crb))
                                                                        if (tns1_inertie_are->est_til_equivalent(*tns2_inertie_are))
                                                                                if (tns1_inertie_crb->est_til_equivalent(*tns2_inertie_crb))
                                                                                        {
                                                                                        CORRESPONDANCE cor(are1,are2,CORRESPONDANCE::PARFAITE);
                                                                                        cmp.ajouter_liste_topologie(cor);
                                                                                        cmp.ajouter_liste_topologie(VCT_COMPARAISON_RESULTAT::ORIGINE_CONSERVEE,are1);
                                                                                        cmp.ajouter_liste_topologie(VCT_COMPARAISON_RESULTAT::MODIFIE_CONSERVEE,are2);
                                                                                        }
                                        it2++;
                                        }
                                }
                        }
                while (ok2==0);
                it1++;
                if (it1==tabare1.end()) ok=1;
                }
        
        //sommet
        std::map<OT_VECTEUR_3DD,MG_SOMMET*,lessOT_VECTEUR_3DD >::iterator its1;
        std::map<OT_VECTEUR_3DD,MG_SOMMET*,lessOT_VECTEUR_3DD >::iterator its2;
        its1=tabsom1.begin();
        ok=0;
        do 
                {
                MG_SOMMET* som=(*its1).second;
                its2=tabsom2.find((*its1).first);
                if (its2!=tabsom2.end())
                        {
                        CORRESPONDANCE cor((*its1).second,(*its2).second,CORRESPONDANCE::PARFAITE);
                        cmp.ajouter_liste_topologie(cor);
                        cmp.ajouter_liste_topologie(VCT_COMPARAISON_RESULTAT::ORIGINE_CONSERVEE,(*its1).second);
                        cmp.ajouter_liste_topologie(VCT_COMPARAISON_RESULTAT::MODIFIE_CONSERVEE,(*its2).second);
                        }
                its1++;
                if (its1==tabsom1.end()) ok=1;
                }
        while (ok==0);
        }
}

void VCT_COMPARAISON::trouve_modification_partielle(VCT_COMPARAISON_RESULTAT &cmp)
{
double2 ZERO(0.);
double2 UN(1.);
//tableau des entites qui n'ont pas pu associees
std::map<OT_VECTEUR_3DD,MG_SOMMET*,lessOT_VECTEUR_3DD > tabsom1;
std::map<OT_VECTEUR_3DD,MG_SOMMET*,lessOT_VECTEUR_3DD > tabsom2;
std::multimap<int,MG_ARETE* > tabare1;
std::multimap<int,MG_ARETE* > tabare2;
std::multimap<int,MG_FACE* > tabface1;
std::multimap<int,MG_FACE*> tabface2;

LISTE_MG_SOMMET::iterator itsom;
LISTE_MG_ARETE::iterator itare;
LISTE_MG_FACE::iterator itface;
for (MG_SOMMET* som=mggeo1->get_premier_sommet(itsom);som!=NULL;som=mggeo1->get_suivant_sommet(itsom))
        {
        unsigned long num=cmp.get_liste_correspondance_modifie(som->get_id());
        if (num==0)
                {
                double xyz[3];
                som->get_point()->evaluer(xyz);
                OT_VECTEUR_3DD vec(xyz[0],xyz[1],xyz[2]);
                std::pair<OT_VECTEUR_3DD,MG_SOMMET*> tmp(vec,som);
                tabsom1.insert(tmp);
                }
        }
for (MG_ARETE* are=mggeo1->get_premier_arete(itare);are!=NULL;are=mggeo1->get_suivant_arete(itare))
        {
        unsigned long num=cmp.get_liste_correspondance_modifie(are->get_id());
        if (num==0)
                {
                TPL_LISTE_ENTITE<double> param;
                int typecrb=are->get_courbe()->get_type_geometrique(param);
                std::pair<int,MG_ARETE*> tmp(typecrb,are);
                tabare1.insert(tmp);
                }
        }
for (MG_FACE* face=mggeo1->get_premier_face(itface);face!=NULL;face=mggeo1->get_suivant_face(itface))
        {
        unsigned long num=cmp.get_liste_correspondance_modifie(face->get_id());
        if (num==0)
                {
                TPL_LISTE_ENTITE<double> param;
                int typesurf=face->get_surface()->get_type_geometrique(param);
                std::pair<int,MG_FACE*> tmp(typesurf,face);
                tabface1.insert(tmp);
                }
        }
for (MG_SOMMET* som=mggeo2->get_premier_sommet(itsom);som!=NULL;som=mggeo2->get_suivant_sommet(itsom))
        {
        unsigned long num=cmp.get_liste_correspondance_origine(som->get_id());
        if (num==0)
                {
                double xyz[3];
                som->get_point()->evaluer(xyz);
                OT_VECTEUR_4DD vec(xyz[0],xyz[1],xyz[2],1.);
                OT_VECTEUR_4DD vectranshomo=transformation_inverse*vec;
                OT_VECTEUR_3DD vectrans(vectranshomo.get_x(),vectranshomo.get_y(),vectranshomo.get_z());
                double2 w=UN/vectranshomo.get_w();
                vectrans=vectrans*w;
                std::pair<OT_VECTEUR_3DD,MG_SOMMET*> tmp(vectrans,som);
                tabsom2.insert(tmp);
                }
        }
for (MG_ARETE* are=mggeo2->get_premier_arete(itare);are!=NULL;are=mggeo2->get_suivant_arete(itare))
        {
        unsigned long num=cmp.get_liste_correspondance_origine(are->get_id());
        if (num==0)
                {
                TPL_LISTE_ENTITE<double> param;
                int typecrb=are->get_courbe()->get_type_geometrique(param);
                std::pair<int,MG_ARETE*> tmp(typecrb,are);
                tabare2.insert(tmp);
                }
        }
for (MG_FACE* face=mggeo2->get_premier_face(itface);face!=NULL;face=mggeo2->get_suivant_face(itface))
        {
        unsigned long num=cmp.get_liste_correspondance_origine(face->get_id());
        if (num==0)
                {
                TPL_LISTE_ENTITE<double> param;
                int typesurf=face->get_surface()->get_type_geometrique(param);
                std::pair<int,MG_FACE*> tmp(typesurf,face);
                tabface2.insert(tmp);
                }
        }
//analyse sommet
std::map<OT_VECTEUR_3DD,MG_SOMMET*,lessOT_VECTEUR_3DD >::iterator its1;
std::map<OT_VECTEUR_3DD,MG_SOMMET*,lessOT_VECTEUR_3DD >::iterator its2;
its1=tabsom1.begin();
int ok=0;
if (tabsom1.size()==0) ok=1;
while (ok==0) 
        {
        its2=tabsom2.find((*its1).first);
        if (its2!=tabsom2.end())
                {
                CORRESPONDANCE cor((*its1).second,(*its2).second,CORRESPONDANCE::MODIFIE);
                cmp.ajouter_liste_topologie(cor);
                cmp.ajouter_liste_topologie(VCT_COMPARAISON_RESULTAT::ORIGINE_CONSERVEE,(*its1).second);
                cmp.ajouter_liste_topologie(VCT_COMPARAISON_RESULTAT::MODIFIE_CONSERVEE,(*its2).second);
                }
        its1++;
        if (its1==tabsom1.end()) ok=1;
        }
//analyse arete
std::multimap<int,MG_ARETE* >::iterator ita1;
std::multimap<int,MG_ARETE* >::iterator ita2;
ita1=tabare1.begin();
ok=0;
if (tabare1.size()==0) ok=1;
while (ok==0)
        {
        MG_ARETE* are1=(*ita1).second;
        int typecrb1=(*ita1).first;
        int nb_geo1_pts= are1->get_courbe()->get_vectorisation().get_nb_points();
        OT_TENSEUR *tns1_metrique_crb=are1->get_courbe()->get_vectorisation().get_tenseur_metrique();
        OT_TENSEUR *tns1_inertie_crb=are1->get_courbe()->get_vectorisation().get_tenseur_inertie_base_locale_4d();
        ita2=tabare2.find(typecrb1);
        int ok2=0;
        do
                {
                if (ita2==tabare2.end()) ok2=1;
                else
                        {
                        MG_ARETE* are2=(*ita2).second;
                        int typecrb2=(*ita2).first;
                        if (!(typecrb2==typecrb1)) ok2=1;
                        else
                                {
                                int nb_geo2_pts= are2->get_courbe()->get_vectorisation().get_nb_points();
                                OT_TENSEUR *tns2_metrique_crb=are2->get_courbe()->get_vectorisation().get_tenseur_metrique();
                                OT_TENSEUR *tns2_inertie_crb=are2->get_courbe()->get_vectorisation().get_tenseur_inertie_base_locale_4d();
                                if (nb_geo1_pts==nb_geo2_pts)
                                        if (tns1_metrique_crb->est_til_equivalent(*tns2_metrique_crb))
                                                if (tns1_inertie_crb->est_til_equivalent(*tns2_inertie_crb))
                                                        if (localise_courbe(are1->get_courbe(),are2->get_courbe()))
                                                        {
                                                        CORRESPONDANCE cor(are1,are2,CORRESPONDANCE::MODIFIE);
                                                        cmp.ajouter_liste_topologie(cor);
                                                        cmp.ajouter_liste_topologie(VCT_COMPARAISON_RESULTAT::ORIGINE_CONSERVEE,are1);
                                                        cmp.ajouter_liste_topologie(VCT_COMPARAISON_RESULTAT::MODIFIE_CONSERVEE,are2);
                                                        }
                                ita2++;
                                }
                        }
                }
        while (ok2==0);
        ita1++;
        if (ita1==tabare1.end()) ok=1;
        }

//analyse face
std::multimap<int,MG_FACE* >::iterator itf1;
std::multimap<int,MG_FACE* >::iterator itf2;
itf1=tabface1.begin();
ok=0;
if (tabface1.size()==0) ok=1;
while (ok==0)
        {
        MG_FACE* face1=(*itf1).second;
        int typefac1=(*itf1).first;
        int nb_geo1_pts= face1->get_surface()->get_vectorisation().get_nb_points();
        OT_TENSEUR *tns1_metrique_surface=face1->get_surface()->get_vectorisation().get_tenseur_metrique();
        OT_TENSEUR *tns1_inertie_surface=face1->get_surface()->get_vectorisation().get_tenseur_inertie_base_locale_4d();
        itf2=tabface2.find(typefac1);
        int ok2=0;
        do
                {
                if (itf2==tabface2.end()) ok2=1;
                else
                        {
                        MG_FACE* face2=(*itf2).second;
                        int typefac2=(*itf2).first;
                        if (typefac1!=typefac2) ok2=1;
                        else
                                {
                                int nb_geo2_pts= face2->get_surface()->get_vectorisation().get_nb_points();
                                OT_TENSEUR *tns2_metrique_surface=face2->get_surface()->get_vectorisation().get_tenseur_metrique();
                                OT_TENSEUR *tns2_inertie_surface=face2->get_surface()->get_vectorisation().get_tenseur_inertie_base_locale_4d();
                                if (nb_geo1_pts==nb_geo2_pts)
                                        //if (tns1_metrique_surface->est_til_equivalent(*tns2_metrique_surface))
                                                //if (tns1_inertie_surface->est_til_equivalent(*tns2_inertie_surface))
                                                        if (localise_surface(face1->get_surface(),face2->get_surface()))
                                                                {
                                                                CORRESPONDANCE cor(face1,face2,CORRESPONDANCE::MODIFIE);
                                                                cmp.ajouter_liste_topologie(cor);
                                                                cmp.ajouter_liste_topologie(VCT_COMPARAISON_RESULTAT::ORIGINE_CONSERVEE,face1);
                                                                cmp.ajouter_liste_topologie(VCT_COMPARAISON_RESULTAT::MODIFIE_CONSERVEE,face2);
                                                                }
                                itf2++;
                                }
                        }
                }
        while (ok2==0);
        itf1++;
        if (itf1==tabface1.end()) ok=1;
        }
//fin remplissage cmp
for (its1=tabsom1.begin();its1!=tabsom1.end();its1++)
        {
        unsigned long num=cmp.get_liste_correspondance_modifie((*its1).second->get_id());
        if (num==0) cmp.ajouter_liste_topologie(VCT_COMPARAISON_RESULTAT::ORIGINE_DISPARUE,(*its1).second);
        }
for (its1=tabsom2.begin();its1!=tabsom2.end();its1++)
        {
        unsigned long num=cmp.get_liste_correspondance_origine((*its1).second->get_id());
        if (num==0) cmp.ajouter_liste_topologie(VCT_COMPARAISON_RESULTAT::MODIFIE_APPARUE,(*its1).second);
        }
for (ita1=tabare1.begin();ita1!=tabare1.end();ita1++)
        {
        unsigned long num=cmp.get_liste_correspondance_modifie((*ita1).second->get_id());
        if (num==0) cmp.ajouter_liste_topologie(VCT_COMPARAISON_RESULTAT::ORIGINE_DISPARUE,(*ita1).second);
        }
for (ita1=tabare2.begin();ita1!=tabare2.end();ita1++)
        {
        unsigned long num=cmp.get_liste_correspondance_origine((*ita1).second->get_id());
        if (num==0) cmp.ajouter_liste_topologie(VCT_COMPARAISON_RESULTAT::MODIFIE_APPARUE,(*ita1).second);
        }
for (itf1=tabface1.begin();itf1!=tabface1.end();itf1++)
        {
        unsigned long num=cmp.get_liste_correspondance_modifie((*itf1).second->get_id());
        if (num==0) cmp.ajouter_liste_topologie(VCT_COMPARAISON_RESULTAT::ORIGINE_DISPARUE,(*itf1).second);
        }
for (itf1=tabface2.begin();itf1!=tabface2.end();itf1++)
        {
        unsigned long num=cmp.get_liste_correspondance_origine((*itf1).second->get_id());
        if (num==0) cmp.ajouter_liste_topologie(VCT_COMPARAISON_RESULTAT::MODIFIE_APPARUE,(*itf1).second);
        }
}


int VCT_COMPARAISON::localise_courbe(MG_COURBE *crb1,MG_COURBE *crb2)
{
double xyz1[3],xyz2[3],xyz3[3],xyz[3];
double t=0.5*(crb2->get_tmax()+crb2->get_tmin());
double dt=(crb2->get_tmax()-crb2->get_tmin())/max(fabs(crb2->get_tmax()),fabs(crb2->get_tmin()));
crb2->evaluer(t,xyz1);
t=t+dt;
crb2->evaluer(t,xyz2);
t=t+dt;
crb2->evaluer(t,xyz3);
change_point_inverse(xyz1);             
change_point_inverse(xyz2);             
change_point_inverse(xyz3);             
OT_VECTEUR_3D vec(xyz1,xyz3);
crb1->inverser(t,xyz1);
crb1->evaluer(t,xyz);
OT_VECTEUR_3D vec1(xyz,xyz1);
if (vec1.get_longueur()>eps) return 0;
crb1->inverser(t,xyz2);
crb1->evaluer(t,xyz);
OT_VECTEUR_3D vec2(xyz,xyz2);
if (vec2.get_longueur()>eps) return 0;
crb1->inverser(t,xyz3);
crb1->evaluer(t,xyz);
OT_VECTEUR_3D vec3(xyz,xyz3);
if (vec3.get_longueur()>eps) return 0;
return 1;
}

int VCT_COMPARAISON::localise_surface(MG_SURFACE *surf1,MG_SURFACE *surf2)
{
double du=surf2->get_umax()-surf2->get_umin();
double dv=surf2->get_vmax()-surf2->get_vmin();
du=du/max(fabs(surf2->get_umax()),fabs(surf2->get_umin()));
dv=dv/max(fabs(surf2->get_vmax()),fabs(surf2->get_vmin()));
double ou=0.5*(surf2->get_umax()+surf2->get_umin());
double ov=0.5*(surf2->get_vmax()+surf2->get_vmin());
for (int i=0;i<3;i++)
        for (int j=0;j<3;j++)
                {
                double uv[2],xyz[3];
                uv[0]=ou+i*du;
                uv[1]=ov+j*dv;
                surf2->evaluer(uv,xyz);
                change_point_inverse(xyz);              
                double xyz1[3];
                surf1->inverser(uv,xyz);
                surf1->evaluer(uv,xyz1);
                OT_VECTEUR_3D vec(xyz,xyz1);
                if (vec.get_longueur()>eps) return 0;
                }
return 1;
}


void VCT_COMPARAISON::change_point_inverse(double *xyz)
{
double2 UN(1.);
OT_VECTEUR_4DD vec(xyz[0],xyz[1],xyz[2],1.);
OT_VECTEUR_4DD vectranshomo=transformation_inverse*vec;
OT_VECTEUR_3DD vectrans(vectranshomo.get_x(),vectranshomo.get_y(),vectranshomo.get_z());
double2 w=UN/vectranshomo.get_w();
vectrans=vectrans*w;
xyz[0]=vectrans.get_x().get_x();
xyz[1]=vectrans.get_y().get_x();
xyz[2]=vectrans.get_z().get_x();
}

void VCT_COMPARAISON::change_point(double *xyz)
{
double2 UN(1.);
OT_VECTEUR_4DD vec(xyz[0],xyz[1],xyz[2],1.);
OT_VECTEUR_4DD vectranshomo=transformation*vec;
OT_VECTEUR_3DD vectrans(vectranshomo.get_x(),vectranshomo.get_y(),vectranshomo.get_z());
double2 w=UN/vectranshomo.get_w();
vectrans=vectrans*w;
xyz[0]=vectrans.get_x().get_x();
xyz[1]=vectrans.get_y().get_x();
xyz[2]=vectrans.get_z().get_x();
}


OT_TENSEUR VCT_COMPARAISON::calcul_transformation(OT_VECTEUR_3DD &bary1,OT_VECTEUR_3DD &bary2,OT_TENSEUR &tns1,OT_TENSEUR &tns2)
{
double2 zero(0.),un(1.);
OT_TENSEUR t1(4,4);
t1(0,0)=tns1(0,0);t1(1,0)=tns1(1,0);t1(2,0)=tns1(2,0);t1(3,0)=zero;
t1(0,1)=tns1(0,1);t1(1,1)=tns1(1,1);t1(2,1)=tns1(2,1);t1(3,1)=zero;
t1(0,2)=tns1(0,2);t1(1,2)=tns1(1,2);t1(2,2)=tns1(2,2);t1(3,2)=zero;
t1(0,3)=bary1.get_x();
t1(1,3)=bary1.get_y();
t1(2,3)=bary1.get_z();
t1(3,3)=un;
OT_TENSEUR t2(4,4);
t2(0,0)=tns2(0,0);t2(1,0)=tns2(1,0);t2(2,0)=tns2(2,0);t2(3,0)=zero;
t2(0,1)=tns2(0,1);t2(1,1)=tns2(1,1);t2(2,1)=tns2(2,1);t2(3,1)=zero;
t2(0,2)=tns2(0,2);t2(1,2)=tns2(1,2);t2(2,2)=tns2(2,2);t2(3,2)=zero;
t2(0,3)=bary2.get_x();
t2(1,3)=bary2.get_y();
t2(2,3)=bary2.get_z();
t2(3,3)=un;
OT_TENSEUR t1inv=t1.inverse_homogene();
OT_TENSEUR trans=t2*t1inv;
return trans;
}

void VCT_COMPARAISON::recale_repere_reference(MG_FACE* faceref1,MG_FACE* faceref2,vector<OT_TENSEUR> &list)
{
OT_TENSEUR tnsref1(3,3),tnsref2(3,3);
double2 zero(0.);
// repere1 
OT_VECTEUR_3DD *bary1=faceref1->get_vectorisation().get_barycentre_3d();
double xyz1[3]={bary1->get_x().get_x(),bary1->get_y().get_x(),bary1->get_z().get_x()};
MG_GEOMETRIE_OUTILS ot;
double uvproj1[2],xyzproj1[3];
ot.projete(xyz1,faceref1,uvproj1,xyzproj1);
double normal1[3];
faceref1->calcul_normale_unitaire(uvproj1,normal1);
double2 normal12[3];normal12[0]=normal1[0];normal12[1]=normal1[1];normal12[2]=normal1[2];
OT_VECTEUR_3DD nor1(normal12);
int sens1=faceref1->get_mg_coface(0)->get_orientation();
nor1=sens1*nor1;
OT_TENSEUR *axe1=faceref1->get_vectorisation().get_base_locale_3d();
int n13=-1;
int signe13=1;
double2 limit1(0.);
for (int i=0;i<3;i++)
        {
        OT_VECTEUR_3DD veci;
        veci[0]=(*axe1)(0,i);
        veci[1]=(*axe1)(1,i);
        veci[2]=(*axe1)(2,i);
        double2 ps=veci*nor1;
        if (f2abs(ps)>limit1) 
                {
                n13=i;
                if (ps<zero) signe13=-1;
                limit1=f2abs(ps);
                }
        }
int n11,n12;
if (n13==0) {n11=1;n12=2;} 
if (n13==1) {n11=0;n12=2;} 
if (n13==2) {n11=0;n12=1;} 
OT_TENSEUR *inertie_base_locale1=faceref1->get_vectorisation().get_tenseur_inertie_base_locale_3d();
if ((*inertie_base_locale1)(n11,n11)<(*inertie_base_locale1)(n12,n12)) {int tmp=n11;n11=n12;n12=tmp;}
OT_VECTEUR_3DD x11((*axe1)(0,n11),(*axe1)(1,n11),(*axe1)(2,n11));
OT_VECTEUR_3DD x13((*axe1)(0,n13)*signe13,(*axe1)(1,n13)*signe13,(*axe1)(2,n13)*signe13);
OT_VECTEUR_3DD x12=x13 & x11;
(tnsref1)(0,0)=x11.get_x();(tnsref1)(1,0)=x11.get_y();(tnsref1)(2,0)=x11.get_z();
(tnsref1)(0,1)=x12.get_x();(tnsref1)(1,1)=x12.get_y();(tnsref1)(2,1)=x12.get_z();
(tnsref1)(0,2)=x13.get_x();(tnsref1)(1,2)=x13.get_y();(tnsref1)(2,2)=x13.get_z();
int nbtest1=1;
if ((*inertie_base_locale1)(n11,n11)==(*inertie_base_locale1)(n12,n12)) nbtest1=0; //nbtest1=2;
for (int test1=0;test1<nbtest1;test1++)
        {
        if (test1==1)
                {
                OT_VECTEUR_3DD x11((*axe1)(0,n12),(*axe1)(1,n12),(*axe1)(2,n12));
                OT_VECTEUR_3DD x12=x13 & x11;
                (tnsref1)(0,0)=x11.get_x();(tnsref1)(1,0)=x11.get_y();(tnsref1)(2,0)=x11.get_z();
                (tnsref1)(0,1)=x12.get_x();(tnsref1)(1,1)=x12.get_y();(tnsref1)(2,1)=x12.get_z();
                (tnsref1)(0,2)=x13.get_x();(tnsref1)(1,2)=x13.get_y();(tnsref1)(2,2)=x13.get_z();
                }
        OT_TENSEUR inv1=tnsref1.transpose();
        int nbpt1=faceref1->get_vectorisation().get_points_controle().size();
        OT_VECTEUR_3DD bary1xp,bary1yp,bary1xn,bary1yn;
        int xp1=0,yp1=0,xn1=0,yn1=0;
        for (int i=0;i<nbpt1;i++)
                {
                OT_VECTEUR_4DD pt=faceref1->get_vectorisation().get_points_controle()[i];
                OT_VECTEUR_3DD point(pt[0],pt[1],pt[2]);
                point=point-(*bary1);
                point=inv1*point;
                if (point.get_x()>zero) 
                        {
                        bary1xp=bary1xp+point;
                        xp1++;
                        }
                if (point.get_x()<zero) 
                        {
                        bary1xn=bary1xn+point;
                        xn1++;
                        }
                if (point.get_y()>zero) 
                        {
                        bary1yp=bary1yp+point;
                        yp1++;
                        }
                if (point.get_y()<zero) 
                        {
                        bary1xn=bary1xn+point;
                        yn1++;
                        }
                }
        bary1xp=bary1xp/xp1;
        bary1xn=bary1xn/xn1;
        bary1yp=bary1yp/yp1;
        bary1yp=bary1yp/yn1;
        //repere2
        OT_VECTEUR_3DD *bary2=faceref2->get_vectorisation().get_barycentre_3d();
        double xyz2[3]={bary2->get_x().get_x(),bary2->get_y().get_x(),bary2->get_z().get_x()};
        double uvproj2[2],xyzproj2[3];
        ot.projete(xyz2,faceref2,uvproj2,xyzproj2);
        double normal2[3];
        faceref2->calcul_normale_unitaire(uvproj2,normal2);
        double2 normal22[3];normal22[0]=normal2[0];normal22[1]=normal2[1];normal22[2]=normal2[2];
        OT_VECTEUR_3DD nor2(normal22);
        int sens2=faceref2->get_mg_coface(0)->get_orientation();
        nor2=sens2*nor2;
        OT_TENSEUR *axe2=faceref2->get_vectorisation().get_base_locale_3d();
        int n23=-1;
        int signe23=1;
        double2 limit2(0.);
        for (int i=0;i<3;i++)
                {
                OT_VECTEUR_3DD veci;
                veci[0]=(*axe2)(0,i);
                veci[1]=(*axe2)(1,i);
                veci[2]=(*axe2)(2,i);
                double2 ps=veci*nor2;
                if (f2abs(ps)>limit2) 
                        {
                        n23=i;
                        if (ps<zero) signe23=-1;
                        limit2=f2abs(ps);
                        }
                }
        int n21,n22;
        if (n23==0) {n21=1;n22=2;} 
        if (n23==1) {n21=0;n22=2;} 
        if (n23==2) {n21=0;n22=1;} 
        OT_TENSEUR *inertie_base_locale2=faceref2->get_vectorisation().get_tenseur_inertie_base_locale_3d();
        if ((*inertie_base_locale2)(n21,n21)<(*inertie_base_locale2)(n22,n22)) {int tmp=n21;n21=n22;n22=tmp;}
        OT_VECTEUR_3DD x21((*axe2)(0,n21),(*axe2)(1,n21),(*axe2)(2,n21));
        OT_VECTEUR_3DD x23((*axe2)(0,n23)*signe23,(*axe2)(1,n23)*signe23,(*axe2)(2,n23)*signe23);
        OT_VECTEUR_3DD x22=x23 & x21;
        (tnsref2)(0,0)=x21.get_x();(tnsref2)(1,0)=x21.get_y();(tnsref2)(2,0)=x21.get_z();
        (tnsref2)(0,1)=x22.get_x();(tnsref2)(1,1)=x22.get_y();(tnsref2)(2,1)=x22.get_z();
        (tnsref2)(0,2)=x23.get_x();(tnsref2)(1,2)=x23.get_y();(tnsref2)(2,2)=x23.get_z();
        int nbtest2=1;
        if ((*inertie_base_locale2)(n21,n21)==(*inertie_base_locale2)(n22,n22))  nbtest1=0;   //nbtest2=2;
        for (int test2=0;test2<nbtest2;test2++)
                {
                if (test2==1)
                        {
                        OT_VECTEUR_3DD x21((*axe1)(0,n22),(*axe1)(1,n22),(*axe1)(2,n22));
                        OT_VECTEUR_3DD x22=x23 & x21;
                        (tnsref2)(0,0)=x21.get_x();(tnsref2)(1,0)=x21.get_y();(tnsref2)(2,0)=x21.get_z();
                        (tnsref2)(0,1)=x22.get_x();(tnsref2)(1,1)=x22.get_y();(tnsref2)(2,1)=x22.get_z();
                        (tnsref2)(0,2)=x23.get_x();(tnsref2)(1,2)=x23.get_y();(tnsref2)(2,2)=x23.get_z();
                        }       
                OT_TENSEUR inv2=tnsref2.transpose();
                int nbpt2=faceref2->get_vectorisation().get_points_controle().size();
                OT_VECTEUR_3DD bary2xp,bary2yp,bary2xn,bary2yn;
                int xp2=0,yp2=0,xn2=0,yn2=0;
                for (int i=0;i<nbpt2;i++)
                        {
                        OT_VECTEUR_4DD pt=faceref2->get_vectorisation().get_points_controle()[i];
                        OT_VECTEUR_3DD point(pt[0],pt[1],pt[2]);
                        point=point-(*bary2);
                        point=inv2*point;
                        if (point.get_x()>zero) 
                                {
                                bary2xp=bary2xp+point;
                                xp2++;
                                }
                        if (point.get_x()<zero) 
                                {
                                bary2xn=bary2xn+point;
                                xn2++;
                                }
                        if (point.get_y()>zero) 
                                {
                                bary2yp=bary2yp+point;
                                yp2++;
                                }
                        if (point.get_y()<zero) 
                                {
                                bary2xn=bary2xn+point;
                                yn2++;
                                }
                        }
                bary2xp=bary2xp/xp2;
                bary2xn=bary2xn/xn2;
                bary2yp=bary2yp/yp2;
                bary2yp=bary2yp/yn2;

                if ((bary2xp==bary1xp) && (bary2xn==bary1xn) && (bary2yp==bary1yp) && (bary2yn==bary1yn))
                        {
                        list.insert(list.end(),tnsref1);
                        list.insert(list.end(),tnsref2);
                        }       
                OT_VECTEUR_3DD vnul(zero,zero,zero);
                bary2xp=vnul;
                bary2xn=vnul;
                bary2yp=vnul;
                bary2yp=vnul;

                tnsref2(0,0)=zero-tnsref2(0,0);
                tnsref2(1,0)=zero-tnsref2(1,0);
                tnsref2(2,0)=zero-tnsref2(2,0);
                tnsref2(0,1)=zero-tnsref2(0,1);
                tnsref2(1,1)=zero-tnsref2(1,1);
                tnsref2(2,1)=zero-tnsref2(2,1);

                inv2=tnsref2.transpose();
                xp2=0,yp2=0,xn2=0,yn2=0;
                for (int i=0;i<nbpt2;i++)
                        {
                        OT_VECTEUR_4DD pt=faceref2->get_vectorisation().get_points_controle()[i];
                        OT_VECTEUR_3DD point(pt[0],pt[1],pt[2]);
                        point=point-(*bary2);
                        point=inv2*point;
                        if (point.get_x()>zero) 
                                {
                                bary2xp=bary2xp+point;
                                xp2++;
                                }
                        if (point.get_x()<zero) 
                                {
                                bary2xn=bary2xn+point;
                                xn2++;
                                }
                        if (point.get_y()>zero) 
                                {
                                bary2yp=bary2yp+point;
                                yp2++;
                                }
                        if (point.get_y()<zero) 
                                {
                                bary2xn=bary2xn+point;
                                yn2++;
                                }
                        }
                bary2xp=bary2xp/xp2;
                bary2xn=bary2xn/xn2;
                bary2yp=bary2yp/yp2;
                bary2yp=bary2yp/yn2;
                if ((bary2xp==bary1xp) && (bary2xn==bary1xn) && (bary2yp==bary1yp) && (bary2yn==bary1yn))
                        {
                        list.insert(list.end(),tnsref1);
                        list.insert(list.end(),tnsref2);
                        }
                }
        }

}


void VCT_COMPARAISON::choisir_une_couleur(double& val)
{
       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;

}


double VCT_COMPARAISON::recherche_couleur(MG_ELEMENT_TOPOLOGIQUE* ele)
{
double val=-1;
int nbccf=ele->get_nb_ccf();
for (int i=0;i<nbccf;i++)
        {
        char nom[10];
        ele->get_type_ccf(i,nom);
        if (strcmp(nom,"Cc")==0) val=ele->get_valeur_ccf(i);
        }
return val;
}

void VCT_COMPARAISON::supprime_couleur(MG_ELEMENT_TOPOLOGIQUE* ele)
{
int nbccf=ele->get_nb_ccf();
for (int i=0;i<nbccf;i++)
        {
        char nom[10];
        ele->get_type_ccf(i,nom);
        if (strcmp(nom,"Cc")==0) {ele->supprimer_ccf(i);nbccf--;i--;}
        }
}

void VCT_COMPARAISON::affecter_les_couleurs(TPL_LISTE_ENTITE<int>& liste)
{
int nb_face1=mggeo1->get_nb_mg_face();
for (int i=0;i<nb_face1;i++)
        supprime_couleur(mggeo1->get_mg_face(i));
int nb_face2=mggeo2->get_nb_mg_face();
for (int i=0;i<nb_face2;i++)
        supprime_couleur(mggeo2->get_mg_face(i));
TPL_LISTE_ENTITE<double> lst_val;
int nbpaire=liste.get_nb()/2;
for (int i=0;i<nbpaire;i++)
        {
        MG_FACE* ele1=mggeo1->get_mg_faceid(liste.get(2*i));
        MG_FACE* ele2=mggeo2->get_mg_faceid(liste.get(2*i+1));
        double val1=recherche_couleur(ele1);
        double val2=recherche_couleur(ele2);
        double val;
        if (val1<0.)
                {
                if (val2<0.)
                        {
                        do
                                {
                                choisir_une_couleur(val);
                                }
                        while (lst_val.est_dans_la_liste(val));
                        lst_val.ajouter(val);
                        }
                else val=val2;
                }
                else val=val1;
        if (val1<0.) ele1->ajouter_ccf((char*)"Cc",val);
        if (val2<0.) ele2->ajouter_ccf((char*)"Cc",val);
        }
}


#ifdef TA_GUEULE 
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().get_tenseur_inertie_base_locale();
              *tns2_surf=surf2->get_vectorisation().get_tenseur_inertie_base_locale();
              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);REMAILLEUR
            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;

 }

#endif
Revision:	272
Committed:	Mon Dec 13 21:04:45 2010 UTC (14 years, 5 months ago) by francois
Original Path:	*magic/lib/vectorisation/src/vct_comparaison.cpp*
File size:	128054 byte(s)
Log Message:	suppression des warnings