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); }