@thi.ng/geom 7.0.1 → 8.0.1

package/rounded-rect.d.ts

@@ -0,0 +1,25 @@
+import type { Vec } from "@thi.ng/vectors";
+import type { Attribs } from "./api.js";
+import { Path } from "./api/path.js";
+/**
+ * Creates a new 2d rounded rect {@link Path}, using the given corner radius or
+ * radii.
+ *
+ * @remarks
+ * If multiple `radii` are given, the interpretation logic is the same as:
+ * https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D/roundRect
+ *
+ * - number: all corners
+ * - `[top-left-and-bottom-right, top-right-and-bottom-left]`
+ * - `[top-left, top-right-and-bottom-left, bottom-right]`
+ * - `[top-left, top-right, bottom-right, bottom-left]`
+ *
+ * No arc segments will be generated for those corners where the radius <= 0
+ *
+ * @param pos
+ * @param size
+ * @param radii
+ * @param attribs
+ */
+export declare const roundedRect: (pos: Vec, [w, h]: Vec, radii: number | [number, number] | [number, number, number] | [number, number, number, number], attribs?: Attribs) => Path;
+//# sourceMappingURL=rounded-rect.d.ts.map

package/rounded-rect.js

@@ -0,0 +1,18 @@
+import { isNumber } from "@thi.ng/checks/is-number";
+import { Path } from "./api/path.js";
+import { pathBuilder } from "./path-builder.js";
+const roundedRect = (pos, [w, h], radii, attribs) => {
+  const [tl, tr, br, bl] = isNumber(radii) ? [radii, radii, radii, radii] : radii.length === 2 ? [radii[0], radii[1], radii[0], radii[1]] : radii.length === 3 ? [radii[0], radii[1], radii[2], radii[1]] : radii;
+  const b = pathBuilder(attribs).moveTo([pos[0] + tl, pos[1]]).hlineTo(w - tl - tr, true);
+  if (tr > 0) b.arcTo([tr, tr], [tr, tr], 0, false, true, true);
+  b.vlineTo(h - tr - br, true);
+  if (br > 0) b.arcTo([-br, br], [br, br], 0, false, true, true);
+  b.hlineTo(-(w - br - bl), true);
+  if (bl > 0) b.arcTo([-bl, -bl], [bl, bl], 0, false, true, true);
+  b.vlineTo(-(h - bl - tl), true);
+  if (tl > 0) b.arcTo([tl, -tl], [tl, tl], 0, false, true, true);
+  return b.current().close();
+};
+export {
+  roundedRect
+};

package/scale-with-center.d.ts

@@ -1,4 +1,4 @@
-import type { IShape } from "@thi.ng/geom-api";
+import type { IShape } from "./api.js";
 import type { ReadonlyVec } from "@thi.ng/vectors";
 /**
  * Applies a sequence of translate and scale operations to return an uniformly
@@ -16,5 +16,5 @@ import type { ReadonlyVec } from "@thi.ng/vectors";
  * @param center
  * @param factor
  */
-export declare const scaleWithCenter: (shape: IShape, center: ReadonlyVec, factor: number) => IShape<IShape<any>>;
+export declare const scaleWithCenter: <T extends IShape>(shape: T, center: ReadonlyVec, factor: number) => T;
 //# sourceMappingURL=scale-with-center.d.ts.map

package/scale.d.ts

@@ -1,6 +1,17 @@
 import type { MultiFn2 } from "@thi.ng/defmulti";
-import type { IShape } from "@thi.ng/geom-api";
 import type { ReadonlyVec } from "@thi.ng/vectors";
+import type { IShape, IShape2, IShape3 } from "./api.js";
+import { Circle } from "./api/circle.js";
+import { Ellipse } from "./api/ellipse.js";
+/**
+ * Function overrides for {@link scale}.
+ */
+export type ScaleFn = {
+    (shape: Circle, factor: number): Circle;
+    (shape: Circle, factor: ReadonlyVec): Ellipse;
+    <T extends IShape2>(shape: T, factor: number | ReadonlyVec): T;
+    <T extends IShape3>(shape: T, factor: number | ReadonlyVec): T;
+} & MultiFn2<IShape, number | ReadonlyVec, IShape>;
 /**
  * Scales given shape uniformly or non-uniformly by given `factor`.
  *
@@ -12,20 +23,31 @@ import type { ReadonlyVec } from "@thi.ng/vectors";
  *
  * - {@link AABB}
  * - {@link Arc}
+ * - {@link BPatch}
  * - {@link Circle}
  * - {@link ComplexPolygon}
  * - {@link Cubic}
+ * - {@link Cubic3}
  * - {@link Ellipse}
+ * - {@link Extra} (returns `undefined`)
  * - {@link Group}
+ * - {@link Group3}
  * - {@link Line}
+ * - {@link Line3}
  * - {@link Path}
+ * - {@link Path3}
  * - {@link Points}
  * - {@link Points3}
  * - {@link Polygon}
+ * - {@link Polygon3}
  * - {@link Polyline}
+ * - {@link Polyline3}
  * - {@link Quad}
+ * - {@link Quad3}
  * - {@link Quadratic}
+ * - {@link Quadratic3}
  * - {@link Ray}
+ * - {@link Ray3}
  * - {@link Rect}
  * - {@link Sphere}
  * - {@link Text}
@@ -34,5 +56,5 @@ import type { ReadonlyVec } from "@thi.ng/vectors";
  * @param shape
  * @param factor
  */
-export declare const scale: MultiFn2<IShape, number | ReadonlyVec, IShape>;
+export declare const scale: ScaleFn;
 //# sourceMappingURL=scale.d.ts.map

package/scale.js

@@ -1,41 +1,50 @@
 import { isNumber } from "@thi.ng/checks/is-number";
 import { defmulti } from "@thi.ng/defmulti/defmulti";
 import { unsupported } from "@thi.ng/errors/unsupported";
-import { mul2, mul3 } from "@thi.ng/vectors/mul";
+import { mul, mul2, mul3 } from "@thi.ng/vectors/mul";
 import { mulN2, mulN3 } from "@thi.ng/vectors/muln";
-import { normalize2 } from "@thi.ng/vectors/normalize";
+import { normalize2, normalize3 } from "@thi.ng/vectors/normalize";
 import { AABB } from "./api/aabb.js";
 import { Circle } from "./api/circle.js";
-import { ComplexPolygon } from "./api/complex-polygon.js";
-import { Cubic } from "./api/cubic.js";
 import { Ellipse } from "./api/ellipse.js";
-import { Line } from "./api/line.js";
-import { Path } from "./api/path.js";
-import { Points, Points3 } from "./api/points.js";
-import { Polygon } from "./api/polygon.js";
-import { Polyline } from "./api/polyline.js";
-import { Quad } from "./api/quad.js";
-import { Quadratic } from "./api/quadratic.js";
 import { Ray } from "./api/ray.js";
+import { Ray3 } from "./api/ray3.js";
 import { Rect } from "./api/rect.js";
 import { Sphere } from "./api/sphere.js";
 import { Text } from "./api/text.js";
-import { Triangle } from "./api/triangle.js";
 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";
 import { __segmentTransformer } from "./internal/transform.js";
 const scale = defmulti(
   __dispatch,
-  {},
+  {
+    bpatch: "points",
+    complexpoly: "group",
+    cubic: "points",
+    cubic3: "points3",
+    group3: "group",
+    line: "points",
+    line3: "points3",
+    path3: "path",
+    poly: "points",
+    poly3: "points3",
+    polyline: "points",
+    polyline3: "points3",
+    quad: "points",
+    quad3: "points3",
+    quadratic: "points",
+    quadratic3: "points3",
+    tri: "points",
+    tri3: "points3"
+  },
   {
     aabb: ($, delta) => {
       delta = __asVec(delta, 3);
       return new AABB(
         mul3([], $.pos, delta),
         mul3([], $.size, delta),
-        __copyAttribs($)
+        __copyAttribs($.attribs)
       );
     },
     arc: ($, delta) => {
@@ -48,51 +57,55 @@ const scale = defmulti(
     circle: ($, delta) => isNumber(delta) ? new Circle(
       mulN2([], $.pos, delta),
       $.r * delta,
-      __copyAttribs($)
+      __copyAttribs($.attribs)
     ) : new Ellipse(
       mul2([], $.pos, delta),
       mulN2([], delta, $.r),
-      __copyAttribs($)
-    ),
-    complexpoly: ($, delta) => new ComplexPolygon(
-      scale($.boundary, delta),
-      $.children.map((child) => scale(child, delta))
+      __copyAttribs($.attribs)
     ),
-    cubic: tx(Cubic),
     ellipse: ($, delta) => {
       delta = __asVec(delta);
       return new Ellipse(
         mul2([], $.pos, delta),
         mul2([], $.r, delta),
-        __copyAttribs($)
+        __copyAttribs($.attribs)
       );
     },
+    extra: ($) => $,
     group: ($, delta) => $.copyTransformed((x) => scale(x, delta)),
-    line: tx(Line),
     path: ($, delta) => {
       delta = __asVec(delta);
-      const $scaleSegments = __segmentTransformer(
-        (geo) => scale(geo, delta),
-        (p) => mul2([], p, delta)
-      );
-      return new Path(
-        $scaleSegments($.segments),
-        $.subPaths.map($scaleSegments),
-        __copyAttribs($)
+      return $.copyTransformed(
+        __segmentTransformer(
+          (geo) => scale(geo, delta),
+          (p) => mul([], p, delta)
+        )
       );
     },
-    points: tx(Points),
-    points3: tx(Points3),
-    poly: tx(Polygon),
-    polyline: tx(Polyline),
-    quad: tx(Quad),
-    quadratic: tx(Quadratic),
+    points: ($, delta) => $.copyTransformed(
+      (points) => points.map(
+        isNumber(delta) ? (x) => mulN2([], x, delta) : (x) => mul2([], x, delta)
+      )
+    ),
+    points3: ($, delta) => $.copyTransformed(
+      (points) => points.map(
+        isNumber(delta) ? (x) => mulN3([], x, delta) : (x) => mul3([], x, delta)
+      )
+    ),
     ray: ($, delta) => {
       delta = __asVec(delta);
       return new Ray(
         mul2([], $.pos, delta),
         normalize2(null, mul2([], $.dir, delta)),
-        __copyAttribs($)
+        __copyAttribs($.attribs)
+      );
+    },
+    ray3: ($, delta) => {
+      delta = __asVec(delta);
+      return new Ray3(
+        mul3([], $.pos, delta),
+        normalize3(null, mul3([], $.dir, delta)),
+        __copyAttribs($.attribs)
       );
     },
     rect: ($, delta) => {
@@ -100,16 +113,19 @@ const scale = defmulti(
       return new Rect(
         mul2([], $.pos, delta),
         mul2([], $.size, delta),
-        __copyAttribs($)
+        __copyAttribs($.attribs)
       );
     },
     sphere: ($, delta) => isNumber(delta) ? new Sphere(
       mulN3([], $.pos, delta),
       $.r * delta,
-      __copyAttribs($)
+      __copyAttribs($.attribs)
     ) : unsupported("can't non-uniformly scale sphere"),
-    text: ($, delta) => new Text(mul2([], $.pos, __asVec(delta)), $.body, __copyAttribs($)),
-    tri: tx(Triangle)
+    text: ($, delta) => new Text(
+      mul2([], $.pos, __asVec(delta)),
+      $.body,
+      __copyAttribs($.attribs)
+    )
   }
 );
 export {

package/scatter.d.ts

@@ -1,4 +1,4 @@
-import type { IShape } from "@thi.ng/geom-api";
+import type { IShape } from "./api.js";
 import type { Vec } from "@thi.ng/vectors";
 /**
  * Produces `num` random points for which {@link pointInside} succeeds for the

package/simplify.d.ts

@@ -1,5 +1,11 @@
 import type { MultiFn1O } from "@thi.ng/defmulti";
-import type { IShape } from "@thi.ng/geom-api";
+import type { IShape, IShape2 } from "./api.js";
+/**
+ * Function overrides for {@link simplify}.
+ */
+export type SimplifyFn = {
+    <T extends IShape2>(shape: IShape2, eps?: number): T;
+} & MultiFn1O<IShape, number, IShape>;
 /**
  * Simplifies given 2D shape boundary using Douglas-Peucker algorithm
  * (implemented by
@@ -21,5 +27,5 @@ import type { IShape } from "@thi.ng/geom-api";
  * @param shape
  * @param threshold
  */
-export declare const simplify: MultiFn1O<IShape, number, IShape>;
+export declare const simplify: SimplifyFn;
 //# sourceMappingURL=simplify.d.ts.map

package/simplify.js

@@ -15,7 +15,7 @@ const simplify = defmulti(
     complexpoly: ($, eps) => new ComplexPolygon(
       simplify($.boundary, eps),
       $.children.map((child) => simplify(child, eps)),
-      __copyAttribs($)
+      __copyAttribs($.attribs)
     ),
     path: ($, eps = 1e-6) => {
       const $simplifySegments = (segments) => {
@@ -51,11 +51,14 @@ const simplify = defmulti(
       return new Path(
         $simplifySegments($.segments),
         $.subPaths.map($simplifySegments),
-        __copyAttribs($)
+        __copyAttribs($.attribs)
       );
     },
-    poly: ($, eps = 1e-6) => new Polygon(_simplify($.points, eps, true), __copyAttribs($)),
-    polyline: ($, eps = 1e-6) => new Polyline(_simplify($.points, eps), __copyAttribs($))
+    poly: ($, eps = 1e-6) => new Polygon(
+      _simplify($.points, eps, true),
+      __copyAttribs($.attribs)
+    ),
+    polyline: ($, eps = 1e-6) => new Polyline(_simplify($.points, eps), __copyAttribs($.attribs))
   }
 );
 export {

package/smooth-poly.d.ts

@@ -0,0 +1,27 @@
+import type { ReadonlyVec } from "@thi.ng/vectors";
+import type { Attribs, CubicOpts, SamplingOpts } from "./api.js";
+import { Polygon } from "./api/polygon.js";
+import { Polyline } from "./api/polyline.js";
+import { type AsPathOpts } from "./as-path.js";
+/**
+ * Creates a new polygon from given initial `points` and optional `attribs`. The
+ * polygon is then first converted into a cubic path using `pathOpts` and then
+ * back into a polygon by sampling the path using `polyOpts`. Returns that final
+ * polygon result.
+ *
+ * @param points
+ * @param attribs
+ * @param pathOpts
+ * @param polyOpts
+ */
+export declare const smoothPolygon: (points: ReadonlyVec[], attribs?: Attribs, pathOpts?: Partial<CubicOpts>, polyOpts?: Partial<SamplingOpts>) => Polygon;
+/**
+ * Like {@link smoothPolygon}, but for polylines.
+ *
+ * @param points
+ * @param attribs
+ * @param pathOpts
+ * @param polyOpts
+ */
+export declare const smoothPolyline: (points: ReadonlyVec[], attribs?: Attribs, pathOpts?: Partial<AsPathOpts>, polyOpts?: Partial<SamplingOpts>) => Polyline;
+//# sourceMappingURL=smooth-poly.d.ts.map

package/smooth-poly.js

@@ -0,0 +1,11 @@
+import { Polygon } from "./api/polygon.js";
+import { Polyline } from "./api/polyline.js";
+import { asPath } from "./as-path.js";
+import { asPolygon } from "./as-polygon.js";
+import { asPolyline } from "./as-polyline.js";
+const smoothPolygon = (points, attribs, pathOpts, polyOpts) => asPolygon(asPath(new Polygon(points, attribs), pathOpts), polyOpts)[0];
+const smoothPolyline = (points, attribs, pathOpts, polyOpts) => asPolyline(asPath(new Polyline(points, attribs), pathOpts), polyOpts)[0];
+export {
+  smoothPolygon,
+  smoothPolyline
+};

package/sphere.d.ts

@@ -1,4 +1,4 @@
-import type { Attribs } from "@thi.ng/geom-api";
+import type { Attribs } from "./api.js";
 import type { ReadonlyVec, Vec } from "@thi.ng/vectors";
 import { Sphere } from "./api/sphere.js";
 export declare function sphere(pos: Vec, r: number, attribs?: Attribs): Sphere;

package/split-arclength.d.ts

@@ -1,6 +1,10 @@
 import type { MultiFn2 } from "@thi.ng/defmulti";
-import type { IShape } from "@thi.ng/geom-api";
+import type { IShape } from "./api.js";
 import { Group } from "./api/group.js";
+/**
+ * Function overrides for {@link splitArcLength}.
+ */
+export type SplitArcLengthFn = {} & MultiFn2<IShape, number, Group>;
 /**
  * Splits given shape into {@link Polyline} segments of given (max) arc length.
  * Returns a {@link Group} of shapes/polylines.
@@ -66,5 +70,5 @@ import { Group } from "./api/group.js";
  * @param shape
  * @param dist
  */
-export declare const splitArcLength: MultiFn2<IShape, number, Group>;
+export declare const splitArcLength: SplitArcLengthFn;
 //# sourceMappingURL=split-arclength.d.ts.map

package/split-at.d.ts

@@ -1,6 +1,17 @@
 import type { Maybe } from "@thi.ng/api";
 import type { MultiFn2 } from "@thi.ng/defmulti";
-import type { IShape } from "@thi.ng/geom-api";
+import type { IShape, IShape2, IShape3 } from "./api.js";
+import { Arc } from "./api/arc.js";
+import type { Circle } from "./api/circle.js";
+/**
+ * Function overrides for {@link splitAt}.
+ */
+export type SplitAtFn = {
+    (shape: Arc, t: number): [Arc, Arc];
+    (shape: Circle, t: number): [Arc, Arc];
+    <T extends IShape2>(shape: T, t: number): T[];
+    <T extends IShape3>(shape: T, t: number): T[];
+} & MultiFn2<IShape, number, Maybe<IShape[]>>;
 /**
  * Splits given shape in 2 parts at normalized parametric position `t`.
  *
@@ -8,13 +19,18 @@ import type { IShape } from "@thi.ng/geom-api";
  * Currently only implemented for:
  *
  * - {@link Arc}
+ * - {@link Circle}
  * - {@link Cubic}
+ * - {@link Cubic3}
  * - {@link Line}
+ * - {@link Line3}
  * - {@link Polyline}
+ * - {@link Polyline3}
  * - {@link Quadratic}
+ * - {@link Quadratic3}
  *
  * @param shape
  * @param t
  */
-export declare const splitAt: MultiFn2<IShape, number, Maybe<IShape[]>>;
+export declare const splitAt: SplitAtFn;
 //# sourceMappingURL=split-at.d.ts.map

package/split-at.js

@@ -2,59 +2,91 @@ import { defmulti } from "@thi.ng/defmulti/defmulti";
 import { Sampler } from "@thi.ng/geom-resample/sampler";
 import { cubicSplitAt } from "@thi.ng/geom-splines/cubic-split";
 import { quadraticSplitAt } from "@thi.ng/geom-splines/quadratic-split";
+import { absDiff } from "@thi.ng/math/abs";
+import { PI, TAU } from "@thi.ng/math/api";
 import { fit01 } from "@thi.ng/math/fit";
-import { set } from "@thi.ng/vectors/set";
+import { set2 } from "@thi.ng/vectors/set";
 import { Arc } from "./api/arc.js";
-import { Cubic } from "./api/cubic.js";
-import { Line } from "./api/line.js";
-import { Polyline } from "./api/polyline.js";
-import { Quadratic } from "./api/quadratic.js";
 import { __copyAttribs } from "./internal/copy.js";
 import { __dispatch } from "./internal/dispatch.js";
 import { __pointArraysAsShapes } from "./internal/points-as-shape.js";
-import { __splitLine } from "./internal/split.js";
+import { __splitLineAt } from "./internal/split.js";
 const splitAt = defmulti(
   __dispatch,
-  {},
   {
-    arc: ($, t) => {
-      const theta = fit01(t, $.start, $.end);
+    cubic3: "cubic",
+    line3: "line",
+    polyline3: "polyline",
+    quadratic3: "quadratic"
+  },
+  {
+    arc: ({ pos, r, start, end, axis, cw, attribs }, t) => {
+      const theta = fit01(t, start, end);
       return [
         new Arc(
-          set([], $.pos),
-          set([], $.r),
-          $.axis,
-          $.start,
+          set2([], pos),
+          set2([], r),
+          axis,
+          start,
           theta,
-          $.xl,
-          $.cw,
-          __copyAttribs($)
+          absDiff(start, theta) >= PI,
+          cw,
+          __copyAttribs(attribs)
         ),
         new Arc(
-          set([], $.pos),
-          set([], $.r),
-          $.axis,
+          set2([], pos),
+          set2([], r),
+          axis,
           theta,
-          $.end,
-          $.xl,
-          $.cw,
-          __copyAttribs($)
+          end,
+          absDiff(theta, end) >= PI,
+          cw,
+          __copyAttribs(attribs)
         )
       ];
     },
-    cubic: ({ attribs, points }, t) => cubicSplitAt(points[0], points[1], points[2], points[3], t).map(
-      (pts) => new Cubic(pts, { ...attribs })
-    ),
-    line: ({ attribs, points }, t) => __splitLine(points[0], points[1], t).map(
-      (pts) => new Line(pts, { ...attribs })
+    circle: ({ pos, r, attribs }, t) => {
+      const theta = t * TAU;
+      return [
+        new Arc(
+          set2([], pos),
+          [r, r],
+          0,
+          0,
+          theta,
+          t >= 0.5,
+          true,
+          __copyAttribs(attribs)
+        ),
+        new Arc(
+          set2([], pos),
+          [r, r],
+          0,
+          theta,
+          TAU,
+          t < 0.5,
+          true,
+          __copyAttribs(attribs)
+        )
+      ];
+    },
+    cubic: ({ attribs, points: [a, b, c, d], constructor: ctor }, t) => __pointArraysAsShapes(
+      ctor,
+      cubicSplitAt(a, b, c, d, t),
+      attribs,
+      false
     ),
-    polyline: ($, t) => __pointArraysAsShapes(
-      Polyline,
-      new Sampler($.points).splitAt(t),
-      $.attribs
+    line: __splitLineAt,
+    polyline: ({ attribs, points, constructor: ctor }, t) => __pointArraysAsShapes(
+      ctor,
+      new Sampler(points).splitAt(t),
+      attribs
     ),
-    quadratic: ({ attribs, points }, t) => quadraticSplitAt(points[0], points[1], points[2], t).map(
-      (pts) => new Quadratic(pts, { ...attribs })
+    quadratic: ({ attribs, points: [a, b, c], constructor: ctor }, t) => __pointArraysAsShapes(
+      ctor,
+      quadraticSplitAt(a, b, c, t),
+      attribs,
+      false
     )
   }
 );

package/split-near.d.ts

@@ -1,7 +1,14 @@
 import type { Maybe } from "@thi.ng/api";
 import type { MultiFn2 } from "@thi.ng/defmulti";
-import type { IShape } from "@thi.ng/geom-api";
 import type { ReadonlyVec } from "@thi.ng/vectors";
+import type { IShape, IShape2, IShape3 } from "./api.js";
+/**
+ * Function overrides for {@link splitNearPoint}.
+ */
+export type SplitNearPointFn = {
+    <T extends IShape2>(shape: T, p: ReadonlyVec): T[];
+    <T extends IShape3>(shape: T, p: ReadonlyVec): T[];
+} & MultiFn2<IShape, ReadonlyVec, Maybe<IShape[]>>;
 /**
  * Similar to {@link splitAt}, but instead of taking a normalized parametric
  * split position, splits the given curve at the closest point to `p`.
@@ -10,12 +17,16 @@ import type { ReadonlyVec } from "@thi.ng/vectors";
  * Currently only implemented for:
  *
  * - {@link Cubic}
+ * - {@link Cubic3}
  * - {@link Line}
+ * - {@link Line3}
  * - {@link Polyline}
+ * - {@link Polyline3}
  * - {@link Quadratic}
+ * - {@link Quadratic3}
  *
  * @param shape - shape to operate on
  * @param p - split point
  */
-export declare const splitNearPoint: MultiFn2<IShape, ReadonlyVec, Maybe<IShape[]>>;
+export declare const splitNearPoint: SplitNearPointFn;
 //# sourceMappingURL=split-near.d.ts.map