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