目录
上一篇： OpenCv_01——图像的基本操作
下一篇： OpenCv_03——图像特征
2. 图像处理
测试图像自取区
boss.jpg car.jpg card1 card2 cat.jpg dog.jpg girl.jpg girl1.jpg girl1_.jpg huo1.jpg img1.jpg maliao.jpg maliao_coin.jpg
2.1 图像阙值
#导包
import cv2
import matplotlib.pyplot as plt
#读取图片
img_cat=cv2.imread('cat.jpg')
ret,thresh1=cv2.threshold(img_cat,127,255,cv2.THRESH_BINARY)
ret,thresh2=cv2.threshold(img_cat,127,255,cv2.THRESH_BINARY_INV)
ret,thresh3=cv2.threshold(img_cat,127,255,cv2.THRESH_TRUNC)
ret,thresh4=cv2.threshold(img_cat,127,255,cv2.THRESH_TOZERO)
ret,thresh5=cv2.threshold(img_cat,127,255,cv2.THRESH_TOZERO_INV)
titles=['Original Image','BINARY','BINARY_INV','TRUNC','TOZERO','TOZERO_INV']
images=[img_cat,thresh1,thresh2,thresh3,thresh4,thresh5]
for i in range(6):
plt.subplot(2,3,i+1),plt.imshow(images[i],'gray')
plt.title(titles[i])
plt.xticks([]),plt.yticks([])
plt.show()
2.2 图像平滑
#导包
import cv2
import matplotlib.pyplot as plt
#读数据
img=cv2.imread('cat.jpg')
#输出图片
cv2.imshow('img',img)
cv2.waitKey(0)
cv2.destroyAllWindows()
#均值滤波
#简单的平均卷积操作
blur=cv2.blur(img,(3,3))
cv2.imshow('blur',blur)
cv2.waitKey(0)
cv2.destroyAllWindows()
#方框滤波
#基本和均值一样，可以选择归一化
box=cv2.boxFilter(img,-1,(3,3),normalize=True)
cv2.imshow('box',box)
cv2.waitKey(0)
cv2.destroyAllWindows()
#方框滤波
#基本和均值一样，可以选择归一化,容易越界
box=cv2.boxFilter(img,-1,(3,3),normalize=True)
cv2.imshow('box',box)
cv2.waitKey(0)
cv2.destroyAllWindows()
#高斯滤波
#高斯模糊的卷积核里的数值是满足高斯分布，相当于更重视中间的
aussian=cv2.GaussianBlur(img,(1,1),1)
cv2.imshow('aussian',aussian)
cv2.waitKey(0)
cv2.destroyAllWindows()
#中值滤波
#相当于用中值代替
median=cv2.medianBlur(img,5)
cv2.imshow('median',median)
cv2.waitKey(0)
cv2.destroyAllWindows()
import numpy as np
#展示所有的
res=np.hstack((blur,aussian,median))
print(res)
cv2.imshow('median vc average',res)
cv2.waitKey(0)
cv2.destroyAllWindows()
[[[122 147 191]
[121 146 190]
[120 145 189]
...
[114 138 184]
[114 138 184]
[115 139 185]]
[[121 146 190]
[121 146 190]
[119 144 188]
...
[113 137 183]
[114 138 184]
[114 138 184]]
[[120 145 189]
[119 144 188]
[118 143 187]
...
[112 136 182]
[113 137 183]
[114 138 184]]
...
[[178 201 233]
[178 201 233]
[178 201 233]
...
[191 211 240]
[192 212 242]
[193 213 243]]
[[180 203 235]
[180 203 235]
[180 203 235]
...
[192 211 242]
[192 212 242]
[193 213 243]]
[[181 204 236]
[181 204 236]
[181 204 236]
...
[192 212 243]
[192 212 243]
[193 213 243]]]
2.3 形态学操作
2.3.1 腐蚀操作
import cv2
import numpy as np
import matplotlib.pyplot as plt
img=cv2.imread('huo1.jpg')
cv2.imshow('huo',img)
cv2.waitKey(0)
cv2.destroyAllWindows()
#腐蚀操作
kernel=np.ones((3,3),np.uint8)
erosion=cv2.erode(img,kernel,iterations=1)
cv2.imshow('erosion',erosion)
cv2.waitKey(0)
cv2.destroyAllWindows()
#膨胀操作
kernel=np.ones((3,3),np.uint8)
dilate=cv2.dilate(img,kernel,iterations=1)
cv2.imshow('dilate',dilate)
cv2.waitKey(0)
cv2.destroyAllWindows()
2.3.2 开运算与闭运算
import cv2
import numpy as np
#开运算：先腐蚀，再膨胀
img=cv2.imread('huo1.jpg')
kerne1=np.ones((5,5),np.uint8)
opening=cv2.morphologyEx(img,cv2.MORPH_OPEN,kerne1)
cv2.imshow('opening',opening)
cv2.waitKey(0)
cv2.destroyAllWindows()
#闭运算：先膨胀，再腐蚀
img=cv2.imread('huo1.jpg')
kerne1=np.ones((5,5),np.uint8)
closing=cv2.morphologyEx(img,cv2.MORPH_CLOSE,kerne1)
cv2.imshow('closing',closing)
cv2.waitKey(0)
cv2.destroyAllWindows()
2.3.3 梯度运算
import cv2
import numpy as np
import matplotlib.pyplot as plt
#分别输出膨胀与腐蚀的图片
pie=cv2.imread('yuan.jpg')
kernel=np.ones((7,7),np.uint8)
dilate=cv2.dilate(pie,kernel,iterations=5)
erosion=cv2.erode(pie,kernel,iterations=5)
res=np.hstack((dilate,erosion))
cv2.imshow('res',res)
cv2.waitKey(0)
cv2.destroyAllWindows()
#梯度=膨胀-腐蚀
#梯度运算，输出边界图
gradient=cv2.morphologyEx(pie,cv2.MORPH_GRADIENT,kernel)
cv2.imshow('gradient',gradient)
cv2.waitKey(0)
cv2.destroyAllWindows()
2.3.4 礼帽与黑帽
import cv2
import numpy as np
import matplotlib.pyplot as plt
#礼帽=原始数据-开运算结果
img=cv2.imread('huo1.jpg')
kernel=np.ones((7,7),np.uint8)
tohat=cv2.morphologyEx(img,cv2.MORPH_TOPHAT,kernel)
cv2.imshow('tohat',tohat)
cv2.waitKey(0)
cv2.destroyAllWindows()
#黑帽
img=cv2.imread('huo1.jpg')
kernel=np.ones((7,7),np.uint8)
blackhat=cv2.morphologyEx(img,cv2.MORPH_BLACKHAT,kernel)
cv2.imshow('blackhat',blackhat)
cv2.waitKey(0)
cv2.destroyAllWindows()
2.4 图像梯度
2.4.1 Sobel算子
import cv2
import numpy as np
import matplotlib.pyplot as plt
img=cv2.imread('yuan.jpg',cv2.IMREAD_GRAYSCALE)
cv2.imshow('img',img)
cv2.waitKey(0)
cv2.destroyAllWindows()
def cv_show(name,img):
cv2.imshow(name,img)
cv2.waitKey(0)
cv2.destroyAllWindows()
sobelx=cv2.Sobel(img,cv2.CV_64F,1,0,ksize=3)
#白到黑是整数，黑到白就是负数了，所有的负数会被截断成0，所以要取绝对值
cv_show('sobelx',sobelx)
sobelx=cv2.Sobel(img,cv2.CV_64F,1,0,ksize=3)
sobelx=cv2.convertScaleAbs(sobelx)
cv_show('sobelx',sobelx)
sobely=cv2.Sobel(img,cv2.CV_64F,0,1,ksize=3)
sobely=cv2.convertScaleAbs(sobely)
cv_show('sobely',sobely)
#同时输出，比较
res=np.hstack((sobelx,sobely))
cv_show('res',res)
#分别计算x和y，再求和
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('sobelxy',sobelxy)
#读取图片，用Sobel算子进行边缘输出
img=cv2.imread('boss.jpg',cv2.IMREAD_GRAYSCALE)
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)
#效果图与原图的灰度图合并输出
res=np.hstack((img,sobelxy))
cv_show('res',res)
sobelxy=cv2.Sobel(img,cv2.CV_64F,1,1,ksize=3)
sobelxy=cv2.convertScaleAbs(sobelxy)
cv_show('sobelxy',sobelxy)
2.4.2 Scharr算子与Lapkacian算子
Scharr算子
Lapkacian算子
import cv2
import numpy as np
import matplotlib.pyplot as plt
def cv_show(name,img):
cv2.imshow(name,img)
cv2.waitKey(0)
cv2.destroyAllWindows()
#比较
img=cv2.imread('boss.jpg',cv2.IMREAD_GRAYSCALE)
#Sobel算子
sobelx=cv2.Sobel(img,cv2.CV_64F,1,0,ksize=3)
sobely=cv2.Sobel(img,cv2.CV_64F,0,1,ksize=3)
sobelx=cv2.convertScaleAbs(sobelx)
sobely=cv2.convertScaleAbs(sobely)
sobelxy=cv2.addWeighted(sobelx,0.5,sobely,0.5,0)
#Scharr算子
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算子
laplacian=cv2.Laplacian(img,cv2.CV_64F)
laplacian=cv2.convertScaleAbs(laplacian)
#输出比较
res=np.hstack((sobelxy,scharrxy,laplacian))
cv_show('res',res)
2.5 边缘检测
Canny边缘检测
- 使用高斯滤波器，以平滑图像，滤除噪声。
- 计算图像中每个像素点的梯度强度和方向。
- 应用非极大值（Non-Maximum Suppression）抑制，以消除边缘检测带来的杂散响应。
- 应用双赋值（Double-Threshold）检测来确定真实和潜在的边缘。
- 通过抑制独立的弱边缘最终完成边缘检测。
高斯滤波器
梯度和方向
非极大值抑制
双阙值检测
import cv2
import numpy as np
import matplotlib.pyplot as plt
def cv_show(name,img):
cv2.imshow(name,img)
cv2.waitKey(0)
cv2.destroyAllWindows()
img=cv2.imread('cat.jpg',cv2.IMREAD_GRAYSCALE)
#进行边缘检测
#minvalue和maxvalue的值由自己设置
v1=cv2.Canny(img,20,60)
v2=cv2.Canny(img,50,100)
res=np.hstack((v1,v2))
cv_show('res',res)
2.6 图像金字塔
向下采样法（缩小）
向上采样法（放大）
- 将图像在每个方向扩大为原来的两倍，新增的行和列用0填充
- 使用先前同样的内核（乘以四）与放大后的图像卷积，获得近似值
普拉斯金字塔
对输入图像实现金字塔的reduce操作就会生成不同分辨率的图像、对这些图像进行金字塔expand操作，然后使用reduce减去expand之后的结果就会得到图像拉普拉斯金字塔图像。
输入图像G(0)
金字塔reduce操作生成 G(1), G(2), G(3)
拉普拉斯金字塔：
L0 = G(0)-expand(G(1))
L1 = G(1)-expand(G(2))
L2 = G(2)–expand(G(3))
G(0)减去expand(G(1))得到的结果就是两次高斯模糊输出的不同，所以L0称为DOG（高斯不同）、它约等于LOG所以又称为拉普拉斯金字塔。所以要求的图像的拉普拉斯金字塔，首先要进行金字塔的reduce操作，然后在通过expand操作，最后相减得到拉普拉斯金字塔图像。
拉普拉斯金字塔生成过程
import cv2
import numpy as np
import matplotlib.pyplot as plt
def cv_show(name,img):
cv2.imshow(name,img)
cv2.waitKey(0)
cv2.destroyAllWindows()
img=cv2.imread('girl.jpg')
cv_show('img',img)
print(img.shape)
#向上采样法
up=cv2.pyrUp(img)
cv_show('up',up)
print(up.shape)
#(1392, 1200, 3)
#向下采样法
down=cv2.pyrDown(img)
cv_show('down',down)
print(down.shape)
#(348, 300, 3)
#拉普拉斯金字塔
down=cv2.pyrDown(img)
down_up=cv2.pyrUp(down)
result=img-down_up
cv_show('result',result)
2.7 轮廓检测
2.7.1 图像轮廓
cv2.findContours(img,mode,method)
mode:轮廓检索模式
| 参数 | 说明 |
|---|---|
| RETR_EXTERNAL | 只检索最外面的轮廓 |
| RETR_LIST | 检索所有的轮廓，并将其保存到一条链表中 |
| RETR_CCOMP | 检索所有的轮廓，并将它们组织为两层；顶层是各部分的外部链接，第二层是空洞的边界 |
| RETR_TREE | 检索所有的轮廓，并重构嵌套轮廓的层次 |
medthod：轮廓逼近方法
| 参数 | 说明 |
|---|---|
| CHAIN_APPROX_NONE | 以Freem链码的方式输出轮廓，所有其他方法输出多边形（顶点的轮廓） |
| CHAIN_APPROX_SIMPLE | 压缩水平的、垂直的和斜的部分，也就是，函数只保留它们的终点部分 |
为了更高的准确率，使用二值图像
import cv2
import numpy as np
import matplotlib.pyplot as plt
def cv_show(name,img):
cv2.imshow(name,img)
cv2.waitKey(0)
cv2.destroyAllWindows()
#为了更高的准确率，使用二值图像
img=cv2.imread('car.jpg')
gray=cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
ret,thresh=cv2.threshold(gray,127,255,cv2.THRESH_BINARY)
cv_show('thresh',thresh)
binary,contours,hierarchy=cv2.findContours(thresh,cv2.RETR_TREE,cv2.CHAIN_APPROX_NONE)
cv_show('binary',binary)
2.7.2 绘制轮廓
cv2.drawContours(image, contours, contourIdx, color, thickness=None, lineType=None, hierarchy=None, maxLevel=None, offset=None)
| 参数 | 说明 |
|---|---|
| 第一个参数 | 指明在哪幅图像上绘制轮廓；image为三通道才能显示轮廓 |
| 第二个参数 | 是轮廓本身，在Python中是一个list; |
thickness参数指定绘制轮廓list中的哪条轮廓，如果是-1，则绘制其中的所有轮廓。其中thickness表明轮廓线的宽度，如果是-1（cv2.FILLED），则为填充模式。
#引入绘制图像，轮廓，轮廓索引，颜色模式，线条厚度
#需要注意copy，要不原图会变
res=img.copy()
res=cv2.drawContours(res,contours,-1,(0,0,255),2)
cv_show('res',res)
#轮廓特征
cnt=contours[0]
#面积
cv2.contourArea(cnt)
#0.0
#周长，True表示闭合的
cv2.arcLength(cnt,True)
#0.0
2.7.3 轮廓近似
cv2.approxPolyDP(InputArray curve, OutputArray approxCurve, double epsilon, bool closed)
| 参数 | 说明 |
|---|---|
| InputArray curve | 输入的点集 |
| OutputArray approxCurve | 输出的点集，当前点集是能最小包容指定点集的。画出来即是一个多边形 |
| double epsilon | 指定的精度，也即是原始曲线与近似曲线之间的最大距离 |
| bool closed | 若为true,则说明近似曲线是闭合的，反之，若为false，则断开 |
img=cv2.imread('img1.jpg')
gray=cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
ret,thresh=cv2.threshold(gray,127,255,cv2.THRESH_BINARY)
binary,contours,hierarchy=cv2.findContours(thresh,cv2.RETR_TREE,cv2.CHAIN_APPROX_NONE)
cnt=contours[0]
draw_img=img.copy()
res=cv2.drawContours(draw_img,[cnt],-1,(0,0,255),2)
cv_show('res',res)
espsilon=0.05*cv2.arcLength(cnt,True)
approx=cv2.approxPolyDP(cnt,espsilon,True)
draw_img=img.copy()
res=cv2.drawContours(draw_img,[approx],-1,(0,0,255),2)
cv_show('res',res)
2.7.4 边界矩形
cv2.rectangle(img, (x,y), (x+w,y+h), (0,255,0), 2)
-
第一个参数：img是原图
-
第二个参数：（x，y）是矩阵的左上点坐标
-
第三个参数：（x+w，y+h）是矩阵的右下点坐标
-
第四个参数：（0,255,0）是画线对应的rgb颜色
-
第五个参数：2是所画的线的宽度
img=cv2.imread('img1.jpg')
gray=cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
ret,thresh=cv2.threshold(gray,127,255,cv2.THRESH_BINARY)
binary,contours,hierarchy=cv2.findContours(thresh,cv2.RETR_TREE,cv2.CHAIN_APPROX_NONE)
cnt=contours[0]
x,y,w,h=cv2.boundingRect(cnt)
img=cv2.rectangle(img,(x,y),(x+w,y+h),(0,255,0),2)
cv_show('img',img)
#轮廓面积与边界矩形比
area=cv2.contourArea(cnt)
x,y,w,h=cv2.boundingRect(cnt)
rect_area=w*h
extent=float(area)/rect_area
print("轮廓面积与边界矩形比",extent)
#轮廓面积与边界矩形比 0.7065451180472189
2.7.5 外接圆
center, radius = cv.minEnclosingCircle( points )
| 参数 | 描述 |
|---|---|
| center | 返回值，圆的中心 |
| radius | 返回值，半径 |
| points | 目标物体的点 |
(x,y),radius=cv2.minEnclosingCircle(cnt)
center=(int(x),int(y))
radius=int(radius)
img=cv2.circle(img,center,radius,(0,2555,0),2)
cv_show('img',img)
2.8 模板匹配
模板匹配和卷积原理很像，模板在原图像上从原点开始滑动，计算模板与（图像被模板覆盖的地方）的差别程度，这个差别程度的计算方法在opencv中有6种，然后将每次计算的结果放入一个矩阵里，作为结果输出。假如原图形是A乘B大小，而模板是a乘b大小，则结果输出的矩阵是（A-a+1）×（B-b+1）
import cv2
import numpy as np
import matplotlib.pyplot as plt
def cv_show(name,img):
cv2.imshow(name,img)
cv2.waitKey(0)
cv2.destroyAllWindows()
#模板匹配
img=cv2.imread('girl1.jpg',0)
template=cv2.imread('girl1_.jpg',0)
h,w=template.shape[:2]
h
#901
w
#629
img.shape
#(2340, 1080)
template.shape
#(901, 629)
methods=['cv2.TM_CCOEFF','cv2.TM_CCOEFF_NORMED','cv2.TM_CCORR',
'cv2.TM_CCORR_NORMED','cv2.TM_SQDIFF','cv2.TM_SQDIFF_NORMED']
| 方法 | 说明 |
|---|---|
| TM_CCOEFF | 计算相关系数，计算出来的值越大，越相关。 |
| TM_CCOEFF_NORMED | 计算归一化相关系数，计算出来的值越接近1，越相关。 |
| TM_CCORR | 计算相关性，计算出来的值越打，越相关。 |
| TM_CCORR_NORMED | 计算归一化相关性，计算出来的值越接近1，越相关。 |
| TM_SQDIFF | 计算平方不同，计算出来的值越小，越相关。 |
| TM_SQDIFF_NORMED | 计算归一化平方不同，计算出来的值越接近0，越相关。 |
res=cv2.matchTemplate(img,template,cv2.TM_SQDIFF)
res.shape
#(1440, 452)
cv2.minMaxLoc(src, mask=None)
函数功能：假设有一个矩阵a,现在需要求这个矩阵的最小值，最大值，并得到最大值，最小值的索引。
咋一看感觉很复杂，但使用这个cv2.minMaxLoc()函数就可全部解决。函数返回的四个值就是上述所要得到的
min_val,max_val,min_loc,max_loc=cv2.minMaxLoc(res)
min_val
#190976.0
max_val
#8067120640.0
min_loc
#(256, 422)
max_loc
#(451, 0)
eval是Python的一个内置函数，功能十分强大，这个函数的作用是，返回传入字符串的表达式的结果。
就是说：将字符串当成有效的表达式 来求值 并 返回计算结果。
cv2.rectangle(img, pt1, pt2, color, thickness, lineType, shift )
for meth in methods:
img2=img.copy()
#匹配方法的真值
method=eval(meth)
print(method)
res=cv2.matchTemplate(img,template,method)
min_val,max_val,min_loc,max_loc=cv2.minMaxLoc(res)
#如果是平方差匹配到TM_SQDIFF或归一化平方差匹配到TM_SQDIFF_NORMED,取最小值
if method in [cv2.TM_SQDIFF,cv2.TM_SQDIFF_NORMED]:
top_left=min_loc
else:
top_left=max_loc
bottom_right=(top_left[0]+w,top_left[1]+h)
#画矩形
cv2.rectangle(img2,top_left,bottom_right,255,20)
plt.subplot(121),plt.imshow(res,cmap='gray')
plt.xticks([]),plt.yticks([])#隐藏坐标轴
plt.subplot(122),plt.imshow(img2,cmap='gray')
plt.xticks([]),plt.yticks([])
plt.suptitle(meth)
plt.show()
#匹配多个对象
img_rgb=cv2.imread('maliao.jpg')
img_gray=cv2.cvtColor(img_rgb,cv2.COLOR_BGR2GRAY)
template=cv2.imread('maliao_coin.jpg',0)
h,w=template.shape[:2]
res=cv2.matchTemplate(img_gray,template,cv2.TM_CCOEFF_NORMED)
#取匹配度大于80%的坐标
threshold=0.8
loc=np.where(res>=threshold)
for pt in zip(*loc[::-1]):#*表示可选参数
bottom_right=(pt[0]+w,pt[1]+h)
cv2.rectangle(img_rgb,pt,bottom_right,(0,0,255),2)
cv2.imshow('img_rgb',img_rgb)
cv2.waitKey(0)
2.9 直方图
2.9.1 直方图定义
cv2.calcHist(images,channels,mask,histSize,ranges)
| 参数 | 说明 |
|---|---|
| images | 原图像图像格式为uint8或float32.当传入函数时应用中括号[]括，例如[img]。 |
| channels | 同样用中括号来括它会告知函数我们统幅图像的直方图。如果入图像是灰度图它的值就是[0],如果是彩色图像的传入的参数可以是[0][1][2],它们分别对应着BGR。 |
| mask | 掩膜图像。统整幅图像的直方图就把它为None。如果你想同图像某一分的直方图的，你就制作一个掩膜图像并使用它。 |
| histSize | BIN的数目。也应用种括号来括。 |
| ranges | 像素值的范围为[0,256]。 |
import cv2
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
#使用%matplotlib命令可以将matplotlib的图表直接嵌入到Notebook之中
def cv_show(name,img):
cv2.imshow(name,img)
cv2.waitKey(0)
cv2.destroyAllWindows()
img=cv2.imread('girl1.jpg',0)#0表示灰度图
hist=cv2.calcHist([img],[0],None,[256],[0,256])
hist.shape
#(256, 1)
#ravel()将多维数据展平为一维数据
plt.hist(img.ravel(),256)
plt.show()
img=cv2.imread('girl1.jpg')
color=('b','g','r')
for i,col in enumerate(color):
histr=cv2.calcHist([img],[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
cv_show('mask',mask)
img=cv2.imread('cat.jpg',0)
plt.hist(img.ravel(),256)
plt.show()
#均衡化函数
equ=cv2.equalizeHist(img)
plt.hist(equ.ravel(),256)
plt.show()
#均衡化之后的图像
res=np.hstack((img,equ))
cv_show('res',res)
2.9.3 直方图均衡化
cv2.createCLAHE(clipLimit,tileGridSize)
| 参数 | 说明 |
|---|---|
| clipLimit | 裁剪限制，此值与对比度受限相对应，对比度限制这个参数是用每块的直方图的每个bins的数和整图的平均灰度分布数的比值来限制的。 裁剪则是将每块图像直方图中超过ClipLimit的bins多出的灰度像素数去除超出部分，然后将所有bins超出的像素数累加后平均分配到所有bins。 |
| tileGridSize | 图像被分成称为“tiles”（瓷砖、地砖、小方地毯、片状材料、块状材料）的小块，在OpenCV中，tilesGridSize默认为8x8 ，即整个图像被划分为8纵8横共64块。然后对每一个块进行直方图均衡处理。 |
cat=cv2.createCLAHE(clipLimit=2.0,tileGridSize=(8,8))
res_cat=cat.apply(img)
res=np.hstack((img,equ,res_cat))
cv_show('res',res)
2.10 傅里叶
2.10.1 傅里叶概述
傅里叶变换
我们生活在时间的世界中，早上7:00起来吃早饭，8:00去挤地铁，9:00开始上班，，，以时间为参照就是时域分析。
但是我们在频域中一切都是静止的。
傅里叶变换的作用
- 高频：变化剧烈的灰度分量，例如边界。
- 低频：变化缓慢的灰度分量，例如一片大海。
滤波
-
低通滤波器：只保留低频，会使图像模糊。
-
高通滤波器：只保留高频，会使图像细节增强。
-
opencv中主要是以cv2.dft()和cv2.idft(),输入图像需要先转换成np.float32格式。
-
得到的结果中频率为0的部分会在左上角，通常要转换到中心位置，可以通过shift变换来实现。
-
cv2.dft()返回的结果是双通道的（实部，虚部），通常还需要转换成图像格式才可能展示（0，255）
2.10.2 代码实现
import cv2
import numpy as np
import matplotlib.pyplot as plt
cv2.dft(原始图像，转换标识)
这里的原始图像必须是np.float32格式。所以，我们首先需要使用cv2.float32()函数将图像转换。
而转换标识的值通常为cv2.DFT_COMPLEX_OUTPUT，用来输出一个复数阵列。
cv2.magnitude(参数1，参数2)
参数1：浮点型x坐标值，也就是实部
参数2：浮点型y坐标值，也就是虚部，它必须和参数1具有相同的大小（size）
得到频谱图像的幅度之后，还需要将幅度映射到灰度空间[0,255]内，使其以灰度图像显示出来。与前篇博文一样，使用20*np.log(cv2.magnitude())。
img=cv2.imread('dog.jpg',0)
img_float32=np.float32(img)
dft=cv2.dft(img_float32,flags=cv2.DFT_COMPLEX_OUTPUT)
dft_shift=np.fft.fftshift(dft)
#得到灰度图能表示的形式
magnitude_sepctrum=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_sepctrum,cmap='gray')
plt.title('Magnitude Spectrum'),plt.xticks([]),plt.yticks([])
plt.show()
img=cv2.imread('dog.jpg',0)
img_float32=np.float32(img)
dft=cv2.dft(img_float32,flags=cv2.DFT_COMPLEX_OUTPUT)
dft_shift=np.fft.fftshift(dft)
rows,cols=img.shape
crow,ccol=int(rows/2),int(cols/2) #中心位置
#低通滤波
mask=np.zeros((rows,cols,2),np.uint8)
mask[crow-30:crow+30,ccol-30:ccol+30]=1
#IDFT
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('Result'),plt.xticks([]),plt.yticks([])
plt.show()
6万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
