一、计算机眼中的图像

1.图像操作

构成像素点的数字在0~255之间

RGB叫做图像的颜色通道

 h=500，w=500

 

 2.灰度图像

3. 彩色图像

 4.图像的读取

 5.视频的读取

cv2.VideoCapture()--在OpenCV中，可以使用VideoCapture来读取视频文件，或是摄像头数据。

cv2.VideoCapture.isOpened()--判断文件打开是否成功，可以使用cv2.VideoCapture.isOpened()这个函数。

cv2.VideoCapture.read()--cv2.VideoCapture.read()提供了一个最简单的视频帧处理方式，集合了抓起Grab（），解码retrieve（）两个功能，返回解码之后的数据。需要特别注意的是，如果获取到空帧，抓取失败或是文件结束，返回值会是一个空指针

示例：

VideoCapture也是支持读取摄像头的，提供rtsp码流即码流地址，

 二

1.截取部分图像数据

import os   
import cv2 
 
# 遍历指定目录，显示目录下的所有文件名
def CropImage4File(filepath,destpath):
    pathDir =  os.listdir(filepath)    # 列出文件路径中的所有路径或文件
    for allDir in pathDir:
        child = os.path.join(filepath, allDir)
        dest = os.path.join(destpath,allDir)
        if os.path.isfile(child):
        	image = cv2.imread(child) 
            sp = image.shape            #获取图像形状：返回【行数值，列数值】列表
            sz1 = sp[0]                 #图像的高度（行 范围）
            sz2 = sp[1]                 #图像的宽度（列 范围）
            #sz3 = sp[2]                #像素值由【RGB】三原色组成
            
            #你想对文件的操作
            a=int(sz1/2-64) # x start
            b=int(sz1/2+64) # x end
            c=int(sz2/2-64) # y start
            d=int(sz2/2+64) # y end
            cropImg = image[a:b,c:d]   #裁剪图像
            cv2.imwrite(dest,cropImg)  #写入图像路径
           
if __name__ == '__main__':
    filepath ='F:\\\maomi'             #源图像
    destpath='F:\\maomi_resize'        # resized images saved here
    CropImage4File(filepath,destpath)

2. 截取部分图像数据-批量处理

"""
处理数据集 和 标签数据集的代码：（主要是对原始数据集裁剪）
    处理方式：分别处理
    注意修改 输入 输出目录 和 生成的文件名
    output_dir = "./label_temp"
    input_dir = "./label"
"""
import cv2
import os
import sys
import time


def get_img(input_dir):
    img_paths = []
    for (path,dirname,filenames) in os.walk(input_dir):
        for filename in filenames:
            img_paths.append(path+'/'+filename)
    print("img_paths:",img_paths)
    return img_paths


def cut_img(img_paths,output_dir):
    scale = len(img_paths)
    for i,img_path in enumerate(img_paths):
        a = "#"* int(i/1000)
        b = "."*(int(scale/1000)-int(i/1000))
        c = (i/scale)*100
        time.sleep(0.2)
        print('正在处理图像： %s' % img_path.split('/')[-1])
        img = cv2.imread(img_path)
        weight = img.shape[1]
        if weight>1600:                         # 正常发票
            cropImg = img[50:200, 700:1500]    # 裁剪【y1,y2：x1,x2】
            #cropImg = cv2.resize(cropImg, None, fx=0.5, fy=0.5,
                                 #interpolation=cv2.INTER_CUBIC) #缩小图像
            cv2.imwrite(output_dir + '/' + img_path.split('/')[-1], cropImg)
        else:                                        # 卷帘发票
            cropImg_01 = img[30:150, 50:600]
            cv2.imwrite(output_dir + '/'+img_path.split('/')[-1], cropImg_01)
        print('{:^3.3f}%[{}>>{}]'.format(c,a,b))

if __name__ == '__main__':
    output_dir = "../img_cut"           # 保存截取的图像目录
    input_dir = "../img"                # 读取图片目录表
    img_paths = get_img(input_dir)
    print('图片获取完成 。。。！')
    cut_img(img_paths,output_dir)

3. 多进程（加快处理）

#coding: utf-8
"""
采用多进程加快处理。添加了在读取图片时捕获异常，OpenCV对大分辨率或者tif格式图片支持不好
处理数据集 和 标签数据集的代码：（主要是对原始数据集裁剪）
    处理方式：分别处理
    注意修改 输入 输出目录 和 生成的文件名
    output_dir = "./label_temp"
    input_dir = "./label"
"""
import multiprocessing
import cv2
import os
import time


def get_img(input_dir):
    img_paths = []
    for (path,dirname,filenames) in os.walk(input_dir):
        for filename in filenames:
            img_paths.append(path+'/'+filename)
    print("img_paths:",img_paths)
    return img_paths


def cut_img(img_paths,output_dir):
    imread_failed = []
    try:
        img = cv2.imread(img_paths)
        height, weight = img.shape[:2]
        if (1.0 * height / weight) < 1.3:       # 正常发票
            cropImg = img[50:200, 700:1500]     # 裁剪【y1,y2：x1,x2】
            cv2.imwrite(output_dir + '/' + img_paths.split('/')[-1], cropImg)
        else:                                   # 卷帘发票
            cropImg_01 = img[30:150, 50:600]
            cv2.imwrite(output_dir + '/' + img_paths.split('/')[-1], cropImg_01)
    except:
        imread_failed.append(img_paths)
    return imread_failed


def main(input_dir,output_dir):
    img_paths = get_img(input_dir)
    scale = len(img_paths)

    results = []
    pool = multiprocessing.Pool(processes = 4)
    for i,img_path in enumerate(img_paths):
        a = "#"* int(i/10)
        b = "."*(int(scale/10)-int(i/10))
        c = (i/scale)*100
        results.append(pool.apply_async(cut_img, (img_path,output_dir )))
        print('{:^3.3f}%[{}>>{}]'.format(c, a, b)) # 进度条（可用tqdm）
    pool.close()                        # 调用join之前，先调用close函数，否则会出错。
    pool.join()                         # join函数等待所有子进程结束
    for result in results:
        print('image read failed!:', result.get())
    print ("All done.")



if __name__ == "__main__":
    input_dir = "D:/image_person"       # 读取图片目录表
    output_dir = "D:/image_person_02"   # 保存截取的图像目录
    main(input_dir, output_dir)

 4.颜色通道提取

在OpenCV中，cv2.split() 函数用于将多通道数组（如彩色图像）拆分为多个单通道数组。彩色图像通常由多个颜色通道组成，例如BGR（蓝绿红）彩色空间中的三个通道。cv2.split() 函数将这些通道拆分为独立的数组，每个数组只包含一个通道的信息。

以下是使用 cv2.split() 的示例代码：

import cv2

# 读取一张彩色图片
image = cv2.imread('path_to_your_color_image.jpg')

# 使用 cv2.split() 拆分通道
b, g, r = cv2.split(image)

# 此时，b, g, r 分别包含蓝色、绿色和红色通道的图像数据

# 如果你想查看每个通道的图像，可以这样做：
cv2.imshow('Blue Channel', b)
cv2.imshow('Green Channel', g)
cv2.imshow('Red Channel', r)

# 等待按键，然后关闭窗口
cv2.waitKey(0)
cv2.destroyAllWindows()

 5.合并颜色通道

cv2.merge() 是 OpenCV 中用来合并多个单通道图像为一个多通道图像的函数。它的工作原理与 cv2.split() 相反。如果你有几个单通道图像（例如，从 cv2.split() 得到的），并且你想将它们合并成一个多通道图像（例如，一个彩色图像），那么你可以使用 cv2.merge()。

以下是 cv2.merge() 的基本用法：

import cv2

# 假设你有三个单通道图像：b, g, r
# 这些通常是通过 cv2.split() 从一个彩色图像中得到的
b = ... # 蓝色通道图像
g = ... # 绿色通道图像
r = ... # 红色通道图像

# 使用 cv2.merge() 将它们合并为一个彩色图像
bgr_image = cv2.merge([b, g, r])

# 现在 bgr_image 是一个包含 b, g, r 三个通道的彩色图像

在 cv2.merge() 函数中，你需要传递一个列表作为参数，该列表包含你想要合并的所有单通道图像。合并的顺序很重要，因为它决定了输出图像中通道的顺序。在上述示例中，我们按照 BGR（蓝绿红）的顺序合并了通道，这是 OpenCV 中彩色图像的标准通道顺序。

如果你想合并的通道顺序与 BGR 不同，例如 RGB（红绿蓝）顺序，你需要相应地调整通道的顺序：

rgb_image = cv2.merge([r, g, b])

请注意，cv2.merge() 要求所有输入图像都具有相同的大小和类型。如果它们的大小或类型不匹配，函数将抛出一个错误。

在处理图像时，理解通道的顺序和类型非常重要，因为不同的图像处理库和函数可能会使用不同的通道顺序和数据类型。OpenCV 使用 BGR 顺序，而一些其他库（如 PIL/Pillow）则使用 RGB 顺序。因此，在将图像从一个库传递到另一个库时，可能需要进行通道顺序的转换。

6.边界填充

cv2.copyMakeBorder() 是 OpenCV 库中的一个函数，用于在图像周围创建边框。cv2.copyMakeBorder(src,top,bottom,left,right,borderType,value)

下面是该函数的参数及其解释：

src：要处理的输入图像。
top：在源图像的顶部添加的像素数目。
bottom：在源图像的底部添加的像素数目。
left：在源图像的左侧添加的像素数目。
right：在源图像的右侧添加的像素数目。
borderType：边框类型，可以是以下之一：
cv2.BORDER_CONSTANT：添加一个常量值的边框。此时需要提供一个value参数，用于指定常量值。
cv2.BORDER_REPLICATE：复制源图像的边界像素。
cv2.BORDER_REFLECT：对源图像的边界进行反射，比如：fedcba|abcdefgh|hgfedcb
cv2.BORDER_REFLECT_101：对源图像的边界进行反射，但略微不同，比如：gfedcb|abcdefgh|gfedcba
cv2.BORDER_WRAP：对源图像的边界进行包装，比如：cdefgh|abcdefgh|abcdefg
value（可选）：当borderType为cv2.BORDER_CONSTANT时，指定的常量值。
该函数返回一个新的图像，其大小为原始图像加上指定边框大小，并且根据指定的边框类型进行填充。

 示例代码：

image = cv2.imread('./img/dog21.png')
image=cv2.cvtColor(image,cv2.COLOR_BGR2RGB)
# 定义填充参数
top_border = 10
bottom_border = 10
left_border = 10
right_border = 10

# 使用常数填充，填充值为0
bordered_image_constant = cv2.copyMakeBorder(image, top_border, bottom_border, left_border, right_border, cv2.BORDER_CONSTANT, value=0)

# 使用边界复制
bordered_image_replicate = cv2.copyMakeBorder(image, top_border, bottom_border, left_border, right_border, cv2.BORDER_REPLICATE)

# 使用边界反射
bordered_image_reflect = cv2.copyMakeBorder(image, top_border, bottom_border, left_border, right_border, cv2.BORDER_REFLECT)

# 使用边界反射101
bordered_image_reflect_101 = cv2.copyMakeBorder(image, top_border, bottom_border, left_border, right_border, cv2.BORDER_REFLECT_101)

# 使用边界包裹
bordered_image_wrap = cv2.copyMakeBorder(image, top_border, bottom_border, left_border, right_border, cv2.BORDER_WRAP)




# 创建子图
fig, ((ax1, ax2, ax3),(ax4, ax5,ax6)) = plt.subplots(2, 3, figsize=(20, 10), sharex=True, sharey=True)



# 显示图像
ax1.imshow(image.copy())
ax1.set_title('original')
ax2.imshow(bordered_image_constant)
ax2.set_title('constant')
ax3.imshow(bordered_image_replicate, cmap='gray')
ax3.set_title('replicate')
ax4.imshow(bordered_image_reflect, cmap='gray')
ax4.set_title('reflect')
ax5.imshow(bordered_image_reflect_101, cmap='gray')
ax5.set_title('reflect_101')
ax6.imshow(bordered_image_wrap, cmap='gray')
ax6.set_title('wrap')
plt.show()

Python OpenCV库中的边界填充通常用于图像处理，比如二值化后的边缘增强、腐蚀膨胀操作后的填补空洞等。边界填充函数cv2.floodFill()是一个常用工具。这个函数会在指定起点周围填充特定颜色，直到遇到另一个更大区域或者达到边界条件。

以下是一个基本的使用示例：

import cv2
import numpy as np

# 假设img是你的输入图像，前景像素是白色，背景是黑色
img = ...  # 你的图像数组

# 定义起始点和填充的颜色
seed_point = (x, y)  # 起始填充点的坐标
new_color = (255, 255, 255)  # 填充的新颜色，这里是白色

# 应用 floodFill
mask = np.zeros(img.shape[:2], dtype=np.uint8)
cv2.floodFill(img, mask, seed_point, new_color)

# 显示结果
cv2.imshow("Filled Image", img)
cv2.waitKey(0)
cv2.destroyAllWindows()

 7.数值计算

 

 cv2.add（）函数中，如果像素点相加之和超过255则最大只能为255，不超过则不变

8.图像融合

两个图片shape值如果不一样不能做数值计算

resize函数

 

 

 1.图像尺寸调整
cv2.resize(img,(w,h))：调整图像img尺寸到w*h；
cv2.resize(img,(0,0),fx=3,fy=1)：将w、h设置为0，fx为x向相对原图的比例，fy为y向相对于原图的比例，fx与fy大于1时图像为放大，小于1时为缩小。
2.图像融合
imgf=cv2.addWeighted(img1,α,img2,β,b)
img1与img2为需要融合的图像
α和β为两张图的融合系数
b为图像偏置量
计算方式：imgf=α×img1+β×img2+b
注意：两张可融合的图片必须尺寸一致，如不一致，需通过resize操作调整为一致方可融合
示例代码

import cv2
import os
os.chdir('e://text')
img1=cv2.imread('wanzi.png')
img2=cv2.imread('car.jpg')
def cv_show(name,img):
    cv2.imshow(name,img)
    cv2.waitKey(0)
    cv2.destroyAllWindows()
print(img1.shape)
print(img2.shape)
img2=cv2.resize(img2,(396,203))
#注意此句，img.shape的数值时(h,w),而resize需要的输入是(w,h),两者是颠倒的
print(img2.shape)
a=cv2.addWeighted(img,1,img2,0.5,0)
#注意：相加后，像素中加和超过255的值会被置为255
cv_show('a',a)