Exemplo n.º 1
0
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;
}
Exemplo n.º 2
0
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;
}
Exemplo n.º 4
0
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++]);
}
Exemplo n.º 5
0
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;
}
Exemplo n.º 6
0
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;
}
Exemplo n.º 7
0
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);
}
Exemplo n.º 8
0
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);
}
Exemplo n.º 9
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"));
}
Exemplo n.º 10
0
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;
}
Exemplo n.º 11
0
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);
    }
}
Exemplo n.º 12
0
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;
}
Exemplo n.º 13
0
Options defaultRxpReaderOptions()
{
    Options options;
    Option filename("filename", testDataPath() + "130501_232206_cut.rxp");
    options.add(filename);
    return options;
}
Exemplo n.º 14
0
const Options Crop::getDefaultOptions() const
{
    Options options;
    Option bounds("bounds",Bounds<double>(),"bounds to crop to");
    options.add(bounds);
    return options;
}
Exemplo n.º 15
0
Options FauxReader::getDefaultOptions()
{
    Options options;
    Option count("num_points", 10, "Number of points");
    options.add(count);
    return options;
}
Exemplo n.º 16
0
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);
}
Exemplo n.º 17
0
Options Splitter::getDefaultOptions()
{
    Options options;
    Option length("length", 1000, "Splitter length");
    options.add(length);

    return options;
}
Exemplo n.º 18
0
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;
}
Exemplo n.º 19
0
Options ColorizationFilter::getDefaultOptions()
{
    Options options;

    options.add("dimensions", "Red:1:1.0, Green:2:1.0, Blue:3");

    return options;
}
Exemplo n.º 20
0
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);
}
Exemplo n.º 21
0
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;
}
Exemplo n.º 22
0
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;
}
Exemplo n.º 23
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;
}
Exemplo n.º 24
0
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;
}
Exemplo n.º 25
0
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;
}
Exemplo n.º 26
0
TEST(TextReaderTest, t1a)
{
    Options textOptions;

    textOptions.add("separator", ',');

    compareTextLas(Support::datapath("text/utm17_1.txt"),
        textOptions, Support::datapath("las/utm17.las"));
}
Exemplo n.º 27
0
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);
}
Exemplo n.º 28
0
// 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"));
}
Exemplo n.º 29
0
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;
}
Exemplo n.º 30
0
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;
}