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