bool WriteKernelDynamic::operator() (const Tracking::GeneratedTrack& in, Tractography::Streamline<>& out)
{
out.index = writer.count;
out.weight = 1.0;
if (!WriteKernel::operator() (in)) {
out.clear();
// Flag to indicate that tracking has completed, and threads should therefore terminate
out.weight = 0.0;
// Actually need to pass this down the queue so that the seeder thread receives it and knows to terminate
return true;
}
out = in;
return true;
}
bool Receiver::operator() (const Tractography::Streamline<>& in)
{
auto display_func = [&](){ return printf ("%8" PRIu64 " read, %8" PRIu64 " written", total_count, count); };
if (number && (count == number))
return false;
++total_count;
if (in.empty()) {
writer (in);
progress.update (display_func);
return true;
}
if (in[0].valid()) {
if (skip) {
--skip;
progress.update (display_func);
return true;
}
writer (in);
} else {
// Explicitly handle case where the streamline has been cropped into multiple components
// Worker class separates track segments using invalid points as delimiters
Tractography::Streamline<> temp;
temp.index = in.index;
temp.weight = in.weight;
for (Tractography::Streamline<>::const_iterator p = in.begin(); p != in.end(); ++p) {
if (p->valid()) {
temp.push_back (*p);
} else if (temp.size()) {
writer (temp);
temp.clear();
}
}
}
++count;
progress.update (display_func);
return (!(number && (count == number)));
}
bool Worker::operator() (const Tractography::Streamline<>& in, Tractography::Streamline<>& out) const
{
out.clear();
out.index = in.index;
out.weight = in.weight;
if (!thresholds (in)) {
// Want to test thresholds before wasting time on upsampling; but if -inverse is set,
// still need to apply both the upsampler and downsampler before writing to output
if (inverse) {
std::vector< Point<float> > tck (in);
upsampler (tck);
downsampler (tck);
tck.swap (out);
}
return true;
}
// Upsample track before mapping to ROIs
std::vector< Point<float> > tck (in);
upsampler (tck);
// Assign to ROIs
if (properties.include.size() || properties.exclude.size()) {
include_visited.assign (properties.include.size(), false);
for (std::vector< Point<float> >::const_iterator p = tck.begin(); p != tck.end(); ++p) {
properties.include.contains (*p, include_visited);
if (properties.exclude.contains (*p)) {
if (inverse) {
downsampler (tck);
tck.swap (out);
}
return true;
}
}
// Make sure all of the include regions were visited
for (std::vector<bool>::const_iterator i = include_visited.begin(); i != include_visited.end(); ++i) {
if (!*i) {
if (inverse) {
downsampler (tck);
tck.swap (out);
}
return true;
}
}
}
if (properties.mask.size()) {
// Split tck into separate tracks based on the mask
std::vector< std::vector< Point<float> > > cropped_tracks;
std::vector< Point<float> > temp;
for (std::vector< Point<float> >::const_iterator p = tck.begin(); p != tck.end(); ++p) {
const bool contains = properties.mask.contains (*p);
if (contains == inverse) {
if (temp.size() >= 2)
cropped_tracks.push_back (temp);
temp.clear();
} else {
temp.push_back (*p);
}
}
if (temp.size() >= 2)
cropped_tracks.push_back (temp);
if (cropped_tracks.empty())
return true;
// Apply downsampler independently to each
for (std::vector< std::vector< Point<float> > >::iterator i = cropped_tracks.begin(); i != cropped_tracks.end(); ++i)
downsampler (*i);
if (cropped_tracks.size() == 1) {
cropped_tracks[0].swap (out);
return true;
}
// Stitch back together in preparation for sending down queue as a single track
out.push_back (Point<float>());
for (std::vector< std::vector< Point<float> > >::const_iterator i = cropped_tracks.begin(); i != cropped_tracks.end(); ++i) {
for (std::vector< Point<float> >::const_iterator p = i->begin(); p != i->end(); ++p)
out.push_back (*p);
out.push_back (Point<float>());
}
out.push_back (Point<float>());
return true;
} else {
if (!inverse) {
downsampler (tck);
tck.swap (out);
}
return true;
}
}
