Discussion :

[floopi51]

bonjour

je recupère la valeur du pixel d'une image dans un entier. Le pixel est codé en RGB. Cela signifie que mon entier contient 4 informations stockées chacune sur un octet : la valeur pour le rouge, pour le vert, pour le bleu et pour l'alpha.
je souhaite récupérer chacune de ces informations séparément dans un entier.

Pour celà j'ai écrit 3 fonctions opérant chacune un décalage et appliquant un masque pour obtenir les valeurs pour les composantes red, green et blue.

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
 
int 
redFromRGB(int *rgb){
   return ((*rgb >> 16) & 0xff);
}
 
int 
greenFromRGB(int *rgb){
  return ((*rgb >> 8) & 0xff);
}
 
int 
blueFromRGB(int *rgb){
     return((*rgb) & 0xff);
}

Problème : je récupère toujours 0 pour les composants red et green.
Où est mon erreur ?

merci pour votre aide

[pfeuh]

Salut,

Problème : je récupère toujours 0 pour les composants red et green.
Où est mon erreur ?

merci pour votre aide

Peut-être un problème d'endianess? essaie avec quelque chose du genre

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <stdio.h>
 
int blueFromRGB(int *rgb);
int blueFromRGB(int *rgb)
{
    int tempval = *rgb;
     return (tempval & 0xff);
}
 
int main()
{
    int mycolor = 0x123456;
    printf ("blue : %02x",blueFromRGB(&mycolor )) ;
    return 0;}

A+

Pfeuh

[diogene]

Ca marche pour moi. Comment et avec quelle valeur appelles-tu tes fonctions ?

[floopi51]

voici l'extrait de code ou j'appelle mes fonctions :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
  int* c_pix;
 ....
      red = redFromRGB(c_pix);
      green = greenFromRGB(c_pix);
      blue = blueFromRGB(c_pix);
 
      fprintf(stderr,"*c_pix=<%d>\n",*c_pix);
      fprintf(stderr,"red=<%d>\n",pix->red);
      fprintf(stderr,"green=<%d>\n",pix->green);
      fprintf(stderr,"blue=<%d>\n",pix->blue);

si j'ai *c_pix = 127.
je recupère :
red = 0
green = 0
blue = 127

[Emmanuel Delahaye]

bonjour

je recupère la valeur du pixel d'une image dans un entier. Le pixel est codé en RGB. Cela signifie que mon entier contient 4 informations stockées chacune sur un octet : la valeur pour le rouge, pour le vert, pour le bleu et pour l'alpha.
je souhaite récupérer chacune de ces informations séparément dans un entier.
Problème : je récupère toujours 0 pour les composants red et green.
Où est mon erreur ?

Je ne vois pas trop de problèmes avec ce code, à part que tout devrait se faire en unsigned...

Ceci :

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
 
#include <stdio.h>
 
int redFromRGB (int *rgb)
{
   return ((*rgb >> 16) & 0xff);
}
 
int greenFromRGB (int *rgb)
{
   return ((*rgb >> 8) & 0xff);
}
 
int blueFromRGB (int *rgb)
{
   return ((*rgb) & 0xff);
}
 
int main (void)
{
   unsigned long rgb = 1;
 
   while (rgb != 0)
   {
      printf ("R=%d ", redFromRGB ((int *) &rgb));
      printf ("G=%d ", greenFromRGB ((int *) &rgb));
      printf ("B=%d\n", blueFromRGB ((int *) &rgb));
      rgb <<= 1lu;
   }
 
   return 0;
}

donne

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
 
R=0 G=0 B=1
R=0 G=0 B=2
R=0 G=0 B=4
R=0 G=0 B=8
R=0 G=0 B=16
R=0 G=0 B=32
R=0 G=0 B=64
R=0 G=0 B=128
R=0 G=1 B=0
R=0 G=2 B=0
R=0 G=4 B=0
R=0 G=8 B=0
R=0 G=16 B=0
R=0 G=32 B=0
R=0 G=64 B=0
R=0 G=128 B=0
R=1 G=0 B=0
R=2 G=0 B=0
R=4 G=0 B=0
R=8 G=0 B=0
R=16 G=0 B=0
R=32 G=0 B=0
R=64 G=0 B=0
R=128 G=0 B=0
R=0 G=0 B=0
R=0 G=0 B=0
R=0 G=0 B=0
R=0 G=0 B=0
R=0 G=0 B=0
R=0 G=0 B=0
R=0 G=0 B=0
R=0 G=0 B=0
 
Process returned 0 (0x0)   execution time : 0.035 s
Press any key to continue.

ce qui me parait normal.

Et je suggère de ne faire qu'une fonction qui charge une structure rgb...

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
 
#include <stdio.h>
 
struct rgb
{
   unsigned r;
   unsigned g;
   unsigned b;
};
 
void getFromRGB (struct rgb *p_rgb, unsigned long i_rgb)
{
   p_rgb->r = (i_rgb >> (8*2)) & 0xFF;
   p_rgb->g = (i_rgb >> (8*1)) & 0xFF;
   p_rgb->b = (i_rgb >> (8*0)) & 0xFF;
}
 
int main (void)
{
   unsigned long i_rgb = 1;
 
   while (i_rgb != 0)
   {
      struct rgb rgb;
 
      getFromRGB (&rgb, i_rgb);
 
      printf ("R=%d ", rgb.r);
      printf ("G=%d ", rgb.g);
      printf ("B=%d\n",rgb.b);
      i_rgb <<= 1lu;
   }
 
   return 0;
}

[Emmanuel Delahaye]

voici l'extrait de code ou j'appelle mes fonctions :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
  int* c_pix;
 ....
      red = redFromRGB(c_pix);
      green = greenFromRGB(c_pix);
      blue = blueFromRGB(c_pix);
 
      fprintf(stderr,"*c_pix=<%d>\n",*c_pix);
      fprintf(stderr,"red=<%d>\n",pix->red);
      fprintf(stderr,"green=<%d>\n",pix->green);
      fprintf(stderr,"blue=<%d>\n",pix->blue);

si j'ai *c_pix = 127.
je recupère :
red = 0
green = 0
blue = 127

Si tu passes des pointeurs non initialisés, il se passe n'importe quoi. Le comportement est indéfini.

[crocodilex]

si j'ai *c_pix = 127.
je recupère :
red = 0
green = 0
blue = 127

Où est le problème ?

[floopi51]

effectivement vu comme ça il n'y a pas de problème.
mais sachant que je recupère les données dans une image qui n'est pas toute bleue, j'ai un problème......

celà doit venir de ma façon de lire les données....
en tout cas merci pour vos réponses.
je continue de chercher........

[floopi51]

en relisant mon code je viens de voir que je ne lisais qu'un octet dans mon fichier au lieu de 4...... donc je ne pouvais pas avoir 4 informations dans mon entier

merci.

[floopi51]

re-... suite :

j'utilise la fonction fread pour récupérer mes 4 octets dans un fichier.
quand j'édite mon fichier en hexa, les données sont dans l'ordre : 78 9c ed 7d.

Lorsque j'affiche la valeur récupérée, j'obtiens : 7d ed 9c 78.

Pourquoi les valeurs sont-elles inversées ??

voici 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
 
int * c_pix
 
....
 
      c_pix = (int*)malloc(sizeof(int));
      if(c_pix == NULL) {
	fprintf(stderr,"Out of memory\n");
	return 1;
      }
      fread(c_pix, 4, 1, fileIn);
 
      /* allocation de la structure de données */
      pix = (struct pixel*)malloc(sizeof(struct pixel));
      if(pix == NULL) {
	fprintf(stderr,"Out of memory\n");
	return 1;
      }
      pix->red = redFromRGB(c_pix);
      pix->green = greenFromRGB(c_pix);
      pix->blue = blueFromRGB(c_pix);
 
	printf("*c_pix=<%08x>\n",*c_pix);
	printf("red=<%d>\n",pix->red);
	printf("green=<%d>\n",pix->green);
	printf("blue=<%d>\n",pix->blue);

merci

[Emmanuel Delahaye]

re-... suite :

j'utilise la fonction fread pour récupérer mes 4 octets dans un fichier.
quand j'édite mon fichier en hexa, les données sont dans l'ordre : 78 9c ed 7d.

Lorsque j'affiche la valeur récupérée, j'obtiens : 7d ed 9c 78.

Pourquoi les valeurs sont-elles inversées ??

Parce que la représentation des entiers peut varier d'une machine à l'autre. Je ne sais pas quelle est la spec de ton fichier, mais l'usage est MSB en tête (comme pour le réseau). Pour lire ce format de manière portable, je recommande ;

Code :

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

1
2
3
4
5
6
7
8
 
{
   unsigned long x = 0;
 
   x |= (fgetc(fp) << (8ul * 3); /* MSB en tete */
   x |= (fgetc(fp) << (8ul * 2);
   x |= (fgetc(fp) << (8ul * 1);
   x |= (fgetc(fp) << (8ul * 0);

Evidemment, une fonction serait toute indiquée...

[pfeuh]

quand j'édite mon fichier en hexa, les données sont dans l'ordre : 78 9c ed 7d.
Lorsque j'affiche la valeur récupérée, j'obtiens : 7d ed 9c 78.

Serais-tu en train de lire un fichier ".bmp"? La spec indique que pour une couleur 24 bits, on donne quatre octets par pixel, dans l'ordre bleu, vert, rouge et un quatrième inutilisé. Attends toi à une autre surprise, le bitmap contient les lignes de la dernière à la première.

une spec des .bmp

A+

Pfeuh

[floopi51]

Serais-tu en train de lire un fichier ".bmp"? La spec indique que pour une couleur 24 bits, on donne quatre octets par pixel, dans l'ordre bleu, vert, rouge et un quatrième inutilisé. Attends toi à une autre surprise, le bitmap contient les lignes de la dernière à la première.

une spec des .bmp

A+

Pfeuh

non je lis un fichier .png. Les caractéristiques sont : image truecolor, bit-depth=8.

[pfeuh]

non je lis un fichier .png. Les caractéristiques sont : image truecolor, bit-depth=8.

Ah, ça je ne connais pas trop, mais je crois que c'est comme un .gif, il y a une palette de 256 couleurs (je ne sais pas si c'est en 24 ou 32 bits, voir une spec .png) et chaque pixel est un index 0-255 dans la table des couleurs (la palette). Je crois qu'il y a en plus une compression pour les pixels consécutifs de la même couleur.

A+

Pfeuh

[floopi51]

Parce que la représentation des entiers peut varier d'une machine à l'autre. Je ne sais pas quelle est la spec de ton fichier, mais l'usage est MSB en tête (comme pour le réseau). Pour lire ce format de manière portable, je recommande ;

le fichier que je lis est de type png. J'ai bien lu les spec de l'entête, je la recupère avant pour lire ensuite les pixels. Je recupère chaque pixel dans un entier.
je fais l'edition du fichier en héxa sur la même machine que celle où je fais tourner mon programme C. Je m'attends donc à ce que la lecture du fichier se fasse dans le même sens.

qu'est-ce que MSB ?

Floopi51

[Emmanuel Delahaye]

qu'est-ce que MSB ?

Most Significant Bits (bits de poids fort)

[floopi51]

Most Significant Bits (bits de poids fort)

étant donné que ce que je récupère sous forme d'un entier est un pixel codé sur 4 bits, qu'est ce qui détermine où seront les bits de poids forts ?


Floopi51

[Emmanuel Delahaye]

étant donné que ce que je récupère sous forme d'un entier est un pixel codé sur 4 bits, qu'est ce qui détermine où seront les bits de poids forts ?

4 bits ? Tu veux sans doute dire 4 octets ? Eh bien, c'est la spec qui dit comment sont codés les données...

La norme réseau dit que le transmission des données se fait MSB en tête. Ca signifie, par exemple, qu'un mot de 32-bit valant 0x12345678 est codé avec une séquence de 4 octets comme suit :

Code :

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

1
2
3
4
5
 
[0] 12 
[1] 34 
[2] 56 
[3] 78

C'est en général le mode de codage retenu pour le fichiers. Mais certaines spécifications ne suivent pas cette norme et définsieent LSB en tête. Le même mot est alors codé :

Code :

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

1
2
3
4
5
 
[0] 78 
[1] 56 
[2] 34 
[3] 12

[floopi51]

4 bits ? Tu veux sans doute dire 4 octets ? Eh bien, c'est la spec qui dit comment sont codés les données...

dans ce cas comment expliquer que pour un même fichier, lorque je l'édite avec hexedit, j'obtiens 4 octets dans l'ordre "78 9C ED 7D" et lorsque je les recupère avec fread j'obtiens "7D ED 9C 78" ?

floopi51

[Invité(e)]

Bonjour,

étant donné que ce que je récupère sous forme d'un entier est un pixel codé sur 4 bits, qu'est ce qui détermine où seront les bits de poids forts ?

N'y a-t-il pas confusion entre bit et octet ?

Les spécifications PNG demandent le MSB en premier. Attention, cela n'a de sens que pour les images où la profondeur pixel est supérieure à 8 bits, les images 3x8bits ou 4x8bits ne sont donc pas concernées.

dans ce cas comment expliquer que pour un même fichier, lorque je l'édite avec hexedit, j'obtiens 4 octets dans l'ordre "78 9C ED 7D" et lorsque je les recupère avec fread j'obtiens "7D ED 9C 78" ?

hexedit édite caractère par caractère.
Si tu lis un entier avec fread, il va tenir compte de l'endianness de ton système.

Si tu lis deux entiers 16 bits avec fread, il y a de fortes chances que tu obtiennes 9C 78 : 7D ED.