base_spike_detector.hpp

#pragma once
 
#include <cstdint>
#include <vector>
 
namespace synapse {

struct SpikeEvent {
  uint64_t timestamp;          // Timestamp when the spike occurred
  uint32_t channel_id;         // Channel ID where the spike was detected
  std::vector<float> waveform; // Waveform samples around the spike
};

class BaseSpikeDetector {
public:
  virtual ~BaseSpikeDetector() = default;

  virtual SpikeEvent *detect(const float sample, const uint64_t frame_timestamp,
                             const uint32_t channel_id) = 0;

  virtual void reset() = 0;
};

template <typename DetectorType>
class SpikeDetectorWrapper : public BaseSpikeDetector {
public:
  explicit SpikeDetectorWrapper(DetectorType detector)
      : detector_instance_(std::move(detector)) {}
 
  template <typename... Args> void setup(Args &&...args) {
    detector_instance_.setup(std::forward<Args>(args)...);
  }
 
  SpikeEvent *detect(const float sample, const uint64_t frame_timestamp,
                     const uint32_t channel_id) override {
    return detector_instance_.detect(sample, frame_timestamp, channel_id);
  }
 
  void reset() override { detector_instance_.reset(); }
 
private:
  DetectorType detector_instance_;
};
 
} // namespace synapse