100 image processing knocks !! (001 --010) Carefully and carefully
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!
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.1. Channel replacement
Load the image and swap RGB in BGR order. To extract the red component of the image, you can use the following code. Note that in the cv2.imread () function, the channels are in BGR order! This will put only the red component of imori.jpg in the variable red.
A1
#OpenCV function cvtColor()Convert BGR and RGB with
img1 = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
#Save the result
cv2.imwrite(OUT_DIR + 'ans1_a.jpg', img1)
#Display image
cv2_imshow(img1)
cv2.waitKey(0)
cv2.destroyAllWindows()
Reference: cvtColor that converts BGR and RGB with Python, OpenCV
Q.2. Grayscale
Make the image grayscale. Grayscale is a kind of image brightness expression method and is calculated by the following formula. Y = 0.2126 R + 0.7152 G + 0.0722 B
A2
#OpenCV function cv2.cvtColor(), cv2.COLOR_Convert with BGR2GRAY
img2 = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
#Save the result
cv2.imwrite(OUT_DIR + 'ans2_.jpg', img2)
#Display image
cv2_imshow(img2)
cv2.waitKey(0)
cv2.destroyAllWindows()
Reference: Convert color image to black and white (grayscale) with Python, OpenCV, NumPy
Q.3. Binarization
Binarize the image. Binarization is a method of expressing an image as a binary of black and white. Here, the threshold value is set to 128 in gray scale, and binarization is performed by the following equation.
A3
#image(grayscale)copy of
img3 = img2.copy()
#Threshold setting
threshold = 128
#Binarization(The number of pixels that exceed the threshold value of 128 is set to 255.)
ret, img3 = cv2.threshold(img3, threshold, 255, cv2.THRESH_BINARY)
#Save the result
cv2.imwrite(OUT_DIR + 'ans3_.jpg', img3)
#Display image
cv2_imshow(img3)
cv2.waitKey(0)
cv2.destroyAllWindows()
Reference: Binarization of OpenCV images Reference: Image threshold processing
Q.4. Binarization of Otsu
Implement Otsu's binarization. Otsu's binarization is called a discriminant analysis method, which is a method of automatically determining the separation threshold in binarization. This is calculated from the ratio of intraclass variance to interclass variance.
A4
#Implemented with OpenCV
#image(grayscale)copy of
gray = img2.copy()
#Binarization process of Otsu
ret, image4 = cv2.threshold(gray, 0, 255, cv2.THRESH_OTSU)
#Save the result
cv2.imwrite(OUT_DIR + 'ans4.jpg', img4)
#Display image
cv2_imshow(img4)
cv2.waitKey(0)
cv2.destroyAllWindows()
Reference: [Python / OpenCV] Binarization processing by Otsu's method
Q.5. HSV conversion
Implement HSV conversion to invert hue H. HSV transformation is a method of expressing colors with Hue (hue), Saturation (saturation), and Value (brightness). Hue ... Hue is expressed from 0 to 360 degrees, and indicates the type of color such as red or blue. (0 <= H <360) Hue corresponds to the following colors. Red Yellow Green Light Blue Blue Purple Red 0 60 120 180 240 300 360 Saturation ... Color vividness. When the saturation is low, the gray color becomes noticeable and the color becomes dull. (0 <= S <1) Value ... Color brightness. The higher the Value, the closer to white, and the lower the Value, the closer to black. (0 <= V <1)
A5
#Copy the image
img5 = img.copy()
# RGB ->Convert to HSV
hsv = cv2.cvtColor(img5, cv2.COLOR_BGR2HSV)
#Add 180 to Hue
hsv[..., 0] = (hsv[..., 0] + 180) % 360
# HSV ->Convert to RGB
img5 = cv2.cvtColor(hsv, cv2.COLOR_HSV2RGB)
#Save the result
cv2.imwrite(OUT_DIR + 'ans5.jpg', img5)
#Display image
cv2_imshow(img5)
cv2.waitKey(0)
cv2.destroyAllWindows()
For some reason, it is slightly different from the answer image. Please let me know if you make a mistake
Reference: [Python / OpenCV] Convert from RGB to HSV (cv2.cvtColor)](https://algorithm.joho.info/programming/python/opencv-rgb-to-hsv-color-space/)
Q.6. Color reduction processing
Here, reduce the value of the image from 256 ^ 3 to 4 ^ 3, that is, R, G, B in {32, 96, 160, 224}. This is a quantization operation. Each value is defined as follows.
A6
def decrease_color(img):
"""
R,G,Set B to 256 and set a value to 4.
[0, 64), [64, 128), [128, 192), (192, 256)Divide into 4 equal parts *[]: Closed section(Above and below), (): Open section(Big or small)
[0, 64)->32, [64, 128)->96, [128, 192)->160, (192, 256) ->Each range conversion to 2224
parameters
-------------------------
param: numpy.ndarray format image
returns
-------------------------
numpy.ndarray format Convert as shown on the right[132 80 67] >>> [160 96 96]
"""
#Copy image
out = img.copy()
print(out)
# 256/4 =Because it is 64, it is divided by 64+32 by doing 32, 96, 160,Convert to 224
out = out // 64 * 64 + 32
return out
img6 = img.copy()
img6 = decrease_color(img6)
#Save the result
cv2.imwrite(OUT_DIR + 'ans6.jpg', img6)
#Display image
cv2_imshow(img6)
cv2.waitKey(0)
cv2.destroyAllWindows()
Reference: Somehow blog
Q.7. Average pooling
Here, the image is divided into grids (divided into certain fixed-length areas), and the values in the area are filled with the average value in the area (cell). The operation of dividing the grid in this way and finding the representative value in that area is called Pooling. These pooling operations play an important role in CNN (Convolutional Neural Network).
A7
def average_pooling(img, G=8):
"""
Average pooling
parameters
-------------------------
param1: numpy.ndarray format image
param2:Grid division into 8x8
returns
-------------------------
Average pooled numpy.ndarray format image
"""
#Copy image
out = img.copy()
# H(Image height), W(Image width), C(color)Get
H, W, C = img.shape
#Grid division
Nh = int(H / G)
Nw = int(W / G)
#Average pooling for each 8-divided range
for y in range(Nh):
for x in range(Nw):
for c in range(C):
out[G*y:G*(y+1), G*x:G*(x+1), c] = np.mean(out[G*y:G*(y+1), G*x:G*(x+1), c]).astype(np.int)
return out
#Average pooling
img7 = average_pooling(img)
#Save the result
cv2.imwrite(OUT_DIR + 'ans7.jpg', img7)
#Display image
cv2_imshow(img7)
cv2.waitKey(0)
cv2.destroyAllWindows()
Q.8. Max pooling
Here, pool with the maximum value instead of the average value.
A8
def max_pooling(img, G=8):
"""
Maximum pooling
parameters
-------------------------
param1: numpy.ndarray format image
param2:Grid division into 8x8
returns
-------------------------
Maximum pooled numpy.ndarray format image
"""
#Copy image
out = img.copy()
# H(Image height), W(Image width), C(color)Get
H, W, C = img.shape
#Grid division
Nh = int(H / G)
Nw = int(W / G)
#Average pooling for each 8-divided range
for y in range(Nh):
for x in range(Nw):
for c in range(C):
out[G*y:G*(y+1), G*x:G*(x+1), c] = np.max(out[G*y:G*(y+1), G*x:G*(x+1), c]).astype(np.int)
return out
#Maximum pooling
img8 = average_pooling(img)
#Save the result
cv2.imwrite(OUT_DIR + 'ans8.jpg', img8)
#Display image
cv2_imshow(img8)
cv2.waitKey(0)
cv2.destroyAllWindows()
Q.9. Gaussian filter
Implement a Gaussian filter (3x3, standard deviation 1.3) to remove the noise in imori_noise.jpg. A Gaussian filter is a type of filter that smoothes an image and is also used for noise removal. Other noise removal methods include a median filter (Q.10), a smoothing filter (Q.11), and a LoG filter (Q.19). The Gaussian filter smoothes the peripheral pixels of the pixel of interest by weighting with a Gaussian distribution, and is defined by the following equation. Such weights are called kernels and filters. However, since the edges of the image cannot be filtered as they are, the part with insufficient pixels is filled with 0. This is called 0 padding. And the weights are normalized. (sum g = 1)
A9
#Processed with OpenCV
# cv2.GaussianBlur(src, ksize, sigmaX)
# src:Input image, ksize:Kernel size, sigmaX:Gaussian distribution sigma_x
img9 = cv2.GaussianBlur(img_noise, ksize=(3, 3), sigmaX=1.3)
#Save the result
cv2.imwrite(OUT_DIR + 'ans9.jpg', img9)
#Display image
cv2_imshow(img9)
cv2.waitKey(0)
cv2.destroyAllWindows()
Reference: [Python / OpenCV] Blur / Smooth with Gaussian Filter
Q.10 Median filter
Implement a median filter (3x3) to remove the noise in imori_noise.jpg. A median filter is a type of filter that smoothes an image. This is a filter that outputs the median value (median value) in the 3x3 area of the pixel of interest. This is also zero padding.
A10
#Processed with OpenCV
"""
cv2.medianBlur(src, ksize)
src input image
Kernel size of kernel filter (near 8 if 3)
"""
#Median filter
img10 = cv2.medianBlur(img_noise, ksize=3)
#Save the result
cv2.imwrite(OUT_DIR + 'ans10.jpg', img10)
#Display image
cv2_imshow(img10)
cv2.waitKey(0)
cv2.destroyAllWindows()
Reference: [Python / OpenCV] Blur / Smooth / Noise Removal with Median Filter
Impressions
Preprocessing is important in machine learning. If you don't know the method, you won't come up with any ideas, so it's well worth the effort. Knock format makes it easy to work on
Recommended Posts