@mark1russell7/packing 0.1.2 → 0.1.3

package/README.md

@@ -78,6 +78,38 @@ const moved = pushCascade(dropped, cards, { gap: 8 });
 const { utilization, raggedness, rows } = packingMetrics(Rect.packed(rects));
 ```
 
+## The Packer interface
+
+Each strategy has one interface: `pack(input, options, context)`. The input is a `PackInput`: a container, items, obstacles and a gap. The output is a `PackOutput`. The output does not change the input.
+
+```ts
+import { checkHard, packWith, type PackInput } from "@mark1russell7/packing";
+
+const input: PackInput = {
+  container: { w: 400, fixed: "width", inset: 8 },
+  gap: 4,
+  items: [
+    { id: "a", w: 120, h: 40, margin: 2 },
+    { id: "pin", w: 60, h: 60, x: 200, y: 8, locked: true },
+    { id: "b", w: 80, h: 30 },
+  ],
+  obstacles: [{ id: "logo", region: { kind: "rect", x: 300, y: 0, w: 100, h: 50 } }],
+};
+const output = packWith("shelf", input, { sortOrder: "input" });
+output.placements; // the position of each item
+output.size; // the size of the container
+checkHard(input, output); // { "no-overlap": 0, "in-container": 0, "locked-kept": 0, complete: 0 }
+```
+
+- The registry `strategies` has `rows`, `skyline`, `shelf` and `push`. `strategy(id)` gives one, and `packWith(id, input, options, seed)` packs with it.
+- `fixed` is `size`, `width`, `height` or `none`. A fixed height turns the axes. The value `none` uses the size search `logSweep`, which wraps `packFree`.
+- Each strategy declares its cells in `supports`. `cellOf(input)` gives the cell of an input. A strategy throws `UnsupportedCell` for an input outside its cells.
+- The strategies of this version do not turn items, read groups or pack shapes. A turnable item, a group or a shape gives `UnsupportedCell`.
+- `checkHard` counts the breaks of the hard rules: `no-overlap`, `in-container`, `locked-kept` and `complete`.
+- `fromRects` and `toRects` connect the interface to the `Rect` objects.
+
+`docs/PACKER.md` in the repository gives the interface in full.
+
 ## More
 
 - [The repository](https://github.com/mark1russell7/packing): the source, the tests and the roadmap.

package/build/index.d.ts

@@ -258,5 +258,342 @@ interface MetricsOptions {
  * ```
  */
 export declare function packingMetrics(rects: readonly Rect[], options?: MetricsOptions): PackingMetrics;
-export type { FreeWidthOptions, FreeWidthResult, FreeWidthTry, MetricsOptions, PackLayoutOptions, PackOptions, PackingMetrics, PushOptions, ShelfOptions, SortOrder };
+/** A region. The forms and the rules are those of `docs/FORMAT.md`. The y axis points down. */
+type Region = {
+  kind: "rect";
+  x: number;
+  y: number;
+  w: number;
+  h: number;
+} | {
+  kind: "polygon";
+  points: [number, number][];
+  holes?: [number, number][][];
+} | {
+  kind: "circle";
+  cx: number;
+  cy: number;
+  r: number;
+} | {
+  kind: "ellipse";
+  cx: number;
+  cy: number;
+  rx: number;
+  ry: number;
+};
+/** The container of a packing. */
+interface Container {
+  /** The width. Without it, the packer searches the width. */
+  w?: number;
+  /** The height. Without it, the packer searches the height. */
+  h?: number;
+  /** The sides that stay: `size` keeps `w` and `h`, `width` keeps `w`, `height` keeps `h`, and `none` searches both. */
+  fixed: "size" | "width" | "height" | "none";
+  /** The target aspect (the width divided by the height) for the value `none` of `fixed`. The default is 1. */
+  aspect?: number;
+  /** The weight of the aspect error in the objective. The value 0 gives the least area. The default is 1. */
+  aspectWeight?: number;
+  /** The shape. Without it, the container is the rectangle from 0, 0 to `w`, `h`. */
+  shape?: Region;
+  /** The space between the border and the items with their margins. The default is 0. */
+  inset?: number;
+}
+/** An obstacle: an area that no item enters. */
+interface Obstacle {
+  id: string;
+  region: Region;
+  /** Without it, the obstacle stays. With it, the packer can move the obstacle for `cost` times the distance. */
+  move?: {
+    cost: number;
+  };
+}
+/** The margin of an item on each side. */
+interface Margin {
+  top: number;
+  right: number;
+  bottom: number;
+  left: number;
+}
+/** A port on the border of an item. */
+interface Port {
+  id: string;
+  side: "top" | "right" | "bottom" | "left";
+  /** The point on the border of the item, relative to its top-left corner. Without it, the router chooses the point. */
+  x?: number;
+  y?: number;
+}
+/** An item to pack. The file format names it a box. */
+interface Item {
+  id: string;
+  w: number;
+  h: number;
+  /** The reading order. Without it, the index in the array is the rank. */
+  rank?: number;
+  group?: string;
+  parent?: string;
+  /** A shape relative to the origin of the item. Without it, the item is the rectangle `w` by `h`. */
+  shape?: Region;
+  /** A locked item keeps `x` and `y`. The packer reads it as an obstacle. */
+  locked?: boolean;
+  x?: number;
+  y?: number;
+  /** The value `true` lets the packer turn the item by 90 degrees. The default is `false`. */
+  turnable?: boolean;
+  /** A ring around the item that no other item and no route enters. The default is 0. */
+  margin?: number | Margin;
+  /** The ports. The packer keeps them, and turns them with the item. */
+  ports?: Port[];
+}
+/** The input of a packing: a `layout-input/1` file without `edges`, with `items` for `boxes`. */
+interface PackInput {
+  container: Container;
+  items: Item[];
+  obstacles?: Obstacle[];
+  /** The free space between two items with their margins. Routes use this space. The default is 0. */
+  gap?: number;
+}
+/** The position of one item after the packing. */
+interface Placement {
+  id: string;
+  x: number;
+  y: number;
+  /** The turn: 0 or 90, only for an item with `turnable` set to `true`. */
+  turn?: 0 | 90;
+}
+/** The facts of one stage of a packing. */
+interface StageTrace {
+  /** The id of the stage, for example `skyline` or `log-sweep`. */
+  id: string;
+  /** The time of the stage in milliseconds. */
+  ms: number;
+  /** The measures of the stage, by the names of `docs/FORMAT.md`. */
+  measures: Record<string, number>;
+}
+/** The output of a packing. The output does not change the input. */
+interface PackOutput {
+  placements: Placement[];
+  /** The ids of the items that the packer did not place. */
+  overflow: string[];
+  /** The size of the container after the packing. For a free size, the size that the search found. */
+  size: {
+    w: number;
+    h: number;
+  };
+  /** The new positions of the obstacles that moved. */
+  moved: {
+    id: string;
+    x: number;
+    y: number;
+  }[];
+  /** The facts of each stage, for the site and the records. */
+  trace: StageTrace[];
+}
+/** The tolerances of the hard rules. */
+interface Tolerance {
+  /** The rule `no-overlap`: two boxes overlap only by more than this value. */
+  overlap: number;
+  /** The router rule that a route does not go through a box. */
+  through: number;
+}
+/** The tolerance for the comparison of two numbers in an engine. */
+export declare const EPS = 1e-6;
+/** The tolerance for the comparison of two numbers of a file. The files round to 3 decimals. */
+export declare const RECORD_EPS = .001;
+/** The default tolerances of the hard rules. Each record writes its tolerances in its top-level field `tolerance`. */
+export declare const DEFAULT_TOLERANCE: Readonly<Tolerance>;
+/** This function gives the margin of an item on each side. A number is the same margin on each side. */
+export declare function marginOf(item: Pick<Item, "margin">): Margin;
+/** This function gives the point `px`, `py` of an item of height `h` after a turn of 90 degrees clockwise. */
+export declare function turnPoint(px: number, py: number, h: number): [number, number];
+/** This function turns a port of an item of height `h` by 90 degrees clockwise. The side turns from top to right. */
+export declare function turnPort(port: Port, h: number): Port;
+/** This function turns a region relative to an item of height `h` by 90 degrees clockwise. */
+export declare function turnRegion(region: Region, h: number): Region;
+/**
+ * This function gives an item after a turn of 90 degrees clockwise, with the y axis down (decision 1 of
+ * `docs/PACKER.md`). The width and the height change places. The top-left corner, the id and the other fields stay.
+ * The ports, the shape and the margin turn with the item. The function does not change its argument.
+ */
+export declare function turnItem(item: Item): Item;
+/** For each dimension of the taxonomy, the values that a strategy supports. `docs/research/TAXONOMY.md` gives the values. */
+interface Supports {
+  containerSize: ("fixed" | "freeHeight" | "freeWidth" | "freeAspect" | "freeArea")[];
+  containerShape: ("rect" | "convex" | "polygon" | "circle" | "ellipse" | "holes")[];
+  /** The movement of the obstacles. An empty list supports only an input with no obstacle and no locked item. */
+  obstacleMove: ("fixed" | "costly" | "free")[];
+  itemShape: ("rect" | "circle" | "convex" | "polygon" | "mixed")[];
+  rotation: ("none" | "quarter" | "any")[];
+  order: ("free" | "soft" | "hard")[];
+  groups: ("none" | "flat" | "nested")[];
+  mode: ("offline" | "online" | "incremental")[];
+}
+/** A dimension of `Supports`. */
+type Dimension = keyof Supports;
+/** A value of a dimension of `Supports`. */
+type DimensionValue<D extends Dimension = Dimension> = Supports[D][number];
+/**
+ * The cell of an input: one value for each packer dimension that the input tells. The input does not tell the mode.
+ * Without obstacles and locked items, the cell has no `obstacleMove`.
+ */
+interface Cell {
+  containerSize: DimensionValue<"containerSize">;
+  containerShape: DimensionValue<"containerShape">;
+  obstacleMove?: DimensionValue<"obstacleMove">;
+  itemShape: DimensionValue<"itemShape">;
+  rotation: DimensionValue<"rotation">;
+  order: DimensionValue<"order">;
+  groups: DimensionValue<"groups">;
+}
+/** The context of one packing. */
+interface PackContext {
+  /** The seed. A strategy gets each random number from `rng`, not from `Math.random`. */
+  seed: number;
+  /** The random numbers in `[0, 1)`, from `mulberry32` with `seed`. */
+  rng: () => number;
+  /** A limit for the strategies that search. The strategy gives its best result at the limit. */
+  budget?: {
+    ms?: number;
+    steps?: number;
+  };
+  /** The previous output, for the mode `incremental`. */
+  previous?: PackOutput;
+}
+/** A packing strategy behind the Packer interface. */
+interface Strategy<O = unknown> {
+  /** A stable name, for example `shelf`. The records use it. */
+  id: string;
+  /** The family of the catalog, for example `shelf` or `skyline`. */
+  family: string;
+  /** The ids of the catalog rows that this strategy builds. */
+  catalog: string[];
+  /** The cells that the strategy supports. */
+  supports: Supports;
+  /** The default options. A record writes the options in full. */
+  defaults: O;
+  /** The value `true` tells that the result depends only on the input, the options and the seed. */
+  deterministic: boolean;
+  /** This method packs an input. It throws `UnsupportedCell` for an input outside the cells of `supports`. */
+  pack(input: PackInput, options: O, context: PackContext): PackOutput;
+}
+/** A size search: it gives a strategy of a fixed width the cells `freeAspect` and `freeArea`. */
+interface SizeSearch {
+  id: string;
+  /** This method searches the size of the container for an input with `fixed` set to `none`. `options` go to `inner`. */
+  search(input: PackInput, inner: Strategy, context: PackContext, options?: unknown): PackOutput;
+}
+/**
+ * The error of a strategy for an input outside its cells. The benchmark records this result. It is not a failure of the
+ * strategy.
+ */
+export declare class UnsupportedCell extends Error {
+  /** The dimension of the taxonomy. */
+  readonly dimension: Dimension;
+  /** The value of the input that the strategy does not support. */
+  readonly value: string;
+  constructor(dimension: Dimension, value: string);
+}
+/** This function gives a generator of random numbers in `[0, 1)`: `mulberry32` of `docs/FORMAT.md`. */
+export declare function mulberry32(seed: number): () => number;
+/** This function makes the context of one packing from a seed. */
+export declare function createContext(seed?: number, more?: Omit<PackContext, "seed" | "rng">): PackContext;
+/**
+ * This function gives the cell of an input: the values of the packer dimensions that the input tells.
+ *
+ * - `containerSize` comes from `fixed`. The value `none` gives `freeArea` when `aspectWeight` is 0, and `freeAspect` if not.
+ * - `containerShape` comes from the shape. A rectangle container with an obstacle of another region gives `holes`.
+ * - `obstacleMove` is the hardest value of the obstacles and the locked items: `costly`, then `free`, then `fixed`.
+ * - `order` is `soft` when an item has a rank, and `free` if not. The input does not tell a hard order.
+ * - `groups` is `nested` when an item has a parent, `flat` when an item has a group, and `none` if not.
+ */
+export declare function cellOf(input: PackInput): Cell;
+/** This function gives the first dimension of a cell that `supports` does not hold, or `undefined` when it holds each one. */
+export declare function unsupportedOf(supports: Supports, cell: Partial<Record<Dimension, string>>): {
+  dimension: Dimension;
+  value: string;
+} | undefined;
+/** This function tells if `supports` holds each value of a cell. A dimension that the cell does not have is held. */
+export declare function supportsCell(supports: Supports, cell: Partial<Record<Dimension, string>>): boolean;
+/** This function throws `UnsupportedCell` for the first value of the cell of an input that `supports` does not hold. */
+export declare function assertSupported(supports: Supports, input: PackInput): void;
+/** The options of the strategies `rows`, `skyline` and `shelf`. */
+interface LayoutStrategyOptions {
+  /** The order of the items before the packing. The items are in the order of their rank first. */
+  sortOrder: SortOrder;
+  /** The number of widths that the first pass of the size search `log-sweep` tries. */
+  samples: number;
+}
+/** The options of the strategy `push`. */
+interface PushStrategyOptions {
+  /** The order of the items that the cascade does not place. */
+  sortOrder: SortOrder;
+  /** The most shoves for each item. The cascade stops at this limit. */
+  maxShovesPerItem: number;
+}
+/**
+ * The strategy `rows` uses `packRows`: a guillotine row packing with a recursive gap fill. It supports no obstacle and
+ * no locked item, because `packRows` does not go around them. Turnable items, groups and shapes throw `UnsupportedCell`.
+ */
+export declare const rows: Strategy<LayoutStrategyOptions>;
+/**
+ * The strategy `skyline` uses `packSkyline`: each item goes to the lowest place where it fits. It packs around the
+ * locked items and the fixed obstacles. Turnable items, groups and shapes throw `UnsupportedCell`.
+ */
+export declare const skyline: Strategy<LayoutStrategyOptions>;
+/**
+ * The strategy `shelf` uses `packShelf`: rows filled left to right, around the locked items and the fixed obstacles.
+ * With the sort order `input`, the rows keep the rank order. Turnable items, groups and shapes throw `UnsupportedCell`.
+ */
+export declare const shelf: Strategy<LayoutStrategyOptions>;
+/**
+ * The size search `log-sweep` uses `packFree` of 0.1.2: widths on a log scale, then the widths near the best width. It
+ * wraps `rows`, `skyline` and `shelf`. The objective is the area of the frame times `1 + aspectWeight * aspectError`.
+ */
+export declare const logSweep: SizeSearch;
+/**
+ * The strategy `push` uses `pushCascade`. Each item starts at its `x` and `y`, or at its place in `context.previous`.
+ * Each item in rank order pushes the items and the movable obstacles that it overlaps. Then `packSkyline` places the
+ * items with no start, and the items that still overlap. The output tells each obstacle that moved.
+ */
+export declare const push: Strategy<PushStrategyOptions>;
+/**
+ * This function makes a `PackInput` from the `Rect` objects of 0.1. The id of each item is the index of its rectangle.
+ *
+ * - `fixedSize` gives `fixed` set to `size`, `fixedWidth` gives `width`, and an outer rectangle without them gives `none`.
+ * - A locked rectangle gives a locked item at its position.
+ * - An outer rectangle at a position other than 0, 0 gives a rectangle shape at that position.
+ */
+export declare function fromRects<T>(rects: readonly Rect<T>[], outer: Rect<T>): PackInput;
+/**
+ * This function writes an output back into the `Rect` objects of `fromRects`. It sets the position and `wasPacked` of
+ * each rectangle, and the free sides of the outer rectangle. It gives the outer rectangle.
+ */
+export declare function toRects<T>(output: PackOutput, rects: Rect<T>[], outer: Rect<T>): Rect<T>;
+/** Each strategy of the package. The benchmark starts each one on each input of the corpus. */
+export declare const strategies: readonly Strategy[];
+/** This function gives the strategy with an id. It throws a `RangeError` for an id that the registry does not have. */
+export declare function strategy(id: string): Strategy;
+/**
+ * This function packs an input with the strategy of an id. The options go over the defaults of the strategy. The
+ * context gets `mulberry32` with the seed. The default seed is 0.
+ */
+export declare function packWith(id: string, input: PackInput, options?: unknown, seed?: number): PackOutput;
+/** The count of the breaks of each hard rule of the packer (`docs/FORMAT.md`). A good run has 0 for each rule. */
+interface HardBreaks {
+  "no-overlap": number;
+  "in-container": number;
+  "locked-kept": number;
+  complete: number;
+}
+/**
+ * This function counts the breaks of the 4 hard rules of the packer for an output.
+ *
+ * - `no-overlap`: each pair of items with their margins, and each pair of an item and an obstacle, that overlap by more than `tolerance.overlap`.
+ * - `in-container`: each item with its margin that goes out of a fixed side by more than `tolerance.overlap`.
+ * - `locked-kept`: each locked item that moved by more than `RECORD_EPS`, or that has no position.
+ * - `complete`: each item with no position that is not in the overflow.
+ *
+ * The rules read a shape of the container or of an obstacle as its bounding box. The result has no tolerance in it.
+ */
+export declare function checkHard(input: PackInput, output: PackOutput, tolerance?: Pick<Tolerance, "overlap">): HardBreaks;
+export type { Cell, Container, Dimension, DimensionValue, FreeWidthOptions, FreeWidthResult, FreeWidthTry, HardBreaks, Item, LayoutStrategyOptions, Margin, MetricsOptions, Obstacle, PackContext, PackInput, PackLayoutOptions, PackOptions, PackOutput, PackingMetrics, Placement, Port, PushOptions, PushStrategyOptions, Region, ShelfOptions, SizeSearch, SortOrder, StageTrace, Strategy, Supports, Tolerance };
 //# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/vector.ts","../src/rect.ts","../src/order.ts","../src/pack.ts","../src/skyline.ts","../src/shelf.ts","../src/free.ts","../src/push.ts","../src/metrics.ts"],"mappings":";qBACa;;EAIX,YAAY,YAAO;;MAMf;MACA,EAAE;;MAEF;MACA,EAAE;;EAGN,IAAI,WAAW;;EAMf,MAAM,GAAG;;EAMT,IAAI,OAAO,SAAS;;EAKpB;;EAKA,SAAS;;EAKT,MAAM,KAAK,QAAQ,KAAK,SAAS;;SAQ1B,GAAG,iBAAiB;;SAKpB,IAAI,SAAS,WAAW;;SASxB,IAAI,SAAS,WAAW;;aASpB,YAAY;;;qBCxEZ,KAAK;;;EAKhB,KAAK;;EAEL;;EAEA;;EAEA;;;;;EAKA;;MAGI,YAAY;;MAEZ,QAAQ;;EAGZ;;EAEA;;EAGA,WAAW;;EAOX,YAAY,QAAQ;;EAMpB;;SAGO,OAAO,GAAG,OAAO,KAAK,OAAO,KAAK;;SAKlC,SAAS,GAAG,OAAO,KAAK,OAAO,KAAK;;SAKpC,YAAY,GAAG,OAAO,KAAK;;SAK3B,SAAS,GAAG,OAAO,KAAK;;SAKxB,UAAU,GAAG,OAAO,KAAK;;;;;;KC/DtB;;qBAGC,sBAAsB;;wBAGnB,aAAa,OAAO,aAAa,GAAG,GAAG,KAAK,IAAI,GAAG,KAAK;;UCLvD;;EAEf,YAAY;;;UAIG,0BAA0B;;;;;EAKzC;;;;;;;wBAqEc,SAAS,GAAG,OAAO,KAAK,MAAM,OAAO,KAAK,IAAI,UAAS,cAAmB,KAAK;;;;;;;;;;;wBAiB/E,KAAK,GAAG,OAAO,KAAK,MAAM,QAAO,KAAK,IAAiB,UAAS,oBAAyB,KAAK;;;;;;wBChG9F,aAAa,SAAS,mBAAmB,eAAe;EAAe;EAAW;;;;;;;;;;;;;;wBAiClF,YAAY,GAAG,OAAO,KAAK,MAAM,OAAO,KAAK,IAAI;EAAW,YAAY;IAAmB,KAAK;;UCrC/F;;EAEf,YAAY;;;;;;;;;;;;;;wBAiDE,UAAU,GAAG,OAAO,KAAK,MAAM,OAAO,KAAK,IAAI,UAAS,eAAoB,KAAK;;UCnDhF,yBAAyB;;EAExC;;;;;EAKA;;EAEA;;;UAIe;;EAEf;;EAEA;;EAEA;;EAEA;;;UAIe,gBAAgB;;EAE/B,OAAO,KAAK;;EAEZ;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA,OAAO;;;wBAIO,YAAY,eAAe,gBAAgB;;;;;;;;;;;wBAe3C,SAAS,GAAG,OAAO,KAAK,MAAM,QAAO,KAAK,IAAiB,UAAS,mBAAwB,gBAAgB;;UC3D3G;;EAEf;;EAEA;;;;;;;;;;;;;wBAqDc,YAAY,GAAG,QAAQ,KAAK,IAAI,gBAAgB,KAAK,MAAM,UAAS,cAAmB,KAAK;;UCzD3F;;EAEf;;EAEA;IAAQ;IAAe;;;EAEvB;;EAEA;;EAEA;;EAEA;;EAEA;;;UAIe;;EAEf;;;;;;;;;;;wBAYc,eAAe,gBAAgB,QAAQ,UAAS,iBAAsB"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/vector.ts","../src/rect.ts","../src/order.ts","../src/pack.ts","../src/skyline.ts","../src/shelf.ts","../src/free.ts","../src/push.ts","../src/metrics.ts","../src/contract.ts","../src/strategy.ts","../src/adapters.ts","../src/convert.ts","../src/registry.ts","../src/check.ts"],"mappings":"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"}