2014-05-19 22:43:59 +02:00
|
|
|
#include <math.h>
|
2014-05-20 20:00:32 +02:00
|
|
|
#include <fstream>
|
2014-05-19 22:43:59 +02:00
|
|
|
|
2014-05-19 17:37:00 +02:00
|
|
|
#define NOMBREOR 1.61803398875
|
|
|
|
|
2014-05-20 20:00:32 +02:00
|
|
|
ofstream journal("PILG-log.txt", ios::out | ios::trunc);
|
|
|
|
|
2014-05-19 17:37:00 +02:00
|
|
|
void presentation() {
|
Mise en utilisation des nouvelles commandes
Les commandes ajoutées dans le code sont désormais accessible depuis le programme, grâce à quelques modifications dans les différents arguments et beaucoup de copier/coller.
* Traitement de la commande
* Ajout des arguments valeur (v1), booléen (b1), texte (t1), fichier (f1), entree (e), sortie (s), composante (p)
* Toutes les valeurs (entier, floattant) sont désormais regroupées dans valeur
* Entree et sortie sont des fichiers qui seront lus et écrits (respectivement) sans conditions (pour une utilisation sans REPL)
* Ajout des commandes creer, ouvrir, sauver, trait, rectangle, cercle, disque, retourner, redimensionner, convRVB
* Ajout et modification de quelques codes d'erreur
* Corrections et améliorations diverses
2014-05-20 22:15:37 +02:00
|
|
|
cout << " ____ ___ _ ____ " << endl
|
|
|
|
<< "| _ \\ |_ _ || | / ___|" << endl
|
|
|
|
<< "| |_) | | | | | | | _ " << endl
|
|
|
|
<< "| __/ | | | |___ | |_| |" << endl
|
|
|
|
<< "|_| |___| |_____| \\____|" << endl;
|
2014-05-19 17:37:00 +02:00
|
|
|
}
|
|
|
|
|
2014-05-22 20:14:36 +02:00
|
|
|
typedef struct {
|
|
|
|
double t;
|
|
|
|
double s;
|
|
|
|
double l;
|
|
|
|
} TSL;
|
|
|
|
|
|
|
|
int rvb2tsl(Pixel entree, TSL &sortie) {
|
|
|
|
double min, max, r = (float) entree.r / entree.maxComposante,
|
|
|
|
v = (float) entree.v / entree.maxComposante,
|
|
|
|
b = (float) entree.b / entree.maxComposante;
|
|
|
|
min = r < v ? r : v;
|
|
|
|
min = min < b ? min : b;
|
|
|
|
max = r > v ? r : v;
|
|
|
|
max = max > b ? max : b;
|
|
|
|
sortie.l = (max + min) / 2;
|
|
|
|
|
|
|
|
if (max == min) {
|
|
|
|
sortie.s = 0;
|
|
|
|
sortie.t = NAN;
|
|
|
|
} else {
|
|
|
|
sortie.s = sortie.l < 0.5 ? (max - min) / (max + min) : (max - min) /
|
|
|
|
(2 - max - min);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (r == max) {
|
|
|
|
sortie.t = (v - b) / (max - min);
|
|
|
|
} else if (v == max) {
|
|
|
|
sortie.t = 2 + (b - r) / (max - min);
|
|
|
|
} else if (b == max) {
|
|
|
|
sortie.t = 4 + (r - v) / (max - min);
|
|
|
|
}
|
|
|
|
|
|
|
|
sortie.t *= 60;
|
|
|
|
|
|
|
|
if (sortie.t < 0) {
|
|
|
|
sortie.t += 360;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int tsl2rvb(TSL entree, Pixel &sortie) {
|
|
|
|
double t3[3], c[3], t2, t1;
|
|
|
|
|
|
|
|
while (entree.t < 0.0) {
|
|
|
|
entree.t += 360.0;
|
|
|
|
}
|
|
|
|
|
|
|
|
while (entree.t > 360.0) {
|
|
|
|
entree.t += -360.0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (entree.s == 0) {
|
2014-05-22 21:26:51 +02:00
|
|
|
fill_n(c, 3, entree.l);
|
2014-05-22 20:14:36 +02:00
|
|
|
} else {
|
|
|
|
fill_n(t3, 3, 0);
|
|
|
|
fill_n(c, 3, 0);
|
|
|
|
t2 = entree.l < 0.5 ? entree.l * (1 + entree.s) : entree.l + entree.s - entree.l
|
|
|
|
* entree.s;
|
|
|
|
t1 = 2 * entree.l - t2;
|
2014-05-22 21:26:51 +02:00
|
|
|
entree.t /= 360.0;
|
2014-05-22 20:14:36 +02:00
|
|
|
t3[0] = entree.t + 1 / 3.0;
|
|
|
|
t3[1] = entree.t;
|
|
|
|
t3[2] = entree.t - 1 / 3.0;
|
|
|
|
|
|
|
|
for (int i = 0; i <= 2; i++) {
|
|
|
|
if (t3[i] < 0) {
|
|
|
|
t3[i] += 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (t3[i] > 1) {
|
|
|
|
t3[i] -= 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (6 * t3[i] < 1) {
|
|
|
|
c[i] = t1 + (t2 - t1) * 6 * t3[i];
|
|
|
|
} else if (2 * t3[i] < 1) {
|
|
|
|
c[i] = t2;
|
|
|
|
} else if (3 * t3[i] < 2) {
|
|
|
|
c[i] = t1 + (t2 - t1) * ((2 / 3.0) - t3[i]) * 6;
|
|
|
|
} else {
|
|
|
|
c[i] = t1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-05-22 21:26:51 +02:00
|
|
|
sortie.r = c[0] * sortie.maxComposante;
|
|
|
|
sortie.v = c[1] * sortie.maxComposante;
|
|
|
|
sortie.b = c[2] * sortie.maxComposante;
|
2014-05-22 20:14:36 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-05-19 17:37:00 +02:00
|
|
|
Image imageDefaut() {
|
|
|
|
int dimY = 256, dimX = dimY * NOMBREOR, maxComposante = 255;
|
|
|
|
Image imageRoue(dimX, dimY, maxComposante, PILG_RVB);
|
2014-05-22 20:14:36 +02:00
|
|
|
int x, y;
|
|
|
|
TSL tsl;
|
2014-05-19 17:37:00 +02:00
|
|
|
Pixel pointRoue = imageRoue.g_pixelVide();
|
2014-05-22 20:14:36 +02:00
|
|
|
tsl.s = 1;
|
2014-05-20 20:00:32 +02:00
|
|
|
|
2014-05-19 17:37:00 +02:00
|
|
|
for (x = 0; x < dimX; x++) {
|
|
|
|
for (y = 0; y < dimY; y++) {
|
2014-05-22 20:14:36 +02:00
|
|
|
tsl.t = ((float) x / dimX) * 360;
|
|
|
|
tsl.l = 1 - ((float) y / dimY);
|
|
|
|
tsl2rvb(tsl, pointRoue);
|
2014-05-19 17:37:00 +02:00
|
|
|
imageRoue.s_pixel(x, y, pointRoue);
|
|
|
|
}
|
|
|
|
}
|
2014-05-20 20:00:32 +02:00
|
|
|
|
2014-05-19 17:37:00 +02:00
|
|
|
return imageRoue;
|
|
|
|
}
|
|
|
|
|
2014-05-20 20:00:32 +02:00
|
|
|
void afficherImage(Image image) {
|
2014-05-22 20:14:36 +02:00
|
|
|
#define MARGE 100
|
|
|
|
int x, y, r, v, b, eX, eY, echelle, contenableX, contenableY,
|
|
|
|
dimensionX = image.g_dimensionX(),
|
|
|
|
dimensionY = image.g_dimensionY(),
|
|
|
|
typeComposantes = image.g_typeComposantes();
|
2014-05-20 20:00:32 +02:00
|
|
|
float ratio = (255.0 / image.g_maxComposante());
|
|
|
|
Pixel pixel;
|
2014-05-22 20:14:36 +02:00
|
|
|
// Calcul de l'échelle
|
|
|
|
contenableX = (ecranX - MARGE) / dimensionX;
|
|
|
|
contenableY = (ecranY - MARGE) / dimensionY;
|
|
|
|
echelle = (contenableX > contenableY ? contenableY : contenableX);
|
|
|
|
echelle = (echelle > 0 ? echelle : 1);
|
|
|
|
dimensionX = dimensionX * echelle;
|
|
|
|
dimensionY = dimensionY * echelle;
|
|
|
|
// journal << "Fenêtre: Image(" << image.g_dimensionX() << ";" <<
|
|
|
|
// image.g_dimensionY() << "), Echelle(" << echelle << "), Fenetre(" <<
|
|
|
|
// dimensionX << ";" << dimensionY << ")" << endl;
|
2014-05-20 20:00:32 +02:00
|
|
|
|
|
|
|
if (fenetreOuverte && (dimensionX != fenetreDimensionX ||
|
|
|
|
dimensionY != fenetreDimensionY)) {
|
|
|
|
fermerFenetre();
|
|
|
|
}
|
|
|
|
|
|
|
|
ouvrirFenetre(dimensionX, dimensionY, "PILG");
|
|
|
|
|
|
|
|
for (x = 0; x < image.g_dimensionX(); x++) {
|
|
|
|
for (y = 0; y < image.g_dimensionY(); y++) {
|
|
|
|
image.g_pixel(x, y, pixel);
|
|
|
|
|
|
|
|
switch (typeComposantes) {
|
|
|
|
case PILG_BIN:
|
|
|
|
r = v = b = (pixel.n ? 255 : 0);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case PILG_NIV:
|
|
|
|
r = v = b = pixel.g * ratio;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case PILG_RVB:
|
|
|
|
r = pixel.r * ratio;
|
|
|
|
v = pixel.v * ratio;
|
|
|
|
b = pixel.b * ratio;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2014-05-22 20:14:36 +02:00
|
|
|
for (eX = 0; eX < echelle; eX++) {
|
|
|
|
for (eY = 0; eY < echelle; eY++) {
|
|
|
|
pointFenetre(x * echelle + eX, y * echelle + eY, r, v, b);
|
2014-05-20 20:00:32 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
afficherFenetre();
|
|
|
|
}
|
|
|
|
|
|
|
|
void messageErreur(string message) {
|
|
|
|
cerr << "Erreur : " << message << '.' << endl;
|
|
|
|
journal << "Erreur : " << message << '.' << endl;
|
|
|
|
}
|
|
|
|
|
2014-05-19 17:37:00 +02:00
|
|
|
int chaineVersEntier(string chaine, int &entier) {
|
|
|
|
entier = atoi(chaine.c_str());
|
2014-05-20 20:00:32 +02:00
|
|
|
|
2014-05-19 17:37:00 +02:00
|
|
|
if (entier == 0 && chaine != "0") {
|
|
|
|
return 1;
|
|
|
|
}
|
2014-05-20 20:00:32 +02:00
|
|
|
|
2014-05-19 17:37:00 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int chaineVersFlottant(string chaine, float &flottant) {
|
|
|
|
flottant = atof(chaine.c_str());
|
2014-05-20 20:00:32 +02:00
|
|
|
|
2014-05-19 17:37:00 +02:00
|
|
|
if (flottant == 0 && chaine != "0") {
|
|
|
|
return 1;
|
|
|
|
}
|
2014-05-20 20:00:32 +02:00
|
|
|
|
2014-05-19 17:37:00 +02:00
|
|
|
return 0;
|
|
|
|
}
|
2014-05-19 22:43:59 +02:00
|
|
|
|
|
|
|
int caraVersEntier(char cara) {
|
|
|
|
// int entier = (int) (0 << 8) + cara;
|
|
|
|
// entier = entier > 0 ? entier : 256+entier;
|
|
|
|
int i, entier = 0;
|
2014-05-20 20:00:32 +02:00
|
|
|
|
2014-05-19 22:43:59 +02:00
|
|
|
for (i = 0; i < 8; i++) {
|
|
|
|
entier += ((cara >> i) & 0x01) ? pow(2, i) : 0;
|
|
|
|
}
|
2014-05-20 20:00:32 +02:00
|
|
|
|
2014-05-19 22:43:59 +02:00
|
|
|
return entier;
|
|
|
|
}
|