void OptechReader::addDimensions(PointLayoutPtr layout)
{
for (auto it : getDefaultDimensions())
{
layout->registerDim(it);
}
}
Reader::Reader(const Bounds<double>& bounds, boost::uint64_t numPoints, Mode mode)
: pdal::Reader(Options::none())
, m_bounds(bounds)
, m_numPoints(numPoints)
, m_mode(mode)
{
m_schema = Schema(getDefaultDimensions());
}
Reader::Reader(const Options& options)
: pdal::Reader(options)
, m_bounds(options.getValueOrThrow<Bounds<double> >("bounds"))
, m_numPoints(options.getValueOrThrow<boost::uint64_t>("num_points"))
, m_mode(string2mode(options.getValueOrThrow<std::string>("mode")))
{
m_schema = Schema(getDefaultDimensions());
}
void FauxReader::addDimensions(PointLayoutPtr layout)
{
layout->registerDims(getDefaultDimensions());
if (m_numReturns > 0)
{
layout->registerDim(Dimension::Id::ReturnNumber);
layout->registerDim(Dimension::Id::NumberOfReturns);
}
}
void FauxReader::addDimensions(PointContextRef ctx)
{
ctx.registerDims(getDefaultDimensions());
if (m_numReturns > 0)
{
ctx.registerDim(Dimension::Id::ReturnNumber);
ctx.registerDim(Dimension::Id::NumberOfReturns);
}
}
void SbetReader::ready(PointContextRef ctx)
{
size_t fileSize = FileUtils::fileSize(m_filename);
size_t pointSize = getDefaultDimensions().size() * sizeof(double);
if (fileSize % pointSize != 0)
throw pdal_error("invalid sbet file size");
m_numPts = fileSize / pointSize;
m_index = 0;
m_stream.reset(new ILeStream(m_filename));
}
void Reader::initialize()
{
pdal::Reader::initialize();
Schema& schema = getSchemaRef();
schema = Schema(getDefaultDimensions());
setNumPoints(m_numPoints);
setPointCountType(PointCount_Fixed);
setBounds(m_bounds);
}
void SbetWriter::write(const PointViewPtr view)
{
Dimension::IdList dims = getDefaultDimensions();
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::Enum dim = *di;
*m_stream << (view->hasDim(dim) ?
view->getFieldAs<double>(dim, idx) : 0.0);
}
}
}
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 SbetReader::seek(PointId idx)
{
m_stream->seek(idx * sizeof(double) * getDefaultDimensions().size());
}
void SbetReader::addDimensions(PointContextRef ctx)
{
ctx.registerDims(getDefaultDimensions());
}
void PcdReader::addDimensions(PointLayoutPtr layout)
{
layout->registerDims(getDefaultDimensions());
}
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;
}
void Reader::registerFields()
{
Schema dimensions(getDefaultDimensions());
double xyz_scale = 1/static_cast<double>(m_header->Units);
Dimension x = dimensions.getDimension("X");
x.setNumericScale(xyz_scale);
x.setNumericOffset(-m_header->OrgX);
Dimension y = dimensions.getDimension("Y");
y.setNumericScale(xyz_scale);
y.setNumericOffset(-m_header->OrgY);
Dimension z = dimensions.getDimension("Z");
z.setNumericScale(xyz_scale);
z.setNumericOffset(-m_header->OrgZ);
if (m_format == TERRASOLID_Format_1)
{
m_schema.appendDimension(dimensions.getDimension("Classification"));
// Fetch PointSource ID Uint8 dimension by UUID because dimensions
// has two "PointSourceId" dimensions added.
m_schema.appendDimension(dimensions.getDimension(
boost::uuids::string_generator()("68c03b56-4248-4cca-ade5-33e90d5c5563")));
m_schema.appendDimension(dimensions.getDimension("Intensity"));
m_schema.appendDimension(x);
m_schema.appendDimension(y);
m_schema.appendDimension(z);
}
if (m_format == TERRASOLID_Format_2)
{
m_schema.appendDimension(x);
m_schema.appendDimension(y);
m_schema.appendDimension(z);
m_schema.appendDimension(dimensions.getDimension("Classification"));
m_schema.appendDimension(dimensions.getDimension(
boost::uuids::string_generator()("465a9a7e-1e04-47b0-97b6-4f826411bc71")));
m_schema.appendDimension(dimensions.getDimension("Flag"));
m_schema.appendDimension(dimensions.getDimension("Mark"));
m_schema.appendDimension(dimensions.getDimension(
boost::uuids::string_generator()("7193bb9f-3ca2-491f-ba18-594321493789")));
m_schema.appendDimension(dimensions.getDimension("Intensity"));
}
if (m_haveTime)
{
m_schema.appendDimension(dimensions.getDimension("Time"));
}
if (m_haveColor)
{
m_schema.appendDimension(dimensions.getDimension("Red"));
m_schema.appendDimension(dimensions.getDimension("Green"));
m_schema.appendDimension(dimensions.getDimension("Blue"));
m_schema.appendDimension(dimensions.getDimension("Alpha"));
}
return;
}
