【图像处理基石】图像压缩有哪些经典算法？

图像压缩是减少图像数据量的技术，主要分为无损压缩 （不丢失信息）和有损压缩（允许一定信息损失以换取更高压缩率）。以下是几种经典算法及其Python实现：

一、经典图像压缩算法简介

行程长度编码（RLE）

无损压缩，适用于存在连续重复像素的图像（如线条图、图标）。原理是记录"像素值+连续出现次数"替代重复像素。
哈夫曼编码（Huffman Coding）

无损压缩，基于像素值出现频率构建变长编码（高频值用短码），广泛用于JPEG、PNG等格式。
离散余弦变换（DCT）

有损压缩，JPEG核心算法。将图像分块后转换到频率域，保留低频分量（视觉重要），丢弃高频分量（细节）。
小波变换（Wavelet Transform）

有损/无损均可，JPEG 2000采用。相比DCT能更好保留边缘信息，压缩率更高。

二、Python实现示例

1. 行程长度编码（RLE）

适用于简单图像（如二值图），实现简单且压缩效果直观。

python 复制代码

import numpy as np
from PIL import Image

def rle_compress(image):
    """将灰度图像压缩为RLE编码（列表形式：[(值, 长度), ...]）"""
    # 将二维图像转为一维数组
    flat = image.flatten()
    if len(flat) == 0:
        return []
    
    compressed = []
    current_val = flat[0]
    count = 1
    
    for val in flat[1:]:
        if val == current_val:
            count += 1
        else:
            compressed.append((current_val, count))
            current_val = val
            count = 1
    # 处理最后一组
    compressed.append((current_val, count))
    return compressed

def rle_decompress(compressed, shape):
    """将RLE编码解压为图像"""
    flat = []
    for val, count in compressed:
        flat.extend([val] * count)
    # 恢复为原始形状
    return np.array(flat).reshape(shape)

# 测试
if __name__ == "__main__":
    # 读取图像并转为灰度图
    img = Image.open("test_image.png").convert("L")  # 替换为你的图像路径
    img_array = np.array(img)
    print("原始图像形状:", img_array.shape)
    print("原始数据量:", img_array.size, "像素")
    
    # 压缩
    compressed = rle_compress(img_array)
    print("RLE压缩后数据量:", len(compressed), "组")
    
    # 解压
    decompressed = rle_decompress(compressed, img_array.shape)
    
    # 验证是否完全恢复（无损压缩）
    print("解压后与原始是否一致:", np.array_equal(img_array, decompressed))
    
    # 保存解压后的图像
    Image.fromarray(decompressed).save("rle_decompressed.png")

2. 哈夫曼编码（Huffman Coding）

基于频率的变长编码，适合像素值分布不均匀的图像。

python 复制代码

import numpy as np
from PIL import Image
import heapq
from collections import defaultdict

# 构建哈夫曼树节点
class HuffmanNode:
    def __init__(self, value, freq):
        self.value = value  # 像素值
        self.freq = freq    # 频率
        self.left = None
        self.right = None
    
    # 用于优先队列排序
    def __lt__(self, other):
        return self.freq < other.freq

# 构建哈夫曼树
def build_huffman_tree(freq_dict):
    heap = [HuffmanNode(val, freq) for val, freq in freq_dict.items()]
    heapq.heapify(heap)
    
    while len(heap) > 1:
        left = heapq.heappop(heap)
        right = heapq.heappop(heap)
        # 合并节点（值为None表示内部节点）
        merged = HuffmanNode(None, left.freq + right.freq)
        merged.left = left
        merged.right = right
        heapq.heappush(heap, merged)
    
    return heap[0] if heap else None

# 生成哈夫曼编码表
def generate_code_table(root):
    code_table = {}
    
    def traverse(node, current_code=""):
        if node is None:
            return
        # 叶子节点（有像素值）
        if node.value is not None:
            code_table[node.value] = current_code if current_code else "0"
            return
        # 左子树加"0"，右子树加"1"
        traverse(node.left, current_code + "0")
        traverse(node.right, current_code + "1")
    
    traverse(root)
    return code_table

# 哈夫曼压缩
def huffman_compress(image):
    flat = image.flatten()
    # 统计频率
    freq_dict = defaultdict(int)
    for val in flat:
        freq_dict[val] += 1
    
    # 构建树和编码表
    root = build_huffman_tree(freq_dict)
    code_table = generate_code_table(root)
    
    # 编码数据（转为二进制字符串）
    encoded_bits = "".join([code_table[val] for val in flat])
    return encoded_bits, code_table, image.shape

# 哈夫曼解压
def huffman_decompress(encoded_bits, code_table, shape):
    # 反转编码表（编码->值）
    reverse_table = {code: val for val, code in code_table.items()}
    current_code = ""
    flat = []
    
    for bit in encoded_bits:
        current_code += bit
        if current_code in reverse_table:
            flat.append(reverse_table[current_code])
            current_code = ""
    
    return np.array(flat).reshape(shape)

# 测试
if __name__ == "__main__":
    img = Image.open("test_image.png").convert("L")
    img_array = np.array(img)
    print("原始图像形状:", img_array.shape)
    print("原始数据量:", img_array.size * 8, "比特（假设8位灰度）")
    
    # 压缩
    encoded_bits, code_table, shape = huffman_compress(img_array)
    print("哈夫曼压缩后数据量:", len(encoded_bits), "比特")
    print("压缩率:", len(encoded_bits)/(img_array.size * 8))
    
    # 解压
    decompressed = huffman_decompress(encoded_bits, code_table, shape)
    
    # 验证无损性
    print("解压后与原始是否一致:", np.array_equal(img_array, decompressed))
    Image.fromarray(decompressed).save("huffman_decompressed.png")

3. 离散余弦变换（DCT）

JPEG核心算法，有损压缩，通过丢弃高频分量减少数据量。

python 复制代码

import numpy as np
from PIL import Image
from scipy.fftpack import dct, idct

# JPEG标准亮度量化矩阵（用于有损压缩）
QUANTIZATION_MATRIX = np.array([
    [16, 11, 10, 16, 24, 40, 51, 61],
    [12, 12, 14, 19, 26, 58, 60, 55],
    [14, 13, 16, 24, 40, 57, 69, 56],
    [14, 17, 22, 29, 51, 87, 80, 62],
    [18, 22, 37, 56, 68, 109, 103, 77],
    [24, 35, 55, 64, 81, 104, 113, 92],
    [49, 64, 78, 87, 103, 121, 120, 101],
    [72, 92, 95, 98, 112, 100, 103, 99]
], dtype=np.float32)

def dct_compress(image, quant_matrix=QUANTIZATION_MATRIX):
    """DCT压缩：分块->DCT->量化"""
    h, w = image.shape
    # 确保尺寸是8的倍数（JPEG分块大小为8x8）
    h_padded = ((h + 7) // 8) * 8
    w_padded = ((w + 7) // 8) * 8
    padded = np.pad(image, ((0, h_padded - h), (0, w_padded - w)), mode='constant')
    
    compressed = np.zeros_like(padded, dtype=np.int32)
    
    # 对每个8x8块进行处理
    for i in range(0, h_padded, 8):
        for j in range(0, w_padded, 8):
            block = padded[i:i+8, j:j+8]
            # 转换为[-128, 127]（DCT通常基于零均值）
            block_shifted = block - 128
            # 2D DCT变换
            dct_block = dct(dct(block_shifted, axis=0, norm='ortho'), axis=1, norm='ortho')
            # 量化（除以量化矩阵并取整，核心压缩步骤）
            quant_block = np.round(dct_block / quant_matrix).astype(np.int32)
            compressed[i:i+8, j:j+8] = quant_block
    
    return compressed, (h, w)  # 保留原始尺寸用于解压

def dct_decompress(compressed, original_shape, quant_matrix=QUANTIZATION_MATRIX):
    """DCT解压：反量化->IDCT->拼接"""
    h_padded, w_padded = compressed.shape
    h, w = original_shape
    decompressed = np.zeros_like(compressed, dtype=np.float32)
    
    # 对每个8x8块处理
    for i in range(0, h_padded, 8):
        for j in range(0, w_padded, 8):
            quant_block = compressed[i:i+8, j:j+8]
            # 反量化
            dct_block = quant_block * quant_matrix
            # 逆DCT变换
            block_shifted = idct(idct(dct_block, axis=0, norm='ortho'), axis=1, norm='ortho')
            # 恢复到[0, 255]
            block = np.round(block_shifted + 128).clip(0, 255).astype(np.uint8)
            decompressed[i:i+8, j:j+8] = block
    
    # 裁剪回原始尺寸
    return decompressed[:h, :w].astype(np.uint8)

# 测试
if __name__ == "__main__":
    img = Image.open("test_image.png").convert("L")
    img_array = np.array(img)
    print("原始图像形状:", img_array.shape)
    
    # 压缩
    compressed, original_shape = dct_compress(img_array)
    
    # 解压（会有损失）
    decompressed = dct_decompress(compressed, original_shape)
    
    # 保存结果
    Image.fromarray(decompressed).save("dct_decompressed.png")
    print("DCT压缩解压完成（有损压缩，可能有画质损失）")

三、算法对比与应用场景

算法	类型	压缩率	适用场景	典型应用
RLE	无损	低	连续重复像素多的图像（图标）	BMP、Fax格式
哈夫曼编码	无损	中	像素分布不均匀的图像	JPEG、PNG、ZIP
DCT	有损	高	自然图像（人眼对细节不敏感）	JPEG
小波变换	有损/无损	高	需要高压缩率+保留细节的场景	JPEG 2000、医学图像

以上实现均为简化版本，实际工业级压缩（如JPEG）会结合多种算法（如DCT+哈夫曼编码）并优化细节（如色彩空间转换、熵编码）。