void QfitReader::addArgs(ProgramArgs& args)
{
args.add("flip_coordinates", "Flip coordinates from 0-360 to -180-180",
m_flip_x);
args.add("scale_z", "Z scale. Use 0.001 to go from mm to m",
m_scale_z, 0.001);
}
void TIndexKernel::validateSwitches(ProgramArgs& args)
{
if (m_merge)
{
if (!m_wkt.empty() && !m_bounds.empty())
throw pdal_error("Can't specify both 'polygon' and "
"'bounds' options.");
if (!m_bounds.empty())
m_wkt = m_bounds.toWKT();
if (m_filespec.empty())
throw pdal_error("No output filename provided.");
StringList invalidArgs;
invalidArgs.push_back("a_srs");
invalidArgs.push_back("src_srs_name");
for (auto arg : invalidArgs)
if (args.set(arg))
{
std::ostringstream out;
out << "option '" << arg << "' not supported during merge.";
throw pdal_error(out.str());
}
}
else
{
if (m_filespec.empty() && !m_usestdin)
throw pdal_error("No input pattern specified");
if (args.set("polygon"))
throw pdal_error("'polygon' option not supported when building "
"index.");
if (args.set("bounds"))
throw pdal_error("'bounds' option not supported when building "
"index.");
}
}
void NumpyReader::addArgs(ProgramArgs& args)
{
args.add("dimension", "In an unstructured array, the dimension name to "
"map to values.", m_defaultDimension, "Intensity");
m_orderArg = &args.add("order", "Order of dimension interpretation "
"of the array. Either 'row'-major (C) or 'column'-major (Fortran)",
m_order);
}
void MyWriter::addArgs(ProgramArgs& args)
{
// setPositional() Makes the argument required.
args.add("filename", "Output filename", m_filename).setPositional();
args.add("newline", "Line terminator", m_newline, "\n");
args.add("datafield", "Data field", m_datafield, "UserData");
args.add("precision", "Precision", m_precision, 3);
}
void HeightAboveGroundKernel::addSwitches(ProgramArgs& args)
{
args.add("use_classification,c", "Use existing classification labels?",
m_use_classification);
args.add("input,i", "Input filename", m_input_file).setPositional();
args.add("ground,g", "Ground filename", m_ground_file).setPositional();
args.add("output,o",
"Output filename", m_output_file).setOptionalPositional();
}
void Kernel::outputHelp(ProgramArgs& args)
{
std::cout << "usage: " << "pdal " << m_appName << " [options] " <<
args.commandLine() << std::endl;
std::cout << "options:" << std::endl;
args.dump(std::cout, 2, Utils::screenWidth());
//ABELL - Fix me.
std::cout <<"\nFor more information, see the full documentation for "
"PDAL at http://pdal.io/\n" << std::endl;
}
TEST(OptionsTest, nan)
{
ProgramArgs args;
double value;
args.add("value", "Not a number", value);
Options ops;
ops.add("value", std::numeric_limits<double>::quiet_NaN());
StringList cmdline = ops.toCommandLine();
EXPECT_NO_THROW(args.parse(cmdline));
}
bool DimBuilder::parseArgs(int argc, char *argv[])
{
ProgramArgs args;
args.add("input,i", "Filename of JSON specification of "
"dimensions", m_input).setPositional();
args.add("output,o", "Filename of output of C++ header representation of "
"provided JSON.", m_output).setPositional();
try
{
args.parse(argc, argv);
}
catch (arg_error& err)
{
std::cerr << err.m_error << "\n";
return false;
}
return true;
}
void Kernel::doSwitches(int argc, const char *argv[], ProgramArgs& args)
{
StringList stringArgs;
OptionsMap& stageOptions = m_manager.stageOptions();
// Scan the argument vector for extra stage options. Pull them out and
// stick them in the list. Let the ProgramArgs handle everything else.
// NOTE: This depends on the format being "option=value" rather than
// "option value". This is what we've always expected, so no problem,
// but it would be better to be more flexible.
for (int i = 0; i < argc; ++i)
{
std::string stageName, opName, value;
if (parseOption(argv[i], stageName, opName, value))
{
Option op(opName, value);
stageOptions[stageName].add(op);
}
else
stringArgs.push_back(argv[i]);
}
try
{
addBasicSwitches(args);
// parseSimple allows us to scan for the help option without
// raising exception about missing arguments and so on.
args.parseSimple(stringArgs);
addSwitches(args);
if (!m_showHelp)
{
args.reset();
args.parse(stringArgs);
}
}
catch (arg_error& e)
{
throw pdal_error(e.m_error);
}
}
void App::outputOptions(std::string const& stageName, std::ostream& strm)
{
// Force plugin loading.
StageFactory f(false);
Stage* s = f.createStage(stageName);
if (!s)
{
std::cerr << "Unable to create stage " << stageName << "\n";
return;
}
ProgramArgs args;
s->addAllArgs(args);
if (!m_showJSON)
{
strm << stageName << " -- " << PluginManager<Stage>::link(stageName) <<
std::endl;
strm << headline << std::endl;
args.dump2(strm , 2, 6, headline.size());
}
else
{
std::ostringstream ostr;
args.dump3(ostr);
NL::json array;
try
{
array = NL::json::parse(ostr.str());
}
catch (NL::json::parse_error)
{}
NL::json object = { stageName, array };
strm << object;
}
}
bool NitfWrap::parseArgs(std::vector<std::string>& argList)
{
ProgramArgs args;
args.add("input,i", "Input filename", m_inputFile).setPositional();
args.add("output,o", "Output filename",
m_outputFile).setOptionalPositional();
args.add("unwrap,u", "Unwrap NITF file", m_unwrap);
try
{
m_nitfWriter.addArgs(args);
}
catch (arg_error& e)
{
throw error(e.m_error);
}
try
{
args.parse(argList);
}
catch (arg_error& e)
{
std::cerr << "nitfwrap: " << e.m_error << std::endl;
outputHelp(args);
return false;
}
if (!FileUtils::fileExists(m_inputFile))
{
std::ostringstream oss;
oss << "Input file '" << m_inputFile << "' doesn't exist.";
throw error(oss.str());
}
if (m_outputFile.empty())
if (!m_unwrap)
m_outputFile = FileUtils::stem(m_inputFile) + ".ntf";
return true;
}
void Kernel::addBasicSwitches(ProgramArgs& args)
{
args.add("help,h", "Print help message", m_showHelp);
args.add("debug,d", "Enable debug mode", m_isDebug);
args.add("developer-debug",
"Enable developer debug (don't trap exceptions)", m_hardCoreDebug);
args.add("label", "A string to label the process with", m_label);
args.add("verbose,v", "Set verbose message level", m_verboseLevel);
args.add("visualize", "Visualize result", m_visualize);
args.add("stdin,s", "Read pipeline JSON from stdin", m_usestdin);
args.add("scale",
"A comma-separated or quoted, space-separated list of scales to "
"set on the output file: \n--scale 0.1,0.1,0.00001\n--scale \""
"0.1 0.1 0.00001\"", m_scales);
args.add("offset",
"A comma-separated or quoted, space-separated list of offsets to "
"set on the output file: \n--offset 0,0,0\n--offset "
"\"1234 5678 91011\"", m_offsets);
}
void App::outputHelp(const ProgramArgs& args)
{
m_out << "Usage:" << std::endl;
m_out << " pdal <options>" << std::endl;
m_out << " pdal <command> <command options>" << std::endl;
args.dump(m_out, 2, 80);
m_out << std::endl;
m_out << "The following commands are available:" << std::endl;
// Load all kernels so that we can report the names.
StageFactory f;
PluginManager<Kernel>::loadAll();
outputCommands(" - ");
m_out << std::endl;
m_out << "See http://pdal.io/apps/ for more detail" << std::endl;
}
TEST(OptionsTest, programargs)
{
ProgramArgs args;
bool falseDef, trueDef;
args.add("falsedef", "False default", falseDef);
args.add("truedef", "True default", trueDef, true);
Options ops;
ops.add("falsedef", false);
ops.add("truedef", false);
StringList cmdLine = ops.toCommandLine();
args.parse(cmdLine);
EXPECT_EQ(falseDef, false);
EXPECT_EQ(trueDef, false);
Options ops2;
ops2.add("falsedef", true);
ops2.add("truedef", true);
cmdLine = ops2.toCommandLine();
args.reset();
args.parse(cmdLine);
EXPECT_EQ(falseDef, true);
EXPECT_EQ(trueDef, true);
cmdLine.clear();
args.reset();
args.parse(cmdLine);
EXPECT_EQ(falseDef, false);
EXPECT_EQ(trueDef, true);
}
void TransformationFilter::addArgs(ProgramArgs& args)
{
args.add("matrix", "Transformation matrix", m_matrixSpec).setPositional();
}
void TextReader::addArgs(ProgramArgs& args)
{
args.add("separator", "Separator character that overrides special "
"character in header line", m_separator, ' ');
}
void FauxPluginKernel::addSwitches(ProgramArgs& args)
{
args.add("fakearg", "Fake argument", m_fakeArg).setPositional();
}
int App::execute(StringList& cmdArgs, LogPtr& log)
{
ProgramArgs args;
addArgs(args);
try
{
args.parseSimple(cmdArgs);
}
catch (arg_val_error const& e)
{
Utils::printError(e.what());
return -1;
}
log.reset(new Log("PDAL", m_log, m_logtiming));
if (m_logLevel != LogLevel::None)
log->setLevel(m_logLevel);
else if (m_debug)
log->setLevel(LogLevel::Debug);
log->get(LogLevel::Debug) << "Debugging..." << std::endl;
PluginManager<Stage>::setLog(log);
PluginManager<Kernel>::setLog(log);
#ifndef _WIN32
if (m_debug)
{
signal(SIGSEGV, [](int sig)
{
logPtr->get(LogLevel::Debug) << "Segmentation fault (signal 11)\n";
StringList lines = Utils::backtrace();
for (const auto& l : lines)
logPtr->get(LogLevel::Debug) << l << std::endl;
exit(1);
});
}
#endif
m_command = Utils::tolower(m_command);
if (!m_command.empty())
{
int ret = 0;
std::string name("kernels." + m_command);
Kernel *kernel = PluginManager<Kernel>::createObject(name);
if (kernel)
{
if (m_help)
cmdArgs.push_back("--help");
// This shouldn't throw. If it does, it's something awful, so
// not cleaning up seems inconsequential.
log->setLeader("pdal " + m_command);
ret = kernel->run(cmdArgs, log);
delete kernel;
// IMPORTANT - The kernel must be destroyed before GDAL
// drivers are unregistered or GDAL will attempt to destroy
// resources more than once, resulting in a crash.
gdal::unregisterDrivers();
}
else
log->get(LogLevel::Error) << "Command '" << m_command <<
"' not recognized" << std::endl << std::endl;
return ret;
}
if (m_showVersion)
outputVersion();
else if (m_showDrivers)
outputDrivers();
else if (m_showOptions.size())
{
if (m_showOptions == "all")
outputOptions();
else
outputOptions(m_showOptions, m_out);
}
else
outputHelp(args);
return 0;
}
void App::addArgs(ProgramArgs& args)
{
args.add("command", "The PDAL command", m_command).setPositional();
args.add("debug", "Sets the output level to 3 (option deprecated)",
m_debug);
args.add("verbose,v", "Sets the output level (0-8)", m_logLevel,
LogLevel::None);
args.add("drivers", "List available drivers", m_showDrivers);
args.add("help,h", "Display help text", m_help);
args.add("list-commands", "List available commands", m_showCommands);
args.add("version", "Show program version", m_showVersion);
args.add("options", "Show options for specified driver (or 'all')",
m_showOptions);
args.add("log", "Log filename (accepts stderr, stdout, stdlog, devnull"
" as special cases)", m_log, "stderr");
args.add("logtiming", "Turn on timing for log messages", m_logtiming);
Arg& json = args.add("showjson", "List options or drivers as JSON output",
m_showJSON);
json.setHidden();
}
void PlyWriter::addArgs(ProgramArgs& args)
{
args.add("filename", "Output filename", m_filename).setPositional();
args.add("storage_mode", "PLY Storage mode", m_storageModeSpec, "default");
}
void Stage::addSpatialReferenceArg(ProgramArgs& args)
{
args.add("spatialreference", "Spatial reference to apply to data",
m_spatialReference);
}
void InfoKernel::addSwitches(ProgramArgs& args)
{
args.add("input,i", "input file name", m_inputFile).setOptionalPositional();
args.add("all", "dump statistics, schema and metadata", m_showAll);
args.add("point,p", "point to dump\n--point=\"1-5,10,100-200\"",
m_pointIndexes);
args.add("query",
"Return points in order of distance from the specified "
"location (2D or 3D)\n"
"--query Xcoord,Ycoord[,Zcoord][/count]",
m_queryPoint);
args.add("stats", "dump stats on all points (reads entire dataset)",
m_showStats);
args.add("boundary", "compute a hexagonal hull/boundary of dataset",
m_boundary);
args.add("dimensions", "dimensions on which to compute statistics",
m_dimensions);
args.add("schema", "dump the schema", m_showSchema);
args.add("pipeline-serialization", "Output file for pipeline serialization",
m_pipelineFile);
args.add("summary", "dump summary of the info", m_showSummary);
args.add("metadata", "dump file metadata info", m_showMetadata);
args.add("pointcloudschema", "dump PointCloudSchema XML output",
m_PointCloudSchemaOutput).setHidden();
}
void Reader::readerAddArgs(ProgramArgs& args)
{
m_filenameArg = &args.add("filename", "Name of file to read", m_filename);
m_countArg = &args.add("count", "Maximum number of points read", m_count,
std::numeric_limits<point_count_t>::max());
}
void addArgs(ProgramArgs& args)
{
args.add("count", "Number of points to return from end.", m_count,
point_count_t(10));
}
void Stage::l_addArgs(ProgramArgs& args)
{
args.add("log", "Debug output filename", m_logname);
readerAddArgs(args);
}
