Programmer un effet de relief sur une image

Version imprimable

2 pièce(s) jointe(s)

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:

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...:cfou:)

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 :ave:)

12/05/2017, 00h54
foetus
Commence par t'amuser avec les matrices de convolution :mrgreen: :mrgreen::

Une petite mise en bouche:

1 pièce(s) jointe(s)

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:

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;
}

14/05/2017, 11h25
piponux

1 pièce(s) jointe(s)
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:

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, };
17/05/2017, 21h37
ohnomorejmmings

Alternatives à un code existant
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
17/05/2017, 21h43
ohnomorejmmings

Progrès & pixels parasites

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.
18/05/2017, 13h38
piponux

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.
18/05/2017, 21h19
ohnomorejmmings

Intérêt des biblios, Lapeyre vs. Developpez.com & gestion des versions

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.
19/05/2017, 11h05
piponux

4 pièce(s) jointe(s)

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)

2 pièce(s) jointe(s)

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

Code:

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);

1 pièce(s) jointe(s)

WO P***** J'AI REUSSI!!!

:chin::yaisse1:

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:

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 :

20/05/2017, 19h55
piponux

2 pièce(s) jointe(s)

Et voici les images transformées :

1/2
20/05/2017, 19h56
piponux

2 pièce(s) jointe(s)

2/2
21/05/2017, 09h20
Christophe

Jets un oeil sur ça :
http://xphilipp.developpez.com/articles/filtres/
21/05/2017, 12h29
piponux

2 pièce(s) jointe(s)
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 :

Pièce jointe 277802

Pièce jointe 277805

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:

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".
22/05/2017, 11h27
piponux

5 pièce(s) jointe(s)

Sobel réussi, mais orientation du gradient non comprise.

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 :
22/05/2017, 21h19
ohnomorejmmings

Orientation

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 !
23/05/2017, 06h25
piponux

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.
23/05/2017, 19h18
ohnomorejmmings

Angles et couleurs

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.
24/05/2017, 12h55
piponux

1 pièce(s) jointe(s)

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).
24/05/2017, 18h54
ohnomorejmmings

Théorie et expérimentation, astuces

Et les autres angles ? Sur tes autres images on voit du gris et d'autres nuances… La frontière entre le noir & blanc et une palette colorée est pas forcément très éloignée. Pour t'en rapprocher si tu manques d'explications une solution consisterait à comparer ton résultat et celui de The GIMP pour une même image. Tu pourrais aussi énumérer toutes les informations dont tu disposes pour les associer et trouver la correspondance répondant à ton besoin. Après quand tu as parlé de cercle chromatique c'est par rapport aux docs que tu as assemblées ?

Sinon t'as pas besoin de travailler avec des images aussi grandes. Il suffirait de choisir une zone incluant tous les éléments dont tu as besoin. Efficacité, rapidité… Pour plonger dans la jungle de pixels il y a les logiciels comme GIMP mais aussi des pipettes comme PixAmp. Des extensions de navigateur comme Web Developer pour Firefox en propose aussi une. C'est très utile car ça permet de connaitre les composantes d'un pixel, de zoomer en temps réel…