// 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 "Increment_vrml.h"
#include <iomanip>
#include <algorithm>
#include "CharUtil.h"
#include <limits>
// CONSTRUCTEURS :
// par defaut
Increment_vrml::Increment_vrml () :
OrdreVisu(".........................choix numeros d'increment" // de 15 à 65=50 caracteres
,"definition d'un numero d'increment ou d'une liste de numero","cni")
,lis_inc(NULL),lis_sor()
{ // par défaut on active cet ordre avec l'incrément initial qui normalement existe
lis_sor.push_back(0);
// cout << "\n liste actuelle: debug ";
// list <int>::iterator ikk,ikkfin=lis_sor.end();
// for (ikk=lis_sor.begin();ikk!=ikkfin;ikk++) cout << *ikk << " ";
// cout << "\n fin *** liste actuelle: debug ";
OrdreVisu::ChoixOrdre();
};
// constructeur de copie
Increment_vrml::Increment_vrml (const Increment_vrml& ord) :
OrdreVisu(ord),lis_inc(ord.lis_inc),lis_sor(ord.lis_sor)
{
};
// DESTRUCTEUR :
Increment_vrml::~Increment_vrml ()
{};
// METHODES PUBLIQUES :
// choix de l'ordre
void Increment_vrml::ChoixOrdre()
{ // demande de précision
bool choix_valide = false;
list<int>::iterator ik,ikfin=lis_inc->end();
// on traite tout d'abord le cas où il n'y a pas d'incrément à visualiser
// dans ce dernier cas on arrête le traitement interactif
if(lis_inc->begin() == ikfin)
{ cout << "\n *** pas d'increment disponible en dehors de l'increment 0 mis par defaut !! ";
return;
}
// puis cas où il existe des incréments non nul
while (!choix_valide)
{try
{ cout << "\n liste actuelle: ";
list <int>::iterator ikk,ikkfin=lis_sor.end();
for (ikk=lis_sor.begin();ikk!=ikkfin;ikk++) cout << *ikk << " ";
cout << "\n liste des increments disponibles (en plus de l'increment 0 mis par defaut): ";
for (ik=lis_inc->begin();ik!=ikfin;ik++)
cout << *ik << " ";
cout << "\n parametre par defaut ? le dernier increment (rep 'o') pour accepter "
<< "\n (rep 'ac') pour laisser en l'etat"
<< "\n (sinon autre) \n";
string rep;
rep = lect_return_defaut(false,"o");
if (rep == "ac")
{ // on laisse en l'etat
cout << "\n aucun changement ";
choix_valide = true;
}
else if (rep != "o")
{
// On regarde tout d'abord si l'on veut des incréments en plus ou si l'on ne veut que
// les incréments que l'on va indiquer
cout << "\n voulez-vous effacer la liste actuelle qui est : ";
list <int>::iterator ik,ikfin=lis_sor.end();
for (ik=lis_sor.begin();ik!=ikfin;ik++) cout << *ik << " ";
cout << "\n rep 'o' pour effacer sinon autre (defaut)? ";
rep = lect_return_defaut(false,"n");
if (rep == "o") lis_sor.erase(lis_sor.begin(),lis_sor.end());
// définition des incréments
cout << "\n differentes options : "
<< "\n un increment rep : 1 "
<< "\n un interval d'increments par pas de 1 rep : 2 "
<< "\n un interval d'increments avec choix du pas "
<< "\n entre deux increment choisit rep : 3 "
<< "\n une liste d'increments rep : 4 "
<< "\n tous les increments rep : 5 "
<< "\n tous les increments sans l'increment 0 rep : 6 "
<< "\n le dernier increment (defaut) rep : 7 ";
rep = lect_return_defaut(false,"7");
if (rep != "7")
cout << "\n un premier chiffre negatif indique que c'est un increment a retirer (si possible)"
<< "\n par contre s'il est positif c'est un increment a ajouter (s'il n'existe pas deja)"
<< "\n les increments sont systematiquement ordonne en fin de traitement ";
if (rep== "1")
{ cout << "\n numero d'increment : ";
int irep; irep=(int)lect_double();
// on vérifie que l'incrément demandé est possible
ik = find(lis_inc->begin(),lis_inc->end(),abs(irep));
if (ik != lis_inc->end()) // cas ou l'incrément existe
{if (irep <= 0)
lis_sor.remove(abs(irep)); // suppression s'il existe
else
lis_sor.push_back(irep);
choix_valide = true;
}
}
else if (rep== "2")
{ cout << "\n increment de depart et increment de fin (deux entiers) : ";
int irep1,irep2; cin >> irep1 >> irep2;
std::cin.ignore( std::numeric_limits<std::streamsize>::max(), '\n' );// purge de cin
// on repère les deux bornes dans la liste
list<int>::iterator idep,ifin;
idep = find(lis_inc->begin(),lis_inc->end(),abs(irep1));
ifin = find(lis_inc->begin(),lis_inc->end(),abs(irep2));
if (!((idep!= lis_inc->end())&&(ifin!= lis_inc->end())))
{ cout << "erreur de borne (inexistantes ou pas dans le bon ordre ?) ";
choix_valide = false;
}
else
{ // on met à jour
ifin++;
for (ik=idep;ik!=ifin;ik++)
{if (irep1 >= 0)
lis_sor.push_back(*ik);
else
lis_sor.remove(*ik); // suppression s'il existe
}
choix_valide = true;
}
}
else if (rep== "3")
{ cout << "\n increment de depart et increment de fin (deux entiers) : ";
int irep1,irep2; cin >> irep1 >> irep2;
std::cin.ignore( std::numeric_limits<std::streamsize>::max(), '\n' );// purge de cin
cout << "\n pas entre deux increments consecutifs (un entier) : ";
int pas_inc; pas_inc=(int)lect_double(); pas_inc = abs(pas_inc);
// on repère les deux bornes dans la liste
list<int>::iterator idep,ifin;
idep = find(lis_inc->begin(),lis_inc->end(),abs(irep1));
ifin = find(lis_inc->begin(),lis_inc->end(),abs(irep2));
if (!((idep!= lis_inc->end())&&(ifin!= lis_inc->end())))
{ cout << "erreur de borne (inexistantes ou pas dans le bon ordre ?) ";
choix_valide = false;
}
else
{ // on positionne la fin suivant le standard stl
ifin++;
// init de ik
ik = idep;
// traitement
while(ik!=ifin)
{ // enregistrement ou effacement
if (irep1 >= 0)
lis_sor.push_back(*ik);
else
lis_sor.remove(*ik); // suppression s'il existe
// incrémentation du pointeur d'incrément
for (int i=1;i<= pas_inc;i++)
{if (ik != ifin)
ik++;}
// on a atteind la borne sup arrêt d'incrémentation
}
choix_valide = true;
}
}
else if (rep == "4")
{ cout << "\nl'entree d'une liste d'increment s'effectue numero par numero ";
int irep = -1; float x_ent;
do
{ cout << "\n un numero ? (un nombre flottant (ex 1.2)pour finir) : ";
x_ent=(float)lect_double(); irep = (int) Abs(x_ent);
// vérification si le numéro est acceptable
list<int>::iterator idep;
idep = find(lis_inc->begin(),lis_inc->end(),abs(irep));
if ((idep== lis_inc->end()))
{ cout << "\n numero non acceptable cf la liste : ";
for (ik=lis_inc->begin();ik!=ikfin;ik++)
cout << *ik << " ";
cout << "\n recommencez ";
irep = -20;
}
else
{ if (irep >= 0)
lis_sor.push_back(irep);
else
lis_sor.remove(abs(irep)); // suppression s'il existe
choix_valide = true;
}
} while (x_ent == (float) irep);
}
else if (rep == "5")
{ list<int>::iterator idepfin = lis_sor.end();
list<int>::iterator idepdebut = lis_sor.begin();
// on commence par effacer la liste actuelle
lis_sor.erase(idepdebut,idepdebut);
// on rempli la liste finale
lis_sor=(*lis_inc);
choix_valide = true;
}
else if (rep == "6")
{ list<int>::iterator idepfin = lis_sor.end();
list<int>::iterator idepdebut = lis_sor.begin();
// on commence par effacer la liste actuelle
lis_sor.erase(idepdebut,idepfin);
// on rempli la liste finale
lis_sor=(*lis_inc);
// on supprime le premier
idepdebut = lis_sor.begin();
lis_sor.erase(idepdebut);
choix_valide = true;
}
else if (rep == "7")
{ // on commence par effacer la liste actuelle
lis_sor.erase(lis_sor.begin(),lis_sor.end());
// on ajoute l'incrément finale
list<int>::const_iterator idepdernier = lis_inc->end();idepdernier--;
lis_sor.push_back(*idepdernier);
choix_valide = true;
}
else
{ cout << "\n choix non valide";
choix_valide = false;
}
}
else
{ // cas ou l'on retiend l'incrément par défaut c'est-à-dire le dernier
// on regarde s'il est déjà enregistré sinon on l'ajoute à la liste de sortie
list <int>::iterator ider = ikfin; ider--; int derIncr= *ider;
list<int>::iterator ipos = find(lis_sor.begin(),lis_sor.end(),derIncr);
if (ipos == lis_sor.end())
lis_sor.push_back(derIncr);
choix_valide = true;
}
} //-- 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 increments, recommencer";
choix_valide = false;
}
} // -- fin du while
// on ordonne la liste puis on supprime les doublons enfin on l'afficher
Propre_liste(lis_sor);
// appel de la méthode de la classe mère
OrdreVisu::ChoixOrdre();
};
// initialisation de la liste à l'incrément 0 et au dernier increment
// s'il est différent
void Increment_vrml::Init_list_inc_DebuEtFin()
{ // on efface la liste actuelle
lis_sor.erase(lis_sor.begin(),lis_sor.end());
lis_sor.push_back(0);
if (lis_inc != NULL)
{ list <int>::iterator ilifin=lis_inc->end();
if (*ilifin != 0) lis_sor.push_back(*ilifin);
};
};
// lecture des paramètres de l'ordre dans un flux
void Increment_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_list_increment")!=NULL)
{// sauvegarde de la liste actuelle
list <int> liste_sauve = lis_sor;
// essaie de lecture
try
{ string nom;
(*entreePrinc.entCVisu) >> nom ;
if (nom != "debut_list_increment")
{ cout << "\n Erreur en lecture des increments a partir d'un fichier .CVisu,"
<< " le premier enregistrement doit etre le mot clef: debut_list_increment "
<< " on ne tiens pas compte de la liste fournie !! ";
}
else
{// appel de l'ordre de la classe mère
OrdreVisu::Lect_para_OrdreVisu_general(entreePrinc);
// on efface la liste actuelle
lis_sor.erase(lis_sor.begin(),lis_sor.end());
// maintenant on n'intervient que s'il y a une liste d'incrément disponible
if (lis_inc != NULL)
{// lecture de la liste demandée
if (strstr(entreePrinc.tablcarCVisu,"tous_les_increments_moins_zero")!=NULL)
{ // cas où on veut tous les incréments
lis_sor = (*lis_inc);
if ((lis_sor.size() != 0) && (*(lis_sor.begin()) == 0))
lis_sor.erase(lis_sor.begin());
}
else if (strstr(entreePrinc.tablcarCVisu,"tous_les_increments")!=NULL)
{ // cas où on veut tous les incréments disponibles
lis_sor = (*lis_inc);
}
else if (strstr(entreePrinc.tablcarCVisu,"dernier_increment")!=NULL)
{ // cas où on veut le dernier incrément
list <int>::iterator iincre = lis_inc->end();
if (lis_inc->size() != 0)
{ iincre--;
lis_sor.push_back(*iincre);
};
}
else
{ // cas de la lecture d'une liste différentes de tous les incréments
int compteur=0; // pour éviter une boucle infinie
int nb_lue_sur_ligne = 0;
while (compteur < 1000000)
{ (*entreePrinc.entCVisu) >> nom; compteur++;nb_lue_sur_ligne++;
if (nom != "fin_list_increment")
{ // on vérifie que l'incrément demandé est possible
int inc=ChangeEntier(nom);
list <int>::iterator ik = find(lis_inc->begin(),lis_inc->end(),inc);
if (ik != lis_inc->end()) // cas ou l'incrément existe
{ lis_sor.push_back(inc);}
else
{ cout << "\n Erreur en lecture de l'increments "<< nom <<" il n'appartient pas a la liste"
<< " d'increment possible ON N'EN TIENT PAS COMPTE !! ";}
if (nb_lue_sur_ligne > 50)
{ nb_lue_sur_ligne=0;entreePrinc.NouvelleDonneeCVisu();}
}
else break;
}
}//-- fin de la lecture d'une liste différentes de tous les incréments
}
else // sinon on met l'incrément 0 par défaut
{lis_sor.push_back(0);
};
};
}
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 increments a partir d'un fichier .CVisu,"
<< " on ne tiens pas compte de la liste fournie !! ";
lis_sor=liste_sauve; // récup de la liste sauvée
if (ParaGlob::NiveauImpression() >= 4)
cout << "\n Increment_vrml::Lecture_parametres_OrdreVisu(..";
}
// on passe à un nouvel enregistrement
entreePrinc.NouvelleDonneeCVisu();
}
};
// écriture des paramètres de l'ordre dans un flux
void Increment_vrml::Ecriture_parametres_OrdreVisu(UtilLecture & entreePrinc)
{ // récup du flot
ostream & sort = (*(entreePrinc.Sort_CommandeVisu()));
// on commente le fonctionnement
sort << "\n # ----------------------------- definition de la liste des increments a balayer: ---------------- "
<< "\n debut_list_increment # un mot cle de debut de liste ";
// appel de l'ordre de la classe mère
OrdreVisu::Ecrit_para_OrdreVisu_general(entreePrinc);
// puis la liste des incréments
sort << "\n # une liste d'entier separee par des blancs, ou le mot cle (tous_les_increments) "
<< "\n # un mot cle de fin de liste ( fin_list_increment)"
<< "\n";
bool cas_simple=false;
if ( lis_sor == (*lis_inc))
{ sort << " tous_les_increments "; cas_simple=true;
}
// on regarde si c'est tous-les-incréments sans le premier incrément
// on crée une liste intermédiaire de travail
list <int> lis_sor_inter = lis_sor;
lis_sor_inter.push_front(*(lis_inc->begin()));// on rajoute le premier à la liste inter
if ( lis_sor_inter == (*lis_inc))
{ sort << " tous_les_increments_moins_zero "; cas_simple=true;
}
// on regarde si ce n'est pas uniquement le dernier incrément
if (lis_sor.size() > 0) // on ne regarde que si la liste n'est pas vide
{ list <int>::iterator iincre = lis_sor.end();iincre--;
if ((lis_sor.size() == 1) && (*(lis_sor.begin())== *iincre))
{sort << " dernier_increment "; cas_simple=true; }
};
if(!cas_simple)
{ // cas ou la liste est différente de la liste complète
// on sort la liste des incréments à balayer, par paquet de 100 maxi sur chaque ligne
list<int>::const_iterator ili,ilifin=lis_sor.end();
int compteur=0;
for (ili=lis_sor.begin();ili!=ilifin;ili++,compteur++)
{ sort << " " << (*ili); if (compteur > 50) {compteur = 0; sort << "\n";}}
}
sort << " fin_list_increment \n";
};