scipy.ndimage.

convolve#

scipy.ndimage.convolve(input, weights, output=None, mode='reflect', cval=0.0, origin=0, *, axes=None)[source]#

多維卷積。

陣列會與給定的核心進行卷積。

參數:

inputarray_like

輸入陣列。

weightsarray_like

權重陣列，維度數量與輸入相同

outputarray 或 dtype，選填

要放入輸出的陣列，或返回陣列的 dtype。預設情況下，將會建立與輸入相同 dtype 的陣列。

mode{‘reflect’, ‘constant’, ‘nearest’, ‘mirror’, ‘wrap’}, 選填

mode 參數決定輸入陣列如何在其邊界之外延伸。預設值為 ‘reflect’。每個有效值的行為如下

‘reflect’ (d c b a | a b c d | d c b a): 輸入會透過反射最後一個像素的邊緣來延伸。此模式有時也稱為半樣本對稱。
‘constant’ (k k k k | a b c d | k k k k): 輸入會透過以相同的常數值（由 cval 參數定義）填滿邊緣以外的所有值來延伸。
‘nearest’ (a a a a | a b c d | d d d d): 輸入會透過複製最後一個像素來延伸。
‘mirror’ (d c b | a b c d | c b a): 輸入會透過反射最後一個像素的中心來延伸。此模式有時也稱為全樣本對稱。
‘wrap’ (a b c d | a b c d | a b c d): 輸入會透過環繞到相對的邊緣來延伸。

為了與內插函數保持一致，也可以使用以下模式名稱

‘grid-mirror’: 這是 ‘reflect’ 的同義詞。
‘grid-constant’: 這是 ‘constant’ 的同義詞。
‘grid-wrap’: 這是 ‘wrap’ 的同義詞。

cvalscalar，選填

如果 mode 為 ‘constant’，則填滿輸入邊緣以外的值。預設值為 0.0

originint 或 sequence，選填

控制濾鏡在輸入陣列像素上的位置。值 0（預設值）將濾鏡置中於像素上方，正值將濾鏡向右移動，負值則向左移動。透過傳遞與輸入陣列維度數量相等的原點序列，可以沿著每個軸指定不同的偏移。

axesint 或 None 的 tuple，選填

如果為 None，則 input 會沿著所有軸進行濾波。否則，input 會沿著指定的軸進行濾波。當指定 axes 時，用於 mode 或 origin 的任何 tuple 都必須與 axes 的長度相符。這些 tuple 中的第 i 個條目對應於 axes 中的第 i 個條目。

返回:

resultndarray: input 與 weights 卷積的結果。

另請參閱

correlate: 將影像與核心進行互相關。

註解

結果中的每個值為 \(C_i = \sum_j{I_{i+k-j} W_j}\)，其中 W 是 weights 核心，j 是 \(W\) 上的 N 維空間索引，I 是 input，而 k 是 W 中心的座標，由輸入參數中的 origin 指定。

範例

可能最容易理解的情況是 mode='constant', cval=0.0，因為在這種情況下，邊界（即，weights 核心，以任何一個值為中心，超出 input 的邊緣）被視為零。

>>> import numpy as np
>>> a = np.array([[1, 2, 0, 0],
...               [5, 3, 0, 4],
...               [0, 0, 0, 7],
...               [9, 3, 0, 0]])
>>> k = np.array([[1,1,1],[1,1,0],[1,0,0]])
>>> from scipy import ndimage
>>> ndimage.convolve(a, k, mode='constant', cval=0.0)
array([[11, 10,  7,  4],
       [10,  3, 11, 11],
       [15, 12, 14,  7],
       [12,  3,  7,  0]])

設定 cval=1.0 相當於用 1.0 填充 input 的外邊緣（然後僅提取結果的原始區域）。

>>> ndimage.convolve(a, k, mode='constant', cval=1.0)
array([[13, 11,  8,  7],
       [11,  3, 11, 14],
       [16, 12, 14, 10],
       [15,  6, 10,  5]])

使用 mode='reflect'（預設值），外部值會在 input 的邊緣反射，以填補遺失的值。

>>> b = np.array([[2, 0, 0],
...               [1, 0, 0],
...               [0, 0, 0]])
>>> k = np.array([[0,1,0], [0,1,0], [0,1,0]])
>>> ndimage.convolve(b, k, mode='reflect')
array([[5, 0, 0],
       [3, 0, 0],
       [1, 0, 0]])

這包括角落的對角線。

>>> k = np.array([[1,0,0],[0,1,0],[0,0,1]])
>>> ndimage.convolve(b, k)
array([[4, 2, 0],
       [3, 2, 0],
       [1, 1, 0]])

使用 mode='nearest'，input 邊緣中最接近的單個值會重複多次，以符合重疊的 weights。

>>> c = np.array([[2, 0, 1],
...               [1, 0, 0],
...               [0, 0, 0]])
>>> k = np.array([[0, 1, 0],
...               [0, 1, 0],
...               [0, 1, 0],
...               [0, 1, 0],
...               [0, 1, 0]])
>>> ndimage.convolve(c, k, mode='nearest')
array([[7, 0, 3],
       [5, 0, 2],
       [3, 0, 1]])