Dag builder

cmake/SetupCMakeProject.cmake

@@ -37,7 +37,7 @@ function(_alp_build_and_install NAME SRC_DIR BUILD_DIR INSTALL_DIR)
                 "-DCMAKE_EXE_LINKER_FLAGS=${CMAKE_EXE_LINKER_FLAGS} ${_alp_sanitizer_flags}"
                 "-DCMAKE_MODULE_LINKER_FLAGS=${CMAKE_MODULE_LINKER_FLAGS} ${_alp_sanitizer_flags}"
                 "-DCMAKE_SHARED_LINKER_FLAGS=${CMAKE_SHARED_LINKER_FLAGS} ${_alp_sanitizer_flags}"
-                -DCMAKE_PREFIX_PATH=${CMAKE_PREFIX_PATH}
+                "-DCMAKE_PREFIX_PATH=${CMAKE_PREFIX_PATH}"
                 -DCMAKE_INSTALL_PREFIX=${INSTALL_DIR}
                 -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}
                 ${ARGN}

src/CMakeLists.txt

@@ -16,7 +16,7 @@ find_package(TBB REQUIRED)
 include(../cmake/SetupGDAL.cmake)
 alp_setup_gdal(GDAL_VERSION v3.10.3 PROJ_VERSION 9.6.0)
 
-alp_setup_cmake_project(cgal URL https://github.com/CGAL/cgal.git COMMITISH "v6.0.1" CMAKE_ARGUMENTS -DCGAL_HEADER_ONLY=ON -DBUILD_TESTING=OFF -DBUILD_EXAMPLES=OFF)
+alp_setup_cmake_project(cgal URL https://github.com/CGAL/cgal.git COMMITISH "v6.0.1" CMAKE_ARGUMENTS -DBUILD_TESTING=OFF -DWITH_examples=OFF)
 find_package(CGAL REQUIRED)
 
 include(../cmake/SetupOpenCV.cmake)

src/dag_builder/ContinuationMode.h

@@ -1,7 +1,7 @@
 #pragma once
 
 enum class ContinuationMode {
+    Error,
     Resume,
     Overwrite,
-    Fail
 };

src/dag_builder/Partitioning.h

@@ -0,0 +1,10 @@
+#pragma once
+
+#include <cstdint>
+#include <vector>
+
+
+struct [[nodiscard]] Partitioning {
+    uint32_t partition_count = 0;
+    std::vector<uint32_t> cluster_partitions; // original cluster index -> partition index
+};

src/dag_builder/VertexInCluster.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include <cstdint>
+
+#include "hash_utils.h"
+
+struct VertexInCluster {
+    uint32_t cluster_index;
+    uint32_t local_vertex_index;
+
+    auto operator<=>(const VertexInCluster &other) const = default;
+};
+
+namespace std {
+    template <>
+    struct hash<VertexInCluster> {
+        size_t operator()(const VertexInCluster &v) const noexcept {
+            return ::hash::combine(v.cluster_index, v.local_vertex_index);
+        }
+    };
+}

src/dag_builder/VertexInClustering.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include <cstdint>
+
+#include "hash_utils.h"
+
+struct VertexInClustering {
+    uint32_t clustering_index;
+    uint32_t global_vertex_index;
+
+    auto operator<=>(const VertexInClustering &other) const = default;
+};
+
+namespace std {
+template <>
+struct hash<VertexInClustering> {
+    size_t operator()(const VertexInClustering &v) const noexcept {
+        return ::hash::combine(v.clustering_index, v.global_vertex_index);
+    }
+};
+} // namespace std

src/dag_builder/atlas/Packer.cpp

@@ -4,6 +4,7 @@
 
 #include <xatlas/xatlas.h>
 #include <glm/glm.hpp>
+#include <glm/gtx/component_wise.hpp>
 
 #include "log.h"
 #include "Packer.h"
@@ -37,10 +38,13 @@ inline void normalize_uvs(std::span<glm::dvec2> uvs) {
 
 struct Packer::Impl {
     std::unique_ptr<xatlas::Atlas, decltype(&xatlas::Destroy)> atlas;
+    double total_effective_pixel_area = 0.0;
 
     Impl() : atlas(xatlas::Create(), xatlas::Destroy) {}
 
     void add_uv_mesh(const UvMesh& mesh) {
+        this->total_effective_pixel_area += glm::compMul(glm::dvec2(mesh.texture_size));
+
         std::vector<glm::vec2> scaled_uvs = transform_vector(mesh.uvs, [&](const glm::dvec2 &uv) {
             const glm::dvec2 scaled = uv * glm::dvec2(mesh.texture_size);
             return glm::vec2(scaled);
@@ -87,9 +91,7 @@ struct Packer::Impl {
 
         normalize_uvs(uvs.flat());
 
-        // TODO: return atlas->width and atlas->height or aspect?
-
-        return Packing(uvs);
+        return Packing(uvs, this->atlas->utilization[0]);
     }
 };
 

src/dag_builder/atlas/Packer.h

@@ -1,9 +1,13 @@
 #pragma once
 
+#include <algorithm>
+#include <cmath>
+#include <cstdint>
 #include <span>
 
 #include <glm/glm.hpp>
 
+#include "number_utils.h"
 #include "SegmentedBuffer.h"
 
 namespace atlas {
@@ -17,8 +21,10 @@ struct UvMesh {
 class Packing {
 public:
     Packing() = default;
-    Packing(std::vector<glm::dvec2> uvs) : Packing(SegmentedBuffer<glm::dvec2>(std::move(uvs))) {}
-    Packing(SegmentedBuffer<glm::dvec2> uvs) : _uvs(std::move(uvs)) {}
+    Packing(std::vector<glm::dvec2> uvs, const double effective_pixel_area, const float utilization = 1.0f)
+        : Packing(SegmentedBuffer<glm::dvec2>(std::move(uvs)), effective_pixel_area, utilization) {}
+    Packing(SegmentedBuffer<glm::dvec2> uvs, const double effective_pixel_area, const float utilization = 1.0f)
+        : _uvs(std::move(uvs)), _effective_pixel_area(effective_pixel_area), _utilization(utilization) {}
 
     std::span<const glm::dvec2> uvs_for_mesh(const uint32_t mesh_index) const {
         return this->_uvs.segment(mesh_index);
@@ -31,8 +37,22 @@ class Packing {
         return this->_uvs.backing();
     }
 
+    // Sum of effective input pixels (source-texture pixels actually covered by UVs) across all packed meshes.
+    double effective_pixel_area() const {
+        return this->_effective_pixel_area;
+    }
+
+    // Fraction of the packed atlas actually covered by charts. 1.0 for
+    // packings that were not produced by the chart packer (e.g. a single
+    // mesh's own UVs), since there is no wasted atlas space to account for.
+    float utilization() const {
+        return this->_utilization;
+    }
+
 private:
     SegmentedBuffer<glm::dvec2> _uvs;
+    double _effective_pixel_area = 0.0;
+    float _utilization = 1.0f;
 };
 
 class Packer {

src/dag_builder/atlas/TextureBaker.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <algorithm>
 #include <cmath>
 #include <functional>
 #include <cstddef>
@@ -12,10 +13,12 @@
 
 #include <opencv2/opencv.hpp>
 #include <glm/glm.hpp>
+#include <glm/gtx/component_wise.hpp>
 
 #include "atlas/Packer.h"
 #include "atlas/pull_reproject_texture.h"
 #include "mesh/bounds.h"
+#include "number_utils.h"
 #include "opencv_utils.h"
 #include "range_utils.h"
 #include "TextureSet.h"
@@ -84,13 +87,25 @@ inline glm::uvec2 get_effective_texture_size(const TextureMap &map) {
 inline glm::uvec2 get_effective_texture_size(const TextureComposition &comp) {
     double area = 0;
     for (const auto &map : comp.maps) {
-        const auto size = get_effective_texture_size(map);
-        area += size.x * size.y;
+        area += glm::compMul(glm::dvec2(get_effective_texture_size(map)));
     }
     return glm::uvec2(std::ceil(std::sqrt(area)));
 }
 } // namespace detail
 
+// Resolution needed to give a compression_ratio fraction of effective_pixel_area
+// worth of resolution, after accounting for atlas packing waste (unused texels
+// between packed charts), capped at max_texture_size.
+inline glm::uvec2 compute_bake_texture_size(const double effective_pixel_area, const float utilization, const double compression_ratio, const uint32_t max_texture_size) {
+    const double target_area = effective_pixel_area * compression_ratio / std::max<double>(utilization, 1e-3);
+    const uint32_t side = static_cast<uint32_t>(std::ceil(std::sqrt(target_area)));
+    return glm::uvec2(std::min(next_power_of_two(side), max_texture_size));
+}
+
+inline glm::uvec2 compute_bake_texture_size(const atlas::Packing &packing, const double compression_ratio, const uint32_t max_texture_size) {
+    return compute_bake_texture_size(packing.effective_pixel_area(), packing.utilization(), compression_ratio, max_texture_size);
+}
+
 class TextureBaker {
 public:
     TextureMapId add_mesh(TexturedMesh mesh) {
@@ -128,36 +143,72 @@ class TextureBaker {
         return id;
     }
 
-    TextureCake bake(const glm::uvec2 texture_size) {
+    // Exact output resolution.
+    TextureCake bake(const glm::uvec2 texture_size) const {
+        return this->bake(this->pack(), texture_size);
+    }
+
+    // Runs atlas packing (chart computation for multi-mesh atlases; a cheap
+    // passthrough for a single entry). Callers that need packing.utilization()
+    // or packing.effective_pixel_area() to choose an output resolution should
+    // call this once and pass the result to bake(packing, texture_size) below,
+    // rather than letting bake(texture_size) compute it again.
+    atlas::Packing pack() const {
         if (this->_entries.size() == 1) {
-            return this->bake_single(this->_entries.front(), texture_size);
-        } else {
-            return this->bake_multi(texture_size);
+            return this->pack_single(this->_entries.front());
+        }
+
+        atlas::Packer packer;
+
+        std::vector<glm::uvec3> target_triangles;
+        for (const Entry& entry : this->_entries) {
+            visit_entry(entry,
+                [&](const TexturedMesh& mesh) {
+                    packer.add_uv_mesh(mesh.triangles, mesh.map.uvs, detail::get_effective_texture_size(mesh.map));
+                },
+                [&](const TextureComposition& comp) {
+                    target_triangles.clear();
+                    target_triangles.reserve(comp.triangles.size());
+                    for (const MappedTriangle &triangle : comp.triangles) {
+                        target_triangles.push_back(triangle.target);
+                    }
+                    packer.add_uv_mesh(
+                        target_triangles,
+                        comp.target_uvs,
+                        detail::get_effective_texture_size(comp)
+                    );
+                });
         }
+
+        return packer.pack();
     }
 
-private:
-    using Entry = std::variant<TexturedMesh, TextureComposition>;
+    // Bakes using an already-computed packing (e.g. from pack()), so no atlas repacking happens.
+    TextureCake bake(const atlas::Packing &packing, const glm::uvec2 texture_size) const {
+        if (this->_entries.size() == 1) {
+            return visit_entry<TextureCake>(this->_entries.front(),
+                [&](const TexturedMesh &mesh) {
+                    TextureCake cake;
+                    cake._packing = packing;
+                    cake._texture = rescale_texture(mesh.map.texture, texture_size);
+                    return cake;
+                },
+                [&](const TextureComposition &) {
+                    TextureCake cake;
+                    cake._packing = packing;
+                    cake._texture = this->bake_texture(cake._packing, texture_size);
+                    return cake;
+                });
+        }
 
-    TextureCake bake_multi(const glm::uvec2 texture_size) const {
         TextureCake cake;
-        cake._packing = this->pack();
+        cake._packing = packing;
         cake._texture = this->bake_texture(cake._packing, texture_size);
         return cake;
     }
 
-    TextureCake bake_single(const Entry &entry, const glm::uvec2 texture_size) const {
-        return visit_entry<TextureCake>(entry,
-            [&](const TexturedMesh &mesh) {
-                TextureCake cake;
-                cake._packing = this->pack_single(mesh);
-                cake._texture = rescale_texture(mesh.map.texture, texture_size);
-                return cake;
-            },
-            [&](const TextureComposition &) {
-                return this->bake_multi(texture_size);
-            });
-    }
+private:
+    using Entry = std::variant<TexturedMesh, TextureComposition>;
 
     Texture bake_texture(const atlas::Packing &packing, const glm::uvec2 texture_size) const {
         TextureReprojector reprojector(texture_size, CV_8UC3);
@@ -233,43 +284,24 @@ class TextureBaker {
     }
 
     atlas::Packing pack_single(const Entry &entry) const {
+        const double area = effective_pixel_area(entry);
         return visit_entry<atlas::Packing>(entry,
             [&](const TexturedMesh &mesh) {
-                return atlas::Packing(mesh.map.uvs);
+                return atlas::Packing(mesh.map.uvs, area);
             },
             [&](const TextureComposition &comp) {
-                return atlas::Packing(comp.target_uvs);
+                return atlas::Packing(comp.target_uvs, area);
             });
     }
 
-    atlas::Packing pack() const {
-        if (this->_entries.size() == 1) {
-            return this->pack_single(this->_entries.front());
-        }
-
-        atlas::Packer packer;
-
-        std::vector<glm::uvec3> target_triangles;
-        for (const Entry& entry : this->_entries) {
-            visit_entry(entry,
-                [&](const TexturedMesh& mesh) {
-                    packer.add_uv_mesh(mesh.triangles, mesh.map.uvs, detail::get_effective_texture_size(mesh.map));
-                },
-                [&](const TextureComposition& comp) {
-                    target_triangles.clear();
-                    target_triangles.reserve(comp.triangles.size());
-                    for (const MappedTriangle &triangle : comp.triangles) {
-                        target_triangles.push_back(triangle.target);
-                    }
-                    packer.add_uv_mesh(
-                        target_triangles,
-                        comp.target_uvs,
-                        detail::get_effective_texture_size(comp)
-                    );
-                });
-        }
-
-        return packer.pack();
+    static double effective_pixel_area(const Entry &entry) {
+        return visit_entry<double>(entry,
+            [](const TexturedMesh &mesh) {
+                return glm::compMul(glm::dvec2(detail::get_effective_texture_size(mesh.map)));
+            },
+            [](const TextureComposition &comp) {
+                return glm::compMul(glm::dvec2(detail::get_effective_texture_size(comp)));
+            });
     }
 
     template <class R = void, class MeshFn, class CompFn>