scipy.ndimage.

distance_transform_edt

scipy.ndimage.distance_transform_edt(input, sampling=None, return_distances=True, return_indices=False, distances=None, indices=None)

Exakter euklidischer Distanztransform.

Diese Funktion berechnet die Distanztransformation des input, indem jedes Vordergrundelement (nicht-Null) durch seine kürzeste Distanz zum Hintergrund (jedes Null-wertige Element) ersetzt wird.

Zusätzlich zur Distanztransformation kann die Merkmals-Transformation berechnet werden. In diesem Fall wird der Index des nächstgelegenen Hintergrundelements zu jedem Vordergrundelement in einem separaten Array zurückgegeben.

Parameter:

inputarray_like

Eingabedaten zum Transformieren. Kann von jedem Typ sein, wird aber binär konvertiert: 1 überall dort, wo der Input True ergibt, sonst 0.

samplingfloat oder Sequenz von float, optional

Abstand der Elemente entlang jeder Dimension. Wenn es sich um eine Sequenz handelt, muss sie die Länge des Eingabegrades haben; wenn es sich um eine einzelne Zahl handelt, wird diese für alle Achsen verwendet. Wenn nicht angegeben, wird ein Gitterabstand von Eins angenommen.

return_distancesbool, optional

Ob die Distanztransformation berechnet werden soll. Standard ist True.

return_indicesbool, optional

Ob die Merkmals-Transformation berechnet werden soll. Standard ist False.

distancesndarray vom Typ float64, optional

Ein Ausgabearray zum Speichern des berechneten Distanztransforms anstelle der Rückgabe. return_distances muss True sein. Es muss die gleiche Form wie input haben.

indicesint32 ndarray, optional

Ein Ausgabe-Array zum Speichern der berechneten Merkmals-Transformation anstelle ihrer Rückgabe. return_indicies muss True sein. Seine Form muss (input.ndim,) + input.shape sein.

Rückgabe:

distancesndarray vom Typ float64, optional

Der berechnete Distanztransform. Wird nur zurückgegeben, wenn return_distances True ist und distances nicht angegeben wurde. Es hat die gleiche Form wie das Eingabearray.

indicesint32 ndarray, optional

Der berechnete Merkmalstransform. Er hat für jede Dimension des Inputs ein Array in der Größe des Inputs. Siehe Beispiel unten. Wird nur zurückgegeben, wenn return_indices True ist und indices nicht angegeben wurde.

Hinweise

Der euklidische Distanztransform gibt die Werte der euklidischen Distanz zurück

              n
y_i = sqrt(sum (x[i]-b[i])**2)
              i

wobei b[i] der Hintergrundpunkt (Wert 0) mit der kleinsten euklidischen Distanz zu den Eingabepunkten x[i] ist und n die Anzahl der Dimensionen ist.

Beispiele

Probieren Sie es in Ihrem Browser aus!

>>> from scipy import ndimage
>>> import numpy as np
>>> a = np.array(([0,1,1,1,1],
...               [0,0,1,1,1],
...               [0,1,1,1,1],
...               [0,1,1,1,0],
...               [0,1,1,0,0]))
>>> ndimage.distance_transform_edt(a)
array([[ 0.    ,  1.    ,  1.4142,  2.2361,  3.    ],
       [ 0.    ,  0.    ,  1.    ,  2.    ,  2.    ],
       [ 0.    ,  1.    ,  1.4142,  1.4142,  1.    ],
       [ 0.    ,  1.    ,  1.4142,  1.    ,  0.    ],
       [ 0.    ,  1.    ,  1.    ,  0.    ,  0.    ]])

Mit einem Abstand von 2 Einheiten entlang x, 1 entlang y

>>> ndimage.distance_transform_edt(a, sampling=[2,1])
array([[ 0.    ,  1.    ,  2.    ,  2.8284,  3.6056],
       [ 0.    ,  0.    ,  1.    ,  2.    ,  3.    ],
       [ 0.    ,  1.    ,  2.    ,  2.2361,  2.    ],
       [ 0.    ,  1.    ,  2.    ,  1.    ,  0.    ],
       [ 0.    ,  1.    ,  1.    ,  0.    ,  0.    ]])

Indizes werden ebenfalls angefordert

>>> edt, inds = ndimage.distance_transform_edt(a, return_indices=True)
>>> inds
array([[[0, 0, 1, 1, 3],
        [1, 1, 1, 1, 3],
        [2, 2, 1, 3, 3],
        [3, 3, 4, 4, 3],
        [4, 4, 4, 4, 4]],
       [[0, 0, 1, 1, 4],
        [0, 1, 1, 1, 4],
        [0, 0, 1, 4, 4],
        [0, 0, 3, 3, 4],
        [0, 0, 3, 3, 4]]], dtype=int32)

Mit bereitgestellten Arrays für In-Place-Ausgaben

>>> indices = np.zeros(((np.ndim(a),) + a.shape), dtype=np.int32)
>>> ndimage.distance_transform_edt(a, return_indices=True, indices=indices)
array([[ 0.    ,  1.    ,  1.4142,  2.2361,  3.    ],
       [ 0.    ,  0.    ,  1.    ,  2.    ,  2.    ],
       [ 0.    ,  1.    ,  1.4142,  1.4142,  1.    ],
       [ 0.    ,  1.    ,  1.4142,  1.    ,  0.    ],
       [ 0.    ,  1.    ,  1.    ,  0.    ,  0.    ]])
>>> indices
array([[[0, 0, 1, 1, 3],
        [1, 1, 1, 1, 3],
        [2, 2, 1, 3, 3],
        [3, 3, 4, 4, 3],
        [4, 4, 4, 4, 4]],
       [[0, 0, 1, 1, 4],
        [0, 1, 1, 1, 4],
        [0, 0, 1, 4, 4],
        [0, 0, 3, 3, 4],
        [0, 0, 3, 3, 4]]], dtype=int32)

ZurückIn Tab öffnen