[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:
parent
425af05430
commit
1f5f2f9c91
|
|
@ -12,7 +12,7 @@ Nos noms complets et le nom du lycée sont masqués pour des raisons d'intimité
|
|||
###Le programme
|
||||
Ce programme est un éditeur basique d'images [PBM/PGM/PPM](http://fr.wikipedia.org/wiki/Portable_pixmap) s’exécutant en ligne de commande.
|
||||
|
||||
*Version :* Prétotype
|
||||
*Version :* Alpha
|
||||
|
||||
*Status :* [](https://travis-ci.org/GeoffreyFrogeye/PILG)
|
||||
|
||||
|
|
|
|||
14
TODO.md
14
TODO.md
|
|
@ -9,9 +9,9 @@
|
|||
*Ordre donné à titre indicatif*
|
||||
|
||||
* Fonction principale **C**
|
||||
* Fonction d'analyse de commande **D**
|
||||
* Fonction d'analyse de commande **C**
|
||||
* Analyse de la commande **C**
|
||||
* Analyse des arguments **D**
|
||||
* Analyse des arguments **C**
|
||||
* Execution des fonctions **C**
|
||||
* Objets **C**
|
||||
* Fenêtre **C**
|
||||
|
|
@ -35,18 +35,18 @@
|
|||
* Luminosité **A**
|
||||
* Contraste **A**
|
||||
* Dessin **D**
|
||||
* Trait **D**
|
||||
* Trait **A**
|
||||
* Rectangle **C**
|
||||
* Cercle **D**
|
||||
* Disque **D**
|
||||
* Cercle **A**
|
||||
* Disque **A**
|
||||
* Géométrie **D**
|
||||
* Zoomer
|
||||
* Pivoter **C**
|
||||
* Retourner **D**
|
||||
* Redimensionner **A**
|
||||
* Conversion du mode **D**
|
||||
* Binaire **D**
|
||||
* Niveaux de gris **D**
|
||||
* Binaire **C**
|
||||
* Niveaux de gris **C**
|
||||
* Couleur **D**
|
||||
* Aide
|
||||
* Documentation
|
||||
|
|
|
|||
|
|
@ -3,8 +3,19 @@
|
|||
#include <iostream>
|
||||
|
||||
int chaineVersEntier(string chaine, int &entier) {
|
||||
entier = chaine[0];
|
||||
return 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;
|
||||
}
|
||||
|
||||
void afficherImage(Image image) {
|
||||
|
|
@ -107,6 +118,7 @@ typedef struct Commande {
|
|||
string fonction;
|
||||
|
||||
int x1, x2, y1, y2;
|
||||
float angle;
|
||||
string fichierEntree, fichierSortie;
|
||||
Pixel couleur;
|
||||
// ...
|
||||
|
|
@ -126,34 +138,100 @@ int analyserDecoupe(Commande &commande, vector< string > decoupe, Image const &i
|
|||
if (decoupe[i].at(0) == '-') {
|
||||
if (decoupe[i] == "-x1" || decoupe[i] == "-x0" || decoupe[i] == "-x") {
|
||||
commande.argumentsPresents.push_back("x1");
|
||||
if (chaineVersEntier(decoupe[i+1], commande.x1)) {
|
||||
i++;
|
||||
if (chaineVersEntier(decoupe[i], commande.x1)) {
|
||||
return 3;
|
||||
}
|
||||
i++;
|
||||
} else if (decoupe[i] == "-y1" || decoupe[i] == "-y0" || decoupe[i] == "-y") {
|
||||
commande.argumentsPresents.push_back("y1");
|
||||
if (chaineVersEntier(decoupe[i+1], commande.y1)) {
|
||||
i++;
|
||||
if (chaineVersEntier(decoupe[i], commande.y1)) {
|
||||
return 3;
|
||||
}
|
||||
i++;
|
||||
} else if (decoupe[i] == "-x2") {
|
||||
commande.argumentsPresents.push_back("x2");
|
||||
if (chaineVersEntier(decoupe[i+1], commande.x2)) {
|
||||
i++;
|
||||
if (chaineVersEntier(decoupe[i], commande.x2)) {
|
||||
return 3;
|
||||
}
|
||||
i++;
|
||||
} else if (decoupe[i] == "-y2") {
|
||||
commande.argumentsPresents.push_back("y2");
|
||||
if (chaineVersEntier(decoupe[i+1], commande.y2)) {
|
||||
i++;
|
||||
if (chaineVersEntier(decoupe[i], commande.y2)) {
|
||||
return 3;
|
||||
}
|
||||
i++;
|
||||
} else if (decoupe[i] == "-couleur" || decoupe[i] == "-c") {
|
||||
commande.argumentsPresents.push_back("couleur");
|
||||
commande.couleur = image.g_pixelVide();
|
||||
// Analyser deuxième partie
|
||||
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 {
|
||||
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;
|
||||
}
|
||||
} 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
|
||||
cout << "Argument présent " << i << " = " << commande.argumentsPresents[i] << endl;
|
||||
}
|
||||
// for (int i = 0; i < commande.argumentsPresents.size(); i++) { // DEBUG
|
||||
// cout << "Argument présent " << i << " = " << commande.argumentsPresents[i] << endl;
|
||||
// }
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -182,10 +260,31 @@ int executerCommande(Commande commande, Image &image) {
|
|||
if (argumentPresent(commande, "x1") && argumentPresent(commande, "x2")
|
||||
&& argumentPresent(commande, "y1") && argumentPresent(commande, "y2")
|
||||
&& 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 {
|
||||
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 {
|
||||
return 1;
|
||||
}
|
||||
|
|
@ -205,18 +304,36 @@ void procederCommande(vector< string > decoupe, Image &image) {
|
|||
case 2:
|
||||
messageErreur("Arguments manquants");
|
||||
break;
|
||||
case 3:
|
||||
messageErreur("Erreur dans l'execution de la commande");
|
||||
break;
|
||||
default:
|
||||
messageErreur("Impossible d'éxecuter la fonction");
|
||||
}
|
||||
break;
|
||||
case 1:
|
||||
messageErreur("Argument inconnu");
|
||||
messageErreur("Un argument a été attendu et autre chose a été donné");
|
||||
break;
|
||||
case 2:
|
||||
messageErreur("Argument inconnu");
|
||||
break;
|
||||
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;
|
||||
default:
|
||||
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;
|
||||
string commandeTexte;
|
||||
|
||||
|
|
|
|||
|
|
@ -51,6 +51,8 @@ Image imageDefaut() {
|
|||
pointRoue.v = 0;
|
||||
pointRoue.b = maxComposante - substep;
|
||||
break;
|
||||
default:
|
||||
pointRoue.r = pointRoue.v = pointRoue.b = 0;
|
||||
}
|
||||
|
||||
// Dégradé vers le noir
|
||||
|
|
|
|||
|
|
@ -106,18 +106,16 @@ int main(int argc, char *args[]) {
|
|||
|
||||
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
|
||||
|
||||
Image imageOriginale = genererRoue(DIMENSIONS, DIMENSIONS, 255);
|
||||
Image image = imageOriginale.g_vide();
|
||||
// while(1) {
|
||||
for (float i = 0; i < 2 * PI; i += 0.1) {
|
||||
pivoter(imageOriginale, image, DIMENSIONS/2, DIMENSIONS/2, i);
|
||||
afficherImage(image);
|
||||
}
|
||||
// }
|
||||
|
||||
|
||||
// // Neige en dégradé
|
||||
|
|
|
|||
|
|
@ -1,21 +1,25 @@
|
|||
#include <math.h>
|
||||
|
||||
#define PI 3.14159265359
|
||||
#define MAXCOMPOSANTEDEFAUT 255
|
||||
|
||||
// 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);
|
||||
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;
|
||||
// sortie = entree
|
||||
// ouvrir(fichierImporte, nomFichier)
|
||||
|
|
@ -25,10 +29,11 @@ void import(Image entree, Image &sortie, string nomFichier, int x, int y) {
|
|||
// FinPour
|
||||
// FinPour
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
// 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[
|
||||
// r1 = 0
|
||||
// r2 = 1
|
||||
|
|
@ -64,18 +69,20 @@ void teinte(Image entree, Image &sortie, float teinte) { // Change la teinte de
|
|||
// pixel.b = b1+(b2-b1)*valeur
|
||||
// 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 y = image.g_DimensionY()
|
||||
// Ajouter la variable saturation à chaque valeur de chaque pixel
|
||||
// Ne pas dépasser le seuil limite MaxComposante !!!
|
||||
// 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 y=0 à y=image.g_DimensionY()
|
||||
// si image.g_typeComposante=1
|
||||
|
|
@ -91,9 +98,10 @@ void luminosite(Image entree, Image &sortie, float luminosite) { // Augmente la
|
|||
// Fin si
|
||||
// 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 y=0 à y=image.g_DimensionY()
|
||||
// si image.g_typeComposante=1
|
||||
|
|
@ -107,10 +115,11 @@ void contraste(Image entree, Image &sortie, float contraste) { // Accentue les c
|
|||
// Fin Pour
|
||||
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
// 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 ;
|
||||
// float e, e(1,0), e(0,1) ; // valeur d’erreur et incréments
|
||||
// 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 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;
|
||||
for (int x = x1; x <= x2; x++) {
|
||||
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;
|
||||
// pour x=0 à x=image.g_dimensionX()
|
||||
// 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 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;
|
||||
// pour x=0 à x=image.g_dimensionX()
|
||||
// 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 pour
|
||||
// fin pour
|
||||
return 1;
|
||||
}
|
||||
|
||||
// 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();
|
||||
float xF, yF, angleF, xI, yI, angleI, h;
|
||||
Pixel pixel = entree.g_pixelVide();
|
||||
|
|
@ -176,109 +190,97 @@ void pivoter(Image entree, Image &sortie, int x0, int y0, float angle) {
|
|||
xI = x0;
|
||||
yI = y0;
|
||||
} else {
|
||||
angleF = atan((yF-y0)/(xF-x0));
|
||||
angleF = (xF-x0<0 ? angleF + PI : (yF-y0 ? angleF + 2*PI: angleF));
|
||||
angleF = atan((yF - y0) / (xF - x0));
|
||||
angleF = (xF - x0 < 0 ? angleF + PI : angleF);
|
||||
angleI = angleF - angle;
|
||||
h = sqrt(pow(xF-x0, 2)+pow(yF-y0, 2));
|
||||
xI = cos(angleI)*h+x0;
|
||||
yI = sin(angleI)*h+y0;
|
||||
h = sqrt(pow(xF - x0, 2) + pow(yF - y0, 2));
|
||||
xI = cos(angleI) * h + x0;
|
||||
yI = sin(angleI) * h + y0;
|
||||
}
|
||||
entree.g_pixel((int) xI, (int) yI, 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) {
|
||||
// Image *nouvelle = new Image(x2-x1, y2-y1, entree.g_maxComposante(), entree.g_typeComposantes());
|
||||
// sortie = *nouvelle;
|
||||
int redimensionner(Image entree, Image &sortie, int x1, int x2, int y1, int y2) {
|
||||
// sortie = *new Image(x2-x1, y2-y1, entree.g_maxComposante(), entree.g_typeComposantes());
|
||||
// pour x=x1 à x=x2
|
||||
// pour y=y1 à y=y2
|
||||
// sortie.s_pixel(x, y, entree.g_pixel(x+x1, y+y1));
|
||||
// FinPour
|
||||
// FinPour
|
||||
return 1;
|
||||
}
|
||||
|
||||
// Modification couleur
|
||||
void convBIN(Image entree, Image &sortie) {
|
||||
Pixel pixel;
|
||||
switch(entrée.g_typeComposantes) {
|
||||
case PILG_BIN:
|
||||
sortie=entree;
|
||||
break;
|
||||
case PILG_NIV:
|
||||
sortie = new Image(entree.g_dimensionX(), entree.g_dimensionY(), 0, PILG_BIN);
|
||||
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.g > entree.g_maxComposante/2);
|
||||
sortie.s_pixel(x, y, pixelF);
|
||||
|
||||
int convBIN(Image entree, Image &sortie) {
|
||||
if (entree.g_typeComposantes() == PILG_BIN) {
|
||||
sortie = entree;
|
||||
} else {
|
||||
sortie = *new Image(entree.g_dimensionX(), entree.g_dimensionY(), 0, PILG_BIN);
|
||||
Pixel pixelI, pixelF;
|
||||
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);
|
||||
switch (entree.g_typeComposantes()) {
|
||||
case PILG_NIV:
|
||||
pixelF.n = (pixelI.g > entree.g_maxComposante() / 2);
|
||||
break;
|
||||
case PILG_RVB:
|
||||
pixelF.n = ((pixelI.r + pixelI.v + pixelI.b) / 3 > entree.g_maxComposante() / 2);
|
||||
break;
|
||||
default:
|
||||
return 2;
|
||||
}
|
||||
sortie.s_pixel(x, y, pixelF);
|
||||
}
|
||||
break;
|
||||
case PILG_RVB:
|
||||
sortie = new Image(entree.g_dimensionX(), entree.g_dimensionY(), 0, PILG_BIN);
|
||||
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;
|
||||
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
void convNIV(Image entree, Image &sortie) {
|
||||
Pixel pixel;
|
||||
switch(entrée.g_typeComposantes) {
|
||||
case PILG_BIN:
|
||||
sortie = new Image(entree.n_dimensionX(), entree.n_dimensionY(), 0, PILG_BIN);
|
||||
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);
|
||||
int convNIV(Image entree, Image &sortie) {
|
||||
if (entree.g_typeComposantes() == PILG_NIV) {
|
||||
sortie = entree;
|
||||
} else {
|
||||
sortie = *new Image(entree.g_dimensionX(), entree.g_dimensionY(), MAXCOMPOSANTEDEFAUT, PILG_NIV);
|
||||
Pixel pixelI, pixelF;
|
||||
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);
|
||||
switch (entree.g_typeComposantes()) {
|
||||
case PILG_BIN:
|
||||
pixelF.g = (pixelI.n ? sortie.g_maxComposante() : 0);
|
||||
sortie.s_pixel(x, y, pixelF);
|
||||
|
||||
break;
|
||||
case PILG_RVB:
|
||||
pixelF.g = (pixelI.r + pixelI.v + pixelI.b) / 3.0 / entree.g_maxComposante() * sortie.g_maxComposante();
|
||||
break;
|
||||
default:
|
||||
return 1;
|
||||
}
|
||||
sortie.s_pixel(x, y, pixelF);
|
||||
}
|
||||
break;
|
||||
case PILG_NIV:
|
||||
sortie = entree;
|
||||
break;
|
||||
case PILG_RVB:
|
||||
sortie = new Image(entree.g_dimensionX(), entree.g_dimensionY(), 0, PILG_NIV);
|
||||
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;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
void convRVB(Image entree, Image &sortie) {
|
||||
int convRVB(Image entree, Image &sortie) {
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
//Help
|
||||
void aide() {
|
||||
int aide() {
|
||||
//Afficher le texte suivant :
|
||||
return 1;
|
||||
}
|
||||
|
|
|
|||
Reference in a new issue