从零实现哈尔小波变换：C++代码详解与图像处理实战-平芜编程栈

1. 项目概述与核心价值

最近在整理一些图像处理相关的代码库，翻到了一个几年前写的哈尔小波变换的C++实现。当时是为了一个嵌入式设备上的图像压缩项目，需要在不依赖大型数学库的情况下，实现一个轻量级、可控的小波变换核心。虽然现在有OpenCV、FFTW等成熟的库，但自己动手实现一遍，对于理解小波变换的数学本质、内存布局优化以及算法性能调优，有着不可替代的价值。这个项目实战，就是带你从零开始，用纯C++实现一维和二维的哈尔小波正变换与反变换，并探讨其在图像压缩、特征提取等场景下的应用。

哈尔小波是所有小波中最简单、最直观的一种。它的滤波器系数只有1和-1，计算过程本质上就是求平均和求差值。正变换将信号分解为“近似”（低频）和“细节”（高频）两部分；反变换则能完美地重构原始信号。这个“项目实战”的核心，不在于调用某个库函数，而在于深入计算过程的每一个细节：如何高效地组织数据？如何处理边界？如何验证变换的可逆性？理解了这些，你不仅能掌握哈尔小波，更能为理解更复杂的Daubechies小波、双正交小波打下坚实的基础。无论你是正在学习数字信号处理的学生，还是需要在资源受限环境中实现特定算法的工程师，这个实战都能提供直接的参考。

2. 哈尔小波变换的核心原理拆解

2.1 从平均与差分的直观理解开始

很多人一听到“小波变换”就觉得高深莫测，其实哈尔小波的核心理念非常朴素。我们抛开复杂的数学公式，用一个简单的例子来感受一下。

假设我们有一组相邻的像素值：[9, 7]。哈尔小波正变换会做两件事：

求平均（Approximation）：计算这两个像素的平均值，(9 + 7) / 2 = 8。这个值代表了该区域的整体亮度水平，是低频信息。
求差分（Detail）：计算这两个像素的差值的一半，(9 - 7) / 2 = 1。这个值代表了两个像素之间的变化剧烈程度，是高频信息。

于是，原始信号[9, 7]被转换成了[8, 1]。这个8就是近似系数，1就是细节系数。你会发现，信息量并没有丢失，我们完全可以从[8, 1]重构回[9, 7]：

第一个像素 = 平均值 + 差值 =8 + 1 = 9
第二个像素 = 平均值 - 差值 =8 - 1 = 7

这就是一维哈尔小波变换最核心的一对一（2点）变换。对于更长的信号，比如[9, 7, 3, 5]，我们将其视为两对[9,7]和[3,5]，分别进行上述操作，得到第一层的近似系数[8, 4]和细节系数[1, -1]。然后，我们可以对近似系数[8, 4]再次进行变换，得到第二层的近似系数[6]和细节系数[2]。最终，经过一层层分解，我们得到了一组系数：[6, 2, 1, -1]。这个序列就是原始信号的小波表示，它以一种层次化的方式组织了信号的信息。

注意：这里为了直观，我们使用了/2的归一化。在标准的正交哈尔小波变换中，为了保持能量（范数）不变，通常使用1/sqrt(2)作为归一化因子。但在很多工程实现中，尤其是注重速度和整型计算的场景，使用/2的版本（称为非标准化形式）也很常见，只要正反变换配对使用即可。本项目实战将同时实现这两种形式，并解释其区别。

2.2 一维正变换的算法流程与矩阵视角

将上述直观过程算法化，对于长度为N（假设为2的整数次幂，如 8, 16, 32...）的一维信号x，其一层哈尔小波正变换的步骤如下：

初始化：创建一个长度同样为N的数组temp用于存储中间结果。
计算近似与细节：遍历信号，每次取一对元素(x[i], x[i+1])。
- 计算近似系数：approx = (x[i] + x[i+1]) / scaling_factor
- 计算细节系数：detail = (x[i] - x[i+1]) / scaling_factor
- 将approx存入temp数组的前半部分，将detail存入temp数组的后半部分。
结果重组：完成所有配对计算后，temp数组的前N/2个元素是当前层的近似系数，后N/2个元素是细节系数。这一层的近似系数可以作为下一层变换的输入，进行更深层次的分解。

这个过程可以用一个矩阵乘法来优雅地表示。对于2点变换，变换矩阵H2是：

H2 = [1/sqrt(2), 1/sqrt(2)] [1/sqrt(2), -1/sqrt(2)]

对于更长的信号，变换矩阵是一个分块对角矩阵。理解矩阵形式有助于我们从线性代数的角度理解小波变换的正交性（即变换矩阵的逆等于其转置），这也是反变换算法设计的理论基础。

2.3 从一维到二维：图像处理的基石

图像是二维信号。二维哈尔小波变换可以通过对行和列分别进行一维变换来实现，这被称为可分离变换。具体步骤如下（以一层变换为例）：

行变换：对图像的每一行独立进行一维哈尔小波正变换。变换后，每一行都被分解为左半部分的近似系数和右半部分的细节系数。
列变换：对上一步得到的结果图像的每一列独立进行一维哈尔小波正变换。

经过行列两次变换，原始图像被分解为四个子带：

LL（低频-低频）：左上角区域，由行变换和列变换的近似部分得到。它代表了原始图像经过两次低通滤波后的结果，是原图的一个缩小版、模糊版，包含了图像最主要的能量和信息。
LH（低频-高频）：右上角区域，行近似、列细节。它捕捉了图像中水平方向的边缘或纹理（因为列方向做了差分）。
HL（高频-低频）：左下角区域，行细节、列近似。它捕捉了图像中垂直方向的边缘或纹理。
HH（高频-高频）：右下角区域，行细节、列细节。它捕捉了图像中对角线方向的细节和噪声。

这个LL, LH, HL, HH的分解结构是理解所有基于小波的图像压缩（如JPEG2000）和特征分析的关键。我们可以继续对LL子带进行同样的二维变换，实现多级（多层）分解，形成一种金字塔式的多分辨率分析。

3. C++项目实战：设计与实现

3.1 项目结构与核心类设计

一个清晰的项目结构是代码可维护性的基础。我们不依赖任何图形界面库，专注于核心算法和数据的输入输出。

HaarWaveletTransform/ ├── include/ │ └── HaarWavelet.h // 核心算法类声明 ├── src/ │ ├── HaarWavelet.cpp // 核心算法类实现 │ └── main.cpp // 测试与演示程序 ├── data/ │ ├── input.txt // 一维测试数据 │ └── lenna_128x128.raw // 二维测试图像（原始灰度图） └── CMakeLists.txt // 跨平台构建配置

HaarWavelet类的设计应该简洁而功能完整：

// HaarWavelet.h #pragma once #include <vector> class HaarWavelet { public: // 构造函数，可选择归一化因子 explicit HaarWavelet(bool normalized = true); // 一维正变换 (in-place 或 out-place) void transform1D(std::vector<double>& signal) const; void transform1D(const std::vector<double>& input, std::vector<double>& output) const; // 一维反变换 void inverseTransform1D(std::vector<double>& coefficients) const; void inverseTransform1D(const std::vector<double>& input, std::vector<double>& output) const; // 二维正变换 (假设图像数据按行优先存储在一维vector中) void transform2D(std::vector<double>& image, int width, int height) const; // 二维反变换 void inverseTransform2D(std::vector<double>& coefficients, int width, int height) const; // 多级分解与重构 void multilevelTransform1D(std::vector<double>& signal, int levels) const; void multilevelInverseTransform1D(std::vector<double>& coeffs, int levels) const; private: double scalingFactor_; // 缩放因子： normalized ? 1/sqrt(2) : 0.5 double inverseScalingFactor_; // 反变换缩放因子 // 内部核心计算函数 void forwardStep(std::vector<double>& data, int length) const; void inverseStep(std::vector<double>& data, int length) const; };

使用std::vector<double>作为主要容器，兼顾了灵活性和与标准库的兼容性。提供in-place（原地修改）和out-place（输出到另一容器）两种接口，以适应不同场景。normalized参数让使用者可以在标准正交变换和计算更快的非标准化变换之间选择。

3.2 一维变换的C++核心实现

让我们深入transform1D的in-place实现，这是理解整个算法的关键。

// HaarWavelet.cpp void HaarWavelet::transform1D(std::vector<double>& signal) const { int n = signal.size(); // 检查信号长度是否为2的幂次，这是快速算法的基础 if (n <= 1 || (n & (n - 1)) != 0) { throw std::invalid_argument("Signal length must be a power of two and greater than 1."); } std::vector<double> temp(n); // 临时数组，避免原地计算的覆盖问题 int length = n; while (length > 1) { int half = length / 2; for (int i = 0; i < half; ++i) { double a = signal[2 * i]; double b = signal[2 * i + 1]; // 核心计算：平均与差分 temp[i] = (a + b) * scalingFactor_; // 近似系数放前半部分 temp[half + i] = (a - b) * scalingFactor_; // 细节系数放后半部分 } // 将本层结果拷贝回原数组的前length个位置，供下一层使用 std::copy(temp.begin(), temp.begin() + length, signal.begin()); length = half; // 下一层只处理近似部分 } }

实现要点解析：

长度校验：快速哈尔小波变换要求信号长度为2的整数次幂。(n & (n - 1)) == 0是一个经典的位运算技巧，用于判断一个数是否是2的幂。
使用临时数组：这是实现中的关键技巧。如果直接在signal数组上计算并覆盖，当计算temp[i]时，signal[2*i+1]可能已经被前一次迭代覆盖（如果采用特定的遍历顺序）。使用临时数组完全避免了这种数据依赖问题，逻辑更清晰。
分层循环：while (length > 1)实现了多级分解。每一轮循环后，length减半，意味着下一轮只处理当前得到的近似系数部分。
系数排列：变换完成后，signal数组中的元素顺序是：[最终近似系数, 第L层细节系数, 第L-1层细节系数, ..., 第1层细节系数]。这种排列方式称为“打包格式”，它将所有系数紧凑地存储在一个数组中，便于管理。

反变换inverseTransform1D是正变换的逆过程，需要按照相反的层次顺序，从最粗的近似系数开始，结合细节系数逐层重构：

void HaarWavelet::inverseTransform1D(std::vector<double>& coeffs) const { int n = coeffs.size(); if (n <= 1 || (n & (n - 1)) != 0) { throw std::invalid_argument("Coefficients length must be a power of two."); } std::vector<double> temp(n); int length = 2; // 从最细的细节开始重构 while (length <= n) { int half = length / 2; for (int i = 0; i < half; ++i) { double approx = coeffs[i]; // 当前层的近似系数 double detail = coeffs[half + i]; // 当前层的细节系数 // 核心重构计算 temp[2 * i] = (approx + detail) * inverseScalingFactor_; temp[2 * i + 1] = (approx - detail) * inverseScalingFactor_; } // 将重构出的本层信号拷贝回原数组 std::copy(temp.begin(), temp.begin() + length, coeffs.begin()); length *= 2; // 向更粗的层次推进 } }

实操心得：验证可逆性。编写完正反变换后，第一件要做的事就是设计一个简单的验证程序。生成一个随机信号original，进行transform1D得到coeff，再对coeff进行inverseTransform1D得到reconstructed。计算original和reconstructed之间的最大绝对误差或均方根误差。在双精度浮点数下，由于计算舍入，误差通常在1e-10到1e-14量级。如果误差很大，说明你的算法实现有逻辑错误。

3.3 二维变换的实现与图像数据处理

二维变换建立在一维变换的基础上。关键点在于理解如何将二维图像数据（矩阵）映射到一维数组（行优先），并在行和列两个方向正确应用变换。

void HaarWavelet::transform2D(std::vector<double>& image, int width, int height) const { // 假设 image 按行优先存储：image[row * width + col] if (width <= 1 || height <= 1 || (width & (width - 1)) != 0 || (height & (height - 1)) != 0) { throw std::invalid_argument("Image width and height must be powers of two and greater than 1."); } std::vector<double> row(width); // 用于存储一行数据 std::vector<double> col(height); // 用于存储一列数据 // 第一步：对每一行进行一维变换 for (int i = 0; i < height; ++i) { // 提取第i行 auto rowStart = image.begin() + i * width; std::copy(rowStart, rowStart + width, row.begin()); // 对该行进行变换 transform1D(row); // 写回图像 std::copy(row.begin(), row.end(), rowStart); } // 第二步：对每一列进行一维变换 for (int j = 0; j < width; ++j) { // 提取第j列 for (int i = 0; i < height; ++i) { col[i] = image[i * width + j]; } // 对该列进行变换 transform1D(col); // 写回图像 for (int i = 0; i < height; ++i) { image[i * width + j] = col[i]; } } // 此时，image中的数据已经是变换后的系数，排列为 [LL|LH; HL|HH] }

内存访问模式优化：上述实现清晰易懂，但在性能上有一个明显瓶颈：列变换。因为图像数据是按行连续存储的，访问同一列的元素 (image[i * width + j]) 会导致严重的缓存不命中（Cache Miss），每次访问都可能需要从主存读取，速度很慢。对于性能要求高的场景，一个常见的优化策略是：

先对图像进行转置。
然后对转置后的图像（相当于原始图像的列变成了行）进行两次行变换。
最后再转置回来。这样，所有的数据访问都是连续的，能极大利用CPU缓存。当然，这增加了两次转置操作的开销，对于小图像可能不划算，但对于大图像（如1024x1024以上）通常是性能净增益。

二维反变换的实现是正变换的逆序：先对列进行反变换，再对行进行反变换。

void HaarWavelet::inverseTransform2D(std::vector<double>& coeffs, int width, int height) const { std::vector<double> col(height); std::vector<double> row(width); // 逆序：先列反变换，再行反变换 for (int j = 0; j < width; ++j) { for (int i = 0; i < height; ++i) { col[i] = coeffs[i * width + j]; } inverseTransform1D(col); for (int i = 0; i < height; ++i) { coeffs[i * width + j] = col[i]; } } for (int i = 0; i < height; ++i) { auto rowStart = coeffs.begin() + i * width; std::copy(rowStart, rowStart + width, row.begin()); inverseTransform1D(row); std::copy(row.begin(), row.end(), rowStart); } }

3.4 多级分解与系数可视化

单层变换只产生一个低频子带（LL）和三个高频子带（LH, HL, HH）。多级（多层）变换可以对LL子带递归应用变换，生成一种多分辨率表示。

void HaarWavelet::multilevelTransform2D(std::vector<double>& image, int width, int height, int levels) const { int currentWidth = width; int currentHeight = height; for (int lvl = 0; lvl < levels; ++lvl) { // 检查当前子图尺寸是否还能继续分解 if (currentWidth < 2 || currentHeight < 2) break; // 对当前“有效区域”（左上角的 currentWidth x currentHeight 部分）进行一层变换 // 我们需要从image中提取这个子区域，变换后再放回。 // 一个简洁的实现方式是传递子区域的起始偏移和步长给一个辅助函数。 // 这里为了概念清晰，我们创建一个子图像的拷贝（实际项目应避免频繁拷贝）。 std::vector<double> subImage(currentWidth * currentHeight); for (int i = 0; i < currentHeight; ++i) { for (int j = 0; j < currentWidth; ++j) { subImage[i * currentWidth + j] = image[i * width + j]; } } transform2D(subImage, currentWidth, currentHeight); // 写回原图对应位置 for (int i = 0; i < currentHeight; ++i) { for (int j = 0; j < currentWidth; ++j) { image[i * width + j] = subImage[i * currentWidth + j]; } } // 下一层只处理左上角的LL子带，所以尺寸减半 currentWidth /= 2; currentHeight /= 2; } }

变换后的系数矩阵（尤其是图像）直接看数值是难以理解的。一个非常有用的调试和演示技巧是系数可视化。由于LL子带的值（平均值）通常远大于高频子带的细节值，直接显示会是一片白。我们需要进行归一化或缩放：

线性缩放：将整个系数矩阵的值线性映射到[0, 255]的灰度区间。pixel = 255 * (coeff - min) / (max - min)。这种方法能看清整体结构，但低频部分可能显得对比度不足。
分块缩放：对LL、LH、HL、HH四个子带分别进行线性缩放，然后拼接到一起显示。这样可以清晰地看到每个频带的信息。
对数缩放：对系数取绝对值后再取对数，pixel = scale * log(1 + abs(coeff))。这种方法能同时增强低频和高频的可见度，是显示小波系数谱的常用方法。

你可以将变换后的系数矩阵保存为PGM（便携式灰度图）格式文件，然后用任何图片查看器打开，直观地检查变换结果是否正确。

4. 性能优化与工程化考量

4.1 计算性能优化技巧

虽然哈尔小波计算简单，但在处理大规模数据（如高清视频）时，性能依然关键。

使用单精度浮点（float）：对于很多图像和信号处理应用，单精度的精度已经足够，而且计算速度更快，内存占用减半。可以将模板类与float和double兼容。

循环展开：在内层循环中手动展开几次计算，可以减少循环开销。现代编译器在优化级别高时（如-O3）会自动进行循环展开，但了解这一概念有益。

// 手动循环展开示例（假设length是偶数） for (int i = 0; i < half; i += 4) { temp[i] = (signal[2*i] + signal[2*i+1]) * scalingFactor_; temp[i+1] = (signal[2*(i+1)] + signal[2*(i+1)+1]) * scalingFactor_; temp[i+2] = (signal[2*(i+2)] + signal[2*(i+2)+1]) * scalingFactor_; temp[i+3] = (signal[2*(i+3)] + signal[2*(i+3)+1]) * scalingFactor_; // ... 细节系数计算类似 }

使用SIMD指令集：这是最大的性能提升点。利用SSE、AVX等SIMD（单指令多数据）指令，可以同时对多个数据对进行“加”、“减”、“乘”操作。例如，使用AVX一次可以处理4个双精度浮点数对（8个数据）。这需要内联汇编或使用编译器 intrinsics（如_mm256_add_pd,_mm256_sub_pd,_mm256_mul_pd）。
并行计算：对于二维变换，各行、各列之间的变换是独立的，可以很容易地用OpenMP或C++标准库的<thread>进行并行化。
```
#pragma omp parallel for for (int i = 0; i < height; ++i) { // 对第i行进行变换 }
```
定点数优化：在嵌入式等对浮点计算不友好的平台，可以使用定点数（整数）来模拟小数运算。例如，将缩放因子1/sqrt(2) ≈ 0.7071放大2^16倍后取整，计算时使用整数乘加，最后再右移16位。这能显著提升速度，但会引入量化误差。

4.2 边界处理与数据格式兼容性

我们的实现假设信号长度是2的幂。但现实中的数据往往不满足这个条件。常见的边界处理策略有：

补零（Zero-padding）：将数据长度扩展到下一个2的幂，用0填充。最简单，但会在边界引入不连续，导致高频系数出现人为的“振铃”效应。
对称延拓（Symmetric Extension）：将边界处的数据镜像反射出去。这种方法能更好地保持信号的连续性，是图像处理中更常用的方法。例如，对于序列[a, b, c, d]，对称延拓后可以是...[c, b, a, b, c, d, c, b...]。实现比补零复杂，但效果更好。
周期延拓：假设信号是周期性的。适用于本身就是周期性的信号。

在工程中，一个健壮的库应该提供这些边界处理模式的选项。此外，还需要考虑数据格式的兼容性。我们的类使用std::vector<double>，但实际数据可能是unsigned char（0-255的像素值）、short、float等。可以通过模板类来支持多种数据类型：

template<typename T> class HaarWaveletT { public: void transform1D(std::vector<T>& signal); // ... 其他方法 }; // 或者针对特定类型进行特化，以进行定点优化。

4.3 集成测试与示例应用

一个完整的项目需要可靠的测试。我们可以构建以下几个测试用例：

可逆性测试：对随机生成的一维、二维数据，验证正变换->反变换后与原数据的误差在可接受范围内。
能量守恒测试：对于正交归一化的变换，变换前后信号的总能量（系数的平方和）应该相等。计算并比较sum(x[i]^2)和sum(coeff[i]^2)。
图像压缩模拟：这是最直观的应用演示。
- 加载一张灰度图像（如经典的Lena图）。
- 进行多级二维哈尔小波变换。
- 阈值处理：将绝对值小于某个阈值的系数置零。这是最简单的压缩手段，因为图像能量主要集中在少数低频系数中，很多高频系数接近于零。
- 对阈值处理后的系数进行反变换，重构图像。
- 计算重构图像与原始图像的PSNR（峰值信噪比），评估压缩带来的失真。
- 通过调整阈值，可以直观地看到压缩率与图像质量之间的权衡。
边缘检测演示：小波变换的HL和LH子带分别对应垂直和水平边缘。我们可以将变换后的图像中LL和HH子带置零，只保留LH和HL，然后进行反变换，得到的结果将突出显示原始图像中的边缘信息。

5. 常见问题与调试技巧实录

在实际编码和调试过程中，你几乎一定会遇到下面这些问题。这里记录了我的排查思路和解决方法。

5.1 变换结果不正确或反变换无法还原

这是最常见的问题。请按以下清单逐步排查：

检查长度是否为2的幂：这是最基本的前提。添加断言或异常检查。
验证缩放因子：确保正变换和反变换使用的缩放因子是互逆的。如果正变换用1/sqrt(2)，反变换必须用1/sqrt(2)（因为正交矩阵的逆是转置，系数相同）。如果正变换用0.5，反变换必须用1.0。一个常见的错误是正变换用了/2，反变换也用了/2，导致结果被错误地缩放。
检查系数排列顺序：在多层变换中，系数在数组中的排列顺序必须一致。你的正变换将细节系数放在后半部分，反变换就必须从后半部分读取细节系数。画一个长度为8的信号的三层分解图，标出每一步后数组中每个位置对应的系数类型（A3, D3, D2, D1），对照代码仔细检查索引计算。
使用最小测试用例：不要一开始就用大图像测试。用一个长度为4的简单数组[1,2,3,4]进行手工计算，然后与你的程序输出对比。二维测试可以用一个2x2的矩阵[[1,2],[3,4]]。
打印中间结果：在正反变换的每一层循环结束后，打印出数组的内容，与手工计算的结果比对，能快速定位错误发生的层级。

5.2 二维变换后图像显示为乱码或全灰

数据范围溢出：原始图像像素是[0,255]的整数。小波变换后，系数范围会远超这个区间（特别是低频系数可能是很大的平均值）。如果你直接将系数当作像素值保存为图像，大部分查看器会将其截断到0-255，导致显示异常。必须先进行可视化缩放（如线性或对数缩放）到0-255区间。
文件格式错误：如果你保存为RAW格式，需要确保查看器知道图像的宽度、高度和位深。保存为PGM（P5二进制或P2文本）格式更可靠，因为文件头包含了这些信息。
行列顺序错误：确保你在行变换和列变换时，正确地计算了一维索引index = row * width + col。一个典型的错误是在列变换时错误地使用了index = col * height + row。

5.3 性能达不到预期

编译器优化：确保在发布版本（Release）下编译，并开启最高优化等级（如GCC/Clang的-O3，MSVC的/O2）。
内存访问模式：如前所述，二维变换的列访问是性能杀手。使用性能分析工具（如perf,VTune）查看缓存命中率。如果缓存未命中率高，考虑实现前面提到的“转置法”优化。
函数调用开销：在最内层循环中，避免调用虚函数或通过复杂接口访问数据。确保数据是连续存储的（std::vector保证了这一点）。
多线程负载均衡：如果使用并行化，确保任务划分均匀。对于行变换，直接对行循环进行并行化是均衡的。对于列变换，如果使用“转置法”，则在转置后对行循环并行化即可。

5.4 应用于图像压缩时的“方块效应”

这是哈尔小波的一个固有缺点，因为它的基函数是方形的、不连续的。在低比特率压缩（即阈值设得很大，很多系数被置零）时，重构图像会在块边界出现明显的方格状瑕疵，称为“方块效应”或“棋盘效应”。

缓解策略：

使用更平滑的小波：如Daubechies (db4, db6) 或双正交小波 (bior)。它们有更长的支撑长度和更好的连续性，能有效减少方块效应，但计算更复杂。
后处理滤波：在重构图像后，使用一个轻微的平滑滤波器（如高斯模糊）过滤掉部分块效应，但这会损失一些真实细节。
优化阈值策略：不要使用全局硬阈值。可以尝试软阈值（将小于阈值的系数收缩为零，大于阈值的系数减去阈值），或者根据子带特性使用不同的阈值（通常高频子带可以用更大的阈值）。

实现这个完整的哈尔小波变换项目，就像亲手搭建了一个理解多分辨率分析的脚手架。它可能不会直接用于生产环境（因为有更优秀的库），但这个过程让你透彻理解了从数学公式到内存操作、从算法到优化的完整链条。当你下次使用pywt或 OpenCV 的dwt2函数时，你看到的将不再是一个黑盒，而是一个你能在脑海中清晰勾勒出每一步数据流动的透明过程。这种深度的理解，是单纯调用API无法获得的。