Rename leftover corner to anchor corner

Author: fontanf

include/packingsolver/irregular/instance.hpp

@@ -45,7 +45,7 @@ struct Parameters
     LengthDbl item_item_minimum_spacing = 0.0;
 
     /** Reference corner to compute the leftover value. */
-    Corner leftover_corner = Corner::BottomLeft;
+    Corner anchor_corner = Corner::BottomLeft;
 
     /** Scale value. */
     LengthDbl scale_value = std::numeric_limits<LengthDbl>::infinity();

include/packingsolver/irregular/instance_builder.hpp

@@ -42,8 +42,8 @@ class InstanceBuilder
     /** Set the aspect ratio for the open dimension xy objective. */
     void set_open_dimension_xy_aspect_ratio(LengthDbl open_dimension_xy_aspect_ratio) { instance_.parameters_.open_dimension_xy_aspect_ratio = open_dimension_xy_aspect_ratio; }
 
-    /** Set reference corner for leftover value. */
-    void set_leftover_corner(Corner leftover_corner) { instance_.parameters_.leftover_corner = leftover_corner; }
+    /** Set the anchor corner. */
+    void set_anchor_corner(Corner anchor_corner) { instance_.parameters_.anchor_corner = anchor_corner; }
 
     /*
      * Set bin types

src/irregular/branching_scheme.cpp

@@ -74,7 +74,7 @@ BranchingScheme::Direction default_direction(
 {
     const BinType& bin_type = instance.bin_type(bin_type_id);
     bool lengthwise = (bin_type.x_max - bin_type.x_min) >= (bin_type.y_max - bin_type.y_min);
-    switch (instance.parameters().leftover_corner) {
+    switch (instance.parameters().anchor_corner) {
     case Corner::BottomLeft: {
         return (lengthwise)?
             BranchingScheme::Direction::LeftToRightThenBottomToTop:
@@ -93,6 +93,7 @@ BranchingScheme::Direction default_direction(
             BranchingScheme::Direction::TopToBottomThenRightToLeft;
     }
     }
+    return BranchingScheme::Direction::LeftToRightThenBottomToTop;
 }
 
 }
@@ -1226,7 +1227,7 @@ BranchingScheme::Node BranchingScheme::child_tmp(
         node.y_max = xy.y + mm.second.y;
     }
 
-    switch (instance().parameters().leftover_corner) {
+    switch (instance().parameters().anchor_corner) {
     case Corner::BottomLeft: {
         node.leftover_value = (bin_type.x_max - bin_type.x_min) * (bin_type.y_max - bin_type.y_min)
             - (node.x_max - bin_type.x_min) * (node.y_max - bin_type.y_min);
@@ -2135,14 +2136,14 @@ Solution BranchingScheme::to_solution(
                 solution.write("solution_irregular.json");
                 throw std::runtime_error(
                         FUNC_SIGNATURE + "; "
-                        "node->xe_max: " + std::to_string(node->xe_max) + "; "
+                        "node->xe_max: " + std::to_string(node->x_max) + "; "
                         "solution.x_max(): " + std::to_string(solution.x_max()) + "; "
                         "d: " + std::to_string((int)node->last_bin_direction) + ".");
             }
             if (!equal(node->y_min, solution.y_min())) {
                 throw std::runtime_error(
                         FUNC_SIGNATURE + "; "
-                        "node->ye_max: " + std::to_string(node->ye_max) + "; "
+                        "node->ye_max: " + std::to_string(node->y_max) + "; "
                         "solution.y_max(): " + std::to_string(solution.y_max()) + "; "
                         "d: " + std::to_string((int)node->last_bin_direction) + ".");
             }

src/irregular/instance.cpp

@@ -338,8 +338,8 @@ std::ostream& Instance::format(
             << "Number of rectangular items:  " << number_of_rectangular_items_ << std::endl
             << "Number of circular items:     " << number_of_circular_items_ << std::endl
             << "Item-item minimum spacing:    " << parameters().item_item_minimum_spacing << std::endl
+            << "Anchor corner:                " << parameters().anchor_corner << std::endl
             << "Open dim. XY aspect ratio:    " << parameters().open_dimension_xy_aspect_ratio << std::endl
-            << "Leftover corner:              " << parameters().leftover_corner << std::endl
             << "Total item area:              " << item_area() << std::endl
             << "Smallest item area:           " << smallest_item_area() << std::endl
             << "Largest item area:            " << largest_item_area() << std::endl
@@ -700,7 +700,7 @@ void Instance::write(
     // Export parameters.
     json["parameters"]["item_item_minimum_spacing"] = parameters().item_item_minimum_spacing;
     json["parameters"]["open_dimension_xy_aspect_ratio"] = parameters().open_dimension_xy_aspect_ratio;
-    json["parameters"]["leftover_corner"] = parameters().leftover_corner;
+    json["parameters"]["anchor_corner"] = parameters().anchor_corner;
 
     file << std::setw(4) << json << std::endl;
 }

src/irregular/instance_builder.cpp

@@ -293,12 +293,12 @@ void InstanceBuilder::read(
         auto json_parameters = j["parameters"];
         if (json_parameters.contains("item_item_minimum_spacing"))
             set_item_item_minimum_spacing(json_parameters["item_item_minimum_spacing"]);
-        if (json_parameters.contains("leftover_corner")) {
-            std::stringstream leftover_corner_ss;
-            leftover_corner_ss << std::string(json_parameters["leftover_corner"]);
-            Corner leftover_corner;
-            leftover_corner_ss >> leftover_corner;
-            set_leftover_corner(leftover_corner);
+        if (json_parameters.contains("anchor_corner")) {
+            std::stringstream anchor_corner_ss;
+            anchor_corner_ss << std::string(json_parameters["anchor_corner"]);
+            Corner anchor_corner;
+            anchor_corner_ss >> anchor_corner;
+            set_anchor_corner(anchor_corner);
         }
     }
 

src/irregular/main.cpp

@@ -111,8 +111,8 @@ int main(int argc, char *argv[])
         instance_builder.set_objective(vm["objective"].as<Objective>());
     if (vm.count("item-item-minimum-spacing"))
         instance_builder.set_item_item_minimum_spacing(vm["item-item-minimum-spacing"].as<LengthDbl>());
-    if (vm.count("leftover-corner"))
-        instance_builder.set_leftover_corner(vm["leftover-corner"].as<Corner>());
+    if (vm.count("anchor-corner"))
+        instance_builder.set_anchor_corner(vm["leftover-corner"].as<Corner>());
     if (vm.count("unweighted"))
         instance_builder.set_item_types_unweighted();
     if (vm.count("bin-unweighted"))

src/irregular/optimize.cpp

@@ -165,7 +165,7 @@ void optimize_tree_search(
         };
     } else if (instance.number_of_bin_types() == 1) {
         if (instance.objective() == Objective::BinPackingWithLeftovers) {
-            switch (instance.parameters().leftover_corner) {
+            switch (instance.parameters().anchor_corner) {
             case Corner::BottomLeft: {
                 directions = {
                     BranchingScheme::Direction::LeftToRightThenBottomToTop,

src/irregular/solution.cpp

@@ -104,7 +104,7 @@ void Solution::add_item(
         y_min_ = std::min(y_min_, bl_corner.y + mm.first.y);
         x_max_ = std::max(x_max_, bl_corner.x + mm.second.x);
         y_max_ = std::max(y_max_, bl_corner.y + mm.second.y);
-        switch (instance().parameters().leftover_corner) {
+        switch (instance().parameters().anchor_corner) {
         case Corner::BottomLeft: {
             leftover_value_ = (bin_type.x_max - bin_type.x_min) * (bin_type.y_max - bin_type.y_min)
                 - (x_max_ - bin_type.x_min) * (y_max_ - bin_type.y_min);