[ALPHA] Fin du travail du 12/05/14

Des commandes qui fonctionnent vraiment ainsi quelques conversions entre types de composantes, cela suffit pour passer en alpha !
* Passage au stade d'alpha
Certaines commandes peuvent désormais être executées pleinement. On ne rajoutera pas de fonctionnalités (hormis les commandes) majeures.
* traitementImage.cpp
	* Mise en fonction de convBIN et convNIV
		* Correction de certaines erreurs
			* Travis devrait être content
		Note : convNIV et convRVB auront des valeurs par défaut en tant que maximum de composante, les fonctions n'étant pas très utiles à la base rien ne sert de les compliquer
	* Enième modification du type de fonctions
		* Resteront des int
		* Permet de prendre en compte les erreurs qui ne devraient normalement pas arriver
	* Passage de certaines lignes oubliées au formatteur
	* pivoter()
		* Suppression d'une stupidité mathématique (modulo 2π)
		(Semble plus rapide, sans raison apparente)
* analyseCommande.cpp
	* Les arguments sont désormais correctement analysés
	* pivoter, convBIN et convNIV peuvent désormais être appelé
	* Mise en fonction de chaineVersEntier()
	* Ajout de chaineVersFlottant()
	* Ajout de l'analyse de l'argument -angle
	* Ajout de l'analyse de l'argument -couleur
	* Ajout de messages d'erreurs correspondant à ce qui a été ennoncé précédement
This commit is contained in:
Geoffrey Frogeye 2014-05-13 22:23:45 +02:00
parent 425af05430
commit 1f5f2f9c91
6 changed files with 234 additions and 115 deletions

View file

@ -12,7 +12,7 @@ Nos noms complets et le nom du lycée sont masqués pour des raisons d'intimité
###Le programme ###Le programme
Ce programme est un éditeur basique d'images [PBM/PGM/PPM](http://fr.wikipedia.org/wiki/Portable_pixmap) sexécutant en ligne de commande. Ce programme est un éditeur basique d'images [PBM/PGM/PPM](http://fr.wikipedia.org/wiki/Portable_pixmap) sexécutant en ligne de commande.
*Version :* Prétotype *Version :* Alpha
*Status :* [![Build Status](https://travis-ci.org/GeoffreyFrogeye/PILG.svg?branch=master)](https://travis-ci.org/GeoffreyFrogeye/PILG) *Status :* [![Build Status](https://travis-ci.org/GeoffreyFrogeye/PILG.svg?branch=master)](https://travis-ci.org/GeoffreyFrogeye/PILG)

14
TODO.md
View file

@ -9,9 +9,9 @@
*Ordre donné à titre indicatif* *Ordre donné à titre indicatif*
* Fonction principale **C** * Fonction principale **C**
* Fonction d'analyse de commande **D** * Fonction d'analyse de commande **C**
* Analyse de la commande **C** * Analyse de la commande **C**
* Analyse des arguments **D** * Analyse des arguments **C**
* Execution des fonctions **C** * Execution des fonctions **C**
* Objets **C** * Objets **C**
* Fenêtre **C** * Fenêtre **C**
@ -35,18 +35,18 @@
* Luminosité **A** * Luminosité **A**
* Contraste **A** * Contraste **A**
* Dessin **D** * Dessin **D**
* Trait **D** * Trait **A**
* Rectangle **C** * Rectangle **C**
* Cercle **D** * Cercle **A**
* Disque **D** * Disque **A**
* Géométrie **D** * Géométrie **D**
* Zoomer * Zoomer
* Pivoter **C** * Pivoter **C**
* Retourner **D** * Retourner **D**
* Redimensionner **A** * Redimensionner **A**
* Conversion du mode **D** * Conversion du mode **D**
* Binaire **D** * Binaire **C**
* Niveaux de gris **D** * Niveaux de gris **C**
* Couleur **D** * Couleur **D**
* Aide * Aide
* Documentation * Documentation

View file

@ -3,7 +3,18 @@
#include <iostream> #include <iostream>
int chaineVersEntier(string chaine, int &entier) { int chaineVersEntier(string chaine, int &entier) {
entier = chaine[0]; entier = atoi(chaine.c_str());
if (entier == 0 && chaine != "0") {
return 1;
}
return 0;
}
int chaineVersFlottant(string chaine, float &flottant) {
flottant = atof(chaine.c_str());
if (flottant == 0 && chaine != "0") {
return 1;
}
return 0; return 0;
} }
@ -107,6 +118,7 @@ typedef struct Commande {
string fonction; string fonction;
int x1, x2, y1, y2; int x1, x2, y1, y2;
float angle;
string fichierEntree, fichierSortie; string fichierEntree, fichierSortie;
Pixel couleur; Pixel couleur;
// ... // ...
@ -126,34 +138,100 @@ int analyserDecoupe(Commande &commande, vector< string > decoupe, Image const &i
if (decoupe[i].at(0) == '-') { if (decoupe[i].at(0) == '-') {
if (decoupe[i] == "-x1" || decoupe[i] == "-x0" || decoupe[i] == "-x") { if (decoupe[i] == "-x1" || decoupe[i] == "-x0" || decoupe[i] == "-x") {
commande.argumentsPresents.push_back("x1"); commande.argumentsPresents.push_back("x1");
if (chaineVersEntier(decoupe[i+1], commande.x1)) { i++;
if (chaineVersEntier(decoupe[i], commande.x1)) {
return 3; return 3;
} }
i++;
} else if (decoupe[i] == "-y1" || decoupe[i] == "-y0" || decoupe[i] == "-y") { } else if (decoupe[i] == "-y1" || decoupe[i] == "-y0" || decoupe[i] == "-y") {
commande.argumentsPresents.push_back("y1"); commande.argumentsPresents.push_back("y1");
if (chaineVersEntier(decoupe[i+1], commande.y1)) { i++;
if (chaineVersEntier(decoupe[i], commande.y1)) {
return 3; return 3;
} }
i++;
} else if (decoupe[i] == "-x2") { } else if (decoupe[i] == "-x2") {
commande.argumentsPresents.push_back("x2"); commande.argumentsPresents.push_back("x2");
if (chaineVersEntier(decoupe[i+1], commande.x2)) { i++;
if (chaineVersEntier(decoupe[i], commande.x2)) {
return 3; return 3;
} }
i++;
} else if (decoupe[i] == "-y2") { } else if (decoupe[i] == "-y2") {
commande.argumentsPresents.push_back("y2"); commande.argumentsPresents.push_back("y2");
if (chaineVersEntier(decoupe[i+1], commande.y2)) { i++;
if (chaineVersEntier(decoupe[i], commande.y2)) {
return 3; return 3;
} }
i++;
} else if (decoupe[i] == "-couleur" || decoupe[i] == "-c") { } else if (decoupe[i] == "-couleur" || decoupe[i] == "-c") {
commande.argumentsPresents.push_back("couleur"); commande.argumentsPresents.push_back("couleur");
commande.couleur = image.g_pixelVide();
// Analyser deuxième partie
i++; i++;
commande.couleur = image.g_pixelVide();
switch (image.g_typeComposantes()) {
case PILG_BIN:
if (decoupe[i] == "b" || decoupe[i] == "1") {
commande.couleur.n = true;
} else if (decoupe[i] == "n" || decoupe[i] == "0") {
commande.couleur.n = false;
} else { } else {
return 4;
}
break;
case PILG_NIV:
int g;
if (!chaineVersEntier(decoupe[i], g)) {
return 3;
}
if (g > image.g_maxComposante()) {
return 5;
}
commande.couleur.g = g;
break;
case PILG_RVB:
int composante = 0;
string chaineCourante = "";
int entierCourant = 0;
for (int iS = 0; iS <= decoupe[i].length(); iS++) {
if (decoupe[i][iS] == ':' || iS == decoupe[i].length()) {
if (chaineVersEntier(chaineCourante, entierCourant)) {
return 3;
}
if (entierCourant > image.g_maxComposante()) {
return 5;
}
switch (composante) {
case 0:
commande.couleur.r = entierCourant;
break;
case 1:
commande.couleur.v = entierCourant;
break;
case 2:
commande.couleur.b = entierCourant;
break;
default:
return 6;
}
chaineCourante = "";
entierCourant = 0;
composante++;
} else {
chaineCourante += decoupe[i][iS];
}
}
if (composante != 3) {
return 6;
}
break;
}
if (!image.v_pixel(commande.couleur)) {
return 7;
}
} else if (decoupe[i] == "-angle" || decoupe[i] == "-a") {
commande.argumentsPresents.push_back("angle");
i++;
if (chaineVersFlottant(decoupe[i], commande.angle)) {
return 8;
}
} else {
cout << decoupe[i] << endl;
return 2; return 2;
} }
} else { } else {
@ -161,9 +239,9 @@ int analyserDecoupe(Commande &commande, vector< string > decoupe, Image const &i
} }
} }
for (int i = 0; i < commande.argumentsPresents.size(); i++) { // DEBUG // for (int i = 0; i < commande.argumentsPresents.size(); i++) { // DEBUG
cout << "Argument présent " << i << " = " << commande.argumentsPresents[i] << endl; // cout << "Argument présent " << i << " = " << commande.argumentsPresents[i] << endl;
} // }
return 0; return 0;
} }
@ -182,10 +260,31 @@ int executerCommande(Commande commande, Image &image) {
if (argumentPresent(commande, "x1") && argumentPresent(commande, "x2") if (argumentPresent(commande, "x1") && argumentPresent(commande, "x2")
&& argumentPresent(commande, "y1") && argumentPresent(commande, "y2") && argumentPresent(commande, "y1") && argumentPresent(commande, "y2")
&& argumentPresent(commande, "couleur")) { && argumentPresent(commande, "couleur")) {
rectangle(image, image, commande.x1, commande.y1, commande.x2, commande.y2, commande.couleur); if (rectangle(image, image, commande.x1, commande.y1, commande.x2, commande.y2, commande.couleur)) {
return 3;
}
} else { } else {
return 2; return 2;
} }
} else if (commande.fonction == "pivoter") {
if (argumentPresent(commande, "x1") && argumentPresent(commande, "y1")
&& argumentPresent(commande, "angle")) {
if (pivoter(image, image, commande.x1, commande.y1, commande.angle)) {
return 3;
}
} else {
return 2;
}
} else if (commande.fonction == "convBIN") {
if (convBIN(image, image)) {
return 3;
}
} else if (commande.fonction == "convNIV") {
if (convNIV(image, image)) {
return 3;
}
// } else if (commande.fonction == "convRVB") {
// convRVB(image, image);
} else { } else {
return 1; return 1;
} }
@ -205,18 +304,36 @@ void procederCommande(vector< string > decoupe, Image &image) {
case 2: case 2:
messageErreur("Arguments manquants"); messageErreur("Arguments manquants");
break; break;
case 3:
messageErreur("Erreur dans l'execution de la commande");
break;
default: default:
messageErreur("Impossible d'éxecuter la fonction"); messageErreur("Impossible d'éxecuter la fonction");
} }
break; break;
case 1: case 1:
messageErreur("Argument inconnu"); messageErreur("Un argument a été attendu et autre chose a été donné");
break; break;
case 2: case 2:
messageErreur("Argument inconnu"); messageErreur("Argument inconnu");
break; break;
case 3: case 3:
messageErreur("Impossible de comprendre un argument"); messageErreur("Un entier a été attendu et n'a pas été donné");
break;
case 4:
messageErreur("La couleur d'une image binaire doit être blanc (1) ou noir (0)");
break;
case 5:
messageErreur("La valeur d'une composante de couleur donnée est superieure au maximum de composante de l'image");
break;
case 6:
messageErreur("La couleur d'une image RVB possède trois composantes");
break;
case 7:
messageErreur("La couleur donnée n'est pas valide, la raison en est inconnue");
break;
case 8:
messageErreur("Un nombre décimal a été attendu et n'a pas été donné (le programme n'accepte que les points)");
break; break;
default: default:
messageErreur("Impossible d'analyser la commande"); messageErreur("Impossible d'analyser la commande");
@ -224,7 +341,7 @@ void procederCommande(vector< string > decoupe, Image &image) {
} }
} }
int boucleDeCommandes(Image image) { // REPL void boucleDeCommandes(Image image) { // REPL
bool continuer = true; bool continuer = true;
string commandeTexte; string commandeTexte;

View file

@ -51,6 +51,8 @@ Image imageDefaut() {
pointRoue.v = 0; pointRoue.v = 0;
pointRoue.b = maxComposante - substep; pointRoue.b = maxComposante - substep;
break; break;
default:
pointRoue.r = pointRoue.v = pointRoue.b = 0;
} }
// Dégradé vers le noir // Dégradé vers le noir

View file

@ -106,18 +106,16 @@ int main(int argc, char *args[]) {
cout << "PILG - Test" << endl; // Message d'entrée et de test cout << "PILG - Test" << endl; // Message d'entrée et de test
Image image = genererRoue(256, 128, 255); // Image image = genererRoue(256, 128, 255);
#define DIMENSIONS 256 #define DIMENSIONS 256
Image imageOriginale = genererRoue(DIMENSIONS, DIMENSIONS, 255); Image imageOriginale = genererRoue(DIMENSIONS, DIMENSIONS, 255);
Image image = imageOriginale.g_vide(); Image image = imageOriginale.g_vide();
// while(1) {
for (float i = 0; i < 2 * PI; i += 0.1) { for (float i = 0; i < 2 * PI; i += 0.1) {
pivoter(imageOriginale, image, DIMENSIONS/2, DIMENSIONS/2, i); pivoter(imageOriginale, image, DIMENSIONS/2, DIMENSIONS/2, i);
afficherImage(image); afficherImage(image);
} }
// }
// // Neige en dégradé // // Neige en dégradé

View file

@ -1,21 +1,25 @@
#include <math.h> #include <math.h>
#define PI 3.14159265359 #define PI 3.14159265359
#define MAXCOMPOSANTEDEFAUT 255
// Gestion de fichiers // Gestion de fichiers
void creer(Image &sortie, unsigned int dimensionX, unsigned int dimensionY, unsigned int maxComposante, PILG_Comp typeComposantes) { // Créer une image de dimensions X et Y int creer(Image &sortie, unsigned int dimensionX, unsigned int dimensionY, unsigned int maxComposante, PILG_Comp typeComposantes) { // Créer une image de dimensions X et Y
sortie = *new Image(dimensionX, dimensionY, maxComposante, typeComposantes); sortie = *new Image(dimensionX, dimensionY, maxComposante, typeComposantes);
return 0;
} }
void ouvrir(Image &sortie, string nomFichier) { // Ouvrir une image existante à partir du nom du fichier ***Geoffrey int ouvrir(Image &sortie, string nomFichier) { // Ouvrir une image existante à partir du nom du fichier ***Geoffrey
return 1;
} }
void sauver(Image entree, string nomFichier, bool ASCII, string commentaire) { // Sauvegarder l'image obtenue dans un nouveau fichier int sauver(Image entree, string nomFichier, bool ASCII, string commentaire) { // Sauvegarder l'image obtenue dans un nouveau fichier
return 1;
} }
void import(Image entree, Image &sortie, string nomFichier, int x, int y) { int importer(Image entree, Image &sortie, string nomFichier, int x, int y) {
// Image fichierImporte; // Image fichierImporte;
// sortie = entree // sortie = entree
// ouvrir(fichierImporte, nomFichier) // ouvrir(fichierImporte, nomFichier)
@ -25,10 +29,11 @@ void import(Image entree, Image &sortie, string nomFichier, int x, int y) {
// FinPour // FinPour
// FinPour // FinPour
return 1;
} }
// Couleur // Couleur
void teinte(Image entree, Image &sortie, float teinte) { // Change la teinte de l'image int teinte(Image entree, Image &sortie, float teinte) { // Change la teinte de l'image
// Si la teinte appartient à [0;1[ // Si la teinte appartient à [0;1[
// r1 = 0 // r1 = 0
// r2 = 1 // r2 = 1
@ -64,18 +69,20 @@ void teinte(Image entree, Image &sortie, float teinte) { // Change la teinte de
// pixel.b = b1+(b2-b1)*valeur // pixel.b = b1+(b2-b1)*valeur
// Fin Pour // Fin Pour
// Fin Pour // Fin Pour
return 1;
} }
void saturation(Image entree, Image &sortie, float saturation) { // Sature l'image int saturation(Image entree, Image &sortie, float saturation) { // Sature l'image
// Pour x = image.g_DimensionX() // Pour x = image.g_DimensionX()
// Pour y = image.g_DimensionY() // Pour y = image.g_DimensionY()
// Ajouter la variable saturation à chaque valeur de chaque pixel // Ajouter la variable saturation à chaque valeur de chaque pixel
// Ne pas dépasser le seuil limite MaxComposante !!! // Ne pas dépasser le seuil limite MaxComposante !!!
// Fin Pour // Fin Pour
// Fin Pour // Fin Pour
return 1;
} }
void luminosite(Image entree, Image &sortie, float luminosite) { // Augmente la luminosité de l'image int luminosite(Image entree, Image &sortie, float luminosite) { // Augmente la luminosité de l'image
// Pour x=0 à x=image.g_DimensionX() // Pour x=0 à x=image.g_DimensionX()
// Pour y=0 à y=image.g_DimensionY() // Pour y=0 à y=image.g_DimensionY()
// si image.g_typeComposante=1 // si image.g_typeComposante=1
@ -91,9 +98,10 @@ void luminosite(Image entree, Image &sortie, float luminosite) { // Augmente la
// Fin si // Fin si
// Fin Pour // Fin Pour
// Fin Pour // Fin Pour
return 1;
} }
void contraste(Image entree, Image &sortie, float contraste) { // Accentue les contrastes de l'image int contraste(Image entree, Image &sortie, float contraste) { // Accentue les contrastes de l'image
// pour x=0 à x=image.g_dimensionX() // pour x=0 à x=image.g_dimensionX()
// pour y=0 à y=image.g_DimensionY() // pour y=0 à y=image.g_DimensionY()
// si image.g_typeComposante=1 // si image.g_typeComposante=1
@ -107,10 +115,11 @@ void contraste(Image entree, Image &sortie, float contraste) { // Accentue les c
// Fin Pour // Fin Pour
return 1;
} }
// Dessin // Dessin
void trait(Image entree, Image &sortie, int x1, int y1, int x2, int y2, Pixel pixel) { // Dessine un trait d'un point (x1,y1) à un point (x2,y2) int trait(Image entree, Image &sortie, int x1, int y1, int x2, int y2, Pixel pixel) { // Dessine un trait d'un point (x1,y1) à un point (x2,y2)
// int x, y, dx, dy ; // int x, y, dx, dy ;
// float e, e(1,0), e(0,1) ; // valeur derreur et incréments // float e, e(1,0), e(0,1) ; // valeur derreur et incréments
// dy ← y2 - y1 ; // dy ← y2 - y1 ;
@ -127,9 +136,10 @@ void trait(Image entree, Image &sortie, int x1, int y1, int x2, int y2, Pixel pi
// fin si ; // fin si ;
// fin pour ; // fin pour ;
return 1;
} }
void rectangle(Image entree, Image &sortie, int x1, int y1, int x2, int y2, Pixel couleur) { int rectangle(Image entree, Image &sortie, int x1, int y1, int x2, int y2, Pixel couleur) {
sortie = entree; sortie = entree;
for (int x = x1; x <= x2; x++) { for (int x = x1; x <= x2; x++) {
for (int y = y1; y <= y2; y++) { for (int y = y1; y <= y2; y++) {
@ -137,9 +147,10 @@ void rectangle(Image entree, Image &sortie, int x1, int y1, int x2, int y2, Pixe
} }
} }
return 0;
} }
void cercle(Image entree, Image &sortie, int x0, int y0, int r, Pixel couleur) { int cercle(Image entree, Image &sortie, int x0, int y0, int r, Pixel couleur) {
// sortie=entree; // sortie=entree;
// pour x=0 à x=image.g_dimensionX() // pour x=0 à x=image.g_dimensionX()
// pour y=0 à y=image.g_dimensionY() // pour y=0 à y=image.g_dimensionY()
@ -148,9 +159,10 @@ void cercle(Image entree, Image &sortie, int x0, int y0, int r, Pixel couleur) {
// Fin si // Fin si
// fin pour // fin pour
// fin pour // fin pour
return 1;
} }
void disque(Image entree, Image &sortie, int x, int y, int r, Pixel couleur) { int disque(Image entree, Image &sortie, int x, int y, int r, Pixel couleur) {
// sortie=entree; // sortie=entree;
// pour x=0 à x=image.g_dimensionX() // pour x=0 à x=image.g_dimensionX()
// pour y=0 à y=image.g_dimensionY() // pour y=0 à y=image.g_dimensionY()
@ -159,14 +171,16 @@ void disque(Image entree, Image &sortie, int x, int y, int r, Pixel couleur) {
// Fin si // Fin si
// fin pour // fin pour
// fin pour // fin pour
return 1;
} }
// Geométrie // Geométrie
void zoom(Image entree, Image &sortie) { int zoom(Image entree, Image &sortie) {
return 1;
} }
void pivoter(Image entree, Image &sortie, int x0, int y0, float angle) { int pivoter(Image entree, Image &sortie, int x0, int y0, float angle) {
sortie = entree.g_vide(); sortie = entree.g_vide();
float xF, yF, angleF, xI, yI, angleI, h; float xF, yF, angleF, xI, yI, angleI, h;
Pixel pixel = entree.g_pixelVide(); Pixel pixel = entree.g_pixelVide();
@ -177,7 +191,7 @@ void pivoter(Image entree, Image &sortie, int x0, int y0, float angle) {
yI = y0; yI = y0;
} else { } else {
angleF = atan((yF - y0) / (xF - x0)); angleF = atan((yF - y0) / (xF - x0));
angleF = (xF-x0<0 ? angleF + PI : (yF-y0 ? angleF + 2*PI: angleF)); angleF = (xF - x0 < 0 ? angleF + PI : angleF);
angleI = angleF - angle; angleI = angleF - angle;
h = sqrt(pow(xF - x0, 2) + pow(yF - y0, 2)); h = sqrt(pow(xF - x0, 2) + pow(yF - y0, 2));
xI = cos(angleI) * h + x0; xI = cos(angleI) * h + x0;
@ -187,98 +201,86 @@ void pivoter(Image entree, Image &sortie, int x0, int y0, float angle) {
sortie.s_pixel((int) xF, (int) yF, pixel); sortie.s_pixel((int) xF, (int) yF, pixel);
} }
} }
return 0;
} }
void retourner(Image entree, Image &sortie, int rotation) { int retourner(Image entree, Image &sortie, int rotation) {
return 1;
} }
void redimensionner(Image entree, Image &sortie, int x1, int x2, int y1, int y2) { int redimensionner(Image entree, Image &sortie, int x1, int x2, int y1, int y2) {
// Image *nouvelle = new Image(x2-x1, y2-y1, entree.g_maxComposante(), entree.g_typeComposantes()); // sortie = *new Image(x2-x1, y2-y1, entree.g_maxComposante(), entree.g_typeComposantes());
// sortie = *nouvelle;
// pour x=x1 à x=x2 // pour x=x1 à x=x2
// pour y=y1 à y=y2 // pour y=y1 à y=y2
// sortie.s_pixel(x, y, entree.g_pixel(x+x1, y+y1)); // sortie.s_pixel(x, y, entree.g_pixel(x+x1, y+y1));
// FinPour // FinPour
// FinPour // FinPour
return 1;
} }
// Modification couleur // Modification couleur
void convBIN(Image entree, Image &sortie) { int convBIN(Image entree, Image &sortie) {
Pixel pixel; if (entree.g_typeComposantes() == PILG_BIN) {
switch(entrée.g_typeComposantes) {
case PILG_BIN:
sortie = entree; sortie = entree;
break; } else {
case PILG_NIV: sortie = *new Image(entree.g_dimensionX(), entree.g_dimensionY(), 0, PILG_BIN);
sortie = new Image(entree.g_dimensionX(), entree.g_dimensionY(), 0, PILG_BIN); Pixel pixelI, pixelF;
pixelI = entree.g_pixelVide();
pixelF = sortie.g_pixelVide(); pixelF = sortie.g_pixelVide();
for (int x = 0; x <= entree.g_dimensionX(); x++) { for (int x = 0; x <= entree.g_dimensionX(); x++) {
for (int y = 0; y <= entree.g_dimensionY(); y++) { for (int y = 0; y <= entree.g_dimensionY(); y++) {
entree.g_pixel(x, y, pixelI); entree.g_pixel(x, y, pixelI);
pixelF.n = (pixelI.g > entree.g_maxComposante/2); switch (entree.g_typeComposantes()) {
sortie.s_pixel(x, y, pixelF); case PILG_NIV:
pixelF.n = (pixelI.g > entree.g_maxComposante() / 2);
}
}
break; break;
case PILG_RVB: case PILG_RVB:
sortie = new Image(entree.g_dimensionX(), entree.g_dimensionY(), 0, PILG_BIN); pixelF.n = ((pixelI.r + pixelI.v + pixelI.b) / 3 > entree.g_maxComposante() / 2);
pixelI = entree.g_pixelVide();
pixelF = sortie.g_pixelVide();
for (int x = 0; x <= entree.g_dimensionX(); x++) {
for (int y = 0; y <= entree.g_dimensionY(); y++) {
entree.g_pixel(x, y, pixelI);
pixelF.n = ((pixelI.r + pixelI.v + pixelI.b)/3 > entree._maxComposante/2);
sortie.s_pixel(x, y, pixelF);
}
}
break; break;
default:
return 2;
}
sortie.s_pixel(x, y, pixelF);
} }
} }
}
return 0;
}
void convNIV(Image entree, Image &sortie) { int convNIV(Image entree, Image &sortie) {
Pixel pixel; if (entree.g_typeComposantes() == PILG_NIV) {
switch(entrée.g_typeComposantes) { sortie = entree;
case PILG_BIN: } else {
sortie = new Image(entree.n_dimensionX(), entree.n_dimensionY(), 0, PILG_BIN); sortie = *new Image(entree.g_dimensionX(), entree.g_dimensionY(), MAXCOMPOSANTEDEFAUT, PILG_NIV);
pixelI = entree.g_pixelVide(); Pixel pixelI, pixelF;
pixelF = sortie.g_pixelVide(); pixelF = sortie.g_pixelVide();
for (int x = 0; x <= entree.g_dimensionX(); x++) { for (int x = 0; x <= entree.g_dimensionX(); x++) {
for (int y = 0; y <= entree.g_dimensionY(); y++) { for (int y = 0; y <= entree.g_dimensionY(); y++) {
entree.g_pixel(x, y, pixelI); entree.g_pixel(x, y, pixelI);
switch (entree.g_typeComposantes()) {
case PILG_BIN:
pixelF.g = (pixelI.n ? sortie.g_maxComposante() : 0); pixelF.g = (pixelI.n ? sortie.g_maxComposante() : 0);
sortie.s_pixel(x, y, pixelF);
}
}
break;
case PILG_NIV:
sortie = entree;
break; break;
case PILG_RVB: case PILG_RVB:
sortie = new Image(entree.g_dimensionX(), entree.g_dimensionY(), 0, PILG_NIV); pixelF.g = (pixelI.r + pixelI.v + pixelI.b) / 3.0 / entree.g_maxComposante() * sortie.g_maxComposante();
pixelI = entree.g_pixelVide();
pixelF = sortie.g_pixelVide();
for (int x = 0; x <= entree.g_dimensionX(); x++) {
for (int y = 0; y <= entree.g_dimensionY(); y++) {
entree.g_pixel(x, y, pixelI);
pixelF.n = (pixelI.r + pixelI.v + pixelI.b)/3;
sortie.s_pixel(x, y, pixelF);
}
}
break; break;
default:
return 1;
}
sortie.s_pixel(x, y, pixelF);
}
}
}
return 0;
} }
void convRVB(Image entree, Image &sortie) { int convRVB(Image entree, Image &sortie) {
return 1;
} }
//Help //Help
void aide() { int aide() {
//Afficher le texte suivant : //Afficher le texte suivant :
return 1;
} }