@thi.ng/geom-sdf 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,16 @@
+# Change Log
+
+- **Last updated**: 2022-06-20T17:33:30Z
+- **Generator**: [thi.ng/monopub](https://thi.ng/monopub)
+
+All notable changes to this project will be documented in this file.
+See [Conventional Commits](https://conventionalcommits.org/) for commit guidelines.
+
+**Note:** Unlisted _patch_ versions only involve non-code or otherwise excluded changes
+and/or version bumps of transitive dependencies.
+
+## [0.1.0](https://github.com/thi-ng/umbrella/tree/@thi.ng/geom-sdf@0.1.0) (2022-06-20)
+
+#### 🚀 Features
+
+- import as new pkg ([06dcca2](https://github.com/thi-ng/umbrella/commit/06dcca2))

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright {yyyy} {name of copyright owner}
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,154 @@
+<!-- This file is generated - DO NOT EDIT! -->
+
+# ![geom-sdf](https://media.thi.ng/umbrella/banners/thing-geom-sdf.svg?6069668d)
+
+[![npm version](https://img.shields.io/npm/v/@thi.ng/geom-sdf.svg)](https://www.npmjs.com/package/@thi.ng/geom-sdf)
+![npm downloads](https://img.shields.io/npm/dm/@thi.ng/geom-sdf.svg)
+[![Twitter Follow](https://img.shields.io/twitter/follow/thing_umbrella.svg?style=flat-square&label=twitter)](https://twitter.com/thing_umbrella)
+
+This project is part of the
+[@thi.ng/umbrella](https://github.com/thi-ng/umbrella/) monorepo.
+
+- [About](#about)
+  - [Status](#status)
+- [Installation](#installation)
+- [Dependencies](#dependencies)
+- [API](#api)
+- [Authors](#authors)
+- [License](#license)
+
+## About
+
+2D Signed Distance Field creation from [@thi.ng/geom](https://github.com/thi-ng/umbrella/tree/develop/packages/geom) shapes, conversions, sampling, combinators.
+
+### Status
+
+**ALPHA** - bleeding edge / work-in-progress
+
+[Search or submit any issues for this package](https://github.com/thi-ng/umbrella/issues?q=%5Bgeom-sdf%5D+in%3Atitle)
+
+## Installation
+
+```bash
+yarn add @thi.ng/geom-sdf
+```
+
+ES module import:
+
+```html
+<script type="module" src="https://cdn.skypack.dev/@thi.ng/geom-sdf"></script>
+```
+
+[Skypack documentation](https://docs.skypack.dev/)
+
+For Node.js REPL:
+
+```text
+# with flag only for < v16
+node --experimental-repl-await
+
+> const geomSdf = await import("@thi.ng/geom-sdf");
+```
+
+Package sizes (gzipped, pre-treeshake): ESM: 2.61 KB
+
+## Dependencies
+
+- [@thi.ng/api](https://github.com/thi-ng/umbrella/tree/develop/packages/api)
+- [@thi.ng/checks](https://github.com/thi-ng/umbrella/tree/develop/packages/checks)
+- [@thi.ng/defmulti](https://github.com/thi-ng/umbrella/tree/develop/packages/defmulti)
+- [@thi.ng/errors](https://github.com/thi-ng/umbrella/tree/develop/packages/errors)
+- [@thi.ng/geom](https://github.com/thi-ng/umbrella/tree/develop/packages/geom)
+- [@thi.ng/geom-api](https://github.com/thi-ng/umbrella/tree/develop/packages/geom-api)
+- [@thi.ng/geom-isoline](https://github.com/thi-ng/umbrella/tree/develop/packages/geom-isoline)
+- [@thi.ng/math](https://github.com/thi-ng/umbrella/tree/develop/packages/math)
+- [@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)
+
+## API
+
+[Generated API docs](https://docs.thi.ng/umbrella/geom-sdf/)
+
+```js
+import { asSvg, bounds, circle, group, simplify, svgDoc } from "@thi.ng/geom";
+import { asPolygons, asSDF, sample2d } from "@thi.ng/geom-sdf";
+import { range, repeatedly } from "@thi.ng/transducers";
+import { randMinMax2 } from "@thi.ng/vectors";
+import { writeFileSync } from "fs";
+
+const RES = [256, 256];
+
+// create a group of 20 random circle shapes
+// the special `__sdf` attrib object is used to control the conversion later
+// the `smooth` option will combine the circles using the `smoothUnion()` operator
+// see: https://docs.thi.ng/umbrella/geom-sdf/interfaces/SDFAttribs.html
+const scene = group({ stroke: "red", __sdf: { smooth: 20 } }, [
+    ...repeatedly(
+        () =>
+            circle(
+                randMinMax2([], [-100, -100], [100, 100]),
+                5 + Math.random() * 15
+            ),
+        20
+    ),
+]);
+
+// compute bounding box + some extra margin
+// the margin is to ensure
+const sceneBounds = bounds(scene, 40);
+
+// convert to an SDF distance function
+// more information about supported shape types:
+// https://docs.thi.ng/umbrella/geom-sdf/modules.html#asSDF
+const sdf = asSDF(scene);
+
+// sample SDF in given bounding rect and resolution
+const image = sample2d(sdf, sceneBounds, RES);
+
+// extract contour polygons from given image
+// in this case the contours extracted are at distances in the [0..32) interval
+// afterwards we also simplify the resulting polygons using the Douglas-Peucker algorithm
+// see: https://en.wikipedia.org/wiki/Ramer%E2%80%93Douglas%E2%80%93Peucker_algorithm
+const contours = asPolygons(image, sceneBounds, RES, range(0, 32, 4)).map(
+    (p) => simplify(p, 0.25)
+);
+
+// convert to SVG and output as file
+writeFileSync(
+    "export/metaballs.svg",
+    asSvg(
+        svgDoc(
+            { fill: "none" },
+            // contour polygons
+            group({ stroke: "#000" }, contours),
+            // original geometry
+            scene
+        )
+    )
+);
+```
+
+Results:
+
+| using `circle()`                                                                                                       | using `rect()`                                                                                                                 |
+|------------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------|
+| ![metaballs based on circles](https://raw.githubusercontent.com/thi-ng/umbrella/develop/assets/geom-sdf/metaballs.png) | ![metaballs based on rectangles](https://raw.githubusercontent.com/thi-ng/umbrella/develop/assets/geom-sdf/metaballs-rect.png) |
+
+## Authors
+
+Karsten Schmidt
+
+If this project contributes to an academic publication, please cite it as:
+
+```bibtex
+@misc{thing-geom-sdf,
+  title = "@thi.ng/geom-sdf",
+  author = "Karsten Schmidt",
+  note = "https://thi.ng/geom-sdf",
+  year = 2022
+}
+```
+
+## License
+
+&copy; 2022 Karsten Schmidt // Apache Software License 2.0

package/api.d.ts

@@ -0,0 +1,12 @@
+import type { Fn } from "@thi.ng/api";
+import type { ReadonlyVec } from "@thi.ng/vectors";
+export declare type SDFn = Fn<ReadonlyVec, number>;
+export declare type SDFCombineOp = "union" | "isec" | "diff";
+export interface SDFAttribs {
+    combine: SDFCombineOp;
+    smooth: number;
+    flip: boolean;
+    abs: boolean;
+    round: number;
+}
+//# sourceMappingURL=api.d.ts.map

package/api.js

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

package/as-sdf.d.ts

@@ -0,0 +1,22 @@
+import type { MultiFn1 } from "@thi.ng/defmulti";
+import type { IShape } from "@thi.ng/geom-api";
+import type { SDFn } from "./api.js";
+/**
+ * Takes an {@link @thi.ng/geom-api#IShape} instance (possibly a tree, e.g. via
+ * {@link @thi.ng/geom#group}) and converts it into a {@link SDFn}.
+ *
+ * @remarks
+ * Currently supported shape types:
+ *
+ * - circle
+ * - ellipse
+ * - group
+ * - line
+ * - points
+ * - polygon
+ * - polyline
+ * - quadratic bezier
+ * - rect
+ */
+export declare const asSDF: MultiFn1<IShape, SDFn>;
+//# sourceMappingURL=as-sdf.d.ts.map

package/as-sdf.js

@@ -0,0 +1,74 @@
+import { DEFAULT, defmulti } from "@thi.ng/defmulti/defmulti";
+import { unsupported } from "@thi.ng/errors/unsupported";
+import { __dispatch } from "@thi.ng/geom/internal/dispatch";
+import { maddN2 } from "@thi.ng/vectors/maddn";
+import { difference, intersection, smoothDifference, smoothIntersection, smoothUnion, union, } from "./ops.js";
+import { box2, circle2, DEFAULT_ATTRIBS, ellipse2, line2, points2, polygon2, polyline2, quadratic2, withSDFAttribs, } from "./shapes.js";
+/**
+ * Takes an {@link @thi.ng/geom-api#IShape} instance (possibly a tree, e.g. via
+ * {@link @thi.ng/geom#group}) and converts it into a {@link SDFn}.
+ *
+ * @remarks
+ * Currently supported shape types:
+ *
+ * - circle
+ * - ellipse
+ * - group
+ * - line
+ * - points
+ * - polygon
+ * - polyline
+ * - quadratic bezier
+ * - rect
+ */
+export const asSDF = defmulti(__dispatch, {
+    quad: "poly",
+    tri: "poly",
+}, {
+    [DEFAULT]: ($) => unsupported(`shape type: ${$.type}`),
+    circle: ($) => circle2($.pos, $.r, __sdfAttribs($.attribs)),
+    ellipse: ($) => ellipse2($.pos, $.r, __sdfAttribs($.attribs)),
+    group: ({ attribs, children }) => {
+        const $attribs = { ...DEFAULT_ATTRIBS, ...__sdfAttribs(attribs) };
+        const $children = children.map(asSDF);
+        let res;
+        if ($children.length > 1) {
+            switch ($attribs.combine) {
+                case "diff":
+                    res =
+                        $attribs.smooth !== 0
+                            ? smoothDifference($attribs.smooth, ...$children)
+                            : difference(...$children);
+                    break;
+                case "isec":
+                    res =
+                        $attribs.smooth !== 0
+                            ? smoothIntersection($attribs.smooth, ...$children)
+                            : intersection($children);
+                    break;
+                case "union":
+                default: {
+                    res =
+                        $attribs.smooth !== 0
+                            ? smoothUnion($attribs.smooth, ...$children)
+                            : union($children);
+                }
+            }
+        }
+        else if ($children.length) {
+            res = $children[0];
+        }
+        else {
+            return $attribs.flip ? () => -Infinity : () => Infinity;
+        }
+        return withSDFAttribs(res, $attribs);
+    },
+    line: ({ points: [a, b], attribs }) => line2(a, b, __sdfAttribs(attribs)),
+    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 }) => box2(maddN2([], size, 0.5, pos), size, __sdfAttribs(attribs)),
+});
+/** @internal */
+const __sdfAttribs = (attribs) => attribs ? attribs.__sdf : null;

package/dist.d.ts

@@ -0,0 +1,10 @@
+import { ReadonlyVec } from "@thi.ng/vectors/api";
+export declare const distCircle2: (p: ReadonlyVec, radius: number) => number;
+export declare const distBox2: (p: ReadonlyVec, size: ReadonlyVec) => number;
+export declare const distPolygon2: (pts: ReadonlyVec[], p: ReadonlyVec) => number;
+export declare const distSegment2: (a: ReadonlyVec, b: ReadonlyVec, p: ReadonlyVec) => number;
+export declare const distPolyline2: (pts: ReadonlyVec[], p: ReadonlyVec) => number;
+export declare const distArc2: (p: ReadonlyVec, apert: ReadonlyVec, ra: number, rb: number) => number;
+export declare const distQuadratic2: (pos: ReadonlyVec, a: ReadonlyVec, b: ReadonlyVec, c: ReadonlyVec, signed?: boolean) => number;
+export declare const distEllipse2: ([px, py]: ReadonlyVec, [abx, aby]: ReadonlyVec) => number;
+//# sourceMappingURL=dist.d.ts.map

package/dist.js

@@ -0,0 +1,150 @@
+import { SQRT3 } from "@thi.ng/math";
+import { clamp01 } from "@thi.ng/math/interval";
+import { abs2 } from "@thi.ng/vectors/abs";
+import { add2 } from "@thi.ng/vectors/add";
+import { ZERO2 } from "@thi.ng/vectors/api";
+import { cross2 } from "@thi.ng/vectors/cross";
+import { distSq2 } from "@thi.ng/vectors/distsq";
+import { dot2 } from "@thi.ng/vectors/dot";
+import { every3 } from "@thi.ng/vectors/every";
+import { maddN2 } from "@thi.ng/vectors/maddn";
+import { magSq2 } from "@thi.ng/vectors/magsq";
+import { max2 } from "@thi.ng/vectors/max";
+import { mul2 } from "@thi.ng/vectors/mul";
+import { mulN2 } from "@thi.ng/vectors/muln";
+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));
+export const distCircle2 = (p, radius) => mag2(p) - radius;
+export const distBox2 = (p, size) => {
+    const d = sub2(null, abs2([], p), size);
+    return Math.min(Math.max(d[0], d[1]), 0) + mag2(max2(null, d, ZERO2));
+};
+export const distPolygon2 = (pts, p) => {
+    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)))));
+        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);
+};
+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)));
+};
+export const distPolyline2 = (pts, p) => {
+    let d = Infinity;
+    for (let i = 1, n = pts.length; i < n; i++) {
+        d = Math.min(d, distSegment2(pts[i - 1], pts[i], p));
+    }
+    return d;
+};
+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);
+};
+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);
+    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 = Math.sqrt(h);
+        const x = [(h - q) / 2, (-h - q) / 2];
+        const uv = mul2(null, sign2([], x), powN2([], abs2([], x), 1 / 3));
+        const t = clamp01(uv[0] + uv[1] - kx);
+        const qq = maddN2(null, maddN2([], bb, t, cc), t, dd);
+        return (mag2(qq) *
+            (signed ? Math.sign(cross2(maddN2([], bb, 2 * t, cc), qq)) : 1));
+    }
+    else {
+        const z = Math.sqrt(-p);
+        const v = Math.acos(q / (p * z * 2)) / 3;
+        const m = Math.cos(v);
+        const n = Math.sin(v) * 1.732050808;
+        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 dx = magSq2(qx);
+        const qy = maddN2(null, maddN2([], 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));
+        }
+    }
+};
+export const distEllipse2 = ([px, py], [abx, aby]) => {
+    px = Math.abs(px);
+    py = Math.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 = 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;
+    }
+    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 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;
+    }
+    const rx = abx * co;
+    const ry = aby * Math.sqrt(1 - co * co);
+    return Math.hypot(rx - px, ry - py) * Math.sign(py - ry);
+};

package/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./api.js";
+export * from "./as-sdf.js";
+export * from "./dist.js";
+export * from "./ops.js";
+export * from "./sample.js";
+export * from "./shapes.js";
+//# sourceMappingURL=index.d.ts.map

package/index.js

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

package/ops.d.ts

@@ -0,0 +1,11 @@
+import type { 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 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;
+//# sourceMappingURL=ops.d.ts.map

package/ops.js

@@ -0,0 +1,22 @@
+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));

package/package.json

@@ -0,0 +1,114 @@
+{
+  "name": "@thi.ng/geom-sdf",
+  "version": "0.1.0",
+  "description": "2D Signed Distance Field creation from @thi.ng/geom shapes, conversions, sampling, combinators",
+  "type": "module",
+  "module": "./index.js",
+  "typings": "./index.d.ts",
+  "sideEffects": false,
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/thi-ng/umbrella.git"
+  },
+  "homepage": "https://github.com/thi-ng/umbrella/tree/master/packages/geom-sdf#readme",
+  "funding": [
+    {
+      "type": "github",
+      "url": "https://github.com/sponsors/postspectacular"
+    },
+    {
+      "type": "patreon",
+      "url": "https://patreon.com/thing_umbrella"
+    }
+  ],
+  "author": "Karsten Schmidt <k+npm@thi.ng>",
+  "license": "Apache-2.0",
+  "scripts": {
+    "build": "yarn clean && tsc --declaration",
+    "clean": "rimraf '*.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",
+    "doc:readme": "yarn doc:stats && tools:readme",
+    "doc:stats": "tools:module-stats",
+    "pub": "yarn npm publish --access public",
+    "test": "testament test"
+  },
+  "dependencies": {
+    "@thi.ng/api": "^8.3.7",
+    "@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-isoline": "^2.1.14",
+    "@thi.ng/math": "^5.3.3",
+    "@thi.ng/transducers": "^8.3.5",
+    "@thi.ng/vectors": "^7.5.6"
+  },
+  "devDependencies": {
+    "@microsoft/api-extractor": "^7.25.0",
+    "@thi.ng/testament": "^0.2.8",
+    "rimraf": "^3.0.2",
+    "tools": "^0.0.1",
+    "typedoc": "^0.22.17",
+    "typescript": "^4.7.3"
+  },
+  "keywords": [
+    "2d",
+    "arc",
+    "circle",
+    "bezier",
+    "conversion",
+    "distance",
+    "field",
+    "geometry",
+    "line",
+    "rect",
+    "sdf",
+    "shape",
+    "typescript"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "browser": {
+    "process": false,
+    "setTimeout": false
+  },
+  "engines": {
+    "node": ">=14"
+  },
+  "files": [
+    "*.js",
+    "*.d.ts"
+  ],
+  "exports": {
+    ".": {
+      "default": "./index.js"
+    },
+    "./api": {
+      "default": "./api.js"
+    },
+    "./as-sdf": {
+      "default": "./as-sdf.js"
+    },
+    "./dist": {
+      "default": "./dist.js"
+    },
+    "./ops": {
+      "default": "./ops.js"
+    },
+    "./sample": {
+      "default": "./sample.js"
+    },
+    "./shapes": {
+      "default": "./shapes.js"
+    }
+  },
+  "thi.ng": {
+    "parent": "@thi.ng/geom",
+    "status": "alpha",
+    "year": 2022
+  },
+  "gitHead": "f50e292ecc7dc74a6705b07fc739bf827cc5efd7\n"
+}

package/sample.d.ts

@@ -0,0 +1,8 @@
+import type { NumericArray } from "@thi.ng/api";
+import type { Polygon } from "@thi.ng/geom";
+import type { AABBLike } from "@thi.ng/geom-api";
+import { ReadonlyVec } 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[];
+//# sourceMappingURL=sample.d.ts.map

package/sample.js

@@ -0,0 +1,37 @@
+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) => {
+    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(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

@@ -0,0 +1,15 @@
+import { ReadonlyVec } from "@thi.ng/vectors";
+import type { SDFAttribs, SDFn } from "./api.js";
+/** @internal */
+export declare const DEFAULT_ATTRIBS: SDFAttribs;
+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 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;
+export declare const line2: (a: ReadonlyVec, b: ReadonlyVec, attribs?: Partial<SDFAttribs>) => SDFn;
+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;
+export declare const quadratic2: (a: ReadonlyVec, b: ReadonlyVec, c: ReadonlyVec, attribs?: Partial<SDFAttribs>) => SDFn;
+//# sourceMappingURL=shapes.d.ts.map

package/shapes.js

@@ -0,0 +1,33 @@
+import { distSq2 } from "@thi.ng/vectors";
+import { sub2 } from "@thi.ng/vectors/sub";
+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";
+/** @internal */
+export const DEFAULT_ATTRIBS = {
+    abs: false,
+    combine: "union",
+    flip: false,
+    round: 0,
+    smooth: 0,
+};
+export const withSDFAttribs = (fn, attribs) => {
+    if (attribs) {
+        const { abs, flip, round } = { ...DEFAULT_ATTRIBS, ...attribs };
+        if (abs)
+            fn = $abs(fn);
+        if (round > 0)
+            fn = $round(fn, round);
+        if (flip)
+            fn = $flip(fn);
+    }
+    return fn;
+};
+export const arc2 = (apert, ra, rb, attribs) => withSDFAttribs((p) => distArc2(p, apert, ra, rb), attribs);
+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);