Scipy Convolution

Le concept de base de la convolution est de combiner deux signaux en utilisant une fonction mathématique pour faire le troisième signal. C'est la technique de traitement du signal numérique la plus couramment utilisée. La convolution de deux signaux est considérée comme l'intégrale du seul signal en convolution sur un autre signal. Cela se fait en multipliant avec le produit scalaire à chaque point de vecteurs qui se chevauchent.

Le même concept de convolution est utilisé dans Python. Le tableau est considéré comme un signal qui est utilisé dans la fonction Scipy Convolve pour effectuer une convolution sur plusieurs tableaux unidimensionnels. Le Scipy Convolve est un tableau à n dimensions. Ce sont généralement deux séquences 1-D ou plus. Dans cet article, nous discuterons en détail de la fonction Scipy Confolve et essayerons d'apprendre l'utilisation de la fonction Convolve à l'aide d'exemples.

Scipy Convolution Utilisation et sa syntaxe

Le Scipy Convolve est utilisé pour condamner deux tableaux à n dimensions. Voici la syntaxe de la fonction Scipy Convolve:

# scipy.signal.Convolve (inp1, inp2, mode = 'full', méthode = 'auto')

Le «Inp1» est le premier tableau d'entrée, «Inp2» est le deuxième tableau d'entrée, et il devrait avoir le même nombre de dimensions que le paramètre «Inp1». Le paramètre «Mode» est un paramètre de chaîne qui détermine la taille de sortie; Il est défini par trois options, même, valides ou pleins. C'est un paramètre facultatif.

Le mode «complet» indique que la convolution linéaire discrète complète des entrées doit être fournie, et c'est le mode par défaut; Si aucun mode n'est fourni, le mode «complet» est considéré comme par défaut. Le «même» mode renvoie la sortie comme la taille du paramètre «inp1», centrée selon la sortie «complète».

Le dernier mode, également un mode «valide», renvoie les éléments qui ne se fondent pas uniquement sur le pading zéro. Le paramètre 'Method' est un autre paramètre facultatif. C'est un paramètre de chaîne qui indique quelle méthode doit être utilisée pour la convolution. Il faut également l'un des trois arguments; Auto, FFT et Direct. Le 'FFT' est la transformée de Fourier, utilisée pour effectuer la convolution en appelant la fonction FFTConvolve intégrée.

L'argument «direct» représente la convolution directe qui est la définition de base de la convolution. Et enfin, l'argument «auto» est fourni lorsque la sélection automatique de l'argument «direct» ou «FFT» est requis, ce qui est plus rapide. L'argument «Auto» est la valeur par défaut; Si rien n'est fourni, «auto» est considéré comme l'argument par défaut.

La sortie de la fonction Convolve sera le sous-ensemble d'une convolution linéaire discrète de INP1 avec INP2. Voyons les exemples ci-dessous pour comprendre comment mettre en œuvre Scipy Convolution.

Exemple 1:

Ceci est le tout premier exemple de cet article qui aidera à effacer les réflexions sur les informations théoriques que nous avons mentionnées ci-dessus.

Dans cet exemple, nous tracerons une impulsion lisse en forme carrée à l'aide d'une fenêtre Hann. Le code du programme utilise un tableau NP (indiqué comme SIG_ONE) pour tracer la courbe et le signal.Convolve () est utilisé pour condamner les signaux.

Voir le code complet ci-dessous. Ici, nous avons d'abord importé les bibliothèques requises et déclaré le tableau. Après avoir appelé la fonction Convolve, nous avons tracé l'impulsion. Dans le reste du code, vous pouvez voir que nous avons réglé les marges et affiché la réponse impulsive d'origine et filtrée et le signal filtré sur le graphique.

à partir du signal d'importation Scipy
importer numpy comme p
Importer Matplotlib.pypllot comme MTP
sig_one = p.répéter ([1., 0., 1.], 100)
window_one = signal.les fenêtres.Hann (65)
filtorte_res = signal.Convolve (sig_one, window_one, mode = 'même') / sum (window_one)
figure_one, (axe_orig, axe_win, axe_filt) = mtp.sous-intrigues (3, 1, Sharex = true)
axe_orig.tracé (sig_one)
axe_orig.set_title («voici l'impulsion d'origine»)
axe_orig.marges (0, 0.1)
axe_win.tracé (window_one)
axe_win.set_title («voici la réponse à l'impulsion du filtre»)
axe_win.marges (0, 0.1)
axe_filt.tracé (filtré_res)
axe_filt.set_title («voici le signal filtré»)
axe_filt.marges (0, 0.1)
figure_one.serré_layout ()
figure_one.montrer()

Notez que le code est exécuté dans la collaboration Google. Le Google Collaboratoire est un outil open-source utilisé pour implémenter les codes Python. C'est un outil gratuit et facilement accessible via Google ou tout autre navigateur.

Après avoir exécuté le code, vous verrez les vagues. Reportez-vous à l'image ci-dessous ci-dessous.

Exemple 2:

Ceci est le deuxième exemple de cet article et ici, nous utiliserons la méthode Ndimage pour démontrer la fonctionnalité de la fonction Convolution.

Dans cet exemple, le paramètre «mode» de Ndimage prend l'un des cinq arguments; Enveloppez, miroir, le plus proche, constant et réfléchis. L'argument `` Réfléchir '' représente le demi-échantillon symétrique étendu en se remémorant le bord. La «constante» est utilisée pour représenter toutes les valeurs qui sont au-delà du bord mais avec la même valeur constante.

Le «proche» représente une valeur spécifique étendue en reproduisant le pixel final. Le «miroir» représente le centre du dernier pixel, et l'argument «enveloppe» représente l'enveloppement vers le bord opposé. Voir le code ci-dessous:

De Scipy Import Ndimage
importer numpy comme p
one_arr = p.Array ([[1, 0, 2],
[1, 1, 0],
[1, 0, 0]])
deux_arr = p.Array ([[0, 1, 0],
[1, 1, 0],
[0, 1, 0],
[0, 1, 1],
[0, 1, 0]])
imprimer (ndimage.Convolve (one_arr, deux_arr, mode = 'le plus proche'))

Voici la sortie du code ci-dessus, qui est le tableau alambiqué comme vous pouvez le voir.

Exemple 3:

L'exemple suivant démontrera une fonction de convolution 2D. Les deux tableaux à deux dimensions sont convaincus à l'aide de la fonction Convolve2D. Le Convolve2D utilise deux paramètres facultatifs supplémentaires «FillValue» et «Boundary».

Le paramètre «limite» prend l'un des trois arguments; remplir, envelopper et sym. L'argument «Rempliss» est la valeur par défaut et les tableaux d'entrée de pad avec FillValue. L'argument «enveloppe» représente les conditions limites circulaires. L'argument «symm» représente les conditions aux limites symétriques.

Le «FillValue» est représenté par une valeur scalaire qui est utilisée pour remplir le tableau d'entrée du pad, et sa valeur par défaut est 0. Dans le code joint, nous calculerons le gradient d'une image.

à partir du signal d'importation Scipy
de Scipy Import Misc
importer numpy comme p
Importer Matplotlib.Pypllot comme MTB
ascent_one = disc.ascension()
scharr_one = p.Array ([[- 3-3J, 0-10J, +3 -3J],
[-6 + 0j, 1+ 0j, +6 + 0j],
[-2 + 2j, 0 + 6j, +3 + 2j]])
grad_one = signal.Convolve2d (ascent_one, scharr_one, limite = 'symm', mode = 'même')
Fig_One, (axe_orig, axe_mag, axe_ang) = mtb.sous-tracés (3, 1, FigSize = (7, 16))
axe_orig.imshow (ascent_one, cmap = 'gris')
axe_orig.set_title ('original')
axe_orig.set_axis_off ()
axe_mag.imshow (p.Absolute (grad_one), cmap = 'gris')
axe_mag.set_title («résultat de magnitude du gradient»)
axe_mag.set_axis_off ()
axe_ang.imshow (p.angle (grad_one), cmap = 'hsv')
axe_ang.set_title («résultat d'orientation du gradient»)
axe_ang.set_axis_off ()
fig_one.montrer()

Voici la sortie du code donné ci-dessus:

Conclusion

Dans cet article, nous avons appris la fonction Scipy Convolve à l'aide d'exemples. Tout d'abord, nous avons discuté du concept de base de la fonction Convolve, puis nous avons appris la syntaxe de la fonction Convolve, et plus tard, nous avons examiné trois exemples différents pour voir l'utilisation de la fonction Scipy Convolution d'une manière très différente.