矩阵论在图像算法中的应用

摘要： 本文详细阐述了矩阵论在图像算法中的广泛应用。首先介绍了图像在计算机中的矩阵表示形式，然后从图像压缩、图像变换、图像特征提取与识别、图像恢复与重建等多个方面深入分析了矩阵论相关技术的作用原理和优势。通过对这些应用的探讨，展示了矩阵论在提高图像处理效率、增强图像质量和实现复杂图像分析任务中的关键地位，同时对其未来发展方向进行了展望。

一、引言

图像作为一种重要的信息载体，在众多领域如计算机视觉、医学成像、遥感、安防等有着广泛的应用。随着数字化技术的发展，对图像的处理和分析要求也日益提高。矩阵论作为数学的一个重要分支，为图像算法提供了坚实的理论基础和有效的计算工具。通过将图像表示为矩阵形式，利用矩阵的各种运算和性质，可以实现图像的高效处理和深入分析。

二、图像的矩阵表示

在计算机中，一幅二维灰度图像可以用一个矩阵来表示。对于一个 $M\times N$ 的图像，其灰度值可以存储在一个 $M\times N$ 的矩阵 $A$ 中，其中矩阵中的每个元素 $a_{ij}$ 表示图像在第 i 行第 j 列位置的灰度值。彩色图像通常可以用多个矩阵来表示，例如对于 RGB 彩色模式，一幅图像可以由红、绿、蓝三个颜色通道的矩阵组成。这种矩阵表示形式使得我们可以方便地利用矩阵运算来处理图像。

三、矩阵论在图像压缩中的应用

（一）奇异值分解（SVD）

奇异值分解是矩阵论中的一种重要分解方法。对于一个 $M\times N$ 的矩阵 $A$ ，可以分解为 $A = U\Sigma V^T$ ，其中U是一个 $m\times m$ 的正交矩阵， $\Sigma$ 是一个 $m\times n$ 的对角矩阵，其对角元素为奇异值，V 是一个 $n\times n$ 的正交矩阵。

在图像压缩中，将图像矩阵进行 SVD 分解。由于奇异值的大小反映了矩阵所包含信息的重要程度，我们可以选择保留较大的奇异值，而舍弃较小的奇异值。通过重构矩阵（其中是保留了部分奇异值的对角矩阵），可以得到压缩后的图像。这种方法可以在损失一定图像质量的情况下，大大减少图像数据的存储量。

（二）小波变换与矩阵表示

小波变换是另一种常用的图像压缩方法。小波变换可以通过离散小波变换（DWT）矩阵来实现。DWT 矩阵将图像矩阵分解为不同尺度和方向的小波系数矩阵。这些系数矩阵具有不同的能量分布，低频部分的系数包含了图像的主要信息，而高频部分则包含了图像的细节信息。通过对小波系数进行阈值量化，将较小的系数置零，可以实现图像的压缩。同时，小波变换的多分辨率特性使得它可以根据需要选择合适的分辨率来压缩图像，进一步提高压缩效率。

四、矩阵论在图像变换中的应用

（一）傅里叶变换

傅里叶变换是一种将图像从空间域转换到频率域的重要变换方法。对于一个离散图像矩阵，其二维离散傅里叶变换（DFT）定义为：

$F(u,v)=\frac{1}{MN}\sum_{x = 0}^{M - 1}\sum_{y = 0}^{N - 1}f(x,y)e^{-j2\pi(\frac{ux}{M}+\frac{vy}{N})}$

（二）离散余弦变换（DCT）

离散余弦变换在图像压缩和变换中也有着广泛的应用。对于一个的图像矩阵，其二维离散余弦变换公式为：

$F(u,v)=\alpha(u)\alpha(v)\sum_{x = 0}^{N - 1}\sum_{y = 0}^{N - 1}f(x,y)\cos\frac{\pi(2x + 1)u}{2N}\cos\frac{\pi(2y + 1)v}{2N}$

DCT 将图像的能量集中在少数几个系数上，在图像压缩标准如 JPEG 中，通过对 DCT 系数进行量化和编码来实现图像压缩。同时，DCT 也可用于图像的特征提取和纹理分析，通过分析 DCT 系数的分布来获取图像的相关特征。

五、矩阵论在图像特征提取与识别中的应用

（一）主成分分析（PCA）

主成分分析是基于矩阵协方差分析的一种数据降维和特征提取方法。对于一组图像数据，可以将每个图像表示为一个向量，然后将这些向量组成一个矩阵。通过计算该矩阵的协方差矩阵，并对协方差矩阵进行特征值分解，得到主成分。这些主成分是原始图像数据的线性组合，它们按照所包含信息量的多少进行排序。

在图像识别中，通过将图像投影到主成分空间，可以减少图像数据的维度，同时保留对分类最有用的信息。新的低维特征向量可以作为图像的特征表示用于分类器的训练和识别，提高了识别效率和准确性。

（二）特征值与特征向量在图像纹理分析中的应用

图像的纹理是图像的重要特征之一。矩阵的特征值和特征向量可以用于分析图像的纹理特征。例如，对于图像的局部区域，可以构建一个灰度共生矩阵，通过计算该矩阵的特征值和特征向量来描述纹理的方向、粗糙度等特性。不同的纹理具有不同的特征值和特征向量分布，这些特征可以用于图像的分类和识别，区分具有不同纹理的图像区域。

六、矩阵论在图像恢复与重建中的应用

（一）最小二乘法在图像去噪中的应用

在图像采集和传输过程中，往往会受到噪声的干扰。假设受到噪声污染的图像可以表示为原始图像 x 和噪声n 的和，即 y=x+n。

如果我们有一个关于原始图像的线性模型 $Ax = b$ （其中A 是一个已知的系数矩阵，可能与图像的采集过程或先验知识有关），可以通过最小二乘法求解X ，使得 $\|Ax - y\|^2$ 最小。在图像去噪中，这个过程可以利用矩阵运算来迭代地优化图像，去除噪声，恢复原始图像的信息。

（二）压缩感知与矩阵重构

压缩感知理论指出，对于一个稀疏信号或可压缩信号，可以通过少量的线性测量来恢复原始信号。在图像中，如果图像在某个变换域是稀疏的（如小波域），可以通过设计合适的测量矩阵对图像进行测量，得到少量的测量值。然后通过求解一个优化问题，利用矩阵重构算法（如基于凸优化的方法或贪婪算法）来恢复原始图像。这种方法在减少图像采集数据量的同时，仍能保证图像的高质量恢复，在医学成像等领域有着重要的应用。

七、结论与展望

矩阵论在图像算法中有着至关重要的应用。从图像的表示、压缩、变换、特征提取到恢复重建等各个环节，矩阵的运算和相关理论为图像算法提供了高效的实现途径和准确的分析方法。随着图像技术的不断发展，如高分辨率图像、动态图像序列的处理需求增加，以及对图像理解和语义分析的深入要求，矩阵论将继续在新的图像算法开发中发挥关键作用。未来，我们可以期待更高效的矩阵分解算法、更适应复杂图像结构的变换方法以及更精确的基于矩阵的图像模型的出现，进一步推动图像技术在各个领域的广泛应用和创新发展。同时，矩阵论与其他数学分支如优化理论、概率论等的结合也将为图像算法带来新的突破。

八、代码示例

以下是上述矩阵论在图像算法各应用场景对应的 C++ OpenCV 代码示例：

一、图像的矩阵表示（OpenCV 中图像本身就是以矩阵形式存储，这里简单展示读取并访问图像矩阵元素的示例）

#include <iostream>
#include <opencv2/opencv.hpp>

int main() {
    // 读取图像
    cv::Mat image = cv::imread("your_image.jpg", cv::IMREAD_COLOR);

    if (image.empty()) {
        std::cout << "无法读取图像！" << std::endl;
        return -1;
    }

    // 获取图像的行数和列数
    int rows = image.rows;
    int cols = image.cols;

    // 访问图像矩阵元素（这里以访问每个像素的蓝色通道为例）
    for (int i = 0; i < rows; ++i) {
        for (int j = 0; j < cols; ++j) {
            // 获取像素点的引用
            cv::Vec3b& pixel = image.at<cv::Vec3b>(i, j);
            // 访问蓝色通道值
            uchar blueValue = pixel[0];
            // 可以在这里对蓝色通道值进行操作，比如修改它
            // pixel[0] = 255; // 将蓝色通道值设为255（这里只是示例，可根据需求修改）
        }
    }

    // 显示处理后的图像（这里只是示例，可根据需求添加更多显示设置等）
    cv::namedWindow("Processed Image", cv::WINDOW_NORMAL);
    cv::imshow("Processed Image", image);
    cv::waitKey(0);

    return 0;
}

二、矩阵论在图像压缩中的应用

奇异值分解（SVD）用于图像压缩

#include <iostream>
#include <opencv2/opencv.hpp>

int main() {
    // 读取图像
    cv::Mat image = cv::imread("your_image.jpg", cv::IMREAD_GRAYSCALE);

    if (image.empty()) {
        std::cout << "无法读取图像！" << std::endl;
        return -1;
    }

    // 对图像进行奇异值分解
    cv::SVD svd(image);

    // 获取奇异值矩阵
    cv::Mat singularValues = svd.w;

    // 选择保留的奇异值数量（这里假设保留前k个奇异值）
    int k = 50;

    // 创建新的奇异值矩阵，只保留前k个奇异值，其余设为0
    cv::Mat singularValuesReduced = cv::Mat::zeros(singularValues.rows, singularValues.cols, singularValues.type());
    for (int i = 0; i < k; ++i) {
        singularValuesReduced.at<double>(i, i) = singularValues.at<double>(i, i);
    }

    // 重构图像
    cv::Mat reconstructedImage = svd.u * singularValuesReduced * svd.vt;

    // 显示原始图像和压缩后重构的图像
    cv::namedWindow("Original Image", cv::WINDOW_NORMAL);
    cv::imshow("Original Image", image);

    cv::namedWindow("Compressed and Reconstructed Image", cv::WINDOW_NORMAL);
    cv::imshow("Compressed and Reconstructed Image", reconstructedImage);

    cv::waitKey(0);

    return 0;
}

小波变换与矩阵表示用于图像压缩

#include <iostream>
#include <opencv2/opencv.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include <opencv2/core/core.hpp>

int main() {
    // 读取图像
    cv::Mat image = cv::imread("your_image.jpg", cv::IMREAD_GRAYSCALE);

    if (image.empty()) {
        std::cout << "无法读取图像！" << std::endl;
        return -1;
    }

    // 进行小波变换
    cv::Mat waveletTransformed;
    cv::dwt(image, waveletTransformed);

    // 获取小波系数矩阵（这里简单示例，实际可能需要更深入处理不同子带系数）
    cv::Mat LL, LH, HL, HH;
    cv::split(waveletTransformed, {LL, LH, HL, HH});

    // 对小波系数进行阈值量化（这里简单设置一个阈值，将小于阈值的系数设为0）
    double threshold = 10.0;
    for (int i = 0; i < LL.rows; ++i) {
        for (int j = 0; j < LL.cols; ++j) {
            if (std::abs(LL.at<double>(i, j)) < threshold) {
                LL.at<double>(i, j) = 0;
            }
        }
    }
    for (int i = 0; i < LH.rows; ++i) {
        for (int j = 0; j < LH.cols; ++j) {
            if (std::abs(LH.at<double>(i, j)) < threshold) {
                LH.at<double>(i, j) = 0;
            }
        }
    }
    for (int i = 0; i < HL.rows; ++i) {
        for (int j = 0; j < HL.cols; ++j) {
            if (std::abs(HL.at<double>(i, j)) < threshold) {
                HL.at<double>(i, j) = 0;
            }
        }
    }
    for (int i = 0; i < HH.rows; ++i) {
        for (int j = 0; j < HH.cols; ++j) {
            if (std::abs(HH.at<double>(i, j)) < threshold) {
                HH.at<double>(i, j) = 0;
            }
        }
    }

    // 重构图像
    cv::Mat reconstructedImage;
    cv::idwt(LL, LH, HL, HH, reconstructedImage);

    // 显示原始图像和压缩后重构的图像
    cv::namedWindow("Original Image", cv::WINDOW_NORMAL);
    cv::imshow("Original Image", image);

    cv::namedWindow("Compressed and Reconstructed Image", cv::WINDOW_NORMAL);
    cv::imshow("Compressed and Reconstructed Image", reconstructedImage);

    cv::waitKey(0);

    return 0;
}

三、矩阵论在图像变换中的应用

傅里叶变换用于图像滤波

#include <iostream>
#include <opencv2/opencv.hpp>

int main() {
    // 读取图像
    cv::Mat image = cv::imread("your_image.jpg", cv::IMREAD_GRAYSCALE);

    if (image.empty()) {
        std::cout << "无法读取图像！" << std::endl;
        return -1;
    }

    // 进行二维离散傅里叶变换
    cv::Mat dftImage;
    cv::dft(image, dftImage, cv::DFT_COMPLEX_OUTPUT);

    // 将零频率分量移到中心
    cv::shift(dftImage, dftImage);

    // 创建滤波器（这里简单创建一个低通滤波器示例）
    int rows = dftImage.rows;
    int cols = dftImage.cols;
    cv::Mat filter = cv::Mat::zeros(rows, cols, CV_32FC2);
    int centerX = rows / 2;
    int centerY = cols / 2;
    int radius = 30;
    for (int i = 0; i < rows; ++i) {
        for (int j = 0; j < cols; ++j) {
            int dx = i - centerX;
            int dy = j - centerY;
            if (sqrt(dx * dx + dy * dy) <= radius) {
                filter.at<cv::Vec2f>(i, j)[0] = 1;
                filter.at<cv::Vec2f>(i, j)[1] = 1;
            }
        }
    }

    // 应用滤波器
    cv::Mat filteredDftImage;
    cv::mulSpectrums(dftImage, filter, filteredDftImage, 0);

    // 将零频率分量移回原来位置
    cv::shift(filteredDftImage, filteredDftImage);

    // 进行逆傅里叶变换
    cv::Mat filteredImage;
    cv::idft(filteredDftImage, filteredImage, cv::DFT_REAL_OUTPUT);

    // 显示原始图像和滤波后的图像
    cv::namedWindow("Original Image", cv::WINDOW_NORMAL);
    cv::imshow("Original Image", image);

    cv::namedWindow("Filtered Image", cv::WINDOW_NORMAL);
    cv::imshow("Filtered Image", filteredImage);

    cv::waitKey(0);

    return 0;
}

离散余弦变换（DCT）用于图像压缩

#include <iostream>
#include <opencv2/opencv.hpp>

int main() {
    // 读取图像
    cv::Mat image = cv::imread("your_image.jpg", cv::IMREAD_GRAYSCALE);

    if (image.empty()) {
        std::cout << "无法读取图像！" << std::endl;
        return -1;
    }

    // 进行二维离散余弦变换
    cv::Mat dctImage;
    cv::dct(image, dctImage);

    // 对DCT系数进行量化（这里简单示例，实际量化方式更复杂）
    for (int i = 0; i < dctImage.rows; ++i) {
        for (int j = 0; j < dctImage.cols; ++j) {
            dctImage.at<double>(i, j) = round(dctImage.at<double>(i, j) / 10);
        }
    }

    // 进行逆离散余弦变换
    cv::Mat reconstructedImage;
    cv::idct(dctImage, reconstructedImage);

    // 显示原始图像和压缩后重构的图像
    cv::namedWindow("Original Image", cv::WINDOW_NORMAL);
    cv::imshow("Original Image", image);

    cv::namedWindow("Compressed and Reconstructed Image", cv::WINDOW_NORMAL);
    cv::imshow("Compressed and Reconstructed Image", reconstructedImage);

    cv::waitKey(0);

    return 0;
}

四、矩阵论在图像特征提取与识别中的应用

主成分分析（PCA）用于图像识别

#include <iostream>
#include <opencv2/opencv.hpp>
#include <opencv2/ml/ml.hpp>

// 假设我们有一组图像数据，这里简单模拟一下，实际应该从文件或数据库读取
std::vector<cv::Mat> loadImageData() {
    std::vector<cv::Mat> imageData;
    // 这里可以添加代码从文件或其他来源加载真实的图像数据，并将每个图像转换为向量形式，这里简单模拟几个示例向量
    cv::Mat image1 = cv::Mat::ones(100, 100, CV_32FC1);
    cv::Mat image2 = cv::Mat::zeros(100, 100, CV_32FC1);
    imageData.push_back(image1.reshape(1, 100 * 100));
    imageData.push_back(image2.reshape(1, 100 * 100));
    return imageData;
}

int main() {
    // 加载图像数据
    std::vector<cv::Mat> imageData = loadImageData();

    // 将图像数据组成矩阵
    cv::Mat dataMatrix;
    for (const auto& image : imageData) {
        if (dataMatrix.empty()) {
            dataMatrix = image;
        } else {
            dataMatrix.push_back(image);
        }
    }

    // 进行主成分分析
    cv::PCA pca(dataMatrix, cv::Mat(), cv::PCA::DATA_AS_ROW, 2);

    // 获取主成分
    cv::Mat eigenvectors = pca.eigenvectors;
    cv::Mat eigenvalues = pca.eigenvalues;

    // 将图像投影到主成分空间
    cv::Mat projectedData;
    pca.project(dataMatrix, projectedData);

    // 这里可以进一步使用投影后的数据进行分类器训练等操作，这里简单展示获取到的投影数据
    std::cout << "投影后的数据：" << std::endl;
    std::cout << projectedData << std::endl;

    return 0;
}

特征值与特征向量在图像纹理分析中的应用

#include <iostream>
#include <opencv2/opencv.hpp>

// 计算灰度共生矩阵
cv::Mat calculateGrayLevelCooccurrenceMatrix(const cv::Mat& image, int distance, int angle) {
    int rows = image.rows;
    int cols = image.cols;
    cv::Mat glcm = cv::Mat::zeros(256, 256, CV_32FC1);

    for (int i = 0; i < rows; ++i) {
        for (int j = 0; j < cols; ++j) {
            uchar currentPixel = image.at<uchar>(i, j);
            int newI = i + (int)(distance * cos(angle));
            int newJ = j + (int)(distance * sin(angle));

            if (newI >= 0 && newI < rows && newJ >= 0 && newJ < cols) {
                uchar neighborPixel = image.at<uchar>(newI, newJ);
                glcm.at<float>(currentPixel, neighborPixel)++;
            }
        }
    }

    return glcm;
}

int main() {
    // 读取图像
    cv::Mat image = cv::imread("your_image.jpg", cv::IMREAD_GRAYSCALE);

    if (image.empty()) {
        std::cout << "无法读取图像！" << std::endl;
        return -1;
    }

    // 计算灰度共生矩阵（这里假设距离为1，角度为0度）
    cv::Mat glcm = calculateGrayLevelCooccurrenceMatrix(image, 1, 0);

    // 计算灰度共生矩阵的特征值和特征向量
    cv::SVD svd(glcm);
    cv::Mat eigenvalues = svd.w;
    cv::Mat eigenvectors = svd.u;

    // 这里可以根据特征值和特征向量分析图像纹理特征，比如纹理的方向、粗糙度等，这里简单展示获取到的特征值和特征向量
    std::cout << "特征值：" << std::endl;
    std::cout << eigenvalues << std::endl;
    std::cout << "特征向量：" << std::endl;
    std::cout << eigenvectors << std::endl;

    return 0;
}

五、矩阵论在图像恢复与重建中的应用

最小二乘法在图像去噪中的应用

#include <iostream>
#include <opencv2/opencv.hpp>

// 假设我们有一个简单的线性模型，这里模拟一下，实际可能与图像采集设备等相关
cv::Mat createCoefficientMatrix(int rows, int cols) {
    cv::Mat A = cv::Mat::ones(rows, cols, CV_32FC1);
    return A;
}

int main() {
    // 读取图像
    cv::Mat image = cv::imread("your_image.jpg", cv::IMREAD_GRAYSCALE);

    if (image.empty()) {
        std::cout << "无法读取图像！" << std::endl;
        return -1;
    }

    // 模拟添加噪声
    cv::Mat noisyImage = image.clone();
    cv::randn(noisyImage, 0, 20); // 添加均值为0，标准差为20的高斯噪声

    // 创建系数矩阵（这里简单模拟）
    cv::Mat A = createCoefficientMatrix(image.rows, image.cols);

    // 利用最小二乘法求解去噪后的图像
    cv::Mat x;
    cv::solve(A, noisyImage, x, cv::DECOMP_NORMAL);

    // 显示原始图像、噪声图像和去噪后的图像
    cv::namedWindow("Original Image", cv::WINDOW_NORMAL);
    cv::imshow("Original Image", image);

    cv::namedWindow("Noisy Image", cv::WINDOW_NORMAL);
    cv::imshow("Noisy Image", noisyImage);

    cv::namedWindow("Denoised Image", cv::WINDOW_NORMAL);
    cv::imshow("Denoised Image", x);

    cv::waitKey(0);

    return 0;
}

奇异值分解（SVD）用于图像压缩

#include <iostream>
#include <opencv2/opencv.hpp>

// 计算压缩比
double calculateCompressionRatio(const cv::Mat& originalImage, const cv::Mat& compressedImage) {
    double originalSize = originalImage.total() * originalImage.elemSize();
    double compressedSize = compressedImage.total() * compressedImage.elemSize();

    return originalSize / compressedSize;
}

int main() {
    // 读取图像
    cv::Mat image = cv::imread("your_image.jpg", cv::IMREAD_GRAYSCALE);

    if (image.empty()) {
        std::cout << "无法读取图像！" << std::endl;
        return -1;
    }

    // 对图像进行奇异值分解
    cv::SVD svd(image);

    // 获取奇异值矩阵
    cv::Mat singularValues = svd.w;

    // 选择保留的奇异值数量（这里通过设置压缩比例来确定保留的奇异值数量）
    double compressionRatio = 0.1; // 设置压缩比例为10%，可根据需求调整
    int k = static_cast<int>(singularValues.rows * compressionRatio);

    // 创建新的奇异值矩阵，只保留前k个奇异值，其余设为0
    cv::Mat singularValuesReduced = cv::Mat::zeros(singularValues.rows, singularValues.cols, singularValues.type());
    for (int i = 0; i < k; ++i) {
        singularValuesReduced.at<double>(i, i) = singularValues.at<double>(i, i);
    }

    // 重构图像
    cv::Mat reconstructedImage = svd.u * singularValuesReduced * svd.vt;

    // 计算压缩比
    double ratio = calculateCompressionRatio(image, reconstructedImage);

    // 显示原始图像和压缩后重构的图像，并输出压缩比
    cv::namedWindow("Original Image", cv::WINDOW_NORMAL);
    cv::imshow("Original Image", image);

    cv::namedWindow("Compressed and Reconstructed Image", cv::WINDOW_NORMAL);
    cv::imshow("Compressed and Reconstructed Image", reconstructedImage);

    std::cout << "压缩比: " << ratio << std::endl;

    cv::waitKey(0);

    return 0;
}

在上述代码中：

calculateCompressionRatio 函数用于计算图像压缩前后的压缩比，通过比较原始图像和压缩后重构图像的数据量来得出。
在 main 函数中，首先读取灰度图像，然后进行奇异值分解。通过设置期望的压缩比例来确定要保留的奇异值数量 k，接着重构图像并计算压缩比，最后显示原始图像和压缩后重构的图像以及输出压缩比信息。

小波变换与矩阵表示用于图像压缩

#include <iostream>
#include <opencv2/opencv.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include <opencv2/core/core.hpp>

// 对小波系数进行阈值量化处理
void thresholdWaveletCoefficients(cv::Mat& waveletCoefficients, double threshold) {
    for (int i = 0; i < waveletCoefficients.rows; ++i) {
        for (int j = 0; j < waveletCoefficients.cols; ++j) {
            if (std::abs(waveletCoefficients.at<double>(i, j)) < threshold) {
                waveletCoefficients.at<double>(i, j) = 0;
            }
        }
    }
}

// 计算压缩比
double calculateCompressionRatio(const cv::Mat& originalImage, const cv::Mat& compressedImage) {
    double originalSize = originalImage.total() * originalImage.elemSize();
    double compressedSize = compressedImage.total() * compressedImage.elemSize();

    return originalSize / compressedSize;
}

int main() {
    // 读取图像
    cv::Mat image = cv::imread("your_image.jpg", cv::IMREAD_GRAYSCALE);

    if (image.empty()) {
        std::cout << "无法读取图像！" << std::endl;
        return -1;
    }

    // 进行小波变换
    cv::Mat waveletTransformed;
    cv::dwt(image, waveletTransformed);

    // 获取小波系数矩阵（这里简单示例，实际可能需要更深入处理不同子带系数）
    cv::Mat LL, LH, HL, HH;
    cv::split(waveletTransformed, {LL, LH, HL, HH});

    // 设置阈值进行小波系数的阈值量化（可根据需求调整阈值）
    double threshold = 10.0;
    thresholdWaveletCoefficients(LL, threshold);
    thresholdWaveletCoefficients(LH, threshold);
    thresholdWaveletCoefficients(HL, threshold);
    thresholdWaveletCoefficients(HH, threshold);

    // 重构图像
    cv::Mat reconstructedImage;
    cv::idwt(LL, LH, HL, HH, reconstructedImage);

    // 计算压缩比
    double ratio = calculateCompressionRatio(image, reconstructedImage);

    // 显示原始图像和压缩后重构的图像，并输出压缩比
    cv::namedWindow("Original Image", cv::WINDOW_NORMAL);
    cv::imshow("Original Image", image);

    cv::namedWindow("Compressed and Reconstructed Image", cv::WINDOW_NORMAL);
    cv::imshow("Compressed and Reconstructed Image", reconstructedImage);

    std::cout << "压缩比: " << ratio << std::endl;

    cv::waitKey(0);

    return 0;
}

以上代码均可直接使用，如有BUG，需要微调，搞不定的可私信我。