15 实战：熵编码模拟器

智算菩萨

已于 2024-10-28 10:40:33 修改

阅读量251

点赞数 3

分类专栏： MPEG4和H.264视频压缩知识点整理文章标签： python 开发语言视频编解码

于 2024-10-28 10:38:35 首次发布

本文链接：https://blog.csdn.net/nmdbbzcl/article/details/143286092

版权

MPEG4和H.264视频压缩知识点整理专栏收录该内容

20 篇文章 ¥9.90 ¥99.00

订阅专栏

超级会员免费看

熵编码模拟器的实现与原理详解

作者：1248693038
日期：2024-10-28

引言

熵编码在信息论和数据压缩领域具有重要的应用，常见的熵编码方法包括预测编码、变长编码（如哈夫曼编码）和算术编码等。本文将详细介绍如何使用Python语言，结合PyQt5构建一个图形用户界面，演示这三种熵编码方法的原理和实现。通过本次学习，您将深入理解熵编码的核心思想，并学会如何将其应用于实际编码中。

1. 项目概述

该项目旨在通过编写一个熵编码模拟器，帮助用户理解预测编码、哈夫曼编码和算术编码的原理和实现。用户可以通过图形界面输入数据，选择编码方式，查看编码和解码的结果。整个项目包含以下主要部分：

图形用户界面（GUI）：使用PyQt5构建，提供友好的用户交互。
编码算法实现：利用Python实现三种熵编码方法。
编码过程展示：在界面上展示编码和解码的结果，并提供编码说明。

2. 环境配置与依赖

在开始项目之前，确保您的Python环境安装了以下库：

Python 3.x：建议使用Python 3.6及以上版本。
PyQt5：用于构建图形用户界面，可以通过pip install PyQt5安装。
NumPy：用于数值计算和数组操作，安装命令为pip install numpy。

3. 项目结构

项目主要包括以下两个Python类：

EntropyCodingSimulator：熵编码模拟器类，实现了预测编码、哈夫曼编码、算术编码的核心算法。
MainWindow：主窗口类，构建了程序的图形用户界面，处理用户交互。

4. 熵编码基础知识

4.1 熵的概念

熵（Entropy）在信息论中表示信息的不确定性，熵越大，信息越不确定。熵编码的目标是利用数据的统计特性，尽可能减少编码后的信息熵，实现数据压缩。

4.2 预测编码

预测编码是一种利用数据之间的相关性进行编码的方法，通过前一个数据预测当前数据，只存储预测误差，从而减少数据冗余，提高压缩效率。

原理：

预测：使用已知数据预测下一个数据。
计算误差：将实际值与预测值求差，得到预测误差。
编码误差：对预测误差进行编码。

4.3 哈夫曼编码

哈夫曼编码（Huffman Coding）是一种基于字符出现频率的无损压缩算法，将较短的编码分配给高频字符，较长的编码分配给低频字符，实现平均编码长度的最小化。

原理：

统计频率：计算每个字符出现的频率。
构建哈夫曼树：利用最小堆构建哈夫曼树。
生成编码：根据哈夫曼树生成每个字符的编码。

4.4 算术编码

算术编码（Arithmetic Coding）是一种基于概率模型的无损压缩算法，将整个消息序列映射为一个区间，通过不断细分区间，实现数据的高效压缩。

原理：

建立概率模型：计算每个符号的概率。
初始化区间：开始区间为 [0,1)。
迭代细分：根据符号概率不断缩小区间。
输出编码：选取区间内的任意小数作为编码。

5. 编码算法的实现

5.1 预测编码的实现

5.1.1 编码过程

初始化：编码序列的第一个值为原始序列的第一个值。
循环处理：从第二个值开始，计算当前值与前一个值的差值，记录在编码序列中。

def predictive_encode(self):
    data = self.numeric_data
    if not data:
        return []
    encoded = [data[0]]  # 第一个值直接编码
    for i in range(1, len(data)):
        encoded.append(data[i] - data[i - 1])
    return encoded

5.1.2 解码过程

初始化：解码序列的第一个值为编码序列的第一个值。
循环处理：从第二个值开始，当前解码值等于前一个解码值加上当前编码值。

def predictive_decode(self, encoded_data):
    if not encoded_data:
        return []
    decoded = [encoded_data[0]]
    for i in range(1, len(encoded_data)):
        decoded.append(encoded_data[i] + decoded[i - 1])
    return decoded

5.2 哈夫曼编码的实现

5.2.1 编码过程

统计频率：创建一个字典，统计每个符号的出现频率。
构建哈夫曼树：
- 使用最小堆（优先级队列）来构建哈夫曼树。
- 不断从堆中取出两个最小频率的节点，合并成新节点并重新放入堆中，直到堆中只有一个节点。
生成编码表：根据哈夫曼树，为每个符号分配编码。

def huffman_encode(self):
    data = self.numeric_data
    if not data:
        return {}, ''
    # 计算频率
    freq = defaultdict(int)
    for symbol in data:
        freq[symbol] += 1

    # 构建哈夫曼树
    heap = [[weight, [symbol, ""]] for symbol, weight in freq.items()]
    heapq.heapify(heap)
    while len(heap) > 1:
        lo = heapq.heappop(heap)
        hi = heapq.heappop(heap)
        for pair in lo[1:]:
            pair[1] = '0' + pair[1]
        for pair in hi[1:]:
            pair[1] = '1' + pair[1]
        new_node = [lo[0] + hi[0]] + lo[1:] + hi[1:]
        heapq.heappush(heap, new_node)
    huff_dict = dict(sorted(heap[0][1:], key=lambda p: (len(p[1]), p)))
    # 编码
    encoded_output = ''.join([huff_dict[symbol] for symbol in data])
    return huff_dict, encoded_output

5.2.2 解码过程

逆向编码表：将编码表的键值对反转，方便解码查找。
遍历编码串：逐位读取编码串，当匹配到编码表中的编码时，添加对应的符号。

def huffman_decode(self, huff_dict, encoded_data):
    inv_huff_dict = {v: k for k, v in huff_dict.items()}
    decoded = []
    code = ''
    for bit in encoded_data:
        code += bit
        if code in inv_huff_dict:
            decoded.append(inv_huff_dict[code])
            code = ''
    return decoded

5.3 算术编码的实现

5.3.1 编码过程

计算概率：统计各符号出现的频率，计算其概率。
建立符号范围：为每个符号分配一个在 [0,1) 区间内的范围，范围大小与概率成正比。
编码迭代：对于每个符号，不断缩小当前区间为对应符号的子区间。
输出编码：最终取区间内的任意值作为编码。

def arithmetic_encode(self):
    data = self.numeric_data
    if not data:
        return {}, 0.0
    # 计算频率和概率
    freq = defaultdict(int)
    for symbol in data:
        freq[symbol] += 1
    total = sum(freq.values())
    probs = {symbol: freq[symbol] / total for symbol in freq}
    # 计算符号范围
    symbols = sorted(probs.keys())
    low = {}
    high = {}
    cumulative = 0.0
    for symbol in symbols:
        low[symbol] = cumulative
        cumulative += probs[symbol]
        high[symbol] = cumulative
    # 编码
    l, h = 0.0, 1.0
    for symbol in data:
        range_ = h - l
        h = l + range_ * high[symbol]
        l = l + range_ * low[symbol]
    code = (l + h) / 2   # 取范围的中间值作为码
    return (low, high), code

5.3.2 解码过程

初始化：使用编码得到的值作为起始解码值。
迭代解码：根据当前值，查找落在哪个符号的范围内，添加符号到解码序列，并更新当前值。

def arithmetic_decode(self, ranges, code, data_length):
    low, high = ranges
    decoded = []
    for _ in range(data_length):
        for symbol in low:
            if low[symbol] <= code < high[symbol]:
                decoded.append(symbol)
                range_ = high[symbol] - low[symbol]
                code = (code - low[symbol]) / range_
                break
    return decoded

6. 图形用户界面设计

6.1 界面布局

利用PyQt5构建一个简洁直观的界面，主要包含以下元素：

输入框：供用户输入待编码的数据，数据以空格分隔。
编码方式选择：使用下拉框让用户选择编码方式（预测编码、哈夫曼编码、算术编码）。
编码和解码按钮：用于触发编码和解码操作。
结果显示区域：包括原始数据、编码结果、解码结果的文本框，方便用户查看。

6.2 界面实现

6.2.1 初始化界面

def init_ui(self):
    # 创建部件
    self.central_widget = QWidget()
    self.setCentralWidget(self.central_widget)

    # 输入数据标签和文本框
    self.input_label = QLabel("请输入数据（用空格分隔）：")
    self.input_edit = QLineEdit()
    self.input_edit.setPlaceholderText("例如：1 2 3 4 5")

    # 编码方式下拉框
    self.encode_label = QLabel("选择编码方式：")
    self.encode_combo = QComboBox()
    self.encode_combo.addItems(['预测编码', '哈夫曼编码', '算术编码'])

    # 编码按钮
    self.encode_button = QPushButton("编码")
    self.decode_button = QPushButton("解码")

    # 显示原始数据、编码结果和解码结果的文本框
    self.original_label = QLabel("原始数据：")
    self.original_text = QTextEdit()
    self.original_text.setReadOnly(True)

    self.encoded_label = QLabel("编码结果：")
    self.encoded_text = QTextEdit()
    self.encoded_text.setReadOnly(True)

    self.decoded_label = QLabel("解码结果：")
    self.decoded_text = QTextEdit()
    self.decoded_text.setReadOnly(True)

    # 说明文本
    self.description_label = QLabel("编码说明：")
    self.description_text = QTextEdit()
    self.description_text.setReadOnly(True)
    self.update_description()

    # 布局设置
    layout = QGridLayout()
    layout.addWidget(self.input_label, 0, 0, 1, 2)
    layout.addWidget(self.input_edit, 0, 2, 1, 4)
    layout.addWidget(self.encode_label, 1, 0)
    layout.addWidget(self.encode_combo, 1, 1)
    layout.addWidget(self.encode_button, 1, 2)
    layout.addWidget(self.decode_button, 1, 3)
    layout.addWidget(self.original_label, 2, 0)
    layout.addWidget(self.original_text, 3, 0, 2, 3)
    layout.addWidget(self.encoded_label, 2, 3)
    layout.addWidget(self.encoded_text, 3, 3, 2, 3)
    layout.addWidget(self.decoded_label, 5, 0)
    layout.addWidget(self.decoded_text, 6, 0, 2, 3)
    layout.addWidget(self.description_label, 5, 3)
    layout.addWidget(self.description_text, 6, 3, 2, 3)

    self.central_widget.setLayout(layout)

    # 信号与槽
    self.encode_button.clicked.connect(self.encode_data)
    self.decode_button.clicked.connect(self.decode_data)
    self.encode_combo.currentTextChanged.connect(self.update_description)

6.2.2 信号与槽机制

利用PyQt5的信号与槽机制，实现按钮点击后的响应操作。例如，当用户点击“编码”按钮时，触发encode_data函数，完成编码过程。

self.encode_button.clicked.connect(self.encode_data)
self.decode_button.clicked.connect(self.decode_data)

6.2.3 编码说明更新

根据用户选择的编码方式，动态更新说明文本，帮助用户理解编码原理。

def update_description(self):
    method = self.encode_combo.currentText()
    if method == '预测编码':
        description = (
            "预测编码是一种利用数据的相关性进行编码的方法。\n"
            "它通过前一个数据值预测当前数据，存储预测误差，达到压缩的效果。"
        )
    elif method == '哈夫曼编码':
        description = (
            "哈夫曼编码是一种无损的变长编码方法，常用于数据压缩。\n"
            "它利用数据中各符号出现的频率，构建哈夫曼树，分配短码给高频符号，长码给低频符号。"
        )
    elif method == '算术编码':
        description = (
            "算术编码是一种基于概率区间的无损压缩方法。\n"
            "它将整个数据映射到一个小数区间，通过逐步缩小区间进行编码。"
        )
    else:
        description = "请选择一种编码方式。"

    self.description_text.setText(description)

7. 用户交互流程

7.1 输入数据

用户在输入框中输入待编码的数据，数据需用空格分隔，如“1 2 3 4 5”。

7.2 选择编码方式

从下拉框中选择需要使用的编码方式：预测编码、哈夫曼编码或算术编码。程序会根据选择动态更新编码说明。

7.3 编码操作

点击“编码”按钮，程序将对输入的数据进行编码，并在编码结果文本框中显示编码后的数据。

7.3.1 编码结果展示

预测编码：显示预测误差序列。
哈夫曼编码：显示编码后的比特串，并弹出一个对话框显示码字表。
算术编码：显示编码得到的小数值，并弹出一个对话框显示符号范围表。

7.4 解码操作

点击“解码”按钮，程序将对编码结果进行解码，并在解码结果文本框中显示解码后的数据。用户可以核对解码结果与原始数据是否一致。

8. 代码关键点解析

8.1 数据转换与验证

在进行编码之前，需要将用户输入的字符串数据转换为数字列表，并进行格式验证，确保输入数据正确。

def str_to_numbers(self, data_str):
    try:
        numbers = list(map(int, data_str.strip().split()))
        return numbers
    except ValueError:
        QMessageBox.warning(None, "错误", "输入的数据格式不正确，请输入数字并用空格分隔。")
        return []

8.2 哈夫曼编码的实现细节

8.2.1 使用最小堆构建哈夫曼树

利用heapq库的最小堆特性，方便地找到最小频率的两个符号，逐步构建哈夫曼树。

heap = [[weight, [symbol, ""]] for symbol, weight in freq.items()]
heapq.heapify(heap)
while len(heap) > 1:
    lo = heapq.heappop(heap)
    hi = heapq.heappop(heap)
    # 合并节点并更新编码

8.2.2 生成编码表

在合并节点时，更新符号的编码，左子树前缀’0’，右子树前缀’1’，最终得到每个符号的哈夫曼编码。

8.3 算术编码的实现细节

8.3.1 符号概率与范围计算

先计算每个符号的概率，然后为其分配一个范围，范围的大小与符号的概率成正比。

probs = {symbol: freq[symbol] / total for symbol in freq}
# 计算符号范围
symbols = sorted(probs.keys())
low = {}
high = {}
cumulative = 0.0
for symbol in symbols:
    low[symbol] = cumulative
    cumulative += probs[symbol]
    high[symbol] = cumulative

8.3.2 区间缩小与编码

遍历数据中的每个符号，不断缩小当前的区间为对应符号的范围，直到编码完成。

8.4 解码过程的注意事项

在解码过程中，需要注意：

预测编码：确保编码数据格式正确，可以成功转换为整数列表。
哈夫曼编码：需要在编码阶段保存哈夫曼码字表，解码时使用。
算术编码：需要在编码阶段保存符号范围表和编码值，解码时根据数据长度进行迭代。

9. 程序运行示例

9.1 预测编码示例

输入数据：10 12 15 13 16

编码结果：10 2 3 -2 3

解码结果：10 12 15 13 16

9.2 哈夫曼编码示例

输入数据：1 3 3 3 5 5 5 5

编码结果：0111111000

哈夫曼码字表：

5: 0
3: 11
1: 10

解码结果：1 3 3 3 5 5 5 5

9.3 算术编码示例

输入数据：2 2 3 3 1

编码结果：0.356

符号范围表：

1: [0.0, 0.2)
2: [0.2, 0.6)
3: [0.6, 1.0)

解码结果：2 2 3 3 1

10. 总结

本文详细介绍了熵编码模拟器的设计与实现，涵盖了预测编码、哈夫曼编码和算术编码三种常见的熵编码方法。通过理论与实践相结合的方式，深入剖析了各编码方法的原理和实现细节。利用Python和PyQt5，我们成功构建了一个直观友好的图形用户界面，帮助用户更好地理解熵编码的概念和应用。

完整代码：

# -*- coding: utf-8 -*-
"""
作者：1248693038
日期：2024-10-28
说明：该程序演示了熵编码中的预测编码、变长编码和算术编码的示例模拟。
      通过图形用户界面，用户可以输入数据，选择编码方式，并查看编码和解码的结果。
"""

import sys
from PyQt5.QtWidgets import (QApplication, QMainWindow, QWidget, QLabel, QPushButton,
                             QLineEdit, QGridLayout, QMessageBox, QComboBox, QTextEdit)
from PyQt5.QtCore import Qt
import numpy as np
import heapq
from collections import defaultdict

class EntropyCodingSimulator:
    """
    熵编码模拟器类，包含预测编码、变长编码和算术编码的实现
    """
    def __init__(self, data):
        self.data = data  # 原始数据，字符串形式
        self.numeric_data = self.str_to_numbers(data)  # 将字符串转换为数字列表

    def str_to_numbers(self, data_str):
        """
        将字符串转换为数字列表，假设以空格分隔
        """
        try:
            numbers = list(map(int, data_str.strip().split()))
            return numbers
        except ValueError:
            QMessageBox.warning(None, "错误", "输入的数据格式不正确，请输入数字并用空格分隔。")
            return []

    # ------------------ 预测编码 ------------------

    def predictive_encode(self):
        """
        对数据进行预测编码，使用简单的一阶预测（当前值减去前一个值）
        """
        data = self.numeric_data
        if not data:
            return []
        encoded = [data[0]]  # 第一个值直接编码
        for i in range(1, len(data)):
            encoded.append(data[i] - data[i - 1])
        return encoded

    def predictive_decode(self, encoded_data):
        """
        对预测编码的数据进行解码
        """
        if not encoded_data:
            return []
        decoded = [encoded_data[0]]
        for i in range(1, len(encoded_data)):
            decoded.append(encoded_data[i] + decoded[i - 1])
        return decoded

    # ------------------ 哈夫曼编码 ------------------

    def huffman_encode(self):
        """
        对数据进行哈夫曼编码
        """
        data = self.numeric_data
        if not data:
            return {}, ''
        # 计算频率
        freq = defaultdict(int)
        for symbol in data:
            freq[symbol] += 1

        # 构建哈夫曼树
        heap = [[weight, [symbol, ""]] for symbol, weight in freq.items()]
        heapq.heapify(heap)
        while len(heap) > 1:
            lo = heapq.heappop(heap)
            hi = heapq.heappop(heap)
            for pair in lo[1:]:
                pair[1] = '0' + pair[1]
            for pair in hi[1:]:
                pair[1] = '1' + pair[1]
            new_node = [lo[0] + hi[0]] + lo[1:] + hi[1:]
            heapq.heappush(heap, new_node)
        huff_dict = dict(sorted(heap[0][1:], key=lambda p: (len(p[1]), p)))
        # 编码
        encoded_output = ''.join([huff_dict[symbol] for symbol in data])
        return huff_dict, encoded_output

    def huffman_decode(self, huff_dict, encoded_data):
        """
        对哈夫曼编码的数据进行解码
        """
        inv_huff_dict = {v: k for k, v in huff_dict.items()}
        decoded = []
        code = ''
        for bit in encoded_data:
            code += bit
            if code in inv_huff_dict:
                decoded.append(inv_huff_dict[code])
                code = ''
        return decoded

    # ------------------ 算术编码 ------------------

    def arithmetic_encode(self):
        """
        对数据进行算术编码
        """
        data = self.numeric_data
        if not data:
            return {}, 0.0
        # 计算频率和概率
        freq = defaultdict(int)
        for symbol in data:
            freq[symbol] += 1
        total = sum(freq.values())
        probs = {symbol: freq[symbol] / total for symbol in freq}
        # 计算符号范围
        symbols = sorted(probs.keys())
        low = {}
        high = {}
        cumulative = 0.0
        for symbol in symbols:
            low[symbol] = cumulative
            cumulative += probs[symbol]
            high[symbol] = cumulative
        # 编码
        l, h = 0.0, 1.0
        for symbol in data:
            range_ = h - l
            h = l + range_ * high[symbol]
            l = l + range_ * low[symbol]
        code = (l + h) / 2   # 取范围的中间值作为码
        return (low, high), code

    def arithmetic_decode(self, ranges, code, data_length):
        """
        对算术编码的数据进行解码
        """
        low, high = ranges
        decoded = []
        for _ in range(data_length):
            for symbol in low:
                if low[symbol] <= code < high[symbol]:
                    decoded.append(symbol)
                    range_ = high[symbol] - low[symbol]
                    code = (code - low[symbol]) / range_
                    break
        return decoded

class MainWindow(QMainWindow):
    """
    主窗口类，构建图形用户界面
    """
    def __init__(self):
        super().__init__()
        self.setWindowTitle("熵编码模拟器")
        self.setFixedSize(800, 600)
        self.init_ui()

    def init_ui(self):
        """
        初始化用户界面
        """
        # 创建部件
        self.central_widget = QWidget()
        self.setCentralWidget(self.central_widget)

        # 输入数据标签和文本框
        self.input_label = QLabel("请输入数据（用空格分隔）：")
        self.input_edit = QLineEdit()
        self.input_edit.setPlaceholderText("例如：1 2 3 4 5")

        # 编码方式下拉框
        self.encode_label = QLabel("选择编码方式：")
        self.encode_combo = QComboBox()
        self.encode_combo.addItems(['预测编码', '哈夫曼编码', '算术编码'])

        # 编码按钮
        self.encode_button = QPushButton("编码")
        self.decode_button = QPushButton("解码")

        # 显示原始数据、编码结果和解码结果的文本框
        self.original_label = QLabel("原始数据：")
        self.original_text = QTextEdit()
        self.original_text.setReadOnly(True)

        self.encoded_label = QLabel("编码结果：")
        self.encoded_text = QTextEdit()
        self.encoded_text.setReadOnly(True)

        self.decoded_label = QLabel("解码结果：")
        self.decoded_text = QTextEdit()
        self.decoded_text.setReadOnly(True)

        # 说明文本
        self.description_label = QLabel("编码说明：")
        self.description_text = QTextEdit()
        self.description_text.setReadOnly(True)
        self.update_description()  # 更新说明

        # 布局设置
        layout = QGridLayout()
        layout.addWidget(self.input_label, 0, 0, 1, 2)
        layout.addWidget(self.input_edit, 0, 2, 1, 4)
        layout.addWidget(self.encode_label, 1, 0)
        layout.addWidget(self.encode_combo, 1, 1)
        layout.addWidget(self.encode_button, 1, 2)
        layout.addWidget(self.decode_button, 1, 3)
        layout.addWidget(self.original_label, 2, 0)
        layout.addWidget(self.original_text, 3, 0, 2, 3)
        layout.addWidget(self.encoded_label, 2, 3)
        layout.addWidget(self.encoded_text, 3, 3, 2, 3)
        layout.addWidget(self.decoded_label, 5, 0)
        layout.addWidget(self.decoded_text, 6, 0, 2, 3)
        layout.addWidget(self.description_label, 5, 3)
        layout.addWidget(self.description_text, 6, 3, 2, 3)

        self.central_widget.setLayout(layout)

        # 信号与槽
        self.encode_button.clicked.connect(self.encode_data)
        self.decode_button.clicked.connect(self.decode_data)
        self.encode_combo.currentTextChanged.connect(self.update_description)

    def update_description(self):
        """
        更新编码方式的说明
        """
        method = self.encode_combo.currentText()
        if method == '预测编码':
            description = (
                "预测编码是一种利用数据的相关性进行编码的方法。\n"
                "它通过前一个数据值预测当前数据，存储预测误差，达到压缩的效果。"
            )
        elif method == '哈夫曼编码':
            description = (
                "哈夫曼编码是一种无损的变长编码方法，常用于数据压缩。\n"
                "它利用数据中各符号出现的频率，构建哈夫曼树，分配短码给高频符号，长码给低频符号。"
            )
        elif method == '算术编码':
            description = (
                "算术编码是一种基于概率区间的无损压缩方法。\n"
                "它将整个数据映射到一个小数区间，通过逐步缩小区间进行编码。"
            )
        else:
            description = "请选择一种编码方式。"

        self.description_text.setText(description)

    def encode_data(self):
        """
        对输入的数据进行编码
        """
        data_str = self.input_edit.text()
        if not data_str.strip():
            QMessageBox.warning(self, "错误", "请输入数据。")
            return
        self.simulator = EntropyCodingSimulator(data_str)
        method = self.encode_combo.currentText()
        self.original_text.setText(data_str)
        if method == '预测编码':
            encoded_data = self.simulator.predictive_encode()
            self.encoded_text.setText(' '.join(map(str, encoded_data)))
        elif method == '哈夫曼编码':
            self.huff_dict, encoded_data = self.simulator.huffman_encode()
            self.encoded_text.setText(encoded_data)
            # 显示码字表
            code_table = '\n'.join([f'{k}: {v}' for k, v in self.huff_dict.items()])
            QMessageBox.information(self, "哈夫曼码字表", code_table)
        elif method == '算术编码':
            self.arith_ranges, self.arith_code = self.simulator.arithmetic_encode()
            self.encoded_text.setText(f'{self.arith_code}')
            # 显示符号范围表
            range_table = '\n'.join([f'{k}: [{v}, {self.arith_ranges[1][k]})' for k, v in self.arith_ranges[0].items()])
            QMessageBox.information(self, "算术编码符号范围表", range_table)
        else:
            QMessageBox.warning(self, "错误", "未知的编码方式。")

    def decode_data(self):
        """
        对编码的数据进行解码
        """
        method = self.encode_combo.currentText()
        if method == '预测编码':
            encoded_str = self.encoded_text.toPlainText()
            if not encoded_str.strip():
                QMessageBox.warning(self, "错误", "没有可解码的数据。")
                return
            try:
                encoded_data = list(map(int, encoded_str.strip().split()))
                decoded_data = self.simulator.predictive_decode(encoded_data)
                self.decoded_text.setText(' '.join(map(str, decoded_data)))
            except ValueError:
                QMessageBox.warning(self, "错误", "编码数据格式不正确。")
        elif method == '哈夫曼编码':
            if not hasattr(self, 'huff_dict'):
                QMessageBox.warning(self, "错误", "没有可解码的数据。")
                return
            encoded_data = self.encoded_text.toPlainText()
            decoded_data = self.simulator.huffman_decode(self.huff_dict, encoded_data)
            self.decoded_text.setText(' '.join(map(str, decoded_data)))
        elif method == '算术编码':
            if not hasattr(self, 'arith_ranges') or not hasattr(self, 'arith_code'):
                QMessageBox.warning(self, "错误", "没有可解码的数据。")
                return
            data_length = len(self.simulator.numeric_data)
            decoded_data = self.simulator.arithmetic_decode(self.arith_ranges, self.arith_code, data_length)
            self.decoded_text.setText(' '.join(map(str, decoded_data)))
        else:
            QMessageBox.warning(self, "错误", "未知的编码方式。")

if __name__ == '__main__':
    app = QApplication(sys.argv)
    window = MainWindow()
    window.show()
    sys.exit(app.exec_())