Working arrange_objects with DJD selection heuristic and a bottom-left placement strategy.

xs/src/libslic3r/Fill/FillRectilinear3.cpp

@@ -470,9 +470,9 @@ static bool prepare_infill_hatching_segments(
 			int ir = std::min<int>(int(out.segs.size()) - 1, (r - x0) / line_spacing);
             // The previous tests were done with floating point arithmetics over an epsilon-extended interval.
             // Now do the same tests with exact arithmetics over the exact interval.
-            while (il <= ir && Int128::orient(out.segs[il].pos, out.segs[il].pos + out.direction, *pl) < 0)
+            while (il <= ir && int128::orient(out.segs[il].pos, out.segs[il].pos + out.direction, *pl) < 0)
                 ++ il;
-            while (il <= ir && Int128::orient(out.segs[ir].pos, out.segs[ir].pos + out.direction, *pr) > 0)
+            while (il <= ir && int128::orient(out.segs[ir].pos, out.segs[ir].pos + out.direction, *pr) > 0)
                 -- ir;
             // Here it is ensured, that
             // 1) out.seg is not parallel to (pl, pr)
@@ -489,8 +489,8 @@ static bool prepare_infill_hatching_segments(
 				is.iSegment = iSegment;
                 // Test whether the calculated intersection point falls into the bounding box of the input segment.
                 // +-1 to take rounding into account.
-				assert(Int128::orient(out.segs[i].pos, out.segs[i].pos + out.direction, *pl) >= 0);
-				assert(Int128::orient(out.segs[i].pos, out.segs[i].pos + out.direction, *pr) <= 0);
+                assert(int128::orient(out.segs[i].pos, out.segs[i].pos + out.direction, *pl) >= 0);
+                assert(int128::orient(out.segs[i].pos, out.segs[i].pos + out.direction, *pr) <= 0);
                 assert(is.pos().x + 1 >= std::min(pl->x, pr->x));
                 assert(is.pos().y + 1 >= std::min(pl->y, pr->y));
                 assert(is.pos().x     <= std::max(pl->x, pr->x) + 1);
@@ -527,7 +527,7 @@ static bool prepare_infill_hatching_segments(
             const Points &contour = poly_with_offset.contour(iContour).points;
             size_t iSegment = sil.intersections[i].iSegment;
             size_t iPrev    = ((iSegment == 0) ? contour.size() : iSegment) - 1;
-			int    dir      = Int128::cross(contour[iSegment] - contour[iPrev], sil.dir);
+            int    dir      = int128::cross(contour[iSegment] - contour[iPrev], sil.dir);
             bool low = dir > 0;
             sil.intersections[i].type = poly_with_offset.is_contour_outer(iContour) ? 
                 (low ? SegmentIntersection::OUTER_LOW : SegmentIntersection::OUTER_HIGH) :

xs/src/libslic3r/Int128.hpp

@@ -48,7 +48,6 @@
 #endif
 
 #include <cassert>
-#include "Point.hpp"
 
 #if ! defined(_MSC_VER) && defined(__SIZEOF_INT128__)
 	#define HAS_INTRINSIC_128_TYPE
@@ -288,20 +287,4 @@ public:
 		}
 		return sign_determinant_2x2(p1, q1, p2, q2) * invert;
 	}
-
-	// Exact orientation predicate,
-	// returns +1: CCW, 0: collinear, -1: CW.
-	static int orient(const Slic3r::Point &p1, const Slic3r::Point &p2, const Slic3r::Point &p3)
-	{
-		Slic3r::Vector v1(p2 - p1);
-		Slic3r::Vector v2(p3 - p1);
-		return sign_determinant_2x2_filtered(v1.x, v1.y, v2.x, v2.y);
-	}
-
-	// Exact orientation predicate,
-	// returns +1: CCW, 0: collinear, -1: CW.
-	static int cross(const Slic3r::Point &v1, const Slic3r::Point &v2)
-	{
-		return sign_determinant_2x2_filtered(v1.x, v1.y, v2.x, v2.y);
-	}
 };

xs/src/libslic3r/Model.cpp

@@ -7,6 +7,12 @@
 #include "Format/STL.hpp"
 #include "Format/3mf.hpp"
 
+#include <numeric>
+#include <libnest2d.h>
+#include <libnest2d/geometries_io.hpp>
+#include <ClipperUtils.hpp>
+#include "slic3r/GUI/GUI.hpp"
+
 #include <float.h>
 
 #include <boost/algorithm/string/predicate.hpp>
@@ -296,35 +302,224 @@ static bool _arrange(const Pointfs &sizes, coordf_t dist, const BoundingBoxf* bb
     return result;
 }
 
+namespace arr {
+
+using namespace libnest2d;
+
+// A container which stores a pointer to the 3D object and its projected
+// 2D shape from top view.
+using ShapeData2D =
+    std::vector<std::pair<Slic3r::ModelInstance*, Item>>;
+
+ShapeData2D projectModelFromTop(const Slic3r::Model &model) {
+    ShapeData2D ret;
+
+    auto s = std::accumulate(model.objects.begin(), model.objects.end(), 0,
+                    [](size_t s, ModelObject* o){
+        return s + o->instances.size();
+    });
+
+    ret.reserve(s);
+
+    for(auto objptr : model.objects) {
+        if(objptr) {
+
+            auto rmesh = objptr->raw_mesh();
+
+            for(auto objinst : objptr->instances) {
+                if(objinst) {
+                    Slic3r::TriangleMesh tmpmesh = rmesh;
+                    objinst->transform_mesh(&tmpmesh);
+                    ClipperLib::PolyNode pn;
+                    auto p = tmpmesh.convex_hull();
+                    p.make_clockwise();
+                    p.append(p.first_point());
+                    pn.Contour = Slic3rMultiPoint_to_ClipperPath( p );
+
+                    ret.emplace_back(objinst, Item(std::move(pn)));
+                }
+            }
+        }
+    }
+
+    return ret;
+}
+
+/**
+ * \brief Arranges the model objects on the screen.
+ *
+ * The arrangement considers multiple bins (aka. print beds) for placing all
+ * the items provided in the model argument. If the items don't fit on one
+ * print bed, the remaining will be placed onto newly created print beds.
+ * The first_bin_only parameter, if set to true, disables this behaviour and
+ * makes sure that only one print bed is filled and the remaining items will be
+ * untouched. When set to false, the items which could not fit onto the
+ * print bed will be placed next to the print bed so the user should see a
+ * pile of items on the print bed and some other piles outside the print
+ * area that can be dragged later onto the print bed as a group.
+ *
+ * \param model The model object with the 3D content.
+ * \param dist The minimum distance which is allowed for any pair of items
+ * on the print bed  in any direction.
+ * \param bb The bounding box of the print bed. It corresponds to the 'bin'
+ * for bin packing.
+ * \param first_bin_only This parameter controls whether to place the
+ * remaining items which do not fit onto the print area next to the print
+ * bed or leave them untouched (let the user arrange them by hand or remove
+ * them).
+ */
+bool arrange(Model &model, coordf_t dist, const Slic3r::BoundingBoxf* bb,
+             bool first_bin_only)
+{
+    using ArrangeResult = _IndexedPackGroup<PolygonImpl>;
+
+    bool ret = true;
+
+    // Create the arranger config
+    auto min_obj_distance = static_cast<Coord>(dist/SCALING_FACTOR);
+
+    // Get the 2D projected shapes with their 3D model instance pointers
+    auto shapemap = arr::projectModelFromTop(model);
+
+    double area = 0;
+    double area_max = 0;
+    Item *biggest = nullptr;
+
+    // Copy the references for the shapes only as the arranger expects a
+    // sequence of objects convertible to Item or ClipperPolygon
+    std::vector<std::reference_wrapper<Item>> shapes;
+    shapes.reserve(shapemap.size());
+    std::for_each(shapemap.begin(), shapemap.end(),
+                  [&shapes, &area, min_obj_distance, &area_max, &biggest]
+                  (ShapeData2D::value_type& it)
+    {
+        Item& item = it.second;
+        item.addOffset(min_obj_distance);
+        auto b = ShapeLike::boundingBox(item.transformedShape());
+        auto a = b.width()*b.height();
+        if(area_max < a) {
+            area_max = static_cast<double>(a);
+            biggest = &item;
+        }
+        area += b.width()*b.height();
+        shapes.push_back(std::ref(it.second));
+    });
+
+    Box bin;
+
+    if(bb != nullptr && bb->defined) {
+        // Scale up the bounding box to clipper scale.
+        BoundingBoxf bbb = *bb;
+        bbb.scale(1.0/SCALING_FACTOR);
+
+        bin = Box({
+                    static_cast<libnest2d::Coord>(bbb.min.x),
+                    static_cast<libnest2d::Coord>(bbb.min.y)
+                },
+                {
+                    static_cast<libnest2d::Coord>(bbb.max.x),
+                    static_cast<libnest2d::Coord>(bbb.max.y)
+                });
+    } else {
+        // Just take the biggest item as bin... ?
+        bin = ShapeLike::boundingBox(biggest->transformedShape());
+    }
+
+    // Will use the DJD selection heuristic with the BottomLeft placement
+    // strategy
+    using Arranger = Arranger<BottomLeftPlacer, DJDHeuristic>;
+
+    Arranger arranger(bin, min_obj_distance);
+
+    // Arrange and return the items with their respective indices within the
+    // input sequence.
+    ArrangeResult result =
+            arranger.arrangeIndexed(shapes.begin(), shapes.end());
+
+
+    auto applyResult = [&shapemap](ArrangeResult::value_type& group,
+            Coord batch_offset)
+    {
+        for(auto& r : group) {
+            auto idx = r.first;     // get the original item index
+            Item& item = r.second;  // get the item itself
+
+            // Get the model instance from the shapemap using the index
+            ModelInstance *inst_ptr = shapemap[idx].first;
+
+            // Get the tranformation data from the item object and scale it
+            // appropriately
+            Radians rot = item.rotation();
+            auto off = item.translation();
+            Pointf foff(off.X*SCALING_FACTOR + batch_offset,
+                        off.Y*SCALING_FACTOR);
+
+            // write the tranformation data into the model instance
+            inst_ptr->rotation += rot;
+            inst_ptr->offset += foff;
+
+            // Debug
+            /*std::cout << "item " << idx << ": \n" << "\toffset_x: "
+             * << foff.x << "\n\toffset_y: " << foff.y << std::endl;*/
+        }
+    };
+
+    if(first_bin_only) {
+        applyResult(result.front(), 0);
+    } else {
+        Coord batch_offset = 0;
+        for(auto& group : result) {
+            applyResult(group, batch_offset);
+
+            // Only the first pack group can be placed onto the print bed. The
+            // other objects which could not fit will be placed next to the
+            // print bed
+            batch_offset += static_cast<Coord>(2*bin.width()*SCALING_FACTOR);
+        }
+    }
+
+    for(auto objptr : model.objects) objptr->invalidate_bounding_box();
+
+    return ret && result.size() == 1;
+}
+}
+
 /*  arrange objects preserving their instance count
     but altering their instance positions */
 bool Model::arrange_objects(coordf_t dist, const BoundingBoxf* bb)
 {
-    // get the (transformed) size of each instance so that we take
-    // into account their different transformations when packing
-    Pointfs instance_sizes;
-    Pointfs instance_centers;
-    for (const ModelObject *o : this->objects)
-        for (size_t i = 0; i < o->instances.size(); ++ i) {
-            // an accurate snug bounding box around the transformed mesh.
-            BoundingBoxf3 bbox(o->instance_bounding_box(i, true));
-            instance_sizes.push_back(bbox.size());
-            instance_centers.push_back(bbox.center());
-        }
+    bool ret = false;
+    if(bb != nullptr && bb->defined) {
+        const bool FIRST_BIN_ONLY = true;
+        ret = arr::arrange(*this, dist, bb, FIRST_BIN_ONLY);
+    } else {
+        // get the (transformed) size of each instance so that we take
+        // into account their different transformations when packing
+        Pointfs instance_sizes;
+        Pointfs instance_centers;
+        for (const ModelObject *o : this->objects)
+            for (size_t i = 0; i < o->instances.size(); ++ i) {
+                // an accurate snug bounding box around the transformed mesh.
+                BoundingBoxf3 bbox(o->instance_bounding_box(i, true));
+                instance_sizes.push_back(bbox.size());
+                instance_centers.push_back(bbox.center());
+            }
 
-    Pointfs positions;
-    if (! _arrange(instance_sizes, dist, bb, positions))
-        return false;
-    
-	size_t idx = 0;
-	for (ModelObject *o : this->objects) {
-        for (ModelInstance *i : o->instances) {
-            i->offset = positions[idx] - instance_centers[idx];
-            ++ idx;
+        Pointfs positions;
+        if (! _arrange(instance_sizes, dist, bb, positions))
+            return false;
+
+        size_t idx = 0;
+        for (ModelObject *o : this->objects) {
+            for (ModelInstance *i : o->instances) {
+                i->offset = positions[idx] - instance_centers[idx];
+                ++ idx;
+            }
+            o->invalidate_bounding_box();
         }
-        o->invalidate_bounding_box();
     }
-    return true;
+
+    return ret;
 }
 
 // Duplicate the entire model preserving instance relative positions.

xs/src/libslic3r/Point.cpp

@@ -1,6 +1,7 @@
 #include "Point.hpp"
 #include "Line.hpp"
 #include "MultiPoint.hpp"
+#include "Int128.hpp"
 #include <algorithm>
 #include <cmath>
 
@@ -375,4 +376,20 @@ Pointf3::vector_to(const Pointf3 &point) const
     return Vectorf3(point.x - this->x, point.y - this->y, point.z - this->z);
 }
 
+namespace int128 {
+
+int orient(const Point &p1, const Point &p2, const Point &p3)
+{
+    Slic3r::Vector v1(p2 - p1);
+    Slic3r::Vector v2(p3 - p1);
+    return Int128::sign_determinant_2x2_filtered(v1.x, v1.y, v2.x, v2.y);
+}
+
+int cross(const Point &v1, const Point &v2)
+{
+    return Int128::sign_determinant_2x2_filtered(v1.x, v1.y, v2.x, v2.y);
+}
+
+}
+
 }

xs/src/libslic3r/Point.hpp

@@ -81,6 +81,17 @@ inline Point operator*(double scalar, const Point& point2) { return Point(scalar
 inline int64_t cross(const Point &v1, const Point &v2) { return int64_t(v1.x) * int64_t(v2.y) - int64_t(v1.y) * int64_t(v2.x); }
 inline int64_t dot(const Point &v1, const Point &v2) { return int64_t(v1.x) * int64_t(v2.x) + int64_t(v1.y) * int64_t(v2.y); }
 
+namespace int128 {
+
+// Exact orientation predicate,
+// returns +1: CCW, 0: collinear, -1: CW.
+int orient(const Point &p1, const Point &p2, const Point &p3);
+
+// Exact orientation predicate,
+// returns +1: CCW, 0: collinear, -1: CW.
+int cross(const Point &v1, const Slic3r::Point &v2);
+}
+
 // To be used by std::unordered_map, std::unordered_multimap and friends.
 struct PointHash {
     size_t operator()(const Point &pt) const {