/* * This file is part of gerbolyze, a vector image preprocessing toolchain * Copyright (C) 2021 Jan Sebastian Götte <gerbolyze@jaseg.de> * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU Affero 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 Affero General Public License for more details. * * You should have received a copy of the GNU Affero General Public License * along with this program. If not, see <https://www.gnu.org/licenses/>. */ #include <cmath> #include <string> #include <iostream> #include <algorithm> #include <vector> #include <regex> #include <opencv2/opencv.hpp> #include "svg_import_util.h" #include "vec_core.h" #include "svg_import_defs.h" #include "jc_voronoi.h" using namespace gerbolyze; using namespace std; ImageVectorizer *gerbolyze::makeVectorizer(const std::string &name) { if (name == "poisson-disc") return new VoronoiVectorizer(POISSON_DISC, /* relax */ true); else if (name == "hex-grid") return new VoronoiVectorizer(HEXGRID, /* relax */ false); else if (name == "square-grid") return new VoronoiVectorizer(SQUAREGRID, /* relax */ false); else if (name == "binary-contours") return new OpenCVContoursVectorizer(); else if (name == "dev-null") return new DevNullVectorizer(); return nullptr; } /* debug function */ static void dbg_show_cv_image(cv::Mat &img) { string windowName = "Debug image"; cv::namedWindow(windowName); cv::imshow(windowName, img); cv::waitKey(0); cv::destroyWindow(windowName); } /* From jcv voronoi README */ static void voronoi_relax_points(const jcv_diagram* diagram, jcv_point* points) { const jcv_site* sites = jcv_diagram_get_sites(diagram); for (int i=0; i<diagram->numsites; i++) { const jcv_site* site = &sites[i]; jcv_point sum = site->p; int count = 1; const jcv_graphedge* edge = site->edges; while (edge) { sum.x += edge->pos[0].x; sum.y += edge->pos[0].y; count++; edge = edge->next; } points[site->index].x = sum.x / count; points[site->index].y = sum.y / count; } } void gerbolyze::parse_img_meta(const pugi::xml_node &node, double &x, double &y, double &width, double &height) { /* Read XML node attributes */ x = usvg_double_attr(node, "x", 0.0); y = usvg_double_attr(node, "y", 0.0); width = usvg_double_attr(node, "width", 0.0); height = usvg_double_attr(node, "height", 0.0); assert (width > 0 && height > 0); cerr << "image elem: w="<<width<<", h="<<height<<endl; } string gerbolyze::read_img_data(const pugi::xml_node &node) { /* Read image from data:base64... URL */ string img_data = parse_data_iri(node.attribute("xlink:href").value()); if (img_data.empty()) { cerr << "Warning: Empty or invalid image element with id \"" << node.attribute("id").value() << "\"" << endl; return ""; } return img_data; } cv::Mat read_img_opencv(const pugi::xml_node &node) { string img_data = read_img_data(node); /* slightly annoying round-trip through the std:: and cv:: APIs */ vector<unsigned char> img_vec(img_data.begin(), img_data.end()); cv::Mat data_mat(img_vec, true); cv::Mat img = cv::imdecode(data_mat, cv::ImreadModes::IMREAD_GRAYSCALE | cv::ImreadModes::IMREAD_ANYDEPTH); data_mat.release(); if (img.empty()) { cerr << "Warning: Could not decode content of image element with id \"" << node.attribute("id").value() << "\"" << endl; } return img; } void gerbolyze::draw_bg_rect(cairo_t *cr, double width, double height, ClipperLib::Paths &clip_path, PolygonSink &sink, cairo_matrix_t &viewport_matrix) { /* For both our debug SVG output and for the gerber output, we have to paint the image's bounding box in black as * background for our halftone blobs. We cannot simply draw a rect here, though. Instead we have to first intersect * the bounding box with the clip path we get from the caller, then we have to translate it into Cairo-SVG's * document units. */ /* First, setup the bounding box rectangle in our local px coordinate space. */ ClipperLib::Path rect_path; for (auto &elem : vector<pair<double, double>> {{0, 0}, {width, 0}, {width, height}, {0, height}}) { double x = elem.first, y = elem.second; cairo_user_to_device(cr, &x, &y); rect_path.push_back({ (ClipperLib::cInt)round(x * clipper_scale), (ClipperLib::cInt)round(y * clipper_scale) }); } /* Intersect the bounding box with the caller's clip path */ ClipperLib::Clipper c; c.AddPath(rect_path, ClipperLib::ptSubject, /* closed */ true); if (!clip_path.empty()) { c.AddPaths(clip_path, ClipperLib::ptClip, /* closed */ true); } ClipperLib::Paths rect_out; c.StrictlySimple(true); c.Execute(ClipperLib::ctIntersection, rect_out, ClipperLib::pftNonZero, ClipperLib::pftNonZero); /* Finally, translate into Cairo-SVG's document units and draw. */ cairo_save(cr); cairo_set_matrix(cr, &viewport_matrix); cairo_new_path(cr); ClipperLib::cairo::clipper_to_cairo(rect_out, cr, CAIRO_PRECISION, ClipperLib::cairo::tNone); cairo_set_source_rgba (cr, 0.0, 0.0, 0.0, 1.0); /* First, draw into SVG */ cairo_fill(cr); cairo_restore(cr); /* Second, draw into gerber. */ for (const auto &poly : rect_out) { vector<array<double, 2>> out; for (const auto &p : poly) out.push_back(std::array<double, 2>{ ((double)p.X) / clipper_scale, ((double)p.Y) / clipper_scale }); sink << GRB_POL_CLEAR << out; } } /* Render image into gerber file. * * This function renders an image into a number of vector primitives emulating the images grayscale brightness by * differently sized vector shaped giving an effect similar to halftone printing used in newspapers. * * On a high level, this function does this in four steps: * 1. It preprocesses the source image at the pixel level. This involves several tasks: * 1.1. It converts the image to grayscale. * 1.2. It scales the image up or down to match the given minimum feature size. * 1.3. It applies a blur depending on the given minimum feature size to prevent aliasing artifacts. * 2. It randomly spread points across the image using poisson disc sampling. This yields points that have a fairly even * average distance to each other across the image, and that have a guaranteed minimum distance that depends on * minimum feature size. * 3. It calculates a voronoi map based on this set of points and it calculats the polygon shape of each cell of the * voronoi map. * 4. It scales each of these voronoi cell polygons to match the input images brightness at the spot covered by this * cell. */ void gerbolyze::VoronoiVectorizer::vectorize_image(cairo_t *cr, const pugi::xml_node &node, ClipperLib::Paths &clip_path, cairo_matrix_t &viewport_matrix, PolygonSink &sink, double min_feature_size_px) { double x, y, width, height; parse_img_meta(node, x, y, width, height); cv::Mat img = read_img_opencv(node); if (img.empty()) return; cairo_save(cr); /* Set up target transform using SVG transform and x/y attributes */ apply_cairo_transform_from_svg(cr, node.attribute("transform").value()); cairo_translate(cr, x, y); double orig_rows = img.rows; double orig_cols = img.cols; double scale_x = (double)width / orig_cols; double scale_y = (double)height / orig_rows; double off_x = 0; double off_y = 0; handle_aspect_ratio(node.attribute("preserveAspectRatio").value(), scale_x, scale_y, off_x, off_y, orig_cols, orig_rows); /* Adjust minimum feature size given in mm and translate into px document units in our local coordinate system. */ double f_x = min_feature_size_px, f_y = 0; cairo_device_to_user_distance(cr, &f_x, &f_y); min_feature_size_px = sqrt(f_x*f_x + f_y*f_y); draw_bg_rect(cr, width, height, clip_path, sink, viewport_matrix); /* Set up a poisson-disc sampled point "grid" covering the image. Calculate poisson disc parameters from given * minimum feature size. */ double grayscale_overhead = 0.8; /* fraction of distance between two adjacent cell centers that is reserved for grayscale interpolation. Larger values -> better grayscale resolution, larger cells. */ double center_distance = min_feature_size_px * 2.0 * (1.0 / (1.0-grayscale_overhead)); vector<d2p> *grid_centers = get_sampler(m_grid_type)(scale_x * orig_cols, scale_y*orig_rows, center_distance); //vector<d2p> *grid_centers = sample_poisson_disc(width, height, min_feature_size_px * 2.0 * 2.0); //vector<d2p> *grid_centers = sample_hexgrid(width, height, center_distance); //vector<d2p> *grid_centers = sample_squaregrid(width, height, center_distance); /* Target factor between given min_feature_size and intermediate image pixels, * i.e. <scale_featuresize_factor> px ^= min_feature_size */ double scale_featuresize_factor = 3.0; /* TODO: support for preserveAspectRatio attribute */ double px_w = width / min_feature_size_px * scale_featuresize_factor; double px_h = height / min_feature_size_px * scale_featuresize_factor; /* Scale intermediate image (step 1.2) to have <scale_featuresize_factor> pixels per min_feature_size. */ cv::Mat scaled(cv::Size{(int)round(px_w), (int)round(px_h)}, img.type()); cv::resize(img, scaled, scaled.size(), 0, 0); cerr << "scaled " << img.cols << ", " << img.rows << " -> " << scaled.cols << ", " << scaled.rows << endl; img.release(); /* Blur image with a kernel larger than our minimum feature size to avoid aliasing. */ cv::Mat blurred(scaled.size(), scaled.type()); int blur_size = (int)ceil(fmax(scaled.cols / width, scaled.rows / height) * center_distance); if (blur_size%2 == 0) blur_size += 1; cerr << "blur size " << blur_size << endl; cv::GaussianBlur(scaled, blurred, {blur_size, blur_size}, 0, 0); scaled.release(); /* Calculate voronoi diagram for the grid generated above. */ jcv_diagram diagram; memset(&diagram, 0, sizeof(jcv_diagram)); cerr << "adjusted scale " << scale_x << " " << scale_y << endl; cerr << "voronoi clip rect " << (scale_x * orig_cols) << " " << (scale_y * orig_rows) << endl; jcv_rect rect {{0.0, 0.0}, {scale_x * orig_cols, scale_y * orig_rows}}; jcv_point *pts = reinterpret_cast<jcv_point *>(grid_centers->data()); /* hackety hack */ jcv_diagram_generate(grid_centers->size(), pts, &rect, 0, &diagram); /* Relax points, i.e. wiggle them around a little bit to equalize differences between cell sizes a little bit. */ if (m_relax) voronoi_relax_points(&diagram, pts); memset(&diagram, 0, sizeof(jcv_diagram)); jcv_diagram_generate(grid_centers->size(), pts, &rect, 0, &diagram); /* For each voronoi cell calculated above, find the brightness of the blurred image pixel below its center. We do * not have to average over the entire cell's area here: The blur is doing a good approximation of that while being * simpler and faster. * * We do this step before generating the cell poygons below because we have to look up a cell's neighbor's fill * factor during gap filling for minimum feature size preservation. */ vector<double> fill_factors(diagram.numsites); /* Factor to be multiplied with site polygon radius to yield target fill level */ const jcv_site* sites = jcv_diagram_get_sites(&diagram); int j = 0; for (int i=0; i<diagram.numsites; i++) { const jcv_point center = sites[i].p; double pxd = (double)blurred.at<unsigned char>( (int)round(center.y / (scale_y * orig_rows / blurred.rows)), (int)round(center.x / (scale_x * orig_cols / blurred.cols))) / 255.0; /* FIXME: This is a workaround for a memory corruption bug that happens with the square-grid setting. When using * square-grid on a fairly small test image, sometimes sites[i].index will be out of bounds here. */ if (sites[i].index < fill_factors.size()) fill_factors[sites[i].index] = sqrt(pxd); } /* Minimum gap between adjacent scaled site polygons. */ double min_gap_px = min_feature_size_px; vector<double> adjusted_fill_factors; adjusted_fill_factors.reserve(32); /* Vector to hold adjusted fill factors for each edge for gap filling */ /* now iterate over all voronoi cells again to generate each cell's scaled polygon halftone blob. */ for (int i=0; i<diagram.numsites; i++) { const jcv_point center = sites[i].p; double fill_factor_ours = fill_factors[sites[i].index]; /* Do not render halftone blobs that are too small */ if (fill_factor_ours * 0.5 * center_distance < min_gap_px) continue; /* Iterate over this cell's edges. For each edge, check the gap that would result between this cell's halftone * blob and the neighboring cell's halftone blob based on their fill factors. If the gap is too small, either * widen it by adjusting both fill factors down a bit (for this edge only!), or eliminate it by setting both * fill factors to 1.0 (again, for this edge only!). */ adjusted_fill_factors.clear(); const jcv_graphedge* e = sites[i].edges; while (e) { /* half distance between both neighbors of this edge, i.e. sites[i] and its neighbor. */ /* Note that in a voronoi tesselation, this edge is always halfway between. */ double adjusted_fill_factor = fill_factor_ours; if (e->neighbor != nullptr) { /* nullptr -> edge is on the voronoi map's border */ double rad = sqrt(pow(center.x - e->neighbor->p.x, 2) + pow(center.y - e->neighbor->p.y, 2)) / 2.0; double fill_factor_theirs = fill_factors[e->neighbor->index]; double gap_px = (1.0 - fill_factor_ours) * rad + (1.0 - fill_factor_theirs) * rad; if (gap_px > min_gap_px) { /* all good. gap is wider than minimum. */ } else if (gap_px > 0.5 * min_gap_px) { /* gap is narrower than minimum, but more than half of minimum width. */ /* force gap open, distribute adjustment evenly on left/right */ double fill_factor_adjustment = (min_gap_px - gap_px) / 2.0 / rad; adjusted_fill_factor -= fill_factor_adjustment; } else { /* gap is less than half of minimum width. Force gap closed. */ adjusted_fill_factor = 1.0; } } adjusted_fill_factors.push_back(adjusted_fill_factor); e = e->next; } /* Now, generate the actual halftone blob polygon */ ClipperLib::Path cell_path; double last_fill_factor = adjusted_fill_factors.back(); e = sites[i].edges; j = 0; while (e) { double fill_factor = adjusted_fill_factors[j]; if (last_fill_factor != fill_factor) { /* Fill factor was adjusted since last edge, so generate one extra point so we have a nice radial * "step". */ double x = e->pos[0].x; double y = e->pos[0].y; x = off_x + center.x + (x - center.x) * fill_factor; y = off_y + center.y + (y - center.y) * fill_factor; cairo_user_to_device(cr, &x, &y); cell_path.push_back({ (ClipperLib::cInt)round(x * clipper_scale), (ClipperLib::cInt)round(y * clipper_scale) }); } /* Emit endpoint of current edge */ double x = e->pos[1].x; double y = e->pos[1].y; x = off_x + center.x + (x - center.x) * fill_factor; y = off_y + center.y + (y - center.y) * fill_factor; cairo_user_to_device(cr, &x, &y); cell_path.push_back({ (ClipperLib::cInt)round(x * clipper_scale), (ClipperLib::cInt)round(y * clipper_scale) }); j += 1; last_fill_factor = fill_factor; e = e->next; } /* Now, clip the halftone blob generated above against the given clip path. We do this individually for each * blob since this way is *much* faster than throwing a million blobs at once at poor clipper. */ ClipperLib::Paths polys; ClipperLib::Clipper c; c.AddPath(cell_path, ClipperLib::ptSubject, /* closed */ true); if (!clip_path.empty()) { c.AddPaths(clip_path, ClipperLib::ptClip, /* closed */ true); } c.StrictlySimple(true); c.Execute(ClipperLib::ctIntersection, polys, ClipperLib::pftNonZero, ClipperLib::pftNonZero); /* Export halftone blob to debug svg */ cairo_save(cr); cairo_set_matrix(cr, &viewport_matrix); cairo_new_path(cr); ClipperLib::cairo::clipper_to_cairo(polys, cr, CAIRO_PRECISION, ClipperLib::cairo::tNone); cairo_set_source_rgba(cr, 1, 1, 1, 1); cairo_fill(cr); cairo_restore(cr); /* And finally, export halftone blob to gerber. */ for (const auto &poly : polys) { vector<array<double, 2>> out; for (const auto &p : poly) out.push_back(std::array<double, 2>{ ((double)p.X) / clipper_scale, ((double)p.Y) / clipper_scale }); sink << GRB_POL_DARK << out; } } blurred.release(); jcv_diagram_free( &diagram ); delete grid_centers; cairo_restore(cr); } void gerbolyze::handle_aspect_ratio(string spec, double &scale_x, double &scale_y, double &off_x, double &off_y, double cols, double rows) { if (spec.empty()) { spec = "xMidYMid meet"; } auto idx = spec.find(" "); string par_align = spec; string par_meet = "meet"; if (idx != string::npos) { par_align = spec.substr(0, idx); par_meet = spec.substr(idx+1); } if (par_align != "none") { double scale = scale_x; if (par_meet == "slice") { scale = std::max(scale_x, scale_y); } else { scale = std::min(scale_x, scale_y); } std::regex reg("x(Min|Mid|Max)Y(Min|Mid|Max)"); std::smatch match; cerr << "data: " <<" "<< scale_x << "/" << scale_y << ": " << scale << endl; off_x = (scale_x - scale) * cols; off_y = (scale_y - scale) * rows; cerr << rows <<","<<cols<<" " << off_x << "," << off_y << endl; if (std::regex_match(par_align, match, reg)) { assert (match.size() == 3); if (match[1].str() == "Min") { off_x = 0; } else if (match[1].str() == "Mid") { off_x *= 0.5; } if (match[2].str() == "Min") { off_y = 0; } else if (match[2].str() == "Mid") { off_y *= 0.5; } } else { cerr << "Invalid preserveAspectRatio meetOrSlice value \"" << par_align << "\"" << endl; off_x *= 0.5; off_y *= 0.5; } scale_x = scale_y = scale; } cerr << "res: "<< off_x << "," << off_y << endl; } void gerbolyze::OpenCVContoursVectorizer::vectorize_image(cairo_t *cr, const pugi::xml_node &node, ClipperLib::Paths &clip_path, cairo_matrix_t &viewport_matrix, PolygonSink &sink, double min_feature_size_px) { double x, y, width, height; parse_img_meta(node, x, y, width, height); cv::Mat img = read_img_opencv(node); if (img.empty()) return; cairo_save(cr); /* Set up target transform using SVG transform and x/y attributes */ apply_cairo_transform_from_svg(cr, node.attribute("transform").value()); cairo_translate(cr, x, y); double scale_x = (double)width / (double)img.cols; double scale_y = (double)height / (double)img.rows; double off_x = 0; double off_y = 0; handle_aspect_ratio(node.attribute("preserveAspectRatio").value(), scale_x, scale_y, off_x, off_y, img.cols, img.rows); draw_bg_rect(cr, width, height, clip_path, sink, viewport_matrix); vector<vector<cv::Point>> contours; vector<cv::Vec4i> hierarchy; cv::findContours(img, contours, hierarchy, cv::RETR_TREE, cv::CHAIN_APPROX_TC89_KCOS); queue<pair<size_t, bool>> child_stack; child_stack.push({ 0, true }); while (!child_stack.empty()) { bool dark = child_stack.front().second; for (int i=child_stack.front().first; i>=0; i = hierarchy[i][0]) { if (hierarchy[i][2] >= 0) { child_stack.push({ hierarchy[i][2], !dark }); } sink << (dark ? GRB_POL_DARK : GRB_POL_CLEAR); bool is_clockwise = cv::contourArea(contours[i], true) > 0; if (!is_clockwise) std::reverse(contours[i].begin(), contours[i].end()); ClipperLib::Path out; for (const auto &p : contours[i]) { double x = off_x + (double)p.x * scale_x; double y = off_y + (double)p.y * scale_y; cairo_user_to_device(cr, &x, &y); out.push_back({ (ClipperLib::cInt)round(x * clipper_scale), (ClipperLib::cInt)round(y * clipper_scale) }); } ClipperLib::Clipper c; c.AddPath(out, ClipperLib::ptSubject, /* closed */ true); if (!clip_path.empty()) { c.AddPaths(clip_path, ClipperLib::ptClip, /* closed */ true); } c.StrictlySimple(true); ClipperLib::Paths polys; c.Execute(ClipperLib::ctIntersection, polys, ClipperLib::pftNonZero, ClipperLib::pftNonZero); /* Finally, translate into Cairo-SVG's document units and draw. */ cairo_save(cr); cairo_set_matrix(cr, &viewport_matrix); cairo_new_path(cr); ClipperLib::cairo::clipper_to_cairo(polys, cr, CAIRO_PRECISION, ClipperLib::cairo::tNone); cairo_set_source_rgba (cr, 0.0, 0.0, 0.0, 1.0); /* First, draw into SVG */ cairo_fill(cr); cairo_restore(cr); /* Second, draw into gerber. */ for (const auto &poly : polys) { vector<array<double, 2>> out; for (const auto &p : poly) out.push_back(std::array<double, 2>{ ((double)p.X) / clipper_scale, ((double)p.Y) / clipper_scale }); sink << out; } } child_stack.pop(); } cairo_restore(cr); } gerbolyze::VectorizerSelectorizer::VectorizerSelectorizer(const string default_vectorizer, const string defs) : m_default(default_vectorizer) { istringstream foo(defs); string elem; while (std::getline(foo, elem, ',')) { size_t pos = elem.find_first_of("="); if (pos == string::npos) { cerr << "Error parsing vectorizer selection string at element \"" << elem << "\"" << endl; continue; } const string parsed_id = elem.substr(0, pos); const string mapping = elem.substr(pos+1); m_map[parsed_id] = mapping; } cerr << "parsed " << m_map.size() << " vectorizers" << endl; for (auto &elem : m_map) { cerr << " " << elem.first << " -> " << elem.second << endl; } } ImageVectorizer *gerbolyze::VectorizerSelectorizer::select(const pugi::xml_node &img) { const string id = img.attribute("id").value(); cerr << "selecting vectorizer for image \"" << id << "\"" << endl; if (m_map.count(id) > 0) { cerr << " -> found" << endl; return makeVectorizer(m_map[id]); } cerr << " -> default" << endl; return makeVectorizer(m_default); }