void Diff::validateSwitches()
{
if (!m_sourceFile.size())
throw app_runtime_error("No source file given!");
if (!m_candidateFile.size())
throw app_runtime_error("No candidate file given!");
}
pdal::PipelineManager* AppSupport::makePipeline(pdal::Options& options)
{
const std::string inputFile = options.getValueOrThrow<std::string>("filename");
if (!pdal::FileUtils::fileExists(inputFile))
{
throw app_runtime_error("file not found: " + inputFile);
}
pdal::PipelineManager* output = new PipelineManager;
pdal::StageFactory factory;
std::string driver = factory.inferReaderDriver(inputFile, options);
if (driver == "")
{
throw app_runtime_error("Cannot determine input file type of " + inputFile);
}
pdal::Stage* stage = output->addReader(driver, options);
if (!stage)
{
throw app_runtime_error("reader creation failed");
}
return output;
}
pdal::Writer* AppSupport::makeWriter(pdal::Options& options, pdal::Stage& stage)
{
const std::string outputFile = options.getValueOrThrow<std::string>("filename");
pdal::StageFactory factory;
std::string driver = factory.inferWriterDriver(outputFile, options);
if (driver == "")
{
throw app_runtime_error("Cannot determine output file type of " + outputFile);
}
pdal::Writer* writer = factory.createWriter(driver, stage, options);
if (!writer)
{
throw app_runtime_error("writer creation failed");
}
return writer;
}
MetadataNode InfoKernel::dumpQuery(PointViewPtr inView) const
{
int count;
std::string location;
// See if there's a provided point count.
StringList parts = Utils::split2(m_queryPoint, '/');
if (parts.size() == 2)
{
location = parts[0];
count = atoi(parts[1].c_str());
}
else if (parts.size() == 1)
{
location = parts[0];
count = inView->size();
}
else
count = 0;
if (count == 0)
throw pdal_error("Invalid location specificiation. "
"--query=\"X,Y[/count]\"");
auto seps = [](char c){ return (c == ',' || c == '|' || c == ' '); };
std::vector<std::string> tokens = Utils::split2(location, seps);
std::vector<double> values;
for (auto ti = tokens.begin(); ti != tokens.end(); ++ti)
values.push_back(boost::lexical_cast<double>(*ti));
if (values.size() != 2 && values.size() != 3)
throw app_runtime_error("--points must be two or three values");
PointViewPtr outView = inView->makeNew();
std::vector<PointId> ids;
if (values.size() >= 3)
{
KD3Index kdi(*inView);
kdi.build();
ids = kdi.neighbors(values[0], values[1], values[2], count);
}
else
{
KD2Index kdi(*inView);
kdi.build();
ids = kdi.neighbors(values[0], values[1], count);
}
for (auto i = ids.begin(); i != ids.end(); ++i)
outView->appendPoint(*inView.get(), *i);
return Utils::toMetadata(outView);
}
int PipelineKernel::execute()
{
if (!FileUtils::fileExists(m_inputFile))
throw app_runtime_error("file not found: " + m_inputFile);
pdal::PipelineManager manager;
pdal::PipelineReader reader(manager, isDebug(), getVerboseLevel());
bool isWriter = reader.readPipeline(m_inputFile);
if (!isWriter)
throw app_runtime_error("Pipeline file does not contain a writer. "
"Use 'pdal info' to read the data.");
for (const auto& pi : getExtraStageOptions())
{
std::string name = pi.first;
Options options = pi.second;
std::vector<Stage *> stages = manager.getStage()->findStage(name);
for (const auto& s : stages)
{
Options opts = s->getOptions();
for (const auto& o : options.getOptions())
opts.add(o);
s->setOptions(opts);
}
}
PointTable table;
manager.getStage()->prepare(table);
manager.getStage()->execute(table);
if (m_pipelineFile.size() > 0)
{
pdal::PipelineWriter writer(manager);
writer.writePipeline(m_pipelineFile);
}
return 0;
}
pdal::Stage* AppSupport::makeReader(pdal::Options& options)
{
const std::string inputFile = options.getValueOrThrow<std::string>("filename");
if (!pdal::FileUtils::fileExists(inputFile))
{
throw app_runtime_error("file not found: " + inputFile);
}
std::string driver = AppSupport::inferReaderDriver(inputFile, options);
if (driver == "")
{
throw app_runtime_error("Cannot determine file type of " + inputFile);
}
pdal::StageFactory factory;
pdal::Stage* stage = factory.createReader(driver, options);
if (!stage)
{
throw app_runtime_error("reader creation failed");
}
return stage;
}
std::map<Point, Point>* cumulatePoints(PointBuffer& source_data,
IndexedPointBuffer& candidate_data)
{
std::map<Point, Point> *output = new std::map<Point, Point>;
boost::uint32_t count(std::min(source_data.getNumPoints(), candidate_data.getNumPoints()));
Schema const& candidate_schema = candidate_data.getSchema();
Dimension const& cDimX = candidate_schema.getDimension("X");
Dimension const& cDimY = candidate_schema.getDimension("Y");
Dimension const& cDimZ = candidate_schema.getDimension("Z");
Schema const& source_schema = source_data.getSchema();
Dimension const& sDimX = source_schema.getDimension("X");
Dimension const& sDimY = source_schema.getDimension("Y");
Dimension const& sDimZ = source_schema.getDimension("Z");
for (boost::uint32_t i = 0; i < count; ++i)
{
double sx = source_data.applyScaling(sDimX, i);
double sy = source_data.applyScaling(sDimY, i);
double sz = source_data.applyScaling(sDimZ, i);
std::vector<std::size_t> ids = candidate_data.neighbors(sx, sy, sz, 1);
if (!ids.size())
{
std::ostringstream oss;
oss << "unable to find point for id '" << i <<"'";
throw app_runtime_error(oss.str() );
}
std::size_t id = ids[0];
double cx = candidate_data.applyScaling(cDimX, id);
double cy = candidate_data.applyScaling(cDimY, id);
double cz = candidate_data.applyScaling(cDimZ, id);
Point s(sx, sy, sz, i);
Point c(cx, cy, cz, id);
output->insert(std::pair<Point, Point>(s, c));
double xd = sx - cx;
double yd = sy - cy;
double zd = sz - cz;
}
return output;
}
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;
}
void Delta::outputDetail(PointBuffer& source_data,
IndexedPointBuffer& candidate_data,
std::map<Point, Point> *points) const
{
Schema const& candidate_schema = candidate_data.getSchema();
Dimension const& cDimX = candidate_schema.getDimension("X");
Dimension const& cDimY = candidate_schema.getDimension("Y");
Dimension const& cDimZ = candidate_schema.getDimension("Z");
Schema const& source_schema = source_data.getSchema();
Dimension const& sDimX = source_schema.getDimension("X");
Dimension const& sDimY = source_schema.getDimension("Y");
Dimension const& sDimZ = source_schema.getDimension("Z");
bool bWroteHeader(false);
std::ostream& ostr = m_outputStream ? *m_outputStream : std::cout;
candidate_data.build(m_3d);
boost::uint32_t count(std::min(source_data.getNumPoints(), candidate_data.getNumPoints()));
for (boost::uint32_t i = 0; i < count; ++i)
{
double sx = source_data.applyScaling(sDimX, i);
double sy = source_data.applyScaling(sDimY, i);
double sz = source_data.applyScaling(sDimZ, i);
std::vector<std::size_t> ids = candidate_data.neighbors(sx, sy, sz, 1);
if (!ids.size())
{
std::ostringstream oss;
oss << "unable to find point for id '" << i <<"'";
throw app_runtime_error(oss.str() );
}
std::size_t id = ids[0];
double cx = candidate_data.applyScaling(cDimX, id);
double cy = candidate_data.applyScaling(cDimY, id);
double cz = candidate_data.applyScaling(cDimZ, id);
Point s(sx, sy, sz, id);
Point c(cx, cy, cz, id);
double xd = sx - cx;
double yd = sy - cy;
double zd = sz - cz;
if (!bWroteHeader)
{
writeHeader(ostr, m_3d);
bWroteHeader = true;
}
ostr << i << ",";
boost::uint32_t precision = Utils::getStreamPrecision(cDimX.getNumericScale());
ostr.setf(std::ios_base::fixed, std::ios_base::floatfield);
ostr.precision(precision);
ostr << xd << ",";
precision = Utils::getStreamPrecision(cDimY.getNumericScale());
ostr.precision(precision);
ostr << yd;
if (m_3d)
{
ostr << ",";
precision = Utils::getStreamPrecision(cDimZ.getNumericScale());
ostr.precision(precision);
ostr << zd;
}
ostr << std::endl;
}
if (m_outputStream)
{
FileUtils::closeFile(m_outputStream);
}
}
