aboutsummaryrefslogtreecommitdiff
path: root/svg-flatten/src
diff options
context:
space:
mode:
Diffstat (limited to 'svg-flatten/src')
-rw-r--r--svg-flatten/src/nopencv.cpp101
-rw-r--r--svg-flatten/src/nopencv.hpp40
-rw-r--r--svg-flatten/src/nopencv_test.cpp11
-rw-r--r--svg-flatten/src/vec_core.cpp141
-rw-r--r--svg-flatten/src/vec_core.h1
5 files changed, 171 insertions, 123 deletions
diff --git a/svg-flatten/src/nopencv.cpp b/svg-flatten/src/nopencv.cpp
index 9fd2b2f..b490217 100644
--- a/svg-flatten/src/nopencv.cpp
+++ b/svg-flatten/src/nopencv.cpp
@@ -2,10 +2,20 @@
#include <iostream>
#include <iomanip>
+#include "nopencv.hpp"
+
#define STB_IMAGE_IMPLEMENTATION
-#include "stb_image.h"
+#include <stb_image.h>
-#include "nopencv.hpp"
+#define STB_IMAGE_RESIZE_IMPLEMENTATION
+#include <stb_image_resize.h>
+
+#define IIR_GAUSS_BLUR_IMPLEMENTATION
+#include "iir_gauss_blur.h"
+
+template void iir_gauss_blur<uint8_t>(unsigned int width, unsigned int height, unsigned char components, uint8_t* image, float sigma);
+template void iir_gauss_blur<uint32_t> (unsigned int width, unsigned int height, unsigned char components, uint32_t* image, float sigma);
+template void iir_gauss_blur<float> (unsigned int width, unsigned int height, unsigned char components, float* image, float sigma);
using namespace gerbolyze;
using namespace gerbolyze::nopencv;
@@ -138,7 +148,7 @@ static void follow(gerbolyze::nopencv::Image32 &img, int start_x, int start_y, D
}
-void gerbolyze::nopencv::find_blobs(gerbolyze::nopencv::Image32 &img, gerbolyze::nopencv::ContourCallback cb) {
+void gerbolyze::nopencv::find_contours(gerbolyze::nopencv::Image32 &img, gerbolyze::nopencv::ContourCallback cb) {
/* Implementation of the hierarchical contour finding algorithm from Suzuki and Abe, 1983: Topological Structural
* Analysis of Digitized Binary Images by Border Following
*
@@ -387,27 +397,40 @@ ContourCallback gerbolyze::nopencv::simplify_contours_teh_chin(ContourCallback c
};
}
+double gerbolyze::nopencv::polygon_area(Polygon_i &poly) {
+ double acc = 0;
+ size_t prev = poly.size() - 1;
+ for (size_t cur=0; cur<poly.size(); cur++) {
+ acc += (poly[prev][0] + poly[cur][0]) * (poly[prev][1] - poly[cur][1]);
+ prev = cur;
+ }
+ return acc / 2;
+}
-gerbolyze::nopencv::Image32::Image32(int size_x, int size_y, const int32_t *data) {
+template<typename T>
+gerbolyze::nopencv::Image<T>::Image(int size_x, int size_y, const T *data) {
assert(size_x > 0 && size_x < 100000);
assert(size_y > 0 && size_y < 100000);
- m_data = new int32_t[size_x * size_y] { 0 };
+ m_data = new T[size_x * size_y] { 0 };
m_rows = size_y;
m_cols = size_x;
if (data != nullptr) {
- memcpy(m_data, data, sizeof(int32_t) * size_x * size_y);
+ memcpy(m_data, data, sizeof(T) * size_x * size_y);
}
}
-bool gerbolyze::nopencv::Image32::load(const char *filename) {
+template<typename T>
+bool gerbolyze::nopencv::Image<T>::load(const char *filename) {
return stb_to_internal(stbi_load(filename, &m_cols, &m_rows, nullptr, 1));
}
-bool gerbolyze::nopencv::Image32::load_memory(uint8_t *buf, size_t len) {
- return stb_to_internal(stbi_load_from_memory(buf, len, &m_cols, &m_rows, nullptr, 1));
+template<typename T>
+bool gerbolyze::nopencv::Image<T>::load_memory(const void *buf, size_t len) {
+ return stb_to_internal(stbi_load_from_memory(reinterpret_cast<const uint8_t *>(buf), len, &m_cols, &m_rows, nullptr, 1));
}
-void gerbolyze::nopencv::Image32::binarize() {
+template<typename T>
+void gerbolyze::nopencv::Image<T>::binarize() {
assert(m_data != nullptr);
assert(m_rows > 0 && m_cols > 0);
@@ -418,7 +441,8 @@ void gerbolyze::nopencv::Image32::binarize() {
}
}
-bool gerbolyze::nopencv::Image32::stb_to_internal(uint8_t *data) {
+template<typename T>
+bool gerbolyze::nopencv::Image<T>::stb_to_internal(uint8_t *data) {
if (data == nullptr)
return false;
@@ -427,7 +451,7 @@ bool gerbolyze::nopencv::Image32::stb_to_internal(uint8_t *data) {
if (m_cols < 0 || m_cols > 100000)
return false;
- m_data = new int32_t[size()] { 0 };
+ m_data = new T[size()] { 0 };
for (int y=0; y<m_rows; y++) {
for (int x=0; x<m_cols; x++) {
m_data[y*m_cols + x] = data[y*m_cols + x];
@@ -438,13 +462,50 @@ bool gerbolyze::nopencv::Image32::stb_to_internal(uint8_t *data) {
return true;
}
-double gerbolyze::nopencv::polygon_area(Polygon_i &poly) {
- double acc = 0;
- size_t prev = poly.size() - 1;
- for (size_t cur=0; cur<poly.size(); cur++) {
- acc += (poly[prev][0] + poly[cur][0]) * (poly[prev][1] - poly[cur][1]);
- prev = cur;
- }
- return acc / 2;
+template<typename T>
+void gerbolyze::nopencv::Image<T>::blur(int radius) {
+ iir_gauss_blur(m_cols, m_rows, 1, m_data, radius/2.0);
+}
+
+template<>
+void gerbolyze::nopencv::Image<float>::resize(int new_w, int new_h) {
+ float *old_data = m_data;
+ m_data = new float[new_w * new_h];
+ stbir_resize_float(old_data, m_cols, m_rows, 0,
+ m_data, new_w, new_h, 0,
+ 1);
+ m_cols = new_w;
+ m_rows = new_h;
+}
+
+template<>
+void gerbolyze::nopencv::Image<uint8_t>::resize(int new_w, int new_h) {
+ uint8_t *old_data = m_data;
+ m_data = new uint8_t[new_w * new_h];
+ stbir_resize_uint8(old_data, m_cols, m_rows, 0,
+ m_data, new_w, new_h, 0,
+ 1);
+ m_cols = new_w;
+ m_rows = new_h;
}
+template gerbolyze::nopencv::Image<int32_t>::Image(int size_x, int size_y, const int32_t *data);
+template bool gerbolyze::nopencv::Image<int32_t>::load(const char *filename);
+template bool gerbolyze::nopencv::Image<int32_t>::load_memory(const void *buf, size_t len);
+template void gerbolyze::nopencv::Image<int32_t>::binarize();
+template bool gerbolyze::nopencv::Image<int32_t>::stb_to_internal(uint8_t *data);
+template void gerbolyze::nopencv::Image<int32_t>::blur(int radius);
+
+template gerbolyze::nopencv::Image<uint8_t>::Image(int size_x, int size_y, const uint8_t *data);
+template bool gerbolyze::nopencv::Image<uint8_t>::load(const char *filename);
+template bool gerbolyze::nopencv::Image<uint8_t>::load_memory(const void *buf, size_t len);
+template void gerbolyze::nopencv::Image<uint8_t>::binarize();
+template bool gerbolyze::nopencv::Image<uint8_t>::stb_to_internal(uint8_t *data);
+template void gerbolyze::nopencv::Image<uint8_t>::blur(int radius);
+
+template gerbolyze::nopencv::Image<float>::Image(int size_x, int size_y, const float *data);
+template bool gerbolyze::nopencv::Image<float>::load(const char *filename);
+template bool gerbolyze::nopencv::Image<float>::load_memory(const void *buf, size_t len);
+template void gerbolyze::nopencv::Image<float>::binarize();
+template bool gerbolyze::nopencv::Image<float>::stb_to_internal(uint8_t *data);
+template void gerbolyze::nopencv::Image<float>::blur(int radius);
diff --git a/svg-flatten/src/nopencv.hpp b/svg-flatten/src/nopencv.hpp
index afebce5..8f399b9 100644
--- a/svg-flatten/src/nopencv.hpp
+++ b/svg-flatten/src/nopencv.hpp
@@ -39,30 +39,37 @@ namespace gerbolyze {
typedef std::function<void(Polygon_i&, ContourPolarity)> ContourCallback;
- class Image32 {
+ template<typename T> class Image {
public:
- Image32() {}
- Image32(int size_x, int size_y, const int32_t *data=nullptr);
- Image32(const Image32 &other) : Image32(other.cols(), other.rows(), other.ptr()) {}
+ Image() {}
+ Image(int w, int h, const T *data=nullptr);
+ Image(const Image<T> &other) : Image<T>(other.cols(), other.rows(), other.ptr()) {}
+ template<typename U> Image(const Image<U> &other) : Image<T>(other.cols(), other.rows()) {
+ for (size_t y=0; y<m_rows; y++) {
+ for (size_t x=0; x<m_cols; x++) {
+ at(x, y) = other.at(x, y);
+ }
+ }
+ }
- ~Image32() {
+ ~Image() {
if (m_data) {
delete m_data;
}
}
bool load(const char *filename);
- bool load_memory(uint8_t *buf, size_t len);
+ bool load_memory(const void *buf, size_t len);
void binarize();
- int32_t &at(int x, int y) {
+ T &at(int x, int y) {
assert(x >= 0 && y >= 0 && x < m_cols && y < m_rows);
assert(m_data != nullptr);
return m_data[y*m_cols + x];
};
- void set_at(int x, int y, int val) {
+ void set_at(int x, int y, T val) {
assert(x >= 0 && y >= 0 && x < m_cols && y < m_rows);
assert(m_data != nullptr);
@@ -70,14 +77,14 @@ namespace gerbolyze {
cerr << "set_at " << x << " " << y << ": " << val << " -> " << at(x, y) << endl;
};
- const int32_t &at(int x, int y) const {
+ const T &at(int x, int y) const {
assert(x >= 0 && y >= 0 && x < m_cols && y < m_rows);
assert(m_data != nullptr);
return m_data[y*m_cols + x];
};
- int32_t at_default(int x, int y, int32_t default_value=0) const {
+ T at_default(int x, int y, T default_value=0) const {
assert(m_data != nullptr);
if (x >= 0 && y >= 0 && x < m_cols && y < m_rows) {
@@ -88,19 +95,26 @@ namespace gerbolyze {
}
};
+ void blur(int radius);
+ void resize(int new_w, int new_h);
+
int rows() const { return m_rows; }
int cols() const { return m_cols; }
int size() const { return m_cols*m_rows; }
- const int32_t *ptr() const { return m_data; }
+ const T *ptr() const { return m_data; }
private:
bool stb_to_internal(uint8_t *data);
- int32_t *m_data = nullptr;
+ T *m_data = nullptr;
int m_rows=0, m_cols=0;
};
- void find_blobs(Image32 &img, ContourCallback cb);
+ typedef Image<uint8_t> Image8;
+ typedef Image<int32_t> Image32;
+ typedef Image<float> Image32f;
+
+ void find_contours(Image32 &img, ContourCallback cb);
ContourCallback simplify_contours_teh_chin(ContourCallback cb);
double polygon_area(Polygon_i &poly);
diff --git a/svg-flatten/src/nopencv_test.cpp b/svg-flatten/src/nopencv_test.cpp
index eae17e2..17ba71e 100644
--- a/svg-flatten/src/nopencv_test.cpp
+++ b/svg-flatten/src/nopencv_test.cpp
@@ -97,7 +97,7 @@ MU_TEST(test_complex_example_from_paper) {
const ContourPolarity expected_polarities[3] = {CP_CONTOUR, CP_HOLE, CP_HOLE};
int invocation_count = 0;
- gerbolyze::nopencv::find_blobs(test_img, [&invocation_count, &expected_polarities, &expected_polys](Polygon_i &poly, ContourPolarity pol) {
+ gerbolyze::nopencv::find_contours(test_img, [&invocation_count, &expected_polarities, &expected_polys](Polygon_i &poly, ContourPolarity pol) {
invocation_count += 1;
mu_assert((invocation_count <= 3), "Too many contours returned");
@@ -188,7 +188,7 @@ static void testdata_roundtrip(const char *fn) {
TempfileHack tmp_png(".png");
SVGPolyRenderer ctx(tmp_svg.c_str(), ref_img.cols(), ref_img.rows());
- gerbolyze::nopencv::find_blobs(ref_img, ctx.callback());
+ gerbolyze::nopencv::find_contours(ref_img, ctx.callback());
ctx.close();
mu_assert_int_eq(0, render_svg(tmp_svg.c_str(), tmp_png.c_str()));
@@ -246,7 +246,7 @@ static void test_polygon_area(const char *fn) {
double pos_sum = 0.0;
double neg_sum = ref_img.size();
- gerbolyze::nopencv::find_blobs(ref_img, [&pos_sum, &neg_sum](Polygon_i& poly, ContourPolarity pol) {
+ gerbolyze::nopencv::find_contours(ref_img, [&pos_sum, &neg_sum](Polygon_i& poly, ContourPolarity pol) {
double area = polygon_area(poly);
//cerr << endl << fn << ": " << area << " " << pos_sum << " / " << neg_sum << " -- " << white_px_count << " / " << black_px_count << " GOT: " << poly.size() << " w/ " << pol << endl;
mu_assert(fabs(area) > 0.99, "Polygon smaller than a single pixel");
@@ -288,7 +288,7 @@ static void chain_approx_test(const char *fn) {
TempfileHack tmp_png(".png");
SVGPolyRenderer ctx(tmp_svg.c_str(), ref_img.cols(), ref_img.rows());
- gerbolyze::nopencv::find_blobs(ref_img, simplify_contours_teh_chin(ctx.callback()));
+ gerbolyze::nopencv::find_contours(ref_img, simplify_contours_teh_chin(ctx.callback()));
ctx.close();
mu_assert_int_eq(0, render_svg(tmp_svg.c_str(), tmp_png.c_str()));
@@ -344,6 +344,7 @@ MU_TEST(chain_approx_test_two_px_inv) { chain_approx_test("testdata/two-
MU_TEST_SUITE(nopencv_contours_suite) {
MU_RUN_TEST(test_complex_example_from_paper);
+
MU_RUN_TEST(test_round_trip_blank);
MU_RUN_TEST(test_round_trip_white);
MU_RUN_TEST(test_round_trip_blob_border_w);
@@ -359,6 +360,7 @@ MU_TEST_SUITE(nopencv_contours_suite) {
MU_RUN_TEST(test_round_trip_two_blobs);
MU_RUN_TEST(test_round_trip_two_px);
MU_RUN_TEST(test_round_trip_two_px_inv);
+
MU_RUN_TEST(chain_approx_test_chromosome);
MU_RUN_TEST(chain_approx_test_blank);
MU_RUN_TEST(chain_approx_test_white);
@@ -375,6 +377,7 @@ MU_TEST_SUITE(nopencv_contours_suite) {
MU_RUN_TEST(chain_approx_test_two_blobs);
MU_RUN_TEST(chain_approx_test_two_px);
MU_RUN_TEST(chain_approx_test_two_px_inv);
+
MU_RUN_TEST(test_polygon_area_blank);
MU_RUN_TEST(test_polygon_area_white);
MU_RUN_TEST(test_polygon_area_blob_border_w);
diff --git a/svg-flatten/src/vec_core.cpp b/svg-flatten/src/vec_core.cpp
index aa4a1cc..b0221ca 100644
--- a/svg-flatten/src/vec_core.cpp
+++ b/svg-flatten/src/vec_core.cpp
@@ -22,7 +22,7 @@
#include <algorithm>
#include <vector>
#include <regex>
-#include <opencv2/opencv.hpp>
+#include "nopencv.hpp"
#include "svg_import_util.h"
#include "vec_core.h"
#include "svg_import_defs.h"
@@ -78,27 +78,18 @@ void gerbolyze::parse_img_meta(const pugi::xml_node &node, double &x, double &y,
cerr << "image elem: w="<<width<<", h="<<height<<endl;
}
-string gerbolyze::read_img_data(const pugi::xml_node &node) {
+template<typename T> nopencv::Image<T> *img_from_node(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 nullptr;
}
- 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()) {
+ auto *img = new nopencv::Image<T>();
+ if (!img->load_memory(img_data.c_str(), img_data.size())) {
cerr << "Warning: Could not decode content of image element with id \"" << node.attribute("id").value() << "\"" << endl;
+ return nullptr;
}
return img;
@@ -164,8 +155,8 @@ void gerbolyze::draw_bg_rect(xform2d &mat, double width, double height, ClipperL
void gerbolyze::VoronoiVectorizer::vectorize_image(xform2d &mat, const pugi::xml_node &node, ClipperLib::Paths &clip_path, 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())
+ nopencv::Image32f *img = img_from_node<float>(node);
+ if (img == nullptr)
return;
/* Set up target transform using SVG transform and x/y attributes */
@@ -173,8 +164,8 @@ void gerbolyze::VoronoiVectorizer::vectorize_image(xform2d &mat, const pugi::xml
local_xf.translate(x, y);
local_xf.transform(xform2d(node.attribute("transform").value()));
- double orig_rows = img.rows;
- double orig_cols = img.cols;
+ 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;
@@ -206,19 +197,15 @@ void gerbolyze::VoronoiVectorizer::vectorize_image(xform2d &mat, const pugi::xml
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();
+ cerr << "scaled " << img->cols() << ", " << img->rows() << " -> " << ((int)round(px_w)) << ", " << ((int)round(px_h)) << endl;
+ img->resize((int)round(px_w), (int)round(px_h));
/* 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);
+ int blur_size = (int)ceil(fmax(img->cols() / width, img->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();
+ img->blur(blur_size);
/* Calculate voronoi diagram for the grid generated above. */
jcv_diagram diagram;
@@ -247,9 +234,9 @@ void gerbolyze::VoronoiVectorizer::vectorize_image(xform2d &mat, const pugi::xml
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;
+ double pxd = img->at(
+ (int)round(center.y / (scale_y * orig_rows / img->rows())),
+ (int)round(center.x / (scale_x * orig_cols / img->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.
*/
@@ -359,9 +346,9 @@ void gerbolyze::VoronoiVectorizer::vectorize_image(xform2d &mat, const pugi::xml
}
}
- blurred.release();
jcv_diagram_free( &diagram );
delete grid_centers;
+ delete img;
}
void gerbolyze::handle_aspect_ratio(string spec, double &scale_x, double &scale_y, double &off_x, double &off_y, double cols, double rows) {
@@ -423,8 +410,8 @@ void gerbolyze::OpenCVContoursVectorizer::vectorize_image(xform2d &mat, const pu
(void) min_feature_size_px; /* unused by this vectorizer */
double x, y, width, height;
parse_img_meta(node, x, y, width, height);
- cv::Mat img = read_img_opencv(node);
- if (img.empty())
+ nopencv::Image32 *img = img_from_node<int32_t>(node);
+ if (img == nullptr)
return;
/* Set up target transform using SVG transform and x/y attributes */
@@ -432,69 +419,53 @@ void gerbolyze::OpenCVContoursVectorizer::vectorize_image(xform2d &mat, const pu
local_xf.transform(xform2d(node.attribute("transform").value()));
local_xf.translate(x, y);
- double scale_x = (double)width / (double)img.cols;
- double scale_y = (double)height / (double)img.rows;
+ 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);
+ scale_x, scale_y, off_x, off_y, img->cols(), img->rows());
draw_bg_rect(local_xf, width, height, clip_path, sink);
- 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 });
+ nopencv::find_contours(*img, [&sink, &local_xf, &clip_path, off_x, off_y, scale_x, scale_y](Polygon_i& poly, nopencv::ContourPolarity pol) {
+ sink << ((pol == nopencv::CP_CONTOUR) ? GRB_POL_DARK : GRB_POL_CLEAR);
- 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 = nopencv::polygon_area(poly) > 0;
+ if (!is_clockwise)
+ std::reverse(poly.begin(), poly.end());
- 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]) {
- d2p q = local_xf.doc2phys(d2p{
- off_x + (double)p.x * scale_x,
- off_y + (double)p.y * scale_y
- });
- out.push_back({
- (ClipperLib::cInt)round(q[0] * clipper_scale),
- (ClipperLib::cInt)round(q[1] * clipper_scale)
- });
- }
+ ClipperLib::Path out;
+ for (const auto &p : poly) {
+ d2p q = local_xf.doc2phys(d2p{
+ off_x + (double)p[0] * scale_x,
+ off_y + (double)p[1] * scale_y
+ });
+ out.push_back({
+ (ClipperLib::cInt)round(q[0] * clipper_scale),
+ (ClipperLib::cInt)round(q[1] * 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);
-
- /* 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;
- }
+ 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);
- child_stack.pop();
- }
+ /* 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;
+ }
+ });
}
gerbolyze::VectorizerSelectorizer::VectorizerSelectorizer(const string default_vectorizer, const string defs)
diff --git a/svg-flatten/src/vec_core.h b/svg-flatten/src/vec_core.h
index 0d4da12..ce25807 100644
--- a/svg-flatten/src/vec_core.h
+++ b/svg-flatten/src/vec_core.h
@@ -50,7 +50,6 @@ namespace gerbolyze {
};
void parse_img_meta(const pugi::xml_node &node, double &x, double &y, double &width, double &height);
- std::string read_img_data(const pugi::xml_node &node);
void draw_bg_rect(xform2d &mat, double width, double height, ClipperLib::Paths &clip_path, PolygonSink &sink);
void handle_aspect_ratio(std::string spec, double &scale_x, double &scale_y, double &off_x, double &off_y, double cols, double rows);
}
generated by cgit (git 2.34.1) at 2024-11-04 21:27:48 +0000