feat: add --allow-rotation flag for automatic item rotation

When --allow-rotation is passed, GuillotineDP automatically adds the
90-degree rotated variant of each non-square item to the item list.
The expanded item list is saved in the solution JSON so the visualizer
renders rotated items with the same color as their original orientation.
n_items_orig is stored to support the color mapping.

Author: NicolaPerin

src/guillotine/__main__.py

@@ -95,12 +95,10 @@ def estimate_memory(sheet_size, defect_sizes, defect_positions):
         try:
             from guillotine.core import _solver
             from guillotine.core.geometry import SheetGeometry
-            # build defects_arr the same way geometry does
             geom = SheetGeometry(sheet_size, defect_sizes, defect_positions)
             t1dx, d1dx, t1dy, d1dy, t2d, d2d = _solver.estimate_slab(
                 W0, H0, geom.defects_arr, n_defects)
 
-            # apply same selection logic as the C solver
             min_data = min(d1dx, d1dy, d2d)
             tolerance = 1.20
             candidates = [
@@ -124,7 +122,6 @@ def estimate_memory(sheet_size, defect_sizes, defect_positions):
             result["total"]           = f_tables + g_tables + prefix + best_data * 4
 
         except ImportError:
-            # fall back to dense estimate if C extension not available
             dense = (W0+1)**2 * (H0+1)**2 * 4
             result["slab_data"]   = dense
             result["slab_mb"]     = dense / 1024**2
@@ -212,6 +209,7 @@ def parse_args(argv=None):
             "  guillotine solve --sheet 27x27 --items 5x5 10x10 --defects 9,9,2x2\n"
             "  guillotine solve problem.json --dry-run\n"
             "  guillotine solve problem.json --plot\n"
+            "  guillotine solve problem.json --allow-rotation\n"
             "  guillotine plot output/solution.json\n"
             "Run 'guillotine <command> --help' for more information."
         ),
@@ -250,6 +248,12 @@ def parse_args(argv=None):
         action="store_true",
         help="Print problem summary and memory estimates without solving"
     )
+    bench_parser.add_argument(
+        "--allow-rotation",
+        action="store_true",
+        default=False,
+        help="Allow 90-degree rotation of items (adds rotated variants automatically)"
+    )
 
     # ---- solve command ----
     solve_parser = subparsers.add_parser(
@@ -301,6 +305,12 @@ def parse_args(argv=None):
         action="store_true",
         help="Print problem summary and memory estimates without solving"
     )
+    solve_parser.add_argument(
+        "--allow-rotation",
+        action="store_true",
+        default=False,
+        help="Allow 90-degree rotation of items (adds rotated variants automatically)"
+    )
 
     # ---- plot command ----
     plot_parser = subparsers.add_parser(
@@ -335,7 +345,8 @@ def parse_args(argv=None):
 # Solver functions
 # -------------------------
 def run_solver(item_sizes, defect_sizes, defect_positions, sheet_size,
-               output_file, profile_file=None, plot_file=None):
+               output_file, profile_file=None, plot_file=None,
+               allow_rotation=False):
     """Run the solver, save results, and optionally plot.
 
     Plotting is done AFTER saving — the solution JSON is loaded back from
@@ -347,17 +358,19 @@ def run_solver(item_sizes, defect_sizes, defect_positions, sheet_size,
     def solve():
         geom = SheetGeometry(sheet_size, defect_sizes, defect_positions)
         patterns = CutPatternGenerator(item_sizes, geom)
-        dp = GuillotineDP(item_sizes, geom, patterns)
+        dp = GuillotineDP(item_sizes, geom, patterns, allow_rotation=allow_rotation)
         start = time.time()
         value, sequence = dp.solve()
         solve_time = time.time() - start
-        return value, sequence, solve_time
+        expanded_item_sizes = [dp.item_w.tolist(), dp.item_h.tolist()]
+        n_items_orig = len(item_sizes[0])
+        return value, sequence, solve_time, expanded_item_sizes, n_items_orig
 
     if profile_file:
         print(f"Profiling enabled, output: {profile_file}")
         profiler = cProfile.Profile()
         profiler.enable()
-        value, sequence, solve_time = solve()
+        value, sequence, solve_time, expanded_item_sizes, n_items_orig = solve()
         profiler.disable()
         profile_file = ensure_output_path(profile_file)
         with open(profile_file, 'w') as f:
@@ -366,36 +379,38 @@ def solve():
             stats.print_stats(50)
         print(f"Profile saved to: {profile_file}")
     else:
-        value, sequence, solve_time = solve()
+        value, sequence, solve_time, expanded_item_sizes, n_items_orig = solve()
 
     output_file = ensure_output_path(output_file)
     save_solution_json(output_file, value, sequence,
-                       item_sizes, defect_sizes, defect_positions, sheet_size)
+                       expanded_item_sizes, defect_sizes, defect_positions,
+                       sheet_size, n_items_orig=n_items_orig)
 
     print(f"Solved in {solve_time:.3f}s")
     print(f"Value: {value}/{sheet_size[0]*sheet_size[1]} "
           f"({value/(sheet_size[0]*sheet_size[1])*100:.1f}%)")
     print(f"Output saved to: {output_file}")
 
-    # Plot from the saved JSON — solver memory is no longer referenced
-    # and can be collected before matplotlib loads.
     if plot_file:
         plot_file = ensure_output_path(plot_file)
         run_plot(output_file, plot_file)
 
 
-def run_benchmark(output_file, profile_file=None, plot_file=None):
+def run_benchmark(output_file, profile_file=None, plot_file=None,
+                  allow_rotation=False):
     """Run the paper benchmark case."""
     print("Running paper benchmark (27x27 sheet)...")
     item_sizes = [[5, 10, 12, 15], [5, 10, 12, 15]]
     defect_sizes = [[2], [2]]
     defect_positions = [[9], [9]]
     sheet_size = (27, 27)
     run_solver(item_sizes, defect_sizes, defect_positions, sheet_size,
-               output_file, profile_file, plot_file)
+               output_file, profile_file, plot_file,
+               allow_rotation=allow_rotation)
 
 
-def run_from_json(input_file, output_file, profile_file=None, plot_file=None):
+def run_from_json(input_file, output_file, profile_file=None, plot_file=None,
+                  allow_rotation=False):
     """Run solver from JSON input file."""
     print(f"Loading problem from {input_file}...")
     problem = load_problem_json(input_file)
@@ -406,7 +421,8 @@ def run_from_json(input_file, output_file, profile_file=None, plot_file=None):
         problem["sheet_size"],
         output_file,
         profile_file,
-        plot_file
+        plot_file,
+        allow_rotation=allow_rotation,
     )
 
 
@@ -429,7 +445,8 @@ def run_plot(solution_file, output_file):
         data["item_sizes"],
         data["defect_sizes"],
         data["defect_positions"],
-        data["sheet_size"]
+        data["sheet_size"],
+        n_items_orig=data.get("n_items_orig", len(data["item_sizes"][0])),
     )
 
     output_file = ensure_output_path(output_file)
@@ -449,11 +466,9 @@ def load_problem_for_dry_run(args):
             "sheet_size": (27, 27),
         }
 
-    # JSON input
     if args.input:
         return load_problem_json(args.input)
 
-    # Inline input
     if args.items and args.sheet:
         try:
             w, h = map(int, args.sheet.lower().split("x"))
@@ -515,13 +530,15 @@ def main(argv=None):
 
     # ---- benchmark ----
     if args.command == "benchmark":
-        run_benchmark(args.output, args.profile, args.plot)
+        run_benchmark(args.output, args.profile, args.plot,
+                      allow_rotation=args.allow_rotation)
         return 0
 
     # ---- solve ----
     elif args.command == "solve":
         if args.input:
-            run_from_json(args.input, args.output, args.profile, args.plot)
+            run_from_json(args.input, args.output, args.profile, args.plot,
+                          allow_rotation=args.allow_rotation)
             return 0
 
         if args.items and args.sheet:
@@ -560,7 +577,8 @@ def main(argv=None):
                 (w, h),
                 args.output,
                 args.profile,
-                args.plot
+                args.plot,
+                allow_rotation=args.allow_rotation,
             )
             return 0
 

src/guillotine/core/dp_solver.py

@@ -22,14 +22,23 @@ class GuillotineDP:
                             optimality without precomputed candidate sets.
     """
 
-    def __init__(self, item_sizes, geometry, patterns):
+    def __init__(self, item_sizes, geometry, patterns, allow_rotation=False):
         self.geom     = geometry
         self.patterns = patterns
         self.W0       = geometry.W0
         self.H0       = geometry.H0
 
-        self.item_w    = np.array(item_sizes[0], dtype=np.int32)
-        self.item_h    = np.array(item_sizes[1], dtype=np.int32)
+        item_w_orig = np.array(item_sizes[0], dtype=np.int32)
+        item_h_orig = np.array(item_sizes[1], dtype=np.int32)
+
+        if allow_rotation:
+            non_square = item_w_orig != item_h_orig
+            self.item_w = np.concatenate([item_w_orig, item_h_orig[non_square]])
+            self.item_h = np.concatenate([item_h_orig, item_w_orig[non_square]])
+        else:
+            self.item_w = item_w_orig
+            self.item_h = item_h_orig
+
         self.item_area = self.item_w * self.item_h
         self.n_items   = len(self.item_w)
 

src/guillotine/io.py

@@ -104,8 +104,8 @@ def load_problem_json(filepath):
     }
 
 
-def save_solution_json(filepath, value, sequence,
-                       item_sizes, defect_sizes, defect_positions, sheet_size):
+def save_solution_json(filepath, value, sequence, item_sizes, defect_sizes, 
+                       defect_positions, sheet_size, n_items_orig=None):
     """Save solution to JSON file with all metrics and the full problem definition.
 
     The problem definition is embedded so that the solution file is
@@ -126,6 +126,7 @@ def save_solution_json(filepath, value, sequence,
 
     output = {
         "problem": _build_problem_dict(item_sizes, defect_sizes, defect_positions, sheet_size),
+        "n_items_orig": n_items_orig if n_items_orig is not None else len(item_sizes[0]),
         "solution": {
             "cut_area": value,
             "total_area": total_area,
@@ -204,6 +205,7 @@ def load_solution_json(filepath):
         "defect_sizes": defect_sizes,
         "defect_positions": defect_positions,
         "sheet_size": sheet_size,
+        "n_items_orig": data.get("n_items_orig", len(item_sizes[0])),
         "cut_area": sol["cut_area"],
         "total_area": sol["total_area"],
         "defect_area": sol["defect_area"],

src/guillotine/visualize.py

@@ -87,17 +87,17 @@ def _select_ticks(all_positions, sheet_dim, max_ticks=20):
 class CuttingVisualizer:
     """Visualizes cutting patterns."""
 
-    def __init__(self, item_sizes, defect_sizes, defect_positions, sheet_size):
+    def __init__(self, item_sizes, defect_sizes, defect_positions, sheet_size, n_items_orig=None):
         self.item_sizes = item_sizes
         self.defect_sizes = defect_sizes
         self.defect_positions = defect_positions
         self.sheet_size = sheet_size
+        self.n_items_orig = n_items_orig if n_items_orig is not None else len(item_sizes[0])
         self.xticks = []
         self.yticks = []
 
     def _get_colors(self):
-        """Return one vibrant color per item type, cycling if needed."""
-        n_items = len(self.item_sizes[0])
+        n_items = self.n_items_orig
         if n_items <= len(_VIBRANT_PALETTE):
             return _VIBRANT_PALETTE[:n_items]
         extra = [
@@ -142,9 +142,10 @@ def _draw_cuts(self, ax, sequence, w, h, colors, lw, offset=(0, 0)):
         if isinstance(sequence, str):
             if sequence.startswith("g_"):
                 item_idx = int(sequence.split("_")[1])
+                color_idx = item_idx % self.n_items_orig
                 item_w = self.item_sizes[0][item_idx]
                 item_h = self.item_sizes[1][item_idx]
-                self._fill_items(ax, w, h, item_w, item_h, colors[item_idx], lw, offset)
+                self._fill_items(ax, w, h, item_w, item_h, colors[color_idx], lw, offset)
             return
 
         direction, z, left, right = sequence