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