packingsolver 0.1.1235__tar.gz → 0.1.1237__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: packingsolver
-Version: 0.1.1235
+Version: 0.1.1237
 Summary: A solver for geometrical packing and cutting-stock problems
 Author: Florian Fontan
 License-Expression: MIT
@@ -29,7 +29,8 @@ Description-Content-Type: text/markdown
 </p>
 
 <p align="center">
-  <b>A state-of-the-art solver for cutting and packing problems.</b>
+  <b>A state-of-the-art solver for cutting and packing problems</b><br>
+  Nesting, cutting optimization, load planning etc
 </p>
 
 <p align="center">
@@ -38,45 +39,57 @@ Description-Content-Type: text/markdown
   <a href="https://github.com/fontanf/packingsolver/discussions">Ask a question</a>
 </p>
 
-PackingSolver computes cutting and loading plans: given a set of pieces to cut or pack (the **items**) and a set of containers (the **bins**), it finds how to place the items in the bins. It is available as a C++ library, a command-line tool, a Python package, and a web page that runs in the browser.
+<p align="center">
+  <a href="https://fontanf.github.io/packingsolver/rectangleguillotine.html"><img src="https://raw.githubusercontent.com/fontanf/packingsolver/master/img/rectangleguillotine.png" width="32%" alt="Rectangles, guillotine cuts"></a>
+  <a href="https://fontanf.github.io/packingsolver/rectangle.html"><img src="https://raw.githubusercontent.com/fontanf/packingsolver/master/img/rectangle.png" width="32%" alt="Rectangles"></a>
+  <a href="https://fontanf.github.io/packingsolver/irregular.html"><img src="https://raw.githubusercontent.com/fontanf/packingsolver/master/img/irregular.png" width="32%" alt="Irregular shapes"></a>
+  <a href="https://fontanf.github.io/packingsolver/box.html"><img src="https://raw.githubusercontent.com/fontanf/packingsolver/master/img/box.png" width="32%" alt="Boxes"></a>
+  <a href="https://fontanf.github.io/packingsolver/boxstacks.html"><img src="https://raw.githubusercontent.com/fontanf/packingsolver/master/img/boxstacks.png" width="32%" alt="Box stacks"></a>
+  <a href="https://fontanf.github.io/packingsolver/onedimensional.html"><img src="https://raw.githubusercontent.com/fontanf/packingsolver/master/img/onedimensional.png" width="32%" alt="One-dimensional"></a>
+</p>
 
-## Problem types
+PackingSolver computes cutting and loading plans. Given the pieces to cut or to load (the **items**: parts, panels, bars, boxes...) and what they must go into (the **bins**: sheets, plates, stock bars, pallets, trucks, containers...), it finds how to place the items in the bins, for example to use as little material as possible.
 
-| Problem type | Example |
-|:--|:--|
-| [**Rectangles, guillotine cuts**](https://fontanf.github.io/packingsolver/rectangleguillotine.html)<br>`rectangleguillotine`<br>Two-dimensional rectangles cut with edge-to-edge (guillotine) cuts | <img src="https://raw.githubusercontent.com/fontanf/packingsolver/master/img/rectangleguillotine.png" width="480"> |
-| [**Rectangles**](https://fontanf.github.io/packingsolver/rectangle.html)<br>`rectangle`<br>Two-dimensional rectangles | <img src="https://raw.githubusercontent.com/fontanf/packingsolver/master/img/rectangle.png" width="480"> |
-| [**Boxes**](https://fontanf.github.io/packingsolver/box.html)<br>`box`<br>Three-dimensional boxes | <img src="https://raw.githubusercontent.com/fontanf/packingsolver/master/img/box.png" width="480"> |
-| [**Box stacks**](https://fontanf.github.io/packingsolver/boxstacks.html)<br>`boxstacks`<br>Three-dimensional boxes, packed in stacks of items with the same width and length | <img src="https://raw.githubusercontent.com/fontanf/packingsolver/master/img/boxstacks.png" width="480"> |
-| [**One-dimensional**](https://fontanf.github.io/packingsolver/onedimensional.html)<br>`onedimensional`<br>One-dimensional items | <img src="https://raw.githubusercontent.com/fontanf/packingsolver/master/img/onedimensional.png" width="480"> |
-| [**Irregular shapes**](https://fontanf.github.io/packingsolver/irregular.html)<br>`irregular`<br>Two-dimensional shapes: polygons, possibly with circular arcs and holes | <img src="https://raw.githubusercontent.com/fontanf/packingsolver/master/img/irregular.png" width="480"> |
+It is available as a C++ library, a command-line tool, a Python package, and a web page that runs in the browser.
+
+## Applications
+
+| Application | Typical use | Problem type |
+|:--|:--|:--|
+| **Panel saws**: wood panels, furniture and cabinet making, glass, stone, paper | Cutting plans with edge-to-edge cuts, taking into account the saw blade thickness, the trims and the defects of the panels | [Rectangles, guillotine cuts](https://fontanf.github.io/packingsolver/rectangleguillotine.html) |
+| **Nesting for CNC, laser, plasma and waterjet cutting**: sheet metal, wood, plastics, foam | Nesting of parts of any shape on sheets, with the spacing between the parts and to the edges, part rotations and mirroring, parts with holes, sheet defects and remnants | [Irregular shapes](https://fontanf.github.io/packingsolver/irregular.html), or [Rectangles](https://fontanf.github.io/packingsolver/rectangle.html) for rectangular parts |
+| **Textile, garment, leather and composite cutting** | Nesting of patterns on a roll, minimizing the length used, or on hides of irregular shapes with defects | [Irregular shapes](https://fontanf.github.io/packingsolver/irregular.html) |
+| **Cutting of bars, tubes, profiles, beams, cables, paper rolls**: window and door frames, steel construction... | Cutting lengths out of stock bars, minimizing the number of bars and keeping the offcuts as long as possible | [One-dimensional](https://fontanf.github.io/packingsolver/onedimensional.html) |
+| **Truck and trailer loading** | Loading stacks of pallets or boxes, with stackability rules, weight limits, the weight on the axles and the unloading order | [Box stacks](https://fontanf.github.io/packingsolver/boxstacks.html) |
+| **Container, pallet and parcel loading** | Placing boxes in containers, on pallets or in cartons, with weight limits | [Boxes](https://fontanf.github.io/packingsolver/box.html) |
+| **Palletizing, floor and warehouse planning** | Placing rectangles on a surface: pallet layers, pallets on a truck or warehouse floor | [Rectangles](https://fontanf.github.io/packingsolver/rectangle.html) |
 
 ## Features
 
-PackingSolver supports the following [objectives](https://fontanf.github.io/packingsolver/objectives.html):
+| Problem type | Example |
+|:--|:--|
+| [**Rectangles, guillotine cuts**](https://fontanf.github.io/packingsolver/rectangleguillotine.html) `rectangleguillotine`<br>Two-dimensional rectangles cut with edge-to-edge (guillotine) cuts<br><br>Maximum number of cutting stages · cut types · first stage orientation · item rotations · cut thickness · trims · defects · cuts through defects · cutting sequences (stacks) · minimum and maximum distances between cuts · maximum number of consecutive 1-cuts and 2-cuts | <img src="https://raw.githubusercontent.com/fontanf/packingsolver/master/img/rectangleguillotine.png" width="480"> |
+| [**Rectangles**](https://fontanf.github.io/packingsolver/rectangle.html) `rectangle`<br>Two-dimensional rectangles<br><br>Item rotations · defects · maximum weight of a bin · unloading constraints | <img src="https://raw.githubusercontent.com/fontanf/packingsolver/master/img/rectangle.png" width="480"> |
+| [**Boxes**](https://fontanf.github.io/packingsolver/box.html) `box`<br>Three-dimensional boxes<br><br>Item rotations · maximum weight of a bin | <img src="https://raw.githubusercontent.com/fontanf/packingsolver/master/img/box.png" width="480"> |
+| [**Box stacks**](https://fontanf.github.io/packingsolver/boxstacks.html) `boxstacks`<br>Three-dimensional boxes, packed in stacks of items with the same width and length<br><br>Item rotations · nesting height · maximum number of items in a stack · maximum weight above an item · maximum stack density · unloading constraints · maximum weight on the middle and rear axles | <img src="https://raw.githubusercontent.com/fontanf/packingsolver/master/img/boxstacks.png" width="480"> |
+| [**One-dimensional**](https://fontanf.github.io/packingsolver/onedimensional.html) `onedimensional`<br>One-dimensional items<br><br>Nesting length · maximum number of items in a bin · maximum weight of a bin · maximum weight after an item | <img src="https://raw.githubusercontent.com/fontanf/packingsolver/master/img/onedimensional.png" width="480"> |
+| [**Irregular shapes**](https://fontanf.github.io/packingsolver/irregular.html) `irregular`<br>Two-dimensional shapes: polygons, possibly with circular arcs and holes<br><br>Irregular bins · discrete and continuous item rotations · item mirroring · holes · defects · item-item, item-bin and item-defect spacing | <img src="https://raw.githubusercontent.com/fontanf/packingsolver/master/img/irregular.png" width="480"> |
 
-* **Bin packing**: pack all the items in a minimum number of bins (optionally maximizing the value of the leftovers)
-* **Variable-sized bin packing**: pack all the items in bins of minimum total cost
-* **Open dimension** (all problem types except one-dimensional): pack all the items in a single bin of minimum length
-* **Knapsack**: pack a subset of the items of maximum total profit
-* **Feasibility**: pack all the items in the given bins
+## Objectives
 
-Each problem type comes with its own constraints:
+PackingSolver supports the following [objectives](https://fontanf.github.io/packingsolver/objectives.html):
 
-| Problem type | Features |
-|:--|:--|
-| [Rectangles, guillotine cuts](https://fontanf.github.io/packingsolver/rectangleguillotine.html) | Guillotine or non-guillotine cuts · maximum number of cutting stages · cut types · first stage orientation · item rotations · cut thickness · trims · defects · cuts through defects · cutting sequences (stacks) · minimum and maximum distances between cuts · maximum number of consecutive 1-cuts and 2-cuts |
-| [Rectangles](https://fontanf.github.io/packingsolver/rectangle.html) | Item rotations · defects · maximum weight of a bin · unloading constraints |
-| [Boxes](https://fontanf.github.io/packingsolver/box.html) | Item rotations · maximum weight of a bin |
-| [Box stacks](https://fontanf.github.io/packingsolver/boxstacks.html) | Item rotations · nesting height · maximum number of items in a stack · maximum weight above an item · maximum stack density · unloading constraints · maximum weight on the middle and rear axles |
-| [One-dimensional](https://fontanf.github.io/packingsolver/onedimensional.html) | Nesting length · maximum number of items in a bin · maximum weight of a bin · maximum weight after an item |
-| [Irregular shapes](https://fontanf.github.io/packingsolver/irregular.html) | Irregular bins · discrete and continuous item rotations · item mirroring · holes · defects · item-item, item-bin and item-defect spacing |
+* **Bin packing**: pack all the items in a minimum number of bins, e.g. use as few sheets as possible (optionally keeping the leftover of the last sheet as large as possible, to reuse it as a remnant)
+* **Variable-sized bin packing**: pack all the items in bins of minimum total cost, e.g. choose the cheapest combination of sheet sizes or trucks
+* **Open dimension** (all problem types except one-dimensional): pack all the items in a single bin of minimum length, e.g. use as little fabric as possible from a roll
+* **Knapsack**: pack a subset of the items of maximum total profit, e.g. fit the most valuable orders in a truck
+* **Feasibility**: pack all the items in the given bins, e.g. check that a load fits in a container
 
 ## Getting started
 
 ### In the browser
 
-The [online solver](https://packingsolver.pages.dev/) runs PackingSolver in your browser. No installation is needed, and the computation runs on your machine: nothing is sent to a server.
+The [online solver](https://packingsolver.pages.dev/) runs PackingSolver in the browser. No installation is needed, and the computation runs locally: nothing is sent to a server.
 
 ### Python
 

{packingsolver-0.1.1235 → packingsolver-0.1.1237}/README.md

@@ -9,7 +9,8 @@
 </p>
 
 <p align="center">
-  <b>A state-of-the-art solver for cutting and packing problems.</b>
+  <b>A state-of-the-art solver for cutting and packing problems</b><br>
+  Nesting, cutting optimization, load planning etc
 </p>
 
 <p align="center">
@@ -18,45 +19,57 @@
   <a href="https://github.com/fontanf/packingsolver/discussions">Ask a question</a>
 </p>
 
-PackingSolver computes cutting and loading plans: given a set of pieces to cut or pack (the **items**) and a set of containers (the **bins**), it finds how to place the items in the bins. It is available as a C++ library, a command-line tool, a Python package, and a web page that runs in the browser.
+<p align="center">
+  <a href="https://fontanf.github.io/packingsolver/rectangleguillotine.html"><img src="https://raw.githubusercontent.com/fontanf/packingsolver/master/img/rectangleguillotine.png" width="32%" alt="Rectangles, guillotine cuts"></a>
+  <a href="https://fontanf.github.io/packingsolver/rectangle.html"><img src="https://raw.githubusercontent.com/fontanf/packingsolver/master/img/rectangle.png" width="32%" alt="Rectangles"></a>
+  <a href="https://fontanf.github.io/packingsolver/irregular.html"><img src="https://raw.githubusercontent.com/fontanf/packingsolver/master/img/irregular.png" width="32%" alt="Irregular shapes"></a>
+  <a href="https://fontanf.github.io/packingsolver/box.html"><img src="https://raw.githubusercontent.com/fontanf/packingsolver/master/img/box.png" width="32%" alt="Boxes"></a>
+  <a href="https://fontanf.github.io/packingsolver/boxstacks.html"><img src="https://raw.githubusercontent.com/fontanf/packingsolver/master/img/boxstacks.png" width="32%" alt="Box stacks"></a>
+  <a href="https://fontanf.github.io/packingsolver/onedimensional.html"><img src="https://raw.githubusercontent.com/fontanf/packingsolver/master/img/onedimensional.png" width="32%" alt="One-dimensional"></a>
+</p>
 
-## Problem types
+PackingSolver computes cutting and loading plans. Given the pieces to cut or to load (the **items**: parts, panels, bars, boxes...) and what they must go into (the **bins**: sheets, plates, stock bars, pallets, trucks, containers...), it finds how to place the items in the bins, for example to use as little material as possible.
 
-| Problem type | Example |
-|:--|:--|
-| [**Rectangles, guillotine cuts**](https://fontanf.github.io/packingsolver/rectangleguillotine.html)<br>`rectangleguillotine`<br>Two-dimensional rectangles cut with edge-to-edge (guillotine) cuts | <img src="https://raw.githubusercontent.com/fontanf/packingsolver/master/img/rectangleguillotine.png" width="480"> |
-| [**Rectangles**](https://fontanf.github.io/packingsolver/rectangle.html)<br>`rectangle`<br>Two-dimensional rectangles | <img src="https://raw.githubusercontent.com/fontanf/packingsolver/master/img/rectangle.png" width="480"> |
-| [**Boxes**](https://fontanf.github.io/packingsolver/box.html)<br>`box`<br>Three-dimensional boxes | <img src="https://raw.githubusercontent.com/fontanf/packingsolver/master/img/box.png" width="480"> |
-| [**Box stacks**](https://fontanf.github.io/packingsolver/boxstacks.html)<br>`boxstacks`<br>Three-dimensional boxes, packed in stacks of items with the same width and length | <img src="https://raw.githubusercontent.com/fontanf/packingsolver/master/img/boxstacks.png" width="480"> |
-| [**One-dimensional**](https://fontanf.github.io/packingsolver/onedimensional.html)<br>`onedimensional`<br>One-dimensional items | <img src="https://raw.githubusercontent.com/fontanf/packingsolver/master/img/onedimensional.png" width="480"> |
-| [**Irregular shapes**](https://fontanf.github.io/packingsolver/irregular.html)<br>`irregular`<br>Two-dimensional shapes: polygons, possibly with circular arcs and holes | <img src="https://raw.githubusercontent.com/fontanf/packingsolver/master/img/irregular.png" width="480"> |
+It is available as a C++ library, a command-line tool, a Python package, and a web page that runs in the browser.
+
+## Applications
+
+| Application | Typical use | Problem type |
+|:--|:--|:--|
+| **Panel saws**: wood panels, furniture and cabinet making, glass, stone, paper | Cutting plans with edge-to-edge cuts, taking into account the saw blade thickness, the trims and the defects of the panels | [Rectangles, guillotine cuts](https://fontanf.github.io/packingsolver/rectangleguillotine.html) |
+| **Nesting for CNC, laser, plasma and waterjet cutting**: sheet metal, wood, plastics, foam | Nesting of parts of any shape on sheets, with the spacing between the parts and to the edges, part rotations and mirroring, parts with holes, sheet defects and remnants | [Irregular shapes](https://fontanf.github.io/packingsolver/irregular.html), or [Rectangles](https://fontanf.github.io/packingsolver/rectangle.html) for rectangular parts |
+| **Textile, garment, leather and composite cutting** | Nesting of patterns on a roll, minimizing the length used, or on hides of irregular shapes with defects | [Irregular shapes](https://fontanf.github.io/packingsolver/irregular.html) |
+| **Cutting of bars, tubes, profiles, beams, cables, paper rolls**: window and door frames, steel construction... | Cutting lengths out of stock bars, minimizing the number of bars and keeping the offcuts as long as possible | [One-dimensional](https://fontanf.github.io/packingsolver/onedimensional.html) |
+| **Truck and trailer loading** | Loading stacks of pallets or boxes, with stackability rules, weight limits, the weight on the axles and the unloading order | [Box stacks](https://fontanf.github.io/packingsolver/boxstacks.html) |
+| **Container, pallet and parcel loading** | Placing boxes in containers, on pallets or in cartons, with weight limits | [Boxes](https://fontanf.github.io/packingsolver/box.html) |
+| **Palletizing, floor and warehouse planning** | Placing rectangles on a surface: pallet layers, pallets on a truck or warehouse floor | [Rectangles](https://fontanf.github.io/packingsolver/rectangle.html) |
 
 ## Features
 
-PackingSolver supports the following [objectives](https://fontanf.github.io/packingsolver/objectives.html):
+| Problem type | Example |
+|:--|:--|
+| [**Rectangles, guillotine cuts**](https://fontanf.github.io/packingsolver/rectangleguillotine.html) `rectangleguillotine`<br>Two-dimensional rectangles cut with edge-to-edge (guillotine) cuts<br><br>Maximum number of cutting stages · cut types · first stage orientation · item rotations · cut thickness · trims · defects · cuts through defects · cutting sequences (stacks) · minimum and maximum distances between cuts · maximum number of consecutive 1-cuts and 2-cuts | <img src="https://raw.githubusercontent.com/fontanf/packingsolver/master/img/rectangleguillotine.png" width="480"> |
+| [**Rectangles**](https://fontanf.github.io/packingsolver/rectangle.html) `rectangle`<br>Two-dimensional rectangles<br><br>Item rotations · defects · maximum weight of a bin · unloading constraints | <img src="https://raw.githubusercontent.com/fontanf/packingsolver/master/img/rectangle.png" width="480"> |
+| [**Boxes**](https://fontanf.github.io/packingsolver/box.html) `box`<br>Three-dimensional boxes<br><br>Item rotations · maximum weight of a bin | <img src="https://raw.githubusercontent.com/fontanf/packingsolver/master/img/box.png" width="480"> |
+| [**Box stacks**](https://fontanf.github.io/packingsolver/boxstacks.html) `boxstacks`<br>Three-dimensional boxes, packed in stacks of items with the same width and length<br><br>Item rotations · nesting height · maximum number of items in a stack · maximum weight above an item · maximum stack density · unloading constraints · maximum weight on the middle and rear axles | <img src="https://raw.githubusercontent.com/fontanf/packingsolver/master/img/boxstacks.png" width="480"> |
+| [**One-dimensional**](https://fontanf.github.io/packingsolver/onedimensional.html) `onedimensional`<br>One-dimensional items<br><br>Nesting length · maximum number of items in a bin · maximum weight of a bin · maximum weight after an item | <img src="https://raw.githubusercontent.com/fontanf/packingsolver/master/img/onedimensional.png" width="480"> |
+| [**Irregular shapes**](https://fontanf.github.io/packingsolver/irregular.html) `irregular`<br>Two-dimensional shapes: polygons, possibly with circular arcs and holes<br><br>Irregular bins · discrete and continuous item rotations · item mirroring · holes · defects · item-item, item-bin and item-defect spacing | <img src="https://raw.githubusercontent.com/fontanf/packingsolver/master/img/irregular.png" width="480"> |
 
-* **Bin packing**: pack all the items in a minimum number of bins (optionally maximizing the value of the leftovers)
-* **Variable-sized bin packing**: pack all the items in bins of minimum total cost
-* **Open dimension** (all problem types except one-dimensional): pack all the items in a single bin of minimum length
-* **Knapsack**: pack a subset of the items of maximum total profit
-* **Feasibility**: pack all the items in the given bins
+## Objectives
 
-Each problem type comes with its own constraints:
+PackingSolver supports the following [objectives](https://fontanf.github.io/packingsolver/objectives.html):
 
-| Problem type | Features |
-|:--|:--|
-| [Rectangles, guillotine cuts](https://fontanf.github.io/packingsolver/rectangleguillotine.html) | Guillotine or non-guillotine cuts · maximum number of cutting stages · cut types · first stage orientation · item rotations · cut thickness · trims · defects · cuts through defects · cutting sequences (stacks) · minimum and maximum distances between cuts · maximum number of consecutive 1-cuts and 2-cuts |
-| [Rectangles](https://fontanf.github.io/packingsolver/rectangle.html) | Item rotations · defects · maximum weight of a bin · unloading constraints |
-| [Boxes](https://fontanf.github.io/packingsolver/box.html) | Item rotations · maximum weight of a bin |
-| [Box stacks](https://fontanf.github.io/packingsolver/boxstacks.html) | Item rotations · nesting height · maximum number of items in a stack · maximum weight above an item · maximum stack density · unloading constraints · maximum weight on the middle and rear axles |
-| [One-dimensional](https://fontanf.github.io/packingsolver/onedimensional.html) | Nesting length · maximum number of items in a bin · maximum weight of a bin · maximum weight after an item |
-| [Irregular shapes](https://fontanf.github.io/packingsolver/irregular.html) | Irregular bins · discrete and continuous item rotations · item mirroring · holes · defects · item-item, item-bin and item-defect spacing |
+* **Bin packing**: pack all the items in a minimum number of bins, e.g. use as few sheets as possible (optionally keeping the leftover of the last sheet as large as possible, to reuse it as a remnant)
+* **Variable-sized bin packing**: pack all the items in bins of minimum total cost, e.g. choose the cheapest combination of sheet sizes or trucks
+* **Open dimension** (all problem types except one-dimensional): pack all the items in a single bin of minimum length, e.g. use as little fabric as possible from a roll
+* **Knapsack**: pack a subset of the items of maximum total profit, e.g. fit the most valuable orders in a truck
+* **Feasibility**: pack all the items in the given bins, e.g. check that a load fits in a container
 
 ## Getting started
 
 ### In the browser
 
-The [online solver](https://packingsolver.pages.dev/) runs PackingSolver in your browser. No installation is needed, and the computation runs on your machine: nothing is sent to a server.
+The [online solver](https://packingsolver.pages.dev/) runs PackingSolver in the browser. No installation is needed, and the computation runs locally: nothing is sent to a server.
 
 ### Python
 

{packingsolver-0.1.1235 → packingsolver-0.1.1237}/include/packingsolver/box/instance.hpp

@@ -140,11 +140,11 @@ struct Box
 };
 
 /**
- * Get the volume used in a bin of dimensions 'bin' whose items end at
- * 'x_max', 'y_max', 'z_max', for a leftover mode (see 'LeftoverMode'): the
- * leftover is the volume of the bin minus this volume.
+ * Get the box used in a bin of dimensions 'bin' whose items end at 'x_max',
+ * 'y_max', 'z_max', for a leftover mode (see 'LeftoverMode'): the leftover is
+ * the volume of the bin minus the volume of this box.
  */
-inline Volume leftover_mode_used_volume(
+inline Box leftover_mode_used_box(
         LeftoverMode leftover_mode,
         const Box& bin,
         Length x_max,
@@ -163,9 +163,10 @@ inline Volume leftover_mode_used_volume(
             || leftover_mode == LeftoverMode::XZ
             || leftover_mode == LeftoverMode::YZ
             || leftover_mode == LeftoverMode::XYZ);
-    return (Volume)(along_x? x_max: bin.x)
-        * (along_y? y_max: bin.y)
-        * (along_z? z_max: bin.z);
+    return {
+        (along_x? x_max: bin.x),
+        (along_y? y_max: bin.y),
+        (along_z? z_max: bin.z)};
 }
 
 inline bool operator==(const Box& box_1, const Box& box_2) { return box_1.x == box_2.x && box_1.y == box_2.y && box_1.z == box_2.z; }
@@ -326,6 +327,14 @@ struct Parameters
 
     /** Leftover mode (see 'LeftoverMode'). */
     LeftoverMode leftover_mode = LeftoverMode::XYZ;
+
+    /**
+     * For the BinPackingWithLeftovers objective, also compare the solutions
+     * on the sum of the leftover values of the bins and on the sum of their
+     * staircase leftover values, after the leftover value and the staircase
+     * leftover value of the last bin.
+     */
+    bool leftover_all_bins = true;
 };
 
 ////////////////////////////////////////////////////////////////////////////////

{packingsolver-0.1.1235 → packingsolver-0.1.1237}/include/packingsolver/box/instance_builder.hpp

@@ -64,6 +64,9 @@ public:
     /** Set the leftover mode (see 'LeftoverMode'). */
     void set_leftover_mode(LeftoverMode leftover_mode) { instance_.parameters_.leftover_mode = leftover_mode; }
 
+    /** Set whether the leftover values of all the bins are compared. */
+    void set_leftover_all_bins(bool leftover_all_bins) { instance_.parameters_.leftover_all_bins = leftover_all_bins; }
+
     /** Set the feasibility callback. */
     void set_feasibility_callback(const FeasibilityCallback& feasibility_callback) { instance_.feasibility_callback_ = feasibility_callback; }
 
@@ -82,6 +85,16 @@ public:
             BinTypeId bin_type_id,
             Profit cost);
 
+    /**
+     * Set the dimensions of a bin type, overriding whatever 'add_bin_type'
+     * gave it. Used by the sequential feasibility algorithm to shrink a bin.
+     */
+    void set_bin_type_box(
+            BinTypeId bin_type_id,
+            Length x,
+            Length y,
+            Length z);
+
     /** Set the maximum weight of a bin type. */
     void set_bin_type_maximum_weight(
             BinTypeId bin_type_id,

{packingsolver-0.1.1235 → packingsolver-0.1.1237}/include/packingsolver/box/optimize.hpp

@@ -214,12 +214,38 @@ struct OptimizeParameters: packingsolver::Parameters<Instance, Solution, Output>
     /** Guides used in the tree search algorithm. */
     std::vector<GuideId> tree_search_guides;
 
+    /** Directions used in the tree search algorithm; see 'TreeSearchParameters::directions'. */
+    std::vector<Direction> tree_search_directions;
+
+    /**
+     * Re-optimize the bins of the best solution at the end, for the
+     * BinPackingWithLeftovers objective in a not-anytime mode.
+     */
+    bool post_process = true;
+
+    /**
+     * The last bin is re-optimized in the post-process only if it contains
+     * (strictly) fewer items than this threshold.
+     */
+    ItemPos post_process_last_bin_maximum_number_of_items = 32;
+
     /** Threshold to consider that a bin contains "many" items. */
     Counter many_items_in_bins_threshold = 16;
 
     /** Threshold to consider that a bin contains "many" items. */
     Counter many_items_in_bins_threshold_2 = 64;
 
+    /**
+     * Threshold to consider that a bin x (resp. y, z) section - a slice of
+     * the bin as long along x (resp. y, z) as the mean item - contains
+     * "many" items, i.e. mean bin y-z (resp. x-z, x-y) area / mean item y-z
+     * (resp. x-z, x-y) area. Used to choose between 'tree_search' (whose
+     * skyline branching factor grows with how many items pack into a single
+     * such section) and 'tree_search_maximal_spaces' (higher overhead per
+     * node, but does not degrade the same way).
+     */
+    Counter many_items_in_section_threshold = 8;
+
     /** Factor to consider that the number of copies of items is "high". */
     Counter many_item_type_copies_factor = 1;
 

packingsolver-0.1.1237/include/packingsolver/box/post_process.hpp

@@ -0,0 +1,56 @@
+#pragma once
+
+#include "packingsolver/box/optimize.hpp"
+
+namespace packingsolver
+{
+namespace box
+{
+
+struct GroupIdenticalBinsOutput: packingsolver::Output<Instance, Solution>
+{
+    GroupIdenticalBinsOutput(const Instance& instance):
+        packingsolver::Output<Instance, Solution>(instance) { }
+};
+
+/**
+ * Group identical bins of a solution together.
+ *
+ * Bins with the same bin type and the same items at the same positions are
+ * merged into a single entry with the combined copy count.
+ */
+GroupIdenticalBinsOutput group_identical_bins(const Solution& solution);
+
+/**
+ * Re-optimize the bin at 'bin_pos' of a solution, as its own single-bin
+ * BinPackingWithLeftovers instance, with 'optimize' and 'parameters' (its
+ * output and its post-process being disabled).
+ *
+ * Return the solution with that bin replaced by the re-optimized one, or the
+ * solution itself if the re-optimization didn't pack all the items of the
+ * bin.
+ */
+Solution reoptimize_bin(
+        const Solution& solution,
+        BinPos bin_pos,
+        const OptimizeParameters& parameters = {});
+
+/**
+ * Re-optimize each bin of a solution except the last one (see
+ * 'reoptimize_bin'), and keep a re-optimized bin if its leftover value is
+ * greater, or if its leftover value is the same and its staircase leftover
+ * value is greater.
+ *
+ * With the algorithms selected as for any instance, a bin with many items
+ * found quickly is re-optimized quickly too.
+ *
+ * The leftover values of the other bins only come after the ones of the last
+ * bin in the objective, so the algorithms hardly try to keep the free space
+ * of the other bins in a single region.
+ */
+Solution reoptimize_non_last_bins(
+        const Solution& solution,
+        const OptimizeParameters& parameters = {});
+
+}
+}

{packingsolver-0.1.1235 → packingsolver-0.1.1237}/include/packingsolver/box/solution.hpp

@@ -41,6 +41,17 @@ struct SolutionBin
 
     /** Resource consumption, indexed by resource_id. */
     std::vector<double> resource_consumption;
+
+    /** Leftover value of the bin (see 'LeftoverMode'). */
+    Volume leftover_value = 0;
+
+    /**
+     * Staircase leftover value of the bin: the volume of the bin which is not
+     * dominated by an item. An item dominates the points of the box between
+     * the origin of the bin and its opposite corner (see 'LeftoverMode' for
+     * the dimensions of the bin which are not considered).
+     */
+    Volume staircase_leftover_value = 0;
 };
 
 bool operator==(const SolutionBin& solution_bin_1, const SolutionBin& solution_bin_2);
@@ -203,6 +214,18 @@ public:
     /** Get the area of the solution. */
     inline Profit leftover_value() const { return leftover_value_; }
 
+    /** Get the staircase leftover value of the last bin of the solution. */
+    inline Volume staircase_leftover_value() const { return staircase_leftover_value_; }
+
+    /** Get the sum of the leftover values of the bins of the solution. */
+    inline Volume total_leftover_value() const { return total_leftover_value_; }
+
+    /**
+     * Get the sum of the staircase leftover values of the bins of the
+     * solution.
+     */
+    inline Volume total_staircase_leftover_value() const { return total_staircase_leftover_value_; }
+
     /** Get the volume of the solution. */
     inline Volume volume() const { return volume_; }
 
@@ -306,6 +329,15 @@ private:
     /** Value of the leftover. */
     Profit leftover_value_ = 0.0;
 
+    /** Staircase leftover value of the last bin. */
+    Volume staircase_leftover_value_ = 0;
+
+    /** Sum of the leftover values of the bins. */
+    Volume total_leftover_value_ = 0;
+
+    /** Sum of the staircase leftover values of the bins. */
+    Volume total_staircase_leftover_value_ = 0;
+
     /** Total volume of the bins of the solution. */
     Volume bin_volume_ = 0;
 

{packingsolver-0.1.1235 → packingsolver-0.1.1237}/include/packingsolver/boxstacks/instance.hpp

@@ -111,6 +111,23 @@ std::ostream& operator<<(
         std::ostream& os,
         Box box);
 
+/**
+ * Get the box used in a bin of dimensions 'bin' whose stacks end at 'x_max'
+ * and 'y_max', for a leftover mode (see 'LeftoverMode'): the leftover is the
+ * volume of the bin minus the volume of this box.
+ */
+inline Box leftover_mode_used_box(
+        LeftoverMode leftover_mode,
+        const Box& bin,
+        Length x_max,
+        Length y_max)
+{
+    return {
+        (leftover_mode == LeftoverMode::Y)? bin.x: x_max,
+        (leftover_mode == LeftoverMode::X)? bin.y: y_max,
+        bin.z};
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 ///////////////////////// Item type, Bin type, Defect //////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
@@ -357,6 +374,14 @@ struct Parameters
     /** Leftover mode (see 'LeftoverMode'). */
     LeftoverMode leftover_mode = LeftoverMode::XY;
 
+    /**
+     * For the BinPackingWithLeftovers objective, also compare the solutions
+     * on the sum of the leftover values of the bins and on the sum of their
+     * staircase leftover values, after the leftover value and the staircase
+     * leftover value of the last bin.
+     */
+    bool leftover_all_bins = true;
+
     /**
      * 'true' iff weight constraints must be satisfied for all items belonging
      * to a larger or equal group.

{packingsolver-0.1.1235 → packingsolver-0.1.1237}/include/packingsolver/boxstacks/instance_builder.hpp

@@ -78,6 +78,9 @@ public:
     /** Set the leftover mode (see 'LeftoverMode'). */
     void set_leftover_mode(LeftoverMode leftover_mode) { instance_.parameters_.leftover_mode = leftover_mode; }
 
+    /** Set whether the leftover values of all the bins are compared. */
+    void set_leftover_all_bins(bool leftover_all_bins) { instance_.parameters_.leftover_all_bins = leftover_all_bins; }
+
     /*
      * Set bin types
      */

{packingsolver-0.1.1235 → packingsolver-0.1.1237}/include/packingsolver/boxstacks/optimize.hpp

@@ -186,6 +186,18 @@ struct OptimizeParameters: packingsolver::Parameters<Instance, Solution, Output>
     /** Guides used in the tree search algorithm. */
     std::vector<GuideId> tree_search_guides;
 
+    /**
+     * Re-optimize the bins of the best solution at the end, for the
+     * BinPackingWithLeftovers objective in a not-anytime mode.
+     */
+    bool post_process = true;
+
+    /**
+     * The last bin is re-optimized in the post-process only if it contains
+     * (strictly) fewer items than this threshold.
+     */
+    ItemPos post_process_last_bin_maximum_number_of_items = 32;
+
     /**
      * Threshold to consider that a bin contains "many" items - see the
      * automatic selection between 'use_sequential_single_knapsack' and

packingsolver-0.1.1237/include/packingsolver/boxstacks/post_process.hpp

@@ -0,0 +1,56 @@
+#pragma once
+
+#include "packingsolver/boxstacks/optimize.hpp"
+
+namespace packingsolver
+{
+namespace boxstacks
+{
+
+struct GroupIdenticalBinsOutput: packingsolver::Output<Instance, Solution>
+{
+    GroupIdenticalBinsOutput(const Instance& instance):
+        packingsolver::Output<Instance, Solution>(instance) { }
+};
+
+/**
+ * Group identical bins of a solution together.
+ *
+ * Bins with the same bin type and the same stacks at the same positions are
+ * merged into a single entry with the combined copy count.
+ */
+GroupIdenticalBinsOutput group_identical_bins(const Solution& solution);
+
+/**
+ * Re-optimize the bin at 'bin_pos' of a solution, as its own single-bin
+ * BinPackingWithLeftovers instance, with 'optimize' and 'parameters' (its
+ * output and its post-process being disabled).
+ *
+ * Return the solution with that bin replaced by the re-optimized one, or the
+ * solution itself if the re-optimization didn't pack all the items of the
+ * bin.
+ */
+Solution reoptimize_bin(
+        const Solution& solution,
+        BinPos bin_pos,
+        const OptimizeParameters& parameters = {});
+
+/**
+ * Re-optimize each bin of a solution except the last one (see
+ * 'reoptimize_bin'), and keep a re-optimized bin if its leftover value is
+ * greater, or if its leftover value is the same and its staircase leftover
+ * value is greater.
+ *
+ * With the algorithms selected as for any instance, a bin with many items
+ * found quickly is re-optimized quickly too.
+ *
+ * The leftover values of the other bins only come after the ones of the last
+ * bin in the objective, so the algorithms hardly try to keep the free space
+ * of the other bins in a single region.
+ */
+Solution reoptimize_non_last_bins(
+        const Solution& solution,
+        const OptimizeParameters& parameters = {});
+
+}
+}

{packingsolver-0.1.1235 → packingsolver-0.1.1237}/include/packingsolver/boxstacks/solution.hpp

@@ -84,6 +84,18 @@ struct SolutionBin
 
     /** Profit. */
     Profit profit = 0.0;
+
+    /** Leftover value of the bin (see 'LeftoverMode'). */
+    Volume leftover_value = 0;
+
+    /**
+     * Staircase leftover value of the bin: the volume of the bin which is not
+     * dominated by a stack. A stack dominates the points of the box between
+     * the origin of the bin and its opposite corner, over the whole height
+     * of the bin (see 'LeftoverMode' for the dimensions of the bin which are
+     * not considered).
+     */
+    Volume staircase_leftover_value = 0;
 };
 
 bool operator==(const SolutionBin& solution_bin_1, const SolutionBin& solution_bin_2);
@@ -277,6 +289,18 @@ public:
      */
     inline Volume leftover_value() const { return bin_volume_ - volume_; }
 
+    /** Get the staircase leftover value of the last bin of the solution. */
+    inline Volume staircase_leftover_value() const { return staircase_leftover_value_; }
+
+    /** Get the sum of the leftover values of the bins of the solution. */
+    inline Volume total_leftover_value() const { return total_leftover_value_; }
+
+    /**
+     * Get the sum of the staircase leftover values of the bins of the
+     * solution.
+     */
+    inline Volume total_staircase_leftover_value() const { return total_staircase_leftover_value_; }
+
     /** Get the fraction of waste of the solution. */
     inline double waste_percentage() const { return (volume() == 0)? 0: (double)waste() / volume(); }
 
@@ -397,6 +421,15 @@ private:
     /** Total volume of the solution. */
     Volume volume_ = 0;
 
+    /** Staircase leftover value of the last bin. */
+    Volume staircase_leftover_value_ = 0;
+
+    /** Sum of the leftover values of the bins. */
+    Volume total_leftover_value_ = 0;
+
+    /** Sum of the staircase leftover values of the bins. */
+    Volume total_staircase_leftover_value_ = 0;
+
     /** Total volume of the bins of the solution. */
     Volume bin_volume_ = 0;