北邮22级信通院DSP：实验三（1）：FFT变换、IFFT变换（附每步8点变换蝶形图）保姆级讲解+用C++程序实现复数域的FFT变换和IFFT变换

北邮22信通一枚~

跟随课程进度更新北邮信通院DSP的笔记、代码和文章，欢迎关注~

获取更多文章，请访问专栏：

北邮22级信通院DSP_青山入墨雨如画的博客-CSDN博客

目录

一、预备知识

1.1 FFT算法

1.2.1由DFT到FFT

1.2.2 基2时域抽选算法

第一步：

第二步：

第三步：

第四步：

1.2 IFFT算法

1.3快速傅里叶算法拓展

1.4 C++中的complex类型

1.5 C++中的cmath库

1.6 C++中处理程序运行时间的chrono头文件

1.6.1时钟类（Clocks）：

1.6.2时间间隔（Durations）：

1.6.3时间点（Time points）：

1.6.4时间相关函数：

1.7 C++中的functional头文件与function方法       

二、程序设计思路

 2.1 FFT算法的实现

2.2 IFFT算法的实现

2.3FFT算法与IFFT算法的合并

2.4程序运行时间的函数

2.5占用内存空间的函数

三、代码部分

3.1代码部分

3.2运行效果 

一、预备知识

1.1 FFT算法

1.2.1由DFT到FFT

 FFT算法是DFT算法的优化算法，相比于DFT算法，FFT算法“对数式”地减少了运算复杂度，提高了程序运行的效率，节约了内存空间。

FFT简化DFT运算的本质是W因子的性质。

以4点DFT为例：

根据性质，可以化为：

整理可得：

所以：

可以看出，原本需要4^2=16次复数乘的DFT运算，被简化成了只需要进行一步复数乘的FFT运算，运算复杂度大大降低。 

1.2.2 基2时域抽选算法

第一步：

所以：

 以N=8点的FFT为例，所以第一步的蝶形图为：

 以下均以N=8点FFT为例。

第二步：

对x1(n)再奇偶分离得： 

可以发现，X1（k）和X2（k）也可以用X3（k）和X4（k）的线性组合表示。

复数乘法也仅仅为1次。 

 以N=8点的FFT为例，所以第二步的蝶形图为：

第三步：

由于N=2^m，所以可以一直二分分解下去。

直到最后分解为2点序列的FFT运算。

 以N=8点的FFT为例，所以第三步的蝶形图为：

第四步：

完整蝶形图 

1.2 IFFT算法

 IFFT算法是FFT算法的逆过程。

可以发现：

 所以对于N=8的IFFT：

可以看出，迭代的每一步相较于FFT，都多乘了一个1/2。 

N=8点的IFFT蝶形图如下：

1.3快速傅里叶算法拓展

关于基于时间/频率抽选的基2^N的FFT和IFFT算法，感兴趣的同学可以参考这篇博客：

Josh 的复习总结之数字信号处理（Part 5——部分 FFT 蝶形图）_fft蝶形图-CSDN博客

1.4 C++中的complex类型

         C++函数提供了专门用于复数计算的头文件#include<complex>。

        这里的complex需要声明是什么数据类型的complex，比如定义一个double类型的complex变量，我们应该写：

complex<double>complex_1={-1,2};

complex库中为我们提供了很多函数，比如取实部和取虚部运算，加减乘除的基本运算。

1.5 C++中的cmath库

         一些数学处理函数，比如三角函数和反三角函数都包含在cmath库中，加头文件#include<cmath>来导入这个库。

1.6 C++中处理程序运行时间的chrono头文件

  <chrono> 头文件中包含了一些主要的类和函数，而不是函数。这些类和函数用于处理时间相关的操作。以下是一些主要的类和函数：

1.6.1时钟类（Clocks）：

  1. std::chrono::system_clock：提供了当前系统时间的功能。
  2. std::chrono::steady_clock：提供了一个稳定的时钟，用于测量时间间隔。
  3. std::chrono::high_resolution_clock：提供了高精度的时钟，通常用于测量程序的执行时间。

1.6.2时间间隔（Durations）：

  1. std::chrono::duration：表示一段时间的长度，可以与时钟一起使用来表示时间间隔。
  2. std::chrono::nanoseconds、std::chrono::microseconds、std::chrono::milliseconds、std::chrono::seconds、std::chrono::minutes、std::chrono::hours：表示不同单位的时间间隔。

1.6.3时间点（Time points）：

  1. std::chrono::time_point：表示时钟上的一个特定时间点。
  2. std::chrono::system_clock::time_point、std::chrono::steady_clock::time_point、std::chrono::high_resolution_clock::time_point：表示特定时钟上的时间点。

1.6.4时间相关函数：

  1. std::chrono::duration_cast：用于执行时间间隔的单位转换。
  2. std::chrono::time_point_cast：用于执行时间点的时钟转换。
  3. std::chrono::high_resolution_clock::now()、std::chrono::steady_clock::now()、std::chrono::system_clock::now()：获取当前时间点。

1.7 C++中的functional头文件与function方法       

  <functional> 是 C++ 标准库中的头文件，其中包含了一组模板类和函数，用于支持函数对象（即可被调用的对象，如函数指针、lambda 表达式等）的操作和处理。

        其中，std::function 是一个模板类，可以用来包装各种可调用对象，包括函数指针、函数对象、成员函数指针、lambda 表达式等，从而实现统一的调用接口。

        使用 std::function，可以将不同类型的可调用对象赋值给同一个 std::function 对象，然后通过调用 std::function 对象来间接调用被包装的可调用对象，而无需关心其具体类型。这样可以提高代码的灵活性和可维护性。

        例如：

#include <functional>
#include <iostream>void foo(int x) {std::cout << "foo: " << x << std::endl;
}int main() {std::function<void(int)> func = foo; // 将函数指针 foo 赋值给 funcfunc(42); // 调用 func，间接调用了 fooreturn 0;
}

         这段代码中，std::function<void(int)> 声明了一个函数对象 func，其参数为 int 类型，返回类型为 void。然后，将函数指针 foo 赋值给了 func，最后通过 func 来调用函数 foo。

二、程序设计思路

 2.1 FFT算法的实现

        以下，均以N=8点FFT为例讲解。

        FFT算法的本质在于递归调用，每次对序列二分之后，对更小的序列继续做FFT变换，直到进行到最底端时候，返回所有现场。

根据以上思路，我们首先对序列做奇偶二分：

void fft(vector<Complex>& a) 
{int n = a.size();                         // 获取输入向量的大小if (n <= 1) return;                       // 如果输入向量大小为1或0，则直接返回，无需变换// 分别定义偶数项和奇数项的向量vector<Complex> even(n / 2), odd(n / 2);for (int i = 0; i < n / 2; ++i){even[i] = a[i * 2];                   // 偶数项odd[i] = a[i * 2 + 1];                // 奇数项}//…
}

 对每一部分更小的序列，使用FFT算法；

void fft(vector<Complex>& a) 
{int n = a.size();                         // 获取输入向量的大小if (n <= 1) return;                       // 如果输入向量大小为1或0，则直接返回，无需变换// 分别定义偶数项和奇数项的向量vector<Complex> even(n / 2), odd(n / 2);for (int i = 0; i < n / 2; ++i){even[i] = a[i * 2];                   // 偶数项odd[i] = a[i * 2 + 1];                // 奇数项}fft(even, inverse);                       // 对偶数项进行递归FFT变换fft(odd, inverse);                        // 对奇数项进行递归FFT变换//…
}

直到进行到两点FFT变换，做该变换并逐层向上溯回，依次返回所有现场；

void fft(vector<Complex>& a) 
{int n = a.size();                         // 获取输入向量的大小if (n <= 1) return;                       // 如果输入向量大小为1或0，则直接返回，无需变换// 分别定义偶数项和奇数项的向量vector<Complex> even(n / 2), odd(n / 2);for (int i = 0; i < n / 2; ++i){even[i] = a[i * 2];                   // 偶数项odd[i] = a[i * 2 + 1];                // 奇数项}fft(even, inverse);                       // 对偶数项进行递归FFT变换fft(odd, inverse);                        // 对奇数项进行递归FFT变换// 计算旋转因子的角度double angle = -2 * PI / n; Complex w(1), wn(cos(angle), sin(angle));         // 初始化旋转因子for (int i = 0; i < n / 2; ++i) {a[i] = even[i] + w * odd[i];                  // 计算上半部分的结果a[i + n / 2] = even[i] - w * odd[i];          // 计算下半部分的结果w *= wn; // 更新旋转因子}
}

以N=8的序列为例，第一步将8点序列奇偶二分，

执行到fft(even, inverse);和fft(odd, inverse);

 

分别对两个N=4的子序列进行FFT变换，这里保存现场。

void fft(vector<Complex>& a) 
{int n = a.size();                         // 获取输入向量的大小if (n <= 1) return;                       // 如果输入向量大小为1或0，则直接返回，无需变换// 分别定义偶数项和奇数项的向量vector<Complex> even(n / 2), odd(n / 2);for (int i = 0; i < n / 2; ++i){even[i] = a[i * 2];                   // 偶数项odd[i] = a[i * 2 + 1];                // 奇数项}fft(even, inverse);                       //执行到这步，并保存现场。fft(odd, inverse);                        //执行到这步，并保存现场。
}

 对每一个N=4的子序列，进行奇偶二分。

重新执行下面的代码：

void fft(vector<Complex>& a) 
{int n = a.size();                         // 获取输入向量的大小if (n <= 1) return;                       // 如果输入向量大小为1或0，则直接返回，无需变换// 分别定义偶数项和奇数项的向量vector<Complex> even(n / 2), odd(n / 2);for (int i = 0; i < n / 2; ++i){even[i] = a[i * 2];                   // 偶数项odd[i] = a[i * 2 + 1];                // 奇数项}fft(even, inverse);                       //执行到这步，并保存现场。fft(odd, inverse);                        //执行到这步，并保存现场。
}

 对每一个N=4的输入序列，都得到两个N=2的子序列。

执行到fft(even, inverse);和fft(odd, inverse);

 

分别对两个N=2的子序列进行FFT变换，这里保存现场。

void fft(vector<Complex>& a) 
{int n = a.size();                         // 获取输入向量的大小if (n <= 1) return;                       // 如果输入向量大小为1或0，则直接返回，无需变换// 分别定义偶数项和奇数项的向量vector<Complex> even(n / 2), odd(n / 2);for (int i = 0; i < n / 2; ++i){even[i] = a[i * 2];                   // 偶数项odd[i] = a[i * 2 + 1];                // 奇数项}fft(even, inverse);                       //执行到这步，并保存现场。fft(odd, inverse);                        //执行到这步，并保存现场。
}

执行之后，对每个输入的N=2的新序列，会奇偶二分之后产生两个N=1的子序列。

之后执行这部分代码：

void fft(vector<Complex>& a) 
{int n = a.size();                         // 获取输入向量的大小if (n <= 1) return;                       // 如果输入向量大小为1或0，则直接返回，无需变换
}

 

 

之后开始大规模返回现场。

首先对于N=1的两个序列结果，返回N=2序列保留的现场，执行这些代码：

void fft(vector<Complex>& a) 
{//这些部分已经执行过了，这里就以……形式标注，方便大家理解// 计算旋转因子的角度double angle = -2 * PI / n; Complex w(1), wn(cos(angle), sin(angle));         // 初始化旋转因子for (int i = 0; i < n / 2; ++i) {a[i] = even[i] + w * odd[i];                  // 计算上半部分的结果a[i + n / 2] = even[i] - w * odd[i];          // 计算下半部分的结果w *= wn; // 更新旋转因子}
}

之后对于N=2的两个序列结果，返回N=4序列保留的现场，执行这些代码：

void fft(vector<Complex>& a) 
{//这些部分已经执行过了，这里就以……形式标注，方便大家理解// 计算旋转因子的角度double angle = -2 * PI / n; Complex w(1), wn(cos(angle), sin(angle));         // 初始化旋转因子for (int i = 0; i < n / 2; ++i) {a[i] = even[i] + w * odd[i];                  // 计算上半部分的结果a[i + n / 2] = even[i] - w * odd[i];          // 计算下半部分的结果w *= wn; // 更新旋转因子}
}

之后对于N=4的两个序列结果，返回N=8序列保留的现场，执行这些代码：

void fft(vector<Complex>& a) 
{//这些部分已经执行过了，这里就以……形式标注，方便大家理解// 计算旋转因子的角度double angle = -2 * PI / n; Complex w(1), wn(cos(angle), sin(angle));         // 初始化旋转因子for (int i = 0; i < n / 2; ++i) {a[i] = even[i] + w * odd[i];                  // 计算上半部分的结果a[i + n / 2] = even[i] - w * odd[i];          // 计算下半部分的结果w *= wn; // 更新旋转因子}
}

最终修改了传入的变量vector<Complex>& a；

2.2 IFFT算法的实现

由于IFFT算法相较于FFT算法，只变了两个地方，一个是W因子的幂次由正变负，一个是每次迭代时候应多乘一个1/2的项，原因见上面：1.2 IFFT算法

所以对IFFT的实现， 代码部分与FFT非常类似：

void ifft(vector<Complex>& a) 
{int n = a.size();                         // 获取输入向量的大小if (n <= 1) return;                       // 如果输入向量大小为1或0，则直接返回，无需变换// 分别定义偶数项和奇数项的向量vector<Complex> even(n / 2), odd(n / 2);for (int i = 0; i < n / 2; ++i){even[i] = a[i * 2];                   // 偶数项odd[i] = a[i * 2 + 1];                // 奇数项}ifft(even, inverse);                       // 对偶数项进行递归IFFT变换ifft(odd, inverse);                        // 对奇数项进行递归IFFT变换// 计算旋转因子的角度double angle = 2 * PI / n;                Complex w(1), wn(cos(angle), sin(angle));         // 初始化旋转因子for (int i = 0; i < n / 2; ++i) {a[i] = even[i] + w * odd[i];                  // 计算上半部分的结果a[i + n / 2] = even[i] - w * odd[i];          // 计算下半部分的结果a[i] /= 2;a[i + n / 2] /= 2;w *= wn; // 更新旋转因子}
}

有关递归调用的过程请类比FFT。 

2.3FFT算法与IFFT算法的合并

由于FFT和IFFT的算法基本相同，我们可以将两个算法做一个合并，在传入的形参中新增bool型一个变量，用于判断是否为IFFT变换，如果是的话，就在FFT变换的基础上新增一些操作。

FFT和IFFT合并算法如下：

// FFT算法函数，参数 a 是输入的复数向量，
// inverse 表示是否进行逆变换，默认为 false
void fft(vector<Complex>& a, bool inverse = false) 
{int n = a.size();                         // 获取输入向量的大小if (n <= 1) return;                       // 如果输入向量大小为1或0，则直接返回，无需变换// 分别定义偶数项和奇数项的向量vector<Complex> even(n / 2), odd(n / 2);for (int i = 0; i < n / 2; ++i){even[i] = a[i * 2];                   // 偶数项odd[i] = a[i * 2 + 1];                // 奇数项}fft(even, inverse);                       // 对偶数项进行递归FFT变换fft(odd, inverse);                        // 对奇数项进行递归FFT变换// 计算旋转因子的角度double angle = (inverse ? 2 : -2) * PI / n;       //false的话是-2，正变换;true的话是2，逆变换Complex w(1), wn(cos(angle), sin(angle));         // 初始化旋转因子for (int i = 0; i < n / 2; ++i) {a[i] = even[i] + w * odd[i];                  // 计算上半部分的结果a[i + n / 2] = even[i] - w * odd[i];          // 计算下半部分的结果if (inverse) {                                             // 如果是逆变换，则需要除以2a[i] /= 2;a[i + n / 2] /= 2;}w *= wn; // 更新旋转因子}
}// IFFT算法函数，参数 a 是输入的复数向量
void ifft(vector<Complex>& a) 
{fft(a, true); // 调用 FFT 函数，inverse 参数设置为 true，进行逆变换
}

2.4程序运行时间的函数

// 计算运行时间
template<typename Func>
void measureTime(Func func, const string& msg) {auto start = chrono::high_resolution_clock::now();func(); // 执行传入的函数auto end = chrono::high_resolution_clock::now();chrono::duration<double> duration = end - start;cout << msg << "运行时间：" << duration.count() * 1000 << " ms" << endl;
}

         需要加头文件#include <chrono>和#include <functional> 

         形参 msg 是用来传递一条描述性的消息，用于在输出中标识这次时间测量的内容。在输出中，这个消息会和执行时间一起显示，使得输出更具可读性，方便理解每次测量所针对的操作。

         auto start = chrono::high_resolution_clock::now();用于获取当前时间点；

        在 <chrono> 头文件中，duration 表示一段时间的长度，以指定的时间单位表示。它是一个模板类，可以根据需要指定不同的时间单位（如秒、毫秒、微秒等）。

        使用方法是首先创建一个 duration 对象，然后可以通过成员函数 count() 获取该持续时间的值，并根据需要转换为所需的时间单位。

        例如，对于 chrono::duration<double>，可以通过 count() 获取持续时间的双精度浮点数值，表示秒数。如果需要将其转换为毫秒，则可以乘以 1000。

2.5占用内存空间的函数

template<typename T>
size_t memoryUsage(const vector<T>& vec) {return vec.size() * sizeof(T);
}

        这段代码计算了一个 vector 对象所占用的内存大小。它通过 vec.size() 获取 vector 中元素的数量，然后乘以 sizeof(T)，其中 T 是 vector 存储的元素类型，表示每个元素所占用的内存大小。

三、代码部分

3.1代码部分

#include<iostream>                                        // 输入输出流头文件
#include <complex>                                        // 包含复数类型的头文件
#include <vector>                                         // 包含向量容器的头文件
#include <cmath>                                          // 包含数学函数的头文件
#include <chrono>                                         // 用于处理程序运行时间的头文件
#include <functional>                                     // 引入 <functional> 头文件用于使用 std::function方法
using namespace std;//用反三角函数定义常数PI
const double PI = acos(-1.0);// 定义复数类型
typedef complex<double> Complex;// FFT算法函数，参数 a 是输入的复数向量，
// inverse 表示是否进行逆变换，默认为 false
void fft(vector<Complex>& a, bool inverse = false) 
{int n = a.size();                         // 获取输入向量的大小if (n <= 1) return;                       // 如果输入向量大小为1或0，则直接返回，无需变换// 分别定义偶数项和奇数项的向量vector<Complex> even(n / 2), odd(n / 2);for (int i = 0; i < n / 2; ++i){even[i] = a[i * 2];                   // 偶数项odd[i] = a[i * 2 + 1];                // 奇数项}fft(even, inverse);                       // 对偶数项进行递归FFT变换fft(odd, inverse);                        // 对奇数项进行递归FFT变换// 计算旋转因子的角度double angle = (inverse ? 2 : -2) * PI / n;       //false的话是-2，正变换;true的话是2，逆变换Complex w(1), wn(cos(angle), sin(angle));         // 初始化旋转因子for (int i = 0; i < n / 2; ++i) {a[i] = even[i] + w * odd[i];                  // 计算上半部分的结果a[i + n / 2] = even[i] - w * odd[i];          // 计算下半部分的结果if (inverse) {                                             // 如果是逆变换，则需要除以2a[i] /= 2;a[i + n / 2] /= 2;}w *= wn; // 更新旋转因子}
}// IFFT算法函数，参数 a 是输入的复数向量
void ifft(vector<Complex>& a) 
{fft(a, true); // 调用 FFT 函数，inverse 参数设置为 true，进行逆变换
}// 计算运行时间
template<typename Func>
void measureTime(Func func, const string& msg) {auto start = chrono::high_resolution_clock::now();func(); // 执行传入的函数auto end = chrono::high_resolution_clock::now();chrono::duration<double> duration = end - start;cout << msg << "运行时间：" << duration.count() * 1000 << " ms" << endl;
}// 计算内存占用
template<typename T>
size_t memoryUsage(const vector<T>& vec) {return vec.size() * sizeof(T);
}int main() 
{system("color 0A");// 输入序列vector<Complex> input = { (1,2),(2,3),(3,4),(4,5),(5,6),(6,7),(7,8),(8,9),(9,1) };// 执行FFT变换fft(input);// 打印FFT变换结果cout << "FFT 变换结果：" << endl << endl;for (const auto& val : input) {cout << val << endl;}cout << endl;// 执行IFFT变换ifft(input);// 打印IFFT变换结果cout << "IFFT 变换结果：" << endl << endl;for (const auto& val : input) {cout << val << endl;}cout << endl;// 计算 IFFT 变换的运行时间measureTime([&input]() {ifft(input);}, "IFFT");// 计算内存占用cout << "内存占用：" << memoryUsage(input) << " bit" << endl;return 0;
}

3.2运行效果 

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/diannao/7831.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

并发编程之阻塞队列BlockingQueue实战及其原理分析

并发编程之阻塞队列BlockingQueue实战及其原理分析

1. 阻塞队列介绍 1.1 队列 是限定在一端进行插入&#xff0c;另一端进行删除的特殊线性表。 先进先出(FIFO)线性表。 允许出队的一端称为队头&#xff0c;允许入队的一端称为队尾。
阅读更多...
使用开放式用户通信连接两台西门子S71200plc

使用开放式用户通信连接两台西门子S71200plc

步骤1.在项目中创建两台PLC。 步骤2.分别设置两个PLC的参数。 plc1 plc2 步骤3.对两个plc进行组态 步骤4.在plc1和plc2中各自创建DB块&#xff0c;用于通信。 须在块的属性中取消优化块的访问选项。 plc1 plc2 步骤5.往plc1的main块中编写代码。 步骤6.往plc2的main块中编写…
阅读更多...
Markdown 精简教程（胎教级教程）

Markdown 精简教程（胎教级教程）

文章目录 一、关于 Markdown1. 什么是 Markdown&#xff1f;2. 为什么要用 Markdown&#xff1f;3. 怎么用 Markdown&#xff1f;&#xff08;编辑软件&#xff09; 二、标题1. 常用标题写法2. 可选标题写法3. 自定义标题 ID4. 注意事项 三、段落四、换行五、字体选项1. 粗体2.…
阅读更多...
15.计算机网络

15.计算机网络

1.物理层的互联设备 中继器 和 集线器 2.集线器可以看做特殊的多路中继器 集线器 不可以做到自动寻址的功能 3.数据链路层 网桥 和 交换机 4.交换机是多端口网桥 5.网络层 路由器 6.应用层 网关 7.广播域 网络层 可以形成多个广播域 冲突域 网络层数据链路层 可以形成多个冲突域…
阅读更多...
网络安全--红队资源大合集

网络安全--红队资源大合集

目录 相关资源列表 攻防测试手册 内网安全文档 学习靶场 工具包集合 内网安全文档 学习手册相关资源 产品设计文档 版本管理平台漏洞收集 相关工具拓展插件 Kali 环境下拓展插件 Nessus 相关工具拓展插件 Awvs 相关工具拓展插件 红队攻击的生命周期&#xff0c;…
阅读更多...
第三节课，前端

第三节课，前端

一、参考链接&#xff1b; 总 知识星球 | 深度连接铁杆粉丝&#xff0c;运营高品质社群&#xff0c;知识变现的工具 分 2022-03-18 星球直播笔记-用户中心&#xff08;下&#xff09; 语雀 二、登录 2.1登录网址 2.2前端页面修改 2.1 页面修改 2.2 页脚的超链接 网址&am…
阅读更多...
Linux初识

Linux初识

1.操作系统的那点事 &#xff08;1&#xff09;结论&#xff1a;操作系统是作软硬件管理的软件&#xff1b; &#xff08;2&#xff09;计算机是操作系统&#xff0c;设备驱动&#xff0c;硬件三个相互结合发挥作用的&#xff0c;操作系统是用来管理硬件的&#xff0c;常见的…
阅读更多...
操作系统真象还原-bochs安装

操作系统真象还原-bochs安装

今天读了《操作系统真象还原》这本书&#xff0c;写上比较幽默通俗。书中例子需要安装一个bochs系统&#xff0c;记录一下安装过程。参考了书中1.4&#xff0c;1.5两节&#xff0c;书中尽让有两处问题&#xff0c;也记录了下来。 1.3 操作系统的宿主环境 下载地址&#xff1a…
阅读更多...
汽车混动结构概念

汽车混动结构概念

混动汽车中的PHEV、HEV和REEV分别代表了不同的技术概念和类型&#xff0c;它们各自有其特点和区别。以下是关于这三种混动汽车的概念和它们之间的主要区别&#xff1a; PHEV&#xff08;插电式混合动力汽车&#xff0c;Plug-in Hybrid Electric Vehicle&#xff09; 概念&…
阅读更多...
简易录制视频做3D高斯

简易录制视频做3D高斯

系统环境 ubuntu20 &#xff0c;cuda11.8&#xff0c;anaconda配置好了3D高斯的环境。 具体参考3D高斯环境配置&#xff1a;https://blog.csdn.net/Son_of_the_Bronx/article/details/138527329?spm1001.2014.3001.5501 colmap安装&#xff1a;https://blog.csdn.net/Son_of…
阅读更多...
嵌入式linux学习第三天汇编语言点灯

嵌入式linux学习第三天汇编语言点灯

嵌入式linux学习第三天汇编语言点灯 今天学习如何在linux板子上点灯。 I.MX6U GPIO 详解 我们发现I.MX6U GPIO是分为两类的&#xff0c;&#xff1a;SNVS 域的和通用的。在讨论i.MX6U或类似的复杂微处理器时&#xff0c;了解其GPIO&#xff08;通用输入输出&#xff09;引脚…
阅读更多...
linux 下 /usr/local的作用

linux 下 /usr/local的作用

在Linux系统中&#xff0c;/usr/local目录扮演着特定的角色&#xff0c;它是为用户自安装的软件提供一个标准位置。以下是/usr/local目录的主要用途和特点&#xff1a; 用户级程序目录&#xff1a;该目录用于存放用户自行编译安装的软件或者第三方应用程序&#xff0c;区别于操…
阅读更多...
mysql5.7.44误删除数据后，使用binlog日志恢复

mysql5.7.44误删除数据后，使用binlog日志恢复

系统环境 #系统版本 # cat /etc/redhat-release CentOS Linux release 7.9.2009 (Core) #数据库版本 # mysql -V mysql Ver 14.14 Distrib 5.7.44, for Linux (x86_64) using EditLine wrapper恢复前提 本文仅适合mysql数据库已经开启binlog日志的情况。 查看binlog是否开启…
阅读更多...
八.吊打面试官系列-Tomcat优化-深入源码剖析Tomcat如何打破双亲委派

八.吊打面试官系列-Tomcat优化-深入源码剖析Tomcat如何打破双亲委派

前言 上篇文章《Tomcat优化-深入Tomcat底层原理》我们从宏观上分析了一下Tomcat的顶层架构以及核心组件的执行流程。本篇文章我们从源码角度来分析Tomcat的类加载机制&#xff0c;且看它是如何打破JVM的ClassLoader双亲委派的 Tomcat ClassLoader 初始化 Tomcat的启动类是在…
阅读更多...
华为eNSP小型园区网络配置（下）

华为eNSP小型园区网络配置（下）

→跟着大佬学习的b站直通车&#xff0c;感谢大佬← →华为eNSP小型园区网络配置&#xff08;上&#xff09;← 目标1&#xff1a;telnet配置 R1 # interface GigabitEthernet0/0/2ip address 100.1.1.2 255.255.255.0 # user-interface vty 0 4authentication-mode aaa # aaa…
阅读更多...
英语新概念2-回译法-lesson12

英语新概念2-回译法-lesson12

第一次翻译 &#xff08;稀巴烂&#xff09; Our neiborhood,Capitain Charles Alison,will sail from P. We will ______ in the _. He will sit in his small boat, Topsail,Topsail is a famous boat. It has been across the A many times. Alison will sail at 8 o’cloc…
阅读更多...
05-06 周一 Shell工程目录划分和开发最佳实践

05-06 周一 Shell工程目录划分和开发最佳实践

05-06 周一 Shell工程目录划分和开发最佳实践 时间版本修改人描述2024年5月6日10:34:13V0.1宋全恒新建文档2024年5月6日11:07:12V1.0宋全恒完成 简介 之前楼主曾经完成过一个shell工程的开发&#xff0c;记得当时项目名称叫做campus-shell&#xff0c;主要是用来一键完成多个模…
阅读更多...
【CV】双边滤波

【CV】双边滤波

双边滤波是一种在图像处理中常用的滤波技术&#xff0c;特别适用于保持图像边缘和纹理细节的情况下进行降噪。在视频图像处理中&#xff0c;双边滤波同样发挥着重要作用&#xff0c;能够有效地提高图像质量和增强视觉效果。 双边滤波原理 双边滤波结合了空间域和灰度值域两个…
阅读更多...
【信息安全管理与评估】某年“信息安全管理与评估”第二阶段：Windows应急响应例题

【信息安全管理与评估】某年“信息安全管理与评估”第二阶段：Windows应急响应例题

文章目录 1、提交攻击者的IP地址&#xff1b;2、识别攻击者使用的操作系统&#xff1b;3、找出攻击者资产收集所使用的平台&#xff1b;4、提交攻击者目录扫描所使用的工具名称&#xff1b;5、提交攻击者首次攻击成功的时间&#xff0c;格式&#xff1a;DD /MM/YY:HH:MM:SS&…
阅读更多...
SpringBoot中HandlerInterceptor拦截器的构建详细教程

SpringBoot中HandlerInterceptor拦截器的构建详细教程

作用范围&#xff1a;拦截器主要作用于Spring MVC的DispatcherServlet处理流程中&#xff0c;针对进入Controller层的请求进行拦截处理。它基于Java的反射机制&#xff0c;通过AOP&#xff08;面向切面编程&#xff09;的思想实现&#xff0c;因此它能够访问Spring容器中的Bean…
阅读更多...
最新文章

Copyright @ 2022~2023