mailleur2d_ins_noeud.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_ins_noeud.cpp
//####//
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//    COPYRIGHT 2000-2024
//####//  jeu 13 jun 2024 11:58:55 EDT
//####//------------------------------------------------------------
//####//------------------------------------------------------------
 
#include "gestionversion.h"
#include "mg_gestionnaire.h"
#include "mg_maillage_outils.h"
#include <string.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 "mailleur0d.h"
#include "mailleur1d.h"
#include "mailleur2d.h"
#include "mailleur3d.h"
#include "mg_geometrie_outils.h"
#include "ot_mathematique.h"
#include "mailleur2d_optimisation.h"
#include "mg_sommet_noeud.h"
 
MAILLEUR2D_INS_NOEUD::MAILLEUR2D_INS_NOEUD(char* magicfilenametmp,int meshnotmp,char* inspointfilenametmp,char* outputfilenametmp,int nivopttmp,int qualswaptmp,double proxvaltmp, double proxedgevaltmp)
:MAILLEUR(false),magicfilename(magicfilenametmp),meshno(meshnotmp),inspointfilename(inspointfilenametmp),outputfilename(outputfilenametmp),nivopt(nivopttmp),qualswap(qualswaptmp),proxval(proxvaltmp),proxedgeval(proxedgevaltmp) 
{
}
MAILLEUR2D_INS_NOEUD::MAILLEUR2D_INS_NOEUD(MAILLEUR2D_INS_NOEUD& mdd)
:MAILLEUR(mdd),magicfilename(mdd.magicfilename),meshno(mdd.meshno),inspointfilename(mdd.inspointfilename),outputfilename(mdd.outputfilename),nivopt(mdd.nivopt),qualswap(mdd.qualswap),proxval(mdd.proxval),proxedgeval(mdd.proxedgeval)
{
}
MAILLEUR2D_INS_NOEUD::~MAILLEUR2D_INS_NOEUD()
{
}
void MAILLEUR2D_INS_NOEUD::ins_points(void)
{
  MG_FILE gest(magicfilename);
  MG_GEOMETRIE* geo=gest.get_mg_geometrie(0);
  MG_MAILLAGE* mai;
  if (meshno==0) mai=gest.get_mg_maillage(meshno); else mai=gest.get_mg_maillageid(meshno); 
  TPL_LISTE_ENTITE<MG_NOEUD*> pins;
  FILE *in=fopen(inspointfilename,"rt");
    if (in==NULL) affiche((char*) "file is not available"); 
  while (!feof(in))
    {
      char chaine[500];
      char* res=fgets(chaine,500,in);
      if(res!=NULL)
      {
      double x,y,z;
      int nb=sscanf(chaine,"%le %le %le",&x,&y,&z);
      if (nb!=-1 && nb!=3) affiche((char*)"Wrong file format"); 
else if (nb!=-1 && nb==3)
{
      MG_NOEUD* p=mai->ajouter_mg_noeud(NULL,x,y,z,MAGIC::ORIGINE::IMPOSE);
      pins.ajouter(p);
}
      }
    }
    fclose(in);
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=mai->get_premier_noeud(it);no!=NULL;no=mai->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 vecmax(xmax,ymax,zmax);
  OT_VECTEUR_3D lengthvec(vecmin,vecmax);
  double search_radius=0.001*(lengthvec.get_longueur());
 //char bboxdiag[1000];
 //sprintf(bboxdiag,"the bounding box diagonal is: %lf , and the neighborhood search radius is: %lf ",vec.get_longueur(),search_radius);
 //affiche((char*) bboxdiag);
 OT_VECTEUR_3D average=(vecmin+vecmax)/2.;
 double length=sqrt(lengthvec*lengthvec);
 double bxr=1.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_TRIANGLE*,MG_NOEUD*> octree;
 octree.initialiser(&lstnoeud,1,xmin,ymin,zmin,xmax,ymax,zmax);
 LISTE_MG_TRIANGLE::iterator it9;
 for (MG_TRIANGLE* tri=mai->get_premier_triangle(it9);tri!=NULL;tri=mai->get_suivant_triangle(it9))
   octree.inserer(tri);
 TPL_OCTREE<MG_NOEUD*,MG_NOEUD*> octreends;
 octreends.initialiser(&lstnoeud,1,xmin,ymin,zmin,xmax,ymax,zmax);
 for (MG_NOEUD* no=mai->get_premier_noeud(it);no!=NULL;no=mai->get_suivant_noeud(it))
   octreends.inserer(no); 
 
for (int ipins=0;ipins<pins.get_nb();ipins++)
{
  
  int sameinsnd_meshnd=0;
  double proximityqual;
  double delaunyinsqual;
  std::multimap<double,MG_NOEUD*,std::greater<double> > lstqualprxndfinal;
  MG_MAILLAGE_OUTILS tq;
  MG_NOEUD* p=pins.get(ipins);
  MG_ELEMENT_TOPOLOGIQUE *top;
  TPL_MAP_ENTITE<MG_TRIANGLE*> lstneitri1;
  int neitrinb1=lstneitri1.get_nb();
  while(neitrinb1==0) 
{
  octree.rechercher(p->get_x(),p->get_y(),p->get_z(),search_radius,lstneitri1);
  neitrinb1=lstneitri1.get_nb();
  search_radius=search_radius+0.1*search_radius;
}
  //check for the point proximity to any tri point 
  
TPL_MAP_ENTITE<MG_TRIANGLE*>::ITERATEUR it01; //can be merged with the delaunay insertion method
TPL_MAP_ENTITE<MG_NOEUD*> proxtrind;  
for (MG_TRIANGLE* tri01=lstneitri1.get_premier(it01);tri01!=NULL;tri01=lstneitri1.get_suivant(it01))
    {
    top=tri01->get_lien_topologie();
    MG_NOEUD* dpnd1=tri01->get_noeud1();
    MG_NOEUD* dpnd2=tri01->get_noeud2();
    MG_NOEUD* dpnd3=tri01->get_noeud3();
    proxtrind.ajouter(dpnd1);
    proxtrind.ajouter(dpnd2);
    proxtrind.ajouter(dpnd3);
    }
std::multimap< double, MG_NOEUD* , std::less<double> > lstdisproxnde;
TPL_MAP_ENTITE<MG_NOEUD*>::ITERATEUR itprnde;    
for(MG_NOEUD* prnde=proxtrind.get_premier(itprnde);prnde!=NULL;prnde=proxtrind.get_suivant(itprnde))
{
  if (prnde->get_x()==p->get_x() && prnde->get_y()==p->get_y() && prnde->get_z()==p->get_z())
  {
    top=prnde->get_lien_topologie();
    prox_nd(prnde,p,mai,octreends,octree);
    sameinsnd_meshnd=sameinsnd_meshnd+1;
    //cout<<"the same node as insertion"<<endl;
    break;
  }
  else
  {
  double dp=sqrt(pow((p->get_x()-prnde->get_x()),2)+pow((p->get_y()-prnde->get_y()),2)+pow((p->get_z()-prnde->get_z()),2));
  lstdisproxnde.insert(std::pair<double, MG_NOEUD*> (dp,prnde));
  }
}
if( sameinsnd_meshnd==0)
 {
std::multimap< double, MG_NOEUD* , std::less<double> >::iterator itlstdprnd=lstdisproxnde.begin();
double mindis=(*itlstdprnd).first;
TPL_LISTE_ENTITE<MG_NOEUD*> lstprnds;
double distelorance=1.1;
 
for (itlstdprnd=lstdisproxnde.begin();itlstdprnd!=lstdisproxnde.end();itlstdprnd++) 
{
  if ((*itlstdprnd).first<(distelorance*mindis)) lstprnds.ajouter((*itlstdprnd).second);
}
 
std::multimap<double,MG_NOEUD*,std::less<double> > lstqualtri;
for(int ilpn=0;ilpn<lstprnds.get_nb();ilpn++)
{
  MG_NOEUD* proxnd=lstprnds.get(ilpn);
  if(proxnd->get_x()==p->get_x() && proxnd->get_y()==p->get_y() && proxnd->get_z()==p->get_z()) std::cout<<"proxinod is the same as insertion node"<<std::endl;
  
  int checkisinspoint=0;
  for(int ipins1=0;ipins1<pins.get_nb();ipins1++ )
  {
    MG_NOEUD* checknotinspoint=pins.get(ipins1);
    if (checknotinspoint==proxnd) checkisinspoint=checkisinspoint+1; 
  }
  if (checkisinspoint==0) 
  {
  int proxndtop=proxnd->get_lien_topologie()->get_dimension();
  if (proxndtop>1)      //prox node is not on edge
  {
  for(int iptr=0;iptr<proxnd->get_lien_triangle()->get_nb();iptr++)
  {
    MG_TRIANGLE* prli=proxnd->get_lien_triangle()->get(iptr);
    MG_SEGMENT* prliseg1=prli->get_segment1();  MG_NOEUD* prliseg1nd1=prliseg1->get_noeud1();   MG_NOEUD* prliseg1nd2=prliseg1->get_noeud2();
    MG_SEGMENT* prliseg2=prli->get_segment2();  MG_NOEUD* prliseg2nd1=prliseg2->get_noeud1();   MG_NOEUD* prliseg2nd2=prliseg2->get_noeud2();
    MG_SEGMENT* prliseg3=prli->get_segment3();  MG_NOEUD* prliseg3nd1=prliseg3->get_noeud1();   MG_NOEUD* prliseg3nd2=prliseg3->get_noeud2();
    MG_NOEUD* prlind1=prli->get_noeud1();
    MG_NOEUD* prlind2=prli->get_noeud2();
    MG_NOEUD* prlind3=prli->get_noeud3();
    MG_SEGMENT* sgchk;
    if(proxnd!=prliseg1nd1 && proxnd!=prliseg1nd2) sgchk=prliseg1;
    if(proxnd!=prliseg2nd1 && proxnd!=prliseg2nd2) sgchk=prliseg2;
    if(proxnd!=prliseg3nd1 && proxnd!=prliseg3nd2) sgchk=prliseg3;
    MG_TRIANGLE* othertriangle;
    if(sgchk->get_lien_triangle()->get(0)!=prli) othertriangle=sgchk->get_lien_triangle()->get(0);
    else if(sgchk->get_lien_triangle()->get(1)!=prli) othertriangle=sgchk->get_lien_triangle()->get(1);
    double insph_swap_chk=inshper_point(p,othertriangle);
    MG_NOEUD* trimateothernd;
    if(othertriangle->get_noeud1()!=sgchk->get_noeud1() && othertriangle->get_noeud1()!=sgchk->get_noeud2()) trimateothernd=othertriangle->get_noeud1();
    else if(othertriangle->get_noeud2()!=sgchk->get_noeud1() && othertriangle->get_noeud2()!=sgchk->get_noeud2()) trimateothernd=othertriangle->get_noeud2();
    else if(othertriangle->get_noeud3()!=sgchk->get_noeud1() && othertriangle->get_noeud3()!=sgchk->get_noeud2()) trimateothernd=othertriangle->get_noeud3();
  
    if(prlind1==proxnd)
    {
      if(insph_swap_chk<=0)
      {
        double tqual1=tq.qualite_triangle(p->get_coord(),prli->get_noeud2()->get_coord(),trimateothernd->get_coord());
        double tqual2=tq.qualite_triangle(p->get_coord(),prli->get_noeud3()->get_coord(),trimateothernd->get_coord());
        lstqualtri.insert(std::pair<double,MG_NOEUD*>(tqual1,proxnd));
        lstqualtri.insert(std::pair<double,MG_NOEUD*>(tqual2,proxnd));
      }
      else 
      {
        double tqual=tq.qualite_triangle(p->get_coord(),prli->get_noeud2()->get_coord(),prli->get_noeud3()->get_coord());
        lstqualtri.insert(std::pair<double,MG_NOEUD*>(tqual,proxnd));
      }
    }
     
    else if(prlind2==proxnd)
    {
      if(insph_swap_chk<=0)
      {
        double tqual1=tq.qualite_triangle(p->get_coord(),prli->get_noeud1()->get_coord(),trimateothernd->get_coord());
        double tqual2=tq.qualite_triangle(p->get_coord(),prli->get_noeud3()->get_coord(),trimateothernd->get_coord());
        lstqualtri.insert(std::pair<double,MG_NOEUD*>(tqual1,proxnd));
        lstqualtri.insert(std::pair<double,MG_NOEUD*>(tqual2,proxnd));
      }
      else 
      {
        double tqual=tq.qualite_triangle(prli->get_noeud1()->get_coord(),p->get_coord(),prli->get_noeud3()->get_coord());
        lstqualtri.insert(std::pair<double,MG_NOEUD*>(tqual,proxnd));
      }
    }
    else if(prlind3==proxnd)
    {
      if(insph_swap_chk<=0)
      {
        double tqual1=tq.qualite_triangle(p->get_coord(),prli->get_noeud1()->get_coord(),trimateothernd->get_coord());
        double tqual2=tq.qualite_triangle(p->get_coord(),prli->get_noeud2()->get_coord(),trimateothernd->get_coord());
        lstqualtri.insert(std::pair<double,MG_NOEUD*>(tqual1,proxnd));
        lstqualtri.insert(std::pair<double,MG_NOEUD*>(tqual2,proxnd));
      }
      else 
      {
        double tqual=tq.qualite_triangle(prli->get_noeud1()->get_coord(),prli->get_noeud2()->get_coord(),p->get_coord());
        lstqualtri.insert(std::pair<double,MG_NOEUD*>(tqual,proxnd));
      }
    }
  }
  
  std::multimap<double,MG_NOEUD*,std::less<double> >::iterator itlstqualtri=lstqualtri.begin();
  lstqualprxndfinal.insert(std::pair<double,MG_NOEUD*>((*itlstqualtri).first,(*itlstqualtri).second));
  }
 
  }
}
if (lstqualprxndfinal.size()==0) proximityqual=0.; 
else
{
std::multimap<double,MG_NOEUD*,std::greater<double> >::iterator itlstqualprxndfinal=lstqualprxndfinal.begin();
  proximityqual=(*itlstqualprxndfinal).first;
}
 
std::multimap<double,MG_TRIANGLE*,std::less<double> > delinsqualtri;  
double normale[3];
int facenb=geo->get_nb_mg_face();
            LISTE_MG_FACE::iterator itf;
            for(MG_FACE* fac=geo->get_premier_face(itf);fac!=NULL;fac=geo->get_suivant_face(itf))
            {
              double uv[2];
              double xyz[3];
              xyz[0]=p->get_x();
              xyz[1]=p->get_y();
              xyz[2]=p->get_z();
              double dis;
              MG_GEOMETRIE_OUTILS f1;
              int ch=f1.calcule_distance_contour_face_xyz(xyz,fac,&dis);
              if (ch==1 && dis>=0.)
              {
                fac->inverser(uv,xyz);
                fac->calcul_normale_unitaire(uv,normale);
                MG_COFACE *coface=fac->get_mg_coface(0);
                int signe=coface->get_orientation();
              }
            }     
TPL_MAP_ENTITE<MG_TRIANGLE*> lstneitri;
int neitrinb=lstneitri.get_nb();
while(neitrinb==0) 
{
  octree.rechercher(p->get_x(),p->get_y(),p->get_z(),search_radius,lstneitri);
  neitrinb=lstneitri.get_nb();
  search_radius=search_radius+0.01*search_radius;
}
TPL_MAP_ENTITE<MG_TRIANGLE*> insphtri;      
TPL_MAP_ENTITE<MG_TRIANGLE*>::ITERATEUR it1;
for (MG_TRIANGLE* tri1=lstneitri.get_premier(it1);tri1!=NULL;tri1=lstneitri.get_suivant(it1))
    {
      top=tri1->get_lien_topologie();
      double insphchk=inshper_point(p,tri1);
      if (insphchk<=0.) insphtri.ajouter(tri1);
    }
   
TPL_MAP_ENTITE<MG_SEGMENT*> segbase;
TPL_MAP_ENTITE<MG_TRIANGLE*> basetri;
double pproj[3];
TPL_MAP_ENTITE<MG_TRIANGLE*>::ITERATEUR inspi;
for (MG_TRIANGLE* insphertri=insphtri.get_premier(inspi);insphertri!=NULL;insphertri=insphtri.get_suivant(inspi))
{
MG_NOEUD* inspnd1=insphertri->get_noeud1();
MG_NOEUD* inspnd2=insphertri->get_noeud2();
MG_NOEUD* inspnd3=insphertri->get_noeud3();
OT_VECTEUR_3D norm=normale; 
double a1=inspnd1->get_x()-p->get_x();double a2=inspnd1->get_x()-inspnd2->get_x();double a3=inspnd1->get_x()-inspnd3->get_x();
OT_VECTEUR_3D r1(a1,a2,a3);
double a11=inspnd1->get_y()-p->get_y();double a12=inspnd1->get_y()-inspnd2->get_y();double a13=inspnd1->get_y()-inspnd3->get_y();
OT_VECTEUR_3D r2(a11,a12,a13);
double a21=inspnd1->get_z()-p->get_z();double a22=inspnd1->get_z()-inspnd2->get_z();double a23=inspnd1->get_z()-inspnd3->get_z();
OT_VECTEUR_3D r3(a21,a22,a23);
double a31=norm.get_x();double a32=inspnd1->get_x()-inspnd2->get_x();double a33=inspnd1->get_x()-inspnd3->get_x();
OT_VECTEUR_3D d1(a31,a32,a33);
OT_VECTEUR_3D d2((norm.get_y()),(inspnd1->get_y()-inspnd2->get_y()),(inspnd1->get_y()-inspnd3->get_y()));
OT_VECTEUR_3D d3((norm.get_z()),(inspnd1->get_z()-inspnd2->get_z()),(inspnd1->get_z()-inspnd3->get_z()));
 
OT_MATRICE_3D tr(r1,r2,r3);
OT_MATRICE_3D td(d1,d2,d3);
double detd=td.get_determinant();
double detr=tr.get_determinant();
double t=detr/detd;
if (detd==0. || detr==0.) affiche((char*)"wrong ins point projection on the mesh");
pproj[0]=p->get_x()+t*norm.get_x();
pproj[1]=p->get_y()+t*norm.get_y();
pproj[2]=p->get_z()+t*norm.get_z();
MG_MAILLAGE_OUTILS tribas;
int tribasval=tribas.estdansletriangle(insphertri,pproj[0],pproj[1],pproj[2]);
int intri=tribas.compare_etat_triangle(tribasval,MG_MAILLAGE_OUTILS::INTERIEUR);
int insidtri=tribas.compare_etat_triangle(tribasval,MG_MAILLAGE_OUTILS::STRICTINTERIEUR);
int onedge=tribas.compare_etat_triangle(tribasval,MG_MAILLAGE_OUTILS::SUR_ARETE);
 
 
 
 
if (insidtri==1)
{
  MG_TRIANGLE* ndintri=insphertri;
  MG_SEGMENT* seg1=ndintri->get_segment1();
  MG_SEGMENT* seg2=ndintri->get_segment2();
  MG_SEGMENT* seg3=ndintri->get_segment3();
  MG_NOEUD* nd1=ndintri->get_noeud1();
  MG_NOEUD* nd2=ndintri->get_noeud2();
  MG_NOEUD* nd3=ndintri->get_noeud3();
  
  MG_TRIANGLE* trioth1;
  if (seg1->get_lien_triangle()->get(0)!=ndintri) trioth1=seg1->get_lien_triangle()->get(0);
  else if (seg1->get_lien_triangle()->get(1)!=ndintri) trioth1=seg1->get_lien_triangle()->get(1);
  double pinsphnb1=inshper_point(p,trioth1);
  if (pinsphnb1<=0.)
  {
    MG_NOEUD* othnd;
    if (trioth1->get_noeud1()!=seg1->get_noeud1() && trioth1->get_noeud1()!=seg1->get_noeud2()) othnd=trioth1->get_noeud1();
    else if (trioth1->get_noeud2()!=seg1->get_noeud1() && trioth1->get_noeud2()!=seg1->get_noeud2()) othnd=trioth1->get_noeud2();
    else if (trioth1->get_noeud3()!=seg1->get_noeud1() && trioth1->get_noeud3()!=seg1->get_noeud2()) othnd=trioth1->get_noeud3();
    double qual1=tq.qualite_triangle(p->get_coord(),seg1->get_noeud1()->get_coord(),othnd->get_coord());
    double qual2=tq.qualite_triangle(p->get_coord(),seg1->get_noeud2()->get_coord(),othnd->get_coord());
    delinsqualtri.insert(std::pair<double,MG_TRIANGLE*>(qual1,ndintri));
    delinsqualtri.insert(std::pair<double,MG_TRIANGLE*>(qual2,ndintri));
  }
  else 
  {
    double qual1=tq.qualite_triangle(p->get_coord(),seg1->get_noeud1()->get_coord(),seg1->get_noeud2()->get_coord());
    delinsqualtri.insert(std::pair<double,MG_TRIANGLE*>(qual1,ndintri));
  }
  
  MG_TRIANGLE* trioth2;
  if (seg2->get_lien_triangle()->get(0)!=ndintri) trioth2=seg2->get_lien_triangle()->get(0);
  else if (seg2->get_lien_triangle()->get(1)!=ndintri) trioth2=seg2->get_lien_triangle()->get(1);
  double pinsphnb2=inshper_point(p,trioth2);
  if (pinsphnb2<=0.)
  {
    MG_NOEUD* othnd;
    if (trioth2->get_noeud1()!=seg2->get_noeud1() && trioth2->get_noeud1()!=seg2->get_noeud2()) othnd=trioth2->get_noeud1();
    else if (trioth2->get_noeud2()!=seg2->get_noeud1() && trioth2->get_noeud2()!=seg2->get_noeud2()) othnd=trioth2->get_noeud2();
    else if (trioth2->get_noeud3()!=seg2->get_noeud1() && trioth2->get_noeud3()!=seg2->get_noeud2()) othnd=trioth2->get_noeud3();
    double qual1=tq.qualite_triangle(p->get_coord(),seg2->get_noeud1()->get_coord(),othnd->get_coord());
    double qual2=tq.qualite_triangle(p->get_coord(),seg2->get_noeud2()->get_coord(),othnd->get_coord());
    delinsqualtri.insert(std::pair<double,MG_TRIANGLE*>(qual1,ndintri));
    delinsqualtri.insert(std::pair<double,MG_TRIANGLE*>(qual2,ndintri));
  }
  else 
  {
    double qual1=tq.qualite_triangle(p->get_coord(),seg2->get_noeud1()->get_coord(),seg2->get_noeud2()->get_coord());
    delinsqualtri.insert(std::pair<double,MG_TRIANGLE*>(qual1,ndintri));
  }
  
  MG_TRIANGLE* trioth3;
  if (seg3->get_lien_triangle()->get(0)!=ndintri) trioth3=seg3->get_lien_triangle()->get(0);
  else if (seg3->get_lien_triangle()->get(1)!=ndintri) trioth3=seg3->get_lien_triangle()->get(1);
  double pinsphnb3=inshper_point(p,trioth3);
  if (pinsphnb3<=0.)
  {
    MG_NOEUD* othnd;
    if (trioth3->get_noeud1()!=seg3->get_noeud1() && trioth3->get_noeud1()!=seg3->get_noeud2()) othnd=trioth3->get_noeud1();
    else if (trioth3->get_noeud2()!=seg3->get_noeud1() && trioth3->get_noeud2()!=seg3->get_noeud2()) othnd=trioth3->get_noeud2();
    else if (trioth3->get_noeud3()!=seg3->get_noeud1() && trioth3->get_noeud3()!=seg3->get_noeud2()) othnd=trioth3->get_noeud3();
    double qual1=tq.qualite_triangle(p->get_coord(),seg3->get_noeud1()->get_coord(),othnd->get_coord());
    double qual2=tq.qualite_triangle(p->get_coord(),seg3->get_noeud2()->get_coord(),othnd->get_coord());
    delinsqualtri.insert(std::pair<double,MG_TRIANGLE*>(qual1,ndintri));
    delinsqualtri.insert(std::pair<double,MG_TRIANGLE*>(qual2,ndintri));
  }
  else 
  {
    double qual1=tq.qualite_triangle(p->get_coord(),seg3->get_noeud1()->get_coord(),seg3->get_noeud2()->get_coord());
    delinsqualtri.insert(std::pair<double,MG_TRIANGLE*>(qual1,ndintri));
  }
 
}
 
if (onedge==1)
{
  MG_TRIANGLE* ndontri=insphertri;
  MG_NOEUD* ndo1=ndontri->get_noeud1();
  MG_NOEUD* ndo2=ndontri->get_noeud2();
  MG_NOEUD* ndo3=ndontri->get_noeud3();
  int onvert1=tribas.compare_etat_triangle(tribasval,MG_MAILLAGE_OUTILS::SOMMET1);
  int onvert2=tribas.compare_etat_triangle(tribasval,MG_MAILLAGE_OUTILS::SOMMET2);
  int onvert3=tribas.compare_etat_triangle(tribasval,MG_MAILLAGE_OUTILS::SOMMET3);
  int onedge1=tribas.compare_etat_triangle(tribasval,MG_MAILLAGE_OUTILS::ARETE1);
  int onedge2=tribas.compare_etat_triangle(tribasval,MG_MAILLAGE_OUTILS::ARETE2);
  int onedge3=tribas.compare_etat_triangle(tribasval,MG_MAILLAGE_OUTILS::ARETE3);
  if (onvert1==1 || onvert2==1 || onvert3==1)
  {
    MG_NOEUD* ond;
    if(onvert1==1)ond=ndo1;
    if(onvert2==1)ond=ndo2;
    if(onvert3==1)ond=ndo3;
    for(int iind=0;iind<ond->get_lien_triangle()->get_nb();iind++)
    {
      MG_TRIANGLE* trlie=ond->get_lien_triangle()->get(iind);
      MG_SEGMENT* trlieseg1=trlie->get_segment1();
      MG_SEGMENT* trlieseg2=trlie->get_segment2();
      MG_SEGMENT* trlieseg3=trlie->get_segment3();
      MG_SEGMENT* segchkk;
      if (trlieseg1->get_noeud1()!=ond && trlieseg1->get_noeud2()!=ond) segchkk=trlieseg1;
      else if (trlieseg2->get_noeud1()!=ond && trlieseg2->get_noeud2()!=ond) segchkk=trlieseg2;
      else if (trlieseg3->get_noeud1()!=ond && trlieseg3->get_noeud2()!=ond) segchkk=trlieseg3;
      MG_TRIANGLE* trioth;
      if(segchkk->get_lien_triangle()->get(0)!=trlie) trioth=segchkk->get_lien_triangle()->get(0);
      else if(segchkk->get_lien_triangle()->get(1)!=trlie) trioth=segchkk->get_lien_triangle()->get(1);
 
  double pinsphnb=inshper_point(p,trioth);
  if (pinsphnb<=0.)
  {
    MG_NOEUD* othnd;
    if (trioth->get_noeud1()!=segchkk->get_noeud1() && trioth->get_noeud1()!=segchkk->get_noeud2()) othnd=trioth->get_noeud1();
    else if (trioth->get_noeud2()!=segchkk->get_noeud1() && trioth->get_noeud2()!=segchkk->get_noeud2()) othnd=trioth->get_noeud2();
    else if (trioth->get_noeud3()!=segchkk->get_noeud1() && trioth->get_noeud3()!=segchkk->get_noeud2()) othnd=trioth->get_noeud3();
    double qual1=tq.qualite_triangle(p->get_coord(),segchkk->get_noeud1()->get_coord(),othnd->get_coord());
    double qual2=tq.qualite_triangle(p->get_coord(),segchkk->get_noeud2()->get_coord(),othnd->get_coord());
    delinsqualtri.insert(std::pair<double,MG_TRIANGLE*>(qual1,trlie));
    delinsqualtri.insert(std::pair<double,MG_TRIANGLE*>(qual2,trlie));
  }
  else 
  {
    double qual1=tq.qualite_triangle(p->get_coord(),segchkk->get_noeud1()->get_coord(),segchkk->get_noeud2()->get_coord());
    delinsqualtri.insert(std::pair<double,MG_TRIANGLE*>(qual1,trlie));
  }
    }
  }
  
  else if(onedge1==1 || onedge2==1 || onedge3==1)
  {
    MG_TRIANGLE* ndontri=insphertri;
    MG_SEGMENT* onseg;
    if (onedge1==1)onseg=ndontri->get_segment1();
    if (onedge2==1)onseg=ndontri->get_segment2();
    if (onedge3==1)onseg=ndontri->get_segment3();
    TPL_MAP_ENTITE<MG_SEGMENT*> freesegs;
    for(int ifr=0;ifr<onseg->get_lien_triangle()->get_nb();ifr++)
    {
      MG_TRIANGLE* trfr=onseg->get_lien_triangle()->get(ifr);
      if (trfr->get_segment1()!=onseg) freesegs.ajouter(trfr->get_segment1());
      if (trfr->get_segment2()!=onseg) freesegs.ajouter(trfr->get_segment2());
      if (trfr->get_segment3()!=onseg) freesegs.ajouter(trfr->get_segment3());
    }
    TPL_MAP_ENTITE<MG_SEGMENT*>::ITERATEUR itfr;
    for (MG_SEGMENT* segfre=freesegs.get_premier(itfr);segfre!=NULL;segfre=freesegs.get_suivant(itfr))
    {
      MG_TRIANGLE* trioth;
      if(segfre->get_lien_triangle()->get(0)==onseg->get_lien_triangle()->get(0) || segfre->get_lien_triangle()->get(0)==onseg->get_lien_triangle()->get(1)) 
        trioth=segfre->get_lien_triangle()->get(1);
      else if(segfre->get_lien_triangle()->get(1)==onseg->get_lien_triangle()->get(0) || segfre->get_lien_triangle()->get(1)==onseg->get_lien_triangle()->get(1))
        trioth=segfre->get_lien_triangle()->get(0);
      double pinsphnb=inshper_point(p,trioth);
  if (pinsphnb<=0.)
  {
    MG_NOEUD* othnd;
    if (trioth->get_noeud1()!=segfre->get_noeud1() && trioth->get_noeud1()!=segfre->get_noeud2()) othnd=trioth->get_noeud1();
    else if (trioth->get_noeud2()!=segfre->get_noeud1() && trioth->get_noeud2()!=segfre->get_noeud2()) othnd=trioth->get_noeud2();
    else if (trioth->get_noeud3()!=segfre->get_noeud1() && trioth->get_noeud3()!=segfre->get_noeud2()) othnd=trioth->get_noeud3();
    double qual1=tq.qualite_triangle(p->get_coord(),segfre->get_noeud1()->get_coord(),othnd->get_coord());
    double qual2=tq.qualite_triangle(p->get_coord(),segfre->get_noeud2()->get_coord(),othnd->get_coord());
    delinsqualtri.insert(std::pair<double,MG_TRIANGLE*>(qual1,ndontri));
    delinsqualtri.insert(std::pair<double,MG_TRIANGLE*>(qual2,ndontri));
  }
  else 
  {
    double qual1=tq.qualite_triangle(p->get_coord(),segfre->get_noeud1()->get_coord(),segfre->get_noeud2()->get_coord());
    delinsqualtri.insert(std::pair<double,MG_TRIANGLE*>(qual1,ndontri));
  }
      
    }
 
  }
}
  
}
 
std::multimap<double,MG_TRIANGLE*,std::less<double> > :: iterator itdelinsqualtri=delinsqualtri.begin();
delaunyinsqual=(*itdelinsqualtri).first;
if (lstqualprxndfinal.size()>0 && proximityqual>delaunyinsqual)
{
  std::multimap<double,MG_NOEUD*,std::greater<double> >::iterator itlstqualprxndfinal=lstqualprxndfinal.begin();
  prox_nd((*itlstqualprxndfinal).second,p,mai,octreends,octree);
}
 
else 
{
  delaunay_ndinsert(p,mai,search_radius,octree,geo,octreends);
}
 }
}
 
int mgvolnb=geo->get_nb_mg_volume();
MG_VOLUME* mgvol;
for (int iv=0;iv<mai->get_mg_geometrie()->get_nb_mg_volume();iv++)
{
  MG_ELEMENT_TOPOLOGIQUE *top1=mai->get_mg_triangle(0)->get_lien_topologie();
  MG_FACE *fac=(MG_FACE*)top1;
 
if (fac->get_mg_coface(0)->get_coquille()->get_mg_volume()==mai->get_mg_geometrie()->get_mg_volume(iv))
  mgvol=mai->get_mg_geometrie()->get_mg_volume(iv);
}
MAILLEUR2D_OPTIMISATION opt(mai,nivopt);
opt.optimise(mgvol);
 
  gest.enregistrer(outputfilename);
  
}
void MAILLEUR2D_INS_NOEUD::ins_point_withbc(double gentriqual, double mesh_size, char* gnifoutputfilename, int insremtyp)
{
  std::vector<double*> lstgnifread;
  std::vector<double*> lstgnifwrite;
  int verycloseee=0;
  int proxndiiadd=0;
  int delonnodiiadd=0;
  int removednodiadd=0;
  MG_FILE gest(magicfilename);
  MG_GEOMETRIE* geo=gest.get_mg_geometrie(0);
  MG_MAILLAGE* mai;
  if (meshno==0) mai=gest.get_mg_maillage(meshno); else mai=gest.get_mg_maillageid(meshno);
 
  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=mai->get_premier_noeud(it);no!=NULL;no=mai->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 vecmax(xmax,ymax,zmax);
  OT_VECTEUR_3D lengthvec(vecmin,vecmax);
  double search_radius=0.001*(lengthvec.get_longueur());
 //char bboxdiag[1000];
 //sprintf(bboxdiag,"the bounding box diagonal is: %lf , and the neighborhood search radius is: %lf ",vec.get_longueur(),search_radius);
 //affiche((char*) bboxdiag);
 OT_VECTEUR_3D average=(vecmin+vecmax)/2.;
 double length=sqrt(lengthvec*lengthvec);
 double bxr=1.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_TRIANGLE*,MG_NOEUD*> octree;
 octree.initialiser(&lstnoeud,1,xmin,ymin,zmin,xmax,ymax,zmax);
 LISTE_MG_TRIANGLE::iterator it9;
 for (MG_TRIANGLE* tri=mai->get_premier_triangle(it9);tri!=NULL;tri=mai->get_suivant_triangle(it9))
   octree.inserer(tri);
 TPL_OCTREE<MG_NOEUD*,MG_NOEUD*> octreends;
 octreends.initialiser(&lstnoeud,1,xmin,ymin,zmin,xmax,ymax,zmax);
 for (MG_NOEUD* no=mai->get_premier_noeud(it);no!=NULL;no=mai->get_suivant_noeud(it))
   octreends.inserer(no);
double prop=0.001;
std::map<MG_NOEUD*,double*> pins;
FILE *in=fopen(inspointfilename,"rt");
if (in==NULL) affiche((char*) "file is not available");
while(!feof(in))
{
  char chaine[500];
  char* res=fgets(chaine,500,in);
  if(res!=NULL)
  {
    double x,y,z;
    double q1,q2,q3;
    double ins_rem_type;
    double* pcoordbc=new double[6];
    
    if(insremtyp==0)
    {
      int nb=sscanf(chaine,"%le %le %le %le %le %le",&x,&y,&z,&q1,&q2,&q3);
      q1=prop*q1;
      q2=prop*q2;
      q3=prop*q3;
      if (nb!=-1 && nb!=6) affiche((char*)"Wrong file format");
      else if (nb==6)
      {
        ins_rem_type=1;
        pcoordbc[0]=x; pcoordbc[1]=y; pcoordbc[2]=z; pcoordbc[3]=q1; pcoordbc[4]=q2; pcoordbc[5]=q3;
        lstgnifread.push_back(pcoordbc);
      }
    }
    else if(insremtyp>0)
    {
      int nb=sscanf(chaine,"%le %le %le %le %le %le %le",&ins_rem_type,&x,&y,&z,&q1,&q2,&q3);
      q1=prop*q1;
      q2=prop*q2;
      q3=prop*q3;
      if (nb!=-1 && nb!=7) affiche((char*)"Wrong file format");
      else if (nb==7)
      {
        pcoordbc[0]=x; pcoordbc[1]=y; pcoordbc[2]=z; pcoordbc[3]=q1; pcoordbc[4]=q2; pcoordbc[5]=q3;
        lstgnifread.push_back(pcoordbc);
      }
    }
    
    int insp_exist=0;
    TPL_MAP_ENTITE<MG_NOEUD*> lstneinds_tstpexist;
    int tstpexistnb=lstneinds_tstpexist.get_nb();
    double search_radius1=search_radius;
  while(tstpexistnb==0) 
{
  octreends.rechercher(x,y,z,search_radius1,lstneinds_tstpexist);
  tstpexistnb=lstneinds_tstpexist.get_nb();
  search_radius1=search_radius1+0.1*search_radius1;
}
 
std::map<double,MG_NOEUD*,std::less<double> > lstneinodins;
std::map<double,MG_NOEUD*,std::less<double> > lstneinodinsedge;
TPL_MAP_ENTITE<MG_NOEUD*>::ITERATEUR itst_pexist; 
for (MG_NOEUD* nds_tstpexist=lstneinds_tstpexist.get_premier(itst_pexist);nds_tstpexist!=NULL;nds_tstpexist=lstneinds_tstpexist.get_suivant(itst_pexist))
{
  double dis1=sqrt(pow((nds_tstpexist->get_x()-x),2.)+pow((nds_tstpexist->get_y()-y),2.)+pow((nds_tstpexist->get_z()-z),2.));
  lstneinodins.insert(std::pair<double,MG_NOEUD*>(dis1,nds_tstpexist));
  if(nds_tstpexist->get_lien_topologie()->get_dimension()<2)
  {
    lstneinodinsedge.insert(std::pair<double,MG_NOEUD*>(dis1,nds_tstpexist));
  }
}
std::map<double,MG_NOEUD*,std::less<double> >::iterator itlstneinodins;
if(lstneinodins.size()>0)
    {
      itlstneinodins=lstneinodins.begin();
      MG_NOEUD* ndaround=(*itlstneinodins).second;
      int sgltop=0;
      TPL_MAP_ENTITE<MG_SEGMENT*> ndgls;
      for(int igtls=0;igtls<ndaround->get_lien_segment()->get_nb();igtls++)
        ndgls.ajouter(ndaround->get_lien_segment()->get(igtls));
      TPL_MAP_ENTITE<MG_SEGMENT*>::ITERATEUR itndgls;
      for(MG_SEGMENT* sgtls=ndgls.get_premier(itndgls);sgtls!=NULL;sgtls=ndgls.get_suivant(itndgls))
      {
        if(sgtls->get_lien_topologie()->get_dimension()<3)
          sgltop++;
      }
      
      if(ndaround->get_x()<x+proxval && ndaround->get_x()>x-proxval)
        if(ndaround->get_y()<y+proxval && ndaround->get_y()>y-proxval)
          if(ndaround->get_z()<z+proxval && ndaround->get_z()>z-proxval)
            if(ndaround->get_lien_topologie()->get_dimension()<3 || sgltop>0)
      {
        
        insp_exist++;
    class MG_SOMMET_NOEUD* somno=geo->ajouter_mg_sommet_noeud(ndaround);
    q1=(0.001*(x-ndaround->get_x()))+q1;
    q2=(0.001*(y-ndaround->get_y()))+q2;
    q3=(0.001*(z-ndaround->get_z()))+q3;
    somno->ajouter_ccf((char*)"Dx",q1);
    somno->ajouter_ccf((char*)"Dy",q2);
    somno->ajouter_ccf((char*)"Dz",q3);
    ndaround->change_origine(MAGIC::ORIGINE::IMPOSE);
    double* pcoordbc=new double[6];
    pcoordbc[0]=x; pcoordbc[1]=y; pcoordbc[2]=z; pcoordbc[3]=q1; pcoordbc[4]=q2; pcoordbc[5]=q3;
    lstgnifwrite.push_back(pcoordbc);
    for(int itri=0;itri<ndaround->get_lien_triangle()->get_nb();itri++)
    {
      MG_TRIANGLE* tricha=ndaround->get_lien_triangle()->get(itri);
      if(ins_rem_type<1)
        tricha->change_origine(MAGIC::ORIGINE::MODIFICATION);
      else if(ins_rem_type>0)
        tricha->change_origine(MAGIC::ORIGINE::IMPOSE);
    }
    
    if(lstneinodinsedge.size()>0 )
    {
      for(std::map<double,MG_NOEUD*,std::less<double> >::iterator itlstneinodinsedgechk=lstneinodinsedge.begin();itlstneinodinsedgechk!=lstneinodinsedge.end();itlstneinodinsedgechk++)
      {
        if (ndaround==(*itlstneinodinsedgechk).second)
          lstneinodinsedge.erase(itlstneinodinsedgechk);
      }
    }
    verycloseee++;
    std::cout<<"VERY VERY VERY CLOSE"<<std::endl;
      }
    }
    std::map<double,MG_NOEUD*,std::less<double> >::iterator itlstneinodinsedge;
    if(lstneinodinsedge.size()>0 && proxedgeval>0.)
          {
            itlstneinodinsedge=lstneinodinsedge.begin();
            MG_NOEUD* ndaround=(*itlstneinodinsedge).second;
            double distp=(*itlstneinodinsedge).first;
            if(distp<proxedgeval)
                {
            insp_exist++;
            class MG_SOMMET_NOEUD* somno=geo->ajouter_mg_sommet_noeud(ndaround);
            q1=(0.001*(x-ndaround->get_x()))+q1;
            q2=(0.001*(y-ndaround->get_y()))+q2;
            q3=(0.001*(z-ndaround->get_z()))+q3;
            somno->ajouter_ccf((char*)"Dx",q1);
            somno->ajouter_ccf((char*)"Dy",q2);
            somno->ajouter_ccf((char*)"Dz",q3);
     ndaround->change_origine(MAGIC::ORIGINE::IMPOSE);
     double* pcoordbc=new double[6];
    pcoordbc[0]=x; pcoordbc[1]=y; pcoordbc[2]=z; pcoordbc[3]=q1; pcoordbc[4]=q2; pcoordbc[5]=q3;
    lstgnifwrite.push_back(pcoordbc);
    for(int itri=0;itri<ndaround->get_lien_triangle()->get_nb();itri++)
    {
      MG_TRIANGLE* tricha=ndaround->get_lien_triangle()->get(itri);
      if(ins_rem_type<1)
        tricha->change_origine(MAGIC::ORIGINE::MODIFICATION);
      else if(ins_rem_type>0)
        tricha->change_origine(MAGIC::ORIGINE::IMPOSE);
    }
            verycloseee++;
            std::cout<<"VERY CLOSE to edges"<<std::endl;
                }
          }
   
   lstneinodinsedge.clear();;
   lstneinodins.clear();;
 if (insp_exist==0)
{
  MG_NOEUD* p=mai->ajouter_mg_noeud(NULL,x,y,z,MAGIC::ORIGINE::IMPOSE); // geometry is NULL no need to add topology later???????
  double* bc=new double[4];
  bc[0]=q1; bc[1]=q2; bc[2]=q3; bc[3]=ins_rem_type;
  pins.insert(std::pair<MG_NOEUD*,double*> (p,bc));
}
  }
}
fclose(in);
double tri_return_angl=3.1415/3.;
std::map<MG_NOEUD*,double*> pins_prox_Delaunay;
int pins_count=0;
  for(std::map<MG_NOEUD*,double*>::iterator itpins=pins.begin();itpins!=pins.end();itpins++)
  {
    pins_count++; 
    //cout<<"POINT INSERT NO.= "<<pins_count<<endl;
  int sameinsnd_meshnd=0;
  double proximityqual=-1.;
  double delaunyinsqual=-1;
  std::multimap<double,MG_NOEUD*,std::greater<double> > lstqualprxndfinal;
  MG_MAILLAGE_OUTILS tq;
  MG_NOEUD* p=(*itpins).first;
  MG_ELEMENT_TOPOLOGIQUE *top;
  TPL_MAP_ENTITE<MG_NOEUD*> proxtrind;
  int neindsnb=proxtrind.get_nb();
  while(neindsnb==0) 
{
  octreends.rechercher(p->get_x(),p->get_y(),p->get_z(),search_radius,proxtrind);
  neindsnb=proxtrind.get_nb();
  search_radius=search_radius+0.1*search_radius;
}
std::multimap< double, MG_NOEUD* , std::less<double> > lstdisproxnde;
TPL_MAP_ENTITE<MG_NOEUD*>::ITERATEUR itprnde;    
for(MG_NOEUD* prnde=proxtrind.get_premier(itprnde);prnde!=NULL;prnde=proxtrind.get_suivant(itprnde))
{
  if (prnde->get_x()==p->get_x() && prnde->get_y()==p->get_y() && prnde->get_z()==p->get_z())
  {
    sameinsnd_meshnd=sameinsnd_meshnd+1;
    std::cout<<"the same node as insertion"<<std::endl;
    break;
  }
  else if(prnde->get_lien_topologie()->get_dimension()>1 && prnde->get_origine()!=MAGIC::ORIGINE::IMPOSE)
  {
  double dp=sqrt(pow((p->get_x()-prnde->get_x()),2)+pow((p->get_y()-prnde->get_y()),2)+pow((p->get_z()-prnde->get_z()),2));
  lstdisproxnde.insert(std::pair<double, MG_NOEUD*> (dp,prnde));
  }
}
if( sameinsnd_meshnd==0)
 {
   std::multimap< double, MG_NOEUD* , std::less<double> >::iterator itlstdprnd=lstdisproxnde.begin();
double mindis=(*itlstdprnd).first;
TPL_LISTE_ENTITE<MG_NOEUD*> lstprnds;
double distelorance=1.1;
for (itlstdprnd=lstdisproxnde.begin();itlstdprnd!=lstdisproxnde.end();itlstdprnd++) 
{
  if ((*itlstdprnd).first<=(distelorance*mindis) && (*itlstdprnd).first<0.8*mesh_size )
    lstprnds.ajouter((*itlstdprnd).second);
}
for(int ilpn=0;ilpn<lstprnds.get_nb();ilpn++)
{
  MG_NOEUD* proxnd=lstprnds.get(ilpn);
  if(proxnd->get_x()==p->get_x() && proxnd->get_y()==p->get_y() && proxnd->get_z()==p->get_z())
    std::cout<<"proxinod is the same as insertion node"<<std::endl;
 
  int proxndtop=proxnd->get_lien_topologie()->get_dimension();
  if (proxndtop>1)      //prox node is not on edge
  {
    std::multimap<double,MG_NOEUD*,std::less<double> > lstqualtri;
for(int iptr=0;iptr<proxnd->get_lien_triangle()->get_nb();iptr++)
{
    MG_TRIANGLE* prli=proxnd->get_lien_triangle()->get(iptr);
    MG_SEGMENT* prliseg1=prli->get_segment1();  
    MG_SEGMENT* prliseg2=prli->get_segment2();  
    MG_SEGMENT* prliseg3=prli->get_segment3();  
    MG_NOEUD* prlind1=prli->get_noeud1();
    MG_NOEUD* prlind2=prli->get_noeud2();
    MG_NOEUD* prlind3=prli->get_noeud3();
    OT_VECTEUR_3D vpt1(prlind1->get_coord(),prlind2->get_coord());
    OT_VECTEUR_3D vpt2(prlind1->get_coord(),prlind3->get_coord());
    OT_VECTEUR_3D normvpt=(vpt1&vpt2); normvpt.norme();
    double tqualvpt=tq.qualite_triangle(prli->get_noeud1()->get_coord(),prli->get_noeud2()->get_coord(),prli->get_noeud3()->get_coord());
    MG_SEGMENT* sgchk;
    if(proxnd!=prliseg1->get_noeud1() && proxnd!=prliseg1->get_noeud2()) sgchk=prliseg1;
    if(proxnd!=prliseg2->get_noeud1() && proxnd!=prliseg2->get_noeud2()) sgchk=prliseg2;
    if(proxnd!=prliseg3->get_noeud1() && proxnd!=prliseg3->get_noeud2()) sgchk=prliseg3;
 if(sgchk->get_lien_triangle()->get_nb()>1 )
 {
       MG_TRIANGLE* othertriangle;
       
    if(sgchk->get_lien_triangle()->get(0)!=prli) othertriangle=sgchk->get_lien_triangle()->get(0);
    else if(sgchk->get_lien_triangle()->get(1)!=prli) othertriangle=sgchk->get_lien_triangle()->get(1);
    OT_VECTEUR_3D vpto1(othertriangle->get_noeud1()->get_coord(),othertriangle->get_noeud2()->get_coord());
    OT_VECTEUR_3D vpto2(othertriangle->get_noeud1()->get_coord(),othertriangle->get_noeud3()->get_coord());
    OT_VECTEUR_3D normvpto=(vpto1&vpto2); normvpto.norme();
    double tqualvpto=tq.qualite_triangle(othertriangle->get_noeud1()->get_coord(),othertriangle->get_noeud2()->get_coord(),othertriangle->get_noeud3()->get_coord());
    double insph_swap_chk1=inshper_point(p,othertriangle);
    MG_NOEUD* trimateothernd;
    if(othertriangle->get_noeud1()!=sgchk->get_noeud1() && othertriangle->get_noeud1()!=sgchk->get_noeud2()) trimateothernd=othertriangle->get_noeud1();
    else if(othertriangle->get_noeud2()!=sgchk->get_noeud1() && othertriangle->get_noeud2()!=sgchk->get_noeud2()) trimateothernd=othertriangle->get_noeud2();
    else if(othertriangle->get_noeud3()!=sgchk->get_noeud1() && othertriangle->get_noeud3()!=sgchk->get_noeud2()) trimateothernd=othertriangle->get_noeud3();
    double insph_swap_chk2=1.;//inshper_point(trimateothernd,prli);
    int insph_swap_chk=0;
    if (insph_swap_chk1<=0. ||insph_swap_chk2<=0.)
      insph_swap_chk++;
 
    
    if (sgchk->get_noeud1()==prli->get_noeud1() && sgchk->get_noeud2()==prli->get_noeud2())
    {
      if(insph_swap_chk>0 && qualswap>0)
      {
        double tqual1=tq.qualite_triangle(p->get_coord(),sgchk->get_noeud1()->get_coord(),trimateothernd->get_coord());
        double tqual2=tq.qualite_triangle(p->get_coord(),trimateothernd->get_coord(),sgchk->get_noeud2()->get_coord());
        OT_VECTEUR_3D vpr11(p->get_coord(),sgchk->get_noeud1()->get_coord());
        OT_VECTEUR_3D vpr12(p->get_coord(),trimateothernd->get_coord());
        OT_VECTEUR_3D normvpr1=(vpr11&vpr12); normvpr1.norme();
        if(normvpr1*normvpt<cos(tri_return_angl) || normvpr1*normvpto<cos(tri_return_angl))
          tqual1=-1.;
        OT_VECTEUR_3D vpr21(p->get_coord(),trimateothernd->get_coord());
        OT_VECTEUR_3D vpr22(p->get_coord(),sgchk->get_noeud2()->get_coord());
        OT_VECTEUR_3D normvpr2=(vpr21&vpr22); normvpr2.norme();
        if(normvpr2*normvpt<cos(tri_return_angl)|| normvpr2*normvpto<cos(tri_return_angl))
          tqual2=-1.;
        if(tqual1<=tqual2)
        {
          if(tqual1<tqualvpt || tqual1<tqualvpto)
            tqual1=-1.;
        }
        else if (tqual2<tqual1)
        {
          if(tqual2<tqualvpt || tqual2<tqualvpto)
            tqual2=-1.;
        }
        lstqualtri.insert(std::pair<double,MG_NOEUD*>(tqual1,proxnd));
        lstqualtri.insert(std::pair<double,MG_NOEUD*>(tqual2,proxnd));
      }
      else 
      {
        double tqual=tq.qualite_triangle(p->get_coord(),sgchk->get_noeud1()->get_coord(),sgchk->get_noeud2()->get_coord());
        OT_VECTEUR_3D vpr1(p->get_coord(),sgchk->get_noeud1()->get_coord());
        OT_VECTEUR_3D vpr2(p->get_coord(),sgchk->get_noeud2()->get_coord());
        OT_VECTEUR_3D normvpr=(vpr1&vpr2); normvpr.norme();
        if(normvpr*normvpt<cos(tri_return_angl) || normvpr*normvpto<cos(tri_return_angl))
          tqual=-1.;
        lstqualtri.insert(std::pair<double,MG_NOEUD*>(tqual,proxnd));
      }
    }
    if (sgchk->get_noeud1()==prli->get_noeud2() && sgchk->get_noeud2()==prli->get_noeud3())
    {
      if(insph_swap_chk>0 && qualswap>0)
      {
        double tqual1=tq.qualite_triangle(p->get_coord(),sgchk->get_noeud1()->get_coord(),trimateothernd->get_coord());
        double tqual2=tq.qualite_triangle(p->get_coord(),trimateothernd->get_coord(),sgchk->get_noeud1()->get_coord());
        OT_VECTEUR_3D vpr11(p->get_coord(),sgchk->get_noeud1()->get_coord());
        OT_VECTEUR_3D vpr12(p->get_coord(),trimateothernd->get_coord());
        OT_VECTEUR_3D normvpr1=(vpr11&vpr12); normvpr1.norme();
        if(normvpr1*normvpt<cos(tri_return_angl) || normvpr1*normvpto<cos(tri_return_angl))
          tqual1=-1.;
        OT_VECTEUR_3D vpr21(p->get_coord(),trimateothernd->get_coord());
        OT_VECTEUR_3D vpr22(p->get_coord(),sgchk->get_noeud1()->get_coord());
        OT_VECTEUR_3D normvpr2=(vpr21&vpr22); normvpr2.norme();
        if(normvpr2*normvpt<cos(tri_return_angl)|| normvpr2*normvpto<cos(tri_return_angl))
          tqual2=-1.;
        if(tqual1<=tqual2)
        {
          if(tqual1<tqualvpt || tqual1<tqualvpto)
            tqual1=-1.;
        }
        else if (tqual2<tqual1)
        {
          if(tqual2<tqualvpt || tqual2<tqualvpto)
            tqual2=-1.;
        }
        lstqualtri.insert(std::pair<double,MG_NOEUD*>(tqual1,proxnd));
        lstqualtri.insert(std::pair<double,MG_NOEUD*>(tqual2,proxnd));
      }
      else 
      {
        double tqual=tq.qualite_triangle(p->get_coord(),sgchk->get_noeud1()->get_coord(),sgchk->get_noeud2()->get_coord());
        OT_VECTEUR_3D vpr1(p->get_coord(),sgchk->get_noeud1()->get_coord());
        OT_VECTEUR_3D vpr2(p->get_coord(),sgchk->get_noeud2()->get_coord());
        OT_VECTEUR_3D normvpr=(vpr1&vpr2); normvpr.norme();
        if(normvpr*normvpt<cos(tri_return_angl) || normvpr*normvpto<cos(tri_return_angl))
          tqual=-1.;
        lstqualtri.insert(std::pair<double,MG_NOEUD*>(tqual,proxnd));
      }
    }
    if (sgchk->get_noeud1()==prli->get_noeud3() && sgchk->get_noeud2()==prli->get_noeud1())
    {
      if(insph_swap_chk>0 && qualswap>0)
      {
        double tqual1=tq.qualite_triangle(p->get_coord(),sgchk->get_noeud1()->get_coord(),trimateothernd->get_coord());
        double tqual2=tq.qualite_triangle(p->get_coord(),trimateothernd->get_coord(),sgchk->get_noeud1()->get_coord());
        OT_VECTEUR_3D vpr11(p->get_coord(),sgchk->get_noeud1()->get_coord());
        OT_VECTEUR_3D vpr12(p->get_coord(),trimateothernd->get_coord());
        OT_VECTEUR_3D normvpr1=(vpr11&vpr12); normvpr1.norme();
        if(normvpr1*normvpt<cos(tri_return_angl) || normvpr1*normvpto<cos(tri_return_angl))
          tqual1=-1.;
        OT_VECTEUR_3D vpr21(p->get_coord(),trimateothernd->get_coord());
        OT_VECTEUR_3D vpr22(p->get_coord(),sgchk->get_noeud1()->get_coord());
        OT_VECTEUR_3D normvpr2=(vpr21&vpr22); normvpr2.norme();
        if(normvpr2*normvpt<cos(tri_return_angl)|| normvpr2*normvpto<cos(tri_return_angl))
          tqual2=-1.;
        if(tqual1<=tqual2)
        {
          if(tqual1<tqualvpt || tqual1<tqualvpto)
            tqual1=-1.;
        }
        else if (tqual2<tqual1)
        {
          if(tqual2<tqualvpt || tqual2<tqualvpto)
            tqual2=-1.;
        }
        lstqualtri.insert(std::pair<double,MG_NOEUD*>(tqual1,proxnd));
        lstqualtri.insert(std::pair<double,MG_NOEUD*>(tqual2,proxnd));
      }
      else 
      {
        double tqual=tq.qualite_triangle(p->get_coord(),sgchk->get_noeud1()->get_coord(),sgchk->get_noeud2()->get_coord());
        OT_VECTEUR_3D vpr1(p->get_coord(),sgchk->get_noeud1()->get_coord());
        OT_VECTEUR_3D vpr2(p->get_coord(),sgchk->get_noeud2()->get_coord());
        OT_VECTEUR_3D normvpr=(vpr1&vpr2); normvpr.norme();
        if(normvpr*normvpt<cos(tri_return_angl) || normvpr*normvpto<cos(tri_return_angl))
          tqual=-1.;
        lstqualtri.insert(std::pair<double,MG_NOEUD*>(tqual,proxnd));
      }
    }
    if (sgchk->get_noeud1()==prli->get_noeud2() && sgchk->get_noeud2()==prli->get_noeud1())
    {
      if(insph_swap_chk>0 && qualswap>0)
      {
        double tqual1=tq.qualite_triangle(p->get_coord(),sgchk->get_noeud2()->get_coord(),trimateothernd->get_coord());
        double tqual2=tq.qualite_triangle(p->get_coord(),trimateothernd->get_coord(),sgchk->get_noeud1()->get_coord());
        OT_VECTEUR_3D vpr11(p->get_coord(),sgchk->get_noeud2()->get_coord());
        OT_VECTEUR_3D vpr12(p->get_coord(),trimateothernd->get_coord());
        OT_VECTEUR_3D normvpr1=(vpr11&vpr12); normvpr1.norme();
        if(normvpr1*normvpt<cos(tri_return_angl) || normvpr1*normvpto<cos(tri_return_angl))
          tqual1=-1.;
        OT_VECTEUR_3D vpr21(p->get_coord(),trimateothernd->get_coord());
        OT_VECTEUR_3D vpr22(p->get_coord(),sgchk->get_noeud1()->get_coord());
        OT_VECTEUR_3D normvpr2=(vpr21&vpr22); normvpr2.norme();
        if(normvpr2*normvpt<cos(tri_return_angl)|| normvpr2*normvpto<cos(tri_return_angl))
          tqual2=-1.;
        if(tqual1<=tqual2)
        {
          if(tqual1<tqualvpt || tqual1<tqualvpto)
            tqual1=-1.;
        }
        else if (tqual2<tqual1)
        {
          if(tqual2<tqualvpt || tqual2<tqualvpto)
            tqual2=-1.;
        }
        lstqualtri.insert(std::pair<double,MG_NOEUD*>(tqual1,proxnd));
        lstqualtri.insert(std::pair<double,MG_NOEUD*>(tqual2,proxnd));
      }
      else 
      {
        double tqual=tq.qualite_triangle(p->get_coord(),sgchk->get_noeud2()->get_coord(),sgchk->get_noeud1()->get_coord());
        OT_VECTEUR_3D vpr1(p->get_coord(),sgchk->get_noeud2()->get_coord());
        OT_VECTEUR_3D vpr2(p->get_coord(),sgchk->get_noeud1()->get_coord());
        OT_VECTEUR_3D normvpr=(vpr1&vpr2); normvpr.norme();
        if(normvpr*normvpt<cos(tri_return_angl) || normvpr*normvpto<cos(tri_return_angl))
          tqual=-1.;
        lstqualtri.insert(std::pair<double,MG_NOEUD*>(tqual,proxnd));
      }
    }
    if (sgchk->get_noeud1()==prli->get_noeud3() && sgchk->get_noeud2()==prli->get_noeud2())
    {
      if(insph_swap_chk>0 && qualswap>0)
      {
        double tqual1=tq.qualite_triangle(p->get_coord(),sgchk->get_noeud2()->get_coord(),trimateothernd->get_coord());
        double tqual2=tq.qualite_triangle(p->get_coord(),trimateothernd->get_coord(),sgchk->get_noeud1()->get_coord());
        OT_VECTEUR_3D vpr11(p->get_coord(),sgchk->get_noeud2()->get_coord());
        OT_VECTEUR_3D vpr12(p->get_coord(),trimateothernd->get_coord());
        OT_VECTEUR_3D normvpr1=(vpr11&vpr12); normvpr1.norme();
        if(normvpr1*normvpt<cos(tri_return_angl) || normvpr1*normvpto<cos(tri_return_angl))
          tqual1=-1.;
        OT_VECTEUR_3D vpr21(p->get_coord(),trimateothernd->get_coord());
        OT_VECTEUR_3D vpr22(p->get_coord(),sgchk->get_noeud1()->get_coord());
        OT_VECTEUR_3D normvpr2=(vpr21&vpr22); normvpr2.norme();
        if(normvpr2*normvpt<cos(tri_return_angl)|| normvpr2*normvpto<cos(tri_return_angl))
          tqual2=-1.;
        if(tqual1<=tqual2)
        {
          if(tqual1<tqualvpt || tqual1<tqualvpto)
            tqual1=-1.;
        }
        else if (tqual2<tqual1)
        {
          if(tqual2<tqualvpt || tqual2<tqualvpto)
            tqual2=-1.;
        }
        lstqualtri.insert(std::pair<double,MG_NOEUD*>(tqual1,proxnd));
        lstqualtri.insert(std::pair<double,MG_NOEUD*>(tqual2,proxnd));
      }
      else 
      {
        double tqual=tq.qualite_triangle(p->get_coord(),sgchk->get_noeud2()->get_coord(),sgchk->get_noeud1()->get_coord());
        OT_VECTEUR_3D vpr1(p->get_coord(),sgchk->get_noeud2()->get_coord());
        OT_VECTEUR_3D vpr2(p->get_coord(),sgchk->get_noeud1()->get_coord());
        OT_VECTEUR_3D normvpr=(vpr1&vpr2); normvpr.norme();
        if(normvpr*normvpt<cos(tri_return_angl) || normvpr*normvpto<cos(tri_return_angl))
          tqual=-1.;
        lstqualtri.insert(std::pair<double,MG_NOEUD*>(tqual,proxnd));
      }
    }
    if (sgchk->get_noeud1()==prli->get_noeud1() && sgchk->get_noeud2()==prli->get_noeud3())
    {
      if(insph_swap_chk>0 && qualswap>0)
      {
        double tqual1=tq.qualite_triangle(p->get_coord(),sgchk->get_noeud2()->get_coord(),trimateothernd->get_coord());
        double tqual2=tq.qualite_triangle(p->get_coord(),trimateothernd->get_coord(),sgchk->get_noeud1()->get_coord());
        OT_VECTEUR_3D vpr11(p->get_coord(),sgchk->get_noeud2()->get_coord());
        OT_VECTEUR_3D vpr12(p->get_coord(),trimateothernd->get_coord());
        OT_VECTEUR_3D normvpr1=(vpr11&vpr12); normvpr1.norme();
        if(normvpr1*normvpt<cos(tri_return_angl) || normvpr1*normvpto<cos(tri_return_angl))
          tqual1=-1.;
        OT_VECTEUR_3D vpr21(p->get_coord(),trimateothernd->get_coord());
        OT_VECTEUR_3D vpr22(p->get_coord(),sgchk->get_noeud1()->get_coord());
        OT_VECTEUR_3D normvpr2=(vpr21&vpr22); normvpr2.norme();
        if(normvpr2*normvpt<cos(tri_return_angl)|| normvpr2*normvpto<cos(tri_return_angl))
          tqual2=-1.;
        if(tqual1<=tqual2)
        {
          if(tqual1<tqualvpt || tqual1<tqualvpto)
            tqual1=-1.;
        }
        else if (tqual2<tqual1)
        {
          if(tqual2<tqualvpt || tqual2<tqualvpto)
            tqual2=-1.;
        }
        lstqualtri.insert(std::pair<double,MG_NOEUD*>(tqual1,proxnd));
        lstqualtri.insert(std::pair<double,MG_NOEUD*>(tqual2,proxnd));
      }
      else 
      {
        double tqual=tq.qualite_triangle(p->get_coord(),sgchk->get_noeud2()->get_coord(),sgchk->get_noeud1()->get_coord());
        OT_VECTEUR_3D vpr1(p->get_coord(),sgchk->get_noeud2()->get_coord());
        OT_VECTEUR_3D vpr2(p->get_coord(),sgchk->get_noeud1()->get_coord());
        OT_VECTEUR_3D normvpr=(vpr1&vpr2); normvpr.norme();
        if(normvpr*normvpt<cos(tri_return_angl) || normvpr*normvpto<cos(tri_return_angl))
          tqual=-1.;
        lstqualtri.insert(std::pair<double,MG_NOEUD*>(tqual,proxnd));
      }
    }
 }
 else
 {
   if (sgchk->get_noeud1()==prli->get_noeud1() && sgchk->get_noeud2()==prli->get_noeud2())
    {
        double tqual=tq.qualite_triangle(p->get_coord(),sgchk->get_noeud1()->get_coord(),sgchk->get_noeud2()->get_coord());
        OT_VECTEUR_3D vpr1(p->get_coord(),sgchk->get_noeud1()->get_coord());
        OT_VECTEUR_3D vpr2(p->get_coord(),sgchk->get_noeud2()->get_coord());
        OT_VECTEUR_3D normvpr=(vpr1&vpr2); normvpr.norme();
        if(normvpr*normvpt<cos(tri_return_angl))
          tqual=-1.;
        lstqualtri.insert(std::pair<double,MG_NOEUD*>(tqual,proxnd));
    }
    if (sgchk->get_noeud1()==prli->get_noeud2() && sgchk->get_noeud2()==prli->get_noeud3())
    {
        double tqual=tq.qualite_triangle(p->get_coord(),sgchk->get_noeud1()->get_coord(),sgchk->get_noeud2()->get_coord());
        OT_VECTEUR_3D vpr1(p->get_coord(),sgchk->get_noeud1()->get_coord());
        OT_VECTEUR_3D vpr2(p->get_coord(),sgchk->get_noeud2()->get_coord());
        OT_VECTEUR_3D normvpr=(vpr1&vpr2); normvpr.norme();
        if(normvpr*normvpt<cos(tri_return_angl))
          tqual=-1.;
        lstqualtri.insert(std::pair<double,MG_NOEUD*>(tqual,proxnd));
    }
    if (sgchk->get_noeud1()==prli->get_noeud3() && sgchk->get_noeud2()==prli->get_noeud1())
    {
        double tqual=tq.qualite_triangle(p->get_coord(),sgchk->get_noeud1()->get_coord(),sgchk->get_noeud2()->get_coord());
        OT_VECTEUR_3D vpr1(p->get_coord(),sgchk->get_noeud1()->get_coord());
        OT_VECTEUR_3D vpr2(p->get_coord(),sgchk->get_noeud2()->get_coord());
        OT_VECTEUR_3D normvpr=(vpr1&vpr2); normvpr.norme();
        if(normvpr*normvpt<cos(tri_return_angl))
          tqual=-1.;
        lstqualtri.insert(std::pair<double,MG_NOEUD*>(tqual,proxnd));
    }
    if (sgchk->get_noeud1()==prli->get_noeud2() && sgchk->get_noeud2()==prli->get_noeud1())
    {
        double tqual=tq.qualite_triangle(p->get_coord(),sgchk->get_noeud2()->get_coord(),sgchk->get_noeud1()->get_coord());
        OT_VECTEUR_3D vpr1(p->get_coord(),sgchk->get_noeud2()->get_coord());
        OT_VECTEUR_3D vpr2(p->get_coord(),sgchk->get_noeud1()->get_coord());
        OT_VECTEUR_3D normvpr=(vpr1&vpr2); normvpr.norme();
        if(normvpr*normvpt<cos(tri_return_angl))
          tqual=-1.;
        lstqualtri.insert(std::pair<double,MG_NOEUD*>(tqual,proxnd));
    }
    if (sgchk->get_noeud1()==prli->get_noeud3() && sgchk->get_noeud2()==prli->get_noeud2())
    {
        double tqual=tq.qualite_triangle(p->get_coord(),sgchk->get_noeud2()->get_coord(),sgchk->get_noeud1()->get_coord());
        OT_VECTEUR_3D vpr1(p->get_coord(),sgchk->get_noeud2()->get_coord());
        OT_VECTEUR_3D vpr2(p->get_coord(),sgchk->get_noeud1()->get_coord());
        OT_VECTEUR_3D normvpr=(vpr1&vpr2); normvpr.norme();
        if(normvpr*normvpt<cos(tri_return_angl))
          tqual=-1.;
        lstqualtri.insert(std::pair<double,MG_NOEUD*>(tqual,proxnd));
    }
    if (sgchk->get_noeud1()==prli->get_noeud1() && sgchk->get_noeud2()==prli->get_noeud3())
    {
      double tqual=tq.qualite_triangle(p->get_coord(),sgchk->get_noeud2()->get_coord(),sgchk->get_noeud1()->get_coord());
        OT_VECTEUR_3D vpr1(p->get_coord(),sgchk->get_noeud2()->get_coord());
        OT_VECTEUR_3D vpr2(p->get_coord(),sgchk->get_noeud1()->get_coord());
        OT_VECTEUR_3D normvpr=(vpr1&vpr2); normvpr.norme();
        if(normvpr*normvpt<cos(tri_return_angl))
          tqual=-1.;
        lstqualtri.insert(std::pair<double,MG_NOEUD*>(tqual,proxnd));
      
    }
 }
 
}
  std::multimap<double,MG_NOEUD*,std::less<double> >::iterator itlstqualtri=lstqualtri.begin();
  lstqualprxndfinal.insert(std::pair<double,MG_NOEUD*>((*itlstqualtri).first,(*itlstqualtri).second));
  
  }
}
 
if (lstqualprxndfinal.size()>0)
{
std::multimap<double,MG_NOEUD*,std::greater<double> >::iterator itlstqualprxndfinal=lstqualprxndfinal.begin();
  proximityqual=(*itlstqualprxndfinal).first;
}
std::multimap<double,MG_TRIANGLE*,std::less<double> > delinsqualtri;  
double normale[3];
int insideface=0;
std::multimap<double,MG_FACE*,std::less<double> > lstfacepointdist;
int facenb=geo->get_nb_mg_face();
            LISTE_MG_FACE::iterator itf;
            double xyz[3];
              xyz[0]=p->get_x();
              xyz[1]=p->get_y();
              xyz[2]=p->get_z();
            for(MG_FACE* fac=geo->get_premier_face(itf);fac!=NULL;fac=geo->get_suivant_face(itf))
            {
              double uv[2];
              fac->inverser(uv,xyz);
              double xyz2[3];
              fac->evaluer(uv,xyz2);
              OT_VECTEUR_3D vechk(xyz,xyz2);
              lstfacepointdist.insert(std::pair<double,MG_FACE*> (vechk.get_longueur(),fac));
              //double dis;
              //MG_GEOMETRIE_OUTILS f1;
              //int ch=f1.calcule_distance_contour_face_xyz(xyz,fac,&dis);
              //cout<<"dis= "<<dis<<"   vechk.get_longueur()= "<<vechk.get_longueur()<<endl;
              //if (ch==1 && dis>=0.)
             // if (vechk.get_longueur()<5e-3)
            }
std::multimap<double,MG_FACE*,std::less<double> >::iterator itlstfacepointdist=lstfacepointdist.begin();
if (lstfacepointdist.size()>0)      
{
  //cout<<"(*itlstfacepointdist).first= "<<(*itlstfacepointdist).first<<endl;
  MG_FACE* face=(*itlstfacepointdist).second;
  double uv[2];
  face->inverser(uv,xyz);
  face->calcul_normale_unitaire(uv,normale);
  MG_COFACE *coface=face->get_mg_coface(0);
  int signe=coface->get_orientation();
  
  TPL_MAP_ENTITE<MG_TRIANGLE*> lstneitri;
  int neitrinb=lstneitri.get_nb();
  while(neitrinb==0) 
{
  octree.rechercher(p->get_x(),p->get_y(),p->get_z(),search_radius,lstneitri);
  neitrinb=lstneitri.get_nb();
  search_radius=search_radius+0.01*search_radius;
}
TPL_MAP_ENTITE<MG_TRIANGLE*>::ITERATEUR itnormtst;
OT_VECTEUR_3D  normale_discrete(0.,0.,0.);
for (MG_TRIANGLE* tri1=lstneitri.get_premier(itnormtst);tri1!=NULL;tri1=lstneitri.get_suivant(itnormtst))
    {
      OT_VECTEUR_3D vec1(tri1->get_noeud1()->get_coord(),tri1->get_noeud2()->get_coord());
      OT_VECTEUR_3D vec2(tri1->get_noeud1()->get_coord(),tri1->get_noeud3()->get_coord());
      OT_VECTEUR_3D normtst=(vec1&vec2); normtst.norme();
      normale_discrete=normtst+normale_discrete;
    }
normale_discrete.norme();
double n_ps=normale_discrete*normale;
n_ps=n_ps*-1;
if (n_ps>1.) n_ps=1.;
if (n_ps<-1.) n_ps=-1.;
double n_angle=acos(n_ps);
if(n_angle<(0.5*3.14159265358979323846) || n_angle>-(0.5*3.14159265358979323846))             
 insideface++;
}
if(insideface>0)            
{           
TPL_MAP_ENTITE<MG_TRIANGLE*> lstneitri;
int neitrinb=lstneitri.get_nb();
while(neitrinb==0) 
{
  octree.rechercher(p->get_x(),p->get_y(),p->get_z(),search_radius,lstneitri);
  neitrinb=lstneitri.get_nb();
  search_radius=search_radius+0.01*search_radius;
}
TPL_MAP_ENTITE<MG_TRIANGLE*> insphtri;      
TPL_MAP_ENTITE<MG_TRIANGLE*>::ITERATEUR it1;
for (MG_TRIANGLE* tri1=lstneitri.get_premier(it1);tri1!=NULL;tri1=lstneitri.get_suivant(it1))
    {
      double insphchk=inshper_point(p,tri1);
      //cout<<"insphchk= "<<insphchk<<endl;
      if (insphchk<=0.)
        insphtri.ajouter(tri1);
    }
TPL_MAP_ENTITE<MG_SEGMENT*> segbase;
TPL_MAP_ENTITE<MG_TRIANGLE*> basetri;
double pproj[3];
TPL_MAP_ENTITE<MG_TRIANGLE*>::ITERATEUR inspi;
for (MG_TRIANGLE* insphertri=insphtri.get_premier(inspi);insphertri!=NULL;insphertri=insphtri.get_suivant(inspi))
{
MG_NOEUD* inspnd1=insphertri->get_noeud1();
MG_NOEUD* inspnd2=insphertri->get_noeud2();
MG_NOEUD* inspnd3=insphertri->get_noeud3();
OT_VECTEUR_3D tvec1(inspnd1->get_coord(),inspnd2->get_coord());
OT_VECTEUR_3D tvec2(inspnd1->get_coord(),inspnd3->get_coord());
OT_VECTEUR_3D tnorm=(tvec1&tvec2); tnorm.norme();
OT_VECTEUR_3D norm=normale;
 
double parallel=norm*tnorm;
/*cramer method
OT_VECTEUR_3D r1((-p->get_x()),(inspnd2->get_x()-inspnd1->get_x()),(inspnd3->get_x()-inspnd1->get_x()));
OT_VECTEUR_3D r2((-p->get_y()),(inspnd2->get_y()-inspnd1->get_y()),(inspnd3->get_y()-inspnd1->get_y()));
OT_VECTEUR_3D r3((-p->get_z()),(inspnd2->get_z()-inspnd1->get_z()),(inspnd3->get_z()-inspnd1->get_z()));
OT_VECTEUR_3D d1((norm.get_x()),(inspnd2->get_x()-inspnd1->get_x()),(inspnd3->get_x()-inspnd1->get_x()));
OT_VECTEUR_3D d2((norm.get_y()),(inspnd2->get_y()-inspnd1->get_y()),(inspnd3->get_y()-inspnd1->get_y()));
OT_VECTEUR_3D d3((norm.get_z()),(inspnd2->get_z()-inspnd1->get_z()),(inspnd3->get_z()-inspnd1->get_z()));
 
OT_MATRICE_3D tr(r1,r2,r3);
OT_MATRICE_3D td(d1,d2,d3);
double detd=td.get_determinant();
double detr=tr.get_determinant();
if (detd==0.)// || detr==0.) 
  cout<<"wrong ins point projection on the mesh"<<endl;
if (detd!=0.)
  */
if (parallel>0.7 || parallel<-0.7)
{
  //cout<<"normale[0]= "<<normale[0]<<" normale[1]= "<<normale[1]<<" normale[2]= "<<normale[2]<<endl;
OT_VECTEUR_3D vvec(inspnd1->get_coord(),p->get_coord());
double t= (tnorm*vvec)/parallel;
t=-t;
pproj[0]=p->get_x()+t*norm.get_x();
pproj[1]=p->get_y()+t*norm.get_y();
pproj[2]=p->get_z()+t*norm.get_z();
MG_MAILLAGE_OUTILS tribas;
int tribasval=tribas.estdansletriangle(insphertri,pproj[0],pproj[1],pproj[2]);
int intri=tribas.compare_etat_triangle(tribasval,MG_MAILLAGE_OUTILS::INTERIEUR);
int insidtri=tribas.compare_etat_triangle(tribasval,MG_MAILLAGE_OUTILS::STRICTINTERIEUR);
int onedge=tribas.compare_etat_triangle(tribasval,MG_MAILLAGE_OUTILS::SUR_ARETE);
if (insidtri==1)
{
  MG_TRIANGLE* ndintri=insphertri;
  MG_SEGMENT* seg1=ndintri->get_segment1();
  MG_SEGMENT* seg2=ndintri->get_segment2();
  MG_SEGMENT* seg3=ndintri->get_segment3();
  
  if(seg1->get_lien_triangle()->get_nb()>1)
  {
    MG_TRIANGLE* trioth1;
  if (seg1->get_lien_triangle()->get(0)!=ndintri) trioth1=seg1->get_lien_triangle()->get(0);
  else if (seg1->get_lien_triangle()->get(1)!=ndintri) trioth1=seg1->get_lien_triangle()->get(1);
  double pinsphnb1=inshper_point(p,trioth1);
  if (pinsphnb1<=0. && seg1->get_lien_topologie()->get_dimension()>1 && qualswap>0)
  {
    MG_NOEUD* othnd;
    if (trioth1->get_noeud1()!=seg1->get_noeud1() && trioth1->get_noeud1()!=seg1->get_noeud2()) othnd=trioth1->get_noeud1();
    else if (trioth1->get_noeud2()!=seg1->get_noeud1() && trioth1->get_noeud2()!=seg1->get_noeud2()) othnd=trioth1->get_noeud2();
    else if (trioth1->get_noeud3()!=seg1->get_noeud1() && trioth1->get_noeud3()!=seg1->get_noeud2()) othnd=trioth1->get_noeud3();
    double qual1=tq.qualite_triangle(p->get_coord(),seg1->get_noeud1()->get_coord(),othnd->get_coord());
    double qual2=tq.qualite_triangle(p->get_coord(),seg1->get_noeud2()->get_coord(),othnd->get_coord());
    delinsqualtri.insert(std::pair<double,MG_TRIANGLE*>(qual1,ndintri));
    delinsqualtri.insert(std::pair<double,MG_TRIANGLE*>(qual2,ndintri));
  }
  else 
  {
    double qual1=tq.qualite_triangle(p->get_coord(),seg1->get_noeud1()->get_coord(),seg1->get_noeud2()->get_coord());
    delinsqualtri.insert(std::pair<double,MG_TRIANGLE*>(qual1,ndintri));
  }
  }
else 
{
  double qual1=tq.qualite_triangle(p->get_coord(),seg1->get_noeud1()->get_coord(),seg1->get_noeud2()->get_coord());
  delinsqualtri.insert(std::pair<double,MG_TRIANGLE*>(qual1,ndintri));
}
  
 if(seg2->get_lien_triangle()->get_nb()>1)
  {
   MG_TRIANGLE* trioth2;
  if (seg2->get_lien_triangle()->get(0)!=ndintri) trioth2=seg2->get_lien_triangle()->get(0);
  else if (seg2->get_lien_triangle()->get(1)!=ndintri) trioth2=seg2->get_lien_triangle()->get(1);
  double pinsphnb2=inshper_point(p,trioth2);
  if (pinsphnb2<=0. && seg2->get_lien_topologie()->get_dimension()>1 && qualswap>0)
  {
    MG_NOEUD* othnd;
    if (trioth2->get_noeud1()!=seg2->get_noeud1() && trioth2->get_noeud1()!=seg2->get_noeud2()) othnd=trioth2->get_noeud1();
    else if (trioth2->get_noeud2()!=seg2->get_noeud1() && trioth2->get_noeud2()!=seg2->get_noeud2()) othnd=trioth2->get_noeud2();
    else if (trioth2->get_noeud3()!=seg2->get_noeud1() && trioth2->get_noeud3()!=seg2->get_noeud2()) othnd=trioth2->get_noeud3();
    double qual1=tq.qualite_triangle(p->get_coord(),seg2->get_noeud1()->get_coord(),othnd->get_coord());
    double qual2=tq.qualite_triangle(p->get_coord(),seg2->get_noeud2()->get_coord(),othnd->get_coord());
    delinsqualtri.insert(std::pair<double,MG_TRIANGLE*>(qual1,ndintri));
    delinsqualtri.insert(std::pair<double,MG_TRIANGLE*>(qual2,ndintri));
  }
  else 
  {
    double qual1=tq.qualite_triangle(p->get_coord(),seg2->get_noeud1()->get_coord(),seg2->get_noeud2()->get_coord());
    delinsqualtri.insert(std::pair<double,MG_TRIANGLE*>(qual1,ndintri));
  } 
  }
   else 
  {
    double qual1=tq.qualite_triangle(p->get_coord(),seg2->get_noeud1()->get_coord(),seg2->get_noeud2()->get_coord());
    delinsqualtri.insert(std::pair<double,MG_TRIANGLE*>(qual1,ndintri));
  } 
  
  if(seg3->get_lien_triangle()->get_nb()>1)
  {
   MG_TRIANGLE* trioth3;
  if (seg3->get_lien_triangle()->get(0)!=ndintri) trioth3=seg3->get_lien_triangle()->get(0);
  else if (seg3->get_lien_triangle()->get(1)!=ndintri) trioth3=seg3->get_lien_triangle()->get(1);
  double pinsphnb3=inshper_point(p,trioth3);
  if (pinsphnb3<=0. && seg3->get_lien_topologie()->get_dimension()>1 && qualswap>0)
  {
    MG_NOEUD* othnd;
    if (trioth3->get_noeud1()!=seg3->get_noeud1() && trioth3->get_noeud1()!=seg3->get_noeud2()) othnd=trioth3->get_noeud1();
    else if (trioth3->get_noeud2()!=seg3->get_noeud1() && trioth3->get_noeud2()!=seg3->get_noeud2()) othnd=trioth3->get_noeud2();
    else if (trioth3->get_noeud3()!=seg3->get_noeud1() && trioth3->get_noeud3()!=seg3->get_noeud2()) othnd=trioth3->get_noeud3();
    double qual1=tq.qualite_triangle(p->get_coord(),seg3->get_noeud1()->get_coord(),othnd->get_coord());
    double qual2=tq.qualite_triangle(p->get_coord(),seg3->get_noeud2()->get_coord(),othnd->get_coord());
    delinsqualtri.insert(std::pair<double,MG_TRIANGLE*>(qual1,ndintri));
    delinsqualtri.insert(std::pair<double,MG_TRIANGLE*>(qual2,ndintri));
  }
  else 
  {
    double qual1=tq.qualite_triangle(p->get_coord(),seg3->get_noeud1()->get_coord(),seg3->get_noeud2()->get_coord());
    delinsqualtri.insert(std::pair<double,MG_TRIANGLE*>(qual1,ndintri));
  } 
  }
  else 
  {
    double qual1=tq.qualite_triangle(p->get_coord(),seg3->get_noeud1()->get_coord(),seg3->get_noeud2()->get_coord());
    delinsqualtri.insert(std::pair<double,MG_TRIANGLE*>(qual1,ndintri));
  }
  break;
}
else if (onedge==1)
{
  MG_TRIANGLE* ndontri=insphertri;
  MG_NOEUD* ndo1=ndontri->get_noeud1();
  MG_NOEUD* ndo2=ndontri->get_noeud2();
  MG_NOEUD* ndo3=ndontri->get_noeud3();
  int onvert1=tribas.compare_etat_triangle(tribasval,MG_MAILLAGE_OUTILS::SOMMET1);
  int onvert2=tribas.compare_etat_triangle(tribasval,MG_MAILLAGE_OUTILS::SOMMET2);
  int onvert3=tribas.compare_etat_triangle(tribasval,MG_MAILLAGE_OUTILS::SOMMET3);
  int onedge1=tribas.compare_etat_triangle(tribasval,MG_MAILLAGE_OUTILS::ARETE1);
  int onedge2=tribas.compare_etat_triangle(tribasval,MG_MAILLAGE_OUTILS::ARETE2);
  int onedge3=tribas.compare_etat_triangle(tribasval,MG_MAILLAGE_OUTILS::ARETE3);
  if (onvert1==1 || onvert2==1 || onvert3==1)
  {
    MG_NOEUD* ond;
    if(onvert1==1)ond=ndo1;
    if(onvert2==1)ond=ndo2;
    if(onvert3==1)ond=ndo3;
    for(int iind=0;iind<ond->get_lien_triangle()->get_nb();iind++)
    {
      MG_TRIANGLE* trlie=ond->get_lien_triangle()->get(iind);
      MG_SEGMENT* trlieseg1=trlie->get_segment1();
      MG_SEGMENT* trlieseg2=trlie->get_segment2();
      MG_SEGMENT* trlieseg3=trlie->get_segment3();
      MG_SEGMENT* segchkk;
      if (trlieseg1->get_noeud1()!=ond && trlieseg1->get_noeud2()!=ond) segchkk=trlieseg1;
      else if (trlieseg2->get_noeud1()!=ond && trlieseg2->get_noeud2()!=ond) segchkk=trlieseg2;
      else if (trlieseg3->get_noeud1()!=ond && trlieseg3->get_noeud2()!=ond) segchkk=trlieseg3;
 
      if(segchkk->get_lien_triangle()->get_nb()>1)
      {
        MG_TRIANGLE* trioth;
      if(segchkk->get_lien_triangle()->get(0)!=trlie) trioth=segchkk->get_lien_triangle()->get(0);
      else if(segchkk->get_lien_triangle()->get(1)!=trlie) trioth=segchkk->get_lien_triangle()->get(1);
 
  double pinsphnb=inshper_point(p,trioth);
  if (pinsphnb<=0. && qualswap>0)
  {
    MG_NOEUD* othnd;
    if (trioth->get_noeud1()!=segchkk->get_noeud1() && trioth->get_noeud1()!=segchkk->get_noeud2()) othnd=trioth->get_noeud1();
    else if (trioth->get_noeud2()!=segchkk->get_noeud1() && trioth->get_noeud2()!=segchkk->get_noeud2()) othnd=trioth->get_noeud2();
    else if (trioth->get_noeud3()!=segchkk->get_noeud1() && trioth->get_noeud3()!=segchkk->get_noeud2()) othnd=trioth->get_noeud3();
    double qual1=tq.qualite_triangle(p->get_coord(),segchkk->get_noeud1()->get_coord(),othnd->get_coord());
    double qual2=tq.qualite_triangle(p->get_coord(),segchkk->get_noeud2()->get_coord(),othnd->get_coord());
    delinsqualtri.insert(std::pair<double,MG_TRIANGLE*>(qual1,trlie));
    delinsqualtri.insert(std::pair<double,MG_TRIANGLE*>(qual2,trlie));
  }
      else 
  {
    double qual1=tq.qualite_triangle(p->get_coord(),segchkk->get_noeud1()->get_coord(),segchkk->get_noeud2()->get_coord());
    delinsqualtri.insert(std::pair<double,MG_TRIANGLE*>(qual1,trlie));
  } 
 
      }
      else if(segchkk->get_lien_triangle()->get_nb()==1)
  {
    double qual1=tq.qualite_triangle(p->get_coord(),segchkk->get_noeud1()->get_coord(),segchkk->get_noeud2()->get_coord());
    delinsqualtri.insert(std::pair<double,MG_TRIANGLE*>(qual1,trlie));
  } 
  
    }
    break;
  }
  
  else if(onedge1==1 || onedge2==1 || onedge3==1)
  {
    MG_TRIANGLE* ndontri=insphertri;
    MG_SEGMENT* onseg;
    if (onedge1==1) onseg=ndontri->get_segment1();
    if (onedge2==1) onseg=ndontri->get_segment2();
    if (onedge3==1) onseg=ndontri->get_segment3();
    TPL_MAP_ENTITE<MG_SEGMENT*> freesegs;
    for(int ifr=0;ifr<onseg->get_lien_triangle()->get_nb();ifr++)
    {
      MG_TRIANGLE* trfr=onseg->get_lien_triangle()->get(ifr);
      if (trfr->get_segment1()!=onseg) freesegs.ajouter(trfr->get_segment1());
      if (trfr->get_segment2()!=onseg) freesegs.ajouter(trfr->get_segment2());
      if (trfr->get_segment3()!=onseg) freesegs.ajouter(trfr->get_segment3());
    }
    TPL_MAP_ENTITE<MG_SEGMENT*>::ITERATEUR itfr;
    for (MG_SEGMENT* segfre=freesegs.get_premier(itfr);segfre!=NULL;segfre=freesegs.get_suivant(itfr))
    {
      if(segfre->get_lien_triangle()->get_nb()>1)
      {
        MG_TRIANGLE* trioth;
      if(segfre->get_lien_triangle()->get(0)==onseg->get_lien_triangle()->get(0) || segfre->get_lien_triangle()->get(0)==onseg->get_lien_triangle()->get(1)) 
        trioth=segfre->get_lien_triangle()->get(1);
      else if(segfre->get_lien_triangle()->get(1)==onseg->get_lien_triangle()->get(0) || segfre->get_lien_triangle()->get(1)==onseg->get_lien_triangle()->get(1))
        trioth=segfre->get_lien_triangle()->get(0);
      double pinsphnb=inshper_point(p,trioth);
  if (pinsphnb<=0. && segfre->get_lien_topologie()->get_dimension()>1 && qualswap>0)
  {
    MG_NOEUD* othnd;
    if (trioth->get_noeud1()!=segfre->get_noeud1() && trioth->get_noeud1()!=segfre->get_noeud2()) othnd=trioth->get_noeud1();
    else if (trioth->get_noeud2()!=segfre->get_noeud1() && trioth->get_noeud2()!=segfre->get_noeud2()) othnd=trioth->get_noeud2();
    else if (trioth->get_noeud3()!=segfre->get_noeud1() && trioth->get_noeud3()!=segfre->get_noeud2()) othnd=trioth->get_noeud3();
    double qual1=tq.qualite_triangle(p->get_coord(),segfre->get_noeud1()->get_coord(),othnd->get_coord());
    double qual2=tq.qualite_triangle(p->get_coord(),segfre->get_noeud2()->get_coord(),othnd->get_coord());
    delinsqualtri.insert(std::pair<double,MG_TRIANGLE*>(qual1,ndontri));
    delinsqualtri.insert(std::pair<double,MG_TRIANGLE*>(qual2,ndontri));
  }
  else 
  {
    double qual1=tq.qualite_triangle(p->get_coord(),segfre->get_noeud1()->get_coord(),segfre->get_noeud2()->get_coord());
    delinsqualtri.insert(std::pair<double,MG_TRIANGLE*>(qual1,ndontri));
  }
      }
 else 
  {
    double qual1=tq.qualite_triangle(p->get_coord(),segfre->get_noeud1()->get_coord(),segfre->get_noeud2()->get_coord());
    delinsqualtri.insert(std::pair<double,MG_TRIANGLE*>(qual1,ndontri));
  }
      
    }
    break;
  }
}
}
}
 }
 
  //cout<<"delinsqualtri.size()= "<<delinsqualtri.size()<<endl;
if(delinsqualtri.size()>0)
{
  std::multimap<double,MG_TRIANGLE*,std::less<double> > :: iterator itdelinsqualtri=delinsqualtri.begin();
  delaunyinsqual=(*itdelinsqualtri).first;
}
 
 if (lstqualprxndfinal.size()>0 && proximityqual>delaunyinsqual && proximityqual>gentriqual)
{
  class MG_SOMMET_NOEUD* somno=geo->ajouter_mg_sommet_noeud(p);
  somno->ajouter_ccf((char*)"Dx",((*itpins).second)[0]);
  somno->ajouter_ccf((char*)"Dy",((*itpins).second)[1]);
  somno->ajouter_ccf((char*)"Dz",((*itpins).second)[2]);
  std::multimap<double,MG_NOEUD*,std::greater<double> >::iterator itlstqualprxndfinal=lstqualprxndfinal.begin();
  prox_nd((*itlstqualprxndfinal).second,p,mai,octreends,octree);
  double* pcoordbc=new double[6];
  pcoordbc[0]=p->get_x(); pcoordbc[1]=p->get_y(); pcoordbc[2]=p->get_z(); pcoordbc[3]=((*itpins).second)[0]; pcoordbc[4]=((*itpins).second)[1]; pcoordbc[5]=((*itpins).second)[2];
  lstgnifwrite.push_back(pcoordbc);
  pins_prox_Delaunay.insert(std::pair<MG_NOEUD*,double*> ((*itpins).first,(*itpins).second));
  proxndiiadd++;
  //cout<<"nds ins by proximity= "<<proxndiiadd<<endl;
}
 else if (delaunyinsqual>gentriqual && delinsqualtri.size()>0)
{
  class MG_SOMMET_NOEUD* somno=geo->ajouter_mg_sommet_noeud(p);
  somno->ajouter_ccf((char*)"Dx",((*itpins).second)[0]);
  somno->ajouter_ccf((char*)"Dy",((*itpins).second)[1]);
  somno->ajouter_ccf((char*)"Dz",((*itpins).second)[2]);
  
  delaunay_ndinsert(p,mai,search_radius,octree,geo,octreends);
  double* pcoordbc=new double[6];
  pcoordbc[0]=p->get_x(); pcoordbc[1]=p->get_y(); pcoordbc[2]=p->get_z(); pcoordbc[3]=((*itpins).second)[0]; pcoordbc[4]=((*itpins).second)[1]; pcoordbc[5]=((*itpins).second)[2];
  lstgnifwrite.push_back(pcoordbc);
  pins_prox_Delaunay.insert(std::pair<MG_NOEUD*,double*> ((*itpins).first,(*itpins).second));
  delonnodiiadd++;
  //cout<<" nds ins by delaunay= "<<delonnodiiadd<<endl;
}
else
{
  std::cout<<"DELITED POINT: p->get_x()= "<<p->get_x()<<"p->get_y()"<<p->get_y()<<std::endl;
  mai->supprimer_mg_noeudid(p->get_id());
  removednodiadd++;
}
 
 }
  }
std::cout<<"nds ins by proximity= "<<proxndiiadd<<" nds ins by delaunay= "<<delonnodiiadd<<" nds removed= "<<removednodiadd<<" verycloseee= "<<verycloseee<<std::endl;
/*
int mgvolnb=geo->get_nb_mg_volume();
MG_VOLUME* mgvol;
for (int iv=0;iv<mgvolnb;iv++)
{
  MG_ELEMENT_TOPOLOGIQUE *top1=mai->get_mg_triangle(0)->get_lien_topologie();
  MG_FACE *fac=(MG_FACE*)top1;
 
if (fac->get_mg_coface(0)->get_coquille()->get_mg_volume()==mai->get_mg_geometrie()->get_mg_volume(iv))
  mgvol=mai->get_mg_geometrie()->get_mg_volume(iv);
}
MAILLEUR2D_OPTIMISATION opt(mai,nivopt);
opt.optimise(mgvol);*/
int mgcouqenb=geo->get_nb_mg_coque();
std::cout<<"mgcouqenb= "<<mgcouqenb<<std::endl;
MAILLEUR2D_OPTIMISATION opt(mai,nivopt);
for(int couqenb=0;couqenb<mgcouqenb;couqenb++) 
{
  MG_COQUE* mgcouqe=geo->get_mg_coque(couqenb);
  opt.optimise(mgcouqe);
}
 
if(insremtyp>0)
{
  for(std::map<MG_NOEUD*,double*>::iterator itpins_prox_Delaunay=pins_prox_Delaunay.begin();itpins_prox_Delaunay!=pins_prox_Delaunay.end();itpins_prox_Delaunay++)
  {
    
    if((*itpins_prox_Delaunay).second[3]<1)
    {
      for(int ippd=0; ippd<((*itpins_prox_Delaunay).first)->get_lien_triangle()->get_nb();ippd++)
      {
        MG_TRIANGLE* tricha=((*itpins_prox_Delaunay).first)->get_lien_triangle()->get(ippd);
        tricha->change_origine(MAGIC::ORIGINE::MODIFICATION);
      }
    }
  }
}
 
 
gest.enregistrer(outputfilename);
 
std::ostringstream oss;
oss << "GNIFout" <<gnifoutputfilename ;
std::string namefic = oss.str();
std::string namefic1=namefic  + "_insremovtypsort.txt";
std::cout<<"namefic1= "<<namefic1<<std::endl;
FILE* in1=fopen(namefic1.c_str(),"wt");
for(std::vector<double*>::iterator itlstpinsert=lstgnifread.begin();itlstpinsert!=lstgnifread.end();itlstpinsert++)
      {
        int gnigcount=0;
        double* xyzpins1;
        xyzpins1=(*itlstpinsert);
        for(std::vector<double*>::iterator itlstpinserted=lstgnifwrite.begin();itlstpinserted!=lstgnifwrite.end();itlstpinserted++)
        {
          double* xyzpins2;
          xyzpins2=(*itlstpinserted);
          if(xyzpins1[0]==xyzpins2[0] && xyzpins1[1]==xyzpins2[1] && xyzpins1[2]==xyzpins2[2] && xyzpins1[3]==xyzpins2[3] && xyzpins1[4]==xyzpins2[4] && xyzpins1[5]==xyzpins2[5])
          {
            fprintf(in1,"1 %le %le %le %le %le %le\n",xyzpins1[0],xyzpins1[1],xyzpins1[2],xyzpins1[3]*1000.,xyzpins1[4]*1000.,xyzpins1[5]*1000.);
            gnigcount++;
          }
          
        }
        if(gnigcount==0)
          fprintf(in1,"0 %le %le %le %le %le %le\n",xyzpins1[0],xyzpins1[1],xyzpins1[2],xyzpins1[3]*1000.,xyzpins1[4]*1000.,xyzpins1[5]*1000.);
      }
fclose(in1);
std::string namefic2=namefic  + "_insertedpoints.txt";
std::cout<<"namefic2= "<<namefic2<<std::endl;
FILE* in2=fopen(namefic2.c_str(),"wt");
for(std::vector<double*>::iterator itlstpinsert=lstgnifwrite.begin();itlstpinsert!=lstgnifwrite.end();itlstpinsert++)
      {
        double* xyzpins1;
        xyzpins1=(*itlstpinsert);
        fprintf(in2,"%le %le %le %le %le %le\n",xyzpins1[0],xyzpins1[1],xyzpins1[2],xyzpins1[3]*1000.,xyzpins1[4]*1000.,xyzpins1[5]*1000.);
      }
fclose(in2);
 
 
}
void MAILLEUR2D_INS_NOEUD::prox_nd(MG_NOEUD* prxnd,MG_NOEUD* pinrt,MG_MAILLAGE* mai,TPL_OCTREE<MG_NOEUD*,MG_NOEUD*> &octreends,TPL_OCTREE<MG_TRIANGLE*,MG_NOEUD*> &octree)
{
 
  pinrt->change_lien_topologie(prxnd->get_lien_topologie());
  TPL_LISTE_ENTITE<MG_TRIANGLE*> deltrilst;
  std::map<MG_TRIANGLE*,MG_SEGMENT*>addseglst;
  TPL_LISTE_ENTITE<MG_TRIANGLE*> lstadtris;
    for (int ili=0;ili<prxnd->get_lien_triangle()->get_nb();ili++)
    {
      MG_TRIANGLE* deltri=prxnd->get_lien_triangle()->get(ili);
      deltrilst.ajouter(deltri);
     }
   for (int isegadlst=0;isegadlst<deltrilst.get_nb();isegadlst++)
   {
     MG_TRIANGLE* trid=deltrilst.get(isegadlst);
     MG_SEGMENT* seg1=trid->get_segment1();
     MG_SEGMENT* seg2=trid->get_segment2();
     MG_SEGMENT* seg3=trid->get_segment3();
     if (prxnd!=seg1->get_noeud1() && prxnd!=seg1->get_noeud2()) addseglst.insert(std::pair<MG_TRIANGLE*,MG_SEGMENT*>(trid,seg1));
     else if (prxnd!=seg2->get_noeud1() && prxnd!=seg2->get_noeud2()) addseglst.insert(std::pair<MG_TRIANGLE*,MG_SEGMENT*>(trid,seg2));
     else if (prxnd!=seg3->get_noeud1() && prxnd!=seg3->get_noeud2()) addseglst.insert(std::pair<MG_TRIANGLE*,MG_SEGMENT*>(trid,seg3));
   }
   std::map<MG_TRIANGLE*,MG_SEGMENT*>::iterator itaddseglst;
   for (itaddseglst=addseglst.begin();itaddseglst!=addseglst.end();itaddseglst++)
  {
    MG_SEGMENT* segcomm=(*itaddseglst).second;
    MG_TRIANGLE* triold=(*itaddseglst).first;
    MG_ELEMENT_TOPOLOGIQUE* toptriloc=triold->get_lien_topologie();
    MG_NOEUD* sgcommnd1=segcomm->get_noeud1();
    MG_NOEUD* sgcommnd2=segcomm->get_noeud2();
    MG_TRIANGLE* triad;
 if (sgcommnd1==triold->get_noeud1() && sgcommnd2==triold->get_noeud2()) triad=mai->ajouter_mg_triangle(toptriloc,sgcommnd1,sgcommnd2,pinrt,MAGIC::ORIGINE::IMPOSE);
 else if (sgcommnd1==triold->get_noeud2() && sgcommnd2==triold->get_noeud1()) triad=mai->ajouter_mg_triangle(toptriloc,sgcommnd2,sgcommnd1,pinrt,MAGIC::ORIGINE::IMPOSE); 
 else if (sgcommnd1==triold->get_noeud2() && sgcommnd2==triold->get_noeud3()) triad=mai->ajouter_mg_triangle(toptriloc,pinrt,sgcommnd1,sgcommnd2,MAGIC::ORIGINE::IMPOSE);
 else if (sgcommnd1==triold->get_noeud3() && sgcommnd2==triold->get_noeud2()) triad=mai->ajouter_mg_triangle(toptriloc,pinrt,sgcommnd2,sgcommnd1,MAGIC::ORIGINE::IMPOSE);
 else if (sgcommnd1==triold->get_noeud3() && sgcommnd2==triold->get_noeud1()) triad=mai->ajouter_mg_triangle(toptriloc,sgcommnd2,pinrt,sgcommnd1,MAGIC::ORIGINE::IMPOSE);
 else if (sgcommnd1==triold->get_noeud1() && sgcommnd2==triold->get_noeud3()) triad=mai->ajouter_mg_triangle(toptriloc,sgcommnd1,pinrt,sgcommnd2,MAGIC::ORIGINE::IMPOSE);
 TPL_LISTE_ENTITE<MG_SEGMENT*> triadsegs;
triadsegs.ajouter(triad->get_segment1());
triadsegs.ajouter(triad->get_segment2());
triadsegs.ajouter(triad->get_segment3());
TPL_LISTE_ENTITE<MG_SEGMENT*> trioldsegs;
trioldsegs.ajouter(triold->get_segment1());
trioldsegs.ajouter(triold->get_segment2());
trioldsegs.ajouter(triold->get_segment3());
for(int itriadsegs=0;itriadsegs<triadsegs.get_nb();itriadsegs++)
 {
  MG_SEGMENT* triadseg=triadsegs.get(itriadsegs);
  if(triadseg==segcomm)
  {
    triadseg->change_lien_topologie(segcomm->get_lien_topologie());
  }
  if(triadseg!=segcomm)
 {
   for(int itrioldsegs=0;itrioldsegs<trioldsegs.get_nb();itrioldsegs++)
  {
    MG_SEGMENT* trioldseg=trioldsegs.get(itrioldsegs);
    if(trioldseg!=segcomm) 
  {
    if(trioldseg->get_noeud1()==sgcommnd1 || trioldseg->get_noeud2()==sgcommnd1)
    {
      if(triadseg->get_noeud1()==sgcommnd1 || triadseg->get_noeud2()==sgcommnd1) triadseg->change_lien_topologie(trioldseg->get_lien_topologie());
    }
    else if(trioldseg->get_noeud1()==sgcommnd2 || trioldseg->get_noeud2()==sgcommnd2)
    {
      if(triadseg->get_noeud1()==sgcommnd2 || triadseg->get_noeud2()==sgcommnd2) triadseg->change_lien_topologie(trioldseg->get_lien_topologie());
    }
  }
  }
 }
 }
octree.inserer(triad);
lstadtris.ajouter(triad);
  }
  octreends.inserer(pinrt);
  octreends.supprimer(prxnd);
  
 
  for (int ideletriangle=0;ideletriangle<deltrilst.get_nb();ideletriangle++)
  {
    MG_TRIANGLE* deletingtri=deltrilst.get(ideletriangle);
    octree.supprimer(deletingtri);
    mai->supprimer_mg_triangleid(deletingtri->get_id());
  }
 TPL_MAP_ENTITE<MG_SEGMENT*> lstsgad;
 for (int iadtris=0;iadtris<lstadtris.get_nb();iadtris++)
  { 
    MG_TRIANGLE* swchktr=lstadtris.get(iadtris);
    lstsgad.ajouter(swchktr->get_segment1());
    lstsgad.ajouter(swchktr->get_segment2());
    lstsgad.ajouter(swchktr->get_segment3());
    del_swap(pinrt,swchktr,mai,octree);
  }
 
}
void MAILLEUR2D_INS_NOEUD::delaunay_ndinsert(MG_NOEUD* dpins,MG_MAILLAGE* mai,double search_radius,TPL_OCTREE<MG_TRIANGLE*,MG_NOEUD*> &octree,MG_GEOMETRIE* geo,TPL_OCTREE<MG_NOEUD*,MG_NOEUD*> &octreends)
{
   MG_MAILLAGE_OUTILS tq;
double normale[3];
int insideface=0;
std::multimap<double,MG_FACE*,std::less<double> > lstfacepointdist;
int facenb=geo->get_nb_mg_face();
            LISTE_MG_FACE::iterator itf;
            double xyz[3];
              xyz[0]=dpins->get_x();
              xyz[1]=dpins->get_y();
              xyz[2]=dpins->get_z();
            for(MG_FACE* fac=geo->get_premier_face(itf);fac!=NULL;fac=geo->get_suivant_face(itf))
            {
              double uv[2];
              fac->inverser(uv,xyz);
              double xyz2[3];
              fac->evaluer(uv,xyz2);
              OT_VECTEUR_3D vechk(xyz,xyz2);
              lstfacepointdist.insert(std::pair<double,MG_FACE*> (vechk.get_longueur(),fac));
              //double dis;
              //MG_GEOMETRIE_OUTILS f1;
              //int ch=f1.calcule_distance_contour_face_xyz(xyz,fac,&dis);
              //cout<<"xyz= "<<xyz[0]<<" xyz= "<<xyz[1]<<" xyz= "<<xyz[2]<<"    xyz2= "<<xyz2[0]<<" xyz2= "<<xyz2[1]<<" xyz2= "<<xyz2[2]<<endl;
              //cout<<"dis= "<<dis<<"   vechk.get_longueur()= "<<vechk.get_longueur()<<endl;
              //if (ch==1 && dis>=0.)
             // if (vechk.get_longueur()<5e-3)
            }
std::multimap<double,MG_FACE*,std::less<double> >::iterator itlstfacepointdist=lstfacepointdist.begin();
if (lstfacepointdist.size()>0)      
{
  //cout<<"(*itlstfacepointdist).first= "<<(*itlstfacepointdist).first<<endl;
  MG_FACE* face=(*itlstfacepointdist).second;
  double uv[2];
  face->inverser(uv,xyz);
  face->calcul_normale_unitaire(uv,normale);
  MG_COFACE *coface=face->get_mg_coface(0);
  int signe=coface->get_orientation();
  
  TPL_MAP_ENTITE<MG_TRIANGLE*> lstneitri;
  int neitrinb=lstneitri.get_nb();
  while(neitrinb==0) 
{
  octree.rechercher(dpins->get_x(),dpins->get_y(),dpins->get_z(),search_radius,lstneitri);
  neitrinb=lstneitri.get_nb();
  search_radius=search_radius+0.01*search_radius;
}
TPL_MAP_ENTITE<MG_TRIANGLE*>::ITERATEUR itnormtst;
OT_VECTEUR_3D  normale_discrete(0.,0.,0.);
for (MG_TRIANGLE* tri1=lstneitri.get_premier(itnormtst);tri1!=NULL;tri1=lstneitri.get_suivant(itnormtst))
    {
      OT_VECTEUR_3D vec1(tri1->get_noeud1()->get_coord(),tri1->get_noeud2()->get_coord());
      OT_VECTEUR_3D vec2(tri1->get_noeud1()->get_coord(),tri1->get_noeud3()->get_coord());
      OT_VECTEUR_3D normtst=(vec1&vec2); normtst.norme();
      normale_discrete=normtst+normale_discrete;
    }
normale_discrete.norme();
double n_ps=normale_discrete*normale;
n_ps=n_ps*-1;
if (n_ps>1.) n_ps=1.;
if (n_ps<-1.) n_ps=-1.;
double n_angle=acos(n_ps);
if(n_angle<(0.5*3.14159265358979323846) || n_angle>-(0.5*3.14159265358979323846))             
 insideface++;
}
if(insideface>0)            
{           
TPL_MAP_ENTITE<MG_TRIANGLE*> lstneitri;
int neitrinb=lstneitri.get_nb();
while(neitrinb==0) 
{
  octree.rechercher(dpins->get_x(),dpins->get_y(),dpins->get_z(),search_radius,lstneitri);
  neitrinb=lstneitri.get_nb();
  search_radius=search_radius+0.01*search_radius;
}           
 
TPL_MAP_ENTITE<MG_TRIANGLE*> insphtri;      
TPL_MAP_ENTITE<MG_TRIANGLE*>::ITERATEUR it1;
for (MG_TRIANGLE* tri1=lstneitri.get_premier(it1);tri1!=NULL;tri1=lstneitri.get_suivant(it1))
{
  double insphchk=inshper_point(dpins,tri1);
  if (insphchk<=0.)
    insphtri.ajouter(tri1);
}
TPL_MAP_ENTITE<MG_SEGMENT*> segbase;
TPL_MAP_ENTITE<MG_TRIANGLE*> basetri;
double pproj[3]; 
TPL_MAP_ENTITE<MG_TRIANGLE*>::ITERATEUR inspi;
for (MG_TRIANGLE* insphertri=insphtri.get_premier(inspi);insphertri!=NULL;insphertri=insphtri.get_suivant(inspi))
{
MG_NOEUD* inspnd1=insphertri->get_noeud1();
MG_NOEUD* inspnd2=insphertri->get_noeud2();
MG_NOEUD* inspnd3=insphertri->get_noeud3();
OT_VECTEUR_3D tvec1(inspnd1->get_coord(),inspnd2->get_coord());
OT_VECTEUR_3D tvec2(inspnd1->get_coord(),inspnd3->get_coord());
OT_VECTEUR_3D tnorm=(tvec1&tvec2); tnorm.norme();
OT_VECTEUR_3D norm=normale;
double parallel=norm*tnorm;
if (parallel<0.7 && parallel>-0.7) std::cout<<"the line and plane are parallel inside DELAUNAY"<<std::endl;
 
if (parallel>0.7 || parallel<-0.7)
{
OT_VECTEUR_3D vvec(inspnd1->get_coord(),dpins->get_coord());
double t= (tnorm*vvec)/parallel;
t=-t;
pproj[0]=dpins->get_x()+t*norm.get_x();
pproj[1]=dpins->get_y()+t*norm.get_y();
pproj[2]=dpins->get_z()+t*norm.get_z();
MG_MAILLAGE_OUTILS tribas;
int tribasval=tribas.estdansletriangle(insphertri,pproj[0],pproj[1],pproj[2]);
int intri=tribas.compare_etat_triangle(tribasval,MG_MAILLAGE_OUTILS::INTERIEUR);
int insidtri=tribas.compare_etat_triangle(tribasval,MG_MAILLAGE_OUTILS::STRICTINTERIEUR);
int onedge=tribas.compare_etat_triangle(tribasval,MG_MAILLAGE_OUTILS::SUR_ARETE);
  
if (insidtri==1) //connect p to 3nds of tri
{
  MG_TRIANGLE* ndintri=insphertri;
  MG_SEGMENT* seg1=ndintri->get_segment1();
  MG_SEGMENT* seg2=ndintri->get_segment2();
  MG_SEGMENT* seg3=ndintri->get_segment3();
 MG_ELEMENT_TOPOLOGIQUE* top1=ndintri->get_lien_topologie();
  MG_NOEUD* sg1nd1=seg1->get_noeud1();
  MG_NOEUD* sg1nd2=seg1->get_noeud2();
  MG_TRIANGLE* triad1;
 if (sg1nd1==ndintri->get_noeud1() && sg1nd2==ndintri->get_noeud2()) triad1=mai->ajouter_mg_triangle(top1,dpins,sg1nd1,sg1nd2,MAGIC::ORIGINE::IMPOSE);
 else if (sg1nd1==ndintri->get_noeud2() && sg1nd2==ndintri->get_noeud1()) triad1=mai->ajouter_mg_triangle(top1,dpins,sg1nd2,sg1nd1,MAGIC::ORIGINE::IMPOSE); 
 if (sg1nd1==ndintri->get_noeud2() && sg1nd2==ndintri->get_noeud3()) triad1=mai->ajouter_mg_triangle(top1,dpins,sg1nd1,sg1nd2,MAGIC::ORIGINE::IMPOSE); 
 else if (sg1nd1==ndintri->get_noeud3() && sg1nd2==ndintri->get_noeud2()) triad1=mai->ajouter_mg_triangle(top1,dpins,sg1nd2,sg1nd1,MAGIC::ORIGINE::IMPOSE); 
 if (sg1nd1==ndintri->get_noeud3() && sg1nd2==ndintri->get_noeud1()) triad1=mai->ajouter_mg_triangle(top1,dpins,sg1nd1,sg1nd2,MAGIC::ORIGINE::IMPOSE); 
 else if (sg1nd1==ndintri->get_noeud1() && sg1nd2==ndintri->get_noeud3()) triad1=mai->ajouter_mg_triangle(top1,dpins,sg1nd2,sg1nd1,MAGIC::ORIGINE::IMPOSE); 
 MG_NOEUD* sg2nd1=seg2->get_noeud1();
 MG_NOEUD* sg2nd2=seg2->get_noeud2();
 MG_TRIANGLE* triad2;
 if (sg2nd1==ndintri->get_noeud1() && sg2nd2==ndintri->get_noeud2()) triad2=mai->ajouter_mg_triangle(top1,dpins,sg2nd1,sg2nd2,MAGIC::ORIGINE::IMPOSE);
 else if (sg2nd1==ndintri->get_noeud2() && sg2nd2==ndintri->get_noeud1()) triad2=mai->ajouter_mg_triangle(top1,dpins,sg2nd2,sg2nd1,MAGIC::ORIGINE::IMPOSE); 
 if (sg2nd1==ndintri->get_noeud2() && sg2nd2==ndintri->get_noeud3()) triad2=mai->ajouter_mg_triangle(top1,dpins,sg2nd1,sg2nd2,MAGIC::ORIGINE::IMPOSE);
 else if (sg2nd1==ndintri->get_noeud3() && sg2nd2==ndintri->get_noeud2()) triad2=mai->ajouter_mg_triangle(top1,dpins,sg2nd2,sg2nd1,MAGIC::ORIGINE::IMPOSE);
 if (sg2nd1==ndintri->get_noeud3() && sg2nd2==ndintri->get_noeud1()) triad2=mai->ajouter_mg_triangle(top1,dpins,sg2nd1,sg2nd2,MAGIC::ORIGINE::IMPOSE);
 else if (sg2nd1==ndintri->get_noeud1() && sg2nd2==ndintri->get_noeud3()) triad2=mai->ajouter_mg_triangle(top1,dpins,sg2nd2,sg2nd1,MAGIC::ORIGINE::IMPOSE);
 MG_NOEUD* sg3nd1=seg3->get_noeud1();
 MG_NOEUD* sg3nd2=seg3->get_noeud2();
 MG_TRIANGLE* triad3;
 if (sg3nd1==ndintri->get_noeud1() && sg3nd2==ndintri->get_noeud2()) triad3=mai->ajouter_mg_triangle(top1,dpins,sg3nd1,sg3nd2,MAGIC::ORIGINE::IMPOSE);
 else if (sg3nd1==ndintri->get_noeud2() && sg3nd2==ndintri->get_noeud1()) triad3=mai->ajouter_mg_triangle(top1,dpins,sg3nd2,sg3nd1,MAGIC::ORIGINE::IMPOSE); 
 if (sg3nd1==ndintri->get_noeud2() && sg3nd2==ndintri->get_noeud3()) triad3=mai->ajouter_mg_triangle(top1,dpins,sg3nd1,sg3nd2,MAGIC::ORIGINE::IMPOSE);
 else if (sg3nd1==ndintri->get_noeud3() && sg3nd2==ndintri->get_noeud2()) triad3=mai->ajouter_mg_triangle(top1,dpins,sg3nd2,sg3nd1,MAGIC::ORIGINE::IMPOSE);
 if (sg3nd1==ndintri->get_noeud3() && sg3nd2==ndintri->get_noeud1()) triad3=mai->ajouter_mg_triangle(top1,dpins,sg3nd1,sg3nd2,MAGIC::ORIGINE::IMPOSE);
 else if (sg3nd1==ndintri->get_noeud1() && sg3nd2==ndintri->get_noeud3()) triad3=mai->ajouter_mg_triangle(top1,dpins,sg3nd2,sg3nd1,MAGIC::ORIGINE::IMPOSE);
 dpins->change_lien_topologie(top1);
  octree.inserer(triad1);
  octree.inserer(triad2);
  octree.inserer(triad3);
 octree.supprimer(ndintri);
 octreends.inserer(dpins);
  mai->supprimer_mg_triangleid(ndintri->get_id());
 int delswap1=0;
 int delswap2=0;
 int delswap3=0;
 double tqual1=tq.qualite_triangle(triad1->get_noeud1()->get_coord(),triad1->get_noeud2()->get_coord(),triad1->get_noeud3()->get_coord());
 double tqual2=tq.qualite_triangle(triad2->get_noeud1()->get_coord(),triad2->get_noeud2()->get_coord(),triad2->get_noeud3()->get_coord());
 double tqual3=tq.qualite_triangle(triad3->get_noeud1()->get_coord(),triad3->get_noeud2()->get_coord(),triad3->get_noeud3()->get_coord());
  del_swap(dpins,triad1,mai,octree);
  del_swap(dpins,triad2,mai,octree);
  del_swap(dpins,triad3,mai,octree);
  break ;
}
 
if (onedge==1) //if on segment: connect p to 6nds of 2 adjacent tries, if on tri vertex: connect to 
{
  MG_TRIANGLE* ndontri=insphertri;
  MG_NOEUD* ndo1=ndontri->get_noeud1();
  MG_NOEUD* ndo2=ndontri->get_noeud2();
  MG_NOEUD* ndo3=ndontri->get_noeud3();
  int onvert1=tribas.compare_etat_triangle(tribasval,MG_MAILLAGE_OUTILS::SOMMET1);
  int onvert2=tribas.compare_etat_triangle(tribasval,MG_MAILLAGE_OUTILS::SOMMET2);
  int onvert3=tribas.compare_etat_triangle(tribasval,MG_MAILLAGE_OUTILS::SOMMET3);
  int onedge1=tribas.compare_etat_triangle(tribasval,MG_MAILLAGE_OUTILS::ARETE1);
  int onedge2=tribas.compare_etat_triangle(tribasval,MG_MAILLAGE_OUTILS::ARETE2);
  int onedge3=tribas.compare_etat_triangle(tribasval,MG_MAILLAGE_OUTILS::ARETE3);
   
   if (onvert1==1 || onvert2==1 || onvert3==1)
  {
    MG_NOEUD* ond;
    if(onvert1==1)ond=ndo1;
    if(onvert2==1)ond=ndo2;
    if(onvert3==1)ond=ndo3;
    dpins->change_lien_topologie(ond->get_lien_topologie());
    TPL_LISTE_ENTITE<MG_TRIANGLE*> deltrilst;
    std::map<MG_TRIANGLE*,MG_SEGMENT*>addseglst;
    TPL_LISTE_ENTITE<MG_TRIANGLE*> lstadtris;
    for (int ili=0;ili<ond->get_lien_triangle()->get_nb();ili++)
    {
      MG_TRIANGLE* deltri=ond->get_lien_triangle()->get(ili);
      deltrilst.ajouter(deltri);
     }
   for (int isegadlst=0;isegadlst<deltrilst.get_nb();isegadlst++)
   {
     MG_TRIANGLE* trid=deltrilst.get(isegadlst);
     MG_SEGMENT* seg1=trid->get_segment1();
     MG_SEGMENT* seg2=trid->get_segment2();
     MG_SEGMENT* seg3=trid->get_segment3();
     if (ond!=seg1->get_noeud1() && ond!=seg1->get_noeud2()) addseglst.insert(std::pair<MG_TRIANGLE*,MG_SEGMENT*>(trid,seg1));
     else if (ond!=seg2->get_noeud1() && ond!=seg2->get_noeud2()) addseglst.insert(std::pair<MG_TRIANGLE*,MG_SEGMENT*>(trid,seg2));
     else if (ond!=seg3->get_noeud1() && ond!=seg3->get_noeud2()) addseglst.insert(std::pair<MG_TRIANGLE*,MG_SEGMENT*>(trid,seg3));
   }
   std::map<MG_TRIANGLE*,MG_SEGMENT*>::iterator itaddseglst;
   for (itaddseglst=addseglst.begin();itaddseglst!=addseglst.end();itaddseglst++)
  {
    MG_SEGMENT* segtrans=(*itaddseglst).second;
    MG_TRIANGLE* triold=(*itaddseglst).first;
    MG_ELEMENT_TOPOLOGIQUE* toptriloc=triold->get_lien_topologie();
    MG_NOEUD* sgnd1=segtrans->get_noeud1();
    MG_NOEUD* sgnd2=segtrans->get_noeud2();
    MG_TRIANGLE* triad;
 if (sgnd1==triold->get_noeud1() && sgnd2==triold->get_noeud2()) triad=mai->ajouter_mg_triangle(toptriloc,sgnd1,sgnd2,dpins,MAGIC::ORIGINE::IMPOSE);
 else if (sgnd1==triold->get_noeud2() && sgnd2==triold->get_noeud1()) triad=mai->ajouter_mg_triangle(toptriloc,sgnd2,sgnd1,dpins,MAGIC::ORIGINE::IMPOSE); 
 else if (sgnd1==triold->get_noeud2() && sgnd2==triold->get_noeud3()) triad=mai->ajouter_mg_triangle(toptriloc,dpins,sgnd1,sgnd2,MAGIC::ORIGINE::IMPOSE);
 else if (sgnd1==triold->get_noeud3() && sgnd2==triold->get_noeud2()) triad=mai->ajouter_mg_triangle(toptriloc,dpins,sgnd2,sgnd1,MAGIC::ORIGINE::IMPOSE);
 else if (sgnd1==triold->get_noeud3() && sgnd2==triold->get_noeud1()) triad=mai->ajouter_mg_triangle(toptriloc,sgnd2,dpins,sgnd1,MAGIC::ORIGINE::IMPOSE);
 else if (sgnd1==triold->get_noeud1() && sgnd2==triold->get_noeud3()) triad=mai->ajouter_mg_triangle(toptriloc,sgnd1,dpins,sgnd2,MAGIC::ORIGINE::IMPOSE);
 dpins->change_lien_topologie(toptriloc);
 TPL_LISTE_ENTITE<MG_SEGMENT*> triadsegs;
triadsegs.ajouter(triad->get_segment1());
triadsegs.ajouter(triad->get_segment2());
triadsegs.ajouter(triad->get_segment3());
TPL_LISTE_ENTITE<MG_SEGMENT*> trioldsegs;
trioldsegs.ajouter(triold->get_segment1());
trioldsegs.ajouter(triold->get_segment2());
trioldsegs.ajouter(triold->get_segment3());
for(int itriadsegs=0;itriadsegs<triadsegs.get_nb();itriadsegs++)
{
  MG_SEGMENT* triadseg=triadsegs.get(itriadsegs);
  if(triadseg!=segtrans)
 {
   for(int itrioldsegs=0;itrioldsegs<trioldsegs.get_nb();itrioldsegs++)
  {
    MG_SEGMENT* trioldseg=trioldsegs.get(itrioldsegs);
    if(trioldseg!=segtrans) 
  {
    if(trioldseg->get_noeud1()==sgnd1 || trioldseg->get_noeud2()==sgnd1)
    {
      if(triadseg->get_noeud1()==sgnd1 || triadseg->get_noeud2()==sgnd1) triadseg->change_lien_topologie(trioldseg->get_lien_topologie());
    }
    else if(trioldseg->get_noeud1()==sgnd2 || trioldseg->get_noeud2()==sgnd2)
    {
      if(triadseg->get_noeud1()==sgnd2 || triadseg->get_noeud2()==sgnd2) triadseg->change_lien_topologie(trioldseg->get_lien_topologie());
    }
  }
  }
 }
}
octree.inserer(triad);
lstadtris.ajouter(triad);
  }
 
  for (int ideletriangle=0;ideletriangle<deltrilst.get_nb();ideletriangle++)
  {
    MG_TRIANGLE* deletingtri=deltrilst.get(ideletriangle);
    octree.supprimer(deletingtri);
    mai->supprimer_mg_triangleid(deletingtri->get_id());
  }
  for (int iadtris=0;iadtris<lstadtris.get_nb();iadtris++)
  { 
    MG_TRIANGLE* swchktr=lstadtris.get(iadtris);
    del_swap(dpins,swchktr,mai,octree);
  }
 
  break;
  }
   
 else if(onedge1==1 || onedge2==1 || onedge3==1)
   {
   MG_SEGMENT* onseg;
   if (onedge1==1)      onseg=ndontri->get_segment1();
   else if (onedge2==1) onseg=ndontri->get_segment2();
   else if (onedge3==1) onseg=ndontri->get_segment3();
   dpins->change_lien_topologie(onseg->get_lien_topologie());
  std::map<MG_SEGMENT*,MG_TRIANGLE*>lstonedtriseg;
 TPL_LISTE_ENTITE<MG_TRIANGLE*> triswilldelete;
 if(onseg->get_lien_triangle()->get_nb()==2)
{
  MG_TRIANGLE* onedtri1=onseg->get_lien_triangle()->get(0);
  MG_TRIANGLE* onedtri2=onseg->get_lien_triangle()->get(1);
  MG_SEGMENT* onedtri1seg1=onedtri1->get_segment1();
  if (onedtri1seg1!=onseg)      lstonedtriseg.insert(std::pair<MG_SEGMENT*,MG_TRIANGLE*>(onedtri1seg1,onedtri1));
  MG_SEGMENT* onedtri1seg2=onedtri1->get_segment2();
  if (onedtri1seg2!=onseg)      lstonedtriseg.insert(std::pair<MG_SEGMENT*,MG_TRIANGLE*>(onedtri1seg2,onedtri1));
  MG_SEGMENT* onedtri1seg3=onedtri1->get_segment3();
  if (onedtri1seg3!=onseg)      lstonedtriseg.insert(std::pair<MG_SEGMENT*,MG_TRIANGLE*>(onedtri1seg3,onedtri1));
  MG_SEGMENT* onedtri2seg1=onedtri2->get_segment1();
  if (onedtri2seg1!=onseg)      lstonedtriseg.insert(std::pair<MG_SEGMENT*,MG_TRIANGLE*>(onedtri2seg1,onedtri2));
  MG_SEGMENT* onedtri2seg2=onedtri2->get_segment2();
  if (onedtri2seg2!=onseg)      lstonedtriseg.insert(std::pair<MG_SEGMENT*,MG_TRIANGLE*>(onedtri2seg2,onedtri2));
  MG_SEGMENT* onedtri2seg3=onedtri2->get_segment3();
  if (onedtri2seg3!=onseg)      lstonedtriseg.insert(std::pair<MG_SEGMENT*,MG_TRIANGLE*>(onedtri2seg3,onedtri2));
  octree.supprimer(onedtri1);
  octree.supprimer(onedtri2);
  triswilldelete.ajouter(onedtri1);
  triswilldelete.ajouter(onedtri2);
}
else if(onseg->get_lien_triangle()->get_nb()==1)
{
  MG_TRIANGLE* onedtri1=onseg->get_lien_triangle()->get(0);
  MG_SEGMENT* onedtri1seg1=onedtri1->get_segment1();
  if (onedtri1seg1!=onseg)      lstonedtriseg.insert(std::pair<MG_SEGMENT*,MG_TRIANGLE*>(onedtri1seg1,onedtri1));
  MG_SEGMENT* onedtri1seg2=onedtri1->get_segment2();
  if (onedtri1seg2!=onseg)      lstonedtriseg.insert(std::pair<MG_SEGMENT*,MG_TRIANGLE*>(onedtri1seg2,onedtri1));
  MG_SEGMENT* onedtri1seg3=onedtri1->get_segment3();
  if (onedtri1seg3!=onseg)      lstonedtriseg.insert(std::pair<MG_SEGMENT*,MG_TRIANGLE*>(onedtri1seg3,onedtri1));
  octree.supprimer(onedtri1);
  triswilldelete.ajouter(onedtri1);
}
 
  TPL_LISTE_ENTITE<MG_TRIANGLE*> lstadtris;
  std::map<MG_SEGMENT*,MG_TRIANGLE*>::iterator itlstonedtriseg;
  for (itlstonedtriseg=lstonedtriseg.begin();itlstonedtriseg!=lstonedtriseg.end();itlstonedtriseg++)
  {
    MG_SEGMENT* segcommon=(*itlstonedtriseg).first;
    MG_TRIANGLE* triold=(*itlstonedtriseg).second;
    MG_ELEMENT_TOPOLOGIQUE* toponseg=triold->get_lien_topologie();
    //cout<<"toponseg->get_dimension()= "<<toponseg->get_id()<<endl;
    MG_NOEUD* sgnd1=segcommon->get_noeud1();
    MG_NOEUD* sgnd2=segcommon->get_noeud2();
    MG_TRIANGLE* triad;
 if (sgnd1==triold->get_noeud1() && sgnd2==triold->get_noeud2()) triad=mai->ajouter_mg_triangle(toponseg,sgnd1,sgnd2,dpins,MAGIC::ORIGINE::IMPOSE);
 else if (sgnd1==triold->get_noeud2() && sgnd2==triold->get_noeud1()) triad=mai->ajouter_mg_triangle(toponseg,sgnd2,sgnd1,dpins,MAGIC::ORIGINE::IMPOSE); 
 else if (sgnd1==triold->get_noeud2() && sgnd2==triold->get_noeud3()) triad=mai->ajouter_mg_triangle(toponseg,dpins,sgnd1,sgnd2,MAGIC::ORIGINE::IMPOSE);
 else if (sgnd1==triold->get_noeud3() && sgnd2==triold->get_noeud2()) triad=mai->ajouter_mg_triangle(toponseg,dpins,sgnd2,sgnd1,MAGIC::ORIGINE::IMPOSE);
 else if (sgnd1==triold->get_noeud3() && sgnd2==triold->get_noeud1()) triad=mai->ajouter_mg_triangle(toponseg,sgnd2,dpins,sgnd1,MAGIC::ORIGINE::IMPOSE);
 else if (sgnd1==triold->get_noeud1() && sgnd2==triold->get_noeud3()) triad=mai->ajouter_mg_triangle(toponseg,sgnd1,dpins,sgnd2,MAGIC::ORIGINE::IMPOSE);
 dpins->change_lien_topologie(toponseg);
 // unify the topology of the segments, keep the edges
 TPL_LISTE_ENTITE<MG_SEGMENT*> triadsegs;
triadsegs.ajouter(triad->get_segment1());
triadsegs.ajouter(triad->get_segment2());
triadsegs.ajouter(triad->get_segment3());
for(int itriadsegs=0;itriadsegs<triadsegs.get_nb();itriadsegs++)
{
  MG_SEGMENT* triadseg=triadsegs.get(itriadsegs);
  if(triadseg!=segcommon)
 {
    if(triadseg->get_noeud1()==onseg->get_noeud1() || triadseg->get_noeud2()==onseg->get_noeud2()
      || triadseg->get_noeud2()==onseg->get_noeud1() || triadseg->get_noeud1()==onseg->get_noeud2())
    {
      triadseg->change_lien_topologie(onseg->get_lien_topologie());
    }
  
  }
}
 octree.inserer(triad);
 octreends.inserer(dpins);
 lstadtris.ajouter(triad);
  }
   for (int itriswilldelete=0;itriswilldelete<triswilldelete.get_nb();itriswilldelete++)
  {
    mai->supprimer_mg_triangleid(triswilldelete.get(itriswilldelete)->get_id());
  }
   
  for (int iadtris=0;iadtris<lstadtris.get_nb();iadtris++)
  { 
    MG_TRIANGLE* swchktr=lstadtris.get(iadtris);
    del_swap(dpins,swchktr,mai,octree);
  }
  
 break;
  }
}
 
} 
} 
}
}
void MAILLEUR2D_INS_NOEUD::del_swap(MG_NOEUD* ndins,MG_TRIANGLE* newtri,MG_MAILLAGE* mai,TPL_OCTREE<MG_TRIANGLE*,MG_NOEUD*> &octree)
{
  MG_MAILLAGE_OUTILS tq;
  MG_ELEMENT_TOPOLOGIQUE *top1=newtri->get_lien_topologie();
  MG_SEGMENT* segchk;
  MG_SEGMENT* segad1=newtri->get_segment1();
  MG_SEGMENT* segad2=newtri->get_segment2();
  MG_SEGMENT* segad3=newtri->get_segment3();
  if (segad1->get_noeud1()!=ndins && segad1->get_noeud2()!=ndins)               segchk=segad1; 
  else if (segad2->get_noeud1()!=ndins && segad2->get_noeud2()!=ndins)  segchk=segad2; 
  else if (segad3->get_noeud1()!=ndins && segad3->get_noeud2()!=ndins)  segchk=segad3; 
int segtopdim=segchk->get_lien_topologie()->get_dimension();
 // int segtopdim=1; //it should be modified !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
if(segchk->get_lien_triangle()->get_nb()>1)
{
  //cout<<"hereee segchk->get_lien_triangle()->get_nb()= "<<segchk->get_lien_triangle()->get_nb()<<endl;
  MG_TRIANGLE* trichk;
  for (int isct=0;isct<segchk->get_lien_triangle()->get_nb();isct++)
  {
   MG_TRIANGLE* trick=segchk->get_lien_triangle()->get(isct);
   if (trick!=newtri) trichk=trick;
  }
 
  MG_NOEUD* othertrianglenode;
  if(trichk->get_noeud1()!=segchk->get_noeud1() && trichk->get_noeud1()!=segchk->get_noeud2()) othertrianglenode=trichk->get_noeud1();
  else if(trichk->get_noeud2()!=segchk->get_noeud1() && trichk->get_noeud2()!=segchk->get_noeud2()) othertrianglenode=trichk->get_noeud2();
  else if(trichk->get_noeud3()!=segchk->get_noeud1() && trichk->get_noeud3()!=segchk->get_noeud2()) othertrianglenode=trichk->get_noeud3();
TPL_MAP_ENTITE<MG_SEGMENT*> relatedseg;
for(int irelatedseg1=0;irelatedseg1<ndins->get_lien_triangle()->get_nb();irelatedseg1++)
{
  MG_TRIANGLE* trirel1=ndins->get_lien_triangle()->get(irelatedseg1);
  relatedseg.ajouter(trirel1->get_segment1());
  relatedseg.ajouter(trirel1->get_segment2());
  relatedseg.ajouter(trirel1->get_segment3());
}
for(int irelatedseg2=0;irelatedseg2<othertrianglenode->get_lien_triangle()->get_nb();irelatedseg2++)
{
  MG_TRIANGLE* trirel2=othertrianglenode->get_lien_triangle()->get(irelatedseg2);
  relatedseg.ajouter(trirel2->get_segment1());
  relatedseg.ajouter(trirel2->get_segment2());
  relatedseg.ajouter(trirel2->get_segment3());
}
int checkifswpdigisexist=0;
TPL_MAP_ENTITE<MG_SEGMENT*>::ITERATEUR itrelatedseg;
for(MG_SEGMENT* segtest=relatedseg.get_premier(itrelatedseg);segtest!=NULL;segtest=relatedseg.get_suivant(itrelatedseg))
{
  if(segtest->get_noeud1()==ndins && segtest->get_noeud2()==othertrianglenode) checkifswpdigisexist++;
  if(segtest->get_noeud2()==ndins && segtest->get_noeud1()==othertrianglenode) checkifswpdigisexist++;
}
if(checkifswpdigisexist==0)
{  
  double pinsphnbnewtri=1.;//=inshper_point(othertrianglenode,newtri);
  double pinsphnbothertri=inshper_point(ndins,trichk);
int qualchk=0;
std::map<double,MG_NOEUD*,std::less<double> > beforeswap;
std::map<double,MG_NOEUD*,std::less<double> > afterswap;
MG_MAILLAGE_OUTILS triquality;
double triqualnew=triquality.qualite_triangle(newtri->get_noeud1()->get_coord(),newtri->get_noeud2()->get_coord(),newtri->get_noeud3()->get_coord());
beforeswap.insert(std::pair<double,MG_NOEUD*> (triqualnew,newtri->get_noeud1()));
double triqualchek=triquality.qualite_triangle(trichk->get_noeud1()->get_coord(),trichk->get_noeud2()->get_coord(),trichk->get_noeud3()->get_coord());
beforeswap.insert(std::pair<double,MG_NOEUD*> (triqualchek,newtri->get_noeud2()));
double afterswap1=triquality.qualite_triangle(ndins->get_coord(),othertrianglenode->get_coord(),segchk->get_noeud1()->get_coord());
afterswap.insert(std::pair<double,MG_NOEUD*>(afterswap1,ndins));
double afterswap2=triquality.qualite_triangle(ndins->get_coord(),othertrianglenode->get_coord(),segchk->get_noeud2()->get_coord());
afterswap.insert(std::pair<double,MG_NOEUD*>(afterswap2,othertrianglenode));
std::map<double,MG_NOEUD*,std::less<double> >::iterator itbeforeswap=beforeswap.begin();
std::map<double,MG_NOEUD*,std::less<double> >::iterator itafterswap=afterswap.begin();
 
if (qualswap>0 && (*itafterswap).first>(*itbeforeswap).first) qualchk=qualchk+1;
if (pinsphnbnewtri<=0.|| pinsphnbothertri<=0.)
  if(qualchk>0)//inside sphere
{
  MG_NOEUD* segchknd1=segchk->get_noeud1();
  MG_NOEUD* segchknd2=segchk->get_noeud2();
  MG_NOEUD* trichknd;
  MG_NOEUD* trichknd1=trichk->get_noeud1();
  MG_NOEUD* trichknd2=trichk->get_noeud2();
  MG_NOEUD* trichknd3=trichk->get_noeud3();
  if (trichknd1!=segchknd1 && trichknd1!=segchknd2) trichknd=trichknd1;
  if (trichknd2!=segchknd1 && trichknd2!=segchknd2) trichknd=trichknd2;
  if (trichknd3!=segchknd1 && trichknd3!=segchknd2) trichknd=trichknd3;
  MG_TRIANGLE* triad1;
  MG_TRIANGLE* triad2;
  if (segchknd1==newtri->get_noeud1() && segchknd2==newtri->get_noeud2())
  {
    triad1=mai->ajouter_mg_triangle(top1,ndins,segchknd1,trichknd,MAGIC::ORIGINE::IMPOSE);
    triad2=mai->ajouter_mg_triangle(top1,ndins,trichknd,segchknd2,MAGIC::ORIGINE::IMPOSE);
  }
  else if (segchknd1==newtri->get_noeud2() && segchknd2==newtri->get_noeud3()) 
  {
    triad1=mai->ajouter_mg_triangle(top1,ndins,segchknd1,trichknd,MAGIC::ORIGINE::IMPOSE);
    triad2=mai->ajouter_mg_triangle(top1,ndins,trichknd,segchknd2,MAGIC::ORIGINE::IMPOSE);
  }
  else if (segchknd1==newtri->get_noeud3() && segchknd2==newtri->get_noeud1()) 
  {
    triad1=mai->ajouter_mg_triangle(top1,ndins,segchknd1,trichknd,MAGIC::ORIGINE::IMPOSE);
    triad2=mai->ajouter_mg_triangle(top1,ndins,trichknd,segchknd2,MAGIC::ORIGINE::IMPOSE);
  }
  else if (segchknd1==newtri->get_noeud2() && segchknd2==newtri->get_noeud1()) 
  {
    triad1=mai->ajouter_mg_triangle(top1,ndins,segchknd2,trichknd,MAGIC::ORIGINE::IMPOSE);
    triad2=mai->ajouter_mg_triangle(top1,ndins,trichknd,segchknd1,MAGIC::ORIGINE::IMPOSE);
  }
   else if (segchknd1==newtri->get_noeud3() && segchknd2==newtri->get_noeud2()) 
  {
    triad1=mai->ajouter_mg_triangle(top1,ndins,segchknd2,trichknd,MAGIC::ORIGINE::IMPOSE);
    triad2=mai->ajouter_mg_triangle(top1,ndins,trichknd,segchknd1,MAGIC::ORIGINE::IMPOSE);
  }
  else if (segchknd1==newtri->get_noeud1() && segchknd2==newtri->get_noeud3()) 
  {
    triad1=mai->ajouter_mg_triangle(top1,ndins,segchknd2,trichknd,MAGIC::ORIGINE::IMPOSE);
    triad2=mai->ajouter_mg_triangle(top1,ndins,trichknd,segchknd1,MAGIC::ORIGINE::IMPOSE);
  }
/*  double qual1=tq.qualite_triangle(triad1->get_noeud1()->get_coord(),triad1->get_noeud2()->get_coord(),triad1->get_noeud3()->get_coord());
  double qual2=tq.qualite_triangle(triad2->get_noeud1()->get_coord(),triad2->get_noeud2()->get_coord(),triad2->get_noeud3()->get_coord());
OT_VECTEUR_3D vpr11(triad1->get_noeud1()->get_coord(),triad1->get_noeud2()->get_coord());
OT_VECTEUR_3D vpr12(triad1->get_noeud1()->get_coord(),triad1->get_noeud3()->get_coord());
OT_VECTEUR_3D normvpr1=(vpr11&vpr12); normvpr1.norme();
OT_VECTEUR_3D vpr21(triad2->get_noeud1()->get_coord(),triad2->get_noeud2()->get_coord());
OT_VECTEUR_3D vpr22(triad2->get_noeud1()->get_coord(),triad2->get_noeud3()->get_coord());
OT_VECTEUR_3D normvpr2=(vpr21&vpr22); normvpr2.norme();
OT_VECTEUR_3D vpto1(trichk->get_noeud1()->get_coord(),trichk->get_noeud2()->get_coord());
OT_VECTEUR_3D vpto2(trichk->get_noeud1()->get_coord(),trichk->get_noeud3()->get_coord());
OT_VECTEUR_3D normvpto=(vpto1&vpto2); normvpto.norme();
OT_VECTEUR_3D vpt1(newtri->get_noeud1()->get_coord(),newtri->get_noeud2()->get_coord());
OT_VECTEUR_3D vpt2(newtri->get_noeud1()->get_coord(),newtri->get_noeud3()->get_coord());
OT_VECTEUR_3D normvpt=(vpt1&vpt2); normvpt.norme();
cout<<"normvpr1= "<<normvpr1<<" normvpr2= "<<normvpr2<<endl;
cout<<"normvpt= "<<normvpt<<" normvpto= "<<normvpto<<endl;*/
  octree.inserer(triad1);
  octree.inserer(triad2);
  octree.supprimer(newtri);
  octree.supprimer(trichk);
  mai->supprimer_mg_triangleid(newtri->get_id());
  mai->supprimer_mg_triangleid(trichk->get_id());
        }
}       
        }
}    
double MAILLEUR2D_INS_NOEUD::inshper_point(MG_NOEUD* insphp,MG_TRIANGLE* insphtri)
{
          MG_NOEUD* node1=insphtri->get_noeud1();  
          MG_NOEUD* node2=insphtri->get_noeud2();
          MG_NOEUD* node3=insphtri->get_noeud3();
          double bisectp1[3];
          double bisectp2[3];
          bisectp1[0]=(node1->get_x()+node2->get_x())/2.;
          bisectp1[1]=(node1->get_y()+node2->get_y())/2.;
          bisectp1[2]=(node1->get_z()+node2->get_z())/2.;
          bisectp2[0]=(node1->get_x()+node3->get_x())/2.;
          bisectp2[1]=(node1->get_y()+node3->get_y())/2.;
          bisectp2[2]=(node1->get_z()+node3->get_z())/2.;
          
          OT_VECTEUR_3D vec1(node1->get_coord(),node2->get_coord());
          OT_VECTEUR_3D vec2(node1->get_coord(),node3->get_coord());
          OT_VECTEUR_3D norvec=(vec1&vec2);
          OT_VECTEUR_3D norunivec=norvec; norunivec.norme();
 
          OT_VECTEUR_3D bivec1=(vec1&norunivec); //D1
          OT_VECTEUR_3D bivec2=(vec2&norunivec); //D2
          
         double determinan1=bivec2.get_x()*bivec1.get_y()-bivec1.get_x()*bivec2.get_y();
         double determinan2=bivec2.get_x()*bivec1.get_z()-bivec1.get_x()*bivec2.get_z();
         double determinan3=bivec2.get_y()*bivec1.get_z()-bivec1.get_y()*bivec2.get_z();
         
         double s,t;
         if(determinan1!=0.)
         {
         s=(bivec1.get_x()*(bisectp2[1]-bisectp1[1])+bivec1.get_y()*(bisectp1[0]-bisectp2[0]))/determinan1;
         t=(bivec2.get_x()*(bisectp2[1]-bisectp1[1])+bivec2.get_y()*(bisectp1[0]-bisectp2[0]))/determinan1;
         }
         else if(determinan2!=0.)
         {
           s=(bivec1.get_x()*(bisectp2[2]-bisectp1[2])+bivec1.get_z()*(bisectp1[0]-bisectp2[0]))/determinan2;
           t=(bivec2.get_x()*(bisectp2[2]-bisectp1[2])+bivec2.get_z()*(bisectp1[0]-bisectp2[0]))/determinan2;
         }
         else if(determinan3!=0.)
         {
           s=(bivec1.get_y()*(bisectp2[2]-bisectp1[2])+bivec1.get_z()*(bisectp1[1]-bisectp2[1]))/determinan3;
           t=(bivec2.get_y()*(bisectp2[2]-bisectp1[2])+bivec2.get_z()*(bisectp1[1]-bisectp2[1]))/determinan3;
         }
         else //cout<<"probleeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeem"<<endl;
         double bisetlinz1=bisectp1[2]+t*bivec1.get_z();
         double bisetlinz2=bisectp2[2]+s*bivec2.get_z();
          
          double cx=bisectp2[0]+s*bivec2.get_x();
          double cy=bisectp2[1]+s*bivec2.get_y();
          double cz=bisectp2[2]+s*bivec2.get_z();
double r=sqrt(pow((cx-node1->get_x()),2)+pow((cy-node1->get_y()),2)+pow((cz-node1->get_z()),2));
double pcircum[3];
          pcircum[0]=(cx+r*norunivec.get_x());
          pcircum[1]=(cy+r*norunivec.get_y());
          pcircum[2]=(cz+r*norunivec.get_z());
          
          double pa[3];
          pa[0]=node1->get_x();
          pa[1]=node1->get_y();
          pa[2]=node1->get_z();
          double pb[3];
          pb[0]=node2->get_x();
          pb[1]=node2->get_y();
          pb[2]=node2->get_z();
          double pc[3];
          pc[0]=node3->get_x();
          pc[1]=node3->get_y();
          pc[2]=node3->get_z();
          double pe[3];
          pe[0]=insphp->get_x();
          pe[1]=insphp->get_y();
          pe[2]=insphp->get_z();
          double isphnb = robustPredicates::insphere(pa,pb,pc,pcircum,pe);
          return isphnb;
        }