@thi.ng/geom 7.0.1 → 8.0.1

package/aabb.d.ts

@@ -1,11 +1,36 @@
-import type { Attribs } from "@thi.ng/geom-api";
 import { type ReadonlyVec, type Vec } from "@thi.ng/vectors/api";
+import type { Attribs } from "./api.js";
 import { AABB } from "./api/aabb.js";
 import type { Sphere } from "./api/sphere.js";
+/**
+ * 3D shape factory. Creates a new axis-aligned bounding box, where `pos` is the
+ * min. position and `size` the extent in each dimension..
+ *
+ * @param pos
+ * @param size
+ * @param attribs
+ */
 export declare function aabb(pos: Vec, size: number | Vec, attribs?: Attribs): AABB;
 export declare function aabb(size: number | Vec, attribs?: Attribs): AABB;
 export declare function aabb(attribs?: Attribs): AABB;
+/**
+ * 3D shape factory. Creates a new axis-aligned bounding box between given
+ * `min`/`max` points.
+ *
+ * @param min
+ * @param max
+ * @param attribs
+ */
 export declare const aabbFromMinMax: (min: Vec, max: Vec, attribs?: Attribs) => AABB;
+/**
+ * Same as {@link aabbFromMinMax}, but enlarges box in all directions by
+ * `margin`.
+ *
+ * @param min
+ * @param max
+ * @param margin
+ * @param attribs
+ */
 export declare const aabbFromMinMaxWithMargin: (min: Vec, max: Vec, margin: number, attribs?: Attribs) => AABB;
 export declare const aabbFromCentroid: (centroid: Vec, size: Vec, attribs?: Attribs) => AABB;
 export declare const aabbWithCentroidAndMargin: (centroid: Vec, size: Vec, margin: number, attribs?: Attribs) => AABB;

package/api/aabb.d.ts

@@ -1,14 +1,15 @@
-import type { IToHiccup } from "@thi.ng/api";
-import type { AABBLike, Attribs } from "@thi.ng/geom-api";
 import { type Vec } from "@thi.ng/vectors/api";
-export declare class AABB implements AABBLike, IToHiccup {
+import type { AABBLike, Attribs, IHiccupShape3 } from "../api.js";
+export declare class AABB implements AABBLike, IHiccupShape3<AABB> {
     pos: Vec;
     attribs?: Attribs | undefined;
+    readonly type = "aabb";
+    readonly dim = 3;
     size: Vec;
     constructor(pos?: Vec, size?: number | Vec, attribs?: Attribs | undefined);
-    get type(): string;
     copy(): AABB;
     withAttribs(attribs: Attribs): AABB;
+    min(): Vec;
     max(): Vec;
     offset(offset: number): this;
     toHiccup(): (string | Vec | Attribs | undefined)[];

package/api/aabb.js

@@ -1,37 +1,40 @@
 import { add3 } from "@thi.ng/vectors/add";
 import { addN3 } from "@thi.ng/vectors/addn";
 import { ZERO3 } from "@thi.ng/vectors/api";
+import { maddN3 } from "@thi.ng/vectors/maddn";
 import { max3 } from "@thi.ng/vectors/max";
 import { set3 } from "@thi.ng/vectors/set";
-import { subN3 } from "@thi.ng/vectors/subn";
 import { __asVec } from "../internal/args.js";
 import { __copyAttribs } from "../internal/copy.js";
 class AABB {
   constructor(pos = [0, 0, 0], size = 1, attribs) {
     this.pos = pos;
     this.attribs = attribs;
-    this.size = __asVec(size, 3);
+    this.size = max3(null, __asVec(size, 3), ZERO3);
   }
+  type = "aabb";
+  dim = 3;
   size;
-  get type() {
-    return "aabb";
-  }
   copy() {
     return new AABB(
       set3([], this.pos),
       set3([], this.size),
-      __copyAttribs(this)
+      __copyAttribs(this.attribs)
     );
   }
   withAttribs(attribs) {
     return new AABB(this.pos, this.size, attribs);
   }
+  min() {
+    return set3([], this.pos);
+  }
   max() {
     return add3([], this.pos, this.size);
   }
   offset(offset) {
-    subN3(null, this.pos, offset);
+    const c = maddN3([], this.size, 0.5, this.pos);
     max3(null, addN3(null, this.size, offset * 2), ZERO3);
+    maddN3(this.pos, this.size, -0.5, c);
     return this;
   }
   toHiccup() {

package/api/apc.d.ts

@@ -1,12 +1,14 @@
-import type { IClear } from "@thi.ng/api";
-import type { Attribs, PCLike } from "@thi.ng/geom-api";
-import type { Vec } from "@thi.ng/vectors";
+import type { Fn, IClear } from "@thi.ng/api";
+import type { ReadonlyVec, Vec } from "@thi.ng/vectors";
+import type { Attribs, PCLike } from "../api.js";
 export declare abstract class APC implements IClear, PCLike {
     attribs?: Attribs | undefined;
     points: Vec[];
     constructor(points?: Iterable<Vec>, attribs?: Attribs | undefined);
     abstract get type(): number | string;
+    abstract get dim(): number;
     abstract copy(): APC;
+    abstract copyTransformed(fn: Fn<ReadonlyVec[], Vec[]>): APC;
     abstract withAttribs(attribs: Attribs): APC;
     [Symbol.iterator](): Generator<Vec, void, undefined>;
     clear(): void;

package/api/arc.d.ts

@@ -1,6 +1,6 @@
-import type { Attribs, IHiccupPathSegment, IHiccupShape } from "@thi.ng/geom-api";
 import type { Vec } from "@thi.ng/vectors";
-export declare class Arc implements IHiccupShape, IHiccupPathSegment {
+import type { Attribs, HiccupPathSegment, IHiccupPathSegment, IHiccupShape2 } from "../api.js";
+export declare class Arc implements IHiccupShape2<Arc>, IHiccupPathSegment {
     pos: Vec;
     r: Vec;
     axis: number;
@@ -9,14 +9,15 @@ export declare class Arc implements IHiccupShape, IHiccupPathSegment {
     xl: boolean;
     cw: boolean;
     attribs?: Attribs | undefined;
+    readonly type = "arc";
+    readonly dim = 2;
     constructor(pos: Vec, r: Vec, axis: number, start: number, end: number, xl?: boolean, cw?: boolean, attribs?: Attribs | undefined);
-    get type(): string;
     copy(): Arc;
     withAttribs(attribs: Attribs): Arc;
     equiv(o: any): boolean;
     pointAt(t: number, out?: Vec): Vec;
     pointAtTheta(theta: number, out?: Vec): Vec;
-    toHiccup(): (string | Attribs | (string | number | boolean | Vec)[][] | undefined)[];
-    toHiccupPathSegments(): (string | number | boolean | Vec)[][];
+    toHiccup(): (string | Attribs | (HiccupPathSegment | (string | Vec)[])[] | undefined)[];
+    toHiccupPathSegments(): HiccupPathSegment[];
 }
 //# sourceMappingURL=arc.d.ts.map

package/api/arc.js

@@ -16,9 +16,8 @@ class Arc {
     this.cw = cw;
     this.attribs = attribs;
   }
-  get type() {
-    return "arc";
-  }
+  type = "arc";
+  dim = 2;
   copy() {
     return new Arc(
       set([], this.pos),
@@ -28,7 +27,7 @@ class Arc {
       this.end,
       this.xl,
       this.cw,
-      __copyAttribs(this)
+      __copyAttribs(this.attribs)
     );
   }
   withAttribs(attribs) {

package/api/bpatch.d.ts

@@ -1,5 +1,6 @@
-import type { Attribs, IHiccupShape } from "@thi.ng/geom-api";
+import type { Fn } from "@thi.ng/api";
 import type { ReadonlyVec, Vec, VecPair } from "@thi.ng/vectors";
+import type { Attribs, IHiccupShape2 } from "../api.js";
 import { APC } from "./apc.js";
 /**
  * nD Cubic bezier patch defined by array of 4x4 control points in this
@@ -27,10 +28,12 @@ import { APC } from "./apc.js";
  * Ported from toxiclibs.
  *
  */
-export declare class BPatch extends APC implements IHiccupShape {
+export declare class BPatch extends APC implements IHiccupShape2<BPatch> {
+    readonly type = "bpatch";
+    readonly dim = 2;
     constructor(points: Iterable<Vec>, attribs?: Attribs);
-    get type(): string;
     copy(): BPatch;
+    copyTransformed(fn: Fn<ReadonlyVec[], Vec[]>): BPatch;
     withAttribs(attribs: Attribs): BPatch;
     edges(): VecPair[];
     unmapPoint(uv: ReadonlyVec, out?: Vec): Vec;

package/api/bpatch.js

@@ -3,16 +3,18 @@ import { __copyShape } from "../internal/copy.js";
 import { __ensureNumVerts } from "../internal/pclike.js";
 import { APC } from "./apc.js";
 class BPatch extends APC {
+  type = "bpatch";
+  dim = 2;
   constructor(points, attribs) {
     super(points, attribs);
     __ensureNumVerts(this.points.length, 16);
   }
-  get type() {
-    return "bpatch";
-  }
   copy() {
     return __copyShape(BPatch, this);
   }
+  copyTransformed(fn) {
+    return __copyShape(BPatch, this, fn(this.points));
+  }
   withAttribs(attribs) {
     return new BPatch(this.points, attribs);
   }

package/api/circle.d.ts

@@ -1,11 +1,12 @@
-import type { Attribs, IHiccupShape } from "@thi.ng/geom-api";
 import type { Vec } from "@thi.ng/vectors";
-export declare class Circle implements IHiccupShape {
+import type { Attribs, IHiccupShape2 } from "../api.js";
+export declare class Circle implements IHiccupShape2<Circle> {
     pos: Vec;
     r: number;
     attribs?: Attribs | undefined;
+    readonly type = "circle";
+    readonly dim = 2;
     constructor(pos?: Vec, r?: number, attribs?: Attribs | undefined);
-    get type(): string;
     copy(): Circle;
     withAttribs(attribs: Attribs): Circle;
     toHiccup(): (string | number | Vec | Attribs | undefined)[];

package/api/circle.js

@@ -1,4 +1,4 @@
-import { set } from "@thi.ng/vectors/set";
+import { set2 } from "@thi.ng/vectors/set";
 import { __copyAttribs } from "../internal/copy.js";
 class Circle {
   constructor(pos = [0, 0], r = 1, attribs) {
@@ -6,17 +6,20 @@ class Circle {
     this.r = r;
     this.attribs = attribs;
   }
-  get type() {
-    return "circle";
-  }
+  type = "circle";
+  dim = 2;
   copy() {
-    return new Circle(set([], this.pos), this.r, __copyAttribs(this));
+    return new Circle(
+      set2([], this.pos),
+      this.r,
+      __copyAttribs(this.attribs)
+    );
   }
   withAttribs(attribs) {
     return new Circle(this.pos, this.r, attribs);
   }
   toHiccup() {
-    return ["circle", this.attribs, this.pos, this.r];
+    return [this.type, this.attribs, this.pos, this.r];
   }
 }
 export {

package/api/complex-polygon.d.ts

@@ -1,13 +1,17 @@
-import type { Attribs, IHiccupShape } from "@thi.ng/geom-api";
+import type { Fn } from "@thi.ng/api";
+import type { Attribs, IHiccupShape2 } from "../api.js";
 import { Polygon } from "./polygon.js";
-export declare class ComplexPolygon implements IHiccupShape {
+export declare class ComplexPolygon implements IHiccupShape2<ComplexPolygon> {
     boundary: Polygon;
     attribs?: Attribs | undefined;
+    readonly type = "complexpoly";
+    readonly dim = 2;
     children: Polygon[];
     constructor(boundary?: Polygon, children?: Iterable<Polygon>, attribs?: Attribs | undefined);
-    get type(): string;
+    [Symbol.iterator](): Generator<Polygon, void, undefined>;
     addChild(poly: Polygon): void;
     copy(): ComplexPolygon;
+    copyTransformed(fn: Fn<Polygon, Polygon>): ComplexPolygon;
     withAttribs(attribs: Attribs): ComplexPolygon;
     toHiccup(): (string | any[] | Attribs | undefined)[];
 }

package/api/complex-polygon.js

@@ -7,9 +7,12 @@ class ComplexPolygon {
     this.attribs = attribs;
     this.children = children ? ensureArray(children) : [];
   }
+  type = "complexpoly";
+  dim = 2;
   children;
-  get type() {
-    return "complexpoly";
+  *[Symbol.iterator]() {
+    yield this.boundary;
+    yield* this.children;
   }
   addChild(poly) {
     this.children.push(poly);
@@ -18,7 +21,14 @@ class ComplexPolygon {
     return new ComplexPolygon(
       this.boundary.copy(),
       this.children.map((h) => h.copy()),
-      __copyAttribs(this)
+      __copyAttribs(this.attribs)
+    );
+  }
+  copyTransformed(fn) {
+    return new ComplexPolygon(
+      fn(this.boundary),
+      this.children.map((child) => fn(child)),
+      __copyAttribs(this.attribs)
     );
   }
   withAttribs(attribs) {
@@ -32,7 +42,7 @@ class ComplexPolygon {
       for (let i = 1, n = points.length; i < n; i++) {
         segments.push(["L", points[i]]);
       }
-      segments.push(["Z"]);
+      segments.push(["z"]);
     };
     $hiccupSegments(this.boundary);
     for (let c of this.children) $hiccupSegments(c);

package/api/cubic.d.ts

@@ -1,12 +1,15 @@
-import type { Attribs, IHiccupPathSegment } from "@thi.ng/geom-api";
-import type { Vec } from "@thi.ng/vectors";
+import type { Fn } from "@thi.ng/api";
+import type { ReadonlyVec, Vec } from "@thi.ng/vectors";
+import type { Attribs, HiccupPathSegment, IHiccupPathSegment, IHiccupShape2 } from "../api.js";
 import { APC } from "./apc.js";
-export declare class Cubic extends APC implements IHiccupPathSegment {
+export declare class Cubic extends APC implements IHiccupShape2<Cubic>, IHiccupPathSegment {
+    readonly type = "cubic";
+    readonly dim = 2;
     constructor(points: Iterable<Vec>, attribs?: Attribs);
-    get type(): string;
     copy(): Cubic;
+    copyTransformed(fn: Fn<ReadonlyVec[], Vec[]>): Cubic;
     withAttribs(attribs: Attribs): Cubic;
     toHiccup(): (string | Attribs | (string | Vec)[][] | undefined)[];
-    toHiccupPathSegments(): (string | Vec)[][];
+    toHiccupPathSegments(): HiccupPathSegment[];
 }
 //# sourceMappingURL=cubic.d.ts.map

package/api/cubic.js

@@ -2,29 +2,35 @@ import { __copyShape } from "../internal/copy.js";
 import { __ensureNumVerts } from "../internal/pclike.js";
 import { APC } from "./apc.js";
 class Cubic extends APC {
+  type = "cubic";
+  dim = 2;
   constructor(points, attribs) {
     super(points, attribs);
     __ensureNumVerts(this.points.length, 4);
   }
-  get type() {
-    return "cubic";
-  }
   copy() {
     return __copyShape(Cubic, this);
   }
+  copyTransformed(fn) {
+    return __copyShape(Cubic, this, fn(this.points));
+  }
   withAttribs(attribs) {
     return new Cubic(this.points, attribs);
   }
   toHiccup() {
+    const [a, b, c, d] = this.points;
     return [
       "path",
       this.attribs,
-      [["M", this.points[0]], ...this.toHiccupPathSegments()]
+      [
+        ["M", a],
+        ["C", b, c, d]
+      ]
     ];
   }
   toHiccupPathSegments() {
-    const pts = this.points;
-    return [["C", pts[1], pts[2], pts[3]]];
+    const [_, b, c, d] = this.points;
+    return [["C", b, c, d]];
   }
 }
 export {

package/api/cubic3.d.ts

@@ -0,0 +1,15 @@
+import type { Fn } from "@thi.ng/api";
+import type { ReadonlyVec, Vec } from "@thi.ng/vectors";
+import type { Attribs, HiccupPathSegment, IHiccupPathSegment, IHiccupShape3 } from "../api.js";
+import { APC } from "./apc.js";
+export declare class Cubic3 extends APC implements IHiccupShape3<Cubic3>, IHiccupPathSegment {
+    readonly type = "cubic3";
+    readonly dim = 3;
+    constructor(points: Iterable<Vec>, attribs?: Attribs);
+    copy(): Cubic3;
+    copyTransformed(fn: Fn<ReadonlyVec[], Vec[]>): Cubic3;
+    withAttribs(attribs: Attribs): Cubic3;
+    toHiccup(): (string | Attribs | (string | Vec)[][] | undefined)[];
+    toHiccupPathSegments(): HiccupPathSegment[];
+}
+//# sourceMappingURL=cubic3.d.ts.map

package/api/cubic3.js

@@ -0,0 +1,38 @@
+import { __copyShape } from "../internal/copy.js";
+import { __ensureNumVerts } from "../internal/pclike.js";
+import { APC } from "./apc.js";
+class Cubic3 extends APC {
+  type = "cubic3";
+  dim = 3;
+  constructor(points, attribs) {
+    super(points, attribs);
+    __ensureNumVerts(this.points.length, 4);
+  }
+  copy() {
+    return __copyShape(Cubic3, this);
+  }
+  copyTransformed(fn) {
+    return __copyShape(Cubic3, this, fn(this.points));
+  }
+  withAttribs(attribs) {
+    return new Cubic3(this.points, attribs);
+  }
+  toHiccup() {
+    const [a, b, c, d] = this.points;
+    return [
+      "path3",
+      this.attribs,
+      [
+        ["M", a],
+        ["C", b, c, d]
+      ]
+    ];
+  }
+  toHiccupPathSegments() {
+    const [_, b, c, d] = this.points;
+    return [["C", b, c, d]];
+  }
+}
+export {
+  Cubic3
+};

package/api/ellipse.d.ts

@@ -1,11 +1,12 @@
-import type { Attribs, IHiccupShape } from "@thi.ng/geom-api";
 import type { Vec } from "@thi.ng/vectors";
-export declare class Ellipse implements IHiccupShape {
+import type { Attribs, IHiccupShape2 } from "../api.js";
+export declare class Ellipse implements IHiccupShape2<Ellipse> {
     pos: Vec;
     attribs?: Attribs | undefined;
+    readonly type = "ellipse";
+    readonly dim = 2;
     r: Vec;
     constructor(pos?: Vec, r?: number | Vec, attribs?: Attribs | undefined);
-    get type(): string;
     copy(): Ellipse;
     withAttribs(attribs: Attribs): Ellipse;
     toHiccup(): (string | Vec | Attribs | undefined)[];

package/api/ellipse.js

@@ -1,4 +1,4 @@
-import { set } from "@thi.ng/vectors/set";
+import { set2 } from "@thi.ng/vectors/set";
 import { __asVec } from "../internal/args.js";
 import { __copyAttribs } from "../internal/copy.js";
 class Ellipse {
@@ -7,22 +7,21 @@ class Ellipse {
     this.attribs = attribs;
     this.r = __asVec(r);
   }
+  type = "ellipse";
+  dim = 2;
   r;
-  get type() {
-    return "ellipse";
-  }
   copy() {
     return new Ellipse(
-      set([], this.pos),
-      set([], this.r),
-      __copyAttribs(this)
+      set2([], this.pos),
+      set2([], this.r),
+      __copyAttribs(this.attribs)
     );
   }
   withAttribs(attribs) {
     return new Ellipse(this.pos, this.r, attribs);
   }
   toHiccup() {
-    return ["ellipse", this.attribs, this.pos, this.r];
+    return [this.type, this.attribs, this.pos, this.r];
   }
 }
 export {

package/api/extra.d.ts

@@ -0,0 +1,15 @@
+import type { IHiccupShape2 } from "../api.js";
+/**
+ * Dummy shape container for arbitrary hiccup elements. See {@link extra} for
+ * more details.
+ */
+export declare class Extra implements IHiccupShape2<Extra> {
+    body: any[];
+    readonly type = "extra";
+    readonly dim = 2;
+    constructor(body: any[]);
+    copy(): Extra;
+    withAttribs(): Extra;
+    toHiccup(): any[];
+}
+//# sourceMappingURL=extra.d.ts.map

package/api/extra.js

@@ -0,0 +1,19 @@
+class Extra {
+  constructor(body) {
+    this.body = body;
+  }
+  type = "extra";
+  dim = 2;
+  copy() {
+    return new Extra(this.body);
+  }
+  withAttribs() {
+    return this.copy();
+  }
+  toHiccup() {
+    return this.body;
+  }
+}
+export {
+  Extra
+};

package/api/group.d.ts

@@ -1,27 +1,28 @@
-import type { Fn, IClear } from "@thi.ng/api";
-import type { Attribs, IHiccupShape } from "@thi.ng/geom-api";
+import type { FnU, IClear } from "@thi.ng/api";
+import type { Attribs, GroupAttribs, IHiccupShape2 } from "../api.js";
 /**
- * Geometry/shape group container for other {@link IHiccupShape}s, incl. nested
+ * Geometry/shape group container for other {@link IHiccupShape2}s, incl. nested
  * groups.
  */
-export declare class Group implements IClear, IHiccupShape {
-    attribs?: Attribs | undefined;
-    children: IHiccupShape[];
-    constructor(attribs?: Attribs | undefined, children?: Iterable<IHiccupShape>);
-    get type(): string;
-    [Symbol.iterator](): Generator<IHiccupShape, void, undefined>;
+export declare class Group implements IClear, IHiccupShape2<Group> {
+    attribs?: GroupAttribs | undefined;
+    readonly type = "group";
+    readonly dim = 2;
+    children: IHiccupShape2[];
+    constructor(attribs?: GroupAttribs | undefined, children?: Iterable<IHiccupShape2>);
+    [Symbol.iterator](): Generator<IHiccupShape2, void, undefined>;
     /**
      * Appends given `shapes` to this {@link Group.children} array.
      *
      * @param shapes
      */
-    add(...shapes: IHiccupShape[]): this;
+    add(...shapes: IHiccupShape2[]): this;
     /**
      * Removes all children from the group.
      */
     clear(): void;
     copy(): Group;
-    copyTransformed(fn: Fn<IHiccupShape, IHiccupShape>): Group;
+    copyTransformed(fn: FnU<IHiccupShape2>): Group;
     withAttribs(attribs: Attribs): Group;
     equiv(o: any): boolean;
     toHiccup(): any[];

package/api/group.js

@@ -6,10 +6,9 @@ class Group {
     this.attribs = attribs;
     this.children = children ? ensureArray(children) : [];
   }
+  type = "group";
+  dim = 2;
   children;
-  get type() {
-    return "group";
-  }
   *[Symbol.iterator]() {
     yield* this.children;
   }
@@ -32,13 +31,13 @@ class Group {
     return this.copyTransformed((c) => c.copy());
   }
   copyTransformed(fn) {
-    return new Group(__copyAttribs(this), this.children.map(fn));
+    return new Group(__copyAttribs(this.attribs), this.children.map(fn));
   }
   withAttribs(attribs) {
     return new Group(attribs, this.children);
   }
   equiv(o) {
-    return o instanceof Group && equiv(this.children, o.children);
+    return o instanceof Group && equiv(this.attribs, o.attribs) && equiv(this.children, o.children);
   }
   toHiccup() {
     return ["g", this.attribs, ...this.children.map((x) => x.toHiccup())];

package/api/group3.d.ts

@@ -0,0 +1,30 @@
+import type { FnU, IClear } from "@thi.ng/api";
+import type { Attribs, IHiccupShape3 } from "../api.js";
+/**
+ * Geometry/shape group container for other {@link IHiccupShape3}s, incl. nested
+ * groups.
+ */
+export declare class Group3 implements IClear, IHiccupShape3<Group3> {
+    attribs?: Attribs | undefined;
+    readonly type = "group3";
+    readonly dim = 3;
+    children: IHiccupShape3[];
+    constructor(attribs?: Attribs | undefined, children?: Iterable<IHiccupShape3>);
+    [Symbol.iterator](): Generator<IHiccupShape3, void, undefined>;
+    /**
+     * Appends given `shapes` to this {@link Group.children} array.
+     *
+     * @param shapes
+     */
+    add(...shapes: IHiccupShape3[]): this;
+    /**
+     * Removes all children from the group.
+     */
+    clear(): void;
+    copy(): Group3;
+    copyTransformed(fn: FnU<IHiccupShape3>): Group3;
+    withAttribs(attribs: Attribs): Group3;
+    equiv(o: any): boolean;
+    toHiccup(): any[];
+}
+//# sourceMappingURL=group3.d.ts.map