//******************************************************************************
// Main
//******************************************************************************
int main(int argc, char **argv) {
args::ArgumentParser parser("Checks if images are different within a tolerance.\n"
"Intended for use with library tests.\n"
"http://github.com/spinicist/QUIT");
args::HelpFlag help(parser, "HELP", "Show this help message", {'h', "help"});
args::Flag verbose(parser, "VERBOSE", "Print more information", {'v', "verbose"});
args::ValueFlag<std::string> input_path(parser, "INPUT", "Input file for difference",
{"input"});
args::ValueFlag<std::string> baseline_path(parser, "BASELINE", "Baseline file for difference",
{"baseline"});
args::ValueFlag<double> tolerance(parser, "TOLERANCE", "Tolerance (mean percent difference)",
{"tolerance"}, 0);
args::ValueFlag<double> noise(parser, "NOISE",
"Added noise level, tolerance is relative to this", {"noise"}, 0);
args::Flag absolute(parser, "ABSOLUTE",
"Use absolute difference, not relative (avoids 0/0 problems)",
{'a', "abs"});
QI::ParseArgs(parser, argc, argv, verbose);
auto input = QI::ReadImage(QI::CheckValue(input_path), verbose);
auto baseline = QI::ReadImage(QI::CheckValue(baseline_path), verbose);
auto diff = itk::SubtractImageFilter<QI::VolumeF>::New();
diff->SetInput1(input);
diff->SetInput2(baseline);
auto sqr_norm = itk::SquareImageFilter<QI::VolumeF, QI::VolumeF>::New();
if (absolute) {
sqr_norm->SetInput(diff->GetOutput());
} else {
auto diff_norm = itk::DivideImageFilter<QI::VolumeF, QI::VolumeF, QI::VolumeF>::New();
diff_norm->SetInput1(diff->GetOutput());
diff_norm->SetInput2(baseline);
diff_norm->Update();
sqr_norm->SetInput(diff_norm->GetOutput());
}
auto stats = itk::StatisticsImageFilter<QI::VolumeF>::New();
stats->SetInput(sqr_norm->GetOutput());
stats->Update();
const double mean_sqr_diff = stats->GetMean();
const double root_mean_sqr_diff = sqrt(mean_sqr_diff);
const double rel_diff =
(noise.Get() > 0) ? root_mean_sqr_diff / noise.Get() : root_mean_sqr_diff;
const bool passed = rel_diff <= tolerance.Get();
QI::Log(verbose, "Mean Square Diff: {}\nRelative noise: {}\nSquare-root mean square diff: {}\nRelative Diff: {}\nTolerance: {}\nResult: ", mean_sqr_diff
,noise.Get()
, root_mean_sqr_diff
, rel_diff
, tolerance.Get()
, (passed ? "Passed" : "Failed"));
if (passed) {
return EXIT_SUCCESS;
} else {
return EXIT_FAILURE;
}
}
bool RDCartSlot::breakAway(unsigned msecs)
{
bool ret=false;
unsigned cartnum=0;
if(slot_options->mode()==RDSlotOptions::BreakawayMode) {
if(msecs==0) {
stop();
SetInput(true);
unload();
slot_box->setService(slot_svcname);
slot_box->setStatusLine(tr("Waiting for break..."));
}
else {
cartnum=SelectCart(slot_svcname,msecs);
if(cartnum!=0) {
switch(slot_deck->state()) {
case RDPlayDeck::Playing:
case RDPlayDeck::Paused:
case RDPlayDeck::Stopping:
slot_breakaway_cart=cartnum;
slot_breakaway_length=msecs;
stop();
break;
case RDPlayDeck::Stopped:
case RDPlayDeck::Finished:
SetInput(false);
if(slot_timescaling_active) {
load(cartnum,msecs);
}
else {
load(cartnum);
}
play();
syslog(LOG_INFO,"started breakaway, len: %u cart: %u cut: %d",
msecs,cartnum,slot_logline->cutNumber());
break;
}
}
else {
slot_box->setStatusLine(tr("No cart found for length")+" "+
RDGetTimeLength(msecs,false,false));
}
}
}
return ret;
}
HRESULT XMLReader::LoadFromBuffer(const BYTE* pBuffer, UINT nLen)
{
CComPtr<IStream> pFileStream;
m_nError = S_OK;
//on ia64 there is no definiton of SHCreateMemStream therfore
//we load it dynamicly from dll file
typedef struct IStream *(STDAPICALLTYPE *CreateMemStream)(__in_bcount_opt(cbInit) const BYTE *pInit, UINT cbInit);
HINSTANCE hInst = ::GetModuleHandleA("SHLWAPI.DLL");
if (NULL == hInst) {
m_nError = S_FALSE;
return m_nError;
}
//12 it's an ordinal for SHCreateMemStream function
CreateMemStream pfMemStream = reinterpret_cast<CreateMemStream>(GetProcAddress(hInst, reinterpret_cast<LPCSTR>(LOWORD(12))));
if (NULL == pfMemStream) {
m_nError = S_FALSE;
return m_nError;
}
pFileStream = (*pfMemStream)(pBuffer, nLen);
if (NULL == pFileStream) {
m_nError = S_FALSE;
}
else {
SetInput(pFileStream);
}
return m_nError;
}
signal_renderer::signal_renderer(const double& sample_frequency,
const double& window_duration)
: m_sample_frequency(sample_frequency),
m_window_duration(window_duration),
m_size(m_sample_frequency*window_duration),
m_data(m_size,m_size,0.0), // capacity, size, value
m_time(gammatone::detail::linspace(0.0,m_window_duration,m_size)),
m_table(decltype(m_table)::New()),
m_xaxis(decltype(m_xaxis)::New()),
m_signal(decltype(m_signal)::New()),
m_view(decltype(m_view)::New()),
m_chart(decltype(m_chart)::New())
{
m_xaxis->SetName("time (s)");
m_signal->SetName("signal");
m_xaxis->SetArray(m_time.data(),m_time.size(),1);
m_signal->SetArray(m_data.linearize(),m_data.size(),1);
m_table->AddColumn(m_xaxis);
m_table->AddColumn(m_signal);
m_view->GetRenderer()->SetBackground(1.0, 1.0, 1.0);
m_view->GetScene()->AddItem(m_chart);
auto line = m_chart->AddPlot(vtkChart::LINE);
line->SetInput(m_table,0,1);
line->SetColor(255, 0, 0, 255);
line->SetWidth(1.0);
}
void WinFrame::ShowDemo()
{
static int n;
static const char* demos[] =
{
"5 + (6! - 8^3)*2.5",
"x = 6",
"y = z = x*2",
"x+y+z",
"log 10 + 26",
"100!",
"10^10^10",
"3---8",
"|3---8|",
"sin pi/2 + sqrt(1 + (2^-12)*2)",
"sum[i=1, 10](i*2 - 2^i)",
"cross([1, 2, 3], [4, 5, 6])",
"| [0, -1, 2] - [4, 0.5, 3] |",
nullptr
};
/* Set next demo */
if (!demos[n])
n = 0;
SetInput(demos[n]);
ExecExpr(demos[n]);
++n;
}
int LoadAsn (AsnInfo *asn) {
/* Arguments:
** input i: Name of input file or image
** asn io: Association info structure
*/
extern int status;
void printInfo (AsnInfo *);
int SetInput (AsnInfo *);
int SetAsnSingle (AsnInfo *);
int GetAsnTable (AsnInfo *);
int GetGlobalInfo (AsnInfo *);
/* Determine whether input is a single file, an association table,
** or an entry from an association table. */
if (SetInput (asn))
return (status);
if (asn->process == FULL) {
sprintf (MsgText,"LoadAsn: Processing FULL Association");
} else if (asn->process == PARTIAL) {
sprintf (MsgText,"LoadAsn: Processing PART of Association");
} else {
sprintf (MsgText,"LoadAsn: Processing SINGLE exposure");
}
trlmessage (MsgText);
/* Read in global info from ASN table's primary header */
if (GetGlobalInfo (asn)) {
trlerror (" Problem getting primary header information.");
return (status);
}
/* Read in ASN table, and load appropriate members info into memory */
if (asn->process == SINGLE) {
/* Set ASN structure values to process a single exposure */
if (SetAsnSingle (asn))
return (status);
} else {
if (GetAsnTable (asn))
return (status);
}
if (asn->debug) {
sprintf (MsgText,"LoadAsn: Read in ASN table %s ", asn->asn_table);
trlmessage (MsgText);
}
/* Print a summary of information about the association */
if (asn->verbose)
printInfo (asn);
return (status);
}
void TrainNet(NET* Net)
{
INT n,t;
POLE Pole;
REAL wOld, wNew, ScoreOld, ScoreNew, dScore, dScoreMean, StepSize;
REAL Input[N];
REAL Output[M];
REAL Target[M];
n = 0;
while (n<TRAIN_STEPS) {
t = 0;
InitializePole(&Pole);
fprintf(f, " Time Angle Force\n");
fprintf(f, "%4.1fs %5.1f° %5.1fN\n", t * T, Pole.w, Pole.F);
wOld = Pole.w;
ScoreOld = ScoreOfPole(&Pole);
SimulatePole(&Pole);
wNew = Pole.w;
ScoreNew = ScoreOfPole(&Pole);
while (PoleStillBalanced(&Pole) AND (t<BALANCED)) {
n++;
t++;
Net->Alpha = 0.5 * pow(0.01, (REAL) n / TRAIN_STEPS);
Net->Alpha_ = 0.5 * pow(0.01, (REAL) n / TRAIN_STEPS);
Net->Alpha__ = 0.005;
Net->Gamma = 0.05;
Net->Sigma = 6.0 * pow(0.2, (REAL) n / TRAIN_STEPS);
Input[0] = wOld;
Input[1] = wNew;
SetInput(Net, Input);
PropagateNet(Net);
GetOutput(Net, Output);
Pole.F = Output[0];
StepSize = Net->KohonenLayer->StepSize[Net->Winner];
Pole.F += StepSize * RandomNormalREAL(0, 10);
fprintf(f, "%4.1fs %5.1f° %5.1fN\n", t * T, Pole.w, Pole.F);
wOld = Pole.w;
ScoreOld = ScoreOfPole(&Pole);
SimulatePole(&Pole);
wNew = Pole.w;
ScoreNew = ScoreOfPole(&Pole);
dScore = ScoreNew - ScoreOld;
dScoreMean = Net->KohonenLayer->dScoreMean[Net->Winner];
if (dScore > dScoreMean) {
Target[0] = Pole.F;
TrainUnits(Net, Input, Target);
}
Net->KohonenLayer->dScoreMean[Net->Winner] += Net->Gamma * (dScore - dScoreMean);
}
if (PoleStillBalanced(&Pole))
fprintf(f, "Pole still balanced after %0.1fs ...\n\n", t * T);
else
fprintf(f, "Pole fallen after %0.1fs ...\n\n", (t+1) * T);
}
}
void CHveditDlg::OnSelchangeListChannels()
{
int n;
n = m_ctlChannels.GetSelItems(m_nChannels, m_Selection);
if (n > 0) {
m_Voltage = m_Demand[ChannelIndex(m_Selection[0])];
SetInput();
}
}
bool WinFrame::ExecExpr(const std::string& expr)
{
/* If expression is empty -> show information */
if (expr.empty())
ShowIntro();
else if (expr == "exit")
{
/* Clear input to avoid storing "exit" in the config-file */
SetInput("");
Close();
}
else if (expr == "demo")
ShowDemo();
else if (expr == "const")
ShowConstants();
else if (expr == "clear")
{
constantsSet_.constants.clear();
constantsSet_.ResetStd();
ShowConstants();
}
else
{
/* Setup compute mode */
Ac::ComputeMode mode;
mode.degree = GetOptionDegree();
/* Show status message */
SetOutput("computing ...");
#ifdef AC_MULTI_THREADED
/* Wait until previous thread has successfully terminated */
if (computing_)
return false;
JoinThread();
#endif
/* Compute expression */
#ifdef AC_MULTI_THREADED
computing_ = true;
thread_ = std::unique_ptr<std::thread>(new std::thread(&WinFrame::ComputeThreadProc, this, expr, mode));
#else
ComputeThreadProc(expr.ToStdString(), mode);
#endif
}
return true;
}
HRESULT XMLReader::LoadFromFile(const std::wstring& sFileName)
{
CComPtr<IStream> pFileStream;
m_nError = S_OK;
if (!FAILED(m_nError = SHCreateStreamOnFile(sFileName.c_str(), STGM_READ, &pFileStream)))
{
SetInput(pFileStream);
}
return m_nError;
}
void SimulateNet(NET* Net, INT* Input, INT* Target, BOOL Training, BOOL Protocoling)
{
INT Output[M];
SetInput(Net, Input, Protocoling);
PropagateNet(Net);
GetOutput(Net, Output, Protocoling);
ComputeOutputError(Net, Target);
if (Training)
AdjustWeights(Net);
}
void SimulateNet(NET* Net, REAL* Input, REAL* Output, REAL* Target, BOOL Training)
{
SetInput(Net, Input);
PropagateNet(Net);
GetOutput(Net, Output);
ComputeOutputError(Net, Target);
if (Training) {
BackpropagateNet(Net);
AdjustWeights(Net);
}
}
void VolumeRayCastMapper::SetInput(int port, vtkDataSet *genericInput)
{
vtkImageData *input =
vtkImageData::SafeDownCast(genericInput);
if (input)
{
SetInput(port, input);
}
else
{
vtkErrorMacro("The SetInput method of this mapper requires vtkImageData as input");
}
}
string FlowAnalysis::vtkWriteGrid(const string& out, vtkSmartPointer<vtkUniformGrid>& grid){
auto compressor=vtkSmartPointer<vtkZLibDataCompressor>::New();
auto writer=vtkSmartPointer<vtkXMLImageDataWriter>::New();
string fn=scene->expandTags(out)+".vti";
writer->SetFileName(fn.c_str());
#if VTK_MAJOR_VERSION==5
writer->SetInput(grid);
#else
writer->SetInputData(grid);
#endif
// writer->SetDataModeToAscii();
writer->SetCompressor(compressor);
writer->Write();
return fn;
}
void RDCartSlot::updateOptions()
{
slot_deck->setCard(slot_options->card());
slot_deck->setPort(slot_options->outputPort());
switch(slot_options->mode()) {
case RDSlotOptions::CartDeckMode:
SetInput(false);
slot_logline->setHookMode(slot_options->hookMode());
if(slot_options->hookMode()) {
slot_options_button->setText(tr("Options")+"\n"+tr("[Hook]"));
}
else {
slot_options_button->setText(tr("Options")+"\n"+tr("[Full]"));
}
break;
case RDSlotOptions::BreakawayMode:
SetInput(true);
slot_start_button->setDisabled(true);
slot_box->setService(slot_svcname);
slot_box->setStatusLine(tr("Waiting for break..."));
slot_load_button->setText(tr("Load"));
slot_logline->setHookMode(false);
slot_options_button->setText(tr("Options")+"\n"+tr("[Breakaway]"));
break;
case RDSlotOptions::LastMode:
break;
}
slot_box->setMode(slot_options->mode());
slot_options->save();
if(slot_logline->cartNumber()!=0) {
load(slot_logline->cartNumber());
}
}
void write_vtk_file(const Domain<lattice_model>& domain, const std::string& output_dir,
const std::string& output_filename, uint64_t t)
{
const auto xl = domain.xlength();
const auto yl = domain.ylength();
const auto zl = domain.zlength();
// Compute point coordinates
auto points = vtkSmartPointer<vtkPoints>::New();
compute_coordinates(domain, points);
// Compute velocity and density vectors
auto velocities = vtkSmartPointer<vtkDoubleArray>::New();
auto densities = vtkSmartPointer<vtkDoubleArray>::New();
velocities->SetNumberOfComponents(lattice_model::D);
densities->SetNumberOfComponents(1);
velocities->SetName("Velocity");
densities->SetName("Density");
for (auto z = 1u; z < zl + 1; ++z) {
for (auto y = 1u; y < yl + 1; ++y) {
for (auto x = 1u; x < xl + 1; ++x) {
auto current_cell = domain.cell(x, y, z);
auto density = current_cell.density();
auto vel = current_cell.velocity(density);
densities->InsertNextTuple1(density);
velocities->InsertNextTuple3(vel[0], vel[1], vel[2]);
}
}
}
// Create a grid and write coordinates and velocity/density
auto structuredGrid = vtkSmartPointer<vtkStructuredGrid>::New();
structuredGrid->SetDimensions(xl, yl, zl);
structuredGrid->SetPoints(points);
structuredGrid->GetPointData()->SetVectors(velocities);
structuredGrid->GetPointData()->SetScalars(densities);
// Save filename as a combination of passed filename and timestep
std::stringstream sstr;
sstr << output_dir << "/" << output_filename << "." << t << ".vts";
// Write file
auto writer = vtkSmartPointer<vtkXMLStructuredGridWriter>::New();
writer->SetFileName(sstr.str().c_str());
writer->SetInput(structuredGrid);
writer->Write();
}
void TechBot::eventManager(std::string str)
{
SavePrevevent();
setEvent(str);
Saveinput();
SetInput(str);
if(!same_event())
{
selectMatch();
}
restore_input();
}
static void AddOffset(const itk::Image<TPixel, VImageDimension>* inputImage, int offset, mitk::Image::Pointer outputImage)
{
typedef itk::Image<TPixel, VImageDimension> ImageType;
typedef itk::ShiftScaleImageFilter<ImageType, ImageType> FilterType;
auto filter = FilterType::New();
filter->SetInput(inputImage);
filter->SetShift(offset);
filter->Update();
// This is the tricky part that is done wrong very often. As the image data
// of ITK images and MITK images are binary compatible, we don't need to
// cast or copy the ITK output image. Instead, we just want to reference
// the image data and tell ITK that we took the ownership.
mitk::GrabItkImageMemory(filter->GetOutput(), outputImage);
}
uint TYL40Adc::Read(const int& InputN) {
TLock Lock(CriticalSection);
EAssert(FileDesc >= 0);
Notify->OnNotifyFmt(TNotifyType::ntInfo, "Reading YL-40 input %d ...", InputN);
SetInput(InputN);
uchar Val;
int Read;
for (int ReadN = 0; ReadN < 2; ReadN++) {
Read = read(FileDesc, &Val, 1);
EAssertR(Read == 1, "Failed to read YL-40!");
usleep(PROCESSING_DELAY);
}
return (uint) Val;
}
void SmoothedClassProbabilites< TImage>
::GenerateData()
{
typename TImage::Pointer out = this->GetOutput(0);
out->SetRegions(this->GetInput(0)->GetLargestPossibleRegion());
out->Allocate();
for(unsigned int i = 0 ; i < this->GetNumberOfInputs(); i++)
{
auto gf = itk::DiscreteGaussianImageFilter<TImage,TImage>::New();
gf->SetInput(this->GetInput(i));
gf->SetVariance(this->m_Sigma);
gf->Update();
ImageRegionConstIterator<TImage> git(gf->GetOutput(),gf->GetOutput()->GetLargestPossibleRegion());
ImageRegionIterator<TImage> maskiter(m_MaskImage, m_MaskImage->GetLargestPossibleRegion());
ImageRegionIterator<TImage> outputIter(out, out->GetLargestPossibleRegion());
while (!outputIter.IsAtEnd())
{
if(maskiter.Value() > 0 ){
if(git.Value() > outputIter.Value())
outputIter.Set(i);
}else
{
outputIter.Set(0);
}
++git;
++outputIter;
++maskiter;
}
}
}
void CHveditDlg::Increment(const float incr)
{
int n, i;
// Get current selection
n = m_ctlChannels.GetSelItems(m_nChannels, m_Selection);
// Set voltage to selected channels
for (i = 0; i < n; i++)
m_Demand[ChannelIndex(m_Selection[i])] = max(0, m_Demand[ChannelIndex(m_Selection[i])] + incr);
if (n > 0)
m_Voltage = m_Demand[ChannelIndex(m_Selection[0])];
SetInput();
UpdateODB(n == 1 ? ChannelIndex(m_Selection[0]) : -1);
UpdateListBox(n == 1 ? m_Selection[0] : -1);
}
VOID
ChangeInput(
PGLOBAL_DEVICE_INFO pGDI,
UCHAR Input,
UCHAR Output,
USHORT Channel,
USHORT Old,
USHORT New
)
/*++
Routine Description
Change an input gradually from its current value to its target value
NOTE - this routine ASSUMES that each input has 32 steps
--*/
{
USHORT Current, Final;
Current = Old >> 11;
Final = New >> 11;
/*
** At least once to get the output amp right
*/
while (TRUE) {
SetInput(pGDI,
Input,
(USHORT)(Current << 11),
Channel,
MIXCROSSCAPS_NORMAL_STEREO,
Output);
if (Current == Final) {
break;
}
Current = Current > Final ? Current - 1 : Current + 1;
}
}
vtkSmartPointer<vtkPolyData> VoxelCarving::createVisualHull(
const double isolevel) const {
// create vtk visualization pipeline from voxel grid
auto spoints = vtkSmartPointer<vtkStructuredPoints>::New();
auto vdim = static_cast<int>(voxel_dim_);
spoints->SetDimensions(vdim, vdim, vdim);
spoints->SetSpacing(params_.voxel_width, params_.voxel_height,
params_.voxel_depth);
spoints->SetOrigin(params_.start_x, params_.start_y, params_.start_z);
auto farray = vtkSmartPointer<vtkFloatArray>::New();
auto vsize = static_cast<vtkIdType>(voxel_size_);
farray->SetNumberOfValues(vsize);
farray->SetArray(vox_array_.get(), vsize, 1);
spoints->GetPointData()->SetScalars(farray);
// create iso surface with marching cubes
auto mc_source = vtkSmartPointer<vtkMarchingCubes>::New();
#if VTK_MAJOR_VERSION < 6
mc_source->SetInput(spoints);
#else
mc_source->SetInputData(spoints);
#endif
mc_source->SetNumberOfContours(1);
mc_source->SetValue(0, isolevel);
// calculate surface normals
auto surface_normals = vtkSmartPointer<vtkPolyDataNormals>::New();
surface_normals->SetInputConnection(mc_source->GetOutputPort());
surface_normals->SetFeatureAngle(60.0);
surface_normals->ComputePointNormalsOn();
surface_normals->Update();
return surface_normals->GetOutput();
}
nsAutoCompleteController::~nsAutoCompleteController()
{
SetInput(nsnull);
}
C3DFileAdapter::OutputTables
C3DFileAdapter::extendRead(const std::string& fileName) const {
auto reader = btk::AcquisitionFileReader::New();
reader->SetFilename(fileName);
reader->Update();
auto acquisition = reader->GetOutput();
OutputTables tables{};
auto& marker_table = *(new TimeSeriesTableVec3{});
auto& force_table = *(new TimeSeriesTableVec3{});
tables.emplace(_markers,
std::shared_ptr<TimeSeriesTableVec3>(&marker_table));
tables.emplace(_forces,
std::shared_ptr<TimeSeriesTableVec3>(&force_table));
auto marker_pts = btk::PointCollection::New();
for(auto it = acquisition->BeginPoint();
it != acquisition->EndPoint();
++it) {
auto pt = *it;
if(pt->GetType() == btk::Point::Marker)
marker_pts->InsertItem(pt);
}
if(marker_pts->GetItemNumber() != 0) {
marker_table.
updTableMetaData().
setValueForKey("DataRate",
std::to_string(acquisition->GetPointFrequency()));
marker_table.
updTableMetaData().
setValueForKey("Units",
acquisition->GetPointUnit());
ValueArray<std::string> marker_labels{};
for(auto it = marker_pts->Begin();
it != marker_pts->End();
++it) {
marker_labels.
upd().
push_back(SimTK::Value<std::string>((*it)->GetLabel()));
}
TimeSeriesTableVec3::DependentsMetaData marker_dep_metadata{};
marker_dep_metadata.setValueArrayForKey("labels", marker_labels);
marker_table.setDependentsMetaData(marker_dep_metadata);
double time_step{1.0 / acquisition->GetPointFrequency()};
for(int f = 0;
f < marker_pts->GetFrontItem()->GetFrameNumber();
++f) {
SimTK::RowVector_<SimTK::Vec3> row{marker_pts->GetItemNumber()};
int m{0};
for(auto it = marker_pts->Begin();
it != marker_pts->End();
++it) {
auto pt = *it;
row[m++] = SimTK::Vec3{pt->GetValues().coeff(f, 0),
pt->GetValues().coeff(f, 1),
pt->GetValues().coeff(f, 2)};
}
marker_table.appendRow(0 + f * time_step, row);
}
}
// This is probably the right way to get the raw forces data from force
// platforms. Extract the collection of force platforms.
auto force_platforms_extractor = btk::ForcePlatformsExtractor::New();
force_platforms_extractor->SetInput(acquisition);
auto force_platform_collection = force_platforms_extractor->GetOutput();
force_platforms_extractor->Update();
std::vector<SimTK::Matrix_<double>> fpCalMatrices{};
std::vector<SimTK::Matrix_<double>> fpCorners{};
std::vector<SimTK::Matrix_<double>> fpOrigins{};
std::vector<unsigned> fpTypes{};
auto fp_force_pts = btk::PointCollection::New();
auto fp_moment_pts = btk::PointCollection::New();
auto fp_position_pts = btk::PointCollection::New();
for(auto platform = force_platform_collection->Begin();
platform != force_platform_collection->End();
++platform) {
const auto& calMatrix = (*platform)->GetCalMatrix();
const auto& corners = (*platform)->GetCorners();
const auto& origins = (*platform)->GetOrigin();
fpCalMatrices.push_back(convertToSimtkMatrix(calMatrix));
fpCorners.push_back(convertToSimtkMatrix(corners));
fpOrigins.push_back(convertToSimtkMatrix(origins));
fpTypes.push_back(static_cast<unsigned>((*platform)->GetType()));
// Get ground reaction wrenches for the force platform.
auto ground_reaction_wrench_filter =
btk::GroundReactionWrenchFilter::New();
ground_reaction_wrench_filter->SetInput(*platform);
auto wrench_collection = ground_reaction_wrench_filter->GetOutput();
ground_reaction_wrench_filter->Update();
for(auto wrench = wrench_collection->Begin();
wrench != wrench_collection->End();
++wrench) {
// Forces time series.
fp_force_pts->InsertItem((*wrench)->GetForce());
// Moment time series.
fp_moment_pts->InsertItem((*wrench)->GetMoment());
// Position time series.
fp_position_pts->InsertItem((*wrench)->GetPosition());
}
}
//shrik<btk::ForcePlatform::Origin> foo;
if(fp_force_pts->GetItemNumber() != 0) {
force_table.
updTableMetaData().
setValueForKey("CalibrationMatrices", std::move(fpCalMatrices));
force_table.
updTableMetaData().
setValueForKey("Corners", std::move(fpCorners));
force_table.
updTableMetaData().
setValueForKey("Origins", std::move(fpOrigins));
force_table.
updTableMetaData().
setValueForKey("Types", std::move(fpTypes));
force_table.
updTableMetaData().
setValueForKey("DataRate",
std::to_string(acquisition->GetAnalogFrequency()));
ValueArray<std::string> labels{};
ValueArray<std::string> units{};
for(int fp = 1; fp <= fp_force_pts->GetItemNumber(); ++fp) {
auto fp_str = std::to_string(fp);
labels.upd().push_back(SimTK::Value<std::string>("f" + fp_str));
auto force_unit = acquisition->GetPointUnits().
at(_unit_index.at("force"));
units.upd().push_back(SimTK::Value<std::string>(force_unit));
labels.upd().push_back(SimTK::Value<std::string>("m" + fp_str));
auto moment_unit = acquisition->GetPointUnits().
at(_unit_index.at("moment"));
units.upd().push_back(SimTK::Value<std::string>(moment_unit));
labels.upd().push_back(SimTK::Value<std::string>("p" + fp_str));
auto position_unit = acquisition->GetPointUnits().
at(_unit_index.at("marker"));
units.upd().push_back(SimTK::Value<std::string>(position_unit));
}
TimeSeriesTableVec3::DependentsMetaData force_dep_metadata{};
force_dep_metadata.setValueArrayForKey("labels", labels);
force_dep_metadata.setValueArrayForKey("units", units);
force_table.setDependentsMetaData(force_dep_metadata);
double time_step{1.0 / acquisition->GetAnalogFrequency()};
for(int f = 0;
f < fp_force_pts->GetFrontItem()->GetFrameNumber();
++f) {
SimTK::RowVector_<SimTK::Vec3>
row{fp_force_pts->GetItemNumber() * 3};
int col{0};
for(auto fit = fp_force_pts->Begin(),
mit = fp_moment_pts->Begin(),
pit = fp_position_pts->Begin();
fit != fp_force_pts->End();
++fit,
++mit,
++pit) {
row[col] = SimTK::Vec3{(*fit)->GetValues().coeff(f, 0),
(*fit)->GetValues().coeff(f, 1),
(*fit)->GetValues().coeff(f, 2)};
++col;
row[col] = SimTK::Vec3{(*mit)->GetValues().coeff(f, 0),
(*mit)->GetValues().coeff(f, 1),
(*mit)->GetValues().coeff(f, 2)};
++col;
row[col] = SimTK::Vec3{(*pit)->GetValues().coeff(f, 0),
(*pit)->GetValues().coeff(f, 1),
(*pit)->GetValues().coeff(f, 2)};
++col;
}
force_table.appendRow(0 + f * time_step, row);
}
}
EventTable event_table{};
auto events = acquisition->GetEvents();
for(auto it = events->Begin();
it != events->End();
++it) {
auto et = *it;
event_table.push_back({et->GetLabel(),
et->GetTime(),
et->GetFrame(),
et->GetDescription()});
}
marker_table.updTableMetaData().setValueForKey("events", event_table);
force_table.updTableMetaData().setValueForKey("events", event_table);
return tables;
}
int main(int argc, char **argv) {
args::ArgumentParser parser(
"Calculates T1/B1 maps from MP2/3-RAGE data\nhttp://github.com/spinicist/QUIT");
args::Positional<std::string> input_path(parser, "INPUT FILE", "Path to complex MP-RAGE data");
args::HelpFlag help(parser, "HELP", "Show this help message", {'h', "help"});
args::Flag verbose(parser, "VERBOSE", "Print more information", {'v', "verbose"});
args::ValueFlag<int> threads(parser,
"THREADS",
"Use N threads (default=4, 0=hardware limit)",
{'T', "threads"},
QI::GetDefaultThreads());
args::ValueFlag<std::string> outarg(
parser, "OUTPREFIX", "Add a prefix to output filenames", {'o', "out"});
args::ValueFlag<std::string> json_file(
parser, "FILE", "Read JSON input from file instead of stdin", {"file"});
args::ValueFlag<float> beta_arg(
parser,
"BETA",
"Regularisation factor for robust contrast calculation "
"(https://journals.plos.org/plosone/article?id=10.1371/journal.pone.0099676)",
{'b', "beta"},
0.0);
args::Flag t1(parser, "T1", "Calculate T1 map via spline look-up", {'t', "t1"});
QI::ParseArgs(parser, argc, argv, verbose, threads);
auto inFile = QI::ReadImage<QI::SeriesXF>(QI::CheckPos(input_path), verbose);
auto ti_1 = itk::ExtractImageFilter<QI::SeriesXF, QI::VolumeXF>::New();
auto ti_2 = itk::ExtractImageFilter<QI::SeriesXF, QI::VolumeXF>::New();
auto region = inFile->GetLargestPossibleRegion();
region.GetModifiableSize()[3] = 0;
ti_1->SetExtractionRegion(region);
ti_1->SetDirectionCollapseToSubmatrix();
ti_1->SetInput(inFile);
region.GetModifiableIndex()[3] = 1;
ti_2->SetExtractionRegion(region);
ti_2->SetDirectionCollapseToSubmatrix();
ti_2->SetInput(inFile);
QI::Log(verbose, "Generating MP2 contrasts");
using BinaryFilter = itk::BinaryGeneratorImageFilter<QI::VolumeXF, QI::VolumeXF, QI::VolumeF>;
auto MP2Filter = BinaryFilter::New();
MP2Filter->SetInput1(ti_1->GetOutput());
MP2Filter->SetInput2(ti_2->GetOutput());
const float &beta = beta_arg.Get();
MP2Filter->SetFunctor([&](const std::complex<float> &p1, const std::complex<float> &p2) {
return MP2Contrast(p1, p2, beta);
});
MP2Filter->Update();
const std::string out_prefix = outarg ? outarg.Get() : QI::StripExt(input_path.Get());
QI::WriteImage(MP2Filter->GetOutput(), out_prefix + "_MP2" + QI::OutExt(), verbose);
if (t1) {
QI::Log(verbose, "Reading sequence information");
rapidjson::Document input =
json_file ? QI::ReadJSON(json_file.Get()) : QI::ReadJSON(std::cin);
QI::MP2RAGESequence mp2rage_sequence(input["MP2RAGE"]);
QI::Log(verbose, "Building look-up spline");
int num_entries = 100;
Eigen::ArrayXd T1_values = Eigen::ArrayXd::LinSpaced(num_entries, 0.25, 4.0);
Eigen::ArrayXd MP2_values(num_entries);
for (int i = 0; i < num_entries; i++) {
const auto sig = One_MP2RAGE(1., T1_values[i], 1., mp2rage_sequence);
const float mp2 = MP2Contrast(sig[0], sig[1]);
if ((i > 0) && (mp2 > MP2_values[i - 1])) {
num_entries = i;
break;
} else {
MP2_values[i] = mp2;
}
}
QI::Log(verbose, "Lookup table length = {}", num_entries);
QI::SplineInterpolator mp2_to_t1(MP2_values.head(num_entries), T1_values.head(num_entries));
if (beta) {
QI::Log(verbose, "Recalculating unregularised MP2 image");
MP2Filter->SetFunctor(
[&](const std::complex<float> &p1, const std::complex<float> &p2) {
return MP2Contrast(p1, p2, 0.0);
});
MP2Filter->Update();
}
using UnaryFilter = itk::UnaryGeneratorImageFilter<QI::VolumeF, QI::VolumeF>;
auto T1LookupFilter = UnaryFilter::New();
T1LookupFilter->SetInput(MP2Filter->GetOutput());
auto lookup = [&](const float &p) { return mp2_to_t1(p); };
T1LookupFilter->SetFunctor(lookup);
QI::Log(verbose, "Calculating T1");
T1LookupFilter->Update();
QI::WriteImage(T1LookupFilter->GetOutput(), out_prefix + "_MP2_T1" + QI::OutExt(), verbose);
}
QI::Log(verbose, "Finished.");
return EXIT_SUCCESS;
}
int main(int argc, char **argv)
{
int i;
int phonetic = 0;
char* wavfilename = NULL;
unsigned char input[256];
memset(input, 0, 256);
if (argc <= 1)
{
PrintUsage();
return 1;
}
i = 1;
while(i < argc)
{
if (argv[i][0] != '-')
{
strcat_s((char*)input, 256, argv[i]);
strcat_s((char*)input, 256, " ");
} else
{
if (strcmp(&argv[i][1], "wav")==0)
{
wavfilename = argv[i+1];
i++;
} else
if (strcmp(&argv[i][1], "sing")==0)
{
EnableSingmode();
} else
if (strcmp(&argv[i][1], "phonetic")==0)
{
phonetic = 1;
} else
if (strcmp(&argv[i][1], "debug")==0)
{
debug = 1;
} else
if (strcmp(&argv[i][1], "pitch")==0)
{
SetPitch((unsigned char)min(atoi(argv[i+1]),255));
i++;
} else
if (strcmp(&argv[i][1], "speed")==0)
{
SetSpeed((unsigned char)min(atoi(argv[i+1]),255));
i++;
} else
if (strcmp(&argv[i][1], "mouth")==0)
{
SetMouth((unsigned char)min(atoi(argv[i+1]),255));
i++;
} else
if (strcmp(&argv[i][1], "throat")==0)
{
SetThroat((unsigned char)min(atoi(argv[i+1]),255));
i++;
} else
{
PrintUsage();
return 1;
}
}
i++;
} //while
for(i=0; input[i] != 0; i++)
input[i] = (unsigned char)toupper((int)input[i]);
if (debug)
{
if (phonetic) printf("phonetic input: %s\n", input);
else printf("text input: %s\n", input);
}
if (!phonetic)
{
strcat_s((char*)input, 256, "[");
if (!TextToPhonemes(input)) return 1;
if (debug)
printf("phonetic input: %s\n", input);
} else strcat_s((char*)input, 256, "\x9b");
#ifdef USESDL
if ( SDL_Init(SDL_INIT_AUDIO) < 0 )
{
printf("Unable to init SDL: %s\n", SDL_GetError());
exit(1);
}
atexit(SDL_Quit);
#endif
SetInput(input);
if (!SAMMain())
{
PrintUsage();
return 1;
}
if (wavfilename != NULL)
WriteWav(wavfilename, GetBuffer(), GetBufferLength()/50);
else
OutputSound();
return 0;
}
void RDCartSlot::stateChangedData(int id,RDPlayDeck::State state)
{
//printf("stateChangedData(%d,%d)\n",id,state);
short lvls[2]={-10000,-10000};
switch(state) {
case RDPlayDeck::Playing:
LogPlayout(state);
slot_start_button->
setEnabled(slot_options->mode()==RDSlotOptions::CartDeckMode);
slot_start_button->setPalette(slot_playing_color);
slot_load_button->setDisabled(true);
slot_options_button->setDisabled(true);
break;
case RDPlayDeck::Stopped:
case RDPlayDeck::Finished:
LogPlayout(state);
slot_start_button->
setEnabled(slot_options->mode()==RDSlotOptions::CartDeckMode);
slot_start_button->setPalette(slot_ready_color);
slot_load_button->setEnabled(true);
slot_options_button->setEnabled(true);
slot_box->setTimer(0);
slot_box->updateMeters(lvls);
slot_box->setCart(slot_logline);
switch(slot_options->mode()) {
case RDSlotOptions::CartDeckMode:
if(!slot_stop_requested) {
switch(slot_options->stopAction()) {
case RDSlotOptions::RecueOnStop:
break;
case RDSlotOptions::UnloadOnStop:
unload();
break;
case RDSlotOptions::LoopOnStop:
play();
break;
case RDSlotOptions::LastStop:
break;
}
}
break;
case RDSlotOptions::BreakawayMode:
if(slot_breakaway_cart>0) {
SetInput(false);
load(slot_breakaway_cart);
play();
syslog(LOG_INFO,"started breakaway, len: %u cart: %u cut: %d",
slot_breakaway_length,slot_breakaway_cart,
slot_logline->cutNumber());
slot_breakaway_cart=0;
slot_breakaway_length=0;
}
else {
SetInput(true);
unload();
slot_box->setService(slot_svcname);
slot_box->setStatusLine(tr("Waiting for break..."));
// LogPlayout(RDAirPlayConf::TrafficFinish);
}
break;
case RDSlotOptions::LastMode:
break;
}
slot_stop_requested=false;
break;
case RDPlayDeck::Stopping:
case RDPlayDeck::Paused:
break;
}
}
void DiPostEffectPass::RefreshInput()
{
SetInput(mInput.first,mInput.second);
}
C3DFileAdapter::OutputTables
C3DFileAdapter::extendRead(const std::string& fileName) const {
auto reader = btk::AcquisitionFileReader::New();
reader->SetFilename(fileName);
reader->Update();
auto acquisition = reader->GetOutput();
EventTable event_table{};
auto events = acquisition->GetEvents();
for (auto it = events->Begin();
it != events->End();
++it) {
auto et = *it;
event_table.push_back({ et->GetLabel(),
et->GetTime(),
et->GetFrame(),
et->GetDescription() });
}
OutputTables tables{};
auto marker_pts = btk::PointCollection::New();
for(auto it = acquisition->BeginPoint();
it != acquisition->EndPoint();
++it) {
auto pt = *it;
if(pt->GetType() == btk::Point::Marker)
marker_pts->InsertItem(pt);
}
if(marker_pts->GetItemNumber() != 0) {
int marker_nrow = marker_pts->GetFrontItem()->GetFrameNumber();
int marker_ncol = marker_pts->GetItemNumber();
std::vector<double> marker_times(marker_nrow);
SimTK::Matrix_<SimTK::Vec3> marker_matrix(marker_nrow, marker_ncol);
std::vector<std::string> marker_labels{};
for (auto it = marker_pts->Begin(); it != marker_pts->End(); ++it) {
marker_labels.push_back(SimTK::Value<std::string>((*it)->GetLabel()));
}
double time_step{1.0 / acquisition->GetPointFrequency()};
for(int f = 0; f < marker_nrow; ++f) {
SimTK::RowVector_<SimTK::Vec3> row{ marker_pts->GetItemNumber(),
SimTK::Vec3(SimTK::NaN) };
int m{0};
for(auto it = marker_pts->Begin(); it != marker_pts->End(); ++it) {
auto pt = *it;
// BTK reads empty values as zero, but sets a "residual" value
// to -1 and it is how it knows to export these values as
// blank, instead of 0, when exporting to .trc
// See: BTKCore/Code/IO/btkTRCFileIO.cpp#L359-L360
// Read in value if it is not zero or residual is not -1
if (!pt->GetValues().row(f).isZero() || //not precisely zero
(pt->GetResiduals().coeff(f) != -1) ) {//residual is not -1
row[m] = SimTK::Vec3{ pt->GetValues().coeff(f, 0),
pt->GetValues().coeff(f, 1),
pt->GetValues().coeff(f, 2) };
}
++m;
}
marker_matrix.updRow(f) = row;
marker_times[f] = 0 + f * time_step; //TODO: 0 should be start_time
}
// Create the data
auto marker_table =
std::make_shared<TimeSeriesTableVec3>(marker_times,
marker_matrix,
marker_labels);
marker_table->
updTableMetaData().
setValueForKey("DataRate",
std::to_string(acquisition->GetPointFrequency()));
marker_table->
updTableMetaData().
setValueForKey("Units",
acquisition->GetPointUnit());
marker_table->updTableMetaData().setValueForKey("events", event_table);
tables.emplace(_markers, marker_table);
}
// This is probably the right way to get the raw forces data from force
// platforms. Extract the collection of force platforms.
auto force_platforms_extractor = btk::ForcePlatformsExtractor::New();
force_platforms_extractor->SetInput(acquisition);
auto force_platform_collection = force_platforms_extractor->GetOutput();
force_platforms_extractor->Update();
std::vector<SimTK::Matrix_<double>> fpCalMatrices{};
std::vector<SimTK::Matrix_<double>> fpCorners{};
std::vector<SimTK::Matrix_<double>> fpOrigins{};
std::vector<unsigned> fpTypes{};
auto fp_force_pts = btk::PointCollection::New();
auto fp_moment_pts = btk::PointCollection::New();
auto fp_position_pts = btk::PointCollection::New();
for(auto platform = force_platform_collection->Begin();
platform != force_platform_collection->End();
++platform) {
const auto& calMatrix = (*platform)->GetCalMatrix();
const auto& corners = (*platform)->GetCorners();
const auto& origins = (*platform)->GetOrigin();
fpCalMatrices.push_back(convertToSimtkMatrix(calMatrix));
fpCorners.push_back(convertToSimtkMatrix(corners));
fpOrigins.push_back(convertToSimtkMatrix(origins));
fpTypes.push_back(static_cast<unsigned>((*platform)->GetType()));
// Get ground reaction wrenches for the force platform.
auto ground_reaction_wrench_filter =
btk::GroundReactionWrenchFilter::New();
ground_reaction_wrench_filter->setLocation(
btk::GroundReactionWrenchFilter::Location(getLocationForForceExpression()));
ground_reaction_wrench_filter->SetInput(*platform);
auto wrench_collection = ground_reaction_wrench_filter->GetOutput();
ground_reaction_wrench_filter->Update();
for(auto wrench = wrench_collection->Begin();
wrench != wrench_collection->End();
++wrench) {
// Forces time series.
fp_force_pts->InsertItem((*wrench)->GetForce());
// Moment time series.
fp_moment_pts->InsertItem((*wrench)->GetMoment());
// Position time series.
fp_position_pts->InsertItem((*wrench)->GetPosition());
}
}
if(fp_force_pts->GetItemNumber() != 0) {
std::vector<std::string> labels{};
ValueArray<std::string> units{};
for(int fp = 1; fp <= fp_force_pts->GetItemNumber(); ++fp) {
auto fp_str = std::to_string(fp);
labels.push_back(SimTK::Value<std::string>("f" + fp_str));
auto force_unit = acquisition->GetPointUnits().
at(_unit_index.at("force"));
units.upd().push_back(SimTK::Value<std::string>(force_unit));
labels.push_back(SimTK::Value<std::string>("p" + fp_str));
auto position_unit = acquisition->GetPointUnits().
at(_unit_index.at("marker"));
units.upd().push_back(SimTK::Value<std::string>(position_unit));
labels.push_back(SimTK::Value<std::string>("m" + fp_str));
auto moment_unit = acquisition->GetPointUnits().
at(_unit_index.at("moment"));
units.upd().push_back(SimTK::Value<std::string>(moment_unit));
}
const int nf = fp_force_pts->GetFrontItem()->GetFrameNumber();
std::vector<double> force_times(nf);
SimTK::Matrix_<SimTK::Vec3> force_matrix(nf, (int)labels.size());
double time_step{1.0 / acquisition->GetAnalogFrequency()};
for(int f = 0; f < nf; ++f) {
SimTK::RowVector_<SimTK::Vec3>
row{fp_force_pts->GetItemNumber() * 3};
int col{0};
for(auto fit = fp_force_pts->Begin(),
mit = fp_moment_pts->Begin(),
pit = fp_position_pts->Begin();
fit != fp_force_pts->End();
++fit,
++mit,
++pit) {
row[col] = SimTK::Vec3{(*fit)->GetValues().coeff(f, 0),
(*fit)->GetValues().coeff(f, 1),
(*fit)->GetValues().coeff(f, 2)};
++col;
row[col] = SimTK::Vec3{(*pit)->GetValues().coeff(f, 0),
(*pit)->GetValues().coeff(f, 1),
(*pit)->GetValues().coeff(f, 2)};
++col;
row[col] = SimTK::Vec3{(*mit)->GetValues().coeff(f, 0),
(*mit)->GetValues().coeff(f, 1),
(*mit)->GetValues().coeff(f, 2)};
++col;
}
force_matrix.updRow(f) = row;
force_times[f] = 0 + f * time_step; //TODO: 0 should be start_time
}
auto& force_table =
*(new TimeSeriesTableVec3(force_times, force_matrix, labels));
TimeSeriesTableVec3::DependentsMetaData force_dep_metadata
= force_table.getDependentsMetaData();
// add units to the dependent meta data
force_dep_metadata.setValueArrayForKey("units", units);
force_table.setDependentsMetaData(force_dep_metadata);
force_table.
updTableMetaData().
setValueForKey("CalibrationMatrices", std::move(fpCalMatrices));
force_table.
updTableMetaData().
setValueForKey("Corners", std::move(fpCorners));
force_table.
updTableMetaData().
setValueForKey("Origins", std::move(fpOrigins));
force_table.
updTableMetaData().
setValueForKey("Types", std::move(fpTypes));
force_table.
updTableMetaData().
setValueForKey("DataRate",
std::to_string(acquisition->GetAnalogFrequency()));
tables.emplace(_forces,
std::shared_ptr<TimeSeriesTableVec3>(&force_table));
force_table.updTableMetaData().setValueForKey("events", event_table);
}
return tables;
}
