void TIndexReader::addDimensions(PointLayoutPtr layout)
{
using namespace pdal::Dimension::Type;
layout->registerDim(pdal::Dimension::Id::X);
layout->registerDim(pdal::Dimension::Id::Y);
layout->registerDim(pdal::Dimension::Id::Z);
}
// 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 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);
}
}
// Try to map dimension names to existing PDAL dimension names by
// checking them with certain characters removed.
Dimension::Id NumpyReader::registerDim(PointLayoutPtr layout,
const std::string& name, Dimension::Type pdalType)
{
Dimension::Id id;
auto registerName = [&layout, &pdalType, &id](std::string name, char elim)
{
if (elim != '\0')
Utils::remove(name, elim);
Dimension::Id tempId = Dimension::id(name);
if (tempId != Dimension::Id::Unknown)
{
id = tempId;
layout->registerDim(id, pdalType);
return true;
}
return false;
};
// Try registering the name in various ways. If that doesn't work,
// just punt and use the name as is.
if (!registerName(name, '\0') && !registerName(name, '-') &&
!registerName(name, ' ') && !registerName(name, '_'))
id = layout->registerOrAssignDim(name, pdalType);
return id;
}
TEST(KDIndex, neighbordims)
{
PointTable table;
PointLayoutPtr layout = table.layout();
PointView view(table);
layout->registerDim(Dimension::Id::X);
layout->registerDim(Dimension::Id::Z);
view.setField(Dimension::Id::X, 0, 0);
view.setField(Dimension::Id::Z, 0, 0);
view.setField(Dimension::Id::X, 1, 1);
view.setField(Dimension::Id::Z, 1, 1);
EXPECT_THROW(KD2Index index(view), pdal_error);
PointTable table2;
PointLayoutPtr layout2 = table.layout();
PointView view2(table2);
layout->registerDim(Dimension::Id::X);
layout->registerDim(Dimension::Id::Y);
view.setField(Dimension::Id::X, 0, 0);
view.setField(Dimension::Id::Y, 0, 0);
view.setField(Dimension::Id::X, 1, 1);
view.setField(Dimension::Id::Y, 1, 1);
EXPECT_THROW(KD3Index index(view2), pdal_error);
}
XMLSchema::XMLSchema(const PointLayoutPtr& layout, MetadataNode m,
Orientation orientation) : m_orientation(orientation), m_metadata(m)
{
DimTypeList dimTypes = layout->dimTypes();
for (DimType& d : dimTypes)
m_dims.push_back(XMLDim(d, layout->dimName(d.m_id)));
}
void LOFFilter::addDimensions(PointLayoutPtr layout)
{
using namespace Dimension;
m_kdist = layout->registerOrAssignDim("KDistance", Type::Double);
m_lrd = layout->registerOrAssignDim("LocalReachabilityDistance", Type::Double);
m_lof = layout->registerOrAssignDim("LocalOutlierFactor", Type::Double);
}
TEST(KDIndex, neighbors2D)
{
PointTable table;
PointLayoutPtr layout = table.layout();
PointView view(table);
layout->registerDim(Dimension::Id::X);
layout->registerDim(Dimension::Id::Y);
view.setField(Dimension::Id::X, 0, 0);
view.setField(Dimension::Id::Y, 0, 0);
view.setField(Dimension::Id::X, 1, 1);
view.setField(Dimension::Id::Y, 1, 1);
view.setField(Dimension::Id::X, 2, 3);
view.setField(Dimension::Id::Y, 2, 3);
view.setField(Dimension::Id::X, 3, 6);
view.setField(Dimension::Id::Y, 3, 6);
view.setField(Dimension::Id::X, 4, 10);
view.setField(Dimension::Id::Y, 4, 10);
KD2Index index(view);
index.build();
EXPECT_EQ(index.neighbor(0, 0), 0u);
EXPECT_EQ(index.neighbor(1.1, 1.1), 1u);
EXPECT_EQ(index.neighbor(3.3, 3.3), 2u);
EXPECT_EQ(index.neighbor(6.1, 6.1), 3u);
EXPECT_EQ(index.neighbor(15, 15), 4u);
std::vector<PointId> ids;
ids = index.neighbors(0, 0, 5);
EXPECT_EQ(ids.size(), 5u);
EXPECT_EQ(ids[0], 0u);
EXPECT_EQ(ids[1], 1u);
EXPECT_EQ(ids[2], 2u);
EXPECT_EQ(ids[3], 3u);
EXPECT_EQ(ids[4], 4u);
ids = index.neighbors(0, 0, 25);
EXPECT_EQ(ids.size(), 5u);
EXPECT_EQ(ids[0], 0u);
EXPECT_EQ(ids[1], 1u);
EXPECT_EQ(ids[2], 2u);
EXPECT_EQ(ids[3], 3u);
EXPECT_EQ(ids[4], 4u);
ids = index.neighbors(3.1, 3.1, 5);
EXPECT_EQ(ids.size(), 5u);
EXPECT_EQ(ids[0], 2u);
EXPECT_EQ(ids[1], 1u);
EXPECT_EQ(ids[2], 3u);
EXPECT_EQ(ids[3], 0u);
EXPECT_EQ(ids[4], 4u);
}
void FauxReader::addDimensions(PointLayoutPtr layout)
{
layout->registerDims(getDefaultDimensions());
if (m_numReturns > 0)
{
layout->registerDim(Dimension::Id::ReturnNumber);
layout->registerDim(Dimension::Id::NumberOfReturns);
}
}
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 GDALReader::addDimensions(PointLayoutPtr layout)
{
layout->registerDim(pdal::Dimension::Id::X);
layout->registerDim(pdal::Dimension::Id::Y);
for (int i = 0; i < m_raster->m_band_count; ++i)
{
std::ostringstream oss;
oss << "band-" << (i + 1);
layout->registerOrAssignDim(oss.str(), Dimension::Type::Double);
}
}
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 FerryFilter::addDimensions(PointLayoutPtr layout)
{
for (auto& info : m_dims)
{
const Dimension::Id fromId = layout->findDim(info.m_fromName);
// Dimensions being created with the "=>Dim" syntax won't
// be in the layout, so we have to assign a default type.
Dimension::Type fromType = layout->dimType(fromId);
if (fromType == Dimension::Type::None)
fromType = Dimension::Type::Double;
info.m_toId = layout->registerOrAssignDim(info.m_toName, fromType);
}
}
TEST(KDIndex, radius3D)
{
PointTable table;
PointLayoutPtr layout = table.layout();
PointView view(table);
layout->registerDim(Dimension::Id::X);
layout->registerDim(Dimension::Id::Y);
layout->registerDim(Dimension::Id::Z);
view.setField(Dimension::Id::X, 0, 0);
view.setField(Dimension::Id::Y, 0, 0);
view.setField(Dimension::Id::Z, 0, 0);
view.setField(Dimension::Id::X, 1, 1);
view.setField(Dimension::Id::Y, 1, 1);
view.setField(Dimension::Id::Z, 1, 1);
view.setField(Dimension::Id::X, 2, 3);
view.setField(Dimension::Id::Y, 2, 3);
view.setField(Dimension::Id::Z, 2, 3);
view.setField(Dimension::Id::X, 3, 6);
view.setField(Dimension::Id::Y, 3, 6);
view.setField(Dimension::Id::Z, 3, 6);
view.setField(Dimension::Id::X, 4, 10);
view.setField(Dimension::Id::Y, 4, 10);
view.setField(Dimension::Id::Z, 4, 10);
KD3Index index(view);
index.build();
std::vector<PointId> ids;
ids = index.radius(0, 0, 0, 5.2);
EXPECT_EQ(ids.size(), 3u);
EXPECT_EQ(ids[0], 0u);
EXPECT_EQ(ids[1], 1u);
EXPECT_EQ(ids[2], 2u);
ids = index.radius(3.1, 3.1, 3.1, 12.2);
EXPECT_EQ(ids.size(), 5u);
EXPECT_EQ(ids[0], 2u);
EXPECT_EQ(ids[1], 1u);
EXPECT_EQ(ids[2], 3u);
EXPECT_EQ(ids[3], 0u);
EXPECT_EQ(ids[4], 4u);
}
void TextWriter::writeCSVHeader(PointTableRef table)
{
const PointLayoutPtr layout(table.layout());
for (auto di = m_dims.begin(); di != m_dims.end(); ++di)
{
if (di != m_dims.begin())
*m_stream << m_delimiter;
if (m_quoteHeader)
*m_stream << "\"" << layout->dimName(*di) << "\"";
else
*m_stream << layout->dimName(*di);
}
*m_stream << m_newline;
}
void PlyReader::addDimensions(PointLayoutPtr layout)
{
for (auto it : m_vertexDimensions)
{
layout->registerDim(it.second);
}
}
void MrsidReader::addDimensions(PointLayoutPtr layout)
{
using namespace Dimension;
if (!m_PS)
throw pdal_error("MrSID object not initialized!");
const LizardTech::PointInfo& pointinfo = m_PS->getPointInfo();
// add a map for PDAL names that aren't the same as LT ones (GPSTime vs Time)
std::map<std::string, std::string> dimensionTranslations;
dimensionTranslations.insert(std::pair<std::string, std::string>("Time", "GPSTime"));
dimensionTranslations.insert(std::pair<std::string, std::string>("NumReturns", "NumberOfReturns"));
dimensionTranslations.insert(std::pair<std::string, std::string>("ReturnNum", "ReturnNumber"));
dimensionTranslations.insert(std::pair<std::string, std::string>("ScanDir", "ScanDirectionFlag"));
dimensionTranslations.insert(std::pair<std::string, std::string>("EdgeFlightLine", "EdgeOfFlightLine"));
dimensionTranslations.insert(std::pair<std::string, std::string>("ScanAngle", "ScanAngleRank"));
dimensionTranslations.insert(std::pair<std::string, std::string>("ClassId", "Classification"));
dimensionTranslations.insert(std::pair<std::string, std::string>("SourceId", "PointSourceId"));
for (unsigned int i=0; i<pointinfo.getNumChannels(); i++)
{
const LizardTech::ChannelInfo &channel = pointinfo.getChannel(i);
const char* name = channel.getName();
auto translated = dimensionTranslations.find(name);
if (translated != dimensionTranslations.end())
name = translated->second.c_str();
LizardTech::DataType t = channel.getDataType();
Dimension::Type::Enum pdal_type = getPDALType(t);
layout->registerOrAssignDim(name, pdal_type);
}
m_layout = layout;
}
void FerryFilter::addDimensions(PointLayoutPtr layout)
{
for (const auto& dim_par : m_name_map)
{
layout->registerOrAssignDim(dim_par.second, Dimension::Type::Double);
}
}
void NormalFilter::addDimensions(PointLayoutPtr layout)
{
using namespace Dimension;
layout->registerDims(
{Id::NormalX, Id::NormalY, Id::NormalZ, Id::Curvature});
}
void OptechReader::addDimensions(PointLayoutPtr layout)
{
for (auto it : getDefaultDimensions())
{
layout->registerDim(it);
}
}
inline MetadataNode toMetadata(PointTableRef table)
{
const PointLayoutPtr layout(table.layout());
MetadataNode root;
for (const auto& id : layout->dims())
{
MetadataNode dim("dimensions");
dim.add("name", layout->dimName(id));
Dimension::Type::Enum t = layout->dimType(id);
dim.add("type", Dimension::toName(Dimension::base(t)));
dim.add("size", layout->dimSize(id));
root.addList(dim);
}
return root;
}
void TextReader::addDimensions(PointLayoutPtr layout)
{
for (auto name : m_dimNames)
{
Dimension::Id::Enum id = layout->registerOrAssignDim(name,
Dimension::Type::Double);
m_dims.push_back(id);
}
}
void TileDBReader::addDimensions(PointLayoutPtr layout)
{
// Dimensions are X/Y and maybe Z
std::vector<tiledb::Dimension> dims =
m_array->schema().domain().dimensions();
Dimension::Id id;
for (size_t i = 0; i < dims.size(); ++i)
{
tiledb::Dimension& dim = dims[i];
DimInfo di;
di.m_name = dim.name();
di.m_offset = i;
di.m_span = dims.size();
di.m_dimCategory = DimCategory::Dimension;
di.m_tileType = dim.type();
di.m_type = getPdalType(di.m_tileType);
di.m_id = layout->registerOrAssignDim(dim.name(), di.m_type);
m_dims.push_back(di);
}
auto attrs = m_array->schema().attributes();
for (const auto& a : attrs)
{
DimInfo di;
di.m_name = a.first;
di.m_offset = 0;
di.m_span = 1;
di.m_dimCategory = DimCategory::Attribute;
di.m_tileType = a.second.type();
di.m_type = getPdalType(di.m_tileType);
di.m_id = layout->registerOrAssignDim(a.first, di.m_type);
m_dims.push_back(di);
}
//ABELL
// Should we check that X Y and Z exist and remap the primary/secondary
// dimensions to X Y and Z if necessary?
}
TEST(TextReaderTest, insertHeader)
{
TextReader reader;
Options options;
options.add("header", "A,B,C,G");
options.add("filename", Support::datapath("text/crlf_test.txt"));
reader.setOptions(options);
PointTable table;
reader.prepare(table);
PointViewSet pointViewSet = reader.execute(table);
PointViewPtr pointViewPtr = *pointViewSet.begin();
EXPECT_EQ(pointViewPtr->size(), 11U);
PointLayoutPtr layout = table.layout();
EXPECT_TRUE(layout->findDim("A") != Dimension::Id::Unknown);
EXPECT_TRUE(layout->findDim("B") != Dimension::Id::Unknown);
EXPECT_TRUE(layout->findDim("C") != Dimension::Id::Unknown);
EXPECT_TRUE(layout->findDim("G") != Dimension::Id::Unknown);
}
void DbReader::loadSchema(PointLayoutPtr layout, const XMLSchema& schema)
{
m_layout = layout;
m_dims = schema.xmlDims();
// Override XYZ to doubles and use those going forward
// we will apply any scaling set before handing it off
// to PDAL.
layout->registerDim(Dimension::Id::X);
layout->registerDim(Dimension::Id::Y);
layout->registerDim(Dimension::Id::Z);
m_orientation = schema.orientation();
m_packedPointSize = 0;
for (auto di = m_dims.begin(); di != m_dims.end(); ++di)
{
di->m_dimType.m_id =
layout->registerOrAssignDim(di->m_name, di->m_dimType.m_type);
m_packedPointSize += Dimension::size(di->m_dimType.m_type);
}
}
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);
}
}
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;
}
}
TEST(GDALReaderTest, simple)
{
Options ro;
ro.add("filename", Support::datapath("png/autzen-height.png"));
GDALReader gr;
gr.setOptions(ro);
PointTable t;
gr.prepare(t);
PointViewSet s = gr.execute(t);
PointViewPtr v = *s.begin();
PointLayoutPtr l = t.layout();
Dimension::Id::Enum id1 = l->findDim("band-1");
Dimension::Id::Enum id2 = l->findDim("band-2");
Dimension::Id::Enum id3 = l->findDim("band-3");
EXPECT_EQ(v->size(), (size_t)(735 * 973));
auto verify = [v, id1, id2, id3]
(PointId idx, double xx, double xy, double xr, double xg, double xb)
{
double r, g, b, x, y;
x = v->getFieldAs<double>(Dimension::Id::X, idx);
y = v->getFieldAs<double>(Dimension::Id::Y, idx);
r = v->getFieldAs<double>(id1, idx);
g = v->getFieldAs<double>(id2, idx);
b = v->getFieldAs<double>(id3, idx);
EXPECT_DOUBLE_EQ(x, xx);
EXPECT_DOUBLE_EQ(y, xy);
EXPECT_DOUBLE_EQ(r, xr);
EXPECT_DOUBLE_EQ(g, xg);
EXPECT_DOUBLE_EQ(b, xb);
};
verify(0, .5, .5, 0, 0, 0);
verify(120000, 195.5, 163.5, 255, 213, 0);
verify(290000, 410.5, 394.5, 0, 255, 206);
verify(715154, 734.5, 972.5, 0, 0, 0);
}
int DeltaKernel::execute()
{
PointTable srcTable;
PointTable candTable;
DimIndexMap dims;
PointViewPtr srcView = loadSet(m_sourceFile, srcTable);
PointViewPtr candView = loadSet(m_candidateFile, candTable);
PointLayoutPtr srcLayout = srcTable.layout();
PointLayoutPtr candLayout = candTable.layout();
Dimension::IdList ids = srcLayout->dims();
for (Dimension::Id dim : ids)
{
std::string name = srcLayout->dimName(dim);
if (!m_allDims)
if (name != "X" && name != "Y" && name != "Z")
continue;
DimIndex d;
d.m_name = name;
d.m_srcId = dim;
dims[name] = d;
}
ids = candLayout->dims();
for (Dimension::Id dim : ids)
{
std::string name = candLayout->dimName(dim);
auto di = dims.find(name);
if (di == dims.end())
continue;
DimIndex& d = di->second;
d.m_candId = dim;
}
// Remove dimensions that aren't in both the source and candidate lists.
for (auto di = dims.begin(); di != dims.end();)
{
DimIndex& d = di->second;
if (d.m_candId == Dimension::Id::Unknown)
dims.erase(di++);
else
++di;
}
// Index the candidate data.
KD3Index index(*candView);
index.build();
MetadataNode root;
if (m_detail)
root = dumpDetail(srcView, candView, index, dims);
else
root = dump(srcView, candView, index, dims);
Utils::toJSON(root, std::cout);
return 0;
}
