[FAQ] [SDL] Erreurs ?

**Laurent Gomila** · 30/07/2006, 10h41

Dans cette Q/R :
http://jeux.developpez.com/faq/sdl/?...odifier_pixels

Code :

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

1
2
/* p est l'adresse du pixel que l'on veut modifier */
    Uint8 *p = (Uint8*)Surface->pixels + y * Surface->pitch + x * bpp;

La variable bpp semble sortir de nulle part. Il faut remplacer par Surface->format->BytesPerPixel n'est-ce pas ?

Dans celle-ci :
http://jeux.developpez.com/faq/sdl/?...2D_definir_rgb

Code :

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

SDL_GetRGB((Uint8)Surf->pixels, Surf->format, &r, &g, &b);

Ce ne serait pas plutôt :

Code :

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

SDL_GetRGB(*(Uint32*)Surf->pixels, Surf->format, &r, &g, &b);

**fearyourself** · 30/07/2006, 11h56

Envoyé par Laurent Gomila

Dans cette Q/R :
http://jeux.developpez.com/faq/sdl/?...odifier_pixels

Code :

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

1
2
/* p est l'adresse du pixel que l'on veut modifier */
    Uint8 *p = (Uint8*)Surface->pixels + y * Surface->pitch + x * bpp;

La variable bpp semble sortir de nulle part. Il faut remplacer par Surface->format->BytesPerPixel n'est-ce pas ?

Tout à fait, je pense que c'est ce que voulait dire Fiquet...

Dans celle-ci :
http://jeux.developpez.com/faq/sdl/?...2D_definir_rgb

Code :

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

SDL_GetRGB((Uint8)Surf->pixels, Surf->format, &r, &g, &b);

Ce ne serait pas plutôt :

Code :

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

SDL_GetRGB(*(Uint32*)Surf->pixels, Surf->format, &r, &g, &b);

Encore une fois raison, je pense d'ailleurs qu'on pourrait faire :

Qui fournit les valeurs dans les paramètres correspondants. Il faut aussi renseigner la fonction avec le format de pixel.

En écrivant une fonction getPixel, on pourra facilement utiliser ces fonctions :

Code :

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

1
2
3
4
5
 
inline int getPixel(int i, int j, int bytesperPix, int pitch)
{
	return i*pitch + j*bytesperPix;
}

Voici son utilisation :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
Uint8 r, g, b;
Uint32 *mespixels;
Uint32 *mespixels = (Uint32*) ((Uint8*) o->pixels + getPixel(75,122,
                                 Surf->format->BytesPerPixel,Surf->pitch));
 
/* Récupère la valeur RGB du premier pixel (0, 0) d'une surface */
SDL_GetRGB(*mespixels, Surf->format, &r, &g, &b);
 
printf("Le pixel (5,5) a une couleur : rouge = %i, vert = %i, bleu = %i", 
                 r, g, b);

Jc

**Laurent Gomila** · 30/07/2006, 12h06

Hmm et pourquoi pas :

Code :

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

1
2
3
4
5
6
Uint32 getPixel(SDL_Surface* surf, int x, int y)
{
    Uint8* Pixel = (Uint8*)surf->pixels + y * surf->pitch + x * surf->format->BytesPerPixel;
 
    return *(Uint32*)Pixel;
}

Quoiqu'il en soit je pense qu'on peut faire une question séparée du genre "Comment récupérer la valeur d'un pixel d'une surface ?", qui irait bien celle qui existe déjà : "Comment modifier ...".

**fearyourself** · 30/07/2006, 12h44

Envoyé par Laurent Gomila

Hmm et pourquoi pas :

Code :

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

1
2
3
4
5
6
Uint32 getPixel(SDL_Surface* surf, int x, int y)
{
    Uint8* Pixel = (Uint8*)surf->pixels + y * surf->pitch + x * surf->format->BytesPerPixel;
 
    return *(Uint32*)Pixel;
}

Quoiqu'il en soit je pense qu'on peut faire une question séparée du genre "Comment récupérer la valeur d'un pixel d'une surface ?", qui irait bien celle qui existe déjà : "Comment modifier ...".

Tout à fait, c'est aussi bon

Jc

**Fiquet** · 30/07/2006, 14h46

Envoyé par Laurent Gomila

La variable bpp semble sortir de nulle part. Il faut remplacer par Surface->format->BytesPerPixel n'est-ce pas ?

Oui tout à fait, selon le code de la doc, il y a en fait cette ligne en plus :

Code :

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

int bpp = Surface->format->BytesPerPixel;

Ce ne serait pas plutôt :

Code :

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

SDL_GetRGB(*(Uint32*)Surf->pixels, Surf->format, &r, &g, &b);

Effectivement, je ne sais pas ce qui m'était passé par la tête

.

Quoiqu'il en soit je pense qu'on peut faire une question séparée du genre "Comment récupérer la valeur d'un pixel d'une surface ?", qui irait bien celle qui existe déjà : "Comment modifier ...".

Oui effectivement. Voici un exemple, avec le même code qui vient de la doc et valable pour toutes les valeurs de bits par pixel.

Pour pouvoir accéder aux pixels d'une surface et récupérer leur valeur, on peut y accéder directement grâce au membre pixels de la structure SDL_Surface qui est un pointeur sur les données de pixels.

La fonction suivante sert à lire un pixel (x, y) d'une SDL_Surface (tiré de la doc officielle) :

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
Uint32 GetPixel(SDL_Surface* Surface, int x, int y)
{
    int bpp = Surface->format->BytesPerPixel;
 
    /* p est l'adresse du pixel que l'on veut récupérer */
    Uint8 *p = (Uint8 *)Surface->pixels + y * Surface->pitch + x * bpp;
 
    switch(bpp)
    {
    case 1:
        return *p;
 
    case 2:
        return *(Uint16*)p;
 
    case 3:
        if(SDL_BYTEORDER == SDL_BIG_ENDIAN)
            return p[0] << 16 | p[1] << 8 | p[2];
        else
            return p[0] | p[1] << 8 | p[2] << 16;
 
    case 4:
        return *(Uint32*)p;
    }
}

Ensuite comme le dit fearyourself on pourrait on pourrait mettre un exemple avec la fonction GetPixel() dans la question sur SDL_GetRGB(), et par exemple faire un lien sur la Q/R que je viens de faire où il y a le code de celle-ci.

Encore désolé pour ces erreurs

.

**Laurent Gomila** · 30/07/2006, 15h13

Ca doit être bête, mais... pourquoi pour le format 24 bits il faut recomposer le pixel à partir des composantes séparément ?

**fearyourself** · 31/07/2006, 09h28

Envoyé par Laurent Gomila

Ca doit être bête, mais... pourquoi pour le format 24 bits il faut recomposer le pixel à partir des composantes séparément ?

Je sais pas trop pourquoi ils le font... J'aurais presque tendance à dire que c'est une erreur ou un oubli de leur part et que personne ne le remarque puisqu'on utilise généralement du 8bit ou du 24bit, rarement du 16...

Mais il n'y a pas de raison que l'endian ne joue pas un rôle pour du 16bit...

Jc

**Ti-R** · 31/07/2006, 18h16

Code :

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

Uint32 GetPixel(SDL_Surface* Surface, int x, int y)

C'est bien pour récupérer 1 pixel, si c'est pour faire de la TNI, ma réaction est ->

**fearyourself** · 31/07/2006, 18h22

Envoyé par Ti-R

Code :

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

Uint32 GetPixel(SDL_Surface* Surface, int x, int y)

C'est bien pour récupérer 1 pixel, si c'est pour faire de la TNI, ma réaction est ->

TNI -> Traitement numérique d'image ?

Si oui :

Si on voulait vraiment faire du traitement numérique, je pense qu'on n'utiliserait pas cette fonction. On utiliserait sûrement une format interne pour être optimal par rapport à ce qu'on veut faire.

Mais généralement, il y a un petit prétraitement des images avant le début du programme.

Que celui-ci soit plus lent qu'une version optimisée dans un programme amateur ne me semble pas idiot...

Jc

**Ti-R** · 31/07/2006, 18h34

TNI -> Traitement numérique d'image ?

-> Oui

Non ce n'est pas idiot, mais juste prévenir que c'est une méthode coûteuse.

**millie** · 31/07/2006, 21h00

Que proposerez-tu de plus efficace ?

**Ti-R** · 31/07/2006, 23h11

Pour aller chercher 1 pixel, rien.

Sinon mettre un pointeur sur

Code :

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

surf->pixels

Et zzzooooooo

"Ploc un mur"

Pourquoi pas faire plusieurs class, qui peuvent hériter d'une autre class commune, Pixel par exemple (L’héritage peut créer des problèmes en mémoire, pour ce qui va suivre)

CGrey
CRGBA
autres...

Ensuite on cast suivant la class

Pixels* GetPixels(); // Qui retourne « surf->pixels »
ou
void* GetPixels(); // ok c'est un peu de C dans ce monde de brute de C++

Code :

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

1
2
3
4
5
// ex de parcourt des pixel en niveau de gris
CGrey* pt_grey_img= (CGrey*) GetPixels();
 
(*pt_grey_img).value; // UCHAR
++pt_grey_img;

Code :

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

1
2
3
4
5
6
7
8
9
// ex de parcourt des pixel en rgba
CRGBA* pt_rgb_img= (CRGBA*) GetPixels();
 
(*pt_rgb_img).r; // UCHAR
(*pt_rgb_img).g; // UCHAR
(*pt_rgb_img).b; // UCHAR
(*pt_rgb_img).a; // UCHAR
 
++pt_rgb_img;

etc...

Ce n'est qu'une idée, je fais "un peu" comme cela pour "caster" des pointeurs de données d'images. En même temps qu'on manipule des pixels, on peut accéder aux valeurs de ceux ci.

On supprime l'appel de fonction, assez cher en temps proc, on supprime les multiplications. Déjà là on gagne énormément.

Ce n’est pas une manière super propre, car on suppose que pour r g b a, des composants UCHAR de la class CRGBA, qu’ils soient contigus en mémoire, je ne suis pas certain, mais ce n’est pas assuré, même si c’est généralement le cas. Pour en être certain, on peut ajouter un union dans la class sur un UINT pour la class CRGBA, pour une class CRGB, cela devient un poil plus compliqué, on peut faire un union sur un tableau UCHAR static de 3 éléments… etc...

Mais suivant le compilateur et la gestion de mémoire on pourrait, je pense avoir un problème surtout pour un tableau de 3 UCHAR. Mais si je n'écris pas de grosses bêtises

, cela devrait fonctionner dans la plupart des cas.
La c’était la construction « clean»

Sinon la solution la plus simple, que tout le monde utilise, c’est simplement un pointeur pour le parcourt de l’image, cela peut paraître abstrait pour beaucoup, mais c’est une, des bonnes manières de faire de mon point de vu pour manipuler des images.

**millie** · 31/07/2006, 23h20

Faire passer un pixel par pointeur ou directement sur la pile, je pense que ça ne change pas grand chose.

taille d'un pointeur = 32 bits (sur une machine classique);
taille d'un pixel au maximum = taille d'un Uint32 = 32 bits.

Donc au final, il y aura le même nombre de donnée sur la pile...

**Ti-R** · 31/07/2006, 23h27

Avec

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
Uint32 GetPixel(SDL_Surface* Surface, int x, int y)
{
    int bpp = Surface->format->BytesPerPixel;
 
    /* p est l'adresse du pixel que l'on veut récupérer */
    Uint8 *p = (Uint8 *)Surface->pixels + y * Surface->pitch + x * bpp;
 
    switch(bpp)
    {
    case 1:
        return *p;
 
    case 2:
        return *(Uint16*)p;
 
    case 3:
        if(SDL_BYTEORDER == SDL_BIG_ENDIAN)
            return p[0] << 16 | p[1] << 8 | p[2];
        else
            return p[0] | p[1] << 8 | p[2] << 16;
 
    case 4:
        return *(Uint32*)p;
    }
}

Au lieu de faire

Code :

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

1
2
3
4
 
for(int j=0;j<y;j++)
 for(int i=0;i<x;i++)
    GetPixel(Surface, i, j);

tu fais

Code :

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

1
2
3
4
5
6
 
CRGBA* pt_rgb_img= (CRGBA*) GetPixels(Surface);
 
for(int j=0;j<y;j++)
 for(int i=0;i<x;i++)
    *(pt_rgb_img++)

Tu peux essayer, en therme de perf, c le jour et la nuit !

**millie** · 31/07/2006, 23h28

Pis le problème de parcourir directement l'image comme ça, c'est de rendre le code peu réutilisable (même si c'est plus rapide).

Si on se retrouve à travailler avec une autre structure d'image, on doit tout recommencer. Alors qu'avec un GetPixel. c'est vite modifiable pour être utiliser avec une autre structure, ou un autre moteur graphique.

**millie** · 31/07/2006, 23h36

Cela dit, tu m'as donné une idée. Pourquoi faire les 4 switch case à chaque fois alors qu'il suffirait de le faire qu'une seule fois au début.

**Ti-R** · 31/07/2006, 23h40

Pis le problème de parcourir directement l'image comme ça, c'est de rendre le code peu réutilisable

Si c'est pour appliquer un flou a l'image, la fonction appelée est toujours la même....

S’il te manque les structures appropriées, faut juste les inclures, ce n'est pas la mort. Et le programme reste aussi propre. Non ?

**millie** · 31/07/2006, 23h40

En fait, j'ai testé, sur un traitement de 11 sec, je n'ai même pas gagné 0.5 sec.

**Ti-R** · 31/07/2006, 23h41

En enlevant juste le switch non ?

**millie** · 31/07/2006, 23h45

Envoyé par Ti-R

Si c'est pour appliquer un flou a l'image, la fonction appelée est toujours la même....

S’il te manque les structures appropriées, faut juste les inclures, ce n'est pas la mort. Et le programme reste aussi propre. Non ?

C'est toujours la même avec un même type d'encodage de l'image. Si on stocke l'image ligne par ligne, ou colonne par colonne, ça va pas être pareil. Avec l'application d'une convolution par exemple, ça va pas être les mêmes indices si on parcourt directement comme toi.

Alors qu'avec un getPixel, ça ne changera rien.

[FAQ] [SDL] Erreurs ?

Contribuez

Discussions similaires

Partager

Partager