计算机视觉OpenCv学习系列：第五部分、颜色操作

第一节、颜色表操作

1.查找表LUT(look up table)

---

查找表可以降低运算时间，实现线性计算时间。

如下图所示0-4分别对应四种颜色。0-4叫做索引(index)。

• 首先构建LUT表
• 循环图像中的索引，去LUT中找对应的颜色
• 用空间换时间

2.颜色查找表

---

变换不同色彩的时候可以通过颜色查找表实现。

（1）Gamma校正

Gamma校正 – 在图像预处理的时候经常使用

• 公式p(x, y)表示输入图像像素值，Gamma为最终输出的一个数。

• 像素值取值范围在0~255之间，每一个值对应一个输出值，这样映射关系，可以先建立查找表LUT
• 根据输入得像素值作为index，在LUT中直接映射读取得到gamma校正之后得值
• 对256x256大小的图像，计算量对比：
  • 不应用找表计算gamma - 65536次，
  • 应用查找表计算gamma – 256次

gamma校正示例：

（2）OpenCV默认的查找表

OpenCV中默认的查找表api，cv.applyColorMap

cv.applyColorMap(src, colormap[, dst]) --> dst
1. 第一个参数输入图像
2. 第二个参数是颜色表
3. dst返回图像

下面是色彩表类型：

3.代码练习与测试

---

（1）多种颜色查找表

# 自定义颜色查找表与系统自带的颜色查找表
def lut_demo():
    cv.namedWindow("lut-demo", cv.WINDOW_NORMAL)
    # 构建一个查找表，lut数组是一些随机的颜色
    lut = [[255, 0, 255], [125, 0, 0], [127, 255, 200], [200, 127, 127], [0, 255, 255]]
    m1 = np.array([[2, 1, 3, 0], [2, 2, 1, 1], [3, 3, 4, 4], [4, 4, 1, 1]])
    m2 = np.zeros((4, 4, 3), dtype=np.uint8)
    # 用索引和颜色做对应
    for i in range(4):
        for j in range(4):
            index = m1[i, j]
            m2[i, j] = lut[index]
    # 按照索引输出对应颜色
    cv.imshow("lut-demo", m2)
    cv.waitKey(0)
    cv.destroyAllWindows()

    # 读取图片
    image = cv.imread(r"F:\python\opencv-4.x\samples\data\butterfly.jpg")
    cv.imshow("input", image)
    cv.namedWindow("butterfly-gamma", cv.WINDOW_AUTOSIZE)

    # 1.建立查找表，直接使用索引对应颜色表示图片
    lut2 = np.zeros((256), dtype=np.uint8)
    gamma = 0.7  # 假定gamma为0.7
    for i in range(256):
        if i == 0:  # 这个是因为i = 0的时候，log(o/255.0)不存在，所以我自己找了个-6.0代替了一下
            print(i, "---", -6.0)
            lut2[i] = int(np.exp(-6.0 * gamma) * 255.0)  # gamma校正的公式
        else:
            print(i, "---", np.log(i / 255.0))
            lut2[i] = int(np.exp(np.log(i / 255.0) * gamma) * 255.0)  # gamma校正的公式
    print(lut2)
    h, w, c = image.shape
    for row in range(h):
        for col in range(w):
            b, g, r = image[row, col]
            image[row, col] = (lut2[b], lut2[g], lut2[r])   # 直接用查找表的索引表示图片
    cv.imshow("butterfly-gamma", image)
    cv.waitKey(0)

    # 2.自定义颜色查找表
    # 注意自己定义颜色查找表的时候第一个维度永远是256，表示总共有0-255种颜色
    # 第二个维度是宽度只有1列，因为每个位置上面有一个值就可以了
    # 第三个维度表示通道数，可以是三通道也可以是单通道
    lut3 = np.zeros((256, 1, 3), dtype=np.uint8)
    for i in range(256):
        if i == 0:  # 这个是因为i = 0的时候，log(o/255.0)不存在，所以我自己找了个-6.0代替了一下
            print(i, "---", -6.0)
            c = int(np.exp(-6.0 * gamma) * 255.0)  # gamma校正的公式
        else:
            print(i, "---", np.log(i / 255.0))
            c = int(np.exp(np.log(i / 255.0) * gamma) * 255.0)  # gamma校正的公式
        lut3[i, 0] = (c, c, c)
    print(lut3)
    dst = cv.LUT(image, lut3)  # 使用自定义的查找表
    cv.imshow("butterfly-gamma", dst)
    cv.waitKey(0)

    # 3.使用系统自带的COLORMAP_PINK颜色查找表
    dst = cv.applyColorMap(image, cv.COLORMAP_PINK)
    cv.imshow("butterfly-pink", dst)
    cv.waitKey(0)
    
    # 4.使用系统自带的COLORMAP_JET颜色查找表
    dst = cv.applyColorMap(image, cv.COLORMAP_JET)
    cv.imshow("butterfly-jet", dst)
    cv.waitKey(0)

    cv.destroyAllWindows()

结果示例：

对于自己给定的一些颜色设计的LUT查找表：

下面几张图从左到右分别是：

1. 读入的原图片
2. 在gamma=0.7的条件下使用自定义的颜色查找表直接对原图片相应使用索引
3. 在gamma=0.7的条件下对原图片使用自定义颜色查找表
4. 对原图片使用系统自带的COLOR_PINK颜色查找表

5. 对原图片使用系统自带的COLOR_JET颜色查找表

（2）滚动条+颜色查找表

将示例中的系统自带的颜色查找表存储在数组中，添加到滚动条中实现不同颜色查找表的切换。

# 用滚动条做系统自带的颜色查找表
def trackbar_lut_callback(pos):
    print(pos)


def trackbar_lut_demo():
    arr = [0, 1, 17, 8, 21, 11, 9, 14, 2, 13, 5, 12, 10, 15, 4, 7, 6, 20, 18, 19]
    image = cv.imread(r"F:\python\opencv-4.x\samples\data\butterfly.jpg")
    cv.namedWindow("trackbar_lut_demo", cv.WINDOW_AUTOSIZE)
    cv.createTrackbar("colormap", "trackbar_lut_demo", 0, 21, trackbar_lut_callback)  # callback先注册后使用
    cv.imshow("trackbar_lut_demo", image)
    while True:
        pos = cv.getTrackbarPos("colormap", "trackbar_lut_demo")
        # 颜色查找表
        if pos in arr:
            dst = cv.applyColorMap(image, pos)
            cv.imshow("trackbar_lut_demo", dst)
        else:
            cv.imshow("trackbar_lut_demo", image)
        # 1ms获取一次键值，默认是 - 1，ESC是27
        c = cv.waitKey(1)
        if c == 27:  # 按ESC建终止调整亮度功能
            break
    cv.waitKey(0)  # 按任意建关闭窗口
    cv.destroyAllWindows()

结果示例：

第二节、随机数与随机颜色

1.随机数与随机颜色

---

OpenCV中的随机数都是使用的Numpy中的random随机函数：

random.randint(low, high=None, size=None, dtype=int) 
# Low表低值，high表示高值，size表示维度，dtype表示类型
np.random.randint(256)
np.random.randint(0, 256)
# 表示产生0~255随机数，类型是int
np.random.randint(0, 256, size=3) 
# size 随机数的尺寸，默认是返回单个，输入3 返回 3个，输入 (3,4） 返回的是一个 3*4 的二维数组。

随机噪声图：

cv.randn(dst, mean, stddev)
# 生成目标图像dst
# 噪声均值mean
# 噪声方差stddev
cv.randn(canvas, (40, 200, 140), (10, 50, 10)) # 噪声图像三个通道的均值分别是40、200、140，方差分别是10、50、10

2.随机绘制

---

随机颜色：

• 修改color和thickness参数实现随机的绘制或者填充

• 位置随机，颜色随机

随机噪声图像：

• 修改mean与stddev参数实现随机噪声图像

3.代码练习与测试

---

# 随机颜色+随机噪声
def random_demo():
    # 设置512*512*3的图像作为画布
    canvas = np.zeros((512, 512, 3), dtype=np.uint8)
    # 随即绘制
    while True:
        # 随机的颜色
        b, g, r = np.random.randint(0, 256, size=3)
        # 随机坐标起点(x1, y1)，终点（x2, y2）
        x1 = np.random.randint(0, 512)
        x2 = np.random.randint(0, 512)
        y1 = np.random.randint(0, 512)
        y2 = np.random.randint(0, 512)
        cv.rectangle(canvas, (x1, y1), (x2, y2), (int(b), int(g), int(r)), -1, 8)
        cv.imshow("canvas", canvas)
        # 50ms获取一次键盘值，默认是-1，ESC是27
        c = cv.waitKey(50)
        if c == 27:
            break
        # 重新绘制背景画布
        cv.rectangle(canvas, (0, 0), (512, 512), (0, 0, 0), -1, 8)  # 擦除之前所绘制的内容
        
    # 随机产生噪声图片
    # cv.randn(canvas, (40, 200, 140), (10, 50, 10))
    cv.randn(canvas, (120, 100, 140), (30, 50, 20))
    cv.imshow("noise image", canvas)

    cv.waitKey(0)
    cv.destroyAllWindows()

注释掉重新绘制画布背景 cv.rectangle(canvas, (0, 0), (512, 512), (0, 0, 0), -1, 8) 之后结果和随机产生噪声的结果示例：

给图片添加噪声：

# 给图片添加噪声
def random_demo_2():
    # 设置512*512*3的图像作为画布
    canvas = np.zeros((512, 512, 3), dtype=np.uint8)
    # 给512*512*3的图片添加噪声
    image = cv.imread(r"F:\python\opencv-4.x\samples\data\lena.jpg")
    # 定义三个随机数
    while True:
        n1 = np.random.randint(0, 100)
        n2 = np.random.randint(0, 100)
        n3 = np.random.randint(0, 100)
        # 将随机数作为噪声的均值和方差
        cv.randn(canvas, (n1, n2, n3), (n1, n2, n3))
        # 在原图中添加噪声
        dst = cv.add(image, canvas)
        cv.imshow("add noise image", dst)
        # 1000ms即1s获取一次键盘值，默认是-1，ESC是27
        c = cv.waitKey(1000)
        if c == 27:
            break
        # 重新绘制背景画布
        cv.rectangle(canvas, (0, 0), (512, 512), (0, 0, 0), -1, 8)  # 擦除之前所绘制的内容

    cv.waitKey(0)
    cv.destroyAllWindows()

结果示例：

第三节、通道分离与合并

1.通道分离与合并

---

通道分离是针对于多通道的图片来说的，如下图我们将一个RGB的彩色图像分离成R、G、B三个通道，最后再合并。

通道分离的原因：可能对某一个单独的通道进行处理，处理完之后再合并。

• RGB/HSV彩色通道分离为单独通道
• 针对不同通道使用不同阈值提取mask
• 提取其中一个通道的信息。

2.函数解释

---

分离函数：

# 通道分离函数
1. cv.split(m[, mv]) --> mv
# m表示输入图像,必须是多通道图像
# mv表示输出的，是多通道分离出来的单通道的数组

合并与混合函数：

# 通道合并
2. cv.merge(mv[, dst])--> dst
# mv表示各个通道
3. cv.mixChannels(src, dst, fromTo)--> dst
# src表示输入多通道图像
# fromTo表示通道索引，例如可以通过调整通道索引把BGR变成RGB（0, 1, 2）--> (2, 1, 0)
# dst表示返回结果

通道阈值：

4. cv.inRange(	src, lowerb, upperb[, dst]) -->	dst
# 其中src是输入图像
# Lowerb是低值
# Upperb是高值
# 只取在Lowerb - Upperb之间的图像变成255，其余部分都变成0
# dst = (lowerb < src < upperb)
# 输出的dst是一个二值mask图像（黑白图像）
# 白色区域是符合约束条件的，黑色区域是背景

3.代码练习与测试

---

# 通道分离与合并
def channel_splits():
    image = cv.imread(r"F:\python\opencv-4.x\samples\data\butterfly.jpg")
    cv.namedWindow("butterfly", cv.WINDOW_AUTOSIZE)
    cv.imshow("butterfly", image)

    # 通道分割
    mv = cv.split(image)
    cv.imshow("B", mv[0])
    cv.imshow("G", mv[1])
    cv.imshow("R", mv[1])
    cv.waitKey(0)
    cv.destroyAllWindows()

    # 通道合并
    mv2 = cv.merge(mv)
    cv.imshow("merge", mv2)
    mv[1][:, :] = 255  # 修改其中一个通道的颜色为全白
    mv3 = cv.merge(mv)
    cv.imshow("merge_1", mv3)
    cv.waitKey(0)
    cv.destroyAllWindows()

    # BGR2RGB
    dst = np.zeros_like(image)
    cv.mixChannels([image], [dst], fromTo=[0, 1, 2, 2, 1, 0])  # (0,1,2)->(2,1,0)
    cv.imshow("mix_channels", dst)
    cv.waitKey(0)
    cv.destroyAllWindows()

    # 通道阈值
    # mask = cv.inRange(image, (43, 46, 100), (128, 200, 200))  #阈值范围为(43, 46, 100), (128, 200, 200)
    mask = cv.inRange(image, (20, 46, 80), (128, 230, 180))  # 阈值范围为(20, 46, 80), (128, 230, 180)
    cv.imshow("inRange", mask)
    cv.waitKey(0)
    cv.destroyAllWindows()

1. 通道分离：

2. 通道合并：

3. BGR与RGB交换通道顺序：

4. 设置通道阈值

   中间图为将颜色在(43, 46, 100) ~ (128, 200, 200)之间的变成白色，其余部分变成黑色。

​ 右图为，将颜色在(20, 46, 80) ~ (128, 230, 180)之间变成白色其余变成黑色。

# BGR2HSV + inRange
def bgr2rgb_inrange():
    image = cv.imread(r"F:\python\opencv-4.x\samples\data\butterfly.jpg")
    cv.namedWindow("butterfly", cv.WINDOW_AUTOSIZE)
    cv.imshow("butterfly", image)

    # BGR2HSV
    hsv = cv.cvtColor(image, cv.COLOR_BGR2HSV)

    # inRange
    mask = cv.inRange(hsv, (43, 46, 100), (128, 200, 200))
    mask2 = cv.inRange(hsv, (20, 46, 80), (128, 230, 180))
    cv.imshow("bgr2rgb_inrange_1", mask)
    cv.imshow("bgr2rgb_inrange_2", mask2)
    cv. waitKey(0)
    cv.destroyAllWindows()

结果示例：

学习参考

本系列所有OpenCv相关的代码示例和内容均来自博主学习的网站：opencv_course