labels_to_svg.cpp

#include "img2num.h"
#include "internal/bezier.h"
#include "internal/contours.h"
#include "internal/graph.h"
 
#include <array>
#include <cmath>
#include <cstdint>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <iomanip>
#include <limits>
#include <map>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <vector>
 
/* Flood fill */
int flood_fill(
    std::vector<int32_t>& label_array, std::vector<int32_t>& region_array,
    const uint8_t* color_array, int x, int y, int target_value, int label_value, size_t width,
    size_t height, std::unique_ptr<std::vector<RGBXY>>& out_pixels
) {
    std::queue<XY> queue;
    auto index = [width](int x, int y) {
        return y * width + x;
    };
 
    int count = 0;
    int dirs[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
 
    RGBXY pix = RGBXY {
        color_array[4 * size_t(index(x, y))], color_array[4 * size_t(index(x, y)) + 1],
        color_array[4 * size_t(index(x, y)) + 2], x, y
    };
 
    queue.push({x, y});
 
    region_array[size_t(index(x, y))] = label_value;
 
    out_pixels->push_back(pix);
    count++;
 
    while (!queue.empty()) {
        XY c = queue.front();
        queue.pop();
        for (auto& d : dirs) {
            int x1 = c.x + d[0];
            int y1 = c.y + d[1];
 
            // check conditions
            if ((x1 >= 0) && (x1 < int(width)) && (y1 >= 0) && (y1 < int(height)) &&
                (label_array[size_t(index(x1, y1))] == target_value) &&
                (region_array[size_t(index(x1, y1))] == -1)) {
                RGBXY pix1 = RGBXY {
                    color_array[4 * size_t(index(x1, y1))],
                    color_array[4 * size_t(index(x1, y1)) + 1],
                    color_array[4 * size_t(index(x1, y1)) + 2], x1, y1
                };
                region_array[size_t(index(x1, y1))] = label_value;
                out_pixels->push_back(pix1);
                count++;
 
                queue.push({x1, y1});
            }
        }
    }
 
    return count;
}
 
void region_labeling(
    const uint8_t* data, std::vector<int32_t>& labels, std::vector<int32_t>& regions, int width,
    int height, std::vector<Node_ptr>& nodes
) {
    auto index = [width](int x, int y) {
        return y * width + x;
    };
 
    regions.resize(static_cast<size_t>(height) * static_cast<size_t>(width), -1);
    int r_lbl = -1;
 
    for (int i = 0; i < width; i++) {
        for (int j = 0; j < height; j++) {
            int label {labels[size_t(index(i, j))]};
            int rlab {regions[size_t(index(i, j))]};
 
            if (rlab == -1) {
                r_lbl++;
                // track pixels for this region
                // std::vector<RGBXY> pixels;
                std::unique_ptr<std::vector<RGBXY>> p_ptr = std::make_unique<std::vector<RGBXY>>();
                int counts =
                    flood_fill(labels, regions, data, i, j, label, r_lbl, width, height, p_ptr);
                int num_pixels = p_ptr->size();
 
                // num_pixels == counts always
                Node_ptr n_ptr = std::make_shared<Node>(r_lbl, p_ptr);
                nodes.push_back(n_ptr);
            }
        }
    }
}
 
void visualize_contours(
    const std::vector<std::vector<Point>>& contours,
    ImageLib::Image<ImageLib::RGBAPixel<uint8_t>>& results, int width, int height, int xmin = 0,
    int ymin = 0
) {
    // Random generator for colors
    static std::mt19937 rng(std::random_device {}());
    static std::uniform_int_distribution<int32_t> dist(0, 255);
    for (const auto& c : contours) {
        ImageLib::RGBAPixel<uint8_t> rand_color {
            static_cast<uint8_t>(dist(rng)), static_cast<uint8_t>(dist(rng)),
            static_cast<uint8_t>(dist(rng)), 255
        };
 
        for (const auto& p : c) {
            int32_t _x {static_cast<int32_t>(p.x) + xmin};
            int32_t _y {static_cast<int32_t>(p.y) + ymin};
 
            // Ensure within bounds
            if (_x < 0 || _x >= width || _y < 0 || _y >= height)
                continue;
 
            results(_x, _y) = rand_color;
        }
    }
}
 
std::string contourToSVGPath(const std::vector<Point>& contour) {
    if (contour.empty())
        return "";
 
    std::ostringstream path;
    path << std::fixed << std::setprecision(2);
 
    // Move to the first point
    path << "M " << contour[0].x << " " << contour[0].y << " ";
 
    // Draw lines to the remaining points
    for (size_t i = 1; i < contour.size(); ++i) {
        path << "L " << contour[i].x << " " << contour[i].y << " ";
    }
 
    // Close the path
    path << "Z";
    return path.str();
}
 
std::string contourToSVGCurve(const std::vector<QuadBezier>& curves) {
    if (curves.empty())
        return "";
 
    std::ostringstream path;
    path << std::fixed << std::setprecision(2);
 
    for (size_t i = 0; i < curves.size(); ++i) {
        const auto& c = curves[i];
        if (i == 0)
            path << "M " << c.p0.x << " " << c.p0.y << " ";
        path << "Q " << c.p1.x << " " << c.p1.y << " " << c.p2.x << " " << c.p2.y << " ";
    }
 
    //  Close the path
    path << "Z";
    return path.str();
}
 
std::string contoursResultToSVG(const ColoredContours& result, const int width, const int height) {
    std::ostringstream svg;
    svg << "<svg xmlns=\"http://www.w3.org/2000/svg\" fill-rule=\"evenodd\" "
           "width=\""
        << width << "\" height=\"" << height << "\">\n";
 
    for (size_t i = 0; i < result.curves.size(); ++i) {
        std::string pathData = contourToSVGCurve(result.curves[i]);
 
        const auto& px = result.colors[i];
        std::ostringstream oss;
        oss << "#" << std::hex << std::uppercase << std::setw(2) << std::setfill('0')
            << static_cast<int>(px.red) << std::setw(2) << std::setfill('0')
            << static_cast<int>(px.green) << std::setw(2) << std::setfill('0')
            << static_cast<int>(px.blue);
 
        // You can optionally style holes differently or rely on fill-rule
        svg << "  <path d=\"" << pathData << "\" fill=\"" << oss.str() << "\" />\n";
    }
 
    svg << "</svg>\n";
    return svg.str();
}
 
namespace img2num {
/*
data: uint8_t* -> output image from K-Means (or similar) in RGBA repeating
format ([r,g,b,a, r,g,b,a, ...]) labels: int32_t* -> output of labelled regions
from K-Means, should be 1/4 the size of data since data is RGBA labels : width *
height : number of pixels in image = 1 : 1 : 1
*/
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 = 0
) {
    const int32_t num_pixels {width * height};
    std::vector<int32_t> labels_vector {labels, labels + num_pixels};
    std::vector<int32_t> region_labels;
 
    // 1. enumerate regions and convert to Nodes
    std::vector<Node_ptr> nodes;
    region_labeling(data, labels_vector, region_labels, width, height, nodes);
 
    // 2. initialize Graph from all Nodes
    std::unique_ptr<std::vector<Node_ptr>> node_ptr =
        std::make_unique<std::vector<Node_ptr>>(std::move(nodes));
    Graph G(node_ptr, width, height);
 
    // 3. Discover node adjacencies - add edges to Graph
    G.discover_edges(region_labels, width, height);
 
    // 4. Merge small area nodes until all nodes are minArea or larger
    G.merge_small_area_nodes(min_area, min_thickness);
 
    // 5. recolor image on new regions
    ImageLib::Image<ImageLib::RGBAPixel<uint8_t>> results {width, height};
    for (auto& n : G.get_nodes()) {
        if (n->area() == 0)
            continue;
 
        auto [r, g, b] = n->color();
        for (auto& [_, p] : n->get_pixels()) {
            results(p.x, p.y) = {r, g, b};
        }
    }
 
    // 6. Contours
    // graph will manage computing contours
    G.compute_contours();
 
    // accumulate all contours for svg export
    ColoredContours all_contours;
    for (auto& n : G.get_nodes()) {
        if (n->area() == 0)
            continue;
        ColoredContours node_contours = n->get_contours();
        for (auto& c : node_contours.contours) {
            all_contours.contours.push_back(c);
        }
        for (auto& c : node_contours.hierarchy) {
            all_contours.hierarchy.push_back(c);
        }
        for (bool b : node_contours.is_hole) {
            all_contours.is_hole.push_back(b);
        }
        for (auto& c : node_contours.colors) {
            all_contours.colors.push_back(c);
        }
        for (auto& c : node_contours.curves) {
            all_contours.curves.push_back(c);
        }
    }
 
    // 7. Return SVG
    return contoursResultToSVG(all_contours, width, height);
}
} // namespace img2num