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);
}
Dimension::IdList FauxReader::getDefaultDimensions()
{
Dimension::IdList ids;
ids.push_back(Dimension::Id::X);
ids.push_back(Dimension::Id::Y);
ids.push_back(Dimension::Id::Z);
ids.push_back(Dimension::Id::OffsetTime);
return ids;
}
Dimension::IdList Ilvis2Reader::getDefaultDimensions()
{
using namespace pdal::Dimension;
Dimension::IdList ids;
ids.push_back(Id::GpsTime);
ids.push_back(Id::Y);
ids.push_back(Id::X);
ids.push_back(Id::Z);
return ids;
}
void SbetWriter::write(const PointViewPtr view)
{
Dimension::IdList dims = fileDimensions();
for (PointId idx = 0; idx < view->size(); ++idx)
{
for (auto di = dims.begin(); di != dims.end(); ++di)
{
// If a dimension doesn't exist, write 0.
Dimension::Id dim = *di;
*m_stream << (view->hasDim(dim) ?
view->getFieldAs<double>(dim, idx) : 0.0);
}
}
}
void BpfWriter::loadBpfDimensions(PointLayoutPtr layout)
{
// Verify that we have X, Y and Z and that they're the first three
// dimensions.
Dimension::IdList dims = layout->dims();
std::sort(dims.begin(), dims.end());
if (dims.size() < 3 || dims[0] != Dimension::Id::X ||
dims[1] != Dimension::Id::Y || dims[2] != Dimension::Id::Z)
{
throw pdal_error("Missing one of dimensions X, Y or Z. "
"Can't write BPF.");
}
for (auto id : dims)
{
BpfDimension dim;
dim.m_id = id;
dim.m_label = layout->dimName(id);
m_dims.push_back(dim);
}
}
void BpfWriter::loadBpfDimensions(PointLayoutPtr layout)
{
Dimension::IdList dims;
if (m_outputDims.size())
{
for (std::string& s : m_outputDims)
{
Dimension::Id::Enum id = layout->findDim(s);
if (id == Dimension::Id::Unknown)
{
std::ostringstream oss;
oss << "Invalid dimension '" << s << "' specified for "
"'output_dims' option.";
throw pdal_error(oss.str());
}
dims.push_back(id);
}
}
else
dims = layout->dims();
// Verify that we have X, Y and Z and that they're the first three
// dimensions.
std::sort(dims.begin(), dims.end());
if (dims.size() < 3 || dims[0] != Dimension::Id::X ||
dims[1] != Dimension::Id::Y || dims[2] != Dimension::Id::Z)
{
throw pdal_error("Missing one of dimensions X, Y or Z. "
"Can't write BPF.");
}
for (auto id : dims)
{
BpfDimension dim;
dim.m_id = id;
dim.m_label = layout->dimName(id);
m_dims.push_back(dim);
}
}
Dimension::IdList OptechReader::getDefaultDimensions()
{
Dimension::IdList dims;
dims.push_back(Dimension::Id::X);
dims.push_back(Dimension::Id::Y);
dims.push_back(Dimension::Id::Z);
dims.push_back(Dimension::Id::GpsTime);
dims.push_back(Dimension::Id::ReturnNumber);
dims.push_back(Dimension::Id::NumberOfReturns);
dims.push_back(Dimension::Id::EchoRange);
dims.push_back(Dimension::Id::Intensity);
dims.push_back(Dimension::Id::ScanAngleRank);
return dims;
}
Dimension::IdList LasHeader::usedDims() const
{
using namespace Dimension;
Dimension::Id::Enum dims[] = { Id::ReturnNumber, Id::NumberOfReturns,
Id::X, Id::Y, Id::Z, Id::Intensity, Id::ScanChannel,
Id::ScanDirectionFlag, Id::EdgeOfFlightLine, Id::Classification,
Id::UserData, Id::ScanAngleRank, Id::PointSourceId };
// This mess is because MSVC doesn't support initializer lists.
Dimension::IdList ids;
std::copy(std::begin(dims), std::end(dims), std::back_inserter(ids));
if (hasTime())
ids.push_back(Id::GpsTime);
if (hasColor())
{
ids.push_back(Id::Red);
ids.push_back(Id::Green);
ids.push_back(Id::Blue);
}
if (hasInfrared())
ids.push_back(Id::Infrared);
return ids;
}
QuickInfo LasReader::inspect()
{
QuickInfo qi;
std::unique_ptr<PointLayout> layout(new PointLayout());
addDimensions(layout.get());
initialize();
Dimension::IdList dims = layout->dims();
for (auto di = dims.begin(); di != dims.end(); ++di)
qi.m_dimNames.push_back(layout->dimName(*di));
qi.m_pointCount =
Utils::saturation_cast<point_count_t>(m_lasHeader.pointCount());
qi.m_bounds = m_lasHeader.getBounds();
qi.m_srs = getSrsFromVlrs();
qi.m_valid = true;
PointTable table;
done(table);
return qi;
}
QuickInfo LasReader::inspect()
{
QuickInfo qi;
std::unique_ptr<PointLayout> layout(new PointLayout());
PointTable table;
initialize(table);
addDimensions(layout.get());
Dimension::IdList dims = layout->dims();
for (auto di = dims.begin(); di != dims.end(); ++di)
qi.m_dimNames.push_back(layout->dimName(*di));
if (!Utils::numericCast(m_lasHeader.pointCount(), qi.m_pointCount))
qi.m_pointCount = std::numeric_limits<point_count_t>::max();
qi.m_bounds = m_lasHeader.getBounds();
qi.m_srs = getSpatialReference();
qi.m_valid = true;
done(table);
return qi;
}
point_count_t SbetReader::read(PointBuffer& buf, point_count_t count)
{
PointId nextId = buf.size();
PointId idx = m_index;
point_count_t numRead = 0;
seek(idx);
Dimension::IdList dims = getDefaultDimensions();
while (numRead < count && idx < m_numPts)
{
for (auto di = dims.begin(); di != dims.end(); ++di)
{
double d;
*m_stream >> d;
Dimension::Id::Enum dim = *di;
buf.setField(dim, nextId, d);
}
idx++;
nextId++;
numRead++;
}
m_index = idx;
return numRead;
}
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);
}
TEST_F(PgpointcloudWriterTest, writeXYZ)
{
if (shouldSkipTests())
{
return;
}
Options ops = getDbOptions();
ops.add("output_dims", "X,Y,Z");
optionsWrite(ops);
PointTable table;
StageFactory factory;
Stage* reader(factory.createStage("readers.pgpointcloud"));
reader->setOptions(getDbOptions());
reader->prepare(table);
Dimension::IdList dims = table.layout()->dims();
EXPECT_EQ(dims.size(), (size_t)3);
EXPECT_TRUE(Utils::contains(dims, Dimension::Id::X));
EXPECT_TRUE(Utils::contains(dims, Dimension::Id::Y));
EXPECT_TRUE(Utils::contains(dims, Dimension::Id::Z));
}
void TextWriter::ready(PointTableRef table)
{
m_stream->precision(m_precision);
*m_stream << std::fixed;
// Find the dimensions listed and put them on the id list.
StringList dimNames = Utils::split2(m_dimOrder, ',');
for (std::string dim : dimNames)
{
Utils::trim(dim);
Dimension::Id d = table.layout()->findDim(dim);
if (d == Dimension::Id::Unknown)
{
std::ostringstream oss;
oss << getName() << ": Dimension not found with name '" <<
dim << "'.";
throw pdal_error(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 (!Utils::contains(m_dims, *di))
m_dims.push_back(*di);
}
if (!m_writeHeader)
log()->get(LogLevel::Debug) << "Not writing header" << std::endl;
else
writeHeader(table);
}
Dimension::IdList Reader::getDefaultDimensions()
{
Dimension::IdList ids;
using namespace Dimension;
ids.push_back(Id::OffsetTime);
ids.push_back(Id::Y);
ids.push_back(Id::X);
ids.push_back(Id::Z);
ids.push_back(Id::StartPulse);
ids.push_back(Id::ReflectedPulse);
ids.push_back(Id::ScanAngleRank);
ids.push_back(Id::Pitch);
ids.push_back(Id::Roll);
ids.push_back(Id::Pdop);
ids.push_back(Id::PulseWidth);
ids.push_back(Id::GpsTime);
return ids;
}
point_count_t IcebridgeReader::read(PointViewPtr view, point_count_t count)
{
//All data we read for icebridge is currently 4 bytes wide, so
// just allocate once and forget it.
//This could be a huge allocation. Perhaps we should do something
// in the icebridge handler?
PointId startId = view->size();
point_count_t remaining = m_hdf5Handler.getNumPoints() - m_index;
count = std::min(count, remaining);
std::unique_ptr<unsigned char>
rawData(new unsigned char[count * sizeof(float)]);
//Not loving the position-linked data, but fine for now.
Dimension::IdList dims = getDefaultDimensions();
auto di = dims.begin();
for (auto ci = hdf5Columns.begin(); ci != hdf5Columns.end(); ++ci, ++di)
{
PointId nextId = startId;
PointId idx = m_index;
const hdf5::Hdf5ColumnData& column = *ci;
try
{
m_hdf5Handler.getColumnEntries(rawData.get(), column.name, count,
m_index);
void *p = (void *)rawData.get();
// This is ugly but avoids a test in a tight loop.
if (column.predType == H5::PredType::NATIVE_FLOAT)
{
// Offset time is in ms but icebridge stores in seconds.
if (*di == Dimension::Id::OffsetTime)
{
float *fval = (float *)p;
for (PointId i = 0; i < count; ++i)
{
view->setField(*di, nextId++, *fval * 1000);
fval++;
}
}
else
{
float *fval = (float *)p;
for (PointId i = 0; i < count; ++i)
view->setField(*di, nextId++, *fval++);
}
}
else if (column.predType == H5::PredType::NATIVE_INT)
{
int32_t *ival = (int32_t *)p;
for (PointId i = 0; i < count; ++i)
view->setField(*di, nextId++, *ival++);
}
}
catch(...)
{
throw icebridge_error("Error fetching column data");
}
}
return count;
}
Dimension::IdList QfitReader::getDefaultDimensions()
{
Dimension::IdList ids;
ids.push_back(Dimension::Id::OffsetTime);
ids.push_back(Dimension::Id::Y);
ids.push_back(Dimension::Id::X);
ids.push_back(Dimension::Id::Z);
ids.push_back(Dimension::Id::StartPulse);
ids.push_back(Dimension::Id::ReflectedPulse);
ids.push_back(Dimension::Id::ScanAngleRank);
ids.push_back(Dimension::Id::Pitch);
ids.push_back(Dimension::Id::Roll);
ids.push_back(Dimension::Id::Pdop);
ids.push_back(Dimension::Id::PulseWidth);
ids.push_back(Dimension::Id::PassiveSignal);
ids.push_back(Dimension::Id::PassiveY);
ids.push_back(Dimension::Id::PassiveX);
ids.push_back(Dimension::Id::PassiveZ);
return ids;
}