VectorLayer - Task AlpineMapsOrg#182

- osm-bright and qwant styles are now parsed and displayed
- qwant style generates too many indices, and does not fit into indexbuffer cascades when drawing vienna -> will most likely solve itself after index buffer refactor

Author: LucasDworschak

app/vectorlayerstyles/osm-bright.json

@@ -333,7 +333,6 @@
       "metadata": {"mapbox:group": "1444849382550.77"},
       "source": "openmaptiles",
       "source-layer": "water",
-      "filter": ["all"],
       "layout": {"visibility": "visible"},
       "paint": {"fill-pattern": "wave", "fill-translate": [0, 2.5]}
     },

gl_engine/shaders/vector_layer.frag

@@ -314,7 +314,12 @@ void main() {
     highp uvec2 offset_size = uvec2(0u);
 
     lowp float pixel_alpha = 0.0;
-    texout_albedo = vec3(242.0f/255.0f, 239.0f/255.0f, 233.0f/255.0f);
+    // openmaptile
+    // texout_albedo = vec3(242.0f/255.0f, 239.0f/255.0f, 233.0f/255.0f);
+    // qwant
+    // texout_albedo = vec3(248.0f/255.0f, 248.0f/255.0f, 248.0f/255.0f);
+    // osm-bright
+    texout_albedo = vec3(248.0f/255.0f, 244.0f/255.0f, 240.0f/255.0f);
 
 
 

nucleus/vector_layer/Scheduler.cpp

@@ -29,6 +29,7 @@ Scheduler::Scheduler(std::string name, QObject* parent)
     // , m_style(":/vectorlayerstyles/basemap.json")
     , m_style(":/vectorlayerstyles/openstreetmap.json")
 // , m_style(":/vectorlayerstyles/qwant.json")
+// , m_style(":/vectorlayerstyles/osm-bright.json")
 {
     connect(&m_style, &Style::load_finished, this, &Scheduler::enable_scheduler);
 }

nucleus/vector_layer/Style.cpp

@@ -115,6 +115,8 @@ void Style::load()
                 s.outline_dash = parse_dasharray(paintObject.value(key).toArray());
             } else if (key == "line-offset") {
                 // might be needed
+            } else if (key == "fill-translate" || key == "line-translate-anchor") {
+                // currentley not supported
             } else if (key == "fill-pattern") {
                 // currently not supported -> causes errors when parsed
                 invalid = true;
@@ -321,7 +323,7 @@ uint32_t Style::parse_color(const QJsonValue& value)
 
         uint8_t a = 255;
         if (matches.size() == 5 && matches[4].length() > 0) {
-            a = std::stod(matches[4]) * 255.0;
+            a = stringToFloat(matches[4]) * 255.0;
         }
 
         // formula from https://www.rapidtables.com/convert/color/hsl-to-rgb.html

nucleus/vector_layer/StyleExpander.cpp

@@ -172,8 +172,9 @@ SubLayerInfo generate_expanded_filters(const QJsonObject& paint, const QJsonArra
             }
         }
     } else {
-        // no all -> only save the current instance as the sub filter
-        sub_filter.push_back(filter);
+        // no all -> only save the current instance as the sub filter (only if there is a filter)
+        if (!filter.isEmpty())
+            sub_filter.push_back(filter);
 
         if (filter.contains("in")) {
             in_filter_index = 0;
@@ -296,7 +297,9 @@ SubLayerInfo generate_expanded_filters(const QJsonObject& paint, const QJsonArra
 
 QJsonArray rejoin_filter(std::vector<QJsonArray> filters)
 {
-    assert(filters.size() > 0);
+    if (filters.size() == 0) {
+        return {};
+    }
 
     if (filters.size() == 1) {
         // just one element -> we can just use it without changing anything

nucleus/vector_layer/StyleExpression.cpp

@@ -24,6 +24,16 @@
 
 namespace nucleus::vector_layer {
 
+QJsonValue StyleExpressionBase::extract_literal(QJsonValue expression)
+{
+    assert(expression.isArray());
+    assert(expression.toArray()[0].isString());
+    assert(expression.toArray()[0].toString() == "literal");
+    assert(expression.toArray().size() == 2);
+
+    return expression.toArray()[1];
+}
+
 std::unique_ptr<StyleExpressionBase> StyleExpressionBase::create_filter_expression(QJsonArray data)
 {
     if (data.isEmpty())
@@ -73,9 +83,28 @@ StyleExpression::StyleExpression(QJsonArray data)
     // values
     if (m_comparator == "in" || m_comparator == "!in") {
         // multiple values
-        for (qsizetype i = 2; i < data.size(); ++i) {
-            m_values.push_back(data[i].toString().toStdString());
+        if (data.size() == 3 && data[2].isArray()) {
+            // we most likely have a "literal" sub array
+            const auto values = extract_literal(data[2]).toArray();
+
+            for (qsizetype i = 0; i < values.size(); ++i) {
+                assert(values[i].isString());
+                m_values.push_back(values[i].toString().toStdString());
+            }
+
+        } else {
+            for (qsizetype i = 2; i < data.size(); ++i) {
+                if (data[i].isDouble()) {
+                    m_values.push_back(std::to_string(data[i].toDouble()));
+                } else if (data[i].isString()) {
+                    m_values.push_back(data[i].toString().toStdString());
+                } else {
+                    qDebug() << "invalid data: " << data[i];
+                    assert(false);
+                }
+            }
         }
+
     } else if (m_comparator == "has" || m_comparator == "!has") {
         // no values for has expressions -> we only check if key is present
         if (data.size() > 2) {
@@ -103,8 +132,8 @@ bool compare_equal(int64_t) { return true; }
 
 bool StyleExpression::matches(const mapbox::vector_tile::GeomType& type, const mapbox::feature::properties_type& properties)
 {
-    mapbox::feature::value value = extract_value(type, properties);
     // qDebug() << "match: " << m_key;
+    mapbox::feature::value value = extract_value(type, properties);
 
     if (m_comparator == "in" || m_comparator == "!in") {
         const auto string_value = std::visit(vector_tile::util::string_print_visitor, value).toStdString(); // we are only using the value to see if it is in a list -> string is sufficient
@@ -161,21 +190,29 @@ StyleExpressionCollection::StyleExpressionCollection(QJsonArray data)
     m_subFilters = std::vector<std::unique_ptr<StyleExpressionBase>>();
 
     for (qsizetype i = 1; i < data.size(); ++i) {
-        if (data[i].isArray())
+        if (data[i].isArray()) {
+            if (data[i].toArray().isEmpty()) {
+                qDebug() << "empty array";
+                assert(false);
+            }
             m_subFilters.push_back(create_filter_expression(data[i].toArray()));
-        else
+        } else {
             qDebug() << "not an array??";
+            assert(false);
+        }
     }
 }
 
 bool StyleExpressionCollection::matches(const mapbox::vector_tile::GeomType& type, const mapbox::feature::properties_type& properties)
 {
     if (m_negate) {
+        assert(m_subFilters.size() == 1);
         // negate should only handle one subfilter -> get the match and negate it
         return !m_subFilters[0]->matches(type, properties);
     }
 
     for (size_t i = 0; i < m_subFilters.size(); ++i) {
+        assert(m_subFilters[i] != nullptr);
         bool result = m_subFilters[i]->matches(type, properties);
         if (m_all && !result) {
             return false; // the current match was false but all had to be true

nucleus/vector_layer/StyleExpression.h

@@ -47,6 +47,7 @@ class StyleExpressionBase {
     virtual bool matches(const mapbox::vector_tile::GeomType& type, const mapbox::feature::properties_type& properties) = 0;
 
     static std::unique_ptr<StyleExpressionBase> create_filter_expression(QJsonArray data);
+    QJsonValue extract_literal(QJsonValue expression);
 };
 
 class StyleExpression : public StyleExpressionBase {

nucleus/vector_layer/StyleFilter.cpp

@@ -45,15 +45,26 @@ std::vector<std::pair<uint32_t, uint32_t>> StyleFilter::indices(unsigned zoom, c
     auto styles = std::vector<std::pair<uint32_t, uint32_t>>();
 
     for (const auto& values : m_filter.at(zoom)) {
+        // qDebug() << (std::get<2>(values) == nullptr);
         if (std::get<2>(values) == nullptr) // no filter is here -> we assume that every feature with layername and zoom is valid
         {
-            assert(m_filter.at(zoom).size() == 1); // if there is no filter -> there should only be one valid value
+            // if (m_filter.at(zoom).size() > 1) {
+            //     qDebug() << "more than one filter is applicable: " << m_filter.at(zoom).size();
+            //     qDebug() << std::get<0>(values);
+            //     qDebug() << std::get<1>(values);
+            // }
+            // assert(m_filter.at(zoom).size() == 1); // if there is no filter -> there should only be one valid value
             styles.push_back(std::make_pair(std::get<0>(values), std::get<1>(values)));
+            // if (m_filter.at(zoom).size() > 1) {
+            //     qDebug() << "why not working?: " << m_filter.at(zoom).size();
+            // }
         } else if (std::get<2>(values)->matches(type, properties)) {
-            styles.push_back(std::make_pair(std::get<0>(values), std::get<1>(values))); // first filter that matches returns the indices
+            styles.push_back(std::make_pair(std::get<0>(values), std::get<1>(values)));
         }
     }
 
+    // qDebug() << "return style!";
+
     return styles;
 }