@thi.ng/geom-sdf 0.1.0 → 0.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thi.ng/geom-sdf",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "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.4.0",
+    "@thi.ng/geom-api": "^3.3.0",
     "@thi.ng/geom-isoline": "^2.1.14",
+    "@thi.ng/geom-poly-utils": "^2.3.1",
+    "@thi.ng/geom-resample": "^2.1.17",
     "@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": "f50e292ecc7dc74a6705b07fc739bf827cc5efd7\n"
+  "gitHead": "207404f1e1fcfd3596780322d9218156aeaac3dd\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);
-};

package/shapes.d.ts

@@ -2,8 +2,18 @@ import { ReadonlyVec } from "@thi.ng/vectors";
 import type { SDFAttribs, SDFn } from "./api.js";
 /** @internal */
 export declare const DEFAULT_ATTRIBS: SDFAttribs;
+/**
+ * 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 declare const withSDFAttribs: (fn: SDFn, attribs?: Partial<SDFAttribs>) => SDFn;
-export declare const arc2: (apert: ReadonlyVec, ra: number, rb: number, attribs?: Partial<SDFAttribs>) => SDFn;
+export declare const arc2: (center: ReadonlyVec, apert: ReadonlyVec, ra: number, rb: number, attribs?: Partial<SDFAttribs>) => SDFn;
 export declare const box2: (center: ReadonlyVec, size: ReadonlyVec, attribs?: Partial<SDFAttribs>) => SDFn;
 export declare const circle2: (center: ReadonlyVec, radius: number, attribs?: Partial<SDFAttribs>) => SDFn;
 export declare const ellipse2: (center: ReadonlyVec, radii: ReadonlyVec, attribs?: Partial<SDFAttribs>) => SDFn;
@@ -11,5 +21,19 @@ export declare const line2: (a: ReadonlyVec, b: ReadonlyVec, attribs?: Partial<S
 export declare const points2: (pts: ReadonlyVec[], attribs?: Partial<SDFAttribs>) => SDFn;
 export declare const polygon2: (pts: ReadonlyVec[], attribs?: Partial<SDFAttribs>) => SDFn;
 export declare const polyline2: (pts: ReadonlyVec[], attribs?: Partial<SDFAttribs>) => SDFn;
+/**
+ * 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 declare const quadratic2: (a: ReadonlyVec, b: ReadonlyVec, c: ReadonlyVec, attribs?: Partial<SDFAttribs>) => SDFn;
 //# sourceMappingURL=shapes.d.ts.map

package/shapes.js

@@ -1,33 +1,81 @@
+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 { abs as $abs, flip as $flip, round as $round } from "./ops.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,
 };
+/**
+ * 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, round } = { ...DEFAULT_ATTRIBS, ...attribs };
+        const { abs, flip, offset } = { ...DEFAULT_ATTRIBS, ...attribs };
         if (abs)
             fn = $abs(fn);
-        if (round > 0)
-            fn = $round(fn, round);
+        if (isFunction(offset) || offset > 0)
+            fn = $offset(fn, offset);
         if (flip)
             fn = $flip(fn);
     }
     return fn;
 };
-export const arc2 = (apert, ra, rb, attribs) => withSDFAttribs((p) => distArc2(p, apert, ra, rb), attribs);
+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;
+};
 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) => withSDFAttribs((p) => distEllipse2(sub2([], p, center), radii), attribs);
-export const line2 = (a, b, attribs) => withSDFAttribs((p) => distSegment2(a, b, p), attribs);
-export const points2 = (pts, attribs) => withSDFAttribs((p) => pts.reduce((acc, q) => Math.min(acc, distSq2(p, q)), Infinity), attribs);
-export const polygon2 = (pts, attribs) => withSDFAttribs((p) => distPolygon2(pts, p), attribs);
-export const polyline2 = (pts, attribs) => withSDFAttribs((p) => distPolyline2(pts, p), attribs);
-export const quadratic2 = (a, b, c, attribs) => withSDFAttribs((p) => distQuadratic2(p, a, b, c), 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;
+};
+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;
+};
+export 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;
+};
+/**
+ * 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 });