// This file is part of the Herezh++ application.
//
// The finite element software Herezh++ is dedicated to the field
// of mechanics for large transformations of solid structures.
// It is developed by Gérard Rio (APP: IDDN.FR.010.0106078.000.R.P.2006.035.20600)
// INSTITUT DE RECHERCHE DUPUY DE LÔME (IRDL) <https://www.irdl.fr/>.
//
// Herezh++ is distributed under GPL 3 license ou ultérieure.
//
// Copyright (C) 1997-2021 Université Bretagne Sud (France)
// AUTHOR : Gérard Rio
// E-MAIL  : gerardrio56@free.fr
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License,
// or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty
// of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
// See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
//
// For more information, please consult: <https://herezh.irdl.fr/>.

#include "Deformees_geomview.h"
#include "CharUtil.h"

#include <iomanip>

    // CONSTRUCTEURS :
// par defaut
Deformees_geomview::Deformees_geomview () :
   Deformees_vrml()
     {}; 
     
     // constructeur de copie 
Deformees_geomview::Deformees_geomview (const Deformees_geomview& ord) :
    Deformees_vrml(ord)
      {};
               
    // DESTRUCTEUR :
Deformees_geomview::~Deformees_geomview () 
     {};  
    
    // METHODES PUBLIQUES :
// execution de l'ordre
// tab_mail : donne les numéros de maillage concerné
// incre : numéro d'incrément qui en cours
// type_incre : indique si c'est le premier le dernier ou l'incrément courant a visualiser ou pas
// animation : indique si l'on est en animation ou pas
// unseul_incre : indique si oui ou non il y a un seul increment à visualiser
void Deformees_geomview::ExeOrdre(ParaGlob * paraGlob,const Tableau <int>& tab_mail,LesMaillages * lesMail,bool ,LesReferences*
                      ,LesLoisDeComp* ,DiversStockage*,Charge*,LesCondLim*
                      ,LesContacts*,Resultats*,UtilLecture & entreePrinc,OrdreVisu::EnumTypeIncre ,int incre
//                      ,LesContacts*,Resultats*,UtilLecture & entreePrinc,OrdreVisu::EnumTypeIncre type_incre,int incre
                      ,bool animation,const map < string, const double * , std::less <string> >&
                      ,const List_io < TypeQuelconque >& listeVecGlob)
 {// visualisation du maillage pointé si actif
  if (actif)
  {ostream &sort = entreePrinc.Sort_princ_geomview();
   // on boucle sur les maillages
   int nbmail = tab_mail.Taille();
   for (int im=1;im<=nbmail;im++)
    { int numMail=tab_mail(im);

      // dans le cas où il n'y a pas d'animation, on sort la déformée
      // dans le cas où c'est l'incrément 0, c'est-à-dire le maillage initial, on ne sort rien
      if ((!animation)&&(incre != 0)) 
       {
        if ((surface)||(filaire)||(numero))
         // écriture d'une entete
          sort << "\n # ====================================="
               << "\n # |      dessin du maillage deforme  |"
               << "\n # =====================================";
      
        if (surface) // cas d'une visualisation par face
        { 
         // quelques commentaires pour indiquer les faces            
         sort << "\n # ------------------------------------------------------"
              << "\n # dessin des facettes des elements du maillage deforme";
         // définition de la géométrie
         sort << "\n  (geometry facettes_in" << incre << "-maillage" << numMail << "  {OFF";
         // on définit le nombre de facette à visualiser
         // === début du comptage
         // un compteur qui globalise le nombre de facette dessinée
         int nbfacette=0;     
                // on balaie tous les éléments du maillage
         int nbmaxiElement = lesMail->Nombre_element(numMail);
         for (int numElem=1; numElem<= nbmaxiElement;numElem++) 
           { // recup de l'élément
             Element & elem = lesMail->Element_LesMaille(numMail,numElem);
             // connection des noeuds des faces par rapport a ceux de l'element
             // en fait on utilise une décomposition triangulaire linéaire de chaque facette
             // on récupère donc tout d'abord ces informations
                // le tableau des triangles linéaire
             const Tableau<Tableau<Tableau<int> > >&  
                        tabtria = elem.ElementGeometrique().Trian_lin();
             // le nombre de face à visualiser           
             int nb_FA = tabtria.Taille();
             // dans le cas où il n'y a pas de facette la boucle suivante ne démarre pas
             for (int k=1;k<= nb_FA;k++)
                { // nombre de triangle de la face
                  nbfacette += tabtria(k).Taille();
                  }
              }
         // === fin du comptage
         // def de l'entité maillage initial
         sort << "\n     # ecriture de l'entete "
              << "\n     # nombre de sommet, de faces, d'arrete = 0";
         int nbmaxinoeud = lesMail->Nombre_noeud(numMail);
         // on ecrit le nombre de sommet, de faces et d'arrete=0
         sort <<"\n        " << nbmaxinoeud << " " << nbfacette << " 0 ";
         // création des points
         sort << "\n     # ecriture des coordonnees des sommets  ";
         // on balaie tous les noeuds du maillage
         for (int numNoeud=1; numNoeud<= nbmaxinoeud;numNoeud++) 
               { // recup du noeud
                 Noeud & noe = lesMail->Noeud_LesMaille(numMail,numNoeud);
                  // deux cas : si l'incrément est 0 et les autres
                 if (incre == 0)
                  { //pas d'amplification
                    sort <<"\n                        "
                      << setw (16);  noe.Coord0().Affiche(sort,16);
                   }
                 else // calcul d'un déplacement amplifié  
                  { // calcul du déplacement amplifié
                    Coordonnee dep(paraGlob->Dimension()); // init à zero par defaut
                    if (noe.ExisteCoord1()) {dep = (noe.Coord1() - noe.Coord0() ) * amplification;};
                    // ecriture des coordonnee avec le déplacement amplifié
                    Coordonnee posifin = (noe.Coord0() + dep);
                    sort <<"\n                        "
                      << setw (16);  posifin.Affiche(sort,16);
                    }   
                 // si l'on n'est pas en dimension 3 on complete avec des zeros
                 if (paraGlob->Dimension () == 2)
                   { sort << setw (16) << 0 <<" ";
                    }
                 else if (paraGlob->Dimension () == 1)
                    { sort << setw (16) << 0  <<" " << setw (16) << 0  <<" ";
                    }
                 sort <<  "  ";
                 }             
         // création des faces
         sort << "\n     # ecriture de la connection des faces et de la couleur de chaque face";
         // on balaie tous les éléments du maillage
         for (int numElem=1; numElem<= nbmaxiElement;numElem++) 
           { // recup de l'élément
             Element & elem = lesMail->Element_LesMaille(numMail,numElem);
             Tableau<Noeud *>& tab_noeud = elem.Tab_noeud (); // ses noeuds
             // connection des noeuds des faces par rapport a ceux de l'element
             // en fait on utilise une décomposition triangulaire linéaire de chaque facette
             // on récupère donc tout d'abord ces informations
                // le tableau des triangles linéaire
             const Tableau<Tableau<Tableau<int> > >&  
                        tabtria = elem.ElementGeometrique().Trian_lin();
             // le nombre de face à visualiser           
             int nb_FA = tabtria.Taille();
             // on ne visualise que si le nombre de facette est différent de 0
             // sinon il la boucle s'arrete de suite
             for (int k=1;k<= nb_FA;k++)
              { // nombre de triangle de la face
                int nbtriangle = tabtria(k).Taille();
                for (int ikt=1;ikt<=nbtriangle;ikt++,nbfacette++)
                 { //const Tableau<int> * tabn = &(tabtria(k)(ikt)); // pour simplifier
                   #ifdef MISE_AU_POINT
                   // vérification du nombre de noeud du triangle
                    if (tabtria(k)(ikt).Taille() != 3)
                      { cout << "\n erreur, les facettes n'ont pas 3 noeuds,"
                             << " nbnoeud = " << tabtria(k)(ikt).Taille()
                             << " \n Deformees_geomview::ExeOrdre(... " ;
                        Sortie(1);     
                       }
                   #endif
                   // la connection
                   sort << "\n 3 "; // le nombre de sommet de la face
                   for (int no = 1; no<=3; no++)
                       sort << (tab_noeud(tabtria(k)(ikt)(no))->Num_noeud() - 1) << " "; 
                   // la couleur
                   sort << Rcoulf << " " << Gcoulf << " " << Bcoulf<< " ";
                  }
                }
              }
         // fin pour les faces 
         // fin: on ferme la géométrie 
         sort << "\n    } )";
         sort << "\n # fin du dessin des facettes des elements du maillage deforme"
              << "\n # -----------------------------------------------------------\n";
        }
      if (filaire)
       { 
         // quelques commentaires pour indiquer les arrêtes            
         sort << "\n # ------------------------------------------------------"
              << "\n # dessin des arretes des elements du maillage deforme";
         // définition de la géométrie
         sort << "\n  (geometry arretes_in" << incre << "-maillage" << numMail << "  {SKEL";
         // def d'un compteur du nombre d'arrete dessiné
         int nbarr = 0;
             // on balaie tous les éléments du maillage
         int nbmaxiElement = lesMail->Nombre_element(numMail);
         for (int numElem=1; numElem<= nbmaxiElement;numElem++) 
           { // recup de l'élément
             Element & elem = lesMail->Element_LesMaille(numMail,numElem);
             // connection des noeuds des arêtes par rapport a ceux de l'element
             Tableau<Tableau<int> > const & nomS =  elem.ElementGeometrique().NonS();
             nbarr += nomS.Taille(); // incrémentation du nombre d'arrêtes
            }
         // === fin du comptage
         // def de l'entité maillage initial
         sort << "\n     # ecriture de l'entete "
              << "\n     # nombre de sommet,  d'arrete ";
         int nbmaxinoeud = lesMail->Nombre_noeud(numMail);
         // on ecrit le nombre de sommet et d'arrete
         sort <<"\n        " << nbmaxinoeud << " " << nbarr << "  ";
         // création des points
         sort << "\n     # ecriture des coordonnees des sommets  ";
         // on balaie tous les noeuds du maillage
         for (int numNoeud=1; numNoeud<= nbmaxinoeud;numNoeud++) 
               { // recup du noeud
                 Noeud & noe = lesMail->Noeud_LesMaille(numMail,numNoeud);
                  // deux cas : si l'incrément est 0 et les autres
                 if (incre == 0)
                  { //pas d'amplification
                    sort <<"\n                        "
                      << setw (16);  noe.Coord0().Affiche(sort,16);
                   }
                 else // calcul d'un déplacement amplifié  
                  { // calcul du déplacement amplifié
                    Coordonnee dep(paraGlob->Dimension()); // init à zero par defaut
                    if (noe.ExisteCoord1()) {dep = (noe.Coord1() - noe.Coord0() ) * amplification;};
                    // ecriture des coordonnee avec le déplacement amplifié
                    Coordonnee posifin = (noe.Coord0() + dep);
                    sort <<"\n                        "
                      << setw (16);  posifin.Affiche(sort,16);
                    }   
                 // si l'on n'est pas en dimension 3 on complete avec des zeros
                 if (paraGlob->Dimension () == 2)
                   { sort << setw (16) << 0 <<" ";
                    }
                 else if (paraGlob->Dimension () == 1)
                    { sort << setw (16) << 0  <<" " << setw (16) << 0  <<" ";
                    }
                 sort <<  "  ";
                 }             
         // création des arrêtes
         sort << "\n     # ecriture de la connection des arrêtes et de la couleur de chaque arrete";
             // on balaie tous les éléments du maillage
         for (int numElem=1; numElem<= nbmaxiElement;numElem++) 
           { // recup de l'élément
             Element & elem = lesMail->Element_LesMaille(numMail,numElem);
             Tableau<Noeud *>& tab_noeud = elem.Tab_noeud (); // ses noeuds
             // connection des noeuds des arêtes par rapport a ceux de l'element
             Tableau<Tableau<int> > const & nomS =  elem.ElementGeometrique().NonS();
             int nb_ar = nomS.Taille(); // nombre d'arrêtes
             for (int k=1;k<= nb_ar;k++,nbarr++)
              { Tableau<int>const & tabn = nomS(k); 
                int nb_no = tabn.Taille(); // le nb de noeud de l'arrête
                sort << "\n                   " << nb_no << " "; //début de l'arrête 
                for (int no = 1; no<=nb_no; no++)
                  sort << (tab_noeud(tabn(no))->Num_noeud() - 1) << "  "; 
                // la couleur
                sort << Rcoull << " " << Gcoull << " " << Bcoull<< " ";
              }
            }  
         // fin pour les arrêtes
         // fin: on ferme la géométrie 
         sort << "\n    } )";
         sort << "\n # fin du dessin des arretes des elements du maillage deforme"
              << "\n # -----------------------------------------------------------\n";
         }                         
        if (numero) // cas d'une des numéros
         { cout << "\n **** erreur sortie des numeros de la frontiere du maillage deforme pas encore implante ****"
                << "\n Deformees_geomview::ExeOrdre(..." << endl;
         }
                                 
        // et on vide le buffer de sortie
        sort << endl; 
        } 
      // -----------------------------------------------------------------------
      // sinon, dans le cas où il y a animation il y a une procédure spéciale 
      // -----------------------------------------------------------------------
      else
       { cout << "\n cas de l'animation avec geomview, actuellement non implante !!}";
         return;
   /*   static string nom_premier_coordinate; // pour le passage d'info au dernier incrément
      // dans le cas du premier incrément on initialise les conteneurs de grandeurs transitoire
      // les facettes ne seront dessinées qu'aux derniers passages dans le cas des isovaleurs
      // sinon on dessine à mesure
      if (type_incre==PREMIER_INCRE)
         { // au premier increment on commence par ré-initialiser les conteneurs
           tab_facette.erase(tab_facette.begin(),tab_facette.end());
           tab_arrete.erase(tab_arrete.begin(),tab_arrete.end());
           num_mail_incr.erase(num_mail_incr.begin(),num_mail_incr.end());
           nom_premier_coordinate = "";
          }
      // on commence par définir la liste des points 
      // def de l'entité forme
      sort << "\n Shape { "
      << "\n  appearance Appearance {}";
      // création des points
      // tout d'abord le nom
      ostrstream tab_out;
      tab_out << "Coordinates" << incre << numMail << ends;
      string nom_coordinate = tab_out.str() ;  // le nom
      // on utilise une géométrie de face indexée bien qu'aucune face soit définit 
      sort << "\n  geometry IndexedFaceSet {"
           << "\n     coord DEF " << nom_coordinate <<  " Coordinate {"
           << "\n                   point [ ";
           
      // on balaie tous les noeuds du maillage
      int nbmaxinoeud = lesMail->Nombre_noeud(numMail);
      list <Coordonnee > listcoor; // une liste intermédiaire
      for (int numNoeud=1; numNoeud<= nbmaxinoeud;numNoeud++) 
               { // recup du noeud
                 Noeud & noe = lesMail->Noeud_LesMaille(numMail,numNoeud);
                 // deux cas : si l'incrément est 0 et les autres
                 if (incre == 0)
                  { //pas d'amplification
                    sort <<"\n                        "
                      << setw (16);  noe.Coord0().Affiche(sort,16);
                    // sauvegarde des coordonnées dans la liste
                    listcoor.push_back(noe.Coord0());
                   }
                 else // calcul d'un déplacement amplifié  
                  { // calcul du déplacement amplifié
                    Coordonnee dep(paraGlob->Dimension()); // init à zero par defaut
                    if (noe.ExisteCoord1()) {dep = (noe.Coord1() - noe.Coord0() ) * amplification;};
                    // ecriture des coordonnee avec le déplacement amplifié
                    Coordonnee posifin = (noe.Coord0() + dep);
                    sort <<"\n                        "
                      << setw (16);  posifin.Affiche(sort,16);
                    // sauvegarde des coordonnées dans la liste
                    listcoor.push_back(posifin);
                    }   
                 // si l'on n'est pas en dimension 3 on complete avec des zeros
                 if (paraGlob->Dimension () == 2)
                   { sort << setw (16) << 0 <<" ";
                    }
                 else if (paraGlob->Dimension () == 1)
                    { sort << setw (16) << 0  <<" " << setw (16) << 0  <<" ";
                    }
                 sort <<  " , ";
                 }
      // fermeture du groupe point, coordinate, de la géométrie et de la forme
      sort << "\n                     ] } } }";
      // on ajoute le nom des coordonnées créés dans la liste de gestion
      list_nom_coordinate.push_back(nom_coordinate); 
      list_coordinate.push_back(listcoor);  
      
      //---------------------------------------------------------------------------------
      // dans le cas où il n'y a pas d'isovaleur on ecrit tout de suite le fichier geomview
      //---------------------------------------------------------------------------------
     if ( !(isovaleurs_vrml->Actif()) )
      {if(surface && ((animation && (type_incre==PREMIER_INCRE))||(!animation)))
        // cas d'une visualisation par face
       { 
         // def de l'entité forme 
         sort << "\n Shape { "
           << "\n   appearance Appearance {}";
         // def de la géométrie
         sort << "\n     geometry IndexedFaceSet {"
         // utilisation des points déjà défini
              << "\n     coord USE Coordinates" << incre << numMail;
          // définition de la couleur
          sort << "\n                 color Color {"
               << "\n                     color ["
               << "\n                       " 
               << Rcoulf << " " << Gcoulf << " " << Bcoulf<< " ,"
               << "\n                     ]"
               << "\n                 }";
          // def des facettes
          sort << "\n                 coordIndex [";
          // un compteur qui globalise le nombre de facette dessinée
          int nbfacette=0;     
             // on balaie tous les éléments du maillage
          int nbmaxiElement = lesMail->Nombre_element(numMail);
          for (int numElem=1; numElem<= nbmaxiElement;numElem++) 
           { // recup de l'élément
             Element & elem = lesMail->Element_LesMaille(numMail,numElem);
             Tableau<Noeud *>& tab_noeud = elem.Tab_noeud (); // ses noeuds
             // connection des noeuds des faces par rapport a ceux de l'element
             // en fait on utilise une décomposition triangulaire linéaire de chaque facette
             // on récupère donc tout d'abord ces informations
                // le tableau des triangles linéaire
             const Tableau<Tableau<Tableau<int> > >&  
                        tabtria = elem.ElementGeometrique().Trian_lin();
             // le nombre de face à visualiser           
             int nb_FA = tabtria.Taille();
             for (int k=1;k<= nb_FA;k++)
              { sort << "\n                    "; //début de la face
                // nombre de triangle de la face
                int nbtriangle = tabtria(k).Taille();
                for (int ikt=1;ikt<=nbtriangle;ikt++,nbfacette++)
                 { //const Tableau<int> * tabn = &(tabtria(k)(ikt)); // pour simplifier
                   #ifdef MISE_AU_POINT
                   // vérification du nombre de noeud du triangle
                    if (tabtria(k)(ikt).Taille() != 3)
                      { cout << "\n erreur, les facettes n'ont pas 3 noeuds,"
                             << " nbnoeud = " << tabtria(k)(ikt).Taille()
                             << " \n Deformees_geomview::ExeOrdre(... " ;
                        Sortie(1);     
                       }
                   #endif
                   for (int no = 1; no<=3; no++)
                       sort << (tab_noeud(tabtria(k)(ikt)(no))->Num_noeud() - 1) << ", "; 
                   sort << "-1, "; 
                  }
                }
              }
          // fin pour les faces et activation de la couleur
          sort << "\n                ]";
          sort << "\n               colorIndex [ ";
          // le tableau des couleurs ici identique
          int ic; // un compteur inter pour qu'il y ait plusieurs numéros sur la même ligne
          int icmax = 10; int nf;
          for (nf=1,ic=1; nf< nbfacette;nf++,ic++) 
             { sort << " 0,"; 
               if (ic >= icmax) { ic = 1; sort << "\n";} // pour limiter la ligne
               }
          sort << " 0 ]"; // la dernière couleur
          // on signale que l'on veut voir que l'extérieur
          sort << "\n                solid TRUE";
          // ON signal que l'on tourne dans le sens positif géométrique
          sort << "\n                ccw TRUE";
          // et que les faces sont convexes
          sort << "\n                convex TRUE";
          // que l'on utilise une couleur par face
          sort << "\n       colorPerVertex FALSE";
          sort << "\n            }";
          // fin: on ferme l'entité forme
          sort << "\n         }";
         } //--- fin du cas ou c'est le premier incrément sans isovaleur pour des facettes
         
      if (filaire && ((animation && (type_incre==PREMIER_INCRE))||(!animation)))
       { 
         // def de l'entité forme
         sort << "\n Shape { "
           << "\n   appearance Appearance {}";
         // définition de la géométrie
         sort << "\n    geometry IndexedLineSet {"
         // utilisation des points déjà défini
              << "\n    coord USE " <<nom_coordinate;
          // définition de la couleur
          sort << "\n                 color Color {"
               << "\n                     color ["
               << "\n                       " 
               << Rcoull << " " << Gcoull << " " << Bcoull<< " ,"
               << "\n                     ]"
               << "\n                 }";
          // def des arrêtes
          sort << "\n                 coordIndex [";
          // def d'un compteur du nombre d'arrete dessiné
          int nbarr = 0;
             // on balaie tous les éléments du maillage
          int nbmaxiElement = lesMail->Nombre_element(numMail);
          for (int numElem=1; numElem<= nbmaxiElement;numElem++) 
           { // recup de l'élément
             Element & elem = lesMail->Element_LesMaille(numMail,numElem);
             Tableau<Noeud *>& tab_noeud = elem.Tab_noeud (); // ses noeuds
             // connection des noeuds des arêtes par rapport a ceux de l'element
             Tableau<Tableau<int> > const & nomS =  elem.ElementGeometrique().NonS();
             int nb_ar = nomS.Taille(); // nombre d'arrêtes
             for (int k=1;k<= nb_ar;k++,nbarr++)
              { sort << "\n                    "; //début de l'arrête 
                Tableau<int>const & tabn = nomS(k); 
                int nb_no = tabn.Taille(); // le nb de noeud de l'arrête
                for (int no = 1; no<=nb_no; no++)
                  sort << (tab_noeud(tabn(no))->Num_noeud() - 1) << ", "; 
                sort << " -1,"; 
                }
              }
          // fin pour les arrêtes et activation de la couleur
          sort << "\n                ]";
          sort << "\n               colorIndex [ ";
           // le tableau des couleurs ici identique
          int ic; // un compteur inter pour qu'il y ait plusieurs numéros sur la même ligne
          int na; int icmax = 10;
          for (na=1,ic=1; na< nbarr;na++,ic++) 
             { sort << " 0,"; 
               if (ic >= icmax) { ic = 1; sort << "\n";} // pour limiter la ligne
               }
          sort << " 0 ]"; // la dernière couleur
          sort << "\n                colorPerVertex FALSE";
          sort << "\n            }";
          // fin: on ferme l'entité forme
          sort << "\n         }";
         }                         
      if (numero && ((animation && (type_incre==PREMIER_INCRE))||(!animation))) // cas d'une des numéros
       { 
         // on balaie tous les noeuds du maillage
         int nbmaxinoeud = lesMail->Nombre_noeud(numMail);
         for (int numNoeud=1; numNoeud<= nbmaxinoeud;numNoeud++) 
               { // recup du noeud
                 Noeud & noe = lesMail->Noeud_LesMaille(numMail,numNoeud);
                 // définition de l'entité billboard qui permet que les numéros restent faces
                 // à l'utilisateur
     //            sort << "\n Billboard { axisOfRotation 0.0 0.0 0.0       children [ ";
                 // on définit un ensemble de déplacement qui permet de ce positionner
                 // aux coordonnées des noeuds 
                 sort << "\n        Transform {  #           X   Y   Z ";
                 // calcul du déplacement amplifié
                    Coordonnee dep(paraGlob->Dimension()); // init à zero par defaut
                    if (noe.ExisteCoord1()) {dep = (noe.Coord1() - noe.Coord0() ) * amplification;};
                 // ecriture des coordonnee avec le déplacement amplifié
                 sort <<"\n              translation "
                      << setw (16);  (noe.Coord0() + dep).Affiche(sort,16);
                 // si l'on n'est pas en dimension 3 on complete avec des zeros
                 if (paraGlob->Dimension () == 2)
                   { sort << setw (16) << 0 <<" ";
                    }
                 else if (paraGlob->Dimension () == 1)
                    { sort << setw (16) << 0  <<" " << setw (16) << 0  <<" ";
                    }
                 // on définit le numéro
                  sort   << "\n                children [";
                 // def de l'entité forme
                 sort << "\n          Shape { "
                   << "\n                appearance Appearance {"
                   << "\n                  material Material { }"
                   << "\n                             }";
                 // le numéro 
                 sort << "\n             geometry Text {"
                      << "\n             string \"" << numNoeud <<"\""
                      << "\n               fontStyle FontStyle {size 0.2} "
                      << "\n                 }} ] }";
                 // on ferme le billboard  et la forme générale       
        //         sort << "\n             ]}";        
                 }
         }
       }
      //---------------------------------------------------------------------------------
      // dans le cas où on a des isovaleurs on sauvegarde les informations pour ne les 
      // traiter qu'au dernier incrément
      //---------------------------------------------------------------------------------
      else
       {if (type_incre==PREMIER_INCRE)
           // sauvegarde pour une utilisation au dernier incrément
           nom_premier_coordinate=nom_coordinate;
        if(surface && ((animation && (type_incre==PREMIER_INCRE))||(!animation)))
          // cas d'une visualisation par face
         {// on balaie tous les éléments du maillage       
          int nbmaxiElement = lesMail->Nombre_element(numMail);
          Tableau <int> tab3(3); // tableau de travail
          for (int numElem=1; numElem<= nbmaxiElement;numElem++) 
           { // recup de l'élément
             Element & elem = lesMail->Element_LesMaille(numMail,numElem);
             Tableau<Noeud *>& tab_noeud = elem.Tab_noeud (); // ses noeuds
             // connection des noeuds des faces par rapport a ceux de l'element
             // en fait on utilise une décomposition triangulaire linéaire de chaque facette
             // on récupère donc tout d'abord ces informations
                // le tableau des triangles linéaire
             const Tableau<Tableau<Tableau<int> > >&  
                        tabtria = elem.ElementGeometrique().Trian_lin();
             // le nombre de face à visualiser           
             int nb_FA = tabtria.Taille();
             for (int k=1;k<= nb_FA;k++)
              { // nombre de triangle de la face
                int nbtriangle = tabtria(k).Taille();
                for (int ikt=1;ikt<=nbtriangle;ikt++)
                 { //const Tableau<int> * tabn = &(tabtria(k)(ikt)); // pour simplifier
                   #ifdef MISE_AU_POINT
                   // vérification du nombre de noeud du triangle
                    if (tabtria(k)(ikt).Taille() != 3)
                      { cout << "\n erreur, les facettes n'ont pas 3 noeuds,"
                             << " nbnoeud = " << tabtria(k)(ikt).Taille()
                             << " \n Deformees_geomview::ExeOrdre(... " ;
                        Sortie(1);     
                       }
                   #endif
                   for (int no = 1; no<=3; no++)
                    tab3(no) = (tab_noeud(tabtria(k)(ikt)(no))->Num_noeud() - 1) ; 
                   tab_facette.push_back(tab3);    
                  }
                }
              }
         } //--- fin du cas pour l'enregistrement des  facettes avec isovaleurs
         
      if (filaire && ((animation && (type_incre==PREMIER_INCRE))||(!animation)))
       {  // on balaie tous les éléments du maillage
          int nbmaxiElement = lesMail->Nombre_element(numMail);
          Tableau <int> tab2(3); // tableau de travail
          for (int numElem=1; numElem<= nbmaxiElement;numElem++) 
           { // recup de l'élément
             Element & elem = lesMail->Element_LesMaille(numMail,numElem);
             Tableau<Noeud *>& tab_noeud = elem.Tab_noeud (); // ses noeuds
             // connection des noeuds des arêtes par rapport a ceux de l'element
             Tableau<Tableau<int> > const & nomS =  elem.ElementGeometrique().NonS();
             int nb_ar = nomS.Taille(); // nombre d'arrêtes
             for (int k=1;k<= nb_ar;k++)
              { Tableau<int>const & tabn = nomS(k); 
                int nb_no = tabn.Taille(); // le nb de noeud de l'arrête
                for (int no = 1; no<=nb_no; no++)
                  tab2(no) = (tab_noeud(tabn(no))->Num_noeud() - 1) ; 
                tab_arrete.push_back(tab2);
                }
              }
         } //--- fin du cas pour l'enregistrement des  arretes avec isovaleurs                         
       
       }
   
      //---------------------------------------------------------------------------------
      // cas du dernier incrément 
      
      // définir les noms des matières :noms_matiere
      
      //---------------------------------------------------------------------------------
      if (type_incre==DERNIER_INCRE)
       {// cas des isovaleurs actives
        if (isovaleurs_vrml->Actif())
         {// récup du nombre de maillage qui sont visualisé
          const list <int> & lis_mail_choisit = choix_mail->List_choisit();
          int nb_maillage= lis_mail_choisit.size();
          // récup du nombre de pas 
          int nb_step = (int) (list_nom_coordinate.size()/nb_maillage);
          // variables de travail
          list <string>::iterator inom=list_nom_coordinate.begin();
          //on boucle sur tous les incréments et sur les maillages choisit
          for (int ist=1; ist<= nb_step; ist++) for (int im=1;im<=nb_maillage;im++,inom++)
          {// def du nom de la matière
           ostrstream tab_mat;
           tab_mat << "matiere" << ist << im << ends;
           string nom_matiere = tab_mat.str() ;  // le nom
           noms_matiere.push_back(nom_matiere);
           // def du nom des couleurs
           ostrstream tab_co;
           tab_co << "couleur" << ist << im << ends;
           string nom_des_couleurs = tab_co.str() ;  // le nom
           noms_couleurs.push_back(nom_des_couleurs);
           if(surface)  // cas d'une visualisation par face
           {  // def de l'entité forme 
              sort << "\n Shape { "
                   << "\n   appearance Appearance {"
                   << "\n          material DEF "<<nom_matiere<<" Material {"
                   << "\n                                     transparency  ";
              if (ist==1) sort << 0.; else sort << 1.;
              sort << "\n                                           }"
                   << "\n                          } "; 
              // def de la géométrie
              sort << "\n     geometry IndexedFaceSet {"
              // utilisation des points déjà défini
                   << "\n     coord USE " << (*inom);
             // def des facettes
             sort << "\n                 coordIndex [";
             list < Tableau < int > >::iterator it,itfin=tab_facette.end();
             // on balaie tous les éléments de la liste
             for (it=tab_facette.begin();it!=itfin;it++)
              { for(int j=1;j<=3;j++)
                   sort << (*it)(j) << ", "; 
                 sort << "-1, ";
               }
             sort << "\n                 ] # fin de coordIndex pour les faces ";
             // fin pour les faces 
             // définition de la couleur
             // récupération des couleurs initiales
             const list < Tableau < Rgb > > & list_couleur=isovaleurs_vrml->List_couleur();
             list < Tableau < Rgb > >::const_iterator icoul_deb=list_couleur.begin();
             const Tableau < Rgb > & tab_coul = (*icoul_deb);
             int taille_tab_coul= tab_coul.Taille();
             // NB: nom_base_couleur est définie dans OrdreVisu (classe mere)
             sort << "\n                 color DEF " << nom_des_couleurs << " Color {"
                  << "\n                     color [";
             for (int i=1;i<= taille_tab_coul;i++)
                sort << "\n                       " 
                     <<tab_coul(i) << " ,";
             sort << "\n                     ]"
                  << "\n                 }";
             // on signale que l'on veut voir que l'extérieur
             sort << "\n                solid TRUE";
             // ON signal que l'on tourne dans le sens positif géométrique
             sort << "\n                ccw TRUE";
             // et que les faces sont convexes
             sort << "\n                convex TRUE";
             // que l'on utilise une couleur par noeud (vertex)
             sort << "\n       colorPerVertex TRUE";
             sort << "\n            }";
             // fin: on ferme l'entité forme
             sort << "\n         }";
            } //--- fin cas  des facettes
         
          if (filaire) // cas des arrêtes 
            {// def de l'entité forme
              sort << "\n Shape { "
                   << "\n   appearance Appearance {";
              if (surface)     
                 sort  << "\n          material USE "<<nom_matiere ;
              else
                {sort  << "\n          material DEF "<<nom_matiere<<" Material {"
                       << "\n                                     transparency  ";
                 if (ist==1) sort << 0.; else sort << 1.;
                 sort << "\n                                           }";
                 }
             sort << "\n                          } "; 
             // définition de la géométrie
             sort << "\n    geometry IndexedLineSet {"
             // utilisation des points déjà défini
                  << "\n    coord USE " << (*inom);
             // def des arrêtes
             sort << "\n                 coordIndex [";
             list < Tableau < int > >::iterator it,itfin=tab_arrete.end();
             // on balaie tous les éléments de la liste
             for (it=tab_arrete.begin();it!=itfin;it++)
              { for(int j=1;j<=2;j++)
                    sort << (*it)(j) << ", "; 
                 sort << "-1, ";
               }
             sort << "\n                 ] # fin de coordIndex pour les arretes ";
             // fin pour les arretes 
             // définition de la couleur
             // récupération des couleurs initiales
             const list < Tableau < Rgb > > & list_couleur=isovaleurs_vrml->List_couleur();
             list < Tableau < Rgb > >::const_iterator icoul_deb=list_couleur.begin();
             const Tableau < Rgb > & tab_coul = (*icoul_deb);
             int taille_tab_coul= tab_coul.Taille();
             // si les facettes sont déjà défini on réutilise leur couleurs sinon on la recré
             if (surface)
              { sort << "\n                 color USE " << nom_des_couleurs << " ";
               }
             else  
              { sort << "\n                 color DEF " << nom_des_couleurs << " Color {"
                     << "\n                     color [";
                for (int i=1;i<= taille_tab_coul;i++)
                  sort << "\n                       " 
                       <<tab_coul(i) << " ,";
                sort << "\n                     ]"
                     << "\n                 } # fin de la definition des couleurs";
               }      
             sort << "\n                colorPerVertex TRUE";
             sort << "\n            }";
             // fin: on ferme l'entité forme
             sort << "\n         }";
           } // -- fin cas des arretes
          } // -- fin boucle sur les incréments                         
         } //-- fin cas isovaleurs actives avec le dernier incrément
       } // -- fin cas du dernier incrément
        // et on vide le buffer de sortie */
        
       }; // -- fin du cas avec animation
    };//-- fin de la boucle sur les maillages
    sort << endl; 
  }; //-- fin du cas actif ou pas

 };