matlab's bwmorph(image, 'spur') in python

Question

I'm porting a matlab image processing script over to python/skimage and haven't been able to find Matlab's bwmorph function, specifically the 'spur' operation in skimage. The matlab docs say this about spur operation:

Removes spur pixels. For example:
0  0  0  0           0  0  0  0
0  0  0  0           0  0  0  0
0  0  1  0  becomes  0  0  0  0
0  1  0  0           0  1  0  0
1  1  0  0           1  1  0  0

I've implemented a version in python than handles the above case fine:

def _neighbors_conv(image):
    image = image.astype(np.int)
    k = np.array([[1,1,1],[1,0,1],[1,1,1]])
    neighborhood_count = ndimage.convolve(image,k, mode='constant', cval=1)
    neighborhood_count[~image.astype(np.bool)] = 0
    return neighborhood_count

def spur(image):
    return _neighbors_conv(image) > 1

def bwmorph(image, fn, n=1):
    for _ in range(n):
        image = fn(image)
    return image

t= [[0, 0, 0, 0],
    [0, 0, 1, 0],
    [0, 1, 0, 0],
    [1, 1, 0, 0]]
t = np.array(t)
print('neighbor count:')
print(_neighbors_conv(t))
print('after spur:')
print(bwmorph(t,spur).astype(np.int))

neighbor count:
[[0 0 0 0]
 [0 0 1 0]
 [0 3 0 0]
 [7 5 0 0]]
after spur:
[[0 0 0 0]
 [0 0 0 0]
 [0 1 0 0]
 [1 1 0 0]]

The above works by removing any pixels that only have a single neighboring pixel.

I have noticed that the above implementation behaves differently than matlab's spur operation though. Take this example in matlab:

0     0     0     0     0
0     0     1     0     0
0     1     1     1     1
0     0     1     0     0
0     0     0     0     0

becomes, via bwmorph(t,'spur',1):

0      0     0     0     0
0      0     0     0     0
0      0     1     1     1
0      0     0     0     0
0      0     0     0     0

The spur operation is a bit more complex than looking at the 8-neighbor count. It is not clear to me how to extend my implementation to satisfy this case without making it too aggressive (i.e. removing valid pixels).

What is the underlying logic of matlab's spur or is there a python implementation already available that I can use?

UPDATE: I have found Octave's implemenation of spur that uses a LUT:

case('spur')
      ## lut=makelut(inline("xor(x(2,2),(sum((x&[0,1,0;1,0,1;0,1,0])(:))==0)&&(sum((x&[1,0,1;0,0,0;1,0,1])(:))==1)&&x(2,2))","x"),3);
      ## which is the same as
      lut=repmat([zeros(16,1);ones(16,1)],16,1); ## identity
      lut([18,21,81,273])=0; ## 4 qualifying patterns
      lut=logical(lut);
      cmd="BW2=applylut(BW, lut);";

(via https://searchcode.com/codesearch/view/9585333/) Assuming that is correct I just need to be able to create this LUT in python and apply it...

Answer 1

I ended up implementing my own version of spur and other operations of bwmorph myself. For future internet travelers who have the same need here is a handy gist of what I ended up using:

https://gist.github.com/bmabey/4dd36d9938b83742a88b6f68ac1901a6