利用奇異值分解(SVD)進行圖像壓縮-python實現

首先要聲明，圖片的算法有很多，如JPEG算法，SVD對圖片的壓縮可能並不是最佳選擇，這里主要說明SVD可以降維

相對於PAC（主成分分析），SVD（奇異值分解）對數據的列和行都進行了降維，左奇異矩陣可以用於行數的壓縮。相對的，右奇異矩陣可以用於列數即特征維度的壓縮，也就是我們的PCA降維。

一張二維n*m的灰度圖片可以看做是n*m的矩陣，利用SVD可以實現對二維圖像的壓縮

1、按照灰度圖片進行壓縮：

#-*- coding: utf-8 -*
import numpy as np
from PIL import Image

def svd_restore(sigma, u, v, K):
    K = min(len(sigma)-1, K)            #當K超過sigma的長度時會造成越界
    print 'Now restore the image with %d ranks' % K
    m = len(u)
    n = v[0].size
    SigRecon = np.zeros((m, n))         #新建一int矩陣，儲存恢復的灰度圖像素
    for k in range(K+1):                #計算X=u*sigma*v
        for i in range(m):
            SigRecon[i] += sigma[k] * u[i][k] * v[k]
    SigRecon = SigRecon.astype('uint8') #計算得到的矩陣還是float型，需要將其轉化為uint8以轉為圖片
    Image.fromarray(SigRecon).save("svd_" + str(K) + "_" +image_file) #保存灰度圖
    
image_file = u'1.jpg'
if __name__ == '__main__':
    im = Image.open(image_file)    #打開圖像文件
    im = im.convert('L')           #將原圖像轉化為灰度圖
    im.save("Gray_" + image_file)  #保存灰度圖
    w, h = im.size                 #得到原圖的長與寬
    dt = np.zeros((w, h), 'uint8') #新建一int矩陣，儲存灰度圖各像素點數據
    for i in range(w):             #逐像素點復制，由於直接對im.getdata()進行數據類型轉換會有偏差
        for j in range(h):
            dt[i][j] = im.getpixel((i, j))
    dt = dt.transpose()            #復制過來的圖像是原圖的翻轉，因此將其再次翻轉到正常角度
    u, sigma, v = np.linalg.svd(dt)#調用numpy庫進行SVM
    u = np.array(u)                #轉為array格式，方便進行乘法運算
    v = np.array(v)                #同上
    for k in [1, 10, 20, 30, 50, 80, 100, 150, 200, 300, 500]:
        svd_restore(sigma, u, v, k)#使用前k個奇異值進行恢復

奇異值分別取1, 10, 20, 30, 50, 80, 100, 150, 200, 300, 500的降維壓縮效果（原始圖片為1.jpg）

2、按照彩色圖片進行壓縮

#-*- coding: utf-8 -*
from PIL import Image 
import numpy as np 
def rebuild_img(u, sigma, v, p):#p表示奇異值的百分比 
    #print p 
    m = len(u) 
    n = len(v) 
    a = np.zeros((m, n)) 

    count = (int)(sum(sigma)) 
    curSum = 0 
    k = 0 
    print sigma[0:2],count* p
    while curSum <= count * p:
        uk = u[:, k].reshape(m, 1)
        vk = v[k].reshape(1, n) 
        #print curSum,count,'--------',k
        a += sigma[k] * np.dot(uk, vk)
        curSum += sigma[k] 
        k += 1
        #print k
    
    print 'k:',k 
    a[a < 0] = 0 
    a[a > 255] = 255
     #按照最近距離取整數，並設置參數類型為uint8 
    return np.rint(a).astype("uint8") 
if __name__ == '__main__':
    img = Image.open(u'招商.jpg', 'r')
    a = np.array(img)
    #print a[:, :, 0]
    # u, sigma, v = np.linalg.svd(a[:, :, 0])
    # R = rebuild_img(u, sigma, v, 0.9)

    for p in np.arange(0.1, 1, 0.1):
        u, sigma, v = np.linalg.svd(a[:, :, 0])
        R = rebuild_img(u, sigma, v, p)
        u, sigma, v = np.linalg.svd(a[:, :, 1])
        G = rebuild_img(u, sigma, v, p)
        u, sigma, v = np.linalg.svd(a[:, :, 2])
        B = rebuild_img(u, sigma, v, p)
        I = np.stack((R, G, B), 2)
        #保存圖片在img文件夾下
        Image.fromarray(I).save("aq\\svd_" + str(int(p * 100)) + ".jpg")

RGB三個通道信息量均按照按照0.1-0.9壓縮的圖片對比：

2、matplotlib展示壓縮前后對比（灰度）

 

#-*- coding: utf-8 -*
import numpy as np
from scipy import ndimage
import matplotlib.pyplot as plt
def pic_compress(k, pic_array):
    u, sigma, vt = np.linalg.svd(pic_array)
    sig = np.eye(k) * sigma[: k]
    new_pic = np.dot(np.dot(u[:, :k], sig), vt[:k, :])  # 還原圖像
    size = u.shape[0] * k + sig.shape[0] * sig.shape[1] + k * vt.shape[1]  # 壓縮后大小
    return new_pic, size

filename = u"招商.jpg" 
ori_img = np.array(ndimage.imread(filename, flatten=True)) 
new_img, size = pic_compress(100, ori_img) 
print("original size:" + str(ori_img.shape[0] * ori_img.shape[1])) 
print("compress size:" + str(size)) 
fig, ax = plt.subplots(1, 2) 
ax[0].imshow(ori_img) 
ax[0].set_title("before compress") 
ax[1].imshow(new_img) 
ax[1].set_title("after compress") 
plt.show()

 

運行效果：

 

參考文獻：

https://my.oschina.net/bgbfbsdchenzheng/blog/687110

https://blog.csdn.net/xuelabizp/article/details/52318708

https://blog.csdn.net/wang454592297/article/details/80999644