MusicSpectrum  1.0.0
Membros Públicos | Membros Privados | Lista de todos os Membros
Referência do <em>Template</em> da Classe FFT< T >

#include <fft.hpp>

Membros Públicos

void fftAnalyze (std::vector< T > &in, std::size_t stride, std::vector< Float_Complex > &out, std::size_t n)
 

Membros Privados

float amp (Float_Complex z)
 
std::size_t bitReverse (std::size_t k, std::size_t n)
 
void applyHannWindow (std::vector< T > &in, std::size_t n)
 
void applyHammingWindow (std::vector< T > &in, std::size_t n)
 
void applyBlackmanWindow (std::vector< T > &in, std::size_t n)
 
void applyFlattopWindow (std::vector< T > &in, std::size_t n)
 
void fft (std::vector< T > &in, std::size_t stride, std::vector< Float_Complex > &out, std::size_t n)
 

Descrição detalhada

template<class T>
class FFT< T >

Classe template para realizar FFT em dados unidimensionais.

Esta classe implementa a Transformada de Fourier Rápida (FFT) para calcular a transformada discreta de Fourier de um sinal unidimensional. Esta implementação de FFT aplica o algoritmo de Cooley-Tukey. Suporta diferentes tipos de dados, como int, short, uint8_t, uint16_t, etc.

Funções membros

◆ amp()

template<class T >
float FFT< T >::amp ( Float_Complex  z)
inlineprivate

Função para calcular a amplitude de um número complexo

Calcula a amplitude (módulo) de um número complexo z.

z: Um número complexo do tipo std::complex<float>.

Rertono: A amplitude (módulo) do número complexo z, calculada como a raiz quadrada da soma dos quadrados das partes real e imaginária.

13  {
14  return std::abs(z);
15 }

◆ applyBlackmanWindow()

template<class T >
void FFT< T >::applyBlackmanWindow ( std::vector< T > &  in,
std::size_t  n 
)
private

Janela de Blackman

Aplica a janela de Blackman aos dados de entrada in com tamanho n.

in: Uma referência a um vetor de dados de entrada do tipo T.

n: O tamanho do vetor de dados de entrada.

85  {
86  for (std::size_t i = 0; i < n; ++i) {
87  float t = static_cast<float>(i) / (n - 1);
88  float blackman =
89  0.42 + 0.5 * std::cos(2 * pi * t) + 0.8 * std::cos(4 * pi * t);
90  in[i] *= blackman;
91  }
92 }
pi
const float pi
Definition: fft.hpp:9

◆ applyFlattopWindow()

template<class T >
void FFT< T >::applyFlattopWindow ( std::vector< T > &  in,
std::size_t  n 
)
private

Janela de Flattop

Aplica a janela de Flattop aos dados de entrada in com tamanho n.

in: Uma referência a um vetor de dados de entrada do tipo T.

n: O tamanho do vetor de dados de entrada.

104  {
105  for (std::size_t i = 0; i < n; ++i) {
106  float t = static_cast<float>(i) / (n - 1);
107  float flattop =
108  1 - 1.93 * std::cos(2 * pi * t) + 1.29 * std::cos(4 * pi * t) -
109  0.388 * std::cos(6 * pi * t) + 0.032 * std::cos(8 * pi * t);
110  in[i] *= flattop;
111  }
112 }

◆ applyHammingWindow()

template<class T >
void FFT< T >::applyHammingWindow ( std::vector< T > &  in,
std::size_t  n 
)
private

Janela de Hamming

Aplica a janela de Hamming aos dados de entrada in com tamanho n.

in: Uma referência a um vetor de dados de entrada do tipo T.

n: O tamanho do vetor de dados de entrada.

67  {
68  for (std::size_t i = 0; i < n; ++i) {
69  float t = static_cast<float>(i) / (n - 1);
70  float hamming = 0.54 - 0.46 * std::cos(2 * pi * t);
71  in[i] *= hamming;
72  }
73 }

◆ applyHannWindow()

template<class T >
void FFT< T >::applyHannWindow ( std::vector< T > &  in,
std::size_t  n 
)
private

Janela de Hann

Aplica a janela de Hann aos dados de entrada in com tamanho n.

in: Uma referência a um vetor de dados de entrada do tipo T.

n: O tamanho do vetor de dados de entrada.

49  {
50  for (std::size_t i = 0; i < n; ++i) {
51  float t = static_cast<float>(i) / (n - 1);
52  float hann = 0.5 - 0.5 * std::cos(2 * pi * t);
53  in[i] *= hann;
54  }
55 }

◆ bitReverse()

template<class T >
std::size_t FFT< T >::bitReverse ( std::size_t  k,
std::size_t  n 
)
private

Função para reversão de bits

Realiza a reversão de bits de um índice k em um número binário de n bits.

k: O índice a ser revertido.

n: O número de bits do índice k.

Returno: O índice k com seus bits revertidos.

30  {
31  std::size_t reversed = 0;
32  for (std::size_t i = 0; i < n; ++i) {
33  reversed = (reversed << 1) | (k & 1);
34  k >>= 1;
35  }
36  return reversed;
37 }

◆ fft()

template<class T >
void FFT< T >::fft ( std::vector< T > &  in,
std::size_t  stride,
std::vector< Float_Complex > &  out,
std::size_t  n 
)
private

Função recursiva para realizar a FFT

Realiza a Transformada Rápida de Fourier (FFT) nos dados de entrada.

in: Uma referência a um vetor de dados de entrada do tipo T.

stride: O passo entre os elementos do vetor de entrada.

out: Uma referência a um vetor de número complexo do tipo

Float_Complex para armazenar a saída da FFT.

n: O tamanho do vetor de dados de entrada e saída.

131  {
132  if (n == 1) {
133  out[0] = in[0];
134  return;
135  }
136 
137  std::vector<T> in_reversed(n, 0);
138  for (std::size_t k = 0; k < n; k++) {
139  std::size_t rev_k = bitReverse(k, static_cast<std::size_t>(log2(n)));
140  in_reversed[k] = in[rev_k * stride];
141  }
142 
143  std::vector<Float_Complex> out_reversed(n / 2, 0);
144  fft(in_reversed, stride * 2, out_reversed, n / 2);
145 
146  for (std::size_t k = 0; k < n / 2; k++) {
147  float t = static_cast<float>(k) / n;
148  Float_Complex v = exp(-2.f * 1if * pi * t) * out_reversed[k];
149  Float_Complex e = out_reversed[k];
150  out[k] = e + v;
151  out[k + n / 2] = e - v;
152  }
153 }
FFT::bitReverse
std::size_t bitReverse(std::size_t k, std::size_t n)
Definition: fft.cpp:30
FFT::fft
void fft(std::vector< T > &in, std::size_t stride, std::vector< Float_Complex > &out, std::size_t n)
Definition: fft.cpp:130
Float_Complex
std::complex< float > Float_Complex
Definition: fft.hpp:11

◆ fftAnalyze()

template<class T >
void FFT< T >::fftAnalyze ( std::vector< T > &  in,
std::size_t  stride,
std::vector< Float_Complex > &  out,
std::size_t  n 
)

Função principal para análise de espectro

Realiza a análise do espectro dos dados de entrada usando a Transformada Rápida de Fourier (FFT) e armazena o resultado em out.

in: Uma referência a um vetor de dados de entrada do tipo T.

stride: O passo entre os elementos do vetor de entrada.

out: Uma referência a um vetor de números complexos do tipo.

Float_Complex para armazenar o espectro calculado.

n: O tamanho do vetor de dados de entrada e saída.

173  {
174  applyHammingWindow(in, n);
175  // applyHannWindow(in, n);
176  // applyBlackmanWindow(in, n);
177  // applyFlattopWindow(in, n);
178 
179  std::vector<Float_Complex> complex_output(n, 0.0f);
180 
181  fft(in, stride, complex_output, n);
182 
183  float step = 1.06;
184  float lowf = 1.0f;
185  std::size_t m = 0;
186  float max_amp = 1.0f;
187 
188  for (float f = lowf; static_cast<std::size_t>(f) < n / 2;
189  f = std::ceil(f * step)) {
190  float f1 = std::ceil(f * step);
191  float a = 0.0f;
192  for (std::size_t q = static_cast<std::size_t>(f);
193  q < n / 2 && q < static_cast<std::size_t>(f1); ++q) {
194  float b = amp(complex_output[q]);
195  (b > a) ? a = b : 0;
196  }
197  (max_amp < a) ? max_amp = a : 0;
198  out[m++] = a;
199  }
200 
201  for (std::size_t i = 0; i < n / 2; ++i) {
202  out[i] /= max_amp;
203  }
204 }
FFT::amp
float amp(Float_Complex z)
Definition: fft.cpp:13
FFT::applyHammingWindow
void applyHammingWindow(std::vector< T > &in, std::size_t n)
Definition: fft.cpp:67
A documentação para essa classe foi gerada a partir dos seguintes arquivos: