Options getReaderOptions()
{
Options options;
options.add("spatialreference", "EPSG:2926");
options.add("connection", tempFilename);
options.add("query", "SELECT b.schema, l.cloud, l.block_id, "
"l.num_points, l.bbox, l.extent, l.points, b.cloud "
"FROM PDAL_TEST_BLOCKS l, PDAL_TEST_BASE b "
"WHERE l.cloud = b.cloud and l.cloud in (1) "
"order by l.cloud");
return options;
}
const Options InPlaceReprojection::getDefaultOptions() const
{
Options options;
Option in_srs("in_srs", std::string(""),"Input SRS to use to override -- fetched from previous stage if not present");
Option out_srs("out_srs", std::string(""), "Output SRS to reproject to");
Option x("x_dim", std::string("X"), "Dimension name to use for 'X' data");
Option y("y_dim", std::string("Y"), "Dimension name to use for 'Y' data");
Option z("z_dim", std::string("Z"), "Dimension name to use for 'Z' data");
Option x_scale("scale_x", 1.0f, "Scale for output X data in the case when 'X' dimension data are to be scaled. Defaults to '1.0'. If not set, the Dimensions's scale will be used");
Option y_scale("scale_y", 1.0f, "Scale for output Y data in the case when 'Y' dimension data are to be scaled. Defaults to '1.0'. If not set, the Dimensions's scale will be used");
Option z_scale("scale_z", 1.0f, "Scale for output Z data in the case when 'Z' dimension data are to be scaled. Defaults to '1.0'. If not set, the Dimensions's scale will be used");
Option x_offset("offset_x", 0.0f, "Offset for output X data in the case when 'X' dimension data are to be scaled. Defaults to '0.0'. If not set, the Dimensions's scale will be used");
Option y_offset("offset_y", 0.0f, "Offset for output Y data in the case when 'Y' dimension data are to be scaled. Defaults to '0.0'. If not set, the Dimensions's scale will be used");
Option z_offset("offset_z", 0.0f, "Offset for output Z data in the case when 'Z' dimension data are to be scaled. Defaults to '0.0'. If not set, the Dimensions's scale will be used");
options.add(in_srs);
options.add(out_srs);
options.add(x);
options.add(y);
options.add(z);
options.add(x_scale);
options.add(y_scale);
options.add(z_scale);
options.add(x_offset);
options.add(y_offset);
options.add(z_offset);
return options;
}
Options *TTestBayesianOneSample::createDefaultOptions()
{
Options *options = new Options();
options->add("variables", new OptionFields());
options->add("testValue", new OptionNumber(0));
options->add("meanDifference", new OptionBoolean());
options->add("confidenceInterval", new OptionBoolean());
options->add("confidenceIntervalInterval", new OptionNumber(.95, 0, 1, "%"));
options->add("descriptives", new OptionBoolean());
vector<string> missingValues;
missingValues.push_back("excludeAnalysisByAnalysis");
missingValues.push_back("excludeListwise");
options->add("missingValues", new OptionList(missingValues));
vector<string> tails;
tails.push_back("twoTailed");
tails.push_back("oneTailedGreaterThan");
tails.push_back("oneTailedLessThan");
options->add("tails", new OptionList(tails));
return options;
}
TEST(SplitterTest, test_buffer)
{
Options readerOptions;
readerOptions.add("filename", Support::datapath("las/1.2-with-color.las"));
LasReader reader;
reader.setOptions(readerOptions);
Options splitterOptions;
splitterOptions.add("length", 1000);
splitterOptions.add("buffer", 20);
SplitterFilter splitter;
splitter.setOptions(splitterOptions);
splitter.setInput(reader);
PointTable table;
splitter.prepare(table);
PointViewSet viewSet = splitter.execute(table);
std::vector<PointViewPtr> views;
std::map<PointViewPtr, BOX2D> bounds;
for (auto it = viewSet.begin(); it != viewSet.end(); ++it)
{
BOX2D b;
PointViewPtr v = *it;
v->calculateBounds(b);
EXPECT_TRUE(b.maxx - b.minx <= 1040);
EXPECT_TRUE(b.maxy - b.miny <= 1040);
bounds[v] = b;
views.push_back(v);
}
auto sorter = [&bounds](PointViewPtr p1, PointViewPtr p2)
{
BOX2D b1 = bounds[p1];
BOX2D b2 = bounds[p2];
return b1.minx < b2.minx ? true :
b1.minx > b2.minx ? false :
b1.miny < b2.miny;
};
std::sort(views.begin(), views.end(), sorter);
EXPECT_EQ(views.size(), 24u);
size_t counts[] = {26, 26, 3, 28, 27, 13, 14, 65, 80, 47, 80, 89, 94,
77, 5, 79, 65, 34, 63, 67, 74, 69, 36, 5};
size_t i = 0;
for (PointViewPtr view : views)
EXPECT_EQ(view->size(), counts[i++]);
}
Options Predicate::getDefaultOptions()
{
Options options;
Option script("script", "");
options.add(script);
Option module("module", "");
options.add(module);
Option function("function", "");
options.add(function);
return options;
}
Options Crop::getDefaultOptions()
{
Options options;
Option bounds("bounds",BOX3D(),"bounds to crop to");
Option polygon("polygon", std::string(""),
"WKT POLYGON() string to use to filter points");
Option inside("inside", true, "keep points that are inside or outside "
"the given polygon");
options.add(inside);
options.add(polygon);
options.add(bounds);
return options;
}
TEST(LasWriterTest, auto_offset)
{
using namespace Dimension;
const std::string FILENAME(Support::temppath("offset_test.las"));
PointTable table;
table.layout()->registerDim(Id::X);
BufferReader bufferReader;
PointViewPtr view(new PointView(table));
view->setField(Id::X, 0, 125000.00);
view->setField(Id::X, 1, 74529.00);
view->setField(Id::X, 2, 523523.02);
bufferReader.addView(view);
Options writerOps;
writerOps.add("filename", FILENAME);
writerOps.add("offset_x", "auto");
writerOps.add("scale_x", "auto");
LasWriter writer;
writer.setOptions(writerOps);
writer.setInput(bufferReader);
writer.prepare(table);
writer.execute(table);
Options readerOps;
readerOps.add("filename", FILENAME);
PointTable readTable;
LasReader reader;
reader.setOptions(readerOps);
reader.prepare(readTable);
EXPECT_DOUBLE_EQ(74529.00, reader.header().offsetX());
PointViewSet viewSet = reader.execute(readTable);
EXPECT_EQ(viewSet.size(), 1u);
view = *viewSet.begin();
EXPECT_EQ(view->size(), 3u);
EXPECT_NEAR(125000.00, view->getFieldAs<double>(Id::X, 0), .0001);
EXPECT_NEAR(74529.00, view->getFieldAs<double>(Id::X, 1), .0001);
EXPECT_NEAR(523523.02, view->getFieldAs<double>(Id::X, 2), .0001);
FileUtils::deleteFile(FILENAME);
}
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);
}
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"));
}
Options QfitReader::getDefaultOptions()
{
Options options;
Option filename("filename", "", "file to read from");
Option flip_coordinates("flip_coordinates", true,
"Flip coordinates from 0-360 to -180-180");
Option convert_z_units("scale_z", 0.001f,
"Z scale. Use 0.001 to go from mm to m");
Option little_endian("little_endian", false,
"Are data in little endian format?");
options.add(filename);
options.add(flip_coordinates);
options.add(convert_z_units);
options.add(little_endian);
return options;
}
void InfoKernel::setup(const std::string& filename)
{
m_manager = makePipeline(filename, !m_needPoints);
Stage *stage = m_manager->getStage();
if (m_showStats)
{
m_statsStage = &(m_manager->addFilter("filters.stats"));
if (m_dimensions.size())
{
Options ops;
ops.add("dimensions", m_dimensions);
m_statsStage->addOptions(ops);
}
m_statsStage->setInput(*stage);
stage = m_statsStage;
}
if (m_boundary)
{
m_hexbinStage = &(m_manager->addFilter("filters.hexbin"));
if (!m_hexbinStage) {
throw pdal_error("Unable to compute boundary -- "
"http://github.com/hobu/hexer is not linked. "
"See the \"boundary\" member in \"stats\" for a coarse "
"bounding box");
}
m_hexbinStage->setInput(*stage);
}
}
int main(int argc, char * const *argv)
{
bool readable = false;
vector<string> graphs;
options.add('h', "human", readable, true, "Human readable output.");
std::set_new_handler(out_of_memory);
std::locale::global(std::locale(""));
graphs = options.parseArgs(argc, argv);
if (graphs.size() != 1) {
cerr << "Wrong number of arguments!" << endl;
options.usage(cerr);
}
if (readable) cout.imbue(std::locale());
Graph<uint64_t, uint64_t> graph(graphs[0]);
for (auto v : graph.vertices) {
for (auto &e : v.edges) {
cout << v.id << " " << e << endl;
}
}
return 0;
}
Options defaultRxpReaderOptions()
{
Options options;
Option filename("filename", testDataPath() + "130501_232206_cut.rxp");
options.add(filename);
return options;
}
const Options Crop::getDefaultOptions() const
{
Options options;
Option bounds("bounds",Bounds<double>(),"bounds to crop to");
options.add(bounds);
return options;
}
Options FauxReader::getDefaultOptions()
{
Options options;
Option count("num_points", 10, "Number of points");
options.add(count);
return options;
}
TEST(OptionsTest, implicitdefault)
{
Options ops;
ops.add("a", "This, is,a, test ,,");
ops.add("b", 25);
int i = ops.getValueOrDefault<int>("c");
EXPECT_EQ(i, 0);
i = ops.getValueOrDefault<int>("b");
EXPECT_EQ(i, 25);
std::vector<std::string> slist =
ops.getValueOrDefault<std::vector<std::string>>("d");
EXPECT_EQ(slist.size(), (size_t)0);
slist = ops.getValueOrDefault<std::vector<std::string>>("a");
EXPECT_EQ(slist.size(), (size_t)4);
}
Options Splitter::getDefaultOptions()
{
Options options;
Option length("length", 1000, "Splitter length");
options.add(length);
return options;
}
Options makeFilterOptions(int threadNum, int filterNum, bool log)
{
using namespace std;
ostringstream id;
id << "T" << threadNum << "F" << filterNum;
ostringstream function_id;
function_id << "function_" << id.str();
ostringstream module_id;
function_id << "module_" << id.str();
ostringstream script;
script <<
"import numpy as np\n"
"def " << function_id.str() << "(ins,outs):\n"
" #print 'hi1 " << id.str() << "'\n"
" X = ins['X']\n"
" #print 'hi2 " << id.str() << "'\n"
" X = X + 1.0\n"
" #print 'hi2 " << id.str() << "'\n"
" outs['X'] = X\n"
" #print 'hi4 " << id.str() << "'\n"
" return True\n"
;
Options opts;
{
const pdal::Option source("source", script.str());
const pdal::Option module("module", module_id.str());
const pdal::Option function("function", function_id.str());
opts.add(source);
opts.add(module);
opts.add(function);
if (log)
{
ostringstream log_id;
log_id << "log_" << id.str() << ".txt";
Option optlog("log", Support::temppath(log_id.str()));
opts.add(optlog);
}
}
return opts;
}
Options ColorizationFilter::getDefaultOptions()
{
Options options;
options.add("dimensions", "Red:1:1.0, Green:2:1.0, Blue:3");
return options;
}
TEST(RangeFilterTest, stream_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 range;
range.setOptions(rangeOps);
range.setInput(reader);
StreamCallbackFilter f;
f.setInput(range);
FixedPointTable table(20);
f.prepare(table);
auto cb = [](PointRef& point)
{
static int i = 0;
int x = point.getFieldAs<int>(Dimension::Id::X);
if (i == 0)
EXPECT_EQ(x, 3);
else if (i == 1)
EXPECT_EQ(x, 4);
else if (i == 2)
EXPECT_EQ(x, 5);
else if (i == 3)
EXPECT_EQ(x, 8);
else if (i == 4)
EXPECT_EQ(x, 9);
EXPECT_TRUE(i < 5);
++i;
return true;
};
f.setCallback(cb);
f.execute(table);
}
const Options Writer::getDefaultOptions() const
{
Options options;
Option grid_x("grid_dist_x", 6.0, "X grid distance");
Option grid_y("grid_dist_y", 6.0, "Y grid distance");
double default_radius = (double) sqrt(2.0) * grid_x.getValue<double>();
Option radius("radius", default_radius);
Option fill_window_size("fill_window_size", 3);
options.add(grid_x);
options.add(grid_y);
options.add(radius);
options.add(fill_window_size);
return options;
}
int SortKernel::execute()
{
Stage& readerStage = makeReader(m_inputFile, m_driverOverride);
Stage& sortStage = makeFilter("filters.mortonorder", readerStage);
Options writerOptions;
if (m_bCompress)
writerOptions.add("compression", true);
if (m_bForwardMetadata)
writerOptions.add("forward_metadata", true);
Stage& writer = makeWriter(m_outputFile, sortStage, "", writerOptions);
PointTable table;
writer.prepare(table);
writer.execute(table);
return 0;
}
const Options Index::getDefaultOptions() const
{
Options options;
Option x("x_dim", std::string("X"), "Dimension name to use for 'X' data");
Option y("y_dim", std::string("Y"), "Dimension name to use for 'Y' data");
Option z("z_dim", std::string("Z"), "Dimension name to use for 'Z' data");
Option filename("filename", "", "Filename to store the index in");
options.add(x);
options.add(y);
options.add(z);
options.add(filename);
return options;
}
Options makeReaderOptions()
{
Options opts;
{
const Bounds<double> bounds(1.0, 2.0, 3.0, 101.0, 102.0, 103.0);
Option opt1("bounds", bounds);
Option opt2("log", Support::temppath("logtest_1.txt"));
Option opt3("num_points", 1000);
Option opt4("mode", "constant");
opts.add(opt1);
opts.add(opt2);
opts.add(opt3);
opts.add(opt4);
}
return opts;
}
const Options Cache::getDefaultOptions() const
{
Options options;
Option max_cache_blocks("max_cache_blocks", 1);
Option cache_block_size("cache_block_size", 32768);
options.add(max_cache_blocks);
options.add(cache_block_size);
return options;
}
TEST(TextReaderTest, t1a)
{
Options textOptions;
textOptions.add("separator", ',');
compareTextLas(Support::datapath("text/utm17_1.txt"),
textOptions, Support::datapath("las/utm17.las"));
}
TEST(LasWriterTest, pdal_add_vlr)
{
PointTable table;
std::string infile(Support::datapath("las/1.2-with-color.las"));
std::string outfile(Support::temppath("simple.las"));
// remove file from earlier run, if needed
FileUtils::deleteFile(outfile);
Options readerOpts;
readerOpts.add("filename", infile);
std::string vlr( " [ { \"description\": \"A description under 32 bytes\", \"record_id\": 42, \"user_id\": \"hobu\", \"data\": \"dGhpcyBpcyBzb21lIHRleHQ=\" }, { \"description\": \"A description under 32 bytes\", \"record_id\": 43, \"user_id\": \"hobu\", \"data\": \"dGhpcyBpcyBzb21lIG1vcmUgdGV4dA==\" } ]");
Options writerOpts;
writerOpts.add("vlrs", vlr);
writerOpts.add("filename", outfile);
LasReader reader;
reader.setOptions(readerOpts);
LasWriter writer;
writer.setOptions(writerOpts);
writer.setInput(reader);
writer.prepare(table);
writer.execute(table);
PointTable t2;
Options readerOpts2;
readerOpts2.add("filename", outfile);
LasReader reader2;
reader2.setOptions(readerOpts2);
reader2.prepare(t2);
reader2.execute(t2);
MetadataNode forward = reader2.getMetadata();
auto pred = [](MetadataNode temp)
{ return Utils::startsWith(temp.name(), "vlr_"); };
MetadataNodeList nodes = forward.findChildren(pred);
EXPECT_EQ(nodes.size(), 2UL);
}
// Make sure that spatialreference works for random readers
TEST(json, issue_2159)
{
class XReader : public Reader
{
std::string getName() const
{ return "readers.x"; }
virtual void addDimensions(PointLayoutPtr layout)
{
using namespace Dimension;
layout->registerDims( { Id::X, Id::Y, Id::Z } );
}
virtual point_count_t read(PointViewPtr v, point_count_t count)
{
using namespace Dimension;
for (PointId idx = 0; idx < count; ++idx)
{
v->setField(Id::X, idx, idx);
v->setField(Id::Y, idx, 10 * idx);
v->setField(Id::Z, idx, 1.152);
}
return count;
}
};
XReader xr;
Options rOpts;
rOpts.add("count", "1000");
rOpts.add("spatialreference", "EPSG:4326");
xr.setOptions(rOpts);
StatsFilter f;
f.setInput(xr);
PointTable t;
f.prepare(t);
PointViewSet s = f.execute(t);
PointViewPtr v = *(s.begin());
SpatialReference srs = v->spatialReference();
EXPECT_EQ(srs, SpatialReference("EPSG:4326"));
}
Stage *PipelineReaderXML::parseElement_Writer(const ptree& tree)
{
Options options;
StageParserContext context;
std::string filename;
map_t attrs;
collect_attributes(attrs, tree);
std::vector<Stage *> prevStages;
for (auto iter = tree.begin(); iter != tree.end(); ++iter)
{
const std::string& name = iter->first;
const ptree& subtree = iter->second;
if (name == "<xmlattr>")
{
// already parsed -- ignore it
}
else if (name == "Option")
{
Option option = parseElement_Option(subtree);
if (option.getName() == "filename")
filename = option.getValue();
options.add(option);
}
else if (name == "Metadata")
{
// ignored
}
else if (name == "Filter" || name == "Reader")
{
context.addStage();
prevStages.push_back(parseElement_anystage(name, subtree));
}
else
{
context.addUnknown(name);
}
}
std::string type;
if (attrs.count("type"))
{
type = attrs["type"];
context.addType();
}
context.validate();
Stage& writer = m_manager.makeWriter(filename, type);
for (auto sp : prevStages)
writer.setInput(*sp);
writer.removeOptions(options);
writer.addOptions(options);
return &writer;
}
Options getOCIOptions()
{
Options options;
options.add("overwrite", false);
options.add("connection", std::string(TestConfig::g_oracle_connection));
options.add("block_table_name", "PDAL_TEST_BLOCKS");
options.add("base_table_name", "PDAL_TEST_BASE");
options.add("cloud_column_name", "CLOUD");
options.add("srid", 26910);
options.add("disable_cloud_trigger", true);
options.add("filename", Support::datapath("autzen/autzen-utm.las"));
options.add("xml_schema_dump", "pcs-oracle-xml-schema-dump.xml");
return options;
}
