okgeometry-api 1.14.0 → 1.15.0

package/src/wasm-bindings.js

@@ -64,6 +64,32 @@ export function brep_boolean_op(a_json, b_json, op, tolerance) {
     }
 }
 
+/**
+ * Boolean-intersection clip of an exact NURBS curve against a CLOSED solid
+ * BREP: the curve is split exactly (knot insertion) at every boundary
+ * crossing and each piece is classified by containment. Every returned
+ * piece lies exactly on the input curve; closed curves merge the run
+ * spanning the parameter seam (same convention as `mesh_clip_polyline`).
+ *
+ * Packing: `[insideCount, (bufLen, curveData…)·insideCount,
+ * outsideCount, (bufLen, curveData…)·outsideCount]` — two concatenated
+ * multi-curve packings, inside pieces first. Returns an empty buffer on
+ * failure (malformed input, or a BREP that is not a closed solid).
+ * @param {Float64Array} curve_data
+ * @param {string} brep_json
+ * @returns {Float64Array}
+ */
+export function brep_clip_curve_op(curve_data, brep_json) {
+    const ptr0 = passArrayF64ToWasm0(curve_data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(brep_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.brep_clip_curve_op(ptr0, len0, ptr1, len1);
+    var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v3;
+}
+
 /**
  * Closest BREP face to a 3D point. Returns [faceIndex, u, v, distance,
  * isNurbs] ((u, v) in the surface's KNOT domain) or empty on failure.
@@ -82,6 +108,34 @@ export function brep_closest_face(json, x, y, z) {
     return v2;
 }
 
+/**
+ * Find all points where a NURBS curve pierces a BREP's faces: per face, the
+ * curve is intersected with the EXACT surface and kept only when the hit
+ * lies INSIDE the face's trimmed region; crossings on shared edges are
+ * deduplicated (smallest face index kept).
+ *
+ * `curve_data` is the standard NURBS curve encoding. Hits are sorted by
+ * curve parameter (normalized [0, 1]); (u, v) are in the face's OWN
+ * parameter space (knot domain for NURBS faces, plane-frame coordinates for
+ * planar faces).
+ *
+ * Packing: `[count, (x, y, z, curveParam, faceIndex, u, v)·count]`.
+ * Returns an empty buffer on malformed input.
+ * @param {string} brep_json
+ * @param {Float64Array} curve_data
+ * @returns {Float64Array}
+ */
+export function brep_curve_intersection_op(brep_json, curve_data) {
+    const ptr0 = passStringToWasm0(brep_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF64ToWasm0(curve_data, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.brep_curve_intersection_op(ptr0, len0, ptr1, len1);
+    var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v3;
+}
+
 /**
  * All BREP edges as polylines: [num_polylines, n1, x,y,z..., n2, ...].
  * @param {string} json
@@ -365,6 +419,36 @@ export function brep_info(json) {
     return v2;
 }
 
+/**
+ * TRIM-EXACT intersection curves between two BREPs (solids OR sheets): the
+ * parametric boolean's SSI → clip → convergence stages run and the fitted 3D
+ * intersection edges come back WITHOUT classification/assembly.
+ *
+ * A closed intersection loop may come back as several contiguous pieces
+ * (split at surface seams and face-boundary crossings); the pieces chain
+ * end-to-end exactly. Coincident (overlapping) face pairs contribute no
+ * curves.
+ *
+ * Packing: `[curveCount, (bufLen, curveData…)·curveCount]` (standard NURBS
+ * curve encoding). Returns an EMPTY buffer on failure (invalid BREP JSON or
+ * a pipeline error) — distinguishable from `[0]`, which means the operands
+ * genuinely do not intersect.
+ * @param {string} a_json
+ * @param {string} b_json
+ * @param {number} tolerance
+ * @returns {Float64Array}
+ */
+export function brep_intersection_curves_op(a_json, b_json, tolerance) {
+    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_intersection_curves_op(ptr0, len0, ptr1, len1, tolerance);
+    var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v3;
+}
+
 /**
  * Loft through profile curves into a BREP.
  * Input: [num_curves, curve1_data..., curve2_data...]. Returns JSON.
@@ -386,6 +470,33 @@ export function brep_loft_curves(data) {
     }
 }
 
+/**
+ * Intersection curves between a BREP and a triangle mesh.
+ *
+ * TESSELLATION-BASED (documented approximation): the BREP is tessellated at
+ * `tolerance` (pass `<= 0` for the deterministic auto display tolerance)
+ * and intersected with the mesh via BVH-pruned tri-tri crossing + chaining.
+ *
+ * Mesh input is the standard `[vertexCount, positions..., indices...]`
+ * buffer. Returns the standard polyline group packing
+ * `[num_polylines, n1, x,y,z,..., n2, x,y,z,...]`; empty on failure.
+ * @param {string} brep_json
+ * @param {number} vertex_count
+ * @param {Float64Array} mesh_buffer
+ * @param {number} tolerance
+ * @returns {Float64Array}
+ */
+export function brep_mesh_intersection_curves_op(brep_json, vertex_count, mesh_buffer, tolerance) {
+    const ptr0 = passStringToWasm0(brep_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF64ToWasm0(mesh_buffer, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.brep_mesh_intersection_curves_op(ptr0, len0, vertex_count, ptr1, len1, tolerance);
+    var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v3;
+}
+
 /**
  * BREP primitives.
  * kind: "box"      [minx,miny,minz, maxx,maxy,maxz]
@@ -1807,6 +1918,36 @@ export function mesh_clip_polyline(vertex_count, buffer, points, closed) {
     return v3;
 }
 
+/**
+ * Clip a polyline by an OPEN oriented sheet: split it at every sheet
+ * crossing and classify each piece by the SIGNED SIDE of the sheet. This is
+ * side classification, NOT containment (unlike `mesh_clip_polyline`, which
+ * requires a closed volume): pieces far from the sheet still classify by
+ * the nearest facet's normal. `inside` = the positive side, in FRONT of the
+ * sheet normal; `outside` = behind it. The sheet may be any non-empty
+ * triangle mesh, open or closed; its stored winding defines the normals.
+ *
+ * Returns two concatenated polyline buffers — inside pieces first, then
+ * outside pieces — each encoded as `[num_polylines, n1, x,y,z,..., ...]`
+ * (identical packing to `mesh_clip_polyline`). Returns an empty buffer on
+ * failure (degenerate polyline/sheet).
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @param {Float64Array} points
+ * @param {boolean} closed
+ * @returns {Float64Array}
+ */
+export function mesh_clip_polyline_by_sheet(vertex_count, buffer, points, closed) {
+    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF64ToWasm0(points, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_clip_polyline_by_sheet(vertex_count, ptr0, len0, ptr1, len1, closed);
+    var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v3;
+}
+
 /**
  * Compute planar curve normal from ordered points.
  * @param {Float64Array} coords
@@ -2472,6 +2613,36 @@ export function mesh_plane_intersect(vertex_count, buffer, nx, ny, nz, d) {
     return v2;
 }
 
+/**
+ * Compute all transversal crossing points of a polyline with a triangle
+ * mesh. Works on OPEN meshes (sheets) — the mesh is NOT required to be a
+ * closed volume, unlike `mesh_clip_polyline`.
+ *
+ * `points` is a flat [x,y,z, ...] vertex list; `closed` marks a closed loop
+ * (segment `i` runs `points[i] → points[(i+1) % n]`; open polylines have
+ * n−1 segments, closed ones n).
+ *
+ * Packing: `[count, (x, y, z, segmentIndex, segmentT, triangleIndex)·count]`,
+ * sorted by (segmentIndex, segmentT). Shared-edge/vertex crossings dedupe to
+ * one hit (smallest triangle index kept); coplanar sliding overlaps yield no
+ * hits. Returns an empty buffer on failure (degenerate polyline/mesh).
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @param {Float64Array} points
+ * @param {boolean} closed
+ * @returns {Float64Array}
+ */
+export function mesh_polyline_intersection_points(vertex_count, buffer, points, closed) {
+    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF64ToWasm0(points, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_polyline_intersection_points(vertex_count, ptr0, len0, ptr1, len1, closed);
+    var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v3;
+}
+
 /**
  * Shift closed boolean cutter curve and adjust height.
  * Returns [height, epsilon, pointCount, x,y,z,...]
@@ -2676,6 +2847,34 @@ export function mesh_split_by_surface_to_brep(vertex_count, buffer, surface_data
     }
 }
 
+/**
+ * Intersect a polyline with a triangle mesh (open sheets allowed) and split
+ * it into pieces at every crossing. Hit points become the shared endpoints
+ * of adjacent pieces; a closed loop is opened at the first hit (N hits → N
+ * pieces), an open polyline yields N + 1 pieces. With no crossings the
+ * original polyline comes back as one piece.
+ *
+ * Packing: a single flat polyline-group buffer
+ * `[num_polylines, n1, x,y,z,..., n2, x,y,z,...]` (same group encoding as
+ * `mesh_clip_polyline`, but ONE list — pieces are not classified). Returns
+ * an empty buffer on failure.
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @param {Float64Array} points
+ * @param {boolean} closed
+ * @returns {Float64Array}
+ */
+export function mesh_split_polyline(vertex_count, buffer, points, closed) {
+    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF64ToWasm0(points, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_split_polyline(vertex_count, ptr0, len0, ptr1, len1, closed);
+    var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v3;
+}
+
 /**
  * Trim an OPEN host surface by all closed cutter meshes in one WASM call.
  *
@@ -2817,6 +3016,32 @@ export function nurbs_curve_curve_intersect(data_a, data_b) {
     return v3;
 }
 
+/**
+ * Find all intersections between two NURBS curves, with exact parameters.
+ *
+ * Inputs are standard NURBS curve encodings
+ * `[degree, num_cp, cp_xyz..., weights..., knots...]` (the same format
+ * consumed by `sample_nurbs_curve` / produced by `build_nurbs_curve`).
+ *
+ * Packing: `[count, (x, y, z, paramA, paramB)·count]`. Parameters are
+ * normalized to [0, 1]; results are sorted by `paramA`. Coincident
+ * (overlapping) curve runs yield NO points (identical curves return
+ * `[0]`). Returns an empty buffer on malformed input.
+ * @param {Float64Array} curve_a_data
+ * @param {Float64Array} curve_b_data
+ * @returns {Float64Array}
+ */
+export function nurbs_curve_curve_intersect_params(curve_a_data, curve_b_data) {
+    const ptr0 = passArrayF64ToWasm0(curve_a_data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF64ToWasm0(curve_b_data, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.nurbs_curve_curve_intersect_params(ptr0, len0, ptr1, len1);
+    var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v3;
+}
+
 /**
  * Intersect a NURBS curve with a plane.
  * Input: same curve format as sample_nurbs_curve + plane normal (nx,ny,nz) and d.
@@ -2837,6 +3062,68 @@ export function nurbs_curve_plane_intersect(data, nx, ny, nz, d) {
     return v2;
 }
 
+/**
+ * Split a NURBS curve at multiple normalized parameters t ∈ [0, 1].
+ *
+ * Splitting is exact (knot insertion), so every returned piece lies exactly
+ * on the input curve. Parameters are sorted/deduplicated/clamped internally;
+ * closed curves are opened at the FIRST parameter (N interior parameters →
+ * N pieces), open curves yield N + 1 pieces. With no valid parameters the
+ * (clamped) curve comes back as the single piece.
+ *
+ * `closed_hint` is an explicit topology override: `> 0` forces closed
+ * (seam-rejoin) semantics, `0` forces open semantics (an open curve whose
+ * endpoints merely coincide keeps N + 1 pieces), `< 0` infers closedness
+ * geometrically from the endpoint distance (the historical behavior).
+ *
+ * Packing: `[curveCount, (bufLen, curveData…)·curveCount]` where curveData
+ * is the standard NURBS curve encoding (same multi-curve packing as
+ * `brep_face_iso_curves_trimmed`). Returns an empty buffer on malformed
+ * input.
+ * @param {Float64Array} curve_data
+ * @param {Float64Array} params
+ * @param {number} closed_hint
+ * @returns {Float64Array}
+ */
+export function nurbs_curve_split_at_params(curve_data, params, closed_hint) {
+    const ptr0 = passArrayF64ToWasm0(curve_data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF64ToWasm0(params, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.nurbs_curve_split_at_params(ptr0, len0, ptr1, len1, closed_hint);
+    var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v3;
+}
+
+/**
+ * Find all isolated intersections of a NURBS curve with a NURBS surface,
+ * with exact parameters.
+ *
+ * `curve_data` is the standard NURBS curve encoding; `surface_data` is the
+ * standard NURBS surface encoding `[degree_u, degree_v, num_u, num_v,
+ * cp(flat)..., weights..., knots_u..., knots_v...]` (same as
+ * `nurbs_surface_evaluate`).
+ *
+ * Packing: `[count, (x, y, z, t, u, v)·count]`. All parameters are
+ * normalized to [0, 1]; results are sorted by `t`. Curve segments lying ON
+ * the surface (coincident runs) yield no points. Returns an empty buffer on
+ * malformed input.
+ * @param {Float64Array} curve_data
+ * @param {Float64Array} surface_data
+ * @returns {Float64Array}
+ */
+export function nurbs_curve_surface_intersect_exact(curve_data, surface_data) {
+    const ptr0 = passArrayF64ToWasm0(curve_data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF64ToWasm0(surface_data, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.nurbs_curve_surface_intersect_exact(ptr0, len0, ptr1, len1);
+    var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v3;
+}
+
 /**
  * Closest point on the surface to (x, y, z).
  * Returns [u, v, px, py, pz] with u, v normalized to [0,1].
@@ -3125,6 +3412,37 @@ export function nurbs_surface_surface_intersect(data_a, data_b, tess) {
     return v3;
 }
 
+/**
+ * EXACT intersection curves of two FULL (untrimmed) NURBS surfaces: the
+ * parametric boolean's SSI pipeline (seeded tri-tri, chaining, tangent-plane
+ * relaxation) fitted to tolerance-verified interpolating NURBS curves —
+ * unlike `nurbs_surface_surface_intersect`, which returns tessellated
+ * polylines.
+ *
+ * Inputs are standard NURBS surface encodings; `tolerance` is absolute
+ * (floored relative to the combined model scale kernel-side). Closed loops
+ * come back as ONE closed curve; coincident (overlapping) surfaces yield no
+ * curves (their overlap is a 2D region).
+ *
+ * Packing: `[curveCount, (bufLen, curveData…)·curveCount]` where curveData
+ * is the standard NURBS curve encoding. Returns an empty buffer on
+ * malformed input.
+ * @param {Float64Array} surf_a_data
+ * @param {Float64Array} surf_b_data
+ * @param {number} tolerance
+ * @returns {Float64Array}
+ */
+export function nurbs_surface_surface_intersect_curves(surf_a_data, surf_b_data, tolerance) {
+    const ptr0 = passArrayF64ToWasm0(surf_a_data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF64ToWasm0(surf_b_data, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.nurbs_surface_surface_intersect_curves(ptr0, len0, ptr1, len1, tolerance);
+    var v3 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v3;
+}
+
 /**
  * Curvature-adaptive tessellation against a chordal tolerance.
  * Returns the standard mesh buffer [vertexCount, positions..., indices...].