目录
13、cv2.inRange(hsv, lower_hsv, upper_hsv)
整理不易，点个赞加个关注吧！
cv2.imread(filename, flags) ：读取加载图片
cv2.imshow(winname, mat) ： 显示图片
cv2.waitKey() ： 等待图片的关闭
cv2.imwrite(filename, img) ： 保存图片
import cv2
# 读取图片，第二个参数为False时，显示为灰度图像，True为原图
img = cv2.imread(filename="cat.jpg", flags=False)
# 显示图片，第一个参数为图片的标题
cv2.imshow(winname="image title", mat=img)
# 等待图片的关闭，不写这句图片会一闪而过
cv2.waitKey()
# 保存图片
cv2.imwrite("Grey_img.jpg", img)cv2.waitKey() ： 等待图片的关闭
可设置参数，为多少毫秒后自动关闭
import cv2 for file in filelist: image = cv2.imread(file, flags=False) cv2.imshow(winname="11",mat=image) # 每隔1000ms显示一张图片 cv2.waitKey(1000)
cv2.destroyAllWindows()：销毁所有窗口
winname作为窗口的唯一标识，如果想使用指定窗口显示目标图像，需要让cv2.imshow(winname)中的winname与窗口的winname需要保持一致。
窗口创建时可以添加的属性：
- cv2.WINDOW_NORMAL：窗口大小可以改变（同cv2.WINDOW_GUI_NORMAL）
- cv2.WINDOW_AUTOSIZE：窗口大小不能改变
- cv2.WINDOW_FREERATIO：窗口大小自适应比例
- cv2.WINDOW_KEEPRATIO：窗口大小保持比例
- cv2.WINDOW_GUI_EXPANDED：显示色彩变成暗色
cv2.WINDOW_FULLSCREEN：全屏显示
cv2.WINDOW_OPENGL：支持OpenGL的窗口
img = cv2.imread("cat.jpg")
# 第二个参数为窗口属性
cv2.namedWindow(winname="title", cv2.WINDOW_NORMAL)
# 如果图片显示想使用上面的窗口，必须保证winname一致
cv2.imshow(winname="title", img)
cv2.waitKey()
# 销毁
cv2.destroyWindow("title")
# 销毁所有窗口：cv2.destroyAllWindows()img.shape：打印图片的高、宽和通道数（当图片为灰度图像时，颜色通道数为1，不显示）
img.size：打印图片的像素数目
img.dtype：打印图片的格式
注意：这几个是图片的属性，并不是调用的函数，所以后面没有‘ () ’。
import cv2
img = cv2.imread("cat.jpg")
imgGrey = cv2.imread("cat.jpg", False)
print(img.shape)
print(imgGrey.shape)
#输出：
#(280, 300, 3)
#(280, 300)
print(img.size)
print(img.dtype)
#输出：
# 252000
# uint8
- 一个图片img，它的某个像素点可以用 img[x, y, c] 表示（x，y为坐标，c为通道数）
- 同理，这个图片的某个矩形区域可以表示为：img[x1:x2, y1:y2, c]（相当于截下一块矩形，左上角坐标为（x1, y1），右下角坐标为（x2, y2））
- 其中 c 一般取值为0，1，2（BGR）代表第几个颜色通道，可以省略不写 img[x, y] 代表所有通道。
实例一：生成一个大小为（300，400）颜色通道为3的红色图片
import cv2
import numpy as np
imgzero = np.zeros(shape=(300, 400, 3), dtype=np.uint8)
imgzero[:, :] = (0, 0, 255) # (B, G, R)
cv2.imshow("imgzero",imgzero)
cv2.waitKey()实例二：从一张图片上截取一个矩形区域
import cv2
import numpy as np
img = cv2.imread("cat.jpg")
# 输出（50，100）上的像素值
num = img[50, 100]
print(num)
# 截取部分区域并显示
region = img[50:100, 50:100]
cv2.imshow("img", region)
cv2.waitKey()
cv2.split(m)：将图片m分离为三个颜色通道
cv2.merge(mv)：将三个颜色通道合并为一张图片
import cv2
img = cv2.imread("cat.jpg")
b, g, r = cv2.split(img)
merge = cv2.merge([b, g, r])cv2.add(src1, src2)：普通相加
cv2.addWeighted(src1, alpha, src2, w2，beta)：带权相加
src1：第一张图片
alpha：第一张图片权重
src2：第二张图片
beta：第二张图片权重
gamma：图1与图2作和后添加的数值。
dst：输出图片
import cv2
img1 = cv2.imread("cat.jpg")
img2 = cv2.imread("dog.jpg")
add1 = cv2.add(img1,img2)
add2 = cv2.addWeighted(img1, 0.5, img2, 0.5, 3)
cv2.imshow("add1", add1)
cv2.imshow("add2", add2)
cv2.waitKey()cv2.addWeighted(src1, alpha, src2, w2，beta)可以改变图像的对比度和亮度。
通过改变alpha的值改变对比度，beta控制亮度。
# 改变对比度和亮度 def contrast_brightness_demo(img, c, b): h, w, ch = img.shape blank = np.zeros([h, w, ch], img.dtype) dst = cv2.addWeighted(img, c, blank, 1-c , b) cv2.imshow("contrast_brightness_demo", dst)
对两张相同大小的图像进行加减乘除，cv2.imread()读取的图像，其实相当于获取了一个多维数组，每一个像素值就是数组坐标下的值。那么像素的基本运算就相当于是数组之间的运算。
def add_demo(m1, m2):
dst = cv2.add(m1, m2)
cv2.imshow("add", dst)
def subtract_demo(m1, m2):
dst = cv2.subtract(m1, m2)
cv2.imshow("subtract", dst)
def multiply_demo(m1, m2):
dst = cv2.multiply(m1, m2)
cv2.imshow("multiply", dst)
def divide_demo(m1, m2):
dst = cv2.divide(m1, m2)
cv2.imshow("divide", dst)def demo(img):
# 均值
M1 = cv2.mean(img)
print(M1)
# 均值和方差
M1, dev1 = cv2.meanStdDev(img)
print(M1)
print(dev1)其中非运算就是对图像进行颜色反转
def logic_demo(m1, m2):
dst = cv2.bitwise_and(m1, m2)
cv2.imshow("bitwise_and", dst)
dst = cv2.bitwise_or(m1, m2)
cv2.imshow("bitwise_or", dst)
dst = cv2.bitwise_not(m1, m2)
cv2.imshow("bitwise_not", dst)
dst = cv2.bitwise_xor(m1, m2)
cv2.imshow("bitwise_xor", dst)时间(s) = 总次数 / 一秒内重复的次数
时间(ms) = 1000 *总次数 / 一秒内重复的次数
t1 = cv2.getTickCount()
function() # 待测试的函数
t2 = cv2.getTickCount()
time = (t2 - t1) / cv2.getTickFrequency()
print("time : %s ms" % (time * 1000))
Windows自带的画图中有一个工具（油桶形状的），看下右图中，白色的背景，你用黑色画一个菱形，然后用这个油桶工具点一下菱形内部，就可以把菱形内部染成红色。
你在菱形内部用鼠标点击的那一下，点在了一个像素点上，我们知道这个像素点是白色的，那么油桶在染色的时候，就在这个原像素点的周围寻找相同的像素（白色像素），然后把和原像素点相同的像素都染成红色。（就像是从原像素点360度无死角发散寻找）
那么它什么时候结束染色呢？当它遇到和原像素点的像素不同的点时，就会中止这个方向的寻找。（也就是遇到了我们画的那个黑色边框）同理在OpenCV里，提供了这样的函数
def floodFill( image, 原图像
mask, 掩码，单通道8位图像，比image的高度多2个像素，宽度多2个像素。
seedPoint, 起始点（原像素点，相当于鼠标点击的那个像素点）
newVal, 在重绘区域像素的新值（RBG值，相当于上图指定的红色）
loDiff=None, 像素值的下限差值（最多比原像素点低多少）
upDiff=None, 像素值的上限差值（最多比原像素点高多少）
flags=None)
- FLOODFILL_FIXED_RANGE – 改变图像，泛洪填充
- FLOODFILL_MASK_ONLY – 不改变图像，只填充遮罩层本身，忽略新的颜色值参数
def fill_color_demo(): copyImg = img.copy() h, w = img.shape[:2] mask = np.zeros([h+2, w+2], np.uint8) cv2.floodFill(copyImg, mask, (100, 200), (0, 255, 0), (100, 100, 100), (50, 50, 50), cv2.FLOODFILL_FIXED_RANGE) cv2.imshow("fill_color_demo", copyImg) def fill_binary_demo(): img2 = np.zeros([400, 400, 3], np.uint8) img2[100:300, 100:300, :] = 255 mask = np.ones([402, 402], np.uint8) mask[101:301, 101:301] = 0 cv2.floodFill(img2, mask, (200, 200), (0, 0, 255), cv2.FLOODFILL_MASK_ONLY) cv2.imshow("fill_binary_demo", img2)
原型：cvtColor(src,code,dst=None,dstCn=None)
作用：将一幅图像从一个色彩空间转换到另一个色彩空间
参数：code，转换的色彩空间
# 色彩空间转换
def color_space_demo(img):
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
cv2.imshow("gray", gray)
hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
cv2.imshow("hsv", hsv)
yuv = cv2.cvtColor(img, cv2.COLOR_BGR2YUV)
cv2.imshow("yuv", yuv)
ycrcb = cv2.cvtColor(img, cv2.COLOR_BGR2YCrCb)
cv2.imshow("ycrcb", ycrcb)
利用cv2.inRange函数设阈值，这里注意用的颜色空间是hsv。
HSV：HSV颜色空间是孟塞尔彩色空间的简化形式，是一种基于感知的颜色模型。它将彩色信号分为3种属性：色调（Hue,H），饱和度（Saturation,S），亮度（Value,V）。色调表示从一个物体反射过来的或透过物体的光波长，也就是说，色调是由颜色的名称来辨别的，如红、黄、蓝；亮度是颜色的明暗程度；饱和度是颜色的深浅，如深红、浅红。
HSV颜色空间反映了人观察色彩的方式，具有两个显著的特点：
- 亮度分量与图像的彩色信息无关
- “色调”和“饱和度”分量与人感受颜色的方式是紧密相连的
可以根据右表来确定lower_hsv, upper_hsv的取值。
# 颜色追踪
def extrace_object_demo():
capture = cv2.VideoCapture("testvideo.mp4")
while(True):
ret, frame = capture.read()
if ret == False:
break
hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
lower_hsv = np.array([0, 0, 0])
upper_hsv = np.array([180, 255, 46])
mask = cv2.inRange(hsv, lower_hsv, upper_hsv)
dst = cv2.bitwise_and(frame, frame, mask=mask)
cv2.imshow("video", frame)
cv2.imshow("video", dst)
c = cv2.waitKey(40)
if c == 27:
break附一篇博客：真正搞懂均值模糊、中值模糊、高斯模糊、双边模糊
模糊操作基本原理：
- 基于离散卷积
- 定义好每个卷积核
- 不同卷积核得到不同的卷积效果
- 模糊是卷积的一种表象
原型：blur(src,ksize,dst=None,anchor=None,borderType=None)
作用：对图像进行算术平均值模糊
参数：ksize，卷积核的大小。dst，若填入dst，则将图像写入到dst矩阵。
原型：mediaBlur(src,ksize,dst=None)
作用：对图像进行中值模糊
def blur_demo(img):
# 均值模糊
dst = cv2.blur(img, (5, 5)) # 5*5的卷积核
cv2.imshow("dst", dst)
# 中值模糊，可以去噪音
dst = cv2.medianBlur(img, 5)
# 自定义
kernel = np.ones([5, 5], np.float32) / 25
dst = cv2.filter2D(img, -1, kernel)
# 锐化（特定的卷积核）
kernel = np.array([[0, -1, 0], [-1, 5, -1], [0, -1, 0]], np.float32)
dst = cv2.filter2D(img, -1, kernel)原型：GaussianBlur(src, ksize, sigmaX, dst=None, sigmaY=None, borderType=None)
作用：对图像进行高斯模糊
参数：sigmaX，X方向上的方差，一般设为0让系统自动计算。
def Gauss_blur():
img = np.array([[14, 15, 16], [24, 25, 26], [34, 35, 36]], dtype=np.float32)
blur = cv2.GaussianBlur(img, (3, 3), 1.5)
print(blur)
Gauss_blur()
# output:
[[20.771631 21.156027 21.540426]
[24.615604 25. 25.3844 ]
[28.45958 28.843975 29.228374]]def bilateralFilter_demo(img):
dst = cv2.bilateralFilter(img, 0, 100, 150)
cv2.imshow("bilateralFilter", dst)
bi_demo(img)二值化就是把图像的像素转变为0或者255，只有这两个像素值。
推荐博客：
原型：threshold(src,thresh,maxval,type,dst=None)
作用：将图像的每个像素点进行二值化
参数：thresh，阈值（最小值）。maxval，二值化的最大取值。
type，二值化类型，一般设为0，也可以取以下的值：
返回值：计算过后的阈值值和二值化后的图像（如果dst是None）
# 全局二值化
def threshold_demo():
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
ret, binary = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU)
cv2.ADAPTIVE
print("threshold value : %s\n" % ret)
cv2.imshow("binary_global", binary)
threshold_demo()函数：adaptiveThreshold(src, maxValue, adaptiveMethod, thresholdType, blockSize, C, dst=None)
参数：
- maxValue：阈值的最大值；
- adaptiveMethod：指定自适应阈值算法。可选择ADAPTIVE_THRESH_MEAN_C 或 ADAPTIVE_THRESH_GAUSSIAN_C两种。（自适应阈值化计算大概过程是为每一个象素点单独计算的阈值，即每个像素点的阈值都是不同的，就是将该像素点周围blockSize*blockSize区域内的像素加权平均，然后减去一个常数C，从而得到该点的阈值。）。
ADAPTIVE_THRESH_MEAN_C：为局部邻域块的平均值。该算法是先求出块中的均值，再减去常数C。
ADAPTIVE_THRESH_GAUSSIAN_C：为局部邻域块的高斯加权和。该算法是在区域中（x，y）周围的像素根 据高斯函数按照他们离中心点的距离进行加权计算， 再减去常数C。
- thresholdType：指定阈值类型。可选择THRESH_BINARY或者THRESH_BINARY_INV两种。（即二进制阈值或反二进制阈值）。
- blockSize：表示邻域块大小，用来计算区域阈值，奇数，一般选择为3、5、7......等。
- C：表示与算法有关的参数，它是一个从均值或加权均值提取的常数，可以是负数。（具体见下面的解释）。
# 局部二值化
def local_threshold_demo():
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
binary = cv2.adaptiveThreshold(gray, 255, cv2.ADAPTIVE_THRESH_MEAN_C, cv2.THRESH_BINARY, 25, 10)
#print("threshold value : %s\n" % ret)
cv2.imshow("binary_local", binary)
模板匹配，就是在整个图像区域发现与给定子图像匹配的小块区域，需要模板图像T和待检测图像-源图像S；
工作方法：在待检测的图像上，从左到右，从上倒下计算模板图像与重叠子图像匹配度，匹配度越大，两者相同的可能性越大。
函数：matchTemplate(image, templ, method, result=None, mask=None)
参数：
- image：源图像S；
- templ：模板图像T，一般是源图像S中的一小块；
- method：模板匹配算法（cv.TM_SQDIFF_NORMED最小时最相似，其他最大时最相似）
import cv2
import numpy as np
from matplotlib import pyplot as plt
def template_demo():
tpl = cv2.imread("sample.jpg")
target = cv2.imread("target.jpg")
cv2.imshow("tpl", tpl)
cv2.imshow("target", target)
methods = [cv2.TM_SQDIFF_NORMED, cv2.TM_CCORR_NORMED, cv2.TM_CCOEFF_NORMED] # 三种模板匹配方法
th, tw = tpl.shape[:2]
for md in methods:
print(md)
result = cv2.matchTemplate(target, tpl, md) # 得到匹配结果
min_val, max_val, min_loc, max_loc = cv2.minMaxLoc(result)
if md == cv2.TM_SQDIFF_NORMED: # cv.TM_SQDIFF_NORMED最小时最相似，其他最大时最相似
tl = min_loc
else:
tl = max_loc
br = (tl[0] + tw, tl[1] + th)
cv2.rectangle(target, tl, br, (0, 0, 255), 2) # tl为左上角坐标，br为右下角坐标，从而画出矩形
cv2.imshow("match-"+np.str(md), target)
template_demo()
cv2.waitKey(0)
cv2.destroyAllWindows()
图像缩小（先高斯模糊，再降采样，需要一次次重复，不能一次到底）
图像扩大（先扩大，再卷积或者使用拉普拉斯金字塔）
推荐博客：OpenCV---图像金字塔原理
import cv2
import numpy as np
# 图像金字塔和拉普拉斯金字塔(L1 = g1 - expand(g2))：reduce：高斯模糊+降采样，expand：扩大+卷积
# PyrDown降采样，PyrUp还原
def pyramid_demo(image):
level = 4
temp = image.copy()
pyramid_images = []
for i in range(level):
dst = cv2.pyrDown(temp)
pyramid_images.append(dst)
cv2.imshow("pyramid_down_"+str(i+1), dst)
temp = dst.copy()
return pyramid_images
def laplace_demo(image): # 注意：图片必须是满足2^n这种分辨率
pyramid_images = pyramid_demo(image)
level = len(pyramid_images)
for i in range(level-1, -1, -1):
if i-1 < 0:
expand = cv2.pyrUp(pyramid_images[i], dstsize=image.shape[:2])
lpls = cv2.subtract(image, expand)
cv2.imshow("laplace_demo"+str(i), lpls)
else:
expand = cv2.pyrUp(pyramid_images[i], dstsize=pyramid_images[i-1].shape[:2])
lpls = cv2.subtract(pyramid_images[i-1], expand)
cv2.imshow("laplace_demo"+str(i), lpls)
src = cv2.imread("img1.jpg") # 图像必须是2^n * 2^m的
cv2.imshow("demo", src)
#pyramid_demo(src)
laplace_demo(src)
cv2.waitKey(0)
cv2.destroyAllWindows()图像梯度其实就是对图像进行求导，图像也是一个函数（离散的），这里其实就是用特定的滤波器来进行卷积操作。
Sobel算子是高斯平滑和微分操作的结合体，所以他的抗噪声能力很好。他计算的是一阶导数，可以自己定义x方向或者y方向。
卷积因子：
原型： Sobel(src,ddepth,dx,dy,dst=None,ksize=None,scale=None,delta=None,borderType=None)
作用：对图像进行Sobel算子计算。检测出其边缘。
参数：dx，x方向上的导数阶数；dy，y方向上的导数阶数。
import cv2 as cv
import numpy as np
def sobel_demo(image):
grad_x = cv2.Sobel(image, cv2.CV_32F, 1, 0) # 采用Scharr边缘更突出
grad_y = cv2.Sobel(image, cv2.CV_32F, 0, 1)
gradx = cv2.convertScaleAbs(grad_x) # 由于算完的图像有正有负，所以对其取绝对值
grady = cv2.convertScaleAbs(grad_y)
# 计算两个图像的权值和，dst = src1*alpha + src2*beta + gamma
gradxy = cv2.addWeighted(gradx, 0.5, grady, 0.5, 0)
cv2.imshow("gradx", gradx)
cv2.imshow("grady", grady)
cv2.imshow("gradient", gradxy)
src = cv.imread("../images/lena.jpg")
cv.imshow("lena",src)
sobel_demo(src)
cv.waitKey(0)
cv.destroyAllWindows()
- 原型：Scharr(src, ddepth, dx, dy, dst=None, scale=None, delta=None, borderType=None, /)
是Sobel的优化版，在使用3*3卷积核时这个优于Sobel，其它尺寸的卷积核用Sobel就行。
import cv2 as cv
import numpy as np
def scharr_demo(image):
grad_x = cv2.Scharr(image, cv2.CV_32F, 1, 0) # 采用Scharr边缘更突出
grad_y = cv2.Scharr(image, cv2.CV_32F, 0, 1)
gradx = cv2.convertScaleAbs(grad_x) # 由于算完的图像有正有负，所以对其取绝对值
grady = cv2.convertScaleAbs(grad_y)
# 计算两个图像的权值和，dst = src1*alpha + src2*beta + gamma
gradxy = cv2.addWeighted(gradx, 0.5, grady, 0.5, 0)
cv2.imshow("gradx", gradx)
cv2.imshow("grady", grady)
cv2.imshow("gradient", gradxy)
src = cv.imread("../images/lena.jpg")
cv.imshow("lena",src)
scharr_demo(src)
cv.waitKey(0)
cv.destroyAllWindows()
Laplacian算子是个二阶微分。下面两个卷积核，靠上的是4邻域的，靠下的是8邻域的。函数默认为8邻域。
原型:Laplacian(src,ddepth,dst=None,ksize=None,scale=None,delta=None,borderType=None)
作用：检测图像边缘。
参数：ddepth，图像位深度，对于灰度图来说，其值为：cv2.CV_8U。ksize，希望使用的卷积核的大小。scale，是缩放导数的比例常数。
import cv2 as cv
import numpy as np
def laplace_demo(image): # 二阶导数，边缘更细
dst = cv2.Laplacian(image,cv2.CV_32F)
lpls = cv2.convertScaleAbs(dst)
cv2.imshow("laplace_demo", lpls)
src = cv.imread("../images/lena.jpg")
cv.imshow("lena",src)
laplace_demo(src)
cv.waitKey(0)
cv.destroyAllWindows()
原型：VideoCapture(*args,**kwargs)
作用：初始化VideoCapture类并利用构造函数读入该视频的当前帧。
参数：一般仅填入一个，即文件名。如果填入整数，则打开对应的捕获设备ID。若为0，则打开默认摄像头。
原型：VideoCapture.get(self,propld)
作用：返回该视频的propld所指定的属性
参数：propld，为需要读取的视频属性参数位，一般以cv2.CAP_PROP_ 开头
| 参数名称 |
作用 |
| CV_CAP_PROP_POS_MSEC |
当前视频文件的时间位置（返回毫秒）或视频捕获时间戳 |
| CV_CAP_PROP_POS_FRAMES |
从0开始的解码/捕获时间帧 |
| CV_CAP_PROP_POS_AVI_RATIO |
返回视频文件的相关位置：0，视频开始。1，视频结束 |
| CV_CAP_PROP_FRAME_WIDTH |
视频流中的帧宽 |
| CV_CAP_PROP_FRAME_HEIGHT |
视频流中的帧高 |
| CV_CAP_PROP_FPS |
帧率 |
| CV_CAP_PROP_FOURCC |
返回解码方式中的四字符 |
| CV_CAP_PROP_FRAME_COUNT |
视频文件的总帧数 |
| CV_CAP_PROP_FORMAT |
由retrieve()函数返回的矩阵对象的格式 |
| CV_CAP_PROP_MODE |
用于预测当前捕获模式的后端专用值 |
| CV_CAP_PROP_BRIGHTNESS |
图像的亮度（仅用于摄像头） |
| CV_CAP_PROP_CONTRAST |
图像的对比度（仅用于摄像头） |
| CV_CAP_PROP_SATURATION |
图像的饱和度（仅用于摄像头） |
| CV_CAP_PROP_HUE |
图像的色调（仅用于摄像头） |
| CV_CAP_PROP_GAIN |
图像增益（仅用于摄像头） |
| CV_CAP_PROP_EXPOSURE |
曝光度（仅用于摄像头） |
| CV_CAP_PROP_CONVERT_RGB |
用于预测图像是否应该被转换为RGB的布尔位 |
| CV_CAP_PROP_WHITE_BALANCE |
白平衡（当前不支持） |
| CV_CAP_PROP_RECTIFICATION |
立体相机的纠正位 |
参数：无
作用：判断设备/文件是否读取成功，若成功，返回True
参数：无
作用：关闭文件/摄像头
参数：无
返回值：bool，numpy.array
作用：读取该文件/摄像头的下一帧，成功与否由bool返回值决定，返回的帧矩阵为第二个参数
原型：cv2.VideoWriter(*args,**kwargs)
参数：第一个，写入的视频文件名。第二个，由cv2.VideoWriter_fourcc返回的视频制式特定代码，通常有XVID，MPEG等。第三个，该视频的fps。第四个，一个tuple，为该视频的宽、高。
| 参数名称 |
解释 |
| CV_FOURCC(‘P’, ‘I’, ‘M’, ‘1’) |
MPEG-1 codec |
| CV_FOURCC(‘M’, ‘J’, ‘P’, ‘G’) |
motion-jpeg codec |
| CV_FOURCC(‘M’, ‘P’, ‘4’, ‘2’) |
MPEG-4.2 codec |
| CV_FOURCC(‘D’, ‘I’, ‘V’, ‘3’) |
MPEG-4.3 codec |
| CV_FOURCC(‘D’, ‘I’, ‘V’, ‘X’) |
MPEG-4 codec |
| CV_FOURCC(‘U’, ‘2’, ‘6’, ‘3’) |
H263 codec |
| CV_FOURCC(‘I’, ‘2’, ‘6’, ‘3’) |
H263I codec |
| CV_FOURCC(‘F’, ‘L’, ‘V’, ‘1’) |
FLV1 codec |
| CV_FOURCC(‘X’, ‘V’, ‘I’, ‘D’) |
MPEG-4 decode |
原型：VideoCapture.write(image)
作用：将当前帧内容写入视频文件
参数：image，写入的当前帧
参考博客：