JSON search tree (#175)

* Add JSON search tree output for irregular problems

* Save current state

* Update JSON search tree output

* Fix treesearchsolver dependency

* Fix json search tree output

* Update json export

* Update json export

* Update treesearchsolver dependency

Author: fontanf

extern/CMakeLists.txt

@@ -50,7 +50,7 @@ FetchContent_MakeAvailable(knapsacksolver)
 FetchContent_Declare(
     treesearchsolver
     GIT_REPOSITORY https://github.com/fontanf/treesearchsolver.git
-    GIT_TAG 985b0d81868cf636d3577f6e88dcad14425345ea
+    GIT_TAG 32da334a71c5039ab031f5e7d949e4d135832352
     #SOURCE_DIR "${PROJECT_SOURCE_DIR}/../treesearchsolver/"
     EXCLUDE_FROM_ALL)
 FetchContent_MakeAvailable(treesearchsolver)

include/packingsolver/algorithms/common.hpp

@@ -300,6 +300,9 @@ struct Parameters: optimizationtools::Parameters
 
     /** New solution callback. */
     NewSolutionCallback<Instance, Solution> new_solution_callback = [](const Output<Instance, Solution>&) { };
+
+    /** JSON search tree path. */
+    std::string json_search_tree_path;
 };
 
 template <typename Instance>

include/packingsolver/irregular/shape.hpp

@@ -145,6 +145,8 @@ struct ShapeElement
     ShapeElement axial_symmetry_y_axis() const;
 
     std::string to_string() const;
+
+    nlohmann::json to_json() const;
 };
 
 /**
@@ -232,6 +234,8 @@ struct Shape
 
     std::string to_string(Counter indentation) const;
 
+    nlohmann::json to_json() const;
+
     std::string to_svg(double factor) const;
 
     void write_svg(

src/irregular/branching_scheme.cpp

@@ -95,27 +95,7 @@ BranchingScheme::BranchingScheme(
             //std::cout << "bin_type_id " << bin_type_id << std::endl;
             const BinType& bin_type = instance().bin_type(bin_type_id);
             BranchingSchemeBinType& bb_bin_type = bin_types_[(int)direction][bin_type_id];
-            Shape bin_shape = bin_type.shape;
-            if (direction == Direction::LeftToRightThenTopToBottom) {
-                bin_shape = bin_shape.axial_symmetry_x_axis();
-            } else if (direction == Direction::RightToLeftThenBottomToTop) {
-                bin_shape = bin_shape.axial_symmetry_y_axis();
-            } else if (direction == Direction::RightToLeftThenTopToBottom) {
-                bin_shape = bin_shape.axial_symmetry_x_axis();
-                bin_shape = bin_shape.axial_symmetry_y_axis();
-            } else if (direction == Direction::BottomToTopThenLeftToRight) {
-                bin_shape = bin_shape.axial_symmetry_identity_line();
-            } else if (direction == Direction::BottomToTopThenRightToLeft) {
-                bin_shape = bin_shape.axial_symmetry_identity_line();
-                bin_shape = bin_shape.axial_symmetry_x_axis();
-            } else if (direction == Direction::TopToBottomThenLeftToRight) {
-                bin_shape = bin_shape.axial_symmetry_identity_line();
-                bin_shape = bin_shape.axial_symmetry_y_axis();
-            } else if (direction == Direction::TopToBottomThenRightToLeft) {
-                bin_shape = bin_shape.axial_symmetry_identity_line();
-                bin_shape = bin_shape.axial_symmetry_y_axis();
-                bin_shape = bin_shape.axial_symmetry_x_axis();
-            }
+            Shape bin_shape = convert_shape(bin_type.shape, direction);
 
             auto mm = bin_shape.compute_min_max();
             bb_bin_type.x_min = mm.first.x;
@@ -755,6 +735,58 @@ BranchingScheme::BranchingScheme(
     }
 }
 
+Shape BranchingScheme::convert_shape(
+        Shape shape,
+        Direction direction) const
+{
+    if (direction == Direction::LeftToRightThenTopToBottom) {
+        shape = shape.axial_symmetry_x_axis();
+    } else if (direction == Direction::RightToLeftThenBottomToTop) {
+        shape = shape.axial_symmetry_y_axis();
+    } else if (direction == Direction::RightToLeftThenTopToBottom) {
+        shape = shape.axial_symmetry_x_axis();
+        shape = shape.axial_symmetry_y_axis();
+    } else if (direction == Direction::BottomToTopThenLeftToRight) {
+        shape = shape.axial_symmetry_identity_line();
+    } else if (direction == Direction::BottomToTopThenRightToLeft) {
+        shape = shape.axial_symmetry_identity_line();
+        shape = shape.axial_symmetry_x_axis();
+    } else if (direction == Direction::TopToBottomThenLeftToRight) {
+        shape = shape.axial_symmetry_identity_line();
+        shape = shape.axial_symmetry_y_axis();
+    } else if (direction == Direction::TopToBottomThenRightToLeft) {
+        shape = shape.axial_symmetry_identity_line();
+        shape = shape.axial_symmetry_y_axis();
+        shape = shape.axial_symmetry_x_axis();
+    }
+    return shape;
+}
+
+Point BranchingScheme::convert_point_back(
+        const Point& point,
+        Direction direction) const
+{
+    if (direction == Direction::LeftToRightThenBottomToTop) {
+        return Point{point.x, point.y};
+    } else if (direction == Direction::LeftToRightThenTopToBottom) {
+        return Point{point.x, -point.y};
+    } else if (direction == Direction::RightToLeftThenBottomToTop) {
+        return Point{-point.x, point.y};
+    } else if (direction == Direction::RightToLeftThenTopToBottom) {
+        return Point{-point.x, -point.y};
+    } else if (direction == Direction::BottomToTopThenLeftToRight) {
+        return Point{point.y, point.x};
+    } else if (direction == Direction::BottomToTopThenRightToLeft) {
+        return Point{-point.y, point.x};
+    } else if (direction == Direction::TopToBottomThenLeftToRight) {
+        return Point{point.y, -point.x};
+    } else if (direction == Direction::TopToBottomThenRightToLeft) {
+        return Point{-point.y, -point.x};
+    }
+    throw std::runtime_error("");
+    return Point();
+}
+
 void BranchingScheme::compute_inflated_trapezoid_sets()
 {
     for (Direction direction: {
@@ -2333,24 +2365,7 @@ Solution BranchingScheme::to_solution(
             bin_pos = solution.add_bin(instance().bin_type_id(current_node->number_of_bins - 1), 1);
 
         const TrapezoidSet& trapezoid_set = trapezoid_sets_[(int)current_node->last_bin_direction][current_node->trapezoid_set_id];
-        Point bl_corner = {0, 0};
-        if (current_node->last_bin_direction == Direction::LeftToRightThenBottomToTop) {
-            bl_corner = Point{current_node->x, current_node->y};
-        } else if (current_node->last_bin_direction == Direction::LeftToRightThenTopToBottom) {
-            bl_corner = Point{current_node->x, -current_node->y};
-        } else if (current_node->last_bin_direction == Direction::RightToLeftThenBottomToTop) {
-            bl_corner = Point{-current_node->x, current_node->y};
-        } else if (current_node->last_bin_direction == Direction::RightToLeftThenTopToBottom) {
-            bl_corner = Point{-current_node->x, -current_node->y};
-        } else if (current_node->last_bin_direction == Direction::BottomToTopThenLeftToRight) {
-            bl_corner = Point{current_node->y, current_node->x};
-        } else if (current_node->last_bin_direction == Direction::BottomToTopThenRightToLeft) {
-            bl_corner = Point{-current_node->y, current_node->x};
-        } else if (current_node->last_bin_direction == Direction::TopToBottomThenLeftToRight) {
-            bl_corner = Point{current_node->y, -current_node->x};
-        } else if (current_node->last_bin_direction == Direction::TopToBottomThenRightToLeft) {
-            bl_corner = Point{-current_node->y, -current_node->x};
-        }
+        Point bl_corner = convert_point_back({current_node->x, current_node->y}, current_node->last_bin_direction);
         //std::cout << "bin_pos " << bin_pos
         //    << " item_type_id " << trapezoid_set.item_type_id
         //    << " bl_corner " << bl_corner.to_string()
@@ -2389,6 +2404,138 @@ Solution BranchingScheme::to_solution(
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 
+nlohmann::json BranchingScheme::json_export_init() const
+{
+    const auto& trapezoid_sets = trapezoid_sets_[(int)Direction::LeftToRightThenBottomToTop];
+    nlohmann::json json_init;
+    Counter i = 0;
+
+    // Bins.
+    json_bins_init_ids_ = std::vector<Counter>(instance().number_of_bin_types(), -1);
+    for (BinTypeId bin_type_id = 0;
+            bin_type_id < instance().number_of_bin_types();
+            ++bin_type_id) {
+        const BinType& bin_type = instance().bin_type(bin_type_id);
+
+        json_bins_init_ids_[bin_type_id] = i;
+        json_init[i][0] = {
+            {"Shape", bin_type.shape.to_json()},
+            {"FillColor", ""},
+        };
+        for (DefectId defect_id = 0;
+                defect_id < (DefectId)bin_type.defects.size();
+                ++defect_id) {
+            const Defect& defect = bin_type.defects[defect_id];
+            json_init[i][defect_id + 1] = {
+                {"Shape", bin_type.shape.to_json()},
+                {"FillColor", "red"},
+            };
+            for (Counter hole_pos = 0;
+                    hole_pos < (Counter)defect.holes.size();
+                    ++hole_pos) {
+                const Shape& hole = defect.holes[hole_pos];
+                json_init[i][hole_pos]["Holes"][hole_pos] = hole.to_json();
+            }
+        }
+        i++;
+    }
+
+    // Items.
+    json_items_init_ids_ = std::vector<std::vector<std::unordered_map<double, Counter>>>(instance().number_of_item_types());
+    for (ItemTypeId item_type_id = 0;
+            item_type_id < instance().number_of_item_types();
+            ++item_type_id) {
+        const ItemType& item_type = instance().item_type(item_type_id);
+
+        json_items_init_ids_[item_type_id] = std::vector<std::unordered_map<double, Counter>>(2);
+        for (bool mirror: {false, true}) {
+
+            for (const auto& angle_range: item_type.allowed_rotations) {
+
+                json_items_init_ids_[item_type_id][mirror][angle_range.first] = i;
+
+                for (ItemShapePos item_shape_pos = 0;
+                        item_shape_pos < (ItemShapePos)item_type.shapes.size();
+                        ++item_shape_pos) {
+                    const ItemShape& item_shape = item_type.shapes[item_shape_pos];
+                    Shape shape = (!mirror)?
+                        item_shape.shape:
+                        item_shape.shape.axial_symmetry_y_axis();
+                    shape = shape.rotate(angle_range.first);
+                    json_init[i][item_shape_pos] = {
+                        {"Shape", shape.to_json()},
+                        {"FillColor", "blue"},
+                    };
+                    for (Counter hole_pos = 0;
+                            hole_pos < (Counter)item_shape.holes.size();
+                            ++hole_pos) {
+                        const Shape& hole = item_shape.holes[hole_pos];
+                        json_init[i][item_shape_pos]["Holes"][hole_pos] = hole.to_json();
+                    }
+                }
+                i++;
+            }
+        }
+    }
+
+    return json_init;
+}
+
+nlohmann::json BranchingScheme::json_export(
+        const std::shared_ptr<Node>& node) const
+{
+    const TrapezoidSet& trapezoid_set = trapezoid_sets_[(int)node->last_bin_direction][node->trapezoid_set_id];
+    Point bl_orig = convert_point_back({node->x, node->y}, node->last_bin_direction);
+    nlohmann::json json = {
+        {"Id", node->id},
+        {"ParentId", (node->parent == nullptr)? -1: node->parent->id},
+        {"TrapezoidSetId", node->trapezoid_set_id},
+        {"ItemTypeId", trapezoid_set.item_type_id},
+        {"Angle", trapezoid_set.angle},
+        {"Mirror", trapezoid_set.mirror},
+        {"X", node->x},
+        {"Y", node->y},
+        {"XOrig", bl_orig.x},
+        {"YOrig", bl_orig.y},
+        {"NumberOfItems", node->number_of_items},
+        {"NumberOfBins", node->number_of_bins},
+        {"Profit", node->profit},
+        {"ItemArea", node->item_area},
+        {"ItemConvexHullArea", node->item_convex_hull_area},
+        {"GuideArea", node->guide_area},
+    };
+    if (node->number_of_items == 0)
+        return json;
+
+    nlohmann::json plot;
+    Counter i = 0;
+    // Plot bin.
+    BinTypeId bin_type_id = instance().bin_type_id(node->number_of_bins - 1);
+    plot[i] = {
+        {"Id",json_bins_init_ids_[bin_type_id]},
+        {"X", 0},
+        {"Y", 0},
+    };
+    i++;
+    // Plot items.
+    for (std::shared_ptr<const Node> node_tmp = node;
+            node_tmp->number_of_bins == node->number_of_bins;
+            node_tmp = node_tmp->parent) {
+        const TrapezoidSet& trapezoid_set = trapezoid_sets_[(int)node_tmp->last_bin_direction][node_tmp->trapezoid_set_id];
+        Point bl_corner = convert_point_back({node_tmp->x, node_tmp->y}, node_tmp->last_bin_direction);
+        plot[i] = {
+            {"Id", json_items_init_ids_[trapezoid_set.item_type_id][trapezoid_set.mirror].at(trapezoid_set.angle)},
+            {"X", bl_corner.x},
+            {"Y", bl_corner.y},
+        };
+        if (node_tmp == node)
+            plot[i]["FillColor"] = "green";
+        i++;
+    }
+    json["Plot"] = plot;
+    return json;
+}
+
 void BranchingScheme::write_svg(
         const std::shared_ptr<Node>& node,
         const std::string& file_path) const

src/irregular/branching_scheme.hpp

@@ -413,10 +413,18 @@ class BranchingScheme
     Solution to_solution(
             const std::shared_ptr<Node>& node) const;
 
+    std::string to_svg(
+            const std::shared_ptr<Node>& node) const;
+
     void write_svg(
             const std::shared_ptr<Node>& node,
             const std::string& file_path) const;
 
+    nlohmann::json json_export_init() const;
+
+    nlohmann::json json_export(
+            const std::shared_ptr<Node>& node) const;
+
 private:
 
     /** Instance. */
@@ -438,6 +446,10 @@ class BranchingScheme
 
     std::vector<AreaDbl> item_types_convex_hull_area_;
 
+    mutable std::vector<std::vector<std::unordered_map<Angle, Counter>>> json_items_init_ids_;
+
+    mutable std::vector<Counter> json_bins_init_ids_;
+
     mutable Counter node_id_ = 0;
 
     mutable std::vector<GeneralizedTrapezoid> uncovered_trapezoids_cur_;
@@ -446,6 +458,14 @@ class BranchingScheme
      * Private methods
      */
 
+    Shape convert_shape(
+            Shape shape,
+            Direction direction) const;
+
+    Point convert_point_back(
+            const Point& point,
+            Direction direction) const;
+
     /** Get the percentage of item inserted into a node. */
     inline double item_percentage(const Node& node) const { return (double)node.number_of_items / instance().number_of_items(); }