Loading...
Searching...
No Matches
reader_utils.h
Go to the documentation of this file.
/* This file is part of the Gudhi Library - https://gudhi.inria.fr/ - which is released under MIT.
* See file LICENSE or go to https://gudhi.inria.fr/licensing/ for full license details.
* Author(s): Clement Maria, Pawel Dlotko, Clement Jamin
*
* Copyright (C) 2014 Inria
*
* Modification(s):
* - YYYY/MM Author: Description of the modification
*/
#ifndef READER_UTILS_H_
#define READER_UTILS_H_
#include <gudhi/graph_simplicial_complex.h>
#include <gudhi/Debug_utils.h>
# include <boost/iterator/function_output_iterator.hpp>
#include <boost/graph/adjacency_list.hpp>
#include <iostream>
#include <fstream>
#include <map>
#include <limits> // for numeric_limits
#include <string>
#include <vector>
#include <utility> // for pair
#include <tuple> // for std::make_tuple
namespace Gudhi {
// Keep this file tag for Doxygen to parse the code, otherwise, functions are not documented.
// It is required for global functions and variables.
inline void read_points(std::string file_name, std::vector<std::vector<double>>& points) {
std::ifstream in_file(file_name.c_str(), std::ios::in);
if (!in_file.is_open()) {
std::cerr << "Unable to open file " << file_name << std::endl;
return;
}
std::string line;
double x;
while (getline(in_file, line)) {
std::vector<double> point;
std::istringstream iss(line);
while (iss >> x) {
point.push_back(x);
}
// Check for empty lines
if (!point.empty()) points.push_back(point);
}
in_file.close();
}
template <typename Graph_t, typename Filtration_value, typename Vertex_handle>
Graph_t read_graph(std::string file_name) {
std::ifstream in_(file_name.c_str(), std::ios::in);
if (!in_.is_open()) {
std::string error_str("read_graph - Unable to open file ");
error_str.append(file_name);
std::cerr << error_str << std::endl;
throw std::invalid_argument(error_str);
}
typedef std::pair<Vertex_handle, Vertex_handle> Edge_t;
std::vector<Edge_t> edges;
std::vector<Filtration_value> edges_fil;
std::map<Vertex_handle, Filtration_value> vertices;
std::string line;
int dim;
Vertex_handle u, v, max_h = -1;
Filtration_value fil;
while (getline(in_, line)) {
std::istringstream iss(line);
while (iss >> dim) {
switch (dim) {
case 0: {
iss >> u;
iss >> fil;
vertices[u] = fil;
if (max_h < u) {
max_h = u;
}
break;
}
case 1: {
iss >> u;
iss >> v;
iss >> fil;
edges.push_back(Edge_t(u, v));
edges_fil.push_back(fil);
break;
}
default: { break; }
}
}
}
in_.close();
if ((size_t)(max_h + 1) != vertices.size()) {
std::cerr << "Error: vertices must be labeled from 0 to n-1 \n";
}
Graph_t skel_graph(edges.begin(), edges.end(), edges_fil.begin(), vertices.size());
auto vertex_prop = boost::get(vertex_filtration_t(), skel_graph);
typename boost::graph_traits<Graph_t>::vertex_iterator vi, vi_end;
auto v_it = vertices.begin();
for (std::tie(vi, vi_end) = boost::vertices(skel_graph); vi != vi_end; ++vi, ++v_it) {
boost::put(vertex_prop, *vi, v_it->second);
}
return skel_graph;
}
template <typename Vertex_handle, typename Filtration_value>
bool read_simplex(std::istream& in_, std::vector<Vertex_handle>& simplex, Filtration_value& fil) {
int dim = 0;
if (!(in_ >> dim)) return false;
Vertex_handle v;
for (int i = 0; i < dim + 1; ++i) {
if (!(in_ >> v)) return false;
simplex.push_back(v);
}
if (!(in_ >> fil)) return false;
in_.ignore((std::numeric_limits<std::streamsize>::max)(), '\n'); // ignore until the carriage return
return true;
}
template <typename Simplex_key, typename Filtration_value>
bool read_hasse_simplex(std::istream& in_, std::vector<Simplex_key>& boundary, Filtration_value& fil) {
int dim;
if (!(in_ >> dim)) return false;
if (dim == 0) {
in_ >> fil;
return true;
}
Simplex_key key;
for (int i = 0; i < dim + 1; ++i) {
in_ >> key;
boundary.push_back(key);
}
in_ >> fil;
return true;
}
template <typename Filtration_value>
std::vector<std::vector<Filtration_value>> read_lower_triangular_matrix_from_csv_file(const std::string& filename,
const char separator = ';') {
#ifdef DEBUG_TRACES
std::clog << "Using procedure read_lower_triangular_matrix_from_csv_file \n";
#endif // DEBUG_TRACES
std::vector<std::vector<Filtration_value>> result;
std::ifstream in;
in.open(filename.c_str());
if (!in.is_open()) {
return result;
}
std::string line;
// the first line is empty, so we ignore it:
std::getline(in, line);
std::vector<Filtration_value> values_in_this_line;
result.push_back(values_in_this_line);
int number_of_line = 0;
// first, read the file line by line to a string:
while (std::getline(in, line)) {
// if line is empty, break
if (line.size() == 0) break;
// if the last element of a string is comma:
if (line[line.size() - 1] == separator) {
// then shrink the string by one
line.pop_back();
}
// replace all commas with spaces
std::replace(line.begin(), line.end(), separator, ' ');
// put the new line to a stream
std::istringstream iss(line);
// and now read the doubles.
int number_of_entry = 0;
std::vector<Filtration_value> values_in_this_line;
while (iss.good()) {
double entry;
iss >> entry;
if (number_of_entry <= number_of_line) {
values_in_this_line.push_back(entry);
}
++number_of_entry;
}
if (!values_in_this_line.empty()) result.push_back(values_in_this_line);
++number_of_line;
}
in.close();
#ifdef DEBUG_TRACES
std::clog << "Here is the matrix we read : \n";
for (size_t i = 0; i != result.size(); ++i) {
for (size_t j = 0; j != result[i].size(); ++j) {
std::clog << result[i][j] << " ";
}
std::clog << std::endl;
}
#endif // DEBUG_TRACES
return result;
} // read_lower_triangular_matrix_from_csv_file
template <typename OutputIterator>
void read_persistence_intervals_and_dimension(std::string const& filename, OutputIterator out) {
#ifdef DEBUG_TRACES
std::clog << "read_persistence_intervals_and_dimension - " << filename << std::endl;
#endif // DEBUG_TRACES
std::ifstream in(filename);
if (!in.is_open()) {
std::string error_str("read_persistence_intervals_and_dimension - Unable to open file ");
error_str.append(filename);
std::cerr << error_str << std::endl;
throw std::invalid_argument(error_str);
}
while (!in.eof()) {
std::string line;
getline(in, line);
if (line.length() != 0 && line[0] != '#') {
double numbers[4];
int n = sscanf(line.c_str(), "%lf %lf %lf %lf", &numbers[0], &numbers[1], &numbers[2], &numbers[3]);
#ifdef DEBUG_TRACES
std::clog << "[" << n << "] = ";
for (int i = 0; i < n; i++) {
std::clog << numbers[i] << ",";
}
std::clog << std::endl;
#endif // DEBUG_TRACES
if (n >= 2) {
int dim = (n >= 3 ? static_cast<int>(numbers[n - 3]) : -1);
*out++ = std::make_tuple(dim, numbers[n - 2], numbers[n - 1]);
}
}
}
}
inline std::map<int, std::vector<std::pair<double, double>>> read_persistence_intervals_grouped_by_dimension(
std::string const& filename) {
std::map<int, std::vector<std::pair<double, double>>> ret;
read_persistence_intervals_and_dimension(
filename, boost::make_function_output_iterator([&ret](std::tuple<int, double, double> t) {
ret[get<0>(t)].push_back(std::make_pair(get<1>(t), get<2>(t)));
}));
return ret;
}
inline std::vector<std::pair<double, double>> read_persistence_intervals_in_dimension(std::string const& filename,
int only_this_dim = -1) {
std::vector<std::pair<double, double>> ret;
read_persistence_intervals_and_dimension(
filename, boost::make_function_output_iterator([only_this_dim, &ret](std::tuple<int, double, double> t) {
if (only_this_dim == get<0>(t) || only_this_dim == -1) ret.emplace_back(get<1>(t), get<2>(t));
}));
return ret;
}
} // namespace Gudhi
#endif // READER_UTILS_H_
graph_simplicial_complex.h
Graph simplicial complex methods.
Gudhi
Gudhi namespace.
Definition SimplicialComplexForAlpha.h:14
Gudhi::read_hasse_simplex
bool read_hasse_simplex(std::istream &in_, std::vector< Simplex_key > &boundary, Filtration_value &fil)
Read a hasse simplex from a file.
Definition reader_utils.h:183
Gudhi::read_graph
Graph_t read_graph(std::string file_name)
Read a graph from a file.
Definition reader_utils.h:84
Gudhi::read_persistence_intervals_in_dimension
std::vector< std::pair< double, double > > read_persistence_intervals_in_dimension(std::string const &filename, int only_this_dim=-1)
Definition reader_utils.h:355
Gudhi::read_persistence_intervals_and_dimension
void read_persistence_intervals_and_dimension(std::string const &filename, OutputIterator out)
Definition reader_utils.h:295
Gudhi::read_simplex
bool read_simplex(std::istream &in_, std::vector< Vertex_handle > &simplex, Filtration_value &fil)
Read a face from a file.
Definition reader_utils.h:158
Gudhi::read_lower_triangular_matrix_from_csv_file
std::vector< std::vector< Filtration_value > > read_lower_triangular_matrix_from_csv_file(const std::string &filename, const char separator=';')
Read a lower triangular distance matrix from a csv file. We assume that the .csv store the whole (squ...
Definition reader_utils.h:220
Gudhi::read_points
void read_points(std::string file_name, std::vector< std::vector< double > > &points)
Read a set of points to turn it into a vector< vector<double> > by filling points.
Definition reader_utils.h:46
Gudhi::read_persistence_intervals_grouped_by_dimension
std::map< int, std::vector< std::pair< double, double > > > read_persistence_intervals_grouped_by_dimension(std::string const &filename)
Definition reader_utils.h:335