SignalDFTPanel.hpp

Go to the documentation of this file.

 
#ifndef ECHOMAP_SIGNALDFTPANEL_HPP
#define ECHOMAP_SIGNALDFTPANEL_HPP
 
#include <sigc++/scoped_connection.h>
 
#include <string>
 
#include "../objects/IDAllocator.hpp"
#include "../objects/factories/WindowFunctions.hpp"
#include "IProjectPanel.hpp"
 
namespace echomap
{
 
class Signal;
class FrequencySpectrum;
class WorkerResultDespatcher;
class DFTResult;
class EchoMap;
class Worker;

class SignalDFTPanel final : public IProjectPanel
{
public:
    explicit SignalDFTPanel(
            Worker* parent_worker,
            WorkerResultDespatcher& despatcher,
            EchoMap* app,
            const Project* initial_project = nullptr
    );
 
    ~SignalDFTPanel() noexcept override;
 
    SignalDFTPanel(const SignalDFTPanel&) = delete;
    SignalDFTPanel& operator=(const SignalDFTPanel&) = delete;
 
    SignalDFTPanel(SignalDFTPanel&&) noexcept;
    SignalDFTPanel& operator=(SignalDFTPanel&&) noexcept = delete;
 
    void draw() noexcept override;
 
    [[nodiscard]] const char* get_imgui_name() const noexcept override;
 
    void change_active_project(const Project* new_project) override;
 
    static const char* get_imgui_stable_name() noexcept;
 
private:
    struct CallbackData
    {
        const FrequencySpectrum* spectrum;
        int index_offset;
    };
 
    static ImPlotPoint get_indexed_frequency_bin(
            int index,
            void* user_data
    ) noexcept;
 
    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
    );

    ImPlotRect spectrum_bounds{
            std::numeric_limits<double>::max(),
            std::numeric_limits<double>::lowest(),
            std::numeric_limits<double>::max(),
            std::numeric_limits<double>::lowest(),
    };
 
    ImPlotRect viewport_bounds; 
 
    std::string panel_name;
    ImPlotSpec plotting_spec_2d;
    Worker* parent_worker;
    const Project* active_project = nullptr;
    EchoMap* app;

    struct CacheKey
    {
        id_type source_id;
        WindowFunctions::AllFunctions window_function;
        std::size_t transform_size;
 
        bool operator==(const CacheKey& key) const;
    };

    struct CacheValue
    {
        enum class State : std::uint8_t
        {
            NotRequested,
            Success,
            Pending,
            Failed,
        } status{State::NotRequested};
 
        std::unique_ptr<FrequencySpectrum> spectrum;
    };

    struct CacheKeyHash
    {
        [[nodiscard]] std::size_t operator()(const CacheKey& key) const noexcept;
 
    private:
        static std::size_t combine(
                std::size_t seed,
                std::size_t value
        ) noexcept;
    };
 
    std::unordered_map<CacheKey, CacheValue, CacheKeyHash> spectra_cache; 
    bool use_log_scale = false; 
    static constexpr unsigned int default_size_log = 7; 
    std::vector<std::string> available_sizes;           
    unsigned int selected_size_log = default_size_log;  
 
 
    WindowFunctions::AllFunctions selected_window = WindowFunctions::Constant{};
 
    std::vector<sigc::scoped_connection> connections;
};
 
} // namespace echomap
 
#endif // ECHOMAP_SIGNALDFTPANEL_HPP