void LasWriter::prepared(PointTableRef table)
{
FlexWriter::validateFilename(table);
PointLayoutPtr layout = table.layout();
// If we've asked for all dimensions, add to extraDims all dimensions
// in the layout that aren't already destined for LAS output.
if (m_extraDims.size() == 1 && m_extraDims[0].m_name == "all")
{
m_extraDims.clear();
Dimension::IdList ids = m_lasHeader.usedDims();
DimTypeList dimTypes = layout->dimTypes();
for (auto& dt : dimTypes)
{
if (!Utils::contains(ids, dt.m_id))
m_extraDims.push_back(
ExtraDim(layout->dimName(dt.m_id), dt.m_type));
}
}
m_extraByteLen = 0;
for (auto& dim : m_extraDims)
{
dim.m_dimType.m_id = table.layout()->findDim(dim.m_name);
if (dim.m_dimType.m_id == Dimension::Id::Unknown)
{
std::ostringstream oss;
oss << "Dimension '" << dim.m_name << "' specified in "
"'extra_dim' option not found.";
throw pdal_error(oss.str());
}
m_extraByteLen += Dimension::size(dim.m_dimType.m_type);
}
}
void LasWriter::readyTable(PointTableRef table)
{
m_firstPoint = true;
m_forwardMetadata = table.privateMetadata("lasforward");
if(m_writePDALMetadata)
{
MetadataNode m = table.metadata();
addMetadataVlr(m);
addPipelineVlr();
}
addExtraBytesVlr();
addUserVlrs();
addForwardVlrs();
}
void LocateFilter::prepared(PointTableRef table)
{
PointLayoutPtr layout(table.layout());
m_dimId = layout->findDim(m_dimName);
if (m_dimId == Dimension::Id::Unknown)
throwError("Invalid dimension '" + m_dimName + "'.");
}
void ColorizationFilter::ready(PointTableRef table)
{
m_forward_transform.assign(0.0);
m_inverse_transform.assign(0.0);
log()->get(LogLevel::Debug) << "Using " << m_rasterFilename <<
" for raster" << std::endl;
m_ds = GDALOpen(m_rasterFilename.c_str(), GA_ReadOnly);
if (m_ds == NULL)
throw pdal_error("Unable to open GDAL datasource!");
if (GDALGetGeoTransform(m_ds, &(m_forward_transform.front())) != CE_None)
throw pdal_error("unable to fetch forward geotransform for raster!");
if (!GDALInvGeoTransform(&(m_forward_transform.front()),
&(m_inverse_transform.front())))
throw pdal_error("unable to fetch inverse geotransform for raster!");
for (auto bi = m_bands.begin(); bi != m_bands.end(); ++bi)
{
if (bi->m_dim == Dimension::Id::Unknown)
bi->m_dim = table.layout()->findDim(bi->m_name);
if (bi->m_dim == Dimension::Id::Unknown)
throw pdal_error((std::string)"Can't colorize - no dimension " +
bi->m_name);
}
}
// Build the list of dimensions for the output schema.
// Placing this here allows validation of dimensions before execution begins.
void DbWriter::prepared(PointTableRef table)
{
using namespace Dimension;
PointLayoutPtr layout = table.layout();
if (m_outputDims.empty())
{
for (auto& dimType : layout->dimTypes())
m_dbDims.push_back(XMLDim(dimType, layout->dimName(dimType.m_id)));
return;
}
DimTypeList dims;
for (std::string& s : m_outputDims)
{
DimType dt = layout->findDimType(s);
if (dt.m_id == Id::Unknown)
{
std::ostringstream oss;
oss << "Invalid dimension '" << s << "' specified for "
"'output_dims' option.";
throw pdal_error(oss.str());
}
m_dbDims.push_back(XMLDim(dt, layout->dimName(dt.m_id)));
}
}
void P2gWriter::done(PointTableRef table)
{
double adfGeoTransform[6];
adfGeoTransform[0] = m_bounds.minx - 0.5*m_GRID_DIST_X;
adfGeoTransform[1] = m_GRID_DIST_X;
adfGeoTransform[2] = 0.0;
adfGeoTransform[3] = m_bounds.maxy + 0.5*m_GRID_DIST_Y;
adfGeoTransform[4] = 0.0;
adfGeoTransform[5] = -1 * m_GRID_DIST_Y;
SpatialReference const& srs = table.spatialReference();
log()->get(LogLevel::Debug) << "Output SRS :'" << srs.getWKT() << "'" <<
std::endl;
// Strip off the extension if it was provided so that we don't get
// file.asc.type.asc or file.asc.asc, as point2grid appends a file
// extension.
std::string extension = FileUtils::extension(m_filename);
if (extension == ".asc" || extension == ".grid" || extension == ".tif")
m_filename = m_filename.substr(0, m_filename.find_last_of("."));
if (m_interpolator->finish(m_filename.c_str(), m_outputFormat,
m_outputTypes, adfGeoTransform, srs.getWKT().c_str()) < 0)
{
ostringstream oss;
oss << getName() << ": interp->finish() error";
throw pdal_error(oss.str());
}
getMetadata().addList("filename", m_filename);
}
// Deferring write until this time allows both points and faces from multiple
// point views to be written.
void PlyWriter::done(PointTableRef table)
{
for (auto& v : m_views)
{
PointRef point(*v, 0);
for (PointId idx = 0; idx < v->size(); ++idx)
{
point.setPointId(idx);
writePoint(point, table.layout());
}
}
if (m_faces)
{
PointId offset = 0;
for (auto& v : m_views)
{
TriangularMesh *mesh = v->mesh();
if (mesh)
{
for (size_t id = 0; id < mesh->size(); ++id)
{
const Triangle& t = (*mesh)[id];
writeTriangle(t, offset);
}
}
offset += v->size();
}
}
Utils::closeFile(m_stream);
m_stream = nullptr;
getMetadata().addList("filename", m_filename);
}
void GreyhoundReader::prepared(PointTableRef table)
{
MetadataNode queryNode(table.privateMetadata("greyhound"));
queryNode.add("info", dense(m_info));
queryNode.add("root", m_params.root());
queryNode.add("params", dense(m_params.toJson()));
}
void AttributeFilter::ready(PointTableRef table)
{
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 = table.layout()->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 ProgrammableFilter::ready(PointTableRef table)
{
plang::Environment::get()->set_stdout(log()->getLogStream());
m_script = new plang::Script(m_source, m_module, m_function);
m_pythonMethod = new plang::BufferedInvocation(*m_script);
m_pythonMethod->compile();
m_totalMetadata = table.metadata();
}
void GeoWaveWriter::ready(PointTableRef table)
{
// get a list of all the dimensions & their types
Dimension::IdList all = table.layout()->dims();
for (auto di = all.begin(); di != all.end(); ++di)
if (!Utils::contains(m_dims, *di))
m_dims.push_back(*di);
}
void GroupByFilter::prepared(PointTableRef table)
{
PointLayoutPtr layout(table.layout());
m_dimId = layout->findDim(m_dimName);
if (m_dimId == Dimension::Id::Unknown)
throwError("Invalid dimension name '" + m_dimName + "'.");
// also need to check that we have a dimension with discrete values
}
void FerryFilter::ready(PointTableRef table)
{
const PointLayoutPtr layout(table.layout());
for (const auto& dim_par : m_name_map)
{
Dimension::Id f = layout->findDim(dim_par.first);
Dimension::Id t = layout->findDim(dim_par.second);
m_dimensions_map.insert(std::make_pair(f,t));
}
}
void PlyWriter::ready(PointTableRef table)
{
if (pointCount() > std::numeric_limits<uint32_t>::max())
throwError("Can't write PLY file. Only " +
std::to_string(std::numeric_limits<uint32_t>::max()) +
" points supported.");
m_stream = Utils::createFile(m_filename, true);
writeHeader(table.layout());
}
void AttributeFilter::prepared(PointTableRef table)
{
m_dim = table.layout()->findDim(m_dimName);
if (m_dim == Dimension::Id::Unknown)
{
std::ostringstream oss;
oss << getName() << ": Dimension '" << m_dimName << "' not found.";
throw pdal_error(oss.str());
}
}
void FerryFilter::prepared(PointTableRef table)
{
for (auto& info : m_dims)
{
info.m_fromId = table.layout()->findDim(info.m_fromName);
if (info.m_fromId == Dimension::Id::Unknown && info.m_fromName.size())
throwError("Can't ferry dimension '" + info.m_fromName + "'. "
"Dimension doesn't exist.");
}
}
PointViewSet Stage::execute(PointTableRef table)
{
//printf("called %s\n", this->classname());
log()->setLevel(LogLevel::Enum::Debug);
std::string cn(this->classname());
log()->setLeader(cn + " Stage::execute");
log()->get(LogLevel::Debug) << "Called by class " << std::endl;
table.layout()->finalize();
PointViewSet views;
if (m_inputs.empty())
{
log()->get(LogLevel::Debug) << "if block, class" << std::endl;
views.insert(PointViewPtr(new PointView(table)));
}
else
{
for (size_t i = 0; i < m_inputs.size(); ++i)
{
log()->get(LogLevel::Debug) << "block, class"
<< "input number "<< i << std::endl;
log()->get(LogLevel::Debug) << "if block, class" << std::endl;
Stage *prev = m_inputs[i];
PointViewSet temp = prev->execute(table);
views.insert(temp.begin(), temp.end());
}
}
PointViewSet outViews;
std::vector<StageRunnerPtr> runners;
ready(table);
for (auto const& it : views)
{
log()->get(LogLevel::Debug) << "run, class" << std::endl;
StageRunnerPtr runner(new StageRunner(this, it));
runners.push_back(runner);
runner->run();
}
for (auto const& it : runners)
{
log()->get(LogLevel::Debug) << "wait, class" << std::endl;
StageRunnerPtr runner(it);
PointViewSet temp = runner->wait();
outViews.insert(temp.begin(), temp.end());
}
l_done(table);
done(table);
return outViews;
}
void PlyWriter::prepared(PointTableRef table)
{
if (m_dimNames.size())
{
for (auto& name : m_dimNames)
{
auto id = table.layout()->findDim(name);
if (id == Dimension::Id::Unknown)
throwError("Unknown dimension '" + name + "' in provided "
"dimension list.");
m_dims.push_back(id);
}
}
else
{
m_dims = table.layout()->dims();
for (auto dim : m_dims)
m_dimNames.push_back(Utils::tolower(table.layout()->dimName(dim)));
}
}
void FerryFilter::prepared(PointTableRef table)
{
for (const auto& dims : m_name_map)
if (table.layout()->findDim(dims.first) == Dimension::Id::Unknown)
{
std::ostringstream oss;
oss << "Can't ferry dimension '" << dims.first << "'. "
"Dimension doesn't exist.";
throw pdal_error(oss.str());
}
}
void P2gWriter::ready(PointTableRef table)
{
if (!table.spatialReferenceUnique())
{
std::ostringstream oss;
oss << getName() << ": Can't write output with multiple spatial "
"references.";
throw pdal_error(oss.str());
}
}
void MADFilter::prepared(PointTableRef table)
{
PointLayoutPtr layout(table.layout());
m_dimId = layout->findDim(m_dimName);
if (m_dimId == Dimension::Id::Unknown)
{
std::ostringstream oss;
oss << "Invalid dimension name in filters.mad 'dimension' "
"option: '" << m_dimName << "'.";
throw pdal_error(oss.str());
}
}
void PlyWriter::done(PointTableRef table)
{
if (!ply_add_element(m_ply, "vertex", m_pointCollector->size()))
{
std::stringstream ss;
ss << "Could not add vertex element";
throw pdal_error(ss.str());
}
auto dimensions = table.layout()->dims();
for (auto dim : dimensions) {
std::string name = Dimension::name(dim);
e_ply_type plyType = getPlyType(Dimension::defaultType(dim));
if (!ply_add_scalar_property(m_ply, name.c_str(), plyType))
{
std::stringstream ss;
ss << "Could not add scalar property '" << name << "'";
throw pdal_error(ss.str());
}
}
if (!ply_add_comment(m_ply, "Generated by PDAL"))
{
std::stringstream ss;
ss << "Could not add comment";
throw pdal_error(ss.str());
}
if (!ply_write_header(m_ply))
{
std::stringstream ss;
ss << "Could not write ply header";
throw pdal_error(ss.str());
}
for (PointId index = 0; index < m_pointCollector->size(); ++index)
{
for (auto dim : dimensions)
{
double value = m_pointCollector->getFieldAs<double>(dim, index);
if (!ply_write(m_ply, value))
{
std::stringstream ss;
ss << "Error writing dimension '" << Dimension::name(dim) <<
"' of point number " << index;
throw pdal_error(ss.str());
}
}
}
if (!ply_close(m_ply))
{
throw pdal_error("Error closing ply file");
}
}
void E57Writer::ready(PointTableRef table)
{
// Extracts dimensions that can be written
auto dimensions = table.layout()->dims();
m_dimensionsToWrite = {};
for (auto pdaldim: dimensions)
{
std::string e57Dimension(pdal::e57plugin::pdalToE57(pdaldim));
if (!e57Dimension.empty())
m_dimensionsToWrite.push_back(e57Dimension);
}
setupWriter();
}
void LasWriter::prepared(PointTableRef table)
{
FlexWriter::validateFilename(table);
PointLayoutPtr layout = table.layout();
// Make sure the dataformatID is set so that we can get the proper
// dimensions being written as part of the standard LAS record.
fillHeader();
// If we've asked for all dimensions, add to extraDims all dimensions
// in the layout that aren't already destined for LAS output.
if (m_extraDims.size() == 1 && m_extraDims[0].m_name == "all")
{
m_extraDims.clear();
Dimension::IdList ids = m_lasHeader.usedDims();
DimTypeList dimTypes = layout->dimTypes();
for (auto& dt : dimTypes)
{
if (!Utils::contains(ids, dt.m_id))
m_extraDims.push_back(
ExtraDim(layout->dimName(dt.m_id), dt.m_type));
}
}
m_extraByteLen = 0;
for (auto& dim : m_extraDims)
{
dim.m_dimType.m_id = table.layout()->findDim(dim.m_name);
if (dim.m_dimType.m_id == Dimension::Id::Unknown)
throwError("Dimension '" + dim.m_name + "' specified in "
"'extra_dim' option not found.");
m_extraByteLen += Dimension::size(dim.m_dimType.m_type);
log()->get(LogLevel::Info) << getName() << ": Writing dimension " <<
dim.m_name <<
"(" << Dimension::interpretationName(dim.m_dimType.m_type) <<
") " << " to LAS extra bytes." << std::endl;
}
}
void RangeFilter::prepared(PointTableRef table)
{
const PointLayoutPtr layout(table.layout());
for (auto& r : m_range_list)
{
r.m_id = layout->findDim(r.m_name);
if (r.m_id == Dimension::Id::Unknown)
throwError("Invalid dimension name in 'limits' option: '" +
r.m_name + "'.");
}
std::sort(m_range_list.begin(), m_range_list.end());
}
void PlyWriter::prepared(PointTableRef table)
{
if (m_precisionArg->set() && m_format != Format::Ascii)
throwError("Option 'precision' can only be set of the 'storage_mode' "
"is ascii.");
if (m_dimNames.size())
{
for (auto& name : m_dimNames)
{
auto id = table.layout()->findDim(name);
if (id == Dimension::Id::Unknown)
throwError("Unknown dimension '" + name + "' in provided "
"dimension list.");
m_dims.push_back(id);
}
}
else
{
m_dims = table.layout()->dims();
for (auto dim : m_dims)
m_dimNames.push_back(Utils::tolower(table.layout()->dimName(dim)));
}
}
void ReprojectionFilter::ready(PointTableRef table)
{
if (m_inferInputSRS)
{
m_inSRS = table.spatialRef();
if (m_inSRS.getWKT().empty())
throw pdal_error("Source data has no spatial reference and none "
"is specified with the 'in_srs' option.");
}
m_in_ref_ptr = ReferencePtr(OSRNewSpatialReference(0),
OGRSpatialReferenceDeleter());
m_out_ref_ptr = ReferencePtr(OSRNewSpatialReference(0),
OGRSpatialReferenceDeleter());
int result =
OSRSetFromUserInput(m_in_ref_ptr.get(),
m_inSRS.getWKT(pdal::SpatialReference::eCompoundOK).c_str());
if (result != OGRERR_NONE)
{
std::ostringstream msg;
msg << "Invalid input spatial reference '" << m_inSRS.getWKT() <<
"'. This is usually caused by a bad value for the 'in_srs'"
"option or an invalid spatial reference in the source file.";
throw pdal_error(msg.str());
}
result = OSRSetFromUserInput(m_out_ref_ptr.get(),
m_outSRS.getWKT(pdal::SpatialReference::eCompoundOK).c_str());
if (result != OGRERR_NONE)
{
std::ostringstream msg;
msg << "Invalid output spatial reference '" << m_outSRS.getWKT() <<
"'. This is usually caused by a bad value for the 'out_srs'"
"option.";
throw pdal_error(msg.str());
}
m_transform_ptr = TransformPtr(
OCTNewCoordinateTransformation(m_in_ref_ptr.get(),
m_out_ref_ptr.get()), OSRTransformDeleter());
if (!m_transform_ptr.get())
{
std::string msg = "Could not construct CoordinateTransformation in "
"ReprojectionFilter:: ";
throw std::runtime_error(msg);
}
setSpatialReference(m_outSRS);
}
void Stage::prepare(PointTableRef table)
{
for (size_t i = 0; i < m_inputs.size(); ++i)
{
Stage *prev = m_inputs[i];
prev->prepare(table);
}
l_processOptions(m_options);
processOptions(m_options);
l_initialize(table);
initialize(table);
addDimensions(table.layout());
prepared(table);
}
void TextWriter::ready(PointTableRef table)
{
m_stream->precision(m_precision);
*m_stream << std::fixed;
typedef boost::tokenizer<boost::char_separator<char>> tokenizer;
// Find the dimensions listed and put them on the id list.
boost::char_separator<char> separator(",");
boost::erase_all(m_dimOrder, " "); // Wipe off spaces
tokenizer sdims(m_dimOrder, separator);
for (tokenizer::iterator ti = sdims.begin(); ti != sdims.end(); ++ti)
{
Dimension::Id::Enum d = table.layout()->findDim(*ti);
if (d == Dimension::Id::Unknown)
{
std::ostringstream oss;
oss << "Dimension not found with name '" << *ti <<"'";
throw pdal::dimension_not_found(oss.str());
}
m_dims.push_back(d);
}
// Add the rest of the dimensions to the list if we're doing that.
// Yes, this isn't efficient when, but it's simple.
if (m_dimOrder.empty() || m_writeAllDims)
{
Dimension::IdList all = table.layout()->dims();
for (auto di = all.begin(); di != all.end(); ++di)
if (!contains(m_dims, *di))
m_dims.push_back(*di);
}
if (!m_writeHeader)
log()->get(LogLevel::Debug) << "Not writing header" << std::endl;
else
writeHeader(table);
}
void StatsFilter::prepared(PointTableRef table)
{
PointLayoutPtr layout(table.layout());
std::unordered_map<std::string, Summary::EnumType> dims;
std::ostream& out = log()->get(LogLevel::Warning);
// Add dimensions to the list.
if (m_dimNames.empty())
{
for (auto id : layout->dims())
dims[layout->dimName(id)] = Summary::NoEnum;
}
else
{
for (auto& s : m_dimNames)
{
if (layout->findDim(s) == Dimension::Id::Unknown)
out << "Dimension '" << s << "' listed in --dimensions "
"option does not exist. Ignoring." << std::endl;
else
dims[s] = Summary::NoEnum;
}
}
// Set the enumeration flag for those dimensions specified.
for (auto& s : m_enums)
{
if (dims.find(s) == dims.end())
out << "Dimension '" << s << "' listed in --enumerate option "
"does not exist. Ignoring." << std::endl;
else
dims[s] = Summary::Enumerate;
}
// Set the enumeration flag for those dimensions specified.
for (auto& s : m_counts)
{
if (dims.find(s) == dims.end())
out << "Dimension '" << s << "' listed in --count option "
"does not exist. Ignoring." << std::endl;
else
dims[s] = Summary::Count;
}
// Create the summary objects.
for (auto& dv : dims)
m_stats.insert(std::make_pair(layout->findDim(dv.first),
Summary(dv.first, dv.second)));
}
