圖像金字塔（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