Discussion :

[SmileSoft]

Salut,

est ce qu'il s'agit d'un simple produit de convolution de l'image par les noyaux horizontaux et verticaux de prewit et sobel, j'ai fais le produit de convolution de mon image par le masque vertical de sobel donné dans ce lien et j'ai obtenu un mauvais résultat, voilà un exemple ci joint.

Merci d'avance

[ToTo13]

Bonjour,

effectivement, tu as un souci de programmation.
- C'est bien une simple convolution. Je pense que ton problème pour l'instant est ici.
- Au détail près que tu auras des valeurs négatives et supérieures à la bornes max habituelles de ton image. Si tu as une image codée sur [0,255], ton image après convolution sera étalée sur [-3x255,3x255].
- Tu as alors plusieurs choix : laisser tel quel mais c'est plus dur à afficher, passer en valeurs absolue puis étaler l'histogramme sur [0,255] ou simplement étaler l'histogramme sur [0,255].

[SmileSoft]

Si tu as une image codée sur [0,255], ton image après convolution sera étalée sur [-3x255,3x255].
- Tu as alors plusieurs choix : laisser tel quel mais c'est plus dur à afficher, passer en valeurs absolue puis étaler l'histogramme sur [0,255] ou simplement étaler l'histogramme sur [0,255].

en étalant l'histogramme sur [0,255] après convolution je n'ai pas un grand changement, par contre j'ai pas compris l'autre choix que vous venez de citer.

merci d'avance.

[ToTo13]

par contre j'ai pas compris l'autre choix que vous venez de citer..

- Après la convolution tu as les valeurs sur [-3x255,3x255].
- Tu prends la valeur absolue => [0,3x255].
- Tu fais ton étalement d'histogramme => [0,255].

Mais je confirme ce que j'ai marqué plus haut, ton problème est dans la convolution et non après.
Montre nous ton morceau de code...

[kmaniche]

Bonjour,

Sinon, il existe encore une autre solution qui consiste à mettre à 0 toutes les valeurs < 0, et à 255 toutes les valeurs > 255

[SmileSoft]

Merci pour vos réponses, voilà le code que j'ai mis pour la convolution;

la fonction Filtre3 a comme paramètres les 9 éléments du noyau 3*3 du filtre et le rapport de normalisation.

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
void __fastcall TForm1::Filtre3(int p0, int p1, int p2, int p3, int p4, int p5, int p6, int p7, int p8, int k)
{
w=Srce->Width-1;
h=Srce->Height;
 P = (jRgb*)Srce->ScanLine[0];
 L = (jRgb*)Srce->ScanLine[1];
 
        for(int y = 2; y < h; y++)
    {
    N = (jRgb*)Srce->ScanLine[y];
    T = (jRgb*)Dest->ScanLine[y-1];
    for(int x = 1; x < w; x++)
        {
        b = (   p0*P[x-1].Blue + p1*P[x].Blue + p2*P[x+1].Blue +
               p3* L[x-1].Blue + p4*L[x].Blue + p5*L[x+1].Blue +
               p6* N[x-1].Blue +p7* N[x].Blue +p8* N[x+1].Blue) / k;
 
 
 
        T[x].Blue = (Byte)b;
        T[x].Green = (Byte)b;
        T[x].Red = (Byte)b;
        }
    P = L;
    L = N;
    }
 
 
         ImageOriginale->Repaint();
      ImageOriginale->Visible=true;
 
         return;
}
 
//Appel de la fonction Filtre3 avec le masque vertical de sobel
Filtre3(-1,0,1,-2,0,2,-1,0,1,4);

[ToTo13]

Sinon, il existe encore une autre solution qui consiste à mettre à 0 toutes les valeurs < 0, et à 255 toutes les valeurs > 255

Euh... NON
Tu perds une sacrée quantité d'information => Tu considères comme identiques des valeurs de gradient allant du simple au triple.


@SmileSoft :
Je ne suis pas d'accord avec ta fonction :
- je pense que ta boucle for sur y devrait plutôt commencer à 1 comme pour celle de x. Mais c'est un détail.
- Inutile de diviser par k dans le cas de fonctions gradients. Tu ne fais pas de moyenne ici.
- Même si je ne connais pas le C++, à mon avis ton problème vient de tes "scanline". Pour traiter les ligne Y, tu as besoin de récupérer (ici scanner) les lignes y-1, y et y+1. Or je n'ai pas vraiment l'impression que c'est ce que tu fais.
- Il te faut une image source (à traiter) ET une image résultat. Tu ne peux pas écrire les résultats sur l'image que tu traites.

[SmileSoft]

Merci ToTo13 pour la réponse, je pense qu'avec les déclarations suivantes le code devient lisible

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
Graphics::TBitmap *Srce;
Graphics::TBitmap *Dest ;
   Byte b;
 
class jRgb
{
public:
Byte Blue;
Byte Green;
Byte Red;
 
};
 
jRgb *N;
jRgb *P;
jRgb *L;

j'utilise deux pointeurs sur bitmap "Scre et Dest", Scre manipule le bitmap original et Dest manipule le bitmap après traitement, les deux pointent sur le composant ImageOriginale parce que je veux que mon résultat s'affiche sur la même image.

- je pense que ta boucle for sur y devrait plutôt commencer à 1 comme pour celle de x. Mais c'est un détail.

non, elle doit commencer par 2 parce que initialement, les deux pointeurs sur jRgb " P et L" pointent respectivement sur les lignes 0 et 1 donc je dois commencer la première itération par 2...

- Même si je ne connais pas le C++, à mon avis ton problème vient de tes "scanline". Pour traiter les ligne Y, tu as besoin de récupérer (ici scanner) les lignes y-1, y et y+1. Or je n'ai pas vraiment l'impression que c'est ce que tu fais.
.

en fait ce que je fais réellement est que je récupère les ligne y-2, y-1 et y du bitmap Scre pour remplir la ligne y-1 du bitmap de la destination. voilà le même code commenté

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
void __fastcall TForm1::Filter3(int p0, int p1, int p2, int p3, int p4, int p5, int p6, int p7, int p8, int k)
{
//en C++ les indices des tableaux commencent par 0
w=Srce->Width-1;
h=Srce->Height;
//Intialement
 P = (jRgb*)Srce->ScanLine[0]; // P pointe sur la premiere ligne (y=0) du bitmap Source
 L = (jRgb*)Srce->ScanLine[1]; // L pointe sur la deuxieme ligne (y=1) du bitmap Source
 
        for(int y = 2; y < h; y++)    // on commence la boucle par la "eme ligne (y=2)
    {
    N = (jRgb*)Srce->ScanLine[y];        // N pointe sur la ligne y du bitmap source
    T = (jRgb*)Dest->ScanLine[y-1];   // T pointe sur la ligne y-1 du bitmap Destination
    for(int x = 1; x < w; x++)
        {
        b = (   p0*P[x-1].Blue + p1*P[x].Blue + p2*P[x+1].Blue +
               p3* L[x-1].Blue + p4*L[x].Blue + p5*L[x+1].Blue +
               p6* N[x-1].Blue +p7* N[x].Blue +p8* N[x+1].Blue) / k;
 
 
 
        T[x].Blue = (Byte)b;
        T[x].Green = (Byte)b;
        T[x].Red = (Byte)b;
        }
 
        // passage de P  à la ligne suivante
    P = L;
            // passage de L à la ligne suivante
    L = N;
    }
 
 
         ImageOriginale->Repaint();
      ImageOriginale->Visible=true;
 
         return;
}

salut,

ce même code donne un très bon résultat pour les filtres moyenneur et gaussien basés en réalité sur le produit de convolution, j'aimerais garder cette fonction pour tout les filtres linéaires, j'ai pris le paramètre k à 1 pour éliminer la division mais le problème devient encore pire. je ne sais pas où se situe réellement le problème.

merci pour votre aide.

[ToTo13]

Si en mettant k=1 tu n'obtiens pas ton gradient, c'est que ta fonction est fausse.

[pseudocode]

ce même code donne un très bon résultat pour les filtres moyenneur et gaussien basés en réalité sur le produit de convolution

Donc des cas ou la valeur obtenue est dans le range [0,255].

Ce qui semble bien prouver qu'il faut que tu normalises ta valeur de "b" dans le cas d'un noyau Sobel

[SmileSoft]

Ce qui semble bien prouver qu'il faut que tu normalises ta valeur de "b" dans le cas d'un noyau Sobel

pas compris

[pseudocode]

pas compris

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
b = ( p0*P[x-1].Blue + p1*P[x].Blue + p2*P[x+1].Blue +
      p3* L[x-1].Blue + p4*L[x].Blue + p5*L[x+1].Blue +
      p6* N[x-1].Blue +p7* N[x].Blue +p8* N[x+1].Blue) / k;

// normalisation de la valeur dans le range [0,255]

b = valeurAbsolue( b );
if (b>255) b=255;

T[x].Blue = (Byte)b;
T[x].Green = (Byte)b;
T[x].Red = (Byte)b;

[SmileSoft]

salut, merci pseudocode, mais je n'ai pas eu un grand changement, je vous attache le résultat avant et après la normalisation (dans le 1er message de ce poste).

[pseudocode]

salut, merci pseudocode, mais je n'ai pas eu un grand changement, je vous attache le résultat avant et après la normalisation (dans le 1er message de ce poste).

Si ce n'est pas une erreur de math, c'est une erreur de code. D'ailleurs je viens de voir que "b" est déclaré comme un "Byte", ce qui provoque surement un dépassement de capacité.

[SmileSoft]

Si ce n'est pas une erreur de math, c'est une erreur de code. D'ailleurs je viens de voir que "b" est déclaré comme un "Byte", ce qui provoque surement un dépassement de capacité.

la condition

Code :

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

if (b>255) b=255;

est toujours non vérifiée, je ne vois pas où est le dépassement de capacité.

[pseudocode]

la condition

Code :

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

if (b>255) b=255;

est toujours non vérifiée, je ne vois pas où est le dépassement de capacité.

Code :

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

1
2
3
4
 
b = ( p0*P[x-1].Blue + p1*P[x].Blue + p2*P[x+1].Blue +
      p3* L[x-1].Blue + p4*L[x].Blue + p5*L[x+1].Blue +
      p6* N[x-1].Blue +p7* N[x].Blue +p8* N[x+1].Blue) / k;

comment peut on stocker toutes les valeurs entre -255 et +255 dans un byte ?

[ToTo13]

Mmm... comme te le fait remarquer pseudocode, utiliser un byte limite tes possibilités.
Tu ne pourras jamais traiter des images codées sur des short.
Utilises donc des int pour régler le souci et t'abstraire du type d'image en niveau de gris (binaire, byte, unsigned short).

[SmileSoft]

ci joint le résultat en prenant b entier:

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
 ...
int b = (   p0*P[x-1].Blue + p1*P[x].Blue + p2*P[x+1].Blue +
               p3* L[x-1].Blue + p4*L[x].Blue + p5*L[x+1].Blue +
               p6* N[x-1].Blue +p7* N[x].Blue +p8* N[x+1].Blue) / k;
 
               b=abs(b);
              if (b>255) b=255;
 
 
 
 
        T[x].Blue = b;
        T[x].Green =b;
        T[x].Red = b;
...

et ce n'est pas un bon résultat, qu'en pensez vous?

[ToTo13]

Euh... c'est pas un gradient ça :-(
A ce stade, je te conseille de prendre une image 5x5 avec juste trois pixels blancs (non nuls) et de tester à la main ton algorithme pour voir ce qui se passe.