Arranging Pattern Pieces on an Irregular Hide

A leather hide isn’t a neat rectangle. It’s irregular, has thin spots near the belly, thickness variations, and natural scars you need to avoid. When you’re cutting pattern pieces—belt blanks, wallet panels, a phone case back—you’re solving a geometric puzzle: arrange these shapes on this specific hide to waste as little as possible.

This is 2D irregular bin packing, and it’s computationally hard. The textile and leather industries spent the 1980s building specialized CAM systems because even a 5% improvement in material utilization pays for itself in months when you’re processing hundreds of hides.

Here’s a greedy approach in TypeScript—place each piece at the first valid position, working left-to-right:

type Rect = { w: number; h: number };
type Placed = Rect & { x: number; y: number };

function packGreedy(pieces: Rect[], binWidth: number): Placed[] {
  const placed: Placed[] = [];
  let y = 0, rowH = 0, x = 0;
  
  for (const p of pieces) {
    if (x + p.w > binWidth) { y += rowH; x = 0; rowH = 0; }
    placed.push({ ...p, x, y });
    x += p.w;
    rowH = Math.max(rowH, p.h);
  }
  return placed;
}

const pieces = [{w:120,h:80}, {w:90,h:60}, {w:150,h:40}];
console.log(packGreedy(pieces, 300));

OCaml makes the shape representation cleaner with algebraic types, and you can express rotation attempts naturally:

type piece = { w: int; h: int }
type placed = { w: int; h: int; x: int; y: int }

let rotate p = { w = p.h; h = p.w }

let rec pack x y row_h bin_w (pieces : piece list) =
  match pieces with
  | [] -> []
  | p :: rest when x + p.w > bin_w ->
      pack 0 (y + row_h) 0 bin_w (p :: rest)
  | p :: rest ->
      { w=p.w; h=p.h; x; y } ::
      pack (x + p.w) y (max row_h p.h) bin_w rest

let pieces = [{ w=120; h=80 }; { w=90; h=60 }; { w=150; h=40 }]
let () = pack 0 0 0 300 pieces |> List.iter
  (fun p -> Printf.printf "(%d,%d) %dx%d\n" p.x p.y p.w p.h)

Real systems try thousands of orientations and orderings, sometimes using genetic algorithms or simulated annealing. But even this naive greedy pass gets you 70-80% utilization, which beats eyeballing it. The hard part isn’t the algorithm—it’s digitizing the hide’s actual usable area, accounting for stretch direction and quality zones.