Python Euclidean distance transform

Euclidean distance transformation

edt, that is Euclidean distance transform., the Euclidean distance transform. For a binary matrix $A$，元素$a\in A$，则$\mathrm{edt}\left(a\right)$ to$The\; shortest\; distance\; from\; a$ to the 0 element in the matrix. Suppose there is a matrix

$$A=\left[\begin{array}{ccccc}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\end{array}\right]$$

记$B=\mathrm{edt}\left(a\right)$ , then

• For $A_{11}$As far as it is 0, the corresponding $B_{11}=0$
• $A_{12}=1$ , distance$A_{12}$The nearest 0 is in $A_{11}$和$A_{22}$, the interval is 1, so $B_{12}=1$
• $A_{13}=1$ , distance$A_{13}$The nearest 0 is in $A_{22}$, since it is in the lower left corner, the distance is $\sqrt{1+1}=\sqrt{2}$, ie $B_{12}=\sqrt{2}$

By analogy, get

$$B=\left[\begin{array}{ccccc}0.& 1.& \sqrt{2}& \sqrt{5}& 3.\\ 0.& 0.& 1.& 2.& 2.\\ 0.& 1.& \sqrt{2}& \sqrt{2}& 1.\\ 0.& 1.& \sqrt{2}& 1.& 0.\\ 0.& 1.& 1.& 0.& 0.\end{array}\right]$$

distance_transform_edt

In scipy.ndimage, distance_transform_edtthe Euclidean transformation can be computed,

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.41421356, 2.23606798, 3.        ],
       [0.        , 0.        , 1.        , 2.        , 2.        ],
       [0.        , 1.        , 1.41421356, 1.41421356, 1.        ],
       [0.        , 1.        , 1.41421356, 1.        , 0.        ],
       [0.        , 1.        , 1.        , 0.        , 0.        ]])
'''

Its full definition is

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

The meaning of its parameters is

• samplingGrid spacing, equivalent to $B$ multiplied by a factor
• return_distancesTrueReturns the distance matrix when
• return_indicesTrueReturns the feature transformation matrix when
• distances, indicesArrays for passing parameters by pointer, don’t worry

Other distance transformation functions

scipy.ndimageBesides edt, two other distance transformation functions are provided

istance_transform_bf(input, metric='euclidean', sampling=None, return_distances=True, return_indices=False, distances=None, indices=None)
distance_transform_cdt(input, metric='chessboard', return_distances=True, return_indices=False, distances=None, indices=None)

Compared with the two edt, there are more metricfunctions, bfthree of which are optional euclidean, taxicab, chessboard, and cdtthere is no euclideanoption. The other difference between the two is mainly the algorithm used.

These three different metricschemes used in calculating the distance are different

• euclideanThat is, the aforementioned Euclidean distance
• chessboardwill count the diagonal distance as 1, not $\sqrt{2}$
• taxicabSimilar to Manhattan distance, does not handle diagonals

The difference between the two is as follows

>>> ndimage.distance_transform_bf(a,'chessboard')
array([[0, 1, 1, 2, 3],
       [0, 0, 1, 2, 2],
       [0, 1, 1, 1, 1],
       [0, 1, 1, 1, 0],
       [0, 1, 1, 0, 0]], dtype=uint32)
>>> ndimage.distance_transform_bf(a,'taxicab')
array([[0, 1, 2, 3, 3],
       [0, 0, 1, 2, 2],
       [0, 1, 2, 2, 1],
       [0, 1, 2, 1, 0],
       [0, 1, 1, 0, 0]], dtype=uint32)
>>>