图像金字塔（Python实现）

图像金字塔（Python实现）
1 简介
在图像处理中常常会调整图像大小,最长的就是放大(zoom in)和缩小(zoom out),尽管集合变换也可以实现图像放大或者缩小
一个图像金字塔式一系列的图像组成,最底下一张式图像尺寸最大,最上方的图像尺寸最小,从空间上从上向下看,就可以看成埃及金字塔.
高斯金字塔–用来对 图像进行降采样
拉普拉斯金字塔–用来重建一张图片根据他的上层降采样图片
2 高斯金字塔
高斯金字塔式从底向上,逐层降采样得到.

降采样之后图像大小式原来 图像的M*N的M/2*N/2,就是对原图像删除偶数行与列,即得到降采样之后上一层的图片

步骤:

对当前层进行高斯模糊
删除当前层的偶数行与列
即可得到上一层的图像,这样上一层跟下一层对比,都只有 他的1/4大小
在这个过程中是一层一层的实现的，不能凭空跳跃多层．

3 高斯不同(Difference of Gaussian -DOG)
Difference of Gaussian(DOG)是高斯函数的差分。可以通过图像与高斯函数进行卷积得到一副图像的低通滤波结果，即去噪过程，这里的高斯和低通高斯式一样的，是一个函数，即为正态分布函数．高斯函数为： 
Ｇ(x)=12πσ2−−−−√e−x22σ2
Ｇ(x)=12πσ2e−x22σ2

那么Difference of Gaussian即高斯函数查分是两附图高斯图像的差.即: 
f(x;μ,σ1,σ2)=1σ12π−−√e−(x−μ)22μ2−1σ22π−−√e−(x−μ)22σ22
f(x;μ,σ1,σ2)=1σ12πe−(x−μ)22μ2−1σ22πe−(x−μ)22σ22
定义:就是把同一张图像在不同的参数下做高斯模糊之后的结果相减,得到的输出图像.称为高斯不同(DOG).
高斯不同式图像的内在特征,在灰度图像增强\角点检测中经常用到.
对于采用的每一层我们都可以做DOG，然后再做下一步的采样
通过高斯不同可以获得图像的轮廓,或者角点.
4 Opencv采样API
详见代码部分.

参考文献
DOG角点检测——opencv实现
DoG (Difference of Gaussian)角点检测
--------------------- 
作者：DataH 
来源：CSDN 
原文：https://blog.csdn.net/weixin_41863685/article/details/81916605 
版权声明：本文为博主原创文章，转载请附上博文链接！

pytorch实现卷积：

class GaussianBlur(nn.Module):
    def __init__(self):
        super(GaussianBlur, self).__init__()
        kernel = [[0.03797616, 0.044863533, 0.03797616],
                  [0.044863533, 0.053, 0.044863533],
                  [0.03797616, 0.044863533, 0.03797616]]
        kernel = torch.FloatTensor(kernel).unsqueeze(0).unsqueeze(0)
        self.weight = nn.Parameter(data=kernel, requires_grad=False)
 
    def forward(self, x):
        x1 = x[:, 0]
        x2 = x[:, 1]
        x3 = x[:, 2]
        x1 = F.conv2d(x1.unsqueeze(1), self.weight, padding=2)
        x2 = F.conv2d(x2.unsqueeze(1), self.weight, padding=2)
        x3 = F.conv2d(x3.unsqueeze(1), self.weight, padding=2)
        x = torch.cat([x1, x2, x3], dim=1)
        return x
 这里为了网络模型需要写成了一个类，这里假设输入的x也就是经过网络提取后的三通道特征图（当然不一定是三通道可以是任意通道）

如果是任意通道的话，使用torch.expand(）向输入的维度前面进行扩充。如下：

    def blur(self, tensor_image):
        kernel = [[0.03797616, 0.044863533, 0.03797616],
               [0.044863533, 0.053, 0.044863533],
               [0.03797616, 0.044863533, 0.03797616]]
       
        min_batch=tensor_image.size()[0]
        channels=tensor_image.size()[1]
        out_channel=channels
        kernel = torch.FloatTensor(kernel).expand(out_channel,channels,3,3)
        self.weight = nn.Parameter(data=kernel, requires_grad=False)
 
        return F.conv2d(tensor_image,self.weight,1,1)
--------------------- 
作者：亮亮兰 
来源：CSDN 
原文：https://blog.csdn.net/lyl771857509/article/details/84113177 
版权声明：本文为博主原创文章，转载请附上博文链接！

 

在这里我将以Python3.6.1，Opencv 3.2版本进行代码展示和讲解。

图像金字塔主要涉及两个函数：cv2.pyrUp()（图像尺寸变小），cv2.pyrDown()（图像尺寸变大，但会模糊）

图像金字塔有两类类型：高斯金字塔和拉普拉斯金字塔。

高斯金字塔cv2.pyrUp() 的效果

高斯金字塔将小图变大图用，cv2.pyrDown()，但是图像会模糊

对于拉普拉斯金字塔，其计算公式与高斯金字塔相关，具体为

Li=Gi-pyrUp(Gi+1), 其中i和i+1为下角标

import cv2
import numpy as np
A = cv2.imread('apple.jpg')
B = cv2.imread('orange.jpg')
# generate Gaussian pyramid for A
G = A.copy()
gpA = [G]
for i in np.arange(6):     #将苹果进行高斯金字塔处理，总共六级处理
    G = cv2.pyrDown(G)
    gpA.append(G)
# generate Gaussian pyramid for B
G = B.copy()
gpB = [G]
for i in np.arange(6):  # #将橘子进行高斯金字塔处理，总共六级处理
    G = cv2.pyrDown(G)
    gpB.append(G)
# generate Laplacian Pyramid for A
lpA = [gpA[5]]               
for i in np.arange(5,0,-1):    #将苹果进行拉普拉斯金字塔处理，总共5级处理
    GE = cv2.pyrUp(gpA[i])
    L = cv2.subtract(gpA[i-1],GE)
    lpA.append(L)
# generate Laplacian Pyramid for B
lpB = [gpB[5]]
for i in np.arange(5,0,-1):    #将橘子进行拉普拉斯金字塔处理，总共5级处理
    GE = cv2.pyrUp(gpB[i])
    L = cv2.subtract(gpB[i-1],GE)
    lpB.append(L)
# Now add left and right halves of images in each level
#numpy.hstack(tup)
#Take a sequence of arrays and stack them horizontally
#to make a single array.
LS = []
for la,lb in zip(lpA,lpB):
    rows,cols,dpt = la.shape
    ls = np.hstack((la[:,0:cols//2], lb[:,cols//2:]))    #将两个图像的矩阵的左半部分和右半部分拼接到一起
    LS.append(ls)
# now reconstruct
ls_ = LS[0]   #这里LS[0]为高斯金字塔的最小图片
for i in xrange(1,6):                        #第一次循环的图像为高斯金字塔的最小图片，依次通过拉普拉斯金字塔恢复到大图像
    ls_ = cv2.pyrUp(ls_)
    ls_ = cv2.add(ls_, LS[i])                #采用金字塔拼接方法的图像
# image with direct connecting each half
real = np.hstack((A[:,:cols/2],B[:,cols/2:]))   #直接的拼接
cv2.imwrite('Pyramid_blending2.jpg',ls_)
cv2.imwrite('Direct_blending.jpg',real)
--------------------- 
作者：Lecol_leng 
来源：CSDN 
原文：https://blog.csdn.net/jjddss/article/details/73469348 
版权声明：本文为博主原创文章，转载请附上博文链接！

pytorch实现LP 金子塔：https://github.com/mtyka/laploss/blob/master/laploss.py

https://ptorch.com/news/115.html