int main(int argc, char **argv)
{
QCoreApplication app(argc, argv);
QCoreApplication::setApplicationName("Problemsolver");
QCoreApplication::setApplicationVersion("0.0.1");
QCommandLineParser parser;
parser.setApplicationDescription("Problem Problem solver using OptiX.");
parser.addHelpOption();
parser.addVersionOption();
parser.addPositionalArgument("source", "Problem definition input file.");
QCommandLineOption deviceOption(QStringList() << "d" << "device", "Device number id. Use -l to list devices.", "device", "0");
QCommandLineOption listOption(QStringList() << "l" << "list", "List present CUDA devices in the machine.");
parser.addOption(deviceOption);
parser.addOption(listOption);
parser.process(app);
const QStringList args = parser.positionalArguments();
if(args.isEmpty())
{
std::cerr << "Missing source parameter" << std::endl;
parser.showHelp(1);
}
QString inputPath = args.first();
if(parser.isSet(listOption)) // -l, then list available devices.
{
listDevices();
exit(0);
}
// parse -d option
bool parseOk;
int deviceNumber = parser.value(deviceOption).toInt(&parseOk);
if(!parseOk)
{
std::cerr << "Expect a number for device option." << std::endl;
parser.showHelp(1);
}
if(deviceNumber < 0)
{
std::cerr << "Option --device(-d) can't be negative." << std::endl;
parser.showHelp(1);
}
// find and check selected device
ComputeDeviceRepository repository;
const std::vector<ComputeDevice> & repo = repository.getComputeDevices();
if(repo.empty())
{
std::cerr << "No computing device found"
"You must have a CUDA enabled GPU to run this application. "
"The CUDA GPUs nVidia developer page(https://developer.nvidia.com/cuda-gpus) has a "
"list of all supported devices." << std::endl;
exit(1);
}
if(deviceNumber >= repo.size())
{
std::cerr << "Invalid device number " << deviceNumber << "." << std::endl
<< "Try -l to list available computing devices." << std::endl;
exit(1);
}
ComputeDevice device = repo.at(deviceNumber);
// Task parented to the application so that it
// will be deleted by the application.
Main *main = new Main(&app, inputPath, device);
// This will cause the application to exit when
// the task signals finished.
QObject::connect(main, SIGNAL(finished()), &app, SLOT(quit()));
// This will run the task from the application event loop.
QTimer::singleShot(0, main, SLOT(run()));
return app.exec();
}
QSharedPointer<CaptureDevice> TimeLapseCapture::parseArguments() {
QCommandLineParser parser;
ErrorMessageHelper die(err.device(), &parser);
parser.setApplicationDescription("Tool for capture sequence of images from digital camera (V4L or GPhoto2 API).");
parser.addHelpOption();
parser.addVersionOption();
QCommandLineOption outputOption(QStringList() << "o" << "output",
QCoreApplication::translate("main", "Output directory."),
QCoreApplication::translate("main", "directory"));
parser.addOption(outputOption);
QCommandLineOption verboseOption(QStringList() << "V" << "verbose",
QCoreApplication::translate("main", "Verbose output."));
parser.addOption(verboseOption);
QCommandLineOption deviceOption(QStringList() << "d" << "device",
QCoreApplication::translate("main", "Capture device."),
QCoreApplication::translate("main", "device"));
parser.addOption(deviceOption);
QCommandLineOption listOption(QStringList() << "l" << "list",
QCoreApplication::translate("main", "List available capture devices and exits."));
parser.addOption(listOption);
QCommandLineOption intervalOption(QStringList() << "i" << "interval",
QCoreApplication::translate("main", "Capture interval (in milliseconds). Default is 10000."),
QCoreApplication::translate("main", "interval"));
parser.addOption(intervalOption);
QCommandLineOption cntOption(QStringList() << "c" << "count",
QCoreApplication::translate("main", "How many images should be captured. Default value is infinite."),
QCoreApplication::translate("main", "count"));
parser.addOption(cntOption);
QCommandLineOption rowOption(QStringList() << "r" << "raw",
QCoreApplication::translate("main", "Store all captured images in raw."));
parser.addOption(rowOption);
QCommandLineOption getShutterSpeedOption(QStringList() << "s" << "shutterspeed-options",
QCoreApplication::translate("main", "Prints available shutterspeed setting choices and exits."));
parser.addOption(getShutterSpeedOption);
QCommandLineOption adaptiveShutterSpeedOption(QStringList() << "a" << "adaptive-shutterspeed",
QCoreApplication::translate("main",
"Camera shutterspeed will be adaptively changed after exposure metering.\n"
"This option setup how many images should be used for exposure metering. \n"
"Default value is 0 - it means that shutterspeed will not be changed by capture tool."
),
QCoreApplication::translate("main", "count"));
parser.addOption(adaptiveShutterSpeedOption);
QCommandLineOption shutterSpeedStepOption(QStringList() << "shutterspeed-step",
QCoreApplication::translate("main",
"How large should be step when changing shutterspeed. \n"
"Default value is 1."
),
QCoreApplication::translate("main", "step"));
parser.addOption(shutterSpeedStepOption);
QCommandLineOption minShutterSpeedOption(QStringList() << "min-shutterspeed",
QCoreApplication::translate("main", "Minimum shutterspeed (fastest shutter) used by adaptive shutterspeed"),
QCoreApplication::translate("main", "shutterspeed"));
parser.addOption(minShutterSpeedOption);
QCommandLineOption maxShutterSpeedOption(QStringList() << "max-shutterspeed",
QCoreApplication::translate("main",
"Maximum shutterspeed (slowest shutter) used by adaptive shutterspeed.\n"
"If camera supports BULB shutterspeed, it can be defined as \"BULB:XX\" here (it means bulb with XX s exposure)."
),
QCoreApplication::translate("main", "shutterspeed"));
parser.addOption(maxShutterSpeedOption);
// Process the actual command line arguments given by the user
parser.process(*this);
// verbose?
if (!parser.isSet(verboseOption)) {
blackHole = new BlackHoleDevice();
verboseOutput.setDevice(blackHole);
} else {
// verbose
verboseOutput << "Turning on verbose output..." << endl;
verboseOutput << applicationName() << " " << applicationVersion() << endl;
}
// raw?
storeRawImages = parser.isSet(rowOption);
// interval
if (parser.isSet(intervalOption)) {
bool ok = false;
long i = parser.value(intervalOption).toLong(&ok);
if (!ok) die << "Cant parse interval.";
if (i <= 0) die << "Interval have to be possitive";
interval = i;
}
// count
if (parser.isSet(cntOption)) {
bool ok = false;
int i = parser.value(cntOption).toInt(&ok);
if (!ok) die << "Cant parse count.";
cnt = i;
}
// list devices?
QList<QSharedPointer < CaptureDevice>> devices = listDevices();
QSharedPointer<CaptureDevice> dev;
if (parser.isSet(listOption)) {
if (devices.isEmpty()) {
die << QCoreApplication::translate("main", "No compatible capture device found");
} else {
out << "Found devices: " << endl;
for (QSharedPointer<CaptureDevice> d : devices) {
out << " " << d->toString() << endl;
}
}
std::exit(0);
}
// capture device
bool assigned = false;
if (!parser.isSet(deviceOption)) {
verboseOutput << "Found devices: " << endl;
for (QSharedPointer<CaptureDevice> d : devices) {
if (!assigned) {
dev = d;
assigned = true;
}
verboseOutput << " " << d->toString() << endl;
}
if (!assigned)
die << "No supported device.";
} else {
QString devVal = parser.value(deviceOption);
for (QSharedPointer<CaptureDevice> d : devices) {
if (d->toString().contains(devVal, Qt::CaseInsensitive)) {
assigned = true;
dev = d;
break;
}
}
if (!assigned) {
die << QString("No device matching \"%1\" found.").arg(devVal);
}
}
out << "Using device " << dev->toString() << endl;
// getShutterSpeedOption ?
QList<ShutterSpeedChoice> choices = dev->getShutterSpeedChoices();
if (parser.isSet(getShutterSpeedOption)) {
if (choices.isEmpty()) {
err << "Device " << dev->toShortString() << " don't support shutterspeed setting" << endl;
} else {
out << "Device " << dev->toShortString() << " shutterspeed choices:" << endl;
for (ShutterSpeedChoice ch : choices) {
out << " " << ch.toString() << endl;
}
out << "Current shutter speed: " << dev->currentShutterSpeed().toString() << endl;
}
std::exit(0);
}
// automatic chutter speed
// this functionality is experimental!
if (parser.isSet(adaptiveShutterSpeedOption)) {
bool ok = false;
int changeThreshold = parser.value(adaptiveShutterSpeedOption).toInt(&ok);
if (!ok) die << "Cant parse adaptive shutterspeed option.";
if (changeThreshold > 0) {
if (choices.isEmpty()) {
die << "Camera don't support shutterspeed setting.";
} else {
ShutterSpeedChoice currentShutterSpeed;
ShutterSpeedChoice minShutterSpeed;
ShutterSpeedChoice maxShutterSpeed;
currentShutterSpeed = dev->currentShutterSpeed();
minShutterSpeed = choices.first();
for (ShutterSpeedChoice ch : choices) {
if ((!ch.isBulb()) && ch.toMicrosecond() > maxShutterSpeed.toMicrosecond())
maxShutterSpeed = ch;
}
int shutterSpeedStep = 1;
if (parser.isSet(shutterSpeedStepOption)) {
bool ok = false;
shutterSpeedStep = parser.value(shutterSpeedStepOption).toInt(&ok);
if (!ok) die << "Cant parse shutterspeed step.";
if (shutterSpeedStep < 1) die << "Shutterspeed step can be less than one.";
}
if (parser.isSet(minShutterSpeedOption)) {
QString optStr = parser.value(minShutterSpeedOption);
minShutterSpeed = getShutterSpeed(optStr, choices, &die);
}
if (parser.isSet(maxShutterSpeedOption)) {
QString optStr = parser.value(maxShutterSpeedOption);
maxShutterSpeed = getShutterSpeed(optStr, choices, &die);
}
out << "Using automatic shutter speed:" << endl;
out << " current shutter speed: " << currentShutterSpeed.toString() << endl;
out << " min shutter speed: " << minShutterSpeed.toString() << endl;
out << " max shutter speed: " << maxShutterSpeed.toString() << endl;
out << " change threshold: " << changeThreshold << endl;
out << " change step: " << shutterSpeedStep << endl;
if (minShutterSpeed.toMicrosecond() <= 0
|| maxShutterSpeed.toMicrosecond() <= 0
|| maxShutterSpeed.toMicrosecond() < minShutterSpeed.toMicrosecond())
die << "Invalid shutter speed configurarion";
if (maxShutterSpeed.toMs() > interval) {
err << QString("Warning: Maximum shutter speed (%1 ms) is greater than capture interval (%2 ms)!")
.arg(maxShutterSpeed.toMs())
.arg(interval) << endl;
}
shutterSpdAlg = new MatrixMeteringAlg(choices, currentShutterSpeed, minShutterSpeed, maxShutterSpeed,
&err, &verboseOutput, changeThreshold, shutterSpeedStep);
}
}
}
// output
if (!parser.isSet(outputOption))
die << "Output directory is not set";
output = QDir(parser.value(outputOption));
if (output.exists())
err << "Output directory exists already." << endl;
if (!output.mkpath("."))
die << QString("Can't create output directory %1 !").arg(output.path());
return dev;
}
QT_USE_NAMESPACE
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
QCommandLineParser parser;
parser.setApplicationDescription(QLatin1String("winrtrunner installs, runs, and collects test "
"results for packages made with Qt."));
parser.addPositionalArgument(QStringLiteral("package [arguments]"),
QLatin1String("The executable or package manifest to act upon. "
"Arguments after the package name will be passed "
"to the application when it starts."));
QCommandLineOption testOption(QStringLiteral("test"),
QLatin1String("Install, start, collect output, stop (if needed), "
"and uninstall the package. This is the "
"default action of winrtrunner."));
parser.addOption(testOption);
QCommandLineOption startOption(QStringLiteral("start"),
QLatin1String("Start the package. The package is installed if "
"it is not already installed. Pass --install to "
"force reinstallation."));
parser.addOption(startOption);
QCommandLineOption debugOption(QStringLiteral("debug"),
QLatin1String("Start the package with the debugger attached. "
"The package is installed if it is not already "
"installed. Pass --install to force "
"reinstallation."),
QLatin1Literal("debugger"));
parser.addOption(debugOption);
QCommandLineOption debuggerArgumentsOption(QStringLiteral("debugger-arguments"),
QLatin1String("Arguments that are passed to the "
"debugger when --debug is used. If no "
"debugger was provided this option is "
"ignored."),
QLatin1String("arguments"));
parser.addOption(debuggerArgumentsOption);
QCommandLineOption suspendOption(QStringLiteral("suspend"),
QLatin1String("Suspend a running package. When combined "
"with --stop or --test, the app will be "
"suspended before being terminated."));
parser.addOption(suspendOption);
QCommandLineOption stopOption(QStringLiteral("stop"),
QLatin1String("Terminate a running package. Can be be "
"combined with --start and --suspend."));
parser.addOption(stopOption);
QCommandLineOption waitOption(QStringLiteral("wait"),
QLatin1String("If the package is running, waits the given "
"number of seconds before continuing to the next "
"task. Passing 0 causes the runner to wait "
"indefinitely."),
QStringLiteral("seconds"));
parser.addOption(waitOption);
QCommandLineOption installOption(QStringLiteral("install"),
QStringLiteral("(Re)installs the package."));
parser.addOption(installOption);
QCommandLineOption removeOption(QStringLiteral("remove"),
QStringLiteral("Uninstalls the package."));
parser.addOption(removeOption);
QCommandLineOption deviceOption(QStringLiteral("device"),
QLatin1String("Specifies the device to target as a device name "
" or index. Use --list-devices to find available "
"devices. The default device is the first device "
"found for the active run profile."),
QStringLiteral("name|index"));
parser.addOption(deviceOption);
QCommandLineOption profileOption(QStringLiteral("profile"),
QStringLiteral("Force a particular run profile."),
QStringLiteral("name"));
parser.addOption(profileOption);
QCommandLineOption listDevicesOption(QStringLiteral("list-devices"),
QLatin1String("List the available devices "
"(for use with --device)."));
parser.addOption(listDevicesOption);
QCommandLineOption verbosityOption(QStringLiteral("verbose"),
QLatin1String("The verbosity level of the message output "
"(0 - silent, 1 - info, 2 - debug). Defaults to 1."),
QStringLiteral("level"), QStringLiteral("1"));
parser.addOption(verbosityOption);
QCommandLineOption ignoreErrorsOption(QStringLiteral("ignore-errors"),
QStringLiteral("Always exit with code 0, regardless of the error state."));
parser.addOption(ignoreErrorsOption);
parser.addHelpOption();
parser.setSingleDashWordOptionMode(QCommandLineParser::ParseAsLongOptions);
QStringList arguments = QCoreApplication::arguments();
parser.parse(arguments);
QStringList filterRules = QStringList() // Default logging rules
<< QStringLiteral("qt.winrtrunner.warning=true")
<< QStringLiteral("qt.winrtrunner.critical=true")
<< QStringLiteral("qt.winrtrunner.app=true");
if (parser.isSet(verbosityOption)) {
bool ok;
uint verbosity = parser.value(verbosityOption).toUInt(&ok);
if (!ok || verbosity > 2) {
qCCritical(lcWinRtRunner) << "Incorrect value specified for verbosity.";
parser.showHelp(1);
}
switch (verbosity) {
case 2: // Enable debug print
filterRules.append(QStringLiteral("qt.winrtrunner.debug=true"));
break;
case 1: // Remove warnings
filterRules.removeFirst();
// fall through
case 0: // Silent
filterRules.removeFirst();
// fall through
default: // Impossible
break;
}
}
QLoggingCategory::setFilterRules(filterRules.join(QLatin1Char('\n')));
if (parser.isSet(listDevicesOption)) {
std::wcout << "Available devices:\n";
const QMap<QString, QStringList> deviceNames = Runner::deviceNames();
foreach (const QString &profile, deviceNames.keys()) {
std::wcout << reinterpret_cast<const wchar_t *>(profile.utf16()) << ":\n";
int index = 0;
foreach (const QString &device, deviceNames.value(profile)) {
std::wcout << " " << index++ << ' '
<< reinterpret_cast<const wchar_t *>(device.utf16()) << '\n';
}
}
std::wcout << std::endl;
return 0;
}
