Dessiner des pixels

Version imprimable

18/09/2016, 19h49
Syarko

Dessiner des pixels

Bonsoir,

Dans mon programme en C, j'ai une matrice d'entier. Chaque case a pour valeur soit 0 (pour blanc), 1 (pour noir) ou 2 (pour rouge). Ce que j'aimerais faire, c'est dessiner cette matrice dans une fenêtre pour en avoir une représentation graphique où chaques cases representerait un pixel. Le problème, c'est qu'il y a pas mal de librairie graphique. J'ai essayé GTK+, mais je n'arrive absolument pas à faire ce que je veux : je trouve très peu d'informations sur internet. :/

Si quelqu'un aurait une idée de comment faire, j'en serai ravi :) :)

Merci.
18/09/2016, 20h44
SkyZoThreaD

Bonsoir.

Tu peux utiliser SDL et la méthode put_pixel() sur la SDL_Surface de la fenêtre.
18/09/2016, 21h51
Syarko

J'ai reussi à créer une fenetre. Par contre la fonction put_pixel(), est -elle definit ?
J'ai trouvé sur la doc de la SDL qu'il y avait une fonction putpixel(), mais en essayant de l'utiliser, la aussi on me dit qu'aucune fonction putpixel() existe. :/
En attendant, j'ai copier/coller le code de putpixel() d'ici : http://sdl.beuc.net/sdl.wiki/Pixel_Access.

Mais si elle existe vraiment putpixel(), faut-il rajouter un #include ou quelque chose d'autre ?
19/09/2016, 10h11
Matt_Houston

Tu peux directement intervenir sur la matrice de pixels d'un SDL_Surface. N'oublie pas d'encapsuler tes accès au sein d'un couple SDL_LockSurface / SDL_UnlockSurface.

Attention, tu sembles te référer à la documentation de la SDL 1.2. Tu utilises probablement (ou tu devrais) la version 2 de l'API : SDL_Surface.

Citation:

Envoyé par Syarko

J'ai reussi à créer une fenetre. Par contre la fonction put_pixel(), est -elle definit ?
J'ai trouvé sur la doc de la SDL qu'il y avait une fonction putpixel(), mais en essayant de l'utiliser, la aussi on me dit qu'aucune fonction putpixel() existe. :/
En attendant, j'ai copier/coller le code de putpixel() d'ici : http://sdl.beuc.net/sdl.wiki/Pixel_Access.

Mais si elle existe vraiment putpixel(), faut-il rajouter un #include ou quelque chose d'autre ?

Pardon je ne me rappelais plus que c'était pas natif :aie:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 // La struct pixel typedef struct { Uint8 r; Uint8 g; Uint8 b; Uint8 a; } pixel; // l'assignation pixel pixel; pixel.r = (Uint8)0xff; pixel.g = (Uint8)0xff; pixel.b = (Uint8)0xff; pixel.a = (Uint8)128; // la fonction :) void put_pixel(SDL_Surface* surf, int x,int y,pixel* p) { Uint32* p_screen = (Uint32*)surf->pixels; p_screen += y*surf->w+x; *p_screen = SDL_MapRGBA(surf->format,p->r,p->g,p->b,p->a); }
il faut bloquer la surface avant d'utiliser cette fonction:
Code:

1 2 3 SDL_LockSurface(surf); put_pixel(...); SDL_UnlockSurface(surf);

Voilà mon code :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 void drawWindow(){ SDL_Init( SDL_INIT_EVERYTHING); SDL_Surface *ecran = SDL_SetVideoMode(512,128,32, SDL_HWSURFACE); pixel pixel; for(int i = 0; i < 512; ++i){ for(int j = 0; j < 128; ++j){ pixel.r = (Uint8)0xff; pixel.g = (Uint8)0xff; pixel.b = (Uint8)0xff; pixel.a = (Uint8)128; SDL_LockSurface(ecran); put_pixel(ecran, i, j, &pixel); SDL_UnlockSurface(ecran); } } pause(); SDL_Quit(); }
Théoriquement, je devrais obtenir une fenêtre toute blanche. Sauf que, des fois, soit la fenêtre est blanche comme prévu, soit elle reste noire. Et je ne comprends vraiment pas pourquoi. :/
Pour info, j'ai repris la fonction put_pixel() donnait plus haut dans ce post.
Ce problème subsiste egalement avec la fonction putpixel() trouvé ici : http://sdl.beuc.net/sdl.wiki/Pixel_Access

Tu n'update peut-être pas la Window à chaque frame ?
C'est jamais évident de prendre en main une lib qu'on ne connaît pas ;)
Voici un code simpliste qui fait ce que tu veux:

Code:

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
#include <SDL.h>
 
SDL_Window *mWindow;
SDL_Surface *mMainSurface;
 
const int Win_W = 1024   ;
const int Win_H = 768;
 
typedef struct {
    Uint8 r;
    Uint8 g;
    Uint8 b;
    Uint8 a;
} pixel;
 
void put_pixel(SDL_Surface* surf, int x,int y,pixel* p)
{
    Uint32* p_screen = (Uint32*)surf->pixels;
    p_screen += y*surf->w+x;
    *p_screen = SDL_MapRGBA(surf->format,p->r,p->g,p->b,p->a);  
}
 
int main( int argc, char* args[] )
{
    pixel mpixel;
    mpixel.r = (Uint8)0xff;
    mpixel.g = (Uint8)0xff;
    mpixel.b = (Uint8)0xff;
    mpixel.a = (Uint8)128;
 
    if( SDL_Init( SDL_INIT_EVERYTHING ) < 0 )
    {
        return -1;
    }
    else
    {
        mWindow = SDL_CreateWindow( "test", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, Win_W, Win_H, SDL_WINDOW_SHOWN );
        if( mWindow == NULL )
        {
            return -2;
        }
        else
        {
            mMainSurface = SDL_GetWindowSurface( mWindow );
 
            while (1)
            {
                SDL_LockSurface(mMainSurface);
 
                for(int ix = 0; ix < Win_W; ix++)
                    for(int iy = 0; iy < Win_H; iy++)
                        put_pixel(mMainSurface, ix, iy, &mpixel);
 
                SDL_UnlockSurface(mMainSurface);
 
                SDL_UpdateWindowSurface( mWindow );
            }
        }
    }
 
    return 0;
}

19/09/2016, 21h22
Syarko

Merci, ca marche. A part le fait que au bout de quelques secondes, la fenêtre se grise pour m'avertir que la fenêtre ne répond plus. :/

Vu que ma fenêtre se base sur une matrice qui évolue dans le temps, j'ai placé le code ci dessus dans un pthread, et qui fait une boucle infinie et redessine la fenêtre en fonction de l’évolution de la matrice.
Mais comme dit plus haut, ma fenêtre se grise, même si les pixels bouge derrière. Une idée ?

Finalement je viens de trouver la solution.

J'ai rajouter ce bout de code dans la boucle while() :
Code:

1 2 3 4 5 6 7 8 if(SDL_PollEvent(&event)){ switch(event.type){ case SDL_QUIT: quit = 1; break; } }
Voilà, tout à l'air de marcher. Merci pour votre aide :) Je pense pouvoir mettre ce poste en Résolu. :D

19/09/2016, 22h29
SkyZoThreaD
Citation:

Envoyé par Syarko

Merci, ca marche. A part le fait que au bout de quelques secondes, la fenêtre se grise pour m'avertir que la fenêtre ne répond plus. :/

Vu que ma fenêtre se base sur une matrice qui évolue dans le temps, j'ai placé le code ci dessus dans un pthread, et qui fait une boucle infinie et redessine la fenêtre en fonction de l’évolution de la matrice.
Mais comme dit plus haut, ma fenêtre se grise, même si les pixels bouge derrière. Une idée ?

C'est parce que les events ne sont pas traités. Je voulais te laisser un peut de boulot :mouarf:
Tu peux ajouter
Code:

1 2 SDL_Event event; SDL_PollEvent(&event);
Au début de la boucle pour intercepter les events (clavier souris fenêtre...). Ainsi windows comprendra que le programme marche bien ;)

edit : De rien, pas le temps de rédiger une réponse que tu trouves tout seul... :mrgreen: Bonne continuation.