Discussion :

[piponux]

Bonjour,
connaitriez vous un algo permettant de programmer un effet néon sur les contours d'une image?

[Kannagi]

Vu la question , j'ai envie de dire que cela n'a rien n'a voir avec le C :p
(Je pense que il existe d'autre sous forum plus spécialisé dans ce domaine )

Sinon un exemple d'effet de neon que tu veux ?
Comme ceci par exemple ? http://www.mediatheque-beziers-agglo...=1&itemId=6141

Le truc c'est que il faut déterminer les sources de lumière.
Parce que ça me semble juste d’être un éclairage par pixel basic sinon.

[piponux]

Bonjour Kannagi.
C'est bien l'effet que je recherche.

Le truc c'est que il faut déterminer les sources de lumière.
Parce que ça me semble juste d’être un éclairage par pixel basic sinon.

Déteminer les sources de lumière, je ne sais pas faire, quant à éclairer les pixel, je sais faire, mais la question est : de quelle façon pour obtenir l'effet néon.

Voici par exemple une fonction qui permet d'appliquer certains effets sur une image. Celà marche trés bien pour le flou de bougé, la mise en relief, et le flou tout court par exemple.

Est il possible d'utiliser cette fonction pour l'effet néon? si oui, comment peut ont faire ça?

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
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
 
 
  int* identity[3*3] = {
   0,  0,  0,
   0,  1,  0,
   0,  0,  0
 
};
 
 
 
  int* relief[3*3] = {
  -1, -1, -1,
  -1,  9, -1,
  -1, -1, -1
 
}; 
 
 
 
  int* flou_de_bouge[9*9] = {
   1,  0,  0, 0, 0, 0, 0, 0, 0,
   0,  1,  0, 0, 0, 0, 0, 0, 0,
 
   0,  0,  1, 0, 0, 0, 0, 0, 0,
   0,  0,  0, 1, 0, 0, 0, 0, 0,
   0,  0,  0, 0, 1, 0, 0, 0, 0,
   0,  0,  0, 0, 0, 1, 0, 0, 0,
   0,  0,  0, 0, 0, 0, 1, 0, 0,
   0,  0,  0, 0, 0, 0, 0, 1, 0,
   0,  0,  0, 0, 0, 0, 0, 0, 1      
};  
 
 
  int* gaussian_blur[3*3] = {
  1, 2, 1,
  2, 4, 2,
  1, 2, 1
};
 
image image_filter_TGA24 (image I, int* K, int kCols, int kRows, float divisor)
{
 /*kCols = nb de colonnes du kernel, kRows = nb de lignes du kernel*/
 int kCenterX = kCols / 2;
 int kCenterY = kRows / 2;
 int i, j, m, mm, n, nn, ii, jj;
 
image J = image_create (I->w, I->h, 0xFF0000FF);
image_save_TGA24 ("./IMAGES/imageTGA24_filter.tga", J);
jfile F = standard_jfile_open ("./IMAGES/imageTGA24_filter.tga", JFILE_MODE_READ);
 
 for (i = 0; i < 16; i++)
  jfile_read_char(F);
 
 for(j=0; j < I->h ; j++)            
 {
 
    for(i=0; i < I->w; i++)         
    {
     byte r=0;
     byte g=0;
     byte b=0;
 
        for(m=0; m < kCols; m++)    
        {
            mm = kCols - 1 - m;      
 
            for(n=0; n < kRows; n++) 
            {
                nn = kRows - 1 - n;
 
 
                ii = i + (n - kCenterX);
                jj = j + (m - kCenterY);
 
 
                if( ii >= 0 || ii < I->w || jj >= 0 || jj < I->h )
                 {
                   byte rr, gg, bb;
 
                   colour_get_rgb ((colour)(long) I->pixel + jj * I->w + ii, &rr, &gg, &bb); 
 
                   if (r < 0) r = 0; if (r > 255) r = 255;
                   if (g < 0) g = 0; if (g > 255) g = 255;
                   if (b < 0) b = 0; if (b > 255) b = 255;                   
 
                   r += /*I->pixel [jj * I->w + ii] * (K[nn * kRows + mm]);*/(rr * (K[nn * kRows + mm] )) / divisor;
                   g += /*I->pixel [jj * I->w + ii] * (K[nn * kRows + mm]);*/(gg * (K[nn * kRows + mm] )) / divisor;
                   b += /*I->pixel [jj* I->w + ii] * (K[nn * kRows + mm]);*/(bb * (K[nn * kRows + mm] )) / divisor;
                   J->pixel[j * I->w + i] = make_colour(r, g, b, 0xFF);
 
                 }   
            }
        }
    }
 }
 
 image_save_TGA24 ("./IMAGES/image_filter_TGA24.tga", J);
 jfile_close(&F);
 return J;
}

[ohnomorejmmings]

Flou gaussien + Affichage par transparence. Après ça dépend du résultat recherché car en infographie il existe plusieurs techniques.

[piponux]

ok, l'effet que je recherche est celui qui correspond au lien posté par Kannagi dans la présente discussion.

Par exemple, calculer un effet néon sur le rectangle jaune.
je vais essayer le flou gaussien + transparence.

[ohnomorejmmings]

Plutôt que des formes pleines je te conseille des lignes afin de reproduire la structure d'une lampe néon. Sinon une astuce pour t'aider c'est de tester l'effet avec un éditeur d'images. Les fonctionnalités existent déjà et à partir de là tu peux déterminer le processus. Faire quelques didacticiels d'infographie au besoin ça peut aussi être une piste.

[piponux]

Bonjour,
je reviens à vous car après des semaines de retournement de cerveau, j'ai à peu près réussi à faire ce que je voulais.
voici comment je procède :

A a place de dessiner un pixel, je dessine un disque avec les algos de Bresenham. Ensuite je pars du centre jusqu'à la périphérie, et pour chaque ligne remplissant le cercle, je calcule une transparence de plus en plus forte.
Pour la seconde image, ce n'est pas un cercle qui forme le pixel "neon" mais un calcul qui ajoute des x ou des y au point du pixel.
Ca vaut ce que ca vaut, mais c'est de moi.
Je ne sais pas du tout si au niveau temps d'éxécution, c'est bien ou non.
Voici plusieurs images avec plusieurs façons de programmer un effet néon.

Code c :

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

1
2
3
4
5
6
void image_putpixel_neon (image I, int x, int y, colour c, int epaisseur)
{
 byte r, g, b, a;
 colour_get_rgba (c, &r, &g, &b, &a); 
 bresenham_disk_modifie_transparence (I, epaisseur, x, y, r, g, b, 50);
}

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
70
71
72
73
74
75
76
77
78
79
80
81
82
void bresenham_disk_modifie_transparence (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, 127);*/
       bresenham_modifie_transparence (I, x_centre, y_centre, x + x_centre, -y + y_centre, r, g, b, rayon);
 
      }
 
   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);*/
      bresenham_modifie_transparence (I, x_centre, y_centre, y + x_centre, -x + y_centre, r, g, b, rayon);
 
 
/*OCTANT 3 NE FONCTIONNE PAS*/
   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);*/
        bresenham_modifie_transparence (I, x_centre, y_centre, y + x_centre, x + y_centre, r, g, b, rayon);
 
 
 
 
 
 
   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);*/
      bresenham_modifie_transparence (I, x_centre, y_centre, x + x_centre, y + y_centre, r, g, b, rayon);
 
 
 
 
   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);*/
       bresenham_modifie_transparence (I, x_centre, y_centre, -x + x_centre, y + y_centre, r, g, b, rayon);
 
 
 
   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);*/
       bresenham_modifie_transparence (I, x_centre, y_centre, -y + x_centre, x + y_centre, r, g, b, rayon);
 
   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);*/
       bresenham_modifie_transparence (I, x_centre, y_centre, -y + x_centre, -x + y_centre, r, g, b, rayon);     
 
 
 
   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);*/
       bresenham_modifie_transparence (I, x_centre, y_centre, -x + x_centre, -y + y_centre, r, g, b, rayon);   
 
   if (m > 0)
    {
     y--;
     m = m - 8 * y;
    }
 
   x++;[ATTACH=CONFIG]271190[/ATTACH]
   m = m + (8 * x) + 4; 
  }
}

(le troisième octant ne fonctionne pas)


voici les images :

Au passage, message pour Jacques Olivier Lapeyre : dans tes lectures de commentaires de ta chaine youtube, tu parles du pseudo Moi Moi en disant qu'il est fou (dans le bon sens du terme) d'avoir regardé tes vidéos en entier. Merci pour le compliment, il s'agit de moi. Merci encore pour tes videos.

[piponux]

voici également le code pour choisir la couleur qu'on veut "néoner" dans une image:
(le code commenté a été utilisé pour l'image jaune ci dessus)

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
void choose_colour_to_glow (image I, colour d)
{
 int x, y, i;
 colour c;
  for ( y = 0; y < I->h; y++)
  {
   for (x = 0; x < I->w; x++)
    {
     c = I->pixel[y * I->w + x];
 
     if (c == d) 
      {
 
       byte rr, gg, bb, aa;
 
       colour_get_rgba (d, &rr, &gg, &bb, &aa);
       image_putpixel_neon (I, x, y, d, 10);     
 
/*
       for (i = 0; i < 15; i++)
        {
         if (x + i >= 0 && x + i < I->w && y + i >=0 && y + i < I->h && x - i >=0 && x - i < I->w
            && y - i >= 0 && y - i < I->h)
         {
          
         
          image_putpixel_alpha (I->pixel + (y + i) * I->w + x, rr, gg, bb, aa - (i * 17));
          image_putpixel_alpha (I->pixel + (y - i) * I->w + x, rr, gg, bb, aa - (i * 17));
          image_putpixel_alpha (I->pixel + y * I->w + (x + i), rr, gg, bb, aa - (i * 17));
          image_putpixel_alpha (I->pixel + y * I->w + (x - i), rr, gg, bb, aa - (i * 17));
         
          image_putpixel_alpha (I->pixel + (y + i) * I->w + (x-i), rr, gg, bb, aa - (i * 17));
          image_putpixel_alpha (I->pixel + (y - i) * I->w + (x-i), rr, gg, bb, aa - (i * 17));
          image_putpixel_alpha (I->pixel + (y+i) * I->w + (x + i), rr, gg, bb, aa - (i * 17));
          image_putpixel_alpha (I->pixel + (y-i) * I->w + (x + i), rr, gg, bb, aa - (i * 17));
          
         }
       
       
         
        } 
*/
 
 
      }
 
 
    }
 
  }
 
}

qui donne par exemple:

(on peut choisir d'allumer seulement le blanc, le vert ou bien le rouge)