488 lines
13 KiB
C++
488 lines
13 KiB
C++
/********************************************************
|
|
* ██████╗ ██████╗████████╗██╗
|
|
* ██╔════╝ ██╔════╝╚══██╔══╝██║
|
|
* ██║ ███╗██║ ██║ ██║
|
|
* ██║ ██║██║ ██║ ██║
|
|
* ╚██████╔╝╚██████╗ ██║ ███████╗
|
|
* ╚═════╝ ╚═════╝ ╚═╝ ╚══════╝
|
|
* Geophysical Computational Tools & Library (GCTL)
|
|
*
|
|
* Copyright (c) 2023 Yi Zhang (yizhang-geo@zju.edu.cn)
|
|
*
|
|
* GCTL is distributed under a dual licensing scheme. You can redistribute
|
|
* it and/or modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation, either version 2
|
|
* of the License, or (at your option) any later version. You should have
|
|
* received a copy of the GNU Lesser General Public License along with this
|
|
* program. If not, see <http://www.gnu.org/licenses/>.
|
|
*
|
|
* If the terms and conditions of the LGPL v.2. would prevent you from using
|
|
* the GCTL, please consider the option to obtain a commercial license for a
|
|
* fee. These licenses are offered by the GCTL's original author. As a rule,
|
|
* licenses are provided "as-is", unlimited in time for a one time fee. Please
|
|
* send corresponding requests to: yizhang-geo@zju.edu.cn. Please do not forget
|
|
* to include some description of your company and the realm of its activities.
|
|
* Also add information on how to contact you by electronic and paper mail.
|
|
******************************************************/
|
|
|
|
#include "text_io.h"
|
|
#include "cmath"
|
|
|
|
|
|
gctl::text_descriptor::text_descriptor()
|
|
{
|
|
set();
|
|
}
|
|
|
|
gctl::text_descriptor::text_descriptor(std::string filename, std::string file_exten,
|
|
std::string col_order, char deli, char att_sym, char tag_sym, int h_num, int io_psn)
|
|
{
|
|
set(filename, file_exten, col_order, deli, att_sym, tag_sym, h_num, io_psn);
|
|
}
|
|
|
|
gctl::text_descriptor::~text_descriptor()
|
|
{
|
|
clear();
|
|
}
|
|
|
|
void gctl::text_descriptor::set(std::string filename, std::string file_exten,
|
|
std::string col_order, char deli, char att_sym, char tag_sym, int h_num, int io_psn)
|
|
{
|
|
file_name_ = filename;
|
|
file_ext_ = file_exten;
|
|
col_str_ = col_order;
|
|
att_sym_ = att_sym;
|
|
tag_sym_ = tag_sym;
|
|
delimiter_ = deli;
|
|
head_num_ = h_num;
|
|
float_psn_ = io_psn;
|
|
return;
|
|
}
|
|
|
|
void gctl::text_descriptor::clear()
|
|
{
|
|
head_strs_.clear();
|
|
annotates_.clear();
|
|
tags_.clear();
|
|
return;
|
|
}
|
|
|
|
void gctl::text_descriptor::set_float_precision(int psn)
|
|
{
|
|
float_psn_ = psn;
|
|
return;
|
|
}
|
|
|
|
void gctl::text_descriptor::set_head_number(int n)
|
|
{
|
|
head_num_ = n;
|
|
return;
|
|
}
|
|
|
|
void gctl::text_descriptor::set_annotation_symbol(char sym)
|
|
{
|
|
att_sym_ = sym;
|
|
return;
|
|
}
|
|
|
|
void gctl::text_descriptor::set_tag_symbol(char sym)
|
|
{
|
|
tag_sym_ = sym;
|
|
return;
|
|
}
|
|
|
|
void gctl::text_descriptor::set_column_delimeter(char sym)
|
|
{
|
|
delimiter_ = sym;
|
|
return;
|
|
}
|
|
|
|
void gctl::text_descriptor::set_file_extension(std::string ext_s)
|
|
{
|
|
file_ext_ = ext_s;
|
|
return;
|
|
}
|
|
|
|
void gctl::text_descriptor::set_column_order(std::string col_s)
|
|
{
|
|
col_str_ = col_s;
|
|
return;
|
|
}
|
|
|
|
void gctl::read_text_lines(text_descriptor &file_desc, std::vector<std::string> &out_vec, int start_line, int end_line)
|
|
{
|
|
if (start_line < 0 || start_line > end_line)
|
|
{
|
|
throw invalid_argument("Invalid line numbers. From gctl::readlines(...)");
|
|
}
|
|
|
|
std::ifstream infile;
|
|
open_infile(infile, file_desc.file_name_, file_desc.file_ext_);
|
|
|
|
if (!out_vec.empty()) out_vec.clear();
|
|
|
|
std::string tmp_line;
|
|
if (start_line == 0 && end_line == 0)
|
|
{
|
|
for (size_t i = 0; i < file_desc.head_num_; i++)
|
|
{
|
|
getline(infile, tmp_line);
|
|
}
|
|
|
|
size_t tl = 0, al = 0, gl = 0;
|
|
while (getline(infile, tmp_line))
|
|
{
|
|
if (tmp_line[0] == file_desc.att_sym_) al++;
|
|
else if (tmp_line[0] == file_desc.tag_sym_) gl++;
|
|
else tl++;
|
|
}
|
|
|
|
out_vec.reserve(tl);
|
|
infile.clear(std::ios::goodbit);
|
|
infile.seekg(0, std::ios::beg);
|
|
|
|
file_desc.annotates_.reserve(al);
|
|
file_desc.tags_.reserve(gl);
|
|
file_desc.head_strs_.reserve(1024);
|
|
|
|
for (size_t i = 0; i < file_desc.head_num_; i++)
|
|
{
|
|
getline(infile, tmp_line);
|
|
file_desc.head_strs_.push_back(tmp_line);
|
|
}
|
|
|
|
while (getline(infile, tmp_line))
|
|
{
|
|
if (tmp_line[0] == file_desc.att_sym_)
|
|
{
|
|
// remove first symbol and space
|
|
tmp_line.erase(0, tmp_line.find_first_not_of(file_desc.att_sym_));
|
|
tmp_line.erase(0, tmp_line.find_first_not_of(" \t"));
|
|
file_desc.annotates_.push_back(tmp_line);
|
|
}
|
|
else if (tmp_line[0] == file_desc.tag_sym_)
|
|
{
|
|
// remove first symbol and space
|
|
tmp_line.erase(0, tmp_line.find_first_not_of(file_desc.tag_sym_));
|
|
tmp_line.erase(0, tmp_line.find_first_not_of(" \t"));
|
|
file_desc.tags_.push_back(tmp_line);
|
|
}
|
|
else out_vec.push_back(tmp_line);
|
|
}
|
|
|
|
infile.close();
|
|
return;
|
|
}
|
|
|
|
out_vec.reserve(end_line - start_line + 1);
|
|
file_desc.annotates_.reserve(1024);
|
|
file_desc.tags_.reserve(1024);
|
|
file_desc.head_strs_.reserve(1024);
|
|
|
|
for (int i = 0; i < start_line + file_desc.head_num_; i++)
|
|
{
|
|
std::getline(infile, tmp_line);
|
|
file_desc.head_strs_.push_back(tmp_line);
|
|
}
|
|
|
|
for (int i = start_line; i <= end_line; i++)
|
|
{
|
|
std::getline(infile, tmp_line);
|
|
if (tmp_line[0] == file_desc.att_sym_)
|
|
{
|
|
// remove first symbol and space
|
|
tmp_line.erase(0, tmp_line.find_first_not_of(file_desc.att_sym_));
|
|
tmp_line.erase(0, tmp_line.find_first_not_of(" \t"));
|
|
file_desc.annotates_.push_back(tmp_line);
|
|
}
|
|
else if (tmp_line[0] == file_desc.tag_sym_)
|
|
{
|
|
// remove first symbol and space
|
|
tmp_line.erase(0, tmp_line.find_first_not_of(file_desc.tag_sym_));
|
|
tmp_line.erase(0, tmp_line.find_first_not_of(" \t"));
|
|
file_desc.tags_.push_back(tmp_line);
|
|
}
|
|
else out_vec.push_back(tmp_line);
|
|
}
|
|
|
|
infile.close();
|
|
return;
|
|
}
|
|
|
|
void gctl::read_annotations(std::string filename, std::vector<std::string> &out_vec,
|
|
std::string file_ext, char annotate)
|
|
{
|
|
std::ifstream infile;
|
|
open_infile(infile, filename, file_ext);
|
|
|
|
if (!out_vec.empty()) out_vec.clear();
|
|
|
|
std::string tmp_line;
|
|
while (std::getline(infile, tmp_line))
|
|
{
|
|
if (!tmp_line.empty() && tmp_line[0] == annotate)
|
|
{
|
|
// 去掉注释符
|
|
tmp_line = tmp_line.substr(1, tmp_line.length());
|
|
// 去掉可能存在的头尾的空白符号
|
|
tmp_line.erase(0, tmp_line.find_first_not_of(" \t"));
|
|
tmp_line.erase(tmp_line.find_last_not_of(" \t") + 1);
|
|
// 保存到字符串数组
|
|
out_vec.push_back(tmp_line);
|
|
}
|
|
}
|
|
|
|
if (out_vec.empty())
|
|
{
|
|
GCTL_ShowWhatError("No annotations found, From read_annotations(...)",
|
|
GCTL_WARNING_ERROR, 0, 0, 0);
|
|
}
|
|
|
|
infile.close();
|
|
return;
|
|
}
|
|
|
|
void gctl::get_xyz_points(const _2d_vector &data_table, array<point3dc> &out_ps, std::string order)
|
|
{
|
|
//默认的读入的数据列为前三列
|
|
int orders[3] = {0, 1, 2};
|
|
|
|
std::stringstream tmp_ss;
|
|
if (order != "0,1,2")
|
|
{
|
|
str2ss(order, tmp_ss, ",");
|
|
tmp_ss >> orders[0] >> orders[1] >> orders[2];
|
|
|
|
if (tmp_ss.fail())
|
|
{
|
|
throw runtime_error("Fail to read column orders. From gctl::get_xyz_points(...)");
|
|
}
|
|
}
|
|
|
|
int max_col = GCTL_MAX(GCTL_MAX(orders[0], orders[1]), orders[2]);
|
|
for (int i = 0; i < data_table.size(); i++)
|
|
{
|
|
if (data_table[i].size() < max_col+1)
|
|
{
|
|
throw runtime_error("Invalid column size. From gctl::get_xyz_points(...)");
|
|
}
|
|
}
|
|
|
|
// convert to point3dc
|
|
out_ps.resize(data_table.size());
|
|
for (int i = 0; i < out_ps.size(); i++)
|
|
{
|
|
out_ps.at(i).x = data_table.at(i).at(orders[0]);
|
|
out_ps.at(i).y = data_table.at(i).at(orders[1]);
|
|
out_ps.at(i).z = data_table.at(i).at(orders[2]);
|
|
}
|
|
return;
|
|
}
|
|
|
|
void gctl::get_xyz_points(const _2d_vector &data_table, array<point3ds> &out_ps, std::string order)
|
|
{
|
|
//默认的读入的数据列为前三列
|
|
int orders[3] = {0, 1, 2};
|
|
|
|
std::stringstream tmp_ss;
|
|
if (order != "0,1,2")
|
|
{
|
|
str2ss(order, tmp_ss, ",");
|
|
tmp_ss >> orders[0] >> orders[1] >> orders[2];
|
|
|
|
if (tmp_ss.fail())
|
|
{
|
|
throw runtime_error("Fail to read column orders. From gctl::get_xyz_points(...)");
|
|
}
|
|
}
|
|
|
|
int max_col = GCTL_MAX(GCTL_MAX(orders[0], orders[1]), orders[2]);
|
|
for (int i = 0; i < data_table.size(); i++)
|
|
{
|
|
if (data_table[i].size() < max_col+1)
|
|
{
|
|
throw runtime_error("Invalid column size. From gctl::get_xyz_points(...)");
|
|
}
|
|
}
|
|
|
|
// convert to point3dc
|
|
out_ps.resize(data_table.size());
|
|
for (int i = 0; i < out_ps.size(); i++)
|
|
{
|
|
out_ps.at(i).lon = data_table.at(i).at(orders[0]);
|
|
out_ps.at(i).lat = data_table.at(i).at(orders[1]);
|
|
out_ps.at(i).rad = data_table.at(i).at(orders[2]);
|
|
}
|
|
return;
|
|
}
|
|
|
|
void gctl::get_xyz_points(std::string filename, array<point3dc> &out_ps, text_descriptor &desc,
|
|
std::string order, std::string file_ext)
|
|
{
|
|
// read file
|
|
_2d_vector points_vec;
|
|
read_text2vector2d(desc, points_vec);
|
|
get_xyz_points(points_vec, out_ps, order);
|
|
destroy_vector(points_vec);
|
|
return;
|
|
}
|
|
|
|
void gctl::get_xyz_points(std::string filename, array<point3ds> &out_ps, text_descriptor &desc,
|
|
std::string order, std::string file_ext)
|
|
{
|
|
// read file
|
|
_2d_vector points_vec;
|
|
read_text2vector2d(desc, points_vec);
|
|
get_xyz_points(points_vec, out_ps, order);
|
|
destroy_vector(points_vec);
|
|
return;
|
|
}
|
|
|
|
/**
|
|
* @brief 读取数据列
|
|
*
|
|
* @param[in] data_table 二维数据向量
|
|
* @param[in] dat_val 输入的数据数组列表
|
|
* @param[in] dat_col 输入的数据列（数据列不足时会按从左到右顺序读入）
|
|
*/
|
|
void gctl::get_data_column(const _2d_vector &data_table, std::initializer_list<array<double>*> dat_val,
|
|
std::initializer_list<int> dat_col)
|
|
{
|
|
// 初始化数据列
|
|
array<int> orders(dat_val.size());
|
|
for (int i = 0; i < dat_val.size(); i++)
|
|
{
|
|
orders[i] = i;
|
|
}
|
|
|
|
int c_count = 0;
|
|
std::initializer_list<int>::iterator ii;
|
|
for (ii = dat_col.begin(); ii != dat_col.end(); ++ii)
|
|
{
|
|
orders[c_count] = *ii;
|
|
c_count++;
|
|
}
|
|
|
|
c_count = 0;
|
|
std::initializer_list<array<double>*>::iterator id;
|
|
array<double> *dat_ptr;
|
|
for (id = dat_val.begin(); id != dat_val.end(); ++id)
|
|
{
|
|
dat_ptr = *id;
|
|
dat_ptr->resize(data_table.size());
|
|
for (int i = 0; i < data_table.size(); i++)
|
|
{
|
|
dat_ptr->at(i) = data_table[i][orders[c_count]];
|
|
}
|
|
c_count++;
|
|
}
|
|
return;
|
|
}
|
|
|
|
void gctl::get_data_column(std::string filename, std::initializer_list<array<double>*> dat_val,
|
|
std::initializer_list<int> dat_col, text_descriptor &desc, std::string file_ext)
|
|
{
|
|
// read file
|
|
_2d_vector data_vec;
|
|
read_text2vector2d(desc, data_vec);
|
|
get_data_column(data_vec, dat_val, dat_col);
|
|
destroy_vector(data_vec);
|
|
return;
|
|
}
|
|
|
|
|
|
void gctl::save_data_column(std::ofstream &outfile, std::initializer_list<array<double>* > dat_val,
|
|
std::initializer_list<std::string> dat_name, char delimiter, int precision)
|
|
{
|
|
std::initializer_list<std::string>::iterator is;
|
|
outfile << "#";
|
|
for (is = dat_name.begin(); is != dat_name.end(); ++is)
|
|
{
|
|
outfile << delimiter << *is;
|
|
}
|
|
outfile << std::endl;
|
|
|
|
size_t d_num = dat_val.size(), d_size = 0;
|
|
std::initializer_list<array<double>*>::iterator id;
|
|
array<double> *dat_ptr;
|
|
for (id = dat_val.begin(); id != dat_val.end(); ++id)
|
|
{
|
|
dat_ptr = *id;
|
|
d_size = GCTL_MAX(d_size, dat_ptr->size());
|
|
}
|
|
|
|
_2d_matrix out_data(d_num, d_size, NAN);
|
|
size_t d_count = 0;
|
|
for (id = dat_val.begin(); id != dat_val.end(); ++id)
|
|
{
|
|
dat_ptr = *id;
|
|
for (size_t j = 0; j < dat_ptr->size(); j++)
|
|
{
|
|
out_data[d_count][j] = dat_ptr->at(j);
|
|
}
|
|
d_count++;
|
|
}
|
|
|
|
for (size_t i = 0; i < d_size; i++)
|
|
{
|
|
outfile << i + 1;
|
|
for (size_t j = 0; j < d_num; j++)
|
|
{
|
|
outfile << std::setprecision(precision) << delimiter << out_data[j][i];
|
|
}
|
|
outfile << std::endl;
|
|
}
|
|
return;
|
|
}
|
|
|
|
void gctl::save_data_column(std::ofstream &outfile, std::initializer_list<std::vector<double>* > dat_val,
|
|
std::initializer_list<std::string> dat_name, char delimiter, int precision)
|
|
{
|
|
std::initializer_list<std::string>::iterator is;
|
|
outfile << "#";
|
|
for (is = dat_name.begin(); is != dat_name.end(); ++is)
|
|
{
|
|
outfile << delimiter << *is;
|
|
}
|
|
outfile << std::endl;
|
|
|
|
size_t d_num = dat_val.size(), tmp_size, d_size = 0;
|
|
std::initializer_list<std::vector<double>* >::iterator id;
|
|
std::vector<double> *dat_ptr;
|
|
for (id = dat_val.begin(); id != dat_val.end(); ++id)
|
|
{
|
|
dat_ptr = *id;
|
|
tmp_size = dat_ptr->size(); // 超细节 size()返回的值类型为 unsigned int 不要直接和 int 做比较
|
|
d_size = GCTL_MAX(d_size, tmp_size);
|
|
}
|
|
|
|
if (d_size <= 0)
|
|
{
|
|
std::string err_str = "Invalid maximal data size (" + std::to_string(d_size) + "), From gctl::save_data_column(...)";
|
|
throw runtime_error(err_str);
|
|
}
|
|
|
|
_2d_matrix out_data(d_num, d_size, NAN);
|
|
size_t d_count = 0;
|
|
for (id = dat_val.begin(); id != dat_val.end(); ++id)
|
|
{
|
|
dat_ptr = *id;
|
|
for (size_t j = 0; j < dat_ptr->size(); j++)
|
|
{
|
|
out_data[d_count][j] = dat_ptr->at(j);
|
|
}
|
|
d_count++;
|
|
}
|
|
|
|
for (size_t i = 0; i < d_size; i++)
|
|
{
|
|
outfile << i + 1;
|
|
for (size_t j = 0; j < d_num; j++)
|
|
{
|
|
outfile << std::setprecision(precision) << delimiter << out_data[j][i];
|
|
}
|
|
outfile << std::endl;
|
|
}
|
|
return;
|
|
}
|