TEST(NitfReaderTest, optionSrs)
{
StageFactory f;
Options nitfOpts;
nitfOpts.add("filename", Support::datapath("nitf/autzen-utm10.ntf"));
std::string sr = "PROJCS[\"NAD83 / UTM zone 11N\",GEOGCS[\"NAD83\",DATUM[\"North_American_Datum_1983\",SPHEROID[\"GRS 1980\",6378137,298.257222101,AUTHORITY[\"EPSG\",\"7019\"]],TOWGS84[0,0,0,0,0,0,0],AUTHORITY[\"EPSG\",\"6269\"]],PRIMEM[\"Greenwich\",0,AUTHORITY[\"EPSG\",\"8901\"]],UNIT[\"degree\",0.0174532925199433,AUTHORITY[\"EPSG\",\"9122\"]],AUTHORITY[\"EPSG\",\"4269\"]],PROJECTION[\"Transverse_Mercator\"],PARAMETER[\"latitude_of_origin\",0],PARAMETER[\"central_meridian\",-123],PARAMETER[\"scale_factor\",0.9996],PARAMETER[\"false_easting\",500000],PARAMETER[\"false_northing\",0],UNIT[\"metre\",1,AUTHORITY[\"EPSG\",\"9001\"]],AXIS[\"Easting\",EAST],AXIS[\"Northing\",NORTH],AUTHORITY[\"EPSG\",\"26910\"]]";
nitfOpts.add("spatialreference", sr);
PointContext ctx;
ReaderPtr nitfReader(f.createReader("readers.nitf"));
EXPECT_TRUE(nitfReader.get());
nitfReader->setOptions(nitfOpts);
Options lasOpts;
lasOpts.add("filename", "/dev/null");
WriterPtr lasWriter(f.createWriter("writers.las"));
EXPECT_TRUE(lasWriter.get());
lasWriter->setInput(nitfReader.get());
lasWriter->setOptions(lasOpts);;
lasWriter->prepare(ctx);
PointBufferSet pbSet = lasWriter->execute(ctx);
EXPECT_EQ(sr, nitfReader->getSpatialReference().getWKT());
EXPECT_EQ("", lasWriter->getSpatialReference().getWKT());
EXPECT_EQ(sr, ctx.spatialRef().getWKT());
}
void AttributeFilter::ready(PointContext ctx)
{
m_gdal_debug = std::shared_ptr<pdal::gdal::Debug>(
new pdal::gdal::Debug(isDebug(), log()));
for (auto& dim_par : m_dimensions)
{
Dimension::Id::Enum t = ctx.findDim(dim_par.first);
dim_par.second.dim = t;
if (dim_par.second.isogr)
{
OGRDSPtr ds = OGRDSPtr(OGROpen(dim_par.second.datasource.c_str(), 0, 0), OGRDataSourceDeleter());
if (!ds)
{
std::ostringstream oss;
oss << "Unable to open data source '" << dim_par.second.datasource <<"'";
throw pdal_error(oss.str());
}
dim_par.second.ds = ds;
}
}
}
void BufferedInvocation::begin(PointBuffer& buffer)
{
PointContext ctx = buffer.m_context;
Dimension::IdList const& dims = ctx.dims();
for (auto di = dims.begin(); di != dims.end(); ++di)
{
Dimension::Id::Enum d = *di;
Dimension::Detail *dd = ctx.dimDetail(d);
void *data = malloc(dd->size() * buffer.size());
m_buffers.push_back(data); // Hold pointer for deallocation
char *p = (char *)data;
for (PointId idx = 0; idx < buffer.size(); ++idx)
{
buffer.getFieldInternal(d, idx, (void *)p);
p += dd->size();
}
std::string name = ctx.dimName(*di);
insertArgument(name, (uint8_t *)data, dd->type(), buffer.size());
}
}
void BufferedInvocation::end(PointBuffer& buffer)
{
// for each entry in the script's outs dictionary,
// look up that entry's name in the schema and then
// copy the data into the right dimension spot in the
// buffer
std::vector<std::string> names;
getOutputNames(names);
PointContext ctx = buffer.m_context;
Dimension::IdList const& dims = ctx.dims();
for (auto di = dims.begin(); di != dims.end(); ++di)
{
Dimension::Id::Enum d = *di;
Dimension::Detail *dd = ctx.dimDetail(d);
std::string name = ctx.dimName(*di);
auto found = std::find(names.begin(), names.end(), name);
if (found == names.end()) continue; // didn't have this dim in the names
assert(name == *found);
assert(hasOutputVariable(name));
size_t size = dd->size();
void *data = extractResult(name, dd->type());
char *p = (char *)data;
for (PointId idx = 0; idx < buffer.size(); ++idx)
{
buffer.setField(d, dd->type(), idx, (void *)p);
p += size;
}
}
for (auto bi = m_buffers.begin(); bi != m_buffers.end(); ++bi)
free(*bi);
m_buffers.clear();
}
virtual void ready(PointContext ctx)
{ m_dim = ctx.findDim(m_dimName); }
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;
}