Addition et division sur des Uint8

Version imprimable

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:

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

Code:

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:

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;

27/09/2024, 23h25
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:

Uint8 side_pixels[8]={0};

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

Il faut revoir les cours de C :aie: :mrgreen:

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

Donc:

Code:

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:

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)

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:

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:

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