point_count_t RialtoReader::read(PointViewPtr view, point_count_t /*not used*/) { // TODO: okay to ignore point count parameter? log()->get(LogLevel::Debug) << "RialtoReader::read()" << std::endl; const TileMath tmm(m_matrixSet->getTmsetMinX(), m_matrixSet->getTmsetMinY(), m_matrixSet->getTmsetMaxX(), m_matrixSet->getTmsetMaxY(), m_matrixSet->getNumColsAtL0(), m_matrixSet->getNumRowsAtL0()); setQueryParams(); const double qMinX = m_queryBox.minx; const double qMinY = m_queryBox.miny; const double qMaxX = m_queryBox.maxx; const double qMaxY = m_queryBox.maxy; const uint32_t level = m_queryLevel; m_gpkg->queryForTiles_begin(m_dataset, qMinX, qMinY, qMaxX, qMaxY, level); GpkgTile info; do { bool ok = m_gpkg->queryForTiles_step(info); if (!ok) break; doQuery(tmm, info, view, qMinX, qMinY, qMaxX, qMaxY); log()->get(LogLevel::Debug) << " resulting view now has " << view->size() << " points" << std::endl; } while (m_gpkg->queryForTiles_next()); return view->size(); }
PointViewPtr IcpFilter::icp(PointViewPtr fixed, PointViewPtr moving) const { typedef pcl::PointXYZ Point; typedef pcl::PointCloud<Point> Cloud; Cloud::Ptr fixedCloud(new Cloud()); pclsupport::PDALtoPCD(fixed, *fixedCloud); Cloud::Ptr movingCloud(new Cloud()); pclsupport::PDALtoPCD(moving, *movingCloud); pcl::IterativeClosestPoint<Point, Point> icp; icp.setInputSource(movingCloud); icp.setInputTarget(fixedCloud); Cloud result; icp.align(result); MetadataNode root = getMetadata(); // I couldn't figure out the template-fu to get // `MetadataNodeImpl::setValue` to work for all Eigen matrices with one // function, so I'm just brute-forcing the cast for now. root.add("transform", Eigen::MatrixXd(icp.getFinalTransformation().cast<double>())); root.add("converged", icp.hasConverged()); root.add("fitness", icp.getFitnessScore()); assert(moving->size() == result.points.size()); for (PointId i = 0; i < moving->size(); ++i) { moving->setField(Dimension::Id::X, i, result.points[i].x); moving->setField(Dimension::Id::Y, i, result.points[i].y); moving->setField(Dimension::Id::Z, i, result.points[i].z); } return moving; }
void LasWriter::writeView(const PointViewPtr view) { Utils::writeProgress(m_progressFd, "READYVIEW", std::to_string(view->size())); m_scaling.setAutoXForm(view); point_count_t pointLen = m_lasHeader.pointLen(); // Make a buffer of at most a meg. m_pointBuf.resize(std::min((point_count_t)1000000, pointLen * view->size())); const PointView& viewRef(*view.get()); point_count_t remaining = view->size(); PointId idx = 0; while (remaining) { point_count_t filled = fillWriteBuf(viewRef, idx, m_pointBuf); idx += filled; remaining -= filled; if (m_compression == LasCompression::LasZip) writeLasZipBuf(m_pointBuf.data(), pointLen, filled); else if (m_compression == LasCompression::LazPerf) writeLazPerfBuf(m_pointBuf.data(), pointLen, filled); else m_ostream->write(m_pointBuf.data(), filled * pointLen); } Utils::writeProgress(m_progressFd, "DONEVIEW", std::to_string(view->size())); }
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; }
// 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()); }
int DiffKernel::execute() { PointTable sourceTable; Stage& source = makeReader(m_sourceFile, m_driverOverride); source.prepare(sourceTable); PointViewSet sourceSet = source.execute(sourceTable); MetadataNode errors; PointTable candidateTable; Stage& candidate = makeReader(m_candidateFile, m_driverOverride); candidate.prepare(candidateTable); PointViewSet candidateSet = candidate.execute(candidateTable); assert(sourceSet.size() == 1); assert(candidateSet.size() == 1); PointViewPtr sourceView = *sourceSet.begin(); PointViewPtr candidateView = *candidateSet.begin(); if (candidateView->size() != sourceView->size()) { std::ostringstream oss; oss << "Source and candidate files do not have the same point count"; errors.add("count.error", oss.str()); errors.add("count.candidate", candidateView->size()); errors.add("count.source", sourceView->size()); } MetadataNode source_metadata = sourceTable.metadata(); MetadataNode candidate_metadata = candidateTable.metadata(); if (source_metadata != candidate_metadata) { std::ostringstream oss; oss << "Source and candidate files do not have the same metadata count"; errors.add("metadata.error", oss.str()); errors.add(source_metadata); errors.add(candidate_metadata); } if (candidateTable.layout()->dims().size() != sourceTable.layout()->dims().size()) { std::ostringstream oss; oss << "Source and candidate files do not have the same " "number of dimensions"; } return 0; }
std::vector<char> getBytes(PointViewPtr view) { std::vector<char> bytes(view->pointSize() * view->size()); DimTypeList dimTypes = view->dimTypes(); char *p = bytes.data(); for (PointId idx = 0; idx < view->size(); ++idx) { view->getPackedPoint(dimTypes, idx, p); p += view->pointSize(); } return bytes; }
PointViewSet run(PointViewPtr view) { if (m_count > view->size()) log()->get(LogLevel::Warning) << "Requested number of points (count=" << m_count << ") exceeds number of available points.\n"; PointViewSet viewSet; PointViewPtr outView = view->makeNew(); for (PointId i = view->size() - std::min(m_count, view->size()); i < view->size(); ++i) outView->appendPoint(*view, i); viewSet.insert(outView); return viewSet; }
// Compare the source LAS file with the extracted OCI data. // Candidate is the OCI reader's view. void compare(const PointViewPtr candidate, std::string filename) { Options options; Option fn("filename", filename); options.add(fn); PointTable table; LasReader reader; reader.setOptions(options); reader.prepare(table); PointViewSet viewSet = reader.execute(table); EXPECT_EQ(viewSet.size(), 1u); PointViewPtr source = *viewSet.begin(); EXPECT_EQ(source->size(), candidate->size()); PointId limit = std::min(source->size(), candidate->size()); for (PointId i = 0; i < limit; ++i) { using namespace Dimension; int32_t sx = source->getFieldAs<int32_t>(Id::X, i); int32_t sy = source->getFieldAs<int32_t>(Id::Y, i); int32_t sz = source->getFieldAs<int32_t>(Id::Z, i); uint16_t sintensity = source->getFieldAs<uint16_t>(Id::Intensity, i); uint16_t sred = source->getFieldAs<uint16_t>(Id::Red, i); uint16_t sgreen = source->getFieldAs<uint16_t>(Id::Green, i); uint16_t sblue = source->getFieldAs<uint16_t>(Id::Blue, i); int32_t cx = candidate->getFieldAs<int32_t>(Id::X, i); int32_t cy = candidate->getFieldAs<int32_t>(Id::Y, i); int32_t cz = candidate->getFieldAs<int32_t>(Id::Z, i); uint16_t cintensity = candidate->getFieldAs<uint16_t>(Id::Intensity, i); uint16_t cred = candidate->getFieldAs<uint16_t>(Id::Red, i); uint16_t cgreen = candidate->getFieldAs<uint16_t>(Id::Green, i); uint16_t cblue = candidate->getFieldAs<uint16_t>(Id::Blue, i); EXPECT_EQ(sx, cx); EXPECT_EQ(sy, cy); EXPECT_EQ(sz, cz); EXPECT_EQ(sintensity, cintensity); EXPECT_EQ(sred, cred); EXPECT_EQ(sgreen, cgreen); EXPECT_EQ(sblue, cblue); } }
void LasWriter::write(const PointViewPtr view) { setAutoOffset(view); size_t pointLen = m_lasHeader.pointLen(); // Make a buffer of at most a meg. std::vector<char> buf(std::min((size_t)1000000, pointLen * view->size())); const PointView& viewRef(*view.get()); //ABELL - Removed callback handling for now. point_count_t remaining = view->size(); PointId idx = 0; while (remaining) { point_count_t filled = fillWriteBuf(viewRef, idx, buf); idx += filled; remaining -= filled; #ifdef PDAL_HAVE_LASZIP if (m_lasHeader.compressed()) { char *pos = buf.data(); for (point_count_t i = 0; i < filled; i++) { memcpy(m_zipPoint->m_lz_point_data.data(), pos, pointLen); if (!m_zipper->write(m_zipPoint->m_lz_point)) { std::ostringstream oss; const char* err = m_zipper->get_error(); if (err == NULL) err = "(unknown error)"; oss << "Error writing point: " << std::string(err); throw pdal_error(oss.str()); } pos += pointLen; } } else m_ostream->write(buf.data(), filled * pointLen); #else m_ostream->write(buf.data(), filled * pointLen); #endif } m_numPointsWritten = view->size() - remaining; }
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)); }
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); }
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(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(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"; **/ }
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); }
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")); }
void TextWriter::writeGeoJSONBuffer(const PointViewPtr view) { using namespace Dimension; for (PointId idx = 0; idx < view->size(); ++idx) { if (idx) *m_stream << ","; *m_stream << "{ \"type\":\"Feature\",\"geometry\": " "{ \"type\": \"Point\", \"coordinates\": ["; *m_stream << view->getFieldAs<double>(Id::X, idx) << ","; *m_stream << view->getFieldAs<double>(Id::Y, idx) << ","; *m_stream << view->getFieldAs<double>(Id::Z, idx) << "]},"; *m_stream << "\"properties\": {"; for (auto di = m_dims.begin(); di != m_dims.end(); ++di) { if (di != m_dims.begin()) *m_stream << ","; *m_stream << "\"" << view->dimName(*di) << "\":"; *m_stream << "\""; *m_stream << view->getFieldAs<double>(*di, idx); *m_stream <<"\""; } *m_stream << "}"; // end properties *m_stream << "}"; // end feature } }
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); }
MetadataNode DeltaKernel::dumpDetail(PointViewPtr& srcView, PointViewPtr& candView, KD3Index& index, DimIndexMap& dims) { MetadataNode root; for (PointId id = 0; id < srcView->size(); ++id) { double x = srcView->getFieldAs<double>(Dimension::Id::X, id); double y = srcView->getFieldAs<double>(Dimension::Id::Y, id); double z = srcView->getFieldAs<double>(Dimension::Id::Z, id); PointId candId = index.neighbor(x, y, z); MetadataNode delta = root.add("delta"); delta.add("i", id); for (auto di = dims.begin(); di != dims.end(); ++di) { DimIndex& d = di->second; double sv = srcView->getFieldAs<double>(d.m_srcId, id); double cv = candView->getFieldAs<double>(d.m_candId, candId); delta.add(d.m_name, sv - cv); } } return root; }
// 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(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, 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(PointViewTest, copy) { PointTable table; PointViewPtr view = makeTestView(table); PointView d2(*view); // read the view back out { EXPECT_EQ( d2.getFieldAs<uint8_t>(Dimension::Id::Classification, 0), view->getFieldAs<uint8_t>(Dimension::Id::Classification, 0)); EXPECT_EQ(d2.getFieldAs<int32_t>(Dimension::Id::X, 0), view->getFieldAs<int32_t>(Dimension::Id::X, 0)); EXPECT_FLOAT_EQ(d2.getFieldAs<double>(Dimension::Id::Y, 0), view->getFieldAs<double>(Dimension::Id::Y, 0)); } for (int i = 1; i < 17; i++) { uint8_t x = d2.getFieldAs<uint8_t>(Dimension::Id::Classification, i); int32_t y = d2.getFieldAs<int32_t>(Dimension::Id::X, i); double z = d2.getFieldAs<double>(Dimension::Id::Y, i); EXPECT_EQ(x, i + 1u); EXPECT_EQ(y, i * 10); EXPECT_TRUE(Utils::compare_approx(z, i * 100.0, (std::numeric_limits<double>::min)())); } EXPECT_EQ(view->size(), d2.size()); }
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); }
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; }
point_count_t BpfReader::readPointMajor(PointViewPtr view, point_count_t count) { PointId nextId = view->size(); PointId idx = m_index; point_count_t numRead = 0; seekPointMajor(idx); while (numRead < count && idx < numPoints()) { for (size_t d = 0; d < m_dims.size(); ++d) { float f; m_stream >> f; view->setField(m_dims[d].m_id, nextId, f + m_dims[d].m_offset); } // Transformation only applies to X, Y and Z double x = view->getFieldAs<double>(Dimension::Id::X, nextId); double y = view->getFieldAs<double>(Dimension::Id::Y, nextId); double z = view->getFieldAs<double>(Dimension::Id::Z, nextId); m_header.m_xform.apply(x, y, z); view->setField(Dimension::Id::X, nextId, x); view->setField(Dimension::Id::Y, nextId, y); view->setField(Dimension::Id::Z, nextId, z); if (m_cb) m_cb(*view, nextId); idx++; numRead++; nextId++; } m_index = idx; return numRead; }
// The P2G writer will only work with a single point view at the current time. // Merge point views before writing. void P2gWriter::write(const PointViewPtr view) { view->calculateBounds(m_bounds); m_GRID_SIZE_X = (int)(ceil((m_bounds.maxx - m_bounds.minx) / m_GRID_DIST_X)) + 1; m_GRID_SIZE_Y = (int)(ceil((m_bounds.maxy - m_bounds.miny) / m_GRID_DIST_Y)) + 1; log()->floatPrecision(6); log()->get(LogLevel::Debug) << "X grid distance: " << m_GRID_DIST_X << std::endl; log()->get(LogLevel::Debug) << "Y grid distance: " << m_GRID_DIST_Y << std::endl; log()->clearFloat(); m_interpolator.reset(new InCoreInterp(m_GRID_DIST_X, m_GRID_DIST_Y, m_GRID_SIZE_X, m_GRID_SIZE_Y, m_RADIUS * m_RADIUS, m_bounds.minx, m_bounds.maxx, m_bounds.miny, m_bounds.maxy, m_fill_window_size)); m_interpolator->init(); for (point_count_t idx = 0; idx < view->size(); idx++) { double x = view->getFieldAs<double>(Dimension::Id::X, idx) - m_bounds.minx; double y = view->getFieldAs<double>(Dimension::Id::Y, idx) - m_bounds.miny; double z = view->getFieldAs<double>(Dimension::Id::Z, idx); if (m_interpolator->update(x, y, z) < 0) { std::ostringstream oss; oss << getName() << ": interp->update() error while processing"; throw pdal_error(oss.str()); } } }
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)); }
cpd::Matrix CpdKernel::readFile(const std::string& filename) { Stage& reader = makeReader(filename, ""); PointTable table; PointViewSet viewSet; if (!m_bounds.empty()) { Options boundsOptions; boundsOptions.add("bounds", m_bounds); Stage& crop = makeFilter("filters.crop", reader); crop.setOptions(boundsOptions); crop.prepare(table); viewSet = crop.execute(table); } else { reader.prepare(table); viewSet = reader.execute(table); } cpd::Matrix matrix(0, 3); for (auto it = viewSet.begin(); it != viewSet.end(); ++it) { PointViewPtr view = *it; point_count_t rowidx; if (matrix.rows() == 0) { rowidx = 0; matrix.resize(view->size(), 3); } else { rowidx = matrix.rows(); matrix.conservativeResize(matrix.rows() + view->size(), 3); } for (point_count_t bufidx = 0; bufidx < view->size(); ++bufidx, ++rowidx) { matrix(rowidx, 0) = view->getFieldAs<double>(Dimension::Id::X, bufidx); matrix(rowidx, 1) = view->getFieldAs<double>(Dimension::Id::Y, bufidx); matrix(rowidx, 2) = view->getFieldAs<double>(Dimension::Id::Z, bufidx); } } return matrix; }