mirror of
https://github.com/OrcaSlicer/OrcaSlicer.git
synced 2026-10-05 14:51:06 +00:00
Ian Bassi
7b0e2f3ce5
Since main moved to Clipper2, parts of this branch no longer gave the same G-code as main: - bridge_over_infill dropped expand(limiting_area, 0.3 * flow.spacing()) as a no-op. The offset is below one unit, but Clipper2 still unites its result, which splits and merges touching polygons and so changes the anchor lines. Running it on the polygons next to the bridge gives main's anchors without the whole-layer pass. - tsp_remove_crossings stopped at the first repeated ordering, where main runs on to its pn * pn cap. The loop is periodic from that point, so it now takes only the steps to the ordering main stops on. - With a single tile, the tiled booleans now make the plain call instead of cutting the clip to the tile first. The tiled boolean test compared rings exactly. With the safety offset a tile unites only the clip polygons near it, and Clipper2 can then round a crossing 1 unit differently, so that case allows 1 unit. Comments that named ClipperLib now say Clipper, and docs/HLSD/polygon-clipping.md describes the tiled booleans. G-code of the five handy models in four configurations and of a baked texture relief is byte-identical to main. Colour-painted models still differ: segmenting each island on its own splits a colour's region into different pieces than one diagram over the layer, which on one model also changes the first layer's tool order.
383 lines
19 KiB
C++
383 lines
19 KiB
C++
#include <catch2/catch_all.hpp>
|
|
|
|
#include <algorithm>
|
|
#include <numeric>
|
|
#include <iostream>
|
|
#include <utility>
|
|
#include <boost/filesystem.hpp>
|
|
|
|
#include "libslic3r/ClipperUtils.hpp"
|
|
#include "libslic3r/ExPolygon.hpp"
|
|
#include "libslic3r/SVG.hpp"
|
|
|
|
using namespace Slic3r;
|
|
|
|
// Clipper may start an output polygon at any of its vertices.
|
|
static Polygon start_at_min(Polygon polygon)
|
|
{
|
|
std::rotate(polygon.points.begin(), std::min_element(polygon.points.begin(), polygon.points.end()), polygon.points.end());
|
|
return polygon;
|
|
}
|
|
static Polygons start_at_min(Polygons polygons)
|
|
{
|
|
for (Polygon &polygon : polygons)
|
|
polygon = start_at_min(std::move(polygon));
|
|
return polygons;
|
|
}
|
|
static ExPolygons start_at_min(ExPolygons expolygons)
|
|
{
|
|
for (ExPolygon &expolygon : expolygons) {
|
|
expolygon.contour = start_at_min(std::move(expolygon.contour));
|
|
expolygon.holes = start_at_min(std::move(expolygon.holes));
|
|
}
|
|
return expolygons;
|
|
}
|
|
|
|
SCENARIO("Various Clipper operations - xs/t/11_clipper.t", "[ClipperUtils]") {
|
|
// CCW oriented contour
|
|
Slic3r::Polygon square{ { 200, 100 }, {200, 200}, {100, 200}, {100, 100} };
|
|
// CW oriented contour
|
|
Slic3r::Polygon hole_in_square{ { 160, 140 }, { 140, 140 }, { 140, 160 }, { 160, 160 } };
|
|
Slic3r::ExPolygon square_with_hole(square, hole_in_square);
|
|
GIVEN("square_with_hole") {
|
|
WHEN("offset") {
|
|
Polygons result = Slic3r::offset(square_with_hole, 5.f);
|
|
THEN("offset matches") {
|
|
REQUIRE(start_at_min(result) == start_at_min(Polygons {
|
|
{ { 205, 205 }, { 95, 205 }, { 95, 95 }, { 205, 95 }, },
|
|
{ { 155, 145 }, { 145, 145 }, { 145, 155 }, { 155, 155 } } }));
|
|
}
|
|
}
|
|
WHEN("offset_ex") {
|
|
ExPolygons result = Slic3r::offset_ex(square_with_hole, 5.f);
|
|
THEN("offset matches") {
|
|
REQUIRE(start_at_min(result) == start_at_min(ExPolygons { {
|
|
{ { 205, 205 }, { 95, 205 }, { 95, 95 }, { 205, 95 }, },
|
|
{ { 145, 145 }, { 145, 155 }, { 155, 155 }, { 155, 145 } } } }));
|
|
}
|
|
}
|
|
WHEN("offset2_ex") {
|
|
ExPolygons result = Slic3r::offset2_ex({ square_with_hole }, 5.f, -2.f);
|
|
THEN("offset matches") {
|
|
REQUIRE(start_at_min(result) == start_at_min(ExPolygons { {
|
|
{ { 203, 203 }, { 97, 203 }, { 97, 97 }, { 203, 97 } },
|
|
{ { 143, 143 }, { 143, 157 }, { 157, 157 }, { 157, 143 } } } }));
|
|
}
|
|
}
|
|
}
|
|
GIVEN("square_with_hole 2") {
|
|
Slic3r::ExPolygon square_with_hole(
|
|
{ { 20000000, 20000000 }, { 0, 20000000 }, { 0, 0 }, { 20000000, 0 } },
|
|
{ { 5000000, 15000000 }, { 15000000, 15000000 }, { 15000000, 5000000 }, { 5000000, 5000000 } });
|
|
WHEN("offset2_ex") {
|
|
Slic3r::ExPolygons result = Slic3r::offset2_ex(ExPolygons { square_with_hole }, -1.f, 1.f);
|
|
THEN("offset matches") {
|
|
REQUIRE(result.size() == 1);
|
|
REQUIRE(square_with_hole.area() == result.front().area());
|
|
}
|
|
}
|
|
}
|
|
GIVEN("square and hole") {
|
|
WHEN("diff_ex") {
|
|
ExPolygons result = Slic3r::diff_ex(Polygons{ square }, Polygons{ hole_in_square });
|
|
THEN("hole is created") {
|
|
REQUIRE(result.size() == 1);
|
|
REQUIRE(square_with_hole.area() == result.front().area());
|
|
}
|
|
}
|
|
}
|
|
GIVEN("polyline") {
|
|
Polyline polyline { { 50, 150 }, { 300, 150 } };
|
|
WHEN("intersection_pl") {
|
|
Polylines result = Slic3r::intersection_pl({ polyline }, Polygons{ square, hole_in_square });
|
|
THEN("correct number of result lines") {
|
|
REQUIRE(result.size() == 2);
|
|
}
|
|
THEN("result lines have correct length") {
|
|
// results are in no particular order
|
|
REQUIRE(result[0].length() == 40);
|
|
REQUIRE(result[1].length() == 40);
|
|
}
|
|
}
|
|
WHEN("diff_pl") {
|
|
Polylines result = Slic3r::diff_pl({ polyline }, Polygons{ square, hole_in_square });
|
|
THEN("correct number of result lines") {
|
|
REQUIRE(result.size() == 3);
|
|
}
|
|
// results are in no particular order
|
|
THEN("the left result line has correct length") {
|
|
REQUIRE(std::count_if(result.begin(), result.end(), [](const Polyline &pl) { return pl.length() == 50; }) == 1);
|
|
}
|
|
THEN("the right result line has correct length") {
|
|
REQUIRE(std::count_if(result.begin(), result.end(), [](const Polyline &pl) { return pl.length() == 100; }) == 1);
|
|
}
|
|
THEN("the central result line has correct length") {
|
|
REQUIRE(std::count_if(result.begin(), result.end(), [](const Polyline &pl) { return pl.length() == 20; }) == 1);
|
|
}
|
|
}
|
|
}
|
|
GIVEN("Clipper bug #96 / Slic3r issue #2028") {
|
|
Slic3r::Polyline subject{
|
|
{ 44735000, 31936670 }, { 55270000, 31936670 }, { 55270000, 25270000 }, { 74730000, 25270000 }, { 74730000, 44730000 }, { 68063296, 44730000 }, { 68063296, 55270000 }, { 74730000, 55270000 },
|
|
{ 74730000, 74730000 }, { 55270000, 74730000 }, { 55270000, 68063296 }, { 44730000, 68063296 }, { 44730000, 74730000 }, { 25270000, 74730000 }, { 25270000, 55270000 }, { 31936670, 55270000 },
|
|
{ 31936670, 44730000 }, { 25270000, 44730000 }, { 25270000, 25270000 }, { 44730000, 25270000 }, { 44730000, 31936670 } };
|
|
Slic3r::Polygon clip { {75200000, 45200000}, {54800000, 45200000}, {54800000, 24800000}, {75200000, 24800000} };
|
|
Slic3r::Polylines result = Slic3r::intersection_pl(subject, Polygons{ clip });
|
|
THEN("intersection_pl - result is not empty") {
|
|
REQUIRE(result.size() == 1);
|
|
}
|
|
}
|
|
GIVEN("Clipper bug #122") {
|
|
Slic3r::Polyline subject { { 1975, 1975 }, { 25, 1975 }, { 25, 25 }, { 1975, 25 }, { 1975, 1975 } };
|
|
Slic3r::Polygons clip { { { 2025, 2025 }, { -25, 2025 } , { -25, -25 }, { 2025, -25 } },
|
|
{ { 525, 525 }, { 525, 1475 }, { 1475, 1475 }, { 1475, 525 } } };
|
|
Slic3r::Polylines result = Slic3r::intersection_pl({ subject }, clip);
|
|
THEN("intersection_pl - result is not empty") {
|
|
REQUIRE(result.size() == 1);
|
|
REQUIRE(result.front().points.size() == 5);
|
|
}
|
|
}
|
|
GIVEN("Clipper bug #126") {
|
|
Slic3r::Polyline subject { { 200000, 19799999 }, { 200000, 200000 }, { 24304692, 200000 }, { 15102879, 17506106 }, { 13883200, 19799999 }, { 200000, 19799999 } };
|
|
Slic3r::Polygon clip { { 15257205, 18493894 }, { 14350057, 20200000 }, { -200000, 20200000 }, { -200000, -200000 }, { 25196917, -200000 } };
|
|
Slic3r::Polylines result = Slic3r::intersection_pl(subject, Polygons{ clip });
|
|
THEN("intersection_pl - result is not empty") {
|
|
REQUIRE(result.size() == 1);
|
|
}
|
|
THEN("intersection_pl - result has same length as subject polyline") {
|
|
REQUIRE(result.front().length() == Catch::Approx(subject.length()));
|
|
}
|
|
}
|
|
|
|
#if 0
|
|
{
|
|
# Clipper does not preserve polyline orientation
|
|
my $polyline = Slic3r::Polyline->new([50, 150], [300, 150]);
|
|
my $result = Slic3r::Geometry::Clipper::intersection_pl([$polyline], [$square]);
|
|
is scalar(@$result), 1, 'intersection_pl - correct number of result lines';
|
|
is_deeply $result->[0]->pp, [[100, 150], [200, 150]], 'clipped line orientation is preserved';
|
|
}
|
|
{
|
|
# Clipper does not preserve polyline orientation
|
|
my $polyline = Slic3r::Polyline->new([300, 150], [50, 150]);
|
|
my $result = Slic3r::Geometry::Clipper::intersection_pl([$polyline], [$square]);
|
|
is scalar(@$result), 1, 'intersection_pl - correct number of result lines';
|
|
is_deeply $result->[0]->pp, [[200, 150], [100, 150]], 'clipped line orientation is preserved';
|
|
}
|
|
{
|
|
# Disabled until Clipper bug #127 is fixed
|
|
my $subject = [
|
|
Slic3r::Polyline->new([-90000000, -100000000], [-90000000, 100000000]), # vertical
|
|
Slic3r::Polyline->new([-100000000, -10000000], [100000000, -10000000]), # horizontal
|
|
Slic3r::Polyline->new([-100000000, 0], [100000000, 0]), # horizontal
|
|
Slic3r::Polyline->new([-100000000, 10000000], [100000000, 10000000]), # horizontal
|
|
];
|
|
my $clip = Slic3r::Polygon->new(# a circular, convex, polygon
|
|
[99452190, 10452846], [97814760, 20791169], [95105652, 30901699], [91354546, 40673664], [86602540, 50000000],
|
|
[80901699, 58778525], [74314483, 66913061], [66913061, 74314483], [58778525, 80901699], [50000000, 86602540],
|
|
[40673664, 91354546], [30901699, 95105652], [20791169, 97814760], [10452846, 99452190], [0, 100000000],
|
|
[-10452846, 99452190], [-20791169, 97814760], [-30901699, 95105652], [-40673664, 91354546],
|
|
[-50000000, 86602540], [-58778525, 80901699], [-66913061, 74314483], [-74314483, 66913061],
|
|
[-80901699, 58778525], [-86602540, 50000000], [-91354546, 40673664], [-95105652, 30901699],
|
|
[-97814760, 20791169], [-99452190, 10452846], [-100000000, 0], [-99452190, -10452846],
|
|
[-97814760, -20791169], [-95105652, -30901699], [-91354546, -40673664], [-86602540, -50000000],
|
|
[-80901699, -58778525], [-74314483, -66913061], [-66913061, -74314483], [-58778525, -80901699],
|
|
[-50000000, -86602540], [-40673664, -91354546], [-30901699, -95105652], [-20791169, -97814760],
|
|
[-10452846, -99452190], [0, -100000000], [10452846, -99452190], [20791169, -97814760],
|
|
[30901699, -95105652], [40673664, -91354546], [50000000, -86602540], [58778525, -80901699],
|
|
[66913061, -74314483], [74314483, -66913061], [80901699, -58778525], [86602540, -50000000],
|
|
[91354546, -40673664], [95105652, -30901699], [97814760, -20791169], [99452190, -10452846], [100000000, 0]
|
|
);
|
|
my $result = Slic3r::Geometry::Clipper::intersection_pl($subject, [$clip]);
|
|
is scalar(@$result), scalar(@$subject), 'intersection_pl - expected number of polylines';
|
|
is sum(map scalar(@$_), @$result), scalar(@$subject) * 2, 'intersection_pl - expected number of points in polylines';
|
|
}
|
|
#endif
|
|
}
|
|
|
|
SCENARIO("Various Clipper operations - t/clipper.t", "[ClipperUtils]") {
|
|
GIVEN("square with hole") {
|
|
// CCW oriented contour
|
|
Slic3r::Polygon square { { 10, 10 }, { 20, 10 }, { 20, 20 }, { 10, 20 } };
|
|
Slic3r::Polygon square2 { { 5, 12 }, { 25, 12 }, { 25, 18 }, { 5, 18 } };
|
|
// CW oriented contour
|
|
Slic3r::Polygon hole_in_square { { 14, 14 }, { 14, 16 }, { 16, 16 }, { 16, 14 } };
|
|
WHEN("intersection_ex with another square") {
|
|
ExPolygons intersection = Slic3r::intersection_ex(Polygons{ square, hole_in_square }, Polygons{ square2 });
|
|
THEN("intersection area matches (hole is preserved)") {
|
|
ExPolygon match({ { 20, 18 }, { 10, 18 }, { 10, 12 }, { 20, 12 } },
|
|
{ { 14, 16 }, { 16, 16 }, { 16, 14 }, { 14, 14 } });
|
|
REQUIRE(intersection.size() == 1);
|
|
REQUIRE(intersection.front().area() == Catch::Approx(match.area()));
|
|
}
|
|
}
|
|
}
|
|
GIVEN("square with hole 2") {
|
|
// CCW oriented contour
|
|
Slic3r::Polygon square { { 0, 0 }, { 40, 0 }, { 40, 40 }, { 0, 40 } };
|
|
Slic3r::Polygon square2 { { 10, 10 }, { 30, 10 }, { 30, 30 }, { 10, 30 } };
|
|
// CW oriented contour
|
|
Slic3r::Polygon hole { { 15, 15 }, { 15, 25 }, { 25, 25 }, {25, 15 } };
|
|
WHEN("union_ex with another square") {
|
|
ExPolygons union_ = Slic3r::union_ex({ square, square2, hole });
|
|
THEN("union of two ccw and one cw is a contour with no holes") {
|
|
REQUIRE(union_.size() == 1);
|
|
REQUIRE(union_.front() == ExPolygon { { 40, 40 }, { 0, 40 }, { 0, 0 }, { 40, 0 } } );
|
|
}
|
|
}
|
|
WHEN("diff_ex with another square") {
|
|
ExPolygons diff = Slic3r::diff_ex(Polygons{ square, square2 }, Polygons{ hole });
|
|
THEN("difference of a cw from two ccw is a contour with one hole") {
|
|
REQUIRE(diff.size() == 1);
|
|
REQUIRE(diff.front().area() == Catch::Approx(ExPolygon({ {40, 40}, {0, 40}, {0, 0}, {40, 0} }, { {15, 25}, {25, 25}, {25, 15}, {15, 15} }).area()));
|
|
}
|
|
}
|
|
}
|
|
GIVEN("yet another square") {
|
|
Slic3r::Polygon square { { 10, 10 }, { 20, 10 }, { 20, 20 }, { 10, 20 } };
|
|
Slic3r::Polyline square_pl = square.split_at_first_point();
|
|
WHEN("no-op diff_pl") {
|
|
Slic3r::Polylines res = Slic3r::diff_pl({ square_pl }, Polygons{});
|
|
THEN("returns the right number of polylines") {
|
|
REQUIRE(res.size() == 1);
|
|
}
|
|
THEN("returns the unmodified input polyline") {
|
|
REQUIRE(res.front().points.size() == square_pl.points.size());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
TEST_CASE("Top level expolygons of an even-odd union", "[ClipperUtils]") {
|
|
// Create a polygon representing unit box
|
|
Polygon unitbox;
|
|
const auto UNIT = coord_t(1. / SCALING_FACTOR);
|
|
unitbox.points = { Vec2crd{0, 0}, Vec2crd{UNIT, 0}, Vec2crd{UNIT, UNIT}, Vec2crd{0, UNIT}};
|
|
|
|
Polygon box_frame = unitbox;
|
|
box_frame.scale(20, 10);
|
|
|
|
Polygon hole_left = unitbox;
|
|
hole_left.scale(8);
|
|
hole_left.translate(UNIT, UNIT);
|
|
hole_left.reverse();
|
|
|
|
Polygon hole_right = hole_left;
|
|
hole_right.translate(UNIT * 10, 0);
|
|
|
|
Polygon inner_left = unitbox;
|
|
inner_left.scale(4);
|
|
inner_left.translate(UNIT * 3, UNIT * 3);
|
|
|
|
Polygon inner_right = inner_left;
|
|
inner_right.translate(UNIT * 10, 0);
|
|
|
|
ExPolygons reference;
|
|
for (const Polygon &polygon : union_({box_frame, hole_left, hole_right, inner_left, inner_right}))
|
|
reference.emplace_back(polygon);
|
|
|
|
double area_sum = box_frame.area() + hole_left.area() +
|
|
hole_right.area() + inner_left.area() +
|
|
inner_right.area();
|
|
|
|
REQUIRE(area_sum > 0);
|
|
|
|
ExPolygons nested;
|
|
ExPolygons top_level = top_level_expolygons(reference, &nested);
|
|
auto area = [](const ExPolygons &expolys) {
|
|
return std::accumulate(expolys.begin(), expolys.end(), 0.0, [](double a, const ExPolygon &e) { return a + e.area(); });
|
|
};
|
|
REQUIRE(top_level.size() == 1);
|
|
REQUIRE(top_level.front().holes.size() == 2);
|
|
REQUIRE(nested.size() == 2);
|
|
REQUIRE(area_sum == Catch::Approx(area(top_level) + area(nested)));
|
|
REQUIRE(top_level_expolygons(reference).size() == 1);
|
|
}
|
|
|
|
// Rings flattened to x,y,x,y... and sorted, with each ring rotated to start at its lowest point: two
|
|
// encodings of the same geometry compare equal however the pieces came back or wherever a ring started.
|
|
static std::vector<std::vector<coord_t>> canonical_rings(const ExPolygons &expolygons)
|
|
{
|
|
std::vector<std::vector<coord_t>> rings;
|
|
const auto add = [&rings](const Polygon &poly) {
|
|
if (poly.points.empty())
|
|
return;
|
|
Points pts = poly.points;
|
|
std::rotate(pts.begin(),
|
|
std::min_element(pts.begin(), pts.end(), [](const Point &a, const Point &b) {
|
|
return std::make_pair(a.x(), a.y()) < std::make_pair(b.x(), b.y());
|
|
}),
|
|
pts.end());
|
|
std::vector<coord_t> flat;
|
|
flat.reserve(pts.size() * 2);
|
|
for (const Point &p : pts) {
|
|
flat.emplace_back(p.x());
|
|
flat.emplace_back(p.y());
|
|
}
|
|
rings.emplace_back(std::move(flat));
|
|
};
|
|
for (const ExPolygon &expoly : expolygons) {
|
|
add(expoly.contour);
|
|
for (const Polygon &hole : expoly.holes)
|
|
add(hole);
|
|
}
|
|
std::sort(rings.begin(), rings.end());
|
|
return rings;
|
|
}
|
|
|
|
// The same rings, every coordinate within `tolerance`.
|
|
static bool same_rings(const ExPolygons &a, const ExPolygons &b, coord_t tolerance)
|
|
{
|
|
const std::vector<std::vector<coord_t>> ra = canonical_rings(a), rb = canonical_rings(b);
|
|
return std::equal(ra.begin(), ra.end(), rb.begin(), rb.end(), [tolerance](const std::vector<coord_t> &x, const std::vector<coord_t> &y) {
|
|
return std::equal(x.begin(), x.end(), y.begin(), y.end(), [tolerance](coord_t u, coord_t v) { return std::abs(u - v) <= tolerance; });
|
|
});
|
|
}
|
|
|
|
TEST_CASE("Tiled diff and intersection return the same polygons as the plain calls", "[ClipperUtils]") {
|
|
// A grid of disjoint framed squares, enough of them to be split into several tiles.
|
|
const int n = 40;
|
|
const coord_t cell = scaled<coord_t>(2.), side = scaled<coord_t>(1.5), frame = scaled<coord_t>(0.3);
|
|
ExPolygons subject;
|
|
for (int y = 0; y < n; ++ y)
|
|
for (int x = 0; x < n; ++ x) {
|
|
const Point o(x * cell, y * cell);
|
|
ExPolygon square(Polygon({ o, o + Point(side, 0), o + Point(side, side), o + Point(0, side) }));
|
|
Polygon hole({ o + Point(frame, frame), o + Point(frame, side - frame), o + Point(side - frame, side - frame), o + Point(side - frame, frame) });
|
|
square.holes.emplace_back(std::move(hole));
|
|
subject.emplace_back(std::move(square));
|
|
}
|
|
// Clip polygons crossing many squares, one of them large with holes of its own.
|
|
Polygons clip;
|
|
const coord_t span = n * cell;
|
|
for (int i = 0; i < 8; ++ i) {
|
|
const coord_t y0 = coord_t(i) * span / 8, y1 = y0 + scaled<coord_t>(0.9);
|
|
clip.emplace_back(Polygon({ Point(- cell, y0), Point(span, y0 + cell * 3), Point(span, y1 + cell * 3), Point(- cell, y1) }));
|
|
}
|
|
ExPolygon big(Polygon({ Point(span / 4, span / 4), Point(3 * span / 4, span / 4), Point(3 * span / 4, 3 * span / 4), Point(span / 4, 3 * span / 4) }));
|
|
for (int i = 0; i < 4; ++ i) {
|
|
const Point o(span / 4 + scaled<coord_t>(3.1) + i * scaled<coord_t>(9.7), span / 4 + scaled<coord_t>(5.3));
|
|
big.holes.emplace_back(Polygon({ o, o + Point(0, scaled<coord_t>(20.)), o + Point(scaled<coord_t>(5.), scaled<coord_t>(20.)), o + Point(scaled<coord_t>(5.), 0) }));
|
|
}
|
|
polygons_append(clip, to_polygons(big));
|
|
|
|
const ApplySafetyOffset safety = GENERATE(ApplySafetyOffset::No, ApplySafetyOffset::Yes);
|
|
|
|
// The point of the fixture: below 128 pieces the helpers fall back to a single tile and the tiled
|
|
// path under test is never taken.
|
|
REQUIRE(ClipperUtils::tile_expolygons(subject, 32).size() > 1);
|
|
|
|
// With the safety offset a tile unites fewer clip polygons, so Clipper2 can round a crossing 1 unit differently.
|
|
const coord_t tolerance = safety == ApplySafetyOffset::Yes ? 1 : 0;
|
|
|
|
const ExPolygons diff_plain = diff_ex(subject, clip, safety);
|
|
const ExPolygons diff_tiled = diff_ex_by_piece(subject, clip, safety);
|
|
REQUIRE(area(diff_plain) > 0.);
|
|
CHECK(same_rings(diff_tiled, diff_plain, tolerance));
|
|
|
|
const ExPolygons intersection_plain = intersection_ex(subject, clip, safety);
|
|
const ExPolygons intersection_tiled = intersection_ex_by_piece(subject, clip, safety);
|
|
REQUIRE(area(intersection_plain) > 0.);
|
|
CHECK(same_rings(intersection_tiled, intersection_plain, tolerance));
|
|
}
|