read_CSVfiles.hpp

Go to the documentation of this file.

/*
 * ReadCSVfiles.hpp
 *
 * groups functions for reading csv files into arrays and matrices
 *
 * Copyright (c) 2019, The Chancellor, Masters and Scholars of the University
 * of Oxford, VITO nv, and the 'Slide' Developers.
 * See the licence file LICENCE.txt for more information.
 */
 
#pragma once
 
#include "../../types/matrix.hpp"
#include "../util_debug.hpp"
 
#include <string>
#include <iostream>
#include <fstream>
#include <cassert>
#include <sstream>
#include <vector>
#include <map>
#include <span>
#include <cstring> 
 
namespace slide {
template <typename Tpath>
std::string getFileContents(const Tpath &name)
{
 
  std::cerr << "NOT IMPLEMENTED YET!\n";
  throw 1234;
 
 
  std::ifstream in(name, std::ios::in | std::ios::binary);
  if (!in.good()) 
  {
    std::cerr << "Error in getFileContents. File " << name << " could not be opened.\n";
    throw 2;
  }
 
  std::ostringstream fileContents;
  fileContents << in.rdbuf();
  in.close();
  return (fileContents.str());
}
 
inline auto getFile(std::string name)
{
  std::cerr << "NOT IMPLEMENTED YET!\n";
  throw 1234;
  static std::map<std::string, std::string> fileMap;
}
 
template <typename Tpath, typename T, size_t ROW, size_t COL>
void loadCSV_mat(const Tpath &name, Matrix<T, ROW, COL> &x)
{
  std::ifstream in(name, std::ios_base::in);
 
  if (!in.good()) 
  {
    std::cerr << "Error in ReadCSVfiles::loadCSV_mat. File " << name << " could not be opened\n";
    throw 2;
  }
 
  char c = '.';
 
  while (in.peek() <= 32) 
    in >> c;
 
  for (size_t i = 0; i < ROW; i++) {
    for (size_t j = 0; j < COL - 1; j++) {
      in >> x[i][j] >> c; 
    }
    in >> x[i][COL - 1]; 
  }
 
  in.close();
}
 
template <typename Tpath, typename T, size_t ROW>
void loadCSV_1col(const Tpath &name, std::array<T, ROW> &x)
{
  slide::Matrix<T, ROW, 1> temp;
  loadCSV_mat(name, temp);
  std::memcpy(&x, &temp, sizeof temp);
}
 
inline void ignoreBOM(std::ifstream &in)
{
  char c = '.';
 
  do {
    in >> c;
  } while (c < 45); 
 
  in.putback(c);
}
 
template <typename Tpath, typename Tx, typename Ty>
void loadCSV_2col(const Tpath &name, Tx &x, Ty &y, int n = 0)
{
  /*
   * Reads data from a CSV file with 2 columns
   *
   * IN
   * name   the name of the file
   * n      the number of rows to read (if n==0, read all), it is used to read a portion of a *.csv file.
   *
   * OUT
   * x      array in which the data from the first column will be put
   * y      array in which the data from the second column will be put
   *
   * THROWS
   * 2      could not open the specified file
   */
 
  std::ifstream in(name, std::ios_base::in);
 
  if (!in.good()) 
  {
    std::cerr << "Error in ReadCSVfiles::loadCSV_2col. File " << name
              << " could not be opened.\n";
    throw 2;
  }
 
  ignoreBOM(in);
 
  int j = 0;
  char c;
  if constexpr (std::is_same<std::vector<double>, Tx>::value) {
    x.clear(); 
    y.clear();
 
    double x_i, y_i;
    while ((n == 0 || j < n) && (in >> x_i >> c >> y_i)) 
    {
      x.push_back(x_i);
      y.push_back(y_i);
      j++;
    }
  } else {                                                 
    while ((n == 0 || j < n) && (in >> x[j] >> c >> y[j])) 
      j++;
  }
}
 
template <typename Tpath, typename Tx>
void loadCSV_Ncol(const Tpath &name, DynamicMatrix<Tx> &x, int n = 0)
{
  /*
   * Reads data from a CSV file with 2 columns
   *
   * IN
   * name   the name of the file
   * n      the number of rows to read (if n==0, read all), it is used to read a portion of a *.csv file.
   *
   * OUT
   * x      array in which the data from the first column will be put
   * y      array in which the data from the second column will be put
   *
   * THROWS
   * 2      could not open the specified file
   */
 
  std::ifstream in(name, std::ios_base::in);
 
  if (!in.good()) 
  {
    std::cerr << "Error in ReadCSVfiles::loadCSV_2col. File " << name
              << " could not be opened.\n";
    throw 2;
  }
 
  ignoreBOM(in);
 
  x.data.clear(); 
 
  std::string line;
 
  int n_rows{ 0 };
  while ((n == 0 || n_rows < n) && std::getline(in, line)) 
  {
    n_rows++;
    std::istringstream in_line(line);
    double x_i;
    char c;
    while (in_line >> x_i) {
      x.data.push_back(x_i);
      in_line >> c;
    }
  }
 
  int n_cols = x.data.size() / n_rows;
 
  x.reshape(n_cols, n_rows);
 
  x.data.shrink_to_fit();
}
 
struct XYplain
{
  std::vector<double> x_vec, y_vec;
};
 
template <typename Tpath>
void loadCSV_2col(const Tpath &name, std::span<double> &x, std::span<double> &y, int n = 0)
{
  /*
   * Reads data from a CSV file with 2 columns
   *
   * IN
   * name   the name of the file
   * n      the number of rows to read (if n==0, read all), it is used to read a portion of a *.csv file.
   *
   * OUT
   * x      array in which the data from the first column will be put
   * y      array in which the data from the second column will be put
   *
   * THROWS
   * 2      could not open the specified file
   */
 
  static std::map<std::string, XYplain> XYdataMap;
 
  auto name_str = name.string();
 
  auto fm = XYdataMap.find(name_str);
 
  if (fm == XYdataMap.end()) {
    XYplain xyp{};
    loadCSV_2col(name, xyp.x_vec, xyp.y_vec); 
 
    XYdataMap[name_str] = std::move(xyp);
  }
 
  if (n == 0) {
    x = std::span<double>(XYdataMap[name_str].x_vec);
    y = std::span<double>(XYdataMap[name_str].y_vec);
  } else {
    x = std::span<double>(&XYdataMap[name_str].x_vec[0], &XYdataMap[name_str].x_vec[0] + n); // #TODO temporary solution using pointers instead of iterators.
    y = std::span<double>(&XYdataMap[name_str].y_vec[0], &XYdataMap[name_str].y_vec[0] + n);
  }
}
 
} // namespace slide