@thi.ng/geom 6.0.6 → 6.0.8

package/classify-point.js

@@ -1,34 +1,27 @@
 import { defmulti } from "@thi.ng/defmulti/defmulti";
-import { classifyPointInCircle, classifyPointInTriangle2, } from "@thi.ng/geom-isec/point";
+import {
+  classifyPointInCircle,
+  classifyPointInTriangle2
+} from "@thi.ng/geom-isec/point";
 import { sign } from "@thi.ng/math/abs";
 import { EPS } from "@thi.ng/math/api";
 import { dot } from "@thi.ng/vectors/dot";
 import { __dispatch } from "./internal/dispatch.js";
-/**
- * Classifies point `p` with respect to given shape. Returns -1 if `p` is
- * inside, 1 if outside  or 0 if `p` is on the shape boundary (using optional
- * tolerance `eps`, default: 1e-6).
- *
- * @remarks
- * Currently only implemented for:
- *
- * - {@link Circle}
- * - {@link Plane}
- * - {@link Sphere}
- * - {@link Triangle}
- *
- * The [thi.ng/geom-sdf](https://thi.ng/thi.ng/geom-sdf) package provides a much
- * more comprehensive feature set (incl. support for more shapes) to perform
- * similar checks as this function.
- *
- * Also see {@link pointInside}.
- *
- * @param shape
- * @param p
- * @param eps
- */
-export const classifyPoint = defmulti(__dispatch, { sphere: "circle" }, {
+const classifyPoint = defmulti(
+  __dispatch,
+  { sphere: "circle" },
+  {
     circle: ($, p, eps = EPS) => classifyPointInCircle(p, $.pos, $.r, eps),
     plane: ($, p, eps) => sign(dot($.normal, p) - $.w, eps),
-    tri: ({ points }, p, eps = EPS) => classifyPointInTriangle2(p, points[0], points[1], points[2], eps),
-});
+    tri: ({ points }, p, eps = EPS) => classifyPointInTriangle2(
+      p,
+      points[0],
+      points[1],
+      points[2],
+      eps
+    )
+  }
+);
+export {
+  classifyPoint
+};

package/clip-convex.js

@@ -8,53 +8,54 @@ import { Polygon } from "./api/polygon.js";
 import { __copyAttribs } from "./internal/copy.js";
 import { __dispatch } from "./internal/dispatch.js";
 import { ensureVertices, vertices } from "./vertices.js";
-/**
- * Takes a shape and a boundary (both convex). Uses the Sutherland-Hodgman
- * algorithm to compute a clipped version of the first shape (against the
- * boundary). Returns `undefined` if there're no remaining result vertices.
- *
- * @remarks
- * Internally uses
- * [`sutherlandHodgeman()`](https://docs.thi.ng/umbrella/geom-clip-poly/functions/sutherlandHodgeman.html).
- * For groups, calls itself for each child shape individually and returns a new
- * group of results (if any).
- *
- * @param shape
- * @param boundary
- */
-export const clipConvex = defmulti(__dispatch, {
+const clipConvex = defmulti(
+  __dispatch,
+  {
     circle: "rect",
     ellipse: "rect",
     path: "rect",
     quad: "poly",
-    tri: "poly",
-}, {
+    tri: "poly"
+  },
+  {
     group: ({ children, attribs }, boundary) => {
-        boundary = ensureVertices(boundary);
-        const clipped = [];
-        for (let c of children) {
-            const res = clipConvex(c, boundary);
-            if (res)
-                clipped.push(res);
-        }
-        return clipped.length
-            ? new Group({ ...attribs }, clipped)
-            : undefined;
+      boundary = ensureVertices(boundary);
+      const clipped = [];
+      for (let c of children) {
+        const res = clipConvex(c, boundary);
+        if (res)
+          clipped.push(res);
+      }
+      return clipped.length ? new Group({ ...attribs }, clipped) : void 0;
     },
     line: ($, boundary) => {
-        const segments = clipLineSegmentPoly($.points[0], $.points[1], ensureVertices(boundary));
-        return segments && segments.length
-            ? new Line(segments[0], __copyAttribs($))
-            : undefined;
+      const segments = clipLineSegmentPoly(
+        $.points[0],
+        $.points[1],
+        ensureVertices(boundary)
+      );
+      return segments && segments.length ? new Line(segments[0], __copyAttribs($)) : void 0;
     },
     poly: ($, boundary) => {
-        boundary = ensureVertices(boundary);
-        const pts = sutherlandHodgeman($.points, boundary, centroid(boundary));
-        return pts.length ? new Polygon(pts, __copyAttribs($)) : undefined;
+      boundary = ensureVertices(boundary);
+      const pts = sutherlandHodgeman(
+        $.points,
+        boundary,
+        centroid(boundary)
+      );
+      return pts.length ? new Polygon(pts, __copyAttribs($)) : void 0;
     },
     rect: ($, boundary) => {
-        boundary = ensureVertices(boundary);
-        const pts = sutherlandHodgeman(vertices($), boundary, centroid(boundary));
-        return pts.length ? new Polygon(pts, __copyAttribs($)) : undefined;
-    },
-});
+      boundary = ensureVertices(boundary);
+      const pts = sutherlandHodgeman(
+        vertices($),
+        boundary,
+        centroid(boundary)
+      );
+      return pts.length ? new Polygon(pts, __copyAttribs($)) : void 0;
+    }
+  }
+);
+export {
+  clipConvex
+};

package/closest-point.js

@@ -1,55 +1,49 @@
 import { defmulti } from "@thi.ng/defmulti/defmulti";
 import { closestPoint as closestPointArc } from "@thi.ng/geom-arc/closest-point";
-import { closestPointAABB, closestPointRect, } from "@thi.ng/geom-closest-point/box";
+import {
+  closestPointAABB,
+  closestPointRect
+} from "@thi.ng/geom-closest-point/box";
 import { closestPointCircle } from "@thi.ng/geom-closest-point/circle";
-import { closestPointPolyline, closestPointSegment, } from "@thi.ng/geom-closest-point/line";
+import {
+  closestPointPolyline,
+  closestPointSegment
+} from "@thi.ng/geom-closest-point/line";
 import { closestPointPlane } from "@thi.ng/geom-closest-point/plane";
 import { closestPointArray } from "@thi.ng/geom-closest-point/points";
 import { closestPointCubic } from "@thi.ng/geom-splines/cubic-closest-point";
 import { closestPointQuadratic } from "@thi.ng/geom-splines/quadratic-closest-point";
 import { add2, add3 } from "@thi.ng/vectors/add";
 import { __dispatch } from "./internal/dispatch.js";
-/**
- * Computes closest point to `p` on boundary of given shape. Writes result in
- * optionally provided output vector (or creates new one if omitted).
- *
- * @remarks
- * Currently implemented for:
- *
- * - {@link AABB}
- * - {@link Arc}
- * - {@link Circle}
- * - {@link Cubic}
- * - {@link Line}
- * - {@link Plane}
- * - {@link Points}
- * - {@link Points3}
- * - {@link Polygon}
- * - {@link Polyline}
- * - {@link Quad}
- * - {@link Quadratic}
- * - {@link Rect}
- * - {@link Sphere}
- *
- * @param shape
- * @param p
- * @param out
- */
-export const closestPoint = defmulti(__dispatch, {
+const closestPoint = defmulti(
+  __dispatch,
+  {
     quad: "poly",
     points3: "points",
     sphere: "circle",
-    tri: "poly",
-}, {
+    tri: "poly"
+  },
+  {
     aabb: ($, p, out) => closestPointAABB(p, $.pos, add3([], $.pos, $.size), out),
     arc: ($, p, out) => closestPointArc(p, $.pos, $.r, $.axis, $.start, $.end, out),
     circle: ($, p, out) => closestPointCircle(p, $.pos, $.r, out),
-    cubic: ({ points }, p, out) => closestPointCubic(p, points[0], points[1], points[2], points[3], out),
+    cubic: ({ points }, p, out) => closestPointCubic(
+      p,
+      points[0],
+      points[1],
+      points[2],
+      points[3],
+      out
+    ),
     line: ({ points }, p, out) => closestPointSegment(p, points[0], points[1], out),
     plane: ($, p, out) => closestPointPlane(p, $.normal, $.w, out),
     points: ($, p, out) => closestPointArray(p, $.points, out),
     poly: ($, p, out) => closestPointPolyline(p, $.points, true, out),
     polyline: ($, p, out) => closestPointPolyline(p, $.points, false, out),
     quadratic: ({ points }, p, out) => closestPointQuadratic(p, points[0], points[1], points[2], out),
-    rect: ($, p, out) => closestPointRect(p, $.pos, add2([], $.pos, $.size), out),
-});
+    rect: ($, p, out) => closestPointRect(p, $.pos, add2([], $.pos, $.size), out)
+  }
+);
+export {
+  closestPoint
+};

package/convex-hull.js

@@ -4,29 +4,9 @@ import { Polygon } from "./api/polygon.js";
 import { __copyAttribs } from "./internal/copy.js";
 import { __dispatch } from "./internal/dispatch.js";
 import { vertices } from "./vertices.js";
-/**
- * Computes the convex hull for given shape and returns it as {@link Polygon}.
- *
- * @remarks
- * Internally uses
- * [`grahamScan2()`](https://docs.thi.ng/umbrella/geom-hull/functions/grahamScan2.html).
- *
- * Currently implemented for:
- *
- * - {@link Arc}
- * - {@link Circle}
- * - {@link Ellipse}
- * - {@link Group} (only the listed child shape types are considered)
- * - {@link Points}
- * - {@link Polygon}
- * - {@link Polyline}
- * - {@link Quad}
- * - {@link Rect}
- * - {@link Triangle}
- *
- * @param shape
- */
-export const convexHull = defmulti(__dispatch, {
+const convexHull = defmulti(
+  __dispatch,
+  {
     arc: "group",
     circle: "tri",
     cubic: "group",
@@ -36,9 +16,14 @@ export const convexHull = defmulti(__dispatch, {
     polyline: "points",
     quad: "points",
     quadratic: "group",
-    rect: "tri",
-}, {
+    rect: "tri"
+  },
+  {
     group: ($) => new Polygon(grahamScan2(vertices($)), __copyAttribs($)),
     points: ($) => new Polygon(grahamScan2($.points), __copyAttribs($)),
-    tri: ($) => new Polygon(vertices($), __copyAttribs($)),
-});
+    tri: ($) => new Polygon(vertices($), __copyAttribs($))
+  }
+);
+export {
+  convexHull
+};

package/cubic.js

@@ -4,9 +4,17 @@ import { cubicFromQuadratic as _quad } from "@thi.ng/geom-splines/cubic-quadrati
 import { Cubic } from "./api/cubic.js";
 import { __copyAttribs } from "./internal/copy.js";
 import { __pclike } from "./internal/pclike.js";
-export function cubic(...args) {
-    return __pclike(Cubic, args);
+function cubic(...args) {
+  return __pclike(Cubic, args);
 }
-export const cubicFromArc = (arc) => _arc(arc.pos, arc.r, arc.axis, arc.start, arc.end).map((c) => new Cubic(c, __copyAttribs(arc)));
-export const cubicFromLine = (a, b, attribs) => new Cubic(_line(a, b), attribs);
-export const cubicFromQuadratic = (a, b, c, attribs) => new Cubic(_quad(a, b, c), attribs);
+const cubicFromArc = (arc) => _arc(arc.pos, arc.r, arc.axis, arc.start, arc.end).map(
+  (c) => new Cubic(c, __copyAttribs(arc))
+);
+const cubicFromLine = (a, b, attribs) => new Cubic(_line(a, b), attribs);
+const cubicFromQuadratic = (a, b, c, attribs) => new Cubic(_quad(a, b, c), attribs);
+export {
+  cubic,
+  cubicFromArc,
+  cubicFromLine,
+  cubicFromQuadratic
+};

package/edges.js

@@ -5,70 +5,37 @@ import { asPolyline } from "./as-polyline.js";
 import { __dispatch } from "./internal/dispatch.js";
 import { __edges } from "./internal/edges.js";
 import { vertices } from "./vertices.js";
-/**
- * Extracts the edges of given shape's boundary and returns them as an iterable
- * of vector pairs.
- *
- * @remarks
- * If the shape has a `__samples` attribute, it will be removed in the result to
- * avoid recursive application.
- *
- * Currently implemented for:
- *
- * - {@link AABB}
- * - {@link Arc}
- * - {@link BPatch}
- * - {@link Circle}
- * - {@link Cubic}
- * - {@link Ellipse}
- * - {@link Group}
- * - {@link Line}
- * - {@link Path}
- * - {@link Polygon}
- * - {@link Polyline}
- * - {@link Quad}
- * - {@link Quadratic}
- * - {@link Rect}
- * - {@link Triangle}
- *
- * The implementations for the following shapes **do not** support
- * [`SamplingOpts`](https://docs.thi.ng/umbrella/geom-api/interfaces/SamplingOpts.html)
- * (all others do):
- *
- * - {@link Line}
- * - {@link Polygon}
- * - {@link Polyline}
- * - {@link Quad}
- * - {@link Rect}
- * - {@link Triangle}
- *
- * @param shape
- * @param opts
- */
-export const edges = defmulti(__dispatch, {
+const edges = defmulti(
+  __dispatch,
+  {
     cubic: "arc",
     ellipse: "circle",
     line: "polyline",
     quad: "poly",
     quadratic: "arc",
-    tri: "poly",
-}, {
+    tri: "poly"
+  },
+  {
     aabb: ($) => {
-        const [a, b, c, d, e, f, g, h] = vertices($);
-        return [
-            [a, b],
-            [b, c],
-            [c, d],
-            [d, a], // bottom
-            [e, f],
-            [f, g],
-            [g, h],
-            [h, e], // top
-            [a, e],
-            [b, f], // left
-            [c, g],
-            [d, h], // right
-        ];
+      const [a, b, c, d, e, f, g, h] = vertices($);
+      return [
+        [a, b],
+        [b, c],
+        [c, d],
+        [d, a],
+        // bottom
+        [e, f],
+        [f, g],
+        [g, h],
+        [h, e],
+        // top
+        [a, e],
+        [b, f],
+        // left
+        [c, g],
+        [d, h]
+        // right
+      ];
     },
     arc: ($, opts) => __edges(asPolyline($, opts).points, false),
     bpatch: ($) => $.edges(),
@@ -77,5 +44,9 @@ export const edges = defmulti(__dispatch, {
     path: ($, opts) => __edges(asPolygon($, opts).points, $.closed),
     poly: ($) => __edges($.points, true),
     polyline: ($) => __edges($.points),
-    rect: ($) => __edges(vertices($), true),
-});
+    rect: ($) => __edges(vertices($), true)
+  }
+);
+export {
+  edges
+};

package/ellipse.js

@@ -1,5 +1,8 @@
 import { Ellipse } from "./api/ellipse.js";
 import { __argsVV } from "./internal/args.js";
-export function ellipse(...args) {
-    return new Ellipse(...__argsVV(args));
+function ellipse(...args) {
+  return new Ellipse(...__argsVV(args));
 }
+export {
+  ellipse
+};

package/fit-into-bounds.js

@@ -12,68 +12,85 @@ import { __collBounds } from "./internal/bounds.js";
 import { mapPoint } from "./map-point.js";
 import { transform } from "./transform.js";
 import { unmapPoint } from "./unmap-point.js";
-/** @internal */
-const __translateScale = (tmat, smat, shape, preTrans, postTrans, scale) => transform(shape, concat([], tmat([], postTrans), smat([], scale), tmat([], preTrans)));
-/**
- * Uniformly rescales & repositions given 2D `shape` such that it fits into
- * destination bounds. Returns transformed copy of `shape`.
- *
- * @param shape
- * @param dest
- */
-export const fitIntoBounds2 = (shape, dest) => {
-    const src = bounds(shape);
-    if (!src)
-        return;
-    const c = centroid(src);
-    if (!c)
-        return;
-    return __translateScale(translation23, scale23, shape, neg(null, c), centroid(dest), minNonZero2(safeDiv(dest.size[0], src.size[0]), safeDiv(dest.size[1], src.size[1])));
+const __translateScale = (tmat, smat, shape, preTrans, postTrans, scale) => transform(
+  shape,
+  concat([], tmat([], postTrans), smat([], scale), tmat([], preTrans))
+);
+const fitIntoBounds2 = (shape, dest) => {
+  const src = bounds(shape);
+  if (!src)
+    return;
+  const c = centroid(src);
+  if (!c)
+    return;
+  return __translateScale(
+    translation23,
+    scale23,
+    shape,
+    neg(null, c),
+    centroid(dest),
+    minNonZero2(
+      safeDiv(dest.size[0], src.size[0]),
+      safeDiv(dest.size[1], src.size[1])
+    )
+  );
 };
-/**
- * 3D version of {@link fitIntoBounds2}.
- *
- * @param shape
- * @param dest
- */
-export const fitIntoBounds3 = (shape, dest) => {
-    const src = bounds(shape);
-    if (!src)
-        return;
-    const c = centroid(src);
-    if (!c)
-        return;
-    return __translateScale(translation44, scale44, shape, neg(null, c), centroid(dest), minNonZero3(safeDiv(dest.size[0], src.size[0]), safeDiv(dest.size[1], src.size[1]), safeDiv(dest.size[2], src.size[2])));
+const fitIntoBounds3 = (shape, dest) => {
+  const src = bounds(shape);
+  if (!src)
+    return;
+  const c = centroid(src);
+  if (!c)
+    return;
+  return __translateScale(
+    translation44,
+    scale44,
+    shape,
+    neg(null, c),
+    centroid(dest),
+    minNonZero3(
+      safeDiv(dest.size[0], src.size[0]),
+      safeDiv(dest.size[1], src.size[1]),
+      safeDiv(dest.size[2], src.size[2])
+    )
+  );
 };
-/**
- * Version of {@link fitIntoBounds2} for multiple source shapes.
- *
- * @param shapes
- * @param dest
- */
-export const fitAllIntoBounds2 = (shapes, dest) => {
-    const sbraw = __collBounds(shapes, bounds);
-    if (!sbraw)
-        return;
-    const src = new Rect(...sbraw);
-    const sx = safeDiv(dest.size[0], src.size[0]);
-    const sy = safeDiv(dest.size[1], src.size[1]);
-    const scale = sx > 0 ? (sy > 0 ? Math.min(sx, sy) : sx) : sy;
-    const smat = scale23([], scale);
-    const b = center(transform(src, smat), centroid(dest));
-    const c1 = [];
-    const c2 = [];
-    const res = [];
-    for (let i = shapes.length; i-- > 0;) {
-        const s = shapes[i];
-        const sc = centroid(s, c1);
-        if (sc) {
-            unmapPoint(b, mapPoint(src, sc), c2);
-            res.push(__translateScale(translation23, scale23, s, neg(null, c1), c2, smat));
-        }
-        else {
-            res.push(s);
-        }
+const fitAllIntoBounds2 = (shapes, dest) => {
+  const sbraw = __collBounds(shapes, bounds);
+  if (!sbraw)
+    return;
+  const src = new Rect(...sbraw);
+  const sx = safeDiv(dest.size[0], src.size[0]);
+  const sy = safeDiv(dest.size[1], src.size[1]);
+  const scale = sx > 0 ? sy > 0 ? Math.min(sx, sy) : sx : sy;
+  const smat = scale23([], scale);
+  const b = center(transform(src, smat), centroid(dest));
+  const c1 = [];
+  const c2 = [];
+  const res = [];
+  for (let i = shapes.length; i-- > 0; ) {
+    const s = shapes[i];
+    const sc = centroid(s, c1);
+    if (sc) {
+      unmapPoint(b, mapPoint(src, sc), c2);
+      res.push(
+        __translateScale(
+          translation23,
+          scale23,
+          s,
+          neg(null, c1),
+          c2,
+          smat
+        )
+      );
+    } else {
+      res.push(s);
     }
-    return res;
+  }
+  return res;
+};
+export {
+  fitAllIntoBounds2,
+  fitIntoBounds2,
+  fitIntoBounds3
 };

package/flip.js

@@ -1,30 +1,9 @@
 import { DEFAULT, defmulti } from "@thi.ng/defmulti/defmulti";
 import { neg } from "@thi.ng/vectors/neg";
 import { __dispatch } from "./internal/dispatch.js";
-/**
- * Reverses vertex ordering or general direction (e.g. for {@link Ray}) of given
- * shape.
- *
- * @remarks
- * Currently implemented for:
- *
- * - {@link Arc}
- * - {@link Cubic}
- * - {@link Group} (only eligible shapes)
- * - {@link Line}
- * - {@link Path}
- * - {@link Points}
- * - {@link Points3}
- * - {@link Polygon}
- * - {@link Polyline}
- * - {@link Quad}
- * - {@link Quadratic}
- * - {@link Ray}
- * - {@link Triangle}
- *
- * @param shape
- */
-export const flip = defmulti(__dispatch, {
+const flip = defmulti(
+  __dispatch,
+  {
     cubic: "points",
     line: "points",
     points3: "points",
@@ -32,30 +11,34 @@ export const flip = defmulti(__dispatch, {
     polyline: "points",
     quad: "points",
     quadratic: "points",
-    tri: "points",
-}, {
+    tri: "points"
+  },
+  {
     [DEFAULT]: (x) => x,
     arc: ($) => {
-        const t = $.start;
-        $.start = $.end;
-        $.end = t;
-        $.cw = !$.cw;
-        return $;
+      const t = $.start;
+      $.start = $.end;
+      $.end = t;
+      $.cw = !$.cw;
+      return $;
     },
     group: ($) => {
-        $.children.forEach(flip);
-        return $;
+      $.children.forEach(flip);
+      return $;
     },
     path: ($) => {
-        // TODO
-        return $;
+      return $;
     },
     points: ($) => {
-        $.points.reverse();
-        return $;
+      $.points.reverse();
+      return $;
     },
     ray: ($) => {
-        $.dir = neg(null, $.dir);
-        return $;
-    },
-});
+      $.dir = neg(null, $.dir);
+      return $;
+    }
+  }
+);
+export {
+  flip
+};

package/group.js

@@ -1,2 +1,5 @@
 import { Group } from "./api/group.js";
-export const group = (attribs = {}, children) => new Group(attribs, children);
+const group = (attribs = {}, children) => new Group(attribs, children);
+export {
+  group
+};