[PYTHON] 100 image processing knocks !! (011 --020) Early game
1.First of all
Practice this to improve the technical capabilities of image preprocessing 100 knocks for image processing !! I will do it with Colaboratory so that it is easy to get started. We will work to complete the goal in two weeks. I will explain it carefully. Please ask a question! 001 --010 is from the link on the right 100 image processing knocks !! (001 --010) Carefully and carefully
2. Preparation
Introduced libraries etc. as follows.
python
#Import library
from google.colab import drive
import numpy as np
import matplotlib.pyplot as plt
import cv2
from google.colab.patches import cv2_imshow
#Loading images
img = cv2.imread('Image path/imori.jpg')
img_noise = cv2.imread('Image path/imori_noise.jpg')
#For image storage
OUT_DIR = 'Output destination path/OUTPUT/'
3. Explanation
Q.11. Smoothing filter
Implement a smoothing filter (3x3). The smoothing filter is a filter that outputs the average value of the pixels in the filter.
A11
"""
Smoothing filter
cv2.filter2D(src, -1, kernel)
src input image
kernel filter kernel(* Give as a NumPy array)
"""
#Filter kernel
kernel = np.ones((3,3),np.float32)/9
#Smoothing filter
img11 = cv2.filter2D(img, -1, kernel)
#Save the result
cv2.imwrite(OUT_DIR + 'ans11.jpg', img11)
#Display image
cv2_imshow(img11)
cv2.waitKey(0)
cv2.destroyAllWindows()
Reference: [Python / OpenCV] Smoothing / contour detection by spatial filtering Reference: Aiming to be a beginner
Q.12. Motion filter
Implement a motion filter (3x3).
A12
def motion_filter(img, k_size=3):
"""
Motion filter(A filter that takes a diagonal mean)
parameters
-------------------------
param1: numpy.ndarray format image
param2:Kernel size
returns
-------------------------
(130x130)Numpy.ndarray format image
"""
#Get image height, width and color
H, W, C = img.shape
#kernel(numpy.diag()Extract diagonal components with)
K = np.diag([1] * k_size).astype(np.float) # array([[1., 0., 0.],[0., 1., 0.],[0., 0., 1.]])
K /= k_size # array([[0.33333333, 0., 0.],[0., 0.33333333, 0.],[0., 0., 0.33333333]])
#Zero padding
pad = k_size // 2
out = np.zeros((H + pad * 2, W + pad * 2, C), dtype=np.float) #out.shape >>> (130, 130, 3)
out[pad:pad+H, pad:pad+W] = img.copy().astype(np.float)
tmp = out.copy()
#filtering
for y in range(H):
for x in range(W):
for c in range(C):
out[pad + y, pad + x, c] = np.sum(K * tmp[y:y+k_size, x:x+k_size, c])
out = out[pad: pad + H, pad: pad + W].astype(np.uint8)
return out
#Motion filter
img12 = motion_filter(img, k_size=3)
#Save the result
cv2.imwrite(OUT_DIR + 'ans12.jpg', img12)
#Display image
cv2_imshow(img12)
cv2.waitKey(0)
cv2.destroyAllWindows()
Q.13. MAX-MIN filter
Implement the MAX-MIN filter (3x3). The MAX-MIN filter is a filter that outputs the difference between the maximum value and the minimum value of the pixels in the filter, and is one of the edge detection filters. Edge detection is to detect lines in an image, and such an operation of extracting information in an image is called feature extraction. Edge detection often filters grayscale images.
A13
def max_min_filter(img, k_size=3):
"""
Max-Min filter(A filter that takes a diagonal mean)
Since it is a grayscale process, it is divided into cases for color images and cases.
parameters
-------------------------
param1: numpy.ndarray format image
param2:Kernel size
returns
-------------------------
(130x130)Numpy.ndarray format image
"""
#When the input image is color
if len(img.shape) == 3:
# H(height), W(width), C(color)
H, W, C = img.shape
#Zero padding
pad = k_size // 2
out = np.zeros((H + pad * 2, W + pad * 2, C), dtype=np.float) #out.shape >>> (130, 130, 3)
out[pad:pad+H, pad:pad+W] = img.copy().astype(np.float)
tmp = out.copy()
#filtering
for y in range(H):
for x in range(W):
for c in range(C):
#Subtract the minimum from the maximum in the 3x3 kernel
out[pad + y, pad + x, c] = np.max(tmp[y:y+k_size, x:x+k_size, c]) - np.min(tmp[y:y+k_size, x:x+k_size, c])
out = out[pad: pad + H, pad: pad + W].astype(np.uint8)
#When the input image is grayscale
else:
H, W = img.shape
#Zero padding
pad = k_size // 2
out = np.zeros((H + pad * 2, W + pad * 2), dtype=np.float)
out[pad:pad+H, pad:pad+W] = img.copy().astype(np.float)
tmp = out.copy()
#filtering
for y in range(H):
for x in range(W):
#Subtract the minimum from the maximum in the 3x3 kernel
out[pad + y, pad + x] = np.max(tmp[y:y+k_size, x:x+k_size]) - np.min(tmp[y:y+k_size, x:x+k_size])
out = out[pad: pad + H, pad: pad + W].astype(np.uint8)
return out
# Max-Min filter
img13 = max_min_filter(img, k_size=3)
#Save the result
cv2.imwrite(OUT_DIR + 'ans13.jpg', img13)
#Display image
cv2_imshow(img13)
cv2.waitKey(0)
cv2.destroyAllWindows()
Reference: Murakami Laboratory Image Processing-Image Processing / Understanding Laboratory
Q.14. Derivative filter
Implement a differential filter (3x3). The differential filter is a filter that extracts the edge of the portion where the sudden change in brightness occurs, and takes the difference between adjacent pixels. It is the part where the brightness changes drastically that becomes an edge in the image. The color of the red part hardly changes, but the color of the blue frame changes drastically. This change becomes the edge.
A14
"""
cv2.Sobel(src, ddepth, dx, dy[, dst[, ksize[, scale[, delta[, borderType]]]]])
src:Input image
ddepth:Output color depth
dx:Derivative order in the x direction
dy:Derivative order in the y direction
ksize:Kernel size, 1, 3, 5,Specify any of 7
"""
#Lateral direction
dx = cv2.Sobel(gray, cv2.CV_64F, 1, 0, ksize=3)
#Longitudinal direction
dy = cv2.Sobel(gray, cv2.CV_64F, 0, 1, ksize=3)
#Save the result
cv2.imwrite(OUT_DIR + 'ans14_v.jpg', dy)
cv2.imwrite(OUT_DIR + 'ans14_h.jpg', dx)
#Display image
cv2_imshow(dy)
cv2_imshow(dx)
cv2.waitKey(0)
cv2.destroyAllWindows()
Impression that the white part is clearer than the image of the model answer
Reference: Edge extraction with python + OpenCV (Sobel filter, Laplacian filter)
Q.15. Prewitt filter
Implement the Prewitt filter (3x3). The Prewitt filter is a type of edge extraction filter and is defined by the following equation. This is an extension of the differential filter to 3x3.
A15
"""
Prewitt(Previt)Is one of the spatial filters that extracts contours from an image
cv2.filter2D(src, -1, kernel)
src input image
cv2.CV_64F float64
kernel filter kernel(* Give as a NumPy array)
"""
#Kernel (for horizontal and vertical contour detection)
kernel_x = np.array([[1, 0, -1],
[1, 0, -1],
[1, 0, -1]])
kernel_y = np.array([[1, 1, 1],
[0, 0, 0],
[-1, -1, -1]])
dx = cv2.filter2D(gray, cv2.CV_64F, kernel_x)
dy = cv2.filter2D(gray, cv2.CV_64F, kernel_y)
#Save the result
cv2.imwrite(OUT_DIR + 'ans15_v.jpg', dy)
cv2.imwrite(OUT_DIR + 'ans15_h.jpg', dx)
#Display image
cv2_imshow(dy)
cv2_imshow(dx)
cv2.waitKey(0)
cv2.destroyAllWindows()
Reference: First-order differential filter Prewitt filter --edge extraction of image Reference: [Python / OpenCV] Contour detection with Prewitt filter
Q.16. Sobel filter
Implement the Sobel filter (3x3). The Sobel filter is also a filter that extracts edges, and is defined by the following equation. This is a filter with a weight in the center of the prewitt filter.
A16
"""
The Sobel filter also emphasizes edges with little difference in brightness.
cv2.filter2D(src, -1, kernel)
src input image
cv2.CV_64F float64
kernel filter kernel(* Give as a NumPy array)
"""
#Kernel (for horizontal and vertical contour detection)
kernel_x = np.array([[1, 0, -1],
[2, 0, -2],
[1, 0, -1]])
kernel_y = np.array([[1, 2, 1],
[0, 0, 0],
[-1, -2, -1]])
dx = cv2.filter2D(gray, cv2.CV_64F, kernel_x)
dy = cv2.filter2D(gray, cv2.CV_64F, kernel_y)
#Save the result
cv2.imwrite(OUT_DIR + 'ans16_v.jpg', dy)
cv2.imwrite(OUT_DIR + 'ans16_h.jpg', dx)
#Display image
cv2_imshow(dy)
cv2_imshow(dx)
cv2.waitKey(0)
cv2.destroyAllWindows()
Reference: 1st derivative filter Sobel filter --edge extraction of image Reference: [Python / OpenCV] Contour detection with Prewitt filter
Q.17. Laplacian filter
Implement the Laplacian filter. The Laplacian filter is a filter that detects edges by taking the second derivative of brightness. Since digital images are discrete data, the first derivative in the x and y directions is expressed by the following equations, respectively. (Same as differential filter)
A17
"""
Laplacian filter(Laplacian Filter)Is a spatial filter that uses quadratic differentiation to extract contours from an image
cv2.filter2D(src, -1, kernel)
src input image
cv2.CV_64F float64
kernel filter kernel(* Give as a NumPy array)
"""
#kernel
kernel = np.array([[0, 1, 0],
[1, -4, 1],
[0, 1, 0]])
#Laplacian filter
img17 = cv2.filter2D(gray, cv2.CV_64F, kernel)
#Save the result
cv2.imwrite(OUT_DIR + 'ans17.jpg', img17)
#Display image
cv2_imshow(img17)
cv2.waitKey(0)
cv2.destroyAllWindows()
Reference: [Python / OpenCV] Contour detection with Laplacian filter (edge extraction)
Q.18. Emboss filter
Implement the Emboss filter. The Emboss filter is a filter that makes the outline part stand out, and is defined by the following equation.
A18
"""
Embossed filter(Emboss Filter)Is a spatial fill that highlights the contours
cv2.filter2D(src, -1, kernel)
src input image
cv2.CV_64F float64
kernel filter kernel(* Give as a NumPy array)
"""
#kernel
kernel = np.array([[-2, -1, 0],
[-1, 1, 1],
[0, 1, 2]])
#Laplacian filter
img18 = cv2.filter2D(gray, cv2.CV_64F, kernel)
#Save the result
cv2.imwrite(OUT_DIR + 'ans18.jpg', img18)
#Display image
cv2_imshow(img18)
cv2.waitKey(0)
cv2.destroyAllWindows()
Reference: [Python / OpenCV] Process with emboss filter
Q.19. LoG filter
Implement a LoG filter (sigma = 3, kernel size = 5) and detect the edges of imori_noise.jpg. The LoG filter is the Laplacian of Gaussian, which is a filter that smoothes an image with a Gaussian filter and then extracts contours with a Laplacian filter. Since the Laplcian filter takes the second derivative, the noise is suppressed by the Gaussian filter in advance in order to prevent the noise from being emphasized. The LoG filter is defined by the following equation.
A19
"""
LoG filter(Laplacian Of Gaussian Filter)Is a filter that combines a Gaussian filter and a Laplacian filter.
After smoothing the image with a Gaussian filter to reduce noise, the Laplacian filter extracts the contour.
Gaussian filter
cv2.GaussianBlur(src, ksize, sigmaX)
src:Input image, ksize:Kernel size, sigmaX:Gaussian distribution sigma_x
Laplacian filter
cv2.filter2D(src, -1, kernel)
src input image
cv2.CV_64F float64
kernel filter kernel(* Give as a NumPy array)
"""
#Gaussian filter
gauss_img = cv2.GaussianBlur(gray_noise, ksize=(3, 3), sigmaX=1.3)
#kernel
kernel = np.array([[0, 0, 1, 0, 0],
[0, 1, 2, 1, 0],
[1, 2, -16, 2, 1],
[0, 1, 2, 1, 0],
[0, 0, 1, 0, 0]])
#Laplacian filter
img19 = cv2.filter2D(gauss_img, cv2.CV_64F, kernel)
#Save the result
cv2.imwrite(OUT_DIR + 'ans19.jpg', img19)
#Display image
cv2_imshow(img19)
cv2.waitKey(0)
cv2.destroyAllWindows()
An image different from the answer. But when I use a Laplacian filter, I feel like this. Please let me know if you make a mistake.
Reference: [Image processing] LoG filter principle / features / calculation formula
Q.20. Histogram display
Use matplotlib to display the histogram of imori_dark.jpg. The histogram is a graph of the number of appearances of pixels. Since matplotlib already has a function called hist (), use it.
A
#histogram
"""
matplotlib.pyplot.hist(x, bins=10, range=None, normed=False, weights=None,
cumulative=False, bottom=None, histtype='bar',
align='mid', orientation='vertical', rwidth=None,
log=False, color=None, label=None, stacked=False,
hold=None, data=None, **kwargs)
x (Mandatory)An array of raw data for creating a histogram.
bins bins(Bar to display)Number of. Number of classes.(Default value: 10)
Specify the minimum and maximum values for the range bin.(Default value: (x.min(), x.max()))
rwidth Specify the width of each bar as a numerical value or an array.
"""
# ravel:Multidimensional list to one-dimensional list,Number of bins:255,Range 0~255
plt.hist(img_dark.ravel(), bins=255, rwidth=0.8, range=(0, 255))
plt.savefig("out.png ")
plt.show()
Reference: Data science in Python
Impressions
In the official version, numpy is used and it is done according to the principle, but OpenCV is used as much as possible to make it easy to implement.
Recommended Posts