Python中的广义距离变换

Question

I'm currently trying to implement the GDT described by Felzenszwalb and Huttenlocher ( http://www.cs.cornell.edu/~dph/papers/dt.pdf ) inside of Python for an image processing algorithm. However I used the algorithm described in the paper they published a few years back but got faulty results. I found a C# implementation here: https://dsp.stackexchange.com/questions/227/fastest-available-algorithm-for-distance-transform/29727?noredirect=1#comment55866_29727

And converted it to Python (which is pretty much the same I had before).

This is my code:

def of_column(dataInput):
    output = zeros(dataInput.shape)
    n = len(dataInput)

    k = 0
    v = zeros((n,))
    z = zeros((n + 1,))

    v[0] = 0
    z[0] = -inf
    z[1] = +inf

    s = 0

    for q in range(1, n):
        while True:
            s = (((dataInput[q] + q * q) - (dataInput[v[k]] + v[k] * v[k])) / (2.0 * q - 2.0 * v[k]))

            if s <= z[k]:
                k -= 1
            else:
                break

        k += 1

        v[k] = q
        z[k] = s
        z[k + 1] = +inf

    k = 0

    for q in range(n):
        while z[k + 1] < q:
            k += 1

        output[q] = ((q - v[k]) * (q - v[k]) + dataInput[v[k]])

    return output

I still can't find my error. When giving the algorithm a binary (boolean) numpy array it just returns the array itself not the Distance Transform. Why is this not working in Python?

Answer 1

I got it working after hours and hours. The answer given in the link above implementing the code in C# suggests putting up the "white" areas to a very large number. My dataInput array was a boolean array (0, 1). I replaced all 1s with 2^32 and it works just fine. The higher the number the more blurry it gets. The lower the more similar to the source it gets.

Answer 2

I would like to add the function for 2D that works with the 1D function described previously:

############################################################################### 
# distance transform of 1d function using squared distance 
############################################################################### 
def dt_1d(dataInput, n):
    output = np.zeros(dataInput.shape)
    k = 0
    v = np.zeros((n,))
    z = np.zeros((n + 1,))
    v[0] = 0
    z[0] = -np.inf
    z[1] = +np.inf
    for q in range(1, n):
        s = (((dataInput[q] + q * q) - (dataInput[v[k]] + v[k] * v[k])) / (2.0 * q - 2.0 * v[k]))
        while s <= z[k]:
            k -= 1
            s = (((dataInput[q] + q * q) - (dataInput[v[k]] + v[k] * v[k])) / (2.0 * q - 2.0 * v[k]))
        k += 1
        v[k] = q
        z[k] = s
        z[k + 1] = +np.inf

    k = 0
    for q in range(n):
        while z[k + 1] < q:
            k += 1
        value = ((q - v[k]) * (q - v[k]) + dataInput[v[k]])
        if value > 255: value = 255
        if value < 0: value = 0
        output[q] = value
    print output
    return output
############################################################################### 
# distance transform of 2d function using squared distance 
###############################################################################     
def dt_2d(dataInput):
    height, width = dataInput.shape
    f = np.zeros(max(height, width))
    # transform along columns
    for x in range(width):
        f = dataInput[:,x]
        dataInput[:,x] = dt_1d(f, height)
    # transform along rows
    for y in range(height):
        f = dataInput[y,:]
        dataInput[y,:] = dt_1d(f, width)
    return dataInput

I hope it helps.