Discussion :

[ironzorg]

Bonjour a tous !

Apres avoir effectué un logiciel stéganographique, je me suis lancé dans la réalisation de filtres. Ces derniers prennent une photo et la transforment, selon le souhait de l'utilisateur, en noir et nlanc, aplatissent les couleurs ( dans mon code c'est un aplatissement sur 4 ) ...
Mon problème réside dans le fait que la transformation en Noir et Blanc dégrade énormément l'image. Avez vous une solution ?

Mon code:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
#include <cstdlib>
#include <cstdio>
#include <iostream>
#include "SDL/SDL.h"
#include "prototypes.h"
 
const int LARGEUR_ECRAN = 640;
const int HAUTEUR_ECRAN = 480;
 
int main(int argc, char *argv[])
{
    SDL_Surface *ecran = NULL, *Tampon = NULL;
 
    SDL_Rect position;
    SDL_Event event;
 
    int i = 0;
    int continuer = 1;
 
    SDL_Init(SDL_INIT_VIDEO);
 
    Tampon = SDL_LoadBMP("./image.bmp");
 
    ecran = SDL_SetVideoMode(Tampon->w, Tampon->h, 32, SDL_HWSURFACE);
 
    position.x = 0;
    position.y = 0;
 
    SDL_FillRect(ecran, NULL, SDL_MapRGB(ecran->format, 0, 0, 0));
 
    Manipulation(Tampon);
 
    SDL_BlitSurface(Tampon, NULL, ecran, &position);
    SDL_Flip(ecran);
 
    while (continuer)
    {
 
        SDL_WaitEvent(&event);
 
        switch(event.type)
        {
            case SDL_QUIT:
                continuer = 0;
 
            case SDL_KEYDOWN:
            if(event.key.keysym.sym == SDLK_ESCAPE)
            {
                continuer = 0;
                break;
            }
        }
    }
 
    SDL_FreeSurface(Tampon);
    SDL_Quit();
 
    return EXIT_SUCCESS;
 
}
 
void Manipulation(SDL_Surface* surface)
{
        int x, y;
 
        Uint8 r_s, g_s, b_s, a_s;
 
        Uint32 pixel_s;
 
        SDL_LockSurface(surface);
 
        for (y = 0 ; y < surface->h; y ++)
        {
                for ( x = 0 ; x < surface->w; x ++)
                {
                        pixel_s = getPixel(surface, x, y);
 
                        SDL_GetRGBA(pixel_s, surface->format, &r_s, &g_s, &b_s, &a_s);
 
                        Uint8 Moyenne = (r_s + g_s + b_s) / 3;
 
                        if(Moyenne < 123)
                        {
                            r_s = 0;
                            g_s = 0;
                            b_s = 0;
                        }
                        else if(Moyenne >= 124)
                        {
                            r_s = 255;
                            g_s = 255;
                            b_s = 255;
                        }
 
                        pixel_s=SDL_MapRGBA(surface->format, r_s, g_s, b_s, a_s);
 
                        setPixel(surface, x, y, pixel_s);
 
                }
        }
        SDL_UnlockSurface(surface);
}
 
Uint8 Verifier_valeur(Uint8 valeur)
{
    if(valeur < 123)
    {
        valeur = 0;
    }
    if(valeur > 123)
    {
        valeur = 255;
    }
 
    return valeur;
}

Je ne vous ai pas mis le pixel.cpp ( pas important dans mon cas ).

Si ça vous interesse de voir mes autres filtres, regardez dans le zip.

le zip

Je précise que ce que vous présente la n'est pas définitif, je vais faire des filtres qui fonctionnent avec les lignes de commandes pour gérer tous les formats d'images.

[Laurent Gomila]

Je pense que tu aurais de meilleurs résultats en prennant non pas la moyenne, mais la formule standard qui définit le niveau de gris :

luminance = 0.30 * red + 0.59 * green + 0.11 * blue

http://en.wikipedia.org/wiki/Grayscale

Ensuite il faut aussi voir par rapport au seuil, je ne sais pas si 123 est la meilleure valeur (au fait, la moitié de 256 c'est 128).

[ironzorg]

Mais la ce que tu me propose, c'est de faire un niveau de gris, et ça je sais le faire ( il est dans le zip ).

[fearyourself]

Mais la ce que tu me propose, c'est de faire un niveau de gris, et ça je sais le faire ( il est dans le zip ).

Oui mais pourquoi pas transformer en niveau de gris avant de passer soit en noir, soit en blanc ?

Le résultat sera sûrement meilleur,

Jc

[ironzorg]

Oui mais pourquoi pas transformer en niveau de gris avant de passer soit en noir, soit en blanc ?

Oui mais ma logique consistait a faire:
- faire la moyenne des composantes
- si la moyenne tend vers le noir, mettre toutes les composantes en noir
- si la moyenne tend vers le blanc, mettre toutes les composantes en blanc


Par définition, le gris se forme quand les composantes ont la meme valeur, donc si on applique mon théorème, on obtiendra rien du tout car le gris ne tends ni vers le blanc, ni vers le noir !

[fearyourself]

Par définition, le gris se forme quand les composantes ont la meme valeur, donc si on applique mon théorème, on obtiendra rien du tout car le gris ne tends ni vers le blanc, ni vers le noir !

Moi je définis cela comme ceci :

Calculer le facteur lumière :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
luminance = 0.30 * red + 0.59 * green + 0.11 * blue

Ensuite :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
Si luminance > seuil_noir
   couleur = blanche
sinon
   couleur = noir
fsi

Jc

[Laurent Gomila]

Il faut forcément passer par un niveau de gris. Dans ton code c'est la moyenne des composantes :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Uint8 Moyenne = (r_s + g_s + b_s) / 3;

Je disais juste que la formule standard serait plus adaptée :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Uint8 Moyenne = (Uint8)(0.30 * r_s + 0.59 * g_s + 0.11 * b_s);

La différence, c'est que dans ta version chaque composante à un poids égal, alors que la formule standard tient compte de la perception de l'oeil pour affecter à chaque composante un coefficient adéquat.

D'ailleurs si tu as un filtre "niveaux de gris" tu devrais aussi utiliser le modifier.

[ironzorg]

Mais c'est quoi alors la relation logique entre ma moyenne et celle que tu donnes ? Comment est ce qu'on a décidé que les coefficient 0,30; 0,59 et 1,11 étaient les bons ?

[hpfx]

Mais c'est quoi alors la relation logique entre ma moyenne et celle que tu donnes ? Comment est ce qu'on a décidé que les coefficient 0,30; 0,59 et 1,11 étaient les bons ?

une etude scientifique
en fait c'est en fonction de ce que percoit l'oeuil humaine (les cones les batons etc...) et le fait qu'un vert sera percut plus clair qu'un rouge. il faut donc ponderer les composantes.
si si, promis, ca marche.

[Laurent Gomila]

Mais c'est quoi alors la relation logique entre ma moyenne et celle que tu donnes ? Comment est ce qu'on a décidé que les coefficient 0,30; 0,59 et 1,11 étaient les bons ?

Je l'avais pourtant expliqué :

La différence, c'est que dans ta version chaque composante à un poids égal, alors que la formule standard tient compte de la perception de l'oeil pour affecter à chaque composante un coefficient adéquat.

Et donné un lien au cas où tu voudrais en savoir plus :

http://en.wikipedia.org/wiki/Grayscale

[ironzorg]

Et donné un lien au cas où tu voudrais en savoir plus :
Citation:
http://en.wikipedia.org/wiki/Grayscale

Ah ok je comprends mieux maintenant. Merci pour le lien

la formule standard tient compte de la perception de l'oeil pour affecter à chaque composante un coefficient adéquat.

Je voulais juste que tu développes.

Je vais tester ça...

[Laurent Gomila]

Je voulais juste que tu développes.

Je connais pas les détails je sais juste que les coefficients sont proportionnels à la luminosité perçue par l'oeil pour chaque couleur (genre le vert est perçu très lumineux, le bleu beaucoup moins).

[ironzorg]

J'ai appliqué la moyenne et j'ai admis dans l'image des pixels gris... Pour voir les noveaux filtres: ici