Herezh_dev/herezh_pp/Resultats/VRML/Deformees_vrml.cc

767 lines
38 KiB
C++
Raw Normal View History

// 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_vrml.h"
#include "CharUtil.h"
#include <iomanip>
#include <limits>
// CONSTRUCTEURS :
// par defaut
Deformees_vrml::Deformees_vrml () :
OrdreVisu("..........................................deformee"
,"visualisation des deformee","de")
,filaire(true),surface(true),numero(false)
,Rcoull(0.0),Gcoull(1.0),Bcoull(1.0)
,Rcoulf(1.0),Gcoulf(1.0),Bcoulf(0.0)
,Rcouln(1.0),Gcouln(0.0),Bcouln(0.0)
,amplification(1.)
,isovaleurs_vrml(NULL)
,tab_facette(),tab_arrete(),num_mail_incr()
,noms_matiere(),choix_mail(NULL)
,noms_couleurs()
{};
// constructeur de copie
Deformees_vrml::Deformees_vrml (const Deformees_vrml& ord) :
OrdreVisu(ord),filaire(ord.filaire)
,surface(ord.surface),numero(ord.numero)
,Rcoull(ord.Rcoull),Gcoull(ord.Gcoull),Bcoull(ord.Bcoull)
,Rcoulf(ord.Rcoulf),Gcoulf(ord.Gcoulf),Bcoulf(ord.Bcoulf)
,Rcouln(ord.Rcouln),Gcouln(ord.Gcouln),Bcouln(ord.Bcouln)
,amplification(ord.amplification)
,isovaleurs_vrml(ord.isovaleurs_vrml)
,tab_facette(ord.tab_facette),tab_arrete(ord.tab_arrete)
,num_mail_incr(ord.num_mail_incr)
,noms_matiere(),choix_mail(ord.choix_mail)
,noms_couleurs(ord.noms_couleurs)
{};
// DESTRUCTEUR :
Deformees_vrml::~Deformees_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 Deformees_vrml::ExeOrdre(ParaGlob * 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)
{ostream &sort = entreePrinc.Sort_princ_vrml();
// on boucle sur les maillages
int nbmail = tab_mail.Taille();
for (int im=1;im<=nbmail;im++)
{ int numMail=tab_mail(im);
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 vrml
//---------------------------------------------------------------------------------
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_vrml::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_vrml::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
//---------------------------------------------------------------------------------
// 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) ))
{// 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
}; //-- fin de la boucle sur les maillages
// et on vide le buffer de sortie
sort << endl;
}; // fin du cas actif 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 Deformees_vrml::ChoixOrdre()
{ // demande de précision
bool choix_valide = false;
cout << "\n ----> preparation de la visualisation des deformees"
<< "\n parametre par defaut ? : affichage en filaire, couleur cyan,"
<< "\n affichage des facettes, couleur jaune,"
<< "\n pas d'affichage de numeros, "
<< "\n amplification du deplacement = 1. "
<< " (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) en fillaire? (2) affichage des facettes ? "
<< "\n (3) affichage des numeros ? (4) couleur pour le filaire "
<< "\n (5) couleur pour les facettes (6) facteur d'amplification";
cout << "\n \n reponse ? ";
rep = lect_return_defaut(false,"0");
if (rep == "fin_prog") Sortie(1);
// sinon
int num = ChangeEntier(rep);
if (num == 0) choix_valide=true;
else if ((num >= 1)&&(num<=6))
{ choix_valide=false;
switch (num)
{ case 1: //"en filaire")
{ cout << "\n en fillaire (par defaut rep 'o') "
<< "ou pas de filaire (rep autre) ? ";
rep = lect_return_defaut(true,"o");
if (rep!= "o") filaire = false;
else filaire = true;
break;}
case 2: // "affichage des facettes ?")
{ cout << "\n affichage des facettes (par defaut rep 'o') "
<< "ou pas de facette (rep autre) ? ";
rep = lect_return_defaut(true,"o");
if (rep!= "o") surface = false;
else surface = true;
break;}
case 3: // "affichage des numéros ?")
{ cout << "\n affichage des numeros (non par defaut rep 'o') "
<< "ou on veut l'affichage des numéros (rep autre) ? ";
rep = lect_return_defaut(true,"o");
if (rep!= "o") numero = true;
else numero = false;
break;}
case 4: // "couleur pour le filaire?")
{ cout << "\n couleur pour le filaire au standard RGB : par defaut cyan (rep 'o') ";
rep = lect_return_defaut(false,"0");
if (rep != "o")
{ cout << "\n couleur au standard RGB (trois réels entre 0 et 1) ? ";
double Rco,Gco,Bco;
cin >> Rco >> Gco >> Bco;
std::cin.ignore( std::numeric_limits<std::streamsize>::max(), '\n' );// purge de cin
if ((Rco <= 1.)&& (Rco >= 0) && (Gco <= 1.)&& (Gco >= 0)
&&(Bco <= 1.)&& (Bco >= 0))
{ Rcoull = Rco; Gcoull = Gco; Bcoull = Bco;
}
else
{ cout << " \n *****choix non valide de couleur**** ";
}
}
else
{ Rcoull = 0; Gcoull = 1; Bcoull = 1;
}
break;}
case 5: // "couleur pour les facettes")
{ cout << "\n couleur au standard RGB pour les facettes : par defaut cyan (rep 'o') ";
rep = lect_return_defaut(false,"o");
if (rep != "o")
{ cout << "\n couleur au standard RGB (trois réels entre 0 et 1) ? ";
double Rco,Gco,Bco;
cin >> Rco >> Gco >> Bco;
std::cin.ignore( std::numeric_limits<std::streamsize>::max(), '\n' );// purge de cin
if ((Rco <= 1.)&& (Rco >= 0) && (Gco <= 1.)&& (Gco >= 0)
&&(Bco <= 1.)&& (Bco >= 0))
{ Rcoulf = Rco; Gcoulf = Gco; Bcoulf = Bco;
}
else
{ cout << " \n *****choix non valide de couleur**** ";
}
}
else
{ Rcoulf = 0; Gcoulf = 1; Bcoulf = 1;
}
break;}
case 6: // "facteur d'amplification")
{ cout << "\n facteur d'amplification : par defaut 1. (rep 'o') ";
rep = lect_return_defaut(false,"o");
if (rep != "o")
{ cout << "\n nouvelle valeur du facteur (un reels ) ? ";
amplification=lect_double();
}
else
amplification = 1.;
break;}
}
}
else { cout << "\n Erreur on attendait un entier entre 0 et 6 !!, "
<< "\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
} //-- fin du if (rep != "o") du départ c'est-à-dire du cas non standart
// appel de la méthode de la classe mère
OrdreVisu::ChoixOrdre();
};
// lecture des paramètres de l'ordre dans un flux
void Deformees_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_deformee")!=NULL)
{// sauvegarde des paramètres actuelles
bool filaire_s=filaire; bool surface_s=surface; bool numero_s = numero;
double Rcoull_s = Rcoull; double Gcoull_s=Gcoull; double Bcoull_s=Bcoull;
double Rcoulf_s = Rcoulf; double Gcoulf_s=Gcoulf; double Bcoulf_s=Bcoulf;
double Rcouln_s = Rcouln; double Gcouln_s=Gcouln; double Bcouln_s=Bcouln;
double amplification_s=amplification;
// essaie de lecture
try
{ string nom;
(*entreePrinc.entCVisu) >> nom ;
if (nom != "debut_deformee")
{ cout << "\n Erreur en lecture des parametres de deformee a partir d'un fichier .CVisu,"
<< " le premier enregistrement doit etre le mot clef: debut_deformee "
<< " on ne tiens pas compte des parametres fournies !! ";
}
else
{ // appel de l'ordre de la classe mère
OrdreVisu::Lect_para_OrdreVisu_general(entreePrinc);
while (nom != "fin_deformee")
{ (*entreePrinc.entCVisu) >> nom;
if (nom == "en_filaire") (*entreePrinc.entCVisu) >> filaire;
if (nom == "surface") (*entreePrinc.entCVisu) >> surface;
if (nom == "les_numeros") (*entreePrinc.entCVisu) >> numero;
if (nom == "couleurs_filaires_RGB")
(*entreePrinc.entCVisu) >> Rcoull >> Gcoull >> Bcoull;
if (nom == "couleurs_surfaces_RGB")
(*entreePrinc.entCVisu) >> Rcoulf >> Gcoulf >> Bcoulf;
if (nom == "couleurs_numeros_RGB")
(*entreePrinc.entCVisu) >> Rcouln >> Gcouln >> Bcouln;
if (nom == "amplification") (*entreePrinc.entCVisu) >> amplification;
entreePrinc.NouvelleDonneeCVisu();
}
}
}
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 de deformee a partir d'un fichier .CVisu,"
<< " on ne tiens pas compte des parametres fournies !! ";
// récup des infos sauvées
filaire=filaire_s; surface=surface_s; numero = numero_s;
Rcoull = Rcoull_s; Gcoull=Gcoull_s; Bcoull=Bcoull_s;
Rcoulf = Rcoulf_s; Gcoulf=Gcoulf_s; Bcoulf=Bcoulf_s;
Rcouln = Rcouln_s; Gcouln=Gcouln_s; Bcouln=Bcouln_s;
amplification=amplification_s;
if (ParaGlob::NiveauImpression() >= 4)
cout << "\n Deformees_vrml::Lecture_parametres_OrdreVisu(..";
}
}
};
// écriture des paramètres de l'ordre dans un flux
void Deformees_vrml::Ecriture_parametres_OrdreVisu(UtilLecture & entreePrinc)
{ // récup du flot
ostream & sort = (*(entreePrinc.Sort_CommandeVisu()));
// on commente le fonctionnement
sort << "\n # ----------------------------- definition des parametres de deformee: ---------------- "
<< "\n debut_deformee # un mot cle de debut de liste";
// appel de l'ordre de la classe mère
OrdreVisu::Ecrit_para_OrdreVisu_general(entreePrinc);
// on sort l'entête des paramètres
sort << "\n # les parametres avec des valeurs: (sur une meme ligne) ";
// puis la liste des paramètres
sort << "\n en_filaire " << filaire << " # en_filaire <0 ou 1> (indique si l'on veut le dessin en filaire)"
<< "\n surface " << surface << " # surface <0 ou 1> (indique si l'on veut le dessin des faces ou surfaces)"
<< "\n les_numeros " << numero << " # numero <0 ou 1> (indique si l'on veut le dessin des numeros)"
<< "\n # couleurs_filaires_RGB <3 réels> (indique la couleur en RGB du trace filaire)"
<< "\n couleurs_filaires_RGB " << Rcoull << " " << Gcoull << " " << Bcoull
<< "\n # couleurs_surfaces_RGB <3 réels> (indique la couleur en RGB du trace des surfaces)"
<< "\n couleurs_surfaces_RGB " << Rcoulf << " " << Gcoulf << " " << Bcoulf
<< "\n # couleurs_numeros_RGB <3 réels> (indique la couleur en RGB du trace des numeros)"
<< "\n couleurs_numeros_RGB " << Rcouln << " " << Gcouln << " " << Bcouln
<< "\n amplification " << amplification << " # amplification <1 réel> (indique le facteur d'amplification de la deformee par rapport au calcul)";
// fin
sort << "\n fin_deformee " << " # un mot cle de fin \n";
};