DTFT，DFT，DCT的关系

最新推荐文章于 2024-04-09 20:37:11 发布
最新推荐文章于 2024-04-09 20:37:11 发布
阅读量4.5k 收藏 6
点赞数
分类专栏： 算法--数学

DTFT，DFT，DCT的关系

DTFT是离散时间傅里叶变换，用来表达连续的信号的频谱。
然后理解DFT：
DFT是离散傅里叶变换，针对的是离散的信号和频谱。DFT是DTFT变化而来，其实就是将连续时间t变成了nT. 为什么要这样做呢，因为计算机是在数字环境下工作的，它不可能看见或者处理现实中连续的信号，只能够进行离散计算，在真实性上尽可能地逼近连续信号。所以DFT是为了我们能够去用工具分析信号而创造出来的，通常我们直接用DTFT的机会很少。
然后再理解FFT：
首先，DCT是DFT的一种形式。所谓“余弦变换”，是在DTFT傅立叶级数展开式中，如果被展开的函数是实偶函数，那么其傅立叶级数中只包含余弦项，再将其离散化(DFT)可导出余弦变换，因此称之为离散余弦变换(DCT)。其实DCT属于DFT的一个子集。DCT用于语音和图像处理比较多。
　　当u，v = 0 时，离散余弦正变换（DCT）后的系数若为F(0，0)=1，则离散余弦反变换（IDCT）后的重现函数 f(x，y)=1/8，是个常 数值，所以将 F(0，0) 称为直流(DC)系数；当 u，v≠0 时，正变换后的系数为 F(u，v)=0，则反变换后的重现函数 f(x，y) 不是常数，此时 正变换后的系数 F(u，v) 为交流（AC）系数。



矩阵表示法

更为简洁的定义方法是采用矩阵式定义。根据以上公式定义可知，离散余弦变换的系数矩阵可以写成如下：

\


如果令N＝4，那么由一维解析式定义可得如下展开式。

\

写成矩阵式

\



二维变换的函数如下：

离散余弦变换(DCT)公式：

 

 

离散余弦逆变换(IDCT)公式：

 

二维离散余弦变换的正变换公式为：

在图像的压缩编码中，N一般取8．

二维DCT的反变换公式为：

以上各式中的系数：

也就是：


 

代码实现：

#include <iostream>

#include <math.h>

using namespace std;

#define NUM 8

#define PI 3.1415926

short round(double a)

{

        if (a >= 0)

        {

                  return (short)(a + 0.5);

        }

        else

        {

                  return (short)(a - 0.5);

        }

}

// DCT - Discrete Cosine Transform

void DCT(short data[NUM][NUM])

{

        short output[NUM][NUM];

        double ALPHA, BETA;

        short u = 0;

        short v = 0;

        short i = 0;

        short j = 0;

        for(u = 0; u < NUM; u++)

        {

                  for(v = 0; v < NUM; v++)

                  {

                           if(u == 0)

                           {

                                    ALPHA = sqrt(1.0 / NUM);

                           }

                           else

                           {

                                    ALPHA = sqrt(2.0 / NUM);

                           }

 

                           if(v == 0)

                           {

                                    BETA = sqrt(1.0 / NUM);

                           }

                           else

                           {

                                    BETA = sqrt(2.0 / NUM);

                           }

 

                           double tmp = 0.0;

                           for(i = 0; i < NUM; i++)

                           {

                                    for(j = 0; j < NUM; j++)

                                    {

                                              tmp += data[i][j] * cos((2*i+1)*u*PI/(2.0 * NUM)) * cos((2*j+1)*v*PI/(2.0 * NUM));

                                    }

                           }

                           output[u][v] = round(ALPHA * BETA * tmp);

                  }

        }

        memset(data, 0, NUM * NUM * sizeof(short));

        memcpy(data, output, NUM * NUM * sizeof(short));

}

// Inverse DCT

void IDCT(short data[NUM][NUM])

{

        short output[NUM][NUM];

        double ALPHA, BETA;

        short u = 0;

        short v = 0;

        short i = 0;

        short j = 0;

        for(i = 0; i < NUM; i++)

        {

                  for(short j = 0; j < NUM; j++)

                  {

                           double tmp = 0.0;

 

                           for(short u = 0; u < NUM; u++)

                           {

                                    for(v = 0; v < NUM; v++)

                                    {

                                              if(u == 0)

                                              {

                                                       ALPHA = sqrt(1.0 / NUM);

                                              }

                                              else

                                              {

                                                       ALPHA = sqrt(2.0 / NUM);

                                              }

                                              if(v == 0)

                                              {

                                                       BETA = sqrt(1.0 / NUM);

                                              }

                                              else

                                              {

                                                       BETA = sqrt(2.0 / NUM);

                                              }

                                              tmp += ALPHA * BETA * data[u][v] * cos((2*i+1)*u*PI/(2.0 * NUM)) * cos((2*j+1)*v*PI/(2.0 * NUM));

                                    }

                           }

                           output[i][j] = round(tmp);

                  }

        }

        memset(data, 0, NUM * NUM * sizeof(short));

        memcpy(data, output, NUM * NUM * sizeof(short));

}

int main(void)

{

        short i = 0;

        short j = 0;

        short u = 0;

        short v = 0;

        // 8 x 8 的图像数据

        short input[NUM][NUM] =

        {

                  {89, 101, 114, 125, 126, 115, 105, 96},

                  {97, 115, 131, 147, 149, 135, 123, 113},

                  {114, 134, 159, 178, 175, 164, 149, 137},

                  {121, 143, 177, 196, 201, 189, 165, 150},

                  {119, 141, 175, 201, 207, 186, 162, 144},

                  {107, 130, 165, 189, 192, 171, 144, 125},

                  {97, 119, 149, 171, 172, 145, 117, 96},

                  {88, 107, 136, 156, 155, 129, 97, 75}

        };

 

        DCT(input);

        cout << "The result of DCT:" << endl;

        for(u = 0; u < NUM; u++)

        {

                  for(v = 0; v < NUM; v++)

                  {

                           cout << input[u][v] << '\t';

                  }

                  cout << endl;

        }

         IDCT(input);

        cout << "The result of IDCT:" << endl;

        for(i = 0; i < NUM; i++)

        {

                  for(short j = 0; j < NUM; j++)

                  {

                           cout << input[i][j] << '\t';

                  }

                  cout << endl;

        }

         return 0;

}

 运算结果如下：

The result of DCT:
1125    -32    -185     -7      2     -1     -2      2 
   -22    -16        45     -3     -2     0      -2     -2 
 -165     32        17     2        1    -1     -3       0 
      -7      -4          0     2        2    -1     -1       2 
     -2        0          0     3        0     0       2       1 
      3        1          1     -1      -2     0       2       0 
      0        0          2     -1      -1     2       1      -1 
      0        3          1     -1       2     1      -2       0 

The result of IDCT:
   89   101   114   125   126   115   105     96 
   97   115   131   147   149   135   123   113 
114   134   159   178   175   164   149   137 
121   143   177   196   201   189   165   150 
119   141   175   201   207   186   162   144 
107   130   165   189   192   171   144   125 
  96   119   150   171   172   145   116      96 
  88   107   136   156   155   129      97     75


 另一个例子：

#include "highgui.h"
#include <math.h>
#include <cv.h>
#include "cxcore.h"
#define cvCvtPlaneToPix cvMerge
double PSNR_B = 0;
double PSNR_G = 0;
double PSNR_R = 0;
double PSNR;

int main(int argc, char* argv[])
{
    const char* imagename = "F:/c/59.jpg";
    IplImage *src;
    CvScalar SrcPixel;
    CvScalar DstPixel;
    double sumB = 0;
    double sumG = 0;
    double sumR = 0;
    double mseB;
    double mseG;
    double mseR;

    src = cvLoadImage(imagename, 1);
    if (!src)
    {
        printf("can't open the image...\n");
        return -1;
    }
    // YUV颜色空间   
    IplImage* YUVImage = cvCreateImage(cvSize(src->width, src->height), src->depth, 3);
    IplImage* dst = cvCreateImage(cvSize(src->width, src->height), src->depth, 3);
    // YUV颜色空间各通道   
    IplImage* Y = cvCreateImage(cvSize(src->width, src->height), IPL_DEPTH_8U, 1);
    IplImage* U = cvCreateImage(cvSize(src->width, src->height), IPL_DEPTH_8U, 1);
    IplImage* V = cvCreateImage(cvSize(src->width, src->height), IPL_DEPTH_8U, 1);

    //cvNamedWindow( "Origin Image", CV_WINDOW_AUTOSIZE );   
    cvCvtColor(src, YUVImage, CV_BGR2YUV); //BGR→YUV   
    cvSplit(YUVImage, Y, U, V, NULL);//分割通道   

    CvMat* MatY = cvCreateMat(Y->height, Y->width, CV_64FC1);
    CvMat* MatU = cvCreateMat(V->height, U->width, CV_64FC1);
    CvMat* MatV = cvCreateMat(V->height, V->width, CV_64FC1);

    CvMat* DCTY = cvCreateMat(Y->height, Y->width, CV_64FC1);
    CvMat* DCTU = cvCreateMat(U->height, U->width, CV_64FC1);
    CvMat* DCTV = cvCreateMat(V->height, V->width, CV_64FC1);

    cvScale(Y, MatY);
    cvScale(U, MatU);
    cvScale(V, MatV);

    cvDCT(MatY, DCTY, CV_DXT_FORWARD); //余弦变换   
    cvDCT(MatU, DCTU, CV_DXT_FORWARD); //余弦变换   
    cvDCT(MatV, DCTV, CV_DXT_FORWARD); //余弦变换   

                                       //Y 通道压缩   
    for (int i = 0; i < Y->height; i++)
    {
        for (int j = 0; j < Y->width; j++)
        {
            double  element = CV_MAT_ELEM(*DCTY, double, i, j);
            if (abs(element) < 10)
                CV_MAT_ELEM(*DCTY, double, i, j) = 0;
        }
    }

    // U 通道压缩   
    for (int i = 0; i < U->height; i++)
    {
        for (int j = 0; j < U->width; j++)
        {
            double  element = CV_MAT_ELEM(*DCTU, double, i, j);
            if (abs(element) < 20)
                CV_MAT_ELEM(*DCTU, double, i, j) = 0;
        }
    }

    // V 通道压缩   
    for (int i = 0; i < V->height; i++)
    {
        for (int j = 0; j < V->width; j++)
        {
            double  element = CV_MAT_ELEM(*DCTV, double, i, j);
            if (abs(element) < 20)
                CV_MAT_ELEM(*DCTV, double, i, j) = 0;
        }
    }
    cvDCT(DCTY, MatY, CV_DXT_INVERSE); //余弦反变换   
    cvDCT(DCTU, MatU, CV_DXT_INVERSE);
    cvDCT(DCTV, MatV, CV_DXT_INVERSE);

    cvScale(MatY, Y);
    cvScale(MatU, U);
    cvScale(MatV, V);

    cvMerge(Y, U, V, NULL, YUVImage);
    cvCvtColor(YUVImage, dst, CV_YUV2BGR); //YUV→BGR   

                                           //  计算前后两幅图像的PSNR值   
    for (int i = 0; i < src->height; i++)
    {
        for (int j = 0; j < src->width; j++)
        {
            SrcPixel = cvGet2D(src, i, j);
            DstPixel = cvGet2D(dst, i, j);
            sumB += (SrcPixel.val[0] - DstPixel.val[0]) * (SrcPixel.val[0] - DstPixel.val[0]);
            sumG += (SrcPixel.val[1] - DstPixel.val[1]) * (SrcPixel.val[1] - DstPixel.val[1]);
            sumR += (SrcPixel.val[2] - DstPixel.val[2]) * (SrcPixel.val[2] - DstPixel.val[2]);

        }
    }
    mseB = sumB / ((src->width) * (src->height)); //计算均方差   
    mseG = sumG / ((src->width) * (src->height));
    mseR = sumR / ((src->width) * (src->height));

    PSNR_B = 10.0 * (log10(255.0 * 255.0 / mseB));
    PSNR_G = 10.0 * (log10(255.0 * 255.0 / mseG));
    PSNR_R = 10.0 * (log10(255.0 * 255.0 / mseR));
    PSNR = (PSNR_B + PSNR_G + PSNR_R) / 3;
    printf("PSNR:%d ", PSNR_B);
    cvShowImage("YImage", Y);
    cvShowImage("UImage", U);
    cvShowImage("VImage", V);
    cvShowImage("DstImage", dst);
    cvSaveImage("F:/dstdemo.jpg", dst);

    while (1)
    {
        if (cvWaitKey(0) == 27) break;
    }

    cvDestroyWindow("YImage");
    cvDestroyWindow("UImage");
    cvDestroyWindow("VImage");
    cvDestroyWindow("DstImage");


    cvReleaseImage(&Y);
    cvReleaseImage(&U);
    cvReleaseImage(&V);
    cvReleaseImage(&src);
    cvReleaseImage(&dst);
    cvReleaseImage(&YUVImage);
    system("pause");
    return 0;

}


主要应用　　

        离散余弦变换，尤其是它的第二种类型，经常被信号处理和图像处理使用，用于对信号和图像(包括静止图像和运动图像)进行有损数据压缩。这是由于离散余弦变换具有很强的"能量集中"特性:大多数的自然信号(包括声音和图像)的能量都集中在离散余弦变换后的低频部分，而且当信号具有接近马尔科夫过程(Markov processes)的统计特性时，离散余弦变换的去相关性接近于K-L变换(Karhunen-Loève 变换--它具有最优的去相关性)的性能。

　　例如，在静止图像编码标准JPEG中，在运动图像编码标准MJPEG和MPEG的各个标准中都使用了离散余弦变换。在这些标准制中都使用了二维的第二种类型离散余弦变换，并将结果进行量化之后进行熵编码。这时对应第二种类型离散余弦变换中的n通常是8，并用该公式对每个8x8块的每行进行变换，然后每列进行变换。得到的是一个8x8的变换系数矩阵。其中(0,0)位置的元素就是直流分量，矩阵中的其他元素根据其位置表示不同频率的交流分类。

　　一个类似的变换, 改进的离散余弦变换被用在高级音频编码(AAC for Advanced Audio Coding)，Vorbis 和 MP3 音频压缩当中。

　　离散余弦变换也经常被用来使用谱方法来解偏微分方程，这时候离散余弦变换的不同的变量对应着数组两端不同的奇/偶边界条件。

 

山西茄子
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
离散余弦变换（Discrete Cosine Transform）
jubincn的专栏
10-17 1783
DCT变换和FFT变换都属于变换压缩方法(TransformCompression)，变换压缩的一个特点是将从前密度均匀的信息分布变换为密度不同的信息分布。在图像中，低频部分的信息量要大于高频部分的信息量，尽管低频部分的数据量比高频部分的数据量要小的多。例如删除掉占50%存储空间的高频部分，信息量的损失可能还不到5%。 变换编码有很多种。K–L变换的压缩效率很高，但算法实现困难；FFT变...
DFT、DTFT、DFS、FFT之间的关系
肥宅快乐博客
03-19 1万+
DFT、DTFT、DFS、FFT、FT、FS之间的关系 FT和FS是研究连续信号的，在数字信号处理中不涉及。 主要是前四种的关系： DFT（Discrete Fourier Transform）：离散傅里叶变换 DTFT（Discrete-time Fourier Transform）：离散时间傅里叶变换 DFS（Discrete Fourier Series）：离散傅里叶级数 F...
利用DFT计算DCT
11-13
Narasimha和Peterson[139]引入了一种描述如何在DFT的帮助下计算DCT的结构[140]。DCT到DFT的映射是非常具有吸引力的，因为我们可以利用FFT类型算法的多种变化。由于DCT－II最为常用，所以我们将进一步探讨DFT与DOT-II之间的关系。为了简化表达式，这里就省略了刻度操作，因为这一步骤可以包括在DFT或FFT计算的末尾。假定变换长度是偶数，用下面的置换： 　　这就很容易转换成C或MATLAB程序，借助于DFT或FFT就可以计算DCT。 　　欢迎转载，信息来源维库电子市场网（www.dzsc.com）   来源:ks99
DTFT与DFT的关系及推导
最新发布
粉色挖掘机的博客
04-09 1020
DTFT与DFT的关系及推导;DTFT：离散时间信号的傅里叶变换；DFT：离散信号的傅里叶变换;
数字信号处理（DTFT与DFT、DFS的详细讲解以及FFT算法）
guorui的博客
08-15 2万+
DTFT与DFT、DFS的详细讲解以及FFT算法DTFT与DFT、DFS的区别在哪里呢？离散傅里叶级数DFS离散傅里叶变换DFT有限长序列的线性卷积和循环卷积利用DFT做连续信号的频谱分析对截短的信号做DFT，这一过程中会遇到的一些问题混叠泄漏栅栏效应DFT的分辨率傅里叶变换的快速算法FFT（按时间抽取，以2为基数的） DTFT与DFT、DFS的区别在哪里呢？ DFT是对DTFT的一个离散化 下面这个网址对DTFT与DFT有很好的解释 https://www.zhihu.com/question/23137
何为DTFT、DFT？他们的关系是什么？
qq_38023974的博客
01-07 3742
在刚开始学习数字信号处理时，对于各种傅里叶变换特别是离散傅里叶变化的概念及作用完全不清楚，在整理了CSDN、百度百科、知乎上关于DTFT、DFT的各知识点后才算理解，下面是自己的总结加整理集合的资料。 通过下⾯的⽹络⽂献得出FS，FFT，DTFT，DFT的关系结论： 在数字信号处理中，对处理数字信号进⾏傅⾥叶变换转频域的情况更多，数字信号来⾃于对模拟信号的采样，即将模拟信号的连续采样后变为离散，这...
一幅图弄清DFT与DTFT,DFS的关系
zhenggege_11的专栏
10-03 284
　很多同学学习了数字信号处理之后，被里面的几个名词搞的晕头转向，比如DFT，DTFT，DFS，FFT，FT,FS等，FT和FS属于信号与系统课程的内容，是对连续时间信号的处理，这里就不过多讨论，只解释一下前四者的关系。 　　首先说明一下，我不是数字信号处理专家，因此这里只站在学生的角度以最浅显易懂的性质来解释问题，而不涉及到任何公式运算。 　　学过卷积，我们都知道有时域卷积定理和频域卷积定理，...
一文搞懂DTFT,DFT,FFT
明月几时有，把酒问青天
01-12 1万+
以下内容来自这里，概念解释的很清楚，搬过来做个备忘。 很多同学学习了数字信号处理之后，被里面的几个名词搞的晕头转向，比如DFT，DTFT，DFS，FFT，FT,FS等，FT和FS属于信号与系统课程的内容，是对连续时间信号的处理，这里就不过多讨论，只解释一下前四者的关系。 首先说明一下，我不是数字信号处理专家，因此这里只站在学生的角度以最浅显易懂的性质来解释问题，而不涉及到任何公式运算。 学过卷积，...
离散余弦变换（DCT）的来龙去脉
热门推荐
dugudaibo的博客
11-01 5万+
本文主要介绍离散余弦变换（DCT），从图像的二维离散变换入手，引出变换核的可分性与对称性导出DCT，并给出实现代码。
DCT余弦变换ppt
02-26
DCT余弦变换介绍，以及知识讲解。DFT、DTFT、FFT之间的关系
LSB算法和量化水印算法对比，DFT、DCT、DWT
01-28
（1）分别用LSB算法和量化水印算法将信息嵌入，在失真度一样的情况下，加入高斯噪声和椒盐噪声，比较提取出来的信息效果。 （2）分别对图像进行DFT、DCT、DWT处理，比较逆变换后的效果。
dwt dct dft变换代码
05-04
matlab写出的关于离散余弦变换离散小波变换 和离散傅立叶变换的一些简单代码
DFT的matlab源代码-MRSP_Notebooks:多速率信号处理教程
05-26
离散余弦变换（DCT） z转换 短时傅立叶变换（STFT） 03频率响应： 频率响应 示例：使用噪声获取“黑匣子”系统的频率响应 示例：使用正弦扫描获得“黑匣子”系统的频率响应 频率响应：z变换和DTFT 示例：低通滤波器...
HEVC原理-图像的二维变换与离散余弦变换（DCT）
Guardian_Bud
02-21 2409
1. 图像的二维离散变换   与一维的有限长离散非周期信号存在傅里叶变换（DFT）一样，图像作为一个二维离散信号同样存在着二维离散变换（注意这里是介绍一个通用的概念，二维离散变换，包括了DFT、DCT等多种变换在内的一种通式写法），其通式可以表达为 1.1 二维变换的可分性与对称性   如果一个二维变换核同时具备可分性与对称性，此时允许用两个一维变换来计算二维变换，即首先沿着输入的行（列）进行...
什么是离散时间傅里叶变换(DTFT)及其应用
# 1. 离散时间傅里叶变换(DTFT)的基础知识 ### 1.1 DTFT的概念和定义 离散时间傅里叶变换（Discrete-Time Fourier Transform，DTFT）是傅里叶变换在离散时间信号上的推广，用于描述...### 1.2 DTFT与傅里叶变换的关系
dtft变换的性质_dtft(dtft和dft的关系区别)
weixin_33329305的博客
02-23 5877
DTFT, DFT 的区别是含义不同知、性质不同、用途不同。1、含义不同：DTFT是离散时间傅里叶变换，DFT是离散傅里叶变换。2、性质不同：DTFT变换后的图形中的频率.FFT , DTFT, DFT 的联系：FFT是DFT的一种高效快速算法，DFT是有限长序列的离散傅里叶变换，DTFT是非周期序列的傅里叶变换，DFT将信号的时域采样变换为其.你好！DFS是周期序列的离散傅里叶级数 DTFT是非...
离散时间傅里叶变换（DTFT）、离散傅里叶变换（DFT）和快速傅里叶变换（FFT）之间的联系和区别
阿星的博客
04-12 7690
本博文介绍、比较、分析了DTFT、DFT和FFT
DTFT和DFT有何区别？一文为你讲解清楚
coachip的博客
09-19 2万+
很多人在开始学习数字信号处理的时候，对于各种傅里叶变换特别是离散傅里叶变化的概念及作用完全不清楚，IC修真院在网上整理了关于DTFT、DFT的各知识点。下面就来了解一下关于DTFT和DFT的区别吧。
DTFT, DFT, FFT 的区别、联系和特点
shouwangyunkai666的博客
10-10 3万+
联系： DTFT是非周期序列的傅里叶变换，DFT是有限长序列的离散傅里叶变换，DFT将信号的时域采样变换为其DTFT的频域采样，FFT是DFT的一种高效快速算法。 区别： 1、含义不同：DTFT是离散时间傅里叶变换，DFT是离散傅里叶变换，FFT是DFT的一种高效快速算法，也称作快速傅里叶变换。 2、性质不同：DTFT变换后的图形中的频率是一般连续的（cos(wn)等这样的特殊函数除外，其变换后是...
DTFT DFT ZT的关系
04-03
DTFT（Discrete-Time Fourier Transform，离散时间傅里叶变换）、DFT（Discrete Fourier Transform，离散傅里叶变换）和ZT（Z变换）是信号处理中常用的数学工具，它们之间存在一定的关系。 1. DTFT（离散时间傅里叶变换）： DTFT是一种将离散时间序列转换为连续频率域的变换方法。它将离散时间序列映射到连续频率域上的复数函数。DTFT的定义如下： X(e^jω) = Σ[x[n] * e^(-jωn)]，其中X(e^jω)表示DTFT变换后的频谱，x[n]表示离散时间序列。 2. DFT（离散傅里叶变换）： DFT是一种将离散时间序列转换为离散频率域的变换方法。它将离散时间序列映射到离散频率域上的复数序列。DFT的定义如下： X[k] = Σ[x[n] * e^(-j2πkn/N)]，其中X[k]表示DFT变换后的频谱，x[n]表示离散时间序列，N表示序列长度。 3. ZT（Z变换）： ZT是一种将离散时间序列转换为复平面上的变换方法。它将离散时间序列映射到复平面上的复数函数。ZT的定义如下： X(z) = Σ[x[n] * z^(-n)]，其中X(z)表示ZT变换后的频谱，x[n]表示离散时间序列，z为复数。 关系： DFT可以看作是DTFT在有限长度序列上的一种离散采样，而ZT可以看作是DTFT在离散时间序列上的一种推广。具体来说： - DFT是DTFT在有限长度序列上的采样，通过对DTFT的频谱进行离散采样得到DFT的频谱。 - ZT是DTFT在离散时间序列上的推广，通过将DTFT中的连续频率变量替换为复平面上的复数变量得到ZT。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值