@mark1russell7/packing 0.2.1 → 0.2.3

package/src/pack.ts

@@ -1,3 +1,4 @@
+import { clearMoves, countMove, MOVES } from "./moves.ts";
 import { compareRects, type SortOrder } from "./order.ts";
 import { Rect } from "./rect.ts";
 import { packRowsInSpace, packShelf } from "./shelf.ts";
@@ -25,10 +26,20 @@ export interface PackLayoutOptions extends PackOptions {
   strategy?: "rows" | "skyline" | "shelf";
 }
 
+/** The depth of the calls of `packInto`. Only the outer gap fill counts its rectangles as moves. */
+let fillDepth = 0;
+
 function packInto<T>(rects: Rect<T>[], region: Rect<T>, offset: Vector, order: SortOrder): void {
   const unpacked = Rect.unpacked(rects);
-  pack(unpacked, region, { sortOrder: order });
-  for (const r of Rect.packed(unpacked)) r.translateBy(offset);
+  fillDepth++;
+  try {
+    pack(unpacked, region, { sortOrder: order });
+  } finally {
+    fillDepth--;
+  }
+  const placed = Rect.packed(unpacked);
+  if (fillDepth === 0) countMove(MOVES.rows, placed.length);
+  for (const r of placed) r.translateBy(offset);
 }
 
 function packRow<T>(rects: Rect<T>[], outer: Rect<T>, order: SortOrder): boolean {
@@ -100,7 +111,8 @@ export function packRows<T>(rects: Rect<T>[], outer: Rect<T>, options: PackOptio
   const space = options.space;
   if (space !== undefined && (!space.plain || rects.some((r) => r.locked))) return packRowsInSpace(rects, outer, order, space);
   for (const r of rects) if (r.locked) r.wasPacked = true;
-  while (!packRow(rects, outer, order));
+  // A row that does not fit grows the height and starts again, thus the gap fills of the try before do not count
+  while (!packRow(rects, outer, order)) if (fillDepth === 0) clearMoves(MOVES.rows);
   return outer;
 }
 

package/src/shelf.ts

@@ -1,3 +1,4 @@
+import { countMove, MOVES } from "./moves.ts";
 import { compareRects, type SortOrder } from "./order.ts";
 import type { Rect } from "./rect.ts";
 import { firstFit, type FreeSpace, type FreeSpan } from "./space.ts";
@@ -111,6 +112,8 @@ export function packShelf<T>(rects: Rect<T>[], outer: Rect<T>, options: ShelfOpt
 
     if (outer.fixedSize && rowTop + h > outer.size.y) continue;
 
+    // The move of a shelf: the rectangle joins an open shelf that a taller rectangle made
+    if (!rowEmpty && rowTop + h < rowBottom) countMove(MOVES.shelf);
     rect.position.set(x + outer.position.x, rowTop + outer.position.y);
     rect.wasPacked = true;
     rowEmpty = false;

package/src/skyline.ts

@@ -1,3 +1,4 @@
+import { countMove, MOVES } from "./moves.ts";
 import { compareRects, type SortOrder } from "./order.ts";
 import type { Rect } from "./rect.ts";
 import type { FreeSpace } from "./space.ts";
@@ -11,6 +12,19 @@ import type { FreeSpace } from "./space.ts";
  * `limit[x, x + rw)`. A second deque keeps that smallest value. No valid window gives the height `Infinity`.
  */
 export function lowestWindow(skyline: ArrayLike<number>, width: number, rw: number, limit?: ArrayLike<number>, rh = 0): { x: number; y: number } {
+  const { x, y } = findWindow(skyline, width, rw, limit, rh);
+  return { x, y };
+}
+
+/** The lowest window of `findWindow`, and `first`: the x of the leftmost valid window, or `-1` */
+interface Window {
+  x: number;
+  y: number;
+  first: number;
+}
+
+/** This function is `lowestWindow`, and it also gives the x of the leftmost valid window. */
+function findWindow(skyline: ArrayLike<number>, width: number, rw: number, limit?: ArrayLike<number>, rh = 0): Window {
   if (limit !== undefined) return lowestLimitedWindow(skyline, limit, width, rw, rh);
   const deque = new Int32Array(width);
   let head = 0;
@@ -29,11 +43,16 @@ export function lowestWindow(skyline: ArrayLike<number>, width: number, rw: numb
       }
     }
   }
-  return { x: bestX, y: bestY };
+  return { x: bestX, y: bestY, first: width >= rw ? 0 : -1 };
+}
+
+/** This function counts the move of the skyline: a window that is lower than the leftmost valid window. */
+function countWindow(w: Window): void {
+  if (Number.isFinite(w.y) && w.first >= 0 && w.x !== w.first) countMove(MOVES.skyline);
 }
 
 /** This function is `lowestWindow` with a limit for each cell. */
-function lowestLimitedWindow(skyline: ArrayLike<number>, limit: ArrayLike<number>, width: number, rw: number, rh: number): { x: number; y: number } {
+function lowestLimitedWindow(skyline: ArrayLike<number>, limit: ArrayLike<number>, width: number, rw: number, rh: number): Window {
   const high = new Int32Array(width);
   const low = new Int32Array(width);
   let hh = 0;
@@ -42,6 +61,7 @@ function lowestLimitedWindow(skyline: ArrayLike<number>, limit: ArrayLike<number
   let lt = 0;
   let bestX = 0;
   let bestY = Infinity;
+  let first = -1;
   for (let i = 0; i < width; i++) {
     while (ht > hh && skyline[high[ht - 1]!]! <= skyline[i]!) ht--;
     high[ht++] = i;
@@ -51,13 +71,15 @@ function lowestLimitedWindow(skyline: ArrayLike<number>, limit: ArrayLike<number
     if (low[lh]! <= i - rw) lh++;
     if (i >= rw - 1) {
       const max = skyline[high[hh]!]!;
-      if (max < bestY && max + rh <= limit[low[lh]!]!) {
+      const valid = max + rh <= limit[low[lh]!]!;
+      if (valid && first < 0) first = i - rw + 1;
+      if (max < bestY && valid) {
         bestY = max;
         bestX = i - rw + 1;
       }
     }
   }
-  return { x: bestX, y: bestY };
+  return { x: bestX, y: bestY, first };
 }
 
 /** The options of `packSkyline` */
@@ -116,8 +138,10 @@ export function packSkyline<T>(rects: Rect<T>[], outer: Rect<T>, options: Skylin
       y = 0;
       for (let i = 0; i < width; i++) if (skyline[i]! > y) y = skyline[i]!;
     } else {
-      ({ x, y } = lowestWindow(skyline, width, rw));
+      const found = findWindow(skyline, width, rw);
+      ({ x, y } = found);
       if (outer.fixedSize && y + rh > outer.size.y) continue;
+      countWindow(found);
     }
 
     rect.position.set(x + outer.position.x, y + outer.position.y);
@@ -179,7 +203,8 @@ function packSkylineInSpace<T>(rects: Rect<T>[], outer: Rect<T>, order: SortOrde
       outer.size.y = Math.max(outer.size.y, y + rh);
       continue;
     }
-    ({ x, y } = lowestWindow(skyline, width, rw, limit, rh));
+    let found = findWindow(skyline, width, rw, limit, rh);
+    ({ x, y } = found);
     let sky: Float64Array = skyline;
     let lim: Float64Array = limit;
     if (!Number.isFinite(y)) {
@@ -189,10 +214,12 @@ function packSkylineInSpace<T>(rects: Rect<T>[], outer: Rect<T>, order: SortOrde
       for (let i = 0; i < width; i++) {
         while (Number.isFinite(lim[i]!) && lim[i]! - sky[i]! < rh && lim[i]! < end) [sky[i], lim[i]] = rangeOf(i, lim[i]!);
       }
-      ({ x, y } = lowestWindow(sky, width, rw, lim, rh));
+      found = findWindow(sky, width, rw, lim, rh);
+      ({ x, y } = found);
       if (!Number.isFinite(y)) continue;
     }
 
+    countWindow(found);
     rect.position.set(x + ox, y + oy);
     rect.wasPacked = true;
     const top = y + rh;