modal_spec.hpp

Go to the documentation of this file.

#pragma once

 
#include <pulp/signal/modal_bank.hpp>
 
#include <algorithm>
#include <cmath>
#include <cstddef>
#include <optional>
#include <string>
#include <string_view>
#include <vector>
 
namespace pulp::signal {

inline constexpr int kModalSpecSchemaVersion = 1;

struct ModalSpecExcitation {
    double contact_s = 0.001;  
    double velocity = 1.0;     
};

struct ModalShapeMap {
    int grid_points = 0;
    std::vector<float> weights;
 
    bool empty() const { return grid_points <= 0 || weights.empty(); }

    float weight_at(int mode, float position) const {
        if (empty()) return 1.0f;
        const int last = grid_points - 1;
        const std::size_t base = static_cast<std::size_t>(mode) *
                                 static_cast<std::size_t>(grid_points);
        if (base + static_cast<std::size_t>(grid_points) > weights.size()) return 1.0f;
        if (last == 0) return weights[base];
        const float x = std::clamp(position, 0.0f, 1.0f) * static_cast<float>(last);
        const int i0 = std::min(static_cast<int>(x), last - 1);
        const float frac = x - static_cast<float>(i0);
        const float w0 = weights[base + static_cast<std::size_t>(i0)];
        const float w1 = weights[base + static_cast<std::size_t>(i0) + 1];
        return w0 + (w1 - w0) * frac;
    }
};

struct ModalSpecTolerances {
    double freq_cents = 10.0;
    double t60_rel = 0.08;
    double gain_rel = 0.10;
    double verify_seconds = 2.0;
};

struct ModalSpec {
    int schema_version = kModalSpecSchemaVersion;
    std::string name;
    std::string description;
    std::vector<ModalMode> modes;
    ModalSpecExcitation excitation;
    ModalShapeMap strike_map;
    ModalShapeMap pickup_map;
    ModalSpecTolerances tolerances;

    int contact_samples(double sample_rate) const {
        const double n = excitation.contact_s * sample_rate;
        return n <= 0.0 ? 0 : static_cast<int>(n + 0.5);
    }
};

inline void resolve_modes(const ModalSpec& spec, float strike_position,
                          float pickup_position, std::vector<ModalMode>& out) {
    out.resize(spec.modes.size());
    for (std::size_t m = 0; m < spec.modes.size(); ++m) {
        ModalMode mode = spec.modes[m];
        const int mi = static_cast<int>(m);
        mode.gain *= spec.strike_map.weight_at(mi, strike_position) *
                     spec.pickup_map.weight_at(mi, pickup_position);
        out[m] = mode;
    }
}

inline std::vector<ModalMode> resolve_modes(const ModalSpec& spec,
                                            float strike_position = 0.5f,
                                            float pickup_position = 0.5f) {
    std::vector<ModalMode> out;
    resolve_modes(spec, strike_position, pickup_position, out);
    return out;
}

template <typename SampleType>
void load_modes(const ModalSpec& spec, ModalBankT<SampleType>& bank,
                std::vector<ModalMode>& scratch, float strike_position = 0.5f,
                float pickup_position = 0.5f) {
    resolve_modes(spec, strike_position, pickup_position, scratch);
    bank.set_modes(scratch);
}

template <typename SampleType>
void prepare_and_load(const ModalSpec& spec, ModalBankT<SampleType>& bank,
                      double sample_rate, float strike_position = 0.5f,
                      float pickup_position = 0.5f) {
    bank.prepare(sample_rate, static_cast<int>(spec.modes.size()));
    std::vector<ModalMode> scratch;
    load_modes(spec, bank, scratch, strike_position, pickup_position);
}

bool validate_modal_spec(const ModalSpec& spec, std::string& error);

struct ModalSpecDiagnostics {
    std::string error;
    std::vector<std::string> unknown_fields;
};

std::optional<ModalSpec> parse_modal_spec(std::string_view json,
                                          ModalSpecDiagnostics* diagnostics = nullptr);

std::string to_json(const ModalSpec& spec, bool pretty = true);

bool operator==(const ModalSpec& a, const ModalSpec& b);
inline bool operator!=(const ModalSpec& a, const ModalSpec& b) { return !(a == b); }
 
} // namespace pulp::signal