int MergeKernel::execute()
{
PointTable table;
MergeFilter filter;
for (size_t i = 0; i < m_files.size(); ++i)
{
Options readerOpts;
readerOpts.add("filename", m_files[i]);
readerOpts.add("debug", isDebug());
readerOpts.add("verbose", getVerboseLevel());
Stage& reader = makeReader(m_files[i]);
reader.setOptions(readerOpts);
filter.setInput(reader);
}
Options writerOpts;
Stage& writer = makeWriter(m_outputFile, filter);
applyExtraStageOptionsRecursive(&writer);
writer.prepare(table);
writer.execute(table);
return 0;
}
int GroundKernel::execute()
{
PointTable table;
Options readerOptions;
readerOptions.add<std::string>("filename", m_inputFile);
setCommonOptions(readerOptions);
Stage& readerStage(Kernel::makeReader(m_inputFile));
readerStage.setOptions(readerOptions);
Options groundOptions;
groundOptions.add<double>("maxWindowSize", m_maxWindowSize);
groundOptions.add<double>("slope", m_slope);
groundOptions.add<double>("maxDistance", m_maxDistance);
groundOptions.add<double>("initialDistance", m_initialDistance);
groundOptions.add<double>("cellSize", m_cellSize);
groundOptions.add<bool>("classify", m_classify);
groundOptions.add<bool>("extract", m_extract);
groundOptions.add<bool>("approximate", m_approximate);
groundOptions.add<bool>("debug", isDebug());
groundOptions.add<uint32_t>("verbose", getVerboseLevel());
StageFactory f;
std::unique_ptr<Stage> groundStage(f.createStage("filters.ground"));
groundStage->setOptions(groundOptions);
groundStage->setInput(readerStage);
// setup the Writer and write the results
Options writerOptions;
writerOptions.add<std::string>("filename", m_outputFile);
setCommonOptions(writerOptions);
Stage& writer(Kernel::makeWriter(m_outputFile, *groundStage));
writer.setOptions(writerOptions);
std::vector<std::string> cmd = getProgressShellCommand();
UserCallback *callback =
cmd.size() ? (UserCallback *)new ShellScriptCallback(cmd) :
(UserCallback *)new HeartbeatCallback();
writer.setUserCallback(callback);
applyExtraStageOptionsRecursive(&writer);
writer.prepare(table);
// process the data, grabbing the PointViewSet for visualization of the
// resulting PointView
PointViewSet viewSetOut = writer.execute(table);
if (isVisualize())
visualize(*viewSetOut.begin());
//visualize(*viewSetIn.begin(), *viewSetOut.begin());
return 0;
}
MetadataNode InfoKernel::run(const std::string& filename)
{
MetadataNode root;
root.add("filename", filename);
if (m_showSummary)
{
QuickInfo qi = m_reader->preview();
MetadataNode summary = dumpSummary(qi).clone("summary");
root.add(summary);
}
else
{
applyExtraStageOptionsRecursive(m_manager->getStage());
if (m_needPoints || m_showMetadata)
m_manager->execute();
else
m_manager->prepare();
dump(root);
}
root.add("pdal_version", pdal::GetFullVersionString());
return root;
}
int TranslateKernel::execute()
{
// setting common options for each stage propagates the debug flag and
// verbosity level
Options readerOptions, filterOptions, writerOptions;
setCommonOptions(readerOptions);
setCommonOptions(filterOptions);
setCommonOptions(writerOptions);
m_manager = std::unique_ptr<PipelineManager>(new PipelineManager);
if (!m_readerType.empty())
{
m_manager->addReader(m_readerType);
}
else
{
StageFactory factory;
std::string driver = factory.inferReaderDriver(m_inputFile);
if (driver.empty())
throw app_runtime_error("Cannot determine input file type of " +
m_inputFile);
m_manager->addReader(driver);
}
if (m_manager == NULL)
throw pdal_error("Error making pipeline\n");
Stage* reader = m_manager->getStage();
if (reader == NULL)
throw pdal_error("Error getting reader\n");
readerOptions.add("filename", m_inputFile);
reader->setOptions(readerOptions);
Stage* stage = reader;
// add each filter provided on the command-line, updating the stage pointer
for (auto const f : m_filterType)
{
std::string filter_name(f);
if (!Utils::startsWith(f, "filters."))
filter_name.insert(0, "filters.");
Stage* filter = &(m_manager->addFilter(filter_name));
if (filter == NULL)
{
std::ostringstream oss;
oss << "Unable to add filter " << filter_name << ". Filter "
"is invalid or plugin could not be loaded. Check "
"'pdal --drivers'.";
throw pdal_error("Error getting filter\n");
}
filter->setOptions(filterOptions);
filter->setInput(*stage);
stage = filter;
}
if (!m_writerType.empty())
{
m_manager->addWriter(m_writerType);
}
else
{
StageFactory factory;
std::string driver = factory.inferWriterDriver(m_outputFile);
if (driver.empty())
throw app_runtime_error("Cannot determine output file type of " +
m_outputFile);
Options options = factory.inferWriterOptionsChanges(m_outputFile);
writerOptions += options;
m_manager->addWriter(driver);
}
Stage* writer = m_manager->getStage();
if (writer == NULL)
throw pdal_error("Error getting writer\n");
writerOptions.add("filename", m_outputFile);
writer->setOptions(writerOptions);
writer->setInput(*stage);
// be sure to recurse through any extra stage options provided by the user
applyExtraStageOptionsRecursive(writer);
m_manager->execute();
if (m_pipelineOutput.size() > 0)
PipelineWriter::writePipeline(m_manager->getStage(), m_pipelineOutput);
return 0;
}
