Signal.hpp

Go to the documentation of this file.

 
#ifndef ECHOMAP_SIGNAL_HPP
#define ECHOMAP_SIGNAL_HPP
 
#include <cstdint>
#include <filesystem>
#include <ranges>
#include <vector>
 
#include "Object.hpp"
 
namespace echomap
{

class Signal : public Object<Signal>
{
public:
    struct Sample
    {
        using TimeT = float;      
        using AmplitudeT = float; 
 
        TimeT time;               
        AmplitudeT amplitude;     
    };
 
private:
    std::vector<Sample::AmplitudeT> samples; 
 
public:
    struct Source
    {
        std::filesystem::path path; 
        std::size_t channel;        
        bool dirty = false;         
        bool is_loaded = false;     
 
        [[nodiscard]] bool operator<(const Source& other) const;
    };

    static constexpr std::pair<Sample::AmplitudeT, Sample::AmplitudeT> normalised_range = {-1.0f, 1.0f};

    [[nodiscard]] std::uint64_t get_sample_count() const noexcept;

    [[nodiscard]] const std::optional<Source>& observe_source() const noexcept;
 
    [[nodiscard]] Sample::TimeT get_time_offset() const noexcept;
    [[nodiscard]] std::size_t get_sample_rate() const noexcept;
 
    [[nodiscard]] decltype(samples)::const_iterator begin() const;
    [[nodiscard]] decltype(samples)::const_iterator end() const;
    [[nodiscard]] decltype(samples)::const_iterator cbegin() const noexcept;
    [[nodiscard]] decltype(samples)::const_iterator cend() const noexcept;
 
    [[nodiscard]] auto timed_samples() const
    {
        return std::views::iota(std::size_t{0}, samples.size()) |
               std::views::transform([this](const std::size_t index) -> Sample {
                   return {.time = get_time_at_index(index), .amplitude = samples[index]};
               });
    }
 
    [[nodiscard]] Sample::AmplitudeT operator[](std::size_t index) const noexcept;
    [[nodiscard]] std::span<const Sample::AmplitudeT> amplitudes() const noexcept;
 
    [[nodiscard]] bool is_uniformly_sampled() const noexcept;

    [[nodiscard]] Sample::TimeT get_time_at_index(std::size_t index) const noexcept;
 
    Signal(const Signal& old_signal);
    Signal(const Signal& old_signal,
           std::string_view new_name);
 
private:
    struct Baseline
    {
        Sample::TimeT time_offset = 0.0f; 
        std::size_t sample_rate = 0;      
        float sample_rate_r = 0.0f;       
    };
 
    friend class SignalFactory;

    explicit Signal(
            std::string_view name = {},
            const std::optional<Source>& source = {}
    );

    void emplace_sample(Sample::AmplitudeT amplitude);

    void emplace_sample(
            Sample::TimeT time,
            Sample::AmplitudeT amplitude
    );

    void emplace_sample(const Sample& sample);

    void emplace_sample_from_source(Sample::AmplitudeT amplitude);

    void emplace_sample_from_source(
            Sample::TimeT time,
            Sample::AmplitudeT amplitude
    );

    void emplace_sample_from_source(const Sample& sample);

    void reserve_samples(std::size_t count);
 
    void set_source(
            const std::filesystem::path& path,
            std::size_t channel
    );
 
    void set_time_offset(Sample::TimeT new_time_offset) noexcept;
    void set_sample_rate(std::size_t new_sample_rate) noexcept;

    void emplace_time(Sample::TimeT given_time);
 
    Baseline timing_baseline;        
    std::optional<Source> fs_source; 

    std::optional<std::vector<Sample::TimeT>> time_offsets;
};
 
template <> constexpr std::string_view Object<Signal>::class_name = "Signal";
 
} // namespace echomap
 
#endif // ECHOMAP_SIGNAL_HPP