OpenCV 入门02

图像的基本操作：

访问像素值并修改它们 - 访问图像属性 - 设置感兴趣区域(ROI) - 分割和合并图像

本节中的几乎所有操作都主要与Numpy相关，而不是与OpenCV相关。要使用OpenCV编写更好的优化代码，需要Numpy的丰富知识

访问和修改像素值

import numpy as np
import cv2 as cv

if __name__ == '__main__':
    img = cv.imread('images/1.jpg')  # img 的数据是bgr 的
    # print(type(img)) # numpy.ndarray  类型
    # print(img.shape) # (1080, 1920, 3)

    # 1 访问（100,100） 位置的像素颜色值
    print(img[100, 100])
    # 2 访问（100,100） 位置的像素颜色值 中的 b的值
    print(img[100, 100, 0])
    # 3 修改（100,100）-> (200,200) 区域为红色
    img[100:200, 100:200] = [0, 0, 255]

    cv.imshow('hh', img)
    cv.waitKey(0)
    cv.destroyAllWindows()

View Code

访问图像属性

图像属性包括行数，列数和通道数，图像数据类型，像素数等

import numpy as np
import cv2 as cv

if __name__ == '__main__':
    img = cv.imread('images/1.jpg')  # img 的数据是bgr 的

    # 1 图像的 shape
    print(img.shape) # (1080, 1920, 3)  如果图像是灰度的，则返回的元组仅包含行数和列数，因此这是检查加载的图像是灰度还是彩色的好方法

    # 2 像素总数
    print(img.size)  # 1080*1920

    # 3 图形数据类型
    print(img.dtype) # uint8

    cv.imshow('hh', img)
    cv.waitKey(0)
    cv.destroyAllWindows()

View Code

拆分和合并图像通道

import numpy as np
import cv2 as cv

if __name__ == '__main__':
    img = cv.imread('images/1.jpg')  # img 的数据是bgr 的

    # 1 split to channel
    b, g, r = cv.split(img)
    # print(b.shape,g.shape,r.shape) # (1080, 1920) (1080, 1920) (1080, 1920)

    # 2 merge channel
    img2 = cv.merge((b, g, r))
    # print(img2.shape)  (1080, 1920,3)

    # ================================
    # 使用Numpy 索引代替 split,因为split耗时更长
    b = img[:, :, 0]
    g = img[:, :, 1]
    r = img[:, :, 2]
    # print(b.shape,g.shape,r.shape) # (1080, 1920) (1080, 1920) (1080, 1920)

    cv.imshow('hh', img)
    cv.waitKey(0)
    cv.destroyAllWindows()

View Code

为图像设置边框（填充）

import numpy as np
import cv2 as cv
from matplotlib import pyplot as plt

if __name__ == '__main__':
    # 如果要在图像周围创建边框（如相框），则可以使用cv.copyMakeBorder()。但是它在卷积运算，零填充等方面有更多应用
    img = cv.imread('images/1.jpg')
    img = img[...,::-1] # 将OpenCV 的bgr  变为rgb
    replicate = cv.copyMakeBorder(img, 200, 200, 200, 200, cv.BORDER_REPLICATE)
    reflect = cv.copyMakeBorder(img, 200, 200, 200, 200, cv.BORDER_REFLECT)
    reflect101 = cv.copyMakeBorder(img, 200, 200, 200, 200, cv.BORDER_REFLECT_101)
    wrap = cv.copyMakeBorder(img, 200, 200, 200, 200, cv.BORDER_WRAP)
    constant = cv.copyMakeBorder(img, 200, 200, 200, 200, cv.BORDER_CONSTANT, value=(255,0,0))
    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()

View Code

图像上的算术运算

图像的几种算术运算，例如加法，减法，按位运算 cv.add，cv.addWeighted

图像加法

默认使用cv.add ,它是饱和运算，当数值大于饱和值的时候，就是饱和值了。

import numpy as np
import cv2 as cv
from matplotlib import pyplot as plt

if __name__ == '__main__':
    # 通过OpenCV函数cv.add()或仅通过numpy操作res = img1 + img2添加两个图像。两个图像应具有相同的深度和类型，或者第二个图像可以只是一个标量值
    x = np.array([
        [
            [1, 2, 3],
            [1, 2, 3],
        ], [
            [1, 2, 3],
            [1, 2, 3],
        ]],dtype="uint8")
    y = np.array([
        [
            [1, 2, 3],
            [1, 2, 3],
        ], [
            [1, 2, 3],
            [1, 2, 3],
        ]],dtype="uint8")

    print(x, y)
    print("#================================")
    print(cv.add(x, y))
    print("#================================")
    print(x + y)  # Numpy 加法

    # 注意 OpenCV加法和Numpy加法之间有区别。OpenCV加法是饱和运算，而Numpy加法是模运算
    z = np.array([
        [
            [255, 255, 255],
            [255, 255, 255],
        ], [
            [255, 255, 255],
            [255, 255, 255],
        ],],dtype="uint8")
    print("#=============cv 是饱和运算===================")
    print(cv.add(x,z)) # cv 是饱和运算 一般使用它！！！
    print("#================================")
    print(x+z) # Numpy 的模运算

View Code

图像融合

import numpy as np
import cv2 as cv
from matplotlib import pyplot as plt

if __name__ == '__main__':
    img1 = cv.imread('images/0.jpg')  # (1080, 1920, 3)
    img2 = cv.imread('images/2.jpg')  # (1080, 1920, 3)
    # 第一幅图像的权重为0.7，第二幅图像的权重为0.3。
    dst = cv.addWeighted(img1, 0.7, img2, 0.3, 0)  # 注意 img1 和 img2 的shape 要一致
    cv.imshow('dst', dst)
    cv.waitKey(0)
    cv.destroyAllWindows()

View Code

按位运算

import cv2 as cv

if __name__ == '__main__':
    img1 = cv.imread("images/1.jpg")
    img2 = cv.imread("images/logo.png")

    # 把logo放在左上角，所以我创建了ROI （region of interest） 感兴趣的区域
    rows, cols, channels = img2.shape
    roi = img1[0:rows, 0:cols]

    # 现在创建logo的掩码，并同时创建其相反掩码
    img2gray = cv.cvtColor(img2, cv.COLOR_BGR2GRAY)
    cv.imshow("logogray",img2gray)

    _, mask = cv.threshold(img2gray, 100, 255, cv.THRESH_BINARY) # 二值化函数 黑底图片用THRESH_BINARY， 白底用THRESH_BINARY_INV
    mask_inv = cv.bitwise_not(mask)
    cv.imshow("mask",mask)

    # 从logo图像中提取logo区域
    img2_fg = cv.bitwise_and(img2, img2, mask=mask)  # fg:foreground  前景

    # 现在将ROI中的logo的区域涂黑
    img1_bg = cv.bitwise_and(roi, roi, mask=mask_inv) # 位运算& # bg:background  背景

    # 将logo放入ROI并修改主图像
    dst = cv.add(img1_bg, img2_fg)
    img1[0:rows, 0:cols] = dst
    cv.imshow('res', img1)
    cv.waitKey(0)
    cv.destroyAllWindows()

View Code

logo 原图：

练习题：

使用cv.addWeighted函数在文件夹中创建图像的幻灯片放映，并在图像之间进行平滑过渡

import cv2 as cv

if __name__ == '__main__':
    # 加载文件夹的图片
    l = []
    for i in range(6):
        l.append(cv.imread(f'images/{i}.jpg'))

    cv.namedWindow('ppt', True)
    dst = cv.addWeighted(l[0], 1, l[1], 0, 0)
    cv.imshow('ppt', dst)

    for idx in range(len(l) - 1):
        a = 1
        img1 = l[idx]
        img2 = l[idx + 1]
        cv.waitKey(0)
        while a >= 0:
            dst = cv.addWeighted(img1, a, img2, 1 - a, 0)
            cv.imshow('ppt', dst)
            cv.waitKey(100)
            a -= 0.1
cv.destroyAllWindows()

View Code

效果：

注：点击任意键切换图片

性能衡量和提升技术

在图像处理中，由于每秒要处理大量操作，因此必须使代码不仅提供正确的解决方案，而且还必须以最快的方式提供，

因此我们要了解：

1，衡量代码的性能

2，一些提高代码性能的技巧

cv.getTickCount，cv.getTickFrequency

衡量性能：

import cv2 as cv

# OpenCv 获取程序执行时间
# img1 = cv.imread('images/1.jpg')
# e1 = cv.getTickCount()
# for i in range(5, 49, 2):
#     img1 = cv.medianBlur(img1, i)
# e2 = cv.getTickCount()
# t = (e2 - e1) / cv.getTickFrequency()
# print(t) # 3.8622963

# time  库获取执行时间 
import time
img1 = cv.imread('images/1.jpg')
t1 = time.time()
for i in range(5, 49, 2):
    img1 = cv.medianBlur(img1, i)
e2 = cv.getTickCount()
print(time.time() - t1) # 3.5017619132995605

View Code

OpenCV 默认优化：

import cv2 as cv


# 许多 OpenCV 函数都是使用 SSE2、 AVX 等进行优化的
# 检查是否启用了优化
print(cv.useOptimized())
cv.setUseOptimized(False)
print(cv.useOptimized())

View Code

性能优化的措施：

尽量避免在Python中使用循环，尤其是双/三重循环等。它们本来就很慢。
由于Numpy和OpenCV已针对向量运算进行了优化，因此将算法/代码向量化到最大程度。
利用缓存一致性。
除非需要，否则切勿创建数组的副本。尝试改用视图。数组复制是一项昂贵的操作。

即使执行了所有这些操作后，如果你的代码仍然很慢，或者不可避免地需要使用大循环，请使用Cython等其他库来使其更快。

OpenCV 中的图像处理

HSV:

HSV H  色调  S 饱和度 V 明度，根据颜色的直观特性由A. R. Smith在1978年创建的一种颜色空间, 也称六角锥体模

Note：OpenCV 中的HSV的色调范围为[0,179]，饱和度范围为[0,255]，值范围为[0,255]。不同的软件使用不同的规模。因此，如果你要将OpenCV值和它们比较，你需要将这些范围标准化。

改变颜色空间：

如何将图像从一个色彩空间转换到另一个，像BGR↔灰色，BGR↔HSV等

如何创建一个应用程序，以提取视频中的彩色对象

cv.cvtColor，cv.inRange

改变颜色空间：

import cv2 as cv
import numpy as np

# OpenCV中有超过150种颜色空间转换方法。但是我们将研究只有两个最广泛使用的,BGR↔灰色和BGR↔HSV。
if __name__ == '__main__':
    # 1
    # cvtColor(input_image, flag)，其中flag决定转换的类型
    # 如何获取flag ，请参考下面代码：
    # flags = [i for i in dir(cv) if i.startswith('COLOR_')]

    # 2
    # 取视频的每一帧 -> 转换从BGR到HSV颜色空间 -> 对HSV图像设置红色范围的阈值
    cap = cv.VideoCapture(0)
    while 1:
        # 读取帧
        _, frame = cap.read()
        # 转换颜色空间 BGR 到 HSV
        hsv = cv.cvtColor(frame, cv.COLOR_BGR2HSV)
        # 定义HSV中红色的范围
        lower_red = np.array([150, 50, 50])
        upper_red = np.array([180, 255, 255])
        # 设置HSV的阈值使得只取红色
        mask = cv.inRange(hsv, lower_red, upper_red)
        res = cv.bitwise_and(frame, frame, mask=mask)
        cv.imshow('frame', frame)
        cv.imshow('mask', mask)
        cv.imshow('res', res)
        k = cv.waitKey(10)
        if k == 27:
            break
    cv.destroyAllWindows()

View Code

1，捕捉相机中的红色元素：

左为原图，中为mask ,右为计算后的（图像中有一些噪点）。

OpenCV HSV 大致范围（参考）：

使用程序将 bgr 转为 hsv：

import cv2 as cv
import numpy as np


def myBgr2Hsv(bgr):
    hsvColor = cv.cvtColor(bgr, cv.COLOR_BGR2HSV)
    print(hsvColor)


if __name__ == '__main__':
    # 1 将bgr 颜色转化为 openCV 中的 HSV值
    myBgr2Hsv(np.uint8([[[203, 192, 255]]]))  # pink
    myBgr2Hsv(np.uint8([[[0, 0, 255]]]))  # red

View Code

2，练习题：

尝试找到一种方法来提取多个彩色对象，例如，同时提取红色，蓝色，绿色对象

答案： Just add then together

import cv2 as cv
import numpy as np

if __name__ == '__main__':
    cap = cv.VideoCapture(0)
    while 1:
        _, frame = cap.read()
        # Convert BGR to HSV
        hsv = cv.cvtColor(frame, cv.COLOR_BGR2HSV)

        # define range of color in HSV
        lower_red = np.array([150, 50, 50])
        upper_red = np.array([179, 255, 255])

        lower_green = np.array([35, 50, 50])
        upper_green = np.array([77, 255, 255])

        lower_blue = np.array([100, 50, 50])
        upper_blue = np.array([125, 255, 255])

        red_mask = cv.inRange(hsv, lower_red, upper_red)
        green_mask = cv.inRange(hsv, lower_green, upper_green)
        blue_mask = cv.inRange(hsv, lower_blue, upper_blue)
        mask = red_mask + blue_mask + green_mask

        # Bitwise-AND mask and original image
        res = cv.bitwise_and(frame, frame, mask=mask)

        cv.imshow('frame', frame)
        cv.imshow('mask', mask)
        cv.imshow('res', res)
        k = cv.waitKey(5)
        if k == 27:
            break

    cv.destroyAllWindows()

View Code

图像的几何变换

将不同的几何变换应用到图像上，如平移、旋转、仿射变换 cv.getPerspectiveTransform

OpenCV提供了两个转换函数cv.warpAffine和cv.warpPerspective，您可以使用它们进行各种转换。cv.warpAffine采用2x3转换矩阵，而cv.warpPerspective采用3x3转换矩阵作为输入。

缩放：

import cv2 as cv
import numpy as np

if __name__ == '__main__':
    # 1
    # 放大 为原来的2倍 使用插值方法为 cv.INTER_CUBIC
    img = cv.imread('images/1.jpg')
    # print(img.shape)  # (1080, 1920, 3)
    cv.imshow("img", img)
    res1 = cv.resize(img, None, fx=2, fy=2, interpolation=cv.INTER_CUBIC)
    # print(res1.shape) # (2160, 3840, 3)
    cv.imshow("res1", res1)

    # 或
    # height, width = img.shape[:2]
    # res2 = cv.resize(img, (2 * width, 2 * height), interpolation=cv.INTER_CUBIC)
    
    cv.waitKey(0)
    cv.destroyAllWindows()