scipy.ndimage.

convolve#

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

Multidimensionale Faltung.

Das Array wird mit dem gegebenen Kernel gefaltet.

Parameter:

inputarray_like

Das Eingabearray.

weightsarray_like

Array von Gewichten, mit der gleichen Anzahl von Dimensionen wie input

outputarray oder dtype, optional

Das Array, in das die Ausgabe platziert werden soll, oder der Datentyp des zurückgegebenen Arrays. Standardmäßig wird ein Array mit demselben Datentyp wie input erstellt.

mode{‘reflect’, ‘constant’, ‘nearest’, ‘mirror’, ‘wrap’}, optional

Der Parameter mode bestimmt, wie das Eingabearray über seine Grenzen hinaus erweitert wird. Standard ist ‘reflect’. Das Verhalten für jeden gültigen Wert ist wie folgt:

‘reflect’ (d c b a | a b c d | d c b a): Die Eingabe wird erweitert, indem über den Rand des letzten Pixels gespiegelt wird. Dieser Modus wird auch manchmal als halb-Sample-symmetrisch bezeichnet.
‘constant’ (k k k k | a b c d | k k k k): Die Eingabe wird erweitert, indem alle Werte außerhalb des Rands mit demselben konstanten Wert gefüllt werden, der durch den Parameter cval definiert ist.
‘nearest’ (a a a a | a b c d | d d d d): Die Eingabe wird erweitert, indem das letzte Pixel wiederholt wird.
‘mirror’ (d c b | a b c d | c b a): Die Eingabe wird erweitert, indem über die Mitte des letzten Pixels gespiegelt wird. Dieser Modus wird auch manchmal als ganz-Sample-symmetrisch bezeichnet.
‘wrap’ (a b c d | a b c d | a b c d): Die Eingabe wird erweitert, indem zum gegenüberliegenden Rand umgebrochen wird.

Zur Konsistenz mit den Interpolationsfunktionen können auch die folgenden Modusnamen verwendet werden:

‘grid-mirror’: Dies ist ein Synonym für ‘reflect’.
‘grid-constant’: Dies ist ein Synonym für ‘constant’.
‘grid-wrap’: Dies ist ein Synonym für ‘wrap’.

cvalskalar, optional

Wert, mit dem Ränder von input aufgefüllt werden, wenn mode 'constant' ist. Standard ist 0.0

originint oder Sequenz, optional

Steuert die Platzierung des Filters auf den Pixeln des Eingabearrays. Ein Wert von 0 (Standard) zentriert den Filter über dem Pixel, positive Werte verschieben den Filter nach rechts und negative nach links. Durch Übergeben einer Sequenz von Origins mit einer Länge, die der Anzahl der Dimensionen des Eingabearrays entspricht, können entlang jeder Achse unterschiedliche Verschiebungen angegeben werden.

axesTupel von int oder None, optional

Wenn None, wird input entlang aller Achsen gefiltert. Andernfalls wird input entlang der angegebenen Achsen gefiltert. Wenn axes angegeben ist, müssen alle für mode oder origin verwendeten Tupel mit der Länge von axes übereinstimmen. Der i-te Eintrag in einem dieser Tupel entspricht dem i-ten Eintrag in axes.

Rückgabe:

resultndarray: Das Ergebnis der Faltung von input mit weights.

Siehe auch

correlate: Ein Bild mit einem Kernel korrelieren.

Hinweise

Jeder Wert in result ist \(C_i = \sum_j{I_{i+k-j} W_j}\), wobei W der weights-Kernel ist, j der N-D räumliche Index über \(W\) ist, I das input ist und k die Koordinate des Zentrums von W ist, spezifiziert durch origin in den Eingabeparametern.

Beispiele

Der vielleicht einfachste Fall zum Verständnis ist mode='constant', cval=0.0, da in diesem Fall Ränder (d. h. wo der weights-Kernel, zentriert auf einem beliebigen Wert, über einen Rand von input hinausgeht) als Nullen behandelt werden.

>>> 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]])

Das Setzen von cval=1.0 entspricht dem Auffüllen des äußeren Rands von input mit 1.0's (und dann nur den ursprünglichen Bereich des Ergebnisses zu extrahieren).

>>> 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]])

Mit mode='reflect' (Standard) werden äußere Werte am Rand von input reflektiert, um fehlende Werte aufzufüllen.

>>> 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]])

Dies schließt Diagonalen an den Ecken ein.

>>> 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]])

Mit mode='nearest' wird der einzelne nächstgelegene Wert am Rand von input so oft wiederholt, wie es nötig ist, um die überlappenden weights anzupassen.

>>> 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]])