Discussion :

[Zaac02]

Bonjour,

Je travail actuellement sur un projet tutoré qui consiste à gérer de la vision avec lunette 3D avec opengl. Pour le moment j'arrive a charger une image, à extraire les trois composantes RVB de mon image et à afficher mes deux images avec un décalage afin d'obtenir mon effet de relief. Le problème est que j'affiche mon image rouge et mon image bleu, hors les lunettes sont bleu et cyan.

Mon problème est donc de savoir comment je peux extraire la composante cyan de mon image ?

Je vous joint l'ensemble de mon code actuel

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
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
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
#include <GL/glut.h>
#include <stdio.h>
#include <jpeglib.h>
#include <jerror.h>
#include <stdlib.h>
 
unsigned char image[800*600*3];
unsigned char texture[800][600][3];
unsigned char rouge[800][600][3],vert[800][600][3],bleu[800][600][3];
 
void affichage();
void displayEye();
void loadJpegImage(char *fichier);
 
int main(int argc,char **argv)
{
 
  loadJpegImage("paysage.jpg");
  /* initialisation de glut et creation
     de la fenetre */
  glutInit(&argc,argv);
  glutInitDisplayMode(GLUT_RGB);
  glutInitWindowPosition(250,100);
  glutInitWindowSize(800,600);
  glutCreateWindow("Lunette 3D");
 
  /* Initialisation d'OpenGL */
  glClearColor(0.0,0.0,0.0,0.0);
  glShadeModel(GL_FLAT);
  glColor3f(1.0,1.0,1.0);
  glPointSize(1.0);
  /* enregistrement des fonctions de rappel */
  glutDisplayFunc(affichage);
 
  /* Entree dans la boucle principale glut */
  glutMainLoop();
  return 0;
}
 
 
 
void affichage()
{  
 
  /* effacement de l'image avec la couleur de fond */
  glClear(GL_COLOR_BUFFER_BIT | GL_ACCUM_BUFFER_BIT);
 
  glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST);
  glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST);
  glTexImage2D(GL_TEXTURE_2D,0,GL_RGB,800,600,0,GL_RGB,GL_UNSIGNED_BYTE,rouge);
  glEnable(GL_TEXTURE_2D);
 
  //glColorMask(1,0,0,1);
 
  displayEye();
 
  glTranslatef(0.02,0,0);
  glTexImage2D(GL_TEXTURE_2D,0,GL_RGB,800,600,0,GL_RGB,GL_UNSIGNED_BYTE,bleu);
  glColorMask(0,1,1,1);
 
  displayEye();
  /* on force l'affichage du resultat */
  glFlush();
}
 
 
 
void displayEye(void){
  /* Dessin du polygone */
  glBegin(GL_POLYGON);
  //glColor3f(1.0,0.0,0.0);
  glTexCoord2i(0,1);glVertex2f(-1,-1);
  //glColor3f(0.0,1.0,0.0);
  glTexCoord2i(1,1);glVertex2f(1,-1);
  //glColor3f(0.0,0.0,1.0);
  glTexCoord2i(1,0);glVertex2f(1,1);
  //glColor3f(1.0,1.0,1.0);
  glTexCoord2i(0,0);glVertex2f(-1,1);
  glEnd();
}
 
 
 
 
void loadJpegImage(char *fichier)
{
  struct jpeg_decompress_struct cinfo;
  struct jpeg_error_mgr jerr;
  FILE *file;	
  unsigned char *ligne;
  int i,j;
 
  cinfo.err = jpeg_std_error(&jerr);
  jpeg_create_decompress(&cinfo);
  if ((file=fopen(fichier,"rb"))==NULL)
    {
      fprintf(stderr,"Erreur : impossible d'ouvrir le fichier texture.jpg\n");
      exit(1);
    }
  jpeg_stdio_src(&cinfo, file);
  jpeg_read_header(&cinfo, TRUE);
 
  if ((cinfo.image_width!=800)||(cinfo.image_height!=600)) {
    fprintf(stdout,"Erreur : l'image doit etre de taille 800x600\n");
    exit(1);
  }
 
  if (cinfo.jpeg_color_space==JCS_GRAYSCALE) {
    fprintf(stdout,"Erreur : l'image doit etre de type RGB\n");
    exit(1);
  }
 
  jpeg_start_decompress(&cinfo);
  ligne=image;
  while (cinfo.output_scanline<cinfo.output_height)
    {
      ligne=image+3*800*cinfo.output_scanline;
      jpeg_read_scanlines(&cinfo,&ligne,1);
    }
  jpeg_finish_decompress(&cinfo);
  jpeg_destroy_decompress(&cinfo);
 
  for (i=0;i<800;i++){
    for (j=0;j<600;j++) {
      //image RVB
      texture[i][j][0]=image[i*600*3+j*3];
      texture[i][j][1]=image[i*600*3+j*3+1];
      texture[i][j][2]=image[i*600*3+j*3+2];
 
      //image rouge
      rouge[i][j][0]=image[i*600*3+j*3];
      //image verte
      vert[i][j][1]=image[i*600*3+j*3+1];
      //image bleu
      bleu[i][j][2]= image[i*600*3+j*3+2];  
    }
  }
 
}

Merci d'avance pour votre aide.

[buggen25]

Salut
Vert + Bleu = Cyan
Dans ton image chaque pixel est composé de triplet (R,V,B) pour rouge, vert, Bleu. comme le Cyan est composé de Vert + Bleu il suffit de recuperer les pixels dont les composantes Vert et Bleu sont egales a 1.0f et la composante Rouge est egale a 0.0f

ps : ah glut sa fait un baille, glutEnterGameMode() tu me manque

[buggen25]

re:
Une petite precision.
tu a utilisé unsigned char pour les matrices qui vont contenir les triplet RVB(R,V,B) danc tu récupère les pixel avec un triplet RVB(0,255,255)
j'espère que sa peut t'aider
cordialement a+

[Zaac02]

merci je teste ça