223 lines
10 KiB
C++
Executable file
223 lines
10 KiB
C++
Executable file
|
|
// 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 "Frontiere_initiale.h"
|
|
|
|
#include <iomanip>
|
|
#include "CharUtil.h"
|
|
#include <limits>
|
|
|
|
// CONSTRUCTEURS :
|
|
// par defaut
|
|
Frontiere_initiale::Frontiere_initiale () :
|
|
OrdreVisu("..............................frontieres initiales"
|
|
,"visualisation des frontieres initiales","fri")
|
|
,filaire(true),surface(true),numero(false)
|
|
,Rcoull(.425),Gcoull(0.0),Bcoull(.425)
|
|
,Rcoulf(1.0),Gcoulf(0.0),Bcoulf(1.0)
|
|
,Rcouln(1.0),Gcouln(1.0),Bcouln(0.0)
|
|
,taille_numero(0.2)
|
|
{};
|
|
|
|
// constructeur de copie
|
|
Frontiere_initiale::Frontiere_initiale (const Frontiere_initiale& 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)
|
|
,taille_numero(ord.taille_numero)
|
|
{};
|
|
|
|
// DESTRUCTEUR :
|
|
Frontiere_initiale::~Frontiere_initiale ()
|
|
{};
|
|
|
|
// 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 Frontiere_initiale::ExeOrdre(ParaGlob * ,const Tableau <int>& ,LesMaillages * ,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_vrml();
|
|
// visualisation du maillage pointé si actif
|
|
if ((actif)&&(incre==0))
|
|
{ cout << "\n *** ordre actuellement non defini *** "
|
|
<< "\n Frontiere_initiale::ExeOrdre( .... " << endl;
|
|
}
|
|
};
|
|
|
|
// 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 Frontiere_initiale::ChoixOrdre()
|
|
{// demande de précision
|
|
bool choix_valide = false;
|
|
cout << "\n ----> préparation de la visualisation des frontieres initiales"
|
|
<< "\n paramètre par défaut ? : affichage en filaire, couleur magenta,"
|
|
<< "\n et affichage des facettes, couleur violet,"
|
|
<< " \n pas d'affichage de numéros. "
|
|
<< " (rep 'o' ou 'f') pour accepter ces paramètres 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 numéros ? (4) couleur pour le filaire "
|
|
<< "\n (5) couleur pour les facettes (6) couleur pour les numeros";
|
|
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 numéros (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 mgenta (rep 'o') ";
|
|
rep = lect_return_defaut(true,"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))
|
|
{ Rcoull = Rco; Gcoull = Gco; Bcoull = Bco;
|
|
}
|
|
else
|
|
{ cout << " \n *****choix non valide de couleur**** ";
|
|
}
|
|
}
|
|
else
|
|
{ Rcoull = .425; Gcoull = 0.; Bcoull = .425;
|
|
}
|
|
break;}
|
|
case 5: // "couleur pour les facettes")
|
|
{ cout << "\n couleur au standard RGB pour les facettes : par defaut violet (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 = 1; Gcoulf = 0; Bcoulf = 1;
|
|
}
|
|
break;}
|
|
case 6: // "couleur pour les numerao")
|
|
{ cout << "\n couleur au standard RGB pour les numeraos : par defaut jaune (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))
|
|
{ Rcouln = Rco; Gcouln = Gco; Bcouln = Bco;
|
|
}
|
|
else
|
|
{ cout << " \n *****choix non valide de couleur**** ";
|
|
}
|
|
}
|
|
else
|
|
{ Rcouln = 1; Gcouln = 1; Bcouln = 0;
|
|
}
|
|
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 clés 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();
|
|
};
|
|
|
|
|