论文复现代码《基于自适应哈夫曼编码的密文可逆信息隐藏算法》调试版

前言

本文展示论文《基于自适应哈夫曼编码的密文可逆信息隐藏算法》的复现代码。代码块的结构如下：

其中，每个代码块都包含了测试该代码块的功能的主函数代码，使用时可放心运行，前提是你按照这个包结构把文件命名改好，放在同一个文件夹下放好。.idea和__pycache__文件不用管。还有main.py、InformationEmbedding.py也是多余的文件。

论文内容解析请参考本人的这篇文章：

论文简述基于自适应哈夫曼编码的密文可逆信息隐藏算法（基于位图压缩的加密图像可逆信息隐藏算法）_zrc007007的博客-CSDN博客

精简版代码在这里：

论文复现代码《基于自适应哈夫曼编码的密文可逆信息隐藏算法》导演剪辑版-CSDN博客

复现代码

MedianEdgeDetector.py

首先是中值预测器，文件名为MedianEdgeDetector.py：

import numpy as np


class MED:
    def __init__(self):
        # 示例数据
        self.data = [
            [162, 162, 162, 161, 162, 157, 163, 161],
            [162, 162, 162, 161, 162, 157, 163, 161],
            [162, 162, 162, 161, 162, 157, 163, 161],
            [162, 162, 162, 161, 162, 157, 163, 161],
            [162, 162, 162, 161, 162, 157, 163, 161],
            [164, 164, 158, 155, 161, 159, 159, 160],
            [160, 160, 163, 158, 160, 162, 159, 156],
            [159, 159, 155, 157, 158, 159, 156, 157]
        ]

    def detect(self, data):
        # 中值预测
        result = np.zeros_like(data)
        result[0][0] = data[0][0]
        for i in range(1, len(data)):
            result[i][0] = data[i][0]
            result[0][i] = data[0][i]
        for i in range(1, len(data)):
            for j in range(1, len(data[0])):
                a = data[i - 1][j - 1]
                b = data[i - 1][j]
                c = data[i][j - 1]
                if a <= min(b, c):
                    result[i][j] = max(b, c)
                elif a >= max(b, c):
                    result[i][j] = min(b, c)
                else:
                    result[i][j] = b + c - a
        return result


if __name__ == "__main__":
    print(MED().detect(MED().data))

AdaptiveHuffmanEncoding.py

对图像进行自适应哈夫曼编码，文件名为AdaptiveHuffmanEncoding.py：

from MedianEdgeDetector import MED
import numpy as np
from math import inf


class HuffCode:
    def compare(self, num1, num2):
        # 比较像素值的相同比特位数
        count = 0
        for i in range(8):
            divisor = pow(2, 7-i)
            if int(num1 // divisor) == int(num2 // divisor):
                count += 1
                num1 = num1 - divisor
                num2 = num2 - divisor
            else:
                break
        return count

    def count(self, origindata,  data):
        # 生成图像相同像素值的比特位数的比较结果
        result = {}
        resultMap = np.zeros_like(data)
        resultMap[0][0] = -1
        for i in range(1, len(data)):
            resultMap[i][0] = -1
            resultMap[0][i] = -1
        for i in range(1, len(data)):
            for j in range(1, len(data[0])):
                num = self.compare(origindata[i][j], data[i][j])
                resultMap[i][j] = num
                result[num] = result.get(num, 0) + 1
        return resultMap, result


# 初始化哈夫曼结点
class Huffmannode(object):
    def __init__(self):
        self.parent=0
        self.left=0
        self.right=0
        self.weight=0


# 选择最小的结点下标
def select_node(huffman):
    # 俩个结点直接返回不需要找最小俩个结点
    if len(huffman)==2:
        return 0,1
    min=semin=inf# 初始化成无穷大
    f=s=-1
    for i in range(len(huffman)):
        if huffman[i].parent==0:
            if min>huffman[i].weight:
                semin=min
                s=f
                min=huffman[i].weight
                f=i
            elif semin>huffman[i].weight:
                semin=huffman[i].weight
                s=i
    return f,s


# 编码
def Huffman_code(origin_dict):
    # 给结点赋权重
    n=len(origin_dict)
    m=2*n-1
    huffman=[]
    for i in origin_dict:
        temp_huffmannode=Huffmannode()
        temp_huffmannode.weight=origin_dict[i]
        huffman.append(temp_huffmannode)
    # 构建Huffman树，选择俩个最小的结点合并
    for i in range(n,m):
        f,s=select_node(huffman)
        temp_huffmannode=Huffmannode()
        temp_huffmannode.weight=huffman[f].weight+huffman[s].weight
        temp_huffmannode.right=f  # 小的放在右边
        temp_huffmannode.left=s
        huffman[f].parent=huffman[s].parent=i
        huffman.append(temp_huffmannode)

    # 0,1编码，右0，左1
    codeing_dict = dict.fromkeys(origin_dict, None)
    for i in range(0,n):
        s=''
        k=i
        parent=huffman[i].parent
        while parent!=0:
            if huffman[parent].left==k:
                s+='1'
                k=parent
                parent=huffman[parent].parent
            else:
                s+='0'
                k=parent
                parent=huffman[parent].parent
        codeing_dict[list(origin_dict.keys())[i]]=list(reversed(s))
    for k in codeing_dict.items():
        codeing_dict[k[0]] = ''.join(k[1])

    return codeing_dict


if __name__ == "__main__":
    MED = MED()
    origindata = MED.data
    MEDdata = MED.detect(origindata)
    print(np.array(origindata))
    print(MEDdata)
    print(HuffCode().compare(159, 160))
    resultMap, result = HuffCode().count(origindata, MEDdata)
    print(result)
    '''
    # 输入原始字符集
    s = input('输入即将被编码的字符：')

    # 创建字典计算频率
    dic = {}
    for i in range(len(s)):
        # get方法，如果有键返回该键对应的值，如果没键，可以设置返回值
        dic[s[i]] = dic.get(s[i], 0) + 1
    '''
    code_dict = Huffman_code(result)
    print(code_dict)

Crypting.py

混沌矩阵加密，文件名为Crypting.py：

import numpy as np
from skimage import io
import matplotlib.pyplot as plt


def crypt(im, miu, x0):
    '''
    logistic混沌加密
    :param im: 图像
    :param miu: μ参数
    :param x0: x0参数
    :return: 返回密文图像
    '''
    h, w = im.shape
    c_ = np.zeros_like(im)
    c_[0][0] = x0
    c=[]
    c.append(x0)
    result = np.zeros_like(im)
    result[0][0] = (x0 * pow(2, 48)) % 256
    for x in range(1, h * w):
        i = x // w
        j = x % w
        c.append(miu * c[x - 1] * (1 - c[x - 1]))
        c_[i][j] = (c[x] * pow(2, 48)) % 256
    for i in range(h):
        for j in range(w):
            result[i][j] = im[i][j] ^ c_[i][j]
    return result


def transform(img):
    column, row = img.shape
    result = np.zeros_like(img, dtype='int_')
    for i in range(column):
        for j in range(row):
            result[i][j] = int(img[i][j] * 255)
    return result


if __name__ == "__main__":
    plt.set_cmap(cmap='gray')
    img = io.imread("../img/lena_grey.tif")
    print(img)
    plt.imshow(img)
    img = transform(img)
    print(img)
    plt.figure()
    enc_img = crypt(img, 3.6, 0.5)
    plt.imshow(enc_img)
    plt.figure()
    dec_img = crypt(enc_img, 3.6, 0.5)
    plt.imshow(dec_img)
    plt.show()

LabelMapEmbedding.py

位图嵌入，文件名LabelMapEmbedding.py：

import numpy as np
import math
from AdaptiveHuffmanEncoding import *
from Crypting import *
# from MedianEdgeDetector import *


def int2bin(num, leng):
    '''
    整数int转二进制格式bin
    Transform a integer to a string whose length is leng.
    :param num: numbers waiting for transforming
    :param leng: the length of hoped result string
    :return: a string of leng length
    '''
    if leng < 1:
        raise Exception("Length isn't positive integer!")
    place = 1
    result = ''
    while place <= leng:
        result = str(num % 2) + result
        num = num // 2
        if num == 0:
            return (leng - place) * '0' + result
        place += 1
    raise Exception("Length of binary string isn't enough!")


def bin2int(string, leng):
    '''
    二进制格式bin转整数int
    Transfer a string of length of leng to a positive integer
    :param string: string waiting to be transferred
    :param leng: the length of reading
    :return: a positive integer less than 2^leng
    '''
    if leng < 1:
        raise Exception("Length isn't positive integer!")
    if len(string) < leng:
        raise Exception("Length of string under transferring isn't enough!")
    place = 1
    result = 0
    while place <= leng:
        result += int(string[place - 1]) * pow(2, leng - place)
        place += 1
    return result


def binstrcomplmt(string, length, complement):
    '''
    给二进制格式补位，补到前面。比如补0就给complement传0，补1就传1
    Complement strings with which we decide.
    :param string: string waiting to be complemented
    :param length: what we hope it to length
    :param complement: using what character to complement it
    :return: string already complemented
    '''
    return (length - len(string)) * complement + string


def binstrbackcomplmt(string, length, complement):
    '''
    给二进制格式补位，补到后面
    Complement strings with which we decide on its backhand.
    :param string: string waiting to be complemented
    :param length: what we hope it to length
    :param complement: using what character to complement it
    :return: string already complemented
    '''
    return string + (length - len(string)) * complement


def generatec(dict):
    '''
    生成嵌入信息中的c1到c8
    generate c info
    :param dict: Huffman code diction
    :return:
    '''
    result = ''
    c = []
    for i in range(9):
        c.append(0)
        c[i] = len(dict.get(i, ''))
        result += int2bin(c[i], 4)
    print(c)
    return result


def generateh(dict):
    '''
    生成嵌入信息中的h1到h8
    generate h info
    :param dict: Huffman code diction
    :return:
    '''
    result = ''
    h = []
    for i in range(9):
        h.append('')
        h[i] = binstrcomplmt(dict.get(i, '0'), 8, '0')
        result += h[i]
    print(h)
    return result


def countLm(countDict, lenDict):
    '''
    生成论文中说的Lm，变成Eta还需要转换一下
    Counting Lm
    :param countDict: diction of Huffman codes' appearance
    :param lenDict: Huffman code diction
    :return:
    '''
    count = 0
    for i in range(9):
        count += countDict.get(i, 0) * len(lenDict.get(i, ''))
    return count


def generatef(Lm, shapeOfImg):
    '''
    生成嵌入信息中的f
    generate f, which is Lm's bits' num's binary format
    :param Lm:
    :param shapeOfImg:
    :return:
    '''
    return int2bin(Lm, math.ceil(np.log2(shapeOfImg[0])) + math.ceil(np.log2(shapeOfImg[1])) + 2)


def generateEta(dic, labelmap):
    '''
    生成嵌入信息中的Eta
    Transferred label map's binary format
    :param dic:
    :param labelmap:
    :return:
    '''
    result = ''
    for i in range(1, labelmap.shape[0]):
        for j in range(1, labelmap.shape[1]):
            result += dic[labelmap[i][j]]
    return result


def generatelabelinfo(HuffDict, CountDict, LabelMap):
    '''
    生成总的嵌入信息
    Generate embedding information of label map
    :param HuffDict: Huffman code diction
    :param CountDict: Length of Huffman codes' diction
    :param LabelMap: The label map
    :return: Embedding information of label map
    '''
    return generatec(HuffDict) + generateh(HuffDict) + generatef(countLm(CountDict,HuffDict), LabelMap.shape)\
           + generateEta(HuffDict, LabelMap)


def embedinfo(LabelInfo, EncryptedImg, LabelMap, data):
    # 嵌入位图信息
    ReferencePixels = ''
    result = np.array(EncryptedImg)
    for i in range(EncryptedImg.shape[0]):
        ReferencePixels += int2bin(EncryptedImg[0][i], 8)
        result[0][i] = bin2int(LabelInfo, 8)
        LabelInfo = LabelInfo[8:]  # 截掉8个
    for i in range(1, EncryptedImg.shape[1]):
        ReferencePixels += int2bin(EncryptedImg[i][0], 8)
        result[i][0] = bin2int(LabelInfo, 8)
        LabelInfo = LabelInfo[8:]
    EmbeddingInfo = LabelInfo + ReferencePixels + data
    print("Length of Reference Pixels is:", len(ReferencePixels))
    count = 0
    row = count // (EncryptedImg.shape[1] - 1) + 1
    column = count % (EncryptedImg.shape[1] - 1) + 1
    t = LabelMap[row][column]
    maximum = (EncryptedImg.shape[0] - 1) * (EncryptedImg.shape[1] - 1)
    while len(EmbeddingInfo) > 0:
        if 0 <= t <= 6:
            result[row][column] = EncryptedImg[row][column] % pow(2, 7 - t)\
                                  + bin2int(binstrbackcomplmt(EmbeddingInfo[:t+1], 8, '0'), 8)
            EmbeddingInfo = EmbeddingInfo[t+1:]
        elif 7 <= t <= 8:
            result[row][column] = bin2int(binstrbackcomplmt(EmbeddingInfo[:8], 8, '0'), 8)
            EmbeddingInfo = EmbeddingInfo[8:]
        count += 1
        if count >= maximum:
            raise Exception("There's no room for embedding!")
        row = count // (EncryptedImg.shape[1] - 1) + 1
        column = count % (EncryptedImg.shape[1] - 1) + 1
        t = LabelMap[row][column]
    return result


def detect(data):
    '''
    测试用预测函数
    :param data:
    :return:
    '''
    result = np.zeros_like(data)
    result[0][0] = data[0][0]
    for i in range(1, len(data)):
        result[i][0] = data[i][0]
        result[0][i] = data[0][i]
    for i in range(1, len(data)):
        for j in range(1, len(data[0])):
            a = data[i - 1][j - 1]
            b = data[i - 1][j]
            c = data[i][j - 1]
            if a <= min(b, c):
                result[i][j] = max(b, c)
            elif a >= max(b, c):
                result[i][j] = min(b, c)
            else:
                result[i][j] = b + c - a
    return result


if __name__ == "__main__":
    print(128//2)
    print(128%2)
    strng = int2bin(1, 8)
    print(strng)
    print(bin2int(strng,8))
    print(bin2int('1', 1))
    MED = MED()
    origindata = MED.data
    origindata = np.array(origindata)
    MEDdata = MED.detect(origindata)
    print("The origin data is:")
    print(np.array(origindata))
    print("The predicted data is:")
    print(MEDdata)
    print(HuffCode().compare(159, 160))
    resultMap, countingResult = HuffCode().count(origindata, MEDdata)
    print("The label map is:")
    print(resultMap)
    print("The counting result of Huffman coding is:", countingResult)
    '''
    # 输入原始字符集
    s = input('输入即将被编码的字符：')

    # 创建字典计算频率
    dic = {}
    for i in range(len(s)):
        # get方法，如果有键返回该键对应的值，如果没键，可以设置返回值
        dic[s[i]] = dic.get(s[i], 0) + 1
    '''

    code_dict = Huffman_code(countingResult)
    print(code_dict)
    generatec(code_dict)
    print(generatec(code_dict))
    print(len(generatec(code_dict)))
    print(generateh(code_dict), len(generateh(code_dict)))

    lm = countLm(countingResult, code_dict)
    print("Lm is:", lm)
    f = generatef(lm, MEDdata.shape)
    print("f is:", f)
    print("length of f is:", len(f))
    Eta = generateEta(code_dict, resultMap)
    print("The length of Eta is:", len(Eta))
    print("Eta is:")
    print(Eta)

    labelInfo = generatelabelinfo(code_dict,countingResult, resultMap)
    print("The length of labelInfo is:", len(labelInfo))
    print("Label info:")
    print(labelInfo)

    print("Is length of c, h, f and Eta equals to labelInfo:", len(generatec(code_dict)) + len(generateh(code_dict)) +\
                                                               len(f) + len(Eta) == len(labelInfo))

    embedded = embedinfo(labelInfo, crypt(origindata, 3.6, 0.5), resultMap, '0110')
    print(embedded)

    strng = int2bin(903, 11)
    print(strng)
    print(strng[12:] == '')
    print(strng[:3])

    print(detect(origindata))

DataExtractionandImageRecovery.py

数据提取和恢复，文件名DataExtractionandImageRecovery.py：

from LabelMapEmbedding import *
from skimage import io
import matplotlib.pyplot as plt


def HuffDecode(HuffDict, info):
    # 哈夫曼解码
    for i in range(9):
        if info[:len(HuffDict.get(i, ''))] == HuffDict.get(i, -1):
            print("The i is:", i)
            print(info[:8])
            print(HuffDict)
            return i, len(HuffDict[i])
    raise Exception("No string matches!")


def extractpixel(pixel, t):
    # 根据t值，恢复像素位数
    if 0 <= t <= 7:
        return int2bin(pixel, 8)[:t+1]
    elif t == 8:
        return int2bin(pixel, 8)
    else:
        raise Exception("T out of range!")


def calctcut(t):
    # 根据t值，返回像素数
    if 0 <= t <= 7:
        return t + 1
    elif t == 8:
        return 8
    else:
        raise Exception("T out of range!")


def extract1(encrypted):
    # 提取第一行、第一列
    info = ''
    LenDict = {}
    HuffDict = {}
    for i in range(encrypted.shape[0]):
        info += int2bin(encrypted[0][i], 8)
    for i in range(1, encrypted.shape[1]):
        info += int2bin(encrypted[i][0], 8)
    for i in range(9):
        LenDict[i] = bin2int(info[:4], 4)
        info = info[4:]
    for i in range(9):
        if LenDict[i] != 0:
            HuffDict[i] = info[8-LenDict[i]:8]
        info = info[8:]
    print(LenDict, HuffDict)
    return HuffDict, info


def extract_exp(encrypted, HuffDict, info, datalen, Label):  # Label是用来测试位图和算出来的是不是一样的，可以删掉
    # 提取位图
    LabelMap = np.zeros_like(encrypted)
    decrypted1 = np.array(encrypted)
    LmLen = math.ceil(np.log2(encrypted.shape[0])) + math.ceil(np.log2(encrypted.shape[1])) + 2
    Lm = bin2int(info[:LmLen], LmLen)
    info = info[LmLen:]
    infoLen = Lm + ((encrypted.shape[0] - 1) + (encrypted.shape[1] - 1) - 1) * 8 + datalen
    count = len(info)  # 已提取到的信息长度
    place = 0
    pursuit = 0
    gonext = 0
    count1 = 1
    while count < infoLen:
        print("count:", count)
        print("Info len:", infoLen)
        print("pursuit:", pursuit)
        row = place // (encrypted.shape[1] - 1) + 1
        column = place % (encrypted.shape[1] - 1) + 1
        print("origin row, column:", row, column)
        if count1 == 1 and count < Lm:
            t, CodeLen = HuffDecode(HuffDict, info)
            print("t is:", t)
            LabelMap[row][column] = t
            info = info[CodeLen:] + extractpixel(encrypted[row][column], t)
            count += calctcut(t)
            place += 1
            print("step1")
            print("Is the Label Map equal to the extrated one:", Label[row][column] == t)
            print("place is:", place)
            print("count is:", count)
        else:
            pursuit = 1
            count1 = 0
        if pursuit == 1 and gonext == 0:
            record = place
            print("\nThe staring of step 2's row and column is:\n", row , column)
            while place < (encrypted.shape[0] - 1) * (encrypted.shape[1] - 1):
                row = place // (encrypted.shape[1] - 1) + 1
                column = place % (encrypted.shape[1] - 1) + 1
                t, CodeLen = HuffDecode(HuffDict, info)
                LabelMap[row][column] = t
                info = info[CodeLen:] + extractpixel(encrypted[row][column], t)
                print("step2")
                print("Is the Label Map equal to the extrated one:", Label[row][column] == t)
                print("T is {}, and the Label is {}".format(t, Label[row][column]))
                print("place:", place)
                print("row, column:", row, column)
                place += 1
                print('haha',place)
                print("end")
            place = record
            row = place // (encrypted.shape[1] - 1) + 1
            column = place % (encrypted.shape[1] - 1) + 1
            gonext = 1
        if gonext == 1 and count - Lm < (encrypted.shape[0] - 1) * (encrypted.shape[1] - 1) * 8 + datalen:
            # print("place:",place)
            # print("row, column:", row, column)
            info += extractpixel(encrypted[row][column], LabelMap[row][column])
            count += calctcut(LabelMap[row][column])
            # print("infolen:", infoLen)
            # print("count:", count)
            # print()
            place += 1
    for i in range(encrypted.shape[0]):
        LabelMap[0][i] = -1
        decrypted1[0][i] = bin2int(info[:8], 8)
        info = info[8:]
    for i in range(1, encrypted.shape[1]):
        LabelMap[i][0] = -1
        decrypted1[i][0] = bin2int(info[:8], 8)
        info = info[8:]
    data = info[:datalen]
    return LabelMap, decrypted1, data


def reverse(char):
    # 反转0和1
    if char == '0':
        return '1'
    elif char == '1':
        return '0'
    else:
        raise Exception("Not 0 or 1!")


def detect(data, i, j):
    '''
    测试用预测函数
    :param data:
    :return:
    '''
    a = data[i - 1][j - 1]
    b = data[i - 1][j]
    c = data[i][j - 1]
    if a <= min(b, c):
        result = max(b, c)
    elif a >= max(b, c):
        result = min(b, c)
    else:
        result = b + c - a
    return result


def recovery(img, LabelMap):
    # 恢复图像
    result = np.zeros_like(img)
    for i in range(img.shape[0]):
        result[0][i] = img[0][i]
    for i in range(1, img.shape[1]):
        result[i][0] = img[i][0]
    for i in range(1, img.shape[0]):
        for j in range(1, img.shape[1]):
            px = detect(result, i, j)
            t = LabelMap[i][j]
            if t == 8:
                result[i][j] = px
            elif 0 <= t <= 7:
                result[i][j] = bin2int(int2bin(px, 8)[:t] + '0' * (8 - t), 8)\
                               + int(reverse(int2bin(px, 8)[t:t+1])) * pow(2, 7 - t) + img[i][j] % pow(2, 7 - t)
            else:
                raise Exception("T out of range!")
    return result


if __name__ == "__main__":
    MED = MED()
    # origindata = MED.data
    origindata = io.imread("../img/lena_grey.tif")
    origindata = transform(origindata)
    origindata = np.array(origindata)
    MEDdata = MED.detect(origindata)
    print("The origin data is:")
    print(np.array(origindata))
    print("The predicted data is:")
    print(MEDdata)
    print(HuffCode().compare(159, 160))
    resultMap, countingResult = HuffCode().count(origindata, MEDdata)
    print("The label map is:")
    print(resultMap)
    print("The counting result of Huffman coding is:", countingResult)

    code_dict = Huffman_code(countingResult)
    print(code_dict)
    generatec(code_dict)
    print(generatec(code_dict))
    print(len(generatec(code_dict)))
    print(generateh(code_dict), len(generateh(code_dict)))

    lm = countLm(countingResult, code_dict)
    print("Lm is:", lm)
    f = generatef(lm, MEDdata.shape)
    print("f is:", f)
    print("length of f is:", len(f))
    Eta = generateEta(code_dict, resultMap)
    print("The length of Eta is:", len(Eta))
    print("Eta is:")
    print(Eta)

    labelInfo = generatelabelinfo(code_dict,countingResult, resultMap)
    print("The length of labelInfo is:", len(labelInfo))
    print("Label info:")
    print(labelInfo)
    secret = '0110010000' * 50  # 用于测试的秘密信息
    embedded = embedinfo(labelInfo, crypt(origindata, 3.6, 0.5), resultMap, secret)  # 嵌入秘密信息
    print(embedded)
    huff_code, info1 = extract1(embedded)
    print("The length of rest of info waiting for extracting is:", len(info1))
    print(int2bin(100, 8))
    print(extractpixel(100, 0))
    # resultMap2, decrypted1, data= extract2(embedded, huff_code, info1, 4)
    resultMap2, decrypted1, data = extract_exp(embedded, huff_code, info1, len(secret), resultMap)
    print("The encrypted img is:\n", crypt(origindata, 3.6, 0.5))
    print("The decrypted1 img is:\n", decrypted1)
    print(resultMap2)
    print(resultMap)
    print(data)
    if secret == data:
        print("THE extract is successful!")
    img1 = crypt(decrypted1, 3.6, 0.5)
    print("img1 is:\n",img1)
    '''
    print("Origin:")
    print(origindata)
    print("Detect img:")
    print(detect(img1))
    print("Detected origin data:")
    print(detect(origindata))
    '''
    res = img1 - origindata
    print("result compare with origin data:\n")
    print(res)
    img2 = recovery(img1, resultMap2)
    print(img2)
    res = img2 - origindata
    print("img2 compares to origin:\n", res)
    plt.set_cmap(cmap='gray')
    plt.subplot(221)
    plt.imshow(origindata)
    plt.title("Origin imagery")
    plt.subplot(222)
    plt.imshow(embedded)
    plt.title("Embedded imagery")
    plt.subplot(223)
    plt.imshow(img1)
    plt.title("Preliminary decrypted imagine")
    plt.subplot(224)
    plt.imshow(img2)
    plt.title("Fully recovered imagine")
    plt.show()

Comparison.py

计算指标，比较结果，文件名Comparison.py：

import numpy as np
import math
import cv2
from DataExtractionandImageRecovery import *
from skimage.color import rgb2gray


def ssim(img1, img2):
   #计算ssim指标
  C1 = (0.01 * 255)**2
  C2 = (0.03 * 255)**2
  img1 = img1.astype(np.float64)
  img2 = img2.astype(np.float64)
  kernel = cv2.getGaussianKernel(11, 1.5)
  window = np.outer(kernel, kernel.transpose())
  mu1 = cv2.filter2D(img1, -1, window)[5:-5, 5:-5] # valid
  mu2 = cv2.filter2D(img2, -1, window)[5:-5, 5:-5]
  mu1_sq = mu1**2
  mu2_sq = mu2**2
  mu1_mu2 = mu1 * mu2
  sigma1_sq = cv2.filter2D(img1**2, -1, window)[5:-5, 5:-5] - mu1_sq
  sigma2_sq = cv2.filter2D(img2**2, -1, window)[5:-5, 5:-5] - mu2_sq
  sigma12 = cv2.filter2D(img1 * img2, -1, window)[5:-5, 5:-5] - mu1_mu2
  ssim_map = ((2 * mu1_mu2 + C1) * (2 * sigma12 + C2)) / ((mu1_sq + mu2_sq + C1) *
                              (sigma1_sq + sigma2_sq + C2))
  return ssim_map.mean()


def psnr(img1, img2):
   # 计算PSNR指标
   mse = np.mean( (img1/255. - img2/255.) ** 2 )
   if mse < 1.0e-10:
      return 100
   PIXEL_MAX = 1
   return 20 * math.log10(PIXEL_MAX / math.sqrt(mse))


if __name__ == "__main__":
    MED = MED()
    # Baboon 3.6 0.5
    origindata = io.imread("../img/lena_gray_512.tif")
    # origindata = rgb2gray(origindata)
    print(origindata)
    # origindata = transform(origindata)
    origindata = np.array(origindata)
    MEDdata = MED.detect(origindata)
    resultMap, countingResult = HuffCode().count(origindata, MEDdata)
    code_dict = Huffman_code(countingResult)
    labelInfo = generatelabelinfo(code_dict, countingResult, resultMap)
    encrypted = crypt(origindata, 3.7, 0.9)
    containingLabel = embedinfo(labelInfo, encrypted, resultMap, '')
    embedded = embedinfo(labelInfo, encrypted, resultMap, '0110010000')
    huff_code, info1 = extract1(embedded)
    # resultMap2, decrypted1, data = extract_exp(embedded, huff_code, info1, 10, resultMap)
    # img1 = crypt(decrypted1, 3.6, 0.5)
    print("Lena")
    print("Comparison of PSNR and SSIM between encrypted imagine and the original:")
    print("PSNR:", psnr(origindata, encrypted))
    print("SSIM:", ssim(origindata, encrypted))

    print()
    print("Comparison of PSNR and SSIM between containing Label Map imagine and the original:")
    print("PSNR:", psnr(origindata, containingLabel))
    print("SSIM:", ssim(origindata, containingLabel))

    print()
    print("Comparison of PSNR and SSIM between embedded imagine and the original:")
    print("(With the secret of '0110010000')")
    print("PSNR:", psnr(origindata, embedded))
    print("SSIM:", ssim(origindata, embedded))