scipy.ndimage.

binary_closing#

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

Mehrdimensionale binäre Schließung mit dem gegebenen Struktur-Element.

Die Schließung eines Eingabebildes durch ein Struktur-Element ist die Erosion der Dilatation des Bildes durch das Struktur-Element.

Parameter:
inputarray_like

Binäres Array_like, das geschlossen werden soll. Nicht-Null (True) Elemente bilden die zu schließende Teilmenge.

structurearray_like, optional

Struktur-Element, das für die Schließung verwendet wird. Nicht-Null-Elemente werden als True betrachtet. Wenn kein Struktur-Element angegeben wird, wird ein Element mit einer quadratischen Konnektivität von eins generiert (d. h. nur benachbarte Pixel sind mit dem Zentrum verbunden, diagonal verbundene Elemente sind keine Nachbarn).

iterationsint, optional

Der Dilatationsschritt der Schließung und dann der Erosionsschritt werden jeweils iterations Mal wiederholt (standardmäßig eins). Wenn Iterationen kleiner als 1 sind, wird jede Operation wiederholt, bis sich das Ergebnis nicht mehr ändert. Nur eine ganze Zahl von Iterationen wird akzeptiert.

outputndarray, optional

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

originint oder Tupel von ints, optional

Platzierung des Filters, standardmäßig 0.

maskarray_like, optional

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

Hinzugefügt in Version 1.1.0.

border_valueint (wird zu 0 oder 1 konvertiert), optional

Wert am Rand im Ausgabearray.

Hinzugefügt in Version 1.1.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 in der aktuellen Iteration verfolgt; wenn True, werden alle Pixel als Kandidaten für die Aktualisierung betrachtet, unabhängig davon, was in der vorherigen Iteration passiert ist. Standardmäßig False.

Hinzugefügt in Version 1.1.0.

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_closingndarray von bools

Schließung des Inputs durch das Struktur-Element.

Siehe auch

grey_closing, binary_opening, binary_dilation, binary_erosion
generate_binary_structure

Hinweise

Schließung [1] ist eine mathematische Morphologie-Operation [2], die aus der Abfolge einer Dilatation und einer Erosion des Inputs mit demselben Struktur-Element besteht. Die Schließung füllt daher Löcher auf, die kleiner als das Struktur-Element sind.

Zusammen mit der Öffnung (binary_opening) kann die Schließung zur Rauschunterdrückung verwendet werden.

Referenzen

Beispiele

>>> from scipy import ndimage
>>> import numpy as np
>>> a = np.zeros((5,5), dtype=int)
>>> a[1:-1, 1:-1] = 1; a[2,2] = 0
>>> a
array([[0, 0, 0, 0, 0],
       [0, 1, 1, 1, 0],
       [0, 1, 0, 1, 0],
       [0, 1, 1, 1, 0],
       [0, 0, 0, 0, 0]])
>>> # Closing removes small holes
>>> ndimage.binary_closing(a).astype(int)
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]])
>>> # Closing is the erosion of the dilation of the input
>>> ndimage.binary_dilation(a).astype(int)
array([[0, 1, 1, 1, 0],
       [1, 1, 1, 1, 1],
       [1, 1, 1, 1, 1],
       [1, 1, 1, 1, 1],
       [0, 1, 1, 1, 0]])
>>> ndimage.binary_erosion(ndimage.binary_dilation(a)).astype(int)
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]])

>>> a = np.zeros((7,7), dtype=int)
>>> a[1:6, 2:5] = 1; a[1:3,3] = 0
>>> a
array([[0, 0, 0, 0, 0, 0, 0],
       [0, 0, 1, 0, 1, 0, 0],
       [0, 0, 1, 0, 1, 0, 0],
       [0, 0, 1, 1, 1, 0, 0],
       [0, 0, 1, 1, 1, 0, 0],
       [0, 0, 1, 1, 1, 0, 0],
       [0, 0, 0, 0, 0, 0, 0]])
>>> # In addition to removing holes, closing can also
>>> # coarsen boundaries with fine hollows.
>>> ndimage.binary_closing(a).astype(int)
array([[0, 0, 0, 0, 0, 0, 0],
       [0, 0, 1, 0, 1, 0, 0],
       [0, 0, 1, 1, 1, 0, 0],
       [0, 0, 1, 1, 1, 0, 0],
       [0, 0, 1, 1, 1, 0, 0],
       [0, 0, 1, 1, 1, 0, 0],
       [0, 0, 0, 0, 0, 0, 0]])
>>> ndimage.binary_closing(a, structure=np.ones((2,2))).astype(int)
array([[0, 0, 0, 0, 0, 0, 0],
       [0, 0, 1, 1, 1, 0, 0],
       [0, 0, 1, 1, 1, 0, 0],
       [0, 0, 1, 1, 1, 0, 0],
       [0, 0, 1, 1, 1, 0, 0],
       [0, 0, 1, 1, 1, 0, 0],
       [0, 0, 0, 0, 0, 0, 0]])
Auf dieser Seite