OpenCV-Python学习基础知识!

opencv是一个强大的图像处理和计算机视觉库,实现了很多实用算法,值得学习和深究下。
  包含编程籽料、学习路线图、源代码、软件安装包等!【点击领取 100%免费】!

1.opencv包安装

·  这里直接安装opencv-python包(非官方): pip install opencv-python

官方文档:https://opencv-python-tutroals.readthedocs.io/en/latest/

2. opencv简单图像处理

2.1 图像像素存储形式

首先得了解下图像在计算机中存储形式:(为了方便画图,每列像素值都写一样了)

对于只有黑白颜色的灰度图,为单通道,一个像素块对应矩阵中一个数字,数值为0到255, 其中0表示最暗(黑色) ,255表示最亮(白色)

对于采用RGB模式的彩色图片,为三通道图,Red、Green、Blue三原色,按不同比例相加,一个像素块对应矩阵中的一个向量, 如[24,180, 50],分别表示三种颜色的比列, 即对应深度上的数字,如下图所示:

需要注意的是,由于历史遗留问题,opencv采用BGR模式,而不是RGB

2.2 图像读取和写入

cv2.imread()

imread(img\_path,flag) 读取图片,返回图片对象
    img\_path: 图片的路径,即使路径错误也不会报错,但打印返回的图片对象为None
    flag:cv2.IMREAD\_COLOR,读取彩色图片,图片透明性会被忽略,为默认参数,也可以传入1
          cv2.IMREAD\_GRAYSCALE,按灰度模式读取图像,也可以传入0
          cv2.IMREAD\_UNCHANGED,读取图像,包括其alpha通道,也可以传入\-1

cv2.imshow()

imshow(window\_name,img):显示图片,窗口自适应图片大小
    window\_name: 指定窗口的名字
    img:显示的图片对象
    可以指定多个窗口名称,显示多个图片
    
waitKey(millseconds)  键盘绑定事件,阻塞监听键盘按键,返回一个数字(不同按键对应的数字不同)
    millseconds: 传入时间毫秒数,在该时间内等待键盘事件;传入0时,会一直等待键盘事件
    
destroyAllWindows(window\_name) 
    window\_name: 需要关闭的窗口名字,不传入时关闭所有窗口

cv2.imwrite()

imwrite(img\_path\_name,img)
    img\_path\_name:保存的文件名
    img:文件对象

使用示例:

#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)

View Code

2.3 图像像素获取和编辑

像素值获取:

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)

图片性质

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')

ROI截取(Range of Interest)

#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))

2.4 添加边界(padding)

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\]

使用示例:

#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 \= \[constant,reflect,reflect01,replicate,wrap\]

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





 

View Code

2.5 像素算术运算

cv2.add() 相加的两个图片,应该有相同的大小和通道

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\]

使用示例:图一无掩膜,图二有掩膜

#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()

View Code

cv.addWeight(): 两张图片相加,分别给予不同权重,实现图片融合和透明背景等效果

cv2.addWeighted() 两张图片相加,分别给予不同权重,实现图片融合和透明背景等效果
    参数:
        img1:图片对象1
        alpha:img1的权重
        img2:图片对象2
        beta:img1的权重
        gamma:常量值,图像相加后再加上常量值
        dtype:返回图像的数据类型,默认为\-1,和img1一样
    (img1\*alpha+img2\*beta+gamma)

使用示例:

#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()

View Code

2.6 图像位运算

btwise_and(), bitwise_or(), bitwise_not(), bitwise_xor()

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:掩膜

使用示例:将logo图片移动到足球图片中,需要截取logo图片的前景和足球图片ROI的背景,然后叠加,效果如下:

#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()

View Code

2.7 图像颜色空间转换

cv2.cvtColor()

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)

2.8 性能评价

cv2.getTickCount(): 获得时钟次数

cv2.getTickFrequency():获得时钟频率 (每秒振动次数)

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

2.9 绑定trackbar到图像

cv2.createTrackbar()

cv2.getTrackbarPos()

    cv2.createTrackbar() 为窗口添加trackbar
    参数:
        trackbarname: trackbar的名字
        winname: 窗口的名字
        value: trackbar创建时的值
        count:trackbar能设置的最大值,最小值总为0
        onChange:trackbar值发生变化时的回调函数,trackbar的值作为参数传给onchange
        
    cv2.getTrackbarPos() 获取某个窗口中trackbar的值
    参数:
        trackbarname: trackbar的名字
        winname: 窗口的名字

使用示例:通过改变trackbar的值,来寻找最优的mask范围,从而识别出图片中蓝色的瓶盖

#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(\[l\_h,l\_s,l\_v\])
    upper\_b \= np.array(\[u\_h,u\_s,u\_v\])
    
    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()

View Code

3. 图像阈值化

cv2.threshold()

cv2.adaptiveThreshold()

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)

使用示例:

#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 \= \[img,thre1,adaptive\_thre1,adaptive\_thre2 \]

for i in range(4):
    plt.subplot(2,2,i+1), plt.imshow(imgs\[i\],"gray")
    plt.title(titles\[i\])
    plt.xticks(\[\]),plt.yticks(\[\])
plt.show()

View Code

奥斯二值化(Otsu’s Binarization)

对于一些双峰图像,奥斯二值化能找到两峰之间的像素值作为阈值,并将其返回。适用于双峰图像的阈值化,或者通过去噪而产生的双峰图像。

官网使用示例:

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\[i\*3\],'gray')
    plt.title(titles\[i\*3\]), plt.xticks(\[\]), plt.yticks(\[\])
    plt.subplot(3,3,i\*3+2),plt.hist(images\[i\*3\].ravel(),256)
    plt.title(titles\[i\*3+1\]), plt.xticks(\[\]), plt.yticks(\[\])
    plt.subplot(3,3,i\*3+3),plt.imshow(images\[i\*3+2\],'gray')
    plt.title(titles\[i\*3+2\]), plt.xticks(\[\]), plt.yticks(\[\])
plt.show()

View Code   

4. 图像形状变换

4.1 cv2.resize() 图像缩放

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 适合于图像放大

官网示例:

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)

图像放大两倍

4.2 cv2.warpAffine() 仿射变换

仿射变换(从二维坐标到二维坐标之间的线性变换,且保持二维图形的“平直性”和“平行性”。仿射变换可以通过一系列的原子变换的复合来实现,包括平移,缩放,翻转,旋转和剪切)

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

常用插值算法:

仿射变换的本质:即一个矩阵A和向量B共同组成的转变矩阵,和原图像坐标相乘来得到新图像的坐标,从而实现图像移动,旋转等。如下矩阵A和向量B组成的转变矩阵M,用来对原图像的坐标(x,y)进行转变,得到新的坐标向量T

矩阵A和向量B

仿射变换(矩阵计算):变换前坐标(x,y)

变换结果:变换后坐标(a00*x+a01 *y+b00, a10*x+a11*y+b10)

4.2.1 平移变换

了解了仿射变换的概念,平移变换只是采用了一个如下的转变矩阵(transformation matrix): 从(x,y)平移到(x+tx, y+ty)

官网使用示例:向右平移100,向下平移50

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()

View Code

4.2.2 放大和缩小

放大和缩小指相对于原坐标(x,y),变换为了(a*x, b*y),即水平方向放大了a倍,水平方向放大了b倍,其对应的转变矩阵如下:

4.2.3 旋转变换

将(x,y),以坐标原点为中心,顺时针方向旋转α得到(x1,y1), 有如下关系x1 = xcosα-ysinα, y1 =xsinα+ycosα; 因此可以构建对应的转变矩阵如下:

opencv将其扩展到,任意点center为中心进行顺时针旋转α,放大scale倍的,转变矩阵如下:

通过getRotationMatrix2D()能得到转变矩阵

  cv2.getRotationMatrix2D()  返回2\*3的转变矩阵(浮点型)
    参数:
        center:旋转的中心点坐标
        angle:旋转角度,单位为度数,证书表示逆时针旋转
        scale:同方向的放大倍数

4.2.4 仿射变换矩阵的计算

通过上述的平移,缩放,旋转的组合变换即实现了仿射变换,上述多个变换的变换矩阵相乘即能得到组合变换的变换矩阵。同时该变换矩阵中涉及到六个未知数(2*3的矩阵),通过变换前后对应三组坐标,也可以求出变换矩阵,opencv提供了函数getAffineTransform()来计算变化矩阵

1> 矩阵相乘:将平移,旋转和缩放的变换矩阵相乘,最后即为仿射变换矩阵

2> getAffineTransform():根据变换前后三组坐标计算变换矩阵

    cv2.getAffineTransform()  返回2\*3的转变矩阵
      参数:
          src:原图像中的三组坐标,如np.float32(\[\[50,50\],\[200,50\],\[50,200\]\])
          dst: 转换后的对应三组坐标,如np.float32(\[\[10,100\],\[200,50\],\[100,250\]\])

官网使用示例:

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()

View Code

4.3 透视变换(persperctive transformation)

仿射变换都是在二维空间的变换,透视变换(投影变换)是在三维空间中发生了旋转。需要前后四组坐标来计算对应的转变矩阵,opencv提供了函数getPerspectiveTransform()来计算转变矩阵,cv2.warpPerspective()函数来进行透视变换。其对应参数如下:

     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

官网使用示例:

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()

View Code

从上图中可以透视变换的一个应用,如果能找到原图中纸张的四个顶点,将其转换到新图中纸张的四个顶点,能将歪斜的roi区域转正,并进行放大;如在书籍,名片拍照上传后进行识别时,是一个很好的图片预处理方法。

opencv中还提供了一个函数perspctiveTransform()来对坐标点进行透视变换,对于原图像上的一点,通过perspctiveTransform()能计算出透视变换后图片上该点的坐标,其对应参数如下:

cv2.perspectiveTransform(src, matrix)

参数: 
    src:坐标点矩阵,注意其格式. 如src=np.array(\[\[589, 91\],\[1355, 91\],\[1355, 219\],\[589, 219\]\], np.float32).reshape(-1, 1, 2), 表示四个坐标点,size为(4, -1, 2)
    matrix:getPerspectiveTransform()得到的透视变换矩阵 返回值:变换后的坐标点,格式和src相同

若变换前坐标点src(x, y),变换后坐标点为dst(X, Y), 其内部计算过程如下

#matrix
matrix \= np.float32(\[\[ 8.06350904e-01 -1.67497791e-02 -4.34096149e+01\]
 \[ 2.85178118e-02  8.29440456e-01 -6.26063898e+01\]
 \[ 2.41877972e-05  1.99790270e-05  1.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)

perspectiveTransform

官方文档: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.opencv包安装

·  这里直接安装opencv-python包(非官方): pip install opencv-python

官方文档:https://opencv-python-tutroals.readthedocs.io/en/latest/

2. opencv简单图像处理

2.1 图像像素存储形式

首先得了解下图像在计算机中存储形式:(为了方便画图,每列像素值都写一样了)

对于只有黑白颜色的灰度图,为单通道,一个像素块对应矩阵中一个数字,数值为0到255, 其中0表示最暗(黑色) ,255表示最亮(白色)

对于采用RGB模式的彩色图片,为三通道图,Red、Green、Blue三原色,按不同比例相加,一个像素块对应矩阵中的一个向量, 如[24,180, 50],分别表示三种颜色的比列, 即对应深度上的数字,如下图所示:

需要注意的是,由于历史遗留问题,opencv采用BGR模式,而不是RGB

2.2 图像读取和写入

cv2.imread()

imread(img\_path,flag) 读取图片,返回图片对象
    img\_path: 图片的路径,即使路径错误也不会报错,但打印返回的图片对象为None
    flag:cv2.IMREAD\_COLOR,读取彩色图片,图片透明性会被忽略,为默认参数,也可以传入1
          cv2.IMREAD\_GRAYSCALE,按灰度模式读取图像,也可以传入0
          cv2.IMREAD\_UNCHANGED,读取图像,包括其alpha通道,也可以传入\-1

cv2.imshow()

imshow(window\_name,img):显示图片,窗口自适应图片大小
    window\_name: 指定窗口的名字
    img:显示的图片对象
    可以指定多个窗口名称,显示多个图片
    
waitKey(millseconds)  键盘绑定事件,阻塞监听键盘按键,返回一个数字(不同按键对应的数字不同)
    millseconds: 传入时间毫秒数,在该时间内等待键盘事件;传入0时,会一直等待键盘事件
    
destroyAllWindows(window\_name) 
    window\_name: 需要关闭的窗口名字,不传入时关闭所有窗口

cv2.imwrite()

imwrite(img\_path\_name,img)
    img\_path\_name:保存的文件名
    img:文件对象

使用示例:

#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)

View Code

2.3 图像像素获取和编辑

像素值获取:

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)

图片性质

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')

ROI截取(Range of Interest)

#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))

2.4 添加边界(padding)

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\]

使用示例:

#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 \= \[constant,reflect,reflect01,replicate,wrap\]

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





 

View Code

2.5 像素算术运算

cv2.add() 相加的两个图片,应该有相同的大小和通道

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\]

使用示例:图一无掩膜,图二有掩膜

#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()

View Code

cv.addWeight(): 两张图片相加,分别给予不同权重,实现图片融合和透明背景等效果

cv2.addWeighted() 两张图片相加,分别给予不同权重,实现图片融合和透明背景等效果
    参数:
        img1:图片对象1
        alpha:img1的权重
        img2:图片对象2
        beta:img1的权重
        gamma:常量值,图像相加后再加上常量值
        dtype:返回图像的数据类型,默认为\-1,和img1一样
    (img1\*alpha+img2\*beta+gamma)

使用示例:

#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()

View Code

2.6 图像位运算

btwise_and(), bitwise_or(), bitwise_not(), bitwise_xor()

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:掩膜

使用示例:将logo图片移动到足球图片中,需要截取logo图片的前景和足球图片ROI的背景,然后叠加,效果如下:

#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()

View Code

2.7 图像颜色空间转换

cv2.cvtColor()

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)

2.8 性能评价

cv2.getTickCount(): 获得时钟次数

cv2.getTickFrequency():获得时钟频率 (每秒振动次数)

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

2.9 绑定trackbar到图像

cv2.createTrackbar()

cv2.getTrackbarPos()

    cv2.createTrackbar() 为窗口添加trackbar
    参数:
        trackbarname: trackbar的名字
        winname: 窗口的名字
        value: trackbar创建时的值
        count:trackbar能设置的最大值,最小值总为0
        onChange:trackbar值发生变化时的回调函数,trackbar的值作为参数传给onchange
        
    cv2.getTrackbarPos() 获取某个窗口中trackbar的值
    参数:
        trackbarname: trackbar的名字
        winname: 窗口的名字

使用示例:通过改变trackbar的值,来寻找最优的mask范围,从而识别出图片中蓝色的瓶盖

#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(\[l\_h,l\_s,l\_v\])
    upper\_b \= np.array(\[u\_h,u\_s,u\_v\])
    
    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()

View Code

3. 图像阈值化

cv2.threshold()

cv2.adaptiveThreshold()

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)

使用示例:

#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 \= \[img,thre1,adaptive\_thre1,adaptive\_thre2 \]

for i in range(4):
    plt.subplot(2,2,i+1), plt.imshow(imgs\[i\],"gray")
    plt.title(titles\[i\])
    plt.xticks(\[\]),plt.yticks(\[\])
plt.show()

View Code

奥斯二值化(Otsu’s Binarization)

对于一些双峰图像,奥斯二值化能找到两峰之间的像素值作为阈值,并将其返回。适用于双峰图像的阈值化,或者通过去噪而产生的双峰图像。

官网使用示例:

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\[i\*3\],'gray')
    plt.title(titles\[i\*3\]), plt.xticks(\[\]), plt.yticks(\[\])
    plt.subplot(3,3,i\*3+2),plt.hist(images\[i\*3\].ravel(),256)
    plt.title(titles\[i\*3+1\]), plt.xticks(\[\]), plt.yticks(\[\])
    plt.subplot(3,3,i\*3+3),plt.imshow(images\[i\*3+2\],'gray')
    plt.title(titles\[i\*3+2\]), plt.xticks(\[\]), plt.yticks(\[\])
plt.show()

View Code   

4. 图像形状变换

4.1 cv2.resize() 图像缩放

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 适合于图像放大

官网示例:

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)

图像放大两倍

4.2 cv2.warpAffine() 仿射变换

仿射变换(从二维坐标到二维坐标之间的线性变换,且保持二维图形的“平直性”和“平行性”。仿射变换可以通过一系列的原子变换的复合来实现,包括平移,缩放,翻转,旋转和剪切)

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

常用插值算法:

仿射变换的本质:即一个矩阵A和向量B共同组成的转变矩阵,和原图像坐标相乘来得到新图像的坐标,从而实现图像移动,旋转等。如下矩阵A和向量B组成的转变矩阵M,用来对原图像的坐标(x,y)进行转变,得到新的坐标向量T

矩阵A和向量B

仿射变换(矩阵计算):变换前坐标(x,y)

变换结果:变换后坐标(a00*x+a01 *y+b00, a10*x+a11*y+b10)

4.2.1 平移变换

了解了仿射变换的概念,平移变换只是采用了一个如下的转变矩阵(transformation matrix): 从(x,y)平移到(x+tx, y+ty)

官网使用示例:向右平移100,向下平移50

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()

View Code

4.2.2 放大和缩小

放大和缩小指相对于原坐标(x,y),变换为了(a*x, b*y),即水平方向放大了a倍,水平方向放大了b倍,其对应的转变矩阵如下:

4.2.3 旋转变换

将(x,y),以坐标原点为中心,顺时针方向旋转α得到(x1,y1), 有如下关系x1 = xcosα-ysinα, y1 =xsinα+ycosα; 因此可以构建对应的转变矩阵如下:

opencv将其扩展到,任意点center为中心进行顺时针旋转α,放大scale倍的,转变矩阵如下:

通过getRotationMatrix2D()能得到转变矩阵

  cv2.getRotationMatrix2D()  返回2\*3的转变矩阵(浮点型)
    参数:
        center:旋转的中心点坐标
        angle:旋转角度,单位为度数,证书表示逆时针旋转
        scale:同方向的放大倍数

4.2.4 仿射变换矩阵的计算

通过上述的平移,缩放,旋转的组合变换即实现了仿射变换,上述多个变换的变换矩阵相乘即能得到组合变换的变换矩阵。同时该变换矩阵中涉及到六个未知数(2*3的矩阵),通过变换前后对应三组坐标,也可以求出变换矩阵,opencv提供了函数getAffineTransform()来计算变化矩阵

1> 矩阵相乘:将平移,旋转和缩放的变换矩阵相乘,最后即为仿射变换矩阵

2> getAffineTransform():根据变换前后三组坐标计算变换矩阵

    cv2.getAffineTransform()  返回2\*3的转变矩阵
      参数:
          src:原图像中的三组坐标,如np.float32(\[\[50,50\],\[200,50\],\[50,200\]\])
          dst: 转换后的对应三组坐标,如np.float32(\[\[10,100\],\[200,50\],\[100,250\]\])

官网使用示例:

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()

View Code

4.3 透视变换(persperctive transformation)

仿射变换都是在二维空间的变换,透视变换(投影变换)是在三维空间中发生了旋转。需要前后四组坐标来计算对应的转变矩阵,opencv提供了函数getPerspectiveTransform()来计算转变矩阵,cv2.warpPerspective()函数来进行透视变换。其对应参数如下:

     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

官网使用示例:

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()

View Code

从上图中可以透视变换的一个应用,如果能找到原图中纸张的四个顶点,将其转换到新图中纸张的四个顶点,能将歪斜的roi区域转正,并进行放大;如在书籍,名片拍照上传后进行识别时,是一个很好的图片预处理方法。

opencv中还提供了一个函数perspctiveTransform()来对坐标点进行透视变换,对于原图像上的一点,通过perspctiveTransform()能计算出透视变换后图片上该点的坐标,其对应参数如下:

cv2.perspectiveTransform(src, matrix)

参数: 
    src:坐标点矩阵,注意其格式. 如src=np.array(\[\[589, 91\],\[1355, 91\],\[1355, 219\],\[589, 219\]\], np.float32).reshape(-1, 1, 2), 表示四个坐标点,size为(4, -1, 2)
    matrix:getPerspectiveTransform()得到的透视变换矩阵 返回值:变换后的坐标点,格式和src相同

若变换前坐标点src(x, y),变换后坐标点为dst(X, Y), 其内部计算过程如下

#matrix
matrix \= np.float32(\[\[ 8.06350904e-01 -1.67497791e-02 -4.34096149e+01\]
 \[ 2.85178118e-02  8.29440456e-01 -6.26063898e+01\]
 \[ 2.41877972e-05  1.99790270e-05  1.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)

最后:关于Python技术储备
学好 Python 不论是就业还是做副业赚钱都不错,但要学会 Python 还是要有一个学习规划。最后给大家分享一份全套的 Python 学习资料,给那些想学习 Python 的小伙伴们一点帮助!
包括:Python激活码+安装包、Python web开发,Python爬虫,Python数据分析,人工智能、自动化办公等学习教程。带你从零基础系统性的学好Python!

在这里插入图片描述

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值