K-SVD稀疏字典学习去噪

python编写的K-SVD稀疏字典学习去噪，可以显示字典的图像，去噪效果还行，还有待改进，有问题可以及时交流。

“““
项目内容：基于K-SVD学习的稀疏字典去噪
作者：忘川
时间：2019-03-11

“““
import ImageProcessing as IP
import math
import cv2
import random
from scipy import ndimage as nd
import copy
import numpy as np
from PIL import Image as im

“““
类说明：使用稀疏字典学习去噪

“““
class SparseClearNoise （）:
    “““
    方法说明：初始化函数
    参数说明：pic：无噪声图像
              npic ：有噪声图像
    返回值：无
    “““    
    def __init__ （self picnpic）:
        self.img = copy.deepcopy （pic）
        self.nimg = copy.deepcopy （npic）
        self.w = npic.shape[1]
        self.h = npic.shape[0]
        self.PicData = np.zeros（（643969））
    “““
    方法说明：创建一个DCT字典
    参数说明：bs：大小
              r；冗余系数
    返回值：DCT：构建好的DCT
    “““
    def CreatDCT （self bs=8 r=4）:
        k = r*bs**2
        hh = int （math.sqrt（k））
        DCT = np.zeros（（bshh））
        for i in range（hh）:
            V = np.cos（np.array（[j*i*math.pi/hh for j in range（bs）]））
            if i > 0:
                V = V - np.mean（V）
            DCT[:i] = V/np.linalg.norm（V）
        DCT = np.kron（DCTDCT）
        return DCT
    “““
    方法说明：以图像的形式显示一个字典
    参数说明：DCT：被显示字典
              ShowFlag：是否排序，只有学习后才使用排序
    返回值：无
    “““
    def ShowDCT （self DCT ShowFlag=0）:
        a = []
        D = copy.deepcopy（DCT）
        #归一化
        for i in range （D.shape[1]）:
            D[:i] = D[:i] - np.min（D[:i]）
            if np.max（D[:i]） != 0:
                D[:i] = D[:i]/np.max（D[:i]）
        if ShowFlag == 1:
            P = np.var （Daxis=0）#列求平局值
            for i in range （len （P））:
                maxn = np.argmax（P）
                a.extend（[maxn]）
                P[maxn] = -P[maxn]
            I = np.zeros（（D.shape[0]D.shape[1]））
            print （D）
            for i in range（D.shape[1]）:
                I[:i] = D[:a[D.shape[1]-i-1]]
            D = I
        L = int（math.sqrt （DCT.shape[1]））
        n = int（math.sqrt （DCT.shape[0]））
        img_DCT = np.zeros（（L*nL*n））

        for i in range（L）:
            for j in range（L）:
                for k in range （D.shape[0]）:
                    img_DCT[i*8+int（k%8）][j*8+int（k/8）] = D[k][i*16+j]
        img_DCT = img_DCT - np.min（D）
        img_DCT = img_DCT/np.max（D）
        img_DCT = np.uint8（img_DCT*255）
        print （img_DCT）
##        image = im.fromarray（img_DCT.astype（np.int））
##        image.show（）
        img_DCT1 = np.zeros（（L*24L*24）np.uint8）
        for i in range（L*8）:
            for j in range（L*8）:
                img_DCT1[i*3:i*3+3j*3:j*3+3] = img_DCT[i][j]
        cv2.imshow （“DCT Image“img_DCT1）
        
    “““
    方法说明：读取一副图像的数据，并以向量的形式给出。
    参数说明：filename：图片数据的地址
    返回值：PicData：图像数据
    “““
    def GetPicInformation （self）:
        k = 0
        self.means = []
        img = self.nimg
        for i in range（63）:
            for j in range（int（63））:#先从坐到右，再从上到下
                data8x8 = img[i*4:i*4+8j*4:j*4+8]
                for ii in range（8）:
                

 属性            大小     日期    时间   名称
----------- ---------  ---------- -----  ----

     文件      65951  2019-03-08 12:02  [4]-稀疏去噪\123.jpg

     文件      26704  2019-03-08 12:04  [4]-稀疏去噪\1234.jpg

     文件       9621  2019-03-11 12:28  [4]-稀疏去噪\ClearNoise.py

     文件     220980  2019-03-01 12:37  [4]-稀疏去噪\Glena.jpg

     文件       2099  2019-03-10 23:06  [4]-稀疏去噪\ImageProcessing.py

     文件     263222  2015-11-04 16:05  [4]-稀疏去噪\lena.bmp

     文件      26703  2019-03-10 20:36  [4]-稀疏去噪\lena1.jpg

     文件     719641  2019-03-01 09:00  [4]-稀疏去噪\lenna1.png

     文件      44251  2019-03-08 09:55  [4]-稀疏去噪\lenna256.jpg

     文件      40634  2019-03-01 09:00  [4]-稀疏去噪\lenna3.jpg

     文件       1670  2019-03-10 23:06  [4]-稀疏去噪\__pycache__\ImageProcessing.cpython-37.pyc

     目录          0  2019-03-10 23:06  [4]-稀疏去噪\__pycache__

     目录          0  2019-03-10 20:36  [4]-稀疏去噪

----------- ---------  ---------- -----  ----

              1421476                    13