十個使用NumPy就可以進行的圖像處理步驟
作者：Ayo Akinkugbe
圖像處理是一種數學計算。數字圖像由稱為像素的彩色小點組成。每個像素由紅、綠、藍(RGB)三個獨立的顏色組成。每個像素中的主色由每個RGB分量的數值決定。
圖像處理是一種數學計算。數字圖像由稱為像素的彩色小點組成。每個像素由紅、綠、藍(RGB)三個獨立的顏色組成。每個像素中的主色由每個RGB分量的數值決定。
本文將介紹10個使用使用NumPy就可以進行的圖像處理步驟，雖然有更強大的圖像處理庫，但是這些簡單的方法可以讓我們更加熟練的掌握NumPy的操作。
我們首先使用pillow讀取圖像
import numpy as np
#Use PIL to access image data
from PIL import Image
img = Image.open('monalisa.jpg')
#Create array from image data
M = np.array(img)
#Display array from image data
display(Image.fromarray(M))1、縮小圖像
def reduce_image_size_by_n(image, n):
# Get the height and width of the image
height, width, channels = image.shape
# Reduce the height and width by n
new_height = height // n
new_width = width // n
# Create a new array to store the reduced image
downsampled_image = np.zeros((new_height, new_width, channels), dtype=image.dtype)
# Iterate over each pixel of the reduced image
for i in range(new_height):
for j in range(new_width):
# Take every other pixel along each axis to reduce the image
downsampled_image[i, j] = image[n*i, n*j]
return downsampled_image
#Try the function using n = 2
reduced_M = reduce_image_size_by_n(M, 2)
display(reduced_M)
2、水平翻轉
def flip_image(image):
# Takes all rows in image (:) and reverses it the order of columns (::-1)
flip_image = image[:, ::-1]
return flip_image
#Try function using reduced image
display(flip_image(reduced_M))
3、垂直翻轉
def rotate_image (image, n):
# rotate image using rot90, use n to determine number of rotation
rotated_img = Image.fromarray(np.rot90(image, k=n, axes=(1, 0)))
return rotated_img
#rotate image twice (n=2)
display(rotate_image(reduced_M, 2))
4、裁剪圖像
def crop_image(image, crop_ratio, zoom_ratio):
#create focused part using crop_ratio and zoom_ratio of choice
top = image.shape[0] // crop_ratio
bottom = zoom_ratio * image.shape[0] // crop_ratio
left = image.shape[1] // crop_ratio
right = zoom_ratio * image.shape[1] // crop_ratio
# Extract the focused part using array slicing
focused_part = image[top:bottom, left:right]
return focused_part
display(crop_image(reduced_M, 4, 2))
5、RGB通道
def RGB_image(image,image_color):
if image_color == 'R':
#make a copy of image for the color channel
img_R = image.copy()
#set other color channel to zero. Here Red is the first channel [0]
img_R[:, :, (1, 2)] = 0
return img_R
elif image_color == 'G':
img_G = image.copy()
#set other color channel to zero. Here Green is the second channel [1]
img_G[:, :, (0, 2)] = 0
return img_G
elif image_color == 'B':
img_B = image.copy()
#set other color channel to zero. Here Blue is the third channel [2]
img_B[:, :, (0, 1)] = 0
return img_B查看紅色通道
M_red = Image.fromarray(RGB_image(reduced_M, 'R'))
display(M_red)
綠色
M_green = Image.fromarray(RGB_image(reduced_M, 'G'))
display(M_green)
藍色
M_blue = Image.fromarray(RGB_image(reduced_M, 'B'))
display(M_blue)
6、應用濾鏡
這里使用棕褐色(Sepia)作為示例，可以根據不同的要求修改轉換矩陣
def apply_sepia(image):
# Sepia transformation matrix
sepia_matrix = np.array([[0.393, 0.769, 0.189],
[0.349, 0.686, 0.168],
[0.272, 0.534, 0.131]])
# Apply the sepia transformation
sepia_img = image.dot(sepia_matrix.T) # Using matrix multiplication
# Ensure values are within valid range [0, 255]
sepia_img = np.clip(sepia_img, 0, 255)
return sepia_img.astype(np.uint8)
# Apply sepia effect
M_sepia = Image.fromarray(apply_sepia(reduced_M))
display(M_sepia)
7、灰度化
灰度化可以簡單的理解為將RBG三個通道合并成一個黑白的通道
import numpy as np
def grayscale(image):
# Convert the RGB image to grayscale using weighted average
grayscale_img = np.dot(image[..., :3], [0.2989, 0.5870, 0.1140])
# Ensure values are within valid range [0, 255]
grayscale_img = np.clip(grayscale_img, 0, 255)
# Convert to uint8 data type
grayscale_img = grayscale_img.astype(np.uint8)
return grayscale_img
# Convert the image to grayscale
M_gray = grayscale(reduced_M)
display(M_gray)
8、像素化
像素是一個一個色塊組成的，像素化顧名思義就是將圖像分成一定的區域，并將這些區域轉換成相應的色塊，再有色塊構成圖形。類似于色彩構圖。簡單來說,就是把矢量圖形轉換成像素點組成的點陣圖形，也叫柵格化。
def pixelate_image(image, block_size):
# Determine the number of blocks in each dimension
num_blocks_y = image.shape[0] // block_size
num_blocks_x = image.shape[1] // block_size
# Calculate the average color for each block
block_means = np.zeros((num_blocks_y, num_blocks_x, 3), dtype=np.uint8)
for y in range(num_blocks_y):
for x in range(num_blocks_x):
block = image[y * block_size: (y + 1) * block_size,
x * block_size: (x + 1) * block_size]
block_mean = np.mean(block, axis=(0, 1))
block_means[y, x] = block_mean.astype(np.uint8)
# Upsample block means to original image size
pixelated_image = np.repeat(np.repeat(block_means, block_size, axis=0), block_size, axis=1)
return pixelated_image
# Set the block size for pixelation (adjust as needed)
block_size = 10
# Pixelate the image
M_pixelated = Image.fromarray(pixelate_image(reduced_M, block_size))
display(M_pixelated)
更通俗的的講就是我的世界風格的圖像
9、二值化（Binarize）
二值化是將數值型特征取值閾值化轉換為布爾型特征取值，或者通俗的講就是設定一個閾值，超過閾值設置成ture，否則設置成false
def binarize_image(image, threshold):
#set pixel value greater than threshold to 255
binarize_image = ((image > threshold) * 255).astype(np.uint8)
return binarize_image
#set threshold
threshold = 68
M_binarized = Image.fromarray(binarize_image(reduced_M, threshold))
display(M_binarized)
10、圖像融合
最簡單的圖像同和方法就是根據不同的透明度，對2張圖象的像素求和相加，如下所示
#import and resize second image
img_2 = np.array(Image.open('Eiffel.jpg').resize(reduced_M.shape[1::-1]))
def blend_image(image1, image2, , visibility_2 ):
#blend images by multiplying by visibility ratio for each image
blend_image = (image1 * visibility_1 + image2 * visibility_2).astype(np.uint8)
return blend_image
modified_image = Image.fromarray(blend_image(reduced_M, img_2, 0.7, 0.3))
display(modified_image)
總結
對于圖像的操作其實就是對于圖像進行數組操作的過程，我們這里展示的一些簡單的操作只是為了熟悉Numpy的操作，如果需要更加專業的操作請使用更加專業的庫，例如OpenCV或者Pillow。
責任編輯：華軒
來源：
DeepHub IMBA
