okgeometry-api 1.16.0 → 1.17.1

package/src/wasm-bindings.d.ts

@@ -14,7 +14,20 @@ export function arc_point_at(cx: number, cy: number, cz: number, nx: number, ny:
 
 /**
  * Parametric BREP boolean: exact surface–surface intersection curves with
- * trimmed-surface output. Both operands must be closed solids.
+ * trimmed-surface output. Operands may be closed solids OR open sheets —
+ * the kernel dispatches on closedness (oriented-sheet convention: a sheet's
+ * "inside" is the FRONT of its normal):
+ * - closed × closed: full volumetric boolean.
+ * - sheet × solid: subtract keeps the sheet outside the solid, intersect
+ *   keeps the inside.
+ * - solid × sheet: subtract keeps the capped half BEHIND the sheet normal,
+ *   intersect the front half.
+ * - sheet × sheet: a sheet's material is its FRONT half-space, so union
+ *   stitches A-BACK + B-BACK at the intersection edges (front pieces are
+ *   interior to the union material; uncut pieces are kept, coincident
+ *   overlaps keep A's copy); subtract keeps A's back pieces; intersect
+ *   A's front pieces.
+ * - union of a solid and a sheet is not defined and returns an error.
  * op: "union" | "intersect" | "subtract".
  * Returns the result BREP as JSON, or {"error": "..."} on failure.
  */
@@ -227,6 +240,24 @@ export function brep_revolve_curve(curve_data: Float64Array, ox: number, oy: num
  */
 export function brep_sheet_from_surface(surface_data: Float64Array): string;
 
+/**
+ * Split an OPEN sheet BREP `a` by another OPEN sheet BREP `b`.
+ * Returns {"inside": <brep|null>, "outside": <brep|null>} or {"error":...}:
+ * `inside` = a's pieces in FRONT of b's oriented normal, `outside` = the
+ * pieces behind it (matching the oriented-sheet convention of
+ * `mesh_clip_polyline` and the sheet boolean dispatch).
+ */
+export function brep_split_sheet_by_sheet_op(a_json: string, b_json: string, tolerance: number): string;
+
+/**
+ * Split an OPEN sheet BREP by a CLOSED solid BREP into containment sides.
+ * Returns {"inside": <brep|null>, "outside": <brep|null>} or {"error":...}:
+ * `inside` = the sheet pieces contained in the solid (ON-boundary pieces
+ * count as inside), `outside` = the rest. Both preserve the sheet's exact
+ * trimmed faces, pcurves and edges.
+ */
+export function brep_split_sheet_by_solid_op(sheet_json: string, solid_json: string, tolerance: number): string;
+
 /**
  * Split a closed solid BREP by a sheet BREP into BOTH capped halves.
  * Returns {"negative": <brep|null>, "positive": <brep|null>} or {"error":...}.
@@ -321,6 +352,49 @@ export function create_line(x1: number, y1: number, z1: number, x2: number, y2:
  */
 export function create_polyline(coords: Float64Array, samples_per_segment: number): Float64Array;
 
+/**
+ * 2D REGION boolean between two CLOSED, COPLANAR curves (Rhino CurveBoolean).
+ *
+ * Both inputs are standard NURBS curve encodings (the TS layer coerces
+ * circles/arcs/polylines/polycurves to exact NURBS first). The curves are
+ * projected onto a common plane (fitted from A, coplanarity verified),
+ * tessellated to polygons, arranged in 2D, classified by inside-A/inside-B
+ * (nonzero winding), and the result loops emitted per op. CLOSURE is
+ * verified kernel-side: each curve's endpoints must coincide within a
+ * scale-relative tolerance, open curves error out (never silently
+ * chord-closed).
+ *
+ * `op`: 0 = union, 1 = subtract (A − B), 2 = intersect.
+ *
+ * Result loops are POLYLINE (degree-1 NURBS) closed curves — Rhino-parity
+ * fidelity. 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 CCW (positive plane-signed area),
+ * holes CW. CCW is measured about a DETERMINISTIC plane normal: the normal
+ * fitted from curve A, flipped so its dominant world-axis component is
+ * positive (for XY-plane curves the reference is +Z). The orientation is
+ * therefore independent of the inputs' drawing direction. Callers
+ * reconstruct nesting from the winding sign.
+ *
+ * Packing: `[curveCount, (bufLen, curveData…)·curveCount]` (same multi-curve
+ * packing as `nurbs_curve_split_at_params`). An EMPTY buffer signals an error
+ * (non-coplanar / open input / malformed input); a valid but EMPTY result
+ * (e.g. disjoint intersect) is the non-empty `[0]` packing.
+ */
+export function curve_region_boolean(a_data: Float64Array, b_data: Float64Array, op: number): Float64Array;
+
+/**
+ * SPLIT two CLOSED, COPLANAR curves into ALL region boundaries (Rhino
+ * "region split"): the arrangement of A and B partitions the plane into the
+ * pieces inside-A-only, inside-B-only and inside-both; each bounded region's
+ * outer and hole loops are returned as their own closed curves.
+ *
+ * Inputs, plane/coplanarity handling, fidelity and orientation follow
+ * `curve_region_boolean`. Same multi-curve packing; empty buffer on error.
+ */
+export function curve_region_split(a_data: Float64Array, b_data: Float64Array): Float64Array;
+
 /**
  * Serialize a curve to a list of points for Three.js rendering
  * Returns a flat array of coordinates: [x1, y1, z1, x2, y2, z2, ...]
@@ -879,6 +953,18 @@ export function mesh_rotate(vertex_count: number, buffer: Float64Array, ax: numb
  */
 export function mesh_scale(vertex_count: number, buffer: Float64Array, sx: number, sy: number, sz: number): Float64Array;
 
+/**
+ * Union of two OPEN oriented sheets (mesh A ∪ mesh B): mutual trim + join.
+ * A sheet's material is its FRONT half-space, so the union boundary keeps
+ * A's pieces BEHIND B and B's pieces BEHIND A (pieces in front of the other
+ * sheet are interior to the union material and are dropped), stitched at
+ * the shared intersection seam; regions the other operand never cuts are
+ * kept wholesale (coincident-overlap regions keep A's copy only). Rejects
+ * closed operands — those belong to the solid boolean. Returns one mesh
+ * buffer in the standard `[vertexCount, positions…, indices…]` layout.
+ */
+export function mesh_sheet_union(vertex_count_a: number, buffer_a: Float64Array, vertex_count_b: number, buffer_b: Float64Array, flags: string): Float64Array;
+
 /**
  * Split a closed solid (mesh A) by a surface (mesh B) into BOTH capped solids.
  * `outside` = the solid on the negative side of the surface, `inside` = the
@@ -1295,6 +1381,8 @@ export interface InitOutput {
     readonly brep_primitive: (a: number, b: number, c: number, d: number) => [number, number];
     readonly brep_revolve_curve: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => [number, number];
     readonly brep_sheet_from_surface: (a: number, b: number) => [number, number];
+    readonly brep_split_sheet_by_sheet_op: (a: number, b: number, c: number, d: number, e: number) => [number, number];
+    readonly brep_split_sheet_by_solid_op: (a: number, b: number, c: number, d: number, e: number) => [number, number];
     readonly brep_split_solid_by_sheet_op: (a: number, b: number, c: number, d: number, e: number) => [number, number];
     readonly brep_tessellate: (a: number, b: number, c: number) => [number, number];
     readonly brep_tessellate_with_face_ranges: (a: number, b: number, c: number) => [number, number];
@@ -1309,6 +1397,8 @@ export interface InitOutput {
     readonly create_circle: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => [number, number];
     readonly create_line: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number];
     readonly create_polyline: (a: number, b: number, c: number) => [number, number];
+    readonly curve_region_boolean: (a: number, b: number, c: number, d: number, e: number) => [number, number];
+    readonly curve_region_split: (a: number, b: number, c: number, d: number) => [number, number];
     readonly curve_to_points: (a: number, b: number, c: number, d: number, e: number) => [number, number];
     readonly evaluate_nurbs_curve_at: (a: number, b: number, c: number) => [number, number];
     readonly extrude_circle: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number) => [number, number];
@@ -1401,6 +1491,7 @@ export interface InitOutput {
     readonly mesh_raycast_many: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => [number, number];
     readonly mesh_rotate: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number];
     readonly mesh_scale: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
+    readonly mesh_sheet_union: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => [number, number];
     readonly mesh_solid_split_by_surface: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => [number, number];
     readonly mesh_solid_split_plane: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => [number, number];
     readonly mesh_split_by_surface_to_brep: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => [number, number];

package/src/wasm-bindings.js

@@ -36,7 +36,20 @@ export function arc_point_at(cx, cy, cz, nx, ny, nz, radius, start_angle, end_an
 
 /**
  * Parametric BREP boolean: exact surface–surface intersection curves with
- * trimmed-surface output. Both operands must be closed solids.
+ * trimmed-surface output. Operands may be closed solids OR open sheets —
+ * the kernel dispatches on closedness (oriented-sheet convention: a sheet's
+ * "inside" is the FRONT of its normal):
+ * - closed × closed: full volumetric boolean.
+ * - sheet × solid: subtract keeps the sheet outside the solid, intersect
+ *   keeps the inside.
+ * - solid × sheet: subtract keeps the capped half BEHIND the sheet normal,
+ *   intersect the front half.
+ * - sheet × sheet: a sheet's material is its FRONT half-space, so union
+ *   stitches A-BACK + B-BACK at the intersection edges (front pieces are
+ *   interior to the union material; uncut pieces are kept, coincident
+ *   overlaps keep A's copy); subtract keeps A's back pieces; intersect
+ *   A's front pieces.
+ * - union of a solid and a sheet is not defined and returns an error.
  * op: "union" | "intersect" | "subtract".
  * Returns the result BREP as JSON, or {"error": "..."} on failure.
  * @param {string} a_json
@@ -603,6 +616,62 @@ export function brep_sheet_from_surface(surface_data) {
     }
 }
 
+/**
+ * Split an OPEN sheet BREP `a` by another OPEN sheet BREP `b`.
+ * Returns {"inside": <brep|null>, "outside": <brep|null>} or {"error":...}:
+ * `inside` = a's pieces in FRONT of b's oriented normal, `outside` = the
+ * pieces behind it (matching the oriented-sheet convention of
+ * `mesh_clip_polyline` and the sheet boolean dispatch).
+ * @param {string} a_json
+ * @param {string} b_json
+ * @param {number} tolerance
+ * @returns {string}
+ */
+export function brep_split_sheet_by_sheet_op(a_json, b_json, tolerance) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(a_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(b_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.brep_split_sheet_by_sheet_op(ptr0, len0, ptr1, len1, tolerance);
+        deferred3_0 = ret[0];
+        deferred3_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+
+/**
+ * Split an OPEN sheet BREP by a CLOSED solid BREP into containment sides.
+ * Returns {"inside": <brep|null>, "outside": <brep|null>} or {"error":...}:
+ * `inside` = the sheet pieces contained in the solid (ON-boundary pieces
+ * count as inside), `outside` = the rest. Both preserve the sheet's exact
+ * trimmed faces, pcurves and edges.
+ * @param {string} sheet_json
+ * @param {string} solid_json
+ * @param {number} tolerance
+ * @returns {string}
+ */
+export function brep_split_sheet_by_solid_op(sheet_json, solid_json, tolerance) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(sheet_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(solid_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.brep_split_sheet_by_solid_op(ptr0, len0, ptr1, len1, tolerance);
+        deferred3_0 = ret[0];
+        deferred3_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+
 /**
  * Split a closed solid BREP by a sheet BREP into BOTH capped halves.
  * Returns {"negative": <brep|null>, "positive": <brep|null>} or {"error":...}.
@@ -873,6 +942,74 @@ export function create_polyline(coords, samples_per_segment) {
     return v2;
 }
 
+/**
+ * 2D REGION boolean between two CLOSED, COPLANAR curves (Rhino CurveBoolean).
+ *
+ * Both inputs are standard NURBS curve encodings (the TS layer coerces
+ * circles/arcs/polylines/polycurves to exact NURBS first). The curves are
+ * projected onto a common plane (fitted from A, coplanarity verified),
+ * tessellated to polygons, arranged in 2D, classified by inside-A/inside-B
+ * (nonzero winding), and the result loops emitted per op. CLOSURE is
+ * verified kernel-side: each curve's endpoints must coincide within a
+ * scale-relative tolerance, open curves error out (never silently
+ * chord-closed).
+ *
+ * `op`: 0 = union, 1 = subtract (A − B), 2 = intersect.
+ *
+ * Result loops are POLYLINE (degree-1 NURBS) closed curves — Rhino-parity
+ * fidelity. 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 CCW (positive plane-signed area),
+ * holes CW. CCW is measured about a DETERMINISTIC plane normal: the normal
+ * fitted from curve A, flipped so its dominant world-axis component is
+ * positive (for XY-plane curves the reference is +Z). The orientation is
+ * therefore independent of the inputs' drawing direction. Callers
+ * reconstruct nesting from the winding sign.
+ *
+ * Packing: `[curveCount, (bufLen, curveData…)·curveCount]` (same multi-curve
+ * packing as `nurbs_curve_split_at_params`). An EMPTY buffer signals an error
+ * (non-coplanar / open input / malformed input); a valid but EMPTY result
+ * (e.g. disjoint intersect) is the non-empty `[0]` packing.
+ * @param {Float64Array} a_data
+ * @param {Float64Array} b_data
+ * @param {number} op
+ * @returns {Float64Array}
+ */
+export function curve_region_boolean(a_data, b_data, op) {
+    const ptr0 = passArrayF64ToWasm0(a_data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF64ToWasm0(b_data, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.curve_region_boolean(ptr0, len0, ptr1, len1, op);
+    var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v3;
+}
+
+/**
+ * SPLIT two CLOSED, COPLANAR curves into ALL region boundaries (Rhino
+ * "region split"): the arrangement of A and B partitions the plane into the
+ * pieces inside-A-only, inside-B-only and inside-both; each bounded region's
+ * outer and hole loops are returned as their own closed curves.
+ *
+ * Inputs, plane/coplanarity handling, fidelity and orientation follow
+ * `curve_region_boolean`. Same multi-curve packing; empty buffer on error.
+ * @param {Float64Array} a_data
+ * @param {Float64Array} b_data
+ * @returns {Float64Array}
+ */
+export function curve_region_split(a_data, b_data) {
+    const ptr0 = passArrayF64ToWasm0(a_data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF64ToWasm0(b_data, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.curve_region_split(ptr0, len0, ptr1, len1);
+    var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v3;
+}
+
 /**
  * Serialize a curve to a list of points for Three.js rendering
  * Returns a flat array of coordinates: [x1, y1, z1, x2, y2, z2, ...]
@@ -2800,6 +2937,35 @@ export function mesh_scale(vertex_count, buffer, sx, sy, sz) {
     return v2;
 }
 
+/**
+ * Union of two OPEN oriented sheets (mesh A ∪ mesh B): mutual trim + join.
+ * A sheet's material is its FRONT half-space, so the union boundary keeps
+ * A's pieces BEHIND B and B's pieces BEHIND A (pieces in front of the other
+ * sheet are interior to the union material and are dropped), stitched at
+ * the shared intersection seam; regions the other operand never cuts are
+ * kept wholesale (coincident-overlap regions keep A's copy only). Rejects
+ * closed operands — those belong to the solid boolean. Returns one mesh
+ * buffer in the standard `[vertexCount, positions…, indices…]` layout.
+ * @param {number} vertex_count_a
+ * @param {Float64Array} buffer_a
+ * @param {number} vertex_count_b
+ * @param {Float64Array} buffer_b
+ * @param {string} flags
+ * @returns {Float64Array}
+ */
+export function mesh_sheet_union(vertex_count_a, buffer_a, vertex_count_b, buffer_b, flags) {
+    const ptr0 = passArrayF64ToWasm0(buffer_a, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF64ToWasm0(buffer_b, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ptr2 = passStringToWasm0(flags, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len2 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_sheet_union(vertex_count_a, ptr0, len0, vertex_count_b, ptr1, len1, ptr2, len2);
+    var v4 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v4;
+}
+
 /**
  * Split a closed solid (mesh A) by a surface (mesh B) into BOTH capped solids.
  * `outside` = the solid on the negative side of the surface, `inside` = the