scipy.ndimage.

binary_dilation#

scipy.ndimage.binary_dilation(input, structure=None, iterations=1, mask=None, output=None, border_value=0, origin=0, brute_force=False, *, axes=None)[Quelle]#

Mehrdimensionale binäre Dilatation mit dem gegebenen Strukturierungselement.

Parameter:
inputarray_like

Binäre array_like, die dilatiert werden soll. Nicht-Null (True) Elemente bilden die zu dilatierende Teilmenge.

structurearray_like, optional

Strukturierungselement, das für die Dilatation verwendet wird. Nicht-Null-Elemente werden als True betrachtet. Wenn kein Strukturierungselement angegeben wird, wird ein Element mit einer quadratischen Konnektivität von eins generiert.

iterationsint, optional

Die Dilatation wird iterations Mal wiederholt (standardmäßig eins). Wenn iterations kleiner als 1 ist, wird die Dilatation wiederholt, bis sich das Ergebnis nicht mehr ändert. Es wird nur eine ganzzahlige Anzahl von Iterationen akzeptiert.

maskarray_like, optional

Wenn eine Maske angegeben wird, werden nur die Elemente mit einem True-Wert an der entsprechenden Maskenposition bei jeder Iteration modifiziert.

outputndarray, optional

Array mit derselben Form wie input, in das die Ausgabe geschrieben wird. Standardmäßig wird ein neues Array erstellt.

border_valueint (wird zu 0 oder 1 konvertiert), optional

Wert am Rand im Ausgabearray.

originint oder Tupel von ints, optional

Platzierung des Filters, standardmäßig 0.

brute_forceboolean, optional

Speicherbedingung: Wenn False, werden nur die Pixel, deren Wert in der letzten Iteration geändert wurde, als Kandidaten für die Aktualisierung (Dilatation) in der aktuellen Iteration verfolgt; wenn True, werden alle Pixel unabhängig davon, was in der vorherigen Iteration passiert ist, als Kandidaten für die Dilatation betrachtet. Standardmäßig False.

axestuple von int oder None

Die Achsen, über die der Filter angewendet wird. Wenn None, wird input über alle Achsen gefiltert. Wenn ein origin-Tupel angegeben wird, muss seine Länge mit der Anzahl der Achsen übereinstimmen.

Rückgabe:
binary_dilationndarray vom Typ bool

Dilatation des Inputs durch das Strukturierungselement.

Siehe auch

grey_dilation, binary_erosion, binary_closing, binary_opening
generate_binary_structure

Hinweise

Dilatation [1] ist eine mathematische Morphologieoperation [2], die ein Strukturierungselement verwendet, um Formen in einem Bild zu erweitern. Die binäre Dilatation eines Bildes durch ein Strukturierungselement ist der Ort der Punkte, die vom Strukturierungselement abgedeckt werden, wenn dessen Zentrum innerhalb der Nicht-Null-Punkte des Bildes liegt.

Referenzen

Beispiele

>>> from scipy import ndimage
>>> import numpy as np
>>> a = np.zeros((5, 5))
>>> a[2, 2] = 1
>>> a
array([[ 0.,  0.,  0.,  0.,  0.],
       [ 0.,  0.,  0.,  0.,  0.],
       [ 0.,  0.,  1.,  0.,  0.],
       [ 0.,  0.,  0.,  0.,  0.],
       [ 0.,  0.,  0.,  0.,  0.]])
>>> ndimage.binary_dilation(a)
array([[False, False, False, False, False],
       [False, False,  True, False, False],
       [False,  True,  True,  True, False],
       [False, False,  True, False, False],
       [False, False, False, False, False]], dtype=bool)
>>> ndimage.binary_dilation(a).astype(a.dtype)
array([[ 0.,  0.,  0.,  0.,  0.],
       [ 0.,  0.,  1.,  0.,  0.],
       [ 0.,  1.,  1.,  1.,  0.],
       [ 0.,  0.,  1.,  0.,  0.],
       [ 0.,  0.,  0.,  0.,  0.]])
>>> # 3x3 structuring element with connectivity 1, used by default
>>> struct1 = ndimage.generate_binary_structure(2, 1)
>>> struct1
array([[False,  True, False],
       [ True,  True,  True],
       [False,  True, False]], dtype=bool)
>>> # 3x3 structuring element with connectivity 2
>>> struct2 = ndimage.generate_binary_structure(2, 2)
>>> struct2
array([[ True,  True,  True],
       [ True,  True,  True],
       [ True,  True,  True]], dtype=bool)
>>> ndimage.binary_dilation(a, structure=struct1).astype(a.dtype)
array([[ 0.,  0.,  0.,  0.,  0.],
       [ 0.,  0.,  1.,  0.,  0.],
       [ 0.,  1.,  1.,  1.,  0.],
       [ 0.,  0.,  1.,  0.,  0.],
       [ 0.,  0.,  0.,  0.,  0.]])
>>> ndimage.binary_dilation(a, structure=struct2).astype(a.dtype)
array([[ 0.,  0.,  0.,  0.,  0.],
       [ 0.,  1.,  1.,  1.,  0.],
       [ 0.,  1.,  1.,  1.,  0.],
       [ 0.,  1.,  1.,  1.,  0.],
       [ 0.,  0.,  0.,  0.,  0.]])
>>> ndimage.binary_dilation(a, structure=struct1,\
... iterations=2).astype(a.dtype)
array([[ 0.,  0.,  1.,  0.,  0.],
       [ 0.,  1.,  1.,  1.,  0.],
       [ 1.,  1.,  1.,  1.,  1.],
       [ 0.,  1.,  1.,  1.,  0.],
       [ 0.,  0.,  1.,  0.,  0.]])
Auf dieser Seite