int main(int argc, char* argv[]) {
// show which dimension this executable is handling
cout << argv[0] << " with dimension = " << __Dim << endl;
Options opts;
opts.addOption("-o", "Specify a filename for an output image", SO_REQ_SEP);
opts.addOption("--fusion", "label fusion from a config", "`--fusion config-file output-file target-image`", SO_REQ_SEP);
opts.addOption("--overlap", "Compute the overlap ratio (dice|jaccard). This option can take two or arguments. The first argument is a gold standard, and other arguments are multiple number of label images to be compared.", "--overlap dice output-text ref1 ref2-1 ref2-2 ... ref2-n", SO_REQ_SEP);
opts.addOption("--p2mat", "point list to matrix", SO_NONE);
opts.addOption("--slice", "extract a slice from 3d volume", "--slice dim index imagefile outputfile", SO_NONE);
opts.addOption("--imageMerge", "merge 2D images into a 3d volume (--imageMerge output input1 input2 ...)", SO_REQ_SEP);
opts.addOption("--qa", "extract a slice with a label map", SO_NONE);
opts.addOption("--config", "[file] use this config file", SO_REQ_SEP);
opts.addOption("--demons", "run Demons registration", SO_NONE);
opts.addOption("--separate", "[input] [x] [y] [z] ... separate vector images into individual image files", SO_NONE);
opts.addOption("--rx", "registration experiments ", SO_NONE);
opts.addOption("--dots", "--rx --dots generate a series of gaussian dot images", SO_NONE);
opts.addOption("--sigma", "sigma value [double]", "--sigma 0.8", SO_REQ_SEP);
opts.addOption("--entropyImage", "Compute an entropy image from a set of given images", "`--entropyImage -o output.nrrd input1.nrrd input2.nrrd ...`", SO_NONE);
opts.addOption("--test", "Run in a test mode. The test mode is context sensitive depending on the given argument. For example, if `--entropyImage --test` is given, it will automatically provide a set of input images and produce an output into a specific directory.", SO_NONE);
opts.addOption("--distanceMap", "Compute the Danielsson's distance map. This will also generate distmag.nrrd, x.nrrd, y.nrrd, and z.nrrd that stores the component of the vector distance map for debugging purpose.", "--distanceMap input output-vector output-magnitude", SO_NONE);
opts.addOption("--help", "print this message", SO_NONE);
opts.ParseOptions(argc, argv, NULL);
StringVector& args = opts.GetStringVector("args");
if (opts.GetBool("--help") || opts.GetBool("-h")) {
cout << "## ParticleRun Command Line Options" << endl;
opts.PrintUsage();
return 0;
}
particle2mat(opts, args);
doSlice(opts, args);
doSeparate(opts, args);
if (opts.GetBool("--qa")) {
executeQARunner(opts, args);
} else if (opts.GetString("--imageMerge", "") != "" && args.size() > 0) {
doMerge(opts, args);
} else if (opts.GetBool("--demons")) {
executeDemonsRunner(opts, args);
} else if (opts.GetBool("--rx")) {
executeRxRunner(opts, args);
} else if (opts.GetString("--fusion", "") != "") {
executeLabelFusionRunner(opts, args);
} else if (opts.GetBool("--entropyImage")) {
executeEntropyImage(opts, args);
} else if (opts.GetString("--overlap") == "dice" || opts.GetString("--overlap") == "jaccard") {
executeVolumeOverlaps(opts, args);
} else if (opts.GetBool("--distanceMap")) {
executeComputeDistanceMap(opts, args);
} else {
executeParticleRunner(opts, args);
}
}
int main(int argc, char* argv[]) {
CSimpleOpt::SOption specs[] = {
{ 9, "--seeConfig", SO_NONE },
{ 1000, "--json", SO_REQ_SEP },
{ 1001, "--config", SO_REQ_SEP },
{ 1002, "--run", SO_NONE },
{ 1, "-w", SO_NONE },
{ 8, "-d", SO_NONE },
{ 2, "-o", SO_REQ_SEP },
{ 3, "--mean", SO_NONE },
{ 4, "--srcidx", SO_REQ_SEP },
{ 7, "--dstidx", SO_REQ_SEP },
{ 6, "--noTrace", SO_NONE },
{ 10, "--markTrace", SO_NONE },
{ 23, "--markOutput", SO_NONE },
{ 11, "--srcsubj", SO_REQ_SEP },
{ 12, "--inputimage", SO_REQ_SEP },
{ 13, "--inputlabel", SO_REQ_SEP },
{ 14, "--normalize", SO_NONE },
{ 15, "--magnitude", SO_NONE },
{ 16, "--distancemap", SO_NONE },
{ 17, "--createmask", SO_NONE },
{ 18, "--rescaletoshort", SO_NONE },
{ 19, "--mask", SO_REQ_SEP },
{ 20, "--align", SO_NONE },
{ 21, "--warp", SO_NONE },
{ 22, "--norigidalign", SO_NONE },
{ 24, "--onlyrigidalign", SO_NONE },
{ 25, "--showpoints", SO_NONE },
{ 26, "--eval", SO_NONE },
{ 27, "--histo", SO_NONE },
{ 28, "--nbin", SO_NONE },
{ 29, "--rmin", SO_NONE },
{ 30, "--rmax", SO_NONE },
{ 31, "--removeborder", SO_NONE },
{ 32, "--size", SO_REQ_SEP },
{ 33, "--traceWarp", SO_NONE },
{ 34, "--interval", SO_REQ_SEP },
{ 35, "--zerocrossing", SO_NONE },
{ 36, "--meanwarp", SO_NONE },
{ 41, "--magnitude2", SO_NONE },
{ 42, "--vector2mat", SO_NONE },
// Experiment #1
{ 37, "--expr1", SO_NONE },
{ 39, "--expr2", SO_NONE },
{ 40, "--bspline2d", SO_NONE },
{ 43, "--particleExpr", SO_NONE },
// Image Processing
{ 100, "--doGaussian", SO_REQ_SEP },
{ 101, "--doBlur2", SO_NONE },
{ 102, "--ellipse", SO_NONE },
{ 103, "--affineReg", SO_NONE },
{ 104, "--gradhist", SO_NONE },
{ 105, "--testgradreg", SO_NONE },
{ 106, "--gradmag", SO_NONE },
{ 107, "--transform2", SO_NONE },
{ 108, "--boundingbox", SO_NONE },
{ 109, "--crop", SO_REQ_SEP },
{ 110, "--slice", SO_NONE },
{ 111, "--padding", SO_REQ_SEP },
{ 112, "--deform", SO_NONE },
{ 113, "--testdisplacementfield", SO_NONE },
{ 114, "--distmap2contour", SO_NONE },
// Test Main
{ 200, "--newuoa", SO_NONE },
{ 201, "--boost", SO_NONE },
{ 202, "--testconfig", SO_NONE },
// Particle Tools
{ 300, "--coverlabel", SO_NONE },
{ 301, "--p2mat", SO_NONE },
// Options Test
{ 400, "--testjson", SO_NONE },
// PatchCompare
{ 500, "--demons", SO_NONE },
{ 501, "--makeGradientPatch", SO_NONE },
{ 502, "--opticalFlow", SO_NONE },
{ 503, "--patchtest", SO_NONE },
SO_END_OF_OPTIONS
};
cout << argv[0] << " version compiled at " << __TIMESTAMP__ << endl;
Options parser;
parser.ParseOptions(argc, argv, specs);
StringVector& args = parser.GetStringVector("args");
string output = parser.GetString("-o", "");
ParticleSystemSolver solver;
ParticleSystem& system = solver.m_System;
Options& options = solver.m_Options;
srcIdx = atoi(parser.GetString("--srcidx", "1").c_str());
dstIdx = atoi(parser.GetString("--dstidx", "0").c_str());
if (parser.GetBool("--run")) {
executeParticleRunner(parser, args);
return 0;
} else if (parser.GetBool("--demons")) {
executeDemonsRunner(parser, args);
} else if (parser.GetBool("--expr1")) {
runExpr1(args);
} else if (parser.GetBool("--expr2")) {
runExpr2(args);
} else if (parser.GetBool("--bspline2d")) {
runBspline2D(args);
} else if (parser.GetBool("--vector2mat")) {
runVector2Mat(args);
} else if (parser.GetBool("--particleExpr")) {
runParticleExperiments(args);
} else if (parser.GetBool("--seeConfig")) {
solver.LoadConfig(args[0].c_str());
cout << "Option Contents:\n\n" << options << endl;
if (args.size() > 1) {
solver.SaveConfig(args[1].c_str());
}
} else if (parser.GetBool("-w", false)) {
if (args.size() < 1 || output == "") {
cout << "warping requires [config.txt] -o [outputimage]" << endl;
return 0;
}
// load data
solver.LoadConfig(args[0].c_str());
// bspline resampling
ParticleBSpline particleTransform;
particleTransform.SetReferenceImage(solver.m_System[0].GetLabel());
int srcIdx = atoi(parser.GetString("--srcidx", "1").c_str());
int dstIdx = atoi(parser.GetString("--dstidx", "0").c_str());
if (parser.GetBool("--mean")) {
system.ComputeXMeanSubject();
particleTransform.EstimateTransform(system.GetMeanSubject(), system[srcIdx]);
} else {
cout << "warping from " << srcIdx << " to " << dstIdx << endl;
particleTransform.EstimateTransform(system[dstIdx], system[srcIdx]);
}
string input = parser.GetString("--inputimage", "");
string label = parser.GetString("--inputlabel", "");
cout << parser << endl;
bool doingSomething = false;
if (label != "") {
// write image
ImageIO<LabelImage> io;
LabelImage::Pointer outputImage = particleTransform.WarpLabel(io.ReadImage(label.c_str()));
io.WriteImage(output.c_str(), outputImage);
doingSomething = true;
}
if (input != "") {
ImageIO<RealImage> io;
RealImage::Pointer outputImage = particleTransform.WarpImage(io.ReadImage(input.c_str()));
io.WriteImage(output.c_str(), outputImage);
doingSomething = true;
}
if (!doingSomething) {
cout << "-w requires --inputimage or --inputlabel to warp" << endl;
}
} else if (parser.GetBool("--warp")) {
if (args.size() < 2) {
cout << "--warp requires [output.txt] --inputimage|inputlabel [source-image] --reference [reference] [warped-output-image]" << endl;
return 0;
}
PRINT_IDX();
string outputName = args[1];
string inputImage, inputLabel, refImageName;
parser.GetStringTo("--inputimage", inputImage);
parser.GetStringTo("--inputlabel", inputLabel);
parser.GetStringTo("--reference", refImageName);
solver.LoadConfig(args[0].c_str());
if (system.size() < 2) {
cout << "system is not loaded successfully" << endl;
return 0;
}
if (inputImage != "") {
RealImage::Pointer refImage;
// warp from srcidx to dstidx
if (refImageName != "") {
refImage = realIO.ReadImage(refImageName.c_str());
}
RealImage::Pointer output = warp_image<RealImage>(system[dstIdx], system[srcIdx], realIO.ReadImage(inputImage.c_str()), refImage, false, parser.GetBool("--norigidalign"), parser.GetBool("--onlyrigidalign"));
realIO.WriteImage(outputName.c_str(), output);
}
if (inputLabel != "") {
LabelImage::Pointer refImage;
// warp from srcidx to dstidx
if (refImageName != "") {
refImage = labelIO.ReadImage(refImageName.c_str());
}
LabelImage::Pointer output = warp_image<LabelImage>(system[dstIdx], system[srcIdx], labelIO.ReadImage(inputLabel.c_str()), refImage, true, parser.GetBool("--norigidalign"), parser.GetBool("--onlyrigidalign"));
labelIO.WriteImage(outputName.c_str(), output);
}
} else if (parser.GetBool("--meanwarp")) {
if (args.size() < 2) {
cout << "--meanwarp requires [output.txt] --inputimage|--inputlabel [source-image] [warped-output-image]" << endl;
return 0;
}
PRINT_IDX();
string outputName = args[1];
string inputImage, inputLabel, refImageName;
parser.GetStringTo("--inputimage", inputImage);
parser.GetStringTo("--inputlabel", inputLabel);
parser.GetStringTo("--reference", refImageName);
solver.LoadConfig(args[0].c_str());
ParticleSubject meanSubj = system.ComputeXMeanSubject();
if (system.size() < 2) {
cout << "system is not loaded successfully" << endl;
return 0;
}
if (inputImage != "") {
RealImage::Pointer refImage;
// warp from srcidx to dstidx
if (refImageName != "") {
refImage = realIO.ReadImage(refImageName.c_str());
}
RealImage::Pointer output = warp_image<RealImage>(meanSubj, system[srcIdx], realIO.ReadImage(inputImage.c_str()), refImage, false, parser.GetBool("--norigidalign"), parser.GetBool("--onlyrigidalign"));
realIO.WriteImage(outputName.c_str(), output);
}
if (inputLabel != "") {
LabelImage::Pointer refImage;
// warp from srcidx to dstidx
if (refImageName != "") {
refImage = labelIO.ReadImage(refImageName.c_str());
}
LabelImage::Pointer output = warp_image<LabelImage>(meanSubj, system[srcIdx], labelIO.ReadImage(inputLabel.c_str()), refImage, true, parser.GetBool("--norigidalign"), parser.GetBool("--onlyrigidalign"));
labelIO.WriteImage(outputName.c_str(), output);
}
} else if (parser.GetBool("--markTrace")) {
if (args.size() < 2) {
cout << "--meanwarp requires [output.txt] [reference-image] [output-image] --srcidx [point-index] --srcsubj [subject-index]" << endl;
return 0;
}
ifstream in(args[0].c_str());
ParticleTrace trace;
trace.Read(in);
in.close();
cout << trace << endl;
int srcIdx = atoi(parser.GetString("--srcidx", "-1").c_str());
int srcSubj = atoi(parser.GetString("--srcsubj", "-1").c_str());
ImageIO<LabelImage> io;
LabelImage::Pointer ref = io.ReadImage(args[1].c_str());
LabelImage::Pointer canvas = io.NewImage(ref);
for (int i = 0; i < trace.system.size(); i++) {
if (srcSubj == -1 || srcSubj == i) {
for (int j = 0; j < trace.system[i].timeSeries.size(); j++) {
for (int k = 0; k <= trace.system[i].maxIdx; k++) {
if (srcIdx == -1 || srcIdx == k) {
Particle& p = trace.system[i].timeSeries[j][k];
IntIndex idx;
fordim (l) {
idx[l] = p.x[l] + 0.5;
}
(*canvas)[idx] = j;
}
}
}
}
}
} else if (parser.GetBool("--markOutput")) {
