@thi.ng/geom 6.0.6 → 6.0.8

package/rect.js

@@ -10,54 +10,55 @@ import { sub2 } from "@thi.ng/vectors/sub";
 import { subN2 } from "@thi.ng/vectors/subn";
 import { Rect } from "./api/rect.js";
 import { __argAttribs, __argsVV, __asVec } from "./internal/args.js";
-export function rect(...args) {
-    return new Rect(...__argsVV(args));
+function rect(...args) {
+  return new Rect(...__argsVV(args));
 }
-export const rectFromMinMax = (min, max, attribs) => new Rect(min, sub2([], max, min), attribs);
-export const rectFromMinMaxWithMargin = (min, max, margin, attribs) => rectFromMinMax(min, max, attribs).offset(margin);
-export const rectWithCentroid = (centroid, size, attribs) => {
-    size = __asVec(size);
-    return new Rect(maddN2([], size, -0.5, centroid), size, attribs);
+const rectFromMinMax = (min, max, attribs) => new Rect(min, sub2([], max, min), attribs);
+const rectFromMinMaxWithMargin = (min, max, margin, attribs) => rectFromMinMax(min, max, attribs).offset(margin);
+const rectWithCentroid = (centroid2, size, attribs) => {
+  size = __asVec(size);
+  return new Rect(maddN2([], size, -0.5, centroid2), size, attribs);
 };
-export const rectWithCentroidAndMargin = (centroid, size, margin, attribs) => rectWithCentroid(centroid, size, attribs).offset(margin);
-/**
- * Returns the intersection rect of given inputs or `undefined` if they
- * are non-overlapping.
- *
- * @param a -
- * @param b -
- */
-export const intersectionRect = (a, b) => {
-    const p = max2([], a.pos, b.pos);
-    const q = min2(null, add2([], a.pos, a.size), add2([], b.pos, b.size));
-    const size = max2(null, sub2(null, q, p), ZERO2);
-    return size[0] > 0 && size[1] > 0 ? new Rect(p, size) : undefined;
+const rectWithCentroidAndMargin = (centroid2, size, margin, attribs) => rectWithCentroid(centroid2, size, attribs).offset(margin);
+const intersectionRect = (a, b) => {
+  const p = max2([], a.pos, b.pos);
+  const q = min2(null, add2([], a.pos, a.size), add2([], b.pos, b.size));
+  const size = max2(null, sub2(null, q, p), ZERO2);
+  return size[0] > 0 && size[1] > 0 ? new Rect(p, size) : void 0;
 };
-export function inscribedSquare(...args) {
-    let pos, r;
-    const attribs = __argAttribs(args);
-    if (args.length === 1) {
-        const c = args[0];
-        pos = c.pos;
-        r = c.r;
-    }
-    else {
-        [pos, r] = args;
-    }
-    r *= SQRT2_2;
-    return rect(subN2([], pos, r), r * 2, attribs);
+function inscribedSquare(...args) {
+  let pos, r;
+  const attribs = __argAttribs(args);
+  if (args.length === 1) {
+    const c = args[0];
+    pos = c.pos;
+    r = c.r;
+  } else {
+    [pos, r] = args;
+  }
+  r *= SQRT2_2;
+  return rect(subN2([], pos, r), r * 2, attribs);
 }
-export function inscribedSquareHex(...args) {
-    let pos, l;
-    const attribs = __argAttribs(args);
-    if (args.length === 1) {
-        const pts = args[0].points;
-        pos = centroid(pts);
-        l = dist(pts[0], pts[1]);
-    }
-    else {
-        [pos, l] = args;
-    }
-    l *= 3 - SQRT3;
-    return rect(subN2([], pos, l / 2), l, attribs);
+function inscribedSquareHex(...args) {
+  let pos, l;
+  const attribs = __argAttribs(args);
+  if (args.length === 1) {
+    const pts = args[0].points;
+    pos = centroid(pts);
+    l = dist(pts[0], pts[1]);
+  } else {
+    [pos, l] = args;
+  }
+  l *= 3 - SQRT3;
+  return rect(subN2([], pos, l / 2), l, attribs);
 }
+export {
+  inscribedSquare,
+  inscribedSquareHex,
+  intersectionRect,
+  rect,
+  rectFromMinMax,
+  rectFromMinMaxWithMargin,
+  rectWithCentroid,
+  rectWithCentroidAndMargin
+};

package/resample.js

@@ -5,36 +5,21 @@ import { Polyline } from "./api/polyline.js";
 import { asPolygon } from "./as-polygon.js";
 import { __copyAttribsNoSamples as __attribs } from "./internal/copy.js";
 import { __dispatch } from "./internal/dispatch.js";
-/**
- * Resamples given 2D shape with given options and returns result as polygon (if
- * closed) or polyline (if open).
- *
- * @remarks
- * If the shape has a `__samples` attribute, it will be removed in the result to
- * avoid recursive application.
- *
- * Currently implemented for:
- *
- * - {@link Circle}
- * - {@link Ellipse}
- * - {@link Line}
- * - {@link Polygon}
- * - {@link Polyline}
- * - {@link Quad}
- * - {@link Rect}
- * - {@link Triangle}
- *
- * @param shape
- * @param opts
- */
-export const resample = defmulti(__dispatch, {
+const resample = defmulti(
+  __dispatch,
+  {
     ellipse: "circle",
     line: "polyline",
     quad: "poly",
     tri: "poly",
-    rect: "circle",
-}, {
+    rect: "circle"
+  },
+  {
     circle: ($, opts) => asPolygon($, opts),
     poly: ($, opts) => new Polygon(_resample($.points, opts, true, true), __attribs($)),
-    polyline: ($, opts) => new Polyline(_resample($.points, opts, false, true), __attribs($)),
-});
+    polyline: ($, opts) => new Polyline(_resample($.points, opts, false, true), __attribs($))
+  }
+);
+export {
+  resample
+};

package/rotate.js

@@ -17,37 +17,14 @@ import { asPolygon } from "./as-polygon.js";
 import { __copyAttribs } from "./internal/copy.js";
 import { __dispatch } from "./internal/dispatch.js";
 import { __rotatedShape as tx } from "./internal/rotate.js";
-/**
- * Rotates given 2D shape by `theta` (in radians).
- *
- * @remarks
- * Currently implemented for:
- *
- * - {@link Arc}
- * - {@link Circle}
- * - {@link Cubic}
- * - {@link Ellipse}
- * - {@link Group}
- * - {@link Line}
- * - {@link Path}
- * - {@link Points}
- * - {@link Polygon}
- * - {@link Polyline}
- * - {@link Quad}
- * - {@link Quadratic}
- * - {@link Ray}
- * - {@link Rect}
- * - {@link Text}
- * - {@link Triangle}
- *
- * @param shape
- * @param theta
- */
-export const rotate = defmulti(__dispatch, {}, {
+const rotate = defmulti(
+  __dispatch,
+  {},
+  {
     arc: ($, theta) => {
-        const a = $.copy();
-        $rotate(null, a.pos, theta);
-        return a;
+      const a = $.copy();
+      $rotate(null, a.pos, theta);
+      return a;
     },
     circle: ($, theta) => new Circle($rotate([], $.pos, theta), $.r, __copyAttribs($)),
     cubic: tx(Cubic),
@@ -55,15 +32,18 @@ export const rotate = defmulti(__dispatch, {}, {
     group: ($, theta) => $.copyTransformed((x) => rotate(x, theta)),
     line: tx(Line),
     path: ($, theta) => {
-        return new Path($.segments.map((s) => s.geo
-            ? {
-                type: s.type,
-                geo: rotate(s.geo, theta),
-            }
-            : {
-                type: s.type,
-                point: $rotate([], s.point, theta),
-            }), __copyAttribs($));
+      return new Path(
+        $.segments.map(
+          (s) => s.geo ? {
+            type: s.type,
+            geo: rotate(s.geo, theta)
+          } : {
+            type: s.type,
+            point: $rotate([], s.point, theta)
+          }
+        ),
+        __copyAttribs($)
+      );
     },
     points: tx(Points),
     poly: tx(Polygon),
@@ -71,9 +51,17 @@ export const rotate = defmulti(__dispatch, {}, {
     quad: tx(Quad),
     quadratic: tx(Quadratic),
     ray: ($, theta) => {
-        return new Ray($rotate([], $.pos, theta), $rotate([], $.dir, theta), __copyAttribs($));
+      return new Ray(
+        $rotate([], $.pos, theta),
+        $rotate([], $.dir, theta),
+        __copyAttribs($)
+      );
     },
     rect: ($, theta) => rotate(asPolygon($), theta),
     text: ($, theta) => new Text($rotate([], $.pos, theta), $.body, __copyAttribs($)),
-    tri: tx(Triangle),
-});
+    tri: tx(Triangle)
+  }
+);
+export {
+  rotate
+};

package/scale.js

@@ -24,71 +24,59 @@ import { __asVec } from "./internal/args.js";
 import { __copyAttribs } from "./internal/copy.js";
 import { __dispatch } from "./internal/dispatch.js";
 import { __scaledShape as tx } from "./internal/scale.js";
-/**
- * Scales given shape uniformly or non-uniformly by given `factor`.
- *
- * @remarks
- * Scaling non-uniformly might result in different result types, e.g.
- * {@link Circle} => {@link Ellipse}.
- *
- * Currently implemented for:
- *
- * - {@link AABB}
- * - {@link Arc}
- * - {@link Circle}
- * - {@link Cubic}
- * - {@link Ellipse}
- * - {@link Group}
- * - {@link Line}
- * - {@link Path}
- * - {@link Points}
- * - {@link Points3}
- * - {@link Polygon}
- * - {@link Polyline}
- * - {@link Quad}
- * - {@link Quadratic}
- * - {@link Ray}
- * - {@link Rect}
- * - {@link Sphere}
- * - {@link Text}
- * - {@link Triangle}
- *
- * @param shape
- * @param factor
- */
-export const scale = defmulti(__dispatch, {}, {
+const scale = defmulti(
+  __dispatch,
+  {},
+  {
     aabb: ($, delta) => {
-        delta = __asVec(delta, 3);
-        return new AABB(mul3([], $.pos, delta), mul3([], $.size, delta), __copyAttribs($));
+      delta = __asVec(delta, 3);
+      return new AABB(
+        mul3([], $.pos, delta),
+        mul3([], $.size, delta),
+        __copyAttribs($)
+      );
     },
     arc: ($, delta) => {
-        delta = __asVec(delta);
-        const a = $.copy();
-        mul2(null, a.pos, delta);
-        mul2(null, a.r, delta);
-        return a;
+      delta = __asVec(delta);
+      const a = $.copy();
+      mul2(null, a.pos, delta);
+      mul2(null, a.r, delta);
+      return a;
     },
-    circle: ($, delta) => isNumber(delta)
-        ? new Circle(mulN2([], $.pos, delta), $.r * delta, __copyAttribs($))
-        : new Ellipse(mul2([], $.pos, delta), mulN2([], delta, $.r), __copyAttribs($)),
+    circle: ($, delta) => isNumber(delta) ? new Circle(
+      mulN2([], $.pos, delta),
+      $.r * delta,
+      __copyAttribs($)
+    ) : new Ellipse(
+      mul2([], $.pos, delta),
+      mulN2([], delta, $.r),
+      __copyAttribs($)
+    ),
     cubic: tx(Cubic),
     ellipse: ($, delta) => {
-        delta = __asVec(delta);
-        return new Ellipse(mul2([], $.pos, delta), mul2([], $.r, delta), __copyAttribs($));
+      delta = __asVec(delta);
+      return new Ellipse(
+        mul2([], $.pos, delta),
+        mul2([], $.r, delta),
+        __copyAttribs($)
+      );
     },
     group: ($, delta) => $.copyTransformed((x) => scale(x, delta)),
     line: tx(Line),
     path: ($, delta) => {
-        delta = __asVec(delta);
-        return new Path($.segments.map((s) => s.geo
-            ? {
-                type: s.type,
-                geo: scale(s.geo, delta),
-            }
-            : {
-                type: s.type,
-                point: mul2([], s.point, delta),
-            }), __copyAttribs($));
+      delta = __asVec(delta);
+      return new Path(
+        $.segments.map(
+          (s) => s.geo ? {
+            type: s.type,
+            geo: scale(s.geo, delta)
+          } : {
+            type: s.type,
+            point: mul2([], s.point, delta)
+          }
+        ),
+        __copyAttribs($)
+      );
     },
     points: tx(Points),
     points3: tx(Points3),
@@ -97,16 +85,30 @@ export const scale = defmulti(__dispatch, {}, {
     quad: tx(Quad),
     quadratic: tx(Quadratic),
     ray: ($, delta) => {
-        delta = __asVec(delta);
-        return new Ray(mul2([], $.pos, delta), normalize2(null, mul2([], $.dir, delta)), __copyAttribs($));
+      delta = __asVec(delta);
+      return new Ray(
+        mul2([], $.pos, delta),
+        normalize2(null, mul2([], $.dir, delta)),
+        __copyAttribs($)
+      );
     },
     rect: ($, delta) => {
-        delta = __asVec(delta);
-        return new Rect(mul2([], $.pos, delta), mul2([], $.size, delta), __copyAttribs($));
+      delta = __asVec(delta);
+      return new Rect(
+        mul2([], $.pos, delta),
+        mul2([], $.size, delta),
+        __copyAttribs($)
+      );
     },
-    sphere: ($, delta) => isNumber(delta)
-        ? new Sphere(mulN3([], $.pos, delta), $.r * delta, __copyAttribs($))
-        : unsupported("can't non-uniformly scale sphere"),
+    sphere: ($, delta) => isNumber(delta) ? new Sphere(
+      mulN3([], $.pos, delta),
+      $.r * delta,
+      __copyAttribs($)
+    ) : unsupported("can't non-uniformly scale sphere"),
     text: ($, delta) => new Text(mul2([], $.pos, __asVec(delta)), $.body, __copyAttribs($)),
-    tri: tx(Triangle),
-});
+    tri: tx(Triangle)
+  }
+);
+export {
+  scale
+};

package/scatter.js

@@ -2,35 +2,23 @@ import { SYSTEM } from "@thi.ng/random/system";
 import { randMinMax } from "@thi.ng/vectors/rand-minmax";
 import { bounds } from "./bounds.js";
 import { pointInside } from "./point-inside.js";
-/**
- * Produces `num` random points for which {@link pointInside} succeeds for the
- * given `shape`. Writes results into `out` array (or creates a new one).
- *
- * @remarks
- * Samples are only created with the shapes bounding box and are chosen using
- * optionally provided `rnd`
- * [`IRandom`](https://docs.thi.ng/umbrella/random/interfaces/IRandom.html)
- * instance.
- *
- * @param shape
- * @param num
- * @param rnd
- * @param out
- */
-export const scatter = (shape, num, rnd = SYSTEM, out = []) => {
-    const b = bounds(shape);
-    if (!b)
-        return;
-    const mi = b.pos;
-    const mx = b.max();
-    for (; num-- > 0;) {
-        while (true) {
-            const p = randMinMax([], mi, mx, rnd);
-            if (pointInside(shape, p)) {
-                out.push(p);
-                break;
-            }
-        }
+const scatter = (shape, num, rnd = SYSTEM, out = []) => {
+  const b = bounds(shape);
+  if (!b)
+    return;
+  const mi = b.pos;
+  const mx = b.max();
+  for (; num-- > 0; ) {
+    while (true) {
+      const p = randMinMax([], mi, mx, rnd);
+      if (pointInside(shape, p)) {
+        out.push(p);
+        break;
+      }
     }
-    return out;
+  }
+  return out;
+};
+export {
+  scatter
 };

package/simplify.js

@@ -7,62 +7,45 @@ import { Polyline } from "./api/polyline.js";
 import { __copyAttribs } from "./internal/copy.js";
 import { __dispatch } from "./internal/dispatch.js";
 import { vertices } from "./vertices.js";
-/**
- * Simplifies given 2D shape boundary using Douglas-Peucker algorithm
- * (implemented by
- * [`simplify()`](https://docs.thi.ng/umbrella/geom-resample/functions/simplify.html))
- * and given `threshold` distance (default: 0, which removes only co-linear
- * vertices).
- *
- * @remarks
- * Currently only implemented for:
- *
- * - {@link Path}
- * - {@link Polygon}
- * - {@link Polyline}
- *
- * Use {@link asPath}, {@link asPolygon} or {@link asPolyline} to convert other
- * shape types first.
- *
- * @param shape
- * @param threshold
- */
-export const simplify = defmulti(__dispatch, {}, {
+const simplify = defmulti(
+  __dispatch,
+  {},
+  {
     path: ($, eps = 0) => {
-        const res = [];
-        const orig = $.segments;
-        const n = orig.length;
-        let points;
-        let lastP;
-        for (let i = 0; i < n; i++) {
-            const s = orig[i];
-            if (s.type === "l" || s.type === "p") {
-                points = points
-                    ? points.concat(vertices(s.geo))
-                    : vertices(s.geo);
-                lastP = peek(points);
-            }
-            else if (points) {
-                points.push(lastP);
-                res.push({
-                    geo: new Polyline(_simplify(points, eps)),
-                    type: "p",
-                });
-                points = null;
-            }
-            else {
-                res.push({ ...s });
-            }
+      const res = [];
+      const orig = $.segments;
+      const n = orig.length;
+      let points;
+      let lastP;
+      for (let i = 0; i < n; i++) {
+        const s = orig[i];
+        if (s.type === "l" || s.type === "p") {
+          points = points ? points.concat(vertices(s.geo)) : vertices(s.geo);
+          lastP = peek(points);
+        } else if (points) {
+          points.push(lastP);
+          res.push({
+            geo: new Polyline(_simplify(points, eps)),
+            type: "p"
+          });
+          points = null;
+        } else {
+          res.push({ ...s });
         }
-        if (points) {
-            points.push(lastP);
-            res.push({
-                geo: new Polyline(points),
-                type: "p",
-            });
-        }
-        return new Path(res, __copyAttribs($));
+      }
+      if (points) {
+        points.push(lastP);
+        res.push({
+          geo: new Polyline(points),
+          type: "p"
+        });
+      }
+      return new Path(res, __copyAttribs($));
     },
     poly: ($, eps = 0) => new Polygon(_simplify($.points, eps, true), __copyAttribs($)),
-    polyline: ($, eps = 0) => new Polyline(_simplify($.points, eps), __copyAttribs($)),
-});
+    polyline: ($, eps = 0) => new Polyline(_simplify($.points, eps), __copyAttribs($))
+  }
+);
+export {
+  simplify
+};

package/sphere.js

@@ -2,7 +2,11 @@ import { dist } from "@thi.ng/vectors/dist";
 import { mixN3 } from "@thi.ng/vectors/mixn";
 import { Sphere } from "./api/sphere.js";
 import { __argsVN } from "./internal/args.js";
-export function sphere(...args) {
-    return new Sphere(...__argsVN(args));
+function sphere(...args) {
+  return new Sphere(...__argsVN(args));
 }
-export const sphereFrom2Points = (a, b, attribs) => new Sphere(mixN3([], a, b, 0.5), dist(a, b) / 2, attribs);
+const sphereFrom2Points = (a, b, attribs) => new Sphere(mixN3([], a, b, 0.5), dist(a, b) / 2, attribs);
+export {
+  sphere,
+  sphereFrom2Points
+};