Discussion :

[piponux]

Bonjour, je viens vers vous car je suis devant un problème que je n'arrive pas à solutionner.

J'ai une struct image.
On accède aux pixels par la formule

position du pixel =

Code c :

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

I->pixel + y * I->w + x

,

où x = colonnes, y = lignes, et où I->pixel représente l'adresse du premier pixel de l'image, sachant que I->w représente la largeur de l'image.

Lorsque je trace un cercle à l'aide de l'algorithme de Bresenham, si les pixels dépassent à droite, on les retrouve à gauche, ce qui est normal.

Or, je ne voudrais pas que ceci se produise, c'est à dire que je voudrais que, si les pixels dépassent à droite ou à gauche, ils ne soient pas dessinés.

Je n'ai pas ce problème pour les pixels qui dépassent en haut et en bas, car il suffit de mettre la condition (si position du pixel < 0), ou (si position du pixel > taille de l'image).

[Obsidian]

Bonjour,
Étant donné que tu disposes de « x », il te suffit de vérifier qu'il ne soit pas inférieur à zéro, ni supérieur à la largeur de l'image. Donc :

Code C :

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

1
2
3
4
5
    if (x>=0 && x<=I->w)
    {
        TracePixel();
        …
    }

[piponux]

j'ai essayé. Celà ne fonctionne pas.
voici le code de ma fonction :

Code c :

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
void bresenham_cercle (image I, int rayon, int x_centre, int y_centre, byte r, byte g, byte b, byte a)
{
 int x, y, m;
 int octant1, octant2, octant3, octant4, octant5, octant6, octant7, octant8;
 
 x = 0;
 y = rayon;
 
 m = 5 - (4 * rayon);
 
 while (x <= y)
  {
   colour* ptr = NULL;
 
   /*Octants de 1 à 8, dans le sens des aiguilles d'un montre*/
 
   octant1 = (-y + y_centre) * I->w + (x + x_centre);
   octant2 = (-x + y_centre) * I->w + (y + x_centre);
   octant3 = (x + y_centre) * I->w + (y + x_centre);
   octant4 = (y + y_centre) * I->w + (x + x_centre);
   octant5 = (y + y_centre) * I->w + (-x + x_centre);
   octant6 = (x + y_centre) * I->w + (-y + x_centre);
   octant7 = (-x + y_centre) * I->w + (-y + x_centre);   
   octant8 = (-y + y_centre) * I->w + (-x + x_centre);
 
   ptr = I->pixel + octant1;
   if (octant1 > 0 && octant1 < I->w * I->h)
      image_putpixel_alpha (ptr, r, g, b, a);
 
   ptr = I->pixel + octant2;
   if (octant2 > 0 && octant2 < I->w * I->h ) 
      image_putpixel_alpha (ptr, r, g, b, a);
 
   ptr = I->pixel + octant3;
   if (octant3 < I->w * I->h  && octant3 > 0 ) 
    image_putpixel_alpha (ptr, r, g, b, a);
 
   ptr = I->pixel + octant4 ;
   if (octant4 <   I->w * I->h && octant4  > 0 )
    image_putpixel_alpha (ptr, r, g, b, a);
 
   ptr = I->pixel + octant5 ;
   if (octant5 <  I->w * I->h && octant5 > 0 ) 
      image_putpixel_alpha (ptr, r, g, b, a);
 
   ptr = I->pixel + octant6;
   if (octant6 > 0 && octant6 < I->w * I->h ) 
      image_putpixel_alpha (ptr, r, g, b, a);
 
   ptr = I->pixel + octant7;
   if (octant7 > 0 && octant7 < I->w * I->h ) 
      image_putpixel_alpha (ptr, r, g, b, a);
 
   ptr = I->pixel + octant8;
   if (octant8 > 0 && octant8 < I->w * I->h ) 
      image_putpixel_alpha (ptr, r, g, b, a);
 
 
 
   if (m > 0)
    {
     y--;
     m = m - 8 * y;
    }
 
   x++;
   m = m + (8 * x) + 4; 
  }
}

l'appel de la fonction est :

Code c :

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

bresenham_cercle (I, 500, I->w / 2, I->h / 2, 255, 255, 255, 255);

et voici le résultat avec un cercle qui dépasse des limites de l'image, alors que je ne voudrais voir aucun pixel dessiné:

[Obsidian]

Un peu de bon sens, voyons…

Tu calcules les offsets « octant1 à 8 » en fonction de tes coordonnées x et y. Ce sont elles qu'il faut utiliser dans tes conditions, pas la valeur de octant qui, elle, ne te donne que l'adresse du pixel à utiliser s'il est valide, par rapport à celui du centre.

Remplace :

Code C :

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

1
2
3
   ptr = I->pixel + octant1;
   if (octant1 > 0 && octant1 < I->w * I->h)
      image_putpixel_alpha (ptr, r, g, b, a);

… par :

Code C :

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

1
2
3
   ptr = I->pixel + octant1;
   if ((x+x_centre) > 0 && (x+x_centre) < I->w && (y+y_centre) > 0 && (y+y_centre) < I->h)
      image_putpixel_alpha (ptr, r, g, b, a);

… et même chose pour les sept blocs qui suivent, en adaptant les signes à chaque fois.

[piponux]

Ah oui, quand on a la réponse sous les yeux, c'est évident.
Merci!

[piponux]

voici donc le code corrigé et qui fonctionne, la preuve en image plus bas.
Merci Obsidian.

Code c :

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
void bresenham_cercle (image I, int rayon, int x_centre, int y_centre, byte r, byte g, byte b, byte a)
{
 int x, y, m;
 x = 0;
 y = rayon;
 
 m = 5 - (4 * rayon);
 
 while (x <= y)
  {
   colour* ptr = NULL;
 
   /*octants de 1 à 8, dans le sens des aiguilles d'une montre*/
 
   ptr = I->pixel + /*octant1*/(-y + y_centre) * I->w + (x + x_centre);
     if ((x + x_centre) >= 0 && (x + x_centre < I->w) && (-y + y_centre) >= 0 && (-y + y_centre) < I->h)
      image_putpixel_alpha (ptr, r, g, b, a);
 
   ptr = I->pixel + /*octant2*/(-x + y_centre) * I->w + (y + x_centre);
     if ((y + x_centre) >= 0 && (y + x_centre < I->w) && (-y + y_centre) >= 0 && (-y + y_centre) < I->h)
      image_putpixel_alpha (ptr, r, g, b, a);
 
   ptr = I->pixel + /*octant3*/(x + y_centre) * I->w + (y + x_centre);
     if ((y + x_centre) >= 0 && (y + x_centre < I->w) && (x + y_centre) >= 0 && (x + y_centre) < I->h)   
    image_putpixel_alpha (ptr, r, g, b, a);
 
   ptr = I->pixel +/* octant4*/(y + y_centre) * I->w + (x + x_centre) ;
     if ((x + x_centre) >= 0 && (x + x_centre < I->w) && (y + y_centre) >= 0 && (y + y_centre) < I->h)   
    image_putpixel_alpha (ptr, r, g, b, a);
 
   ptr = I->pixel + /*octant5*/(y + y_centre) * I->w + (-x + x_centre) ;
     if ((-x + x_centre) >= 0 && (-x + x_centre < I->w) && (y + y_centre) >= 0 && (y + y_centre) < I->h)   
      image_putpixel_alpha (ptr, r, g, b, a);
 
   ptr = I->pixel + /*octant6*/(x + y_centre) * I->w + (-y + x_centre);
     if ((-y + x_centre) >= 0 && (-y + x_centre < I->w) && (x + y_centre) >= 0 && (x + y_centre) < I->h)   
      image_putpixel_alpha (ptr, r, g, b, a);
 
   ptr = I->pixel + /*octant7*/(-x + y_centre) * I->w + (-y + x_centre);
     if ((-y + x_centre) >= 0 && (-y + x_centre < I->w) && (-x + y_centre) >= 0 && (-x + y_centre) < I->h)   
      image_putpixel_alpha (ptr, r, g, b, a);
 
   ptr = I->pixel + /*octant8*/(-y + y_centre) * I->w + (-x + x_centre);
     if ((-x + x_centre) >= 0 && (-x + x_centre < I->w) && (-y + y_centre) >= 0 && (-y + y_centre) < I->h)   
      image_putpixel_alpha (ptr, r, g, b, a);
 
   if (m > 0)
    {
     y--;
     m = m - 8 * y;
    }
 
   x++;
   m = m + (8 * x) + 4; 
  }
}