@thi.ng/geom-sdf 0.1.1 → 0.2.0

package/dist.js

@@ -1,4 +1,4 @@
-import { SQRT3 } from "@thi.ng/math";
+import { SQRT3 } from "@thi.ng/math/api";
 import { clamp01 } from "@thi.ng/math/interval";
 import { abs2 } from "@thi.ng/vectors/abs";
 import { add2 } from "@thi.ng/vectors/add";
@@ -16,55 +16,135 @@ import { powN2 } from "@thi.ng/vectors/pown";
 import { sign2 } from "@thi.ng/vectors/sign";
 import { some3 } from "@thi.ng/vectors/some";
 import { sub2 } from "@thi.ng/vectors/sub";
-const mag2 = (v) => Math.sqrt(magSq2(v));
+const t1 = [];
+const t2 = [];
+const t3 = [];
+const t4 = [];
+const t5 = [];
+const { abs, cos, min, max, sign, sin, sqrt } = Math;
+const mag2 = (v) => sqrt(magSq2(v));
+/**
+ * Computes signed distance to centered 2D circle of given `radius`.
+ *
+ * @remarks
+ * Ported from code by Inigo Quilez:
+ * https://iquilezles.org/articles/distfunctions2d/
+ *
+ * @param p
+ * @param radius
+ */
 export const distCircle2 = (p, radius) => mag2(p) - radius;
+/**
+ * Computes signed distance to centered 2D box of given `halfSize`.
+ *
+ * @remarks
+ * Ported from code by Inigo Quilez:
+ * https://iquilezles.org/articles/distfunctions2d/
+ *
+ * @param p
+ * @param halfSize
+ */
 export const distBox2 = (p, halfSize) => {
-    const d = sub2(null, abs2([], p), halfSize);
-    return Math.min(Math.max(d[0], d[1]), 0) + mag2(max2(null, d, ZERO2));
+    const d = sub2(null, abs2(t1, p), halfSize);
+    return min(max(d[0], d[1]), 0) + mag2(max2(null, d, ZERO2));
 };
-export const distPolygon2 = (pts, p) => {
+/**
+ * Computes signed distance to the 2D polygon defined by given point array.
+ *
+ * @remarks
+ * Ported from code by Inigo Quilez:
+ * https://iquilezles.org/articles/distfunctions2d/
+ *
+ * @param p
+ * @param pts
+ */
+export const distPolygon2 = (p, pts) => {
     let d = distSq2(p, pts[0]);
     let s = 1;
     const py = p[1];
-    const t1 = [];
-    const t2 = [];
-    const t3 = [];
     for (let n = pts.length, i = 0, j = n - 1; i < n; j = i, i++) {
         const pi = pts[i];
         const pj = pts[j];
         const e = sub2(t1, pj, pi);
         const w = sub2(t2, p, pi);
-        d = Math.min(d, distSq2(w, mulN2(t3, e, clamp01(dot2(w, e) / magSq2(e)))));
+        d = min(d, distSq2(w, mulN2(t3, e, clamp01(dot2(w, e) / magSq2(e)))));
         const c = [py >= pi[1], py < pj[1], e[0] * w[1] > e[1] * w[0]];
         if (every3(c) || !some3(c))
             s *= -1;
     }
-    return s * Math.sqrt(d);
+    return s * sqrt(d);
 };
-export const distSegment2 = (a, b, p) => {
-    const pa = sub2([], p, a);
-    const ba = sub2([], b, a);
-    const h = clamp01(dot2(pa, ba) / magSq2(ba));
-    return mag2(sub2(null, pa, mulN2(null, ba, h)));
+/**
+ * Computes distance to 2D line segment defined by endpoints `a` and `b`.
+ *
+ * @remarks
+ * Ported from code by Inigo Quilez:
+ * https://iquilezles.org/articles/distfunctions2d/
+ *
+ * @param p
+ * @param a
+ * @param b
+ */
+export const distSegment2 = (p, a, b) => {
+    const pa = sub2(t1, p, a);
+    const ba = sub2(t2, b, a);
+    return mag2(sub2(null, pa, mulN2(null, ba, clamp01(dot2(pa, ba) / magSq2(ba)))));
 };
-export const distPolyline2 = (pts, p) => {
+/**
+ * Computes distance to 2D polyline defined by given point array (i.e. the union
+ * of pairwise results of {@link distSegment2}).
+ *
+ * @param p
+ * @param pts
+ */
+export const distPolyline2 = (p, pts) => {
     let d = Infinity;
     for (let i = 1, n = pts.length; i < n; i++) {
-        d = Math.min(d, distSegment2(pts[i - 1], pts[i], p));
+        d = min(d, distSegment2(p, pts[i - 1], pts[i]));
     }
     return d;
 };
+/**
+ * Computes signed distance to circular arc with given aperture, radius and
+ * radius offset (thickness). The aperture is symmetric along the Y-axis and has
+ * its origin in +Y.
+ *
+ * @remarks
+ * Ported from code by Inigo Quilez:
+ * https://iquilezles.org/articles/distfunctions2d/
+ *
+ * @param p
+ * @param apert - pre-computed vec2 of [sin, cos] of aperture angle
+ * @param ra - inner radius
+ * @param rb - outer radius offset (thickness)
+ */
 export const distArc2 = (p, apert, ra, rb) => {
-    const q = [Math.abs(p[0]), p[1]];
-    return ((apert[1] * q[0] > apert[0] * q[1]
-        ? mag2(maddN2(q, apert, -ra, q))
-        : Math.abs(mag2(q) - ra)) - rb);
+    t1[0] = abs(p[0]);
+    t1[1] = p[1];
+    return ((apert[1] * t1[0] > apert[0] * t1[1]
+        ? mag2(maddN2(t1, apert, -ra, t1))
+        : abs(mag2(t1) - ra)) - rb);
 };
-export const distQuadratic2 = (pos, a, b, c, signed = true) => {
-    const aa = sub2([], b, a);
-    const bb = add2(null, maddN2([], b, -2, a), c);
-    const cc = mulN2([], aa, 2);
-    const dd = sub2([], a, pos);
+/**
+ * Computes (unsigned, by default) distance to given 2D quadratic bezier
+ * segment. If `signed` is set to true, points in the curve's interior region
+ * will yield negative distances.
+ *
+ * @remarks
+ * Based on code by Inigo Quilez:
+ * https://iquilezles.org/articles/distfunctions2d/
+ *
+ * @param pos
+ * @param a
+ * @param b
+ * @param c
+ * @param signed
+ */
+export const distQuadratic2 = (pos, a, b, c, signed = false) => {
+    const aa = sub2(t1, b, a);
+    const bb = add2(null, maddN2(t2, b, -2, a), c);
+    const cc = mulN2(t3, aa, 2);
+    const dd = sub2(t4, a, pos);
     const kk = 1 / magSq2(bb);
     const kx = kk * dot2(aa, bb);
     const ky = (kk * (2 * magSq2(aa) + dot2(dd, bb))) / 3;
@@ -75,38 +155,45 @@ export const distQuadratic2 = (pos, a, b, c, signed = true) => {
     const q2 = q * q;
     let h = q2 + 4 * p3;
     if (h >= 0) {
-        h = Math.sqrt(h);
+        h = sqrt(h);
         const x = [(h - q) / 2, (-h - q) / 2];
-        const uv = mul2(null, sign2([], x), powN2([], abs2([], x), 1 / 3));
+        const uv = mul2(null, sign2(t1, x), powN2(null, abs2(null, x), 1 / 3));
         const t = clamp01(uv[0] + uv[1] - kx);
-        const qq = maddN2(null, maddN2([], bb, t, cc), t, dd);
+        const qq = maddN2(null, maddN2(t1, bb, t, cc), t, dd);
         return (mag2(qq) *
-            (signed ? Math.sign(cross2(maddN2([], bb, 2 * t, cc), qq)) : 1));
+            (signed ? sign(cross2(maddN2(bb, bb, 2 * t, cc), qq)) : 1));
     }
     else {
-        const z = Math.sqrt(-p);
+        const z = sqrt(-p);
         const v = Math.acos(q / (p * z * 2)) / 3;
-        const m = Math.cos(v);
-        const n = Math.sin(v) * 1.732050808;
+        const m = cos(v);
+        const n = sin(v) * SQRT3;
         const tx = clamp01((m + m) * z - kx);
         const ty = clamp01((-n - m) * z - kx);
-        const qx = maddN2(null, maddN2([], bb, tx, cc), tx, dd);
+        const qx = maddN2(null, maddN2(t1, bb, tx, cc), tx, dd);
         const dx = magSq2(qx);
-        const qy = maddN2(null, maddN2([], bb, ty, cc), ty, dd);
+        const qy = maddN2(null, maddN2(t5, bb, ty, cc), ty, dd);
         const dy = magSq2(qy);
-        if (dx < dy) {
-            return (Math.sqrt(dx) *
-                (signed ? Math.sign(cross2(maddN2([], bb, 2 * tx, cc), qx)) : 1));
-        }
-        else {
-            return (Math.sqrt(dy) *
-                (signed ? Math.sign(cross2(maddN2([], bb, 2 * ty, cc), qy)) : 1));
-        }
+        return dx < dy
+            ? sqrt(dx) *
+                (signed ? sign(cross2(maddN2(bb, bb, 2 * tx, cc), qx)) : 1)
+            : sqrt(dy) *
+                (signed ? sign(cross2(maddN2(bb, bb, 2 * ty, cc), qy)) : 1);
     }
 };
+/**
+ * Computes signed distance to centered 2D ellipse.
+ *
+ * @remarks
+ * Based on code by Inigo Quilez:
+ * https://iquilezles.org/articles/distfunctions2d/
+ *
+ * @param p
+ * @param radii
+ */
 export const distEllipse2 = ([px, py], [abx, aby]) => {
-    px = Math.abs(px);
-    py = Math.abs(py);
+    px = abs(px);
+    py = abs(py);
     if (px > py) {
         let t = px;
         px = py;
@@ -129,22 +216,22 @@ export const distEllipse2 = ([px, py], [abx, aby]) => {
     let co;
     if (d < 0) {
         const h = Math.acos(q / c3) / 3;
-        const s = Math.cos(h);
-        const t = Math.sin(h) * SQRT3;
-        const rx = Math.sqrt(-c * (s + t + 2) + m2);
-        const ry = Math.sqrt(-c * (s - t + 2) + m2);
-        co = (ry + Math.sign(l) * rx + Math.abs(g) / (rx * ry) - m) / 2;
+        const s = cos(h);
+        const t = sin(h) * SQRT3;
+        const rx = sqrt(-c * (s + t + 2) + m2);
+        const ry = sqrt(-c * (s - t + 2) + m2);
+        co = (ry + sign(l) * rx + abs(g) / (rx * ry) - m) / 2;
     }
     else {
-        const h = 2 * m * n * Math.sqrt(d);
-        const s = Math.sign(q + h) * Math.cbrt(Math.abs(q + h));
-        const u = Math.sign(q - h) * Math.cbrt(Math.abs(q - h));
+        const h = 2 * m * n * sqrt(d);
+        const s = sign(q + h) * Math.cbrt(abs(q + h));
+        const u = sign(q - h) * Math.cbrt(abs(q - h));
         const rx = -s - u - c * 4 + 2 * m2;
         const ry = (s - u) * SQRT3;
         const rm = Math.hypot(rx, ry);
-        co = (ry / Math.sqrt(rm - rx) + (2 * g) / rm - m) / 2;
+        co = (ry / sqrt(rm - rx) + (2 * g) / rm - m) / 2;
     }
     const rx = abx * co;
-    const ry = aby * Math.sqrt(1 - co * co);
-    return Math.hypot(rx - px, ry - py) * Math.sign(py - ry);
+    const ry = aby * sqrt(1 - co * co);
+    return Math.hypot(rx - px, ry - py) * sign(py - ry);
 };

package/domain.d.ts

@@ -0,0 +1,34 @@
+import type { ReadonlyVec, Vec } from "@thi.ng/vectors/api";
+/**
+ * @remarks
+ * Ported from: HG_SDF by Mercury Demogroup
+ * https://mercury.sexy/hg_sdf/
+ *
+ * @param size
+ */
+export declare const repeat2: (size: ReadonlyVec) => (p: ReadonlyVec) => Vec;
+/**
+ * @remarks
+ * Ported from: HG_SDF by Mercury Demogroup
+ * https://mercury.sexy/hg_sdf/
+ *
+ * @param size
+ */
+export declare const repeatMirror2: (size: ReadonlyVec) => (p: ReadonlyVec) => Vec;
+/**
+ * @remarks
+ * Ported from: HG_SDF by Mercury Demogroup
+ * https://mercury.sexy/hg_sdf/
+ *
+ * @param size
+ */
+export declare const repeatGrid2: (size: ReadonlyVec) => (p: ReadonlyVec) => ReadonlyVec;
+/**
+ * @remarks
+ * Ported from: HG_SDF by Mercury Demogroup
+ * https://mercury.sexy/hg_sdf/
+ *
+ * @param n - number of repetition
+ */
+export declare const repeatPolar2: (n: number) => (p: ReadonlyVec) => number[];
+//# sourceMappingURL=domain.d.ts.map

package/domain.js

@@ -0,0 +1,63 @@
+import { cossin } from "@thi.ng/math";
+import { TAU } from "@thi.ng/math/api";
+import { mod } from "@thi.ng/math/prec";
+import { add2 } from "@thi.ng/vectors/add";
+import { div2 } from "@thi.ng/vectors/div";
+import { floor2 } from "@thi.ng/vectors/floor";
+import { mag } from "@thi.ng/vectors/mag";
+import { mod2 } from "@thi.ng/vectors/mod";
+import { modN2 } from "@thi.ng/vectors/modn";
+import { mul2 } from "@thi.ng/vectors/mul";
+import { mulN2 } from "@thi.ng/vectors/muln";
+import { sub2 } from "@thi.ng/vectors/sub";
+import { subN2 } from "@thi.ng/vectors/subn";
+/**
+ * @remarks
+ * Ported from: HG_SDF by Mercury Demogroup
+ * https://mercury.sexy/hg_sdf/
+ *
+ * @param size
+ */
+export const repeat2 = (size) => {
+    const s2 = mulN2([], size, 0.5);
+    return (p) => sub2(null, mod2(null, add2([], s2, p), size), s2);
+};
+/**
+ * @remarks
+ * Ported from: HG_SDF by Mercury Demogroup
+ * https://mercury.sexy/hg_sdf/
+ *
+ * @param size
+ */
+export const repeatMirror2 = (size) => {
+    const c = [];
+    const s2 = mulN2([], size, 0.5);
+    return (p) => mul2(null, sub2(null, mod2(null, add2([], s2, p), size), s2), subN2(null, mulN2(null, modN2(null, floor2(null, div2(null, add2(c, s2, p), size)), 2), 2), 1));
+};
+/**
+ * @remarks
+ * Ported from: HG_SDF by Mercury Demogroup
+ * https://mercury.sexy/hg_sdf/
+ *
+ * @param size
+ */
+export const repeatGrid2 = (size) => {
+    const s2 = mulN2([], size, 0.5);
+    const rm = repeatMirror2(size);
+    return (p) => {
+        p = sub2(null, rm(p), s2);
+        return p[0] > p[1] ? [p[1], p[0]] : p;
+    };
+};
+/**
+ * @remarks
+ * Ported from: HG_SDF by Mercury Demogroup
+ * https://mercury.sexy/hg_sdf/
+ *
+ * @param n - number of repetition
+ */
+export const repeatPolar2 = (n) => {
+    const theta = TAU / n;
+    const halfTheta = theta / 2;
+    return (p) => cossin(mod(Math.atan2(p[1], p[0]) + halfTheta, theta) - halfTheta, mag(p));
+};

package/index.d.ts

@@ -1,6 +1,8 @@
 export * from "./api.js";
+export * from "./as-polygons.js";
 export * from "./as-sdf.js";
 export * from "./dist.js";
+export * from "./domain.js";
 export * from "./ops.js";
 export * from "./sample.js";
 export * from "./shapes.js";

package/index.js

@@ -1,6 +1,8 @@
 export * from "./api.js";
+export * from "./as-polygons.js";
 export * from "./as-sdf.js";
 export * from "./dist.js";
+export * from "./domain.js";
 export * from "./ops.js";
 export * from "./sample.js";
 export * from "./shapes.js";

package/ops.d.ts

@@ -1,11 +1,23 @@
-import type { SDFn } from "./api.js";
+import type { Fn3, FnN2 } from "@thi.ng/api";
+import type { FieldCoeff, SDFn } from "./api.js";
 export declare const abs: (sdf: SDFn) => SDFn;
 export declare const flip: (sdf: SDFn) => SDFn;
-export declare const round: (sdf: SDFn, r: number) => SDFn;
+export declare const offset: (sdf: SDFn, r: number | FieldCoeff) => SDFn;
+export declare const defOp: (op: FnN2) => (children: SDFn[]) => SDFn;
 export declare const union: (children: SDFn[]) => SDFn;
-export declare const intersection: (children: SDFn[]) => SDFn;
-export declare const difference: (a: SDFn, ...children: SDFn[]) => SDFn;
-export declare const smoothUnion: (k: number, a: SDFn, ...children: SDFn[]) => SDFn;
-export declare const smoothIntersection: (k: number, a: SDFn, ...children: SDFn[]) => SDFn;
-export declare const smoothDifference: (k: number, a: SDFn, ...children: SDFn[]) => SDFn;
+export declare const isec: (children: SDFn[]) => SDFn;
+export declare const diff: (children: SDFn[]) => SDFn;
+export declare const defParamOp: <T = number>(op: Fn3<number, number, T, number>) => (k: T | FieldCoeff<T>, children: SDFn[]) => SDFn;
+export declare const smoothUnion: (k: number | FieldCoeff<number>, children: SDFn[]) => SDFn;
+export declare const smoothIsec: (k: number | FieldCoeff<number>, children: SDFn[]) => SDFn;
+export declare const smoothDiff: (k: number | FieldCoeff<number>, children: SDFn[]) => SDFn;
+export declare const chamferUnion: (k: number | FieldCoeff<number>, children: SDFn[]) => SDFn;
+export declare const chamferIsec: (k: number | FieldCoeff<number>, children: SDFn[]) => SDFn;
+export declare const chamferDiff: (k: number | FieldCoeff<number>, children: SDFn[]) => SDFn;
+export declare const roundUnion: (k: number | FieldCoeff<number>, children: SDFn[]) => SDFn;
+export declare const roundIsec: (k: number | FieldCoeff<number>, children: SDFn[]) => SDFn;
+export declare const roundDiff: (k: number | FieldCoeff<number>, children: SDFn[]) => SDFn;
+export declare const stepUnion: (k: [number, number] | FieldCoeff<[number, number]>, children: SDFn[]) => SDFn;
+export declare const stepIsec: (k: [number, number] | FieldCoeff<[number, number]>, children: SDFn[]) => SDFn;
+export declare const stepDiff: (k: [number, number] | FieldCoeff<[number, number]>, children: SDFn[]) => SDFn;
 //# sourceMappingURL=ops.d.ts.map

package/ops.js

@@ -1,22 +1,74 @@
-import { clamp01, mix } from "@thi.ng/math";
-export const abs = (sdf) => (p) => Math.abs(sdf(p));
-export const flip = (sdf) => (p) => -sdf(p);
-export const round = (sdf, r) => (p) => sdf(p) - r;
-export const union = (children) => (p) => children.reduce((acc, f) => Math.min(acc, f(p)), Infinity);
-export const intersection = (children) => (p) => children.reduce((acc, f) => Math.max(acc, f(p)), -Infinity);
-export const difference = (a, ...children) => (p) => children.reduce((acc, f) => Math.max(acc, -f(p)), a(p));
-export const smoothUnion = (k, a, ...children) => (p) => children.reduce((acc, f) => {
-    const d = f(p);
-    const h = clamp01(0.5 + (0.5 * (d - acc)) / k);
-    return mix(d, acc, h) - k * h * (1 - h);
-}, a(p));
-export const smoothIntersection = (k, a, ...children) => (p) => children.reduce((acc, f) => {
-    const d = f(p);
-    const h = clamp01(0.5 - (0.5 * (d - acc)) / k);
-    return mix(d, acc, h) + k * h * (1 - h);
-}, a(p));
-export const smoothDifference = (k, a, ...children) => (p) => children.reduce((acc, f) => {
-    const d = f(p);
-    const h = clamp01(0.5 - (0.5 * (acc + d)) / k);
-    return mix(acc, -d, h) + k * h * (1 - h);
-}, a(p));
+import { isFunction } from "@thi.ng/checks/is-function";
+import { assert } from "@thi.ng/errors/assert";
+import { clamp01, mix, mod, SQRT2_2 } from "@thi.ng/math";
+const __asField = (k) => (isFunction(k) ? k : () => k);
+const __ensureChildren = (children, min = 1) => assert(children.length >= 1, `require at least ${min} SDF(s)`);
+const { min, max } = Math;
+export const abs = (sdf) => (p, minD) => Math.abs(sdf(p, minD));
+export const flip = (sdf) => (p, minD) => -sdf(p, minD);
+export const offset = (sdf, r) => isFunction(r)
+    ? (p, minD) => sdf(p, minD) - r(p)
+    : (p, minD) => sdf(p, minD) - r;
+export const defOp = (op) => (children) => {
+    __ensureChildren(children);
+    const n = children.length;
+    return (p, minD = Infinity) => {
+        let res = children[0](p, minD);
+        if (res < minD)
+            minD = res;
+        for (let i = 1; i < n; i++) {
+            const d = children[i](p, minD);
+            if (d < minD)
+                minD = d;
+            res = op(res, d);
+        }
+        return res;
+    };
+};
+export const union = defOp(min);
+export const isec = defOp(max);
+export const diff = defOp((a, b) => max(a, -b));
+export const defParamOp = (op) => (k, children) => {
+    __ensureChildren(children);
+    const kfield = __asField(k);
+    const n = children.length;
+    return (p, minD = Infinity) => {
+        const $k = kfield(p);
+        let res = children[0](p, minD);
+        if (res < minD)
+            minD = res;
+        for (let i = 1; i < n; i++) {
+            const d = children[i](p, minD);
+            if (d < minD)
+                minD = d;
+            res = op(res, d, $k);
+        }
+        return res;
+    };
+};
+export const smoothUnion = defParamOp((a, b, k) => {
+    const h = clamp01(0.5 + (0.5 * (b - a)) / k);
+    return mix(b, a, h) - k * h * (1 - h);
+});
+export const smoothIsec = defParamOp((a, b, k) => {
+    const h = clamp01(0.5 - (0.5 * (b - a)) / k);
+    return mix(b, a, h) + k * h * (1 - h);
+});
+export const smoothDiff = defParamOp((a, b, k) => {
+    const h = clamp01(0.5 - (0.5 * (a + b)) / k);
+    return mix(a, -b, h) + k * h * (1 - h);
+});
+export const chamferUnion = defParamOp((a, b, k) => min(min(a, b), (a - k + b) * SQRT2_2));
+export const chamferIsec = defParamOp((a, b, k) => max(max(a, b), (a + k + b) * SQRT2_2));
+export const chamferDiff = defParamOp((a, b, k) => max(max(a, -b), (a + k - b) * SQRT2_2));
+export const roundUnion = defParamOp((a, b, k) => max(k, min(a, b)) - Math.hypot(max(k - a, 0), max(k - b, 0)));
+export const roundIsec = defParamOp((a, b, k) => min(-k, max(a, b)) + Math.hypot(max(k + a, 0), max(k + b, 0)));
+export const roundDiff = defParamOp((a, b, k) => min(-k, max(a, -b)) + Math.hypot(max(k + a, 0), max(k - b, 0)));
+const __steps = (a, b, [r, n]) => {
+    const s = r / n;
+    const u = b - r;
+    return min(min(a, b), 0.5 * (u + a + Math.abs(mod(u - a + s, 2 * s) - s)));
+};
+export const stepUnion = defParamOp(__steps);
+export const stepIsec = defParamOp((a, b, k) => -__steps(-a, -b, k));
+export const stepDiff = defParamOp((a, b, k) => -__steps(-a, b, k));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thi.ng/geom-sdf",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "2D Signed Distance Field creation from @thi.ng/geom shapes, conversions, sampling, combinators",
   "type": "module",
   "module": "./index.js",
@@ -38,9 +38,11 @@
     "@thi.ng/checks": "^3.2.1",
     "@thi.ng/defmulti": "^2.1.7",
     "@thi.ng/errors": "^2.1.7",
-    "@thi.ng/geom": "^3.3.0",
-    "@thi.ng/geom-api": "^3.2.0",
+    "@thi.ng/geom": "^3.3.1",
+    "@thi.ng/geom-api": "^3.2.1",
     "@thi.ng/geom-isoline": "^2.1.14",
+    "@thi.ng/geom-poly-utils": "^2.3.0",
+    "@thi.ng/geom-resample": "^2.1.16",
     "@thi.ng/math": "^5.3.3",
     "@thi.ng/transducers": "^8.3.5",
     "@thi.ng/vectors": "^7.5.6"
@@ -89,12 +91,21 @@
     "./api": {
       "default": "./api.js"
     },
+    "./as-polygons": {
+      "default": "./as-polygons.js"
+    },
     "./as-sdf": {
       "default": "./as-sdf.js"
     },
+    "./bounds": {
+      "default": "./bounds.js"
+    },
     "./dist": {
       "default": "./dist.js"
     },
+    "./domain": {
+      "default": "./domain.js"
+    },
     "./ops": {
       "default": "./ops.js"
     },
@@ -107,8 +118,14 @@
   },
   "thi.ng": {
     "parent": "@thi.ng/geom",
+    "related": [
+      "distance-transform",
+      "geom-isoline",
+      "pixel",
+      "shader-ast-stdlib"
+    ],
     "status": "alpha",
     "year": 2022
   },
-  "gitHead": "1486ab1a34372b2d07ed29b521ef6c97b275f9a7\n"
+  "gitHead": "73139849c7b46c0451693d994e14a34bc2434280\n"
 }

package/sample.d.ts

@@ -1,8 +1,18 @@
-import type { NumericArray } from "@thi.ng/api";
-import type { Polygon } from "@thi.ng/geom";
+import type { Fn, NumericArray } from "@thi.ng/api";
 import type { AABBLike } from "@thi.ng/geom-api";
-import { ReadonlyVec } from "@thi.ng/vectors";
+import type { ReadonlyVec, Vec } from "@thi.ng/vectors";
 import type { SDFn } from "./api.js";
-export declare const sample2d: (sdf: SDFn, { pos: [px, py], size: [width, height] }: AABBLike, [resX, resY]: ReadonlyVec, buf?: NumericArray) => NumericArray;
-export declare const asPolygons: (sdf: NumericArray | SDFn, bounds: AABBLike, res: ReadonlyVec, isoLevels?: Iterable<number>) => Polygon[];
+/**
+ * Samples and discretizes the given SDF within the given bounding rect and
+ * resolution. The optional `domain` fn can be used to apply modifiers to each
+ * sample position. If `buf` is provided, writes results into it, else creates a
+ * new buffer automatically. Returns buffer.
+ *
+ * @param sdf
+ * @param bounds
+ * @param res
+ * @param domain
+ * @param buf
+ */
+export declare const sample2d: (sdf: SDFn, { pos: [px, py], size: [width, height] }: AABBLike, [resX, resY]: ReadonlyVec, domain?: Fn<ReadonlyVec, Vec>, buf?: NumericArray) => NumericArray;
 //# sourceMappingURL=sample.d.ts.map

package/sample.js

@@ -1,14 +1,17 @@
-import { isFunction } from "@thi.ng/checks/is-function";
 import { assert } from "@thi.ng/errors/assert";
-import { isolines, setBorder } from "@thi.ng/geom-isoline";
-import { polygon } from "@thi.ng/geom/polygon";
-import { comp } from "@thi.ng/transducers/comp";
-import { map } from "@thi.ng/transducers/map";
-import { mapcat } from "@thi.ng/transducers/mapcat";
-import { push } from "@thi.ng/transducers/push";
-import { transduce } from "@thi.ng/transducers/transduce";
-import { add2, div2 } from "@thi.ng/vectors";
-export const sample2d = (sdf, { pos: [px, py], size: [width, height] }, [resX, resY], buf) => {
+/**
+ * Samples and discretizes the given SDF within the given bounding rect and
+ * resolution. The optional `domain` fn can be used to apply modifiers to each
+ * sample position. If `buf` is provided, writes results into it, else creates a
+ * new buffer automatically. Returns buffer.
+ *
+ * @param sdf
+ * @param bounds
+ * @param res
+ * @param domain
+ * @param buf
+ */
+export const sample2d = (sdf, { pos: [px, py], size: [width, height] }, [resX, resY], domain, buf) => {
     if (buf) {
         assert(buf.length >= resX * resY, "insufficient buffer size");
     }
@@ -22,16 +25,8 @@ export const sample2d = (sdf, { pos: [px, py], size: [width, height] }, [resX, r
         p[1] = py + y * dy;
         for (let x = 0; x < resX; x++, i++) {
             p[0] = px + x * dx;
-            buf[i] = sdf(p);
+            buf[i] = sdf(domain ? domain(p) : p);
         }
     }
     return buf;
 };
-export const asPolygons = (sdf, bounds, res, isoLevels = [0]) => {
-    const $sdf = isFunction(sdf) ? sample2d(sdf, bounds, res) : sdf;
-    const { pos, size } = bounds;
-    const [resX, resY] = res;
-    setBorder($sdf, resX, resY, 1e6);
-    const scale = div2([], size, [resX - 1, resY - 1]);
-    return transduce(comp(mapcat((iso) => isolines($sdf, resX, resY, iso, scale)), map((pts) => polygon(pts.map((p) => add2(null, p, pos))))), push(), isoLevels);
-};