Skip to content
Snippets Groups Projects
Commit 9713ea1a authored by Vasileios Karakasis's avatar Vasileios Karakasis
Browse files

Renamed cell_record to swc_record. 

Fixes issue #8.
parent 223078a3
No related branches found
No related tags found
No related merge requests found
Hide whitespace changes
Inline Side-by-side
src/swcio.cpp
+ 37
− 37
View file @ 9713ea1a
......@@ -12,9 +12,9 @@ namespace io
{
//
// cell_record implementation
// swc_record implementation
//
void cell_record::renumber(id_type new_id, std::map<id_type, id_type> &idmap)
void swc_record::renumber(id_type new_id, std::map<id_type, id_type> &idmap)
{
auto old_id = id_;
id_ = new_id;
......@@ -29,12 +29,12 @@ void cell_record::renumber(id_type new_id, std::map<id_type, id_type> &idmap)
idmap.insert(std::make_pair(old_id, new_id));
}
void cell_record::check_consistency() const
void swc_record::check_consistency() const
{
// Check cell type as well; enum's do not offer complete type safety,
// Check record type as well; enum's do not offer complete type safety,
// since you can cast anything that fits to its underlying type
if (type_ < 0 || type_ > custom) {
throw std::invalid_argument("unknown cell type");
throw std::invalid_argument("unknown record type");
}
if (id_ < 0) {
......@@ -54,24 +54,24 @@ void cell_record::check_consistency() const
}
}
std::istream &operator>>(std::istream &is, cell_record &cell)
std::istream &operator>>(std::istream &is, swc_record &record)
{
swc_parser parser;
parser.parse_record(is, cell);
parser.parse_record(is, record);
return is;
}
std::ostream &operator<<(std::ostream &os, const cell_record &cell)
std::ostream &operator<<(std::ostream &os, const swc_record &record)
{
// output in one-based indexing
os << cell.id_+1 << " "
<< cell.type_ << " "
<< std::setprecision(7) << cell.x_ << " "
<< std::setprecision(7) << cell.y_ << " "
<< std::setprecision(7) << cell.z_ << " "
<< std::setprecision(7) << cell.r_ << " "
<< ((cell.parent_id_ == -1) ? cell.parent_id_ : cell.parent_id_+1);
os << record.id_+1 << " "
<< record.type_ << " "
<< std::setprecision(7) << record.x_ << " "
<< std::setprecision(7) << record.y_ << " "
<< std::setprecision(7) << record.z_ << " "
<< std::setprecision(7) << record.r_ << " "
<< ((record.parent_id_ == -1) ? record.parent_id_ : record.parent_id_+1);
return os;
}
......@@ -104,22 +104,22 @@ T parse_value_strict(std::istream &is, const swc_parser &parser)
return val;
}
// specialize parsing for cell types
// specialize parsing for record types
template<>
cell_record::kind parse_value_strict(std::istream &is, const swc_parser &parser)
swc_record::kind parse_value_strict(std::istream &is, const swc_parser &parser)
{
cell_record::id_type val;
swc_record::id_type val;
check_parse_status(is >> val, parser);
// Let cell_record's constructor check for the type validity
return static_cast<cell_record::kind>(val);
// Let swc_record's constructor check for the type validity
return static_cast<swc_record::kind>(val);
}
//
// swc_parser implementation
//
std::istream &swc_parser::parse_record(std::istream &is, cell_record &cell)
std::istream &swc_parser::parse_record(std::istream &is, swc_record &record)
{
while (!is.eof() && !is.bad()) {
// consume empty and comment lines first
......@@ -146,7 +146,7 @@ std::istream &swc_parser::parse_record(std::istream &is, cell_record &cell)
std::istringstream line(linebuff_);
try {
cell = parse_record(line);
record = parse_record(line);
} catch (std::invalid_argument &e) {
// Rethrow as a parse error
throw swc_parse_error(e.what(), lineno_);
......@@ -155,34 +155,34 @@ std::istream &swc_parser::parse_record(std::istream &is, cell_record &cell)
return is;
}
cell_record swc_parser::parse_record(std::istringstream &is)
swc_record swc_parser::parse_record(std::istringstream &is)
{
auto id = parse_value_strict<int>(is, *this);
auto type = parse_value_strict<cell_record::kind>(is, *this);
auto type = parse_value_strict<swc_record::kind>(is, *this);
auto x = parse_value_strict<float>(is, *this);
auto y = parse_value_strict<float>(is, *this);
auto z = parse_value_strict<float>(is, *this);
auto r = parse_value_strict<float>(is, *this);
auto parent_id = parse_value_strict<cell_record::id_type>(is, *this);
auto parent_id = parse_value_strict<swc_record::id_type>(is, *this);
// Convert to zero-based, leaving parent_id as-is if -1
if (parent_id != -1) {
parent_id--;
}
return cell_record(type, id-1, x, y, z, r, parent_id);
return swc_record(type, id-1, x, y, z, r, parent_id);
}
cell_record_range_clean::cell_record_range_clean(std::istream &is)
swc_record_range_clean::swc_record_range_clean(std::istream &is)
{
std::unordered_set<cell_record::id_type> ids;
std::unordered_set<swc_record::id_type> ids;
std::size_t num_trees = 0;
cell_record::id_type last_id = -1;
swc_record::id_type last_id = -1;
bool needsort = false;
cell_record curr_cell;
swc_record curr_record;
for (auto c : swc_get_records<swc_io_raw>(is)) {
if (c.parent() == -1 && ++num_trees > 1) {
// only a single tree is allowed
......@@ -191,8 +191,8 @@ cell_record_range_clean::cell_record_range_clean(std::istream &is)
auto inserted = ids.insert(c.id());
if (inserted.second) {
// not a duplicate; insert cell
cells_.push_back(c);
// not a duplicate; insert record
records_.push_back(c);
if (!needsort && c.id() < last_id) {
needsort = true;
}
......@@ -202,13 +202,13 @@ cell_record_range_clean::cell_record_range_clean(std::istream &is)
}
if (needsort) {
std::sort(cells_.begin(), cells_.end());
std::sort(records_.begin(), records_.end());
}
// Renumber cells if necessary
std::map<cell_record::id_type, cell_record::id_type> idmap;
cell_record::id_type next_id = 0;
for (auto &c : cells_) {
// Renumber records if necessary
std::map<swc_record::id_type, swc_record::id_type> idmap;
swc_record::id_type next_id = 0;
for (auto &c : records_) {
if (c.id() != next_id) {
c.renumber(next_id, idmap);
}
......
src/swcio.hpp
+ 64
− 64
View file @ 9713ea1a
......@@ -13,7 +13,7 @@ namespace io
{
class cell_record
class swc_record
{
public:
using id_type = int;
......@@ -33,8 +33,8 @@ public:
custom
};
// cell records assume zero-based indexing; root's parent remains -1
cell_record(kind type, int id,
// swc records assume zero-based indexing; root's parent remains -1
swc_record(kind type, int id,
float x, float y, float z, float r,
int parent_id)
: type_(type)
......@@ -48,8 +48,8 @@ public:
check_consistency();
}
cell_record()
: type_(cell_record::undefined)
swc_record()
: type_(swc_record::undefined)
, id_(0)
, x_(0)
, y_(0)
......@@ -58,10 +58,10 @@ public:
, parent_id_(-1)
{ }
cell_record(const cell_record &other) = default;
cell_record &operator=(const cell_record &other) = default;
swc_record(const swc_record &other) = default;
swc_record &operator=(const swc_record &other) = default;
bool strict_equals(const cell_record &other) const
bool strict_equals(const swc_record &other) const
{
return id_ == other.id_ &&
x_ == other.x_ &&
......@@ -72,43 +72,43 @@ public:
}
// Equality and comparison operators
friend bool operator==(const cell_record &lhs,
const cell_record &rhs)
friend bool operator==(const swc_record &lhs,
const swc_record &rhs)
{
return lhs.id_ == rhs.id_;
}
friend bool operator<(const cell_record &lhs,
const cell_record &rhs)
friend bool operator<(const swc_record &lhs,
const swc_record &rhs)
{
return lhs.id_ < rhs.id_;
}
friend bool operator<=(const cell_record &lhs,
const cell_record &rhs)
friend bool operator<=(const swc_record &lhs,
const swc_record &rhs)
{
return (lhs < rhs) || (lhs == rhs);
}
friend bool operator!=(const cell_record &lhs,
const cell_record &rhs)
friend bool operator!=(const swc_record &lhs,
const swc_record &rhs)
{
return !(lhs == rhs);
}
friend bool operator>(const cell_record &lhs,
const cell_record &rhs)
friend bool operator>(const swc_record &lhs,
const swc_record &rhs)
{
return !(lhs < rhs) && (lhs != rhs);
}
friend bool operator>=(const cell_record &lhs,
const cell_record &rhs)
friend bool operator>=(const swc_record &lhs,
const swc_record &rhs)
{
return !(lhs < rhs);
}
friend std::ostream &operator<<(std::ostream &os, const cell_record &cell);
friend std::ostream &operator<<(std::ostream &os, const swc_record &record);
kind type() const
{
......@@ -155,11 +155,11 @@ public:
private:
void check_consistency() const;
kind type_; // cell type
id_type id_; // cell id
float x_, y_, z_; // cell coordinates
float r_; // cell radius
id_type parent_id_; // cell parent's id
kind type_; // record type
id_type id_; // record id
float x_, y_, z_; // record coordinates
float r_; // record radius
id_type parent_id_; // record parent's id
};
......@@ -206,11 +206,11 @@ public:
return lineno_;
}
std::istream &parse_record(std::istream &is, cell_record &cell);
std::istream &parse_record(std::istream &is, swc_record &record);
private:
// Read the record from a string stream; will be treated like a single line
cell_record parse_record(std::istringstream &is);
swc_record parse_record(std::istringstream &is);
std::string delim_;
std::string comment_prefix_;
......@@ -219,15 +219,15 @@ private:
};
std::istream &operator>>(std::istream &is, cell_record &cell);
std::istream &operator>>(std::istream &is, swc_record &record);
class cell_record_stream_iterator :
public std::iterator<std::forward_iterator_tag, cell_record>
class swc_record_stream_iterator :
public std::iterator<std::forward_iterator_tag, swc_record>
{
public:
struct eof_tag { };
cell_record_stream_iterator(std::istream &is)
swc_record_stream_iterator(std::istream &is)
: is_(is)
, eof_(false)
{
......@@ -236,19 +236,19 @@ public:
read_next_record();
}
cell_record_stream_iterator(std::istream &is, eof_tag)
swc_record_stream_iterator(std::istream &is, eof_tag)
: is_(is)
, eof_(true)
{ }
cell_record_stream_iterator(const cell_record_stream_iterator &other)
swc_record_stream_iterator(const swc_record_stream_iterator &other)
: is_(other.is_)
, parser_(other.parser_)
, curr_record_(other.curr_record_)
, eof_(other.eof_)
{ }
cell_record_stream_iterator &operator++()
swc_record_stream_iterator &operator++()
{
if (eof_) {
throw std::out_of_range("attempt to read past eof");
......@@ -258,9 +258,9 @@ public:
return *this;
}
cell_record_stream_iterator operator++(int)
swc_record_stream_iterator operator++(int)
{
cell_record_stream_iterator ret(*this);
swc_record_stream_iterator ret(*this);
operator++();
return ret;
}
......@@ -274,7 +274,7 @@ public:
return curr_record_;
}
bool operator==(const cell_record_stream_iterator &other) const
bool operator==(const swc_record_stream_iterator &other) const
{
if (eof_ && other.eof_) {
return true;
......@@ -283,13 +283,13 @@ public:
}
}
bool operator!=(const cell_record_stream_iterator &other) const
bool operator!=(const swc_record_stream_iterator &other) const
{
return !(*this == other);
}
friend std::ostream &operator<<(std::ostream &os,
const cell_record_stream_iterator &iter)
const swc_record_stream_iterator &iter)
{
os << "{ is_.tellg(): " << iter.is_.tellg() << ", "
<< "curr_record_: " << iter.curr_record_ << ", "
......@@ -309,7 +309,7 @@ private:
std::istream &is_;
swc_parser parser_;
cell_record curr_record_;
swc_record curr_record_;
// indicator of eof; we need a way to define an end() iterator without
// seeking to the end of file
......@@ -317,28 +317,28 @@ private:
};
class cell_record_range_raw
class swc_record_range_raw
{
public:
using value_type = cell_record;
using value_type = swc_record;
using reference = value_type &;
using const_reference = const value_type &;
using iterator = cell_record_stream_iterator;
using const_iterator = const cell_record_stream_iterator;
using iterator = swc_record_stream_iterator;
using const_iterator = const swc_record_stream_iterator;
cell_record_range_raw(std::istream &is)
swc_record_range_raw(std::istream &is)
: is_(is)
{ }
iterator begin() const
{
return cell_record_stream_iterator(is_);
return swc_record_stream_iterator(is_);
}
iterator end() const
{
iterator::eof_tag eof;
return cell_record_stream_iterator(is_, eof);
return swc_record_stream_iterator(is_, eof);
}
bool empty() const
......@@ -351,62 +351,62 @@ private:
};
//
// Reads cells from an input stream until an eof is encountered and returns a
// cleaned sequence of cell records.
// Reads records from an input stream until an eof is encountered and returns a
// cleaned sequence of swc records.
//
// For more information check here:
// https://github.com/eth-cscs/cell_algorithms/wiki/SWC-file-parsing
//
class cell_record_range_clean
class swc_record_range_clean
{
public:
using value_type = cell_record;
using value_type = swc_record;
using reference = value_type &;
using const_referene = const value_type &;
using iterator = std::vector<cell_record>::iterator;
using const_iterator = std::vector<cell_record>::const_iterator;
using iterator = std::vector<swc_record>::iterator;
using const_iterator = std::vector<swc_record>::const_iterator;
cell_record_range_clean(std::istream &is);
swc_record_range_clean(std::istream &is);
iterator begin()
{
return cells_.begin();
return records_.begin();
}
iterator end()
{
return cells_.end();
return records_.end();
}
std::size_t size()
{
return cells_.size();
return records_.size();
}
bool empty() const
{
return cells_.empty();
return records_.empty();
}
private:
std::vector<cell_record> cells_;
std::vector<swc_record> records_;
};
struct swc_io_raw
{
using cell_range_type = cell_record_range_raw;
using record_range_type = swc_record_range_raw;
};
struct swc_io_clean
{
using cell_range_type = cell_record_range_clean;
using record_range_type = swc_record_range_clean;
};
template<typename T = swc_io_clean>
typename T::cell_range_type swc_get_records(std::istream &is)
typename T::record_range_type swc_get_records(std::istream &is)
{
return typename T::cell_range_type(is);
return typename T::record_range_type(is);
}
} // end of nestmc::io
......
tests/test_swcio.cpp
+ 81
− 81
View file @ 9713ea1a
......@@ -10,8 +10,8 @@
#include <swcio.hpp>
// SWC tests
void expect_cell_equals(const nestmc::io::cell_record &expected,
const nestmc::io::cell_record &actual)
void expect_record_equals(const nestmc::io::swc_record &expected,
const nestmc::io::swc_record &actual)
{
EXPECT_EQ(expected.id(), actual.id());
EXPECT_EQ(expected.type(), actual.type());
......@@ -22,85 +22,85 @@ void expect_cell_equals(const nestmc::io::cell_record &expected,
EXPECT_EQ(expected.parent(), actual.parent());
}
TEST(cell_record, construction)
TEST(swc_record, construction)
{
using namespace nestmc::io;
{
// force an invalid type
cell_record::kind invalid_type = static_cast<cell_record::kind>(100);
EXPECT_THROW(cell_record cell(invalid_type, 7, 1., 1., 1., 1., 5),
swc_record::kind invalid_type = static_cast<swc_record::kind>(100);
EXPECT_THROW(swc_record record(invalid_type, 7, 1., 1., 1., 1., 5),
std::invalid_argument);
}
{
// invalid id
EXPECT_THROW(cell_record cell(
cell_record::custom, -3, 1., 1., 1., 1., 5),
EXPECT_THROW(swc_record record(
swc_record::custom, -3, 1., 1., 1., 1., 5),
std::invalid_argument);
}
{
// invalid parent id
EXPECT_THROW(cell_record cell(
cell_record::custom, 0, 1., 1., 1., 1., -5),
EXPECT_THROW(swc_record record(
swc_record::custom, 0, 1., 1., 1., 1., -5),
std::invalid_argument);
}
{
// invalid radius
EXPECT_THROW(cell_record cell(
cell_record::custom, 0, 1., 1., 1., -1., -1),
EXPECT_THROW(swc_record record(
swc_record::custom, 0, 1., 1., 1., -1., -1),
std::invalid_argument);
}
{
// parent_id > id
EXPECT_THROW(cell_record cell(
cell_record::custom, 0, 1., 1., 1., 1., 2),
EXPECT_THROW(swc_record record(
swc_record::custom, 0, 1., 1., 1., 1., 2),
std::invalid_argument);
}
{
// parent_id == id
EXPECT_THROW(cell_record cell(
cell_record::custom, 0, 1., 1., 1., 1., 0),
EXPECT_THROW(swc_record record(
swc_record::custom, 0, 1., 1., 1., 1., 0),
std::invalid_argument);
}
{
// check standard construction by value
cell_record cell(cell_record::custom, 0, 1., 1., 1., 1., -1);
EXPECT_EQ(cell.id(), 0);
EXPECT_EQ(cell.type(), cell_record::custom);
EXPECT_EQ(cell.x(), 1.);
EXPECT_EQ(cell.y(), 1.);
EXPECT_EQ(cell.z(), 1.);
EXPECT_EQ(cell.radius(), 1.);
EXPECT_EQ(cell.diameter(), 2*1.);
EXPECT_EQ(cell.parent(), -1);
swc_record record(swc_record::custom, 0, 1., 1., 1., 1., -1);
EXPECT_EQ(record.id(), 0);
EXPECT_EQ(record.type(), swc_record::custom);
EXPECT_EQ(record.x(), 1.);
EXPECT_EQ(record.y(), 1.);
EXPECT_EQ(record.z(), 1.);
EXPECT_EQ(record.radius(), 1.);
EXPECT_EQ(record.diameter(), 2*1.);
EXPECT_EQ(record.parent(), -1);
}
{
// check copy constructor
cell_record cell_orig(cell_record::custom, 0, 1., 1., 1., 1., -1);
cell_record cell(cell_orig);
expect_cell_equals(cell_orig, cell);
swc_record record_orig(swc_record::custom, 0, 1., 1., 1., 1., -1);
swc_record record(record_orig);
expect_record_equals(record_orig, record);
}
}
TEST(cell_record, comparison)
TEST(swc_record, comparison)
{
using namespace nestmc::io;
{
// check comparison operators
cell_record cell0(cell_record::custom, 0, 1., 1., 1., 1., -1);
cell_record cell1(cell_record::custom, 0, 2., 3., 4., 5., -1);
cell_record cell2(cell_record::custom, 1, 2., 3., 4., 5., -1);
EXPECT_EQ(cell0, cell1);
EXPECT_LT(cell0, cell2);
EXPECT_GT(cell2, cell1);
swc_record record0(swc_record::custom, 0, 1., 1., 1., 1., -1);
swc_record record1(swc_record::custom, 0, 2., 3., 4., 5., -1);
swc_record record2(swc_record::custom, 1, 2., 3., 4., 5., -1);
EXPECT_EQ(record0, record1);
EXPECT_LT(record0, record2);
EXPECT_GT(record2, record1);
}
}
......@@ -112,24 +112,24 @@ TEST(swc_parser, invalid_input)
{
// check incomplete lines; missing parent
std::istringstream is("1 1 14.566132 34.873772 7.857000 0.717830\n");
cell_record cell;
EXPECT_THROW(is >> cell, swc_parse_error);
swc_record record;
EXPECT_THROW(is >> record, swc_parse_error);
}
{
// Check non-parsable values
std::istringstream is(
"1a 1 14.566132 34.873772 7.857000 0.717830 -1\n");
cell_record cell;
EXPECT_THROW(is >> cell, swc_parse_error);
swc_record record;
EXPECT_THROW(is >> record, swc_parse_error);
}
{
// Check invalid cell type
// Check invalid record type
std::istringstream is(
"1 10 14.566132 34.873772 7.857000 0.717830 -1\n");
cell_record cell;
EXPECT_THROW(is >> cell, swc_parse_error);
swc_record record;
EXPECT_THROW(is >> record, swc_parse_error);
}
}
......@@ -139,58 +139,58 @@ TEST(swc_parser, valid_input)
using namespace nestmc::io;
{
// check empty file; no cell may be parsed
cell_record cell, cell_orig;
// check empty file; no record may be parsed
swc_record record, record_orig;
std::istringstream is("");
EXPECT_NO_THROW(is >> cell);
expect_cell_equals(cell_orig, cell);
EXPECT_NO_THROW(is >> record);
expect_record_equals(record_orig, record);
}
{
// check comment-only file not ending with a newline;
// no cell may be parsed
cell_record cell, cell_orig;
// no record may be parsed
swc_record record, record_orig;
std::istringstream is("#comment\n#comment");
EXPECT_NO_THROW(is >> cell);
expect_cell_equals(cell_orig, cell);
EXPECT_NO_THROW(is >> record);
expect_record_equals(record_orig, record);
}
{
// check last line case (no newline at the end)
std::istringstream is("1 1 14.566132 34.873772 7.857000 0.717830 -1");
cell_record cell;
EXPECT_NO_THROW(is >> cell);
EXPECT_EQ(0, cell.id()); // zero-based indexing
EXPECT_EQ(cell_record::soma, cell.type());
EXPECT_FLOAT_EQ(14.566132, cell.x());
EXPECT_FLOAT_EQ(34.873772, cell.y());
EXPECT_FLOAT_EQ( 7.857000, cell.z());
EXPECT_FLOAT_EQ( 0.717830, cell.radius());
EXPECT_FLOAT_EQ( -1, cell.parent());
swc_record record;
EXPECT_NO_THROW(is >> record);
EXPECT_EQ(0, record.id()); // zero-based indexing
EXPECT_EQ(swc_record::soma, record.type());
EXPECT_FLOAT_EQ(14.566132, record.x());
EXPECT_FLOAT_EQ(34.873772, record.y());
EXPECT_FLOAT_EQ( 7.857000, record.z());
EXPECT_FLOAT_EQ( 0.717830, record.radius());
EXPECT_FLOAT_EQ( -1, record.parent());
}
{
// check valid input with a series of records
std::vector<cell_record> cells_orig = {
cell_record(cell_record::soma, 0,
std::vector<swc_record> records_orig = {
swc_record(swc_record::soma, 0,
14.566132, 34.873772, 7.857000, 0.717830, -1),
cell_record(cell_record::dendrite, 1,
swc_record(swc_record::dendrite, 1,
14.566132+1, 34.873772+1, 7.857000+1, 0.717830+1, -1)
};
std::stringstream swc_input;
swc_input << "# this is a comment\n";
swc_input << "# this is a comment\n";
for (auto c : cells_orig)
for (auto c : records_orig)
swc_input << c << "\n";
swc_input << "# this is a final comment\n";
std::size_t nr_records = 0;
for (auto cell : swc_get_records<swc_io_raw>(swc_input)) {
ASSERT_LT(nr_records, cells_orig.size());
expect_cell_equals(cells_orig[nr_records], cell);
for (auto record : swc_get_records<swc_io_raw>(swc_input)) {
ASSERT_LT(nr_records, records_orig.size());
expect_record_equals(records_orig[nr_records], record);
++nr_records;
}
}
......@@ -207,8 +207,8 @@ TEST(swc_parser, from_allen_db)
return;
}
// load the cell records into a std::vector
std::vector<io::cell_record> nodes;
// load the record records into a std::vector
std::vector<io::swc_record> nodes;
for (auto node : io::swc_get_records<io::swc_io_raw>(fid)) {
nodes.push_back(std::move(node));
}
......@@ -240,8 +240,8 @@ TEST(swc_parser, input_cleaning)
is << "3 1 14.566132 34.873772 7.857000 0.717830 -1\n";
is << "4 1 14.566132 34.873772 7.857000 0.717830 1\n";
auto cells = swc_get_records(is);
EXPECT_EQ(2u, cells.size());
auto records = swc_get_records(is);
EXPECT_EQ(2u, records.size());
}
{
......@@ -252,7 +252,7 @@ TEST(swc_parser, input_cleaning)
is << "4 1 14.566132 34.873772 7.857000 0.717830 1\n";
is << "1 1 14.566132 34.873772 7.857000 0.717830 -1\n";
std::array<cell_record::id_type, 4> expected_id_list = {{ 0, 1, 2, 3 }};
std::array<swc_record::id_type, 4> expected_id_list = {{ 0, 1, 2, 3 }};
auto expected_id = expected_id_list.cbegin();
for (auto c : swc_get_records(is)) {
......@@ -274,9 +274,9 @@ TEST(swc_parser, input_cleaning)
is << "51 1 14.566132 34.873772 7.857000 0.717830 1\n";
is << "61 1 14.566132 34.873772 7.857000 0.717830 51\n";
std::array<cell_record::id_type, 6> expected_id_list =
std::array<swc_record::id_type, 6> expected_id_list =
{{ 0, 1, 2, 3, 4, 5 }};
std::array<cell_record::id_type, 6> expected_parent_list =
std::array<swc_record::id_type, 6> expected_parent_list =
{{ -1, 0, 1, 1, 0, 4 }};
auto expected_id = expected_id_list.cbegin();
......@@ -294,7 +294,7 @@ TEST(swc_parser, input_cleaning)
}
}
TEST(cell_record_ranges, raw)
TEST(swc_record_ranges, raw)
{
using namespace nestmc::io;
......@@ -306,17 +306,17 @@ TEST(cell_record_ranges, raw)
is << "3 1 14.566132 34.873772 7.857000 0.717830 1\n";
is << "4 1 14.566132 34.873772 7.857000 0.717830 1\n";
std::vector<cell_record> cells;
std::vector<swc_record> records;
for (auto c : swc_get_records<swc_io_raw>(is)) {
cells.push_back(c);
records.push_back(c);
}
EXPECT_EQ(4u, cells.size());
EXPECT_EQ(4u, records.size());
bool entered = false;
auto citer = cells.begin();
auto citer = records.begin();
for (auto c : swc_get_records<swc_io_raw>(is)) {
expect_cell_equals(c, *citer++);
expect_record_equals(c, *citer++);
entered = true;
}
......@@ -343,7 +343,7 @@ TEST(cell_record_ranges, raw)
auto iter = swc_get_records<swc_io_raw>(is).begin();
auto iend = swc_get_records<swc_io_raw>(is).end();
cell_record c;
swc_record c;
EXPECT_NO_THROW(c = *iter++);
EXPECT_EQ(-1, c.parent());
EXPECT_EQ(iend, iter);
......@@ -360,10 +360,10 @@ TEST(cell_record_ranges, raw)
is << "3 10 14.566132 34.873772 7.857000 0.717830 1\n";
is << "4 1 14.566132 34.873772 7.857000 0.717830 1\n";
std::vector<cell_record> cells;
std::vector<swc_record> records;
try {
for (auto c : swc_get_records<swc_io_raw>(is)) {
cells.push_back(c);
records.push_back(c);
}
ADD_FAILURE() << "expected an exception\n";
......
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment