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"
#include "ot_cpu.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),affichageactif(0)
{
    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::active_affichage(void (*fonc)(char*))
{
    affiche=fonc;
    affichageactif=1;
}


void VCT_COMPARAISON::compare(VCT_COMPARAISON_RESULTAT &cmp,MG_VOLUME* vol1,MG_VOLUME* vol2,OT_CPU *cpu)
{
    if (vol1==NULL) vol1=mggeo1->get_mg_volume(0);
    if (vol2==NULL) vol2=mggeo2->get_mg_volume(0);
    if (affichageactif==1)
    {
        char mess[300];
        sprintf(mess,"      Fichier 1 : %d faces",mggeo1->get_nb_mg_face());
        affiche((char*)mess);
        sprintf(mess,"      Fichier 2 : %d faces",mggeo2->get_nb_mg_face());
        affiche((char*)mess);
        affiche((char*)"  Recherche de similarité");
    }
    trouve_similarite();
    if (cpu!=NULL) cpu->ajouter_etape("Similarite");
    if (affichageactif==1)
    {
        char mess[300];
        sprintf(mess,"      Nombre de paires de faces similaires : %d",similarite.get_nb()/2);
        affiche((char*)mess);
        affiche((char*)"  Recherche d'identite");
    }
    trouve_identite();
    if (cpu!=NULL) cpu->ajouter_etape("Identite");
    if (affichageactif==1)
    {
        char mess[300];
        sprintf(mess,"      Nombre de paires de faces identiques : %d",identite.get_nb()/2);
        affiche((char*)mess);
        affiche((char*)"  Recherche de localisation");
    }
    trouve_localise(cmp);
    if (cpu!=NULL) cpu->ajouter_etape("Localisation");
    if (affichageactif==1)
    {
        char mess[300];
        sprintf(mess,"      Matrice de changement de repere : %lf %lf %lf %lf",transformation(0,0).get_x(),transformation(0,1).get_x(),transformation(0,2).get_x(),transformation(0,3).get_x());
        affiche((char*)mess);
        sprintf(mess,"                                      : %lf %lf %lf %lf",transformation(1,0).get_x(),transformation(1,1).get_x(),transformation(1,2).get_x(),transformation(1,3).get_x());
        affiche((char*)mess);
        sprintf(mess,"       R1 vers R2                     : %lf %lf %lf %lf",transformation(2,0).get_x(),transformation(2,1).get_x(),transformation(2,2).get_x(),transformation(2,3).get_x());
        affiche((char*)mess);
        sprintf(mess,"                                      : %lf %lf %lf %lf",transformation(3,0).get_x(),transformation(3,1).get_x(),transformation(3,2).get_x(),transformation(3,3).get_x());
        affiche((char*)mess);

        sprintf(mess,"      Nombre de paires de faces localisées : %d",localise.get_nb()/2);
        affiche((char*)mess);
        affiche((char*)"  Recherche des arêtes et des sommets correspondants");
    }
    affecter_les_couleurs(localise);
    identifie_correspondance(cmp);
    if (cpu!=NULL) cpu->ajouter_etape("Correspondance");
    if (affichageactif==1) affiche((char*)"  Recherche des modifications partielles");
    trouve_modification_partielle(cmp);
    if (cpu!=NULL) cpu->ajouter_etape("Modifications partielles");
}

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.;
    if (nbpaire==0)
    {
        OT_TENSEUR tmp(4,4);
        tmp.identite();
        transformation=tmp;
        transformation_inverse=tmp;
        return;
    }
    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 sommetparfait=0,areteparfait=0;
    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,sommetparfait,areteparfait);
    }
    if (affichageactif==1)
    {
        char mess[300];
        sprintf(mess,"      Nombre de paires de sommets localisés : %d",sommetparfait);
        affiche((char*)mess);
        sprintf(mess,"      Nombre de paires d'aretes localisées : %d",areteparfait);
        affiche((char*)mess);
    }
}

void VCT_COMPARAISON::identifie_topologie_sous_jacente(VCT_COMPARAISON_RESULTAT &cmp,MG_FACE* face1,MG_FACE* face2,int& sommetparfait,int& areteparfait)
{
    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);
                                                int res=cmp.ajouter_liste_topologie(cor);
                                                if (res==1)
                                                {
                                                    cmp.ajouter_liste_topologie(VCT_COMPARAISON_RESULTAT::ORIGINE_CONSERVEE,are1);
                                                    cmp.ajouter_liste_topologie(VCT_COMPARAISON_RESULTAT::MODIFIE_CONSERVEE,are2);
                                                    areteparfait++;
                                                }
                                            }
                        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);
                int res=cmp.ajouter_liste_topologie(cor);
                if (res==1)
                {
                    cmp.ajouter_liste_topologie(VCT_COMPARAISON_RESULTAT::ORIGINE_CONSERVEE,(*its1).second);
                    cmp.ajouter_liste_topologie(VCT_COMPARAISON_RESULTAT::MODIFIE_CONSERVEE,(*its2).second);
                    sommetparfait++;
                }
            }
            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.);
    int sommetpartiel=0,aretepartiel=0,facepartiel=0;
//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);
            sommetpartiel++;
        }
        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);
                                    aretepartiel++;
                                }
                    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);
                            facepartiel++;
                        }
                    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);
    }
    if (affichageactif==1)
    {
        char mess[300];
        sprintf(mess,"      Nombre de paires de sommets : %d",sommetpartiel);
        affiche((char*)mess);
        sprintf(mess,"      Nombre de paires d'aretes : %d",aretepartiel);
        affiche((char*)mess);
        sprintf(mess,"      Nombre de paires de faces : %d",facepartiel);
        affiche((char*)mess);
    }

}


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:	283
Committed:	Tue Sep 13 21:11:20 2011 UTC (13 years, 8 months ago) by francois
Original Path:	*magic/lib/vectorisation/src/vct_comparaison.cpp*
File size:	131143 byte(s)
Log Message:	structure de l'écriture