void PcInfo::dumpOnePoint(const Stage& stage) const
{
const Schema& schema = stage.getSchema();
PointBuffer data(schema, 1);
boost::scoped_ptr<StageSequentialIterator> iter(stage.createSequentialIterator(data));
iter->skip(m_pointNumber);
const boost::uint32_t numRead = iter->read(data);
if (numRead != 1)
{
std::ostringstream oss;
oss << "problem reading point number " << m_pointNumber;
throw app_runtime_error(oss.str());
}
boost::property_tree::ptree tree = data.toPTree();
std::ostream& ostr = m_outputStream ? *m_outputStream : std::cout;
boost::property_tree::ptree output;
output.add_child("point", tree.get_child("0"));
if (m_useXML)
write_xml(ostr, output);
else
write_json(ostr, tree.get_child("0"));
return;
}
void Stage::setCoreProperties(const Stage& stage)
{
this->setSchema(stage.getSchema());
this->setNumPoints(stage.getNumPoints());
this->setPointCountType(stage.getPointCountType());
this->setBounds(stage.getBounds());
this->setSpatialReference(stage.getSpatialReference());
return;
}
void PcInfo::dumpSDO_PCMetadata(const Stage& stage) const
{
boost::property_tree::ptree metadata = stage.serializePipeline();
const Schema& schema = stage.getSchema();
std::string xml = pdal::Schema::to_xml(schema, &metadata);
std::ostream& ostr = m_outputStream ? *m_outputStream : std::cout;
ostr << xml;
}
void PcInfo::dumpSchema(const Stage& stage) const
{
const Schema& schema = stage.getSchema();
boost::property_tree::ptree tree = schema.toPTree();
std::ostream& ostr = m_outputStream ? *m_outputStream : std::cout;
if (m_useXML)
write_xml(ostr, tree);
else
write_json(ostr, tree);
return;
}
int PcInfo::execute()
{
Options readerOptions;
{
if (m_usestdin)
m_inputFile = "STDIN";
readerOptions.add<std::string>("filename", m_inputFile);
readerOptions.add<bool>("debug", isDebug());
readerOptions.add<boost::uint32_t>("verbose", getVerboseLevel());
}
Stage* reader = AppSupport::makeReader(readerOptions);
if (m_seed != 0)
{
Option seed_option("seed", m_seed, "seed value");
m_options.add(seed_option);
}
Option sample_size("sample_size", m_sample_size, "sample size for random sample");
m_options.add(sample_size);
Option cls("exact_count", "Classification", "use exact counts for classification stats");
Option rn("exact_count", "ReturnNumber", "use exact counts for ReturnNumber stats");
Option nr("exact_count", "NumberOfReturns", "use exact counts for ReturnNumber stats");
m_options.add(cls);
m_options.add(rn);
m_options.add(nr);
if (m_Dimensions.size())
{
Option dimensions("dimensions", m_Dimensions, "Use explicit list of dimensions");
m_options.add(dimensions);
Option do_sample("do_sample", false, "Dont do sampling");
m_options.add(do_sample);
}
pdal::Options options = m_options + readerOptions;
pdal::filters::Stats* filter = new pdal::filters::Stats(*reader, options);
filter->initialize();
if (m_pointNumber != (std::numeric_limits<boost::uint64_t>::max)())
{
dumpOnePoint(*filter);
}
if (m_showStats)
{
dumpStats(*filter);
}
if (m_showSchema)
{
dumpSchema(*reader);
}
if (m_showMetadata)
{
dumpMetadata(*reader);
}
if (m_showStage)
{
dumpStage(*reader);
}
if (m_showSDOPCMetadata)
{
dumpSDO_PCMetadata(*reader);
}
if (m_QueryPoint.size())
{
IndexedPointBuffer buffer(reader->getSchema(), reader->getNumPoints());
dumpQuery(*reader, buffer);
}
std::ostream& ostr = m_outputStream ? *m_outputStream : std::cout;
ostr << std::endl;
delete filter;
delete reader;
if (m_outputStream)
{
FileUtils::closeFile(m_outputStream);
}
return 0;
}
int Delta::execute()
{
Options sourceOptions;
{
sourceOptions.add<std::string>("filename", m_sourceFile);
sourceOptions.add<bool>("debug", isDebug());
sourceOptions.add<boost::uint32_t>("verbose", getVerboseLevel());
}
Stage* source = AppSupport::makeReader(sourceOptions);
source->initialize();
boost::uint32_t totalPointCount(source->getNumPoints());
PointBuffer source_data(source->getSchema(), totalPointCount);
StageSequentialIterator* source_iter = source->createSequentialIterator(source_data);
boost::uint32_t numRead = source_iter->read(source_data);
assert(numRead == source_data.getNumPoints());
delete source_iter;
delete source;
Options candidateOptions;
{
candidateOptions.add<std::string>("filename", m_candidateFile);
candidateOptions.add<bool>("debug", isDebug());
candidateOptions.add<boost::uint32_t>("verbose", getVerboseLevel());
}
Stage* candidate = AppSupport::makeReader(candidateOptions);
candidate->initialize();
IndexedPointBuffer candidate_data(candidate->getSchema(), totalPointCount);
StageSequentialIterator* candidate_iter = candidate->createSequentialIterator(candidate_data);
numRead = candidate_iter->read(candidate_data);
assert(numRead == candidate_data.getNumPoints());
delete candidate_iter;
if (source_data.getNumPoints() != candidate_data.getNumPoints())
{
std::cerr << "Source and candidate files do not have the same point count, testing each source point only!" << std::endl;
}
// m_summary_x(xd);
// m_summary_y(yd);
// m_summary_z(zd);
if (m_outputFileName.size())
{
m_outputStream = FileUtils::createFile(m_outputFileName);
}
candidate_data.build(m_3d);
boost::uint32_t count(std::min(source_data.getNumPoints(), candidate_data.getNumPoints()));
boost::scoped_ptr<std::map<Point, Point> > points(cumulatePoints(source_data, candidate_data));
if (m_OutputDetail)
{
outputDetail(source_data, candidate_data, points.get());
return 0;
}
std::map<Point, Point>::const_iterator i;
for(i = points->begin(); i != points->end(); ++i)
{
Point const& s = i->first;
Point const& c = i->second;
double xd = s.x - c.x;
double yd = s.y - c.y;
double zd = s.z - c.z;
m_summary_x(xd);
m_summary_y(yd);
m_summary_z(zd);
}
std::string headline("------------------------------------------------------------------------------------------");
std::cout << headline << std::endl;
std::cout << " Delta summary for source '" << m_sourceFile << "' and candidate '" << m_candidateFile <<"'" << std::endl;
std::cout << headline << std::endl;
std::cout << std::endl;
std::string thead("----------- --------------- --------------- --------------");
std::cout << thead << std::endl;
std::cout << " Dimension X Y Z " << std::endl;
std::cout << thead << std::endl;
boost::format fmt("%.4f");
double sminx = (boost::accumulators::min)(m_summary_x);
double sminy = (boost::accumulators::min)(m_summary_y);
double sminz = (boost::accumulators::min)(m_summary_z);
double smaxx = (boost::accumulators::max)(m_summary_x);
double smaxy = (boost::accumulators::max)(m_summary_y);
double smaxz = (boost::accumulators::max)(m_summary_z);
double smeanx = (boost::accumulators::mean)(m_summary_x);
double smeany = (boost::accumulators::mean)(m_summary_y);
double smeanz = (boost::accumulators::mean)(m_summary_z);
std::cout << " Min " << fmt % sminx << " " << fmt % sminy << " " << fmt % sminz<<std::endl;
std::cout << " Min " << fmt % smaxx << " " << fmt % smaxy << " " << fmt % smaxz<<std::endl;
std::cout << " Mean " << fmt % smeanx << " " << fmt % smeany << " " << fmt % smeanz<<std::endl;
std::cout << thead << std::endl;
return 0;
}
int PcQuery::execute()
{
Options readerOptions;
{
readerOptions.add<std::string>("filename", m_inputFile);
readerOptions.add<bool>("debug", isDebug());
readerOptions.add<boost::uint32_t>("verbose", getVerboseLevel());
}
Stage* reader = AppSupport::makeReader(readerOptions);
pdal::Options options = m_options + readerOptions;
options.add<boost::uint32_t>("dimensions", 2);
pdal::filters::Index* filter = new pdal::filters::Index(*reader, options);
filter->initialize();
boost::uint32_t chunkSize(pdal::Writer::s_defaultChunkSize);
if (filter->getNumPoints() > 0 && m_chunkSize == 0)
{
chunkSize = filter->getNumPoints();
}
else if (m_chunkSize > 0)
{
chunkSize = m_chunkSize;
}
PointBuffer data(filter->getSchema(), chunkSize);
StageSequentialIterator* iter = filter->createSequentialIterator(data);
readPoints(iter, data);
pdal::filters::iterators::sequential::Index* idx = dynamic_cast<pdal::filters::iterators::sequential::Index*>(iter);
if (!idx)
{
throw app_runtime_error("unable to cast iterator to Index iterator!");
}
idx->build();
if (m_point.size())
{
boost::char_separator<char> sep(SEPARATORS);
tokenizer tokens(m_point, sep);
std::vector<double> values;
for (tokenizer::iterator t = tokens.begin(); t != tokens.end(); ++t) {
values.push_back(boost::lexical_cast<double>(*t));
}
if (values.size() < 2)
throw app_runtime_error("--points must be two or three values");
double x = values[0];
double y = values[1];
double z(0.0);
if (values.size() > 2)
z = values[2];
std::vector<boost::uint32_t> ids = idx->query(x, y, z, 0.0, 1);
if (ids.size())
{
PointBuffer data(reader->getSchema(), 1);
StageRandomIterator* iterator = reader->createRandomIterator(data);
iterator->seek(ids[0]);
Schema const& schema = data.getSchema();
Dimension const& dimX = schema.getDimension("X");
Dimension const& dimY = schema.getDimension("Y");
Dimension const& dimZ = schema.getDimension("Z");
iterator->read(data);
boost::int32_t xi = data.getField<boost::int32_t>(dimX, 0);
boost::int32_t yi = data.getField<boost::int32_t>(dimY, 0);
boost::int32_t zi = data.getField<boost::int32_t>(dimZ, 0);
double x = dimX.applyScaling<boost::int32_t>(xi);
double y = dimY.applyScaling<boost::int32_t>(yi);
double z = dimZ.applyScaling<boost::int32_t>(zi);
std::cout.precision(8);
std::cout << x << "," << y << "," << z << std::endl;
}
else
{
throw app_runtime_error("Candidate point not found!");
}
}
std::cout << std::endl;
delete filter;
delete reader;
return 0;
}