packingsolver 0.1.1237__tar.gz → 0.1.1245__tar.gz

{packingsolver-0.1.1237 → packingsolver-0.1.1245}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: packingsolver
-Version: 0.1.1237
+Version: 0.1.1245
 Summary: A solver for geometrical packing and cutting-stock problems
 Author: Florian Fontan
 License-Expression: MIT

{packingsolver-0.1.1237 → packingsolver-0.1.1245}/include/packingsolver/irregular/optimize.hpp

@@ -210,6 +210,12 @@ struct OptimizeParameters: packingsolver::Parameters<Instance, Solution, Output>
     /** Use tree search periodic packing algorithm. */
     bool use_tree_search_periodic_packing = false;
 
+    /**
+     * Use tree search maximal spaces algorithm (only for instances with a
+     * single bin; never selected automatically).
+     */
+    bool use_tree_search_maximal_spaces = false;
+
     /**
      * Use local search algorithm with the linear programming engine (the
      * items are shrunk to remove the overlaps).
@@ -350,6 +356,9 @@ struct OptimizeParameters: packingsolver::Parameters<Instance, Solution, Output>
     /** Size of the queue in the tree search periodic packing algorithm. */
     NodeId not_anytime_tree_search_periodic_packing_queue_size = 16;
 
+    /** Size of the queue in the tree search maximal spaces algorithm. */
+    NodeId not_anytime_tree_search_maximal_spaces_queue_size = 4;
+
     /**
      * Size of the queue in the single knapsack subproblem of the sequential
      * single knapsack algorithm.

packingsolver-0.1.1245/python/packingsolver/_version.py

@@ -0,0 +1 @@
+__version__ = "0.1.1245"

{packingsolver-0.1.1237 → packingsolver-0.1.1245}/python/src/irregular.cpp

@@ -661,6 +661,7 @@ void bind_irregular(nb::module_& m)
         .def_rw("linear_programming_solver_name", &OptimizeParameters::linear_programming_solver_name)
         .def_rw("use_tree_search", &OptimizeParameters::use_tree_search)
         .def_rw("use_tree_search_periodic_packing", &OptimizeParameters::use_tree_search_periodic_packing)
+        .def_rw("use_tree_search_maximal_spaces", &OptimizeParameters::use_tree_search_maximal_spaces)
         .def_rw("use_local_search_linear_programming", &OptimizeParameters::use_local_search_linear_programming)
         .def_rw("use_local_search_nonlinear_programming", &OptimizeParameters::use_local_search_nonlinear_programming)
         .def_rw("use_local_search_direct_trigonometry", &OptimizeParameters::use_local_search_direct_trigonometry)
@@ -682,6 +683,7 @@ void bind_irregular(nb::module_& m)
         .def_rw("not_anytime_maximum_approximation_ratio", &OptimizeParameters::not_anytime_maximum_approximation_ratio)
         .def_rw("not_anytime_tree_search_queue_size", &OptimizeParameters::not_anytime_tree_search_queue_size)
         .def_rw("not_anytime_tree_search_periodic_packing_queue_size", &OptimizeParameters::not_anytime_tree_search_periodic_packing_queue_size)
+        .def_rw("not_anytime_tree_search_maximal_spaces_queue_size", &OptimizeParameters::not_anytime_tree_search_maximal_spaces_queue_size)
         .def_rw("not_anytime_sequential_single_knapsack_subproblem_tree_search_queue_size", &OptimizeParameters::not_anytime_sequential_single_knapsack_subproblem_tree_search_queue_size)
         .def_rw("not_anytime_sequential_value_correction_number_of_iterations", &OptimizeParameters::not_anytime_sequential_value_correction_number_of_iterations)
         .def_rw("not_anytime_local_search_maximum_number_of_failed_separations", &OptimizeParameters::not_anytime_local_search_maximum_number_of_failed_separations)

{packingsolver-0.1.1237 → packingsolver-0.1.1245}/src/irregular/CMakeLists.txt

@@ -12,8 +12,12 @@ target_sources(PackingSolver_irregular PRIVATE
     shape_simplification.cpp
     rotations.cpp
     periodic_packing.cpp
+    empty_spaces.cpp
+    trapezoid_set.cpp
+    trapezoid_slider.cpp
     tree_search.cpp
     tree_search_periodic_packing.cpp
+    tree_search_maximal_spaces.cpp
     linear_programming/anchor.cpp
     linear_programming/separation_model.cpp
     linear_programming/separator.cpp

packingsolver-0.1.1245/src/irregular/empty_spaces.cpp

@@ -0,0 +1,156 @@
+#include "irregular/empty_spaces.hpp"
+
+using namespace packingsolver;
+using namespace packingsolver::irregular;
+
+bool packingsolver::irregular::overlaps(
+        const EmptySpace& space,
+        Point bl_corner,
+        LengthDbl bx,
+        LengthDbl by)
+{
+    return shape::strictly_lesser(bl_corner.x, space.xe())
+        && shape::strictly_greater(bl_corner.x + bx, space.xs())
+        && shape::strictly_lesser(bl_corner.y, space.ye())
+        && shape::strictly_greater(bl_corner.y + by, space.ys());
+}
+
+void packingsolver::irregular::add_empty_space(
+        std::vector<EmptySpace>& spaces,
+        const EmptySpace& new_space)
+{
+    if (!shape::strictly_greater(new_space.bx, 0.0) || !shape::strictly_greater(new_space.by, 0.0))
+        return;
+    for (const EmptySpace& existing: spaces)
+        if (existing.contains(new_space))
+            return;
+    spaces.push_back(new_space);
+}
+
+void packingsolver::irregular::cut_empty_spaces(
+        std::vector<EmptySpace>& spaces,
+        Point bl_corner,
+        LengthDbl bx,
+        LengthDbl by)
+{
+    for (ItemPos i = 0; i < (ItemPos)spaces.size(); ) {
+        if (!overlaps(spaces[i], bl_corner, bx, by)) {
+            ++i;
+            continue;
+        }
+        EmptySpace space = spaces[i];
+        spaces[i] = spaces.back();
+        spaces.pop_back();
+
+        // Left (x-)
+        if (shape::strictly_greater(bl_corner.x, space.xs())) {
+            EmptySpace sub;
+            sub.bl_corner.x = space.bl_corner.x;
+            sub.bl_corner.y = space.bl_corner.y;
+            sub.bx = bl_corner.x - space.bl_corner.x;
+            sub.by = space.by;
+            add_empty_space(spaces, sub);
+        }
+        // Right (x+)
+        if (shape::strictly_lesser(bl_corner.x + bx, space.xe())) {
+            EmptySpace sub;
+            sub.bl_corner.x = bl_corner.x + bx;
+            sub.bl_corner.y = space.bl_corner.y;
+            sub.bx = space.xe() - (bl_corner.x + bx);
+            sub.by = space.by;
+            add_empty_space(spaces, sub);
+        }
+        // Bottom (y-)
+        if (shape::strictly_greater(bl_corner.y, space.ys())) {
+            EmptySpace sub;
+            sub.bl_corner.x = space.bl_corner.x;
+            sub.bl_corner.y = space.bl_corner.y;
+            sub.bx = space.bx;
+            sub.by = bl_corner.y - space.bl_corner.y;
+            add_empty_space(spaces, sub);
+        }
+        // Top (y+)
+        if (shape::strictly_lesser(bl_corner.y + by, space.ye())) {
+            EmptySpace sub;
+            sub.bl_corner.x = space.bl_corner.x;
+            sub.bl_corner.y = bl_corner.y + by;
+            sub.bx = space.bx;
+            sub.by = space.ye() - (bl_corner.y + by);
+            add_empty_space(spaces, sub);
+        }
+        // Do not increment i: the element swapped into position i must be checked.
+    }
+}
+
+void packingsolver::irregular::cut_empty_spaces(
+        std::vector<EmptySpace>& spaces,
+        const std::vector<AxisAlignedBoundingBox>& rectangles,
+        LengthDbl minimum_width,
+        LengthDbl minimum_height)
+{
+    if (rectangles.empty())
+        return;
+    AxisAlignedBoundingBox rectangles_aabb;
+    for (const AxisAlignedBoundingBox& rectangle: rectangles)
+        rectangles_aabb = merge(rectangles_aabb, rectangle);
+
+    // Cut each empty space overlapping a rectangle by all the rectangles,
+    // on its own: the containment checks are then only made between its own
+    // parts, and its final parts are checked against all the empty spaces
+    // once.
+    std::vector<EmptySpace> new_spaces;
+    std::vector<EmptySpace> parts;
+    for (ItemPos space_pos = 0; space_pos < (ItemPos)spaces.size(); ) {
+        const EmptySpace& space = spaces[space_pos];
+        bool cut = false;
+        if (overlaps(
+                    space,
+                    {rectangles_aabb.x_min, rectangles_aabb.y_min},
+                    rectangles_aabb.x_max - rectangles_aabb.x_min,
+                    rectangles_aabb.y_max - rectangles_aabb.y_min)) {
+            for (const AxisAlignedBoundingBox& rectangle: rectangles) {
+                if (overlaps(
+                            space,
+                            {rectangle.x_min, rectangle.y_min},
+                            rectangle.x_max - rectangle.x_min,
+                            rectangle.y_max - rectangle.y_min)) {
+                    cut = true;
+                    break;
+                }
+            }
+        }
+        if (!cut) {
+            ++space_pos;
+            continue;
+        }
+        parts = {space};
+        spaces[space_pos] = spaces.back();
+        spaces.pop_back();
+        for (const AxisAlignedBoundingBox& rectangle: rectangles) {
+            cut_empty_spaces(
+                    parts,
+                    {rectangle.x_min, rectangle.y_min},
+                    rectangle.x_max - rectangle.x_min,
+                    rectangle.y_max - rectangle.y_min);
+        }
+        for (const EmptySpace& part: parts) {
+            if (shape::strictly_lesser(part.bx, minimum_width)
+                    || shape::strictly_lesser(part.by, minimum_height)) {
+                continue;
+            }
+            new_spaces.push_back(part);
+        }
+    }
+
+    // Add the largest parts first, so that a part is never added before a
+    // part containing it.
+    std::sort(
+            new_spaces.begin(),
+            new_spaces.end(),
+            [](const EmptySpace& space_1, const EmptySpace& space_2)
+            {
+                return space_1.area() > space_2.area();
+            });
+    for (const EmptySpace& new_space: new_spaces)
+        add_empty_space(spaces, new_space);
+}

packingsolver-0.1.1245/src/irregular/empty_spaces.hpp

@@ -0,0 +1,82 @@
+#pragma once
+
+#include "packingsolver/irregular/instance.hpp"
+
+namespace packingsolver
+{
+namespace irregular
+{
+
+/**
+ * A maximal empty space: the largest axis-aligned rectangle that can be placed
+ * at a given position without overlapping any placed block or the bin walls.
+ * All lengths are in scaled coordinates.
+ */
+struct EmptySpace
+{
+    Point bl_corner = {0.0, 0.0};
+    LengthDbl bx = 0.0;
+    LengthDbl by = 0.0;
+
+    inline LengthDbl xs() const { return bl_corner.x; }
+    inline LengthDbl ys() const { return bl_corner.y; }
+    inline LengthDbl xe() const { return bl_corner.x + bx; }
+    inline LengthDbl ye() const { return bl_corner.y + by; }
+
+    /** Returns true iff this space fully contains other. */
+    inline bool contains(const EmptySpace& other) const
+    {
+        return !strictly_greater(xs(), other.xs())
+            && !strictly_greater(ys(), other.ys())
+            && !strictly_lesser(xe(), other.xe())
+            && !strictly_lesser(ye(), other.ye());
+    }
+
+    inline AreaDbl area() const { return bx * by; }
+};
+
+/**
+ * Return 'true' iff the rectangle of bottom-left corner 'bl_corner' and of
+ * dimensions 'bx' x 'by' overlaps the empty space.
+ */
+bool overlaps(
+        const EmptySpace& space,
+        Point bl_corner,
+        LengthDbl bx,
+        LengthDbl by);
+
+/**
+ * Add an empty space to a list of maximal empty spaces, unless it is empty or
+ * contained in one of them.
+ */
+void add_empty_space(
+        std::vector<EmptySpace>& spaces,
+        const EmptySpace& new_space);
+
+/**
+ * Update a list of maximal empty spaces when the rectangle of bottom-left
+ * corner 'bl_corner' and of dimensions 'bx' x 'by' gets occupied: each empty
+ * space it overlaps is replaced by its (up to four) parts on the left, on the
+ * right, below and above the rectangle.
+ */
+void cut_empty_spaces(
+        std::vector<EmptySpace>& spaces,
+        Point bl_corner,
+        LengthDbl bx,
+        LengthDbl by);
+
+/**
+ * Update a list of maximal empty spaces when a set of rectangles gets
+ * occupied.
+ *
+ * The new empty spaces narrower than 'minimum_width' or lower than
+ * 'minimum_height' are discarded.
+ */
+void cut_empty_spaces(
+        std::vector<EmptySpace>& spaces,
+        const std::vector<AxisAlignedBoundingBox>& rectangles,
+        LengthDbl minimum_width = 0.0,
+        LengthDbl minimum_height = 0.0);
+
+}
+}

{packingsolver-0.1.1237 → packingsolver-0.1.1245}/src/irregular/main.cpp

@@ -85,6 +85,7 @@ int main(int argc, char *argv[])
             ("optimization-mode,", po::value<OptimizationMode>(), "set optimization mode")
             ("use-tree-search,", po::value<bool>(), "enable tree search algorithm")
             ("use-tree-search-periodic-packing,", po::value<bool>(), "enable tree search periodic packing algorithm")
+            ("use-tree-search-maximal-spaces,", po::value<bool>(), "enable tree search maximal spaces algorithm")
             ("use-milp-raster,", po::value<bool>(), "enable MILP raster algorithm")
             ("use-local-search-linear-programming,", po::value<bool>(), "enable local search algorithm with the linear programming engine")
             ("use-local-search-nonlinear-programming,", po::value<bool>(), "enable local search algorithm with the nonlinear programming engine (requires Knitro)")
@@ -104,6 +105,7 @@ int main(int argc, char *argv[])
             ("not-anytime-maximum-approximation-ratio,", po::value<double>(), "")
             ("not-anytime-tree-search-queue-size,", po::value<Counter>(), "")
             ("not-anytime-tree-search-periodic-packing-queue-size,", po::value<Counter>(), "")
+            ("not-anytime-tree-search-maximal-spaces-queue-size,", po::value<Counter>(), "")
             ("not-anytime-sequential-single-knapsack-subproblem-tree-search-queue-size,", po::value<Counter>(), "")
             ("not-anytime-sequential-value-correction-number-of-iterations,", po::value<Counter>(), "")
             ("not-anytime-local-search-maximum-number-of-failed-separations,", po::value<Counter>(), "")
@@ -177,6 +179,8 @@ int main(int argc, char *argv[])
             parameters.use_tree_search = vm["use-tree-search"].as<bool>();
         if (vm.count("use-tree-search-periodic-packing"))
             parameters.use_tree_search_periodic_packing = vm["use-tree-search-periodic-packing"].as<bool>();
+        if (vm.count("use-tree-search-maximal-spaces"))
+            parameters.use_tree_search_maximal_spaces = vm["use-tree-search-maximal-spaces"].as<bool>();
         if (vm.count("use-milp-raster"))
             parameters.use_milp_raster = vm["use-milp-raster"].as<bool>();
         if (vm.count("use-local-search-linear-programming"))
@@ -214,6 +218,8 @@ int main(int argc, char *argv[])
             parameters.not_anytime_tree_search_queue_size = vm["not-anytime-tree-search-queue-size"].as<Counter>();
         if (vm.count("not-anytime-tree-search-periodic-packing-queue-size"))
             parameters.not_anytime_tree_search_periodic_packing_queue_size = vm["not-anytime-tree-search-periodic-packing-queue-size"].as<Counter>();
+        if (vm.count("not-anytime-tree-search-maximal-spaces-queue-size"))
+            parameters.not_anytime_tree_search_maximal_spaces_queue_size = vm["not-anytime-tree-search-maximal-spaces-queue-size"].as<Counter>();
         if (vm.count("not-anytime-sequential-single-knapsack-subproblem-tree-search-queue-size"))
             parameters.not_anytime_sequential_single_knapsack_subproblem_tree_search_queue_size = vm["not-anytime-sequential-single-knapsack-subproblem-tree-search-queue-size"].as<Counter>();
         if (vm.count("not-anytime-sequential-value-correction-number-of-iterations"))

{packingsolver-0.1.1237 → packingsolver-0.1.1245}/src/irregular/optimize.cpp

@@ -6,6 +6,7 @@
 #include "irregular/trivial.hpp"
 #include "irregular/tree_search.hpp"
 #include "irregular/tree_search_periodic_packing.hpp"
+#include "irregular/tree_search_maximal_spaces.hpp"
 #include "irregular/milp_raster.hpp"
 #include "irregular/local_search.hpp"
 #include "algorithms/dichotomic_search.hpp"
@@ -765,6 +766,30 @@ void optimize_tree_search_periodic_packing(
     tree_search_periodic_packing(instance, ts_pp_parameters);
 }
 
+void optimize_tree_search_maximal_spaces(
+        const Instance& instance,
+        const OptimizeParameters& parameters,
+        AlgorithmFormatter& algorithm_formatter)
+{
+    TreeSearchMaximalSpacesParameters ts_ms_parameters;
+    ts_ms_parameters.verbosity_level = 0;
+    ts_ms_parameters.timer = parameters.timer;
+    ts_ms_parameters.timer.add_end_boolean(&algorithm_formatter.end_boolean());
+    ts_ms_parameters.optimization_mode = parameters.optimization_mode;
+    ts_ms_parameters.not_anytime_tree_search_queue_size
+        = parameters.not_anytime_tree_search_maximal_spaces_queue_size;
+    ts_ms_parameters.maximum_approximation_ratio
+        = parameters.not_anytime_maximum_approximation_ratio;
+    ts_ms_parameters.new_solution_callback = [&algorithm_formatter](
+            const packingsolver::Output<Instance, Solution>& ts_output)
+    {
+        algorithm_formatter.update_solution(
+                ts_output.solution_pool.best(),
+                "TSMS " + ts_output.solution_pool.best_label());
+    };
+    tree_search_maximal_spaces(instance, ts_ms_parameters);
+}
+
 void optimize_milp_raster(
         const Instance& instance,
         const OptimizeParameters& parameters,
@@ -970,6 +995,7 @@ packingsolver::irregular::Output packingsolver::irregular::optimize(
         = largest_bin_space(instance) / mean_item_space(instance);
     bool use_tree_search = parameters.use_tree_search;
     bool use_tree_search_periodic_packing = parameters.use_tree_search_periodic_packing;
+    bool use_tree_search_maximal_spaces = parameters.use_tree_search_maximal_spaces;
     bool use_local_search_linear_programming = parameters.use_local_search_linear_programming;
     bool use_local_search_nonlinear_programming = parameters.use_local_search_nonlinear_programming;
     bool use_local_search_direct_trigonometry = parameters.use_local_search_direct_trigonometry;
@@ -996,6 +1022,7 @@ packingsolver::irregular::Output packingsolver::irregular::optimize(
         // Automatic selection.
         if (!use_tree_search
                 && !use_tree_search_periodic_packing
+                && !use_tree_search_maximal_spaces
                 && !use_local_search_linear_programming
                 && !use_local_search_nonlinear_programming
                 && !use_local_search_direct_trigonometry
@@ -1196,6 +1223,9 @@ packingsolver::irregular::Output packingsolver::irregular::optimize(
             }
         }
     }
+    // tree_search_maximal_spaces only supports a single bin.
+    if (instance.number_of_bins() > 1)
+        use_tree_search_maximal_spaces = false;
 
     // Run selected algorithms.
     // In 'NotAnytimeDeterministic' mode, algorithms still run in parallel, but
@@ -1271,6 +1301,19 @@ packingsolver::irregular::Output packingsolver::irregular::optimize(
                     *context.second);
         });
     }
+    // Tree search maximal spaces.
+    if (use_tree_search_maximal_spaces) {
+        exception_ptr_list.push_front(std::exception_ptr());
+        std::exception_ptr& exception_ptr = exception_ptr_list.front();
+        auto context = task_context();
+        tasks.push_back([&exception_ptr, &instance, context]() {
+            wrapper<decltype(&optimize_tree_search_maximal_spaces), optimize_tree_search_maximal_spaces>(
+                    exception_ptr,
+                    instance,
+                    *context.first,
+                    *context.second);
+        });
+    }
     // Tree search periodic packing.
     if (use_tree_search_periodic_packing) {
         exception_ptr_list.push_front(std::exception_ptr());