size_t positionToIndex(double position, const string &unit, const SampledDimension &dimension) {
size_t index;
boost::optional<string> dim_unit = dimension.unit();
double scaling = 1.0;
if (!dim_unit && unit != "none") {
throw nix::IncompatibleDimensions("Units of position and SampledDimension must both be given!", "nix::util::positionToIndex");
}
if (dim_unit && unit != "none") {
try {
scaling = util::getSIScaling(unit, *dim_unit);
} catch (...) {
throw nix::IncompatibleDimensions("Cannot apply a position with unit to a SetDimension", "nix::util::positionToIndex");
}
}
index = dimension.indexOf(position * scaling);
return index;
}
void BaseTestDataAccess::testTagFeatureData() {
DataArray number_feat = block.createDataArray("number feature", "test", nix::DataType::Double, {1});
std::vector<double> number = {10.0};
number_feat.setData(number);
DataArray ramp_feat = block.createDataArray("ramp feature", "test", nix::DataType::Double, {10});
ramp_feat.label("voltage");
ramp_feat.unit("mV");
SampledDimension dim = ramp_feat.appendSampledDimension(1.0);
dim.unit("ms");
std::vector<double> ramp_data = {0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0};
ramp_feat.setData(ramp_data);
Tag pos_tag = block.createTag("feature test", "test", {5.0});
pos_tag.units({"ms"});
Feature f1 = pos_tag.createFeature(number_feat, nix::LinkType::Untagged);
Feature f2 = pos_tag.createFeature(ramp_feat, nix::LinkType::Tagged);
Feature f3 = pos_tag.createFeature(ramp_feat, nix::LinkType::Untagged);
DataView data1 = util::retrieveFeatureData(pos_tag, 0);
DataView data2 = util::retrieveFeatureData(pos_tag, 1);
DataView data3 = util::retrieveFeatureData(pos_tag, 2);
CPPUNIT_ASSERT(pos_tag.featureCount() == 3);
CPPUNIT_ASSERT(data1.dataExtent().nelms() == 1);
CPPUNIT_ASSERT(data2.dataExtent().nelms() == 1);
CPPUNIT_ASSERT(data3.dataExtent().nelms() == ramp_data.size());
// make tag pointing to a slice
pos_tag.extent({2.0});
data1 = util::retrieveFeatureData(pos_tag, 0);
data2 = util::retrieveFeatureData(pos_tag, 1);
data3 = util::retrieveFeatureData(pos_tag, 2);
CPPUNIT_ASSERT(data1.dataExtent().nelms() == 1);
CPPUNIT_ASSERT(data2.dataExtent().nelms() == 2);
CPPUNIT_ASSERT(data3.dataExtent().nelms() == ramp_data.size());
pos_tag.deleteFeature(f1.id());
pos_tag.deleteFeature(f2.id());
pos_tag.deleteFeature(f3.id());
block.deleteDataArray(number_feat.id());
block.deleteDataArray(ramp_feat.id());
block.deleteTag(pos_tag);
}
Dimension::Dimension(const SampledDimension &other)
: ImplContainer(dynamic_pointer_cast<IDimension>(other.impl()))
{
}
void BaseTestMultiTag::testDataAccess() {
DataArray data_array = block.createDataArray("dimensionTest",
"test",
DataType::Double,
NDSize({0, 0, 0}));
double samplingInterval = 1.0;
std::vector<double> ticks {1.2, 2.3, 3.4, 4.5, 6.7};
std::string unit = "ms";
typedef boost::multi_array<double, 3> array_type;
typedef array_type::index index;
array_type data(boost::extents[2][10][5]);
int value;
for(index i = 0; i != 2; ++i) {
value = 0;
for(index j = 0; j != 10; ++j) {
for(index k = 0; k != 5; ++k) {
data[i][j][k] = value++;
}
}
}
data_array.setData(data);
SetDimension setDim = data_array.appendSetDimension();
std::vector<std::string> labels = {"label_a", "label_b"};
setDim.labels(labels);
SampledDimension sampledDim = data_array.appendSampledDimension(samplingInterval);
sampledDim.unit(unit);
RangeDimension rangeDim = data_array.appendRangeDimension(ticks);
rangeDim.unit(unit);
typedef boost::multi_array<double, 2> position_type;
position_type event_positions(boost::extents[2][3]);
position_type event_extents(boost::extents[2][3]);
event_positions[0][0] = 0.0;
event_positions[0][1] = 3.0;
event_positions[0][2] = 3.4;
event_extents[0][0] = 0.0;
event_extents[0][1] = 6.0;
event_extents[0][2] = 2.3;
event_positions[1][0] = 0.0;
event_positions[1][1] = 8.0;
event_positions[1][2] = 2.3;
event_extents[1][0] = 0.0;
event_extents[1][1] = 3.0;
event_extents[1][2] = 2.0;
std::vector<std::string> event_labels = {"event 1", "event 2"};
std::vector<std::string> dim_labels = {"dim 0", "dim 1", "dim 2"};
DataArray event_array = block.createDataArray("positions", "test",
DataType::Double, NDSize({ 0, 0 }));
event_array.setData(event_positions);
SetDimension event_set_dim;
event_set_dim = event_array.appendSetDimension();
event_set_dim.labels(event_labels);
event_set_dim = event_array.appendSetDimension();
event_set_dim.labels(dim_labels);
DataArray extent_array = block.createDataArray("extents", "test",
DataType::Double, NDSize({ 0, 0 }));
extent_array.setData(event_extents);
SetDimension extent_set_dim;
extent_set_dim = extent_array.appendSetDimension();
extent_set_dim.labels(event_labels);
extent_set_dim = extent_array.appendSetDimension();
extent_set_dim.labels(dim_labels);
MultiTag multi_tag = block.createMultiTag("multi_tag", "events", event_array);
multi_tag.extents(extent_array);
multi_tag.addReference(data_array);
CPPUNIT_ASSERT_THROW(multi_tag.taggedData(0, -1), nix::OutOfBounds);
CPPUNIT_ASSERT_THROW(multi_tag.taggedData(0, 1), nix::OutOfBounds);
CPPUNIT_ASSERT_THROW(multi_tag.taggedData(-1, 0), nix::OutOfBounds);
CPPUNIT_ASSERT_THROW(multi_tag.taggedData(10, 0), nix::OutOfBounds);
DataView ret_data = multi_tag.taggedData(0, 0);
NDSize data_size = ret_data.dataExtent();
CPPUNIT_ASSERT(data_size.size() == 3);
CPPUNIT_ASSERT(data_size[0] == 1 && data_size[1] == 7 && data_size[2] == 2);
ret_data = multi_tag.taggedData(0, data_array.name());
data_size = ret_data.dataExtent();
CPPUNIT_ASSERT(data_size.size() == 3);
CPPUNIT_ASSERT(data_size[0] == 1 && data_size[1] == 7 && data_size[2] == 2);
CPPUNIT_ASSERT_THROW(multi_tag.taggedData(1, 0), nix::OutOfBounds);
block.deleteMultiTag(multi_tag);
block.deleteDataArray(data_array);
block.deleteDataArray(event_array);
block.deleteDataArray(event_array);
}
void BaseTestTag::testDataAccess() {
double samplingInterval = 1.0;
std::vector<double> ticks {1.2, 2.3, 3.4, 4.5, 6.7};
std::string unit = "ms";
SampledDimension sampledDim;
RangeDimension rangeDim;
SetDimension setDim;
std::vector<double> position {0.0, 2.0, 3.4};
std::vector<double> extent {0.0, 6.0, 2.3};
std::vector<std::string> units {"none", "ms", "ms"};
DataArray data_array = block.createDataArray("dimensionTest",
"test",
DataType::Double,
NDSize({0, 0, 0}));
std::vector<DataArray> reference;
reference.push_back(data_array);
typedef boost::multi_array<double, 3> array_type;
typedef array_type::index index;
array_type data(boost::extents[2][10][5]);
int value;
for(index i = 0; i != 2; ++i) {
value = 0;
for(index j = 0; j != 10; ++j) {
for(index k = 0; k != 5; ++k) {
data[i][j][k] = value++;
}
}
}
data_array.setData(data);
setDim = data_array.appendSetDimension();
std::vector<std::string> labels = {"label_a", "label_b"};
setDim.labels(labels);
sampledDim = data_array.appendSampledDimension(samplingInterval);
sampledDim.unit(unit);
rangeDim = data_array.appendRangeDimension(ticks);
rangeDim.unit(unit);
Tag position_tag = block.createTag("position tag", "event", position);
position_tag.references(reference);
position_tag.units(units);
Tag segment_tag = block.createTag("region tag", "segment", position);
segment_tag.references(reference);
segment_tag.extent(extent);
segment_tag.units(units);
DataView retrieved_data = position_tag.retrieveData(0);
NDSize data_size = retrieved_data.dataExtent();
CPPUNIT_ASSERT(data_size.size() == 3);
CPPUNIT_ASSERT(data_size[0] == 1 && data_size[1] == 1 && data_size[2] == 1);
retrieved_data = segment_tag.retrieveData( 0);
data_size = retrieved_data.dataExtent();
CPPUNIT_ASSERT(data_size.size() == 3);
CPPUNIT_ASSERT(data_size[0] == 1 && data_size[1] == 6 && data_size[2] == 2);
block.deleteTag(position_tag);
block.deleteTag(segment_tag);
}
