comparison src/Modules/Strobes/ModuleLocalMax.cc @ 32:9122efd2b227

-New AIMCopy main for the SSI features (temporary hack till I get a working module load system)
-LocalMax strobe criterion. This is faster and better than the parabola version, which still seems buggy.
-Noise generator module. Adds noise to a signal. Uses boost for the random number generator.
-New options for the SSI
-Slice now respects all its flags (oops!).
-MATLAB functions for visualisation
-Scripts for generating data to view in MATLAB
-Script to download and build HTK - useful for running experiments

+// Copyright 2010, Thomas Walters
+//
+// AIM-C: A C++ implementation of the Auditory Image Model
+// http://www.acousticscale.org/AIMC
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+/*!
+ * \file
+ * \brief 
+ *
+ * \author Thomas Walters <[e-mail]>
+ * \date created 2010/02/23
+ * \version \$Id$
+ */
+
+#include <math.h>
+#include "Modules/Strobes/ModuleLocalMax.h"
+
+namespace aimc {
+ModuleLocalMax::ModuleLocalMax(Parameters *params) : Module(params) {
+  module_description_ = "Local maximum strobe criterion: decaying threshold "
+                        "with timeout";
+  module_identifier_ = "local_max";
+  module_type_ = "strobes";
+  module_version_ = "$Id$";
+
+  decay_time_ms_ = parameters_->DefaultFloat("strobes.decay_time_ms", 20.0f);
+  timeout_ms_ = parameters_->DefaultFloat("strobes.timeout_ms", 3.0f);
+}
+
+ModuleLocalMax::~ModuleLocalMax() {
+}
+
+bool ModuleLocalMax::InitializeInternal(const SignalBank &input) {
+  // Copy the parameters of the input signal bank into internal variables, so
+  // that they can be checked later.
+  sample_rate_ = input.sample_rate();
+  buffer_length_ = input.buffer_length();
+  channel_count_ = input.channel_count();
+  output_.Initialize(input);
+  strobe_timeout_samples_ = floor(timeout_ms_ * sample_rate_ / 1000.0f);
+  strobe_decay_samples_ = floor(decay_time_ms_ * sample_rate_ / 1000.0f);
+  ResetInternal();
+  return true;
+}
+
+void ModuleLocalMax::ResetInternal() {
+  threshold_.clear();
+  threshold_.resize(channel_count_, 0.0f);
+
+  decay_constant_.clear();
+  decay_constant_.resize(channel_count_, 1.0f);
+
+  prev_sample_.clear();
+  prev_sample_.resize(channel_count_, 10000.0f);
+  curr_sample_.clear();
+  curr_sample_.resize(channel_count_, 5000.0f);
+  next_sample_.clear();
+  next_sample_.resize(channel_count_, 0.0f);
+}
+
+void ModuleLocalMax::Process(const SignalBank &input) {
+  // Check to see if the module has been initialized. If not, processing
+  // should not continue.
+  if (!initialized_) {
+    LOG_ERROR(_T("Module %s not initialized."), module_identifier_.c_str());
+    return;
+  }
+
+  // Check that ths input this time is the same as the input passed to
+  // Initialize()
+  if (buffer_length_ != input.buffer_length()
+      || channel_count_ != input.channel_count()) {
+    LOG_ERROR(_T("Mismatch between input to Initialize() and input to "
+                 "Process() in module %s."), module_identifier_.c_str());
+    return;
+  }
+
+  for (int ch = 0; ch < output_.channel_count(); ch++) {
+    output_.ResetStrobes(ch);
+  }
+  output_.set_start_time(input.start_time());
+  for (int i = 0; i < input.buffer_length(); i++) {
+    for (int ch = 0; ch < input.channel_count(); ++ch) {
+      // curr_sample is the sample at time (i - 1)
+      prev_sample_[ch] = curr_sample_[ch];
+      curr_sample_[ch] = next_sample_[ch];
+      next_sample_[ch] = input.sample(ch, i);
+      // Copy input signal to output signal
+      output_.set_sample(ch, i, input.sample(ch, i));
+
+      // If the current sample is above threshold, the threshold is raised to
+      // the level of the current sample, and decays from there.
+      if (curr_sample_[ch] >= threshold_[ch]) {
+        threshold_[ch] = curr_sample_[ch];
+        decay_constant_[ch] = threshold_[ch] / strobe_decay_samples_;
+
+        // If the current sample is also a peak, then it is a potential strobe
+        // point.
+        if (prev_sample_[ch] < curr_sample_[ch]
+            && next_sample_[ch] < curr_sample_[ch]) {
+          // If there are no strobes so far in this channel, then the sample
+          // is definitely a strobe (this means that the timeout is not 
+          // respected across frame boundaries. This is a minor bug, but I
+          // don't believe that it's serious enough to warrant updating the
+          // samples since last strobe all the time.)
+          int count = output_.strobe_count(ch);
+          if (count > 0) {
+            // If there are previous strobes, then calculate the time since
+            // the last one. If it's long enough, then this is a strobe point,
+            // if not, then just move on.
+            int samples_since_last = (i - 1) - output_.strobe(ch, count - 1);
+            if (samples_since_last > strobe_timeout_samples_) {
+              output_.AddStrobe(ch, i - 1);
+            }
+          } else {
+            output_.AddStrobe(ch, i - 1);
+          }
+        }
+      }
+
+      // Update the threshold, decaying as necessary
+      if (threshold_[ch] > decay_constant_[ch])
+        threshold_[ch] -= decay_constant_[ch];
+      else
+        threshold_[ch] = 0.0f;
+    }
+  }
+  PushOutput();
+}
+}  // namespace aimc
+