threshold_detector.hpp

#pragma once
 
#include "synapse-app-sdk/dsp/spike/base_spike_detector.hpp"
#include <deque>
#include <memory>
 
namespace synapse {

class ThresholdDetector {
public:
  struct Config {
    float threshold; // Voltage threshold for spike detection (absolute value)
    uint32_t waveform_size; // Total number of samples in the waveform
                            // (threshold in middle)
    uint64_t
        refractory_period; // Minimum time between spikes (in timestamp units)
    float sample_rate_hz;  // Sample rate used for timestamp calculations
  };
 
  explicit ThresholdDetector(const Config &config)
      : config_(config), buffer_(config.waveform_size), last_spike_time_(0),
        collecting_spike_(false), samples_after_threshold_(0),
        pending_spike_(nullptr),
        sample_period_ns_(static_cast<uint64_t>(1e9 / config.sample_rate_hz)),
        sample_count_(0) {}
 
  void setup(const Config &config) {
    config_ = config;
    buffer_.resize(config.waveform_size);
    sample_period_ns_ = static_cast<uint64_t>(1e9 / config.sample_rate_hz);
    reset();
  }
 
  SpikeEvent *detect(const float sample, const uint64_t frame_timestamp,
                     const uint32_t channel_id) {
    // Calculate a timestamp for this specific sample based on sample count and
    // rate This ensures precise timing even within frames
    uint64_t sample_timestamp =
        frame_timestamp + (sample_count_ * sample_period_ns_);
    sample_count_++;
 
    // Store sample and timestamp in circular buffer
    buffer_.push_back({sample, sample_timestamp});
 
    // Check if we're collecting post-threshold samples for a spike
    if (collecting_spike_) {
      samples_after_threshold_++;
 
      // If we've collected enough post-threshold samples, return the spike
      const uint32_t samples_after_needed = config_.waveform_size / 2;
      if (samples_after_threshold_ >= samples_after_needed) {
        collecting_spike_ = false;
 
        // Fill the spike waveform from the buffer
        pending_spike_->waveform.reserve(buffer_.size());
        for (const auto &sample_data : buffer_) {
          pending_spike_->waveform.push_back(sample_data.value);
        }
 
        SpikeEvent *event = pending_spike_;
        pending_spike_ = nullptr;
        return event;
      }
 
      return nullptr;
    }
 
    // Check for threshold crossing (negative polarity only)
    const bool threshold_crossed = sample <= -std::abs(config_.threshold);
 
    // Check if we've crossed threshold and are outside refractory period
    if (threshold_crossed &&
        (sample_timestamp - last_spike_time_ >= config_.refractory_period)) {
      last_spike_time_ = sample_timestamp;
      collecting_spike_ = true;
      samples_after_threshold_ = 0;
 
      // Create new spike event
      pending_spike_ = new SpikeEvent();
 
      // The timestamp is the current sample's threshold crossing time
      pending_spike_->timestamp = sample_timestamp;
      pending_spike_->channel_id = channel_id;
      pending_spike_->waveform.reserve(buffer_.size());
 
      return nullptr;
    }
 
    return nullptr;
  }
 
  void reset() {
    buffer_.clear();
    for (size_t i = 0; i < buffer_.size(); i++) {
      buffer_.push_back({0.0f, 0}); // Initialize with zeros
    }
 
    collecting_spike_ = false;
    samples_after_threshold_ = 0;
    last_spike_time_ = 0;
    sample_count_ = 0;
 
    if (pending_spike_) {
      delete pending_spike_;
      pending_spike_ = nullptr;
    }
  }
 
private:
  // Structure to store sample value and its timestamp
  struct SampleData {
    float value;
    uint64_t timestamp;
  };
 
  Config config_;
  std::deque<SampleData> buffer_; // Circular buffer for sample storage
  uint64_t last_spike_time_;      // Timestamp of last detected spike
  bool collecting_spike_;         // Flag indicating if we're collecting a spike
  uint32_t
      samples_after_threshold_; // Number of samples collected after threshold
  SpikeEvent *pending_spike_;   // Spike currently being collected
  uint64_t sample_period_ns_;   // Period between samples in ns
  uint64_t
      sample_count_; // Count of samples processed for timestamp calculation
};

std::unique_ptr<BaseSpikeDetector> create_threshold_detector(
    const float threshold, const uint32_t waveform_size = 50,
    const uint64_t refractory_us = 1000, // 1ms default refractory period
    const float sample_rate_hz = 30000.0);
 
} // namespace synapse