Herezh_dev/Resultats/Ext_visu/spectre.cc

196 lines
8.9 KiB
C++

// 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 "spectre.h"
// ---------------- def des grandeurs statiques ----------------
Rgb Spectre::spectre[7][8] = {
/*Standard */ {Bleu, Cyan, Vert, Jaune, Rouge},
/*ArcEnCiel*/ {Violet, Bleu, Cyan, Vert, Jaune, Rouge},
/*Thermique*/ {Noir, Bleu, Magenta, Rouge, Jaune, Blanc},
/*Maximum */ {Noir, Mag, Bleu2, Cyan2, Vert2, Jaune, Rouge, Blanc},
/*NoirBlanc*/ {Noir, Blanc},
/*Geo */ {Noir, Bleu, Cyan, Vert, Jaune, Rouge, Blanc, Noir},
/*Phaser */ {Bleu3, Cyan, Vert, Jaune, Rouge}};
Spectre::Initialisation_description_spectre::Initialisation_description_spectre()
{ description_spectre.Change_taille(7);
description_spectre(1) = " SPECTRE_STANDART: Bleu, Cyan, Vert, Jaune, Rouge ";
description_spectre(2) = " SPECTRE_ARCENCIEL: Violet, Bleu, Cyan, Vert, Jaune, Rouge ";
description_spectre(3) = " SPECTRE_THERMIQUE: Noir, Bleu, Magenta, Rouge, Jaune, Blanc ";
description_spectre(4) = " SPECTRE_MAXIMUM: Noir, Mag, Bleu2, Cyan2, Vert2, Jaune, Rouge, Blanc ";
description_spectre(5) = " SPECTRE_NOIRBLANC: Noir, Blanc ";
description_spectre(6) = " SSPECTRE_GEO: Noir, Bleu, Cyan, Vert, Jaune, Rouge, Blanc, Noir ";
description_spectre(7) = " SPECTRE_PHASER: Bleu3, Cyan, Vert, Jaune, Rouge ";
}
Tableau <string> Spectre::description_spectre; // initialisation par défaut de la description des spectres
Spectre::Initialisation_description_spectre Spectre::inti_spectre; // remplissage de la description des spectres
// ---------------- fin de l'intialisation des variables statiques ------------------
// constructeur par défaut
Spectre::Spectre() :
spectre_courant(5) // initialisations par défaut au spectre standart
,type_spectre(SPECTRE_STANDART)
,val_des_coul(5)
{ val_des_coul(1)=0.; val_des_coul(5)=1.;
delta_val= (val_des_coul(5)-val_des_coul(1))/4.;
double val_inter=val_des_coul(1);
for (int i=1;i<=5;i++)
{spectre_courant(i)=spectre[0][i-1]; val_des_coul(i)= val_inter; val_inter +=delta_val;}
}
// constructeur fonction d'un énuméré
Spectre::Spectre(EnumType_spectre type_spect,double val_min,double val_max) :
spectre_courant(),val_des_coul()
,type_spectre(type_spect)
{ int i1,j1max; // le premier indice de spectre et le maxi des éléments du spectre
switch (type_spectre)
{ case SPECTRE_STANDART: { i1=0;j1max=5;break;}
case SPECTRE_ARCENCIEL: { i1=1;j1max=6;break;}
case SPECTRE_THERMIQUE: { i1=2;j1max=6;break;}
case SPECTRE_MAXIMUM: { i1=3;j1max=8;break;}
case SPECTRE_NOIRBLANCN: { i1=4;j1max=2;break;}
case SPECTRE_GEO: { i1=5;j1max=8;break;}
case SPECTRE_PHASER: { i1=6;j1max=5;break;}
}
// def du spectre
spectre_courant.Change_taille(j1max);val_des_coul.Change_taille(j1max);
val_des_coul(1)=val_min;val_des_coul(j1max)=val_max;
delta_val= (val_max-val_min)/((double) (j1max-1));
double val_inter=val_des_coul(1);
for (int i=1;i<=j1max;i++)
{spectre_courant(i)=spectre[i1][i-1]; val_des_coul(i)= val_inter; val_inter +=delta_val;}
};
// constructeur de copie
Spectre::Spectre(const Spectre& spect) :
spectre_courant(spect.spectre_courant)
,type_spectre(spect.type_spectre)
,val_des_coul(spect.val_des_coul)
,delta_val(spect.delta_val)
{};
// ------------ Méthodes --------------------
// changement des valeurs min et max
void Spectre::Change_min_max(const double& val_min,const double& val_max)
{ if (val_min > val_max)
{ cout << "\n erreur, la valeur minimale " << val_min <<" est supérieur à la valeur maxi " << val_max
<< "\n Spectre::Change_min_max(double& val_min,double& val_max)";
Sortie(1);
}
int j1max= spectre_courant.Taille();
val_des_coul(1)=val_min;val_des_coul(j1max)=val_max;
delta_val= (val_max-val_min)/((double) (j1max-1)); double val_inter=val_min;
for (int i=1;i<=j1max;i++)
{val_des_coul(i)= val_inter; val_inter +=delta_val;}
};
// changement du spectre courant
void Spectre::Change_spectre_courant(EnumType_spectre type_spectre)
{ int i1,j1max; // le premier indice de spectre et le maxi des éléments du spectre
switch (type_spectre)
{ case SPECTRE_STANDART: { i1=0;j1max=5;break;}
case SPECTRE_ARCENCIEL: { i1=1;j1max=6;break;}
case SPECTRE_THERMIQUE: { i1=2;j1max=6;break;}
case SPECTRE_MAXIMUM: { i1=3;j1max=8;break;}
case SPECTRE_NOIRBLANCN: { i1=4;j1max=2;break;}
case SPECTRE_GEO: { i1=5;j1max=8;break;}
case SPECTRE_PHASER: { i1=6;j1max=5;break;}
}
// def du spectre
double val_min = val_des_coul(1); // sauve du mini
double val_max = val_des_coul(val_des_coul.Taille()); // sauv du maxi
spectre_courant.Change_taille(j1max);val_des_coul.Change_taille(j1max);
val_des_coul(1)=val_min;val_des_coul(j1max)=val_max;
delta_val= (val_max-val_min)/((double) (j1max-1));
double val_inter=val_des_coul(1);
for (int i=1;i<=j1max;i++)
{spectre_courant(i)=spectre[i1][i-1]; val_des_coul(i)= val_inter; val_inter +=delta_val;}
};
// Retourne le nom d'un type de spectre a partir de son identificateur de
// type enumere id_Type_spectre correspondant
char* Spectre::Nom_Type_Spectre (const Spectre::EnumType_spectre id_nom)
{ char* result="";
switch (id_nom)
{ case SPECTRE_STANDART : result="SPECTRE_STANDART";break;
case SPECTRE_ARCENCIEL : result="SPECTRE_ARCENCIEL";break;
case SPECTRE_THERMIQUE : result="SPECTRE_THERMIQUE";break;
case SPECTRE_MAXIMUM : result="SPECTRE_MAXIMUM";break;
case SPECTRE_NOIRBLANCN : result="SPECTRE_NOIRBLANCN";break;
case SPECTRE_GEO : result="SPECTRE_GEO";break;
case SPECTRE_PHASER : result="SPECTRE_PHASER";break;
default :
{cout << "\nErreur : valeur incorrecte du type EnumType_spectre !\n";
cout << "Spectre::Nom_Type_Spectre (const Spectre::EnumType_spectre id_nom) \n";
Sortie(1);}
};
return result;
};
// Retourne l'identificateur de type enumere associe au nom du type de spectre
Spectre::EnumType_spectre Spectre::Id_nom_TypeSpectre (const char* nom)
{ EnumType_spectre result;
if ( strcmp(nom,"SPECTRE_STANDART")==0 )result=SPECTRE_STANDART;
else if ( strcmp(nom,"SPECTRE_ARCENCIEL")==0 )result=SPECTRE_ARCENCIEL;
else if ( strcmp(nom,"SPECTRE_THERMIQUE")==0 )result=SPECTRE_THERMIQUE;
else if ( strcmp(nom,"SPECTRE_MAXIMUM")==0 )result=SPECTRE_MAXIMUM;
else if ( strcmp(nom,"SPECTRE_NOIRBLANCN")==0 )result=SPECTRE_NOIRBLANCN;
else if ( strcmp(nom,"SPECTRE_GEO")==0 )result=SPECTRE_GEO;
else if ( strcmp(nom,"SPECTRE_PHASER")==0 )result=SPECTRE_PHASER;
else
{ cout << "\nErreur : nom du degre de type de spectre inconnu ! ("
<< nom << ") \n";
cout << "EnumType_spectre Spectre::Id_nom_TypeSpectre (const char* nom_TypeSpectre) \n";
Sortie(1);
};
return result;
};
// définition d'une couleur en fonction d'une valeur numérique
// si la valeur est inférieure à la valeur mini du spectre, on retourne la valeur mini
// si la valeur est supérieure à la valeur maxi du spectre, on retourne la valeur maxi
Rgb Spectre::CouleurVal(const double& valx) const
{ int nbval=spectre_courant.Taille();
// traitement des extrèmes
// int ix = std::abs((valx-val_des_coul(1))/delta_val) + 1;
int ix = ((valx-val_des_coul(1))/delta_val) + 1;
if (ix < 1) return spectre_courant(1);
if (ix >= nbval) return spectre_courant(nbval);
// cas entre min et max
// la valeur est entre la couleur ix et ix+1
Rgb ret = ( (valx-val_des_coul(ix))/delta_val* spectre_courant(ix+1)
+ (val_des_coul(ix+1)-valx)/delta_val* spectre_courant(ix) );
return ret;
};