TEST(PointViewTest, order) { PointTable table; const size_t COUNT(1000); std::array<PointViewPtr, COUNT> views; std::random_device dev; std::mt19937 generator(dev()); for (size_t i = 0; i < COUNT; ++i) views[i] = PointViewPtr(new PointView(table)); std::shuffle(views.begin(), views.end(), generator); PointViewSet set; for (size_t i = 0; i < COUNT; ++i) set.insert(views[i]); PointViewSet::iterator pi; for (auto si = set.begin(); si != set.end(); ++si) { if (si != set.begin()) EXPECT_TRUE((*pi)->id() < (*si)->id()); pi = si; } }
TEST(DecimationFilterTest, DecimationFilterTest_test1) { BOX3D srcBounds(0.0, 0.0, 0.0, 100.0, 100.0, 100.0); Options ops; ops.add("bounds", srcBounds); ops.add("mode", "random"); ops.add("num_points", 30); FauxReader reader; reader.setOptions(ops); Options decimationOps; decimationOps.add("step", 10); DecimationFilter filter; filter.setOptions(decimationOps); filter.setInput(reader); PointTable table; filter.prepare(table); PointViewSet viewSet = filter.execute(table); EXPECT_EQ(viewSet.size(), 1u); PointViewPtr view = *viewSet.begin(); EXPECT_EQ(view->size(), 3u); uint64_t t0 = view->getFieldAs<uint64_t>(Dimension::Id::OffsetTime, 0); uint64_t t1 = view->getFieldAs<uint64_t>(Dimension::Id::OffsetTime, 1); uint64_t t2 = view->getFieldAs<uint64_t>(Dimension::Id::OffsetTime, 2); EXPECT_EQ(t0, 0u); EXPECT_EQ(t1, 10u); EXPECT_EQ(t2, 20u); }
TEST(Ilvis2ReaderTest, testReadHigh) { Option filename("filename", Support::datapath("ilvis2/ILVIS2_TEST_FILE.TXT")); Options options(filename); options.add("mapping","high"); std::shared_ptr<Ilvis2Reader> reader(new Ilvis2Reader); 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(), 3u); checkPoint(*view.get(), 0, 42504.48313, 78.307672,-58.785213,1956.777 ); checkPoint(*view.get(), 1, 42504.48512, 78.307592, 101.215097, 1956.588 ); checkPoint(*view.get(), 2, 42504.48712, 78.307512, -58.78459, 2956.667 ); }
TEST(CropFilterTest, test_crop) { BOX3D srcBounds(0.0, 0.0, 0.0, 10.0, 100.0, 1000.0); Options opts; opts.add("bounds", srcBounds); opts.add("num_points", 1000); opts.add("mode", "ramp"); FauxReader reader; reader.setOptions(opts); // crop the window to 1/3rd the size in each dimension BOX2D dstBounds(3.33333, 33.33333, 6.66666, 66.66666); Options cropOpts; cropOpts.add("bounds", dstBounds); CropFilter filter; filter.setOptions(cropOpts); filter.setInput(reader); Options statOpts; StatsFilter stats; stats.setOptions(statOpts); stats.setInput(filter); PointTable table; stats.prepare(table); PointViewSet viewSet = stats.execute(table); EXPECT_EQ(viewSet.size(), 1u); PointViewPtr buf = *viewSet.begin(); 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_EQ(buf->size(), 333u); const double minX = statsX.minimum(); const double minY = statsY.minimum(); const double minZ = statsZ.minimum(); const double maxX = statsX.maximum(); const double maxY = statsY.maximum(); const double maxZ = statsZ.maximum(); const double avgX = statsX.average(); const double avgY = statsY.average(); const double avgZ = statsZ.average(); const double delX = 10.0 / 999.0 * 100.0; const double delY = 100.0 / 999.0 * 100.0; const double delZ = 1000.0 / 999.0 * 100.0; EXPECT_NEAR(minX, 3.33333, delX); EXPECT_NEAR(minY, 33.33333, delY); EXPECT_NEAR(minZ, 333.33333, delZ); EXPECT_NEAR(maxX, 6.66666, delX); EXPECT_NEAR(maxY, 66.66666, delY); EXPECT_NEAR(maxZ, 666.66666, delZ); EXPECT_NEAR(avgX, 5.00000, delX); EXPECT_NEAR(avgY, 50.00000, delY); EXPECT_NEAR(avgZ, 500.00000, delZ); }
TEST(RangeFilterTest, negativeValues) { BOX3D srcBounds(0.0, 0.0, -10.0, 0.0, 0.0, 10.0); Options ops; ops.add("bounds", srcBounds); ops.add("mode", "ramp"); ops.add("count", 21); FauxReader reader; reader.setOptions(ops); Options rangeOps; rangeOps.add("limits", "Z[-1:1)"); RangeFilter filter; filter.setOptions(rangeOps); filter.setInput(reader); PointTable table; filter.prepare(table); PointViewSet viewSet = filter.execute(table); PointViewPtr view = *viewSet.begin(); EXPECT_EQ(1u, viewSet.size()); EXPECT_EQ(2u, view->size()); EXPECT_FLOAT_EQ(-1.0, view->getFieldAs<double>(Dimension::Id::Z, 0)); EXPECT_FLOAT_EQ(0.0, view->getFieldAs<double>(Dimension::Id::Z, 1)); }
TEST(QFITReaderTest, test_10_word) { Options options; options.add("filename", Support::datapath("qfit/10-word.qi"), "Input filename for reader to use"); options.add("flip_coordinates", false, "Flip coordinates from 0-360 to -180-180"); options.add("scale_z", 0.001f, "Z scale from mm to m"); options.add("count", 3); std::shared_ptr<QfitReader> reader(new QfitReader); reader->setOptions(options); EXPECT_EQ(reader->getName(), "readers.qfit"); PointTable table; reader->prepare(table); PointViewSet viewSet = reader->execute(table); EXPECT_EQ(viewSet.size(), 1u); PointViewPtr view = *viewSet.begin(); EXPECT_EQ(view->size(), 3u); Check_Point(*view, 0, 221.826822, 59.205160, 32.0900, 0); Check_Point(*view, 1, 221.826740, 59.205161, 32.0190, 0); Check_Point(*view, 2, 221.826658, 59.205164, 32.0000, 0); }
TEST(RangeFilterTest, negation) { BOX3D srcBounds(0.0, 0.0, 1.0, 0.0, 0.0, 10.0); Options ops; ops.add("bounds", srcBounds); ops.add("mode", "ramp"); ops.add("count", 10); StageFactory f; FauxReader reader; reader.setOptions(ops); Options rangeOps; rangeOps.add("limits", "Z![2:5]"); RangeFilter filter; filter.setOptions(rangeOps); filter.setInput(reader); PointTable table; filter.prepare(table); PointViewSet viewSet = filter.execute(table); PointViewPtr view = *viewSet.begin(); EXPECT_EQ(1u, viewSet.size()); EXPECT_EQ(6u, view->size()); EXPECT_FLOAT_EQ(1.0, view->getFieldAs<double>(Dimension::Id::Z, 0)); EXPECT_FLOAT_EQ(6.0, view->getFieldAs<double>(Dimension::Id::Z, 1)); EXPECT_FLOAT_EQ(7.0, view->getFieldAs<double>(Dimension::Id::Z, 2)); EXPECT_FLOAT_EQ(8.0, view->getFieldAs<double>(Dimension::Id::Z, 3)); EXPECT_FLOAT_EQ(9.0, view->getFieldAs<double>(Dimension::Id::Z, 4)); EXPECT_FLOAT_EQ(10.0, view->getFieldAs<double>(Dimension::Id::Z, 5)); }
// Test that data from three input views gets written to separate output files. TEST(LasWriterTest, flex) { std::array<std::string, 3> outname = {{ "test_1.las", "test_2.las", "test_3.las" }}; Options readerOps; readerOps.add("filename", Support::datapath("las/simple.las")); PointTable table; LasReader reader; 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); for (size_t i = 0; i < outname.size(); ++i) FileUtils::deleteFile(Support::temppath(outname[i])); BufferReader reader2; reader2.addView(v1); reader2.addView(v2); reader2.addView(v3); Options writerOps; writerOps.add("filename", Support::temppath("test_#.las")); LasWriter writer; writer.setOptions(writerOps); writer.setInput(reader2); writer.prepare(table); writer.execute(table); for (size_t i = 0; i < outname.size(); ++i) { std::string filename = Support::temppath(outname[i]); EXPECT_TRUE(FileUtils::fileExists(filename)); Options ops; ops.add("filename", filename); LasReader r; r.setOptions(ops); EXPECT_EQ(r.preview().m_pointCount, 355u); } }
TEST(FerryFilterTest, test_ferry_copy_xml) { PipelineManager mgr; mgr.readPipeline(Support::configuredpath("filters/ferry.xml")); mgr.execute(); ConstPointTableRef table(mgr.pointTable()); PointViewSet viewSet = mgr.views(); EXPECT_EQ(viewSet.size(), 1u); PointViewPtr view = *viewSet.begin(); EXPECT_EQ(view->size(), 1065u); Dimension::Id::Enum state_plane_x = table.layout()->findDim("StatePlaneX"); Dimension::Id::Enum state_plane_y = table.layout()->findDim("StatePlaneY"); double lon = view->getFieldAs<double>(Dimension::Id::X, 0); double lat = view->getFieldAs<double>(Dimension::Id::Y, 0); double x = view->getFieldAs<double>(state_plane_x, 0); double y = view->getFieldAs<double>(state_plane_y, 0); EXPECT_DOUBLE_EQ(-117.2501328350574, lon); EXPECT_DOUBLE_EQ(49.341077824192915, lat); EXPECT_DOUBLE_EQ(637012.24, x); EXPECT_DOUBLE_EQ(849028.31, y); }
TEST(RangeFilterTest, multipleDimensions) { BOX3D srcBounds(0.0, 1.0, 1.0, 0.0, 10.0, 10.0); Options ops; ops.add("bounds", srcBounds); ops.add("mode", "ramp"); ops.add("count", 10); FauxReader reader; reader.setOptions(ops); Options rangeOps; rangeOps.add("limits", "Y[4.00e0:+6]"); rangeOps.add("limits", "Z[4:6]"); RangeFilter filter; filter.setOptions(rangeOps); filter.setInput(reader); PointTable table; filter.prepare(table); PointViewSet viewSet = filter.execute(table); PointViewPtr view = *viewSet.begin(); EXPECT_EQ(1u, viewSet.size()); EXPECT_EQ(3u, view->size()); EXPECT_FLOAT_EQ(4.0, view->getFieldAs<double>(Dimension::Id::Y, 0)); EXPECT_FLOAT_EQ(5.0, view->getFieldAs<double>(Dimension::Id::Y, 1)); EXPECT_FLOAT_EQ(6.0, view->getFieldAs<double>(Dimension::Id::Y, 2)); EXPECT_FLOAT_EQ(4.0, view->getFieldAs<double>(Dimension::Id::Z, 0)); EXPECT_FLOAT_EQ(5.0, view->getFieldAs<double>(Dimension::Id::Z, 1)); EXPECT_FLOAT_EQ(6.0, view->getFieldAs<double>(Dimension::Id::Z, 2)); }
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")); }
PointViewSet PredicateFilter::run(PointViewPtr view) { MetadataNode n; m_pythonMethod->resetArguments(); m_pythonMethod->begin(*view, n); m_pythonMethod->execute(); if (!m_pythonMethod->hasOutputVariable("Mask")) throw pdal::pdal_error("Mask variable not set in predicate " "filter function."); PointViewPtr outview = view->makeNew(); void *pydata = m_pythonMethod->extractResult("Mask", Dimension::Type::Unsigned8); char *ok = (char *)pydata; for (PointId idx = 0; idx < view->size(); ++idx) if (*ok++) outview->appendPoint(*view, idx); PointViewSet viewSet; viewSet.insert(outview); return viewSet; }
TEST(RangeFilterTest, simple_logic) { Options ops; ops.add("bounds", BOX3D(1, 101, 201, 10, 110, 210)); ops.add("mode", "ramp"); ops.add("count", 10); FauxReader reader; reader.setOptions(ops); Options rangeOps; rangeOps.add("limits", "Y[108:109], X[2:5], Z[1:1000], X[7:9], Y[103:105]"); RangeFilter filter; filter.setOptions(rangeOps); filter.setInput(reader); PointTable table; filter.prepare(table); PointViewSet viewSet = filter.execute(table); PointViewPtr view = *viewSet.begin(); EXPECT_EQ(1u, viewSet.size()); EXPECT_EQ(5u, view->size()); EXPECT_EQ(view->getFieldAs<int>(Dimension::Id::X, 0), 3); EXPECT_EQ(view->getFieldAs<int>(Dimension::Id::X, 1), 4); EXPECT_EQ(view->getFieldAs<int>(Dimension::Id::X, 2), 5); EXPECT_EQ(view->getFieldAs<int>(Dimension::Id::X, 3), 8); EXPECT_EQ(view->getFieldAs<int>(Dimension::Id::X, 4), 9); }
PointViewSet LocateFilter::run(PointViewPtr inView) { PointViewSet viewSet; if (!inView->size()) return viewSet; PointId minidx, maxidx; double minval = (std::numeric_limits<double>::max)(); double maxval = std::numeric_limits<double>::lowest(); for (PointId idx = 0; idx < inView->size(); idx++) { double val = inView->getFieldAs<double>(m_dimId, idx); if (val > maxval) { maxval = val; maxidx = idx; } if (val < minval) { minval = val; minidx = idx; } } PointViewPtr outView = inView->makeNew(); if (Utils::iequals("min", m_minmax)) outView->appendPoint(*inView.get(), minidx); if (Utils::iequals("max", m_minmax)) outView->appendPoint(*inView.get(), maxidx); viewSet.insert(outView); return viewSet; }
int GroundKernel::execute() { PointTable table; Stage& readerStage(makeReader(m_inputFile, "")); Options groundOptions; groundOptions.add("max_window_size", m_maxWindowSize); groundOptions.add("slope", m_slope); groundOptions.add("max_distance", m_maxDistance); groundOptions.add("initial_distance", m_initialDistance); groundOptions.add("cell_size", m_cellSize); groundOptions.add("classify", m_classify); groundOptions.add("extract", m_extract); groundOptions.add("approximate", m_approximate); Stage& groundStage = makeFilter("filters.ground", readerStage); groundStage.addOptions(groundOptions); // setup the Writer and write the results Stage& writer(makeWriter(m_outputFile, groundStage, "")); 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; }
static void test_a_format(const std::string& file, uint8_t majorVersion, uint8_t minorVersion, int pointFormat, double xref, double yref, double zref, double tref, uint16_t rref, uint16_t gref, uint16_t bref) { PointTable table; Options ops1; ops1.add("filename", Support::datapath(file)); ops1.add("count", 1); LasReader reader; reader.setOptions(ops1); reader.prepare(table); EXPECT_EQ(reader.header().pointFormat(), pointFormat); EXPECT_EQ(reader.header().versionMajor(), majorVersion); EXPECT_EQ(reader.header().versionMinor(), minorVersion); PointViewSet viewSet = reader.execute(table); EXPECT_EQ(viewSet.size(), 1u); PointViewPtr view = *viewSet.begin(); EXPECT_EQ(view->size(), 1u); Support::check_pN(*view, 0, xref, yref, zref, tref, rref, gref, bref); }
TEST(RandomizeFilterTest, simple) { // This isn't a real test. It's just here to allow easy debugging. point_count_t count = 1000; Options readerOps; readerOps.add("bounds", BOX3D(1, 1, 1, (double)count, (double)count, (double)count)); readerOps.add("mode", "ramp"); readerOps.add("count", count); FauxReader r; r.setOptions(readerOps); RandomizeFilter f; f.setInput(r); PointTable t; f.prepare(t); PointViewSet s = f.execute(t); EXPECT_EQ(s.size(), 1u); PointViewPtr v = *s.begin(); EXPECT_EQ(v->size(), (size_t)count); /** for (PointId i = 0; i < count; i++) std::cerr << "X[" << i << "] = " << v->getFieldAs<double>(Dimension::Id::X, i) << "!\n"; **/ }
void PointView::calculateBounds(const PointViewSet& set, BOX3D& output) { for (auto iter = set.begin(); iter != set.end(); ++iter) { PointViewPtr buf = *iter; buf->calculateBounds(output); } }
PointViewSet DecimationFilter::run(PointViewPtr inView) { PointViewSet viewSet; PointViewPtr outView = inView->makeNew(); decimate(*inView.get(), *outView.get()); viewSet.insert(outView); return viewSet; }
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)); }
PointViewPtr DeltaKernel::loadSet(const std::string& filename, PointTable& table) { Stage& reader = makeReader(filename, m_driverOverride); reader.prepare(table); PointViewSet viewSet = reader.execute(table); assert(viewSet.size() == 1); return *viewSet.begin(); }
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; }
PointViewSet PMFFilter::run(PointViewPtr input) { bool logOutput = log()->getLevel() > LogLevel::Debug1; if (logOutput) log()->floatPrecision(8); log()->get(LogLevel::Debug2) << "Process PMFFilter...\n"; auto idx = processGround(input); PointViewSet viewSet; if (!idx.empty() && (m_classify || m_extract)) { if (m_classify) { log()->get(LogLevel::Debug2) << "Labeled " << idx.size() << " ground returns!\n"; // set the classification label of ground returns as 2 // (corresponding to ASPRS LAS specification) for (const auto& i : idx) { input->setField(Dimension::Id::Classification, i, 2); } viewSet.insert(input); } if (m_extract) { log()->get(LogLevel::Debug2) << "Extracted " << idx.size() << " ground returns!\n"; // create new PointView containing only ground returns PointViewPtr output = input->makeNew(); for (const auto& i : idx) { output->appendPoint(*input, i); } viewSet.erase(input); viewSet.insert(output); } } else { if (idx.empty()) log()->get(LogLevel::Debug2) << "Filtered cloud has no ground returns!\n"; if (!(m_classify || m_extract)) log()->get(LogLevel::Debug2) << "Must choose --classify or --extract\n"; // return the input buffer unchanged viewSet.insert(input); } return viewSet; }
// 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()); }
PointViewSet SMRFilter::run(PointViewPtr view) { log()->get(LogLevel::Info) << "run: Process SMRFilter...\n"; std::vector<PointId> idx = processGround(view); PointViewSet viewSet; if (!idx.empty() && (m_classify || m_extract)) { if (m_classify) { log()->get(LogLevel::Info) << "run: Labeled " << idx.size() << " ground returns!\n"; // set the classification label of ground returns as 2 // (corresponding to ASPRS LAS specification) for (const auto& i : idx) { view->setField(Dimension::Id::Classification, i, 2); } viewSet.insert(view); } if (m_extract) { log()->get(LogLevel::Info) << "run: Extracted " << idx.size() << " ground returns!\n"; // create new PointView containing only ground returns PointViewPtr output = view->makeNew(); for (const auto& i : idx) { output->appendPoint(*view, i); } viewSet.erase(view); viewSet.insert(output); } } else { if (idx.empty()) log()->get(LogLevel::Info) << "run: Filtered cloud has no ground returns!\n"; if (!(m_classify || m_extract)) log()->get(LogLevel::Info) << "run: Must choose --classify or --extract\n"; // return the view buffer unchanged viewSet.insert(view); } return viewSet; }
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); }
int SmoothKernel::execute() { PointTable table; Stage& readerStage(makeReader(m_inputFile, "")); // go ahead and prepare/execute on reader stage only to grab input // PointViewSet, this makes the input PointView available to both the // processing pipeline and the visualizer readerStage.prepare(table); PointViewSet viewSetIn = readerStage.execute(table); // the input PointViewSet will be used to populate a BufferReader that is // consumed by the processing pipeline PointViewPtr input_view = *viewSetIn.begin(); PipelineManager manager; manager.commonOptions() = m_manager.commonOptions(); manager.stageOptions() = m_manager.stageOptions(); BufferReader& bufferReader = static_cast<BufferReader&>(manager.makeReader("", "readers.buffer")); bufferReader.addView(input_view); std::ostringstream ss; ss << "{"; ss << " \"pipeline\": {"; ss << " \"filters\": [{"; ss << " \"name\": \"MovingLeastSquares\""; ss << " }]"; ss << " }"; ss << "}"; Options smoothOptions; smoothOptions.add("json", ss.str()); Stage& smoothStage = manager.makeFilter("filters.pclblock", bufferReader); smoothStage.addOptions(smoothOptions); Stage& writer(Kernel::makeWriter(m_outputFile, smoothStage, "")); 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(LasWriterTest, all_extra_dims) { Options readerOps; readerOps.add("filename", Support::datapath("bpf/simple-extra.bpf")); BpfReader reader; reader.setOptions(readerOps); FileUtils::deleteFile(Support::temppath("simple.las")); Options writerOps; writerOps.add("extra_dims", "all"); writerOps.add("filename", Support::temppath("simple.las")); writerOps.add("minor_version", 4); LasWriter writer; writer.setInput(reader); writer.setOptions(writerOps); PointTable table; writer.prepare(table); writer.execute(table); Options ops; ops.add("filename", Support::temppath("simple.las")); LasReader r; r.setOptions(ops); PointTable t2; r.prepare(t2); Dimension::Id foo = t2.layout()->findDim("Foo"); Dimension::Id bar = t2.layout()->findDim("Bar"); Dimension::Id baz = t2.layout()->findDim("Baz"); PointViewSet s = r.execute(t2); EXPECT_EQ(s.size(), 1u); PointViewPtr v = *s.begin(); // We test for floats instead of doubles because when X, Y and Z // get written, they are written scaled, which loses precision. The // foo, bar and baz values are written as full-precision doubles. for (PointId i = 0; i < v->size(); ++i) { using namespace Dimension; ASSERT_FLOAT_EQ(v->getFieldAs<float>(Id::X, i), v->getFieldAs<float>(foo, i)); ASSERT_FLOAT_EQ(v->getFieldAs<float>(Id::Y, i), v->getFieldAs<float>(bar, i)); ASSERT_FLOAT_EQ(v->getFieldAs<float>(Id::Z, i), v->getFieldAs<float>(baz, i)); } }