Scipy Convvove

Il concetto di base di conquista è combinare due segnali usando una funzione matematica per fare il terzo segnale. È la tecnica di elaborazione del segnale digitale più comunemente utilizzata. La convoluzione di due segnali è considerata l'integrale di un segnale convocato su un altro segnale. Questo viene fatto moltiplicando con il prodotto scalare in ciascun punto dei vettori che si sovrappongono.

Lo stesso concetto di conversazione è usato in Python. L'array è considerato come un segnale utilizzato nella funzione Scipy Convolve per eseguire la convoluzione su più array monodimensionali. La convocazione di Scipy è un array n-dimensionale. Di solito sono due o più sequenze 1-D. In questo articolo, discuteremo in dettaglio la funzione Scipy Convive e cercheremo di apprendere l'uso della funzione di convocazione con l'aiuto di esempi.

SCIPY Convveolve Usage e la sua sintassi

La convocazione Scipy viene utilizzata per convogliare due array N-dimensionali. Ecco la sintassi della funzione Scipy Convive:

# Scipy.segnale.convVolve (INP1, inp2, modalità = 'full', method = 'auto')

Il 'INP1' è il primo array di input, 'INP2' è il secondo array di input e dovrebbe avere lo stesso numero di dimensioni del parametro 'INP1'. Il parametro "Modalità" è un parametro stringa che determina la dimensione dell'uscita; È definito da tre opzioni, uguali, validi o completi. È un parametro opzionale.

La modalità "completa" indica che dovrebbe essere fornita la convoluzione lineare discreta completa degli input ed è la modalità predefinita; Se non viene fornita alcuna modalità, la modalità "completa" è considerata predefinita. La modalità "stessa" restituisce l'output della dimensione come parametro "INP1", centrato in base all'output "completo".

L'ultima modalità, anche una modalità "valida", restituisce elementi che non si basano esclusivamente sul taglio zero. Il parametro "Metodo" è un altro parametro opzionale. È un parametro stringa che indica quale metodo deve essere utilizzato per la convoluzione. Prende anche uno dei tre argomenti; auto, fft e diretto. La "FFT" è la trasformata di Fourier, utilizzata per eseguire la convoluzione chiamando la funzione FFTConVolve integrata.

L'argomento "diretto" rappresenta la convoluzione diretta che è la definizione di base di convoluzione. E infine, viene fornito l'argomento "auto" in cui è richiesta la selezione automatica dell'argomento "diretto" o "FFT", a seconda di quale sia più veloce. L'argomento "auto" è il valore predefinito; Se non viene fornito nulla, "auto" è considerato l'argomento predefinito.

L'output della funzione convocata sarà il sottoinsieme della convoluzione lineare discreta di INP1 con INP2. Vediamo gli esempi di seguito per capire come implementare Scipy Convluve.

Esempio 1:

Questo è il primo esempio di questo articolo che aiuterà a liberare i pensieri sulle informazioni teoriche che abbiamo menzionato sopra.

In questo esempio, tracceremo un impulso liscio in forma quadrata usando una finestra di Hann. Il codice del programma utilizza un array NP (indicato come sig_one) per tracciare la curva e il segnale.Convvove () viene utilizzato per convogliare i segnali.

Vedere il codice completo allegato di seguito. Qui, abbiamo importato prima le librerie richieste e ha dichiarato l'array. Dopo aver chiamato la funzione convocata, abbiamo tracciato l'impulso. Nel resto del codice, puoi vedere che abbiamo impostato i margini e visualizzato la risposta all'impulso originale e filtrata e il segnale filtrato sul grafico.

Dal segnale di importazione di Scipy
importa numpy come p
Importa matplotlib.Pyplot come mtp
sig_one = p.Ripeti ([1., 0., 1.], 100)
finestra_one = segnale.finestre.Hann (65)
Filtered_res = Signal.convVolve (sig_one, window_one, modalità = 'stesso') / sum (window_one)
figura_one, (axis_orig, axis_win, axis_filt) = mtp.sottotrame (3, 1, sharix = true)
axis_orig.Plot (sig_one)
axis_orig.set_title ('ecco l'impulso originale')
axis_orig.margini (0, 0.1)
axis_win.Plot (window_one)
axis_win.set_title ("ecco la risposta all'impulso del filtro")
axis_win.margini (0, 0.1)
axis_filt.Plot (Filtered_res)
axis_filt.set_title ("ecco il segnale filtrato")
axis_filt.margini (0, 0.1)
Figura_one.stretto_layout ()
Figura_one.spettacolo()

Si noti che il codice viene eseguito nella collaborazione di Google. Il collaboratorio di Google è uno strumento open source utilizzato per implementare i codici Python. È uno strumento gratuito e facilmente accessibile tramite Google o qualsiasi altro browser.

Dopo aver eseguito il codice, vedrai le onde. Fare riferimento all'immagine allegata di seguito.

Esempio 2:

Questo è il secondo esempio di questo articolo e qui utilizzeremo il metodo NDImage per dimostrare la funzionalità della funzione di convive.

In questo esempio, il parametro "modalità" di NDIMAGE prende uno dei cinque argomenti; avvolgere, specchio, più vicino, costante e riflettere. L'argomento "riflette" rappresenta il mezzo campione simmetrico esteso ricordando il bordo. La "costante" viene utilizzata per rappresentare tutti i valori che sono oltre il bordo ma con lo stesso valore costante.

Il "più vicino" rappresenta un valore specifico che viene esteso replicando il pixel finale. Lo "specchio" rappresenta il centro dell'ultimo pixel e l'argomento "avvolgimento" rappresenta l'avvolgimento sul bordo opposto. Vedi il codice indicato di seguito:

da Scipy Import Ndimage
importa numpy come p
one_arr = p.Array ([[1, 0, 2],
[1, 1, 0],
[1, 0, 0]])
due_arr = p.Array ([[0, 1, 0],
[1, 1, 0],
[0, 1, 0],
[0, 1, 1],
[0, 1, 0]])
Stampa (ndimage.convVolve (one_arr, due_arr, modalità = 'più vicino'))

Ecco l'output del codice sopra, che è l'array contorto come puoi vedere.

Esempio 3:

L'esempio seguente dimostrerà una funzione convocata 2D. I due array bidimensionali sono contorti usando la funzione convluve2d. ConvVolve2d utilizza due parametri opzionali "FillValue" e "Confine".

Il parametro "confine" prende uno dei tre argomenti; Riempi, avvolgi e simm. L'argomento "riempimento" è il valore predefinito e gli array di input del pad con Fillvalue. L'argomento "avvolgimento" rappresenta le condizioni al contorno circolari. L'argomento "simm" rappresenta le condizioni al contorno simmetriche.

Il "FillValue" è rappresentato da un valore scalare che viene utilizzato per riempire l'array di input del pad e il suo valore predefinito è 0. Nel codice allegato, calcoleremo il gradiente di un'immagine.

Dal segnale di importazione di Scipy
da Scipy Import Misc
importa numpy come p
Importa matplotlib.Pyplot come mtb
Ascent_one = misc.salita()
scharr_one = p.Array ([[-3-3J, 0-10J, +3 -3J],
[-6 +0J, 1+ 0J, +6 +0J],
[-2 +2J, 0 +6J, +3 +2J]])
grad_one = segnale.Convolve2d (ascent_one, scharr_one, limite = 'simm', modalità = 'stesso')
fig_one, (axis_orig, axis_mag, axis_ang) = mtb.sottotrame (3, 1, figsize = (7, 16))
axis_orig.imshow (ascent_one, cmap = 'grigio')
axis_orig.set_title ('originale')
axis_orig.set_axis_off ()
axis_mag.imshow (p.Absolute (grad_one), cmap = 'grigio')
axis_mag.set_title ("risultato di magnitudo gradiente")
axis_mag.set_axis_off ()
axis_ang.imshow (p.Angle (grad_one), cmap = 'hsv')
axis_ang.set_title ("risultato di orientamento gradiente")
axis_ang.set_axis_off ()
fig_one.spettacolo()

Ecco l'output del codice sopra indicato:

Conclusione

In questo articolo, abbiamo imparato la funzione Scipy Convive con l'aiuto di esempi. Innanzitutto, abbiamo discusso del concetto di base della funzione convocata, e poi abbiamo appreso la sintassi della funzione convoca.