Couleur d'un pixel d'une fenêtre glut en mode RGB

      Bonjour à tous,
Je voudrais savoir s'il existait une fonction permettant de récupérer les composantes
de la couleur d'un pixel de coordonnées (x,y) d'une fenêtre opengl (glut)
en mode RGBA... 
  J'ai en fait charger une image .ppm avec la fonction suivante et voudrais utiliser les
couleurs de chaque pixel pour une une comparaison...  merci de votre réponse!!!


typedef struct {
    int sizeX, sizeY;
    GLubyte *data;
} PPMImage;

static PPMImage *LoadPPM(const char *filename)
{
    char buff[16];
    PPMImage *result;
    FILE *fp;
    int maxval,lig_comm=0;

    fp = fopen(filename, "rb");
    if (!fp)
    {
fprintf(stderr, "Unable to open file `%s'\n", filename);
exit(1);
    }

    if (fread(buff, 1, 3, fp)!=3)
    {
perror(filename);
exit(1);
    }

    if (buff[0] != 'P' || buff[1] != '6')
    {
fprintf(stderr, "Invalid image format (must be `P6')\n");
exit(1);
    }

    if (buff[2] != 0x0a)
      fseek(fp,-1,SEEK_CUR);

    while (fgetc(fp) == '#'){
      lig_comm++;
      while (fgetc(fp) != '\n')
;
      }

    fseek(fp,-1,SEEK_CUR);

    result = (PPMImage *)malloc(sizeof(PPMImage));
    if (!result)
    {
fprintf(stderr, "Unable to allocate memory\n");
exit(1);
    }

    if (fscanf(fp, "%d %d", &result->sizeX, &result->sizeY) != 2)
    {
fprintf(stderr, "Error loading image `%s'\n", filename);
exit(1);
    }

    if (fscanf(fp, "%d", &maxval) != 1)
    {
fprintf(stderr, "Error loading image `%s'\n", filename);
exit(1);
    }

    while (fgetc(fp) != '\n')
;

    result->data = (GLubyte *)malloc(3 * result->sizeX * result->sizeY);
    if (!result)
    {
fprintf(stderr, "Unable to allocate memory\n");
exit(1);
    }

    if (fread(result->data, 3 * result->sizeX, result->sizeY, fp) != result->sizeY)
    {
fprintf(stderr, "Error loading image `%s'\n", filename);
exit(1);
    }

    fclose(fp);

    return result;
}

Ouaip ca existe, regardes du cote de glReadPixel / et glReadBuffer au cas ou tu sois en double buffer.

@+, KeniiyK.

Merci de ta réponse Keniiyk, mais en fait,  glReadPixels(GLint x,GLint y,GLsizei l,
GLsizei h,GLenum format,GLenum type,GLvoid *pixels) renvoie dans pixels le
contenu d'une zone rectangulaire lue dans le tampon chromatique et moi je voudrais
savoir s'il était possible de juste répurer format, donc la composante de la couleur,
dans une variable x par exemple de même type que type... j'espère qu'il existe
un moyen, merci.

Et ben tu fais
GLubyte pixel[4];
glReadPixels(x,y,1,1,GL_RGBA,GL_UNSIGNED_BYTE,pixel);

et apres pixel[0] == composante rouge, pixel[1] == composante vert, pixel[2] == composante bleue, pixel[3] == composante alpha.



KeniiyK

Je te remercie Keniiyk, grace à toi j'y vois plus claire, car en effet cela m'a l'air de
marcher pas mal ... merci encore et à la prochaine astuce!!!

En fin de compte, pixel[0] == composante rouge, pixel[1] == composante vert, pixel[2] == composante bleue, pixel[3] == composante alpha. ne donnent pas les valeurs
qu'il faut après avoir chargé image .ppm... je ne sais pas si c'est un problème
d'initialisation... mais je n'arrive pas à voir ce que c'est, est-ce peut être un
problème d'initialisation?

glReadPixels(x,y,1,1,GL_RGBA,GL_UNSIGNED_BYTE,pixel);

cet appel lis en x,y coord fenetre sur un carre 1*1, c'est peut-etre ca....

(si pa ca di clairement ce que tu veu faire)


KeniiyK

En fait j'ai les 2 déclarations suivantes: GLubyte *image et GLubyte pixels[4].
Mon image est chargé dans *image que j'affiche avec glDrawPixels(...) et jusque là,
pas de problème. Mais j'ai remarqué que lorsque je chargais l'image complète dans
pixel[4] avec glReadPixels(x,y,width,height,GL_RGBA,GL_UNSIGNED_BYTE,pixel),
printf("La composante rouge est : %u\n",pixel[0]);
printf("La composante verte est : %u\n",pixel[1]);
printf("La composante bleue est : %u\n",pixel[2]);
printf("La composante alpha est : %u\n",pixel[3]);
ne m'affichent pas les mêmes résultats que
printf("La composante rouge est : %u\n",image[0]);
printf("La composante verte est : %u\n",image[1]);
printf("La composante bleue est : %u\n",image[2]);
printf("La composante alpha est : %u\n",image[3]);
qui eux m'ont paru plus logique vu la couleur de l'image affiché. Mais, comme je
voudrais travailler avec la couleur de chaque pixel, je me dis peut être que
je travaillerai avec des composantes couleur fausses lorsque je vais charger un pixel
avec lReadPixels(x,y,1,1,GL_RGBA,GL_UNSIGNED_BYTE,pixel), vu que le
résultat n'a pas été satisfaisant sur l'image complète...

Ok mais glReadPixel fonctionne en coordonnée fenetre (== coord souris) et glDrawPixel() marche avec la position de trame active donc surement que tu lis des valeurs qui sont bien dans l'image mais qui ne sont pas au meme coordonnées, tu vois ce que je veux dire...?

KeniiyK

il est aussi possible que ton image soit en RGB et non en RGBA