Next (work on vector map rendering and the avalanche layer)

.github/workflows/deploy.yml

@@ -39,7 +39,7 @@ jobs:
         fetch-depth: 0
         fetch-tags: true
 
-    - name: Install Qt native version (the one provided by aqt doesn't seem to work)
+    - name: Install Qt native version (the one provided by aqt does not seem to work)
       uses: jurplel/install-qt-action@v4
       with:
         aqtversion: '==3.1.*'

.github/workflows/linux.yml

@@ -65,16 +65,6 @@ jobs:
         modules: 'qtcharts qtpositioning'
         cache: true
 
-    - name: Debug output
-      shell: bash
-      run: |
-        echo "${{github.workspace}}/qt/Qt/6.8.1":
-        ls ${{github.workspace}}/qt/Qt/6.8.1
-        echo "==="
-        echo "${QT_ROOT_DIR}/lib/cmake/Qt6Linguist:"
-        ls ${QT_ROOT_DIR}/lib/cmake/Qt6Linguist
-        echo "==="
-
     - name: Configure
       env:
         CC: ${{ matrix.CC }}

gl_engine/Texture.cpp

@@ -58,6 +58,8 @@ GlParams gl_tex_params(gl_engine::Texture::Format format)
         return { GL_RG8, GL_RG, GL_UNSIGNED_BYTE, 2, 1, true };
     case F::RG32UI:
         return { GL_RG32UI, GL_RG_INTEGER, GL_UNSIGNED_INT, 2, 4 };
+    case F::RGB32UI:
+        return { GL_RGB32UI, GL_RGB_INTEGER, GL_UNSIGNED_INT, 3, 4 };
     case F::R8UI:
         return { GL_R8UI, GL_RED_INTEGER, GL_UNSIGNED_BYTE, 1, 1 };
     case F::R16UI:
@@ -230,8 +232,9 @@ template <typename T> void gl_engine::Texture::upload(const nucleus::Raster<T>&
 template void gl_engine::Texture::upload<uint8_t>(const nucleus::Raster<uint8_t>&, unsigned);
 template void gl_engine::Texture::upload<uint16_t>(const nucleus::Raster<uint16_t>&, unsigned);
 template void gl_engine::Texture::upload<uint32_t>(const nucleus::Raster<uint32_t>&, unsigned);
-template void gl_engine::Texture::upload<glm::vec<2, uint32_t>>(const nucleus::Raster<glm::vec<2, uint32_t>>&, unsigned);
 template void gl_engine::Texture::upload<glm::vec<2, uint8_t>>(const nucleus::Raster<glm::vec<2, uint8_t>>&, unsigned);
+template void gl_engine::Texture::upload<glm::vec<2, uint32_t>>(const nucleus::Raster<glm::vec<2, uint32_t>>&, unsigned);
+template void gl_engine::Texture::upload<glm::vec<3, uint32_t>>(const nucleus::Raster<glm::vec<3, uint32_t>>&, unsigned);
 template void gl_engine::Texture::upload<glm::vec<4, uint8_t>>(const nucleus::Raster<glm::vec<4, uint8_t>>&, unsigned);
 template void gl_engine::Texture::upload<glm::vec<4, float>>(const nucleus::Raster<glm::vec<4, float>>&, unsigned);
 
@@ -260,6 +263,7 @@ template void gl_engine::Texture::upload<uint8_t>(const nucleus::Raster<uint8_t>
 template void gl_engine::Texture::upload<uint16_t>(const nucleus::Raster<uint16_t>&);
 template void gl_engine::Texture::upload<uint32_t>(const nucleus::Raster<uint32_t>&);
 template void gl_engine::Texture::upload<glm::vec<2, uint32_t>>(const nucleus::Raster<glm::vec<2, uint32_t>>&);
+template void gl_engine::Texture::upload<glm::vec<3, uint32_t>>(const nucleus::Raster<glm::vec<3, uint32_t>>&);
 template void gl_engine::Texture::upload<glm::vec<2, uint8_t>>(const nucleus::Raster<glm::vec<2, uint8_t>>&);
 template void gl_engine::Texture::upload<glm::vec<4, uint8_t>>(const nucleus::Raster<glm::vec<4, uint8_t>>&);
 template void gl_engine::Texture::upload<glm::vec<4, float>>(const nucleus::Raster<glm::vec<4, float>>&);

gl_engine/Texture.h

@@ -39,6 +39,7 @@ class Texture {
         RGBA32F,
         RG8, // normalised on gpu
         RG32UI,
+        RGB32UI,
         R8UI,
         R16UI,
         R32UI,
@@ -84,7 +85,12 @@ class Texture {
 extern template void gl_engine::Texture::upload<uint16_t>(const nucleus::Raster<uint16_t>&);
 extern template void gl_engine::Texture::upload<uint32_t>(const nucleus::Raster<uint32_t>&);
 extern template void gl_engine::Texture::upload<glm::vec<2, uint32_t>>(const nucleus::Raster<glm::vec<2, uint32_t>>&);
+extern template void gl_engine::Texture::upload<glm::vec<3, uint32_t>>(const nucleus::Raster<glm::vec<3, uint32_t>>&);
 extern template void gl_engine::Texture::upload<glm::vec<2, uint8_t>>(const nucleus::Raster<glm::vec<2, uint8_t>>&);
 extern template void gl_engine::Texture::upload<glm::vec<4, uint8_t>>(const nucleus::Raster<glm::vec<4, uint8_t>>&);
 
+extern template void gl_engine::Texture::upload<uint32_t>(const nucleus::Raster<uint32_t>&, unsigned int);
+extern template void gl_engine::Texture::upload<glm::vec<2, uint32_t>>(const nucleus::Raster<glm::vec<2, uint32_t>>&, unsigned int);
+extern template void gl_engine::Texture::upload<glm::vec<3, uint32_t>>(const nucleus::Raster<glm::vec<3, uint32_t>>&, unsigned int);
+
 } // namespace gl_engine

nucleus/CMakeLists.txt

@@ -29,6 +29,7 @@ if(ALP_ENABLE_LABELS)
     alp_add_git_repository(vector_tiles URL https://github.com/AlpineMapsOrg/vector-tile.git COMMITISH faba88257716c4bc01ebd44d8b8b98f711ecb78c)
 endif()
 alp_add_git_repository(goofy_tc URL https://github.com/AlpineMapsOrgDependencies/Goofy_slim.git COMMITISH 13b228784960a6227bb6ca704ff34161bbac1b91 DO_NOT_ADD_SUBPROJECT)
+alp_add_git_repository(cdt URL https://github.com/artem-ogre/CDT.git COMMITISH 46f1ce1f495a97617d90e8c833d0d29406335fdf DO_NOT_ADD_SUBPROJECT)
 
 add_library(zppbits INTERFACE)
 target_include_directories(zppbits SYSTEM INTERFACE ${zppbits_SOURCE_DIR})
@@ -40,6 +41,9 @@ set_target_properties(goofy_tc PROPERTIES SYSTEM true)
 add_library(tl_expected INTERFACE)
 target_include_directories(tl_expected INTERFACE ${tl_expected_SOURCE_DIR}/include)
 
+add_library(cdt INTERFACE)
+target_include_directories(cdt INTERFACE ${cdt_SOURCE_DIR}/CDT/include)
+
 set(alp_version_out ${CMAKE_BINARY_DIR}/alp_version/nucleus/version.cpp)
 
 # cmake tests for existance of ${alp_version_out}.do_always_run. since it's always missing, cmake tries to generate it using this command.
@@ -113,6 +117,7 @@ qt_add_library(nucleus STATIC
     tile/GeometryScheduler.h tile/GeometryScheduler.cpp
     utils/error.h
     utils/lang.h
+    utils/rasterizer.h utils/rasterizer.cpp
     tile/SchedulerDirector.h tile/SchedulerDirector.cpp
     tile/drawing.h tile/drawing.cpp
     camera/gesture.h
@@ -147,7 +152,7 @@ endif()
 
 target_include_directories(nucleus PUBLIC ${CMAKE_SOURCE_DIR})
 # Please keep Qt::Gui outside the nucleus. If you need it optional via a cmake based switch
-target_link_libraries(nucleus PUBLIC radix Qt::Core Qt::Network zppbits tl_expected nucleus_version stb_slim goofy_tc)
+target_link_libraries(nucleus PUBLIC radix Qt::Core Qt::Network zppbits tl_expected nucleus_version stb_slim goofy_tc cdt)
 
 qt_add_resources(nucleus "icons"
     PREFIX "/map_icons"

nucleus/tile/conversion.h

@@ -115,4 +115,38 @@ inline glm::u8vec4 uint162alpineRGBA(uint16_t v)
 {
     return { v >> 8, v & 255, 0, 255 };
 }
+
+inline QImage u8raster_to_qimage(const nucleus::Raster<uint8_t>& raster)
+{
+    size_t width = raster.width();
+    size_t height = raster.height();
+
+    QImage image(width, height, QImage::Format_Grayscale8);
+
+    for (size_t y = 0; y < height; ++y) {
+        uchar* line = image.scanLine(y);
+        for (size_t x = 0; x < width; ++x) {
+            line[x] = raster.pixel({ x, y });
+        }
+    }
+
+    return image;
+}
+
+inline QImage u8raster_2_to_qimage(const nucleus::Raster<uint8_t>& raster1, const nucleus::Raster<uint8_t>& raster2)
+{
+    size_t width = raster1.width();
+    size_t height = raster1.height();
+
+    QImage image(width, height, QImage::Format_RGB888);
+
+    for (size_t y = 0; y < height; ++y) {
+        for (size_t x = 0; x < width; ++x) {
+            image.setPixel(QPoint(x, y), (raster1.pixel({ x, y }) << 16) + (raster2.pixel({ x, y }) << 8));
+        }
+    }
+
+    return image;
+}
+
 } // namespace nucleus::tile::conversion

nucleus/utils/rasterizer.cpp

@@ -0,0 +1,103 @@
+/*****************************************************************************
+ * AlpineMaps.org
+ * Copyright (C) 2024 Lucas Dworschak
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *****************************************************************************/
+
+#include "rasterizer.h"
+
+#include <CDT.h>
+
+namespace nucleus::utils::rasterizer {
+
+std::vector<glm::ivec2> generate_neighbour_edges(std::vector<glm::vec2> polygon_points, const size_t start_offset)
+{
+    std::vector<glm::ivec2> edges;
+    { // create the edges
+        edges.reserve(polygon_points.size());
+        for (size_t i = 0; i < polygon_points.size() - 1; i++) {
+            edges.push_back(glm::ivec2(start_offset + int(i), start_offset + int(i + 1)));
+        }
+
+        // last edge between start and end vertex
+        edges.push_back(glm::ivec2(start_offset + polygon_points.size() - 1, start_offset));
+    }
+
+    return edges;
+}
+
+std::vector<glm::vec2> triangulize(std::vector<glm::vec2> polygon_points, std::vector<glm::ivec2> edges, bool remove_duplicate_vertices)
+{
+    std::vector<glm::vec2> processed_triangles;
+
+    // triangulation
+    CDT::Triangulation<double> cdt;
+
+    if (remove_duplicate_vertices) {
+        CDT::RemoveDuplicatesAndRemapEdges<double>(
+            polygon_points,
+            [](const glm::vec2& p) { return p.x; },
+            [](const glm::vec2& p) { return p.y; },
+            edges.begin(),
+            edges.end(),
+            [](const glm::ivec2& p) { return p.x; },
+            [](const glm::ivec2& p) { return p.y; },
+            [](CDT::VertInd start, CDT::VertInd end) { return glm::ivec2 { start, end }; });
+    }
+
+    cdt.insertVertices(polygon_points.begin(), polygon_points.end(), [](const glm::vec2& p) { return p.x; }, [](const glm::vec2& p) { return p.y; });
+    cdt.insertEdges(edges.begin(), edges.end(), [](const glm::ivec2& p) { return p.x; }, [](const glm::ivec2& p) { return p.y; });
+    cdt.eraseOuterTrianglesAndHoles();
+
+    // fill our own data structures
+    for (size_t i = 0; i < cdt.triangles.size(); ++i) {
+        auto tri = cdt.triangles[i];
+
+        std::vector<size_t> tri_indices = { tri.vertices[0], tri.vertices[1], tri.vertices[2] };
+
+        int top_index = (cdt.vertices[tri.vertices[0]].y < cdt.vertices[tri.vertices[1]].y) ? ((cdt.vertices[tri.vertices[0]].y < cdt.vertices[tri.vertices[2]].y) ? 0 : 2)
+                                                                                            : ((cdt.vertices[tri.vertices[1]].y < cdt.vertices[tri.vertices[2]].y) ? 1 : 2);
+        // for middle and bottom index we first initialize them randomly with the values that still need to be tested
+        int middle_index;
+        int bottom_index;
+        if (top_index == 0) {
+            middle_index = 1;
+            bottom_index = 2;
+        } else if (top_index == 1) {
+            middle_index = 2;
+            bottom_index = 0;
+        } else {
+            middle_index = 0;
+            bottom_index = 1;
+        }
+
+        // and now we test if we assigned them correctly
+        if (cdt.vertices[tri.vertices[middle_index]].y > cdt.vertices[tri.vertices[bottom_index]].y) {
+            // if not we have to interchange them
+            int tmp = middle_index;
+            middle_index = bottom_index;
+            bottom_index = tmp;
+        }
+
+        // lastly add the vertices to the vector in the correct order
+        processed_triangles.push_back({ cdt.vertices[tri.vertices[top_index]].x, cdt.vertices[tri.vertices[top_index]].y });
+        processed_triangles.push_back({ cdt.vertices[tri.vertices[middle_index]].x, cdt.vertices[tri.vertices[middle_index]].y });
+        processed_triangles.push_back({ cdt.vertices[tri.vertices[bottom_index]].x, cdt.vertices[tri.vertices[bottom_index]].y });
+    }
+
+    return processed_triangles;
+}
+
+} // namespace nucleus::utils::rasterizer