Discussion :

[yacinechaouche]

Salut,

Je voudrais que quelqu'un m'explique ce que je dois faire precisement pour avoir la valeur d'un pixel de ma fenetre dont les coordonnées sont x et y.

Merci à tous ceux qui réponderont.

[GLDavid]

C'est pour du traitement image ?
Parce que là, c'est vague

[bafman]

regarde du coté de glReadPixel() je peut pas te dire comment ca marche precisement car j'ai pas ma doc mais c'est ca qu'il faut utiliser (attention c'est quand même super lent. Sur un de même projet j'avait utilisé ca pour lire 1 pixel a l'ecran et je perdait ~30 fps )

[yacinechaouche]

Salut à tous,

Merci d'avoir pris la peine de lire et de répondre à mon post.

En fait ce que je veux faire c'est de dessiner des cercles sur une fenetre de la maniere suivante :

Je dessiner n cercles de rayon 1( 1 pixel),puis je dessine n cercles cocentriques aux n derniers,avec un rayon de 2 pixel, et je reitere jusqu'à un rayon assez grand.Evidement,une fois que le rayon deviens suffisasment grand,les cercles de plus en de plus grand vont se rejoindre.Dans ce cas,avant de dessiner un point d'un cercle quelqonc,je teste d'abord si le point que je vais dessiner n'appartient pas dàjç à un autre cercle (intersection avec un autre cercle),si le point est "vide",je dessine.Si le point est dèjà dessiner,je ne le dessine pas une deuxiemme fois.J'explique trés mal mais si vous avez dèjà fait ce genre d'algorithme peut étre que vous m'avez compris.En gros je dessine des cercles qui grossissent à chaque tour de boucle,et s'ils se touchent en un point je ne dessine pas ce point....

Bon,c'est donc pour cela que je dois savoir comment tester si un point est déjà dessiné ou pas,donc de connaitre la valeur du pixel de coordonnèes (x,y).Si vous connaissez d'autre langages autre que openGL(bien que ce ne soit pas le bon forum je m'en excuse) qui le font encore plus facilement,n'hésitez pas à me le fair savoir.

En vous remerciant tous par avance de votre amabilité.

Ciao.

[charly]

Deja , si tu veux le faire sous dos , c'est ultra facile en mode graphique , si tu veux sous windows , l'api windows sera amplement suffisante pour l'utilisation que tu veux faire . Neamoin , opengl reste apte a faire ce genre de chose ...

[yacinechaouche]

heu ??? et sous linux ?

[charly]

je ne connais pas linux , mais je suppose que le systeme doit avoir des routine de dessin basique ...

[GLDavid]

Ouah ! Balèze ton projet. Tu vas voir des cercles de partout
Blague à part, je te conseille d'utiliser la fonction glReadPixels().
Je l'ai utilisé pour un de mes projets avec JOGL et la fonction se révèle efficace. Cependant, attention ! La fonction est gourmande en ressources.
Voici le prototype :

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
 
void glReadPixels(GLint x,
                  GLint y,
                  GLsizei width,
                  GLsizei height,
                  GLenum format,
                  GLenum type,
                  GLvoid *pixels)
 
PARAMETERS
 
x, y
    Specify the window coordinates of the first pixel that is read from the frame buffer. This location is the lower left corner of a rectangular block of pixels.
 
width, height
    Specify the dimensions of the pixel rectangle. width and height of one correspond to a single pixel.
 
format
    Specifies the format of the pixel data. The following symbolic values are accepted: GL_COLOR_INDEX, GL_STENCIL_INDEX, GL_DEPTH_COMPONENT, GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_RGBA, GL_LUMINANCE, and GL_LUMINANCE_ALPHA.
 
type
    Specifies the data type of the pixel data. Must be one of GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, or GL_FLOAT.
 
pixels
    Returns the pixel data.

@ ++

[yacinechaouche]

Merci à tous !

[exxos]

En meme temps, tu auras peut etre plus vite fait (et ce sera plus propre) de faire les calculs mathematiques.

En effet, il suffit que tu garde en memoire le diametre et le centre de chaque cercle, puis que tu verifies a cahque fois si ton point est à l'interieur d'un des cercles. Et là faut demander sur des forums de math avec des questions du genre:"comment savoir si un point est à l'interieur d'un cercle?"

fais un tour du coté de faqs.org

[yacinechaouche]

Les calculs mathématiques pour savoir si on est à l'interieur ou à l'exterieur d'un cercle,je ne crois pas qu'on ai le choix : il faut calculer x2+y2-R2 et regarder son signe.Donc trop trop long....

Par contre,pour avoir la valeur d'un pixel sur l'écran j'ai fait un truc bien plus simple qu'un copain a trouvé :

Il suffisait de declarer un tableau d'entier qui aura la taille de ma fenetre et de stocker à l'indice [i][j] la valeur du pixel (i,j) sur l'écran.

En gros si ma fenetre fait L de largeur et H de hauteur j'aurais un tableau int tab_val_pix[L][H].Quand je dessine un point en (x,y),j'appele la fonction qui dessine par exemple Dessiner(fenetre,x,y,couleur),et je remplis aussi la case tab_val_pix[x][y]=couleur.

Quand je veux avoir la valeur d'un pixel sur ma fenetre,je n'ai plus qu'à lire tab_val_pix[x][y] où x,y représentent les coordonnées de mon pixel !

Bien sûre,il faut initialiser le tableau avec la valeur de l'arrière plan de la fenetre.

Merci encore à tous.

Ciao.

[LeGreg]

si tu connais x et y c'est
plus rapide de faire x*x + y*y et de comparer à r*r (constante déjà calculée)

Lire dans un tableau surtout s'il fait la taille de ton écran est une très mauvaise idée sur un ordi moderne.

Évidemment si tu as quelque chose de plus compliqué qu'un cercle il faudra reconsidérer mais bon..

Par ailleurs ta methode par iteration me semble assez compliquée et surtout trop lente pour esperer gagner deux cycles en ne faisant pas une multiplication et une addition. (tu optimises le mauvais bout..)

LeGreg

[yacinechaouche]

Salut à tous,

je viens de finir le projet et il tourne. Vous pourrez trouver le source(avec makefile)et des captures d'écrans à l'adresse suivante :

http://perso.wanadoo.fr/ychaouche

Un petit bout de code pour voir comment ça marche :

Code :

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

1
2
3
4
5
6
7
8
9
 
/*Macros definitions*/
#define HAUTEUR 800
#define LARGEUR 1000
/*Definition de types*/
typedef int couleur;
typedef int flag;
/*Variables globales*/
couleur pix_val[LARGEUR][HAUTEUR];       //Je stocke ici les couleurs de chaque pixel de ma fenetre

la fonction qui teste si j'ai le droit de dessiner est :

Code :

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

1
2
3
4
 
int test(int a,int b){
  return (a<LARGEUR && a>0 && b<HAUTEUR && b>0 && pix_val[a][b]==white);
}

que j'appele ici :

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
 
int sym_cercle(int x,int y,int CentreX,int CentreY,couleur color){
 
  int dessines=0;
 
  XSetForeground(dp,gc,color);
  if(test(x,y)){
    XDrawPoint(dp,win,gc,x,y);
    XDrawPoint(dp,p,gc,x,y);
    pix_val[x][y]=color;
    dessines++;
  }
  if(test((2*CentreX)-x,y)){
    XDrawPoint(dp,win,gc,(2*CentreX)-x,y);
    XDrawPoint(dp,p,gc,(2*CentreX)-x,y);
    pix_val[(2*CentreX)-x][y]=color;
    dessines++;
  }
  if(test(x,(2*CentreY)-y)){
    XDrawPoint(dp,win,gc,x,(2*CentreY)-y);
    XDrawPoint(dp,p,gc,x,(2*CentreY)-y);
    pix_val[x][(2*CentreY)-y]=color;
    dessines++;
  }
  if(test(2*(CentreX)-x,(2*CentreY)-y)){
    XDrawPoint(dp,win,gc,2*(CentreX)-x,(2*CentreY)-y);
    XDrawPoint(dp,p,gc,2*(CentreX)-x,(2*CentreY)-y);
    pix_val[2*(CentreX)-x][(2*CentreY)-y]=color;
    dessines++;
  }
  return dessines;//renvoie le nombre de points dessines
}

qui est appele pour dessiner les 3 symetriques du points (x,y).Pour dessiner tout les points d'un cercle, avec un rayon fixe,j'appele :

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
 
int dessiner_cercle(int CentreX,int CentreY,int Ray,couleur color){
 
  int x,y,F,F1,F2,nb_pts_dessines;
 
  nb_pts_dessines=0;
 
  x=CentreX;
  y=CentreY+Ray;
  F=0;
 
  do{
    nb_pts_dessines+=sym_cercle(x,y,CentreX,CentreY,color);
    F1=F+(2*(x-CentreX))+1;
    F2=F-(2*(y-CentreY))+1;
    if(abs(F1)<=abs(F2)){
      x++;
      F=F1;
    }
    else{
      y--;
      F=F2;
    }
  }while (y>=CentreY);
 
  return nb_pts_dessines;
}

Et enfin,pour dessiner plusieurs cercles,en faisant grandir le rayon je fait appele a :

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
 
void cellules(){
 
  int cercles[ncercles][2]; //Contient les coordonnes des centres des cercles
  int i;
  int R;  
  int min_r = 5;
  char nb_cercles_dessines=0;
 
  //init
  /********/
  //mettre les flags a 1
  for(i=0;i<ncercles;i++)
    flags_cercles[i]=1;
  //tirer les coordonnes au hasard
  for(i=0;i<ncercles;i++){
    cercles[i][0]=rand()%LARGEUR;
    cercles[i][1]=rand()%HAUTEUR;
  }
  //distinguer les centres par une couleur noir
  APPARENCE_CENTRE{
  for(R=0;R<min_r;R++)
    for(i=0;i<ncercles;i++)
      dessiner_cercle(cercles[i][0],cercles[i][1],R,black);
  }
  /********/
 
  //deux boucles imbriquees : une pour les rayons en croissance...
  for(R=min_r;R<MAX_RAYON;R++){
    if(arreter_dessin(nb_cercles_dessines)){
      printf("Tous les cercles ont ete dessines(%d/%d),rayon maximum atteint %d\n",ncercles,nb_cercles_dessines,R);
      return;    }
    //...et une qui parcours les cercles a dessiner,avec un rayon R
    for(i=0;i<ncercles;i++){
      if(continuer_dessin(i))
	if((flags_cercles[i]=(flag)dessiner_cercle(cercles[i][0],cercles[i][1],R,couleurs[i]))==0)
	  nb_cercles_dessines++;
    }
  }
}
/***********************************/
//Teste s'il reste encore des cercles a dessiner
int arreter_dessin(int deja_dessines){
 
  return (deja_dessines==ncercles);
 
}
/***********************************/
//Teste si on continue de dessiner le cercle num_cercle
int continuer_dessin(int num_cercle){
 
  return (flags_cercles[num_cercle]!=0);
 
}

Pardon pour la qualité du code mais il fallait le rendre au plus vite !!

Encore merci à tous et bon courage.