// 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-2022 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 "Isovaleurs_vrml.h"

#include <iomanip>
#include <algorithm>
#include "CharUtil.h"
#include "Coordonnee2.h"
#include "ConstMath.h"
#include "MathUtil.h"
#include "Banniere.h"
#include <limits>

    // CONSTRUCTEURS :
// par defaut
Isovaleurs_vrml::Isovaleurs_vrml () :
   OrdreVisu("........................................isovaleurs"
             ,"visualisation des isovaleurs","iso")
   ,choix_peau(true),choix_legende(true),choix_min_max(1)
   ,pour_legende_min(0),pour_legende_max(100)
   ,valMini(0.),valMaxi(0.)
   ,tabnoeud_type_ddl(),type_ddl_retenu(),choix_var_ddl()
   ,tabelement_type_ddl()
   ,spectre_coul(),nb_iso_val()
   ,couleurs_noeud(),val_noeud(),num_mail_incr()
   ,absolue(true)
     {// par défaut le nombre d'isovaleur vaut le nombre de couleur du spectre
      nb_iso_val=spectre_coul.NbCouleurBaseSpectre(); 
      }; 
     
     // constructeur de copie 
Isovaleurs_vrml::Isovaleurs_vrml (const Isovaleurs_vrml& ord) :
    OrdreVisu(ord) 
   ,choix_peau(ord.choix_peau),choix_legende(ord.choix_legende)
   ,choix_min_max(ord.choix_min_max)
   ,pour_legende_min(ord.pour_legende_min),pour_legende_max(ord.pour_legende_max)
   ,valMini(ord.valMini),valMaxi(ord.valMaxi)
   ,tabnoeud_type_ddl(ord.tabnoeud_type_ddl)
   ,type_ddl_retenu(ord.type_ddl_retenu),choix_var_ddl(ord.choix_var_ddl)
   ,tabelement_type_ddl(ord.tabelement_type_ddl)
   ,spectre_coul(ord.spectre_coul),nb_iso_val(ord.nb_iso_val)
   ,couleurs_noeud(ord.couleurs_noeud),val_noeud(ord.val_noeud)
   ,num_mail_incr(ord.num_mail_incr)
   ,absolue(ord.absolue)
     { };
               
    // DESTRUCTEUR :
Isovaleurs_vrml::~Isovaleurs_vrml () 
     {  };  
    
    // 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 Isovaleurs_vrml::ExeOrdre(ParaGlob * ,const Tableau <int>& tab_mail,LesMaillages * lesMail,bool ,LesReferences*
                      ,LesLoisDeComp* ,DiversStockage*,Charge*,LesCondLim*
                      ,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)
  {// 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 aucun type de ddl retenu on arrête tout de suite
      if (type_ddl_retenu.Taille() == 0)
       { cout << "\n *** aucun type de ddl n'est defini en sortie, on ne fait rien \n";
         }
      else  // cas où il y a des ddl défini   
      {// en fait on se contente de définir les couleurs aux noeuds par rapport à l'échelle 
       // actuelle des couleurs
       // actualisation du conteneur du résultat
       if (type_incre==PREMIER_INCRE)
         { // au premier increment on commence par ré-initialiser les conteneurs
           couleurs_noeud.erase(couleurs_noeud.begin(),couleurs_noeud.end());
           num_mail_incr.erase(num_mail_incr.begin(),num_mail_incr.end());
           val_noeud.erase(val_noeud.begin(),val_noeud.end());
           // dans le cas d'un calcul de mini max  automatique on initialise
           if ((choix_min_max == 1)||(choix_min_max==3)) // cas d'un seul min max
            { valMini=0.;valMaxi=0.;};
          };
          
       // on définit deux variables intermédiaires
       // qui serviront ensuite à complèter les deux listes
       int nbmaxinoeud = lesMail->Nombre_noeud(numMail);
       Tableau < double > v_noeuds(nbmaxinoeud);
       Deuxentiers deuxi; deuxi.mail = numMail; deuxi.incr=incre;
       
       // on balaie tous les noeuds du maillage
       list <Coordonnee > listcoor; // une liste intermédiaire
       for (int numNoeud=1; numNoeud<= nbmaxinoeud;numNoeud++) 
          { // recup du noeud
            Noeud & noe = lesMail->Noeud_LesMaille(numMail,numNoeud);
            // recup de la valeur du ddl
            double val_ddl = noe.Valeur_tdt(type_ddl_retenu(numMail).Enum());
            if (!choix_var_ddl(numMail))
              val_ddl -= noe.Valeur_0(type_ddl_retenu(numMail).Enum());
            // enregistrement de la valeur
            v_noeuds(numNoeud)=val_ddl;
            // dans le cas on l'on utilise un mini max global automatique 
            // on le met à jour
            if ((choix_min_max == 1)||(choix_min_max==3)) // cas d'un seul min max
              { if (val_ddl > valMaxi) valMaxi = val_ddl;
                if (val_ddl < valMini) valMini = val_ddl;
               };
           };       
           
       // on sauvegarde les grandeurs intermédiaires
       num_mail_incr.push_back(deuxi);   
       val_noeud.push_back(v_noeuds);                          

       // cas du dernier incrément ou du premier sans animation, se qui signifie que c'est également le dernier
       if ((type_incre==DERNIER_INCRE)||( (type_incre==PREMIER_INCRE) && (!animation) ))
        {  // dans le cas du dernier incrément on met les valeurs à la bonne échelle
           // si c'est une échelle automatique
           if ((choix_min_max == 1) || (choix_min_max==3))
            { //on regarde si l'échelle n'est pas nulle si oui on la met à une valeur arbitraire de 1
              if ( Dabs(valMaxi - valMini) <= ConstMath::petit)
                { cout << "\n *** attention la valeur mini "<< valMini <<" et maxi " << valMaxi 
                       << " sont trop rapprochees pour le calcul de la plage d'isovaleur"
                       << "\n le mini et le maxi sont mis arbitrairement a 0 et 1";
                  valMaxi = 1.; valMini= 0.;     
                 }
             if (choix_min_max == 1)  // cas d'un min max normal automatique   
               {spectre_coul.Change_min_max(valMini,valMaxi) ;}
             else if (choix_min_max == 3)  // cas d'un min max automatique en %
               {// on applique les %
                double leg_min=valMini + (valMaxi-valMini) * pour_legende_min/100.;
                double leg_max=valMini + (valMaxi-valMini) * pour_legende_max/100.;
                spectre_coul.Change_min_max(leg_min,leg_max) ;
                }
            } 
          // maintenant on défini les couleurs
          // on passe en revue toutes les valeurs enregistrées
          list < Tableau < double > >::iterator it,itfin=val_noeud.end();
          for (it=val_noeud.begin();it!= itfin;it++)
           { int taimax=(*it).Taille();
             Tableau < Rgb > coul_noeuds(taimax);
             Tableau < double > & tab = (*it); // par facilité
             // dans le cas ou le min max varie à chaque incrément il faut d'abord le calculer
             if (choix_min_max==2)
              { valMini = 0.; valMaxi = 0.; // init
                double val_ddl;
                for (int j=1;j<=taimax;j++)
                 { val_ddl=tab(j);
                   if (val_ddl > valMaxi) valMaxi = val_ddl;
                   if (val_ddl < valMini) valMini = val_ddl;
                   }
                //on regarde si l'échelle n'est pas nulle si oui on la met à une valeur arbitraire de 1
                if ( Dabs(valMaxi - valMini) <= ConstMath::petit)
                { cout << "\n *** attention (2) la valeur mini "<< valMini <<" et maxi " << valMaxi 
                       << " sont trop rapprochees pour le calcul de la plage d'isovaleur"
                       << "\n le mini et le maxi sont mis arbitrairement a 0 et 1";
                  valMaxi = 1.; valMini= 0.;     
                 } 
                // maintenant on applique les %
                double leg_min=valMini + (valMaxi-valMini) * pour_legende_min/100.;
                double leg_max=valMini + (valMaxi-valMini) * pour_legende_max/100.;
                spectre_coul.Change_min_max(leg_min,leg_max) ;
               }; 
             // maintenant on calcul les couleurs            
             for (int i=1;i<=taimax;i++)
                coul_noeuds(i)=spectre_coul.CouleurVal(tab(i));
             couleurs_noeud.push_back(coul_noeuds);
             }
          // on dessine la légende au dernier  passage
          // car c'est seulement à la fin que l'on connait exactement l'échelle (dans le cas d'un
          // calcul automatique de l'échelle)
          // dans les autres cas la légende ne concerne que le dernier cas
          Sortie_dessin_legende(entreePrinc);
          if (choix_min_max==2)
            { cout << "\n *** attention ici la legende ne concerne que le dernier increment !!";}; 
         }
        }; //-- fin du choix où il y a ou pas des ddl actifs definis
    }; //-- fin de la boucle sur les maillages
  };//-- fin du choix actf ou pas  

 };

// choix de l'ordre, cet méthode peut entraîner la demande d'informations
// supplémentaires si nécessaire. qui sont ensuite gérer par la classe elle même
void Isovaleurs_vrml::ChoixOrdre()
 { bool choix_valide = false;
   cout << "\n ---- isovaleurs ---- ";
   string rep;
   while (!choix_valide)
      {
       try 
        { 
          cout 
          << "\n (0 ou f ou fin) fin modif"
          << "\n (1) definition des parametres generaux "
          << "\n (2) choix de l'isovaleur "
          << "\n (3) transferts aux noeuds de grandeurs existantes aux points d'integration";
          cout << "\n \n reponse ? ";
          rep = lect_return_defaut(false,"f");
          if (rep == "fin_prog") Sortie(1);
          // sinon
          int num = ChangeEntier(rep);
          if ((rep == "0")||(rep == "f")||(rep == "fin")) 
            { choix_valide=true; }
          else if ((num >= 1)&&(num<=3)) 
           { choix_valide=false;
             switch (num)
              { case 1:  //"definition des parametres generaux"
                { ParametresGeneraux(); break;}
                case 2:  // "choix de l'isovaleur"
                 {ChoixIsovaleur(); break;}
                case 3:  // "transferts aux noeuds de grandeurs existantes aux points d'integration"
                { TransfertGrandeursPtIntegAuNoeud(); break;}
               }
             } 
          else { cout << "\n Erreur on attendait un entier entre 0 et 3 !!, "
                      << "\n redonnez une bonne valeur"
                      << "\n ou taper fin_prog pour arreter le programme"; 
              choix_valide=false;
             }
         }    
       catch (ErrSortieFinale)
            // cas d'une direction voulue vers la sortie
            // on relance l'interuption pour le niveau supérieur
          { ErrSortieFinale toto;
            throw (toto);
          }
       catch (...)// erreur de lecture
       {  cout << "\n Erreur on attendait un des mots cles proposés !!, "
                      << "\n redonnez une bonne valeur"
                      << "\n ou taper fin_prog pour arreter le programme"; 
              choix_valide=false;
        }
       } //-- fin du while
   // appel de la méthode de la classe mère
   OrdreVisu::ChoixOrdre();    
  };     
            
// initialisation : permet d'initialiser les différents paramètres de l'ordre
// lors d'un premier passage des différents incréments
// en virtuelle, a priori est défini si nécessaire dans les classes dérivées
void Isovaleurs_vrml::Initialisation(ParaGlob * paraGlob,LesMaillages * lesmail,LesReferences* lesRef
                      ,LesLoisDeComp* lesLoisDeComp,DiversStockage* diversStockage,Charge* charge
                      ,LesCondLim* lesCondLim,LesContacts* lesContacts
                      ,Resultats* resultats,EnumTypeIncre type_incre,int incre
                      ,const map < string, const double * , std::less <string> >& listeVarGlob
                      ,const List_io < TypeQuelconque >& listeVecGlob
                      ,bool fil_calcul) 
   { // initialisation de la liste des différentes isovaleurs possibles
     // uniquement lors du premier et du dernier passage pour économiser 
     if ((type_incre == OrdreVisu::DERNIER_INCRE) || (type_incre == OrdreVisu::PREMIER_INCRE))
      {Init_liste_isovaleur(lesmail,lesContacts);}
     //appel de l'ordre d'initialisation de la classe mère
     OrdreVisu::Initialisation(paraGlob,lesmail,lesRef,lesLoisDeComp,diversStockage,charge
                      ,lesCondLim,lesContacts,resultats,type_incre,incre
                      ,listeVarGlob,listeVecGlob,fil_calcul);
     choix_var_ddl.Change_taille(lesmail->NbMaillage());                  
   };
            
// initialisation de la liste des différentes isovaleurs possibles
void Isovaleurs_vrml::Init_liste_isovaleur(LesMaillages * lesMail,LesContacts* lesContacts)
   { // récupération des ddl présents dans les maillages aux noeuds
	    tabnoeud_type_ddl = lesMail->Les_type_de_ddl_par_noeud(absolue);
	    tabelement_type_ddl = lesMail->Les_type_de_ddl_par_element(absolue);
   }; 
   
// lecture des paramètres de l'ordre dans un flux
void Isovaleurs_vrml::Lecture_parametres_OrdreVisu(UtilLecture & entreePrinc)
 { // si dans le flot il existe l'identificateur adoc on lit sinon on passe
   if (strstr(entreePrinc.tablcarCVisu,"debut_isovaleur_vrml")!=NULL)
     {// sauvegarde des parametres actuels
      bool choix_peau_s=choix_peau; bool choix_legende_s=choix_legende; int choix_min_max_s=choix_min_max;
      double valMini_s=valMini; double valMaxi_s=valMaxi; int nb_iso_val_s=nb_iso_val;
      Tableau < Ddl_enum_etendu>  type_ddl_retenu_s(type_ddl_retenu);
      // essaie de lecture
      try 
        { string nom,nom1; 
          (*entreePrinc.entCVisu)  >> nom ;
          if (nom != "debut_isovaleur_vrml")
            { cout << "\n Erreur en lecture des parametres pour les isovaleurs a partir d'un fichier .CVisu,"
                   << " le premier enregistrement doit etre le mot clef: debut_isovaleur_vrml "
                   << " on ne tiens pas compte  des parametres fournis !! ";
              }
          else
           { // appel de l'ordre de la classe mère
             OrdreVisu::Lect_para_OrdreVisu_general(entreePrinc);
             // puis lecture des parametres propres
             // lecture  du type de sortie des tenseurs
             if (strstr(entreePrinc.tablcarCVisu,"tenseur_en_absolue_")!=NULL)
               {(*entreePrinc.entCVisu) >> nom >> absolue;
					           if (nom != "tenseur_en_absolue_")
					            { cout << "\n lecture de l'indicateur de type de tensue, on a lue ( "<< nom
								                << " ) et on attendait tenseur_en_absolue_"
								                << " la suite de la lecture du .CVisu risque d'etre completement fausse, on arrete !!" ; 
						             cout << "\n Isovaleurs_Gmsh::Lecture_parametres_OrdreVisu(... ";     
                   UtilLecture::ErrNouvelEnregCVisu sortie(-1) ; throw (sortie);
						           }
					           else // sinon c'est ok
					            {entreePrinc.NouvelleDonneeCVisu();}; // on passe un enregistrement
               };
             int nb_maillage = tabnoeud_type_ddl.Taille(); 
             
             while (strstr(entreePrinc.tablcarCVisu,"fin_isovaleur_vrml")==NULL)
              { (*entreePrinc.entCVisu) >> nom; // lecture du numero de maillage
                if (nom == "choix_peau") (*entreePrinc.entCVisu) >> choix_peau;
                if (nom == "choix_legende") (*entreePrinc.entCVisu) >> choix_legende;
                if (nom == "choix_min_max") (*entreePrinc.entCVisu) >> choix_min_max;
                if (nom == "valMini") (*entreePrinc.entCVisu) >> valMini;
                if (nom == "valMaxi") (*entreePrinc.entCVisu) >> valMaxi;
                if (nom == "pour_legende_min") (*entreePrinc.entCVisu) >> pour_legende_min;
                if (nom == "pour_legende_max") (*entreePrinc.entCVisu) >> pour_legende_max;
                if (nom == "nb_iso_val") (*entreePrinc.entCVisu) >> nb_iso_val;
                if (nom == "debut_tableau_ddl") 
                  { (*entreePrinc.entCVisu) >> nom1;
                    if (nom1 != "fin_tableau_ddl")
                     { type_ddl_retenu.Change_taille(nb_maillage);
                       choix_var_ddl.Change_taille(nb_maillage); 
                       type_ddl_retenu(1) = Ddl_enum_etendu(nom1);
                       for (int i=2;i<= nb_maillage; i++) 
                         { (*entreePrinc.entCVisu) >> type_ddl_retenu(i);
                           (*entreePrinc.entCVisu) >> choix_var_ddl(i);
                          } 
                      }
                   }    
                entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement                   
               }        
             entreePrinc.NouvelleDonneeCVisu(); // on passe un enregistrement
            } // -- fin du if then else sur "debut_isovaleur_vrml"       
         } // -- fin du try    
      catch (ErrSortieFinale)
           // cas d'une direction voulue vers la sortie
           // on relance l'interuption pour le niveau supérieur
         { ErrSortieFinale toto;
           throw (toto);
         }
      catch (...)// erreur de lecture
       {  cout << "\n Erreur en lecture des parametres pour les isovaleurs a partir d'un fichier .CVisu,"
               << " on ne tiens pas compte  des parametres fournis !! ";
          // récup des  parametres sauvées
          choix_peau=choix_peau_s; choix_legende=choix_legende_s; choix_min_max=choix_min_max_s;
          valMini=valMini_s; valMaxi=valMaxi_s; nb_iso_val=nb_iso_val_s;
          type_ddl_retenu = type_ddl_retenu_s;
          if (ParaGlob::NiveauImpression() >= 4)     
             cout  << "\n Isovaleurs_vrml::Lecture_parametres_OrdreVisu(..";
        }
      }  
  };

// écriture des paramètres de l'ordre dans un flux
void Isovaleurs_vrml::Ecriture_parametres_OrdreVisu(UtilLecture & entreePrinc)
 { // récup du flot  
   ostream & sort = (*(entreePrinc.Sort_CommandeVisu()));
   // on commente le fonctionnement
   sort << "\n #  ----------------------------- definition des parametres pour les isovaleurs : ---------------- ";
   // mot clé de démarrage
   sort << "\n debut_isovaleur_vrml         # mot cle de debut des parametres pour les isovaleurs"; 
   // appel de l'ordre de la classe mère
   OrdreVisu::Ecrit_para_OrdreVisu_general(entreePrinc);
   // le type de sortie des tenseurs
   sort << "\n# un parametre indiquant si les tenseurs sont en absolue (rep 1) ou suivant un repere ad hoc"
        << "\n# (tangent pour les coques, suivant la fibre moyenne pour les element 1D ) ";
   sort << "\n tenseur_en_absolue_  " <<  absolue;
   // puis les paramètres
   sort << "\n choix_peau " << choix_peau << "  # <0 ou 1> si 1 visualisation uniquement de la peau";
   sort << "\n choix_legende " << choix_legende << "  # <0 ou 1> si 1  affichage de la legende";
   sort << "\n choix_min_max " << choix_min_max << "  # <0 ou 1 ou 2> si 1 min max calcule automatiquement, 2 auto en % par incre";
   sort << "\n valMini " << valMini << "  # mini  <un reel> utilises si choix_min_max = 0";
   sort << "\n valMaxi " << valMaxi << "  # maxi  <un reel> utilises si choix_min_max = 0";
   sort << "\n pour_legende_min " << pour_legende_min << "  # mini  <un reel> utilises si choix_min_max = 2";
   sort << "\n pour_legende_max " << pour_legende_max << "  # maxi  <un reel> utilises si choix_min_max = 2";
   sort << "\n nb_iso_val " << nb_iso_val << "  # <un entier> nombre d'isovaleurs dans la legende";
   // ---- les ddl a visualiser
   sort << "\n #   tableau de ddl a visualiser, un par maillage";
   int nb_mail = type_ddl_retenu.Taille();
   sort << "\n debut_tableau_ddl " ;
   for (int i=1;i<= nb_mail;i++) 
      { sort << type_ddl_retenu(i) << " " << choix_var_ddl(i) << " ";};
   sort << " fin_tableau_ddl " ;
   // mot clé de fin
   sort << "\n fin_isovaleur_vrml         # mot cle de fin des parametres pour les isovaleurs \n";
  };

// ======================================== méthodes privées =====================================
                           
// sortie du dessin de la légende
void Isovaleurs_vrml::Sortie_dessin_legende(UtilLecture & entreePrinc)
  {ostream &sort = entreePrinc.Sort_legende_vrml();
   // écriture de l'entête
   sort << "#VRML V2.0 utf8\n";
   // le titre
   sort << "WorldInfo {\n"
        << "title \" Légende pour isovaleurs du calcul éléments finis : Herezh++ V" << ParaGlob::NbVersion()
                                                               << " \" \n"
 //       << "info [ \"Copyright (c) 1997-2003, Gérard Rio (gerard.rio@univ-ubs.fr) http://www-lg2m.univ-ubs.fr\" ]\n"
        << "info [ \" " << Banniere::CopiPirate << " \" ]\n"
        << "}\n";
   sort << "NavigationInfo {\n"
        << "type [ \"EXAMINE\", \"ANY\" ] \n"
        << "headlight TRUE \n"
        << "}\n";
   // on définit un rectangle pour chaque niveau d'isovaleur 
   // globalement on définit le rectangle global par les points extrèmes
   Coordonnee2 ptdeb(0.,0.); Coordonnee2 ptfin(10.,200.);
   // on définit le deltax et le delta y
   Coordonnee2 deltax(10.,0.);Coordonnee2 deltay(0.,200./(nb_iso_val-1.));  
   // définition des points de vue avec l'angle adoc
   // l'objectif est de positionner les viewpoints relativement à la legende
   // pour l'instant pb avec maclookat donc on simplifie        
 /*  Vecteur diag = ptfin - ptdeb;
   double lmax = diag.Norme();
   Vecteur centre = (ptfin + ptdeb)/2.;
   // si la dimension est différente de 3 on force à 3 
   // d'où les autres coordonnées sont nulles
   centre.Change_taille(3);
   // def de la distance d'observation grande pour minimiser la déformation
   double dist = 5.*lmax;
   // calcul de l'angle du cone de vue
   double angle = 1.25*atan(lmax/dist); 
   int i1= std::abs( centre(1));
   int i2= std::abs( centre(2)); 
   int i3= std::abs( centre(3)+ dist); 
   sort << "\n Viewpoint {"
        << "\n position " << i1 <<" "<< i2 <<" "<< i3
        << "\n fieldOfView " << angle
        << "\n description \"suivant Z \""
        << "\n }";
*/
   sort << "\n Viewpoint {"
        << "\n position " << " 5       100      1000 "
        << "\n fieldOfView " << 0.25
        << "\n description \"suivant Z \""
        << "\n }";
   // definition du tableau des points de la legende
   Tableau <Coordonnee2> tab_pt(2*nb_iso_val,ptdeb);
   for (int i=1;i<= nb_iso_val;i++)
     { tab_pt(i) += (i-1) * deltay;
       tab_pt(i+nb_iso_val) = tab_pt(i) + deltax;
      }  
   // on  ecrit 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 << "Coordonnees"  << 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 [ \n";
   int deux_nb_iso_val = 2*nb_iso_val;    
   for (int i=1;i<= deux_nb_iso_val;i++)
     { sort <<"\n                        "
                   << setw (4);  
       tab_pt(i).Affiche(sort,16);
       sort << setw (16) << 0 <<" "; // pour etre en 3D
      } 
   // fermeture du groupe point, coordinate, de la géométrie et de la forme
   sort << "\n                     ] } } }";
   // maintenant les facettes:  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 Coordonnees" ;
   // def des facettes
   sort << "\n                 coordIndex [";
   for (int i=0;i< nb_iso_val-1;i++)
     { // on definit deux triangle pour chaque facette,
       sort << "\n                    "; //début de la face 1
       sort << i << ", " << i+nb_iso_val << ", " << i+1 << ", -1,";
       sort << "\n                    "; //début de la face 2
       sort << i+nb_iso_val << ", " << i+nb_iso_val+1 << ", " << i+1 << ", -1,";
       }
   // fin pour les faces 
   sort << "\n                ]";
   // definition des couleurs aux noeuds 
   // on sauvegarde puis modifie les min max pour les adapter au tracé de la légende
   double legende_min = spectre_coul.Valeur_mini();
   double legende_max = spectre_coul.Valeur_maxi();
   spectre_coul.Change_min_max(ptdeb(2),ptfin(2)) ;
   sort << "\n                 color Color {"
        << "\n                     color [";
   for (int i=1;i<= nb_iso_val;i++)
     { // récup de la couleur
       Rgb rgb = spectre_coul.CouleurVal(tab_pt(i)(2));
       sort << "\n                     " <<  rgb << ", ";
      } 
   for (int i=1;i<= nb_iso_val;i++)
     { // récup de la couleur
       Rgb rgb = spectre_coul.CouleurVal(tab_pt(i+nb_iso_val)(2));
       sort << "\n                     " <<  rgb << " , ";
      } 
    sort    << "\n                     ]"
            << "\n                 }";
    // remise normale du min max du spectre
    spectre_coul.Change_min_max(legende_min,legende_max) ;
            
    // on signal que l'on utilise une couleur par noeud (vertex)
    sort    << "\n                 colorPerVertex  TRUE";
    // on signal que l'on peut voir des deux cotés des facettes
    sort    << "\n                 solid FALSE";
   sort << "\n            }";
    // fin: on ferme l'entité forme
    sort << "\n         }";
    
    // maintenant on définit les valeurs de la légende
    // def d'un décalage suivant x de la légende couleur
    double decax = (ptfin(1) - ptdeb(1))/ 5.;        
    // on boucle sur les isovals
    double delta_val_y=(legende_max-legende_min)/(nb_iso_val-1);
    double val_iso=legende_min;
    for (int i=1;i<= nb_iso_val;i++)
     { // creation de la chaine de caractère qui contient la valeur de l'isovaleur
       ostrstream tab_out;
       #ifndef ENLINUX_STREAM
            tab_out.setf(ios_base::scientific);
       #else  
            tab_out.setf(ios::scientific); 
       #endif
       tab_out << setprecision(6) << val_iso << ends;
       // on définit une entité déplacé qui permet de ce positionner
       // aux coordonnées que l'on veut 
       sort << "\n        Transform {  #           X                   Y                 Z ";
       sort <<"\n              translation "
            << setw (16) << (tab_pt(i+nb_iso_val)(1) + decax) << " " 
            << setw (16) << tab_pt(i+nb_iso_val)(2) << " " 
            << setw (16) << 0 << " "; 
       // écrit la valeur
       sort   << "\n                children [";
       // def de l'entité forme
       sort << "\n          Shape { "
            << "\n                appearance Appearance {"
            << "\n                  material Material { }"
            << "\n                             }"
            << "\n             geometry Text {"
            << "\n             string \"" << tab_out.str() <<"\""
            << "\n               fontStyle FontStyle {size 10} "
            << "\n                 }} ] }";
       val_iso += delta_val_y;     
      }
   // définition du titre du travail
   sort << "\n        Transform {  #           X                   Y                 Z ";
   sort <<"\n              translation "
            << setw (16) << -10 << " " 
            << setw (16) << -10<< " " 
            << setw (16) << 0 << " "; 
   // écrit le texte
   sort   << "\n                children [";
   // def de l'entité forme
   sort << "\n          Shape { "
            << "\n                appearance Appearance {"
            << "\n                  material Material { }"
            << "\n                             }"
            << "\n             geometry Text {"
            << "\n             string \"" << "Herezh++  V" << ParaGlob::NbVersion()<<" \""
            << "\n               fontStyle FontStyle {size 10} "
            << "\n                 }} ] }";
    // définition du nom del'isovaleur
   sort << "\n        Transform {  #           X                   Y                 Z ";
   sort <<"\n              translation "
            << setw (16) << -28 << " " 
            << setw (16) << -18<< " " 
            << setw (16) << 0 << " "; 
   // écrit le texte
   sort   << "\n                children [";
   // def de l'entité forme
   sort << "\n          Shape { "
            << "\n                appearance Appearance {"
            << "\n                  material Material { }"
            << "\n                             }"
            << "\n             geometry Text {"
            << "\n             string \"" << "isovaleur de " ;
    if (type_ddl_retenu.Taille() != 0) 
             sort << type_ddl_retenu(1); //.Nom();            
    sort    << " \""
            << "\n               fontStyle FontStyle {size 10} "
            << "\n                 }} ] }";
       
  // et on vide le buffer de sortie
  sort << endl; 
  };
  
    
// définition interactives des paramètres généraux des isovaleurs
void Isovaleurs_vrml::ParametresGeneraux()
 { bool choix_valide = false;
   cout << "\n ----> preparation de la visualisation des isovaleurs"
        << "\n  parametre par defaut ? : affichage de la peau par facettes triangulaires,"
        << "\n                           ajout de la legende avec min_max automatique,"
        << "\n                           spectre standart, "
        << "   (rep 'o') pour accepter ces parametres sinon autre ";
   string rep;
   cout << "\n reponse ? "; rep = lect_return_defaut(true,"o");
   if (rep != "o") 
    {// cas d'un choix autre que standart
     while (!choix_valide)
      {
       try 
        { 
          cout 
          << "\n (0) fin modif"
          << "\n (1) plus visualisation interne             (2) calcul NON automatique des min max de la legende "
          << "\n (3) visualisation que des peaux            (4) calcul auto global des min max de la legende"
          << "\n (5) autres spectres                        (6) % auto sur l'incr des min max de la legende"
          << "\n (7) spectre standart                       (8) % auto sur tous les incr des min max de la legende"
          << "\n (9) nombre isovaleurs "
          << "\n (10) sortie des tenseurs dans le repere absolu (par defaut) "
          << "\n (11) sortie des tenseurs dans un repere ad hoc, qui depend du type d'element ";
          cout << "\n \n reponse ? ";
          rep = lect_return_defaut(false,"0");
          if (rep == "fin_prog") Sortie(1);
//          if ((rep == "0")||(rep == "f")||(rep == "fin")) return;
          // sinon
          int num = ChangeEntier(rep);
          if (num == 0) choix_valide=true;
          else if ((num >= 1)&&(num<=11))
           { choix_valide=false;
             switch (num)
              { case 1:  //"visualisation interne")
                { choix_peau = true; break;}
                case 2:  // "calcul NON automatique des min max de la légende")
                 {bool choixvalideLoc = false;
                  while (!choixvalideLoc)
                   {// on récupère les mini et maxi de la légende
                    cout << "\n actuellement les mini/maxi sont: " 
                         << " mini= " << spectre_coul.Valeur_mini() 
                         << " maxi= " << spectre_coul.Valeur_maxi();
                    cout << "\n differentes methodes pour modifier les extremes: "
                         << "\n donnez les valeurs explicitements des extremes   (rep 1)"
                         << "\n donnez en % de la plage actuelle des mini et maxi  (rep 2)"
                         << "\n    (dans ce dernier cas, modif a chaque increment)        "
                         << "\n laisser tel quel                                   (rep f ou 0 ou fin)";
                    cout << "\n \n reponse ? ";
                    string reploc; reploc = lect_return_defaut(false,"f");
                    if (reploc == "1")
                     {cout << "\n donner le mini et le maxi de la legende (2 reels)  ";
                      double legende_min,legende_max; // min max de la légende
                      cin >> legende_min >> legende_max;
                      std::cin.ignore( std::numeric_limits<std::streamsize>::max(), '\n' );// purge de cin
                      if ( legende_max < legende_min)
                        {cout << "\n donnees non valides, le maxi doit etre superieur au mini !! ";
                         choixvalideLoc=false;
                         }
                      else  
                       {choix_min_max = 0;
                        spectre_coul.Change_min_max(legende_min,legende_max) ;
                        choixvalideLoc = true;
                        };
                       }
                    else if (reploc == "2")    
                      {cout << "\n donner le mini et le maxi en % de la plage (2 reels)  ";
                      double pr_legende_min,pr_legende_max; // min max de la légende
                      cin >> pr_legende_min >> pr_legende_max;
                      std::cin.ignore( std::numeric_limits<std::streamsize>::max(), '\n' );// purge de cin
                      if ( pr_legende_max < pr_legende_min)
                        {cout << "\n donnees non valides, le maxi doit etre superieur au mini !! ";
                         choixvalideLoc=false;
                         }
                      else  
                       {choix_min_max = 0;
                        double leg_min=spectre_coul.Valeur_mini() + 
                                       (spectre_coul.Valeur_maxi()-spectre_coul.Valeur_mini())
                                         * pr_legende_min/100.;
                        double leg_max=spectre_coul.Valeur_mini() + 
                                       (spectre_coul.Valeur_maxi()-spectre_coul.Valeur_mini())
                                         * pr_legende_max/100.;
                        spectre_coul.Change_min_max(leg_min,leg_max) ;
                        cout << "\n nouvelles valeurs: mini= " <<leg_min << " maxi= " <<leg_max <<" ";  
                        choixvalideLoc=true;
                        };
                       } 
                     else if ((reploc == "f")||(reploc == "0")||(reploc == "fin"))
                       { choixvalideLoc=true;}
                     else 
                       { cout << "\n erreur d'entree, recommencez ";
                         choixvalideLoc=false;
                         };
                     };       
                    break;
                  }
                case 3:  // "visualisation que des peaux")
                { choix_peau = false; break;}
                case 4:  // "calcul automatique des min max de la légende")
                { choix_min_max = 1; break;}
                case 5:  // "autres spectres")
                { // on récupère les différents spectres
                  const Tableau <string> & tab_spectre = Spectre::Description_spectres_disponibles();
                  int nb_spectre= tab_spectre.Taille();
                  bool choix_val = false;
                  cout << "\n donner un choix de spectre";
                  while (!choix_val)
                   { 
                    try 
                     { cout << "\n (0) fin modif spectre";
                       for (int i=1;i<=nb_spectre;i++)
                         cout << "\n ("<<i<<")  " << tab_spectre(i);
                       cout << "\n \n reponse ? ";
                       rep = lect_return_defaut(false,"0");
                       if (rep == "fin_prog") Sortie(1);
                       // sinon
                       int nim = ChangeEntier(rep);
                       if (nim == 0) choix_val=true;
                       else if ((nim >= 1)&&(nim<=nb_spectre)) 
                         { choix_val=false;
                           spectre_coul.Change_spectre_courant(Spectre::EnumType_spectre(nim));
                          } 
                       else
                          {  cout << "\n ERREUR *** choix non valide :on attendait un nombre entre  0 et "<< nb_spectre
                                  << "\n redonnez une bonne valeur ****** \n \n ";
                             choix_val=false;
                           }                          
                       }
                    catch (ErrSortieFinale)
                         // cas d'une direction voulue vers la sortie
                         // on relance l'interuption pour le niveau supérieur
                       { ErrSortieFinale toto;
                         throw (toto);
                       }
                    catch (...)// erreur en lecture
                     {  cout << "\n Erreur on attendait un des mots cles proposes !!, "
                             << "\n redonnez une bonne valeur"
                             << "\n ou taper fin_prog pour arreter le programme"; 
                        choix_val=false;
                      }
                    } //-- fin du while  
                 break;}
                case 6:  // "calcul automatique en % pour chaque incre des min max de la légende")
                { cout << "\n donner le mini et le maxi en % de la plage de l'increment (2 reels)  ";
                  double pr_legende_min,pr_legende_max; // min max de la légende
                  cin >> pr_legende_min >> pr_legende_max;
                  std::cin.ignore( std::numeric_limits<std::streamsize>::max(), '\n' );// purge de cin
                  if ( pr_legende_max < pr_legende_min)
                      {cout << "\n donnees non valides, le maxi doit etre superieur au mini !! ";}
                  else  
                       {choix_min_max = 2;
                        pour_legende_min=pr_legende_min;pour_legende_max=pr_legende_max;
                        cout << "\n %lu (util pour chaque incr): mini= " <<pour_legende_min 
                             << " maxi= " <<pour_legende_max <<" ";  
                        };
                  break;
                  }
                case 7:  // "spectre standart")
                { spectre_coul.Change_spectre_courant(Spectre::EnumType_spectre(1));
                  break;}
                case 8:  // "calcul automatique en % global des min max de la légende")
                { cout << "\n donner le mini et le maxi en % de la plage de l'increment (2 reels)  ";
                  double pr_legende_min,pr_legende_max; // min max de la légende
                  cin >> pr_legende_min >> pr_legende_max;
                  std::cin.ignore( std::numeric_limits<std::streamsize>::max(), '\n' );// purge de cin
                  if ( pr_legende_max < pr_legende_min)
                      {cout << "\n donnees non valides, le maxi doit etre superieur au mini !! ";}
                  else  
                       {choix_min_max = 3;
                        pour_legende_min=pr_legende_min;pour_legende_max=pr_legende_max;
                        cout << "\n %lu (util pour tous les incr): mini= " <<pour_legende_min 
                             << " maxi= " <<pour_legende_max <<" ";  
                        };
                  break;
                  }
                case 9:  // "nombre d'isovaleurs")
                { bool choix_val = false;
                  int inter_int;
                  cout << "\n le nombre actuel est : " << nb_iso_val;
                  while (!choix_val)
                   { 
                    try 
                     { cout << "\n donnez une nouvelle valeur entre 2 et 100 ou 0  pour laisser en l'etat";
                       cout << "\n \n valeur ? ";
                       inter_int=(int)lect_double();
                       if (inter_int == 0) choix_val = true;
                       // sinon
                       else if ((inter_int <= 2) || (inter_int > 100)) 
                         cout << "\n le nombre d'isovaleur doit etre strictement superieur a 2 et"
                              << "inferieur ou egal a 100";
                       else {nb_iso_val = inter_int;choix_val = true;}
                       }
                    catch (ErrSortieFinale)
                         // cas d'une direction voulue vers la sortie
                         // on relance l'interuption pour le niveau supérieur
                       { ErrSortieFinale toto;
                         throw (toto);
                       }
                    catch (...)// erreur en lecture
                     {  cout << "\n Erreur on attendait soit 0 pour garder la valeur precedente"
                             << " ou un nombre entre 2 et 100 !!, "
                             << "\n redonnez une bonne valeur";
                        choix_val=false;
                      }
                    } //-- fin du while  
                 break;}
			             case 10: { absolue = true; break;}
			             case 11: { absolue = false; break;}
              }
             } 
          else { cout << "\n Erreur on attendait un entier entre 0 et 9 !!, "
                      << "\n redonnez une bonne valeur"
                      << "\n ou taper fin_prog pour arreter le programme"; 
              choix_valide=false;
             }
         }    
       catch (ErrSortieFinale)
            // cas d'une direction voulue vers la sortie
            // on relance l'interuption pour le niveau supérieur
          { ErrSortieFinale toto;
            throw (toto);
          }
       catch (...)// erreur de lecture
       {  cout << "\n Erreur on attendait un des mots cles proposés !!, "
                      << "\n redonnez une bonne valeur"
                      << "\n ou taper fin_prog pour arreter le programme"; 
              choix_valide=false;
        }
       } //-- fin du while
    }      
  };

// choix de l'isovaleur à visualiser
void Isovaleurs_vrml::ChoixIsovaleur()
 { bool choix_valide = false;
   string rep;
   cout << "\n  choix de l'isovaleur a visualiser, on choisit une isovaleur maxi par maillage";
   int nbmail = tabnoeud_type_ddl.Taille();
   // update du tableau de ddl à visualiser si nécessaire
   if (type_ddl_retenu.Taille() != nbmail)
       type_ddl_retenu.Change_taille(nbmail);

   for (int imail = 1;imail<=nbmail;imail++)
     {choix_valide=false;
      while (!choix_valide) // premier while
      {
       try 
        { 
          cout << "\n (0 ou f ou fin) fin choix ddl ";
          cout << "\n listes de type de ddl a visualiser ";
          cout << "\n Maillage nb: " << imail << " liste des types de ddl disponibles "
                                     << "\n" << tabnoeud_type_ddl(imail);
          cout << "\n donner le ddl a visulaliser "
               << "\n reponse ?  ";
          rep = lect_return_defaut(false,"f");
          if (rep == "fin_prog") Sortie(1);
          // sinon
          if ((rep == "0") || (rep == "f") || (rep == "fin")) 
              choix_valide=true;
          else if (ExisteEnum_ddl(rep.c_str())) // test pour savoir si c'est vraiment un ddl
            { Enum_ddl enum_d = Id_nom_ddl(rep.c_str());
              Ddl_enum_etendu ddl_enu_etendue(enum_d);
              // on vérifie si le ddl existe dans la liste proposée
              if (Ddl_enum_etendu::Existe_dans_la_liste(tabnoeud_type_ddl(imail),ddl_enu_etendue))
                 {type_ddl_retenu(imail) = ddl_enu_etendue;}
              else
                 {cout << "\n ddl inexistant dans la liste proposee, recommencez";
                  choix_valide=false;
                  }
             }     
          }
        catch (ErrSortieFinale)
             // cas d'une direction voulue vers la sortie
             // on relance l'interuption pour le niveau supérieur
           { ErrSortieFinale toto;
             throw (toto);
           }
        catch (...)// erreur en lecture
          {  cout << "\n Erreur dans la lecture de ddl !!, "
                  << "\n redonnez une bonne valeur"
                  << "\n ou taper fin_prog pour arreter le programme"; 
             choix_valide=false;
           }
      } //-- fin du premier while 
     choix_valide=false; 
     while (!choix_valide)
      {
       try 
        { cout << "\n valeur du ddl ou variation entre t=0 et t (rep 1 ou 0 ) ? \n"
               << "\n reponse ?  ";
          rep = lect_1_0(false);
          if (rep == "1") {choix_var_ddl(imail)=true;choix_valide=true;}
          else if (rep == "0") {choix_var_ddl(imail)=false;choix_valide=true;}
          else 
           {cout << "\n mauvais choix, recommencez";choix_valide=false;}
          }
        catch (ErrSortieFinale)
             // cas d'une direction voulue vers la sortie
             // on relance l'interuption pour le niveau supérieur
           { ErrSortieFinale toto;
             throw (toto);
           }
        catch (...)// erreur en lecture
          {  cout << "\n Erreur dans le choix de la variation ou non des ddl !!, "
                  << "\n redonnez une bonne valeur";
             choix_valide=false;
           }
      } //-- fin du second while      
     }//-- fin de la boucle sur les maillages   
  };
  
// choix de grandeur existantes aux points d'intégrations et à ramener aux noeuds
// pour préparer une visualisation d'isovaleurs
void Isovaleurs_vrml::TransfertGrandeursPtIntegAuNoeud()
 { /*bool choix_valide = false;
   string rep;
   while (!choix_valide)
      {try 
        { cout 
          << "\n (0 ou f ou fin) fin modif"
          << "\n (1) definition des parametres generaux "
          << "\n (2) choix de l'isovaleur "
          << "\n (3) transferts aux noeuds de grandeurs existantes aux points d'integration";
          cout << "\n \n reponse ? ";
          cin >> rep;
          if (rep == "fin_prog") Sortie(1);
          // sinon
          int num = ChangeEntier(rep);
          if ((rep == "0")||(rep == "f")||(rep == "fin")) 
            { choix_valide=true; }
          else if ((num >= 1)&&(num<=3)) 
           { choix_valide=false;
             switch (num)
              { case 1:  //"definition des parametres generaux"
                { ParametresGeneraux(); break;}
                case 2:  // "choix de l'isovaleur"
                 {ChoixIsovaleur(); break;}
                case 3:  // "transferts aux noeuds de grandeurs existantes aux points d'integration"
                { choix_peau = false; break;}
                case 4:  // "calcul automatique des min max de la légende")
                { TransfertGrandeursPtIntegAuNoeud(); break;}
               }
             } 
          else { cout << "\n Erreur on attendait un entier entre 0 et 3 !!, "
                      << "\n redonnez une bonne valeur"
                      << "\n ou taper fin_prog pour arreter le programme"; 
              choix_valide=false;
             }
         }    
       catch (...)// erreur de lecture
       {  cout << "\n Erreur on attendait un des mots cles proposés !!, "
                      << "\n redonnez une bonne valeur"
                      << "\n ou taper fin_prog pour arreter le programme"; 
              choix_valide=false;
        }
       } //-- fin du while*/
  };