okgeometry-api 1.16.0 → 1.17.1

package/src/Mesh.ts

@@ -1268,9 +1268,15 @@ export class Mesh {
       return { points: [], radius: 0 };
     }
 
+    // Circle.sample(k) spans the full closed parameter range inclusively, so
+    // its last point repeats the first (the seam). A planar circle POLYGON
+    // must be `segments` unique vertices with an implicit closing edge —
+    // sample one extra point and drop the duplicated seam.
     const circle = new Circle(center, radius, n);
+    const samples = circle.sample(Math.floor(segments) + 1);
+    samples.pop();
     return {
-      points: circle.sample(Math.floor(segments)),
+      points: samples,
       radius,
     };
   }
@@ -2203,8 +2209,9 @@ export class Mesh {
     const topology = `A=${aClosed ? "closed" : "open"}, B=${bClosed ? "closed" : "open"}`;
     if (operation === "union") {
       return new Error(
-        `Boolean union requires both inputs to be closed volumes (${topology}). `
-        + "Close or cap the open mesh before calling union().",
+        `Boolean union of a closed solid and an open sheet is not defined (${topology}). `
+        + "Trim the sheet with subtract/intersect, or close it into a solid first. "
+        + "Union supports closed x closed (volumetric) and open x open (sheet trim + join).",
       );
     }
 
@@ -2229,9 +2236,75 @@ export class Mesh {
       return Mesh.mergeMeshComponents(operation === "subtraction" ? split.outside : split.inside);
     }
 
+    if (!aClosed && !bClosed && operation === "union") {
+      return this.sheetUnion(other, options);
+    }
+
     throw Mesh.createUnsupportedOpenMeshBooleanError(operation, aClosed, bClosed);
   }
 
+  /**
+   * Union of two OPEN oriented sheets: mutual trim + join, mirroring the
+   * parametric sheet x sheet union (`Brep.unionBrep`) exactly. A sheet's
+   * material is its FRONT half-space, so the union boundary keeps this
+   * sheet's pieces BEHIND the other (pieces in front of the other sheet are
+   * interior to the union material and are dropped) and the other's pieces
+   * BEHIND this one, welded into one crack-free mesh at the shared
+   * intersection seam. Regions the other operand never cuts are kept
+   * wholesale (union never loses non-conflicting material);
+   * coincident-overlap regions keep THIS sheet's copy only.
+   *
+   * Called by `union()` when both operands are open.
+   */
+  private sheetUnion(other: Mesh, options?: MeshBooleanOptions): Mesh {
+    if (this.faceCount === 0) return Mesh.cloneMesh(other);
+    if (other.faceCount === 0) return Mesh.cloneMesh(this);
+
+    const boundsA = Mesh.computeRawBounds(this);
+    const boundsB = Mesh.computeRawBounds(other);
+    const contactTol = Mesh.booleanContactTolerance(boundsA, boundsB);
+    if (!Mesh.boundsOverlap(boundsA, boundsB, contactTol)) {
+      return Mesh.mergeMeshes([this, other]);
+    }
+
+    if (!options?.allowUnsafe) {
+      const limits = Mesh.resolveBooleanLimits(options?.limits);
+      const faceCountA = this.faceCount;
+      const faceCountB = other.faceCount;
+      const maxInputFaces = Math.max(faceCountA, faceCountB);
+      const combinedInputFaces = faceCountA + faceCountB;
+      const faceProduct = faceCountA * faceCountB;
+      if (
+        maxInputFaces > limits.maxInputFacesPerMesh
+        || combinedInputFaces > limits.maxCombinedInputFaces
+        || faceProduct > limits.maxFaceProduct
+      ) {
+        throw new Error(
+          `Boolean union blocked by safety limits `
+          + `(A faces=${faceCountA}, B faces=${faceCountB}, faceProduct=${faceProduct}). `
+          + "Simplify inputs, run in a Worker, or pass allowUnsafe: true to force execution.",
+        );
+      }
+    }
+
+    const token = Mesh.encodeBooleanSplitToken(this, other, options);
+    const result = wasm.mesh_sheet_union(
+      this._vertexCount,
+      this._buffer,
+      other._vertexCount,
+      other._buffer,
+      token,
+    );
+    if (result.length === 0) {
+      throw new Error("Boolean union of open sheets failed and returned an invalid mesh buffer.");
+    }
+    const vertexCount = result[0];
+    if (!Number.isFinite(vertexCount) || vertexCount < 0) {
+      throw new Error("Boolean union of open sheets failed and returned a corrupt mesh buffer.");
+    }
+    return Mesh.fromTrustedBuffer(result);
+  }
+
   static encodeBooleanOperationToken(
     operation: MeshBooleanOperation,
     a: Mesh,
@@ -2267,7 +2340,13 @@ export class Mesh {
 
   /**
    * Compute boolean union with another mesh.
-   * Requires both inputs to be closed volumes.
+   *
+   * Closed x closed inputs run the volumetric CSG union. Open x open inputs
+   * run the SHEET union (mutual trim + join): a sheet's material is its
+   * FRONT half-space, so the union keeps this sheet's pieces BEHIND the
+   * other plus the other's pieces BEHIND this one, welded at the shared
+   * seam, with uncut regions kept wholesale. A closed solid combined
+   * with an open sheet has no defined union and throws.
    * @param other - Mesh to union with
    * @param options - Optional safety overrides
    * @returns New mesh containing volume of both inputs
@@ -2276,7 +2355,8 @@ export class Mesh {
     ensureInit();
     const lhs = Mesh.normalizeClosedVolumeOrientation(this);
     const rhs = Mesh.normalizeClosedVolumeOrientation(other);
-    lhs.resolveOpenMeshBooleanFallback(rhs, "union", options);
+    const fallback = lhs.resolveOpenMeshBooleanFallback(rhs, "union", options);
+    if (fallback) return fallback;
     const operationToken = Mesh.encodeBooleanOperationToken("union", lhs, rhs, options);
     return lhs.runBoolean(
       rhs,

package/src/NurbsCurve.ts

@@ -239,6 +239,116 @@ export class NurbsCurve {
     return pieces;
   }
 
+  /**
+   * 2D REGION boolean between this curve and another, both CLOSED and
+   * COPLANAR (Rhino CurveBoolean). Closed planar curves bound regions, so
+   * union / subtract / intersect are well defined: the curves are projected
+   * onto a common plane (fitted from this curve, coplanarity verified),
+   * tessellated to polygons, arranged in 2D, classified by nonzero winding,
+   * and the result loops emitted.
+   *
+   * The result is a list of closed POLYLINE (degree-1 NURBS) curves —
+   * Rhino-parity fidelity, so curved input boundaries are approximated to the
+   * tessellation tolerance. Tessellation samples include every distinct
+   * interior knot value, so degree-1 polygon corners and C0 kinks are
+   * preserved EXACTLY, and consecutive collinear points are collapsed so
+   * straight runs come back as single segments. OUTER boundaries are
+   * counter-clockwise (positive signed area in the fitted plane); HOLE
+   * boundaries are clockwise. CCW is measured about a DETERMINISTIC plane
+   * normal: the normal fitted from THIS curve, flipped so its dominant
+   * world-axis component is positive (for curves in the world XY plane the
+   * reference normal is +Z, so outer loops are CCW viewed from +Z). The
+   * emitted orientation is therefore independent of either curve's drawing
+   * direction. Callers reconstruct the region topology by nesting (a CW loop
+   * inside a CCW loop is that region's hole).
+   *
+   * A valid but empty result (e.g. a disjoint intersect) returns `[]`. Throws
+   * on non-coplanar or OPEN input (closure is verified kernel-side: the
+   * curves' endpoints must coincide within a scale-relative tolerance).
+   *
+   * @param other - The other closed coplanar curve
+   * @param op - 0 = union, 1 = subtract (this − other), 2 = intersect
+   * @returns Result region boundary loops (outer CCW, holes CW)
+   */
+  private regionBoolean(other: NurbsCurve, op: number): NurbsCurve[] {
+    ensureInit();
+    const buf = wasm.curve_region_boolean(this._data, other._data, op);
+    // An EMPTY buffer signals an error (non-coplanar / malformed); a valid
+    // empty result is the non-empty [0] packing.
+    if (buf.length === 0) {
+      throw new Error(
+        "NurbsCurve region boolean failed — curves must be closed and coplanar",
+      );
+    }
+    return NurbsCurve.decodeCurveList(buf);
+  }
+
+  /**
+   * Region UNION with another closed coplanar curve. See {@link regionBoolean}.
+   * @param other - The other closed coplanar curve
+   * @returns Boundary loops of (inside-this OR inside-other), outer CCW / holes CW
+   */
+  regionUnion(other: NurbsCurve): NurbsCurve[] {
+    return this.regionBoolean(other, 0);
+  }
+
+  /**
+   * Region SUBTRACT (this − other) of a closed coplanar curve. Order matters.
+   * See {@link regionBoolean}.
+   * @param other - The curve subtracted from this
+   * @returns Boundary loops of (inside-this AND NOT inside-other)
+   */
+  regionSubtract(other: NurbsCurve): NurbsCurve[] {
+    return this.regionBoolean(other, 1);
+  }
+
+  /**
+   * Region INTERSECT with another closed coplanar curve. See
+   * {@link regionBoolean}.
+   * @param other - The other closed coplanar curve
+   * @returns Boundary loops of (inside-this AND inside-other)
+   */
+  regionIntersect(other: NurbsCurve): NurbsCurve[] {
+    return this.regionBoolean(other, 2);
+  }
+
+  /**
+   * Region SPLIT: partition this curve and another closed coplanar curve into
+   * ALL region boundaries (Rhino "region split"). The arrangement partitions
+   * the plane into the pieces inside-this-only, inside-other-only and
+   * inside-both; every bounded region's outer and hole loops come back as
+   * their own closed curves (outer CCW, holes CW). See {@link regionBoolean}
+   * for the fidelity and orientation contract.
+   *
+   * @param other - The other closed coplanar curve
+   * @returns All region boundary loops
+   */
+  regionSplit(other: NurbsCurve): NurbsCurve[] {
+    ensureInit();
+    const buf = wasm.curve_region_split(this._data, other._data);
+    if (buf.length === 0) {
+      throw new Error(
+        "NurbsCurve region split failed — curves must be closed and coplanar",
+      );
+    }
+    return NurbsCurve.decodeCurveList(buf);
+  }
+
+  /** Parse [count, (bufLen, curveData…)·count] into NurbsCurves. */
+  private static decodeCurveList(buf: Float64Array): NurbsCurve[] {
+    if (buf.length < 1) return [];
+    const out: NurbsCurve[] = [];
+    let offset = 1;
+    const count = Number(buf[0]);
+    for (let k = 0; k < count && offset < buf.length; k++) {
+      const len = Number(buf[offset]);
+      offset += 1;
+      out.push(NurbsCurve.fromData(buf.subarray(offset, offset + len)));
+      offset += len;
+    }
+    return out;
+  }
+
   /**
    * Translate this curve by an offset vector.
    * @param offset - Translation vector

package/src/index.ts

@@ -1,79 +1,88 @@
-// Core initialization
-export { init, isInitialized } from "./engine.js";
-
-// Shared types and utilities
-export type {
-  SweepableCurve,
-  LoftableCurve,
-  RotationAxis,
-  CurveSegment,
-  CurveOffsetJoinStyle,
-  CurveOffsetOptions,
-} from "./types.js";
-export { CurveTypeCode, SegmentTypeCode } from "./types.js";
-export {
-  pointsToCoords,
-  coordsToPoints,
-  parsePolylineBuffer,
-  parseIntersectionPoints,
-} from "./BufferCodec.js";
-
-// Primitive types
-export { Vec3 } from "./Vec3.js";
-export { Point } from "./Point.js";
-export { Plane } from "./Plane.js";
-export { Ray } from "./Ray.js";
-
-// Curve types
-export { Line } from "./Line.js";
-export { Circle } from "./Circle.js";
-export { Arc } from "./Arc.js";
-export { Polyline } from "./Polyline.js";
-export { Polygon } from "./Polygon.js";
-export { PolyCurve } from "./PolyCurve.js";
-export { NurbsCurve } from "./NurbsCurve.js";
-export { NurbsSurface } from "./NurbsSurface.js";
-export { MeshSurface } from "./MeshSurface.js";
-export type { Surface } from "./Surface.js";
-
-// Boundary representation
-export { Brep } from "./Brep.js";
-export type {
-  BrepInfo,
-  BrepValidationReport,
-  BrepBooleanOptions,
-  BrepParametricBooleanOptions,
-  MeshToBrepConversionOptions,
-  BrepSplitSolidResult,
-} from "./Brep.js";
-
-// Mesh and operations
-export { Mesh, MeshBooleanExecutionError } from "./Mesh.js";
-export type {
-  MeshBooleanOperation,
-  MeshBooleanDebugProbeId,
-  MeshBooleanDebugOptions,
-  MeshBooleanDebugProbe,
-  MeshBooleanDebugProbeSummary,
-  MeshBooleanDebugReport,
-  MeshBooleanReproOperand,
-  MeshBooleanReproResult,
-  MeshBooleanReproError,
-  MeshBooleanReproPayload,
-  MeshBooleanReproOptions,
-  MeshSplitResult,
-  MeshPlaneSplitResult,
-  MeshPlaneSplitOptions,
-  MeshCurveSplitOptions,
-  MeshPlanarFace,
-  MeshDebugBounds,
-  MeshDebugRayHit,
-  MeshDebugSummary,
-  MeshBooleanLimits,
-  MeshBooleanOptions,
-  MeshBooleanAsyncOptions,
-  MeshBooleanErrorCode,
-  MeshBooleanErrorPayload,
-  MeshBooleanProgressEvent,
-} from "./Mesh.js";
-export { intersect } from "./Geometry.js";
+// Core initialization
+export { init, isInitialized } from "./engine.js";
+
+// Shared types and utilities
+export type {
+  SweepableCurve,
+  LoftableCurve,
+  RotationAxis,
+  CurveSegment,
+  CurveOffsetJoinStyle,
+  CurveOffsetOptions,
+} from "./types.js";
+export { CurveTypeCode, SegmentTypeCode } from "./types.js";
+export {
+  pointsToCoords,
+  coordsToPoints,
+  parsePolylineBuffer,
+  parseIntersectionPoints,
+} from "./BufferCodec.js";
+
+// Primitive types
+export { Vec3 } from "./Vec3.js";
+export { Point } from "./Point.js";
+export { Plane } from "./Plane.js";
+export { Ray } from "./Ray.js";
+
+// Curve types
+export { Line } from "./Line.js";
+export { Circle } from "./Circle.js";
+export { Arc } from "./Arc.js";
+export { Polyline } from "./Polyline.js";
+export { Polygon } from "./Polygon.js";
+export { PolyCurve } from "./PolyCurve.js";
+export { NurbsCurve } from "./NurbsCurve.js";
+export { NurbsSurface } from "./NurbsSurface.js";
+export { MeshSurface } from "./MeshSurface.js";
+export type { Surface } from "./Surface.js";
+
+// Boundary representation
+export { Brep } from "./Brep.js";
+export type {
+  BrepInfo,
+  BrepValidationReport,
+  BrepBooleanOptions,
+  BrepParametricBooleanOptions,
+  MeshToBrepConversionOptions,
+  BrepSplitSolidResult,
+} from "./Brep.js";
+
+// Mesh and operations
+export { Mesh, MeshBooleanExecutionError } from "./Mesh.js";
+export type {
+  MeshBooleanOperation,
+  MeshBooleanDebugProbeId,
+  MeshBooleanDebugOptions,
+  MeshBooleanDebugProbe,
+  MeshBooleanDebugProbeSummary,
+  MeshBooleanDebugReport,
+  MeshBooleanReproOperand,
+  MeshBooleanReproResult,
+  MeshBooleanReproError,
+  MeshBooleanReproPayload,
+  MeshBooleanReproOptions,
+  MeshSplitResult,
+  MeshPlaneSplitResult,
+  MeshPlaneSplitOptions,
+  MeshCurveSplitOptions,
+  MeshPlanarFace,
+  MeshDebugBounds,
+  MeshDebugRayHit,
+  MeshDebugSummary,
+  MeshBooleanLimits,
+  MeshBooleanOptions,
+  MeshBooleanAsyncOptions,
+  MeshBooleanErrorCode,
+  MeshBooleanErrorPayload,
+  MeshBooleanProgressEvent,
+} from "./Mesh.js";
+export { intersect } from "./Geometry.js";
+
+// Universal geometry boolean dispatcher
+export { geometryBoolean, geometrySplit } from "./GeometryBoolean.js";
+export type {
+  BooleanOpKind,
+  BooleanOperand,
+  GeometryBooleanOptions,
+  GeometryBooleanResult,
+} from "./GeometryBoolean.js";