Mise en fonction de l'objet Image
Import du code de Geoffrey lors de la séance du 14/02/14, la plupart étant du travail à la maison * Ajout d'un Makefile * Seul l'objet image a été découpé * Instruction test * Modification de l'objet Image * Initialisation du tableau dans le constructeur * Changement de certains int en unsigned int (puisque ne pouvant pas avoir de valeurs négative) * typeComposantes est maintenant un ensemble de constantes * Correction de diverses fautes * Ajout de g_pixelVide pour créer un objet Pixel déjà compatible avec une image * Modification de test_affichageFenetre.cpp en test.cpp * Vérifie désormais si l'objet Image est fonctionnel * Changement de la façon dont la surface est bloquée dans affichageFenetreSDL.cpp * Passage de tous les fichiers C++ au formatteur (d'où le nombre exageré de lignes modifiées) * Correction de README.md * Syntaxe * Message de mise en garde sur la non-disponibilité d'un fichier binaire * Mise à jour de TODO.md * Correction de LICENCE.md * Respect de l'ordre alphabétique, et de la cohérence vis-à-vis des autres fichiers * Ajout des dossiers bin/ et obj/ pour éviter de les créer après un clone
This commit is contained in:
parent
f5a82baaf6
commit
22bcfb2b2f
15 changed files with 407 additions and 305 deletions
|
|
@ -1,27 +1,27 @@
|
|||
#include <graphics.h>
|
||||
|
||||
int ouvrirFenetre(int dimensionX, int dimensionY, const char* nom) { // Crée une fenêtre
|
||||
int ouvrirFenetre(int dimensionX, int dimensionY, const char *nom) { // Crée une fenêtre
|
||||
initwindow(dimensionX, dimensionY, nom, 0, 0);
|
||||
return 0;
|
||||
return 0;
|
||||
}
|
||||
|
||||
int setNomFenetre(const char* nom) { // Change le nom de la fenêtre
|
||||
return 0;
|
||||
int setNomFenetre(const char *nom) { // Change le nom de la fenêtre
|
||||
return 0;
|
||||
}
|
||||
|
||||
int pointFenetre(int x, int y, int r, int v, int b) {
|
||||
putpixel(x, y, COLOR(r, v, b));
|
||||
return 0;
|
||||
return 0;
|
||||
}
|
||||
|
||||
int afficherFenetre() {
|
||||
|
||||
return 0;
|
||||
return 0;
|
||||
}
|
||||
|
||||
int attendreFenetre() {
|
||||
while (kbhit()) {
|
||||
delay(100);
|
||||
delay(100);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -3,12 +3,11 @@
|
|||
|
||||
int fenetreDimensionX; // Stocke les dimensions X de la fenêtre
|
||||
int fenetreDimensionY; // Stocke les dimensions Y de la fenêtre
|
||||
SDL_Surface* fenetreEcran;
|
||||
SDL_Surface* fenetreImage;
|
||||
SDL_Surface *fenetreEcran;
|
||||
SDL_Surface *fenetreImage;
|
||||
|
||||
|
||||
void definirPixel(SDL_Surface *surface, int x, int y, Uint32 pixel)
|
||||
{
|
||||
void definirPixel(SDL_Surface *surface, int x, int y, Uint32 pixel) {
|
||||
/*nbOctetsParPixel représente le nombre d'octets utilisés pour stocker un pixel.
|
||||
En multipliant ce nombre d'octets par 8 (un octet = 8 bits), on obtient la profondeur de couleur
|
||||
de l'image : 8, 16, 24 ou 32 bits.*/
|
||||
|
|
@ -18,95 +17,86 @@ void definirPixel(SDL_Surface *surface, int x, int y, Uint32 pixel)
|
|||
Uint8 *p = (Uint8 *)surface->pixels + y * surface->pitch + x * nbOctetsParPixel;
|
||||
|
||||
/*Gestion différente suivant le nombre d'octets par pixel de l'image*/
|
||||
switch(nbOctetsParPixel)
|
||||
{
|
||||
case 1:
|
||||
*p = pixel;
|
||||
break;
|
||||
switch (nbOctetsParPixel) {
|
||||
case 1:
|
||||
*p = pixel;
|
||||
break;
|
||||
|
||||
case 2:
|
||||
*(Uint16 *)p = pixel;
|
||||
break;
|
||||
case 2:
|
||||
*(Uint16 *)p = pixel;
|
||||
break;
|
||||
|
||||
case 3:
|
||||
/*Suivant l'architecture de la machine*/
|
||||
if(SDL_BYTEORDER == SDL_BIG_ENDIAN)
|
||||
{
|
||||
p[0] = (pixel >> 16) & 0xff;
|
||||
p[1] = (pixel >> 8) & 0xff;
|
||||
p[2] = pixel & 0xff;
|
||||
}
|
||||
else
|
||||
{
|
||||
p[0] = pixel & 0xff;
|
||||
p[1] = (pixel >> 8) & 0xff;
|
||||
p[2] = (pixel >> 16) & 0xff;
|
||||
}
|
||||
break;
|
||||
case 3:
|
||||
/*Suivant l'architecture de la machine*/
|
||||
if (SDL_BYTEORDER == SDL_BIG_ENDIAN) {
|
||||
p[0] = (pixel >> 16) & 0xff;
|
||||
p[1] = (pixel >> 8) & 0xff;
|
||||
p[2] = pixel & 0xff;
|
||||
} else {
|
||||
p[0] = pixel & 0xff;
|
||||
p[1] = (pixel >> 8) & 0xff;
|
||||
p[2] = (pixel >> 16) & 0xff;
|
||||
}
|
||||
break;
|
||||
|
||||
case 4:
|
||||
*(Uint32 *)p = pixel;
|
||||
break;
|
||||
case 4:
|
||||
*(Uint32 *)p = pixel;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
int ouvrirFenetre(int dimensionX, int dimensionY, std::string nom) { // Crée une fenêtre
|
||||
SDL_Init(SDL_INIT_VIDEO);
|
||||
fenetreDimensionX = dimensionX;
|
||||
fenetreDimensionY = dimensionY;
|
||||
fenetreEcran = SDL_SetVideoMode(fenetreDimensionX, fenetreDimensionY, 32, SDL_HWSURFACE);
|
||||
fenetreImage = SDL_CreateRGBSurface(SDL_HWSURFACE, fenetreDimensionX, fenetreDimensionX, 32, 0, 0, 0, 0);
|
||||
SDL_FillRect(fenetreImage, NULL, SDL_MapRGB(fenetreEcran->format, 0, 0, 0));
|
||||
setNomFenetre(nom);
|
||||
return 0;
|
||||
void setNomFenetre(std::string nom) { // Change le nom de la fenêtre
|
||||
SDL_WM_SetCaption(nom.c_str(), NULL);
|
||||
}
|
||||
|
||||
int setNomFenetre(std::string nom) { // Change le nom de la fenêtre
|
||||
SDL_WM_SetCaption(nom.c_str(), NULL);
|
||||
return 0;
|
||||
void pointFenetre(int x, int y, int r, int v, int b) {
|
||||
// std::cout << "(" << x << ";" << y << ") = (" << r << ";" << v << ";" << b << ")" << std::endl; // DEBUG
|
||||
|
||||
Uint32 pixel;
|
||||
|
||||
Uint8 u_r, u_v, u_b, u_a;
|
||||
u_r = (r > 255 ? 0xff : (Uint8) r);
|
||||
u_v = (v > 255 ? 0xff : (Uint8) v);
|
||||
u_b = (b > 255 ? 0xff : (Uint8) b);
|
||||
u_a = 0xff;
|
||||
|
||||
pixel = SDL_MapRGBA(fenetreImage->format, u_r, u_v, u_b, u_a);
|
||||
|
||||
definirPixel(fenetreImage, x, y, pixel);
|
||||
|
||||
}
|
||||
|
||||
int pointFenetre(int x, int y, int r, int v, int b) {
|
||||
// TODO (erreur) Vérifications des dimensions
|
||||
|
||||
// std::cout << "(" << x << ";" << y << ") = (" << r << ";" << v << ";" << b << ")" << std::endl; // DEBUG
|
||||
|
||||
Uint32 pixel;
|
||||
|
||||
Uint8 u_r, u_v, u_b, u_a;
|
||||
u_r = (Uint8) (r > 255 ? 255 : r); // TODO (performance, facultatif, erreur) Si > 255, on renvoit 0xff sinon on convertit
|
||||
u_v = (Uint8) (v > 255 ? 255 : v);
|
||||
u_b = (Uint8) (b > 255 ? 255 : b);
|
||||
u_a = (Uint8) 255;
|
||||
|
||||
pixel = SDL_MapRGBA(fenetreImage->format, u_r, u_v, u_b, u_a);
|
||||
|
||||
SDL_LockSurface(fenetreImage);
|
||||
definirPixel(fenetreImage, x, y, pixel);
|
||||
SDL_UnlockSurface(fenetreImage);
|
||||
|
||||
return 0;
|
||||
void afficherFenetre() {
|
||||
SDL_Rect position;
|
||||
position.x = 0;
|
||||
position.y = 0;
|
||||
SDL_UnlockSurface(fenetreImage);
|
||||
SDL_BlitSurface(fenetreImage, NULL, fenetreEcran, &position);
|
||||
SDL_Flip(fenetreEcran);
|
||||
SDL_LockSurface(fenetreImage);
|
||||
}
|
||||
|
||||
int afficherFenetre() {
|
||||
// TODO (performance, facultatif) fenetreImage pourrait être crée pendant afficherFenetre(), et pointFenetre() ne modifierait qu'un tableau
|
||||
SDL_Rect position;
|
||||
position.x = 0; position.y = 0;
|
||||
SDL_BlitSurface(fenetreImage, NULL, fenetreEcran, &position);
|
||||
SDL_Flip(fenetreEcran);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int attendreFenetre() {
|
||||
SDL_Event evenement;
|
||||
void attendreFenetre() {
|
||||
SDL_Event evenement;
|
||||
|
||||
while (evenement.type != SDL_QUIT) {
|
||||
SDL_WaitEvent(&evenement);
|
||||
SDL_WaitEvent(&evenement);
|
||||
}
|
||||
}
|
||||
|
||||
int fermerFenetre() {
|
||||
SDL_FreeSurface(fenetreImage);
|
||||
SDL_Quit();
|
||||
return 0;
|
||||
void fermerFenetre() {
|
||||
SDL_UnlockSurface(fenetreImage);
|
||||
SDL_FreeSurface(fenetreImage);
|
||||
SDL_Quit();
|
||||
}
|
||||
|
||||
void ouvrirFenetre(int dimensionX, int dimensionY, std::string nom) { // Crée une fenêtre
|
||||
SDL_Init(SDL_INIT_VIDEO);
|
||||
fenetreDimensionX = dimensionX;
|
||||
fenetreDimensionY = dimensionY;
|
||||
fenetreEcran = SDL_SetVideoMode(fenetreDimensionX, fenetreDimensionY, 32, SDL_HWSURFACE);
|
||||
fenetreImage = SDL_CreateRGBSurface(SDL_HWSURFACE, fenetreDimensionX, fenetreDimensionX, 32, 0, 0, 0, 0);
|
||||
SDL_FillRect(fenetreImage, NULL, SDL_MapRGB(fenetreEcran->format, 0, 0, 0));
|
||||
setNomFenetre(nom);
|
||||
SDL_LockSurface(fenetreImage);
|
||||
}
|
||||
|
|
|
|||
120
src/image.cpp
120
src/image.cpp
|
|
@ -1,55 +1,95 @@
|
|||
int Image::Image(int dimensionX, int dimensionY, int maxComposante, int typeComposantes) { // Crée l'objet Image
|
||||
|
||||
#include "image.h"
|
||||
|
||||
Image::Image(unsigned int dimensionX, unsigned int dimensionY, unsigned int maxComposante, PILG_Comp typeComposantes): m_dimensionX(dimensionX), m_dimensionY(dimensionY), m_maxComposante(maxComposante), m_typeComposantes(typeComposantes) {
|
||||
Pixel pixelVide = g_pixelVide();
|
||||
for (int xT = 0; xT < dimensionX; xT++) {
|
||||
std::vector< Pixel > colonne;
|
||||
for (int yT = 0; yT < dimensionX; yT++) {
|
||||
colonne.push_back(pixelVide);
|
||||
}
|
||||
m_tab.push_back(colonne);
|
||||
}
|
||||
}
|
||||
|
||||
// Getters
|
||||
int Image::g_dimensionX() {
|
||||
return m_dimensionX;
|
||||
unsigned int Image::g_dimensionX() const {
|
||||
return m_dimensionX;
|
||||
}
|
||||
int Image::g_dimensionY() {
|
||||
return m_dimensionY;
|
||||
|
||||
unsigned int Image::g_dimensionY() const {
|
||||
return m_dimensionY;
|
||||
}
|
||||
int Image::g_typeComposante() {
|
||||
return m_typeComposante;
|
||||
}
|
||||
int Image::g_maxComposante() {
|
||||
return m_typeComposante;
|
||||
|
||||
PILG_Comp Image::g_typeComposantes() const {
|
||||
return m_typeComposantes;
|
||||
}
|
||||
int g_point(int x, int y, Pixel &pixel) {
|
||||
if (en_Limites(x, y)) {
|
||||
pixel = m_tab[x][y];
|
||||
return 0;
|
||||
} else {
|
||||
return 1;
|
||||
}
|
||||
|
||||
unsigned int Image::g_maxComposante() const {
|
||||
return m_maxComposante;
|
||||
}
|
||||
|
||||
int Image::g_point(unsigned int x, unsigned int y, Pixel &pixel) const {
|
||||
if (enLimites(x, y)) {
|
||||
pixel = m_tab[x][y];
|
||||
return 0;
|
||||
} else {
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
||||
// Setters
|
||||
int Image::s_point(unsigned int x, unsigned int y, Pixel pixel) {
|
||||
if (enLimites(x, y)
|
||||
&& pixel.typeComposantes == m_typeComposantes
|
||||
&& pixel.maxComposante == m_maxComposante
|
||||
&& enLimitesComposantes(pixel)) {
|
||||
m_tab[x][y] = pixel;
|
||||
return 0;
|
||||
} else {
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
||||
int Image::s_point(int x, int y, Pixel pixel) {
|
||||
if (en_Limites(x, y) && pixel.typeComposantes == Image.g_typeComposante && pixel.maxComposante == Image.g_maxComposante && enLimitesComposantes(pixel)) {
|
||||
m_tab[x][y] = pixel;
|
||||
}
|
||||
|
||||
// Utilitaires
|
||||
Pixel Image::g_pixelVide() const {
|
||||
Pixel pixel;
|
||||
pixel.typeComposantes = m_typeComposantes;
|
||||
pixel.maxComposante = m_maxComposante;
|
||||
switch (pixel.typeComposantes) {
|
||||
case PILG_BIN:
|
||||
pixel.b = false;
|
||||
break;
|
||||
case PILG_NIV:
|
||||
pixel.g = 0;
|
||||
break;
|
||||
case PILG_RVB:
|
||||
pixel.r = 0;
|
||||
pixel.b = 0;
|
||||
pixel.v = 0;
|
||||
break;
|
||||
}
|
||||
return pixel;
|
||||
}
|
||||
|
||||
bool Image::enLimitesComposantes(Pixel pixel) {
|
||||
switch (pixel.typeComposantes) {
|
||||
case 0:
|
||||
return true;
|
||||
break;
|
||||
case 1:
|
||||
return pixel.m <= pixel.maxComposante;
|
||||
break;
|
||||
case 2:
|
||||
return (pixel.r <= pixel.maxComposante && pixel.v <= pixel.maxComposante && pixel.b <= pixel.maxComposante);
|
||||
break;
|
||||
default:
|
||||
return false;
|
||||
break;
|
||||
}
|
||||
switch (pixel.typeComposantes) {
|
||||
case PILG_BIN:
|
||||
return true;
|
||||
break;
|
||||
case PILG_NIV:
|
||||
return (pixel.g <= pixel.maxComposante);
|
||||
break;
|
||||
case PILG_RVB:
|
||||
return (pixel.r <= pixel.maxComposante
|
||||
&& pixel.v <= pixel.maxComposante
|
||||
&& pixel.b <= pixel.maxComposante);
|
||||
break;
|
||||
default:
|
||||
return false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
bool Image::enLimites(int x, int y) {
|
||||
return (x >= 0 && x < g_dimensionX && y >= 0 && y < g_dimensionY);
|
||||
}
|
||||
bool Image::enLimites(unsigned int x, unsigned int y) const {
|
||||
return (x >= 0 && x < m_dimensionX && y >= 0 && y < m_dimensionY);
|
||||
}
|
||||
|
|
|
|||
53
src/image.h
53
src/image.h
|
|
@ -1,34 +1,39 @@
|
|||
#include <vector>
|
||||
|
||||
typedef Pixel {
|
||||
int typeComposantes;
|
||||
int maxComposante;
|
||||
int r;
|
||||
int v;
|
||||
int b;
|
||||
int g;
|
||||
bool n;
|
||||
typedef enum {PILG_BIN, PILG_NIV, PILG_RVB} PILG_Comp;
|
||||
|
||||
typedef struct Pixel {
|
||||
PILG_Comp typeComposantes;
|
||||
unsigned int maxComposante;
|
||||
unsigned int r;
|
||||
unsigned int v;
|
||||
unsigned int b;
|
||||
unsigned int g;
|
||||
bool n;
|
||||
} Pixel;
|
||||
|
||||
class Image {
|
||||
public:
|
||||
int Image(int dimensionX, int dimensionY, int maxComposante, int typeComposantes); // Crée l'objet Image
|
||||
// Getters
|
||||
int g_dimensionX();
|
||||
int g_dimensionY();
|
||||
int g_typeComposante();
|
||||
int g_maxComposante();
|
||||
Pixel g_point(int x, int y);
|
||||
// Setters
|
||||
int s_point(int x, int y, Pixel pixel);
|
||||
Image(unsigned int dimensionX, unsigned int dimensionY, unsigned int maxComposante, PILG_Comp typeComposantes);
|
||||
// Getters
|
||||
unsigned int g_dimensionX() const;
|
||||
unsigned int g_dimensionY() const;
|
||||
PILG_Comp g_typeComposantes() const;
|
||||
unsigned int g_maxComposante() const;
|
||||
int g_point(unsigned int x, unsigned int y, Pixel &pixel) const;
|
||||
// Setters
|
||||
int s_point(unsigned int x, unsigned int y, Pixel pixel);
|
||||
// Utilitaires
|
||||
Pixel g_pixelVide() const;
|
||||
|
||||
private:
|
||||
bool enLimitesComposantes(Pixel pixel);
|
||||
bool enLimites(int x, int y);
|
||||
int m_dimensionX;
|
||||
int m_dimensionY;
|
||||
int m_typeComposantes; // 0 : N&B, 1 : Niveaux de gris, 2 : RVB
|
||||
int m_maxComposante; // Maximum de composante (inutilisé pour binaire)
|
||||
vector< vector< Pixel > > m_tab;
|
||||
// Utilitaires
|
||||
static bool enLimitesComposantes(Pixel pixel);
|
||||
bool enLimites(unsigned int x, unsigned int y) const;
|
||||
// Variables
|
||||
unsigned int m_dimensionX;
|
||||
unsigned int m_dimensionY;
|
||||
PILG_Comp m_typeComposantes; // 0 : N&B, 1 : Niveaux de gris, 2 : RVB
|
||||
unsigned int m_maxComposante; // Maximum de composante (sauf binaire)
|
||||
std::vector< std::vector< Pixel > > m_tab;
|
||||
};
|
||||
|
|
|
|||
12
src/main.cpp
12
src/main.cpp
|
|
@ -3,21 +3,19 @@
|
|||
|
||||
#include "affichageFenetreSDL.cpp"
|
||||
|
||||
|
||||
using namespace std;
|
||||
|
||||
// Insertion des ensembles de fonctions massives séparés pour plus de clarté
|
||||
#include "analyserCommande.cpp"
|
||||
#include "traitementImage.cpp"
|
||||
|
||||
int main(int argc, char* args[]) {
|
||||
|
||||
#if defined(WIN32) // Permet de refaire fonctionner cin et cout sous Windows après démarrage de SDL
|
||||
freopen("CON", "w", stdout);
|
||||
freopen("CON", "w", stderr);
|
||||
int main(int argc, char *args[]) {
|
||||
#if defined(WIN32) // Permet de refaire fonctionner cin et cout sous Windows après démarrage de SDL
|
||||
freopen("CON", "w", stdout);
|
||||
freopen("CON", "w", stderr);
|
||||
#endif
|
||||
|
||||
cout << "PILG" << endl; // Message d'entrée et de test
|
||||
cout << "PILG" << endl; // Message d'entrée et de test
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
|
|||
64
src/test.cpp
Normal file
64
src/test.cpp
Normal file
|
|
@ -0,0 +1,64 @@
|
|||
#include <iostream>
|
||||
#include <string>
|
||||
|
||||
#include "affichageFenetreSDL.cpp"
|
||||
#include "image.h"
|
||||
|
||||
using namespace std;
|
||||
|
||||
|
||||
int main(int argc, char *args[]) {
|
||||
#if defined(WIN32) // Permet de refaire fonctionner cin et cout sous Windows après démarrage de SDL
|
||||
freopen("CON", "w", stdout);
|
||||
freopen("CON", "w", stderr);
|
||||
#endif
|
||||
|
||||
cout << "TEST AFFICHAGE FENETRE" << endl; // Message d'entrée et de test
|
||||
|
||||
int dimX = 640, dimY = 480;
|
||||
ouvrirFenetre(dimX, dimY, "Test affichage fenêtre");
|
||||
|
||||
Image image(dimX, dimY, 255, PILG_RVB);
|
||||
int x, y, c;
|
||||
Pixel point;
|
||||
point = image.g_pixelVide();
|
||||
// cout << "R : " << point.r << " - V : " << point.v << " - B : " << point.b << endl; // DEBUG
|
||||
|
||||
|
||||
// Cycle de couleurs avec utilisation d'Image
|
||||
for (c = 0; c < 256; c++) { // À peu près 28 FPS avec SDL
|
||||
for (x = 0; x < dimX; x++) {
|
||||
for (y = 0; y < dimY; y++) {
|
||||
point.r = c;
|
||||
point.v = image.g_maxComposante() - c;
|
||||
point.b = 0;
|
||||
if (image.s_point(x, y, point) == 1) {
|
||||
cerr << "Erreur : s_point() a été entré avec des valeurs incorrectes" << endl;
|
||||
cout << "X : " << x << " - Y: " << y << " - R : " << point.r << " - V : " << point.v << " - B : " << point.b << endl; // DEBUG
|
||||
return 1;
|
||||
}
|
||||
image.g_point(x, y, point);
|
||||
pointFenetre(x, y, point.r, point.v, point.b);
|
||||
}
|
||||
}
|
||||
afficherFenetre();
|
||||
}
|
||||
|
||||
// // Cycle de couleurs sans utilisation d'Image
|
||||
// for (c = 0; c < 256; c++) { // À peu près 75 FPS avec SDL
|
||||
// for (x = 0; x < dimX; x++) {
|
||||
// for (y = 0; y < dimY; y++) {
|
||||
// pointFenetre(x, y, c, 255 - c, 0);
|
||||
// }
|
||||
// }
|
||||
// afficherFenetre();
|
||||
// }
|
||||
|
||||
|
||||
|
||||
cout << "Éxecution du programme terminée. Vous pouvez quitter la fenêtre." << endl;
|
||||
attendreFenetre();
|
||||
fermerFenetre();
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1,36 +0,0 @@
|
|||
#include <iostream>
|
||||
#include <string>
|
||||
|
||||
#include "affichageFenetreBGI.cpp"
|
||||
|
||||
using namespace std;
|
||||
|
||||
|
||||
int main(int argc, char* args[]) {
|
||||
|
||||
#if defined(WIN32) // Permet de refaire fonctionner cin et cout sous Windows après démarrage de SDL
|
||||
freopen("CON", "w", stdout);
|
||||
freopen("CON", "w", stderr);
|
||||
#endif
|
||||
|
||||
cout << "TEST AFFICHAGE FENETRE" << endl; // Message d'entrée et de test
|
||||
|
||||
int dimX = 640, dimY = 480;
|
||||
ouvrirFenetre(dimX, dimY, "Test affichage fenêtre");
|
||||
|
||||
for (int c = 0; c <= 255; c++) { // À peu près 58 FPS
|
||||
for (int x = 0; x <= dimX; x++) {
|
||||
for (int y = 0; y <= dimY; y++) {
|
||||
pointFenetre(x, y, c, 255-c, 0);
|
||||
}
|
||||
}
|
||||
afficherFenetre();
|
||||
}
|
||||
|
||||
cout << "Éxecution du programme terminée. Vous pouvez quitter la fenêtre." << endl;
|
||||
attendreFenetre();
|
||||
fermerFenetre();
|
||||
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -31,77 +31,77 @@ int refaire() { // répeter la dernière action
|
|||
|
||||
// Couleur
|
||||
int teinte(Image entree, Image &sortie, float teinte) { // Change la teinte de l'image
|
||||
// Si la teinte appartient à [0;1[
|
||||
// r1 = 0
|
||||
// r2 = 1
|
||||
// v1 = 1
|
||||
// v2 = 2
|
||||
// b1 = 2
|
||||
// b2 = 0
|
||||
// Valeur = Teinte
|
||||
// Sinon Si la teinte appartient à [1;2[
|
||||
// r1 = 1
|
||||
// r2 = 2
|
||||
// v1 = 2
|
||||
// v2 = 0
|
||||
// b1 = 0
|
||||
// b2 = 1
|
||||
// Valeur = Teinte-1
|
||||
// Sinon Si la teinte appartient à [2;3]
|
||||
// r1 = 2
|
||||
// r2 = 0
|
||||
// v1 = 0
|
||||
// v2 = 1
|
||||
// b1 = 1
|
||||
// b2 = 2
|
||||
// Valeur = Teinte-2
|
||||
// Fin Si
|
||||
// Pour x=0 à x=image.getDimensionX()
|
||||
// Pour y=0 à y=image.getDimensionY()
|
||||
//
|
||||
//
|
||||
//
|
||||
// pixel.r = r1+(r2-r1)*valeur
|
||||
// pixel.v = v1+(v2-v1)*valeur
|
||||
// pixel.b = b1+(b2-b1)*valeur
|
||||
// Fin Pour
|
||||
// Fin Pour
|
||||
// Si la teinte appartient à [0;1[
|
||||
// r1 = 0
|
||||
// r2 = 1
|
||||
// v1 = 1
|
||||
// v2 = 2
|
||||
// b1 = 2
|
||||
// b2 = 0
|
||||
// Valeur = Teinte
|
||||
// Sinon Si la teinte appartient à [1;2[
|
||||
// r1 = 1
|
||||
// r2 = 2
|
||||
// v1 = 2
|
||||
// v2 = 0
|
||||
// b1 = 0
|
||||
// b2 = 1
|
||||
// Valeur = Teinte-1
|
||||
// Sinon Si la teinte appartient à [2;3]
|
||||
// r1 = 2
|
||||
// r2 = 0
|
||||
// v1 = 0
|
||||
// v2 = 1
|
||||
// b1 = 1
|
||||
// b2 = 2
|
||||
// Valeur = Teinte-2
|
||||
// Fin Si
|
||||
// Pour x=0 à x=image.getDimensionX()
|
||||
// Pour y=0 à y=image.getDimensionY()
|
||||
//
|
||||
//
|
||||
//
|
||||
// pixel.r = r1+(r2-r1)*valeur
|
||||
// pixel.v = v1+(v2-v1)*valeur
|
||||
// pixel.b = b1+(b2-b1)*valeur
|
||||
// Fin Pour
|
||||
// Fin Pour
|
||||
}
|
||||
|
||||
int saturation(Image entree, Image &sortie, float saturation) { // Sature l'image
|
||||
// Pour x = xMin to x = xMax
|
||||
// Pour y = yMin to y = yMax
|
||||
// Ajouter la variable saturation à chaque valeur de chaque pixel
|
||||
// Ne pas dépasser le seuil limite MaxComposante !!!
|
||||
// Fin Pour
|
||||
// Fin Pour
|
||||
// Pour x = xMin to x = xMax
|
||||
// Pour y = yMin to y = yMax
|
||||
// Ajouter la variable saturation à chaque valeur de chaque pixel
|
||||
// Ne pas dépasser le seuil limite MaxComposante !!!
|
||||
// Fin Pour
|
||||
// Fin Pour
|
||||
}
|
||||
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
|
||||
// pixel = image.g_point(x,y);
|
||||
// pixel.g = luminosite*10+pixel.g;
|
||||
// image.s_point(x, y, pixel);
|
||||
// sinon si image.g_typeComposante=2
|
||||
// pixel = image.g_point(x,y);
|
||||
// pixel.r = luminosite*10+pixel.r;
|
||||
// pixel.v = luminosite*10+pixel.v;
|
||||
// pixel.b = luminosite*10+pixel.b;
|
||||
// image.s_point(x, y, pixel);
|
||||
// Fin si
|
||||
// Fin Pour
|
||||
// Fin Pour
|
||||
// Pour x=0 à x=image.g_DimensionX()
|
||||
// Pour y=0 à y=image.g_DimensionY()
|
||||
// si image.g_typeComposante=1
|
||||
// pixel = image.g_point(x,y);
|
||||
// pixel.g = luminosite*10+pixel.g;
|
||||
// image.s_point(x, y, pixel);
|
||||
// sinon si image.g_typeComposante=2
|
||||
// pixel = image.g_point(x,y);
|
||||
// pixel.r = luminosite*10+pixel.r;
|
||||
// pixel.v = luminosite*10+pixel.v;
|
||||
// pixel.b = luminosite*10+pixel.b;
|
||||
// image.s_point(x, y, pixel);
|
||||
// Fin si
|
||||
// Fin Pour
|
||||
// Fin Pour
|
||||
}
|
||||
int contraste(Image entree, Image &sortie, float contraste) { // Accentue les contrastes de l'image
|
||||
// pour x=0 à x=image.g_dimensionX()
|
||||
//pour y=0 à x=image.g_DimensionY()
|
||||
//si image.g_typeComposante=1
|
||||
//pixel = image.g_point(x,y);
|
||||
//pixel.g = contraste*pixel.g;
|
||||
// if pixel.g > Image.g_maxComposante
|
||||
// pixel.g = Image.g_maxComposante
|
||||
// end if
|
||||
// pour x=0 à x=image.g_dimensionX()
|
||||
//pour y=0 à x=image.g_DimensionY()
|
||||
//si image.g_typeComposante=1
|
||||
//pixel = image.g_point(x,y);
|
||||
//pixel.g = contraste*pixel.g;
|
||||
// if pixel.g > Image.g_maxComposante
|
||||
// pixel.g = Image.g_maxComposante
|
||||
// end if
|
||||
|
||||
|
||||
}
|
||||
|
|
@ -142,4 +142,4 @@ int convRVB(Image entree, Image &sortie) {
|
|||
//Help
|
||||
int aide() {
|
||||
|
||||
}
|
||||
}
|
||||
Reference in a new issue