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

#include <iomanip>

    // CONSTRUCTEURS :
// par defaut
Mail_initiale_geomview::Mail_initiale_geomview () :
   Mail_initiale_vrml()
     {}; 
     
     // constructeur de copie 
Mail_initiale_geomview::Mail_initiale_geomview (const Mail_initiale_geomview& ord) :
    Mail_initiale_vrml(ord)
      {};
               
    // DESTRUCTEUR :
Mail_initiale_geomview::~Mail_initiale_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 Mail_initiale_geomview::ExeOrdre(ParaGlob * paraGlob,const Tableau <int>& tab_mail,LesMaillages * lesMail,bool ,LesReferences*
                      ,LesLoisDeComp* ,DiversStockage*,Charge*,LesCondLim*
//                      ,LesContacts*,Resultats*,ostream & sort,EnumTypeIncre type_incre,int incre
                      ,LesContacts*,Resultats*,UtilLecture & entreePrinc,OrdreVisu::EnumTypeIncre ,int incre
//                      ,bool animation)
                      ,bool,const map < string, const double * , std::less <string> >&
                      ,const List_io < TypeQuelconque >& listeVecGlob)
 {ostream &sort = entreePrinc.Sort_princ_geomview();
  // visualisation du maillage pointé si actif
  if ((actif)&&(incre==0))
  {// on boucle sur les maillages
   int nbmail = tab_mail.Taille();
   for (int im=1;im<=nbmail;im++)
    { int numMail=tab_mail(im);
      if ((surface)||(filaire)||(numero))
        // écriture d'une entete
         sort << "\n # ====================================="
              << "\n # |      dessin du maillage initiale  |"
              << "\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 initiale";
         // définition de la géométrie
         sort << "\n  (geometry facettes_in0-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);
                 // ecriture des coordonnee à 0 
                 sort <<"\n                        "
                      << setw (16);  noe.Coord0().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 Mail_initiale_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 initial"
              << "\n # -----------------------------------------------------------\n";
         }
      if (filaire)
       { 
         // quelques commentaires pour indiquer les arrêtes            
         sort << "\n # ------------------------------------------------------"
              << "\n # dessin des arretes des elements du maillage initiale";
         // définition de la géométrie
         sort << "\n  (geometry arretes_in0-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);
                 // ecriture des coordonnee à 0 
                 sort <<"\n                        "
                      << setw (16);  noe.Coord0().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 initial"
              << "\n # -----------------------------------------------------------\n";
       }                         
      if (numero) // cas d'une des numéros
       { cout << "\n **** erreur sortie des numeros de la frontiere du maillage iniaitle pas encore implante ****"
              << "\n Mail_initiale_geomview::ExeOrdre(..." << endl;
       };
    }; //-- fin boucle sur les maillages
                                 
   // et on vide le buffer de sortie
   sort << endl; 
    
  };//-- fin actif ou pas
 };