@thi.ng/geom 6.1.9 → 7.0.1

package/area.js

@@ -14,9 +14,12 @@ const area = defmulti(
       ($) => 0.5 * Math.abs($.start - $.end) * $.r[0] * $.r[1]
     ),
     circle: ($) => PI * $.r ** 2,
+    complexpoly: ($, signed) => area($.boundary, signed) - $.children.reduce((acc, c) => acc + area(c, signed), 0),
     ellipse: ($) => PI * $.r[0] * $.r[1],
     group: ({ children }) => children.reduce((sum, $) => sum + area($, false), 0),
-    path: ($) => $.closed ? area(asPolygon($)) : 0,
+    path: ($, signed) => {
+      return $.closed ? asPolygon($).reduce((acc, p) => acc + area(p, signed), 0) : 0;
+    },
     plane: () => Infinity,
     poly: ($, signed) => {
       const area2 = polyArea2($.points);

package/as-cubic.d.ts

@@ -10,6 +10,7 @@ import { Cubic } from "./api/cubic.js";
  *
  * - {@link Arc}
  * - {@link Circle}
+ * - {@link ComplexPolygon}
  * - {@link Cubic}
  * - {@link Ellipse}
  * - {@link Group}
@@ -27,6 +28,7 @@ import { Cubic } from "./api/cubic.js";
  * for more details):
  *
  * - {@link Group} (only used for eligible children)
+ * - {@link ComplexPolygon}
  * - {@link Polygon}
  * - {@link Polyline}
  * - {@link Quad}

package/as-cubic.js

@@ -8,6 +8,8 @@ import {
   openCubicFromControlPoints
 } from "@thi.ng/geom-splines/cubic-from-controlpoints";
 import { TAU } from "@thi.ng/math/api";
+import { concat } from "@thi.ng/transducers/concat";
+import { flatten1 } from "@thi.ng/transducers/flatten1";
 import { mapcat } from "@thi.ng/transducers/mapcat";
 import { Cubic } from "./api/cubic.js";
 import { arc } from "./arc.js";
@@ -25,6 +27,9 @@ const asCubic = defmulti(
   {
     arc: cubicFromArc,
     circle: ($) => asCubic(arc($.pos, $.r, 0, 0, TAU, true, true)),
+    complexpoly: ($, opts = {}) => [
+      ...mapcat((x) => asCubic(x, opts), [$.boundary, ...$.children])
+    ],
     cubic: ($) => [$],
     group: ($, opts) => [
       ...mapcat((x) => asCubic(x, opts), $.children)
@@ -33,7 +38,10 @@ const asCubic = defmulti(
       cubicFromLine(points[0], points[1], { ...attribs })
     ],
     path: ($) => [
-      ...mapcat((s) => s.geo ? asCubic(s.geo) : null, $.segments)
+      ...mapcat(
+        (segment) => segment.geo ? asCubic(segment.geo) : null,
+        concat($.segments, flatten1($.subPaths))
+      )
     ],
     poly: ($, opts = {}) => __polyCubic(
       $,
@@ -50,7 +58,7 @@ const asCubic = defmulti(
     quadratic: ({ attribs, points }) => [
       cubicFromQuadratic(points[0], points[1], points[2], { ...attribs })
     ],
-    rect: ($, opts) => asCubic(asPolygon($), opts)
+    rect: ($, opts) => asCubic(asPolygon($)[0], opts)
   }
 );
 const __polyCubic = ($, opts, breakPoints, controlPoints) => {

package/as-path.d.ts

@@ -1,10 +1,26 @@
-import type { Attribs, IShape } from "@thi.ng/geom-api";
+import type { Maybe } from "@thi.ng/api";
+import type { MultiFn2O } from "@thi.ng/defmulti";
+import type { Attribs, CubicOpts, IShape } from "@thi.ng/geom-api";
+import { Path } from "./api/path.js";
+export interface AsPathOpts extends CubicOpts {
+    /**
+     * If true (default: false), creates path consisting of linear segments
+     * only.
+     */
+    linear: boolean;
+}
 /**
- * Converts given shape into a {@link Path} (via {@link asCubic} and
+ * Converts given shape into a {@link Path} (by default via {@link asCubic} and
  * {@link pathFromCubics}).
  *
+ * @remarks
+ * If {@link AsPathOpts.linear} is enabled the shape will be converted into a
+ * path consisting only of linear segments (NOT cubic beziers). As an interim
+ * step this will involve a conversion via {@link asPolygon} or
+ * {@link asPolyline} with default opts.
+ *
  * @param src
  * @param attribs
  */
-export declare const asPath: (src: IShape, attribs?: Attribs) => import("./index.js").Path;
+export declare const asPath: ((shape: IShape, opts?: Partial<AsPathOpts>, attribs?: Attribs) => Path) & MultiFn2O<IShape, Maybe<Partial<AsPathOpts>>, Attribs, Path>;
 //# sourceMappingURL=as-path.d.ts.map

package/as-path.js

@@ -1,7 +1,60 @@
+import { DEFAULT, defmulti } from "@thi.ng/defmulti/defmulti";
+import { copy } from "@thi.ng/vectors/copy";
+import { Line } from "./api/line.js";
+import { Path } from "./api/path.js";
 import { asCubic } from "./as-cubic.js";
+import { asPolygon } from "./as-polygon.js";
+import { asPolyline } from "./as-polyline.js";
 import { __copyAttribs } from "./internal/copy.js";
+import { __dispatch } from "./internal/dispatch.js";
 import { pathFromCubics } from "./path.js";
-const asPath = (src, attribs) => pathFromCubics(asCubic(src), attribs || __copyAttribs(src));
+const asPath = defmulti(
+  __dispatch,
+  {
+    line: "polyline",
+    quad: "poly",
+    tri: "poly"
+  },
+  {
+    [DEFAULT]: (src, opts, attribs) => opts?.linear ? asPath(asPolygon(src)[0], opts, attribs || __copyAttribs(src)) : __defaultImpl(src, opts, attribs),
+    arc: ($, opts, attribs) => opts?.linear ? asPath(asPolyline($)[0], opts, attribs || __copyAttribs($)) : __defaultImpl($, opts, attribs),
+    complexpoly: ($, opts, attribs) => {
+      attribs = attribs || __copyAttribs($);
+      if (opts?.linear) {
+        return __linearPath(
+          $.boundary,
+          $.children.map((c) => __lineSegments(c.points, true)),
+          attribs,
+          true
+        );
+      }
+      const res = pathFromCubics(asCubic($.boundary, opts), attribs);
+      for (let child of $.children) {
+        res.addSubPaths(pathFromCubics(asCubic(child, opts)).segments);
+      }
+      return res;
+    },
+    poly: ($, opts, attribs) => opts?.linear ? __linearPath($, [], attribs, true) : __defaultImpl($, opts, attribs),
+    polyline: ($, opts, attribs) => opts?.linear ? __linearPath($, [], attribs, false) : __defaultImpl($, opts, attribs)
+  }
+);
+const __defaultImpl = (src, opts, attribs) => pathFromCubics(asCubic(src, opts), attribs || __copyAttribs(src));
+const __lineSegments = (points, closed) => {
+  if (!points.length) return [];
+  const segments = [{ type: "m", point: copy(points[0]) }];
+  for (let i = 1, n = points.length; i < n; i++)
+    segments.push({
+      type: "l",
+      geo: new Line([copy(points[i - 1]), copy(points[i])])
+    });
+  if (closed) segments.push({ type: "z" });
+  return segments;
+};
+const __linearPath = (shape, subPaths, attribs, closed = false) => new Path(
+  __lineSegments(shape.points, closed),
+  subPaths,
+  attribs || __copyAttribs(shape)
+);
 export {
   asPath
 };

package/as-polygon.d.ts

@@ -2,19 +2,21 @@ import type { MultiFn1O } from "@thi.ng/defmulti";
 import type { IShape, SamplingOpts } from "@thi.ng/geom-api";
 import { Polygon } from "./api/polygon.js";
 /**
- * Converts given shape into a {@link Polygon}, optionally using provided
+ * Converts given shape into an array of {@link Polygon}s, optionally using
+ * provided
  * [`SamplingOpts`](https://docs.thi.ng/umbrella/geom-api/interfaces/SamplingOpts.html)
  * or number of target vertices.
  *
  * @remarks
- * If the shape has a `__samples` attribute, it will be removed in the result to
- * avoid recursive application.
+ * If the input shape has a `__samples` attribute, it will be removed in the
+ * results polys to avoid recursive application.
  *
  * Currently implemented for:
  *
  * - {@link Circle}
+ * - {@link ComplexPolygon}
  * - {@link Ellipse}
- * - {@link Line}
+ * - {@link Line}  (will be closed)
  * - {@link Path}
  * - {@link Polygon}
  * - {@link Polyline} (will be closed)
@@ -25,5 +27,5 @@ import { Polygon } from "./api/polygon.js";
  * @param shape
  * @param opts
  */
-export declare const asPolygon: MultiFn1O<IShape, number | Partial<SamplingOpts>, Polygon>;
+export declare const asPolygon: MultiFn1O<IShape, number | Partial<SamplingOpts>, Polygon[]>;
 //# sourceMappingURL=as-polygon.d.ts.map

package/as-polygon.js

@@ -1,4 +1,5 @@
 import { defmulti } from "@thi.ng/defmulti/defmulti";
+import { Path } from "./api/path.js";
 import { Polygon } from "./api/polygon.js";
 import { __copyAttribsNoSamples as __attribs } from "./internal/copy.js";
 import { __dispatch } from "./internal/dispatch.js";
@@ -17,7 +18,19 @@ const asPolygon = defmulti(
     tri: "points"
   },
   {
-    points: ($, opts) => new Polygon(vertices($, opts), __attribs($))
+    complexpoly: ($, opts) => [$.boundary, ...$.children].map(
+      (x) => new Polygon(vertices(x, opts), __attribs($))
+    ),
+    path: ($, opts) => {
+      const tmp = new Path();
+      return [$.segments, ...$.subPaths].map((segments) => {
+        tmp.segments = segments;
+        return new Polygon(vertices(tmp, opts), __attribs($));
+      });
+    },
+    points: ($, opts) => [
+      new Polygon(vertices($, opts), __attribs($))
+    ]
   }
 );
 export {

package/as-polyline.d.ts

@@ -2,18 +2,20 @@ import type { MultiFn1O } from "@thi.ng/defmulti";
 import type { IShape, SamplingOpts } from "@thi.ng/geom-api";
 import { Polyline } from "./api/polyline.js";
 /**
- * Converts given shape into a {@link Polyline}, optionally using provided
+ * Converts given shape into an array of {@link Polyline}s, optionally using
+ * provided
  * [`SamplingOpts`](https://docs.thi.ng/umbrella/geom-api/interfaces/SamplingOpts.html)
  * or number of target vertices.
  *
  * @remarks
- * If the shape has a `__samples` attribute, it will be removed in the result to
- * avoid recursive application.
+ * If the shape has a `__samples` attribute, it will be removed in the results
+ * to avoid recursive application.
  *
  * Currently implemented for:
  *
  * - {@link Arc}
  * - {@link Circle}
+ * - {@link ComplexPolygon}
  * - {@link Cubic}
  * - {@link Ellipse}
  * - {@link Line}
@@ -28,5 +30,5 @@ import { Polyline } from "./api/polyline.js";
  * @param shape
  * @param opts
  */
-export declare const asPolyline: MultiFn1O<IShape, number | Partial<SamplingOpts>, Polyline>;
+export declare const asPolyline: MultiFn1O<IShape, number | Partial<SamplingOpts>, Polyline[]>;
 //# sourceMappingURL=as-polyline.d.ts.map

package/as-polyline.js

@@ -1,5 +1,8 @@
+import { peek } from "@thi.ng/arrays/peek";
 import { defmulti } from "@thi.ng/defmulti/defmulti";
+import { mapcat } from "@thi.ng/transducers/mapcat";
 import { set } from "@thi.ng/vectors/set";
+import { Path } from "./api/path.js";
 import { Polyline } from "./api/polyline.js";
 import { __copyAttribsNoSamples as __attribs } from "./internal/copy.js";
 import { __dispatch } from "./internal/dispatch.js";
@@ -19,16 +22,27 @@ const asPolyline = defmulti(
     tri: "poly"
   },
   {
-    points: ($, opts) => new Polyline(vertices($, opts), __attribs($)),
+    complexpoly: ($, opts) => [
+      ...asPolyline($.boundary, opts),
+      ...mapcat((child) => asPolyline(child, opts), $.children)
+    ],
+    group: ($, opts) => [
+      ...mapcat((child) => asPolyline(child, opts), $.children)
+    ],
+    points: ($, opts) => [new Polyline(vertices($, opts), __attribs($))],
     path: ($, opts) => {
-      const pts = vertices($, opts);
-      $.closed && pts.push(set([], pts[0]));
-      return new Polyline(pts, __attribs($));
+      const tmp = new Path();
+      return [$.segments, ...$.subPaths].map((segments) => {
+        tmp.segments = segments;
+        const pts = vertices(tmp, opts);
+        peek(segments).type === "z" && pts.push(set([], pts[0]));
+        return new Polyline(pts, __attribs($));
+      });
     },
     poly: ($, opts) => {
       const pts = vertices($, opts);
       pts.push(set([], pts[0]));
-      return new Polyline(pts, __attribs($));
+      return [new Polyline(pts, __attribs($))];
     }
   }
 );

package/bounds.js

@@ -7,6 +7,7 @@ import { comp } from "@thi.ng/transducers/comp";
 import { filter } from "@thi.ng/transducers/filter";
 import { iterator1 } from "@thi.ng/transducers/iterator";
 import { map } from "@thi.ng/transducers/map";
+import { mapcat } from "@thi.ng/transducers/mapcat";
 import { addN2 } from "@thi.ng/vectors/addn";
 import { max } from "@thi.ng/vectors/max";
 import { min } from "@thi.ng/vectors/min";
@@ -38,6 +39,10 @@ const bounds = defmulti(
       subN2([], $.pos, $.r + margin),
       mulN2(null, [2, 2], $.r + margin)
     ),
+    complexpoly: ($, margin = 0) => {
+      const res = __collBounds([$.boundary, ...$.children], bounds);
+      return res ? new Rect(...res).offset(margin) : void 0;
+    },
     cubic: ({ points }, margin = 0) => rectFromMinMaxWithMargin(
       ...cubicBounds(points[0], points[1], points[2], points[3]),
       margin
@@ -52,15 +57,17 @@ const bounds = defmulti(
     },
     line: ({ points: [a, b] }, margin = 0) => rectFromMinMaxWithMargin(min([], a, b), max([], a, b), margin),
     path: (path, margin = 0) => {
+      const $segmentGeo = (segments) => iterator1(
+        comp(
+          map((s) => s.geo),
+          filter((s) => !!s)
+        ),
+        segments
+      );
       const b = __collBounds(
         [
-          ...iterator1(
-            comp(
-              map((s) => s.geo),
-              filter((s) => !!s)
-            ),
-            path.segments
-          )
+          ...$segmentGeo(path.segments),
+          ...mapcat($segmentGeo, path.subPaths)
         ],
         bounds
       );

package/centroid.d.ts

@@ -3,8 +3,8 @@ import type { MultiFn1O } from "@thi.ng/defmulti";
 import type { IShape } from "@thi.ng/geom-api";
 import type { Vec } from "@thi.ng/vectors";
 /**
- * Computes centroid of given shape, writes result in optionally provided output
- * vector (or creates new one if omitted).
+ * Computes (possibly weighted) centroid of given shape, writes result in
+ * optionally provided output vector (or creates new one if omitted).
  *
  * @remarks
  * Currently implemented for:
@@ -13,6 +13,7 @@ import type { Vec } from "@thi.ng/vectors";
  * - {@link Arc}
  * - {@link BPatch}
  * - {@link Circle}
+ * - {@link ComplexPolygon}
  * - {@link Cubic}
  * - {@link Ellipse}
  * - {@link Group}

package/centroid.js

@@ -1,5 +1,8 @@
 import { defmulti } from "@thi.ng/defmulti/defmulti";
-import { centerOfWeight2 } from "@thi.ng/geom-poly-utils/center-of-weight";
+import {
+  centerOfWeight2,
+  complexCenterOfWeight2
+} from "@thi.ng/geom-poly-utils/center-of-weight";
 import { centroid as _centroid } from "@thi.ng/geom-poly-utils/centroid";
 import { add } from "@thi.ng/vectors/add";
 import { addmN } from "@thi.ng/vectors/addmn";
@@ -17,6 +20,7 @@ const centroid = defmulti(
     bpatch: "points",
     ellipse: "circle",
     line3: "line",
+    path: "group",
     points3: "points",
     polyline: "points",
     quad: "poly",
@@ -26,6 +30,11 @@ const centroid = defmulti(
   },
   {
     circle: ($, out) => set(out || [], $.pos),
+    complexpoly: ($, out) => complexCenterOfWeight2(
+      $.boundary.points,
+      $.children.map((c) => c.points),
+      out
+    ),
     group: ($, out) => {
       const b = bounds($);
       return b ? centroid(b, out) : void 0;

package/classify-point.d.ts

@@ -10,7 +10,7 @@ import type { ReadonlyVec } from "@thi.ng/vectors";
  * Currently only implemented for:
  *
  * - {@link Circle}
- * - {@link Plane}
+ * - {@link Plane} (-1 = below, +1 = above)
  * - {@link Sphere}
  * - {@link Triangle}
  *
@@ -18,7 +18,10 @@ import type { ReadonlyVec } from "@thi.ng/vectors";
  * more comprehensive feature set (incl. support for more shapes) to perform
  * similar checks as this function.
  *
- * Also see {@link pointInside}.
+ * Also see:
+ * - {@link closestPoint}
+ * - {@link pointInside}
+ * - {@link proximity}
  *
  * @param shape
  * @param p

package/clip-convex.d.ts

@@ -3,9 +3,10 @@ import type { MultiFn2 } from "@thi.ng/defmulti";
 import type { IShape } from "@thi.ng/geom-api";
 import type { ReadonlyVec } from "@thi.ng/vectors";
 /**
- * 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.
+ * Takes a shape and a boundary (both convex), then uses the Sutherland-Hodgeman
+ * algorithm to compute a clipped version of the shape (against the boundary)
+ * and returns resulting clipped shape or `undefined` if there're no remaining
+ * result vertices (i.e. if the original shape was clipped entirely).
  *
  * @remarks
  * Internally uses
@@ -13,6 +14,24 @@ import type { ReadonlyVec } from "@thi.ng/vectors";
  * For groups, calls itself for each child shape individually and returns a new
  * group of results (if any).
  *
+ * For {@link ComplexPolygon}s, children are only processed if the main boundary
+ * hasn't been completely clipped. Similarly for paths, where sub-paths are only
+ * processed if the main path has remaining vertices. Paths are
+ * sampled/converted to polygons and are only processed if the main path is
+ * {@link Path.closed}.
+ *
+ * Currently implemented for:
+ *
+ * - {@link Circle}
+ * - {@link ComplexPolygon}
+ * - {@link Ellipse}
+ * - {@link Group}
+ * - {@link Line}
+ * - {@link Path}
+ * - {@link Polygon}
+ * - {@link Quad}
+ * - {@link Triangle}
+ *
  * @param shape
  * @param boundary
  */

package/clip-convex.js

@@ -2,29 +2,46 @@ import { defmulti } from "@thi.ng/defmulti/defmulti";
 import { clipLineSegmentPoly } from "@thi.ng/geom-clip-line/clip-poly";
 import { sutherlandHodgeman } from "@thi.ng/geom-clip-poly";
 import { centroid } from "@thi.ng/geom-poly-utils/centroid";
+import { ComplexPolygon } from "./api/complex-polygon.js";
 import { Group } from "./api/group.js";
 import { Line } from "./api/line.js";
+import { Path } from "./api/path.js";
 import { Polygon } from "./api/polygon.js";
 import { __copyAttribs } from "./internal/copy.js";
 import { __dispatch } from "./internal/dispatch.js";
 import { ensureVertices, vertices } from "./vertices.js";
+const __clipVertices = ($, boundary) => {
+  boundary = ensureVertices(boundary);
+  const pts = sutherlandHodgeman(vertices($), boundary, centroid(boundary));
+  return pts.length ? new Polygon(pts, __copyAttribs($)) : void 0;
+};
 const clipConvex = defmulti(
   __dispatch,
   {
     circle: "rect",
     ellipse: "rect",
-    path: "rect",
     quad: "poly",
     tri: "poly"
   },
   {
+    complexpoly: ($, boundary) => {
+      boundary = ensureVertices(boundary);
+      const c = centroid(boundary);
+      let clipped = sutherlandHodgeman($.boundary.points, boundary, c);
+      if (!clipped.length) return void 0;
+      const res = [new Polygon(clipped)];
+      for (let child of $.children) {
+        clipped = sutherlandHodgeman(child.points, boundary, c);
+        if (clipped.length) res.push(new Polygon(clipped));
+      }
+      return new ComplexPolygon(res[0], res.slice(1), __copyAttribs($));
+    },
     group: ({ children, attribs }, boundary) => {
       boundary = ensureVertices(boundary);
       const clipped = [];
       for (let c of children) {
         const res = clipConvex(c, boundary);
-        if (res)
-          clipped.push(res);
+        if (res) clipped.push(res);
       }
       return clipped.length ? new Group({ ...attribs }, clipped) : void 0;
     },
@@ -36,6 +53,24 @@ const clipConvex = defmulti(
       );
       return segments && segments.length ? new Line(segments[0], __copyAttribs($)) : void 0;
     },
+    path: ($, boundary) => {
+      if ($.closed) return void 0;
+      boundary = ensureVertices(boundary);
+      let clipped = __clipVertices($, boundary);
+      if (!clipped) return void 0;
+      const res = new ComplexPolygon(clipped, [], __copyAttribs($));
+      for (let sub of $.subPaths) {
+        clipped = __clipVertices(
+          new Path(sub, [], __copyAttribs($)),
+          boundary
+        );
+        if (clipped) {
+          clipped.attribs = void 0;
+          res.addChild(clipped);
+        }
+      }
+      return res;
+    },
     poly: ($, boundary) => {
       boundary = ensureVertices(boundary);
       const pts = sutherlandHodgeman(
@@ -45,15 +80,7 @@ const clipConvex = defmulti(
       );
       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($)) : void 0;
-    }
+    rect: __clipVertices
   }
 );
 export {

package/closest-point.d.ts

@@ -12,8 +12,10 @@ import type { ReadonlyVec, Vec } from "@thi.ng/vectors";
  * - {@link AABB}
  * - {@link Arc}
  * - {@link Circle}
+ * - {@link ComplexPolygon}
  * - {@link Cubic}
  * - {@link Line}
+ * - {@link Path}
  * - {@link Plane}
  * - {@link Points}
  * - {@link Points3}

package/closest-point.js

@@ -14,6 +14,8 @@ 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 { distSq2 } from "@thi.ng/vectors/distsq";
+import { set2 } from "@thi.ng/vectors/set";
 import { __dispatch } from "./internal/dispatch.js";
 const closestPoint = defmulti(
   __dispatch,
@@ -27,6 +29,20 @@ const closestPoint = defmulti(
     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),
+    complexpoly: ($, p, out) => {
+      out = closestPointPolyline(p, $.boundary.points, true, out);
+      let minD = distSq2(p, out);
+      let tmp = [];
+      for (let child of $.children) {
+        closestPointPolyline(p, child.points, true, tmp);
+        const d = distSq2(p, tmp);
+        if (d < minD) {
+          minD = d;
+          set2(out, tmp);
+        }
+      }
+      return out;
+    },
     cubic: ({ points }, p, out) => closestPointCubic(
       p,
       points[0],
@@ -36,6 +52,24 @@ const closestPoint = defmulti(
       out
     ),
     line: ({ points }, p, out) => closestPointSegment(p, points[0], points[1], out),
+    path: ($, p, out) => {
+      let minD = Infinity;
+      const $closestPSegment = (segments) => {
+        for (let s of segments) {
+          if (!s.geo) continue;
+          const q = closestPoint(s.geo, p);
+          if (!q) continue;
+          const d = distSq2(p, q);
+          if (d < minD) {
+            minD = d;
+            out = set2(out || [], q);
+          }
+        }
+      };
+      $closestPSegment($.segments);
+      for (let sub of $.subPaths) $closestPSegment(sub);
+      return out;
+    },
     plane: ($, p, out) => closestPointPlane(p, $.normal, $.w, out),
     points: ($, p, out) => closestPointArray(p, $.points, out),
     poly: ($, p, out) => closestPointPolyline(p, $.points, true, out),

package/complex-polygon-from-path.d.ts

@@ -0,0 +1,14 @@
+import type { Attribs, SamplingOpts } from "@thi.ng/geom-api";
+import { ComplexPolygon } from "./api/complex-polygon.js";
+import type { Path } from "./api/path.js";
+/**
+ * Converts given path into a {@link ComplexPolygon}, using `opts` to control
+ * the conversion (via {@link asPolygon}). If no new `attribs` are given, those
+ * of the path will be used (shallow copy).
+ *
+ * @param path
+ * @param opts
+ * @param attribs
+ */
+export declare const complexPolygonFromPath: (path: Path, opts?: number | Partial<SamplingOpts>, attribs?: Attribs) => ComplexPolygon;
+//# sourceMappingURL=complex-polygon-from-path.d.ts.map

package/complex-polygon-from-path.js

@@ -0,0 +1,9 @@
+import { ComplexPolygon } from "./api/complex-polygon.js";
+import { asPolygon } from "./as-polygon.js";
+const complexPolygonFromPath = (path, opts, attribs) => {
+  const [boundary, ...children] = asPolygon(path, opts);
+  return new ComplexPolygon(boundary, children, attribs || boundary.attribs);
+};
+export {
+  complexPolygonFromPath
+};

package/complex-polygon.d.ts

@@ -0,0 +1,23 @@
+import type { Attribs } from "@thi.ng/geom-api";
+import { ComplexPolygon } from "./api/complex-polygon.js";
+import { Polygon } from "./api/polygon.js";
+/**
+ * Creates a {@link ComplexPolygon} instance from given `boundary` and `child`
+ * polygons (the latter are assumed non-overlapping holes and will be
+ * interpreted as such).
+ *
+ * @remarks
+ * Child polygons are considered holes and fully enclosed by the boundary poly.
+ * Depending on usage, holes should also have the opposite vertex order (e.g.
+ * via {@link flip}) than the boundary. This is not enforced automatically and
+ * the user's responsibility.
+ *
+ * Any attribs on `boundary` or `children` will be ignored, only those given as
+ * `attribs` will be used.
+ *
+ * @param boundary
+ * @param children
+ * @param attribs
+ */
+export declare const complexPolygon: (boundary?: Polygon, children?: Iterable<Polygon>, attribs?: Attribs) => ComplexPolygon;
+//# sourceMappingURL=complex-polygon.d.ts.map

package/complex-polygon.js

@@ -0,0 +1,6 @@
+import { ComplexPolygon } from "./api/complex-polygon.js";
+import { Polygon } from "./api/polygon.js";
+const complexPolygon = (boundary, children, attribs) => new ComplexPolygon(boundary, children, attribs);
+export {
+  complexPolygon
+};