Merge branch 'master' into fs_emboss

# Conflicts:
#	src/libslic3r/Format/3mf.cpp
#	src/slic3r/GUI/Gizmos/GLGizmoSimplify.hpp

tests/libslic3r/CMakeLists.txt

@@ -23,6 +23,7 @@ add_executable(${_TEST_NAME}_tests
     test_png_io.cpp
     test_timeutils.cpp
     test_indexed_triangle_set.cpp
+    ../libnest2d/printer_parts.cpp
 	)
 
 if (TARGET OpenVDB::openvdb)

tests/libslic3r/test_3mf.cpp

@@ -65,10 +65,7 @@ SCENARIO("Export+Import geometry to/from 3mf file cycle", "[3mf]") {
 
             // compare meshes
             TriangleMesh src_mesh = src_model.mesh();
-            src_mesh.repair();
-
             TriangleMesh dst_mesh = dst_model.mesh();
-            dst_mesh.repair();
 
             bool res = src_mesh.its.vertices.size() == dst_mesh.its.vertices.size();
             if (res) {

tests/libslic3r/test_aabbindirect.cpp

@@ -9,7 +9,6 @@ using namespace Slic3r;
 TEST_CASE("Building a tree over a box, ray caster and closest query", "[AABBIndirect]")
 {
     TriangleMesh tmesh = make_cube(1., 1., 1.);
-    tmesh.repair();
 
     auto tree = AABBTreeIndirect::build_aabb_tree_over_indexed_triangle_set(tmesh.its.vertices, tmesh.its.indices);
     REQUIRE(! tree.empty());

tests/libslic3r/test_clipper_utils.cpp

@@ -99,7 +99,7 @@ SCENARIO("Various Clipper operations - xs/t/11_clipper.t", "[ClipperUtils]") {
 			{ 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 }, { clip });
+        Slic3r::Polylines result = Slic3r::intersection_pl(subject, { clip });
 		THEN("intersection_pl - result is not empty") {
 			REQUIRE(result.size() == 1);
 		}
@@ -117,7 +117,7 @@ SCENARIO("Various Clipper operations - xs/t/11_clipper.t", "[ClipperUtils]") {
 	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 }, { clip });
+		Slic3r::Polylines result = Slic3r::intersection_pl(subject, { clip });
 		THEN("intersection_pl - result is not empty") {
 			REQUIRE(result.size() == 1);
 		}

tests/libslic3r/test_config.cpp

@@ -3,6 +3,11 @@
 #include "libslic3r/PrintConfig.hpp"
 #include "libslic3r/LocalesUtils.hpp"
 
+#include <cereal/types/polymorphic.hpp>
+#include <cereal/types/string.hpp> 
+#include <cereal/types/vector.hpp> 
+#include <cereal/archives/binary.hpp>
+
 using namespace Slic3r;
 
 SCENARIO("Generic config validation performs as expected.", "[Config]") {
@@ -202,3 +207,33 @@ SCENARIO("Config ini load/save interface", "[Config]") {
         }
     }
 }
+
+SCENARIO("DynamicPrintConfig serialization", "[Config]") {
+    WHEN("DynamicPrintConfig is serialized and deserialized") {
+        FullPrintConfig full_print_config;
+        DynamicPrintConfig cfg;
+        cfg.apply(full_print_config, false);
+
+        std::string serialized;
+        try {
+            std::ostringstream ss;
+            cereal::BinaryOutputArchive oarchive(ss);
+            oarchive(cfg);
+            serialized = ss.str();
+        } catch (std::runtime_error e) {
+            e.what();
+        }
+
+        THEN("Config object contains ini file options.") {
+            DynamicPrintConfig cfg2;
+            try {
+                std::stringstream ss(serialized);
+                cereal::BinaryInputArchive iarchive(ss);
+                iarchive(cfg2);
+            } catch (std::runtime_error e) {
+                e.what();
+            }
+            REQUIRE(cfg == cfg2);
+        }
+    }
+}

tests/libslic3r/test_geometry.cpp

@@ -9,6 +9,14 @@
 #include "libslic3r/ClipperUtils.hpp"
 #include "libslic3r/ShortestPath.hpp"
 
+//#include <random>
+//#include "libnest2d/tools/benchmark.h"
+#include "libslic3r/SVG.hpp"
+
+#include "../libnest2d/printer_parts.hpp"
+
+#include <unordered_set>
+
 using namespace Slic3r;
 
 TEST_CASE("Polygon::contains works properly", "[Geometry]"){
@@ -452,3 +460,225 @@ SCENARIO("Ported from xs/t/14_geometry.t", "[Geometry]"){
     	REQUIRE(! Slic3r::Geometry::directions_parallel(M_PI /2, PI, M_PI /180));
     }
 }
+
+TEST_CASE("Convex polygon intersection on two disjoint squares", "[Geometry][Rotcalip]") {
+    Polygon A{{0, 0}, {10, 0}, {10, 10}, {0, 10}};
+    A.scale(1. / SCALING_FACTOR);
+
+    Polygon B = A;
+    B.translate(20 / SCALING_FACTOR, 0);
+
+    bool is_inters = Geometry::intersects(A, B);
+
+    REQUIRE(is_inters == false);
+}
+
+TEST_CASE("Convex polygon intersection on two intersecting squares", "[Geometry][Rotcalip]") {
+    Polygon A{{0, 0}, {10, 0}, {10, 10}, {0, 10}};
+    A.scale(1. / SCALING_FACTOR);
+
+    Polygon B = A;
+    B.translate(5 / SCALING_FACTOR, 5 / SCALING_FACTOR);
+
+    bool is_inters = Geometry::intersects(A, B);
+
+    REQUIRE(is_inters == true);
+}
+
+TEST_CASE("Convex polygon intersection on two squares touching one edge", "[Geometry][Rotcalip]") {
+    Polygon A{{0, 0}, {10, 0}, {10, 10}, {0, 10}};
+    A.scale(1. / SCALING_FACTOR);
+
+    Polygon B = A;
+    B.translate(10 / SCALING_FACTOR, 0);
+
+    bool is_inters = Geometry::intersects(A, B);
+
+    REQUIRE(is_inters == false);
+}
+
+TEST_CASE("Convex polygon intersection on two squares touching one vertex", "[Geometry][Rotcalip]") {
+    Polygon A{{0, 0}, {10, 0}, {10, 10}, {0, 10}};
+    A.scale(1. / SCALING_FACTOR);
+
+    Polygon B = A;
+    B.translate(10 / SCALING_FACTOR, 10 / SCALING_FACTOR);
+
+    SVG svg{std::string("one_vertex_touch") + ".svg"};
+    svg.draw(A, "blue");
+    svg.draw(B, "green");
+    svg.Close();
+
+    bool is_inters = Geometry::intersects(A, B);
+
+    REQUIRE(is_inters == false);
+}
+
+TEST_CASE("Convex polygon intersection on two overlapping squares", "[Geometry][Rotcalip]") {
+    Polygon A{{0, 0}, {10, 0}, {10, 10}, {0, 10}};
+    A.scale(1. / SCALING_FACTOR);
+
+    Polygon B = A;
+
+    bool is_inters = Geometry::intersects(A, B);
+
+    REQUIRE(is_inters == true);
+}
+
+//// Only for benchmarking
+//static Polygon gen_convex_poly(std::mt19937_64 &rg, size_t point_cnt)
+//{
+//    std::uniform_int_distribution<coord_t> dist(0, 100);
+
+//    Polygon out;
+//    out.points.reserve(point_cnt);
+
+//    coord_t tr = dist(rg) * 2 / SCALING_FACTOR;
+
+//    for (size_t i = 0; i < point_cnt; ++i)
+//        out.points.emplace_back(tr + dist(rg) / SCALING_FACTOR,
+//                                tr + dist(rg) / SCALING_FACTOR);
+
+//    return Geometry::convex_hull(out.points);
+//}
+//TEST_CASE("Convex polygon intersection test on random polygons", "[Geometry]") {
+//    constexpr size_t TEST_CNT = 1000;
+//    constexpr size_t POINT_CNT = 1000;
+
+//    auto seed = std::random_device{}();
+////    unsigned long seed = 2525634386;
+//    std::mt19937_64 rg{seed};
+//    Benchmark bench;
+
+//    auto tests = reserve_vector<std::pair<Polygon, Polygon>>(TEST_CNT);
+//    auto results = reserve_vector<bool>(TEST_CNT);
+//    auto expects = reserve_vector<bool>(TEST_CNT);
+
+//    for (size_t i = 0; i < TEST_CNT; ++i) {
+//        tests.emplace_back(gen_convex_poly(rg, POINT_CNT), gen_convex_poly(rg, POINT_CNT));
+//    }
+
+//    bench.start();
+//    for (const auto &test : tests)
+//        results.emplace_back(Geometry::intersects(test.first, test.second));
+//    bench.stop();
+
+//    std::cout << "Test time: " << bench.getElapsedSec() << std::endl;
+
+//    bench.start();
+//    for (const auto &test : tests)
+//        expects.emplace_back(!intersection(test.first, test.second).empty());
+//    bench.stop();
+
+//    std::cout << "Clipper time: " << bench.getElapsedSec() << std::endl;
+
+//    REQUIRE(results.size() == expects.size());
+
+//    auto seedstr = std::to_string(seed);
+//    for (size_t i = 0; i < results.size(); ++i) {
+//        // std::cout << expects[i] << " ";
+
+//        if (results[i] != expects[i]) {
+//            SVG svg{std::string("fail_seed") + seedstr + "_" + std::to_string(i) + ".svg"};
+//            svg.draw(tests[i].first, "blue");
+//            svg.draw(tests[i].second, "green");
+//            svg.Close();
+
+//            // std::cout << std::endl;
+//        }
+//        REQUIRE(results[i] == expects[i]);
+//    }
+//    std::cout << std::endl;
+
+//}
+
+struct Pair
+{
+    size_t first, second;
+    bool operator==(const Pair &b) const { return first == b.first && second == b.second; }
+};
+
+template<> struct std::hash<Pair> {
+    size_t operator()(const Pair &c) const
+    {
+        return c.first * PRINTER_PART_POLYGONS.size() + c.second;
+    }
+};
+
+TEST_CASE("Convex polygon intersection test prusa polygons", "[Geometry][Rotcalip]") {
+
+    // Overlap of the same polygon should always be an intersection
+    for (size_t i = 0; i < PRINTER_PART_POLYGONS.size(); ++i) {
+        Polygon P = PRINTER_PART_POLYGONS[i];
+        P = Geometry::convex_hull(P.points);
+        bool res = Geometry::intersects(P, P);
+        if (!res) {
+            SVG svg{std::string("fail_self") + std::to_string(i) + ".svg"};
+            svg.draw(P, "green");
+            svg.Close();
+        }
+        REQUIRE(res == true);
+    }
+
+    std::unordered_set<Pair> combos;
+    for (size_t i = 0; i < PRINTER_PART_POLYGONS.size(); ++i) {
+        for (size_t j = 0; j < PRINTER_PART_POLYGONS.size(); ++j) {
+            if (i != j) {
+                size_t a = std::min(i, j), b = std::max(i, j);
+                combos.insert(Pair{a, b});
+            }
+        }
+    }
+
+    // All disjoint
+    for (const auto &combo : combos) {
+        Polygon A = PRINTER_PART_POLYGONS[combo.first], B = PRINTER_PART_POLYGONS[combo.second];
+        A = Geometry::convex_hull(A.points);
+        B = Geometry::convex_hull(B.points);
+
+        auto bba = A.bounding_box();
+        auto bbb = B.bounding_box();
+
+        A.translate(-bba.center());
+        B.translate(-bbb.center());
+
+        B.translate(bba.size() + bbb.size());
+
+        bool res = Geometry::intersects(A, B);
+        bool ref = !intersection(A, B).empty();
+
+        if (res != ref) {
+            SVG svg{std::string("fail") + std::to_string(combo.first) + "_" + std::to_string(combo.second) + ".svg"};
+            svg.draw(A, "blue");
+            svg.draw(B, "green");
+            svg.Close();
+        }
+
+        REQUIRE(res == ref);
+    }
+
+    // All intersecting
+    for (const auto &combo : combos) {
+        Polygon A = PRINTER_PART_POLYGONS[combo.first], B = PRINTER_PART_POLYGONS[combo.second];
+        A = Geometry::convex_hull(A.points);
+        B = Geometry::convex_hull(B.points);
+
+        auto bba = A.bounding_box();
+        auto bbb = B.bounding_box();
+
+        A.translate(-bba.center());
+        B.translate(-bbb.center());
+
+        bool res = Geometry::intersects(A, B);
+        bool ref = !intersection(A, B).empty();
+
+        if (res != ref) {
+            SVG svg{std::string("fail") + std::to_string(combo.first) + "_" + std::to_string(combo.second) + ".svg"};
+            svg.draw(A, "blue");
+            svg.draw(B, "green");
+            svg.Close();
+        }
+
+        REQUIRE(res == ref);
+    }
+}

tests/libslic3r/test_hollowing.cpp

@@ -13,7 +13,6 @@ TEST_CASE("Hollow two overlapping spheres") {
     sphere2.translate( 5.f, 0.f, 0.f);
 
     sphere1.merge(sphere2);
-    sphere1.require_shared_vertices();
 
     sla::hollow_mesh(sphere1, sla::HollowingConfig{}, sla::HollowingFlags::hfRemoveInsideTriangles);
 

tests/libslic3r/test_marchingsquares.cpp

@@ -319,7 +319,6 @@ static void recreate_object_from_rasters(const std::string &objname, float lh) {
     mesh.translate(tr.x(), tr.y(), tr.z());
     bb = mesh.bounding_box();
     
-    assert(mesh.has_shared_vertices());
     std::vector<ExPolygons> layers = slice_mesh_ex(mesh.its, grid(float(bb.min.z()) + lh, float(bb.max.z()), lh));
     
     sla::RasterBase::Resolution res{2560, 1440};