Discussion :

[Powopaf]

Bonjour

J'utilise sdl et cherche a faire une fonction de floutage pour cela je fait des opérations sur les Uint8*

Voici une partie de mon code ou pixel est le pixel actuel de type Uint8*. on fait +1,+2 sur le pointeur pour récupérer les 2 autres couleurs (on commence sur le rouge)
je déclare side_pixels comme ça :

Code :

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

1
2
 
Utin8* side_pixels[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };

Code :

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

1
2
3
4
5
6
7
8
9
 
Uint8* moy = 0;
            for (size_t i = 0; i < 8; i++) {
                moy = moy + side_pixels[i];
            }
            moy = moy / 8;
            pixel[0] = moy;
            pixel[1] = moy;
            pixel[2] = moy;

Voici mon message d'erreur :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
gcc  -o blur.o -c blur.c
blur.c: In function ‘blurring’:
blur.c:37:27: error: invalid operands to binary + (have ‘Uint8 *’ {aka ‘unsigned char *’} and ‘Uint8 *’ {aka ‘unsigned char *’})
   37 |                 moy = moy + side_pixels[i];
      |                           ^ ~~~~~~~~~~~~~~
      |                                        |
      |                                        Uint8 * {aka unsigned char *}
blur.c:39:23: error: invalid operands to binary / (have ‘Uint8 *’ {aka ‘unsigned char *’} and ‘int’)
   39 |             moy = moy / 8;

[edgarjacobs]

Hello,

Avec juste ce petit bout de code, tout ce que je peux dire, c'est: pourquoi employer des Uint8 * ? Uint8 *side_pixels[8] déclare un tableau de 8 pointeurs sur des Uint8, pas un tableau de 8 Uint8. Idem pour moy.

Accessoirement, pour initialiser un tableau à zéro, on peut écrire

Code :

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

Uint8 side_pixels[8]={0};

Pas besoin de se farcir tous les éléments.

[foetus]

Il faut revoir les cours de C

les 2 opérations que tu veux faire l'addition des éléments et la division ne nécessite aucun pointeur.

Donc:

Code :

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

1
2
3
4
5
6
    Uint8 moy = 0;
 
    for (size_t i = 0; i < 8; i++) {
        moy = moy + side_pixels[i];
    }
    moy = moy / 8;

Sinon il faut utiliser la syntaxe pointeur

Code :

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

1
2
3
4
5
6
7
8
9
10
    Uint8* moy = malloc( sizeof(Uint8) ); // test NULL
 
    (*moy) = 0;
    for (size_t i = 0; i < 8; i++) {
        (*moy) = (*moy) + side_pixels[i];
    }
    (*moy) = (*moy) / 8;
 
//  ...
    free(moy)

[Guesset]

Bonjour,

Nonobstant les corrections évoquées, avec un environnement de points d'un seul Uint8, je ne vois pas comment obtenir un flou pertinent pour un pixel à 3 composantes.

Ensuite la somme de 8 Uint ne tient pas nécessairement dans un seul.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
    Utin8 side_pixels[8][3];
    // ...
 
    Uint16 moy[3] = {0};
     for (size_t i = 0; i < 8; i++) {
        moy[0] += side_pixels[i][0];
        moy[1] += side_pixels[i][1];
        moy[2] += side_pixels[i][2];
    }
    pixel[0] = Uint8(moy[0]  >> 3);
    pixel[1] = Uint8(moy[1]  >> 3);
    pixel[2] = Uint8(moy[2]  >> 3);

J'ai gardé l'approche en tableau qui n'est pas nécessairement la meilleure (ne serait-ce qu'en terme de lisibilité). Une structure RGBZ serait plus facile à utiliser d'autant si elle est en union avec un Uint32 :

Code :

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

1
2
struct TPixel { Uint8 R, G, B, Z; }; 
union TPixelx { Uint32 clr; TPixel px };

Ensuite, c'est typiquement un domaine où l'usage des instructions SIMD font des merveilles, mais cela nécessite d'inclure du code asm...

Enfin, en général, dans un flou on garde une pondération non nulle (voire plutôt supérieure à celles des points alentours du pixel à flouter) or ici elle est nulle.

Salutations