OpenCV计算机视觉学习（1）——图像基本操作（图像视频读取，ROI区域截取，常用cv函数解释）

如果需要处理的原图及代码，请移步小编的GitHub地址

　　传送门：请点击我

　　如果点击有误：https://github.com/LeBron-Jian/ComputerVisionPractice

1，计算机眼中的图像

　　我们打开经典的 Lena图片，看看计算机是如何看待图片的：

 　　我们点击图中的一个小格子，发现计算机会将其分为R，G，B三种通道。每个通道分别由一堆0~256之间的数字组成，那OpenCV如何读取，处理图片呢，我们下面详细学习。

2，图像的加载，显示和保存

　　我们看看在OpenCV中如何操作：

import cv2

# 生成图片
img = cv2.imread("lena.jpg")
# 生成灰色图片
imgGrey = cv2.imread("lena.jpg", 0)
#  展示原图
cv2.imshow("img", img)
#  展示灰色图片
cv2.imshow("imgGrey", imgGrey)
#  等待图片的关闭
cv2.waitKey()
# 保存灰色图片
cv2.imwrite("Copy.jpg", imgGrey)

 　　图像的显示，也可以创建多个窗口。

2.1 图像的加载函数 cv2.imread()

　　cv2.imread() 函数原型如下：

imread(filename, flags=None)

　　使用函数cv2.imread() 读入图像。这幅图像应该在此程序的工作路径，或者给函数提供完整路径，第二个参数是要告诉函数应该如何读取这幅图片。

• cv2.IMREAD_COLOR：读入一副彩色图像。图像的透明度会被忽略，这是默认参数
• cv2.IMREAD_GRAYSCALE：以灰度模式读入图像
• cv2.IMREAD_UNCHANGED：保留读取图片原有的颜色通道 
• +1 ：等同于cv2.IMREAD_COLOR 
•  0 ：等同于cv2.IMREAD_GRAYSCALE 
•  -1 ：等同于cv2.IMREAD_UNCHANGED 

　　PS：调用opencv，就算图像的路径是错的，OpenCV 也不会提醒你的，但是当你使用命令 print(img) 时得到的结果是None。

2.2 图像的显示函数 cv2.imshow()

　　cv2.imshow() 函数作用是在窗口中显示图像，窗口自动适合于图像大小，我们也可以通过imutils模块调整显示图像的窗口大小。

　　函数官方定义如下：

imshow(winname, mat)

　　参数解释如下：

• 参数一： 窗口名称(字符串) 
• 参数二： 图像对象，类型是numpy中的ndarray类型，注：这里可以通过imutils模块改变图像显示大小

2.3  图像的保存函数 cv2.imwrite()

　　cv2.imwrite()  函数检查图像保存到本地，官方定义如下：

cv2.imwrite(image_filename, image)

　　参数解释如下：

• 参数一： 保存的图像名称(字符串) 
• 参数二： 图像对象，类型是numpy中的ndarray类型

3，图像显示窗口创建与销毁

　　当我们使用imshow函数展示图像时，最后需要在程序中对图像展示窗口进行销毁，否则程序将无法正常终止，常用的销毁窗口的函数有下面两个：

(1)、cv2.destroyWindow(windows_name) #销毁单个特定窗口 
参数： 将要销毁的窗口的名字

(2)、cv2.destroyAllWindows() #销毁全部窗口，无参数 

　　那我们合适销毁窗口，肯定不能图片窗口一出现我们就将窗口销毁，这样便没法观看窗口，试想有两种方式： 

• (1) 让窗口停留一段时间然后自动销毁； 
• (2) 接收指定的命令，如接收指定的键盘敲击然后结束我们想要结束的窗口 

　　以上两种情况都将使用cv2.waitKey函数， 首先产看函数定义：

cv2.waitKey(time_of_milliseconds)

　　唯一参数delay是整数，可正可负也可是零，含义和操作也不同，分别对应上面说的两种情况。

(1) time_of_milliseconds > 0 ：
此时time_of_milliseconds表示时间，单位是毫秒，
含义表示等待 time_of_milliseconds毫秒后图像将自动销毁，看以下示例

#表示等待10秒后，将销毁所有图像
if cv2.waitKey(10000):
    cv2.destroyAllWindows()

#表示等待10秒，将销毁窗口名称为'origin image'的图像窗口
if cv2.waitKey(10000):
    cv2.destroyWindow('origin image')



(2) time_of_milliseconds <= 0 ： 
此时图像窗口将等待一个键盘敲击，接收到指定的键盘敲击便会进行窗口销毁。
我们可以自定义等待敲击的键盘，通过下面的例子进行更好的解释

#当指定waitKey(0) == 27时当敲击键盘 Esc 时便销毁所有窗口
if cv2.waitKey(0) == 27:
    cv2.destroyAllWindows()

#当接收到键盘敲击A时，便销毁名称为'origin image'的图像窗口
if cv2.waitKey(-1) == ord('A'):
    cv2.destroyWindow('origin image')

　　

　  waitKey()函数原型：

C++: int waitKey(int delay=0)       Python: cv2.waitKey([delay]) → retval

C: int cvWaitKey(int delay=0 )       Python: cv.WaitKey(delay=0) → int

　　waitKey()函数功能：

　　waitKey() 函数的功能是不断地刷新图像，频率时间为delay，单位为ms。返回值为当前键盘按键值。

 　　waitKey()函数作用：

　　1，waitKey()  这个函数是在一个给定的时间内（单位ms）等待用户按键触发；如果用户没有按下键，则继续等待（循环）。

　　2，如果设置waitKey(0)，则表示程序会无限制的等待用户的按键事件。

　　3，用OpenCV来显示图像或者视频时，如果后面不加cvWaitKey这个函数，基本上是显示不出来的。

　   4，显示图像，一般要在cvShowImage()函数后面加一句cvWaitKey(0)；否则图像无法正常显示。

　　waitKey()源代码：

def waitKey(delay=None): # real signature unknown; restored from __doc__
    """
    waitKey([, delay]) -> retval
    .   @brief Waits for a pressed key.
    .   
    .   The function waitKey waits for a key event infinitely (when f$	exttt{delay}leq 0f$ ) or for delay
    .   milliseconds, when it is positive. Since the OS has a minimum time between switching threads, the
    .   function will not wait exactly delay ms, it will wait at least delay ms, depending on what else is
    .   running on your computer at that time. It returns the code of the pressed key or -1 if no key was
    .   pressed before the specified time had elapsed.
    .   
    .   @note
    .   
    .   This function is the only method in HighGUI that can fetch and handle events, so it needs to be
    .   called periodically for normal event processing unless HighGUI is used within an environment that
    .   takes care of event processing.
    .   
    .   @note
    .   
    .   The function only works if there is at least one HighGUI window created and the window is active.
    .   If there are several HighGUI windows, any of them can be active.
    .   
    .   @param delay Delay in milliseconds. 0 is the special value that means "forever".
    """
    pass

指定窗口大小模式的属性：

• cv2.WINDOW_AUTOSIZE：根据图像大小自动创建大小
• cv2.WINDOW_NORMAL：窗口大小可调整

# 设置为WINDOW_NORMAL可以任意缩放
# cv.namedWindow('input_image', cv.WINDOW_NORMAL)

　　代码如下：

import cv2

img = cv2.imread("lena.jpg")

cv2.namedWindow("img", cv2.WINDOW_NORMAL)
cv2.imshow("img", img)
cv2.waitKey()
cv2.destroyAllWindows()

4，视频的读取，处理与保存

　　（视频读取流程的话：可以达到30fps，即一秒30帧，不过基本都是25~30左右）

　　cv2.VideoCapture（）： 可以捕获摄像头，用数字来控制不同的设备，例如0,1。如果是视频文件，直接指定好路径即可。设备索引只是指定哪台摄像机的号码，0代表第一台摄像机，1代表第二台摄像机。之后就可以逐帧捕获视频，但最后，不要忘记释放捕获。

　　cap.read（）：返回一个布尔值（True / False）。如果帧被正确读取，则返回true，否则返回false。可以通过检查这个返回值来判断视频是否结束。　　

　　cap.isOpened（）：检查cap是否被初始化。若没有初始化，则使用cap.open（）打开它。当cap没有初始化时，上面的代码会报错。　　

　　retval,image= cv2.VideoCapture.read([,image]) 抓取，解码并返回下一个视频帧。返回值为true表明抓取成功。该函数是组合了grab()和retrieve()，这是最方便的方法。如果没有帧，该函数返回false，并输出空图像。
　　retval, image = cv2.VideoCapture.retrieve([, image[, flag]]) 解码并返回抓取的视频帧
　　retval = cv2.VideoCapture.grab() 从视频文件或相机中抓取下一帧。true为抓取成功。该函数主要用于多摄像头时。
　　cv2.VideoCapture.release() 关闭视频文件或相机设备。

　　cap.get（propId）：访问视频的某些功能，其中propId是一个从0到18的数字，每个数字表示视频的属性（Property Identifier）。其中一些值可以使用cap.set（propId，value）进行修改，value是修改后的值。
　　举个例子：我通过cap.get（3）和cap.get（4）来检查帧的宽度和高度，默认的值是640x480。但我想修改为320x240，可以使用ret = cap.set（3, 320）和ret = cap.set（4, 240）。

propId 常见取值如下:

• cv2.CAP_PROP_POS_MSEC：     视频文件的当前位置（ms）
• cv2.CAP_PROP_POS_FRAMES：   从0开始索引帧，帧位置。
• cv2.CAP_PROP_POS_AVI_RATIO：视频文件的相对位置（0表示开始，1表示结束）
• cv2.CAP_PROP_FRAME_WIDTH：  视频流的帧宽度。
• cv2.CAP_PROP_FRAME_HEIGHT： 视频流的帧高度。
• cv2.CAP_PROP_FPS：          帧率
• cv2.CAP_PROP_FOURCC：       编解码器四字符代码
• cv2.CAP_PROP_FRAME_COUNT：  视频文件的帧数
• cv2.CAP_PROP_FORMAT：       retrieve()返回的Mat对象的格式。
• cv2.CAP_PROP_MODE：         后端专用的值，指示当前捕获模式
• cv2.CAP_PROP_BRIGHTNESS：图像的亮度，仅适用于支持的相机
• cv2.CAP_PROP_CONTRAST：  图像对比度，仅适用于相机
• cv2.CAP_PROP_SATURATION：图像饱和度，仅适用于相机
• cv2.CAP_PROP_HUE：       图像色调，仅适用于相机
• cv2.CAP_PROP_GAIN：      图像增益，仅适用于支持的相机
• cv2.CAP_PROP_EXPOSURE：    曝光，仅适用于支持的相机
• cv2.CAP_PROP_CONVERT_RGB：布尔标志，指示是否应将图像转换为RGB。

　　视频读取与处理代码：

import cv2

# 参数为视频文件目录
videoc = cv2.VideoCapture('test.mp4')
# VideoCapture对象，参数可以是设备索引或视频文件名称，设备索引只是指定哪台摄像机的号码
# 0代表第一台摄像机，1代表第二台摄像机，之后可以逐帧捕获视频，但是最后需要释放捕获
# 调用内置摄像头
# cap = cv2.VideoCapture(0)
# 调用USB摄像头
# cap = cv2.VideoCapture(1)


# 检查是否打开正确
if videoc.isOpened():
    open, frame = videoc.read()
else:
    open = False

# 逐帧显示实现视频播放
while open:
    ret, frame = videoc.read()  # 读取
    if frame is None:
        break
    if ret == True:
        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
        cv2.imshow('result', gray)
        if cv2.waitKey(10) & 0xFF == 27:  # 读取完自动退出
        # if cv2.waitKey(1) & 0xFF == ord('q'):  # 读完按 q 退出
            break

# 释放摄像头对象和窗口
videoc.release()
cv2.destroyAllWindows()

 　　解释一下从文件中播放视频： 和从相机捕获视频相同，只需要更改相机索引和视频文件名。在显示帧时，选择适当地 cv2.waitKey() 时间，如果该值太小，视频会非常快，如果他太大，则视频会非常慢（这可以用慢动作显示视频）。正常情况下 25毫秒即可。

　　保存视频：我们需要创建一个 VideoWriter对象，指定输出文件名（例如：output.avi）。之后指定 FourCC代码（FourCC是用于指定视频编码解码器的四字节代码，可用的代码列标：http://www.fourcc.org/codecs.php）。接下来传递每秒帧数（FPS）和帧大小，最后一个是 isColor标注，如果他为TRUE，编码器编码成彩色帧，否则编码成灰度框帧。

　　视频保存代码：

import numpy as np
import cv2

cap = cv2.VideoCapture(0)

# Define the codec and create VideoWriter object
fourcc = cv2.VideoWriter_fourcc(*'XVID')
out = cv2.VideoWriter('output.avi',fourcc, 20.0, (640,480))

while(cap.isOpened()):
    ret, frame = cap.read()
    if ret==True:
        frame = cv2.flip(frame,0)

        # write the flipped frame
        out.write(frame)

        cv2.imshow('frame',frame)
        if cv2.waitKey(1) & 0xFF == ord('q'):
            break
    else:
        break

# Release everything if job is finished
cap.release()
out.release()
cv2.destroyAllWindows()

OpenCV提供了接口VideoWriter 用于视频的保存：

<VideoWriter object> = cv.VideoWriter( filename, fourcc, fps, frameSize[, isColor] )

函数参数：

• filename：给要保存的视频起个名字
• fourcc：指定视频编解码器的4字节代码

1. 【（‘P’，‘I’，‘M’，‘1’）是MPEG-1编解码器】
2. 【（‘M’，‘J’，‘P’，'G '）是一个运动jpeg编解码器】

• fps：帧率
• frameSize：帧大小
• retval = cv2.VideoWriter_fourcc( c1, c2, c3, c4 ) 将4字符串接为fourcc代码。
• cv.VideoWriter.write( image ) 将帧图像保存为视频文件。
• isColor：如果为true，则视频为彩色，否则为灰度视频，默认为true

5，图像ROI

　　ROI（Region of Interest）表示感兴趣区域。感兴趣区域，就是我们从图像中选择一个图像区域，这个区域就是图像分析所关注的焦点。我们圈定这个区域，那么我们要处理的图像就是要从一个大图像变为小图像区域了，这样以便进行进一步处理，可以大大减少处理时间。

　　ROI 也是使用Numpy 索引来获得的，其本质上是多维数组（矩阵）的切片，如下图所示：

 　　其实，原理很简单，就是利用数组切片和索引操作来选择指定区域的内容，通过像素矩阵可以直接获取ROI区域，如 img[200:400,  200: 400]。Rect 四个形参分别是：x坐标，y坐标，长，高，注意（x,  y）指的是矩形的左上角点。

　　比如我要获取欧文的头，图如下：

 　　简易的矩形ROI区域获取代码如下

import cv2
import numpy as np
import matplotlib.pyplot as plt

# 读取原始图像
img = cv2.imread('irving.jpg')
# print(img.shape)  # (458, 558, 3)

# 我们自己计算要获取的头部的大小，以及左上角的坐标
# 这里左上角的坐标为：w:h=250 7  区域为100*100
roi_zero = img[7:107, 250:350]

# 显示图像
cv2.imshow("Image", roi_zero)

# 等待显示
cv2.waitKey(0)
cv2.destroyAllWindows()

 　　结果如下：

6，图像宽，高，通道数获取

　　img.shape 返回图像高（图像矩阵的行数），宽（图像矩阵的列数）和通道数3个属性组成的元组，若图像是非彩色图（即灰度图，二值图等），则只返回高和宽组成的元组。

import cv2

img = cv2.imread("1.jpg")
imgGrey = cv2.imread("1.jpg", 0)

sp1 = img.shape
sp2 = imgGrey.shape

print(sp1)
print(sp2)# ======输出=======#(1200, 1920, 3)#(1200, 1920)

7，图像像素数目和图像数据类型的获取

　　图像矩阵img 的 size属性和 dtype 分别对应图像的像素总数目和图像数据类型。一般情况下，图像的数据类型是 uint8。

　　通过size关键字获取图像的像素数目，其中灰度图像返回行数*列数，彩色图像返回行数*列数*通道数。

　　通过dtype关键字获取图像的数据类型，通常返回 uint8

　　代码如下：

# -*- coding:utf-8 -*-
import cv2
import numpy

#读取图片
img = cv2.imread("test.jpg", cv2.IMREAD_UNCHANGED)

#获取图像形状
print(img.shape)

#获取像素数目
print(img.size)

#获取图像类型
print(img.dtype)

　　结果如下：

(615, 327, 3)

603315   # 603315=615*327*3

uint8

　　注意1：如果图像是灰度图，返回值仅有行数和列数，所以通过检查这个返回值就可以知道加载的是灰度图还是彩色图。img.size可以返回图像的像素数目。

　　注意2：在debug时， img.dtype 非常重要，因为在OpenCV Python代码中经常出现数据类型的不一致。

8，生成指定大小的空图像

　　生成指定大小的空图形，方便我们后续填充，空图形是黑色的图（因为指定的是0）。

import cv2
import numpy as np

img = cv2.imread("1.jpg")
imgZero = np.zeros(img.shape, np.uint8)

imgFix = np.zeros((300, 500, 3), np.uint8)
# imgFix = np.zeros((300,500),np.uint8)

cv2.imshow("img", img)
cv2.imshow("imgZero", imgZero)
cv2.imshow("imgFix", imgFix)
cv2.waitKey()

 　

9，访问和操作图像像素

　　OpenCV中图像矩阵的顺序是 B,G,R。可以直接通过坐标位置访问和操作图像像素。

import cv2
 
img = cv2.imread("01.jpg")
 
numb = img[50,100]
print(numb)
 
img[50,100] = (0,0,255)
cv2.imshow("img",img)
cv2.waitKey()

 　　分开访问图像某一通道像素值也非常方便（下面代码将图像变为白色，即255）：

import cv2
 
img = cv2.imread("01.jpg")
 
img[0:100,100:200,0] = 255
img[100:200,200:300,1] = 255
img[200:300,300:400,2] = 255
 
cv2.imshow("img",img)
cv2.waitKey()

 　　Python中，更改图像某一矩形区域的像素值也很方便。

import cv2
 
img = cv2.imread("01.jpg")
 
img[0:50,1:100] = (0,0,255)
 
cv2.imshow("img",img)
cv2.waitKey()

 　　注意：优化

　　首先我们需要读入一幅图像，然后根据像素的行和列的坐标获取它的像素值。对BGR图像而言，返回值为B，G，R的值，对灰度图像而言，会返回它的灰度值（亮度？ intensity）

import cv2
import numpy as np

img=cv2.imread('test.jpg')
px=img[100,100]
print(px)
blue=img[100,100,0]
print(blue)

# 我们可以使用类似的方式修改像素值
img[100,100]=[255,255,255]
print(img[100,100])
## [255 255 255]

　　注意1：Numpy 是经过优化了的进行快速矩阵运算的软件包，所以我们不推荐逐个获取像素值并修改，这样会很慢，能有矩阵运算就不要循环。

　　注意2：上面提到的方法被用来选取矩阵的一个区域，比如说 前 5行的后3列。对于获取每一个像素值，也许使用Numpy 的 array.item()  和 array.itemset()  会更好，但是返回是标量。如果你想获得所有 B，G，R的值，你需要使用 array.item() 分割他们。

　　获取像素值及其修改的更好的方法

import cv2
import numpy as np

img=cv2.imread('test.jpg')
print(img.item(10,10,2))
img.itemset((10,10,2),100)
print(img.item(10,10,2))
# 59
# 100

　　

10，图像颜色通道分离与合并

　　分离图像通道可以使用 cv2中 split函数，合并则可以使用 merge函数。

import cv2
 
img = cv2.imread("01.jpg")
 
b , g , r = cv2.split(img)
 
# b = cv2.split(img)[0]
# g = cv2.split(img)[1]
# r = cv2.split(img)[2]
 
merged = cv2.merge([b,g,r])
 
cv2.imshow("Blue",b)
cv2.imshow("Green",g)
cv2.imshow("Red",r)
 
cv2.imshow("Merged",merged)
cv2.waitKey()

 　　　有时候，我们需要对 BGR 三个通道分别进行操作，这时你就需要把BGR拆分成单个通道，有时你需要把独立通道的图片合成一个BGR图像。下面学习一下拆分及其合并图像通道的cv函数　　

　　代码如下：

# _*_coding:utf-8_*_
import cv2
import numpy as np


def split_image(img_path):
    img = cv2.imread(img_path)
    print(img.shape)  # (800, 800, 3)
    # b, g, r = cv2.split(img)
    b = img[:, :, 0]
    g = img[:, :, 1]
    r = img[:, :, 2]
    cv2.imshow('b', b)
    # cv2.imshow('g', g)
    # cv2.imshow('r', r)
    cv2.waitKey(0)
    cv2.destroyAllWindows()


def merge_image(img_path):
    img = cv2.imread(img_path)
    b, g, r = cv2.split(img)
    img = cv2.merge([b, g, r])
    cv2.imshow('merge', img)
    cv2.waitKey(0)
    cv2.destroyAllWindows()


if __name__ == '__main__':
    img_path = 'durant.jpg'
    split_image(img_path)
    # merge_image(img_path)

　　注意：这里拆分写了两个方法，为什么呢？就是因为 cv2.split()是一个比较耗时的操作，只有真正需要时才用它，能用Numpy索引就尽量使用索引。

　　原图：

 　　B，G，R 三种通道的图片：

　　合并后的图片

 　　假设，我们想是所有像素的红色通道值都为0，我们不必先拆分再赋值，我们可以直接使用 Numpy 索引，这样会更快：

def assign_image(img_path):
    img = cv2.imread(img_path)
    img[:, :, 1] = 0
    cv2.imshow('assign', img)
    cv2.waitKey(0)
    cv2.destroyAllWindows()


if __name__ == '__main__':
    img_path = 'durant.jpg'
    assign_image(img_path)

　　结果如下：

11，在图像上输出文字

使用putText函数在图片上输出文字，函数原型：

putText(img, text, org, fontFace, fontScale, color, thickness=None, lineType=None, bottomLeftOrigin=None)

 　　参数意思：

1. img： 图像
2. text：要输出的文本
3. org： 文字的起点坐标
4. fontFace： 字体
5. fontScale： 字体大小
6. color： 字体颜色
7. thickness： 字图加粗

　　　代码如下：

import cv2

img = cv2.imread("durant.jpg")

cv2.putText(img, "durant is my favorite super star", (100, 100), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255))

cv2.imshow("img", img)
cv2.waitKey()

 　　图如下：

12， 图像缩放

　　cv2.resize()函数是来调整图片的大小，改变图片尺寸。

　　注意：CV2是BGR，而我们读取的图片是RGB，所以要注意一下，变换的时候注意对应。

　　其函数原型如下：

def resize(src, dsize, dst=None, fx=None, fy=None, interpolation=None)

　　对应的各个参数意思：

　　src：输入，原图像，即待改变大小的图像；

　　dsize：输出图像的大小。如果这个参数不为0，那么就代表将原图像缩放到这个Size(width，height)指定的大小；如果这个参数为0，那么原图像缩放之后的大小就要通过下面的公式来计算：

　　　　　　　　　　　　　　dsize = Size(round(fx*src.cols), round(fy*src.rows))

其中，fx和fy就是下面要说的两个参数，是图像width方向和height方向的缩放比例。

　　fx：width方向的缩放比例，如果它是0，那么它就会按照(double)dsize.width/src.cols来计算；

　　fy：height方向的缩放比例，如果它是0，那么它就会按照(double)dsize.height/src.rows来计算；

　　interpolation：这个是指定插值的方式，图像缩放之后，肯定像素要进行重新计算的，就靠这个参数来指定重新计算像素的方式，有以下几种：

• INTER_NEAREST                 - 最邻近插值
• INTER_LINEAR                     - 双线性插值，如果最后一个参数你不指定，默认使用这种方法
• INTER_AREA                         -  使用像素区域关系进行重采样    resampling using pixel area relation. It may be a preferred method for image decimation, as it gives moire’-free results. But when the image is zoomed, it is similar to the INTER_NEAREST method.
• INTER_CUBIC                      - 4x4像素邻域内的双立方插值
• INTER_LANCZOS4             - 8x8像素邻域内的Lanczos插值

　　对于插值方法，正常情况下使用默认的双线性插值法就够了。几种常用方法的效率为：

最邻近插值>双线性插值>双立方插值>Lanczos插值

　　但是效率和效果是反比的，所以根据自己的情况酌情使用。

　　注意：输出的尺寸格式为（宽，高）

　　示例：

# _*_coding:utf-8_*_
import cv2

image = cv2.imread('TestData\arial_qz8Shv_10.png')
# 对图片进行灰度化，注意这里变换！！
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

crop_img = cv2.resize(gray, (224, 224), interpolation=cv2.INTER_LANCZOS4)

　　对图像缩放，做一个完整的示例：

import cv2
import os
import numpy as np
import matplotlib.pyplot as plt


img = cv2.imread("cat.jpg")
# resize的插值方法：正常情况下使用默认的双线性插值法
res_img = cv2.resize(img, (200, 100))
res_fx = cv2.resize(img, (0, 0), fx=0.5, fy=1)
res_fy = cv2.resize(img, (0, 0), fx=1, fy=0.5)
print('origin image shape is ',img.shape)
print('resize 200*100 image shape is ',res_img.shape)
print('resize  0.5:1 shape is ',res_fx.shape)
print('resize  1:0.5  image shape is ',res_fy.shape)
'''
origin image shape is  (414, 500, 3)
resize 200*100 image shape is  (100, 200, 3)
resize  0.5:1 shape is  (414, 250, 3)
resize  1:0.5  image shape is  (207, 500, 3)
'''

# 标题
title = ['Origin Image', 'resize200*100', 'resize_fx/2', 'resize_fy/2']
# 对应的图像
image = [img, res_img, res_fx, res_fy]

for i in range(len(image)):
    plt.subplot(2, 2, i+1), plt.imshow(image[i])
    plt.title(title[i])
    plt.xticks([]), plt.yticks([])
plt.show()

 　　效果图如下：

　　

13   cv2.cvtColor()函数用法介绍

　　在日常生活中，我们看到的大多数彩色图像都是RGB类型，但是在图像处理过程中，常常需要用到灰度图像、二值图像、HSV、HSI等颜色，OpenCV提供了cvtColor()函数实现这些功能。其函数原型如下所示：

cvtColor(src, code, dst=None, dstCn=None)

　　变量含义：

• src表示输入图像，需要进行颜色空间变换的原图像
• dst表示输出图像，其大小和深度与src一致
• code表示转换的代码或标识
• dstCn表示目标图像通道数，其值为0时，则有src和code决定

　　该函数的作用是将一个图像从一个颜色空间转换到另一个颜色空间，其中，RGB是指Red、Green和Blue，一副图像由这三个通道（channel）构成；Gray表示只有灰度值一个通道；HSV包含Hue（色调）、Saturation（饱和度）和Value（亮度）三个通道。在OpenCV中，常见的颜色空间转换标识包括CV_BGR2BGRA、CV_RGB2GRAY、CV_GRAY2RGB、CV_BGR2HSV、CV_BGR2XYZ、CV_BGR2HLS等。
　　下面代码对比了九种常见的颜色空间，包括BGR、RGB、GRAY、HSV、YCrCb、HLS、XYZ、LAB和YUV，并循环显示处理后的图像。

#encoding:utf-8
import cv2  
import numpy as np  
import matplotlib.pyplot as plt

#读取原始图像
img_BGR = cv2.imread('durant.jpg')

#BGR转换为RGB
img_RGB = cv2.cvtColor(img_BGR, cv2.COLOR_BGR2RGB)

#灰度化处理
img_GRAY = cv2.cvtColor(img_BGR, cv2.COLOR_BGR2GRAY)

#BGR转HSV
img_HSV = cv2.cvtColor(img_BGR, cv2.COLOR_BGR2HSV)

#BGR转YCrCb
img_YCrCb = cv2.cvtColor(img_BGR, cv2.COLOR_BGR2YCrCb)

#BGR转HLS
img_HLS = cv2.cvtColor(img_BGR, cv2.COLOR_BGR2HLS)

#BGR转XYZ
img_XYZ = cv2.cvtColor(img_BGR, cv2.COLOR_BGR2XYZ)

#BGR转LAB
img_LAB = cv2.cvtColor(img_BGR, cv2.COLOR_BGR2LAB)

#BGR转YUV
img_YUV = cv2.cvtColor(img_BGR, cv2.COLOR_BGR2YUV)

#调用matplotlib显示处理结果
titles = ['BGR', 'RGB', 'GRAY', 'HSV', 'YCrCb', 'HLS', 'XYZ', 'LAB', 'YUV']  
images = [img_BGR, img_RGB, img_GRAY, img_HSV, img_YCrCb,
          img_HLS, img_XYZ, img_LAB, img_YUV]  
for i in xrange(9):  
   plt.subplot(3, 3, i+1), plt.imshow(images[i], 'gray')  
   plt.title(titles[i])  
   plt.xticks([]),plt.yticks([])  
plt.show()

　　效果图如下：

　　如果想查看参数的全部类型，请执行以下程序便可查阅，总共有274种空间转换类型：

import cv2
flags = [i for i in dir(cv2) if i.startswith('COLOR_')]
print(flags)

13.1， BGR2YUV

　　（参考地址：https://zhuanlan.zhihu.com/p/98622289）

　　OpenCV BGR 图转 YUV图的的C++源码如下：

// file name: convert.cpp
#include <opencv2/opencv.hpp>

// BGR 转 YUV
void BGR2YUV(const cv::Mat bgrImg, cv::Mat &y, cv::Mat &u, cv::Mat &v) {
    cv::Mat out;
    cv::cvtColor(bgrImg, out, cv::COLOR_BGR2YUV);
bgr
    cv::bgr channel[3];
    cv::split(out, channel);

    y = channel[0];
    u = channel[1];
    v = channel[2];
}

// YUV 转 BGR
void YUV2BGR(const cv::Mat y, const cv::Mat u, const cv::Mat v, cv::Mat& bgrImg) {
    std::vector<cv::Mat> inChannels;
    inChannels.push_back(y);
    inChannels.push_back(u);
    inChannels.push_back(v);

    // 合并3个单独的 channel 进一个矩阵
    cv::Mat yuvImg;
    cv::merge(inChannels, yuvImg);

    cv::cvtColor(yuvImg, bgrImg, cv::COLOR_YUV2BGR);
}

// 使用例子
int main() {
    cv::Mat origImg = cv::imread("test.png");

    cv::Mat y, u, v;
    BGR2YUV(origImg, y, u, v);

    cv::Mat bgrImg;
    YUV2BGR(y, u, v, bgrImg);

    cv::imshow("origImg", origImg);
    cv::imshow("Y channel", y);
    cv::imshow("U channel", u);
    cv::imshow("V channel", v);
    cv::imshow("converted bgrImg", bgrImg);
    cv::waitKey(0);

    return 0;
}

 　　在python中测试如下：

import cv2
import matplotlib.pyplot as plt


def bgr2yuv(img):
    yuv_img = cv2.cvtColor(img, cv2.COLOR_BGR2YUV)
    y, u, v = cv2.split(yuv_img)

    return y, u, v


def yuv2bgr(y, u, v):
    yuv_img = cv2.merge([y, u, v])
    bgr_img = cv2.cvtColor(yuv_img, cv2.COLOR_YUV2BGR)

    return bgr_img


def main():
    orig_img = cv2.imread('durant.jpg')
    gray = cv2.cvtColor(orig_img, cv2.COLOR_BGR2GRAY)
    y, u, v = bgr2yuv(orig_img)

    bgr_img = yuv2bgr(y, u, v)

    titles = ['orig_img', 'gray', 'Y channel','U channel','V channel','bgr_img']
    images = [orig_img, gray, y, u, v, bgr_img]
    for i in range(len(titles)):
        plt.subplot(2, 3, i+1)
        plt.imshow(images[i])
        plt.title(titles[i])
        plt.xticks([]), plt.yticks([])
    plt.show()

if __name__ == '__main__':
    main()

 　　图如下：

 下面区分一下YUV和YCbCr，YUV色彩模型来源于RGB模型，该模型的特点是将亮度和色度分离开，从而适合于图像处理领域。
应用：模拟领域
Y'= 0.299*R' + 0.587*G' + 0.114*B'
U'= -0.147*R' - 0.289*G' + 0.436*B' = 0.492*(B'- Y')
V'= 0.615*R' - 0.515*G' - 0.100*B' = 0.877*(R'- Y')
R' = Y' + 1.140*V'
G' = Y' - 0.394*U' - 0.581*V'
B' = Y' + 2.032*U'

YCbCr模型来源于YUV模型。YCbCr是 YUV 颜色空间的偏移版本，应用：数字视频，ITU-R BT.601建议
Y’ = 0.257*R' + 0.504*G' + 0.098*B' + 16
Cb' = -0.148*R' - 0.291*G' + 0.439*B' + 128
Cr' = 0.439*R' - 0.368*G' - 0.071*B' + 128
R' = 1.164*(Y’-16) + 1.596*(Cr'-128)
G' = 1.164*(Y’-16) - 0.813*(Cr'-128) - 0.392*(Cb'-128)
B' = 1.164*(Y’-16) + 2.017*(Cb'-128)

参考文献：https://blog.csdn.net/woainishifu/article/details/53260546

https://blog.csdn.net/eastmount/article/details/82177300

https://www.cnblogs.com/Undo-self-blog/p/8434906.html

https://www.cnblogs.com/zlel/p/9267629.html

视频读取：https://opencv-python-tutroals.readthedocs.io/en/latest/py_tutorials/py_gui/py_video_display/py_video_display.html

https://blog.csdn.net/qq_25436597/article/details/79621833

https://zhuanlan.zhihu.com/p/44255577

OpenCV中的rgb2Yuv转换公式问题：https://bbs.csdn.net/topics/390713769