@thi.ng/geom-sdf 0.2.86 → 0.2.87

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Change Log
 
-- **Last updated**: 2023-12-09T19:12:03Z
+- **Last updated**: 2023-12-11T10:07:09Z
 - **Generator**: [thi.ng/monopub](https://thi.ng/monopub)
 
 All notable changes to this project will be documented in this file.

package/README.md

@@ -135,7 +135,7 @@ For Node.js REPL:
 const geomSdf = await import("@thi.ng/geom-sdf");
 ```
 
-Package sizes (brotli'd, pre-treeshake): ESM: 3.53 KB
+Package sizes (brotli'd, pre-treeshake): ESM: 3.55 KB
 
 ## Dependencies
 

package/api.js

@@ -1 +0,0 @@
-export {};

package/as-polygons.js

@@ -10,30 +10,22 @@ import { transduce } from "@thi.ng/transducers/transduce";
 import { add2 } from "@thi.ng/vectors/add";
 import { div2 } from "@thi.ng/vectors/div";
 import { sample2d } from "./sample.js";
-/**
- * Extract contour polygons from given SDF at specified `distances`. The SDF can
- * be either given as distance function or as pre-discretized image (e.g. as
- * result of {@link sample2d}). The SDF will be sampled in the given bounding
- * rect and resolution (if SDF was given as image, resolution MUST be the
- * same!).
- *
- * @remarks
- * If `distances` are not given, only the original boundary (i.e. distance=0)
- * will be extracted. By default all resulting polygons will be simplified using
- * Douglas-Peucker with a threshold of `eps`. By default this will only remove
- * co-linear vertices, but more agressive settings are possible/recommended.
- *
- * @param sdf
- * @param bounds
- * @param res
- * @param distances
- * @param eps
- */
-export const asPolygons = (sdf, bounds, res, distances = [0], eps = 1e-6) => {
-    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) => pts.map((p) => add2(null, p, pos))), map((pts) => polygon(eps >= 0 ? simplify(pts, eps, true) : pts))), push(), distances);
+const asPolygons = (sdf, bounds, res, distances = [0], eps = 1e-6) => {
+  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) => pts.map((p) => add2(null, p, pos))),
+      map((pts) => polygon(eps >= 0 ? simplify(pts, eps, true) : pts))
+    ),
+    push(),
+    distances
+  );
+};
+export {
+  asPolygons
 };

package/as-sdf.js

@@ -7,111 +7,123 @@ import { simplify } from "@thi.ng/geom/simplify";
 import { __dispatch } from "@thi.ng/geom/internal/dispatch";
 import { add2 } from "@thi.ng/vectors/add";
 import { mulN2 } from "@thi.ng/vectors/muln";
-import { chamferDiff, chamferIsec, chamferUnion, diff, isec, roundDiff, roundIsec, roundUnion, smoothDiff, smoothIsec, smoothUnion, stepDiff, stepIsec, stepUnion, union, } from "./ops.js";
-import { box2, circle2, DEFAULT_ATTRIBS, ellipse2, line2, points2, polygon2, polyline2, quadratic2, withSDFAttribs, } from "./shapes.js";
-/**
- * Takes an
- * [`IShape`](https://docs.thi.ng/umbrella/geom-api/interfaces/IShape.html)
- * instance (possibly a tree, e.g. via
- * [`group()`](https://docs.thi.ng/umbrella/geom/functions/group.html)) and
- * converts it into a {@link SDFn}.
- *
- * @remarks
- * Currently supported shape types:
- *
- * - circle
- * - cubic (auto-converted to polyline)
- * - ellipse
- * - group
- * - line
- * - path (auto-converted to polygon/polyline)
- * - points
- * - polygon
- * - polyline
- * - quadratic bezier
- * - rect
- *
- * For shapes which need to be converted to polygons/polylines, the
- * {@link SDFAttribs.samples} attribute can be used to control the resulting
- * number of vertices. If not specified
- * [`DEFAULT_SAMPLES`](https://docs.thi.ng/umbrella/geom-api/variables/DEFAULT_SAMPLES.html)
- * will be used (which can be globally set via
- * [`setDefaultSamples()`](https://docs.thi.ng/umbrella/geom-api/functions/setDefaultSamples.html)).
- */
-export const asSDF = defmulti(__dispatch, {
+import {
+  chamferDiff,
+  chamferIsec,
+  chamferUnion,
+  diff,
+  isec,
+  roundDiff,
+  roundIsec,
+  roundUnion,
+  smoothDiff,
+  smoothIsec,
+  smoothUnion,
+  stepDiff,
+  stepIsec,
+  stepUnion,
+  union
+} from "./ops.js";
+import {
+  box2,
+  circle2,
+  DEFAULT_ATTRIBS,
+  ellipse2,
+  line2,
+  points2,
+  polygon2,
+  polyline2,
+  quadratic2,
+  withSDFAttribs
+} from "./shapes.js";
+const asSDF = defmulti(
+  __dispatch,
+  {
     quad: "poly",
-    tri: "poly",
-}, {
+    tri: "poly"
+  },
+  {
     [DEFAULT]: ($) => unsupported(`shape type: ${$.type}`),
     circle: ($) => circle2($.pos, $.r, __sdfAttribs($.attribs)),
-    cubic: ($) => asSDF(simplify(asPolyline($, (__sdfAttribs($.attribs) || {}).samples), 0)),
+    cubic: ($) => asSDF(
+      simplify(
+        asPolyline($, (__sdfAttribs($.attribs) || {}).samples),
+        0
+      )
+    ),
     ellipse: ($) => ellipse2($.pos, $.r, __sdfAttribs($.attribs)),
     group: ($) => {
-        const { attribs, children } = $;
-        const attr = { ...DEFAULT_ATTRIBS, ...__sdfAttribs(attribs) };
-        __validateAttribs(attr);
-        const $children = children.map(asSDF);
-        let res;
-        if ($children.length > 1) {
-            switch (attr.combine) {
-                case "diff":
-                    res = __selectCombineOp(attr, $children, diff, {
-                        chamfer: chamferDiff,
-                        round: roundDiff,
-                        smooth: smoothDiff,
-                        steps: stepDiff,
-                    });
-                    break;
-                case "isec":
-                    res = __selectCombineOp(attr, $children, isec, {
-                        chamfer: chamferIsec,
-                        round: roundIsec,
-                        smooth: smoothIsec,
-                        steps: stepIsec,
-                    });
-                    break;
-                case "union":
-                default: {
-                    res = __selectCombineOp(attr, $children, union, {
-                        chamfer: chamferUnion,
-                        round: roundUnion,
-                        smooth: smoothUnion,
-                        steps: stepUnion,
-                    });
-                }
-            }
+      const { attribs, children } = $;
+      const attr = { ...DEFAULT_ATTRIBS, ...__sdfAttribs(attribs) };
+      __validateAttribs(attr);
+      const $children = children.map(asSDF);
+      let res;
+      if ($children.length > 1) {
+        switch (attr.combine) {
+          case "diff":
+            res = __selectCombineOp(attr, $children, diff, {
+              chamfer: chamferDiff,
+              round: roundDiff,
+              smooth: smoothDiff,
+              steps: stepDiff
+            });
+            break;
+          case "isec":
+            res = __selectCombineOp(attr, $children, isec, {
+              chamfer: chamferIsec,
+              round: roundIsec,
+              smooth: smoothIsec,
+              steps: stepIsec
+            });
+            break;
+          case "union":
+          default: {
+            res = __selectCombineOp(attr, $children, union, {
+              chamfer: chamferUnion,
+              round: roundUnion,
+              smooth: smoothUnion,
+              steps: stepUnion
+            });
+          }
         }
-        else if ($children.length) {
-            res = $children[0];
-        }
-        else {
-            return attr.flip ? () => -Infinity : () => Infinity;
-        }
-        return withSDFAttribs(res, attr);
+      } else if ($children.length) {
+        res = $children[0];
+      } else {
+        return attr.flip ? () => -Infinity : () => Infinity;
+      }
+      return withSDFAttribs(res, attr);
     },
     line: ({ points: [a, b], attribs }) => line2(a, b, __sdfAttribs(attribs)),
     path: ($) => {
-        const n = (__sdfAttribs($.attribs) || {}).samples;
-        return asSDF(simplify($.closed ? asPolygon($, n) : asPolyline($, n), 0));
+      const n = (__sdfAttribs($.attribs) || {}).samples;
+      return asSDF(
+        simplify($.closed ? asPolygon($, n) : asPolyline($, n), 0)
+      );
     },
     points: ($) => points2($.points, __sdfAttribs($.attribs)),
     poly: ($) => polygon2($.points, __sdfAttribs($.attribs)),
     polyline: ($) => polyline2($.points, __sdfAttribs($.attribs)),
     quadratic: ({ points: [a, b, c], attribs }) => quadratic2(a, b, c, __sdfAttribs(attribs)),
     rect: ({ pos, size, attribs }) => {
-        const s = mulN2([], size, 0.5);
-        return box2(add2([], s, pos), s, __sdfAttribs(attribs));
-    },
-});
-/** @internal */
-const __sdfAttribs = (attribs) => attribs ? attribs.__sdf : undefined;
+      const s = mulN2([], size, 0.5);
+      return box2(add2([], s, pos), s, __sdfAttribs(attribs));
+    }
+  }
+);
+const __sdfAttribs = (attribs) => attribs ? attribs.__sdf : void 0;
 const OPS = ["chamfer", "round", "smooth", "steps"];
-const __validateAttribs = (attribs) => assert(OPS.filter((x) => attribs[x]).length < 2, "only 1 of these options can be used at once: chamfer, round, smooth");
+const __validateAttribs = (attribs) => assert(
+  OPS.filter((x) => attribs[x]).length < 2,
+  "only 1 of these options can be used at once: chamfer, round, smooth"
+);
 const __selectCombineOp = (attribs, children, op, paramOps) => {
-    for (let k of OPS) {
-        if (attribs[k]) {
-            return paramOps[k](attribs[k], children);
-        }
+  for (let k of OPS) {
+    if (attribs[k]) {
+      return paramOps[k](attribs[k], children);
     }
-    return op(children);
+  }
+  return op(children);
+};
+export {
+  asSDF
 };

package/bounds.js

@@ -3,29 +3,29 @@ import { addmN2 } from "@thi.ng/vectors/addmn";
 import { sub2 } from "@thi.ng/vectors/sub";
 import { submN2 } from "@thi.ng/vectors/submn";
 import { distBox2 } from "./dist.js";
-export function withBoundingCircle(sdf, ...args) {
-    let [[cx, cy], r] = args.length === 1
-        ? boundingCircle(args[0])
-        : args;
-    r *= r;
-    return (p, minD = Infinity) => {
-        if (minD === Infinity)
-            return sdf(p, minD);
-        const dx = p[0] - cx;
-        const dy = p[1] - cy;
-        return dx * dx + dy * dy - r < minD * minD ? sdf(p, minD) : minD;
-    };
+function withBoundingCircle(sdf, ...args) {
+  let [[cx, cy], r] = args.length === 1 ? boundingCircle(args[0]) : args;
+  r *= r;
+  return (p, minD = Infinity) => {
+    if (minD === Infinity)
+      return sdf(p, minD);
+    const dx = p[0] - cx;
+    const dy = p[1] - cy;
+    return dx * dx + dy * dy - r < minD * minD ? sdf(p, minD) : minD;
+  };
 }
-export function withBoundingRect(sdf, ...args) {
-    const [min, max] = args.length === 1 ? bounds2(args[0]) : args;
-    const centroid = addmN2([], min, max, 0.5);
-    const hSize = submN2([], max, min, 0.5);
-    const t = [0, 0];
-    return (p, minD = Infinity) => {
-        if (minD === Infinity)
-            return sdf(p, minD);
-        return distBox2(sub2(t, p, centroid), hSize) < minD
-            ? sdf(p, minD)
-            : minD;
-    };
+function withBoundingRect(sdf, ...args) {
+  const [min, max] = args.length === 1 ? bounds2(args[0]) : args;
+  const centroid = addmN2([], min, max, 0.5);
+  const hSize = submN2([], max, min, 0.5);
+  const t = [0, 0];
+  return (p, minD = Infinity) => {
+    if (minD === Infinity)
+      return sdf(p, minD);
+    return distBox2(sub2(t, p, centroid), hSize) < minD ? sdf(p, minD) : minD;
+  };
 }
+export {
+  withBoundingCircle,
+  withBoundingRect
+};

package/dist.js

@@ -23,215 +23,131 @@ 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(t1, p), halfSize);
-    return min(max(d[0], d[1]), 0) + mag2(max2(null, d, ZERO2));
+const distCircle2 = (p, radius) => mag2(p) - radius;
+const distBox2 = (p, halfSize) => {
+  const d = sub2(null, abs2(t1, p), halfSize);
+  return min(max(d[0], d[1]), 0) + mag2(max2(null, d, ZERO2));
 };
-/**
- * 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];
-    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 = 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 * sqrt(d);
+const distPolygon2 = (p, pts) => {
+  let d = distSq2(p, pts[0]);
+  let s = 1;
+  const py = p[1];
+  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 = 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 * sqrt(d);
 };
-/**
- * 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)))));
+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))))
+  );
 };
-/**
- * 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 = min(d, distSegment2(p, pts[i - 1], pts[i]));
-    }
-    return d;
+const distPolyline2 = (p, pts) => {
+  let d = Infinity;
+  for (let i = 1, n = pts.length; i < n; i++) {
+    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) => {
-    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);
+const distArc2 = (p, apert, 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;
 };
-/**
- * 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;
-    const kz = kk * dot2(dd, aa);
-    const p = ky - kx * kx;
-    const q = kx * (2 * kx * kx - 3 * ky) + kz;
-    const p3 = p * p * p;
-    const q2 = q * q;
-    let h = q2 + 4 * p3;
-    if (h >= 0) {
-        h = sqrt(h);
-        const x = [(h - q) / 2, (-h - q) / 2];
-        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(t1, bb, t, cc), t, dd);
-        return (mag2(qq) *
-            (signed ? sign(cross2(maddN2(bb, bb, 2 * t, cc), qq)) : 1));
-    }
-    else {
-        const z = sqrt(-p);
-        const v = Math.acos(q / (p * z * 2)) / 3;
-        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(t1, bb, tx, cc), tx, dd);
-        const dx = magSq2(qx);
-        const qy = maddN2(null, maddN2(t5, bb, ty, cc), ty, dd);
-        const dy = magSq2(qy);
-        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);
-    }
+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;
+  const kz = kk * dot2(dd, aa);
+  const p = ky - kx * kx;
+  const q = kx * (2 * kx * kx - 3 * ky) + kz;
+  const p3 = p * p * p;
+  const q2 = q * q;
+  let h = q2 + 4 * p3;
+  if (h >= 0) {
+    h = sqrt(h);
+    const x = [(h - q) / 2, (-h - q) / 2];
+    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(t1, bb, t, cc), t, dd);
+    return mag2(qq) * (signed ? sign(cross2(maddN2(bb, bb, 2 * t, cc), qq)) : 1);
+  } else {
+    const z = sqrt(-p);
+    const v = Math.acos(q / (p * z * 2)) / 3;
+    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(t1, bb, tx, cc), tx, dd);
+    const dx = magSq2(qx);
+    const qy = maddN2(null, maddN2(t5, bb, ty, cc), ty, dd);
+    const dy = magSq2(qy);
+    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 = abs(px);
-    py = abs(py);
-    if (px > py) {
-        let t = px;
-        px = py;
-        py = t;
-        t = abx;
-        abx = aby;
-        aby = t;
-    }
-    const l = aby * aby - abx * abx;
-    const m = (abx * px) / l;
-    const m2 = m * m;
-    const n = (aby * py) / l;
-    const n2 = n * n;
-    const c = (m2 + n2 - 1) / 3;
-    const c3 = c * c * c;
-    const mn2 = m2 * n2;
-    const d = c3 + mn2;
-    const q = c3 + mn2 * 2;
-    const g = m + m * n2;
-    let co;
-    if (d < 0) {
-        const h = Math.acos(q / c3) / 3;
-        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 * 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 / sqrt(rm - rx) + (2 * g) / rm - m) / 2;
-    }
-    const rx = abx * co;
-    const ry = aby * sqrt(1 - co * co);
-    return Math.hypot(rx - px, ry - py) * sign(py - ry);
+const distEllipse2 = ([px, py], [abx, aby]) => {
+  px = abs(px);
+  py = abs(py);
+  if (px > py) {
+    let t = px;
+    px = py;
+    py = t;
+    t = abx;
+    abx = aby;
+    aby = t;
+  }
+  const l = aby * aby - abx * abx;
+  const m = abx * px / l;
+  const m2 = m * m;
+  const n = aby * py / l;
+  const n2 = n * n;
+  const c = (m2 + n2 - 1) / 3;
+  const c3 = c * c * c;
+  const mn2 = m2 * n2;
+  const d = c3 + mn2;
+  const q = c3 + mn2 * 2;
+  const g = m + m * n2;
+  let co;
+  if (d < 0) {
+    const h = Math.acos(q / c3) / 3;
+    const s = cos(h);
+    const t = sin(h) * SQRT3;
+    const rx2 = sqrt(-c * (s + t + 2) + m2);
+    const ry2 = sqrt(-c * (s - t + 2) + m2);
+    co = (ry2 + sign(l) * rx2 + abs(g) / (rx2 * ry2) - m) / 2;
+  } else {
+    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 rx2 = -s - u - c * 4 + 2 * m2;
+    const ry2 = (s - u) * SQRT3;
+    const rm = Math.hypot(rx2, ry2);
+    co = (ry2 / sqrt(rm - rx2) + 2 * g / rm - m) / 2;
+  }
+  const rx = abx * co;
+  const ry = aby * sqrt(1 - co * co);
+  return Math.hypot(rx - px, ry - py) * sign(py - ry);
+};
+export {
+  distArc2,
+  distBox2,
+  distCircle2,
+  distEllipse2,
+  distPolygon2,
+  distPolyline2,
+  distQuadratic2,
+  distSegment2
 };

package/domain.js

@@ -11,53 +11,50 @@ 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);
+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));
+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;
-    };
+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));
+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)
+  );
+};
+export {
+  repeat2,
+  repeatGrid2,
+  repeatMirror2,
+  repeatPolar2
 };

package/ops.js

@@ -1,74 +1,110 @@
 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 __asField = (k) => isFunction(k) ? k : () => k;
+const __ensureChildren = (children, min2 = 1) => assert(children.length >= 1, `require at least ${min2} 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;
-    };
+const abs = (sdf) => (p, minD) => Math.abs(sdf(p, minD));
+const flip = (sdf) => (p, minD) => -sdf(p, minD);
+const offset = (sdf, r) => isFunction(r) ? (p, minD) => sdf(p, minD) - r(p) : (p, minD) => sdf(p, minD) - r;
+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;
-    };
+const union = defOp(min);
+const isec = defOp(max);
+const diff = defOp((a, b) => max(a, -b));
+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);
+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);
+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);
+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 chamferUnion = defParamOp(
+  (a, b, k) => min(min(a, b), (a - k + b) * SQRT2_2)
+);
+const chamferIsec = defParamOp(
+  (a, b, k) => max(max(a, b), (a + k + b) * SQRT2_2)
+);
+const chamferDiff = defParamOp(
+  (a, b, k) => max(max(a, -b), (a + k - b) * SQRT2_2)
+);
+const roundUnion = defParamOp(
+  (a, b, k) => max(k, min(a, b)) - Math.hypot(max(k - a, 0), max(k - b, 0))
+);
+const roundIsec = defParamOp(
+  (a, b, k) => min(-k, max(a, b)) + Math.hypot(max(k + a, 0), max(k + b, 0))
+);
+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)));
+  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)));
+};
+const stepUnion = defParamOp(__steps);
+const stepIsec = defParamOp(
+  (a, b, k) => -__steps(-a, -b, k)
+);
+const stepDiff = defParamOp(
+  (a, b, k) => -__steps(-a, b, k)
+);
+export {
+  abs,
+  chamferDiff,
+  chamferIsec,
+  chamferUnion,
+  defOp,
+  defParamOp,
+  diff,
+  flip,
+  isec,
+  offset,
+  roundDiff,
+  roundIsec,
+  roundUnion,
+  smoothDiff,
+  smoothIsec,
+  smoothUnion,
+  stepDiff,
+  stepIsec,
+  stepUnion,
+  union
 };
-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.2.86",
+  "version": "0.2.87",
   "description": "2D Signed Distance Field creation from @thi.ng/geom shapes, conversions, sampling, combinators",
   "type": "module",
   "module": "./index.js",
@@ -24,7 +24,9 @@
   "author": "Karsten Schmidt (https://thi.ng)",
   "license": "Apache-2.0",
   "scripts": {
-    "build": "yarn clean && tsc --declaration",
+    "build": "yarn build:esbuild && yarn build:decl",
+    "build:decl": "tsc --declaration --emitDeclarationOnly",
+    "build:esbuild": "esbuild --format=esm --platform=neutral --target=es2022 --tsconfig=tsconfig.json --outdir=. src/**/*.ts",
     "clean": "rimraf --glob '*.js' '*.d.ts' '*.map' doc",
     "doc": "typedoc --excludePrivate --excludeInternal --out doc src/index.ts",
     "doc:ae": "mkdir -p .ae/doc .ae/temp && api-extractor run --local --verbose",
@@ -33,21 +35,22 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@thi.ng/api": "^8.9.11",
-    "@thi.ng/checks": "^3.4.11",
-    "@thi.ng/defmulti": "^3.0.9",
-    "@thi.ng/errors": "^2.4.5",
-    "@thi.ng/geom": "^6.0.7",
-    "@thi.ng/geom-api": "^3.4.49",
-    "@thi.ng/geom-isoline": "^2.1.87",
-    "@thi.ng/geom-poly-utils": "^2.3.75",
-    "@thi.ng/geom-resample": "^2.3.13",
-    "@thi.ng/math": "^5.7.6",
-    "@thi.ng/transducers": "^8.8.14",
-    "@thi.ng/vectors": "^7.8.8"
+    "@thi.ng/api": "^8.9.12",
+    "@thi.ng/checks": "^3.4.12",
+    "@thi.ng/defmulti": "^3.0.10",
+    "@thi.ng/errors": "^2.4.6",
+    "@thi.ng/geom": "^6.0.8",
+    "@thi.ng/geom-api": "^3.4.50",
+    "@thi.ng/geom-isoline": "^2.1.88",
+    "@thi.ng/geom-poly-utils": "^2.3.76",
+    "@thi.ng/geom-resample": "^2.3.14",
+    "@thi.ng/math": "^5.7.7",
+    "@thi.ng/transducers": "^8.8.15",
+    "@thi.ng/vectors": "^7.8.9"
   },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.38.3",
+    "esbuild": "^0.19.8",
     "rimraf": "^5.0.5",
     "tools": "^0.0.1",
     "typedoc": "^0.25.4",
@@ -125,5 +128,5 @@
     "status": "alpha",
     "year": 2022
   },
-  "gitHead": "25f2ac8ff795a432a930119661b364d4d93b59a0\n"
+  "gitHead": "5e7bafedfc3d53bc131469a28de31dd8e5b4a3ff\n"
 }

package/sample.js

@@ -1,32 +1,22 @@
 import { assert } from "@thi.ng/errors/assert";
-/**
- * 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");
+const sample2d = (sdf, { pos: [px, py], size: [width, height] }, [resX, resY], domain, buf) => {
+  if (buf) {
+    assert(buf.length >= resX * resY, "insufficient buffer size");
+  } else {
+    buf = new Float32Array(resX * resY);
+  }
+  const dx = width / (resX - 1);
+  const dy = height / (resY - 1);
+  const p = [0, 0];
+  for (let y = 0, i = 0; y < resY; y++) {
+    p[1] = py + y * dy;
+    for (let x = 0; x < resX; x++, i++) {
+      p[0] = px + x * dx;
+      buf[i] = sdf(domain ? domain(p) : p);
     }
-    else {
-        buf = new Float32Array(resX * resY);
-    }
-    const dx = width / (resX - 1);
-    const dy = height / (resY - 1);
-    const p = [0, 0];
-    for (let y = 0, i = 0; y < resY; y++) {
-        p[1] = py + y * dy;
-        for (let x = 0; x < resX; x++, i++) {
-            p[0] = px + x * dx;
-            buf[i] = sdf(domain ? domain(p) : p);
-        }
-    }
-    return buf;
+  }
+  return buf;
+};
+export {
+  sample2d
 };

package/shapes.js

@@ -2,80 +2,85 @@ import { isFunction } from "@thi.ng/checks/is-function";
 import { distSq2 } from "@thi.ng/vectors";
 import { sub2 } from "@thi.ng/vectors/sub";
 import { withBoundingCircle } from "./bounds.js";
-import { distArc2, distBox2, distCircle2, distEllipse2, distPolygon2, distPolyline2, distQuadratic2, distSegment2, } from "./dist.js";
+import {
+  distArc2,
+  distBox2,
+  distCircle2,
+  distEllipse2,
+  distPolygon2,
+  distPolyline2,
+  distQuadratic2,
+  distSegment2
+} from "./dist.js";
 import { abs as $abs, flip as $flip, offset as $offset } from "./ops.js";
-/** @internal */
-export const DEFAULT_ATTRIBS = {
-    abs: false,
-    bounds: false,
-    chamfer: 0,
-    combine: "union",
-    flip: false,
-    offset: 0,
-    round: 0,
-    smooth: 0,
+const DEFAULT_ATTRIBS = {
+  abs: false,
+  bounds: false,
+  chamfer: 0,
+  combine: "union",
+  flip: false,
+  offset: 0,
+  round: 0,
+  smooth: 0
 };
-/**
- * Applies any SDF modifiers specified via {@link SDFAttribs} to the given
- * distance function. Returns a possibly updated distance function.
- *
- * @remarks
- * Order of application is: abs, offset, flip
- *
- * @param fn
- * @param attribs
- */
-export const withSDFAttribs = (fn, attribs) => {
-    if (attribs) {
-        const { abs, flip, offset } = { ...DEFAULT_ATTRIBS, ...attribs };
-        if (abs)
-            fn = $abs(fn);
-        if (isFunction(offset) || offset > 0)
-            fn = $offset(fn, offset);
-        if (flip)
-            fn = $flip(fn);
-    }
-    return fn;
+const withSDFAttribs = (fn, attribs) => {
+  if (attribs) {
+    const { abs, flip, offset } = { ...DEFAULT_ATTRIBS, ...attribs };
+    if (abs)
+      fn = $abs(fn);
+    if (isFunction(offset) || offset > 0)
+      fn = $offset(fn, offset);
+    if (flip)
+      fn = $flip(fn);
+  }
+  return fn;
 };
-export const arc2 = (center, apert, ra, rb, attribs = {}) => {
-    const sdf = withSDFAttribs((p) => distArc2(sub2([], p, center), apert, ra, rb), attribs);
-    return attribs.bounds ? withBoundingCircle(sdf, center, ra + rb) : sdf;
+const arc2 = (center, apert, ra, rb, attribs = {}) => {
+  const sdf = withSDFAttribs(
+    (p) => distArc2(sub2([], p, center), apert, ra, rb),
+    attribs
+  );
+  return attribs.bounds ? withBoundingCircle(sdf, center, ra + rb) : sdf;
 };
-export const box2 = (center, size, attribs) => withSDFAttribs((p) => distBox2(sub2([], p, center), size), attribs);
-export const circle2 = (center, radius, attribs) => withSDFAttribs((p) => distCircle2(sub2([], p, center), radius), attribs);
-export const ellipse2 = (center, radii, attribs = {}) => {
-    const sdf = withSDFAttribs((p) => distEllipse2(sub2([], p, center), radii), attribs);
-    return attribs.bounds
-        ? withBoundingCircle(sdf, center, Math.max(...radii))
-        : sdf;
+const box2 = (center, size, attribs) => withSDFAttribs((p) => distBox2(sub2([], p, center), size), attribs);
+const circle2 = (center, radius, attribs) => withSDFAttribs((p) => distCircle2(sub2([], p, center), radius), attribs);
+const ellipse2 = (center, radii, attribs = {}) => {
+  const sdf = withSDFAttribs(
+    (p) => distEllipse2(sub2([], p, center), radii),
+    attribs
+  );
+  return attribs.bounds ? withBoundingCircle(sdf, center, Math.max(...radii)) : sdf;
 };
-export const line2 = (a, b, attribs) => withSDFAttribs((p) => distSegment2(p, a, b), attribs);
-export const points2 = (pts, attribs = {}) => {
-    const sdf = withSDFAttribs((p) => pts.reduce((acc, q) => Math.min(acc, distSq2(p, q)), Infinity), attribs);
-    return attribs.bounds ? withBoundingCircle(sdf, pts) : sdf;
+const line2 = (a, b, attribs) => withSDFAttribs((p) => distSegment2(p, a, b), attribs);
+const points2 = (pts, attribs = {}) => {
+  const sdf = withSDFAttribs(
+    (p) => pts.reduce((acc, q) => Math.min(acc, distSq2(p, q)), Infinity),
+    attribs
+  );
+  return attribs.bounds ? withBoundingCircle(sdf, pts) : sdf;
 };
-export const polygon2 = (pts, attribs = {}) => {
-    const sdf = withSDFAttribs((p) => distPolygon2(p, pts), attribs);
-    return attribs.bounds ? withBoundingCircle(sdf, pts) : sdf;
+const polygon2 = (pts, attribs = {}) => {
+  const sdf = withSDFAttribs((p) => distPolygon2(p, pts), attribs);
+  return attribs.bounds ? withBoundingCircle(sdf, pts) : sdf;
 };
-export const polyline2 = (pts, attribs = {}) => {
-    const sdf = withSDFAttribs((p) => distPolyline2(p, pts), attribs);
-    return attribs.bounds ? withBoundingCircle(sdf, pts) : sdf;
+const polyline2 = (pts, attribs = {}) => {
+  const sdf = withSDFAttribs((p) => distPolyline2(p, pts), attribs);
+  return attribs.bounds ? withBoundingCircle(sdf, pts) : sdf;
+};
+const quadratic2 = (a, b, c, attribs) => withSDFAttribs(
+  !attribs || attribs.abs !== false ? (p) => distQuadratic2(p, a, b, c) : (p) => distQuadratic2(p, a, b, c, true),
+  { ...attribs, abs: false }
+);
+export {
+  DEFAULT_ATTRIBS,
+  arc2,
+  box2,
+  circle2,
+  ellipse2,
+  line2,
+  points2,
+  polygon2,
+  polyline2,
+  quadratic2,
+  withSDFAttribs
 };
-/**
- * SDF for a single quadratic bezier segment. Similar to {@link line2}, by
- * default only computes the _unsigned_ distance to the segment. To obtain the
- * signed distance (for the "interior" region, if any), set the `abs` attribute
- * explicitly to `false`.
- *
- * @remarks
- * See {@link SDFAttribs.abs} for details.
- *
- * @param a
- * @param b
- * @param c
- * @param attribs
- */
-export const quadratic2 = (a, b, c, attribs) => withSDFAttribs(!attribs || attribs.abs !== false
-    ? (p) => distQuadratic2(p, a, b, c)
-    : (p) => distQuadratic2(p, a, b, c, true), { ...attribs, abs: false });