vct_comparaison_resultat.cpp

Aller à la documentation de ce fichier.

//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//  MAGiC
//####//  Jean Christophe Cuilliere et Vincent FRANCOIS
//####//  Departement de Genie Mecanique - UQTR
//####//------------------------------------------------------------
//####//  MAGIC est un projet de recherche de l equipe ERICCA
//####//  du departement de genie mecanique de l Universite du Quebec a Trois Rivieres
//####//  http://www.uqtr.ca/ericca
//####//  http://www.uqtr.ca/
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//
//####//       vct_comparaison_resultat.cpp
//####//
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//    COPYRIGHT 2000-2024
//####//  jeu 13 jun 2024 11:58:56 EDT
//####//------------------------------------------------------------
//####//------------------------------------------------------------
#include "gestionversion.h"
#include "vct_comparaison_resultat.h"
#include "mg_file.h"
#include "ot_tenseur.h"
 
 
 
 
 
VCT_COMPARAISON_RESULTAT::VCT_COMPARAISON_RESULTAT(class MG_GESTIONNAIRE* origest,MG_GESTIONNAIRE* modgest,class MG_GEOMETRIE* origeo,MG_GEOMETRIE* modgeo):gest_origine(origest),gest_modifie(modgest),geo_origine(origeo),geo_modifie(modgeo)
{
    OT_VECTEUR_3D vec1(1.0,0.,0.);
    OT_VECTEUR_3D vec2(0.,1.0,0.);
    OT_VECTEUR_3D vec3(0.,0.,1.0);
    OT_VECTEUR_3D vec4(0.,0.,0.);
    initialise_changement_repere(vec1,vec2,vec3,vec4);
}
 
VCT_COMPARAISON_RESULTAT::VCT_COMPARAISON_RESULTAT()
{
    OT_VECTEUR_3D vec1(1.0,0.,0.);
    OT_VECTEUR_3D vec2(0.,1.0,0.);
    OT_VECTEUR_3D vec3(0.,0.,1.0);
    OT_VECTEUR_3D vec4(0.,0.,0.);
    initialise_changement_repere(vec1,vec2,vec3,vec4);
}
 
VCT_COMPARAISON_RESULTAT::~VCT_COMPARAISON_RESULTAT()
{
}
 
 
void VCT_COMPARAISON_RESULTAT::initialise_changement_repere(OT_VECTEUR_3D& vec1,OT_VECTEUR_3D& vec2,OT_VECTEUR_3D& vec3,OT_VECTEUR_3D& vec4)
{
    translation=vec4;
    rotation.change_vecteur1(vec1);
    rotation.change_vecteur2(vec2);
    rotation.change_vecteur3(vec3);
}
 
 
void VCT_COMPARAISON_RESULTAT::ajouter_liste_topologie(int type,MG_ELEMENT_TOPOLOGIQUE* ele)
{
    switch (type)
    {
    case ORIGINE_CONSERVEE:
        origineconserve.ajouter(ele);
        break;
    case ORIGINE_DISPARUE:
        originedisparue.ajouter(ele);
        break;
    case MODIFIE_APPARUE:
        modifieapparue.ajouter(ele);
        break;
    case MODIFIE_CONSERVEE:
        modifieconserve.ajouter(ele);
        break;
    }
}
 
 
int VCT_COMPARAISON_RESULTAT::ajouter_liste_topologie(CORRESPONDANCE ele)
{
    std::pair<std::map<unsigned long,CORRESPONDANCE,std::less <unsigned long> >::iterator,bool> ret;
    std::pair<unsigned long,CORRESPONDANCE> tmp(ele.eleorigine->get_id(),ele);
    ret=listecorrespondante1.insert(tmp);
    if (ret.second==false) return 0;
    std::pair<unsigned long,CORRESPONDANCE> tmp2(ele.elemodifie->get_id(),ele);
    listecorrespondante1bis.insert(tmp2);
    return 1;
}
 
 
 
void VCT_COMPARAISON_RESULTAT::supprimer_liste_topologie(int type,MG_ELEMENT_TOPOLOGIQUE* ele)
{
    switch (type)
    {
    case ORIGINE_CONSERVEE:
        origineconserve.supprimer(ele);
        break;
    case ORIGINE_DISPARUE:
        originedisparue.supprimer(ele);
        break;
    case MODIFIE_APPARUE:
        modifieapparue.supprimer(ele);
        break;
    case MODIFIE_CONSERVEE:
        modifieconserve.supprimer(ele);
        break;
    }
}
 
int VCT_COMPARAISON_RESULTAT::get_nb_liste_topologie(int type)
{
    int nb=0;
    switch (type)
    {
    case ORIGINE_CONSERVEE:
        nb=origineconserve.get_nb();
        break;
    case ORIGINE_DISPARUE:
        nb=originedisparue.get_nb();
        break;
    case MODIFIE_APPARUE:
        nb=modifieapparue.get_nb();
        break;
    case MODIFIE_CONSERVEE:
        nb=modifieconserve.get_nb();
        break;
    }
    return nb;
}
 
 
int VCT_COMPARAISON_RESULTAT::get_nb_liste_correspondance(void)
{
    return listecorrespondante1.size();
}
 
 
MG_ELEMENT_TOPOLOGIQUE* VCT_COMPARAISON_RESULTAT::get_liste_topologie(int type,int num)
{
    MG_ELEMENT_TOPOLOGIQUE* ele=NULL;
    switch (type)
    {
    case ORIGINE_CONSERVEE:
        ele=origineconserve.get(num);
        break;
    case ORIGINE_DISPARUE:
        ele=originedisparue.get(num);
        break;
    case MODIFIE_APPARUE:
        ele=modifieapparue.get(num);
        break;
    case MODIFIE_CONSERVEE:
        ele=modifieconserve.get(num);
        break;
    }
    return ele;
}
 
MG_FACE* VCT_COMPARAISON_RESULTAT::get_face_reference1(void)
{
return faceref1;
}
 
MG_FACE* VCT_COMPARAISON_RESULTAT::get_face_reference2(void)
{
return faceref2;
}
 
void VCT_COMPARAISON_RESULTAT::change_face_reference1(MG_FACE* face)
{
faceref1=face;
}
 
void VCT_COMPARAISON_RESULTAT::change_face_reference2(MG_FACE* face)
{
faceref2=face;  
}
    
 
unsigned long VCT_COMPARAISON_RESULTAT::get_liste_correspondance_modifie(unsigned long id)
{
    std::map<unsigned long,CORRESPONDANCE,std::less <unsigned long> >::iterator it=listecorrespondante1.find(id);
    if (it==listecorrespondante1.end()) return 0;
    CORRESPONDANCE ele=(*it).second;
    return ele.elemodifie->get_id();
}
 
unsigned long VCT_COMPARAISON_RESULTAT::get_liste_correspondance_origine(unsigned long id)
{
    std::map<unsigned long,CORRESPONDANCE,std::less <unsigned long> >::iterator it=listecorrespondante1bis.find(id);
    if (it==listecorrespondante1bis.end()) return 0;
    CORRESPONDANCE ele=(*it).second;
    return ele.eleorigine->get_id();
}
 
 
void VCT_COMPARAISON_RESULTAT::enregistrer(char *nom,char* nomgestori,char *nomgestmod)
{
    gest_origine->enregistrer(nomgestori);
    gest_modifie->enregistrer(nomgestmod);
    FILE* in =fopen(nom,"wt");
    fprintf(in,"%s %lu\n",nomgestori,geo_origine->get_id());
    fprintf(in,"%s %lu\n",nomgestmod,geo_modifie->get_id());
    fprintf(in,"%e %e %e\n",rotation.get_vecteur1().get_x(),rotation.get_vecteur1().get_y(),rotation.get_vecteur1().get_z());
    fprintf(in,"%e %e %e\n",rotation.get_vecteur2().get_x(),rotation.get_vecteur2().get_y(),rotation.get_vecteur2().get_z());
    fprintf(in,"%e %e %e\n",rotation.get_vecteur3().get_x(),rotation.get_vecteur3().get_y(),rotation.get_vecteur3().get_z());
    fprintf(in,"%e %e %e\n",translation.get_x(),translation.get_y(),translation.get_z());
    fprintf(in,"%lu // face reference 1\n",faceref1->get_id());
    fprintf(in,"%lu // face reference 2\n",faceref2->get_id());
    int nb=get_nb_liste_correspondance();
    fprintf(in,"%d //tableau correspondance\n",nb);
    for (std::map<unsigned long,CORRESPONDANCE,std::less <unsigned long> >::iterator it=listecorrespondante1.begin();it!=listecorrespondante1.end();it++)
    {
        CORRESPONDANCE cor=(*it).second;
        char typeent;
        if (cor.eleorigine->get_dimension()==0) typeent='S';
        if (cor.eleorigine->get_dimension()==1) typeent='A';
        if (cor.eleorigine->get_dimension()==2) typeent='F';
        fprintf(in,"%lu %lu %c %c\n",cor.eleorigine->get_id(),cor.elemodifie->get_id(),cor.typeco,typeent);
    }
    nb=get_nb_liste_topologie(ORIGINE_CONSERVEE);
    fprintf(in,"%d //tableau origine_conservee\n",nb);
    for (int i=0;i<nb;i++)
        fprintf(in," %lu \n",get_liste_topologie(ORIGINE_CONSERVEE,i)->get_id());
    nb=get_nb_liste_topologie(ORIGINE_DISPARUE);
    fprintf(in,"%d //tableau origine_disparue\n",nb);
    for (int i=0;i<nb;i++)
        fprintf(in," %lu \n",get_liste_topologie(ORIGINE_DISPARUE,i)->get_id());
    nb=get_nb_liste_topologie(MODIFIE_CONSERVEE);
    fprintf(in,"%d //tableau modifie_conserve\n",nb);
    for (int i=0;i<nb;i++)
        fprintf(in," %lu \n",get_liste_topologie(MODIFIE_CONSERVEE,i)->get_id());
    nb=get_nb_liste_topologie(MODIFIE_APPARUE);
    fprintf(in,"%d //tableau modifie_apparue\n",nb);
    for (int i=0;i<nb;i++)
        fprintf(in," %lu \n",get_liste_topologie(MODIFIE_APPARUE,i)->get_id());
    nb=get_nb_correspondance();
    fprintf(in,"%d //tableau correspondance noeud et tetra\n",nb);
    unsigned long id1,id2;
    int res=get_correspondance_premier(id1,id2);
    while (res==1)
    {
        fprintf(in," %lu %lu\n",id1,id2);
        res=get_correspondance_suivant(id1,id2);
    }
    fclose(in);
}
 
void VCT_COMPARAISON_RESULTAT::lire(char *nom,MG_GESTIONNAIRE** gestori,MG_GESTIONNAIRE** gestmod)
{
    FILE* in =fopen(nom,"rt");
    char mess[500];
    char* res=fgets(mess,500,in);
    char nomfich[500];
    long id;
    sscanf(mess,"%s %lu",nomfich,&id);
    gest_origine=new MG_FILE(nomfich);
    *gestori=gest_origine;
    geo_origine=gest_origine->get_mg_geometrieid(id);
    res=fgets(mess,500,in);
    sscanf(mess,"%s %lu",nomfich,&id);
    gest_modifie=new MG_FILE(nomfich);
    *gestmod=gest_modifie;
    geo_modifie=gest_modifie->get_mg_geometrieid(id);
    res=fgets(mess,500,in);
    double x,y,z;
    sscanf(mess,"%le %le %le",&x,&y,&z);
    rotation.get_vecteur1().change_x(x);
    rotation.get_vecteur1().change_y(y);
    rotation.get_vecteur1().change_z(z);
    res=fgets(mess,500,in);
    sscanf(mess,"%le %le %le",&x,&y,&z);
    rotation.get_vecteur2().change_x(x);
    rotation.get_vecteur2().change_y(y);
    rotation.get_vecteur2().change_z(z);
    res=fgets(mess,500,in);
    sscanf(mess,"%le %le %le",&x,&y,&z);
    rotation.get_vecteur3().change_x(x);
    rotation.get_vecteur3().change_y(y);
    rotation.get_vecteur3().change_z(z);
    res=fgets(mess,500,in);
    sscanf(mess,"%le %le %le",&x,&y,&z);
    translation.change_x(x);
    translation.change_y(y);
    translation.change_z(z);
    unsigned long id1,id2;
    res=fgets(mess,500,in);
    sscanf(mess,"%lu",&id1);
    res=fgets(mess,500,in);
    sscanf(mess,"%lu",&id2);
    change_face_reference1(geo_origine->get_mg_faceid(id1));
    change_face_reference2(geo_modifie->get_mg_faceid(id2));
    int nb;
    res=fgets(mess,500,in);
    sscanf(mess,"%d",&nb);
    for (int i=0;i<nb;i++)
    {
        long id1,id2;
        char c;
        char* res=fgets(mess,500,in);
        sscanf(mess,"%lu %lu %c",&id1,&id2,&c);
        CORRESPONDANCE cor(retrouver(geo_origine,id1),retrouver(geo_modifie,id2),(CORRESPONDANCE::typecorres)c);
        ajouter_liste_topologie(cor);
    }
    res=fgets(mess,500,in);
    sscanf(mess,"%d",&nb);
    for (int i=0;i<nb;i++)
    {
        char* res=fgets(mess,500,in);
        sscanf(mess,"%lu",&id);
        MG_ELEMENT_TOPOLOGIQUE* ele=retrouver(geo_origine,id);
        ajouter_liste_topologie(ORIGINE_CONSERVEE,ele);
    }
    res=fgets(mess,500,in);
    sscanf(mess,"%d",&nb);
    for (int i=0;i<nb;i++)
    {
        char* res=fgets(mess,500,in);
        sscanf(mess,"%lu",&id);
        MG_ELEMENT_TOPOLOGIQUE* ele=retrouver(geo_origine,id);
        ajouter_liste_topologie(ORIGINE_DISPARUE,ele);
    }
    res=fgets(mess,500,in);
    sscanf(mess,"%d",&nb);
    for (int i=0;i<nb;i++)
    {
        char* res=fgets(mess,500,in);
        sscanf(mess,"%lu",&id);
        MG_ELEMENT_TOPOLOGIQUE* ele=retrouver(geo_modifie,id);
        ajouter_liste_topologie(MODIFIE_CONSERVEE,ele);
    }
    res=fgets(mess,500,in);
    sscanf(mess,"%d",&nb);
    for (int i=0;i<nb;i++)
    {
        char* res=fgets(mess,500,in);
        sscanf(mess,"%lu",&id);
        MG_ELEMENT_TOPOLOGIQUE* ele=retrouver(geo_modifie,id);
        ajouter_liste_topologie(MODIFIE_APPARUE,ele);
    }
    res=fgets(mess,500,in);
    sscanf(mess,"%d",&nb);
    for (int i=0;i<nb;i++)
    {
        char* res=fgets(mess,500,in);
        unsigned long id1,id2;
        sscanf(mess,"%lu %lu",&id1,&id2);
        ajouter_correspondance(id1,id2);
    }
}
 
MG_ELEMENT_TOPOLOGIQUE* VCT_COMPARAISON_RESULTAT::retrouver(MG_GEOMETRIE* geo,long id)
{
    MG_ELEMENT_TOPOLOGIQUE* ele=NULL;
    ele=geo->get_mg_sommetid(id);
    if (ele==NULL) ele=geo->get_mg_areteid(id);
    if (ele==NULL) ele=geo->get_mg_faceid(id);
    return ele;
}
 
 
int VCT_COMPARAISON_RESULTAT::get_nb_correspondance(void)
{
    return listecorrespondante2.size();
}
 
void VCT_COMPARAISON_RESULTAT::ajouter_correspondance(unsigned long idorigine,unsigned long idmodifie)
{
    std::pair<unsigned long,unsigned long> tmp(idorigine,idmodifie);
    listecorrespondante2.insert(tmp);
    std::pair<unsigned long,unsigned long> tmp2(idmodifie,idorigine);
    listecorrespondante3.insert(tmp2);
}
 
unsigned long VCT_COMPARAISON_RESULTAT::get_correspondance_origine(unsigned long idorigine)
{
    unsigned long id=(*listecorrespondante2.find(idorigine)).second;
    return id;
}
 
unsigned long VCT_COMPARAISON_RESULTAT::get_correspondance_modifie(unsigned long idmodifie)
{
    unsigned long id=(*listecorrespondante3.find(idmodifie)).second;
    return id;
}
 
int  VCT_COMPARAISON_RESULTAT::get_correspondance_premier(unsigned long &idorigine,unsigned long &idmodifie)
{
    it=listecorrespondante2.begin();
    if (it==listecorrespondante2.end()) return 0;
    idorigine=(*it).first;
    idmodifie=(*it).second;
    return 1;
}
 
int VCT_COMPARAISON_RESULTAT::get_correspondance_suivant(unsigned long &idorigine,unsigned long &idmodifie)
{
    it++;
    if (it==listecorrespondante2.end()) return 0;
    idorigine=(*it).first;
    idmodifie=(*it).second;
    return 1;
}
 
 
OT_VECTEUR_3D VCT_COMPARAISON_RESULTAT::change_coord_ori_mod(OT_VECTEUR_3D vec)
{
    OT_VECTEUR_3D vecres=rotation*vec+translation;
    return vecres;
}
 
OT_VECTEUR_3D VCT_COMPARAISON_RESULTAT::change_coord_mod_ori(OT_VECTEUR_3D vec)
{
    OT_MATRICE_3D rotinv;
    rotation.transpose(rotinv);
    OT_VECTEUR_3D vecres=rotinv*vec-rotinv*translation;
    return vecres;
}
 
OT_VECTEUR_3D VCT_COMPARAISON_RESULTAT::change_vecteur_ori_mod(OT_VECTEUR_3D vec)
{
    OT_VECTEUR_3D vecres=rotation*vec;
    return vecres;
}
 
 
OT_VECTEUR_3D VCT_COMPARAISON_RESULTAT::change_vecteur_mod_ori(OT_VECTEUR_3D vec)
{
    OT_MATRICE_3D rotinv;
    rotation.transpose(rotinv);
    OT_VECTEUR_3D vecres=rotinv*vec;
    return vecres;
}
 
 
OT_MATRICE_3D VCT_COMPARAISON_RESULTAT::change_base_ori_mod(OT_MATRICE_3D base)
{
    OT_MATRICE_3D baseres=rotation*base;
    return baseres;
}
 
OT_MATRICE_3D VCT_COMPARAISON_RESULTAT::change(OT_TENSEUR* tens)
{
    OT_VECTEUR_3D vec1((*tens)(0,0).get_x(),(*tens)(1,0).get_x(),(*tens)(2,0).get_x());
    OT_VECTEUR_3D vec2((*tens)(0,1).get_x(),(*tens)(1,1).get_x(),(*tens)(2,1).get_x());
    OT_VECTEUR_3D vec3((*tens)(0,2).get_x(),(*tens)(1,2).get_x(),(*tens)(2,2).get_x());
    OT_MATRICE_3D mat(vec1,vec2,vec3);
    return mat;
}
 
 
OT_MATRICE_3D VCT_COMPARAISON_RESULTAT::change_base_mod_ori(OT_MATRICE_3D base)
{
    OT_MATRICE_3D rotinv;
    rotation.transpose(rotinv);
    OT_MATRICE_3D baseres=rotinv*base;
    return baseres;
}
 
void VCT_COMPARAISON_RESULTAT::ajouter_similarite(unsigned long val)
{
similarite.ajouter(val);  
}
 
void VCT_COMPARAISON_RESULTAT::ajouter_identite(unsigned long val)
{
identite.ajouter(val);  
}
 
void VCT_COMPARAISON_RESULTAT::ajouter_localise_face(unsigned long val)
{
localise_face.ajouter(val);  
}
void VCT_COMPARAISON_RESULTAT::ajouter_localise_arete(unsigned long val)
{
localise_arete.ajouter(val);  
}
void VCT_COMPARAISON_RESULTAT::ajouter_localise_sommet(unsigned long val)
{
localise_sommet.ajouter(val);  
}
void VCT_COMPARAISON_RESULTAT::ajouter_modifie_face(unsigned long val)
{
modifie_face.ajouter(val);  
}
void VCT_COMPARAISON_RESULTAT::ajouter_modifie_arete(unsigned long val)
{
modifie_arete.ajouter(val);  
}
 
int VCT_COMPARAISON_RESULTAT::get_nb_liste_similarite(void)
{
    return similarite.get_nb();
}
 
int VCT_COMPARAISON_RESULTAT::get_nb_liste_identite(void)
{
    return identite.get_nb();
}
 
int VCT_COMPARAISON_RESULTAT::get_nb_liste_localise_face(void)
{
    return localise_face.get_nb();
}
 
long unsigned int VCT_COMPARAISON_RESULTAT::get_liste_localise_face(int num)
{
    return localise_face.get(num);
}
 
long unsigned int VCT_COMPARAISON_RESULTAT::get_liste_identite(int num)
{
    return identite.get(num);
}
 
long unsigned int VCT_COMPARAISON_RESULTAT::get_liste_similarite(int num)
{
    return similarite.get(num);
}
 
 
 
 
void VCT_COMPARAISON_RESULTAT::compare_enregistrement(char *nom,char *nom1,char *nom2)
{
FILE* in =fopen(nom,"wt");
fprintf(in,"//*************************************************************\n");
fprintf(in,"//                 CAD Model Comparison\n");
fprintf(in,"//      Jean-Christophe Cuillière and Vincent Francois\n");
fprintf(in,"//                  ERICCA - UQTR \n");
fprintf(in,"//*************************************************************\n");
fprintf(in,"Model A:\n");
fprintf(in,"      %s\n",nom1);
fprintf(in,"Model B:\n");
fprintf(in,"      %s\n",nom2);
fprintf(in,"Reference faces :\n");
fprintf(in,"  Model A:\n");
fprintf(in,"      %lu\n",faceref1->get_id());
fprintf(in,"  Model B:\n");
fprintf(in,"      %lu\n",faceref2->get_id());
fprintf(in,"Transformation matrix :\n");
fprintf(in," %le %le %le %le\n",rotation.get_vecteur1().get_x(),rotation.get_vecteur2().get_x(),rotation.get_vecteur3().get_x(),translation.get_x());
fprintf(in," %le %le %le %le\n",rotation.get_vecteur1().get_y(),rotation.get_vecteur2().get_y(),rotation.get_vecteur3().get_y(),translation.get_y());
fprintf(in," %le %le %le %le\n",rotation.get_vecteur1().get_z(),rotation.get_vecteur2().get_z(),rotation.get_vecteur3().get_z(),translation.get_z());
fprintf(in," %le %le %le %le\n",0.,0.,0.,1.);
fprintf(in,"%d Similar faces :\n",similarite.get_nb()/2);
for (int i=0;i<similarite.get_nb()/2;i++)
  fprintf(in,"  %lu %lu\n",similarite.get(2*i),similarite.get(2*i+1));
fprintf(in,"%d Identical faces :\n",identite.get_nb()/2);
for (int i=0;i<identite.get_nb()/2;i++)
  fprintf(in,"  %lu %lu\n",identite.get(2*i),identite.get(2*i+1));
fprintf(in,"%d Localized identical faces :\n",localise_face.get_nb()/2);
for (int i=0;i<localise_face.get_nb()/2;i++)
  fprintf(in,"  %lu %lu\n",localise_face.get(2*i),localise_face.get(2*i+1));
fprintf(in,"%d Localized identical edges :\n",localise_arete.get_nb()/2);
for (int i=0;i<localise_arete.get_nb()/2;i++)
  fprintf(in,"  %lu %lu\n",localise_arete.get(2*i),localise_arete.get(2*i+1));
fprintf(in,"%d Localized identical vertices :\n",localise_sommet.get_nb()/2);
for (int i=0;i<localise_sommet.get_nb()/2;i++)
  fprintf(in,"  %lu %lu\n",localise_sommet.get(2*i),localise_sommet.get(2*i+1));
fprintf(in,"%d Localized modified faces :\n",modifie_face.get_nb()/2);
for (int i=0;i<modifie_face.get_nb()/2;i++)
  fprintf(in,"  %lu %lu\n",modifie_face.get(2*i),modifie_face.get(2*i+1));
fprintf(in,"%d Localized modified edges :\n",modifie_arete.get_nb()/2);
for (int i=0;i<modifie_arete.get_nb()/2;i++)
  fprintf(in,"  %lu %lu\n",modifie_arete.get(2*i),modifie_arete.get(2*i+1));
fprintf(in,"//*************************************************************\n");
fprintf(in,"//                      End of file\n");
fprintf(in,"//*************************************************************\n");
fclose(in);
}