echomap::SignalDFTPanel Class Reference

Provides an IPanel to display and interact with previews of Signal frequency spectra (i.e., Signal DFTs). More...

#include <SignalDFTPanel.hpp>

Inheritance diagram for echomap::SignalDFTPanel:

Classes
struct	CallbackData
struct	CacheKey
	A three-way key into the FrequencySpectrum cache. More...
struct	CacheValue
	A keyed value within the FrequencySpectrum cache, either denoting a pending, failed, or present DFT. More...
struct	CacheKeyHash
	The hash functor for CacheKey. More...

Public Member Functions
	SignalDFTPanel (Worker *parent_worker, WorkerResultDespatcher &despatcher, EchoMap *app, const Project *initial_project=nullptr)
	Create a new SignalDFTPanel to display DFTs of Signal waveforms in the frequency domain.
	SignalDFTPanel (const SignalDFTPanel &)=delete
SignalDFTPanel &	operator= (const SignalDFTPanel &)=delete
	SignalDFTPanel (SignalDFTPanel &&) noexcept
SignalDFTPanel &	operator= (SignalDFTPanel &&) noexcept=delete
void	draw () noexcept override
	Draw the panel to the active rendering context.
const char *	get_imgui_name () const noexcept override
	Retrieves the name of the IPanel for Dear ImGui API functions.
void	change_active_project (const Project *new_project) override
	Updates the active Project being described by the IPanel.
Public Member Functions inherited from echomap::IPanel
virtual void	update_gpu (const wgpu::CommandEncoder &command_encoder)
	Delegate work to the GPU via the WebGPU platform.

Static Public Member Functions
static const char *	get_imgui_stable_name () noexcept

Private Member Functions
void	handle_completed_dft (DFTResult &&result)
void	draw_configuration_section () noexcept
void	draw_configuration_window_function () noexcept
void	draw_configuration_transform_size () noexcept
void	draw_configuration_scale_type () noexcept
void	draw_configuration_preview_actions () noexcept
void	draw_preview_section () noexcept
void	draw_preview_of_signal (std::shared_ptr< Signal > signal) noexcept
void	reset_available_transform_sizes ()
void	update_spectrum_bounds (const FrequencySpectrum &spectrum) noexcept
void	update_spectrum_bounds () noexcept
void	update_available_sizes (std::uint64_t maximum_sample_count)
void	reset_viewport_bounds () noexcept
const FrequencySpectrum *	get_spectra (std::shared_ptr< Signal > signal, WindowFunctions::AllFunctions window_function, std::size_t transform_size)

Static Private Member Functions
static ImPlotPoint	get_indexed_frequency_bin (int index, void *user_data) noexcept

Private Attributes
ImPlotRect	spectrum_bounds
	The minimal bounding box required to fully contain the DFT spectrum plot.
ImPlotRect	viewport_bounds
	The user-controlled bounding box of the DFT plots.
std::string	panel_name
ImPlotSpec	plotting_spec_2d
Worker *	parent_worker
const Project *	active_project = nullptr
EchoMap *	app
std::unordered_map< CacheKey, CacheValue, CacheKeyHash >	spectra_cache
	Cached DFT spectra.
bool	use_log_scale = false
	Should the DFT be plotted with a linear or base-10 logarithmic freq.
std::vector< std::string >	available_sizes
	Strings of all available transform sizes.
unsigned int	selected_size_log = default_size_log
	Base-2 log of selected transform size.
WindowFunctions::AllFunctions	selected_window = WindowFunctions::Constant{}
std::vector< sigc::scoped_connection >	connections

Static Private Attributes
static constexpr unsigned int	default_size_log = 7
	Base-2 log of the minimum transform size.

Additional Inherited Members
Static Protected Attributes inherited from echomap::IPanel
static constexpr ImVec2	button_size {80.0f, 20.0f}
static constexpr auto	table_flags

Detailed Description

Provides an IPanel to display and interact with previews of Signal frequency spectra (i.e., Signal DFTs).

Definition at line 34 of file SignalDFTPanel.hpp.

Constructor & Destructor Documentation

SignalDFTPanel()

echomap::SignalDFTPanel::SignalDFTPanel ( Worker * parent_worker, WorkerResultDespatcher & despatcher, EchoMap * app, const Project * initial_project = nullptr )

explicit

Create a new SignalDFTPanel to display DFTs of Signal waveforms in the frequency domain.

The SignalDFTPanel consumes the DFTResult message.

Parameters

parent_worker	The Worker to receive ITask commands over the command bus.
despatcher	The despatcher to expose the result buses.
app	The parent application instance.
initial_project	An optional initial Project for the IPanel to display.

Definition at line 37 of file SignalDFTPanel.cpp.

  :
    panel_name(std::string("Signal DFT Panel") + get_imgui_stable_name()),
    parent_worker(parent_worker),
    active_project(initial_project),
    app(app)
{
    connections.emplace_back(despatcher.dft_finished_channel.nominate_consumer(
            sigc::mem_fun(*this, &SignalDFTPanel::handle_completed_dft)
    ));
 
    reset_available_transform_sizes();
}

Member Function Documentation

change_active_project()

void echomap::SignalDFTPanel::change_active_project ( const Project * new_project )

overridevirtual

Updates the active Project being described by the IPanel.

Parameters

new_project

An observing pointer to the new active Project.

Implements echomap::IProjectPanel.

Definition at line 90 of file SignalDFTPanel.cpp.

{
    active_project = new_project;
    spectra_cache.clear();
    reset_available_transform_sizes();
    update_spectrum_bounds();
    reset_viewport_bounds();
}

draw()

void echomap::SignalDFTPanel::draw ( )

overridevirtualnoexcept

Draw the panel to the active rendering context.

Implements echomap::IPanel.

Definition at line 59 of file SignalDFTPanel.cpp.

{
    if (ImGui::Begin(panel_name.c_str())) {
        if (active_project == nullptr)
            ImGui::Text("No project is loaded.");
        else {
            bool drawn_any = false;
            std::uint64_t max_sample_count = 0;
 
            for (const auto& signal : active_project->observe_signals()) {
                max_sample_count = std::max(max_sample_count, signal.get_sample_count());
                drawn_any = true;
            }
 
            if (drawn_any) {
                update_available_sizes(max_sample_count);
                draw_configuration_section();
                draw_preview_section();
            } else
                ImGui::Text("No signals are available.");
        }
    }
 
    ImGui::End();
}

draw_configuration_preview_actions()

void echomap::SignalDFTPanel::draw_configuration_preview_actions ( )

privatenoexcept

Definition at line 268 of file SignalDFTPanel.cpp.

{
    ImGui::TextUnformatted("Preview Actions");
    ImGui::TableNextColumn();
 
    if (ImGui::Button("Reset Viewports##DFTOptionsResetViewport"))
        reset_viewport_bounds();
    ImGui::SameLine();
    if (ImGui::Button("Reset Cached DFTs##DFTOptionsResetCache")) {
        spectra_cache.clear();
        update_spectrum_bounds();
        reset_viewport_bounds();
        app->increment_forced_frames();
    }
}

draw_configuration_scale_type()

void echomap::SignalDFTPanel::draw_configuration_scale_type ( )

privatenoexcept

Definition at line 257 of file SignalDFTPanel.cpp.

{
    ImGui::TextUnformatted("Logarithmic Frequency Scale");
    ImGui::TableNextColumn();
 
    if (ImGui::Checkbox("##DFTOptionsLogScale", &use_log_scale)) {
        update_spectrum_bounds();
        reset_viewport_bounds();
    }
}

draw_configuration_section()

void echomap::SignalDFTPanel::draw_configuration_section ( )

privatenoexcept

Definition at line 158 of file SignalDFTPanel.cpp.

{
    ImGui::SeparatorText("DFT Configuration");
 
    if (ImGui::BeginTable("##DFTOptionsTable", 2, table_flags)) {
        ImGui::TableSetupColumn("##DFTOptionsTableLabel", ImGuiTableColumnFlags_WidthFixed);
        ImGui::TableSetupColumn("##DFTOptionsTableControl", ImGuiTableColumnFlags_WidthStretch);
 
        ImGui::TableNextRow();
        ImGui::TableNextColumn();
        draw_configuration_window_function();
 
        ImGui::TableNextRow();
        ImGui::TableNextColumn();
        draw_configuration_transform_size();
 
        ImGui::TableNextRow();
        ImGui::TableNextColumn();
        draw_configuration_scale_type();
 
        ImGui::TableNextRow();
        ImGui::TableNextColumn();
        draw_configuration_preview_actions();
 
        ImGui::EndTable();
    }
}

draw_configuration_transform_size()

void echomap::SignalDFTPanel::draw_configuration_transform_size ( )

privatenoexcept

Definition at line 229 of file SignalDFTPanel.cpp.

{
    ImGui::TextUnformatted("Transform Size");
    ImGui::TableNextColumn();
 
    ImGui::SetNextItemWidth(-std::numeric_limits<float>::min());
 
    if (ImGui::BeginCombo("##DFTOptionsTransformSize", available_sizes[selected_size_log - default_size_log].c_str())) {
        for (unsigned int item_idx = 0; item_idx < available_sizes.size(); ++item_idx) {
            const auto is_selected = item_idx == selected_size_log - default_size_log;
            if (ImGui::Selectable(available_sizes[item_idx].c_str(), is_selected) &&
                selected_size_log != item_idx + default_size_log) {
 
                // The selected size has changed.
                selected_size_log = item_idx + default_size_log;
                update_spectrum_bounds();
                reset_viewport_bounds();
            }
 
            if (is_selected)
                ImGui::SetItemDefaultFocus();
        }
 
        ImGui::EndCombo();
        app->increment_forced_frames();
    }
}

draw_configuration_window_function()

void echomap::SignalDFTPanel::draw_configuration_window_function ( )

privatenoexcept

Definition at line 186 of file SignalDFTPanel.cpp.

{
    ImGui::TextUnformatted("Input Window Function");
    ImGui::TableNextColumn();
 
    ImGui::SetNextItemWidth(-std::numeric_limits<float>::min());
 
    if (auto selected_idx = selected_window.index();
        /*
         * Disabled string_view::data warnings: we know that the views were constructed from string literals, hence
         * NULL-terminated. Dear ImGui provides no API for specifying the lengths of the expected data, so we can rely
         * on the termination here.
         */
 
        // NOLINTNEXTLINE(*-suspicious-stringview-data-usage)
        ImGui::BeginCombo("##DFTOptionsWindowFunction", window_function_names[selected_idx].data())) {
        for (std::size_t item_idx = 0; item_idx < window_function_names.size(); ++item_idx) {
            const auto is_selected = item_idx == selected_idx;
 
            // NOLINTNEXTLINE(*-suspicious-stringview-data-usage)
            if (ImGui::Selectable(window_function_names[item_idx].data(), is_selected) && selected_idx != item_idx) {
                selected_idx = item_idx;
 
                try {
                    selected_window = variant_helpers::variant_from_index<WindowFunctions::AllFunctions>(selected_idx);
                } catch (const std::out_of_range&) {
                    LOG_WARN("Invalid window function index was selected. Resetting to the default.");
                    selected_window = WindowFunctions::Constant{};
                }
 
                update_spectrum_bounds();
                reset_viewport_bounds();
            }
 
            if (is_selected)
                ImGui::SetItemDefaultFocus();
        }
 
        ImGui::EndCombo();
        app->increment_forced_frames();
    }
}

draw_preview_of_signal()

void echomap::SignalDFTPanel::draw_preview_of_signal ( std::shared_ptr< Signal > signal )

privatenoexcept

Definition at line 302 of file SignalDFTPanel.cpp.

{
    const auto* const name = signal->get_imgui_name();
    if (const auto* const spectrum =
                get_spectra(std::move(signal), selected_window, std::size_t{1} << selected_size_log);
        spectrum != nullptr) {
 
        // Case 1: we got a spectrum immediately.
        if (ImPlot::BeginPlot(spectrum->get_imgui_name())) {
            ImPlot::SetupAxes("Frequency (Hz)", "Magnitude (dBfs)");
            ImPlot::SetupAxisScale(ImAxis_X1, use_log_scale ? ImPlotScale_Log10 : ImPlotScale_Linear);
            ImPlot::SetupAxisLinks(ImAxis_X1, &viewport_bounds.X.Min, &viewport_bounds.X.Max);
            ImPlot::SetupAxisLinks(ImAxis_Y1, &viewport_bounds.Y.Min, &viewport_bounds.Y.Max);
 
            int plottable_bin_count = static_cast<int>(spectrum->get_bin_count());
            CallbackData callback_data = {.spectrum = spectrum, .index_offset = 0};
 
            if (plottable_bin_count > 0 && use_log_scale) {
                // If we're plotting on the log scale, discount the DC component if it exists.
                --plottable_bin_count;
                callback_data.index_offset = 1;
            }
 
            ImPlot::PlotLineG(
                    "",
                    &SignalDFTPanel::get_indexed_frequency_bin,
                    &callback_data,
                    plottable_bin_count,
                    plotting_spec_2d
            );
 
            ImPlot::EndPlot();
        }
 
    } else
        // Case 2: we didn't get one immediately. Either it's pending, or it failed.
        // TODO: indicate failure here as well as loading.
        ImGui::Text(
                "Loading DFT of %s with the %s window function...",
                name,
                // NOLINTNEXTLINE(*-suspicious-stringview-data-usage)
                window_function_names[selected_window.index()].data()
        );
}

draw_preview_section()

void echomap::SignalDFTPanel::draw_preview_section ( )

privatenoexcept

Definition at line 284 of file SignalDFTPanel.cpp.

{
    ImGui::SeparatorText("DFT Previews");
 
    if (ImPlot::BeginAlignedPlots("##DFTAlignedGroup")) {
        ImPlot::PushStyleColor(ImPlotCol_FrameBg, ImVec4(0.0f, 0.0f, 0.0f, 0.0f));
 
        for (const auto& signal :
             active_project->share_signals() | std::views::filter([](const std::shared_ptr<Signal>& candidate) {
                 return candidate->is_uniformly_sampled();
             }))
            draw_preview_of_signal(signal);
 
        ImPlot::EndAlignedPlots();
        ImPlot::PopStyleColor();
    }
}

get_imgui_name()

const char * echomap::SignalDFTPanel::get_imgui_name ( ) const

nodiscardoverridevirtualnoexcept

Retrieves the name of the IPanel for Dear ImGui API functions.

Returns

The human-readable name of the window as a NULL-terminated C string.

Implements echomap::IPanel.

Definition at line 85 of file SignalDFTPanel.cpp.

{
    return panel_name.c_str();
}

get_imgui_stable_name()

const char * echomap::SignalDFTPanel::get_imgui_stable_name ( )

staticnoexcept

Definition at line 101 of file SignalDFTPanel.cpp.

{
    return "###SignalDFTPanel";
}

get_indexed_frequency_bin()

ImPlotPoint echomap::SignalDFTPanel::get_indexed_frequency_bin ( int index, void * user_data )

staticprivatenoexcept

Definition at line 148 of file SignalDFTPanel.cpp.

{
    const auto* const info = static_cast<CallbackData*>(user_data);
    index += info->index_offset;
    return {info->spectrum->cbegin()[index].frequency, info->spectrum->cbegin()[index].magnitude};
}

get_spectra()

const FrequencySpectrum * echomap::SignalDFTPanel::get_spectra ( std::shared_ptr< Signal > signal, WindowFunctions::AllFunctions window_function, std::size_t transform_size )

private

Definition at line 448 of file SignalDFTPanel.cpp.

{
    assert(signal != nullptr);
 
    const CacheKey key{
            .source_id = signal->get_id(),
            .window_function = window_function,
            .transform_size = transform_size,
    };
 
    auto& entry = spectra_cache[key];
    if (entry.spectrum != nullptr)
        return entry.spectrum.get();
 
    if (entry.status != CacheValue::State::Pending) {
        entry.status = CacheValue::State::Pending;
        parent_worker->submit(std::make_unique<DFTTask>(std::move(signal), window_function, transform_size));
    }
 
    return nullptr;
}

handle_completed_dft()

void echomap::SignalDFTPanel::handle_completed_dft ( DFTResult && result )

private

Definition at line 106 of file SignalDFTPanel.cpp.

{
    auto spectrum = std::move(result).take_spectrum();
 
    if (spectrum == nullptr) {
        LOG_WARN("Dropping a null DFT result.");
        return;
    }
 
    const CacheKey key{
        .source_id = result.get_source_id(),
            .window_function = spectrum->observe_preprocessor(),
            .transform_size = result.get_transform_size(),
    };
 
    const auto cache_slot_it = spectra_cache.find(key);
    if (cache_slot_it == spectra_cache.end()) {
        LOG_F_WARN("Dropping an unexpected result for the DFT of Signal {}.", spectrum->get_name());
        return;
    }
 
    cache_slot_it->second.status = CacheValue::State::Success;
    cache_slot_it->second.spectrum = std::move(spectrum);
 
    const bool result_is_currently_visible = key.window_function.index() == selected_window.index() &&
                                             key.transform_size == (std::size_t{1} << selected_size_log);
 
    if (result_is_currently_visible) {
        const auto had_no_visible_spectrum =
                spectrum_bounds.X.Min > spectrum_bounds.X.Max || spectrum_bounds.Y.Min > spectrum_bounds.Y.Max;
 
        update_spectrum_bounds(*cache_slot_it->second.spectrum);
 
        if (had_no_visible_spectrum)
            reset_viewport_bounds();
 
        app->increment_forced_frames();
    }
}

reset_available_transform_sizes()

void echomap::SignalDFTPanel::reset_available_transform_sizes ( )

private

Definition at line 349 of file SignalDFTPanel.cpp.

{
    // TODO: what if we have signals, but they all have less than 128 samples?
 
    available_sizes.clear();
    available_sizes.push_back(std::to_string(std::size_t{1} << default_size_log));
    selected_size_log = default_size_log;
}

reset_viewport_bounds()

void echomap::SignalDFTPanel::reset_viewport_bounds ( )

privatenoexcept

Definition at line 430 of file SignalDFTPanel.cpp.

{
    viewport_bounds = spectrum_bounds;
 
    if (use_log_scale && viewport_bounds.X.Min <= 0.0)
        viewport_bounds.X.Min = 1.0;
 
    if (viewport_bounds.X.Min >= viewport_bounds.X.Max) {
        viewport_bounds.X.Min = use_log_scale ? 1.0 : 0.0;
        viewport_bounds.X.Max = 1.0;
    }
 
    if (viewport_bounds.Y.Min >= viewport_bounds.Y.Max) {
        viewport_bounds.Y.Min = 0.0;
        viewport_bounds.Y.Max = 1.0;
    }
}

update_available_sizes()

void echomap::SignalDFTPanel::update_available_sizes ( std::uint64_t maximum_sample_count )

private

Definition at line 399 of file SignalDFTPanel.cpp.

{
    if (available_sizes.empty())
        reset_available_transform_sizes();
 
    if (maximum_sample_count > std::uint64_t{1} << (available_sizes.size() + default_size_log - 1)) {
        /*
         * If the maximum sample count can support a large transform size than currently advertised, re-create the list.
         * (Yes, we could be smarter here and just append the tail.)
         */
        constexpr std::uint64_t minimum_transform_size = std::uint64_t{1} << default_size_log;
        const std::size_t maximum_transform_size =
                std::max(minimum_transform_size, std::bit_floor(maximum_sample_count));
 
        available_sizes.clear();
        for (std::uint64_t size = minimum_transform_size; size <= maximum_transform_size; size <<= std::uint64_t{1}) {
            available_sizes.push_back(std::to_string(size));
            if (size > std::numeric_limits<std::uint64_t>::max() / 2)
                break;
        }
    }
 
    // Once we know the correct maximum transform size, bound the selection to the maximum available.
    if (selected_size_log >= available_sizes.size() + default_size_log) {
        selected_size_log =
                static_cast<unsigned int>(available_sizes.size() + default_size_log - 1);
    }
}

update_spectrum_bounds() [1/2]

void echomap::SignalDFTPanel::update_spectrum_bounds ( )

privatenoexcept

Definition at line 384 of file SignalDFTPanel.cpp.

{
    spectrum_bounds.X.Min = std::numeric_limits<double>::max();
    spectrum_bounds.X.Max = std::numeric_limits<double>::lowest();
    spectrum_bounds.Y.Min = std::numeric_limits<double>::max();
    spectrum_bounds.Y.Max = std::numeric_limits<double>::lowest();
 
    const auto selected_transform_size = std::size_t{1} << selected_size_log;
 
    for (const auto& [key, value] : spectra_cache)
        if (value.spectrum != nullptr && key.window_function.index() == selected_window.index() &&
            key.transform_size == selected_transform_size)
            update_spectrum_bounds(*value.spectrum);
}

update_spectrum_bounds() [2/2]

void echomap::SignalDFTPanel::update_spectrum_bounds ( const FrequencySpectrum & spectrum )

privatenoexcept

Definition at line 358 of file SignalDFTPanel.cpp.

{
    using BoundType = decltype(spectrum_bounds.X.Min);
 
    const auto bin_count = static_cast<std::ptrdiff_t>(spectrum.get_bin_count());
    if (bin_count == 0)
        return;
 
    const ptrdiff_t first_bin_idx = use_log_scale && bin_count > 1 ? 1 : 0;
    if (first_bin_idx >= bin_count)
        return;
 
    spectrum_bounds.X.Min =
            std::min(static_cast<BoundType>(spectrum.cbegin()[first_bin_idx].frequency), spectrum_bounds.X.Min);
    spectrum_bounds.X.Max =
            std::max(static_cast<BoundType>(spectrum.cbegin()[bin_count - 1].frequency), spectrum_bounds.X.Max);
 
    for (auto bin_idx = first_bin_idx; bin_idx < bin_count; ++bin_idx) {
        const auto magnitude = static_cast<BoundType>(spectrum.cbegin()[bin_idx].magnitude);
        spectrum_bounds.Y.Min = std::min(magnitude, spectrum_bounds.Y.Min);
        spectrum_bounds.Y.Max = std::max(magnitude, spectrum_bounds.Y.Max);
    }
}

Member Data Documentation

active_project

const Project* echomap::SignalDFTPanel::active_project = nullptr

private

Definition at line 120 of file SignalDFTPanel.hpp.

app

EchoMap* echomap::SignalDFTPanel::app

private

Definition at line 121 of file SignalDFTPanel.hpp.

available_sizes

std::vector<std::string> echomap::SignalDFTPanel::available_sizes

private

Strings of all available transform sizes.

Definition at line 168 of file SignalDFTPanel.hpp.

connections

std::vector<sigc::scoped_connection> echomap::SignalDFTPanel::connections

private

Definition at line 174 of file SignalDFTPanel.hpp.

default_size_log

unsigned int echomap::SignalDFTPanel::default_size_log = 7

staticconstexprprivate

Base-2 log of the minimum transform size.

Definition at line 167 of file SignalDFTPanel.hpp.

panel_name

std::string echomap::SignalDFTPanel::panel_name

private

Definition at line 117 of file SignalDFTPanel.hpp.

parent_worker

Worker* echomap::SignalDFTPanel::parent_worker

private

Definition at line 119 of file SignalDFTPanel.hpp.

plotting_spec_2d

ImPlotSpec echomap::SignalDFTPanel::plotting_spec_2d

private

Definition at line 118 of file SignalDFTPanel.hpp.

selected_size_log

unsigned int echomap::SignalDFTPanel::selected_size_log = default_size_log

private

Base-2 log of selected transform size.

Definition at line 169 of file SignalDFTPanel.hpp.

selected_window

WindowFunctions::AllFunctions echomap::SignalDFTPanel::selected_window = WindowFunctions::Constant{}

private

Definition at line 172 of file SignalDFTPanel.hpp.

{};

spectra_cache

std::unordered_map<CacheKey, CacheValue, CacheKeyHash> echomap::SignalDFTPanel::spectra_cache

private

Cached DFT spectra.

Definition at line 165 of file SignalDFTPanel.hpp.

spectrum_bounds

ImPlotRect echomap::SignalDFTPanel::spectrum_bounds

private

Initial value:

{
            std::numeric_limits<double>::max(),
            std::numeric_limits<double>::lowest(),
            std::numeric_limits<double>::max(),
            std::numeric_limits<double>::lowest(),
    }

The minimal bounding box required to fully contain the DFT spectrum plot.

Definition at line 108 of file SignalDFTPanel.hpp.

                              {
            std::numeric_limits<double>::max(),
            std::numeric_limits<double>::lowest(),
            std::numeric_limits<double>::max(),
            std::numeric_limits<double>::lowest(),
    };

use_log_scale

bool echomap::SignalDFTPanel::use_log_scale = false

private

Should the DFT be plotted with a linear or base-10 logarithmic freq.

axis?

Definition at line 166 of file SignalDFTPanel.hpp.

viewport_bounds

ImPlotRect echomap::SignalDFTPanel::viewport_bounds

private

The user-controlled bounding box of the DFT plots.

Definition at line 115 of file SignalDFTPanel.hpp.

---

The documentation for this class was generated from the following files:

• src/panels/SignalDFTPanel.hpp
• src/panels/SignalDFTPanel.cpp