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);
}
// 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;
}
void FerryFilter::addDimensions(PointLayoutPtr layout)
{
for (const auto& dim_par : m_name_map)
{
layout->registerOrAssignDim(dim_par.second, Dimension::Type::Double);
}
}
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 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?
}
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 TextReader::addDimensions(PointLayoutPtr layout)
{
m_dims.clear();
for (auto name : m_dimNames)
{
Utils::trim(name);
Dimension::Id id = layout->registerOrAssignDim(name,
Dimension::Type::Double);
if (Utils::contains(m_dims, id) && id != pdal::Dimension::Id::Unknown)
throwError("Duplicate dimension '" + name +
"' detected in input file '" + m_filename + "'.");
m_dims.push_back(id);
}
}
void BpfReader::addDimensions(PointLayoutPtr layout)
{
for (size_t i = 0; i < m_dims.size(); ++i)
{
Dimension::Type::Enum type = Dimension::Type::Float;
BpfDimension& dim = m_dims[i];
if (dim.m_label == "X" ||
dim.m_label == "Y" ||
dim.m_label == "Z")
type = Dimension::Type::Double;
dim.m_id = layout->registerOrAssignDim(dim.m_label, type);
}
}
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);
}
}
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 ProgrammableFilter::addDimensions(PointLayoutPtr layout)
{
for (const std::string& s : m_addDimensions)
layout->registerOrAssignDim(s, pdal::Dimension::Type::Double);
}
void FerryFilter::addDimensions(PointLayoutPtr layout)
{
for (auto& info : m_dims)
info.m_toId = layout->registerOrAssignDim(info.m_toName,
Dimension::Type::Double);
}
void MyFilter::addDimensions(PointLayoutPtr layout)
{
layout->registerDim(Dimension::Id::Intensity);
m_myDimension = layout->registerOrAssignDim("MyDimension",
Dimension::Type::Unsigned8);
}
void GreyhoundReader::addDimensions(PointLayoutPtr layout)
{
std::map<std::string, const Json::Value*> remote;
for (const auto& d : m_info["schema"])
remote[d["name"].asString()] = &d;
// The dimensions we will query are determined in the following order, the
// first of which is present taking precedence:
// - The `dims` PDAL option on this stage.
// - A `schema` query parameter parsed from the `url` option.
// - Finally, fall back to the full `info.schema`.
if (m_args.dims.isNull())
{
// If no dimensions are explicitly listed, only include the indexed
// schema - omitting any appended dimensions. Those must be explicitly
// specified if desired.
Json::Value nativeSchema;
for (const Json::Value d : m_info["schema"])
if (!d["addon"].asBool())
nativeSchema.append(d);
const Json::Value& readSchema = m_params["schema"].isNull() ?
nativeSchema : m_params["schema"];
for (const auto& d : readSchema)
{
m_args.dims.append(d["name"].asString());
}
}
auto isXyz([](const std::string& name)
{
return name == "X" || name == "Y" || name == "Z";
});
// Build the request layout from the specified `dims`.
for (const auto& n : m_args.dims)
{
const auto name(n.asString());
if (!remote.count(name))
throw pdal_error(name + " does not exist in the remote schema");
const auto& d(*remote.at(name));
const int baseType(
Utils::toNative(Dimension::fromName(d["type"].asString())));
const int size(d["size"].asInt());
const Dimension::Type type(
isXyz(name) ?
Dimension::Type::Double :
static_cast<Dimension::Type>(baseType | size));
layout->registerOrAssignDim(name, type);
m_readLayout.registerOrAssignDim(name, type);
}
if (!m_params.obounds().isNull())
{
layout->registerDim(Dimension::Id::Omit);
}
// We'll keep track of the point ordering here in case any intermediate
// filters reorder them. We need to write them with a 1:1 mapping to the
// original query.
layout->registerDim(Dimension::Id::PointId);
m_params["schema"] = layoutToSchema(m_readLayout);
log()->get(LogLevel::Debug) << "Schema: " << m_params["schema"] <<
std::endl;
}
void EstimateRankFilter::addDimensions(PointLayoutPtr layout)
{
m_rank = layout->registerOrAssignDim("Rank", Dimension::Type::Unsigned8);
}
void KDistanceFilter::addDimensions(PointLayoutPtr layout)
{
using namespace Dimension;
m_kdist = layout->registerOrAssignDim("KDistance", Type::Double);
}
void ColorizationFilter::addDimensions(PointLayoutPtr layout)
{
for (auto& band : m_bands)
band.m_dim = layout->registerOrAssignDim(band.m_name,
Dimension::defaultType(Dimension::Id::Red));
}
