用Python实现对图像进行不同程度的JPEG压缩，用cv2库函数实现图像的输入输出，压缩过程不能使用库函数

首先，需要明确JPEG压缩的基本流程。JPEG压缩主要分为离散余弦变换（DCT）和量化两个过程。

DCT过程：

1. 将RGB图像转换为YUV图像，其中Y表示亮度，U和V表示色度。
2. 对每个YUV分量进行8x8的划分，对于每个8x8的图像块，进行DCT变换。
3. 对DCT系数进行量化，将较大的系数变为0，降低信息量。
4. 对量化后的系数进行Z字形扫描，并进行哈夫曼编码压缩。

量化过程：

1. 分别生成亮度和色度的量化矩阵。
2. 将DCT系数根据量化矩阵进行量化。

下面是Python实现对图像进行不同程度的JPEG压缩的代码：

import cv2
import numpy as np

# 定义亮度和色度量化矩阵
lumin_quant = 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]])

chrom_quant = np.array([[17, 18, 24, 47, 99, 99, 99, 99],
                        [18, 21, 26, 66, 99, 99, 99, 99],
                        [24, 26, 56, 99, 99, 99, 99, 99],
                        [47, 66, 99, 99, 99, 99, 99, 99],
                        [99, 99, 99, 99, 99, 99, 99, 99],
                        [99, 99, 99, 99, 99, 99, 99, 99],
                        [99, 99, 99, 99, 99, 99, 99, 99],
                        [99, 99, 99, 99, 99, 99, 99, 99]])

# 定义DCT变换矩阵
dct_matrix = np.zeros((8, 8))
for i in range(8):
    for j in range(8):
        if i == 0:
            dct_matrix[i][j] = 1 / np.sqrt(8)
        else:
            dct_matrix[i][j] = np.sqrt(2 / 8) * np.cos((2 * j + 1) * i * np.pi / 16)

# 定义Z字形扫描顺序
zigzag_order = np.array([[0, 1, 5, 6, 14, 15, 27, 28],
                         [2, 4, 7, 13, 16, 26, 29, 42],
                         [3, 8, 12, 17, 25, 30, 41, 43],
                         [9, 11, 18, 24, 31, 40, 44, 53],
                         [10, 19, 23, 32, 39, 45, 52, 54],
                         [20, 22, 33, 38, 46, 51, 55, 60],
                         [21, 34, 37, 47, 50, 56, 59, 61],
                         [35, 36, 48, 49, 57, 58, 62, 63]])

# 定义JPEG压缩函数
def jpeg_compress(img, quality):
    # 转换为YUV格式
    yuv_img = cv2.cvtColor(img, cv2.COLOR_BGR2YUV)
    rows, cols, _ = yuv_img.shape

    # 划分为8x8的图像块
    y_blocks = np.zeros((rows, cols))
    u_blocks = np.zeros((rows, cols))
    v_blocks = np.zeros((rows, cols))
    for i in range(0, rows, 8):
        for j in range(0, cols, 8):
            y_blocks[i:i+8, j:j+8] = yuv_img[i:i+8, j:j+8, 0]
            u_blocks[i:i+8, j:j+8] = yuv_img[i:i+8, j:j+8, 1]
            v_blocks[i:i+8, j:j+8] = yuv_img[i:i+8, j:j+8, 2]

    # 对YUV分量进行DCT变换和量化
    y_dct_blocks = np.zeros((rows, cols))
    u_dct_blocks = np.zeros((rows, cols))
    v_dct_blocks = np.zeros((rows, cols))
    for i in range(0, rows, 8):
        for j in range(0, cols, 8):
            y_dct_blocks[i:i+8, j:j+8] = np.dot(np.dot(dct_matrix, y_blocks[i:i+8, j:j+8]), dct_matrix.T)
            u_dct_blocks[i:i+8, j:j+8] = np.dot(np.dot(dct_matrix, u_blocks[i:i+8, j:j+8]), dct_matrix.T)
            v_dct_blocks[i:i+8, j:j+8] = np.dot(np.dot(dct_matrix, v_blocks[i:i+8, j:j+8]), dct_matrix.T)

            y_dct_blocks[i:i+8, j:j+8] = np.round(y_dct_blocks[i:i+8, j:j+8] / (lumin_quant * quality))
            u_dct_blocks[i:i+8, j:j+8] = np.round(u_dct_blocks[i:i+8, j:j+8] / (chrom_quant * quality))
            v_dct_blocks[i:i+8, j:j+8] = np.round(v_dct_blocks[i:i+8, j:j+8] / (chrom_quant * quality))

    # 对DCT系数进行Z字形扫描和哈夫曼编码
    y_zigzag_blocks = np.zeros((rows, cols))
    u_zigzag_blocks = np.zeros((rows, cols))
    v_zigzag_blocks = np.zeros((rows, cols))
    for i in range(0, rows, 8):
        for j in range(0, cols, 8):
            y_zigzag_blocks[i:i+8, j:j+8] = y_dct_blocks[i:i+8, j:j+8][zigzag_order]
            u_zigzag_blocks[i:i+8, j:j+8] = u_dct_blocks[i:i+8, j:j+8][zigzag_order]
            v_zigzag_blocks[i:i+8, j:j+8] = v_dct_blocks[i:i+8, j:j+8][zigzag_order]

    # 将YUV分量合并为一张图像
    yuv_compress = np.zeros((rows, cols, 3))
    yuv_compress[..., 0] = y_zigzag_blocks
    yuv_compress[..., 1] = u_zigzag_blocks
    yuv_compress[..., 2] = v_zigzag_blocks

    # 转换为BGR格式
    compress_img = cv2.cvtColor(yuv_compress.astype(np.uint8), cv2.COLOR_YUV2BGR)
    return compress_img

# 读取图像
img = cv2.imread('lena.jpg')

# 不同质量下的JPEG压缩
quality1 = 10
quality2 = 50
quality3 = 90
compress_img1 = jpeg_compress(img, quality1)
compress_img2 = jpeg_compress(img, quality2)
compress_img3 = jpeg_compress(img, quality3)

# 显示压缩后的图像
cv2.imshow('compress_img1', compress_img1)
cv2.imshow('compress_img2', compress_img2)
cv2.imshow('compress_img3', compress_img3)
cv2.waitKey(0)
cv2.destroyAllWindows()

在上面的代码中，我们首先定义了亮度和色度的量化矩阵、DCT变换矩阵和Z字形扫描顺序。然后，我们定义了一个JPEG压缩函数，该函数接受一个图像和一个质量参数作为输入，并返回压缩后的图像。在函数中，我们首先将图像转换为YUV格式，然后对YUV分量进行8x8的划分，对每个8x8的图像块进行DCT变换和量化，并对量化后的系数进行Z字形扫描和哈夫曼编码。最后，我们将YUV分量合并为一张图像，转换为BGR格式，并返回压缩后的图像。

在主函数中，我们读取了一张图像，并分别对图像进行了不同质量下的JPEG压缩，并显示压缩后的图像。