304 lines
10 KiB
C++
304 lines
10 KiB
C++
#include <mbgl/map/vector_tile.hpp>
|
|
#include <mbgl/style/filter_expression_private.hpp>
|
|
#include <mbgl/style/filter_comparison_private.hpp>
|
|
|
|
#include <algorithm>
|
|
#include <iostream>
|
|
|
|
using namespace mbgl;
|
|
|
|
|
|
std::ostream& mbgl::operator<<(std::ostream& os, const FeatureType& type) {
|
|
switch (type) {
|
|
case FeatureType::Unknown: return os << "Unknown";
|
|
case FeatureType::Point: return os << "Point";
|
|
case FeatureType::LineString: return os << "LineString";
|
|
case FeatureType::Polygon: return os << "Polygon";
|
|
default: return os << "Invalid";
|
|
}
|
|
}
|
|
|
|
VectorTileFeature::VectorTileFeature(pbf feature, const VectorTileLayer& layer) {
|
|
while (feature.next()) {
|
|
if (feature.tag == 1) { // id
|
|
id = feature.varint<uint64_t>();
|
|
} else if (feature.tag == 2) { // tags
|
|
// tags are packed varints. They should have an even length.
|
|
pbf tags = feature.message();
|
|
while (tags) {
|
|
uint32_t tag_key = tags.varint();
|
|
|
|
if (layer.keys.size() <= tag_key) {
|
|
throw std::runtime_error("feature referenced out of range key");
|
|
}
|
|
|
|
if (tags) {
|
|
uint32_t tag_val = tags.varint();
|
|
if (layer.values.size() <= tag_val) {
|
|
throw std::runtime_error("feature referenced out of range value");
|
|
}
|
|
|
|
properties.emplace(layer.keys[tag_key], layer.values[tag_val]);
|
|
} else {
|
|
throw std::runtime_error("uneven number of feature tag ids");
|
|
}
|
|
}
|
|
} else if (feature.tag == 3) { // type
|
|
type = (FeatureType)feature.varint();
|
|
} else if (feature.tag == 4) { // geometry
|
|
geometry = feature.message();
|
|
} else {
|
|
feature.skip();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
std::ostream& mbgl::operator<<(std::ostream& os, const VectorTileFeature& feature) {
|
|
os << "Feature(" << feature.id << "): " << feature.type << std::endl;
|
|
for (const auto& prop : feature.properties) {
|
|
os << " - " << prop.first << ": " << prop.second << std::endl;
|
|
}
|
|
return os;
|
|
}
|
|
|
|
|
|
VectorTile::VectorTile() {}
|
|
|
|
|
|
VectorTile::VectorTile(pbf tile) {
|
|
while (tile.next()) {
|
|
if (tile.tag == 3) { // layer
|
|
VectorTileLayer layer(tile.message());
|
|
layers.emplace(layer.name, std::forward<VectorTileLayer>(layer));
|
|
} else {
|
|
tile.skip();
|
|
}
|
|
}
|
|
}
|
|
|
|
VectorTile& VectorTile::operator=(VectorTile && other) {
|
|
if (this != &other) {
|
|
layers.swap(other.layers);
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
VectorTileLayer::VectorTileLayer(pbf layer) : data(layer) {
|
|
std::vector<std::string> stacks;
|
|
|
|
while (layer.next()) {
|
|
if (layer.tag == 1) { // name
|
|
name = layer.string();
|
|
} else if (layer.tag == 3) { // keys
|
|
keys.emplace_back(layer.string());
|
|
key_index.emplace(keys.back(), keys.size() - 1);
|
|
} else if (layer.tag == 4) { // values
|
|
values.emplace_back(std::move(parseValue(layer.message())));
|
|
} else if (layer.tag == 5) { // extent
|
|
extent = layer.varint();
|
|
} else {
|
|
layer.skip();
|
|
}
|
|
}
|
|
}
|
|
|
|
FilteredVectorTileLayer::FilteredVectorTileLayer(const VectorTileLayer& layer, const FilterExpression &filterExpression)
|
|
: layer(layer),
|
|
filterExpression(filterExpression) {
|
|
}
|
|
|
|
FilteredVectorTileLayer::iterator FilteredVectorTileLayer::begin() const {
|
|
return iterator(*this, layer.data);
|
|
}
|
|
|
|
FilteredVectorTileLayer::iterator FilteredVectorTileLayer::end() const {
|
|
return iterator(*this, pbf(layer.data.end, 0));
|
|
}
|
|
|
|
FilteredVectorTileLayer::iterator::iterator(const FilteredVectorTileLayer& parent, const pbf& data)
|
|
: parent(parent),
|
|
feature(pbf()),
|
|
data(data) {
|
|
operator++();
|
|
}
|
|
|
|
//bool FilteredVectorTileLayer::iterator::matchesFilterExpression(const FilterExpression &filterExpression, const pbf &tags_pbf) {
|
|
// if (filterExpression.empty()) {
|
|
// return true;
|
|
// }
|
|
//
|
|
//
|
|
//
|
|
//
|
|
// if (filterExpression.is<util::recursive_wrapper<PropertyFilter>>()) {
|
|
// return matchesFilter(filterExpression.get<util::recursive_wrapper<PropertyFilter>>().get(), tags_pbf);
|
|
// } else if (filterExpression.is<util::recursive_wrapper<PropertyExpression>>()) {
|
|
// return matchesExpression(filterExpression.get<util::recursive_wrapper<PropertyExpression>>().get(), tags_pbf);
|
|
// } else if (filterExpression.is<std::true_type>()) {
|
|
// return true;
|
|
// } else {
|
|
// return false;
|
|
// }
|
|
// return true;
|
|
//}
|
|
|
|
//
|
|
//bool FilteredVectorTileLayer::iterator::matchesFilter(const PropertyFilter &filter, const pbf &const_tags_pbf) {
|
|
// auto field_it = parent.layer.key_index.find(filter.field);
|
|
// if (field_it != parent.layer.key_index.end()) {
|
|
// const uint32_t filter_key = field_it->second;
|
|
//
|
|
// // Now loop through all the key/value pair tags.
|
|
// // tags are packed varints. They should have an even length.
|
|
// pbf tags_pbf = const_tags_pbf;
|
|
// while (tags_pbf) {
|
|
// uint32_t tag_key = tags_pbf.varint();
|
|
// if (!tags_pbf) {
|
|
// // This should not happen; otherwise the vector tile
|
|
// // is invalid.
|
|
// throw std::runtime_error("uneven number of feature tag ids");
|
|
// }
|
|
// uint32_t tag_val = tags_pbf.varint();
|
|
//
|
|
// if (tag_key == filter_key) {
|
|
// if (parent.layer.values.size() > tag_val) {
|
|
// const Value &value = parent.layer.values[tag_val];
|
|
// return filter.compare(value);
|
|
// } else {
|
|
// throw std::runtime_error("feature references out of range value");
|
|
// }
|
|
// }
|
|
// }
|
|
// }
|
|
//
|
|
// // The feature doesn't contain the field that we're looking to compare.
|
|
// // Depending on the filter, this may still be okay.
|
|
// return filter.isMissingFieldOkay();
|
|
//}
|
|
//
|
|
//bool FilteredVectorTileLayer::iterator::matchesExpression(const PropertyExpression &expression, const pbf &tags_pbf) {
|
|
// if (expression.op == ExpressionOperator::Or) {
|
|
// for (const PropertyFilterExpression &filterExpression : expression.operands) {
|
|
// if (matchesFilterExpression(filterExpression, tags_pbf)) {
|
|
// return true;
|
|
// }
|
|
// }
|
|
// return false;
|
|
// } else if (expression.op == ExpressionOperator::And) {
|
|
// for (const PropertyFilterExpression &filterExpression : expression.operands) {
|
|
// if (!matchesFilterExpression(filterExpression, tags_pbf)) {
|
|
// return false;
|
|
// }
|
|
// }
|
|
// return true;
|
|
// } else {
|
|
// return false;
|
|
// }
|
|
//}
|
|
//
|
|
|
|
VectorTileTagExtractor::VectorTileTagExtractor(const VectorTileLayer &layer) : layer_(layer) {}
|
|
|
|
|
|
void VectorTileTagExtractor::setTags(const pbf &pbf) {
|
|
tags_ = pbf;
|
|
}
|
|
|
|
std::vector<Value> VectorTileTagExtractor::getValues(const std::string &key) const {
|
|
std::vector<Value> values;
|
|
|
|
auto field_it = layer_.key_index.find(key);
|
|
if (field_it != layer_.key_index.end()) {
|
|
const uint32_t filter_key = field_it->second;
|
|
|
|
// Now loop through all the key/value pair tags.
|
|
// tags are packed varints. They should have an even length.
|
|
pbf tags_pbf = tags_;
|
|
uint32_t tag_key, tag_val;
|
|
while (tags_pbf) {
|
|
tag_key = tags_pbf.varint();
|
|
if (!tags_pbf) {
|
|
// This should not happen; otherwise the vector tile is invalid.
|
|
fprintf(stderr, "[WARNING] uneven number of feature tag ids\n");
|
|
return values;
|
|
}
|
|
// Note: We need to run this command in all cases, even if the keys don't match.
|
|
tag_val = tags_pbf.varint();
|
|
|
|
if (tag_key == filter_key) {
|
|
if (layer_.values.size() > tag_val) {
|
|
values.emplace_back(layer_.values[tag_val]);
|
|
} else {
|
|
fprintf(stderr, "[WARNING] feature references out of range value\n");
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return values;
|
|
}
|
|
|
|
void VectorTileTagExtractor::setType(FilterExpression::GeometryType type) {
|
|
type_ = type;
|
|
}
|
|
|
|
FilterExpression::GeometryType VectorTileTagExtractor::getType() const {
|
|
return type_;
|
|
}
|
|
|
|
void FilteredVectorTileLayer::iterator::operator++() {
|
|
valid = false;
|
|
|
|
const FilterExpression &expression = parent.filterExpression;
|
|
|
|
while (data.next(2)) { // feature
|
|
feature = data.message();
|
|
pbf feature_pbf = feature;
|
|
bool matched = false;
|
|
|
|
// Treat the absence of any expression filters as a match.
|
|
if (expression.empty()) {
|
|
matched = true;
|
|
}
|
|
|
|
if (!matched) {
|
|
VectorTileTagExtractor extractor(parent.layer);
|
|
|
|
// Retrieve the basic information
|
|
while (feature_pbf.next()) {
|
|
if (feature_pbf.tag == 2) { // tags
|
|
extractor.setTags(feature_pbf.message());
|
|
} else if (feature_pbf.tag == 3) { // geometry type
|
|
switch (FeatureType(feature_pbf.varint())) {
|
|
case FeatureType::Point: extractor.setType(FilterExpression::GeometryType::Point); break;
|
|
case FeatureType::LineString: extractor.setType(FilterExpression::GeometryType::LineString); break;
|
|
case FeatureType::Polygon: extractor.setType(FilterExpression::GeometryType::Polygon); break;
|
|
default: break;
|
|
}
|
|
} else {
|
|
feature_pbf.skip();
|
|
}
|
|
}
|
|
|
|
matched = expression.compare(extractor);
|
|
}
|
|
|
|
if (matched) {
|
|
valid = true;
|
|
return; // data loop
|
|
} else {
|
|
valid = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
bool FilteredVectorTileLayer::iterator::operator!=(const iterator& other) const {
|
|
return !(data.data == other.data.data && data.end == other.data.end && valid == other.valid);
|
|
}
|
|
|
|
const pbf& FilteredVectorTileLayer::iterator:: operator*() const {
|
|
return feature;
|
|
}
|