fix(core)!: prevent holes during SVG generation

Dockerfile.dev

@@ -81,6 +81,7 @@ ENV EMSDK=$EMSDK_DIR
 # Auto-load emsdk in all shells
 RUN echo "source /opt/emsdk/emsdk_env.sh" >> /etc/bash.bashrc
 
+RUN chown -R dev:dev /opt/emsdk/
 # --------------------------------------------------------------------------------------------------------------
 # Dawn dependencies
 RUN --mount=type=cache,target=/var/cache/apt,sharing=locked \

bindings/c/include/cimg2num.h

@@ -42,6 +42,7 @@ typedef struct img2num_ImageToSvgConfig {
 
     /// Minimum area (in pixels) for a region to be included in the SVG.
     int min_cluster_area;
+    int min_thickness;
 
     /// Color space flag.
     /// - 0 = CIE LAB (more perceptually accurate)
@@ -80,10 +81,8 @@ void img2num_bilateral_filter(
 );
 
 /// @copydoc ::IMG2NUM_H_LABELS_TO_SVG_DOC
-char* img2num_labels_to_svg(
-    const uint8_t* data, const int32_t* labels, const int width, const int height,
-    const int min_area
-);
+char *img2num_labels_to_svg(const uint8_t *data, const int32_t *labels, const int width,
+                            const int height, const int min_area, const int min_thickness);
 
 /// @copydoc ::IMG2NUM_H_IMAGE_TO_SVG_DOC
 char* img2num_image_to_svg(

bindings/c/src/cimg2num.cpp

@@ -21,6 +21,7 @@ static img2num::ImageToSvgConfig to_cpp(const img2num_ImageToSvgConfig& c) {
         },
 
         .min_cluster_area = c.min_cluster_area,
+        .min_thickness = c.min_thickness,
         .color_space = c.color_space
     };
     // clang-format on
@@ -38,6 +39,7 @@ static img2num_ImageToSvgConfig to_c(const img2num::ImageToSvgConfig& cpp) {
             .max_iter = cpp.kmeans.max_iter
         },
         .min_cluster_area = cpp.min_cluster_area,
+        .min_thickness = cpp.min_thickness,
         .color_space = cpp.color_space
     };
     // clang-format on
@@ -90,22 +92,19 @@ void img2num_bilateral_filter(
     );
 }
 
-char* img2num_labels_to_svg(
-    const uint8_t* data, const int32_t* labels, const int width, const int height,
-    const int min_area
-) {
-    char* result {nullptr};
+char *img2num_labels_to_svg(const uint8_t *data, const int32_t *labels, const int width,
+                            const int height, const int min_area, const int min_thickness) {
+    char *result{nullptr};
     img2num::clear_last_error_and_catch(
-        [&](const uint8_t* d, const int32_t* l, const int w, const int h, const int min_a) {
-            std::string svg {img2num::labels_to_svg(d, l, w, h, min_a)};
-            result = static_cast<char*>(std::malloc(svg.size() + 1));
+        [&](const uint8_t *d, const int32_t *l, const int w, const int h, const int min_a, const int min_t) {
+            std::string svg{img2num::labels_to_svg(d, l, w, h, min_a, min_t)};
+            result = static_cast<char *>(std::malloc(svg.size() + 1));
             if (!result) {
                 return; // Allocation failed
             }
             std::memcpy(result, svg.c_str(), svg.size() + 1);
         },
-        data, labels, width, height, min_area
-    );
+        data, labels, width, height, min_area, min_thickness);
     return result;
 }
 

bindings/js/src/wasm_wrapper.c

@@ -34,24 +34,23 @@ EMSCRIPTEN_KEEPALIVE void bilateral_filter(
     img2num_bilateral_filter(image, width, height, sigma_spatial, sigma_range, color_space);
 }
 
-EMSCRIPTEN_KEEPALIVE char* labels_to_svg(
-    uint8_t* data, int32_t* labels, const int width, const int height, const int min_area
-) {
-    return img2num_labels_to_svg(data, labels, width, height, min_area);
+EMSCRIPTEN_KEEPALIVE char *labels_to_svg(uint8_t *data, int32_t *labels, const int width,
+                                         const int height, const int min_area, const int min_thickness) {
+    return img2num_labels_to_svg(data, labels, width, height, min_area, min_thickness);
 }
 
-EMSCRIPTEN_KEEPALIVE char* image_to_svg(
-    const uint8_t* data, const int width, const int height, double sigma_spatial,
-    double sigma_range, const int32_t k, const int32_t max_iter, const int min_area,
-    const uint8_t color_space
-) {
+EMSCRIPTEN_KEEPALIVE char *image_to_svg(const uint8_t *data, const int width, const int height,
+                                        double sigma_spatial, double sigma_range, const int32_t k,
+                                        const int32_t max_iter, const int min_area, const int min_thickness,
+                                        const uint8_t color_space) {
     img2num_ImageToSvgConfig config = img2num_ImageToSvgConfig_default();
 
     config.bilateral_filter.sigma_spatial = sigma_spatial;
     config.bilateral_filter.sigma_range = sigma_range;
     config.kmeans.k = k;
     config.kmeans.max_iter = max_iter;
     config.min_cluster_area = min_area;
+    config.min_thickness = min_thickness;
     config.color_space = color_space;
 
     return img2num_image_to_svg(data, width, height, &config);

bindings/py/src/img2num_pybind.cpp

@@ -121,18 +121,17 @@ PYBIND11_MODULE(_img2num, m) {
         "labels_to_svg",
         [](pybind11::array_t<uint8_t, pybind11::array::c_style> data,
            pybind11::array_t<int32_t, pybind11::array::c_style> labels, int width, int height,
-           int min_area) {
-            const uint8_t* data_ptr {static_cast<const uint8_t*>(data.request().ptr)};
-            const int32_t* labels_ptr {static_cast<const int32_t*>(labels.request().ptr)};
+           int min_area, int min_thickness) {
+            const uint8_t *data_ptr{static_cast<const uint8_t *>(data.request().ptr)};
+            const int32_t *labels_ptr{static_cast<const int32_t *>(labels.request().ptr)};
 
-            std::string svg {img2num::labels_to_svg(data_ptr, labels_ptr, width, height, min_area)};
+            std::string svg{img2num::labels_to_svg(data_ptr, labels_ptr, width, height, min_area, min_thickness)};
             pybind11::str svg_py_str(std::move(svg));
 
             return svg_py_str;
         },
         pybind11::arg("data"), pybind11::arg("labels"), pybind11::arg("width"),
-        pybind11::arg("height"), pybind11::arg("min_area"), "Convert labels to SVG string"
-    );
+        pybind11::arg("height"), pybind11::arg("min_area"), pybind11::arg("min_thickness"), "Convert labels to SVG string");
 
     // ---------------------- Config Structs ----------------------
     pybind11::class_<img2num::ImageToSvgConfig> config(m, "ImageToSvgConfig");
@@ -160,36 +159,37 @@ PYBIND11_MODULE(_img2num, m) {
         });
 
     config
-        .def(
-            pybind11::init([](pybind11::dict bf_dict, pybind11::dict km_dict,
-                              pybind11::kwargs kwargs) {
-                // hand over ownership to python
-                std::unique_ptr<img2num::ImageToSvgConfig> c =
-                    std::make_unique<img2num::ImageToSvgConfig>();
-                if (bf_dict.contains("sigma_spatial"))
-                    c->bilateral_filter.sigma_spatial = bf_dict["sigma_spatial"].cast<double>();
-                if (bf_dict.contains("sigma_range"))
-                    c->bilateral_filter.sigma_range = bf_dict["sigma_range"].cast<double>();
-
-                // 3. Process KMeans overrides from the 'km' dictionary
-                if (km_dict.contains("k"))
-                    c->kmeans.k = km_dict["k"].cast<int>();
-                if (km_dict.contains("max_iter"))
-                    c->kmeans.max_iter = km_dict["max_iter"].cast<int>();
-
-                // 4. Process remaining top-level kwargs (like color_space or min_cluster_area)
-                if (kwargs.contains("min_cluster_area"))
-                    c->min_cluster_area = kwargs["min_cluster_area"].cast<int>();
-                if (kwargs.contains("color_space"))
-                    c->color_space = kwargs["color_space"].cast<uint8_t>();
-
-                return c;
-            }),
-            pybind11::arg("bilateral_filter") = pybind11::dict(), // Defaults to empty dict
-            pybind11::arg("kmeans") = pybind11::dict()            // Defaults to empty dict
-        )
+        .def(pybind11::init([](pybind11::dict bf_dict, pybind11::dict km_dict,
+                               pybind11::kwargs kwargs) {
+                 // hand over ownership to python
+                 std::unique_ptr<img2num::ImageToSvgConfig> c =
+                     std::make_unique<img2num::ImageToSvgConfig>();
+                 if (bf_dict.contains("sigma_spatial"))
+                     c->bilateral_filter.sigma_spatial = bf_dict["sigma_spatial"].cast<double>();
+                 if (bf_dict.contains("sigma_range"))
+                     c->bilateral_filter.sigma_range = bf_dict["sigma_range"].cast<double>();
+
+                 // 3. Process KMeans overrides from the 'km' dictionary
+                 if (km_dict.contains("k")) c->kmeans.k = km_dict["k"].cast<int>();
+                 if (km_dict.contains("max_iter"))
+                     c->kmeans.max_iter = km_dict["max_iter"].cast<int>();
+
+                 // 4. Process remaining top-level kwargs (like color_space or min_cluster_area)
+                 if (kwargs.contains("min_cluster_area"))
+                     c->min_cluster_area = kwargs["min_cluster_area"].cast<int>();
+                 if (kwargs.contains("min_thickness"))
+                     c->min_thickness = kwargs["min_thickness"].cast<int>();
+                 if (kwargs.contains("color_space"))
+                     c->color_space = kwargs["color_space"].cast<uint8_t>();
+
+                 return c;
+             }),
+             pybind11::arg("bilateral_filter") = pybind11::dict(),  // Defaults to empty dict
+             pybind11::arg("kmeans") = pybind11::dict()   // Defaults to empty dict
+             )
         .def_readwrite("bilateral_filter", &img2num::ImageToSvgConfig::bilateral_filter)
         .def_readwrite("min_cluster_area", &img2num::ImageToSvgConfig::min_cluster_area)
+        .def_readwrite("min_thickness", &img2num::ImageToSvgConfig::min_thickness)
         .def_readwrite("color_space", &img2num::ImageToSvgConfig::color_space)
         .def_readwrite("kmeans", &img2num::ImageToSvgConfig::kmeans)
         .def("__repr__", [](const img2num::ImageToSvgConfig& c) {
@@ -199,6 +199,7 @@ PYBIND11_MODULE(_img2num, m) {
                << "bilateral_filter: "
                << pybind11::repr(pybind11::cast(c.bilateral_filter)).cast<std::string>() << ", "
                << "min_cluster_area: " << c.min_cluster_area << ", "
+               << "min_thickness: " << c.min_thickness << ", "
                << "color_space: " << (int)c.color_space << ", "
                << "kmeans: " << pybind11::repr(pybind11::cast(c.kmeans)).cast<std::string>()
                << "}>";

core/include/img2num.h

@@ -41,6 +41,7 @@ struct ImageToSvgConfig {
 
     /// Minimum area (in pixels) for a region to be included in the SVG.
     int min_cluster_area = 100;
+    int min_thickness = 0;
 
     /// Color space flag.
     /// - 0 = CIE LAB (more perceptually accurate)
@@ -75,10 +76,8 @@ void bilateral_filter(
 );
 
 /// @copydoc IMG2NUM_H_LABELS_TO_SVG_DOC
-std::string labels_to_svg(
-    const uint8_t* data, const int32_t* labels, const int width, const int height,
-    const int min_area
-);
+std::string labels_to_svg(const uint8_t *data, const int32_t *labels, const int width,
+                          const int height, const int min_area, const int min_thickness);
 
 /// @copydoc IMG2NUM_H_IMAGE_TO_SVG_DOC
 std::string image_to_svg(

core/include/internal/bezier.h

@@ -3,8 +3,14 @@
 
 #include "internal/contours.h"
 
-void fit_curve_reduction(
-    const std::vector<std::vector<Point>>& chains, std::vector<std::vector<QuadBezier>>& results,
-    float tolerance
-);
+void fit_curve_reduction(const std::vector<std::vector<Point>> &chains,
+                         std::vector<std::vector<QuadBezier>> &results, float tolerance);
+
+// Same, but `fixed[i][k]!=0` marks point k of chain i as a junction that must NOT
+// move: the chain is split at those points so each becomes an exact (pinned)
+// curve endpoint. Chains with no fixed points fit identically to the overload
+// above.
+void fit_curve_reduction(const std::vector<std::vector<Point>> &chains,
+                         const std::vector<std::vector<uint8_t>> &fixed,
+                         std::vector<std::vector<QuadBezier>> &results, float tolerance);
 #endif

core/include/internal/contours.h

@@ -49,9 +49,10 @@ ContoursResult find_contours(const std::vector<uint8_t>& binary, int width, int
 void stitch_smooth(std::vector<Point>& vecA, std::vector<Point>& vecB);
 void coupled_smooth(std::vector<std::vector<Point>>& contours, Rect bounds);
 
-void pack_with_boundary_constraints(
-    std::vector<std::vector<Point>>& contours, Rect bounds, int iterations = 15
-);
+void coupled_smooth_junctions(std::vector<std::vector<Point>> &contours, Rect bounds, std::vector<uint8_t> junctions, int width);
+
+void pack_with_boundary_constraints(std::vector<std::vector<Point>> &contours, Rect bounds,
+                                    int iterations = 15);
 
 } // namespace contours
 

core/include/internal/douglas_peucker.h

@@ -0,0 +1,28 @@
+#ifndef DOUGLAS_PEUCKER_H
+#define DOUGLAS_PEUCKER_H
+
+#include <cstdint>
+#include <vector>
+
+#include "internal/contours.h"
+
+// Douglas-Peucker point reduction. Reduces each contour's point count directly
+// (the bezier least-squares fit's only real purpose here was shrinking the SVG).
+//
+// `fixed[i][k]!=0` marks junctions/corners that must NOT be removed: the chain is
+// split at them so every one survives as an exact, shared endpoint -- neighbours
+// that share a junction therefore split at the SAME point. Simplification is
+// bounded so it never retracts a boundary inward past the inter-region overlap
+// margin, so reducing one region never eats its overlap with another and opens a
+// gap. Kept points are emitted as straight-line quads, so the existing QuadBezier
+// SVG path emission (and its closing 'Z') is unchanged.
+//
+// `eps`        : overall deviation tolerance (px). Env override IMG2NUM_DP_EPS.
+// retract_eps  : max inward (region-shrinking) move allowed when dropping a
+//                vertex; defaults to min(eps, 0.5px). Env override
+//                IMG2NUM_DP_RETRACT.
+void dp_curve_reduction(const std::vector<std::vector<Point>> &chains,
+                        const std::vector<std::vector<uint8_t>> &fixed,
+                        std::vector<std::vector<QuadBezier>> &results, float eps);
+
+#endif

core/include/internal/graph.h

@@ -39,11 +39,16 @@ class Graph {
     void hash_node_ids(void);
     void process_overlapping_edges();
 
-  public:
-    inline Graph(std::unique_ptr<std::vector<Node_ptr>>& nodes, int width, int height)
-        : m_nodes(std::move(nodes))
-        , m_width(width)
-        , m_height(height) {
+    inline uint8_t getPixel(const std::vector<uint8_t>& img, int w, int h, int x, int y) {
+        if (x < 0 || x >= w || y < 0 || y >= h) return 0; // Boundary check
+        return img[y * w + x];
+    }
+
+    std::vector<uint8_t> analyzeJunctions(const std::vector<uint8_t>& skel, int w, int h);
+
+   public:
+    inline Graph(std::unique_ptr<std::vector<Node_ptr>> &nodes, int width, int height)
+        : m_nodes(std::move(nodes)), m_width(width), m_height(height) {
         hash_node_ids();
     }
 
@@ -68,10 +73,9 @@ class Graph {
         return m_nodes->size();
     }
 
-    void discover_edges(
-        const std::vector<int32_t>& region_labels, const int32_t width, const int32_t height
-    );
-    void merge_small_area_nodes(const int32_t min_area);
+    void discover_edges(const std::vector<int32_t> &region_labels, const int32_t width,
+                        const int32_t height);
+    void merge_small_area_nodes(const int32_t min_area, const int32_t min_thickness = 0);
     void compute_contours();
 };
 

core/include/internal/shared_contours.h

@@ -0,0 +1,30 @@
+#ifndef SHARED_CONTOURS_H
+#define SHARED_CONTOURS_H
+
+#include <cstdint>
+#include <unordered_map>
+#include <vector>
+
+#include "internal/Point.h"
+#include "internal/contours.h"  // QuadBezier
+
+// Crack-based shared-edge contour builder.
+//
+// Builds region boundaries on the pixel-corner ("crack") grid rather than on
+// pixel centres. The boundary between two regions is extracted ONCE as a
+// canonical edge (a chain of cracks between two junction corners), simplified
+// once, and then reused by BOTH adjacent regions. Neighbouring contours are
+// therefore exactly coincident along every shared edge -- no overlap band and no
+// gaps, by construction.
+//
+// `labels` is the per-pixel region id (w*h, row major); any value is treated as a
+// distinct region, out-of-bounds is the image exterior. Returns, per region id,
+// its list of closed boundary loops, each a sequence of quadratic beziers in
+// corner coordinates (0..w, 0..h). Each shared edge is fitted ONCE and reused by
+// both adjacent regions, so neighbouring loops are exactly coincident.
+//
+// `eps` is the curve-fit tolerance applied to each canonical edge.
+std::unordered_map<int32_t, std::vector<std::vector<QuadBezier>>> build_shared_loops(
+    const std::vector<int32_t> &labels, int w, int h, float eps);
+
+#endif

core/src/internal/bezier.cpp

@@ -154,3 +154,37 @@ void fit_curve_reduction(
         results.push_back(result);
     }
 }
+
+// --- Junction-aware wrapper ---
+// Splits each chain at its fixed (junction) points and fits the pieces
+// separately. Because fitRecursive always keeps a segment's first and last point
+// exactly, every junction becomes a pinned on-curve point the fit cannot move.
+void fit_curve_reduction(const std::vector<std::vector<Point>> &chains,
+                         const std::vector<std::vector<uint8_t>> &fixed,
+                         std::vector<std::vector<QuadBezier>> &results, float tolerance) {
+    for (size_t i = 0; i < chains.size(); ++i) {
+        const std::vector<Point> &chain = chains[i];
+        const int n = static_cast<int>(chain.size());
+        std::vector<QuadBezier> result;
+        if (n < 2) {
+            results.push_back(result);
+            continue;
+        }
+
+        // Segment boundaries: chain ends plus every interior junction point.
+        std::vector<int> bounds;
+        bounds.push_back(0);
+        for (int k = 1; k < n - 1; ++k)
+            if (k < static_cast<int>(fixed[i].size()) && fixed[i][k]) bounds.push_back(k);
+        bounds.push_back(n - 1);
+
+        // Fit each [bounds[s], bounds[s+1]] piece; consecutive pieces share the
+        // junction point, so the curve stays continuous and pinned there.
+        for (size_t s = 0; s + 1 < bounds.size(); ++s) {
+            const int a = bounds[s], b = bounds[s + 1];
+            std::vector<Point> seg(chain.begin() + a, chain.begin() + b + 1);
+            fitRecursive(seg, tolerance, result);
+        }
+        results.push_back(result);
+    }
+}