Programmer un effet de relief sur une image

**piponux** · 11/05/2017, 22h32

Bonjour.
J'ai modifié une fonction déjà existante sur le net pour l'adapter à mon programme.
Mon but était de donner du relief à une image.
Voici la fonction en question :

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
image image_filter_rect_aux2 (image* I, int x1, int y1, int x2, int y2, int* K, int kCols, int kRows, int divisor)
{
 
 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, 0xffffffff);
 
 
 for(j = y1 + 1 ; j < y2 - 1  ; j++)            
 {
    for(i = x1  + 1; i < x2 - 1 ; i++)         
    {
 
     byte r=0;
     byte g=0;
     byte b=0;
 
        for(m=0; m < kRows; m++)    
        {
            mm = kRows - 1 - m;      
 
            for(n=0; n < kCols; n++) 
            {
 
 
                ii = i + (m - kCenterX);/*changer le i + et le j + en i - et en j - pour changer impression de relief*/
                jj = j - (n - kCenterY);
                if( ii >= 0 && ii < (*I)->w && jj >= 0 && jj < (*I)->h )
                 {
                   byte rr, gg, bb;
 
                   nn = kCols + 1 + n;
 
                   colour_get_rgb ((*I)->pixel [jj * (*I)->w + ii]  , &rr, &gg, &bb);  
 
                   r += (rr * (K[mm * kRows + nn])) / divisor ;
                   g += (gg * (K[mm * kRows + nn])) / divisor;
                   b += (bb * (K[mm * kRows + nn])) / divisor;
 
                   image_putpixel (J, i, j, make_colour(r, g, b, 0xff));
 
                 }   
            }
        }
    }
 }
 
for (j = 0; j < J->h; j++)
 {
  for (i = 0; i < J->w; i++)
   {
    byte a, b, c;
    colour_get_rgb (J->pixel[j * J->w + i], &a, &b, &c);
    J->pixel[j * J->w + i] = make_colour (255-a, 255-b, 255-c, 0xff);
   }
 }
 
/*
for (j = 0; j < J->h; j++)
 {
  for (i = 0; i < J->w; i++)
   {
    byte a, b, c;
    colour_get_rgb (J->pixel[j * J->w + i], &a, &b, &c);
    if (J->pixel[j * J->w + i] == 0xffffffff)
     J->pixel[j * J->w + i] = make_colour (180, 180, 180, 0xff);
   }
 }
*/
 
 return J;
}

Quand je compare mon image (la première) à celle obtenue avec The Gimp (la seconde image), Je préfère le résultat obtenu avec The Gimp (ah bon? ça alors, c'est étonnant...

)

Voici ma question : Avec The Gimp, pour obtenir cet effet, on va dans Filtres => Distorsions => relief.

Une fois là, on le choix de modifier : Azimut, Elevation, Profondeur. (il y a ausi le choix entre carte de relief et relief).

Savez vous comment il serait possible de modifier la fonction que j'utilise pour paramétrer l'elevation, la profondeur et l'Azimut svp? ( + carte de relief et relief : quelle est la signification de tous ces termes?).

De plus, quelle est la méthode pour "lisser" l'image et ne pas se retrouver, comme moi, avec des pixels tout pourris?

Merci d'avance.

image 1 (moi), image 2 (The Gimp

)

**foetus** · 12/05/2017, 00h54

Commence par t'amuser avec les matrices de convolution

:

Une petite mise en bouche:

**piponux** · 13/05/2017, 10h39

Bonjour foetus.

il y a un truc qui cloche dans ma fonctin, c'est sûr. Par exemple, quand j'applique la fonction (encore modifiée) suivante avec ce filtre et ces paramètres, j'obtiens l'image suivante. Ce qui n'est pas du tout le résultat attendu.

Comment se débarrasser des pixels qui bruitent (c'est à dire ceux dont la couleur tranche trop avec la couleur de contexte de l'image)?

Ne vaudrait il mieux pas passer par des coefficients à virgule, quitte à recalculer chaque pixel pour que la valeur de ceux ci s'approchent de la valeur au dessus / au dessous (par exemple 0.6 donne 1 et 0.4 donne 0)

le résultat est le même avec une image 512 x 512 qu'avec une image 2200 x 1600

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
/*filtre*/
int* laplacien[5*5] = {
  -1, -1, -1, -1, -1,
  -1, -1, -1, -1, -1,
 
  -1, -1, 24, -1, -1,
  -1, -1, -1, -1, -1,
  -1, -1, -1, -1, -1,  
}; 
 
/*Appel de la fonction*/
image J = image_convolution (&I, 0, 0, 512, 512, &laplacien, 5, 5, 5, 7);
 
 
/*Fonction elle même*/
 
image image_convolution (image* I, int x1, int y1, int x2, int y2, int* K, int kCols, int kRows, int divisor, int luminosite)
{
 
 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, 0xffffffff);
 
 
 
 
 for(j = y1 + kRows; j < y2 - kRows ; j++)            
 {
 
    for(i = x1 + kCols ; i < x2 - kCols; i++)         
    {
     byte r=0;
     byte g=0;
     byte b=0;
 
        for(m=0; m < kRows; m++)    
        {
            mm = kRows + 1 + m;      
 
            for(n=0; n < kCols; n++) 
            {
                nn = kCols - 1 - n;
 
 
                ii = i + (n + kCenterX);
                jj = j + (n + kCenterY);
 
 
                if( ii >= 0 && ii < (*I)->w && jj >= 0 && jj < (*I)->h )
                 {
                   byte rr, gg, bb;
 
                   colour_get_rgb ((*I)->pixel [jj * (*I)->w + ii], &rr, &gg, &bb);  
 
 
                   r += ((rr * (K[nn * kRows + mm])/divisor)+ luminosite) ;
 
                   g += ((gg * (K[nn * kRows + mm])/divisor) + luminosite) ;
 
                   b += ((bb * (K[nn * kRows + mm])/divisor) + luminosite) ;
 
 
                   image_putpixel_alpha(J->pixel + j * J->w + i , r, g, b, 0xff);
                 }   
 
            }
 
        }
 
    }
 
 }
 
 return J;
}

**piponux** · 14/05/2017, 11h25

j'ai changé ma fonction (j'ai essayé de corriger sur papier avant d'écrire le code). J'ai modifié certaines opérations. Voici mon résultat. N'ayant aucune connaissance dans le domaine, pouvez vous me dire si l'image ci-dessous se rapproche du résultat normal avec ce filtre?

qu'obtenez-vous avec ce filtre pour vos propres fonctions? sachant que l'image d'origine est en couleurs.

Code c :

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

1
2
3
4
5
6
7
8
 int* laplacien[5*5] = {
  -1, -1, -1, -1, -1,
  -1, -1, -1, -1, -1,
 
  -1, -1, 24, -1, -1,
  -1, -1, -1, -1, -1,
  -1, -1, -1, -1, -1,  
};

**ohnomorejmmings** · 17/05/2017, 21h37

Partir d'un code existant c'est à double-tranchant surtout que celui-ci est assez cryptique. I une image et i un int ? J une nouvelle image ? r et rr ? Pourquoi pas rrr ?! Après la logique derrière semble cohérente mais Je vois 3 alternatives :

Opter pour une bibliothèque de traitement d'images/calcul scientifique (Comme NumPy et SciPy en Python)
Jeter un coup d'œil au code de The GIMP puisque c'est un logiciel libre
Coder à partir d'explications/algorithmes afin de se les approprier

**ohnomorejmmings** · 17/05/2017, 21h43

Tu sembles te rapprocher de l'image de l'article Wikipédia. Pour les pixels parasites c'est peut-être parce qu'il faut borner les composantes. Si le calcul fait plus de 255 ou moins de 0 ça donne n'importe quoi. Désolé je peux pas être plus précis car je connais pas trop de filtre.

**piponux** · 18/05/2017, 13h38

Je ne veux pas me servir d'une bibliothèque car je voudrais comprendre les rouages du truc.
Pour mon niveau en maths, il est plutôt nul...

I est un pointeur de struct nommée "image" dont les champs sont "int w (width), int h (height) et colour* pixel (colour* étant un pointeur d'unsigned char). J'ai repris cette struct des cours de Jacques Olivier Lapeyre, sur youtube.

J'avais réussi à régler une fonction avec une effet de relief trés réussi, mais j'ai mis le code à la corbeille par inadvertance. Je vais essayer de le retrouver.

**ohnomorejmmings** · 18/05/2017, 21h19

Pour les biblios justement te servir d'une peut être une première étape pour comprendre. Après rien ne t'empêche de te plonger dans son code et faire la même chose à ta sauce. L'intérêt c'est que ça soit documenté, plus fiable… Elles sont aussi souvent accompagnées de plein de ressources dont des pédagogiques justement pour permettre à tout le monde de les utiliser. Sinon personne n'est nul en math on passe tous par la même case départ. D'ailleurs les problèmes que t'as résolu prouve que t'es capable de plein de choses !

Alors j'ai jeté un coup d'œil aux cours de Lapeyre et c'est un professeur très productif mais peut-être justement que c'est au détriment de la qualité. Certes il y a plusieurs façons de faire mais c'est important d'adapter des explications ou un code. Comment est-ce que tu appelerais une variable de type image ? Comment parcourerais-tu les pixels d'une image ? Aussi en utilisant i et j ? La première fois que j'étais tombé sur ce code, dans l'autre discu je crois, je me souviens aussi que j'avais tilté sur les pointeurs. Des trucs comme (*I)->w c'est compliquer les choses pour rien et quand on débute c'est encore pire. Mon C est rouillé mais ça veut dire qu'I est un pointeur de pointeur d'où l'* devant ! Si les & viennent aussi de toi je te conseille de réviser cette spécificité du langage car c'est vrai qu'on peut s'y perdre au début ou si on tombe sur des trucs un peu tordus. On en revient encore aux bases vraiment importantes pour avancer sans stresser. Au passage tu as jeté un coup d'œil aux ressources du site ? Question de comparer avec celles de Lapeyre. Je me souviens que les FAQs C/C++ m'avaient été utiles il y a quelques mois pour vérifier quelques trucs…

Enfin pour ton code perdu pour que ça n'arrive plus une solution miracle c'est un logiciel de gestion des versions (CVS, Subversion…). Ça change réellement la vie d'un développeur ! Ça t'aurait permis d'archiver une version de ton projet avec un fier commentaire pour bien marquer l'évènement. Une astuce temporaire pourrait consister à nommer différemment plusieurs fonctions similaires et donc à conserver toutes celles le méritant.

**piponux** · 19/05/2017, 11h05

Merci encore pour les encouragements et les conseils.
J'en profite pour poster des images obtenues avec une fonction encore modifiée, qui prend en compte la transparence des pixels de l'image de destination.
Le résultat est presque satisfaisant :

Les images couleur sont les images source, et les images en noir et blanc sont celles traitées. Elles sont en noir et blanc (ou plutôt niveaux de gris) car j'ai repassé les images traitées dans une fonction qui transforme une image couleur en une image en niveaux de gris.

(le cercle et la ligne qu'on voit que l'image niveaux de gris des lions est une image de test, pour suivre les conseils de ternel, que j'ai oublié d'enlever)

**piponux** · 19/05/2017, 13h19

la même fonction avec un coefficient négatif un filtre différent (edge):

Code c :

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

1
2
3
4
5
6
7
8
 
int* edge[3 * 3] = {/*Plus on augmente le diviseur dans le négatif, plus le contraste est elevé*/
 (int*)1, (int*)1, (int*)1,
 (int*)1, (int*)-4,(int*) 1,
 (int*)1, (int*)1, (int*)1
};
 
image J = image_convolution (&I, 0, 0, I->w, I->h, &edge, 3, 3, -64);

**piponux** · 20/05/2017, 19h52

Salut!

J'ai enfin réussi à obtenir ce que je voulais exactement!

J'ai refait entièrement la fonction, et ce qui m'a fait comprendre comment marche la convolution d'image, c'est ce site :

http://setosa.io/ev/image-kernels/

Bon, ok, je dois être le millionième à écrire ma fonction, mais cette fois ci, c'est de moi. Quel pied!

Voici le code :

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
image image_convolution_labo (image* I, int x1, int y1, int x2, int y2, int* K, int kCols, int kRows, int divisor, int coef)
{
 int i, j, m, n;
 colour c;
 image J;
 byte rr, gg, bb,aa;
 byte r, g, b, a;
 J = image_create ((*I)->w, (*I)->h, 0xffffffff);
 
 for(j = y1 ; j < y2   ; j++)            
  {
   for(i = x1  ; i < x2  ; i++)         
    {
     r = 0; g = 0; b = 0; a = 0;
       for(m=0; m < kRows; m++)    
        {
            int index_Image = 0;
            int index = 0;
            for(n=0; n < kCols; n++) 
             {
                index = m * kRows +  n;
                index_Image = (m +j) * (*I)->w + n + i;
                colour_get_rgba ((*I)->pixel [index_Image]  , &rr, &gg, &bb, &aa);  
 
                if (r >= 0 && r < 256 && g >= 0 && g < 256 && b >= 0 && b < 256)
                  {
                   r += ((rr * (K[index])) / divisor) + coef;
                   g += ((gg * (K[index])) / divisor) + coef;
                   b += ((bb * (K[index])) / divisor) + coef;
                   a += ((aa * (K[index])) / divisor) + coef;
                   normalise_bytes (&r, &g, &b);
                   c = make_colour (r, g, b, 0xff);
                   image_putpixel(J, i, j, c);
                   index++;
                  }
             }     
        }   
    } 
 }    
 
 
 return J;
}

Voici l'image de départ :

**piponux** · 20/05/2017, 19h55

1/2

**piponux** · 20/05/2017, 19h56

2/2

**chrtophe** · 21/05/2017, 09h20

Jets un oeil sur ça :
http://xphilipp.developpez.com/articles/filtres/

**piponux** · 21/05/2017, 12h29

merci pour le lien, j'avais déjà lu l'article, mais mon niveau en maths ne me permet même pas de traduire les formules du type :

$Nom : latex-id3.png Affichages : 756 Taille : 2,1 Ko$

$Nom : latex-id12.png Affichages : 680 Taille : 1,5 Ko$

Je vais tout de même exposer ce que je comprends, par exemple à la page 5 de l'article:

- on suppose qu'on décompose le pixel à traiter en ses composantes r, g, b.

- on calcule les facteurs positifs et négatifs de la matrice: par exemple pour une matrice

Code c :

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

1
2
3
4
 
int* K {-1, 0, 1,
          -1, 0, 1
          -1, 0, 1};

le facteur négatif est -3; le facteur positif est +3, et donc la valeur la plus grande entre la valeur absolue de -3 est la valeur absolue de +3, c'est +3. Donc, le facteur de normalisation est : +3.

- Ce facteur (+3), est ce avec quoi on va diviser chaque composante r, g, b;

=> Doit on diviser TOUTES les composantes r, g, b, ou SEULEMENT les composantes r, g,b qui dépassent la valeur 255?
=> que fait on des composantes r, g, b négatives? Doit on aussi les diviser ou bien doit on les remettre à 0?

L'article dit "si la valeur obtenue n'est pas dans les limites imposées par le format (entier(s) entre 0...255), alors la valeur doit être normalisée". => "SI la valeur obtenue...ALORS elle doit être normalisée".

**piponux** · 22/05/2017, 11h27

Bon, j'ai réussi mes filtres de Sobel, grâce à la chaîne youtube COMPUTERPHILE.

En revanche, je ne comprends pas comment implémenter l'orientation du gradient, avec la fonction atan.

Qqu'1 pour m'expliquer ce dernier point svp?

Mes images :

**ohnomorejmmings** · 22/05/2017, 21h19

Qui dit orientation dit angle et atan te permet de le calculer à partir du couple sinus/cosinus (y/x) dans un triangle rectangle par exemple. C'est de la trigonométrie et d'après l'article Wikipédia sur le filtre de Sobel il faut t'aider de 2 matrices (horizontal/vertical).

Sinon super pour tes progrès !

**piponux** · 23/05/2017, 06h25

ok pour D(x,y) = Arctan(Gy/Gx).

Mais une fois qu'on a déterminé cela, qu'est-ce qu'on en fait? Mon but est de colorer les contours avec les couleurs du cercle chromatique, c'est à dire que les contours blancs deviennent multicolores.

**ohnomorejmmings** · 23/05/2017, 19h18

Je comprends à peu près ce que tu veux faire. Est-ce que tu as un résultat pour te guider ? Sinon c'est important de comprendre à quoi sert l'angle calculé. Par exemple à quoi correspond le blanc ? À partir de là juste en scannant l'article Wikipédia le coloriage me semble logique. Mais attention je rappelle que je ne connais pas suffisamment ce filtre ! Je me base juste sur d'autres problèmes résolus.

**piponux** · 24/05/2017, 12h55

Voilà le résultat que j'aimerais obtenir.
Il me semble que le blanc correspond à un angle de 0°. Mais comment obtenir un autre résultat que blanc, avec des contour plus fins, presque translucides, et colorés? pour l'instant, mystère...
(l'image est volontairement grosse pour qu'on puisse distinguer la finesse des contours obtenue avec The Gimp).

Programmer un effet de relief sur une image

C

Discussions similaires

Partager

Partager