mailleur2d_mergemai.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/
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//
//####//       mailleur2d_mergemai.cpp
//####//
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//    COPYRIGHT 2000-2024
//####//  jeu 13 jun 2024 11:58:55 EDT
//####//------------------------------------------------------------
//####//------------------------------------------------------------
#include "mailleur2d_mergemai.h"
#include "gestionversion.h"
#include "mg_gestionnaire.h"
#include "mg_maillage_outils.h"
#include <string.h>
#include "mg_geometrie.h"
#include <stdio.h>
#include "gestionversion.h"
#include "mailleur2d_ins_noeud.h"
#include "mg_gestionnaire.h"
#include "robustpredicates.hxx"
#include <math.h>
#include <map>
#include "mg_maillage_outils.h"
#include "mg_file.h"
#include "occ_import.h"
#include "fct_generateur_3d.h"
#include "mg_geometrie_outils.h"
#include "ot_mathematique.h"
#include "mailleur2d_optimisation.h"
#include "mg_sommet_noeud.h"
 
MAILLEUR2D_MERGEMAI::MAILLEUR2D_MERGEMAI(char* cadfilenametmp,char* scanfilenametmp, char* mergefilenametmp,int cadmeshnotmp,int scnmeshnotmp)
:MAILLEUR(false),cadfilename(cadfilenametmp),scanfilename(scanfilenametmp),mergefilename(mergefilenametmp),cadmeshno(cadmeshnotmp),scnmeshno(scnmeshnotmp)//MAILLEUR(false): since it is a child of MAILLEUR
{
}
MAILLEUR2D_MERGEMAI::MAILLEUR2D_MERGEMAI(MAILLEUR2D_MERGEMAI& mdd)
:MAILLEUR(mdd),cadfilename(mdd.cadfilename),scanfilename(mdd.scanfilename),mergefilename(mdd.mergefilename),cadmeshno(mdd.cadmeshno),scnmeshno(mdd.scnmeshno)
{
}
MAILLEUR2D_MERGEMAI::~MAILLEUR2D_MERGEMAI()
{
}
 
void MAILLEUR2D_MERGEMAI::mergmsh(void)
{
  affiche((char*) "merging started");
  MG_FILE gestcad(cadfilename); //deformedcad_sansscannedpart.magic
  MG_FILE gestscn(scanfilename); //3dsurfmesh_scanned.magic
  MG_GESTIONNAIRE mergegest;
  MG_MAILLAGE* maicad;
  MG_MAILLAGE* maiscn;
  MG_MAILLAGE* maimrg=new MG_MAILLAGE(NULL);
  mergegest.ajouter_mg_maillage(maimrg);
  if (cadmeshno==0) maicad=gestcad.get_mg_maillageid(cadmeshno); else maicad=gestcad.get_mg_maillageid(cadmeshno);//256171
  if (scnmeshno==0) maiscn=gestscn.get_mg_maillageid(scnmeshno); else maiscn=gestscn.get_mg_maillageid(scnmeshno);//1669364
  
  LISTE_MG_NOEUD::iterator itnds;
  LISTE_MG_SEGMENT::iterator itSeg;
  LISTE_MG_TRIANGLE::iterator itTri;
  //read scan and cad mesh
  for(MG_NOEUD* cadnd=maicad->get_premier_noeud(itnds);cadnd!=NULL;cadnd=maicad->get_suivant_noeud(itnds))
  {
    double x=cadnd->get_x(); 
    double y=cadnd->get_y(); 
    double z=cadnd->get_z();
    MG_NOEUD *newno=new MG_NOEUD(NULL,x,y,z,cadnd->get_origine());
    maimrg->ajouter_mg_noeud(newno);
    cadnd->change_nouveau_numero(newno->get_id());
    newno->change_nouveau_numero(1); //cadmesh nds in merge mesh has nouveau_numero=1
  }
  for (MG_SEGMENT * segment =maicad->get_premier_segment(itSeg); segment!=NULL; segment=maicad->get_suivant_segment(itSeg))
  {
    MG_ELEMENT_TOPOLOGIQUE *topseg=segment->get_lien_topologie();
    MG_FACE* faceseg=(MG_FACE*) (segment->get_lien_topologie());
    MG_NOEUD* no1=maimrg->get_mg_noeudid(segment->get_noeud1()->get_nouveau_numero());
    MG_NOEUD* no2=maimrg->get_mg_noeudid(segment->get_noeud2()->get_nouveau_numero());
    MG_SEGMENT *seg=new MG_SEGMENT(NULL,no1,no2,segment->get_origine());
    maimrg->ajouter_mg_segment(seg);
  }
  for (MG_TRIANGLE * triangle =maicad->get_premier_triangle(itTri); triangle; triangle=maicad->get_suivant_triangle(itTri))      
  {
    MG_ELEMENT_TOPOLOGIQUE *toptri=triangle->get_lien_topologie();
    MG_FACE* facetri=(MG_FACE*) (triangle->get_lien_topologie());
    MG_NOEUD* no1=maimrg->get_mg_noeudid(triangle->get_noeud1()->get_nouveau_numero());
    MG_NOEUD* no2=maimrg->get_mg_noeudid(triangle->get_noeud2()->get_nouveau_numero());
    MG_NOEUD* no3=maimrg->get_mg_noeudid(triangle->get_noeud3()->get_nouveau_numero());
    maimrg->ajouter_mg_triangle(NULL,no1,no2,no3,triangle->get_origine());
  }
  for(MG_NOEUD* cadnd=maiscn->get_premier_noeud(itnds);cadnd!=NULL;cadnd=maiscn->get_suivant_noeud(itnds))
  {
    double x=cadnd->get_x(); 
    double y=cadnd->get_y(); 
    double z=cadnd->get_z();
    MG_NOEUD *newno=new MG_NOEUD(NULL,x,y,z,cadnd->get_origine());
    maimrg->ajouter_mg_noeud(newno);
    cadnd->change_nouveau_numero(newno->get_id());
    newno->change_nouveau_numero(2); //scanmesh nds in merge mesh has nouveau_numero=2
  }
  for (MG_SEGMENT * segment =maiscn->get_premier_segment(itSeg); segment!=NULL; segment=maiscn->get_suivant_segment(itSeg))
  {
    MG_ELEMENT_TOPOLOGIQUE *topseg=segment->get_lien_topologie();
    MG_FACE* faceseg=(MG_FACE*) (segment->get_lien_topologie());
    MG_NOEUD* no1=maimrg->get_mg_noeudid(segment->get_noeud1()->get_nouveau_numero());
    MG_NOEUD* no2=maimrg->get_mg_noeudid(segment->get_noeud2()->get_nouveau_numero());
    MG_SEGMENT *seg=new MG_SEGMENT(NULL,no1,no2,segment->get_origine());
    maimrg->ajouter_mg_segment(seg);
  }
  for (MG_TRIANGLE * triangle =maiscn->get_premier_triangle(itTri); triangle; triangle=maiscn->get_suivant_triangle(itTri))      
  {
    MG_ELEMENT_TOPOLOGIQUE *toptri=triangle->get_lien_topologie();
    MG_FACE* facetri=(MG_FACE*) (triangle->get_lien_topologie());
    MG_NOEUD* no1=maimrg->get_mg_noeudid(triangle->get_noeud1()->get_nouveau_numero());
    MG_NOEUD* no2=maimrg->get_mg_noeudid(triangle->get_noeud2()->get_nouveau_numero());
    MG_NOEUD* no3=maimrg->get_mg_noeudid(triangle->get_noeud3()->get_nouveau_numero());
    maimrg->ajouter_mg_triangle(NULL,no1,no2,no3,triangle->get_origine());
  }
  
  TPL_MAP_ENTITE<MG_SEGMENT*> lst_sgcad;
  TPL_MAP_ENTITE<MG_NOEUD*> lst_ndcad;
  for (MG_SEGMENT * segment =maimrg->get_premier_segment(itSeg); segment!=NULL; segment=maimrg->get_suivant_segment(itSeg))
  {
    if(segment->get_noeud1()->get_nouveau_numero()==1 && segment->get_noeud2()->get_nouveau_numero()==1)
    {
      lst_ndcad.ajouter(segment->get_noeud1());
      lst_ndcad.ajouter(segment->get_noeud2());
      lst_sgcad.ajouter(segment);
    }
  }
  
    //find the boundary elements
  TPL_MAP_ENTITE<MG_SEGMENT*> edgsegcad;
  TPL_MAP_ENTITE<MG_NOEUD*> edgndcad;
  TPL_MAP_ENTITE<MG_SEGMENT*> edgsegscn;
  TPL_MAP_ENTITE<MG_NOEUD*> edgndscn;
  TPL_MAP_ENTITE<MG_SEGMENT*> bndryseglstcad;
  TPL_MAP_ENTITE<MG_NOEUD*> bndryndlstcad;
  TPL_MAP_ENTITE<MG_SEGMENT*> bndryseglstscan;
  TPL_MAP_ENTITE<MG_NOEUD*> bndryndlstscan;
  for(MG_SEGMENT* segmnt=maimrg->get_premier_segment(itSeg);segmnt!=NULL;segmnt=maimrg->get_suivant_segment(itSeg))
  {
    if(segmnt->get_lien_triangle()->get_nb()==1)
    {
      if(segmnt->get_noeud1()->get_nouveau_numero()==1 && segmnt->get_noeud2()->get_nouveau_numero()==1)
      {
        segmnt->get_noeud1()->change_nouveau_numero(3);
        segmnt->get_noeud2()->change_nouveau_numero(3);
        bndryseglstcad.ajouter(segmnt);
        edgsegcad.ajouter(segmnt);
        bndryndlstcad.ajouter(segmnt->get_noeud1());
        bndryndlstcad.ajouter(segmnt->get_noeud2());
        edgndcad.ajouter(segmnt->get_noeud1());
        edgndcad.ajouter(segmnt->get_noeud2());
      }
      if(segmnt->get_noeud1()->get_nouveau_numero()==2 && segmnt->get_noeud2()->get_nouveau_numero()==2)
      {
        segmnt->get_noeud1()->change_nouveau_numero(4);
        segmnt->get_noeud2()->change_nouveau_numero(4);
        bndryseglstscan.ajouter(segmnt);
        edgsegscn.ajouter(segmnt);
        bndryndlstscan.ajouter(segmnt->get_noeud1());
        bndryndlstscan.ajouter(segmnt->get_noeud2());
        edgndscn.ajouter(segmnt->get_noeud1());
        edgndscn.ajouter(segmnt->get_noeud2());
      }
    }
 
  }
double xmin=1e308,ymin=1e308,zmin=1e308,xmax=-1e308,ymax=-1e308,zmax=-1e308;
TPL_MAP_ENTITE<MG_NOEUD*> lstnoeud;
LISTE_MG_NOEUD::iterator it;
for (MG_NOEUD* no=maimrg->get_premier_noeud(it);no!=NULL;no=maimrg->get_suivant_noeud(it))
  {
  if (no->get_x()<xmin) xmin=no->get_x();  
  if (no->get_y()<ymin) ymin=no->get_y();
  if (no->get_z()<zmin) zmin=no->get_z();  
  if (no->get_x()>xmax) xmax=no->get_x();  
  if (no->get_y()>ymax) ymax=no->get_y();  
  if (no->get_z()>zmax) zmax=no->get_z();
  lstnoeud.ajouter(no);
  }
 OT_VECTEUR_3D vecmin(xmin,ymin,zmin);OT_VECTEUR_3D vecmmax(xmax,ymax,zmax);
 OT_VECTEUR_3D vec(vecmmax,vecmin);
 double search_radius=0.001*(vec.get_longueur());
 OT_VECTEUR_3D min(xmin,ymin,zmin); OT_VECTEUR_3D max(xmax,ymax,zmax); OT_VECTEUR_3D average=(min+max)/2.; OT_VECTEUR_3D lengthvec(min,max);
 double length=sqrt(lengthvec*lengthvec); double bxr=2.1;
 xmin=average.get_x()-(length*bxr);ymin=average.get_y()-(length*bxr);zmin=average.get_z()-(length*bxr);
 xmax=average.get_x()+(length*bxr);ymax=average.get_y()+(length*bxr);zmax=average.get_z()+(length*bxr);
 
TPL_OCTREE<MG_NOEUD*,MG_NOEUD*> octreends;
octreends.initialiser(&bndryndlstcad,1,xmin,ymin,zmin,xmax,ymax,zmax);
TPL_MAP_ENTITE<MG_NOEUD*>::ITERATEUR itbndryndlstcad;
for(MG_NOEUD* no1=bndryndlstcad.get_premier(itbndryndlstcad);no1!=NULL;no1=bndryndlstcad.get_suivant(itbndryndlstcad))
  octreends.inserer(no1);
 
TPL_OCTREE<MG_SEGMENT*,MG_NOEUD*> octreesegs;
LISTE_MG_SEGMENT::iterator itseg;
octreesegs.initialiser(&lst_ndcad,1,xmin,ymin,zmin,xmax,ymax,zmax);
TPL_MAP_ENTITE<MG_SEGMENT*>::ITERATEUR itbndryseglstcad;
for(MG_SEGMENT* seg=lst_sgcad.get_premier(itbndryseglstcad);seg!=NULL;seg=lst_sgcad.get_suivant(itbndryseglstcad))
  octreesegs.inserer(seg);
 
TPL_MAP_ENTITE<MG_NOEUD*>::ITERATEUR itmpnd;
TPL_MAP_ENTITE<MG_SEGMENT*>::ITERATEUR itmpsg;
TPL_MAP_ENTITE<MG_TRIANGLE*>::ITERATEUR itmptri;
 
for(MG_SEGMENT* seg=maimrg->get_premier_segment(itseg);seg!=NULL;seg=maimrg->get_suivant_segment(itseg))
{
  //if(seg->get_lien_triangle()->get_nb()<1 || seg->get_lien_triangle()->get_nb()>2)
    //cout<<"seg->get_lien_triangle()->get_nb()= "<<seg->get_lien_triangle()->get_nb()<<endl;
}
 
double proximity_coof=20.1*search_radius; //can be based on the size of scan mesh
int beshmar1=0;
TPL_MAP_ENTITE<MG_NOEUD*> removescnbndnd;
for(MG_NOEUD* nd=bndryndlstscan.get_premier(itmpnd);nd!=NULL;nd=bndryndlstscan.get_suivant(itmpnd))
{
  beshmar1++;
  //cout<<"                     beshmar1= "<<beshmar1<<endl;
  //cout<<"bndryndlstscan.get_nb()= "<<bndryndlstscan.get_nb()<<endl;
 proxndmerg(maimrg,search_radius,nd,octreends,proximity_coof,removescnbndnd,octreesegs);
}
 
TPL_MAP_ENTITE<MG_NOEUD*> bndryndlstscan_afterprox;
for(MG_NOEUD* nd=bndryndlstscan.get_premier(itmpnd);nd!=NULL;nd=bndryndlstscan.get_suivant(itmpnd))
{
  int should_remove=0;
  TPL_MAP_ENTITE<MG_NOEUD*>::ITERATEUR itremovescnbndnd;
  for(MG_NOEUD* ndbnd=removescnbndnd.get_premier(itremovescnbndnd);ndbnd!=NULL;ndbnd=removescnbndnd.get_suivant(itremovescnbndnd))
  {
    if(ndbnd==nd)
      should_remove++;
  }
  if(should_remove==0)
    bndryndlstscan_afterprox.ajouter(nd);
}
int testbeshmr=0;
TPL_MAP_ENTITE<MG_NOEUD*> removescnbndnd_prxseg;
for(MG_NOEUD* bndscnd=bndryndlstscan_afterprox.get_premier(itmpnd);bndscnd!=NULL;bndscnd=bndryndlstscan_afterprox.get_suivant(itmpnd))
{
  testbeshmr++;
  //cout<<"testbeshmr= "<<testbeshmr<<endl;
 //if (testbeshmr<5)
 proxsegmrg(maimrg,search_radius,bndscnd,octreesegs,removescnbndnd_prxseg);
}
                                                TPL_MAP_ENTITE<MG_NOEUD*> bndryndlstscan_afterproxseg;
for(MG_NOEUD* nd=bndryndlstscan_afterprox.get_premier(itmpnd);nd!=NULL;nd=bndryndlstscan_afterprox.get_suivant(itmpnd))
{
  int should_remove=0;
  TPL_MAP_ENTITE<MG_NOEUD*>::ITERATEUR itremovescnbndnd;
  for(MG_NOEUD* ndbnd=removescnbndnd_prxseg.get_premier(itremovescnbndnd);ndbnd!=NULL;ndbnd=removescnbndnd_prxseg.get_suivant(itremovescnbndnd))
  {
    if(ndbnd==nd)
      should_remove++;
  }
  if(should_remove==0)
    bndryndlstscan_afterproxseg.ajouter(nd);
}
  mergegest.enregistrer(mergefilename);
}
 
void MAILLEUR2D_MERGEMAI::proxndmerg(MG_MAILLAGE* maimrg, double search_radius,MG_NOEUD* nd,TPL_OCTREE<MG_NOEUD*,MG_NOEUD*> &octreends,double proximity_coof,
                             TPL_MAP_ENTITE<MG_NOEUD*> &removescnbndnd,TPL_OCTREE<MG_SEGMENT*,MG_NOEUD*> &octreesegs)
{
TPL_MAP_ENTITE<MG_NOEUD*> lstndnei;
int lstndneinb=lstndnei.get_nb();
double search_radius1=search_radius;
 
{
  octreends.rechercher(nd->get_x(),nd->get_y(),nd->get_z(),search_radius1,lstndnei);
  lstndneinb=lstndnei.get_nb();
  //if(lstndneinb<1)
    //maimrg->supprimer_mg_triangleid(nd->get_lien_triangle()->get(0)->get_id());
    
  if(lstndneinb>0)
  {
    //cout<<"lstndnei.get_nb() before:= "<<lstndnei.get_nb()<<endl;
    TPL_MAP_ENTITE<MG_NOEUD*>::ITERATEUR itmpnd1;
    for(MG_NOEUD* ndclosecad=lstndnei.get_premier(itmpnd1);ndclosecad!=NULL;ndclosecad=lstndnei.get_suivant(itmpnd1))
    {
      double dist=sqrt(pow(ndclosecad->get_x()-nd->get_x(),2)+pow(ndclosecad->get_y()-nd->get_y(),2)+pow(ndclosecad->get_z()-nd->get_z(),2));
      //cout<<"                                         distdist= "<<dist<<endl;
      if(ndclosecad->get_nouveau_numero()!=3)
        lstndnei.supprimer(ndclosecad);
    }
    lstndneinb=lstndnei.get_nb();
  }
  
  search_radius1=search_radius1+0.1*search_radius;
}
 
std::multimap<double,MG_NOEUD*,std::less<double> > closends;
if(lstndnei.get_nb()>0)
{
TPL_MAP_ENTITE<MG_NOEUD*>::ITERATEUR itmpnd2;
for(MG_NOEUD* ndclosecad=lstndnei.get_premier(itmpnd2);ndclosecad!=NULL;ndclosecad=lstndnei.get_suivant(itmpnd2))
{
  if(ndclosecad->get_nouveau_numero()==3)
  {
    double dist=sqrt(pow(ndclosecad->get_x()-nd->get_x(),2)+pow(ndclosecad->get_y()-nd->get_y(),2)+pow(ndclosecad->get_z()-nd->get_z(),2));
    closends.insert(std::pair<double,MG_NOEUD*> (dist,ndclosecad));    
  }
}
 
TPL_MAP_ENTITE<MG_NOEUD*> proxnds;
for(std::multimap<double,MG_NOEUD*,std::less<double> >::iterator itclosends=closends.begin();itclosends!=closends.end();itclosends++)
{
  double distancenew=(*itclosends).first;
  //cout<<"distancenew= "<<distancenew<<endl;
  if(distancenew<proximity_coof)
    proxnds.ajouter((*itclosends).second);
}
/*
LISTE_MG_SEGMENT::iterator itseg1;
for(MG_SEGMENT* seg=maimrg->get_premier_segment(itseg1);seg!=NULL;seg=maimrg->get_suivant_segment(itseg1))
{
  if(seg->get_lien_triangle()->get_nb()<1 || seg->get_lien_triangle()->get_nb()>2)
    cout<<"seg->get_lien_triangle()->get_nb()11111111111111= "<<seg->get_lien_triangle()->get_nb()<<endl;
}
*/
  TPL_MAP_ENTITE<MG_NOEUD*>::ITERATEUR itmpnd3;
 for(MG_NOEUD* ndprx=proxnds.get_premier(itmpnd3);ndprx!=NULL;ndprx=proxnds.get_suivant(itmpnd3))
{
  // cout<<"ndprx->get_lien_triangle()->get_nb()= "<<ndprx->get_lien_triangle()->get_nb()<<endl;
  
  //TPL_MAP_ENTITE<MG_SEGMENT*> lstseg_conestprox;
  std::map<MG_SEGMENT*,MG_TRIANGLE*> lstseg_conestprox;
  TPL_MAP_ENTITE<MG_TRIANGLE*> lsttri_conestprox;
  TPL_MAP_ENTITE<MG_TRIANGLE*> lsttri_added;
  for(int nbsg=0;nbsg<ndprx->get_lien_triangle()->get_nb();nbsg++)
  {
    int countr_ndsg1=0;
    int countr_ndsg2=0;
    int countr_ndsg3=0;
    MG_TRIANGLE* tripr=ndprx->get_lien_triangle()->get(nbsg);
    lsttri_conestprox.ajouter(tripr);
    TPL_MAP_ENTITE<MG_NOEUD*>::ITERATEUR itmpnd4;
    if(tripr->get_segment1()->get_noeud1()!=ndprx && tripr->get_segment1()->get_noeud2()!=ndprx)
    {
      /*for(MG_NOEUD* ndprx1=proxnds.get_premier(itmpnd4);ndprx1!=NULL;ndprx1=proxnds.get_suivant(itmpnd4))
      {
        if(tripr->get_segment1()->get_noeud1()==ndprx1 || tripr->get_segment1()->get_noeud2()==ndprx1)
          countr_ndsg1++;
      }
    if(countr_ndsg1==0)*/
      lstseg_conestprox.insert(std::pair< MG_SEGMENT*,MG_TRIANGLE* >((tripr->get_segment1()),tripr));
     //lstseg_conestprox.ajouter(tripr->get_segment1());
    }
    
    if(tripr->get_segment2()->get_noeud1()!=ndprx && tripr->get_segment2()->get_noeud2()!=ndprx)
    {
      /*for(MG_NOEUD* ndprx1=proxnds.get_premier(itmpnd4);ndprx1!=NULL;ndprx1=proxnds.get_suivant(itmpnd4))
      {
        if(tripr->get_segment2()->get_noeud1()==ndprx1 || tripr->get_segment2()->get_noeud2()==ndprx1)
          countr_ndsg2++;
      }
    if(countr_ndsg2==0)*/
      lstseg_conestprox.insert(std::pair< MG_SEGMENT*,MG_TRIANGLE* >((tripr->get_segment2()),tripr));
      //lstseg_conestprox.ajouter(tripr->get_segment2());
    }
    
    if(tripr->get_segment3()->get_noeud1()!=ndprx && tripr->get_segment3()->get_noeud2()!=ndprx)
    {
      /*for(MG_NOEUD* ndprx1=proxnds.get_premier(itmpnd4);ndprx1!=NULL;ndprx1=proxnds.get_suivant(itmpnd4))
      {
        if(tripr->get_segment3()->get_noeud1()==ndprx1 || tripr->get_segment3()->get_noeud2()==ndprx1)
          countr_ndsg3++;
      }
    if(countr_ndsg3==0)*/
      lstseg_conestprox.insert(std::pair< MG_SEGMENT*,MG_TRIANGLE* >((tripr->get_segment3()),tripr));
      //lstseg_conestprox.ajouter(tripr->get_segment3());
    }
  
  }
  
TPL_MAP_ENTITE<MG_SEGMENT*> segadded;
for(std::map<MG_SEGMENT*,MG_TRIANGLE*>::iterator itlstseg_conestprox=lstseg_conestprox.begin();itlstseg_conestprox!=lstseg_conestprox.end();itlstseg_conestprox++)
{
  MG_SEGMENT* segconctprx=(*itlstseg_conestprox).first;
  //cout<<"segconctprx->get_lien_triangle()->get_nb()= "<<segconctprx->get_lien_triangle()->get_nb()<<endl;
  //cout<<"segconctprx->get_noeud1()->get_nouveau_numero()= "<<segconctprx->get_noeud1()->get_nouveau_numero()<<endl;
  //cout<<"segconctprx->get_noeud2()->get_nouveau_numero()= "<<segconctprx->get_noeud2()->get_nouveau_numero()<<endl;
  //if(segconctprx->get_lien_triangle()->get_nb()!=0)
  {
  //MG_TRIANGLE* trioppose=segconctprx->get_lien_triangle()->get(0);
   MG_TRIANGLE* trioppose=(*itlstseg_conestprox).second;
  int triorintation=0;
  if(segconctprx->get_noeud1()==trioppose->get_noeud1() && segconctprx->get_noeud2()==trioppose->get_noeud2())
    triorintation++;
  if(segconctprx->get_noeud1()==trioppose->get_noeud2() && segconctprx->get_noeud2()==trioppose->get_noeud3())
    triorintation++;
  if(segconctprx->get_noeud1()==trioppose->get_noeud3() && segconctprx->get_noeud2()==trioppose->get_noeud1())
    triorintation++;
  
 if(triorintation==0)
 {
   MG_TRIANGLE* triad=maimrg->ajouter_mg_triangle(NULL,segconctprx->get_noeud2(),segconctprx->get_noeud1(),nd,MAGIC::ORIGINE::IMPOSE);
   nd->change_nouveau_numero(3);
   segadded.ajouter(triad->get_segment1());
   segadded.ajouter(triad->get_segment2());
   segadded.ajouter(triad->get_segment3());   
}
   
 else if(triorintation>0)
 {
   MG_TRIANGLE* triad= maimrg->ajouter_mg_triangle(NULL,segconctprx->get_noeud1(),segconctprx->get_noeud2(),nd,MAGIC::ORIGINE::IMPOSE);
   nd->change_nouveau_numero(3);
   segadded.ajouter(triad->get_segment1());
   segadded.ajouter(triad->get_segment2());
   segadded.ajouter(triad->get_segment3());
 }
  }
}
removescnbndnd.ajouter(nd);
octreends.supprimer(ndprx);
 
TPL_MAP_ENTITE<MG_SEGMENT*>::ITERATEUR itsegadded;
for(MG_SEGMENT* segaded=segadded.get_premier(itsegadded);segaded!=NULL;segaded=segadded.get_suivant(itsegadded))
  octreesegs.inserer(segaded);
 
 
TPL_MAP_ENTITE<MG_TRIANGLE*>::ITERATEUR itmptri;
for(MG_TRIANGLE* tridelet=lsttri_conestprox.get_premier(itmptri);tridelet!=NULL;tridelet=lsttri_conestprox.get_suivant(itmptri))
{
  octreesegs.supprimer(tridelet->get_segment1());
  octreesegs.supprimer(tridelet->get_segment2());
  octreesegs.supprimer(tridelet->get_segment3());
  maimrg->supprimer_mg_triangleid(tridelet->get_id());
}
 
 
  
 
}
}
} 
 
void MAILLEUR2D_MERGEMAI::proxsegmrg(MG_MAILLAGE* maimrg, double search_radius,MG_NOEUD* bndscnd,TPL_OCTREE<MG_SEGMENT*,MG_NOEUD*> &octreesegs,TPL_MAP_ENTITE<MG_NOEUD*> &removescnbndnd_prxseg)
{
  //cout<<"the second part started"<<endl;
  TPL_MAP_ENTITE<MG_SEGMENT*> lstneisg;
  TPL_LISTE_ENTITE<MG_SEGMENT*> lstasupprimer;
  int lstneisgnb=lstneisg.get_nb();
  double search_radius1=search_radius;
  //while(lstneisgnb==0) 
  {
    octreesegs.rechercher(bndscnd->get_x(),bndscnd->get_y(),bndscnd->get_z(),search_radius1,lstneisg);
    lstneisgnb=lstneisg.get_nb();
    search_radius1=search_radius1+0.1*search_radius;
    if(lstneisgnb>0)
    {
      //cout<<"                                 lstneisgnb =  "<<lstneisgnb<<endl;
      TPL_MAP_ENTITE<MG_SEGMENT*>::ITERATEUR itmpsg1;
      for(MG_SEGMENT* clsgcad=lstneisg.get_premier(itmpsg1);clsgcad!=NULL;clsgcad=lstneisg.get_suivant(itmpsg1))
      {
        if(clsgcad->get_noeud1()->get_nouveau_numero()!=3 && clsgcad->get_noeud2()->get_nouveau_numero()!=3)
          lstasupprimer.ajouter(clsgcad);
        
        OT_VECTEUR_3D vec1(clsgcad->get_noeud1()->get_coord(),bndscnd->get_coord());
        OT_VECTEUR_3D vec2(clsgcad->get_noeud1()->get_coord(),clsgcad->get_noeud2()->get_coord());
        double val1=vec1*vec2;
        double val2=vec2*vec2;
        
        if(val1<0 || val1>val2)
        {
          //cout<<"             vec1*vec2= "<<val1<<" vec1*vec1= "<<val2<<endl;
          //cout<<"             vec1= "<<vec1.get_longueur()<<" vec1= "<<vec2.get_longueur()<<endl;
          lstasupprimer.ajouter(clsgcad);
        }
        else 
        {
          //cout<<"                             yeki moondehhhh"<<endl;
          //cout<<"??????               vec1*vec2= "<<val1<<" vec1*vec1= "<<val2<<endl;
        //cout<<"??????         vec1= "<<vec1.get_longueur()<<" vec1= "<<vec2.get_longueur()<<endl;
        } 
        
        //cout<<"clsgcad->get_lien_triangle()->get_nb()="<<clsgcad->get_lien_triangle()->get_nb()<<endl;
        //if(clsgcad->get_lien_triangle()->get_nb()>1)
         // lstneisg.supprimer(clsgcad);
      }
    }
  }
  for (int i=0;i<lstasupprimer.get_nb();i++)
    {
     MG_SEGMENT* seg=lstasupprimer.get(i);
     lstneisg.supprimer(seg);
    }
  //if(lstneisg.get_nb()==0)
  //cout<<"                                                                     lstneisg.get_nb()==0 lstneisg.get_nb()==0 lstneisg.get_nb()==0"<<endl;
  if(lstneisg.get_nb()>0)
  {
  std::multimap<double,MG_SEGMENT*,std::less<double> > closesegscad;
  TPL_MAP_ENTITE<MG_SEGMENT*>::ITERATEUR itmpsg2;
  for(MG_SEGMENT* clsgcad=lstneisg.get_premier(itmpsg2);clsgcad!=NULL;clsgcad=lstneisg.get_suivant(itmpsg2))
  {
    if(clsgcad->get_noeud1()->get_nouveau_numero()!=2 || clsgcad->get_noeud2()->get_nouveau_numero()!=2)
    {
      //the distance between a point and a segment is not accurate in 3D
      /*
      double distns1=sqrt(pow(clsgcad->get_noeud1()->get_x()-bndscnd->get_x(),2)+pow(clsgcad->get_noeud1()->get_y()-bndscnd->get_y(),2)+pow(clsgcad->get_noeud1()->get_z()-bndscnd->get_z(),2));
      double distns2=sqrt(pow(clsgcad->get_noeud2()->get_x()-bndscnd->get_x(),2)+pow(clsgcad->get_noeud2()->get_y()-bndscnd->get_y(),2)+pow(clsgcad->get_noeud2()->get_z()-bndscnd->get_z(),2));
      double distns=(distns1+distns2)/2.;
      */
      OT_VECTEUR_3D vec1(clsgcad->get_noeud1()->get_coord(),bndscnd->get_coord());
      OT_VECTEUR_3D vec2(clsgcad->get_noeud1()->get_coord(),clsgcad->get_noeud2()->get_coord());
      double val1=vec1*vec2;
      double val2=vec2*vec2;
      OT_VECTEUR_3D vec3=(val1/(vec1.get_longueur()*vec1.get_longueur()))*vec1;
      OT_VECTEUR_3D vec4=vec3-vec2;
      double distns=vec4.get_longueur();
      closesegscad.insert(std::pair<double,MG_SEGMENT*>(distns,clsgcad));
    }
  }
  //for(multimap<double,MG_SEGMENT*,std::less<double> >::iterator itclosgs=closesegscad.begin();itclosgs!=closesegscad.end();itclosgs++)
  std::multimap<double,MG_SEGMENT*,std::less<double> >::iterator itclosgs=closesegscad.begin();
  {
    MG_SEGMENT* cadsegprx=(*itclosgs).second;
    MG_TRIANGLE* tricont=cadsegprx->get_lien_triangle()->get(0);
    TPL_MAP_ENTITE<MG_SEGMENT*> tricontsgs;
    if(tricont->get_segment1()!=cadsegprx)
      tricontsgs.ajouter(tricont->get_segment1());
    if(tricont->get_segment2()!=cadsegprx)
      tricontsgs.ajouter(tricont->get_segment2());
    if(tricont->get_segment3()!=cadsegprx)
      tricontsgs.ajouter(tricont->get_segment3());
    TPL_MAP_ENTITE<MG_SEGMENT*> segadded;
    TPL_MAP_ENTITE<MG_SEGMENT*>::ITERATEUR ittricontsgs;
    for(MG_SEGMENT* seg=tricontsgs.get_premier(ittricontsgs);seg!=NULL;seg=tricontsgs.get_suivant(ittricontsgs))
    {
      int newtriorient=0;
      if(seg->get_noeud1()==tricont->get_noeud1() && seg->get_noeud2()==tricont->get_noeud2())
        newtriorient++;
      if(seg->get_noeud1()==tricont->get_noeud2() && seg->get_noeud2()==tricont->get_noeud3())
        newtriorient++;
      if(seg->get_noeud1()==tricont->get_noeud3() && seg->get_noeud2()==tricont->get_noeud1())
        newtriorient++;
      if(newtriorient==0)
      {
        MG_TRIANGLE* triad= maimrg->ajouter_mg_triangle(NULL,seg->get_noeud2(),seg->get_noeud1(),bndscnd,MAGIC::ORIGINE::IMPOSE);
        bndscnd->change_nouveau_numero(3);
        segadded.ajouter(triad->get_segment1());
        segadded.ajouter(triad->get_segment2());
        segadded.ajouter(triad->get_segment3());
      }
      else if(newtriorient>0)
      {
        MG_TRIANGLE* triad=maimrg->ajouter_mg_triangle(NULL,seg->get_noeud1(),seg->get_noeud2(),bndscnd,MAGIC::ORIGINE::IMPOSE);
        bndscnd->change_nouveau_numero(3);
        segadded.ajouter(triad->get_segment1());
        segadded.ajouter(triad->get_segment2());
        segadded.ajouter(triad->get_segment3());
      }
    }
TPL_MAP_ENTITE<MG_SEGMENT*>::ITERATEUR itsegadded;
for(MG_SEGMENT* segaded=segadded.get_premier(itsegadded);segaded!=NULL;segaded=segadded.get_suivant(itsegadded))
  octreesegs.inserer(segaded);
   
    octreesegs.supprimer(tricont->get_segment1());
    octreesegs.supprimer(tricont->get_segment2());
    octreesegs.supprimer(tricont->get_segment3());
    maimrg->supprimer_mg_triangleid(tricont->get_id());
  }
  removescnbndnd_prxseg.ajouter(bndscnd);
  }
  
}