数字图像处理(8):实现FFT快速算法(C语言)

已于 2024-01-26 09:37:24 修改
阅读量5.8k 收藏 78
点赞数 8
分类专栏： 数字图像处理 文章标签： 算法 c语言 开发语言
于 2020-06-26 22:32:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ZhaoDongyu_AK47/article/details/106975214
版权

文章目录

1. 实验内容

1.1 使用平台及语言

使用平台：VS2015

语言：C语言

1.2 代码流程

在这里插入图片描述

其中，对频谱图像进行了一三、二四象限的对调，这样便于观察分析。

1.3 FFT、IFFT

对图像进行操作要进行两次，先对行进行FFT，再对列进行FFT，顺序反过来也可以。

FFT最主要的是蝶形运算

    /*蝶形运算*/
    for (k = 0; k<power; k++)
    {
        for (j = 0; j<1 << k; j++)
        {
            bfsize = 1 << (power - k);
            for (i = 0; i<bfsize / 2; i++)
            {
                p = j*bfsize;
                X2[i + p] = Add(X1[i + p], X1[i + p + bfsize / 2]);
                X2[i + p + bfsize / 2] = Mul(Sub(X1[i + p],X1[i + p + bfsize / 2]), W[i*(1 << k)]);
            }
        }
        X = X1;
        X1 = X2;
        X2 = X ;
    }

IFFT计算过程：

数据取共轭,然后fft,结果再取共轭后除以N

void IFFT(COMPLEX *FD, COMPLEX *TD, int power)
{
    int i, count;
    COMPLEX *x;
    /*计算傅里叶反变换点数*/
    count = 1 << power;
    /*分配运算所需存储器*/
    x = (COMPLEX *)malloc(sizeof(COMPLEX)*count);
    /*将频域点写入存储器*/
    memcpy(x, FD, sizeof(COMPLEX)*count);
    /*求频域点的共轭*/
    for (i = 0; i<count; i++)
    {
        x[i].im = -x[i].im;
    }
    /*调用快速傅里叶变换*/
    FFT(x, TD, power);
    /*求时域点的共轭*/
    for (i = 0; i<count; i++)
    {
        TD[i].re /= count;
        TD[i].im = -TD[i].im / count;
    }
    /*释放存储器*/
    free(x);
}

2. 实验结果

2.1 输入图片及其频谱

在这里插入图片描述
在这里插入图片描述

2.2 进行低频滤波

将频谱图中心20*20区域置零，进行IFFT变换，得到结果
在这里插入图片描述
分析：得到的结果比较恐怖，和预期不符。怀疑是把直流分量置零的原因。

2.3 去除直流分量

对频谱中心2*2置0（即去除直流成分）结果
在这里插入图片描述

2.4 低频滤波

进行低频滤波，将频谱图中心20*20区域置零（除了中间的直流成分），进行IFFT变换，得到结果
在这里插入图片描述
分析：这是高通滤波，低频成分被去除。图片的效果很明显，变化不大的地方被抑制，留下的都是变化快的地方、边缘部分（高频部分）。

2.5 高频滤波

进行高频滤波，除了频谱中心300*300区域其他置零，进行IFFT变换，得到结果
在这里插入图片描述

分析：这是低通滤波，高频成分被去除。图片里变化快的地方（树的纹理、博雅塔受到影响）。

2.6 进一步的高频率波

上个效果不是很明显，重新进行高频滤波，除了频谱中心200*200区域其他置零，进行IFFT变换，得到结果
在这里插入图片描述

分析：对比博雅塔部分——此次的结果和上次没有太大差别，只是云那儿受到影响多了一点。怀疑是加的这点效果对博雅塔没什么效果（因为这儿本来就高频比较高吧）
在这里插入图片描述

2.7 更进一步的高频滤波

上个效果加强其实也不是很明显，重新进行高频滤波，除了频谱中心100*100区域其他置零，进行IFFT变换，得到结果
在这里插入图片描述

分析：没想到这么丑，感觉这次的结果可以和高频滤波结果对比观看——
在这里插入图片描述

很明显二者重点的区域完全相反。

3. 遇到的问题及收获

3.1 问题一

最开始有一次遇到了这个问题（堆栈溢出问题），遇过这个坑，所以解决得比较顺利——
在这里插入图片描述

这个问题的定位在于最开始定义了数组

    COMPLEX td[height*width];
    COMPLEX fd[height*width];

其中

typedef struct
{
        double re;
        double im;
}COMPLEX;

图像大小是512*512的，这么一算，这两句需要的堆栈就是
2 * 512 * 512 * 2 * 8Bit(size of double) = 8M

解决方法有两种：一是设置堆栈增大容量；二是开辟内存存放数据。我用的第二种。即



td =(COMPLEX*)malloc(height*width*sizeof(COMPLEX));
if (td == NULL)
    return -1;
fd = (COMPLEX*)malloc(height*width*sizeof(COMPLEX));
if (fd == NULL)
    return -1;

3.2 问题二

关于频谱图归一化问题,在显示频谱图时，尝试进行了归一化至0~255

temp = (temp - min) * 255.0 / (max - min);

但是效果很不好——
在这里插入图片描述

如图，只有中间有个白点，别的看不出来。不得已将temp的值乘以100后才能看到比较好的效果。
在这里插入图片描述

感觉这一问题应该是老师上课讲的直流分量数值太大的原因。致使即使归一化也还是不能很好的展现高频分量。

3.3 问题三

进行IFFT变换后，保存图像时想当然的将复数的幅度的值给了图像，代码如下——

double temp = sqrt((td[i * width + j].re) * (td[i * width + j].re) + (fd[i * width + j].im) * (fd[i * width + j].im));
Pic[i][j] = (unsigned char)temp;

未对频域进行处理，只对图像进行FFT和IFFT，输出结果如下
在这里插入图片描述

更改代码，只将实部赋值给图像

Pic[i][j] = (unsigned char)td[i * width + j].re;

效果正常
在这里插入图片描述

附代码：

main.c

#include <stdio.h>  
#include <stdlib.h>  
#include <string.h>  
#include "fft_ifft.h"
#include <math.h>

#define height  512  
#define width   512 
#define LOW_PASS 1   //是否为低通
#define DEGREE   150     //滤波程度
typedef unsigned char  BYTE;    // 定义BYTE类型，占1个字节  

int main(void)
{
    FILE *fp = NULL;
    //  BYTE Pic[height][width];
    BYTE *ptr;
    BYTE **Pic = new BYTE *[height];
    for (int i = 0; i != height; ++i)
    {
        Pic[i] = new BYTE[width];
    }
    int i, j;
    double max = 0;
    double min = 255;
    COMPLEX *td = NULL;
    COMPLEX *fd = NULL;
    //COMPLEX td[height*width];
    //COMPLEX fd[height*width];
    td = (COMPLEX*)malloc(height*width*sizeof(COMPLEX));
    if (td == NULL)
        return -1;
    fd = (COMPLEX*)malloc(height*width*sizeof(COMPLEX));
    if (fd == NULL)
        return -1;
    fp = fopen("weiminglake512x512.raw", "rb");
    ptr = (BYTE*)malloc(width * height * sizeof(BYTE));//创建内存
    for (i = 0; i < height; i++)
    {
        for (j = 0; j < width; j++)
        {
            fread(ptr, 1, 1, fp);
            Pic[i][j] = *ptr;  // 把图像输入到2维数组中,变成矩阵型式 
            td[i * width + j].re = *ptr;
            td[i * width + j].im = 0.0;
            ptr++;
        }
    }
    fclose(fp);
    FFT2(td, height, width, fd);

    for (i = 0; i < height; i++)
    {
        for (j = 0; j < width; j++)
        {
            double temp = sqrt((fd[i * width + j].re / (height*width)) * (fd[i * width + j].re / (height*width)) + (fd[i * width + j].im / (height*width)) * (fd[i * width + j].im / (height*width)));
            if (temp > max)
                max = temp;
            if (temp < min)
                min = temp;
        }
    }
    //显示频谱
    for (i = 0; i < height; i++)
    {
        for (j = 0; j < width; j++)
        {
            double temp = sqrt((fd[i * width + j].re / (height*width)) * (fd[i * width + j].re / (height*width)) + (fd[i * width + j].im / (height*width)) * (fd[i * width + j].im / (height*width)));
            temp = (temp - min) * 25500.0 / (max - min);
            Pic[i][j] = (unsigned char)temp;
            //printf("%f\t", temp);
        }
    }
    //频谱更改位置
    //二四象限置换位置
    for (i = 0; i < height / 2;i++)
    {
        for (j = 0; j < width / 2; j++)
        {
            unsigned char t = Pic[i][j];
            Pic[i][j] = Pic[height/2 + i][width/2 + j];
            Pic[height / 2 + i][width / 2 + j] = t;
        }
    }
    //一三象限置换位置
    for (i = 0; i < height / 2; i++)
    {
        for (j = width/2; j < width; j++)
        {
            unsigned char t = Pic[i][j];
            Pic[i][j] = Pic[height / 2 + i][j - width / 2];
            Pic[height / 2 + i][j - width / 2] = t;
        }
    }
    //保存频谱图
    fp = fopen("pinpu.raw", "wb");
    for (i = 0; i < height; i++)
    {
        for (j = 0; j < width; j++)
        {
            fwrite(&Pic[i][j], 1, 1, fp);
        }
    }
    fclose(fp);
    //对频谱进行处理
    for (i = 0; i < height; i++){
        for (j = 0; j < width; j++){
            if (LOW_PASS == 1){       //低通，滤掉高频。
                if (((i<DEGREE) && (j<DEGREE)) || ((i>(width - DEGREE)) && (j<DEGREE)) || (i<DEGREE) && (j>(height - DEGREE))) || ((i>(width - DEGREE)) && (j>(height - DEGREE))))
                {
                }
                else
                {
                    fd[i * width + j].re = 0;
                    fd[i * width + j].im = 0;
                }
            }
            else{                   //高通，滤掉低频。即四个角置0
                if (((i<DEGREE) && (j<DEGREE)) || ((i>(width - DEGREE)) && (j<DEGREE)) || i<DEGREE) && (j>(height - DEGREE))) || ((i>(width - DEGREE)) && (j>(height - DEGREE))))
                {
                    if (((i<1) && (j<1)) || ((i>(width - 1)) && (j<1)) || ((i<1) && (j>(height - 1))) || ((i>(width - 1)) && (j>(height - 1))))
                    {
                    }
                    else
                    {
                        fd[i * width + j].re = 0;
                        fd[i * width + j].im = 0;
                    }
                }
            }
        }
    }
    //保存处理频谱图
    for (i = 0; i < height; i++)
    {
        for (j = 0; j < width; j++)
        {
            double temp = sqrt((fd[i * width + j].re / (height*width)) * (fd[i * width + j].re / (height*width)) + fd[i * width + j].im / (height*width)) * (fd[i * width + j].im / (height*width)));
            temp = (temp - min) * 25500.0 / (max - min);
            Pic[i][j] = (unsigned char)temp;
            //printf("%f\t", temp);
        }
    }
    //频谱更改位置
    //二四象限置换位置
    for (i = 0; i < height / 2; i++)
    {
        for (j = 0; j < width / 2; j++)
        {
            unsigned char t = Pic[i][j];
            Pic[i][j] = Pic[height / 2 + i][width / 2 + j];
            Pic[height / 2 + i][width / 2 + j] = t;
        }
    }
    //一三象限置换位置
    for (i = 0; i < height / 2; i++)
    {
        for (j = width / 2; j < width; j++)
        {
            unsigned char t = Pic[i][j];
            Pic[i][j] = Pic[height / 2 + i][j - width / 2];
            Pic[height / 2 + i][j - width / 2] = t;
        }
    }
    fp = fopen("p_pinpu.raw", "wb");
    for (i = 0; i < height; i++)
    {
        for (j = 0; j < width; j++)
        {
            fwrite(&Pic[i][j], 1, 1, fp);
        }
    }
    fclose(fp);
    IFFT2(td,height, width, fd)
    for (i = 0; i < height; i++)
    {
        for (j = 0; j < width; j++)
        {
            double temp = sqrt((td[i * width + j].re) * (td[i * width + j].re) + fd[i * width + j].im) * (fd[i * width + j].im));
            Pic[i][j] = (unsigned char)td[i * width + j].re;
            //printf("%f\t", temp);
        }
    }

    fp = fopen("processed.raw", "wb");
    for (i = 0; i < height; i++)
    {
        for (j = 0; j < width; j++)
        {
            fwrite(&Pic[i][j], 1, 1, fp);
        }
    }
    fclose(fp);
    system("pause");
    return 0;
}

Fft_ifft.c

#include <math.h>
#include <malloc.h>
#include <string.h>
#include <stdio.h>  
#include "fft_ifft.h"

/*快速傅里叶变换
TD为时域值,FD为频域值,power为2的幂数*/
void FFT(COMPLEX * TD, COMPLEX * FD, int power)
{
    int count;
    int i, j, k, bfsize, p;
    double angle;
    COMPLEX *W, *X1, *X2, *X;

    /*计算傅里叶变换点数*/
    count = 1 << power;
    /*分配运算所需存储器*/
    W = (COMPLEX *)malloc(sizeof(COMPLEX)*count / 2);
    X1 = (COMPLEX *)malloc(sizeof(COMPLEX)*count);
    X2 = (COMPLEX *)malloc(sizeof(COMPLEX)*count);
    /*计算加权系数*/
    for (i = 0; i<count / 2; i++)
    {
        angle = -i* pi * 2 / count;
        W[i].re = cos(angle);
        W[i].im = sin(angle);
    }
    /*将时域点写入存储器*/
    memcpy(X1, TD, sizeof(COMPLEX)*count);
    /*蝶形运算*/
    for (k = 0; k<power; k++)
    {
        for (j = 0; j<1 << k; j++)
        {
            bfsize = 1 << (power - k);
            for (i = 0; i<bfsize / 2; i++)
            {
                p = j*bfsize;
                X2[i + p] = Add(X1[i + p], X1[i + p + bfsize / 2]);
                X2[i + p + bfsize / 2] = Mul(Sub(X1[i + p],X1[i + p + bfsize / 2]), W[i*(1 << k)]);
            }
        }
        X = X1;
        X1 = X2;
        X2 = X ;
    }
    /*重新排序*/
    for (j = 0; j<count; j++)
    {
        p = 0;
        for (i = 0; i<power; i++)
        {
            if (j&(1 << i)) p += 1 << (power - i - 1);
        }
        FD[j] = X1[p];
    }
    /*释放存储器*/
    free(W);
    free(X1);
    free(X2);
}
/*快速傅里叶反变换,利用快速傅里叶变换
FD为频域值,TD为时域值,power为2的幂数*/
void IFFT(COMPLEX *FD, COMPLEX *TD, int power)
{
    int i, count;
    COMPLEX *x;
    /*计算傅里叶反变换点数*/
    count = 1 << power;
    /*分配运算所需存储器*/
    x = (COMPLEX *)malloc(sizeof(COMPLEX)*count);
    /*将频域点写入存储器*/
    memcpy(x, FD, sizeof(COMPLEX)*count);
    /*求频域点的共轭*/
    for (i = 0; i<count; i++)
    {
        x[i].im = -x[i].im;
    }
    /*调用快速傅里叶变换*/
    FFT(x, TD, power);
    /*求时域点的共轭*/
    for (i = 0; i<count; i++)
    {
        TD[i].re /= count;
        TD[i].im = -TD[i].im / count;
    }
    /*释放存储器*/
    free(x);
}
 /*************************************************************************
*
* 函数名称：
*   Fourier()
*
* 参数:
*   COMPLEX* TD          -输入的时域序列
*    long lWidth     -图象宽度
*    long lHeight    -图象高度
*    COMPLEX* FD     -输出的频域序列
*
* 返回值:
*   BOOL               - 成功返回TRUE，否则返回FALSE。
*
* 说明:
*   该函数进行二维快速付立叶变换。
*
************************************************************************/
void FFT2(COMPLEX * TD, long lWidth, long lHeight, COMPLEX  * FD)
{
    COMPLEX *TempT, *TempF;
    // 循环变量
    long i;
    long j;
 
    // 进行傅里叶变换的宽度和高度（2的整数次方）
    long w = 1;
    long h = 1;
    int wp = 0;
    int hp = 0;
 
    // 计算进行付立叶变换的宽度和高度（2的整数次方）
    while (w < lWidth){
        w *= 2;
        wp++;
    }

    while (h < lHeight){
        h *= 2;
        hp++;
    }
    // 分配内存
    TempT = (COMPLEX *)malloc(sizeof(COMPLEX)*h);
    TempF = (COMPLEX *)malloc(sizeof(COMPLEX)*h);
    // 对y方向进行快速付立叶变换
    //rgb
    /*for (i = 0; i < w * 3; i++)
    {
    // 抽取数据
    for (j = 0; j < h; j++)
    TempT[j] = TD[j * w * 3 + i];//rgb
    // 一维快速傅立叶变换
    FFT(TempT, TempF, hp);
 
    // 保存变换结果
    for (j = 0; j < h; j++)
    TD[j * w * 3 + i] = TempF[j];
    }
    */
    //灰度
    for (i = 0; i < w; i++){
        // 抽取数据
        for (j = 0; j < h; j++){
            TempT[j] = TD[j * w + i];
        }
         // 一维快速傅立叶变换
        FFT(TempT, TempF, hp);
        // 保存变换结果
        for (j = 0; j < h; j++){
            TD[j * w + i] = TempF[j];
        }
    }
    // 释放内存
    free(TempT);
    free(TempF);

    // 分配内存
    TempT = (COMPLEX *)malloc(sizeof(COMPLEX)*w);
    TempF = (COMPLEX *)malloc(sizeof(COMPLEX)*w);
    // 对x方向进行快速付立叶变换
    //rgb
    /*
    for (i = 0; i < h; i++)
    {
    for (k = 0; k < 3; k++)
    {
    // 抽取数据
    for (j = 0; j < w; j++)
    TempT[j] = TD[i * w * 3 + j * 3 + k];
    // 一维快速傅立叶变换
    FFT(TempT, TempF, wp);
    // 保存变换结果
    for (j = 0; j < w; j++)
    FD[i * w * 3 + j * 3 + k] = TempF[j];
    }
    }
    */
    //灰度
    for (i = 0; i < h; i++)
    {
        // 抽取数据
        for (j = 0; j < w; j++){
            TempT[j] = TD[i * w + j];
        }
        // 一维快速傅立叶变换
        FFT(TempT, TempF, wp);
        // 保存变换结果
        for (j = 0; j < w; j++){
            FD[i * w + j] = TempF[j];
        }
    }
    // 释放内存
    free(TempT);
    free(TempF);
}
/*************************************************************************
*
* 函数名称：
*   IFourier()
*
* 参数:
*   LPBYTE TD        -返回的空域数据
*   long lWidth      -空域图象的宽度
*    long lHeight    -空域图象的高度
*    COMPLEX* FD     -输入的频域数据
*
* 返回值:
*   BOOL               - 成功返回TRUE，否则返回FALSE。
*
* 说明:
*   该函数进行二维快速付立叶逆变换。
*
************************************************************************/
void IFFT2(COMPLEX *TD, long lWidth, long lHeight, COMPLEX * FD)
{
    COMPLEX *TempT, *TempF;
    // 循环变量
    long i;
    long j;
    // 进行傅里叶变换的宽度和高度（2的整数次方）
    long w = 1;
    long h = 1;
    int wp = 0;
    int hp = 0;
    // 计算进行傅里叶变换的宽度和高度（2的整数次方）
    while (w < lWidth){
        w *= 2;
        wp++;
    }
    while (h < lHeight){
        h *= 2;
        hp++;
    }
    // 计算图像每行的字节数
    //long lLineBytes = WIDTHBYTES(lWidth * 24);
    // 分配内存
    TempT = (COMPLEX *)malloc(sizeof(COMPLEX)*w);
    TempF = (COMPLEX *)malloc(sizeof(COMPLEX)*w);
    // 对x方向进行快速付立叶变换
    //rgb
    /*
    for (i = 0; i < h; i++)
    {
    for (k = 0; k < 3; k++)
    {
    // 抽取数据
    for (j = 0; j < w; j++)
    TempF[j] = FD[i * w * 3 + j * 3 + k];
    // 一维快速傅立叶变换
    IFFT(TempF, TempT, wp);
    // 保存变换结果
    for (j = 0; j < w; j++)
    FD[i * w * 3 + j * 3 + k] = TempT[j];
    }
    }
    */
    //灰度
    for (i = 0; i < h; i++){
        // 抽取数据
        for (j = 0; j < w; j++)
            TempF[j] = FD[i * w + j];
        // 一维快速傅立叶变换
        IFFT(TempF, TempT, wp);
        // 保存变换结果
        for (j = 0; j < w; j++)
            FD[i * w + j] = TempT[j];
    }
    // 释放内存
    free(TempT);
    free(TempF);
    TempT = (COMPLEX *)malloc(sizeof(COMPLEX)*h);
    TempF = (COMPLEX *)malloc(sizeof(COMPLEX)*h);
    // 对y方向进行快速付立叶变换
    //rgb
    /*
    for (i = 0; i < w * 3; i++)
    {
    // 抽取数据
    for (j = 0; j < h; j++)
    TempF[j] = FD[j * w * 3 + i];

    // 一维快速傅立叶变换
    IFFT(TempF, TempT, hp);
    // 保存变换结果
    for (j = 0; j < h; j++)
    TD[j * w * 3 + i] = TempT[j];
    }
    */
    //灰度
    for (i = 0; i < w; i++){
        // 抽取数据
        for (j = 0; j < h; j++)
            TempF[j] = FD[j * w + i];
        // 一维快速傅立叶变换
        IFFT(TempF, TempT, hp);
        // 保存变换结果
        for (j = 0; j < h; j++)
            TD[j * w + i] = TempT[j];
    }
    // 释放内存
    free(TempT);
    free(TempF);
 
    /*for (i = 0; i < h; i++)
    {
    for (j = 0; j < w * 3; j++)
    {
    if (i < lHeight && j < lLineBytes)
    *(TD + i * lLineBytes + j) = FD[i * w * 3 +
j].re;
    }
    }
    */
}

fft_ifft.h

#pragma once
#ifndef COM_H_INCLUDED
#define COM_H_INCLUDED

#define pi (double)3.14159265359

/*复数定义*/
typedef struct
{
	double re;
	double im;
}COMPLEX;


/*复数加运算*/
static COMPLEX Add(COMPLEX c1, COMPLEX c2)
{
	COMPLEX c;
	c.re = c1.re + c2.re;
	c.im = c1.im + c2.im;
	return c;
}


/*复数减运算*/

static COMPLEX Sub(COMPLEX c1, COMPLEX c2)
{
	COMPLEX c;
	c.re = c1.re - c2.re;
	c.im = c1.im - c2.im;
	return c;
}

/*复数乘运算*/

static COMPLEX Mul(COMPLEX c1, COMPLEX c2)
{
	COMPLEX c;
	c.re = c1.re*c2.re - c1.im*c2.im;
	c.im = c1.re*c2.im + c2.re*c1.im;
	return c;
}
void FFT(COMPLEX * TD, COMPLEX * FD, int power);
void IFFT(COMPLEX *FD, COMPLEX *TD, int power);
void FFT2(COMPLEX * TD, long lWidth, long lHeight, COMPLEX  * FD);
void IFFT2(COMPLEX *TD, long lWidth, long lHeight, COMPLEX * FD);

#endif

有问题多交流，可留言可发邮件，我的邮箱是zhaodongyu艾特pku(这里换成点)edu.cn。

本工程源码已更新至github，欢迎star，欢迎PR:)

Zhao Dongyu
关注
  • 8
    点赞
  • 踩
  • 78
    收藏
    觉得还不错? 一键收藏
  • 14
    评论
专栏目录
C语言实现FFT算法
12-02
C语言实现FFT算法，与Matlab结果一致，详情请见https://blog.csdn.net/weixin_43216875/article/details/103343416
FFT的C语言实现代码
02-24
快速傅里叶变换 (fast Fourier transform), 即利用计算机计算离散傅里叶变换（DFT)的高效、快速计算方法的统称，简称FFT。本程序以C语言为平台，实现了按时间抽取的基-2FFT算法（蝶形算法）。具体见https://blog.csdn.net/SXGY_07/article/details/87902235
快速傅里叶变换（Fast Fourier Transform, FFT）算法
最新发布
weixin_45339016的博客
07-10 300
傅里叶变换是一种数学工具，用于将信号从其原本的时间域或者空间域转换到频率域。对于连续时间信号，我们通常讨论的是傅里叶变换（Fourier Transform），而对于离散时间信号，则会使用离散傅里叶变换（Discrete Fourier Transform, DFT）。在实际应用中，快速傅里叶变换（Fast Fourier Transform, FFT）算法被广泛用来高效地计算DFT。模块进行快速傅里叶变换的例子，我们将对一个简单的正弦波信号进行FFT，并展示其频谱。在Python中，我们可以使用。
基于PIC单片机FFT音乐频谱Proteus仿真设计 包含源程序仿真文件
08-08
基于PIC单片机FFT音乐频谱Proteus仿真设计 包含源程序仿真文件
FFT说明.zip_FFT算法的C语言实现_fft_fft 谐波_谐波算法_谐波计算
07-15
FFT算法的C语言实现，采用倒位序算法，蝶形运算实现谐波计算
《C》C语言实现FFT算法
杨贵安的博客
01-29 4万+
一、什么是FFT？ DFT虽好，但是其计算的次数太多，不利于大数据量的计算，FFT是DFT的快速算法，可以节省大量的计算时间，快速傅里叶变换（FFT）是一种能在O(nlogn)的时间内将一个多项式转换成它的点值表示的算法。 点值表示法： 设一个函数f(x)为n-1次多项式，带入一个n个不同的x会得到n个不同的y，这n对(x,y)唯一确定了该多项式，即只有一个多项式能同时满足“代入这些x，得到...
C语言FFT
m0_51077616的博客
06-10 5711
FFT，C++
C语言实现快速傅立叶（FFT）(一)
weixin_38604759的博客
12-15 2121
DFT(FFT)的作用是可以将信号从时域变换到频域，而且时域和频域都是离散的，通俗的说，可以求出一个信号由哪些正弦波叠加而成，求出的结果就是这些正弦波的幅度和相位.在第一步，8个频谱（每个频谱包含1点）被合成为4频谱（每个频谱包含2点），在第二步，4个频谱（每个频谱包含2点）被合成为2频谱（每个频谱包含4点），最后一步使得FFT的输出是一个8点的频谱。使用不同的时间窗，它的时域形状和频域特征是不相同的。矩形窗、汉宁窗和平顶窗的时域形状和频域特征如下图所示，可以看出，窗函数不同，时域和频域都是不同的。
数字图像处理各种算法 C语言实现
12-08
在IT领域，数字图像处理是一种关键技术，用于对图像进行分析、增强、恢复和识别等操作。C语言由于其高效和灵活性，常被用来实现这些算法。以下是对标题和描述中涉及的一些关键知识点的详细说明： 1. **图像空域滤波...
DIT-FFT算法c语言实现
02-06
在给定的文件“fft”中，可能包含了使用C语言实现的DIT-FFT算法，包括了上述的各个步骤和细节。这个实现可以帮助读者理解FFT的工作原理，并为他们提供一个可复用的代码基础，以便在自己的项目中使用或扩展。通过阅读...
c语言数字图像处理（五）：空间滤波
06-11
在C语言中进行数字图像处理是一项复杂而有趣的任务，它涉及到计算机视觉领域的核心概念——空间滤波。空间滤波是一种常见的图像处理技术，用于改善图像质量、去除噪声、增强细节或者进行其他形式的图像变换。在本篇...
实序列FFT算法的C语言实现
10-22
在数字信号处理领域，FFT算法扮演着至关重要的角色，广泛应用于信号分析、图像处理、通信系统等多个领域。 1. 傅里叶变换基础 傅里叶变换（FT）是一种数学工具，能够将一个时域信号转换为其频域表示。离散傅里叶...
FFT算法C语言实现
04-21
学习和理解FFT算法的C语言实现，不仅可以深入掌握信号处理的基本原理，还可以提高编程技能，为实际工程问题提供解决方案。对于C语言开发者来说，理解并能编写FFT算法是提升自己能力的一个重要环节。
fft C语言实现.zip_FFT语言_c语言实现_c语言实现FFT_fft_fft c语言
07-15
总结来说，"fft C语言实现.zip"包含的是一个关于如何用C语言实现快速傅里叶变换的教程或代码示例，可能详细解释了FFT的基本原理，提供了具体的C语言代码，并通过"fft C语言实现.txt"文件呈现这些内容。理解和掌握FFT...
c语言数字图像处理（六）：二维离散傅里叶变换
06-11
C语言实现2D DFT时，通常采用分块计算和快速傅里叶变换（FFT）来提高效率。FFT是一种递归算法，它可以将2D DFT的时间复杂度从O(MN²)降低到O(MN log MN)。在C语言中，可以使用库函数如FFTW来实现FFT。 具体步骤包括...
快速傅里叶变换(FFT)c语言实现
AlepH_Sin的博客
01-01 8939
按时间抽取基2FFT，C语言实现与详解
图像的FFT变换
Mr_Page的博客
04-21 7834
一．实验设备 计算机，matlab软件 二．实验目的 1.理解并掌握图像的FFT变换的原理。 2.学习使用matlab对图像进行FFT变换。 三．实验原理 图像fft变换可以将图像空间域变为频率域，进而对频率域图像进行操作，这样会使操作变得简单。使用MATLAB中自带的函数F=fft2()，图像变为频率域，但由于低频分量在图像四周，故需进行频移，将低频分量移至中间。 四．实验步骤 1.启动MATLAB程序，读入一幅图像；对图像做FFT，同时观察其原图与频谱。 2.对图像进行频移。 3.观察并分析结果。 五．
用c语言实现的FFT
热门推荐
tf18269639242的博客
11-03 4万+
一、对FFT的介绍 1. FFT（Fast Fourier Transformation）,即为快速傅里叶变换，是离散傅里叶变换的快速算法，它是根据离散傅里叶变换的奇、偶、虚、实等特性，对离散傅里叶变换的算法进行改进获得的。 2.FFT算法的基本原理       FFT算法是把长序列的DFT逐次分解为较短序列的DFT。       按照抽取方式的不同可分为DIT-FFT(按时间抽取)和DI
fft快速算法代码下载
06-05
FFT是快速傅里叶变换的缩写，是一种非常常用的算法，广泛用于数字信号处理、数字图像处理、声音处理等领域。很多人对于FFT算法感兴趣，想要学习或者使用这一算法，而其中最基本的一步，就是要求得FFT的代码，这样才能在自己的程序中进行调用。 目前，网上可以找到很多FFT算法的代码下载，一般来说，标准的FFT算法都是用C语言编写的，由于C语言具有高效、快速的特点，因此广受欢迎。除了常见的C语言FFT算法代码，还有一些其他语言的代码，比如MATLAB、Python等。 在下载FFT算法代码时，需要根据自己的需求选择合适的版本，比如要根据不同的信号类型选择不同的算法。此外，还需要注意代码的来源和版本，选择可靠的网站下载代码，并且仔细查看代码的注释和参数说明，以确保能够正确使用。 总体来说，FFT算法是很重要的一个信号处理算法，对于工程师和科学家来说都具有重要的意义，因此，在研究和使用FFT算法时，要注意代码的来源、版本和使用方法，以确保正确地使用FFT算法。
评论 14
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值