OpenCV函数 - 技术栈

1，cv2.imread

cv2.imread:这个函数可以直接用cv2.imread('filename', cv2.IMREAD_GRAYSCALE)直接将图片以黑白图像输入，也可以通过cv2.imread(img, 0)来将图片以黑白图像输入。其实这两者是一样的，如下图所示，可以将特定的颜色通道用数字表示。如果直接用cv2.imread('filename')表示默认读入彩色图像.注意cv2.imread() 如果无法从指定文件读取图像，并不会报错，而是数返回一个空矩阵。

cv2.imread() 指定图片的存储路径和文件名，在 python3 中不支持中文和空格（但并不会报错）。必须使用中文时，可以使用 cv2.imdecode() 处理

2，img.resize()与cv2.resize()

img.resize()

img.resize()是PIL库中的函数，用于调整图像的大小。该函数接受一个元组作为参数，指定调整后的目标大小。调整后的图像可能会被拉伸或压缩以适应新的尺寸。

需要先通过Image.open('filename')来读入图片，并创建image对象，如下

python 复制代码

from PIL import Image
# 打开图片
img = Image.open("example.jpg")
# 将图片调整为指定大小
resized_img = img.resize((300, 200))
# 仅指定宽度，高度按比例调整
resized_img_width = img.resize((400, 0))
# 仅指定高度，宽度按比例调整
resized_img_height = img.resize((0, 300))
# 使用 Image.ANTIALIAS 参数，宽高比保持不变
resized_img_antialias = img.resize((400, 300), Image.ANTIALIAS)

cv2.resize()

在opencv中常用的函数

python 复制代码

import cv2
img = cv2.imread('1.jpg')
img = cv2.resize(img, (400,400))
img = cv2.resize(img, (0,0), fx=3, fy=1)#表示x方向扩大三倍，y方向不变

3，cv2.imshow

python 复制代码

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

cv2.imshow('filename', img) #第一个参数指打开后窗口要命名的名字，第二个参数是要打开的图片

也可以用cv2.imshow('filename', np.hstack(img1,img2))一个窗口显示多张图片

4， img.shape

python 复制代码

img = cv2.imread('1.jpg')
print(img.shape)#显示图像矩阵大小

5，img.size

python 复制代码

img = cv2.imread('1.jpg')
print(img.size)#显示图像像素点个数

6，img.dtype

python 复制代码

img = cv2.imread('1.jpg')
print(img.dtype)#显示图像数据类型

7，cv2.imwrite

python 复制代码

img = cv2.imread('1.jpg')
cv2.imwrite('2.jpg',img)#将图片img复制一份命名为2.jpg并保存在路径中

8，cv2.VideoCapture

读取视频，并创建对象

python 复制代码

video = cv2.VideoCapture('video.mp4')
video.isopend()#创建完对象后可以利用对象的方
               #isOpened()表示如果视频成功打开，则返回1，通常用于判断

9，video.read()

在上一步cv2.VideoCapture()创建video对象后，此步可以使用对象方法video.read()

此函数通常返回两个值，用两个变量接收

python 复制代码

open,frame = video.read()
#第一个参数为bool变量，如果返回True表示视频成功读入，返回False表示视频未读入

10，cv2.cvtColor

cv2.cvtColor 是它可以将图像从一个颜色空间转换到另一个颜色空间，比如从 BGR 转换到灰度、HSV、YCrCb 等。在 OpenCV 中，默认加载的图像颜色空间是 BGR（蓝绿红），而不是通常的 RGB（红绿蓝）。因此，在处理图像时，经常需要转换颜色空间。用于转换图像颜色空间的一个非常有用的函数。

python 复制代码

import cv2
image = cv2.imread('example.png')
# 使用cv2.COLOR_BGR2GRAY将图像转换为灰度图
gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

python 复制代码

#由BGR转换为RGB
rgb_image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

python 复制代码

#由BGR转换为HSV
#HSV（色调、饱和度、亮度）是一种更直观的颜色空间，它对于某些图像处理任务（如颜色分割、颜色追 #踪等）来说非常有用。将图像从 BGR 转换到 HSV 可以让你更容易地根据色调、饱和度和亮度来分析和处#理
hsv_image = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)

11，img[:,:,:]分割图像

img[0:200,0:200]：显示图像x从0到200，y从0到200的图像区域

img[:,:]:表示显示全部图像

img[0:200,0:200,0] :BGR索引分别为0,1,2，最后选择0表示选择的是B通道图像，但是会显示为黑白，利用这个可以只显示但颜色通道，如下

python 复制代码

cur_img[:,:,0]=0#按照B G R这个顺序，B的索引为0，G索引为1，R索引为2
cur_img[:,:,1]=0
cv_show('R',cur_img)

12，cv2.merge与cv2.split

python 复制代码

b,g,r = cv2.split(img)#分离颜色通道
img = cv2.merge((b,g,r))#合并颜色通道

13，cv2.copyMakeBorder

cv2.copyMakeBorder(img,top_size,bottom_size,left_size,right_size,borderType=cv2.BORDER_REPLICATE):img指要填充的图像，top_size,bottom_size,left_size,right_size指图像上下左右要填充的大小，Type指填充类型，类型如下所列出

python 复制代码

#指定上下左右要填充的值大小，如下
top_size,bottom_size,left_size,right_size = (50,50,50,50)
replicate = cv2.copyMakeBorder(img,top_size,bottom_size,left_size,right_size,borderType=cv2.BORDER_REPLICATE)

14，cv2.add与cv2.addWeight

cv2.add是将两个图像像素数据相加，超过255的值置为255。它与图像与图像直接相加(实际上就是矩阵相加)不同，直接相加超过255的部分会从0开始重新开始加

python 复制代码

#后面加的[:5,:,0]是指只看前5组数据，可以不加
cv2.add(img_cat,img_cat2)[:5,:,0]

cv2.addWeight 用于图像融合，数据权重计算

python 复制代码

res = cv2.addWeighted(img_cat , 0.4,img_dog, 0.6 ,0)#图像融合，0.4和0.6表示要融合图像的像素值比例，0表示偏置项(可以改变整体亮度)

15，cv2.threshold

设置图像阈值用于二值化

ret, dst = cv2.threshold(src, thresh, maxval, type):第一个参数src是输入图，只能输入单通道图，通常来说是灰度图，thresh是二值化阈值，maxval是像素最大值如果像素超过该值则赋值该值，type是二值化操作类型，共以下几种。ret 变量存储了使用的阈值

16，cv2.blur

用于均值滤波

cv2.blur(img, (3,3))：img是输入图像，(3,3)指以3*3为一个区域算均值。

17，cv2.boxFilter

方框滤波

方框滤波中，可以自由选择是否对均值滤波的结果进行归一化，即可以自由选择滤波结果是邻域像素值之和的平均值，还是邻域像素值之和。

python 复制代码

#第二个参数-1：Python中指定-1表示让它自动进行计算，他表示我们得到的结果和原始输入的颜色通道数在颜色通道上是一致的，通常情况下也就用-1
#第四个参数normalize=TRUE则和均值滤波一摸一样，如果等于False，则将3*3内的9个数据相加而不取均值，如果大于255.则这个像素点就取255.效果如下图
box = cv2.boxFilter(img,-1,(3,3),normalize=TRUE)

当normalize=True时，与均值滤波结果相同；

当normalize=False时，表示对加和后的结果不进行平均操作，大于255的使用255表示。

18，cv2.GaussianBlur

高斯滤波

高斯滤波(Gauss Filter)基于二维高斯核函数。用一个模板（或称卷积、掩模）扫描图像中的每一个像素，用模板确定的邻域内像素的加权平均灰度值去替代模板中心像素点的值。高斯滤波主要用来去除高斯噪声。

python 复制代码

aussian = cv2.GaussianBlur(img,(5,5),1)

19，cv2.medianBlur

中值滤波

中值滤波是一种非线性滤波器，以3*3大小的核为中值滤波核，则取9个像素的中值像素替换原像素。

python 复制代码

median = cv2.medianBlur(img,5)#5表示5*5

20，cv2.erode

对二值化图像进行操作

腐蚀操作

python 复制代码

img = cv2.imread('1.jpg')
#创建一个5*5，且全为1的二维数组
kernel = np.ones((5,5), np.unit8)
erosion = cv2.erode(img, kernel, iterations=1)#iterations为迭代顺序

21，cv2.dilate

对二值化图像进行操作

腐蚀操作逆操作

python 复制代码

kernel = np.ones((3,3),np.uint8)
dige_dilate = cv2.dilate(dige_erosion,kernel,iterations = 1)

22，cv2.morphologyEx

对二值化图像进行操作

开运算：先腐蚀后膨胀

python 复制代码

img = cv2.imread('1.png')
kernel = np.ones((5,5),np.uint8)
opening = cv2.morphologyEx(img, cv2.MORPH_OPEN, kernel)

闭运算：先膨胀后腐蚀

python 复制代码

img = cv2.imread('1.png')
kernel = np.ones((5,5),np.uint8)
closing = cv2.morphologyEx(img, cv2.MORPH_CLOSE, kernel)

梯度运算：膨胀-腐蚀

python 复制代码

gradient = cv2.morphologyEx(pie, cv2.MORPH_GRADIENT, kernel)

礼帽：开运算-开运算结果

python 复制代码

img = cv2.imread('dige.png')
tophat = cv2.morphologyEx(img, cv2.MORPH_TOPHAT, kernel)

黑帽：闭运算-原始输入

python 复制代码

img = cv2.imread('dige.png')
blackhat = cv2.morphologyEx(img, cv2.MORPH_BLACKHAT, kernel)

23， cv2.Sobel

用于图像梯度计算的Sobel算子

dst = cv2.Sobel(src,ddepth,dx,dy,ksize)

python 复制代码

img = cv2.imread('pie.png',cv2.IMREAD_GRAYSCALE)
sobelx = cv2.Sobel(img,cv2.CV_64F,1,0,ksize=3)
#cv2.CV_64F:算出的结果有正有负，opencv会默认把负值截断成0，
#而负值按道理应该取为绝对值，在未取绝对值之前，应该保留负数
#cv2.CV_64F可以保留负数
#dx指定为1，dy指定为0表示只算水平的

24，cv2.convertScaleAbs

绝对值函数

python 复制代码

img = cv2.imread('pie.png',cv2.IMREAD_GRAYSCALE)
sobelxy = cv2.Sobel(img,cv2.CV_64F,1,1,ksize=3)
sobelxy = cv2.convertScaleAbs(soblexy)#取绝对值

25， cv2.Scharr

与Sobel算子作用相同的另一种算子

cv2.Scharr()参数除了没有ksize，其他与Sobel相同

26，cv2.Laplacian

图像梯度计算的另一个算法

python 复制代码

laplacian = cv2.Laplacian(img,cv2.CV_64F)#只需要输入2个参数

27，cv2.Canny

边缘检测函数

python 复制代码

img = cv2.imread('lena.jpg',cv2.IMREAD_GRAYSCALE)
v1 = cv2.Canny(img,80,150)#80为minVal,150为maxVal
v2 = cv2.Canny(img,50,100)
res = np.hstack((v1,v2))

28，cv2.pryUp与cv.pryDown

图像高斯金字塔放大，缩小函数

cv.pryUp(img)#直接输入要处理的图像即可

29，cv2.findContours

用于轮廓检测，提取物体的轮廓

用此函数之前要将img转换为二值化黑白图像

函数返回两个值，第一个值contours就是轮廓点，第二个值hierarchy就是层级，把结果保存在层级之中。

python 复制代码

contours, hierarchy = cv2.findContours(thresh,cv2.RETR_TREE,cv2.CHAIN_APPROX_NONE)

30，cv2.drawContours

根据cv2.findContours的轮廓点画出轮廓

python 复制代码

draw_img = img.copy()#注意要使用copy，因为cv2.drawContours画出的轮廓会将原始图像覆盖
res = cv2.drawContours(draw_img, contours, -1, (0,0,255), 2)#draw_img必须为三颜色通道图片
#第三个参数表示要画几个轮廓，-1表示都画进来，第四个参数(0,0,255)分别表示BGR,此处表示用红色的线去画，2表示线条宽度

31，cv2.contourArea

计算轮廓的面积

python 复制代码

cnt = contours[0]#第一个轮廓，由findContours得到
#计算面积
cv2.contourArea(cnt)
#计算周长,True表示闭合

32，cv2.arcLength

计算轮廓周长

python 复制代码

cnt = contours[0]
#计算周长,True表示闭合
cv2.arcLength(cnt,True)

33，cv2.approxPolyDP

轮廓近似(将轮廓近似为规整图形)使用

函数返回一个逼近后的多边形，表示为 2D 点的列表或 NumPy 数组。

curve：要逼近的曲线，可以是 2D 点的列表或 NumPy 数组。
epsilon：逼近精度。它是一个距离值，表示曲线上的点与逼近后的多边形之间的最大距离。值越小，逼近越精确，但点数也可能越多。
closed：一个布尔值，指示曲线是否闭合。如果为 True，则函数将闭合曲线。
返回值是近似图形的各个顶点坐标,且返回值为三维数组

python 复制代码

epsilon = 0.1*cv2.arcLength(cnt,True)
#第一个参数指要近似的轮廓点，第二个参数是要指定的阈值一般情况下为上述公式
approx = cv2.approxPolyDP(cnt,epsilon,True)
draw_img = img.copy()
res = cv2.drawContours(draw_img, [approx], -1, (0,0,255), 2)

34，cv2.boundingRect与cv2.minEnclosingCircle

给定findContours找的轮廓，cv2.boundingRect会根据轮廓找外接矩形

返回值有4个，x,y,w,h分别表示举行框左上角坐标，矩形框长和高

cv2.minEnclosingCircle是找外界圆,返回参数为圆心位置(x,y),外接圆半径radius

35，cv2.rectangle与cv2.circle

cv2.rectangle包含的参数有：(img, pt1, pt2, color, thickness=None, lineType=None, shift=None )

各参数的含义如下：

img：指定一张图片，在这张图片的基础上进行绘制；（img相当于一个画板）

pt1：由（x_min，y_min）组成，为绘制的边框的左上角；

pt2：由（x_max, y_max）坐标，为绘制的边框的右下角，示意如下：

color：指定边框的颜色，由（B,G,R）组成，当为（255,0，0）时为绿色，可以自由设定；

thinkness：线条的粗细值，为正值时代表线条的粗细（以像素为单位），为负值时边框实心;

python 复制代码

import cv2
picture = cv2.imread('1.jpg')		# picture_path为图片路径;(cv读取的文件为BGR形式)
cv2.rectangle(picture, (x,y), (x+w,y+h), (255, 0, 255), -1)

cv2.circle(image, center, radius, color, thickness)

image:它是要在其上绘制圆的图像。

center：它是圆的中心坐标。坐标表示为两个值的元组，即(X坐标值，Y坐标值)。

radius:它是圆的半径。

color:它是要绘制的圆的边界线的颜色。对于BGR，我们通过一个元组。例如：(255，0，0)为蓝色。

thickness:它是圆边界线的粗细像素。厚度-1像素将以指定的颜色填充矩形形状。

36，cv2.matchTemplat和cv2.minMaxLoc

模板匹配所用函数

共需要输入三个参数,第三个参数是模板匹配的计算方法共有六种

python 复制代码

#img表示原始图像，template表示截取图像
res = cv2.matchTemplate(img,template,cv2.TM_SQDIFF)

函数 cv2.matchTemplate()的返回值 result 是由每个位置的比较结果组合所构成的一个结果集，类型是单通道 32 位浮点型。如果输入图像（原始图像）尺寸是 WH，模板的尺寸是 wh，

则返回值的大小为(W-w+1)*(H-h+1)。

在进行模板匹配时，模板在原始图像内遍历.

cv2.matchTemplat和cv2.minMaxLoc搭配使用，cv2.minMaxLoc可以比较cv2.matchTemplat中的数据，它的返回值有4个，最小值和最大值，最小值出现的位置和最大值出现的位置，这样就可以通过cv2.rectangle画出匹配结果

python 复制代码

min_val,max_val,min_loc,max_loc=cv2.minMaxLoc(res)

37，np.where

Numpy库中的函数，用于根据指定的条件返回一个向量或数组中满足条件的元素的位置。

基本语法：condition是一个布尔数组或布尔条件表达式，用于指定需要满足的条件。x和y分别是满足条件和不满足条件的替代值。它们可以使标量，向量或数组

np.where(condition, x, y)

python 复制代码

import numpy as np
# 例1：使用np.where()替换满足条件的元素
arr = np.array([1, 2, 3, 4, 5])
new_arr = np.where(arr < 3, 0, arr)
print(new_arr)  # 输出: [0, 0, 3, 4, 5]
# 例2：使用np.where()获取满足条件的元素的位置
arr = np.array([1, 2, 3, 4, 5])
indexes = np.where(arr > 3)
print(indexes)  # 输出: (array([3, 4]),)
# 例3：使用np.where()替换多个条件
arr = np.array([1, 2, 3, 4, 5])
new_arr = np.where((arr < 3) | (arr > 4), 0, arr)
print(new_arr)  # 输出: [0, 0, 3, 0, 5]
# 创建一个示例数组
arr = np.array([1, 2, 3, 4, 5])
arr1 = np.array([1, 2, 3, 4, 5])
new_arr = np.where(arr > 2, arr1+1, arr1)
print(new_arr)

对于多维数组时

python 复制代码

print(np.where(a < 4))
# (array([0, 0, 0, 1]), array([0, 1, 2, 0]))

print(type(np.where(a < 4)))
# <class 'tuple'>

显然得到的索引不好理解，可以使用list(),zip()以及*对其进行以下整理，结果如下

python 复制代码

print(list(zip(*np.where(a < 4))))
# [(0, 0), (0, 1), (0, 2), (1, 0)]

多维同样适用

python 复制代码

a_3d = np.arange(24).reshape(2, 3, 4)
print(a_3d)
# [[[ 0  1  2  3]
#   [ 4  5  6  7]
#   [ 8  9 10 11]]
# 
#  [[12 13 14 15]
#   [16 17 18 19]
#   [20 21 22 23]]]

print(np.where(a_3d < 5))
# (array([0, 0, 0, 0, 0]), array([0, 0, 0, 0, 1]), array([0, 1, 2, 3, 0]))

print(list(zip(*np.where(a_3d < 5))))
# [(0, 0, 0), (0, 0, 1), (0, 0, 2), (0, 0, 3), (0, 1, 0)]

38，cv2.calcHist和plt.hist和plt.show和plt.xlim和plt.ylim和plt.plot

用于直方图统计

以下为直方图统计函数，第一个参数是要输入的图像，通常情况下转换为灰度图。第二个参数是输入图像不是灰度图时，可输入0 1 2分别表示BGR三个通道的数值统计。第三个参数mask掩膜是指输入一张图像时，正常情况下是对图像整体进行统计，而这个参数是告诉函数统计图像的哪个部分。第四个参数是指统计结果的直方图中横坐标一个矩形格代表的范围，比如0~10,11~20以bin=10为间距的，也可以是0~20,21~40以bin=20为间距的。最后一个参数是像素的取值范围

hist返回值：hist = cv2.calcHist([img],[0],None,[256],[0,256])中，hist是一个256*1的矩阵，每一个值代表了每个灰度值对应的像素点数目

plt.hist和plt.show是用来显示直方图的

函数功能：判定数据(或特征)的分布情况

调用方法：plt.hist(x, bins=10, range=None, normed=False, weights=None, cumulative=False, bottom=None, histtype='bar', align='mid', orientation='vertical', rwidth=None, log=False, color=None, label=None, stacked=False)

参数说明：

x：指定要绘制直方图的数据；

bins：指定直方图条形的个数；

range：指定直方图数据的上下界，默认包含绘图数据的最大值和最小值；

density：是否将直方图的频数转换成频率；

weights：该参数可为每一个数据点设置权重；

cumulative：是否需要计算累计频数或频率；

bottom：可以为直方图的每个条形添加基准线，默认为0；

histtype：指定直方图的类型，默认为bar，除此还有'barstacked', 'step', 'stepfilled'；

align：设置条形边界值的对其方式，默认为mid，除此还有'left'和'right'；

orientation：设置直方图的摆放方向，默认为垂直方向；

rwidth：设置直方图条形宽度的百分比；

log：是否需要对绘图数据进行log变换；

color：设置直方图的填充色；

label：设置直方图的标签，可通过legend展示其图例；

stacked：当有多个数据时，是否需要将直方图呈堆叠摆放，默认水平摆放；

python 复制代码

import cv2
import numpy as np
import matplotlib.pyplot as plt
def cv_show(img,name):
    cv2.imshow(name,img)
    cv2.waitKey()
    cv2.destroyAllWindows()

img = cv2.imread('cat.jpg',0)#0表示灰度图
hist = cv2.calcHist([img],[0],None,[256],[0,256])#参数外必须加中括号
                                                 #已经为灰度图了，只有一个通道,[0]表示选择第一个通道
#img.ravel() 将图像转成一维数组，这里没有中括号
plt.hist(img.ravel(),256)
plt.show()#展示图像，用opencv也可以

plt.plot

它的作用是将一组数据点连接起来，也就是曲线图，以可视化数据的趋势、关系或模式

plt.plot(x, y, format_string, **kwargs)

第一个参数x为x轴数据列表或数组，可选。第二个参数为y轴数据。第三个是一个可选的格式字符串，用于指定线条的样式、标记和颜色，例如，'ro-' 表示红色圆点线条。第四个参数是一系列可选参数，用于进一步自定义线条的属性，如线宽、标记大小、标签等。

plt.xlim和plt.ylim

plt .xlim显示的是x轴的作图范围.plt.ylim显示的是y轴的作图范围

python 复制代码

#共有两个参数输入
plt.xlim(xmin=num1,xmax=num2)
plt.ylim(ymin=num1,ymax=num2)

python 复制代码

import cv2
import numpy as np
import matplotlib.pyplot as plt
x=np.arange(10)
y=np.array([0,2,4,6,8,10,12,14,16,18])
plt.xlim(0,10)
plt.ylim(0,20)#如果不指定xlim，ylim，系统会根据输入数据自动指定
plt.plot(x,y)
plt.show()

输出结果如下：

39，cv2.equalizeHist

直方图均衡化使用的函数

cv2.equalizeHize(img)

40，cv2.createCLAHE

cv2.createCLAHE是一种限制对比度自适应直方图均衡化方法（Contrast Limited Adaptive Hitogram Equalization），采用了限制直方图分布的方法和加速的插值方法。CLAHE 是一种增强图像局部对比度的技术，通过限制对比度来避免传统直方图均衡化所引入的噪声和过度增强。

cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))

参数clipLimit:对比度限幅。从全局对比度的角度出发，对比度受限的程度。默认值为 2.0。当 clipLimit 设置为 0 或者负值时，表示没有对比度限制。较高的值会增加对比度，但可能导致噪声放大。tileGridSize:每个小网格的大小，以像素为单位（行数，列数）。默认值为 (8, 8)。图像将被分为多个大小相同的网格块，CLAHE 算法分别对每个网格块进行直方图均衡化。

python 复制代码

import cv2
# 读取灰度图像
image = cv2.imread('input.jpg', cv2.IMREAD_GRAYSCALE)
 
# 创建 CLAHE 对象
clipLimit = 2.0
tileGridSize = (8, 8)
clahe = cv2.createCLAHE(clipLimit=clipLimit, tileGridSize=tileGridSize)
 
# 对图像应用 CLAHE
enhanced_image = clahe.apply(image)
 
# 显示结果
cv2.imshow("Original Image", image)
cv2.imshow("Enhanced Image", enhanced_image)
cv2.waitKey(0)
cv2.destroyAllWindows()

41，myutils.sort_contours

自定义函数，实现对轮廓的排序（给轮廓一个位置标号，按照x位置排序，x小在前）

myutils.sort_contours(contours, method = "left-to-right")

python 复制代码

def sort_contours(cnts, method):
    reverse = False
    i = 0
    if method == "right-to-left" or method == "bottom-to-top":
        reverse = True
    if method == "top-to-bottom" or method == "bottom-to-top":
        i = 1
    #返回的boundingBoxes是一个元组，其中包含4个值，分别为x,y,w,h
    boundingBoxes = [cv2.boundingRect(c) for c in cnts]
    (cnts, boundingBoxes) = zip(*sorted(zip(cnts, boundingBoxes),
                                    key = lambda b: b[1][i], reverse = reverse))
    return cnts, boundingBoxes

42，cv2.getStructuringElement

在进行形态学操作时，必须使用一个特定的核，该核可以自定义生成，也可以通过函数构造

cv2.getStructuringElement(shape， ksize)

shape：代表形状类型

cv2. MORPH_RECT：矩形结构元素，所有元素值都是1

cv2. MORPH_CROSS：十字形结构元素，对角线元素值都是1

cv2. MORPH_ELLIPSE：椭圆形结构元素

ksize：代表形状元素的大小

python 复制代码

import cv2
import numpy as np
kernel1 = cv2.getStructuringElement(cv2.MORPH_RECT, (5, 5))
kernel2 = cv2.getStructuringElement(cv2.MORPH_CROSS, (5, 5))
kernel3 = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))
print(kernel1)
print('\n', kernel2)
print('\n', kernel3)
# 输出为：
# [[1 1 1 1 1]
#  [1 1 1 1 1]
#  [1 1 1 1 1]
#  [1 1 1 1 1]
#  [1 1 1 1 1]]
#
#  [[0 0 1 0 0]
#  [0 0 1 0 0]
#  [1 1 1 1 1]
#  [0 0 1 0 0]
#  [0 0 1 0 0]]
# 
#  [[0 0 1 0 0]
#  [1 1 1 1 1]
#  [1 1 1 1 1]
#  [1 1 1 1 1]
#  [0 0 1 0 0]]

43，cv2.bitwise_and

制作掩膜时常用

python 复制代码

cv2.bitwise_and(src1, src2, dst=None, mask=None)

src1：第一幅输入图像

src2：第二幅输入图像

dst：可选参数，输出图像，与输入图像具有相同的尺寸和数据类型

mask：可选参数，掩码图像，用于指定哪些像素进行按位与操作

示例代码

python 复制代码

import numpy as np
import cv2
 
# 读取图像
img = cv2.imread('1.jpg')
img = cv2.resize(img, dsize=None, fx=0.3, fy=0.3)
# 下面2行代码构造输出OpenCV图标的掩膜，255确保所有位都是1
imgMask = np.zeros(img.shape, dtype=np.uint8)
imgMask[100:200, 400:500] = 255
 
# 执行按位与操作
resultImg1 = cv2.bitwise_and(img, imgMask)
resultImg2 = cv2.bitwise_and(img, (255, 0, 0))
resultImg3 = cv2.bitwise_and(img, (0, 255, 0))
resultImg4 = cv2.bitwise_and(img, (0, 0, 255))
 
# 显示结果图像
cv2.imshow('resultImg1', resultImg1)
cv2.imshow('resultImg2', resultImg2)
cv2.imshow('resultImg3', resultImg3)
cv2.imshow('resultImg4', resultImg4)
cv2.waitKey(0)

44，cv2.dft与cv2.idft

cv2.dft()就是执行傅里叶变换，得到的结果是一个频域，没办法显示出来。为了显示还要使用cv2.idft()进行逆变换一下

45，np.fft.fftshift

np.fft.fftshift（）用于将FFT变换之后的频谱显示范围从[0, N]变为：[-N/2, N/2-1](N为偶数) 或者[-(N-1)/2, (N-1)/2](N为奇数)，这一步的目的是在后续画频域图时候，能将低频部分移到中心，在使用IDFT时也需要进行这个操作。

46，np.log与np.log10

np.log指的是数学中的ln,np.log10指的是数学中的lg

47，np.magnitude

cv2.magnitude一般用于cv2中的傅里叶变换一块，在numpy中使用的是abs取均值法，而cv2中则使用了一个函数--magnitude。该函数用于将传入的参数平方和取根

python 复制代码

a1 = np.array([1,1,1],dtype='float32')
a2 = np.array([1,2,3],dtype='float32')
print(cv2.magnitude(a1, a2))
#输出结果为[1.4142135 2.236068 3.1622777]
#相当于(a1**2+a2**2)**(1/2)

48，plt.figure和plt.subplot和plt.subplots，plt.xticks和plt.yticks

Matplotlib中的 plt.figure() 函数的作用就是创建一个图像，一般和plt.subplot() 一起用

python 复制代码

matplotlib.pyplot.figure(num=None, 
figsize=None, 
dpi=None, 
facecolor=None,
edgecolor=None, 
frameon=True, 
FigureClass=<class 'matplotlib.figure.Figure'>, 
clear=False, 
**kwargs)

num:图像编号或名称，数字为编号，字符串为名称。不指定调用figure时就会默认从1开始。
figsize:指定figure的宽和高，单位为英寸
dpi参数指定绘图对象的分辨率，即每英寸多少个像素
facecolor:背景颜色
edgecolor:边框颜色
frameon:是否显示边框

plt.subplot（）函数用于直接制定划分方式和位置进行绘图。在 Matplotlib 中 plt.subplot() 就是用来创建单个子图的。subplot可以将figure划分为n个子图，但每条subplot命令只会创建一个子图，如果要绘制多个子图，可以考虑使用for 循环。

python 复制代码

plt.subplot(nrows,
ncols,
sharex,
sharey,
subplot_kw,
**fig_kw)

nrows 表示 subplot 的行数
ncols 表示 subplot 的列数
sharex 表示 subplot 中 x 轴的刻度，所有的 subplot x 轴应该保持相同的刻度
sharey 表示 subplot 中 y 轴的刻度，所有的 subplot y 轴应该保持相同的刻度

python 复制代码

#plt.subplot(221)表示将整个图像窗口分为2行2列(可以容纳4个表格), 当前位置为1.
plt.subplot(221)

# plt.subplot(222)表示将整个图像窗口分为2行2列, 当前位置为2.
plt.subplot(222)   # 第一行的右图

# plt.subplot(223)表示将整个图像窗口分为2行2列, 当前位置为3.
plt.subplot(223)

# plt.subplot(224)表示将整个图像窗口分为2行2列, 当前位置为4.
plt.subplot(224)

python 复制代码

plt.figure(figsize= (10, 6), facecolor = 'r', edgecolor = 'y')
plt.subplot(3, 2, 1)
plt.subplot(3, 2, 2)
plt.show()

输出结果：未指定横纵坐标数值长度，默认为1

在 Matplotlib 中 plt.subplots() 的用法和subplot() 相似，但subplots 可以创建多个子图。

python 复制代码

plt.subplots(2,2)

一次创建多个坐标，如下

在 Matplotlib 中 plt.ticks() 函数表示的是刻度, plt.xticks() 就表示x 轴刻度，plt.yticks() 就表示y 轴刻度。

xticks(ticks=None, labels=None, **kwargs)

**ticks：**x轴刻度位置的列表，若传入空列表，即不显示x轴

**labels：**放在指定刻度位置的标签文本。当ticks参数有输入值，该参数才能传入参数

****kwargs：**文本属性用来控制标签文本的展示，例如字体大小、字体样式等

python 复制代码

plt.figure(figsize=(20, 10))
plt.subplot(2, 3, 1)
plt.xticks([])  # 不显示x 轴刻度
plt.yticks([])  # 不显示y 轴刻度
plt.show()

输出结果：

python 复制代码

#可以自己指定横纵坐标值
plt.figure(figsize=(10, 10))
plt.subplot(1, 1, 1)
plt.xticks([0,1,2,3])  # 不显示x 轴刻度
plt.yticks([0,2,5,8])  # 不显示y 轴刻度
plt.show()

输出结果

python 复制代码

#可以在坐标对应位置写入a，b，c，d
plt.figure(figsize=(3, 3))
plt.subplot(1, 1, 1)
plt.xticks([0,1,2,3],['a', 'b', 'c', 'd'])  # 不显示x 轴刻度
plt.yticks([0,2,5,8])  # 不显示y 轴刻度
plt.show()

输出结果

python 复制代码

#可以指定旋转角度旋转坐标值
plt.figure(figsize=(3, 3))
plt.subplot(1, 1, 1)
plt.xticks([0,1,2,3],['a', 'b', 'c', 'd'], rotation = 30)  # 不显示x 轴刻度
plt.yticks([0,2,5,8])  # 不显示y 轴刻度
plt.show()

输出结果

49，plt.imshow

imshow()其实就是将数组的值以图片的形式展示出来,数组的值对应着不同的颜色深浅,而数值的横纵坐标就是数组的索引,比如一个1000X1000的数组,图片里的点也就有1000X1000个,比如第一个行第一个点的坐标就是(0,0),它的值会通过colorbar(也就是cmap)反映出来,所以按照我的理解，imshow()函数的功能就是把数值展示成热图。

plt.imshow(image, cmap, aspect, interpolation,alpha,vmin,vmax)

cmap：颜色设置。常用的值有'viridis'、'gray'、'hot'等。可以通过plt.colormaps()查看可用的颜色映射。
aspect：调整坐标轴。这将根据图像数据自动调整坐标轴的比例。常用的值有'auto'、'equal'等。设置为'auto'时会根据图像数据自动调整纵横比，而设置为'equal'时则会强制保持纵横比相等。
interpolation：插值方法。它定义了图像在放大或缩小时的插值方式。常用的值有'nearest'、'bilinear'、'bicubic'等。较高的插值方法可以使图像看起来更平滑，但计算成本更高。
alpha：透明度。它允许您设置图像的透明度，取值范围为0（完全透明）到1（完全不透明）之间。
vmin和vmax：用于设置显示的数据值范围。当指定了这两个参数时，imshow()将会根据给定的范围显示图像，超出范围的值会被截断显示。

和cv2.imread差不多，以下为cv2.imshow得到的图片

以下为plt.imshow得到的图片,其中横纵坐标最大值为图像长宽

50， cv2.putText

在OpenCV中，调用cv2.putText()函数可添加文字到指定位置，对于需要在图片中加入文字的场景提供了一种比较直接方便的方式。

注意：OpenCV 不支持显示中文字符，使用 cv2.putText() 时添加的文本字符串不能包含中文字符（包括中文标点符号）

python 复制代码

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

img：需要绘制文本的图像；
text：要绘制的文本内容；
org：表示要绘制的位置，图像中文本字符串的左下角；可以用一个元祖来表示x、y坐标，例如(10, 100)表示x=10，y=100。
fontFace：字体类型，如cv2.FONT_HERSHEY_SIMPLEX、cv2.FONT_HERSHEY_PLAIN等；对应的字体类型如下：

python 复制代码

 cv2.FONT_ITALIC：斜体字的标志
 cv2.FONT_HERSHEY_PLAIN：小尺寸无衬线字体
 cv2.FONT_HERSHEY_SIMPLEX：正常大小的无衬线字体
 cv2.FONT_HERSHEY_DUPLEX：正常大小的无衬线字体（比FONT_HERSHEY_SIMPLEX更复杂）
 cv2.FONT_HERSHEY_COMPLEX：正常大小的衬线字体
 cv2.FONT_HERSHEY_TRIPLEX：正常大小的衬线字体（比FONT_HERSHEY_COMPLEX更复杂）
 cv2.FONT_HERSHEY_SCRIPT_SIMPLEX：手写体字体
 cv2.FONT_HERSHEY_SCRIPT_COMPLEX（比FONT_HERSHEY_SCRIPT_SIMPLEX的更复杂）

fontScale：字体的大小，字体比例因子乘以font-specific基本大小;
color：文本字体颜色，设置三通道的元组BGR，比如(255，0，0)

常见颜色：

red (0, 0, 255)

green (0, 128, 0)

blue (255, 0, 0)

yellow (0, 255, 255)

purple (128, 0, 128)

orange (0, 165, 255)

white (255, 255, 255)

black (0, 0, 0)

gray (128, 128, 128)

thickness：字体粗细，默认为1；
lineType：线条类型，默认为cv2.LINE_AA；
bottomLeftOrigin：坐标原点，如果为真，则图像数据原点位于左下角，否则它在左上角;其中，org定义了文本起始位置，可以用一个元祖来表示x、y坐标，例如(10, 100)表示x=10，y=100。

51，cv2.getPerspectiveTransform与cv2.warpPerspective

复制代码

透视变换函数：

透视变换（Perspective Transformation)是指利用透视中心、像点、目标点三点共线的条件，按透视旋转定律使承影面（透视面）绕迹线（透视轴）旋转某一角度，破坏原有的投影光线束，仍能保持承影面上投影几何图形不变的变换。透视变换(Perspective Transformation)是将图片投影到一个新的视平面 (Viewing Plane)，也称作投影映射(Projective Mapping)

cv2.getPerspectiveTransform(src, dst)

src：输入图像的四个点的坐标，格式为 [[],[],[],[]]
dst：输出图像的四个点的坐标，格式为 [[],[],[],[]]
函数的返回值是一个 3x3 的透视变换矩阵M ，该矩阵可以应用于源图像，以实现从源四边形到目标四边形的透视变换。这个矩阵可以通过 cv2.warpPerspective() 函数来应用到源图像上，实现透视变换。

dst = warpPerspective(src, M, dsize[, flags[, borderMode[, borderValue]]])

src：这是源图像，即你希望应用透视变换的图像。通常，这是一个二维的 numpy 数组。
M：这是一个3x3的透视变换矩阵，它描述了如何对源图像进行变换。你可以使用函数来获取这个矩阵。cv2.getPerspectiveTransform()
dsize：这是一个元组，表示输出图像的大小。通常，它以的形式指定。输出图像的大小可以与源图像大小不同，你可以选择将其调整为所需的尺寸。(宽度, 高度)
flags：这是一个可选参数，用于指定插值方法。它可以采用以下值之一：

cv2.INTER_NEAREST：最近邻插值。

cv2.INTER_LINEAR：双线性插值（默认）。

cv2.INTER_CUBIC：双三次插值。

cv2.INTER_LANCZOS4：Lanczos插值。

borderMode：这是一个可选参数，用于指定处理边界像素的方式。它可以采用以下值之一：

cv2.BORDER_CONSTANT：使用固定的边界值。

cv2.BORDER_REPLICATE：复制边界像素的值。

cv2.BORDER_REFLECT：反射边界像素。

cv2.BORDER_WRAP：环绕边界像素。

borderValue：这是一个可选参数，用于指定在模式下要使用的边界值。通常，它是一个标量值，例如表示黑色。cv2.BORDER_CONSTANT(0, 0, 0)。
返回值：目标图像，即经过透视变换后的图像

52，np.reshape

reshape()函数的功能是改变数组或矩阵的形状

a.reshape(m,n)表示将原有数组a转化为一个m行n列的新数组，a自身不变。m与n的乘积等于数组中的元素总数

reshape(m,n)中参数m或n其中一个可写为"-1"，"-1"的作用在于计算机根据原数组中的元素总数自动计算行或列的值。

python 复制代码

a = np.array(range(10), float)
a = a.reshape(5,-1)  #将数组a改为一个5行的二维新数组
print(a)
#输出结果
array([[0., 1.],
       [2., 3.],
       [4., 5.],
       [6., 7.],
       [8., 9.]])

53，np.argmin和np.armax

python的numpy库的argmin()函数，用于获取沿指定轴的最小值的索引。

python 复制代码

numpy.argmin(a, axis=None, out=None, *, keepdims=<no value>)

argmin()返回沿指定轴的最小值的索引。

参数axis表示指定轴，默认为None表示整个数组的最小值的索引而不是某个轴的最小值，即转为一维数组后的最小值的索引。axis只能为整数，不支持整数元组。

参数keepdims表示是否保留指定轴的尺寸为1，默认为False，不保留。

54，np.diff

np.diff()可以用于计算相邻元素之间的差值,从而检测突变点、分析变化率等

python 复制代码

np.diff(a, n=1, axis=-1, prepend=<no value>, append=<no value>)[source]

a：输入数组。
n：可选参数，差值计算的次数，如果为 0，那么得到的数组就和输入进去的一样。
axis：可选参数，选择需要做差的轴，默认的是最后的轴。
prepend：该参数暂时不讨论。
返回值：返回一个维度比原始数组小的数组，且数组的数据类型和原始数组一致。具体的在我们后面的示例中会提到。

python 复制代码

arr = [1, 2, 3, 4, 5]
np.diff(arr)
#结果是:[1 1 1 1]

这是因为:

差值：1 和 2 是 1

差值：2 和 3 是 1

差值：3 和 4 是 1

差值：4 和 5 是 1

所以np.diff()返回一个数组,包含原数组中相邻元素之间的差值

可以看到，当直接使用 np.diff(x) 时，得到的数组最终元素比原始数组小 1，事实上它计算的是，原始数组后一个元素对前一个元素的差值的结果 [3-1, 5-3, 7-5, 9-7]= [2,2,2,2]，此时对应的默认 n 值为 1，最终给我们得到的数组比原始数组的元素个数少了 1。

而如果我们设定 n 值为 2，那么在第一次计算的基础上，对第一次计算差值的结果再进行后一个元素对前一个元素的差值计算，最终得到 [2-2, 2-2,2-2]=[0,0,0]，此时元素总个数又减少了 1，如果 n=3，则再次对计算两次得到的结果进行处理，以此类推，类似于一个递归。