計算機視覺 ： 影像形態學處理方法，包括影像的直方圖均衡化和傅里葉變換，以及影像梯度與邊緣檢測

熟悉一些影像形態學處理方法

使用軟體：pycharm，主要涉及到的操作包括開運算、閉運算、梯度運算、禮帽與黑帽運算等操作，

具體運行結果截圖如下，

貓貓探頭！

小狗餅干->餅干變質orz

影像的直方圖與均衡化操作

練習涉及到的方法主要是calcHist(images.channels,mask,histSize,ranges)
其中涉及到的引數和含義見下：

• images:原影像影像格式為unit8或float32，當傳入函式應用中括號將其框住，比如[img]
• channels:同樣需要用中括號將其框住，如果輸入的影像是灰度影像，其值為[0]，如果是彩色影像，傳入的引數可以是[0][1][2]分別對應BGR通道
• mask:掩模影像，要是對全部的影像進行操作的話就設定成None就行了，但是要是對影像中的某一部分進行操作的話就需要制作一個掩模影像在對其進行操作
• histSize:BIN的數目，也用中括號把它框住
• ranges:像素值，范圍一般在0 ~ 255之間，就是[0] ~ [255]

具體練習結果截圖見下，

滴！貓貓灰度影像直方圖：

滴，彩色影像RGB統計，這張好像是狗狗的嗯：

滴！直方圖均衡化對比：

滴！影像均衡化和自適應均衡化對比：

傅里葉變換

傅里葉變換，是將一個時域非周期的連續信號，轉換為一個在頻域非周期的連續信號，

這里介紹一下高頻和低頻的區別，簡單來講高頻就類似于變化劇烈的灰度分量，例如邊界；低頻的話就是變化緩慢的灰度分量，例如一片大海，

傅里葉變換中常見的包含倆種濾波器：

• 低通濾波器：只保留低頻，會使得影像模糊
• 高通濾波器：只保留高頻，會使得影像細節增強

具體練習結果截圖如下，

影像梯度與邊緣檢測

練習涉及到的方法主要是Sobel(src,ddepth,dx,dy,ksize)，其中ddepth表示影像的深度，dx和dy分別表示水平和豎直方向，ksize是Sobel算子的大小，練習時分別對影像進行了水平方向和豎直方向的檢測，改變算子大小對影像進行對比，還比較了不同算子之間的差異，

具體練習結果截圖如下，

滴！改變算子大小的影像對比：

滴！不同算子之間的差異對比：

另外，針對canny算子進行了更深入的學習，

1. 使用高斯濾波器，以平滑影像，濾波噪聲，
2. 計算影像中每個像素點的梯度強度和方向
3. 應用非極大值(Non-Maximum Suppression)抑制
4. 應用雙閾值(Double-Threshold)檢測來確定真實的和潛在的邊緣
5. 通過抑制孤立的弱邊緣最終完成邊緣檢測

具體練習結果截圖如下，

滴！邊緣檢測canny算子不同引數對比：

練習代碼（全）

imgPreprocessing4.py

# -*- coding: utf-8 -*-
# @TIME     : 2020/10/12 11:43
# @Author   : Chen Shan
# @Email    : jacobon@foxmail.com
# @File     : imgPreprocessing4.py
# @Software : PyCharm

import cv2  #opencv 讀取進來為BGR格式
import matplotlib.pyplot as plt
import numpy as np

# 定義圖片顯式的方法
def cv_show(name,img):
    cv2.imshow(name,img)
    cv2.waitKey(0)
    cv2.destroyAllWindows()

img = cv2.imread('bluecat.jpg',0)

kernel = np.ones((3,3),np.uint8)

erosion = cv2.erode(img,kernel,iterations = 2)
dilation = cv2.dilate(img,kernel,iterations =1)
res = np.hstack((img,erosion))
res2 = np.hstack((img,dilation))

# cv_show('erosion',res)
# cv_show('dilation',res2)

mydog = cv2.imread('dog.jpg')
# cv_show('mydog',mydog)

kernel = np.ones((5,5),np.uint8)

erode_1 = cv2.erode(mydog,kernel,iterations = 1)
erode_2 = cv2.erode(mydog,kernel,iterations = 2)
erode_3 = cv2.erode(mydog,kernel,iterations = 3)
res3 = np.hstack((erode_1,erode_2,erode_3))
# cv_show('erode',res3)

dilate_1 = cv2.dilate(mydog,kernel,iterations = 1)
dilate_2 = cv2.dilate(mydog,kernel,iterations = 2)
dilate_3 = cv2.dilate(mydog,kernel,iterations = 3)
res4 = np.hstack((dilate_1,dilate_2,dilate_3))
# cv_show('dilate',res4)

# 開運算
opening = cv2.morphologyEx(mydog,cv2.MORPH_OPEN,kernel)
res5 = np.hstack((mydog,opening))
# cv_show('opening',res5)

# 閉運算
closing = cv2.morphologyEx(mydog,cv2.MORPH_CLOSE,kernel)
res6 = np.hstack((mydog,closing))
# cv_show('closing',res6)

# 梯度運算
dilated = cv2.dilate(img,kernel, iterations =1)
erosion = cv2.erode(img,kernel, iterations =1)
res7 = np.hstack((dilated, erosion, dilated-erosion))
# cv_show('Gradient', res7)

gradient = cv2.morphologyEx(img,cv2.MORPH_GRADIENT,kernel)
# cv_show('gradient',gradient)

# 禮帽與黑帽
tophat = cv2.morphologyEx(img, cv2.MORPH_TOPHAT, kernel)
res8 = np.hstack((img, tophat))
# cv_show('tophat', res8)

blackhat = cv2.morphologyEx(img, cv2.MORPH_BLACKHAT, kernel)
res9 = np.hstack((img, blackhat))
# cv_show('blackhat', res9)

# 直方圖
gcat = cv2.imread('bluecat.jpg',cv2.IMREAD_GRAYSCALE)

hist = cv2.calcHist([gcat],[0],None,[256],[0,256])
# print(hist.shape)

hist = hist.flatten()
# print(hist.shape)

#print(np.arange(256))
#x = np.array([x for x in range(256)]);
#x = np.arange(256).reshape(256,1)
#x = np.transpose(x)
#print(x.shape)
#plt.plot(hist)

# plt.bar(np.arange(256),hist)

# plt.subplot(2,1,1),plt.imshow(gcat,'gray')
# plt.subplot(2,1,2),plt.hist(gcat.ravel(),256,[0,256]);

cat =  cv2.imread('bluecat.jpg')
color = ('b','g','r')
# for i,col in enumerate(color):
#     histr = cv2.calcHist([cat],[i],None,[256],[0,256])
#     plt.plot(histr,color = col)
#     plt.xlim([0,256])

# mask操作
# mask = np.zeros(img.shape[:2], np.uint8)
#
# mask[100:300, 100:400] = 255
# masked_img = cv2.bitwise_and(img,img,mask = mask)
#
# # 計算掩碼區域和非掩碼區域的直方圖
# # 檢查作為掩碼的第三個引數
# hist_full = cv2.calcHist([img],[0],None,[256],[0,256])
# hist_mask = cv2.calcHist([img],[0],mask,[256],[0,256])
# plt.subplot(221), plt.imshow(img, 'gray')
# plt.subplot(222), plt.imshow(mask,'gray')
# plt.subplot(223), plt.imshow(masked_img, 'gray')
# plt.subplot(224), plt.plot(hist_full), plt.plot(hist_mask)
# plt.xlim([0,256])

# 直方圖均衡化
# plt.hist(img.ravel(),256)
equ = cv2.equalizeHist(img)
# plt.hist(equ.ravel(),256)

# plt.show()

#均衡化對比
res10 = np.hstack((img,equ))
# cv_show('res',res10)

# 加上自適應均衡化的對比圖
clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8,8))
cl1 = clahe.apply(img)
res11 = np.hstack((img,equ,cl1))
# cv_show('res11',res11)

imgPreprocessing5.py

# -*- coding: utf-8 -*-
# @TIME     : 2020/10/12 15:49
# @Author   : Chen Shan
# @Email    : jacobon@foxmail.com
# @File     : imgPreprocessing5.py
# @Software : PyCharm
import cv2
import numpy as np
from matplotlib import pyplot as plt

def cv_show(name,img):
    cv2.imshow(name,img)
    cv2.waitKey(0)
    cv2.destroyAllWindows()


img = cv2.imread('bluecat.jpg',0)

img_float32 = np.float32(img)
dft = cv2.dft(img_float32,flags = cv2.DFT_COMPLEX_OUTPUT)

dft_shift = np.fft.fftshift(dft)
# 得到灰度圖能表示的形式
magnitude_spectrum = 20*np.log(cv2.magnitude(dft_shift[:,:,0],dft_shift[:,:,1]))

plt.subplot(121),plt.imshow(img, cmap = 'gray')
plt.title('Input Image'), plt.xticks([]), plt.yticks([])
plt.subplot(122),plt.imshow(magnitude_spectrum, cmap = 'gray')
plt.title('Magnitude Spectrum'), plt.xticks([]), plt.yticks([])
# plt.show()

rows, cols = img.shape
crow, ccol = np.int32(rows/2) , np.int32(cols/2)

# 首先創建一個掩碼，中心正方形為1，其余全為零(低通濾波器)
mask = np.zeros((rows,cols,2),np.uint8)
mask[crow-30:crow+30, ccol-30:ccol+30] = 0

# 應用掩碼和逆DFT
fshift = dft_shift*mask
f_ishift = np.fft.ifftshift(fshift)

img_back = cv2.idft(f_ishift)
img_back = cv2.magnitude(img_back[:,:,0],img_back[:,:,1])

plt.subplot(121),plt.imshow(img, cmap = 'gray')
plt.title('Input Image'), plt.xticks([]), plt.yticks([])
plt.subplot(122),plt.imshow(img_back, cmap = 'gray')
plt.title('Magnitude Spectrum'), plt.xticks([]), plt.yticks([])
# plt.show()

# 影像梯度與邊緣檢測
cat = cv2.imread('bluecat.jpg',cv2.IMREAD_GRAYSCALE)
sobelx = cv2.Sobel(cat,cv2.CV_64F,1,0,ksize=3)
sobely= cv2.Sobel(img,cv2.CV_64F,0,1,ksize=3)

# plt.imshow(sobelx,cmap = 'gray')
# plt.imshow(sobely,cmap = 'gray')
# plt.show()

sobelx = cv2.convertScaleAbs(sobelx)
sobely = cv2.convertScaleAbs(sobely)
sobelxy = cv2.addWeighted(sobelx,0.5,sobely,0.5,0)
# cv_show('sobelxy',sobelxy)

sobelxy = cv2.Sobel(img,cv2.CV_64F,1,1,ksize=3)
sobelxy = cv2.convertScaleAbs(sobelxy)
# cv_show('sobelxy2',sobelxy)

# 不同算子的差異
sobelx = cv2.Sobel(img,cv2.CV_64F,1,0,ksize=3)
sobelx = cv2.convertScaleAbs(sobelx)
sobely = cv2.Sobel(img,cv2.CV_64F,0,1,ksize=3)
sobely = cv2.convertScaleAbs(sobely)
sobelxy = cv2.addWeighted(sobelx,0.5,sobely,0.5,0)

scharrx = cv2.Scharr(img,cv2.CV_64F,1,0)
scharry = cv2.Scharr(img,cv2.CV_64F,0,1)
scharrx = cv2.convertScaleAbs(scharrx)
scharry = cv2.convertScaleAbs(scharry)
scharrxy = cv2.addWeighted(scharrx,0.5,scharry,0.5,0)

laplacian  = cv2.Laplacian(img, cv2.CV_64F)
laplacian = cv2.convertScaleAbs(laplacian)

res = np.hstack((sobelxy, scharrxy, laplacian))
# cv_show('res',res)

# canny算子
v1 = cv2.Canny(img, 80, 150)
v2 = cv2.Canny(img, 50, 100)
res2 = np.hstack((v1,v2))
cv_show('res',res2)

嗶嗶賴賴

抗拒寫作業，不太好，但總歸不是熱愛的，

這是任務，完成即可
這是本分，做到就行

下次一定，886，ycz老師說下周可能會有一個小的案例了，不知道會不會短暫的改變我的看法，或者說加劇我的逆反心理，越發討厭了（擔心，但會盡量克制住）