PipelineManagerPtr InfoKernel::makePipeline(const std::string& filename, bool noPoints) { if (!pdal::FileUtils::fileExists(filename)) throw pdal_error("File not found: " + filename); PipelineManagerPtr output(new PipelineManager); if (filename == "STDIN") { output->readPipeline(std::cin); } else if (FileUtils::extension(filename) == ".xml" || FileUtils::extension(filename) == ".json") { output->readPipeline(filename); } else { StageFactory factory; std::string driver = factory.inferReaderDriver(filename); if (driver.empty()) throw pdal_error("Cannot determine input file type of " + filename); Stage& reader = output->addReader(driver); Options ro; ro.add("filename", filename); if (noPoints) ro.add("count", 0); reader.setOptions(ro); m_reader = &reader; } return output; }
// Test auto scale/offset for streaming mode. TEST(LasWriterTest, issue1940) { StageFactory f; Stage& r = *(f.createStage("readers.faux")); Options ro; ro.add("mode", "constant"); ro.add("bounds", "([55,55],[55,55],[55,55])"); ro.add("count", 20); r.addOptions(ro); LasWriter w; Options wo; //LogPtr log(new Log("TEST", &std::clog)); //log->setLevel((LogLevel)5); //w.setLog(log); wo.add("filename", Support::temppath("out.las")); wo.add("scale_x", "auto"); wo.add("offset_y", "auto"); w.addOptions(wo); w.setInput(r); FixedPointTable t(100); w.prepare(t); w.execute(t); LasTester tester; LasHeader *h = tester.header(w); EXPECT_DOUBLE_EQ(h->offsetX(), 0); EXPECT_DOUBLE_EQ(h->offsetY(), 55); EXPECT_DOUBLE_EQ(h->scaleX(), 1.0); EXPECT_DOUBLE_EQ(h->scaleY(), .01); }
TEST_F(PgpointcloudWriterTest, writetNoPointcloudExtension) { if (shouldSkipTests()) { return; } StageFactory f; Stage* writer(f.createStage("writers.pgpointcloud")); EXPECT_TRUE(writer); executeOnTestDb("DROP EXTENSION pointcloud"); const std::string file(Support::datapath("las/1.2-with-color.las")); const Option opt_filename("filename", file); Stage* reader(f.createStage("readers.las")); EXPECT_TRUE(reader); Options options; options.add(opt_filename); reader->setOptions(options); writer->setOptions(getDbOptions()); writer->setInput(*reader); PointTable table; writer->prepare(table); EXPECT_THROW(writer->execute(table), pdal_error); }
TEST(NitfReaderTest, optionSrs) { StageFactory f; Options nitfOpts; nitfOpts.add("filename", Support::datapath("nitf/autzen-utm10.ntf")); std::string sr = "PROJCS[\"NAD83 / UTM zone 11N\",GEOGCS[\"NAD83\",DATUM[\"North_American_Datum_1983\",SPHEROID[\"GRS 1980\",6378137,298.257222101,AUTHORITY[\"EPSG\",\"7019\"]],TOWGS84[0,0,0,0,0,0,0],AUTHORITY[\"EPSG\",\"6269\"]],PRIMEM[\"Greenwich\",0,AUTHORITY[\"EPSG\",\"8901\"]],UNIT[\"degree\",0.0174532925199433,AUTHORITY[\"EPSG\",\"9122\"]],AUTHORITY[\"EPSG\",\"4269\"]],PROJECTION[\"Transverse_Mercator\"],PARAMETER[\"latitude_of_origin\",0],PARAMETER[\"central_meridian\",-123],PARAMETER[\"scale_factor\",0.9996],PARAMETER[\"false_easting\",500000],PARAMETER[\"false_northing\",0],UNIT[\"metre\",1,AUTHORITY[\"EPSG\",\"9001\"]],AXIS[\"Easting\",EAST],AXIS[\"Northing\",NORTH],AUTHORITY[\"EPSG\",\"26910\"]]"; nitfOpts.add("spatialreference", sr); PointContext ctx; ReaderPtr nitfReader(f.createReader("readers.nitf")); EXPECT_TRUE(nitfReader.get()); nitfReader->setOptions(nitfOpts); Options lasOpts; lasOpts.add("filename", "/dev/null"); WriterPtr lasWriter(f.createWriter("writers.las")); EXPECT_TRUE(lasWriter.get()); lasWriter->setInput(nitfReader.get()); lasWriter->setOptions(lasOpts);; lasWriter->prepare(ctx); PointBufferSet pbSet = lasWriter->execute(ctx); EXPECT_EQ(sr, nitfReader->getSpatialReference().getWKT()); EXPECT_EQ("", lasWriter->getSpatialReference().getWKT()); EXPECT_EQ(sr, ctx.spatialRef().getWKT()); }
int MyKernel::execute() { PointTable table; StageFactory f; Stage * reader = f.createStage("readers.las"); Options readerOptions; readerOptions.add("filename", m_input_file); reader->setOptions(readerOptions); Stage * filter = f.createStage("filters.decimation"); Options filterOptions; filterOptions.add("step", 10); filter->setOptions(filterOptions); filter->setInput(*reader); Stage * writer = f.createStage("writers.text"); Options writerOptions; writerOptions.add("filename", m_output_file); writer->setOptions(writerOptions); writer->setInput(*filter); writer->prepare(table); writer->execute(table); return 0; }
void readData() { std::ostringstream oss; oss << "SELECT l.\"OBJ_ID\", l.\"BLK_ID\", l.\"BLK_EXTENT\", " << "l.\"BLK_DOMAIN\", l.\"PCBLK_MIN_RES\", l.\"PCBLK_MAX_RES\", " << "l.\"NUM_POINTS\", l.\"NUM_UNSORTED_POINTS\", l.\"PT_SORT_DIM\", " << "l.\"POINTS\", b.cloud " "FROM PDAL_TEST_BLOCKS l, PDAL_TEST_BASE b " "WHERE b.id = l.obj_id ORDER BY l.blk_id "; Options options = readerOptions(); options.add("query", oss.str()); StageFactory f; Stage* reader(f.createStage("readers.oci")); EXPECT_TRUE(reader); reader->setOptions(options); PointTable table; reader->prepare(table); PointViewSet viewSet = reader->execute(table); EXPECT_EQ(viewSet.size(), 1u); PointViewPtr view = *viewSet.begin(); EXPECT_EQ(view->size(), 1065u); compare(view, Support::datapath("autzen/autzen-utm.las")); }
TEST(LasReaderTest, create) { StageFactory f; auto s = f.createStage("readers.las"); EXPECT_TRUE(s); }
TEST(PtsReader, Constructor) { PtsReader reader1; StageFactory f; Stage* reader2(f.createStage("readers.pts")); EXPECT_TRUE(reader2); }
TEST(PlyReader, Constructor) { PlyReader reader1; StageFactory f; std::unique_ptr<Stage> reader2(f.createStage("readers.ply")); EXPECT_TRUE(reader2.get()); }
TEST_F(PredicateFilterTest, PredicateFilterTest_test_programmable) { StageFactory f; BOX3D bounds(0.0, 0.0, 0.0, 2.0, 2.0, 2.0); Options readerOps; readerOps.add("bounds", bounds); readerOps.add("count", 1000); readerOps.add("mode", "ramp"); FauxReader reader; reader.setOptions(readerOps); // keep all points where x less than 1.0 const Option source("source", // "X < 1.0" "import numpy as np\n" "def yow1(ins,outs):\n" " X = ins['X']\n" " Mask = np.less(X, 1.0)\n" " #print X\n" " #print Mask\n" " outs['Mask'] = Mask\n" " return True\n" ); const Option module("module", "MyModule1"); const Option function("function", "yow1"); Options opts; opts.add(source); opts.add(module); opts.add(function); Stage* filter(f.createStage("filters.python")); filter->setOptions(opts); filter->setInput(reader); Options statOpts; std::unique_ptr<StatsFilter> stats(new StatsFilter); stats->setOptions(statOpts); stats->setInput(*filter); PointTable table; stats->prepare(table); PointViewSet viewSet = stats->execute(table); EXPECT_EQ(viewSet.size(), 1u); const stats::Summary& statsX = stats->getStats(Dimension::Id::X); const stats::Summary& statsY = stats->getStats(Dimension::Id::Y); const stats::Summary& statsZ = stats->getStats(Dimension::Id::Z); EXPECT_TRUE(Utils::compare_approx(statsX.minimum(), 0.0, 0.01)); EXPECT_TRUE(Utils::compare_approx(statsY.minimum(), 0.0, 0.01)); EXPECT_TRUE(Utils::compare_approx(statsZ.minimum(), 0.0, 0.01)); EXPECT_TRUE(Utils::compare_approx(statsX.maximum(), 1.0, 0.01)); EXPECT_TRUE(Utils::compare_approx(statsY.maximum(), 1.0, 0.01)); EXPECT_TRUE(Utils::compare_approx(statsZ.maximum(), 1.0, 0.01)); }
TEST(PredicateFilterTest, PredicateFilterTest_test2) { StageFactory f; // same as above, but with 'Y >' instead of 'X <' BOX3D bounds(0.0, 0.0, 0.0, 2.0, 2.0, 2.0); Options readerOps; readerOps.add("bounds", bounds); readerOps.add("num_points", 1000); readerOps.add("mode", "ramp"); FauxReader reader; reader.setOptions(readerOps); Option source("source", // "Y > 1.0" "import numpy as np\n" "def yow2(ins,outs):\n" " Y = ins['Y']\n" " Mask = np.greater(Y, 1.0)\n" " #print Mask\n" " outs['Mask'] = Mask\n" " return True\n" ); Option module("module", "MyModule1"); Option function("function", "yow2"); Options opts; opts.add(source); opts.add(module); opts.add(function); std::unique_ptr<Stage> filter(f.createStage("filters.predicate")); filter->setOptions(opts); filter->setInput(reader); Options statOpts; std::unique_ptr<StatsFilter> stats(new StatsFilter); stats->setOptions(statOpts); stats->setInput(*filter); PointTable table; stats->prepare(table); PointViewSet viewSet = stats->execute(table); EXPECT_EQ(viewSet.size(), 1u); const stats::Summary& statsX = stats->getStats(Dimension::Id::X); const stats::Summary& statsY = stats->getStats(Dimension::Id::Y); const stats::Summary& statsZ = stats->getStats(Dimension::Id::Z); EXPECT_TRUE(Utils::compare_approx<double>(statsX.minimum(), 1.0, 0.01)); EXPECT_TRUE(Utils::compare_approx<double>(statsY.minimum(), 1.0, 0.01)); EXPECT_TRUE(Utils::compare_approx<double>(statsZ.minimum(), 1.0, 0.01)); EXPECT_TRUE(Utils::compare_approx<double>(statsX.maximum(), 2.0, 0.01)); EXPECT_TRUE(Utils::compare_approx<double>(statsY.maximum(), 2.0, 0.01)); EXPECT_TRUE(Utils::compare_approx<double>(statsZ.maximum(), 2.0, 0.01)); }
void testReadWrite(bool compression, bool scaling) { FileUtils::deleteFile(tempFilename); Options writerOptions = getWriterOptions(); if (scaling) { writerOptions.add("scale_x", 0.01); writerOptions.add("scale_y", 0.01); } writerOptions.add("compression", compression); StageFactory f; { std::cerr << "*** Writing data!\n"; Options lasReadOpts; lasReadOpts.add("filename", Support::datapath("las/1.2-with-color.las")); lasReadOpts.add("count", 11); LasReader reader; reader.setOptions(lasReadOpts); Stage* sqliteWriter(f.createStage("writers.sqlite")); sqliteWriter->setOptions(writerOptions); sqliteWriter->setInput(reader); PointTable table; sqliteWriter->prepare(table); sqliteWriter->execute(table); } { Stage* sqliteReader(f.createStage("readers.sqlite")); sqliteReader->setOptions(getReaderOptions()); PointTable table2; sqliteReader->prepare(table2); PointViewSet viewSet = sqliteReader->execute(table2); EXPECT_EQ(viewSet.size(), 1U); PointViewPtr view = *viewSet.begin(); using namespace Dimension; uint16_t reds[] = {68, 54, 112, 178, 134, 99, 90, 106, 106, 100, 64}; for (PointId idx = 0; idx < 11; idx++) { uint16_t r = view->getFieldAs<uint16_t>(Id::Red, idx); EXPECT_EQ(r, reds[idx]); } int32_t x = view->getFieldAs<int32_t>(Id::X, 10); EXPECT_EQ(x, 636038); double xd = view->getFieldAs<double>(Id::X, 10); EXPECT_FLOAT_EQ(xd, 636037.53); } // FileUtils::deleteFile(tempFilename); }
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; }
// Test that data from three input views gets written to a single output file. TEST(NitfWriterTest, flex2) { StageFactory f; Options readerOps; readerOps.add("filename", Support::datapath("nitf/autzen-utm10.ntf")); PointTable table; Stage* reader(f.createStage("readers.nitf")); reader->setOptions(readerOps); reader->prepare(table); PointViewSet views = reader->execute(table); PointViewPtr v = *(views.begin()); PointViewPtr v1(new PointView(table)); PointViewPtr v2(new PointView(table)); PointViewPtr v3(new PointView(table)); std::vector<PointViewPtr> vs; vs.push_back(v1); vs.push_back(v2); vs.push_back(v3); for (PointId i = 0; i < v->size(); ++i) vs[i % 3]->appendPoint(*v, i); std::string outfile(Support::temppath("test_flex.ntf")); FileUtils::deleteFile(outfile); BufferReader reader2; reader2.addView(v1); reader2.addView(v2); reader2.addView(v3); Options writerOps; writerOps.add("filename", outfile); Stage* writer(f.createStage("writers.nitf")); writer->setOptions(writerOps); writer->setInput(reader2); writer->prepare(table); writer->execute(table); EXPECT_TRUE(FileUtils::fileExists(outfile)); Options ops; ops.add("filename", outfile); Stage* r(f.createStage("readers.nitf")); r->setOptions(ops); EXPECT_EQ(r->preview().m_pointCount, v->size()); }
TEST_F(PredicateFilterTest, PredicateFilterTest_test_programmable_4) { StageFactory f; // test the point counters in the Predicate's iterator BOX3D bounds(0.0, 0.0, 0.0, 2.0, 2.0, 2.0); Options readerOpts; readerOpts.add("bounds", bounds); readerOpts.add("count", 1000); readerOpts.add("mode", "ramp"); FauxReader reader; reader.setOptions(readerOpts); const Option source("source", // "Y > 0.5" "import numpy as np\n" "def yow2(ins,outs):\n" " Y = ins['Y']\n" " Mask = np.greater(Y, 0.5)\n" " #print Mask\n" " outs['Mask'] = Mask\n" " return True\n" ); const Option module("module", "MyModule1"); const Option function("function", "yow2"); Options opts; opts.add(source); opts.add(module); opts.add(function); Stage* filter(f.createStage("filters.python")); filter->setOptions(opts); filter->setInput(reader); PointTable table; PointViewPtr buf(new PointView(table)); filter->prepare(table); StageWrapper::ready(reader, table); PointViewSet viewSet = StageWrapper::run(reader, buf); StageWrapper::done(reader, table); EXPECT_EQ(viewSet.size(), 1u); buf = *viewSet.begin(); EXPECT_EQ(buf->size(), 1000u); StageWrapper::ready(*filter, table); viewSet = StageWrapper::run(*filter, buf); StageWrapper::done(*filter, table); EXPECT_EQ(viewSet.size(), 1u); buf = *viewSet.begin(); EXPECT_EQ(buf->size(), 750u); }
TEST(Stats, metadata) { BOX3D bounds(1.0, 2.0, 3.0, 101.0, 102.0, 103.0); Options ops; ops.add("bounds", bounds); ops.add("count", 1000); ops.add("mode", "constant"); StageFactory f; std::unique_ptr<Stage> reader(f.createStage("readers.faux")); EXPECT_TRUE(reader.get()); reader->setOptions(ops); Options filterOps; filterOps.add("dimensions", " , X, Z "); StatsFilter filter; filter.setInput(*reader); filter.setOptions(filterOps); PointTable table; filter.prepare(table); filter.execute(table); MetadataNode m = filter.getMetadata(); std::vector<MetadataNode> children = m.children("statistic"); auto findNode = [](MetadataNode m, const std::string name, const std::string val) { auto findNameVal = [name, val](MetadataNode m) { return (m.name() == name && m.value() == val); }; return m.find(findNameVal); }; for (auto mi = children.begin(); mi != children.end(); ++mi) { if (findNode(*mi, "name", "X").valid()) { EXPECT_DOUBLE_EQ(mi->findChild("average").value<double>(), 1.0); EXPECT_DOUBLE_EQ(mi->findChild("minimum").value<double>(), 1.0); EXPECT_DOUBLE_EQ(mi->findChild("maximum").value<double>(), 1.0); EXPECT_DOUBLE_EQ(mi->findChild("count").value<double>(), 1000.0); } if (findNode(*mi, "name", "Z").valid()) { EXPECT_DOUBLE_EQ(mi->findChild("average").value<double>(), 3.0); EXPECT_DOUBLE_EQ(mi->findChild("minimum").value<double>(), 3.0); EXPECT_DOUBLE_EQ(mi->findChild("maximum").value<double>(), 3.0); EXPECT_DOUBLE_EQ(mi->findChild("count").value<double>(), 1000.0); } } }
TEST_F(PythonFilterTest, add_dimension) { StageFactory f; BOX3D bounds(0.0, 0.0, 0.0, 1.0, 1.0, 1.0); Options ops; ops.add("bounds", bounds); ops.add("count", 10); ops.add("mode", "ramp"); FauxReader reader; reader.setOptions(ops); Option source("source", "import numpy\n" "def myfunc(ins,outs):\n" " outs['AddedIntensity'] = np.zeros(ins['X'].size, dtype=numpy.double) + 1\n" " outs['AddedPointSourceId'] = np.zeros(ins['X'].size, dtype=numpy.double) + 2\n" " return True\n" ); Option module("module", "MyModule"); Option function("function", "myfunc"); Option intensity("add_dimension", "AddedIntensity"); Option scanDirection("add_dimension", "AddedPointSourceId"); Options opts; opts.add(source); opts.add(module); opts.add(function); opts.add(intensity); opts.add(scanDirection); Stage* filter(f.createStage("filters.python")); filter->setOptions(opts); filter->setInput(reader); PointTable table; filter->prepare(table); PointViewSet viewSet = filter->execute(table); EXPECT_EQ(viewSet.size(), 1u); PointViewPtr view = *viewSet.begin(); PointLayoutPtr layout(table.layout()); Dimension::Id int_id = layout->findDim("AddedIntensity"); Dimension::Id psid_id = layout->findDim("AddedPointSourceId"); for (unsigned int i = 0; i < view->size(); ++i) { EXPECT_EQ(view->getFieldAs<uint16_t>(int_id, i), 1); EXPECT_EQ(view->getFieldAs<uint16_t>(psid_id, i), 2); } }
void Kernel::visualize(PointBufferPtr buffer) const { BufferReader bufferReader; bufferReader.addBuffer(buffer); StageFactory f; WriterPtr writer(f.createWriter("writers.pclvisualizer")); writer->setInput(&bufferReader); PointContext ctx; writer->prepare(ctx); writer->execute(ctx); }
TEST(OldPCLBlockTests, PMF) { StageFactory f; Options ro; ro.add("filename", Support::datapath("autzen/autzen-point-format-3.las")); Stage* r(f.createStage("readers.las")); EXPECT_TRUE(r); r->setOptions(ro); Options ao; ao.add("assignment", "Classification[:]=0"); Stage* assign(f.createStage("filters.assign")); EXPECT_TRUE(assign); assign->setOptions(ao); assign->setInput(*r); Options fo; fo.add("max_window_size", 33.0); fo.add("cell_size", 10.0); fo.add("slope", 1.0); fo.add("initial_distance", 0.15); fo.add("max_distance", 2.5); fo.add("returns", "first"); fo.add("returns", "intermediate"); fo.add("returns", "last"); fo.add("returns", "only"); Stage* outlier(f.createStage("filters.pmf")); EXPECT_TRUE(outlier); outlier->setOptions(fo); outlier->setInput(*assign); Options rangeOpts; rangeOpts.add("limits", "Classification[2:2]"); Stage* range(f.createStage("filters.range")); EXPECT_TRUE(range); range->setOptions(rangeOpts); range->setInput(*outlier); PointTable table; range->prepare(table); PointViewSet viewSet = range->execute(table); EXPECT_EQ(1u, viewSet.size()); PointViewPtr view = *viewSet.begin(); EXPECT_EQ(79u, view->size()); }
TEST_F(PythonFilterTest, metadata) { StageFactory f; BOX3D bounds(0.0, 0.0, 0.0, 1.0, 1.0, 1.0); Options ops; ops.add("bounds", bounds); ops.add("count", 10); ops.add("mode", "ramp"); FauxReader reader; reader.setOptions(ops); Option source("source", "import numpy\n" "import sys\n" "import redirector\n" "def myfunc(ins,outs):\n" " global metadata\n" " #print('before', globals(), file=sys.stderr,)\n" " metadata = {'name': 'root', 'value': 'a string', 'type': 'string', 'description': 'a description', 'children': [{'name': 'filters.python', 'value': 52, 'type': 'integer', 'description': 'a filter description', 'children': []}, {'name': 'readers.faux', 'value': 'another string', 'type': 'string', 'description': 'a reader description', 'children': []}]}\n" " # print ('schema', schema, file=sys.stderr,)\n" " return True\n" ); Option module("module", "MyModule"); Option function("function", "myfunc"); Options opts; opts.add(source); opts.add(module); opts.add(function); Stage* filter(f.createStage("filters.python")); filter->setOptions(opts); filter->setInput(reader); PointTable table; filter->prepare(table); PointViewSet viewSet = filter->execute(table); EXPECT_EQ(viewSet.size(), 1u); PointViewPtr view = *viewSet.begin(); PointLayoutPtr layout(table.layout()); MetadataNode m = table.metadata(); m = m.findChild("filters.python"); MetadataNodeList l = m.children(); EXPECT_EQ(l.size(), 3u); EXPECT_EQ(l[0].name(), "filters.python"); EXPECT_EQ(l[0].value(), "52"); EXPECT_EQ(l[0].description(), "a filter description"); }
TEST(IcebridgeReaderTest, testRead) { StageFactory f; Stage* reader(f.createStage("readers.icebridge")); EXPECT_TRUE(reader); Option filename("filename", getFilePath(), ""); Options options(filename); reader->setOptions(options); PointTable table; reader->prepare(table); PointViewSet viewSet = reader->execute(table); EXPECT_EQ(viewSet.size(), 1u); PointViewPtr view = *viewSet.begin(); EXPECT_EQ(view->size(), 2u); checkPoint( *view, 0, 141437548, // time 82.605319, // latitude -58.593811, // longitude 18.678, // elevation 2408, // xmtSig 181, // rcvSig 49.91, // azimuth -4.376, // pitch 0.608, // roll 2.9, // gpsPdop 20.0, // pulseWidth 0.0); // relTime checkPoint( *view, 1, 141437548, // time 82.605287, // latitude -58.593811, // longitude 18.688, // elevation 2642, // xmtSig 173, // rcvSig 52.006, // azimuth -4.376, // pitch 0.609, // roll 2.9, // gpsPdop 17.0, // pulseWidth 0.0); // relTime }
TEST(IcebridgeReaderTest, testRead) { StageFactory f; ReaderPtr reader(f.createReader("readers.icebridge")); EXPECT_TRUE(reader.get()); Option filename("filename", getFilePath(), ""); Options options(filename); reader->setOptions(options); PointContext ctx; reader->prepare(ctx); PointBufferSet pbSet = reader->execute(ctx); EXPECT_EQ(pbSet.size(), 1u); PointBufferPtr buf = *pbSet.begin(); EXPECT_EQ(buf->size(), 2u); checkPoint( *buf, 0, 141437548, // time 82.605319, // latitude 301.406196, // longitude 18.678, // elevation 2408, // xmtSig 181, // rcvSig 49.91, // azimuth -4.376, // pitch 0.608, // roll 2.9, // gpsPdop 20.0, // pulseWidth 0.0); // relTime checkPoint( *buf, 1, 141437548, // time 82.605287, // latitude 301.404862, // longitude 18.688, // elevation 2642, // xmtSig 173, // rcvSig 52.006, // azimuth -4.376, // pitch 0.609, // roll 2.9, // gpsPdop 17.0, // pulseWidth 0.0); // relTime }
int SplitKernel::execute() { PointTable table; Options readerOpts; readerOpts.add("filename", m_inputFile); readerOpts.add("debug", isDebug()); readerOpts.add("verbose", getVerboseLevel()); Stage& reader = makeReader(m_inputFile); reader.setOptions(readerOpts); std::unique_ptr<Stage> f; StageFactory factory; Options filterOpts; if (m_length) { f.reset(factory.createStage("filters.splitter")); filterOpts.add("length", m_length); filterOpts.add("origin_x", m_xOrigin); filterOpts.add("origin_y", m_yOrigin); } else { f.reset(factory.createStage("filters.chipper")); filterOpts.add("capacity", m_capacity); } f->setInput(reader); f->setOptions(filterOpts); f->prepare(table); PointViewSet pvSet = f->execute(table); int filenum = 1; for (auto& pvp : pvSet) { BufferReader reader; reader.addView(pvp); std::string filename = makeFilename(m_outputFile, filenum++); Stage& writer = makeWriter(filename, reader); writer.prepare(table); writer.execute(table); } return 0; }
void writeData(Orientation orient, bool scaling, bool compression = false) { Options options; options.add("capacity", 10000); options.add("connection", std::string(connectString)); options.add("debug", "true"); options.add("block_table_name", blockTableName); options.add("base_table_name", baseTableName); options.add("cloud_column_name", "CLOUD"); options.add("srid", 26910); options.add("disable_cloud_trigger", true); options.add("store_dimensional_orientation", orient == Orientation::DimensionMajor); if (scaling) { options.add("offset_x", "auto"); options.add("offset_y", "auto"); options.add("offset_z", "auto"); options.add("scale_x", 1e-6); options.add("scale_y", 1e-6); options.add("scale_z", 1e-6); } if (compression) options.add("compression", true); PointTable table; Options readerOps; readerOps.add("filename", Support::datapath("autzen/autzen-utm.las")); StageFactory f; LasReader reader; reader.setOptions(readerOps); SplitFilter split; split.setInput(reader); Stage* writer(f.createStage("writers.oci")); EXPECT_TRUE(writer); writer->setOptions(options); writer->setInput(split); writer->prepare(table); writer->execute(table); }
Stage* Random::makeReader(Options readerOptions) { if (isDebug()) { readerOptions.add<bool>("debug", true); boost::uint32_t verbosity(getVerboseLevel()); if (!verbosity) verbosity = 1; readerOptions.add<boost::uint32_t>("verbose", verbosity); readerOptions.add<std::string>("log", "STDERR"); } StageFactory factory; Stage* reader_stage = factory.createReader("readers.faux"); reader_stage->setOptions(readerOptions); return reader_stage; }
TEST_F(PythonFilterTest, pdalargs) { StageFactory f; BOX3D bounds(0.0, 0.0, 0.0, 1.0, 1.0, 1.0); Options ops; ops.add("bounds", bounds); ops.add("count", 10); ops.add("mode", "ramp"); FauxReader reader; reader.setOptions(ops); Option source("source", "import numpy\n" "import sys\n" "import redirector\n" "def myfunc(ins,outs):\n" " pdalargs['name']\n" "# print ('pdalargs', pdalargs, file=sys.stderr,)\n" " return True\n" ); Option module("module", "MyModule"); Option function("function", "myfunc"); Option args("pdalargs", "{\"name\":\"Howard\",\"something\":42, \"another\": \"True\"}"); Options opts; opts.add(source); opts.add(module); opts.add(function); opts.add(args); Stage* filter(f.createStage("filters.python")); filter->setOptions(opts); filter->setInput(reader); PointTable table; filter->prepare(table); PointViewSet viewSet = filter->execute(table); EXPECT_EQ(viewSet.size(), 1u); PointViewPtr view = *viewSet.begin(); // Not throwing anything is success for now }
TEST(Stats, simple) { BOX3D bounds(1.0, 2.0, 3.0, 101.0, 102.0, 103.0); Options ops; ops.add("bounds", bounds); ops.add("count", 1000); ops.add("mode", "constant"); StageFactory f; std::unique_ptr<Stage> reader(f.createStage("readers.faux")); EXPECT_TRUE(reader.get()); reader->setOptions(ops); StatsFilter filter; filter.setInput(*reader); EXPECT_EQ(filter.getName(), "filters.stats"); PointTable table; filter.prepare(table); filter.execute(table); const stats::Summary& statsX = filter.getStats(Dimension::Id::X); const stats::Summary& statsY = filter.getStats(Dimension::Id::Y); const stats::Summary& statsZ = filter.getStats(Dimension::Id::Z); EXPECT_EQ(statsX.count(), 1000u); EXPECT_EQ(statsY.count(), 1000u); EXPECT_EQ(statsZ.count(), 1000u); EXPECT_FLOAT_EQ(statsX.minimum(), 1.0); EXPECT_FLOAT_EQ(statsY.minimum(), 2.0); EXPECT_FLOAT_EQ(statsZ.minimum(), 3.0); EXPECT_FLOAT_EQ(statsX.maximum(), 1.0); EXPECT_FLOAT_EQ(statsY.maximum(), 2.0); EXPECT_FLOAT_EQ(statsZ.maximum(), 3.0); EXPECT_FLOAT_EQ(statsX.average(), 1.0); EXPECT_FLOAT_EQ(statsY.average(), 2.0); EXPECT_FLOAT_EQ(statsZ.average(), 3.0); }
TEST(PredicateFilterTest, PredicateFilterTest_test5) { StageFactory f; // test error handling if missing Mask BOX3D bounds(0.0, 0.0, 0.0, 2.0, 2.0, 2.0); Options readerOpts; readerOpts.add("bounds", bounds); readerOpts.add("num_points", 1000); readerOpts.add("mode", "ramp"); FauxReader reader; reader.setOptions(readerOpts); const Option source("source", // "Y > 0.5" "import numpy as np\n" "def yow2(ins,outs):\n" " Y = ins['Y']\n" " Mask = np.greater(Y, 0.5)\n" " #print Mask\n" " outs['xxxMaskxxx'] = Mask # delierbately rong\n" " return True\n" ); const Option module("module", "MyModule1"); const Option function("function", "yow2"); Options opts; opts.add(source); opts.add(module); opts.add(function); std::unique_ptr<Stage> filter(f.createStage("filters.predicate")); filter->setOptions(opts); filter->setInput(reader); PointTable table; filter->prepare(table); ASSERT_THROW(filter->execute(table), plang::error); }
TEST(NitfWriterTest, longFtitle) { StageFactory f; Stage *r = f.createStage("readers.las"); Options ro; ro.add("filename", Support::datapath("nitf/autzen-utm10.las")); r->setOptions(ro); Stage *w = f.createStage("writers.nitf"); Options wo; wo.add("filename", "aaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbccccccccccccccccccccccddddddddddddddeeeeeeeeeeee"); w->setOptions(wo); w->setInput(*r); PointTable t; w->prepare(t); EXPECT_THROW(w->execute(t), pdal_error); }
TEST(OldPCLBlockTests, StatisticalOutliers2) { StageFactory f; Options ro; ro.add("filename", Support::datapath("autzen/autzen-point-format-3.las")); Stage* r(f.createStage("readers.las")); EXPECT_TRUE(r); r->setOptions(ro); Options fo; fo.add("method", "statistical"); fo.add("multiplier", 0.0); fo.add("mean_k", 5); Stage* outlier(f.createStage("filters.outlier")); EXPECT_TRUE(outlier); outlier->setOptions(fo); outlier->setInput(*r); Options rangeOpts; rangeOpts.add("limits", "Classification![7:7]"); Stage* range(f.createStage("filters.range")); EXPECT_TRUE(range); range->setOptions(rangeOpts); range->setInput(*outlier); PointTable table; range->prepare(table); PointViewSet viewSet = range->execute(table); EXPECT_EQ(1u, viewSet.size()); PointViewPtr view = *viewSet.begin(); EXPECT_EQ(63u, view->size()); }