【画像処理】Numpyでモルフォロジー演算

import numpy as np
import matplotlib.pyplot as plt

original_image = plt.imread(image_name)
if np.issubdtype(original_image.dtype, np.floating):
  original_image = (original_image * 255).astype(np.uint8)
gray_image = (0.2116 * original_image[:,:,0] + 0.7152 * original_image[:,:,1] + 0.0722 * original_image[:,:,2]).astype(np.uint8)
plt.imshow(gray_image, cmap='gray')

def thresholding(image, threshold):
  return np.where(image <= threshold, 0, 255)
  
binary_image = thresholding(gray_image, 128)
plt.imshow(binary_image, cmap='gray')

def erode(image, boundary='edge'):
  pad_image = np.pad(image, 1, boundary)
  areas = np.lib.stride_tricks.as_strided(pad_image, image.shape + (3, 3), pad_image.strides * 2)
  return np.min(areas, axis=(2, 3))

erode_binary_image = erode(binary_image)
plt.imshow(erode_binary_image, cmap='gray')

erode_gray_image = erode(gray_image)
plt.imshow(erode_gray_image, cmap='gray')

def dilate(image, boundary='edge'):
  pad_image = np.pad(image, 1, boundary)
  areas = np.lib.stride_tricks.as_strided(pad_image, image.shape + (3, 3), pad_image.strides * 2)
  return np.max(areas, axis=(2, 3))

dilate_binary_image = dilate(binary_image)
plt.imshow(dilate_binary_image, cmap='gray')

dilate_gray_image = dilate(gray_image)
plt.imshow(dilate_gray_image, cmap='gray')

def opening(image, n=2, boundary='edge'):
  for i in range(n):
    image = erode(image, boundary)
  for i in range(n):
    image = dilate(image, boundary)
  return image

opening_binary_image = opening(binary_image)
plt.imshow(opening_binary_image, cmap='gray')

opening_gray_image = opening(gray_image)
plt.imshow(opening_gray_image, cmap='gray')

def closing(image, n=2, boundary='edge'):
  for i in range(n):
    image = dilate(image, boundary)
  for i in range(n):
    image = erode(image, boundary)
  return image

closing_binary_image = closing(binary_image)
plt.imshow(closing_binary_image, cmap='gray')

closing_gray_image = closing(gray_image)
plt.imshow(closing_gray_image, cmap='gray')

def tophat(image, n=2, boundary='edge'):
  opening_image = opening(image, n, boundary)
  return image - opening_image

tophat_binary_image = tophat(binary_image)
plt.imshow(tophat_binary_image, cmap='gray')

tophat_gray_image = tophat(gray_image)
plt.imshow(tophat_gray_image, cmap='gray')

def blackhat(image, n=2, boundary='edge'):
  closing_image = opening(image, n, boundary)
  return closing_image - image

blackhat_binary_image = blackhat(binary_image)
plt.imshow(blackhat_binary_image, cmap='gray')

blackhat_gray_image = blackhat(gray_image)
plt.imshow(blackhat_gray_image, cmap='gray')