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