tools.cpp

Go to the documentation of this file.

#include <iostream>
#include <dirent.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <vector>
#include <cmath>
#include <Bela.h>
#include "tools.h"
#include "conndetect.h" // For NUMBER_FEATURES
 
using namespace std;
 
 
static bool in(const vector<string>& list,const string& key) {
  for(auto& item: list) {
    if(item == key) return true;
  }
  return false;
}
 
static string unique_name(const string& basename, const string& ext) {
 
  vector<string> dir_contents = list_dir(".");
  string full_name, new_basename;
  string number;
  int i = 0;
 
  do {
 
    if(i<10) number = "0" + to_string(i);
    else number = to_string(i);
 
    new_basename = basename + "_" + number;
    full_name = new_basename + ext;
    
    i++;
 
  } while(in(dir_contents, full_name));
 
  return full_name;
}
 
 
bool StartupSanityChecks(BelaContext *context) {
 
  if (NCHANNELS_INPUT_AUDIO != context->audioInChannels) {
    cerr << "Unexpected number of audio in channels. Given: "
      << context->analogInChannels
      << ". But required: " << NCHANNELS_INPUT_ANALOG << endl;
    return false;
  }
 
  if (NCHANNELS_INPUT_ANALOG != context->analogInChannels) {
    cerr << "Unexpected number of analog in channels. Given: "
      << context->analogInChannels
      << ". But required: " << NCHANNELS_INPUT_ANALOG << endl;
    return false;
  }
 
  if (context->analogFrames != PERIOD_SIZE) {
    cerr << "analogFrames should be equal to " << PERIOD_SIZE << "!" << endl;
    return false;
  }
 
  if (context->audioFrames != context->analogFrames) {
    cerr << "The number of audio frames should be equal to the number of "
      "analog frames!"
      << endl;
    return false;
  }
 
  if (context->digitalFrames != context->analogFrames) {
    cerr << "The number of digital frames does not match analog frames! "
      "Digital is: "
      << context->digitalFrames << "." << endl;
    return false;
  }
 
  // Sanity checks for sensors etc.
  if (fabsf(context->audioSampleRate - SAMPLING_FREQUENCY) > 1e-4) {
    cerr << "Invalid audio sampling frequency, should be " << SAMPLING_FREQUENCY
      << ", but is set at: " << context->audioSampleRate << "." << endl;
    return false;
  }
 
  // Sanity checks for sensors etc.
  if (fabsf(context->analogSampleRate - SAMPLING_FREQUENCY) > 1e-4) {
    cerr << "Invalid analog sampling frequency, should be "
      << SAMPLING_FREQUENCY
      << ", but is set at: " << context->analogSampleRate << "." << endl;
    fprintf(stderr, "Diff is: %0.4e]n",
        (context->analogSampleRate - SAMPLING_FREQUENCY));
    return false;
  }
  return true;
}
 
vector<string> list_dir(const char *path) {
  struct dirent *entry;
  DIR *dir = opendir(path);
  vector<string> dir_contents;
 
  if (dir == NULL) {
    return dir_contents;
  }
  while ((entry = readdir(dir)) != NULL) {
    dir_contents.push_back(entry->d_name);
  }
  closedir(dir);
  return dir_contents;
}
 
time_t last_modification_time(const std::string& filepath) {
  struct stat file_stat;
  if(stat(filepath.c_str(), &file_stat) != 0) {
    throw std::runtime_error("Cannot stat file!");
  }
  return file_stat.st_mtime;
}
 
 
template <us num_cols>
LogFile<num_cols>::LogFile(const char* filename, const char* header,bool createUnique) {
 
  string str_filename = filename;
  if(createUnique) {
    string basename = str_filename.substr(0, str_filename.length() -4);
    string ext = str_filename.substr(str_filename.length() -4,
        str_filename.length());
    str_filename = unique_name(basename, ext);
  }
 
 
  static_assert(num_cols > 0, "num_cols should be > 0");
  file = new WriteFile();
  if(!file) throw std::runtime_error("Could not create logfile!");
  file->setup(str_filename.c_str(), 
      true, // <==overwrite
      false // <== append
      );
 
  file->setFileType(kText);
  string header_str = header;
  if(header_str[header_str.size()-1] != '\n') {
    header_str += "\n";
  }
 
  // Create the file format
  string fileFormat = logFileFormat;
  for(us col=0; col < num_cols-1; col++) {
    fileFormat += string(",") + logFileFormat;
  }
  fileFormat += "\n";
  file->setFormat(fileFormat.c_str());
 
  // Set the header
  file->setHeader(header_str.c_str());
  file->setFooter("");
 
}
 
template <us num_cols>
void LogFile<num_cols>::log(const std::array<float, num_cols>& data) {
  file->log(data.data(), data.size());
}
 
template <us num_cols>
LogFile<num_cols>::~LogFile() {
  delete file;
}
 
 
// Explicit instantiation
template class LogFile<NUMBER_FEATURES>;
 
 
static bool existsAndIsNumber(JSONObject& json, const std::wstring& str)
{
  return (json.find(str) != json.end() && json[str]->IsNumber());
}
double retrieveAsNumber(JSONObject& json, const std::string& str)
{
  std::wstring ws = JSON::s2ws(str);
  if(existsAndIsNumber(json, ws))
  {
    double ret = json[ws]->AsNumber();
    /* printf("Received parameter \"%s\": %f\n", str.c_str(), ret); */
    return ret;
  }
  else
    throw(std::runtime_error("Value " + str + "not found\n"));
}