(一)OpenCV-Python学习—基础知识

说真话不该被屏蔽 發表於 2019-6-11 22:09:00

opencv是一个强大的图像处理和计算机视觉库，实现了很多实用算法，值得学习和深究下。方便大家阅读，整理了下文章链接合集：
(一)OpenCV-Python学习—基础知识
(二)OpenCV-Python学习—对比度增强
(三)OpenCV-Python学习—图像平滑
(四)OpenCV-Python学习—形态学处理
(五)OpenCV-Python学习—边缘检测1
(六)OpenCV-Python学习—边缘检测2
(七)OpenCV-Python学习—几何形状拟合
(八)OpenCV-Python学习—轮廓查找，绘制和拟合
(九)OpenCV-Python学习—图像傅里叶变换
(十)OpenCV-Python学习—频率域滤波
1.opencv包安装
·　　这里直接安装opencv-python包（非官方）： pip install opencv-python
　　官方文档：https://opencv-python-tutroals.readthedocs.io/en/latest/
2. opencv简单图像处理
　　2.1 图像像素存储形式
　　　　首先得了解下图像在计算机中存储形式：(为了方便画图，每列像素值都写一样了)
　　　　对于只有黑白颜色的灰度图，为单通道，一个像素块对应矩阵中一个数字，数值为0到255, 其中0表示最暗（黑色），255表示最亮（白色）
　　　　<img src="https://img2018.cnblogs.com/blog/1483773/201905/1483773-20190526153832514-1217750130.png">
 
　　　　对于采用RGB模式的彩色图片，为三通道图，Red、Green、Blue三原色，按不同比例相加，一个像素块对应矩阵中的一个向量, 如，分别表示三种颜色的比列, 即对应深度上的数字，如下图所示：
　　　　<img src="https://img2018.cnblogs.com/blog/1483773/201905/1483773-20190526153914949-1975709262.png">
　　　　需要注意的是，由于历史遗留问题，opencv采用BGR模式，而不是RGB
　　2.2 图像读取和写入
　　　　cv2.imread()
<div class="cnblogs_code">
<pre>imread(img_path,flag) 读取图片，返回图片对象
img_path: 图片的路径，即使路径错误也不会报错，但打印返回的图片对象为None
flag：cv2.IMREAD_COLOR，读取彩色图片，图片透明性会被忽略，为默认参数，也可以传入1
 cv2.IMREAD_GRAYSCALE,按灰度模式读取图像，也可以传入0
 cv2.IMREAD_UNCHANGED,读取图像，包括其alpha通道，也可以传入-1</pre>
</div>
　　　　cv2.imshow()
<div class="cnblogs_code">
<pre>imshow(window_name,img)：显示图片，窗口自适应图片大小
window_name: 指定窗口的名字
img：显示的图片对象
可以指定多个窗口名称，显示多个图片

waitKey(millseconds)键盘绑定事件，阻塞监听键盘按键，返回一个数字（不同按键对应的数字不同）
millseconds: 传入时间毫秒数，在该时间内等待键盘事件；传入0时，会一直等待键盘事件

destroyAllWindows(window_name)
window_name: 需要关闭的窗口名字，不传入时关闭所有窗口</pre>
</div>
　　　　cv2.imwrite()
<div class="cnblogs_code">
<pre>imwrite(img_path_name,img)
img_path_name:保存的文件名
img：文件对象</pre>
</div>
　　使用示例：
<div class="cnblogs_code"><img src="http://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif"><img alt="" id="code_img_opened_8dad4e6b-ea42-457f-9aca-c9ec245a7362" class="code_img_opened lazyload" style="display: none" data-src="http://images.cnblogs.com/OutliningIndicators/ExpandedBlockStart.gif">
<div id="cnblogs_code_open_8dad4e6b-ea42-457f-9aca-c9ec245a7362" class="cnblogs_code_hide">
<pre>#coding:utf-8

import cv2
img = cv2.imread(r"C:\Users\Administrator\Desktop\roi.jpg")
# print(img.shape)
img_gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
ret,img_threshold = cv2.threshold(img_gray,127,255,cv2.THRESH_BINARY)
cv2.imshow("img",img)
cv2.imshow("thre",img_threshold)

key = cv2.waitKey(0)
if key==27: #按esc键时，关闭所有窗口
print(key)
cv2.destroyAllWindows()
cv2.imwrite(r"C:\Users\Administrator\Desktop\thre.jpg",img_threshold)</pre>
</div>
View Code</div>
　　2.3 图像像素获取和编辑
　　　　像素值获取：
<div class="cnblogs_code">
<pre>img = cv2.imread(r"C:\Users\Administrator\Desktop\roi.jpg")

#获取和设置
pixel = img[100,100]#[57 63 68],获取(100,100)处的像素值
img[100,100]=[57,63,99] #设置像素值
b = img[100,100,0] #57, 获取(100,100)处，blue通道像素值
g = img[100,100,1] #63
r = img[100,100,2] #68
r = img[100,100,2]=99 #设置red通道值

#获取和设置
piexl = img.item(100,100,2)
img.itemset((100,100,2),99)</pre>
</div>
　　　　图片性质
<div class="cnblogs_code">
<pre>import cv2
img = cv2.imread(r"C:\Users\Administrator\Desktop\roi.jpg")

#rows,cols,channels
img.shape #返回(280, 450, 3), 宽280(rows)，长450(cols)，3通道(channels)
#size
img.size #返回378000，所有像素数量，=280*450*3
#type
img.dtype #dtype('uint8')</pre>
</div>
　　　ROI截取（Range of Interest）
<div class="cnblogs_code">
<pre>#ROI,Range of instrest
roi = img[100:200,300:400]#截取100行到200行，列为300到400列的整块区域
img[50:150,200:300] = roi #将截取的roi移动到该区域（50到100行，200到300列）
b = img[:,:,0]#截取整个蓝色通道

b,g,r = cv2.split(img) #截取三个通道，比较耗时
img = cv2.merge((b,g,r))</pre>
</div>
　　2.4 添加边界(padding)　　
<div class="cnblogs_code">
<pre>cv2.copyMakeBorder()
参数：
 img:图像对象
 top,bottom,left,right: 上下左右边界宽度，单位为像素值
 borderType:
 cv2.BORDER_CONSTANT, 带颜色的边界，需要传入另外一个颜色值
 cv2.BORDER_REFLECT, 边缘元素的镜像反射做为边界
 cv2.BORDER_REFLECT_101/cv2.BORDER_DEFAULT
 cv2.BORDER_REPLICATE, 边缘元素的复制做为边界
 CV2.BORDER_WRAP
 value: borderType为cv2.BORDER_CONSTANT时，传入的边界颜色值，如[0,255,0]</pre>
</div>
　　　　使用示例：
<div class="cnblogs_code"><img alt="" id="code_img_closed_1817ce0c-8f6c-4789-9011-7104982efcbd" class="code_img_closed lazyload" data-src="http://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif"><img alt="" id="code_img_opened_1817ce0c-8f6c-4789-9011-7104982efcbd" class="code_img_opened lazyload" style="display: none" data-src="http://images.cnblogs.com/OutliningIndicators/ExpandedBlockStart.gif">
<div id="cnblogs_code_open_1817ce0c-8f6c-4789-9011-7104982efcbd" class="cnblogs_code_hide">
<pre>#coding:utf-8

import cv2 as cv
import matplotlib.pyplot as plt

img2 = cv.imread(r"C:\Users\Administrator\Desktop\dog.jpg")
img = cv.cvtColor(img2,cv.COLOR_BGR2RGB)#matplotlib的图像为RGB格式
constant = cv.copyMakeBorder(img,20,20,20,20,cv.BORDER_CONSTANT,value=[0,255,0]) #绿色
reflect = cv.copyMakeBorder(img,20,20,20,20,cv.BORDER_REFLECT)
reflect01 = cv.copyMakeBorder(img,20,20,20,20,cv.BORDER_REFLECT_101)
replicate = cv.copyMakeBorder(img,20,20,20,20,cv.BORDER_REPLICATE)
wrap = cv.copyMakeBorder(img,20,20,20,20,cv.BORDER_WRAP)
titles = ["constant","reflect","reflect01","replicate","wrap"]
images =

for i in range(5):
plt.subplot(2,3,i+1),plt.imshow(images),plt.title(titles)
plt.xticks([]),plt.yticks([])
plt.show()

</pre>
</div>
View Code</div>
　　　　<img alt="" data-src="https://img2018.cnblogs.com/blog/1483773/201906/1483773-20190601115405976-1234855474.png">
　　2.5 像素算术运算
　　　　　　cv2.add()  相加的两个图片，应该有相同的大小和通道
<div class="cnblogs_code">
<pre>cv2.add()
参数：
 img1:图片对象1
 img2:图片对象2
 mask:None （掩膜，一般用灰度图做掩膜，img1和img2相加后，和掩膜与运算，从而达到掩盖部分区域的目的）
 dtype:-1

注意：图像相加时应该用cv2.add(img1,img2)代替img1+img2
 >>> x = np.uint8([250])
 >>> y = np.uint8([10])
 >>> print cv2.add(x,y) # 250+10 = 260 => 255#相加，opencv超过255的截取为255
 [[255]]
 >>> print x+y # 250+10 = 260 % 256 = 4#相加，np超过255的会取模运算（uint8只能表示0-255，所以取模）
 [4]</pre>
</div>
　　　　　　使用示例：图一无掩膜，图二有掩膜
<div class="cnblogs_code"><img src="http://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif"><img alt="" id="code_img_opened_54d9a4a9-6b59-4f32-a49b-50fc7b092aca" class="code_img_opened lazyload" style="display: none" data-src="http://images.cnblogs.com/OutliningIndicators/ExpandedBlockStart.gif">
<div id="cnblogs_code_open_54d9a4a9-6b59-4f32-a49b-50fc7b092aca" class="cnblogs_code_hide">
<pre>#coding:utf-8

import cv2 as cv
import numpy as np
img1 = cv.imread("C:\Users\Administrator\Desktop\cat.jpg",0)
roi_img= np.zeros(img1.shape[0:2],dtype=np.uint8)
# print(img1.shape[0:2])
roi_img[100:280,400:550]=255

img_add = cv.add(img1,img1)
img_add_mask = cv.add(img1,img1,mask=roi_img)
# cv.imshow("img1",img1)
# cv.imshow("roi_img",roi_img)
cv.imshow("img_add",img_add)
cv.imshow("img_add_mask",img_add_mask)

cv.waitKey(0)
cv.destroyAllWindows()</pre>
</div>
View Code</div>
　　　　　　<img alt="" data-src="https://img2018.cnblogs.com/blog/1483773/201906/1483773-20190601141536082-1019705943.png">
　　
　　　　　　<img src="https://img2018.cnblogs.com/blog/1483773/201906/1483773-20190601141609497-107446803.png">
　　　　　　cv.addWeight(): 两张图片相加，分别给予不同权重，实现图片融合和透明背景等效果
<div class="cnblogs_code">
<pre>cv2.addWeighted() 两张图片相加，分别给予不同权重，实现图片融合和透明背景等效果
参数：
 img1:图片对象1
 alpha:img1的权重
 img2:图片对象2
 beta:img1的权重
 gamma：常量值，图像相加后再加上常量值
 dtype：返回图像的数据类型，默认为-1，和img1一样
(img1*alpha+img2*beta+gamma)</pre>
</div>
　　　　使用示例：
<div class="cnblogs_code"><img src="http://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif"><img alt="" id="code_img_opened_cbff0068-52cb-4140-9a58-96f714e7e8f9" class="code_img_opened lazyload" style="display: none" data-src="http://images.cnblogs.com/OutliningIndicators/ExpandedBlockStart.gif">
<div id="cnblogs_code_open_cbff0068-52cb-4140-9a58-96f714e7e8f9" class="cnblogs_code_hide">
<pre>#coding:utf-8

import cv2 as cv

img1 = cv.imread(r"C:\Users\Administrator\Desktop\dog.jpg")
img = img1[0:426,43:683]
img2 = cv.imread(r"C:\Users\Administrator\Desktop\cat.jpg")

blend = cv.addWeighted(img,0.5,img2,0.9,0)#两张图的大小和通道也应该相同

cv.imshow("blend",blend)
cv.waitKey()
cv.destroyAllWindows()</pre>
</div>
View Code</div>
　　　　<img alt="" data-src="https://img2018.cnblogs.com/blog/1483773/201906/1483773-20190601143333535-439856475.png">
　　2.6 图像位运算
　　　　　btwise_and(), bitwise_or(), bitwise_not(), bitwise_xor()
<div class="cnblogs_code">
<pre>cv2.btwise_and(): 与运算
参数：
 img1:图片对象1
 img2:图片对象2
 mask:掩膜
cv2.bitwise_or()：或运算
参数：
 img1:图片对象1
 img2:图片对象2
 mask:掩膜
cv2.bitwise_not(): 非运算
 img1:图片对象1
 mask:掩膜
cv2.bitwise_xor():异或运算，相同为1，不同为0（1^1=0,1^0=1）
 img1:图片对象1
 img2:图片对象2
 mask:掩膜</pre>
</div>
　　使用示例：将logo图片移动到足球图片中，需要截取logo图片的前景和足球图片ROI的背景，然后叠加，效果如下：
<div class="cnblogs_code"><img src="http://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif"><img alt="" id="code_img_opened_ff2b6773-e214-4772-a27c-df0d62a15487" class="code_img_opened lazyload" style="display: none" data-src="http://images.cnblogs.com/OutliningIndicators/ExpandedBlockStart.gif">
<div id="cnblogs_code_open_ff2b6773-e214-4772-a27c-df0d62a15487" class="cnblogs_code_hide">
<pre>#coding:utf-8

import cv2 as cv
import matplotlib.pyplot as plt

img1 = cv.imread(r"C:\Users\Administrator\Desktop\logo.png")
rows,cols = img1.shape[0:2]
img2 = cv.imread(r"C:\Users\Administrator\Desktop\Messi.jpg")
roi = img2[0:rows,0:cols]
img1_gray = cv.cvtColor(img1,cv.COLOR_BGR2GRAY)

ret,img1_thres = cv.threshold(img1_gray,200,255,cv.THRESH_BINARY_INV)
img1_fg =cv.add(img1,img1,mask=img1_thres) #拿到logo图案的前景

img1_thres_inv = cv.bitwise_not(img1_thres)
roi_bg = cv.add(roi,roi,mask=img1_thres_inv)#拿到roi图案的背景

img_add = cv.add(img1_fg,roi_bg) #背景和前景相加
img2[0:rows,0:cols] = img_add

cv.imshow("gray",img1_gray)
cv.imshow("thres",img1_thres)
cv.imshow("fg",img1_fg)
cv.imshow("tinv",img1_thres_inv)
cv.imshow("roi_bg",roi_bg)
cv.imshow("img_add",img_add)
cv.imshow("img2",img2)
cv.waitKey(0)
cv.destroyAllWindows()</pre>
</div>
View Code</div>
<img alt="" data-src="https://img2018.cnblogs.com/blog/1483773/201906/1483773-20190601161550607-2134006672.png">
　　2.7 图像颜色空间转换
　　　　cv2.cvtColor()
<div class="cnblogs_code">
<pre>cv2.cvtColor()
参数：
 img: 图像对象
 code：
 cv2.COLOR_RGB2GRAY: RGB转换到灰度模式
 cv2.COLOR_RGB2HSV： RGB转换到HSV模式（hue,saturation,Value）
cv2.inRange()
参数：
 img: 图像对象/array
 lowerb: 低边界array，如lower_blue = np.array([110,50,50])
 upperb：高边界array，如 upper_blue = np.array([130,255,255])
mask = cv2.inRange(hsv, lower_green, upper_green)</pre>
</div>
　　2.8 性能评价　
　　　cv2.getTickCount()：获得时钟次数
　　　cv2.getTickFrequency()：获得时钟频率（每秒振动次数）
<div class="cnblogs_code">
<pre>img1 = cv2.imread('messi5.jpg')

e1 = cv2.getTickCount()
for i in xrange(5,49,2):
img1 = cv2.medianBlur(img1,i)
e2 = cv2.getTickCount()
t = (e2 - e1)/cv2.getTickFrequency()
print t</pre>
</div>
 　　2.9 绑定trackbar到图像
　　　　cv2.createTrackbar()
　　　　cv2.getTrackbarPos()
<div class="cnblogs_code">
<pre> cv2.createTrackbar() 为窗口添加trackbar
参数：
 trackbarname: trackbar的名字
 winname: 窗口的名字
 value: trackbar创建时的值
 count：trackbar能设置的最大值，最小值总为0
 onChange：trackbar值发生变化时的回调函数，trackbar的值作为参数传给onchange

cv2.getTrackbarPos() 获取某个窗口中trackbar的值
参数：
 trackbarname: trackbar的名字
 winname: 窗口的名字</pre>
</div>
　　　　使用示例：通过改变trackbar的值，来寻找最优的mask范围，从而识别出图片中蓝色的瓶盖
<div class="cnblogs_code"><img src="http://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif"><img alt="" id="code_img_opened_48530925-6cb7-4cf3-aff2-188b4837c0df" class="code_img_opened lazyload" style="display: none" data-src="http://images.cnblogs.com/OutliningIndicators/ExpandedBlockStart.gif">
<div id="cnblogs_code_open_48530925-6cb7-4cf3-aff2-188b4837c0df" class="cnblogs_code_hide">
<pre>#coding:utf-8

import cv2 as cv
import numpy as np

def nothing(args):
pass

img = cv.imread(r"C:\Users\Administrator\Desktop\frame.png")
img_hsv = cv.cvtColor(img,cv.COLOR_BGR2HSV)
cv.namedWindow('tracks')
cv.createTrackbar("LH","tracks",0,255,nothing)
cv.createTrackbar("LS","tracks",0,255,nothing)
cv.createTrackbar("LV","tracks",0,255,nothing)

cv.createTrackbar("UH","tracks",255,255,nothing)
cv.createTrackbar("US","tracks",255,255,nothing)
cv.createTrackbar("UV","tracks",255,255,nothing)

# switch = "0:OFF \n1:ON"
# cv.createTrackbar(switch,"tracks",0,1,nothing)

while(1):

l_h = cv.getTrackbarPos("LH","tracks")
l_s = cv.getTrackbarPos("LS","tracks")
l_v = cv.getTrackbarPos("LV","tracks")
u_h = cv.getTrackbarPos("UH","tracks")
u_s = cv.getTrackbarPos("US","tracks")
u_v = cv.getTrackbarPos("UV","tracks")

lower_b = np.array()
upper_b = np.array()

mask = cv.inRange(img_hsv,lower_b,upper_b)
res = cv.add(img,img,mask=mask)

cv.imshow("img",img)
cv.imshow("mask",mask)
cv.imshow("res",res)
k = cv.waitKey(1)
if k==27:
 break

# print(r,g,b)
# if s==0:
 # img[:]=0
# else:
 # img[:]=

cv.destroyAllWindows()</pre>
</div>
View Code</div>
　　　　　　<img alt="" data-src="https://img2018.cnblogs.com/blog/1483773/201906/1483773-20190601191315454-2089153172.png">
 
　　　<img src="https://img2018.cnblogs.com/blog/1483773/201906/1483773-20190601190419060-1506057737.png">
3. 图像阈值化
　　cv2.threshold()
　　cv2.adaptiveThreshold()
<div class="cnblogs_code">
<pre>cv2.threshold():
参数：
img:图像对象，必须是灰度图
thresh:阈值
maxval：最大值
type:
 cv2.THRESH_BINARY: 小于阈值的像素置为0，大于阈值的置为maxval
 cv2.THRESH_BINARY_INV：小于阈值的像素置为maxval，大于阈值的置为0
 cv2.THRESH_TRUNC： 小于阈值的像素不变，大于阈值的置为thresh
 cv2.THRESH_TOZERO 小于阈值的像素置0，大于阈值的不变
 cv2.THRESH_TOZERO_INV 小于阈值的不变，大于阈值的像素置0
返回两个值
ret:阈值
img：阈值化处理后的图像

cv2.adaptiveThreshold() 自适应阈值处理，图像不同部位采用不同的阈值进行处理
参数：
img: 图像对象，8-bit单通道图
maxValue:最大值
adaptiveMethod: 自适应方法
 cv2.ADAPTIVE_THRESH_MEAN_C ：阈值为周围像素的平均值
 cv2.ADAPTIVE_THRESH_GAUSSIAN_C : 阈值为周围像素的高斯均值（按权重）
threshType:
 cv2.THRESH_BINARY: 小于阈值的像素置为0，大于阈值的置为maxValuel
 cv2.THRESH_BINARY_INV:小于阈值的像素置为maxValue，大于阈值的置为0
blocksize: 计算阈值时，自适应的窗口大小,必须为奇数（如3：表示附近3个像素范围内的像素点，进行计算阈值）
C：常数值，通过自适应方法计算的值，减去该常数值
(mean value of the blocksize*blocksize neighborhood of (x, y) minus C)</pre>
</div>
　　使用示例：
<div class="cnblogs_code"><img src="http://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif"><img alt="" id="code_img_opened_9f7bb581-d1c1-4d9a-800c-1845659f62d5" class="code_img_opened lazyload" style="display: none" data-src="http://images.cnblogs.com/OutliningIndicators/ExpandedBlockStart.gif">
<div id="cnblogs_code_open_9f7bb581-d1c1-4d9a-800c-1845659f62d5" class="cnblogs_code_hide">
<pre>#coding:utf-8

import cv2 as cv
import matplotlib.pyplot as plt

img = cv.imread(r"C:\Users\Administrator\Desktop\maze.png",0)

ret,thre1 = cv.threshold(img,127,255,cv.THRESH_BINARY)
adaptive_thre1 = cv.adaptiveThreshold(img,255,cv.ADAPTIVE_THRESH_MEAN_C,cv.THRESH_BINARY,7,2)
adaptive_thre2 = cv.adaptiveThreshold(img,255,cv.ADAPTIVE_THRESH_GAUSSIAN_C,cv.THRESH_BINARY,7,2)

titles = ["img","thre1","adaptive_thre1","adaptive_thre2"]
imgs =

for i in range(4):
plt.subplot(2,2,i+1), plt.imshow(imgs,"gray")
plt.title(titles)
plt.xticks([]),plt.yticks([])
plt.show()</pre>
</div>
View Code</div>
　　　　<img alt="" style="display: block; margin-left: auto; margin-right: auto" data-src="https://img2018.cnblogs.com/blog/1483773/201906/1483773-20190601224018337-495239331.png">
　　奥斯二值化（Otsu's Binarization）
　　　　对于一些双峰图像，奥斯二值化能找到两峰之间的像素值作为阈值，并将其返回。适用于双峰图像的阈值化，或者通过去噪而产生的双峰图像。
　　　　官网使用示例：
<div class="cnblogs_code"><img src="http://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif"><img alt="" id="code_img_opened_01a2197b-079d-4fbf-bf7d-a0ae69de2299" class="code_img_opened lazyload" style="display: none" data-src="http://images.cnblogs.com/OutliningIndicators/ExpandedBlockStart.gif">
<div id="cnblogs_code_open_01a2197b-079d-4fbf-bf7d-a0ae69de2299" class="cnblogs_code_hide">
<pre>import cv2
import numpy as np
from matplotlib import pyplot as plt

img = cv2.imread('noisy2.png',0)

# global thresholding
ret1,th1 = cv2.threshold(img,127,255,cv2.THRESH_BINARY)

# Otsu's thresholding
ret2,th2 = cv2.threshold(img,0,255,cv2.THRESH_BINARY+cv2.THRESH_OTSU)

# Otsu's thresholding after Gaussian filtering
blur = cv2.GaussianBlur(img,(5,5),0)
ret3,th3 = cv2.threshold(blur,0,255,cv2.THRESH_BINARY+cv2.THRESH_OTSU)

# plot all the images and their histograms
images = [img, 0, th1,
 img, 0, th2,
 blur, 0, th3]
titles = ['Original Noisy Image','Histogram','Global Thresholding (v=127)',
 'Original Noisy Image','Histogram',"Otsu's Thresholding",
 'Gaussian filtered Image','Histogram',"Otsu's Thresholding"]

for i in xrange(3):
plt.subplot(3,3,i*3+1),plt.imshow(images,'gray')
plt.title(titles), plt.xticks([]), plt.yticks([])
plt.subplot(3,3,i*3+2),plt.hist(images.ravel(),256)
plt.title(titles), plt.xticks([]), plt.yticks([])
plt.subplot(3,3,i*3+3),plt.imshow(images,'gray')
plt.title(titles), plt.xticks([]), plt.yticks([])
plt.show()</pre>
</div>
View Code　　　<img alt="" style="display: block; margin-left: auto; margin-right: auto" data-src="https://img2018.cnblogs.com/blog/1483773/201906/1483773-20190601224852098-1757221396.png"></div>
 
4. 图像形状变换
　　4.1 cv2.resize()   图像缩放
<div class="cnblogs_code">
<pre>cv2.resize() 放大和缩小图像
参数：
 src: 输入图像对象
 dsize：输出矩阵/图像的大小，为0时计算方式如下：dsize = Size(round(fx*src.cols),round(fy*src.rows))
 fx: 水平轴的缩放因子，为0时计算方式：(double)dsize.width/src.cols
 fy: 垂直轴的缩放因子，为0时计算方式：(double)dsize.heigh/src.rows
 interpolation：插值算法
 cv2.INTER_NEAREST : 最近邻插值法
 cv2.INTER_LINEAR 默认值，双线性插值法
 cv2.INTER_AREA 基于局部像素的重采样（resampling using pixel area relation）。对于图像抽取（image decimation）来说，这可能是一个更好的方法。但如果是放大图像时，它和最近邻法的效果类似。
 cv2.INTER_CUBIC 基于4x4像素邻域的3次插值法
 cv2.INTER_LANCZOS4 基于8x8像素邻域的Lanczos插值

cv2.INTER_AREA 适合于图像缩小， cv2.INTER_CUBIC (slow) & cv2.INTER_LINEAR 适合于图像放大</pre>
</div>
　　　　官网示例：
<div class="cnblogs_code"><img src="http://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif"><img alt="" id="code_img_opened_a7c25570-c9d0-4617-bbdf-d755f78f9bd3" class="code_img_opened lazyload" style="display: none" data-src="http://images.cnblogs.com/OutliningIndicators/ExpandedBlockStart.gif">
<div id="cnblogs_code_open_a7c25570-c9d0-4617-bbdf-d755f78f9bd3" class="cnblogs_code_hide">
<pre>import cv2
import numpy as np

img = cv2.imread('messi5.jpg')

res = cv2.resize(img,None,fx=2, fy=2, interpolation = cv2.INTER_CUBIC)

#OR

height, width = img.shape[:2]
res = cv2.resize(img,(2*width, 2*height), interpolation = cv2.INTER_CUBIC)</pre>
</div>
图像放大两倍</div>
　　4.2 cv2.warpAffine()     仿射变换
　　　　仿射变换（从二维坐标到二维坐标之间的线性变换，且保持二维图形的“平直性”和“平行性”。仿射变换可以通过一系列的原子变换的复合来实现，包括平移，缩放，翻转，旋转和剪切）
<div class="cnblogs_code">
<pre>cv2.warpAffine() 仿射变换（从二维坐标到二维坐标之间的线性变换，且保持二维图形的“平直性”和“平行性”。仿射变换可以通过一系列的原子变换的复合来实现，包括平移，缩放，翻转，旋转和剪切）
参数：
 img: 图像对象
 M：2*3 transformation matrix (转变矩阵)
 dsize：输出矩阵的大小,注意格式为（cols，rows）即width对应cols，height对应rows
 flags：可选，插值算法标识符，有默认值INTER_LINEAR，
 如果插值算法为WARP_INVERSE_MAP, warpAffine函数使用如下矩阵进行图像转dst(x,y)=src(M11*x+M12*y+M13,M21*x+M22*y+M23)
 borderMode：可选，边界像素模式，有默认值BORDER_CONSTANT
 borderValue:可选，边界取值，有默认值Scalar()即0</pre>
</div>
　　　　　常用插值算法：
<img alt="" style="display: block; margin-left: auto; margin-right: auto" data-src="https://img2018.cnblogs.com/blog/1483773/201906/1483773-20190602091005036-227493627.png">
　　　仿射变换的本质：即一个矩阵A和向量B共同组成的转变矩阵，和原图像坐标相乘来得到新图像的坐标，从而实现图像移动，旋转等。如下矩阵A和向量B组成的转变矩阵M，用来对原图像的坐标（x,y）进行转变，得到新的坐标向量T
　　　　矩阵A和向量B
<img src="https://img2018.cnblogs.com/blog/1483773/201906/1483773-20190602092346111-65750210.png">
　　　　仿射变换（矩阵计算）：变换前坐标（x,y）
<img src="https://img2018.cnblogs.com/blog/1483773/201906/1483773-20190602092700612-1331464134.png">
　　　　变换结果：变换后坐标（a00*x+a01 *y+b00, a10*x+a11*y+b10）
<img src="https://img2018.cnblogs.com/blog/1483773/201906/1483773-20190602092727342-320819378.png">
　　4.2.1 平移变换
　　　　了解了仿射变换的概念，平移变换只是采用了一个如下的转变矩阵（transformation matrix）: 从（x,y）平移到（x+tx, y+ty）
　　　　　　　　　　　　　　　　　　<img src="https://img2018.cnblogs.com/blog/1483773/201906/1483773-20190607095256206-1049501258.png">
　　　　　　　　　　　<img src="https://img2018.cnblogs.com/blog/1483773/201906/1483773-20190607101003221-1123704351.png">
　　　　　官网使用示例：向右平移100，向下平移50
<div class="cnblogs_code"><img src="http://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif"><img alt="" id="code_img_opened_74aa4e6f-8303-4422-8ef6-e32563e4cfdd" class="code_img_opened lazyload" style="display: none" data-src="http://images.cnblogs.com/OutliningIndicators/ExpandedBlockStart.gif">
<div id="cnblogs_code_open_74aa4e6f-8303-4422-8ef6-e32563e4cfdd" class="cnblogs_code_hide">
<pre>import cv2
import numpy as np

img = cv2.imread('messi5.jpg',0)
rows,cols = img.shape

M = np.float32([[1,0,100],[0,1,50]])
dst = cv2.warpAffine(img,M,(cols,rows))

cv2.imshow('img',dst)
cv2.waitKey(0)
cv2.destroyAllWindows()</pre>
</div>
View Code</div>
　　4.2.2 放大和缩小
　　　　　放大和缩小指相对于原坐标（x,y）,变换为了（a*x, b*y）,即水平方向放大了a倍，水平方向放大了b倍，其对应的转变矩阵如下：
　　　　　　　　　　　　<img alt="" data-src="https://img2018.cnblogs.com/blog/1483773/201906/1483773-20190607111439230-653546455.png">
　　4.2.3 旋转变换
　　　　　　将（x,y），以坐标原点为中心，顺时针方向旋转α得到(x1,y1)，有如下关系x1 = xcosα-ysinα, y1 =xsinα+ycosα; 因此可以构建对应的转变矩阵如下：<img src="https://img2018.cnblogs.com/blog/1483773/201906/1483773-20190607104028901-605422183.png">
　　　　　　opencv将其扩展到，任意点center为中心进行顺时针旋转α，放大scale倍的，转变矩阵如下：
　　　　　　　　　　　　<img src="https://img2018.cnblogs.com/blog/1483773/201906/1483773-20190607104933761-1590038994.png">
 　　　　　　通过getRotationMatrix2D()能得到转变矩阵
<div class="cnblogs_code">
<pre>　　cv2.getRotationMatrix2D()返回2*3的转变矩阵（浮点型）
参数：
 center：旋转的中心点坐标
 angle：旋转角度，单位为度数，证书表示逆时针旋转
 scale：同方向的放大倍数</pre>
</div>
　　4.2.4 仿射变换矩阵的计算
　　　　通过上述的平移，缩放，旋转的组合变换即实现了仿射变换，上述多个变换的变换矩阵相乘即能得到组合变换的变换矩阵。同时该变换矩阵中涉及到六个未知数（2*3的矩阵），通过变换前后对应三组坐标，也可以求出变换矩阵，opencv提供了函数getAffineTransform()来计算变化矩阵
　　　　1> 矩阵相乘：将平移，旋转和缩放的变换矩阵相乘，最后即为仿射变换矩阵
　　　　2> getAffineTransform()：根据变换前后三组坐标计算变换矩阵　　　　　
<div class="cnblogs_code">
<pre>　　　　cv2.getAffineTransform()返回2*3的转变矩阵
　参数：
 　　 src：原图像中的三组坐标，如np.float32([[50,50],[200,50],[50,200]])
 　　dst: 转换后的对应三组坐标，如np.float32([[10,100],[200,50],[100,250]])</pre>
</div>
　　　　官网使用示例：　　　　　
<div class="cnblogs_code"><img src="http://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif"><img alt="" id="code_img_opened_fd7dee36-339f-4d5c-a43a-cd9d7c62bf16" class="code_img_opened lazyload" style="display: none" data-src="http://images.cnblogs.com/OutliningIndicators/ExpandedBlockStart.gif">
<div id="cnblogs_code_open_fd7dee36-339f-4d5c-a43a-cd9d7c62bf16" class="cnblogs_code_hide">
<pre>img = cv2.imread('drawing.png')
rows,cols,ch = img.shape

pts1 = np.float32([[50,50],[200,50],[50,200]])
pts2 = np.float32([[10,100],[200,50],[100,250]])

M = cv2.getAffineTransform(pts1,pts2)

dst = cv2.warpAffine(img,M,(cols,rows))

plt.subplot(121),plt.imshow(img),plt.title('Input')
plt.subplot(122),plt.imshow(dst),plt.title('Output')
plt.show()</pre>
</div>
View Code</div>
　　4.3 透视变换(persperctive transformation)
　　　　仿射变换都是在二维空间的变换，透视变换（投影变换）是在三维空间中发生了旋转。需要前后四组坐标来计算对应的转变矩阵，opencv提供了函数getPerspectiveTransform()来计算转变矩阵，cv2.warpPerspective()函数来进行透视变换。其对应参数如下：　
<div class="cnblogs_code">
<pre>　　　　　cv2.getPerspectiveTransform() 返回3*3的转变矩阵
 参数：
 src：原图像中的四组坐标，如 np.float32([[56,65],[368,52],[28,387],[389,390]])
 dst: 转换后的对应四组坐标，如np.float32([[0,0],[300,0],[0,300],[300,300]])


 cv2.warpPerspective()
 参数：
 src: 图像对象
 M：3*3 transformation matrix (转变矩阵)
 dsize：输出矩阵的大小，注意格式为（cols，rows）即width对应cols，height对应rows
 flags：可选，插值算法标识符，有默认值INTER_LINEAR，
 如果插值算法为WARP_INVERSE_MAP, warpAffine函数使用如下矩阵进行图像转dst(x,y)=src(M11*x+M12*y+M13,M21*x+M22*y+M23)
 borderMode：可选，边界像素模式，有默认值BORDER_CONSTANT
 borderValue:可选，边界取值，有默认值Scalar()即0</pre>
</div>
　　　官网使用示例：
<div class="cnblogs_code"><img alt="" id="code_img_closed_dc3a9e73-cf2d-42a2-8def-a751878e0389" class="code_img_closed lazyload" data-src="http://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif"><img alt="" id="code_img_opened_dc3a9e73-cf2d-42a2-8def-a751878e0389" class="code_img_opened lazyload" style="display: none" data-src="http://images.cnblogs.com/OutliningIndicators/ExpandedBlockStart.gif">
<div id="cnblogs_code_open_dc3a9e73-cf2d-42a2-8def-a751878e0389" class="cnblogs_code_hide">
<pre>img = cv2.imread('sudokusmall.png')
rows,cols,ch = img.shape

pts1 = np.float32([[56,65],[368,52],[28,387],[389,390]])
pts2 = np.float32([[0,0],[300,0],[0,300],[300,300]])

M = cv2.getPerspectiveTransform(pts1,pts2)

dst = cv2.warpPerspective(img,M,(300,300))

plt.subplot(121),plt.imshow(img),plt.title('Input')
plt.subplot(122),plt.imshow(dst),plt.title('Output')
plt.show()</pre>
</div>
View Code</div>
　　　　　　<img alt="" data-src="https://img2018.cnblogs.com/blog/1483773/201906/1483773-20190607114939954-1993012118.png">
　　　从上图中可以透视变换的一个应用，如果能找到原图中纸张的四个顶点，将其转换到新图中纸张的四个顶点，能将歪斜的roi区域转正，并进行放大；如在书籍，名片拍照上传后进行识别时，是一个很好的图片预处理方法。
 　　　opencv中还提供了一个函数perspctiveTransform()来对坐标点进行透视变换，对于原图像上的一点，通过perspctiveTransform()能计算出透视变换后图片上该点的坐标，其对应参数如下：
<div class="cnblogs_code">
<pre>cv2.perspectiveTransform(src, matrix)

参数：
src：坐标点矩阵，注意其格式. 如src=np.array([,,,], np.float32).reshape(-1, 1, 2), 表示四个坐标点，size为(4, -1, 2)</pre>
<pre> matrix：getPerspectiveTransform()得到的透视变换矩阵返回值：变换后的坐标点，格式和src相同</pre>
</div>
　　若变换前坐标点src(x, y),变换后坐标点为dst(X, Y)，其内部计算过程如下
<img src="https://img2020.cnblogs.com/blog/1483773/202102/1483773-20210210175616751-623661270.png">
 
 　　
<div class="cnblogs_code"><img id="code_img_closed_a2c3fd75-3b41-42c6-b856-e0328a70ed28" class="code_img_closed lazyload" data-src="http://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif"><img id="code_img_opened_a2c3fd75-3b41-42c6-b856-e0328a70ed28" class="code_img_opened lazyload" style="display: none" data-src="http://images.cnblogs.com/OutliningIndicators/ExpandedBlockStart.gif">
<div id="cnblogs_code_open_a2c3fd75-3b41-42c6-b856-e0328a70ed28" class="cnblogs_code_hide">
<pre>#matrix
matrix = np.float32([[ 8.06350904e-01 -1.67497791e-02 -4.34096149e+01]
[ 2.85178118e-028.29440456e-01 -6.26063898e+01]
[ 2.41877972e-051.99790270e-051.00000000e+00]])

rect = np.array([[589, 91], [1355, 91], [1355, 219], [589, 219]], np.float32)
rect = rect.reshape(-1, 1, 2)
newRect = cv2.perspectiveTransform(rect, matrix)

def test(rect, matrix):
rect_fill = np.ones((4, 3), dtype=np.float32)
rect_fill[:, :2] = rect
mid_rect = np.dot(matrix, rect_fill.T)
mid_rect = mid_rect.T
mid_rect[:, :2] = mid_rect[:, :2]/mid_rect[:, 2:]
print("TEST", mid_rect)</pre>
</div>
perspectiveTransform</div>
 官方文档：https://docs.opencv.org/3.0-beta/modules/imgproc/doc/miscellaneous_transformations.html?highlight=adaptivethreshold#cv2.adaptiveThreshold
 Tutorial：https://opencv-python-tutroals.readthedocs.io/en/latest/py_tutorials/py_gui/py_trackbar/py_trackbar.html#trackbar 
来源：https://www.cnblogs.com/silence-cho/p/10926248.html

頁: [1]

琼殿技术论坛's Archiver

(一)OpenCV-Python学习—基础知识