@thi.ng/geom-subdiv-curve 2.1.131 → 3.0.1

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Change Log
 
-- **Last updated**: 2024-05-08T18:24:32Z
+- **Last updated**: 2024-06-29T09:28:36Z
 - **Generator**: [thi.ng/monopub](https://thi.ng/monopub)
 
 All notable changes to this project will be documented in this file.
@@ -9,6 +9,42 @@ See [Conventional Commits](https://conventionalcommits.org/) for commit guidelin
 **Note:** Unlisted _patch_ versions only involve non-code or otherwise excluded changes
 and/or version bumps of transitive dependencies.
 
+# [3.0.0](https://github.com/thi-ng/umbrella/tree/@thi.ng/geom-subdiv-curve@3.0.0) (2024-06-21)
+
+#### 🛑 Breaking changes
+
+- migrate types from [@thi.ng/geom-api](https://github.com/thi-ng/umbrella/tree/main/packages/geom-api) ([c7564f2](https://github.com/thi-ng/umbrella/commit/c7564f2))
+- BREAKING CHANGE: migrate/internalize types from [@thi.ng/geom-api](https://github.com/thi-ng/umbrella/tree/main/packages/geom-api)
+  - add/migrate SubdivKernel
+  - update imports
+  - update deps
+- update subdiv kernels ([cd69dd4](https://github.com/thi-ng/umbrella/commit/cd69dd4))
+- BREAKING CHANGE: update SubdivKernel interface & impls
+  - update `SubdivKernel` fns to support both open/closed versions
+  - merge/rename open/closed kernels & remove obsolete
+    - SUBDIV_MID
+    - SUBDIV_THIRDS
+    - SUBDIV_CHAIKIN
+    - SUBDIV_CUBIC
+  - add SUBDIV_DLG kernel
+- update subdivide() signature ([25576ca](https://github.com/thi-ng/umbrella/commit/25576ca))
+- BREAKING CHANGE: update subdivide() signature
+  - only accept kernels as array
+  - add `closed` arg/flag
+
+#### 🚀 Features
+
+- add SUBDIV_DISPLACE higher-order kernel ([7655e50](https://github.com/thi-ng/umbrella/commit/7655e50))
+- add support for passing multiple kernels to subdivide() ([03c5e54](https://github.com/thi-ng/umbrella/commit/03c5e54))
+  - update args to support multiple kernels as array
+- update SUBDIV_DISPLACE ([a75f37c](https://github.com/thi-ng/umbrella/commit/a75f37c))
+  - update displace config to allow specifying normalized split positions
+  - add/update docs & example
+
+#### ♻️ Refactoring
+
+- update SUBDIV_DISPLACE, internal refactoring ([3e84ba8](https://github.com/thi-ng/umbrella/commit/3e84ba8))
+
 ### [2.1.86](https://github.com/thi-ng/umbrella/tree/@thi.ng/geom-subdiv-curve@2.1.86) (2023-11-09)
 
 #### ♻️ Refactoring

package/README.md

@@ -7,7 +7,7 @@
 [![Mastodon Follow](https://img.shields.io/mastodon/follow/109331703950160316?domain=https%3A%2F%2Fmastodon.thi.ng&style=social)](https://mastodon.thi.ng/@toxi)
 
 > [!NOTE]
-> This is one of 192 standalone projects, maintained as part
+> This is one of 189 standalone projects, maintained as part
 > of the [@thi.ng/umbrella](https://github.com/thi-ng/umbrella/) monorepo
 > and anti-framework.
 >
@@ -15,6 +15,13 @@
 > GitHub](https://github.com/sponsors/postspectacular). Thank you! ❤️
 
 - [About](#about)
+  - [Available subdivision schemes](#available-subdivision-schemes)
+    - [Chaikin subdivision](#chaikin-subdivision)
+    - [Cubic subdivision](#cubic-subdivision)
+    - [Dyn-Levin-Gregory subdivision](#dyn-levin-gregory-subdivision)
+    - [Displacement subdivision](#displacement-subdivision)
+    - [Split at midpoints](#split-at-midpoints)
+    - [Split at thirds](#split-at-thirds)
 - [Status](#status)
 - [Related packages](#related-packages)
 - [Installation](#installation)
@@ -33,16 +40,55 @@ Based in principle on:
   GPU](http://algorithmicbotany.org/papers/subgpu.sig2003.pdf)
 - Clojure version [thi.ng/geom-clj](http://thi.ng/geom-clj).
 
-Supplied / implemented subdivision schemes:
+### Available subdivision schemes
 
-- Split @ midpoints (open / closed)
-- Split @ thirds (open / closed)
-- Chaikin (open / closed)
-- Cubic (closed only)
+The following schemes are available as presets and their effects illustrated.
 
-| Chaikin (closed)                                        | Chaikin (open)                                      |
-|---------------------------------------------------------|-----------------------------------------------------|
-| ![chaikin closed](../../assets/geom/chaikin-closed.svg) | ![chaikin open](../../assets/geom/chaikin-open.svg) |
+#### Chaikin subdivision
+
+[`SUBDIV_CHAIKIN`](https://docs.thi.ng/umbrella/geom-subdiv-curve/variables/SUBDIV_CHAIKIN.html) is supported for open & closed geometries.
+
+![SUBDIV_CHAIKIN preset on open geometry](https://raw.githubusercontent.com/thi-ng/umbrella/develop/assets/geom-subdiv-curve/subdiv-chaikin-open.png)
+
+![SUBDIV_CHAIKIN preset on closed geometry](https://raw.githubusercontent.com/thi-ng/umbrella/develop/assets/geom-subdiv-curve/subdiv-chaikin-closed.png)
+
+#### Cubic subdivision
+
+[`SUBDIV_CUBIC`](https://docs.thi.ng/umbrella/geom-subdiv-curve/variables/SUBDIV_CUBIC.html)
+is only supported for closed geometries (at current).
+
+![SUBDIV_CUBIC preset on closed geometry](https://raw.githubusercontent.com/thi-ng/umbrella/develop/assets/geom-subdiv-curve/subdiv-cubic-closed.png)
+
+#### Dyn-Levin-Gregory subdivision
+
+[`SUBDIV_DLG`](https://docs.thi.ng/umbrella/geom-subdiv-curve/variables/SUBDIV_DLG.html)
+is only supported for closed geometries (at current).
+
+![SUBDIV_DLG preset on closed geometry](https://raw.githubusercontent.com/thi-ng/umbrella/develop/assets/geom-subdiv-curve/subdiv-dlg-closed.png)
+
+#### Displacement subdivision
+
+[`SUBDIV_DISPLACE`](https://docs.thi.ng/umbrella/geom-subdiv-curve/variables/SUBDIV_DISPLACE.html) is a higher order, customizable subdivision and supported for open & closed geometries.
+
+![SUBDIV_DISPLACE preset on open geometry](https://raw.githubusercontent.com/thi-ng/umbrella/develop/assets/geom-subdiv-curve/subdiv-displace-open.png)
+
+![SUBDIV_DISPLACE preset on closed geometry](https://raw.githubusercontent.com/thi-ng/umbrella/develop/assets/geom-subdiv-curve/subdiv-displace-closed.png)
+
+#### Split at midpoints
+
+[`SUBDIV_MID`](https://docs.thi.ng/umbrella/geom-subdiv-curve/variables/SUBDIV_MID.html) is supported for open & closed geometries.
+
+![SUBDIV_MID preset on open geometry](https://raw.githubusercontent.com/thi-ng/umbrella/develop/assets/geom-subdiv-curve/subdiv-mid-open.png)
+
+![SUBDIV_MID preset on closed geometry](https://raw.githubusercontent.com/thi-ng/umbrella/develop/assets/geom-subdiv-curve/subdiv-mid-closed.png)
+
+#### Split at thirds
+
+[`SUBDIV_THIRDS`](https://docs.thi.ng/umbrella/geom-subdiv-curve/variables/SUBDIV_THIRDS.html) is supported for open & closed geometries.
+
+![SUBDIV_THIRDS preset on open geometry](https://raw.githubusercontent.com/thi-ng/umbrella/develop/assets/geom-subdiv-curve/subdiv-thirds-open.png)
+
+![SUBDIV_THIRDS preset on closed geometry](https://raw.githubusercontent.com/thi-ng/umbrella/develop/assets/geom-subdiv-curve/subdiv-thirds-closed.png)
 
 ## Status
 
@@ -80,12 +126,10 @@ For Node.js REPL:
 const gsc = await import("@thi.ng/geom-subdiv-curve");
 ```
 
-Package sizes (brotli'd, pre-treeshake): ESM: 661 bytes
+Package sizes (brotli'd, pre-treeshake): ESM: 801 bytes
 
 ## Dependencies
 
-- [@thi.ng/api](https://github.com/thi-ng/umbrella/tree/develop/packages/api)
-- [@thi.ng/geom-api](https://github.com/thi-ng/umbrella/tree/develop/packages/geom-api)
 - [@thi.ng/transducers](https://github.com/thi-ng/umbrella/tree/develop/packages/transducers)
 - [@thi.ng/vectors](https://github.com/thi-ng/umbrella/tree/develop/packages/vectors)
 
@@ -96,7 +140,7 @@ Package sizes (brotli'd, pre-treeshake): ESM: 661 bytes
 ```ts
 import * as gsc from "@thi.ng/geom-subdiv-curve";
 
-gsc.subdivide([[0,0], [100,0], [100,100], [0,100]], gsc.SUBDIV_CHAIKIN_CLOSED, 4)
+gsc.subdivide([[0,0], [100,0], [100,100], [0,100]], [gsc.SUBDIV_CHAIKIN], true);
 ```
 
 ## Authors

package/api.d.ts

@@ -1,34 +1,34 @@
-import type { SubdivKernel } from "@thi.ng/geom-api";
-/**
- * Splits each curve / line segment into halves at midpoint. Version for
- * open curves.
- */
-export declare const SUBDIV_MID_OPEN: SubdivKernel;
-/**
- * Splits each curve / line segment into halves at midpoint. Version for
- * closed curves.
- */
-export declare const SUBDIV_MID_CLOSED: SubdivKernel;
-/**
- * Splits each curve / line segment into 3 parts at 1/3 and 2/3. Version for
- * open curves.
- */
-export declare const SUBDIV_THIRDS_OPEN: SubdivKernel;
-/**
- * Splits each curve / line segment into 3 parts at 1/3 and 2/3. Version for
- * open curves.
- */
-export declare const SUBDIV_THIRDS_CLOSED: SubdivKernel;
-/**
- * Chaikin subdivision scheme for open curves.
- */
-export declare const SUBDIV_CHAIKIN_OPEN: SubdivKernel;
-/**
- * Chaikin subdivision scheme for closed curves.
- */
-export declare const SUBDIV_CHAIKIN_CLOSED: SubdivKernel;
-/**
- * Cubic bezier subdivision scheme for closed curves.
- */
-export declare const SUBDIV_CUBIC_CLOSED: SubdivKernel;
+import type { ReadonlyVec, Vec } from "@thi.ng/vectors";
+export interface SubdivKernel {
+    /**
+     * Subdivision function. Called with an array of {@link SubdivKernel.size}
+     * consecutive points of the original curve and can produce any number of
+     * result points. Additionally is passed the index `i` of the processed
+     * point and `nump`, the total number of point in the curve/polyline. The
+     * latter 2 args are useful to implement custom behaviors for the start /
+     * end points of the curve.
+     *
+     * @param pts
+     * @param i
+     * @param nump
+     * @param closed
+     */
+    fn: (pts: ReadonlyVec[], i: number, nump: number, closed: boolean) => Vec[];
+    /**
+     * Optional function to pre-process the original curve points prior
+     * to each subdivision iteration and MUST yield an iterable of
+     * points (e.g. for closed curves / polygons to prepend the last
+     * point before the first). If omitted, the curve points are
+     * processed as is.
+     *
+     * @param pts
+     * @param closed
+     */
+    pre?: (pts: ReadonlyVec[], closed: boolean) => Iterable<ReadonlyVec>;
+    /**
+     * Kernal size. The subdivision function `fn` always receives `size`
+     * number consecutive points.
+     */
+    size: number;
+}
 //# sourceMappingURL=api.d.ts.map

package/api.js

@@ -1,58 +0,0 @@
-import { wrapSides } from "@thi.ng/transducers/wrap-sides";
-import { addmN } from "@thi.ng/vectors/addmn";
-import { mixN } from "@thi.ng/vectors/mixn";
-import { kernel3 } from "./kernels.js";
-const MIDP = ([a, b]) => [a, addmN([], a, b, 0.5)];
-const THIRDS = ([a, b]) => [
-  a,
-  mixN([], a, b, 1 / 3),
-  mixN([], a, b, 2 / 3)
-];
-const wrap2 = (pts) => wrapSides(pts, 0, 1);
-const wrap3 = (pts) => wrapSides(pts, 1, 1);
-const subdivWith = (fn) => (pts, i, n) => i < n - 2 ? fn(pts) : [...fn(pts), pts[1]];
-const SUBDIV_MID_OPEN = {
-  fn: subdivWith(MIDP),
-  size: 2
-};
-const SUBDIV_MID_CLOSED = {
-  fn: MIDP,
-  pre: wrap2,
-  size: 2
-};
-const SUBDIV_THIRDS_OPEN = {
-  fn: subdivWith(THIRDS),
-  size: 2
-};
-const SUBDIV_THIRDS_CLOSED = {
-  fn: THIRDS,
-  pre: wrap2,
-  size: 2
-};
-const CHAIKIN_FIRST = kernel3([1 / 2, 1 / 2, 0], [0, 3 / 4, 1 / 4]);
-const CHAIKIN_MAIN = kernel3([1 / 4, 3 / 4, 0], [0, 3 / 4, 1 / 4]);
-const CHAIKIN_LAST = kernel3([1 / 4, 3 / 4, 0], [0, 1 / 2, 1 / 2]);
-const SUBDIV_CHAIKIN_OPEN = {
-  fn: (pts, i, n) => i == 0 ? [pts[0], ...CHAIKIN_FIRST(pts)] : i === n - 3 ? [...CHAIKIN_LAST(pts), pts[2]] : CHAIKIN_MAIN(pts),
-  size: 3
-};
-const SUBDIV_CHAIKIN_CLOSED = {
-  fn: CHAIKIN_MAIN,
-  pre: wrap3,
-  size: 3
-};
-const CUBIC_MAIN = kernel3([1 / 8, 3 / 4, 1 / 8], [0, 1 / 2, 1 / 2]);
-const SUBDIV_CUBIC_CLOSED = {
-  fn: CUBIC_MAIN,
-  pre: wrap3,
-  size: 3
-};
-export {
-  SUBDIV_CHAIKIN_CLOSED,
-  SUBDIV_CHAIKIN_OPEN,
-  SUBDIV_CUBIC_CLOSED,
-  SUBDIV_MID_CLOSED,
-  SUBDIV_MID_OPEN,
-  SUBDIV_THIRDS_CLOSED,
-  SUBDIV_THIRDS_OPEN
-};

package/kernels.d.ts

@@ -1,4 +1,5 @@
 import type { ReadonlyVec } from "@thi.ng/vectors";
+import type { SubdivKernel } from "./api.js";
 /**
  * HOF subdiv kernel function for computing 2 split points from 2 source
  * points, using weighted summation (thi.ng/vectors/addW2)
@@ -23,4 +24,61 @@ export declare const kernel3: ([ua, ub, uc]: number[], [va, vb, vc]: number[]) =
  * @param v - split coeffs
  */
 export declare const kernel5: ([ua, ub, uc, ud, ue]: number[], [va, vb, vc, vd, ve]: number[]) => ([a, b, c, d, e]: ReadonlyVec[]) => import("@thi.ng/vectors").Vec[];
+/**
+ * Splits each curve / line segment into halves at midpoint.
+ */
+export declare const SUBDIV_MID: SubdivKernel;
+/**
+ * Splits each curve / line segment into 3 parts at 1/3 and 2/3.
+ */
+export declare const SUBDIV_THIRDS: SubdivKernel;
+/**
+ * Chaikin subdivision scheme for open curves.
+ */
+export declare const SUBDIV_CHAIKIN: SubdivKernel;
+/**
+ * Cubic bezier subdivision scheme. Currently ONLY supported for closed curves.
+ */
+export declare const SUBDIV_CUBIC: SubdivKernel;
+/**
+ * Subdivision kernel for Dyn-Levin-Gregory subdivision. Currently ONLY
+ * supported for closed curves.
+ *
+ * @remarks
+ * Reference:
+ * - https://web.archive.org/web/20060816003547/https://algorithmicbotany.org/papers/subgpu.sig2003.pdf
+ */
+export declare const SUBDIV_DLG: SubdivKernel;
+/**
+ * Higher-order subdiv kernel. Takes an array of 2-tuples of `[t,x]` where `t`
+ * is the normalized split position (along each edge) and `x` is the normalized
+ * displacement amount (relative to edge length). The `closed` flag indicates if
+ * to be used for open/closed curves. Returns a {@link SubdivKernel} which
+ * results in `displace.length` points for each original edge and displaces each
+ * point by `displace[i][1] * edgeLength` units along the normal of the edge.
+ *
+ * @remarks
+ * The original edge end points are always remaining in place. The normalized
+ * split positions `t` must be in the open (0,1) interval.
+ *
+ * @example
+ * ```ts tangle:../export/subdiv-displace.ts
+ * import { subdivide, SUBDIV_DISPLACE } from "@thi.ng/geom-subdiv-curve";
+ *
+ * // define subdiv kernel w/ custom displacements
+ * const kernel = SUBDIV_DISPLACE([[0.25, 0.25], [0.75, -0.25]]);
+ *
+ * // subdivide polyline with the kernel
+ * console.log(
+ *   subdivide([[0,0], [100, 100], [200, 0]], kernel)
+ * );
+ * // [
+ * //   [ 0, 0 ], [ 50, 0 ], [ 50, 100 ], [ 100, 100 ],
+ * //   [100, 50 ], [ 200, 50 ], [ 200, 0 ]
+ * // ]
+ * ```
+ *
+ * @param displace
+ */
+export declare const SUBDIV_DISPLACE: (displace: number[][]) => SubdivKernel;
 //# sourceMappingURL=kernels.d.ts.map

package/kernels.js

@@ -1,11 +1,84 @@
+import { wrapSides } from "@thi.ng/transducers/wrap-sides";
+import { addmN } from "@thi.ng/vectors/addmn";
 import { addW2, addW3, addW5 } from "@thi.ng/vectors/addw";
+import { mag2 } from "@thi.ng/vectors/mag";
+import { mixN } from "@thi.ng/vectors/mixn";
+import { normalize2 } from "@thi.ng/vectors/normalize";
+import { perpendicularCW } from "@thi.ng/vectors/perpendicular";
+import { sub2 } from "@thi.ng/vectors/sub";
 const kernel2 = ([ua, ub], [va, vb]) => ([a, b]) => [addW2([], a, b, ua, ub), addW2([], a, b, va, vb)];
 const kernel3 = ([ua, ub, uc], [va, vb, vc]) => ([a, b, c]) => [addW3([], a, b, c, ua, ub, uc), addW3([], a, b, c, va, vb, vc)];
 const kernel5 = ([ua, ub, uc, ud, ue], [va, vb, vc, vd, ve]) => ([a, b, c, d, e]) => [
   addW5([], a, b, c, d, e, ua, ub, uc, ud, ue),
   addW5([], a, b, c, d, e, va, vb, vc, vd, ve)
 ];
+const __wrap2 = (pts, closed) => closed ? wrapSides(pts, 0, 1) : pts;
+const __wrap3 = (pts, closed) => closed ? wrapSides(pts, 1, 1) : pts;
+const SUBDIV_MID = {
+  fn: ([a, b], i, nump, closed) => {
+    const res = [a, addmN([], a, b, 0.5)];
+    if (!closed && i === nump - 2) res.push(b);
+    return res;
+  },
+  pre: __wrap2,
+  size: 2
+};
+const SUBDIV_THIRDS = {
+  fn: ([a, b], i, nump, closed) => {
+    const res = [a, mixN([], a, b, 1 / 3), mixN([], a, b, 2 / 3)];
+    if (!closed && i === nump - 2) res.push(b);
+    return res;
+  },
+  pre: __wrap2,
+  size: 2
+};
+const CHAIKIN_FIRST = kernel3([1 / 2, 1 / 2, 0], [0, 3 / 4, 1 / 4]);
+const CHAIKIN_MAIN = kernel3([1 / 4, 3 / 4, 0], [0, 3 / 4, 1 / 4]);
+const CHAIKIN_LAST = kernel3([1 / 4, 3 / 4, 0], [0, 1 / 2, 1 / 2]);
+const SUBDIV_CHAIKIN = {
+  fn: (pts, i, n, closed) => closed ? CHAIKIN_MAIN(pts) : i == 0 ? [pts[0], ...CHAIKIN_FIRST(pts)] : i === n - 3 ? [...CHAIKIN_LAST(pts), pts[2]] : CHAIKIN_MAIN(pts),
+  pre: __wrap3,
+  size: 3
+};
+const CUBIC_MAIN = kernel3([1 / 8, 3 / 4, 1 / 8], [0, 1 / 2, 1 / 2]);
+const SUBDIV_CUBIC = {
+  fn: (pts) => CUBIC_MAIN(pts),
+  pre: (pts) => wrapSides(pts, 1, 1),
+  size: 3
+};
+const DLG_MAIN = kernel5(
+  [0, 0, 1, 0, 0],
+  [0, -1 / 16, 9 / 16, 9 / 16, -1 / 16]
+);
+const SUBDIV_DLG = {
+  fn: (pts) => DLG_MAIN(pts),
+  pre: (pts) => wrapSides(pts, 2, 2),
+  size: 5
+};
+const SUBDIV_DISPLACE = (displace) => ({
+  fn: ([a, b], i, nump, closed) => {
+    const delta = sub2([], b, a);
+    const len = mag2(delta);
+    const normal = perpendicularCW(null, normalize2([], delta));
+    const res = [
+      a,
+      ...displace.map(
+        ([t, x]) => addW3([], a, delta, normal, 1, t, x * len)
+      )
+    ];
+    if (!closed && i === nump - 2) res.push(b);
+    return res;
+  },
+  size: 2,
+  pre: __wrap2
+});
 export {
+  SUBDIV_CHAIKIN,
+  SUBDIV_CUBIC,
+  SUBDIV_DISPLACE,
+  SUBDIV_DLG,
+  SUBDIV_MID,
+  SUBDIV_THIRDS,
   kernel2,
   kernel3,
   kernel5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thi.ng/geom-subdiv-curve",
-  "version": "2.1.131",
+  "version": "3.0.1",
   "description": "Freely customizable, iterative nD subdivision curves for open / closed geometries",
   "type": "module",
   "module": "./index.js",
@@ -10,7 +10,7 @@
     "type": "git",
     "url": "https://github.com/thi-ng/umbrella.git"
   },
-  "homepage": "https://github.com/thi-ng/umbrella/tree/develop/packages/geom-subdiv-curve#readme",
+  "homepage": "https://thi.ng/geom-subdiv-curve",
   "funding": [
     {
       "type": "github",
@@ -33,19 +33,18 @@
     "doc:readme": "bun ../../tools/src/module-stats.ts && bun ../../tools/src/readme.ts",
     "pub": "yarn npm publish --access public",
     "test": "bun test",
-    "tool:tangle": "../../node_modules/.bin/tangle src/**/*.ts"
+    "tool:tangle": "../../node_modules/.bin/tangle src/**/*.ts",
+    "tool:viz": "bun tools/visualize.ts"
   },
   "dependencies": {
-    "@thi.ng/api": "^8.11.2",
-    "@thi.ng/geom-api": "^4.0.10",
-    "@thi.ng/transducers": "^9.0.5",
-    "@thi.ng/vectors": "^7.10.31"
+    "@thi.ng/transducers": "^9.0.7",
+    "@thi.ng/vectors": "^7.11.1"
   },
   "devDependencies": {
-    "@microsoft/api-extractor": "^7.43.2",
-    "esbuild": "^0.21.1",
+    "@microsoft/api-extractor": "^7.47.0",
+    "esbuild": "^0.21.5",
     "typedoc": "^0.25.13",
-    "typescript": "^5.4.5"
+    "typescript": "^5.5.2"
   },
   "keywords": [
     "2d",
@@ -91,5 +90,5 @@
       "geom-splines"
     ]
   },
-  "gitHead": "df34b4a9e650cc7323575356de207d78933bdcf3\n"
+  "gitHead": "7b950c112fba0b2e7c450765b15624c3382f1354\n"
 }

package/subdivide.d.ts

@@ -1,11 +1,19 @@
-import type { SubdivKernel } from "@thi.ng/geom-api";
 import type { ReadonlyVec } from "@thi.ng/vectors";
+import type { SubdivKernel } from "./api.js";
 /**
- * http://algorithmicbotany.org/papers/subgpu.sig2003.pdf
+ * Takes an array of `points` and an array of subdivision `kernels`. Iterativel
+ * applies kernels in given order (each iteration operating on the result of the
+ * previous iteration). The `closed` flag (default: false) indicates if the
+ * points define a closed or open geometry (i.e. polygon vs. polyline).
  *
- * @param kernel - subdivision scheme
- * @param pts - source points
- * @param iter - number of iterations
+ * @remarks
+ * Reference:
+ * - https://web.archive.org/web/20060816003547/https://algorithmicbotany.org/papers/subgpu.sig2003.pdf
+ * - https://www.csl.mtu.edu/cs3621/common/Subdivision.pdf
+ *
+ * @param points - source points
+ * @param kernels - subdivision scheme(s)
+ * @param closed
  */
-export declare const subdivide: (pts: ReadonlyVec[], { fn, pre, size }: SubdivKernel, iter?: number) => ReadonlyVec[];
+export declare function subdivide(points: ReadonlyVec[], kernels: SubdivKernel[], closed?: boolean): ReadonlyVec[];
 //# sourceMappingURL=subdivide.d.ts.map

package/subdivide.js

@@ -3,20 +3,20 @@ import { mapcatIndexed } from "@thi.ng/transducers/mapcat-indexed";
 import { partition } from "@thi.ng/transducers/partition";
 import { push } from "@thi.ng/transducers/push";
 import { transduce } from "@thi.ng/transducers/transduce";
-const subdivide = (pts, { fn, pre, size }, iter = 1) => {
-  while (iter-- > 0) {
-    const nump = pts.length;
-    pts = transduce(
+function subdivide(points, kernels, closed = false) {
+  for (let { fn, pre, size } of kernels) {
+    const nump = points.length;
+    points = transduce(
       comp(
         partition(size, 1),
-        mapcatIndexed((i, pts2) => fn(pts2, i, nump))
+        mapcatIndexed((i, pts) => fn(pts, i, nump, closed))
       ),
       push(),
-      pre ? pre(pts) : pts
+      pre ? pre(points, closed) : points
     );
   }
-  return pts;
-};
+  return points;
+}
 export {
   subdivide
 };