Support for limiting the number of guillotine stages

Author: JeroenGar

README.md

@@ -20,6 +20,7 @@ The algorithm currently has support for:
 - [x] 90° rotation of items
 - [x] can handle instances with insufficient bins to produce all items
 - [x] configurable cost and stock quantity per bin type
+- [x] configurable maximum number of guillotine stages
 
 # How to use
 
@@ -82,6 +83,9 @@ If provided, the algorithm will run until the predefined number of iterations is
 Both `maxRRIterations` and `maxRunTime` fields are optional. 
 The algorithm will continue execution until either, one of the termination conditions (defined in the config json) is reached, or it is manually terminated (CTRL+C). 
 
+The `maxStages` field (optional) can be used to limit the number stages the guillotine saw can make.
+A value of `"maxStages": 2` will ensure that all patterns can be cut with at most 2 rotations of the guillotine saw.
+
 Configuring more than 1 thread for instances with only a single type of bin won't make much of an improvement to the end result.
 On the contrary, many threads will result in a reduction of iterations/s per individual thread. 
 Which, in turn, can lead to increased runtimes to reach the same solution quality.

src/core/entities/layout.rs

@@ -1,6 +1,5 @@
 use generational_arena::{Arena, Index};
 use itertools::Itertools;
-
 use crate::core::{cost::Cost, insertion::insertion_blueprint::InsertionBlueprint};
 use crate::core::entities::node::Node;
 use crate::core::insertion::node_blueprint::NodeBlueprint;
@@ -25,7 +24,7 @@ pub struct Layout<'a> {
 impl<'a> Layout<'a> {
     pub fn new(id: usize, sheettype: &'a SheetType, first_cut_orientation: Orientation) -> Self {
         let mut nodes = Arena::new();
-        let top_node = Node::new(sheettype.width(), sheettype.height(), first_cut_orientation, None);
+        let top_node = Node::new(0, sheettype.width(), sheettype.height(), first_cut_orientation, None);
         let top_node_i = nodes.insert(top_node);
 
         let mut layout = Self {
@@ -39,7 +38,7 @@ impl<'a> Layout<'a> {
         };
 
         //The top node cannot be modified, so we register a placeholder node to be able to insert parts
-        let placeholder_node = Node::new(sheettype.width(), sheettype.height(), first_cut_orientation.rotate(), None);
+        let placeholder_node = Node::new(1, sheettype.width(), sheettype.height(), first_cut_orientation.rotate(), None);
         layout.register_node(placeholder_node, top_node_i, true);
 
         layout
@@ -75,7 +74,7 @@ impl<'a> Layout<'a> {
     fn implement_node_blueprint(&mut self, parent: Index, blueprint: &NodeBlueprint, instance: &'a Instance, new_nodes: &mut Vec<Index>) {
         let parttype = blueprint.parttype_id().map(|id| instance.get_parttype(id));
 
-        let node = Node::new(blueprint.width(), blueprint.height(), blueprint.next_cut_orient(), parttype);
+        let node = Node::new(self.nodes[parent].level() + 1, blueprint.width(), blueprint.height(), blueprint.next_cut_orient(), parttype);
         let node_index = self.register_node(node, parent, blueprint.is_empty());
 
         new_nodes.push(node_index);
@@ -138,11 +137,11 @@ impl<'a> Layout<'a> {
                     let replacement_node = match parent_node.next_cut_orient() {
                         Orientation::Horizontal => {
                             let new_height = empty_node.height() + node.height();
-                            Node::new(node.width(), new_height, node.next_cut_orient(), None)
+                            Node::new(node.level(), node.width(), new_height, node.next_cut_orient(), None)
                         }
                         Orientation::Vertical => {
                             let new_width = empty_node.width() + node.width();
-                            Node::new(new_width, node.height(), node.next_cut_orient(), None)
+                            Node::new(node.level(), new_width, node.height(), node.next_cut_orient(), None)
                         }
                     };
 
@@ -155,7 +154,7 @@ impl<'a> Layout<'a> {
                     let grandparent_index = parent_node.parent().expect("grandparent node needs to be present").clone();
 
                     //create empty parent
-                    let empty_parent_node = Node::new(parent_node.width(), parent_node.height(), parent_node.next_cut_orient(), None);
+                    let empty_parent_node = Node::new(parent_node.level(), parent_node.width(), parent_node.height(), parent_node.next_cut_orient(), None);
 
                     //replace
                     self.unregister_node(parent_node_index, &mut removed_parts);
@@ -167,7 +166,7 @@ impl<'a> Layout<'a> {
 
                 //create empty replacement node
                 let node = &self.nodes[node_index];
-                let replacement_node = Node::new(node.width(), node.height(), node.next_cut_orient(), None);
+                let replacement_node = Node::new(node.level(), node.width(), node.height(), node.next_cut_orient(), None);
 
                 //replace
                 self.unregister_node(node_index, &mut removed_parts);
@@ -211,6 +210,8 @@ impl<'a> Layout<'a> {
             self.register_part(parttype);
         }
 
+        debug_assert!(node.level() == self.nodes[parent].level() + 1);
+
         let node_index = self.nodes.insert(node);
 
         //All empty nodes need to be added to the sorted empty nodes list

src/core/entities/node.rs

@@ -9,6 +9,7 @@ use crate::core::rotation::Rotation;
 
 #[derive(Debug, Clone)]
 pub struct Node<'a> {
+    level: u8,
     width: u64,
     height: u64,
     children: Vec<Index>,
@@ -19,8 +20,9 @@ pub struct Node<'a> {
 
 
 impl<'a> Node<'a> {
-    pub fn new(width: u64, height: u64, next_cut_orient: Orientation, parttype: Option<&'a PartType>) -> Node<'a> {
+    pub fn new(level: u8, width: u64, height: u64, next_cut_orient: Orientation, parttype: Option<&'a PartType>) -> Node<'a> {
         Node {
+            level,
             width,
             height,
             children: vec![],
@@ -43,7 +45,7 @@ impl<'a> Node<'a> {
         self.children.remove(old_child_index);
     }
 
-    pub fn generate_insertion_node_blueprints(&self, parttype: &'a PartType, rotation: Rotation, mut insertion_replacements: Vec<Vec<NodeBlueprint>>) -> Vec<Vec<NodeBlueprint>> {
+    pub fn generate_insertion_node_blueprints(&self, parttype: &'a PartType, rotation: Rotation, max_level: u8, mut insertion_replacements: Vec<Vec<NodeBlueprint>>) -> Vec<Vec<NodeBlueprint>> {
         debug_assert!(self.insertion_possible(parttype, rotation));
 
         let part_size = match rotation {
@@ -101,7 +103,7 @@ impl<'a> Node<'a> {
              ---*****          ---*****
          */
 
-        if self.next_cut_orient == Orientation::Horizontal && self.width == part_size.width() {
+        if self.next_cut_orient == Orientation::Horizontal && self.width == part_size.width() && self.level < max_level {
             let mut copy = NodeBlueprint::new(self.width, self.height, None, self.next_cut_orient);
 
             let remainder_height = self.height - part_size.height();
@@ -116,7 +118,7 @@ impl<'a> Node<'a> {
             return insertion_replacements;
         }
 
-        if self.next_cut_orient == Orientation::Vertical && self.height == part_size.height() {
+        if self.next_cut_orient == Orientation::Vertical && self.height == part_size.height() && self.level < max_level {
             let mut copy = NodeBlueprint::new(self.width, self.height, None, self.next_cut_orient);
 
             let remainder_width = self.width - part_size.width();
@@ -145,7 +147,7 @@ impl<'a> Node<'a> {
              This requires an extra available level
          */
 
-        if self.next_cut_orient == Orientation::Horizontal {
+        if self.next_cut_orient == Orientation::Horizontal && self.level < max_level {
             let remainder_width_top = self.width - part_size.width();
             let mut part_node_parent = NodeBlueprint::new(part_size.width(), self.height, None, self.next_cut_orient);
             let remainder_node_top = NodeBlueprint::new(remainder_width_top, self.height, None, self.next_cut_orient);
@@ -160,7 +162,7 @@ impl<'a> Node<'a> {
             insertion_replacements.push(vec![part_node_parent, remainder_node_top]);
         }
 
-        if self.next_cut_orient == Orientation::Vertical {
+        if self.next_cut_orient == Orientation::Vertical && self.level < max_level {
             let remainder_height_top = self.height - part_size.height();
             let mut part_node_parent = NodeBlueprint::new(self.width, part_size.height(), None, self.next_cut_orient);
             let remainder_node_top = NodeBlueprint::new(self.width, remainder_height_top, None, self.next_cut_orient);
@@ -185,7 +187,7 @@ impl<'a> Node<'a> {
 
          */
 
-        if self.next_cut_orient == Orientation::Horizontal {
+        if self.next_cut_orient == Orientation::Horizontal && self.level + 1 < max_level {
             let mut copy = NodeBlueprint::new(self.width, self.height, None, self.next_cut_orient);
 
             let remainder_height_top = self.height - part_size.height();
@@ -205,7 +207,7 @@ impl<'a> Node<'a> {
             insertion_replacements.push(vec![copy]);
         }
 
-        if self.next_cut_orient == Orientation::Vertical {
+        if self.next_cut_orient == Orientation::Vertical && self.level + 1 < max_level {
             let mut copy = NodeBlueprint::new(self.width, self.height, None, self.next_cut_orient);
 
             let remainder_width_top = self.width - part_size.width();
@@ -225,7 +227,7 @@ impl<'a> Node<'a> {
 
             insertion_replacements.push(vec![copy]);
         }
-        return insertion_replacements;
+        insertion_replacements
     }
 
     pub fn insertion_possible(&self, parttype: &PartType, rotation: Rotation) -> bool {
@@ -274,6 +276,9 @@ impl<'a> Node<'a> {
     pub fn parent(&self) -> &Option<Index> {
         &self.parent
     }
+    pub fn level(&self) -> u8 {
+        self.level
+    }
 }
 
 

src/core/entities/sheettype.rs

@@ -8,16 +8,18 @@ pub struct SheetType {
     height: u64,
     value: u64,
     fixed_first_cut_orientation: Option<Orientation>,
+    max_stages: u8,
 }
 
 impl SheetType {
-    pub fn new(id: usize, width: u64, height: u64, value: u64, fixed_first_cut_orientation: Option<Orientation>) -> SheetType {
+    pub fn new(id: usize, width: u64, height: u64, value: u64, fixed_first_cut_orientation: Option<Orientation>, max_stages: u8) -> SheetType {
         SheetType {
             id,
             width,
             height,
             value,
             fixed_first_cut_orientation,
+            max_stages,
         }
     }
 
@@ -44,6 +46,10 @@ impl SheetType {
     pub fn fixed_first_cut_orientation(&self) -> Option<Orientation> {
         self.fixed_first_cut_orientation
     }
+
+    pub fn max_stages(&self) -> u8 {
+        self.max_stages
+    }
 }
 
 impl Hash for SheetType {

src/core/insertion/insertion_option.rs

@@ -1,6 +1,6 @@
 use std::fmt::Debug;
 
-use generational_arena::{Index};
+use generational_arena::Index;
 use itertools::Itertools;
 
 use crate::core::cost::Cost;
@@ -29,20 +29,21 @@ impl<'a> InsertionOption<'a> {
             layout_i,
             original_node_i,
             parttype,
-            rotation
+            rotation,
         }
     }
 
     pub fn generate_blueprints(&self, problem: &Problem) -> Vec<InsertionBlueprint<'a>> {
         let layout = problem.get_layout(&self.layout_i);
         let original_node = &layout.nodes()[self.original_node_i];
+        let max_stages = layout.sheettype().max_stages();
         let node_blueprints = match self.rotation {
             Some(rotation) => {
-                original_node.generate_insertion_node_blueprints(self.parttype, rotation,  vec![])
+                original_node.generate_insertion_node_blueprints(self.parttype, rotation, max_stages, vec![])
             }
             None => {
-                let node_blueprints = original_node.generate_insertion_node_blueprints(self.parttype, Rotation::Default, vec![]);
-                original_node.generate_insertion_node_blueprints(self.parttype, Rotation::Rotated, node_blueprints)
+                let node_blueprints = original_node.generate_insertion_node_blueprints(self.parttype, Rotation::Default, max_stages, vec![]);
+                original_node.generate_insertion_node_blueprints(self.parttype, Rotation::Rotated, max_stages, node_blueprints)
             }
         };
         let original_cost = original_node.calculate_cost();

src/io/parser.rs

@@ -39,17 +39,18 @@ pub fn generate_instance(json_instance: &mut JsonInstance, config: &Config) -> I
             SheetValuationMode::Cost => json_sheet.cost
         };
 
+        let max_stages = config.max_stages.unwrap_or(u8::MAX);
+
         let sheettype = SheetType::new(
             sheet_id,
             json_sheet.length,
             json_sheet.height,
             sheet_value,
             None,
+            max_stages
         );
-        let stock = match json_sheet.stock {
-            Some(stock) => stock,
-            None => usize::MAX
-        };
+
+        let stock = json_sheet.stock.unwrap_or(usize::MAX);
         sheets.push((sheettype, stock));
         sheet_id += 1;
     }

src/optimization/config.rs

@@ -15,6 +15,7 @@ pub struct Config {
     pub rotation_allowed: bool,
     pub n_threads: usize,
     pub sheet_valuation_mode : SheetValuationMode,
+    pub max_stages: Option<u8>,
 }
 
 #[derive(Serialize, Deserialize)]

src/optimization/sol_collectors/global_sol_collector.rs

@@ -129,7 +129,12 @@ impl GlobalSolCollector {
                 self.best_complete_solution = Some(solution.clone());
 
                 for tx_sync in &self.tx_syncs {
-                    tx_sync.send(SyncMessage::SyncMatLimit(solution.cost().material_cost)).expect("Error sending sync matlimit message");
+                    match tx_sync.send(SyncMessage::SyncMatLimit(solution.cost().material_cost)) {
+                        Ok(_) => {},
+                        Err(err) => {
+                            timed_println!("{}: {:?}", "Error syncing material limit".bright_red().bold(), err.to_string());
+                        },
+                    }
                 }
             }
         }