测试环境

安装库

我们需要安装关于python使用OpenCV的几个库

  • opencv-python
  • opencv-contrib-python
  • pytesseract

那么正常的安装方法是在cmd命令行中输入 pip install 库名
但是这样下载速度很慢，所以我们要使用镜像下载
python -m pip

python -m pip install -i https://pypi.tuna.tsinghua.edu.cn/simple 库名

全部复制到cmd中，更改库名为你选择的库，进行下载

测试环境

import cv2 as cv

src = cv.imread("C:/Users/acer/Desktop/Other/img/01.jpg")
cv.namedWindow("input image",cv.WINDOW_AUTOSIZE)
cv.imshow("input image",src)
cv.waitKey(0)
cv.destroyAllWindows()

在这里有2点需要注意：
1.一定要首先import导入cv2库
2.在cv.imread中读取本机的一张图片地址，要用 / 而不是用 \

此时点击运行会出现一张图片，就代表环境搭建成功了

c86_server镜像文件下载_等待时间

如果中文注释报错 请在顶部加上 # coding:utf-8

获取完整图片

# coding:utf-8
import cv2 as cv

src = cv.imread("01.jpg")
src2 = cv.imread("01.jpg",cv.IMREAD_GRAYSCALE)#读取灰度图像
cv.imshow("image",src) #给窗口指定一个名字
cv.waitKey(0) #等待时间，毫秒，0表示任意键终止
cv.destroyAllWindows() #触发关闭操作，关闭窗口
  • coding:utf-8：设置编码格式为utf-8
  • import cv2 as cv 导入opencv库 我们起名为cv
  • 通过cv.imread来读取一张图片，这图片在我的项目里，所以直接写名字就可，如果在别的地方写全路径
  • cv.imread("01.jpg",cv.IMREAD_GRAYSCALE) 后面的参数是设置读取灰度图像
  • imshow第一个参数是名字，第二个参数是图片
  • waitkey等待时间
  • destroyAlliwindows 关闭窗口的操作

shape可代表opencv在图像坐标里的图像行数，列数，色彩通道数

截取部分图片

src = cv.imread("01.jpg")
demo = src[0:50,0:200]
cv.imshow("image",demo) #给窗口指定一个名字
cv.waitKey(0) #等待时间，毫秒，0表示任意键终止
cv.destroyAllWindows() #触发关闭操作，关闭窗口
  • 通过imread读取图片
  • 通过 图片名称[0:50,0:200] 高50 宽200
  • 剩下操作就是和完整图片类似

读取视频

# coding:utf-8
import cv2 as cv

vc = cv.VideoCapture("test.mp4");
if vc.isOpened():
    open, frame = vc.read() # open 是布尔值，frame是当前这一帧的图像
else:
    open = False

while open: #如果open是true就是能打开 进入while循环
    ret, frame = vc.read() #读一下
    if frame is None: #如果这个帧为空，就是没有下一帧了，就结束
        break
    if ret == True: #读这一帧数没错误
        gray = cv.cvtColor(frame,cv.COLOR_BGR2GRAY)
        #转换成灰度图 frame：传递当前这一帧，COLOR_BGR2GRAY：生成灰度图

        cv.imshow('result',gray) #展示结果，名字result 传进来gray

        if cv.waitKey(10) & 0xFF == 27: #0xFF == 27 代表执行过程中按一个键就退出
            break
vc.release()
cv.destroyAllWindows()
  • cv.VideoCapture("test.mp4") 获取视频的地址路径
  • open 是布尔值，代表是否打开该视频；frame是当前这一帧的图像
  • cv.cvtColor(frame,cv.COLOR_BGR2GRAY) 转换成灰度图，frame当前帧，COLOR_BGR2GRAY：生成灰度图
  • 0xFF == 27 代表执行过程中按一个键就退出

BGR

只保留R

# coding:utf-8
import cv2 as cv

src = cv.imread("01.jpg")
cur_img = src.copy()
cur_img[:,:,0] = 0
cur_img[:,:,1] = 0
cv.imshow('R',cur_img)

cv.waitKey(0) #等待时间，毫秒，0表示任意键终止
cv.destroyAllWindows() #触发关闭操作，关闭窗口

通过设置BGR只保留R BG为0

c86_server镜像文件下载_灰度图_02

只保留G

# coding:utf-8
import cv2 as cv

src = cv.imread("01.jpg")
cur_img = src.copy()
cur_img[:,:,0] = 0
cur_img[:,:,2] = 0
cv.imshow('G',cur_img)

cv.waitKey(0) #等待时间，毫秒，0表示任意键终止
cv.destroyAllWindows() #触发关闭操作，关闭窗口

通过设置BGR只保留G BR为0

只保留B

# coding:utf-8
import cv2 as cv

src = cv.imread("01.jpg")
cur_img = src.copy()
cur_img[:,:,1] = 0
cur_img[:,:,2] = 0
cv.imshow('B',cur_img)

cv.waitKey(0) #等待时间，毫秒，0表示任意键终止
cv.destroyAllWindows() #触发关闭操作，关闭窗口

通过设置BGR只保留B GR为0

c86_server镜像文件下载_关闭窗口_03

边界填充

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)
reflect = cv2.copyMakeBorder(img, top_size, bottom_size, left_size, right_size,cv2.BORDER_REFLECT)
reflect101 = cv2.copyMakeBorder(img, top_size, bottom_size, left_size, right_size, cv2.BORDER_REFLECT_101)
wrap = cv2.copyMakeBorder(img, top_size, bottom_size, left_size, right_size, cv2.BORDER_WRAP)
constant = cv2.copyMakeBorder(img, top_size, bottom_size, left_size, right_size,cv2.BORDER_CONSTANT, value=0)

通过matplot画图

import matplotlib.pyplot as plt
plt.subplot(231), plt.imshow(img, 'gray'), plt.title('ORIGINAL')
plt.subplot(232), plt.imshow(replicate, 'gray'), plt.title('REPLICATE')
plt.subplot(233), plt.imshow(reflect, 'gray'), plt.title('REFLECT')
plt.subplot(234), plt.imshow(reflect101, 'gray'), plt.title('REFLECT_101')
plt.subplot(235), plt.imshow(wrap, 'gray'), plt.title('WRAP')
plt.subplot(236), plt.imshow(constant, 'gray'), plt.title('CONSTANT')

plt.show()

c86_server镜像文件下载_关闭窗口_04

  • BORDER_REPLICATE：复制法，也就是复制最边缘像素。
  • BORDER_REFLECT：反射法，对感兴趣的图像中的像素在两边进行复制例如：fedcba|abcdefgh|hgfedcb
  • BORDER_REFLECT_101：反射法，也就是以最边缘像素为轴，对称，gfedcb|abcdefgh|gfedcba
  • BORDER_WRAP：外包装法cdefgh|abcdefgh|abcdefg
  • BORDER_CONSTANT：常量法，常数值填充。

数值计算

获取猫狗，然后狗=猫+10，最后结果获取前5行

img_cat=cv2.imread('cat.jpg')
img_dog=cv2.imread('dog.jpg')
img_cat2= img_cat +10 
img_cat[:5,:,0]

array([[142, 146, 151, ..., 156, 155, 154],
       [107, 112, 117, ..., 155, 154, 153],
       [108, 112, 118, ..., 154, 153, 152],
       [139, 143, 148, ..., 156, 155, 154],
       [153, 158, 163, ..., 160, 159, 158]], dtype=uint8)

查看此时猫2的值

img_cat2[:5,:,0] #查看此时猫2的值

array([[152, 156, 161, ..., 166, 165, 164],
       [117, 122, 127, ..., 165, 164, 163],
       [118, 122, 128, ..., 164, 163, 162],
       [149, 153, 158, ..., 166, 165, 164],
       [163, 168, 173, ..., 170, 169, 168]], dtype=uint8)

猫1+猫2 按理来说是142+152=294 为什么第一行是38了
是因为unit8只有0-255位，所以结果需要 %256取余数，即294-255=38

#相当于% 256
(img_cat + img_cat2)[:5,:,0] 

array([[ 38,  46,  56, ...,  66,  64,  62],
       [224, 234, 244, ...,  64,  62,  60],
       [226, 234, 246, ...,  62,  60,  58],
       [ 32,  40,  50, ...,  66,  64,  62],
       [ 60,  70,  80, ...,  74,  72,  70]], dtype=uint8)

这个add相加，当越界以后不会%255 而是直接输出255

cv2.add(img_cat,img_cat2)[:5,:,0]	

array([[255, 255, 255, ..., 255, 255, 255],
       [224, 234, 244, ..., 255, 255, 255],
       [226, 234, 246, ..., 255, 255, 255],
       [255, 255, 255, ..., 255, 255, 255],
       [255, 255, 255, ..., 255, 255, 255]], dtype=uint8)

图像融合

当直接相加以后

img_cat + img_dog


ValueError: operands could not be broadcast together with shapes (414,500,3) (429,499,3)

会报错，说这2个的值不相同没办法相加。

那此时就需要进行resize 操作 使其相同
通过resize(图片对象，需要更改的值)

img_dog = cv2.resize(img_dog, (500, 414))
img_dog.shape

(414, 500, 3)

addWeighted

res = cv2.addWeighted(img_cat, 0.4, img_dog, 0.6, 0)
plt.imshow(res)
res = cv2.resize(img, (0, 0), fx=4, fy=4)
plt.imshow(res)

在这里你设置0，0 但是通过fx和fy设置倍数使其改变

res = cv2.resize(img, (0, 0), fx=1, fy=3)
plt.imshow(res)

图像阈值

ret, dst = cv2.threshold(src, thresh, maxval, type)
  • src： 输入图，只能输入单通道图像，通常来说为灰度图
  • dst： 输出图
  • thresh： 阈值
  • maxval： 当像素值超过了阈值（或者小于阈值，根据type来决定），所赋予的值
  • type：二值化操作的类型，包含以下5种类型： cv2.THRESH_BINARY； cv2.THRESH_BINARY_INV； cv2.THRESH_TRUNC； cv2.THRESH_TOZERO；cv2.THRESH_TOZERO_INV
  • cv2.THRESH_BINARY 超过阈值部分取maxval（最大值），否则取0
  • cv2.THRESH_BINARY_INV THRESH_BINARY的反转
  • cv2.THRESH_TRUNC 大于阈值部分设为阈值，否则不变
  • cv2.THRESH_TOZERO 大于阈值部分不改变，否则设为0
  • cv2.THRESH_TOZERO_INV THRESH_TOZERO的反转
ret, thresh1 = cv2.threshold(img_gray, 127, 255, cv2.THRESH_BINARY)
ret, thresh2 = cv2.threshold(img_gray, 127, 255, cv2.THRESH_BINARY_INV)
ret, thresh3 = cv2.threshold(img_gray, 127, 255, cv2.THRESH_TRUNC)
ret, thresh4 = cv2.threshold(img_gray, 127, 255, cv2.THRESH_TOZERO)
ret, thresh5 = cv2.threshold(img_gray, 127, 255, cv2.THRESH_TOZERO_INV)

titles = ['Original Image', 'BINARY', 'BINARY_INV', 'TRUNC', 'TOZERO', 'TOZERO_INV']
images = [img, thresh1, thresh2, thresh3, thresh4, thresh5]

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

图像平滑

img = cv2.imread('lenaNoise.png')

cv2.imshow('img', img)
cv2.waitKey(0)
cv2.destroyAllWindows()

# 均值滤波
# 简单的平均卷积操作
blur = cv2.blur(img, (3, 3))

cv2.imshow('blur', blur)
cv2.waitKey(0)
cv2.destroyAllWindows()


# 方框滤波
# 基本和均值一样，可以选择归一化
box = cv2.boxFilter(img,-1,(3,3), normalize=True)  

cv2.imshow('box', box)
cv2.waitKey(0)
cv2.destroyAllWindows()


# 方框滤波
# 基本和均值一样，可以选择归一化,容易越界
box = cv2.boxFilter(img,-1,(3,3), normalize=False)  

cv2.imshow('box', box)
cv2.waitKey(0)
cv2.destroyAllWindows()



# 高斯滤波
# 高斯模糊的卷积核里的数值是满足高斯分布，相当于更重视中间的
aussian = cv2.GaussianBlur(img, (5, 5), 1)  

cv2.imshow('aussian', aussian)
cv2.waitKey(0)
cv2.destroyAllWindows()


# 中值滤波
# 相当于用中值代替
median = cv2.medianBlur(img, 5)  # 中值滤波

cv2.imshow('median', median)
cv2.waitKey(0)
cv2.destroyAllWindows()


# 展示所有的
res = np.hstack((blur,aussian,median))
#print (res)
cv2.imshow('median vs average', res)
cv2.waitKey(0)
cv2.destroyAllWindows()