scipy.ndimage.

generic_filter

scipy.ndimage.generic_filter(input, function, size=None, footprint=None, output=None, mode='reflect', cval=0.0, origin=0, extra_arguments=(), extra_keywords=None, *, axes=None)

Berechnet einen multidimensionalen Filter mit der gegebenen Funktion.

An jedem Element wird die bereitgestellte Funktion aufgerufen. Die Eingabewerte innerhalb des Filter-Fußabdrucks an diesem Element werden der Funktion als 1D-Array von Gleitkommawerten übergeben.

Parameter:

inputarray_like

Das Eingabearray.

function{callable, scipy.LowLevelCallable}

Funktion, die an jedem Element angewendet werden soll.

sizeSkalar oder Tupel, optional

Siehe footprint unten. Ignoriert, wenn footprint angegeben ist.

footprintArray, optional

Entweder size oder footprint muss definiert sein. size gibt die Form an, die vom Eingabearray an jeder Elementposition genommen wird, um die Eingabe für die Filterfunktion zu definieren. footprint ist ein boolesches Array, das (implizit) eine Form angibt, aber auch, welche der Elemente innerhalb dieser Form an die Filterfunktion übergeben werden. Somit ist size=(n,m) äquivalent zu footprint=np.ones((n,m)). Wir passen size an die Anzahl der Dimensionen des Eingabearrays an, so dass, wenn das Eingabearray die Form (10,10,10) hat und size 2 ist, die tatsächliche verwendete Größe (2,2,2) ist. Wenn footprint angegeben ist, wird size ignoriert.

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 die Ränder der Eingabe gefüllt werden, wenn mode ‘constant’ ist. Standard ist 0.0.

originint oder Sequenz, optional

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

extra_argumentssequence, optional

Sequenz zusätzlicher Positionsargumente, die an die übergebene Funktion übergeben werden.

extra_keywordsdict, optional

Dict mit zusätzlichen Schlüsselwortargumenten, die an die übergebene Funktion übergeben werden.

axesTupel von int oder None, optional

Wenn None, wird input über alle Achsen gefiltert. Andernfalls wird input entlang der angegebenen Achsen gefiltert. Wenn axes angegeben ist, müssen Tupel, die für size oder origin verwendet werden, die Länge von axes haben. Der i-te Eintrag in einem dieser Tupel entspricht dem i-ten Eintrag in axes.

Rückgabe:

outputndarray

Gefiltertes Array. Hat die gleiche Form wie input.

Siehe auch

vectorized_filter

ähnliche Funktionalität, aber optimiert für vektorisierte aufrufbare Elemente

Hinweise

Diese Funktion eignet sich ideal für die Verwendung mit Instanzen von scipy.LowLevelCallable; für vektorisierte, reine Python-aufrufbare Elemente sollten Sie vectorized_filter für verbesserte Leistung in Betracht ziehen.

Low-Level-Callback-Funktionen müssen eine der folgenden Signaturen haben

int callback(double *buffer, npy_intp filter_size,
             double *return_value, void *user_data)
int callback(double *buffer, intptr_t filter_size,
             double *return_value, void *user_data)

Die aufrufende Funktion durchläuft die Elemente der Eingabe- und Ausgabearrays und ruft die Callback-Funktion für jedes Element auf. Die Elemente innerhalb des Filter-Fußabdrucks am aktuellen Element werden über den Parameter buffer übergeben, und die Anzahl der Elemente innerhalb des Fußabdrucks über filter_size. Der berechnete Wert wird in return_value zurückgegeben. user_data ist der an scipy.LowLevelCallable übergebene Datenzeiger im Originalzustand.

Die Callback-Funktion muss einen ganzzahligen Fehlerstatus zurückgeben, der Null ist, wenn etwas schief gelaufen ist, und eins sonst. Wenn ein Fehler auftritt, sollten Sie normalerweise den Python-Fehlerstatus mit einer aussagekräftigen Nachricht setzen, bevor Sie zurückkehren, andernfalls wird eine Standardfehlermeldung von der aufrufenden Funktion gesetzt.

Zusätzlich werden einige andere Low-Level-Funktionszeigerspezifikationen akzeptiert, diese sind jedoch nur aus Kompatibilitätsgründen vorhanden und sollten nicht in neuem Code verwendet werden.

Beispiele

Probieren Sie es in Ihrem Browser aus!

Importieren Sie die notwendigen Module und laden Sie das für die Filterung verwendete Beispielbild.

>>> import numpy as np
>>> from scipy import datasets
>>> from scipy.ndimage import zoom, generic_filter
>>> import matplotlib.pyplot as plt
>>> ascent = zoom(datasets.ascent(), 0.5)

Berechnen Sie einen maximalen Filter mit der Kernelgröße 5, indem Sie eine einfache NumPy-Aggregationsfunktion als Argument an function übergeben.

>>> maximum_filter_result = generic_filter(ascent, np.amax, [5, 5])

Während ein maximaler Filter auch direkt über maximum_filter erhalten werden könnte, ermöglicht generic_filter die Verwendung von generischen Python-Funktionen oder scipy.LowLevelCallable als Filter. Hier berechnen wir die Spanne zwischen dem maximalen und dem minimalen Wert als Beispiel für eine Kernelgröße von 5.

>>> def custom_filter(image):
...     return np.amax(image) - np.amin(image)
>>> custom_filter_result = generic_filter(ascent, custom_filter, [5, 5])

Plotten Sie die Original- und die gefilterten Bilder.

>>> fig, axes = plt.subplots(3, 1, figsize=(3, 9))
>>> plt.gray()  # show the filtered result in grayscale
>>> top, middle, bottom = axes
>>> for ax in axes:
...     ax.set_axis_off()  # remove coordinate system
>>> top.imshow(ascent)
>>> top.set_title("Original image")
>>> middle.imshow(maximum_filter_result)
>>> middle.set_title("Maximum filter, Kernel: 5x5")
>>> bottom.imshow(custom_filter_result)
>>> bottom.set_title("Custom filter, Kernel: 5x5")
>>> fig.tight_layout()

ZurückIn Tab öffnen