Referência da Classe Spectrum

#include <spectrum.hpp>

Membros Públicos
void	run (std::function< void(std::vector< Float_Complex >, std::size_t)> handlePlot)
void	viewWaveform ()
	Renderiza a forma de onda do sinal de áudio utilizando linhas. Mais...
void	viewWaveformFFT ()
	Renderiza a FFT do sinal de áudio utilizando linhas. Mais...
void	viewWaveformRect ()
	Renderiza a forma de onda do sinal de áudio utilizando retângulo. Mais...
void	viewWaveformRectFFT ()
	Renderiza a FFT do sinal de áudio utilizando retângulos. Mais...
	Spectrum (std::shared_ptr< sf::RenderWindow > win, std::shared_ptr< HUD > hud, std::shared_ptr< FFT< sf::Int16 >> fft)

Atributos Privados
std::shared_ptr< sf::RenderWindow >	window
std::shared_ptr< HUD >	hud_ptr
std::shared_ptr< FFT< sf::Int16 > >	fft_ptr
std::unique_ptr< Timer >	timer_ptr
std::unique_ptr< Sample >	sample_ptr
float	gravity_velocity = 0.001f
const float	gravity_acceleration = 9.81f
sf::Color	start_color = sf::Color::Blue
sf::Color	end_color = sf::Color::Magenta
std::vector< sf::RectangleShape >	rectangles

Descrição detalhada

Esta classe visualiza a forma de onda de um sinal de áudio utilizando retângulos coloridos. Ela também pode renderizar a FFT do sinal.

A classe Spectrum utiliza bibliotecas como SFML e FFT para processar e renderizar a forma de onda do áudio fornecido. Ela interage com outras classes como HUD e Sample para auxiliar na exibição e processamento dos dados.

Construtores e Destrutores

Spectrum()

Spectrum::Spectrum	(	std::shared_ptr< sf::RenderWindow >	win,
		std::shared_ptr< HUD >	hud,
		std::shared_ptr< FFT< sf::Int16 >>	fft
	)

Construtor da classe Spectrum.

• win: Ponteiro compartilhado para a janela renderizada pelo SFML.
• hud: Ponteiro compartilhado para a classe HUD.
• fft: Ponteiro compartilhado para a classe FFT.

    : window(win), hud_ptr(hud), fft_ptr(fft),
      timer_ptr(std::make_unique<Timer>()),
      sample_ptr(std::make_unique<Sample>(hud)) {}

Funções membros

run()

void Spectrum::run

(

std::function< void(std::vector< Float_Complex >, std::size_t)>

handlePlot

)

Executa o loop principal da aplicação, processando e renderizando a forma de onda ou FFT do sinal de áudio. A função de callback handlePlot é utilizada para tratar os dados do plot (forma de onda ou FFT).

handlePlot: Função callback para processar os dados do plot (forma de onda ou FFT).

                    {
    sample_ptr->processStereoToMono();
    std::vector<Float_Complex> spectrum;
 
    if (hud_ptr->sound.getStatus() == sf::SoundSource::Playing) {
        sample_ptr->getSampleBuffer();
 
        std::size_t fft_size = 1;
        while (fft_size < buffer_size) {
            fft_size *= 2;
        }
 
        spectrum.resize(fft_size, 0);
 
        handlePlot(spectrum, fft_size);
    }
 
    std::this_thread::sleep_for(std::chrono::milliseconds(10));
}

viewWaveform()

void Spectrum::viewWaveform

(

)

Renderiza a forma de onda do sinal de áudio utilizando linhas.

                            {
    sf::VertexArray waveform(sf::LineStrip, buffer_size);
    float offsetY = HEIGHT / 2.f;
 
    for (std::size_t i = 0; i < buffer_size; ++i) {
        sf::Int16 sample_value = hud_ptr->sample_buffer[i];
        float normalized_value = static_cast<float>(sample_value) / 32767.f;
        waveform[i].position = sf::Vector2f(
            static_cast<float>(i), normalized_value * offsetY + offsetY);
 
        float milliseconds = timer_ptr->elapsed() / 1000;
        float interval = milliseconds / 80.0f;
 
        float t = interval + (static_cast<float>(i) / buffer_size);
        t = t - static_cast<int>(t);
 
        sf::Color vertex_color(
            static_cast<sf::Uint8>(start_color.r * (1 - t) + end_color.r * t),
            static_cast<sf::Uint8>(start_color.g * (1 - t) + end_color.g * t),
            static_cast<sf::Uint8>(start_color.b * (1 - t) + end_color.b * t));
 
        waveform[i].color = vertex_color;
    }
 
    window->draw(waveform);
}

viewWaveformFFT()

void Spectrum::viewWaveformFFT

(

)

Renderiza a FFT do sinal de áudio utilizando linhas.

                               {
    sf::VertexArray waveform(sf::LineStrip, buffer_size);
    float centerY = HEIGHT - 10.f;
 
    for (std::size_t i = 0; i < buffer_size; ++i) {
        float amplitude = std::abs(hud_ptr->sample_buffer[i]) / 32767.f;
        float offsetY = amplitude * HEIGHT;
        waveform[i].position =
            sf::Vector2f(static_cast<float>(i), centerY - offsetY);
 
        float t = static_cast<float>(i) / buffer_size;
        sf::Color vertex_color(
            static_cast<sf::Uint8>(start_color.r * (1 - t) + end_color.r * t),
            static_cast<sf::Uint8>(start_color.g * (1 - t) + end_color.g * t),
            static_cast<sf::Uint8>(start_color.b * (1 - t) + end_color.b * t));
 
        waveform[i].color = vertex_color;
    }
 
    window->draw(waveform);
}

viewWaveformRect()

void Spectrum::viewWaveformRect

(

)

Renderiza a forma de onda do sinal de áudio utilizando retângulo.

                                {
    float rect_width = 3.0f;
    float rect_spacing = 1.f;
    float offsetY = HEIGHT / 2.f;
 
    for (std::size_t i = 0; i < buffer_size - 1; i += 5) {
        sf::Int16 sample_value = hud_ptr->sample_buffer[i];
        float normalized_value = static_cast<float>(sample_value) / 32767.f;
 
        float rect_height = normalized_value * 150;
 
        float t = static_cast<float>(i * 4) / buffer_size;
        t = t * t * (3.0f - 2.0f * t);
        sf::Color vertex_color(
            static_cast<sf::Uint8>(start_color.r * (1 - t) + end_color.r * t),
            static_cast<sf::Uint8>(start_color.g * (1 - t) + end_color.g * t),
            static_cast<sf::Uint8>(start_color.b * (1 - t) + end_color.b * t));
 
        sf::RectangleShape rectangle(sf::Vector2f(rect_width, rect_height));
        rectangle.setFillColor(vertex_color);
 
        rectangle.setPosition(static_cast<float>(i) *
                                  (rect_width + rect_spacing),
                              offsetY - rect_height);
        window->draw(rectangle);
    }
}

viewWaveformRectFFT()

void Spectrum::viewWaveformRectFFT

(

)

Renderiza a FFT do sinal de áudio utilizando retângulos.

                                   {
    float rect_width = 3.f;
    float centerY = HEIGHT - 10.f;
    static std::vector<float> prev_amplitudes(buffer_size, 0.0f);
 
    for (std::size_t j = 0; j < buffer_size - 1; j += 6) {
        float amplitude = std::abs(hud_ptr->sample_buffer[j]) / 32767.f;
        float rect_height = amplitude * HEIGHT;
 
        sf::RectangleShape rectangle(sf::Vector2f(rect_width, rect_height));
 
        float t = static_cast<float>(j * 3) / buffer_size;
        t = t * t * (3.0f - 2.0f * t);
        sf::Color vertex_color(
            static_cast<sf::Uint8>(start_color.r * (1 - t) + end_color.r * t),
            static_cast<sf::Uint8>(start_color.g * (1 - t) + end_color.g * t),
            static_cast<sf::Uint8>(start_color.b * (1 - t) + end_color.b * t));
 
        rectangle.setFillColor(vertex_color);
        sf::Vector2f position(j * rect_width, centerY - rect_height);
        rectangle.setPosition(position);
 
        window->draw(rectangle);
 
        sf::RectangleShape gravity_rect(sf::Vector2f(10.f, 5.f));
        gravity_rect.setFillColor(vertex_color);
        sf::Vector2f rect_pos = sf::Vector2f(
            position.x + (rect_width - 10.f) / 2, position.y - 5.f);
 
        gravity_velocity += gravity_acceleration;
        rect_pos.y += gravity_velocity;
 
        if (rect_pos.y > centerY - 5.f) {
            rect_pos.y = centerY - 5.f;
            gravity_velocity = -gravity_velocity;
        }
 
        gravity_rect.setPosition(rect_pos);
 
        window->draw(gravity_rect);
    }
}

Atributos

end_color

sf::Color Spectrum::end_color = sf::Color::Magenta

private

fft_ptr

std::shared_ptr<FFT<sf::Int16> > Spectrum::fft_ptr

private

gravity_acceleration

const float Spectrum::gravity_acceleration = 9.81f

private

gravity_velocity

float Spectrum::gravity_velocity = 0.001f

private

hud_ptr

std::shared_ptr<HUD> Spectrum::hud_ptr

private

rectangles

std::vector<sf::RectangleShape> Spectrum::rectangles

private

sample_ptr

std::unique_ptr<Sample> Spectrum::sample_ptr

private

start_color

sf::Color Spectrum::start_color = sf::Color::Blue

private

timer_ptr

std::unique_ptr<Timer> Spectrum::timer_ptr

private

window

std::shared_ptr<sf::RenderWindow> Spectrum::window

private

---

A documentação para essa classe foi gerada a partir dos seguintes arquivos:

• spectrum.hpp
• spectrum.cpp
• waves_rect.cpp
• Spectrum/waves_sine.cpp