OpenCV基于Python图像金字塔_cv.pyrdown(

目标

通过本篇文章，你将学习到以下内容：

• 学习图像金字塔
• 使用图像金字塔创建一个新的水果“Orapple”
• 使用功能：cv.pyrUp()，cv.pyrDown()

1. 理论

通常，我们过去使用的是恒定大小的图像，但是在某些情况下，我们需要使用不同分辨率的（相同）图像。例如，当在图像中搜索某些东西（例如人脸）时，我们不确定对象将以多大的尺寸显示在图像中。在这种情况下，我们将需要创建一组具有不同分辨率的相同图像，并在所有图像中搜索对象，这些具有不同分辨率的图像集称为“图像金字塔”（因为当它们堆叠在底部时，最高分辨率的图像位于底部，最低分辨率的图像位于顶部时，看起来像金字塔）。

图像金字塔有两种：
1）高斯金字塔
2）拉普拉斯金字塔

1.1 高斯金字塔

高斯金字塔中的较高级别（低分辨率）是通过删除较低级别（较高分辨率）图像中的连续行和列而形成的。然后，较高级别的每个像素由基础级别的5个像素的贡献与高斯权重形成，通过这样做，M×N图像变成M/2 × N/2图像。因此面积减少到原始面积的四分之一，它被称为Octave。当我们在金字塔中越靠上时（即分辨率下降），这种模式就会继续。同样，在扩展时(向下)，每个级别的面积变为4倍。我们可以使用cv.pyrDown()和cv.pyrUp()函数找到高斯金字塔。

实现代码如下：

import numpy as np
import cv2 as cv

img = cv.imread('./data/lena.jpg')
# 高斯金字塔
level = 3
higher_reso = img.copy()
pyramids_images = []  # 空列表
for i in range(level):
	# 先对图像进行高斯平滑，然后再进行降采样（将图像尺寸行和列方向缩减半）
    lower_reso = cv.pyrDown(higher_reso)
    # 在列表末尾添加新的对象
    pyramids_images.append(lower_reso)
    cv.imshow('lower_reso' + str(i), lower_reso)
    higher_reso = lower_reso.copy()

cv.imshow('input image', img)
cv.waitKey()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

以下是图像金字塔中的4个级别，效果如下：

高斯金字塔效果

你可以使用cv.pyrUp()函数从一个低分辨率小尺寸的图像向下构建一个金字塔，该图像尺寸变大，但分辨率不会增加。

对上述生成的高斯金字塔第2层图像使用函数cv.pyrUd()查看图像

import numpy as np
import cv2 as cv

img = cv.imread('./data/lena.jpg')
# 高斯金字塔
level = 3
higher_reso = img.copy()
pyramids_images = []  # 空列表
for i in range(level):
    lower_reso = cv.pyrDown(higher_reso)
    pyramids_images.append(lower_reso)
    cv.imshow('lower_reso' + str(i), lower_reso)
    higher_reso = lower_reso.copy()

cv.imshow('input image', img)
cv.waitKey()

# 对上述生成的高斯金字塔第2层图像使用函数cv.pyrUd()
lower_reso0 = pyramids_images[0]
higher_reso2 = cv.pyrUp(lower_reso0)
cv.imshow('higher_reso2', higher_reso2)
cv.waitKey()
cv.destroyAllWindows()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

效果如下图所示：

cv.pyrUd()查看高斯金字塔第2层图像

注意：
当用cv.pyrDown()函数时，图像的分辨率会降低，信息就会被丢失。如果先使用cv.pyrDown()产生的中间图像再使用函数cv.pyrUp()产生图像，则与原图像相比分辨率差会很多。上述的高斯金字塔第2层图像使用函数cv.pyrUd()的效果显然比输入输图像的分辨率低。

下面的演示更能说明此结果：

import numpy as np
import cv2 as cv

img = cv.imread('./data/lena.jpg')

lower_reso = cv.pyrDown(img)
higher_reso = cv.pyrUp(lower_reso)

cv.imshow('img', img)
cv.imshow('lower_reso', lower_reso)
cv.imshow('higher_reso', higher_reso)
cv.waitKey()
1
2
3
4
5
6
7
8
9
10
11
12

img原图→lower_reso→higher_reso结果

1.2 拉普拉斯金字塔

拉普拉斯金字塔由高斯金字塔形成，没有特殊的功能。拉普拉斯金字塔图像像边缘图像，它的大多数像素值为零，主要用于图像压缩。拉普拉斯金字塔的层由高斯金字塔的层与其扩展层之间的差形成，即用高斯金字塔的每一层图像减去其上一层图像上采样并高斯卷积之后的预测图像，得到一系列的差值图像即为 LP 分解图像。拉普拉斯的三个等级效果如下所示（可以调整对比度以增强内容）：

import cv2
import numpy as np

# 高斯金字塔
def pyramid_demo(image):
    level = 3
    temp = image.copy()
    pyramids_images = []  # 空列表
    for i in range(level):
        dst = cv2.pyrDown(temp)  # 先对图像进行高斯平滑，然后再进行降采样（将图像尺寸行和列方向缩减一半）
        pyramids_images.append(dst)  # 在列表末尾添加新的对象
        cv2.imshow("pyramid_down_"+str(i), dst)
        temp = dst.copy()
    return pyramids_images

# 拉普拉斯金字塔
def lapalian_demo(image):
    pyramids_images = pyramid_demo(image)  # 拉普拉斯金字塔必须用到高斯金字塔的结果
    level = len(pyramids_images)
    # 递减
    for i in range(level-1, -1, -1):
        if i - 1 < 0:
            expand = cv2.pyrUp(pyramids_images[i], dstsize=image.shape[0:2])
            lpls = cv2.subtract(image, expand)
            cv2.imshow("lapalian_down_" + str(i), lpls)

        else:
            expand = cv2.pyrUp(pyramids_images[i], dstsize=pyramids_images[i - 1].shape[:2])
            lpls = cv2.subtract(pyramids_images[i - 1], expand)
            cv2.imshow("lapalian_down_" + str(i), lpls)

if __name__ == "__main__":
    img = cv2.imread("./data/lena.jpg")
    cv2.namedWindow("input image", cv2.WINDOW_AUTOSIZE)
    cv2.imshow("input image", img)
    lapalian_demo(img)
    cv2.waitKey(0)
    cv2.destroyAllWindows()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

拉普拉斯金字塔

2. 使用金字塔进行图像融合

金字塔的一种应用是图像融合。例如，在图像拼接中，您需要将两个图像堆叠在一起，但是由于图像灰度值之间的不连续性，可能使拼接效果不佳。在这种情况下，使用金字塔混合图像可以无缝混合，而不会在图像中保留大量数据。一个经典的例子是将两种水果，橙和苹果混合在一起，步骤如下：

1. 加载苹果和橙子的两个图像
2. 查找苹果和橙子的高斯金字塔（在此示例中， 级别数为6）
3. 在高斯金字塔中，找到其拉普拉斯金字塔
4. 然后在每个拉普拉斯金字塔级别中加入苹果的左半部分和橙子的右半部分
5. 最后从此融合图像金字塔中重建原始图像

代码如下（为简单起见，每个步骤都是单独进行的，这可能会占用更多的内存。如果需要，可以对其进行优化）：

import cv2 as cv
import numpy as np
import sys

# 加载图像
A = cv.imread('./data/apple.jpg')
B = cv.imread('./data/orange.jpg')
# 生成A的高斯金字塔
G = A.copy()
gpA = [G]
for i in range(6):
    G = cv.pyrDown(G)
    gpA.append(G)
# 生成B的高斯金字塔
G = B.copy()
gpB = [G]
for i in range(6):
    G = cv.pyrDown(G)
    gpB.append(G)
# 生成A的拉普拉斯金字塔
lpA = [gpA[5]]
for i in range(5, 0, -1):
    GE = cv.pyrUp(gpA[i])
    L = cv.subtract(gpA[i-1], GE)
    lpA.append(L)
# 生成B的拉普拉斯金字塔
lpB = [gpB[5]]
for i in range(5, 0, -1):
    GE = cv.pyrUp(gpB[i])
    L = cv.subtract(gpB[i-1], GE)
    lpB.append(L)
# 现在在每个级别中添加左右两半图像
LS = []
for la, lb in zip(lpA, lpB):
    rows, cols, dpt = la.shape
    # ls = np.hstack((la[:, 0:cols/2], lb[:, cols/2:]))
    ls = np.hstack((la[:, 0:cols // 2], lb[:, cols // 2:]))
    LS.append(ls)
# 现在重建
ls_ = LS[0]
for i in range(1, 6):
    ls_ = cv.pyrUp(ls_)
    ls_ = cv.add(ls_, LS[i])
# 图像与直接连接的每一半
# real = np.hstack((A[:, :cols/2], B[:, cols/2:]))
real = np.hstack((A[:, :cols//2], B[:, cols//2:]))

# opencv的一个像素为：[B,G,R] ,matplotlib的一个像素为：[R,G,B]
# 转换像素位置
A = cv.cvtColor(A, cv.COLOR_BGR2RGB)
B = cv.cvtColor(B, cv.COLOR_BGR2RGB)
real = cv.cvtColor(real, cv.COLOR_BGR2RGB)
ls_ = cv.cvtColor(ls_, cv.COLOR_BGR2RGB)
# 显示图像
plt.figure(figsize=(10, 10))
plt.subplot(2, 2, 1), plt.imshow(A), plt.title('input apple image')
plt.subplot(2, 2, 2), plt.imshow(B), plt.title('input orange image')
plt.subplot(2, 2, 3), plt.imshow(real), plt.title('Direct_blending')
plt.subplot(2, 2, 4), plt.imshow(ls_), plt.title('Pyramid_blending2')
plt.show()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

结果如下图所示：

金字塔图像融合

附加参考资源：
Image Blending：http://pages.cs.wisc.edu/~csverma/CS766_09/ImageMosaic/
imagemosaic.html