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