TEST(IcebridgeReaderTest, testRead)
{
StageFactory f;
ReaderPtr reader(f.createReader("readers.icebridge"));
EXPECT_TRUE(reader.get());
Option filename("filename", getFilePath(), "");
Options options(filename);
reader->setOptions(options);
PointContext ctx;
reader->prepare(ctx);
PointBufferSet pbSet = reader->execute(ctx);
EXPECT_EQ(pbSet.size(), 1u);
PointBufferPtr buf = *pbSet.begin();
EXPECT_EQ(buf->size(), 2u);
checkPoint(
*buf,
0,
141437548, // time
82.605319, // latitude
301.406196, // longitude
18.678, // elevation
2408, // xmtSig
181, // rcvSig
49.91, // azimuth
-4.376, // pitch
0.608, // roll
2.9, // gpsPdop
20.0, // pulseWidth
0.0); // relTime
checkPoint(
*buf,
1,
141437548, // time
82.605287, // latitude
301.404862, // longitude
18.688, // elevation
2642, // xmtSig
173, // rcvSig
52.006, // azimuth
-4.376, // pitch
0.609, // roll
2.9, // gpsPdop
17.0, // pulseWidth
0.0); // relTime
}
TEST(SortFilterTest, pipeline)
{
PipelineManager mgr;
PipelineReader reader(mgr);
reader.readPipeline(Support::configuredpath("filters/sort.xml"));
mgr.execute();
PointBufferSet pbSet = mgr.buffers();
EXPECT_EQ(pbSet.size(), 1u);
PointBufferPtr buf = *pbSet.begin();
for (PointId i = 1; i < buf->size(); ++i)
{
double d1 = buf->getFieldAs<double>(Dimension::Id::X, i - 1);
double d2 = buf->getFieldAs<double>(Dimension::Id::X, i);
EXPECT_TRUE(d1 <= d2);
}
}
TEST(LasReaderTest, test_sequential)
{
PointContext ctx;
Options ops1;
ops1.add("filename", Support::datapath("las/1.2-with-color.las"));
ops1.add("count", 103);
LasReader reader;
reader.setOptions(ops1);
reader.prepare(ctx);
PointBufferSet pbSet = reader.execute(ctx);
EXPECT_EQ(pbSet.size(), 1u);
PointBufferPtr buf = *pbSet.begin();
Support::check_p0_p1_p2(*buf);
PointBufferPtr buf2 = buf->makeNew();
buf2->appendPoint(*buf, 100);
buf2->appendPoint(*buf, 101);
buf2->appendPoint(*buf, 102);
Support::check_p100_p101_p102(*buf2);
}
static void test_a_format(const std::string& file, boost::uint8_t majorVersion, boost::uint8_t minorVersion, int pointFormat,
double xref, double yref, double zref, double tref, boost::uint16_t rref, boost::uint16_t gref, boost::uint16_t bref)
{
PointContext ctx;
Options ops1;
ops1.add("filename", Support::datapath(file));
ops1.add("count", 1);
pdal::drivers::las::Reader reader;
reader.setOptions(ops1);
reader.prepare(ctx);
BOOST_CHECK_EQUAL(reader.header().pointFormat(), pointFormat);
BOOST_CHECK_EQUAL(reader.header().versionMajor(), majorVersion);
BOOST_CHECK_EQUAL(reader.header().versionMinor(), minorVersion);
PointBufferSet pbSet = reader.execute(ctx);
BOOST_CHECK_EQUAL(pbSet.size(), 1);
PointBufferPtr buf = *pbSet.begin();
BOOST_CHECK_EQUAL(buf->size(), 1);
Support::check_pN(*buf, 0, xref, yref, zref, tref, rref, gref, bref);
}
TEST(NitfReaderTest, test_one)
{
StageFactory f;
Options nitf_opts;
nitf_opts.add("filename", Support::datapath("nitf/autzen-utm10.ntf"));
nitf_opts.add("count", 750);
PointContext ctx;
ReaderPtr nitf_reader(f.createReader("readers.nitf"));
EXPECT_TRUE(nitf_reader.get());
nitf_reader->setOptions(nitf_opts);
nitf_reader->prepare(ctx);
PointBufferSet pbSet = nitf_reader->execute(ctx);
EXPECT_EQ(nitf_reader->getDescription(), "NITF Reader");
EXPECT_EQ(pbSet.size(), 1u);
PointBufferPtr buf = *pbSet.begin();
// check metadata
//ABELL
/**
{
Metadata metadata = nitf_reader.getMetadata();
/////////////////////////////////////////////////EXPECT_EQ(metadatums.size(), 80u);
EXPECT_EQ(metadata.toPTree().get<std::string>("metadata.FH_FDT.value"), "20120323002946");
}
**/
//
// read LAS
//
Options las_opts;
las_opts.add("count", 750);
las_opts.add("filename", Support::datapath("nitf/autzen-utm10.las"));
PointContext ctx2;
ReaderPtr las_reader(f.createReader("readers.las"));
EXPECT_TRUE(las_reader.get());
las_reader->setOptions(las_opts);
las_reader->prepare(ctx2);
PointBufferSet pbSet2 = las_reader->execute(ctx2);
EXPECT_EQ(pbSet2.size(), 1u);
PointBufferPtr buf2 = *pbSet.begin();
//
//
// compare the two buffers
//
EXPECT_EQ(buf->size(), buf2->size());
for (PointId i = 0; i < buf2->size(); i++)
{
int32_t nitf_x = buf->getFieldAs<int32_t>(Dimension::Id::X, i);
int32_t nitf_y = buf->getFieldAs<int32_t>(Dimension::Id::Y, i);
int32_t nitf_z = buf->getFieldAs<int32_t>(Dimension::Id::Z, i);
int32_t las_x = buf2->getFieldAs<int32_t>(Dimension::Id::X, i);
int32_t las_y = buf2->getFieldAs<int32_t>(Dimension::Id::Y, i);
int32_t las_z = buf2->getFieldAs<int32_t>(Dimension::Id::Z, i);
EXPECT_EQ(nitf_x, las_x);
EXPECT_EQ(nitf_y, las_y);
EXPECT_EQ(nitf_z, las_z);
}
}
TEST(ColorizationFilterTest, ColorizationFilterTest_test_1)
{
Options ops1;
ops1.add("filename", Support::datapath("autzen/autzen-point-format-3.las"));
LasReader reader;
reader.setOptions(ops1);
Options options;
Option red("dimension", "Red", "");
Option b0("band",1, "");
Option s0("scale", 1.0f, "scale factor for this dimension");
Options redO;
redO.add(b0);
redO.add(s0);
red.setOptions(redO);
Option green("dimension", "Green", "");
Option b1("band",2, "");
Option s1("scale", 1.0f, "scale factor for this dimension");
Options greenO;
greenO.add(b1);
greenO.add(s1);
green.setOptions(greenO);
Option blue("dimension", "Blue", "");
Option b2("band",3, "");
Option s2("scale", 255.0f, "scale factor for this dimension");
Options blueO;
blueO.add(b2);
blueO.add(s2);
blue.setOptions(blueO);
Option datasource("raster", Support::datapath("autzen/autzen.jpg"),
"raster to read");
Options reader_options;
reader_options.add(red);
reader_options.add(green);
reader_options.add(blue);
reader_options.add(datasource);
ColorizationFilter filter;
filter.setOptions(reader_options);
filter.setInput(&reader);
PointContext ctx;
filter.prepare(ctx);
PointBufferSet pbSet = filter.execute(ctx);
EXPECT_EQ(pbSet.size(), 1u);
PointBufferPtr buf = *pbSet.begin();
uint16_t r = buf->getFieldAs<uint16_t>(Dimension::Id::Red, 0);
uint16_t g = buf->getFieldAs<uint16_t>(Dimension::Id::Green, 0);
uint16_t b = buf->getFieldAs<uint16_t>(Dimension::Id::Blue, 0);
EXPECT_EQ(r, 210u);
EXPECT_EQ(g, 205u);
// We scaled this up to 16bit by multiplying by 255
EXPECT_EQ(b, 47175u);
}
int Diff::execute()
{
PointContext sourceCtx;
Options sourceOptions;
{
sourceOptions.add<std::string>("filename", m_sourceFile);
sourceOptions.add<bool>("debug", isDebug());
sourceOptions.add<boost::uint32_t>("verbose", getVerboseLevel());
}
std::unique_ptr<Stage> source(AppSupport::makeReader(m_sourceFile));
source->setOptions(sourceOptions);
source->prepare(sourceCtx);
PointBufferSet sourceSet = source->execute(sourceCtx);
ptree errors;
PointContext candidateCtx;
Options candidateOptions;
{
candidateOptions.add<std::string>("filename", m_candidateFile);
candidateOptions.add<bool>("debug", isDebug());
candidateOptions.add<boost::uint32_t>("verbose", getVerboseLevel());
}
std::unique_ptr<Stage> candidate(AppSupport::makeReader(m_candidateFile));
candidate->setOptions(candidateOptions);
candidate->prepare(candidateCtx);
PointBufferSet candidateSet = candidate->execute(candidateCtx);
assert(sourceSet.size() == 1);
assert(candidateSet.size() == 1);
PointBufferPtr sourceBuf = *sourceSet.begin();
PointBufferPtr candidateBuf = *candidateSet.begin();
if (candidateBuf->size() != sourceBuf->size())
{
std::ostringstream oss;
oss << "Source and candidate files do not have the same point count";
errors.put("count.error", oss.str());
errors.put("count.candidate", candidateBuf->size());
errors.put("count.source", sourceBuf->size());
}
MetadataNode source_metadata = sourceCtx.metadata();
MetadataNode candidate_metadata = candidateCtx.metadata();
if (source_metadata != candidate_metadata)
{
std::ostringstream oss;
oss << "Source and candidate files do not have the same metadata count";
errors.put("metadata.error", oss.str());
errors.put_child("metadata.source", pdal::utils::toPTree(source_metadata));
errors.put_child("metadata.candidate", pdal::utils::toPTree(candidate_metadata));
}
if (candidateCtx.dims().size() != sourceCtx.dims().size())
{
std::ostringstream oss;
oss << "Source and candidate files do not have the same "
"number of dimensions";
errors.put<std::string>("schema.error", oss.str());
//Need to "ptree" the PointContext dimension list in some way
// errors.put_child("schema.source", sourceCtx.schema()->toPTree());
// errors.put_child("schema.candidate",
// candidateCtx.schema()->toPTree());
}
if (errors.size())
{
write_json(std::cout, errors);
return 1;
}
else
{
// If we made it this far with no errors, now we'll
// check the points.
checkPoints(*sourceBuf, *candidateBuf, errors);
if (errors.size())
{
write_json(std::cout, errors);
return 1;
}
}
return 0;
}