Signification du paramètre kernel de filter2D

Salut les OpenCV.

Bon je connais un peu le C++, mais pour l'instant je bosse avec l'implémentation python de OpenCV (cv2).

Et je me pose des questions concernant la fonction filter2D.

Code:

---

Python: cv2.filter2D(src, ddepth, kernel[, dst[, anchor[, delta[, borderType]]]]) -> dst

---

Et plus précisément au sujet du fonctionnement du kernel passer en argument qui est (corriger moi si je me trompe)

une matrice impaire dont le milieux correspond au pixel actuel et tous les autres aux pixels autours.


Par exemple:

Code:

---

1 2 3 4

[[-2, -1, 0], [-1, 8, 1], [ 0, 1, 2]]

---

Alors je voudrai savoir, si vous savez, comment les valeurs du kernel (y compris la valeur du milieux) fonctionnent entre eux afin de produire un résultat ?

Je sais que ça reste vague mais je ne sais pas a quoi correspondent ces valeurs sauf que les pixels entourant le pixel du milieu agissent sur celui-ci, même la valeur du pixel du milieux dans le kernel reste un mystère pour moi.

Je ne comprends pas le fonctionnement.

Toute info est la bienvenue.

Merci pour vos réponses éclairées.

Bon après avoir passer quelques heures dessus,

il s'avère que je me trompe peut-être sur un point:

Que le point du milieux d'une matrice impair représente le pixel courant sur laquelle passe la matrice fenêtre ???

Sinon je pense que les valeurs représentent les poids des pixels et que pour obtenir le résultat du pixel cible il faut diviser par le carré de la matrice:

Code:

---

5² pour une matrice 5x5

---

.

Si vous avez une info, un lien, un conseil, etc... ils sont la bienvenue.

Apparemment pas grand monde dans ce forum !!!

Je passe par ici, mais je vais [sûrement] dire des bêtises :wow:

C'est une matrice de convolution, et en gros c'est pour faire des intégrales. Le calcul correspond à une moyenne pondérée des [8] pixels entourant un pixel [je ne sais plus comment on gère les bords]

Par exemple, avec ta matrice,

Code:

---

1 2 3

[[-2, -1, 0], [-1, 8, 1], [ 0, 1, 2]]

---

ton point central a un coef de 1 (8 / 8) auquel on va additionner 0.5 ((1 + 1 + 2) / 8) fois le coin inférieur droite et retrancher 0.5 ((1 + 1 + 2) / 8) fois le coin supérieur gauche.

Certaines matrices sont très connues, comme celles pour faire de la détection de contours: Image Convolution is Fun ! ou Inkscape

Merci foetus,

pour ta réponse car apparemment il n'y a pas grand monde sur ce forum:

Car j'ai poster le 10/08/2015 a 20h54 et j'ai eu une seule réponse de ta part le 15/08/2015 a 08h00.

Brefs, une matrice de convolution est une matrice qui sert de fenêtre, en passant tous les pixels de l'image par cette fenêtre,
le point central représentant le pixel courant les autres ceux l'entourant: mais alors comment gérer le pixel situer a [0:0] ou [0][0] car il n'a pas de pixels a sa gauche au dessus ni dans le coin des deux.

Citation:

---

[je ne sais plus comment on gère les bords]

---

Et bien d'après le lien que tu m'a fournis il y a plusieurs techniques pour résoudre le problème:

-) En remplaçant les valeurs manquantes de la matrice par 0.
-) Dupliquer les pixels de bords afin de créer un voisinage.
-) Enroulage de la matrice: le pixel manquant prend la valeur du pixel opposé.
-) Miroir: par symétrie la ligne supérieur et inférieur sont remplacer par les valeurs de la ligne centrale et idem concernant a gauche et a droite (la colonne du milieux) et les coins prennent la valeur du point centrale.

La matrice que j'ai pris pour exemple est une matrice de type emboss:

Code:

---

1 2 3

[[-2, -1, 0], [-1, 8, 1], [ 0, 1, 2]]

---

mais je pense qu'il faut remplacer le 8 par un 1 afin que le poids globale de la matrice soit égale a valeur 1: calcule de la somme de toutes les valeurs de la matrice.

D'ailleurs si le poids globale équivaut a 0 l'on se retrouve très souvent avec un fond noir mettant en avant les objets de l'image le fond étant noir.
Si le poids globale de la matrice est supérieur a 1 l'on se retrouve souvent avec un fond blanc ou des effets de blanchiment.
Avec un poids globale égale a 1 c'est normale.
Sinon égale a -1 c'est souvent très foncé et l'on y voit pas grand chose voir pas du tout (image toute noir).
Mais cela dépend grandement du type de matrice utilisé.

Sinon tu a raison la variété des types de matrices est grandes ainsi que les astuces comme normaliser les valeurs par exemple...

Merci pour les deux liens j'en ai déjà lu un, et pour tes explications éclairées.

Bonjour,
Pour répondre à ta première question concernant le filtrage au niveau des valeurs singulières, si on peut les appeler comme ça (comme les coins), on génère d'abord des valeurs virtuelles au voisinage de ce point, par exemple :

Code:

---

1 2 3

[1,2,3 4,5,6 7,8,9]

---

Pour calculer le filtrage au point 1, on régénère le voisinage comme ceci:

Code:

---

1 2 3

[a,b,c d,1,2 e,4,5]

---

tel que {a,b,c,d,e} est une fonction de l'ancien voisinage (on peut les calculer par symétrie, moyenne..etc) mais souvent on utilise le zéro padding, on remplace simplement ces valeurs par zeros, et ensuite on applique la convolution.
Pour revenir à la convolution elle-même, faut avoir en tête l’expression mathématique en tête et la dérouler, si on a un signal x filtré par un noyau h, on peut l'écrire comme ceci :

Code:

---

S(m,n) = X(m,n) * H(m,n) = Somme_i[Somme_j[X(i,j).H(m-i,n-j)]]

---

.

Un exemple pour mieux comprendre (le zero padding est utilisé ici) :

Code:

---

1 2 3

[1,2,3 [-1,-2,-1 [-13,-20,-17 4,5,6 * 0,0,0 = -18,-24,-18 7,8,9] 1,2,1] 13 20 17]

---

Donc si on déroule pour la première valeur,

Code:

---

1 2 3 4

S(0,0) = X(-1,-1).H(1,1) + X(0,-1).H(0,1) + X(1,-1).H(-1,1) + X(-1,0).H(1,0) + X(0,0).H(0,0) + X(1,0).H(-1,0) + X(-1,1).H(1,-1) + X(0,1).H(0,-1) + X(1,1).H(-1,-1) = 0.1+ 0.2 + 0.0 +1.0 +2.0 +0.(-1) + 4.(-2) + 5(-1) = -13.

---

Voila j'espère que c'est plus clair maintenant ;).