Better morphological operations

[asudyn]

As far as I understand, right now we're limited to only use 3x3 kernels and the set of operations is pretty limited. I'd really want a more powerful ImageMorph class with ability to set any kernel and ability to work with non-binary images.

[nulano]

I think you can use an arbitrary 3x3 or 5x5 kernel with ImageFilter.Kernel: https://pillow.readthedocs.io/en/stable/reference/ImageFilter.html#PIL.ImageFilter.Kernel

[asudyn]

Thanks, I didn't see that. 5x5 is good. Still I want to be able to apply 7x7, 9x9 and so on. Right now I've written a function to do that but it's extremely slow. It takes 2.5 seconds to apply it to 250x250 pixel image. The function adds an outline of a configurable size to a PNG with alpha channel. I'm trying to speed it up.

def addStroke(image,strokeSize=1,color=(0,0,0)):
	#Create a disc kernel
	kernelSize=math.ceil(strokeSize)*2+1 #Should always be odd
	kernelExtent=int(kernelSize/2)
	kernelRadius=strokeSize+0.5
	kernelCenter=kernelSize/2-1
	pixelRadius=1/math.sqrt(math.pi)
	kernel=[]
	for x in range(kernelSize):
		for y in range(kernelSize):
			distanceToCenter=math.sqrt((kernelCenter-x+0.5)**2+(kernelCenter-y+0.5)**2)
			if(distanceToCenter<=kernelRadius-pixelRadius):
				value=1 #This pixel is fully inside the circle
			elif(distanceToCenter<=kernelRadius):
				value=min(1,(kernelRadius-distanceToCenter+pixelRadius)/(pixelRadius*2)) #Mostly inside
			elif(distanceToCenter<=kernelRadius+pixelRadius):
				value=min(1,(pixelRadius-(distanceToCenter-kernelRadius))/(pixelRadius*2)) #Mostly outside
			else:
				value=0 #This pixel is fully outside the circle
			kernel.append((x-kernelExtent,y-kernelExtent,value))
	kernel=tuple(kernel)

	#Debug save kernel to image
	# image_out=Image.new("L",(kernelSize,kernelSize))
	# image_out.putdata([int(round((1-k[2])*255)) for k in kernel])
	# image_out.save('kernel.png')

	alphaPixels=image.getchannel("A").load()
	outlineValues=[]
	imageWidth,imageHeight=image.size

	start_time=time.time()

	#Morphological grayscale dilation
	for y in range(imageWidth):
		for x in range(imageHeight):
			values=[]
			##############
			#This part slows everything down A LOT
			##############
			for kx,ky,kval in kernel:
				mx,my=x+kx,y+ky
				if(0<=mx<imageWidth and 0<=my<imageHeight):
					values.append(alphaPixels[mx,my]*kval)
			outlineValues.append(int(max(values)))

	print("--- Calculated outline in "+str((time.time()-start_time))+" seconds ---")

	outline=Image.new(mode='RGB',size=image.size,color=color)
	outlineAlpha=Image.new(mode='L',size=image.size,color=0)
	outlineAlpha.putdata(outlineValues)
	outline.putalpha(outlineAlpha)
	outline.paste(image,(0,0),image)
	return outline

[AX-I]

PIL (and Python loops) is not designed for these convolution-type operations, which are more suited for Numpy. You can utilise the np.array(image) and Image.fromarray(array) conversions and speed up your code as follows:

Add this function to convert the kernel into a Numpy array:

def convertKernelNP(k, ksize):
    k = np.array(k)
    k[:,0:2] -= np.min(k[:,0:2])
    out = np.zeros((ksize,ksize))
    out[k[:,0].astype('int'),k[:,1].astype('int')] = k[:,2]
    return out

Replace the big loop after #Morphological grayscale dilation with:

kernelNP = convertKernelNP(kernel, kernelSize)
imageNP = np.array(image)
alphaNP = np.pad(imageNP[:,:,3], strokeSize)
outlineAlphaNP = np.zeros_like(imageNP[:,:,0], dtype='float')

for y in range(kernelSize):
    for x in range(kernelSize):
        np.maximum(outlineAlphaNP,
                   kernelNP[y,x] * alphaNP[y:y+imageHeight,x:x+imageWidth],
                   out=outlineAlphaNP)

Replace these two lines

outlineAlpha=Image.new(mode='L',size=image.size,color=0)
outlineAlpha.putdata(outlineValues)

with:

outlineAlpha=Image.fromarray(outlineAlphaNP.astype('uint8'))

Result: on my computer calling with strokeSize = 8

Before: 3.5253 seconds
After: 0.0156 seconds