okgeometry-api 0.4.5 → 0.4.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "okgeometry-api",
-  "version": "0.4.5",
+  "version": "0.4.6",
   "description": "Geometry engine API for AEC applications — NURBS, meshes, booleans, intersections. Powered by Rust/WASM.",
   "type": "module",
   "main": "dist/index.js",

package/wasm/okgeometrycore_bg.js

@@ -289,6 +289,28 @@ export function line_length(x1, y1, z1, x2, y2, z2) {
     return ret;
 }
 
+/**
+ * Offset a line segment perpendicular to line direction relative to reference normal.
+ * Returns [startX,startY,startZ,endX,endY,endZ]
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} z1
+ * @param {number} x2
+ * @param {number} y2
+ * @param {number} z2
+ * @param {number} distance
+ * @param {number} nx
+ * @param {number} ny
+ * @param {number} nz
+ * @returns {Float64Array}
+ */
+export function line_offset(x1, y1, z1, x2, y2, z2, distance, nx, ny, nz) {
+    const ret = wasm.line_offset(x1, y1, z1, x2, y2, z2, distance, nx, ny, nz);
+    var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v1;
+}
+
 /**
  * Evaluate a point on a line segment at parameter t ∈ [0,1].
  * Returns [x, y, z].
@@ -372,20 +394,20 @@ export function loft_nurbs_surface(data) {
  * # Parameters
  * * `polyline_data` - Flat array where each polyline is prefixed by its point count:
  *   [count1, x1, y1, z1, x2, y2, z2, ..., count2, x1, y1, z1, ...]
- * * `segments` - Number of segments to sample along each curve
- * * `with_caps` - Whether to create end caps
+ * * `_segments` - Ignored for polylines (kept for API compat). Points are used directly.
+ * * `with_caps` - Whether to create end caps (fan triangulation from center)
  *
  * # Returns
  * Mesh buffers for the lofted surface
  * @param {Float64Array} polyline_data
- * @param {number} segments
+ * @param {number} _segments
  * @param {boolean} with_caps
  * @returns {Float64Array}
  */
-export function loft_polylines(polyline_data, segments, with_caps) {
+export function loft_polylines(polyline_data, _segments, with_caps) {
     const ptr0 = passArrayF64ToWasm0(polyline_data, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.loft_polylines(ptr0, len0, segments, with_caps);
+    const ret = wasm.loft_polylines(ptr0, len0, _segments, with_caps);
     var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
     wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
     return v2;
@@ -532,6 +554,23 @@ export function mesh_boundary_polylines(vertex_count, buffer) {
     return v2;
 }
 
+/**
+ * Coplanar connected face groups.
+ * Output format:
+ * [groupCount, triCount, tri..., centroidX,centroidY,centroidZ, normalX,normalY,normalZ, ...]
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @returns {Float64Array}
+ */
+export function mesh_build_coplanar_connected_face_groups(vertex_count, buffer) {
+    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_build_coplanar_connected_face_groups(vertex_count, ptr0, len0);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
 /**
  * Chamfer all edges of a primitive mesh (flat bevel)
  *
@@ -558,6 +597,37 @@ export function mesh_chamfer_all_edges(mesh_type, params, offset) {
     return v3;
 }
 
+/**
+ * Compute planar curve normal from ordered points.
+ * @param {Float64Array} coords
+ * @param {boolean} closed
+ * @returns {Float64Array}
+ */
+export function mesh_compute_planar_curve_normal(coords, closed) {
+    const ptr0 = passArrayF64ToWasm0(coords, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_compute_planar_curve_normal(ptr0, len0, closed);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
+/**
+ * Odd/even mesh containment test.
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @param {number} px
+ * @param {number} py
+ * @param {number} pz
+ * @returns {boolean}
+ */
+export function mesh_contains_point(vertex_count, buffer, px, py, pz) {
+    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_contains_point(vertex_count, ptr0, len0, px, py, pz);
+    return ret !== 0;
+}
+
 /**
  * Create a box mesh and return buffers
  * Returns [vertices..., indices...]
@@ -629,6 +699,26 @@ export function mesh_create_sphere(radius, segments, rings) {
     return v1;
 }
 
+/**
+ * Evaluate a point on a mesh surface at parametric coordinates (u, v).
+ * Maps u ∈ [0,1] and v ∈ [0,1] to the mesh's AABB bounding box,
+ * then casts a ray perpendicular to the best-fit projection plane.
+ * Returns [x, y, z] of the intersection point, or [NaN, NaN, NaN] if no hit.
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @param {number} u
+ * @param {number} v
+ * @returns {Float64Array}
+ */
+export function mesh_evaluate(vertex_count, buffer, u, v) {
+    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_evaluate(vertex_count, ptr0, len0, u, v);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
 /**
  * Export a mesh to OBJ format
  * Takes mesh buffers as input (same format as mesh_to_buffers output)
@@ -652,6 +742,220 @@ export function mesh_export_obj(vertex_count, buffer) {
     }
 }
 
+/**
+ * Push/pull a planar face set by moving its coplanar connected region.
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @param {number} face_index
+ * @param {number} distance
+ * @returns {Float64Array}
+ */
+export function mesh_extrude_face(vertex_count, buffer, face_index, distance) {
+    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_extrude_face(vertex_count, ptr0, len0, face_index, distance);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
+/**
+ * Extrude planar curve profile by normal * height.
+ * @param {Float64Array} coords
+ * @param {number} nx
+ * @param {number} ny
+ * @param {number} nz
+ * @param {number} height
+ * @param {boolean} closed
+ * @returns {Float64Array}
+ */
+export function mesh_extrude_planar_curve(coords, nx, ny, nz, height, closed) {
+    const ptr0 = passArrayF64ToWasm0(coords, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_extrude_planar_curve(ptr0, len0, nx, ny, nz, height, closed);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
+/**
+ * Find the best matching coplanar connected face group by normal and optional near-point.
+ * Output format: [centroidX, centroidY, centroidZ, normalX, normalY, normalZ] or [].
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @param {number} nx
+ * @param {number} ny
+ * @param {number} nz
+ * @param {number} near_x
+ * @param {number} near_y
+ * @param {number} near_z
+ * @param {boolean} use_near_point
+ * @returns {Float64Array}
+ */
+export function mesh_find_face_group_by_normal(vertex_count, buffer, nx, ny, nz, near_x, near_y, near_z, use_near_point) {
+    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_find_face_group_by_normal(vertex_count, ptr0, len0, nx, ny, nz, near_x, near_y, near_z, use_near_point);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
+/**
+ * Find the coplanar connected face group containing triangle_index.
+ * Output format: [centroidX, centroidY, centroidZ, normalX, normalY, normalZ] or [].
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @param {number} triangle_index
+ * @returns {Float64Array}
+ */
+export function mesh_find_face_group_by_triangle_index(vertex_count, buffer, triangle_index) {
+    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_find_face_group_by_triangle_index(vertex_count, ptr0, len0, triangle_index);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
+/**
+ * Axis-aligned bounding box as [minX, minY, minZ, maxX, maxY, maxZ].
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @returns {Float64Array}
+ */
+export function mesh_get_bounds(vertex_count, buffer) {
+    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_get_bounds(vertex_count, ptr0, len0);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
+/**
+ * Coplanar connected face-group centroid containing a given triangle face index.
+ * Output format: [x, y, z] or [] when unavailable.
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @param {number} face_index
+ * @returns {Float64Array}
+ */
+export function mesh_get_coplanar_face_group_centroid(vertex_count, buffer, face_index) {
+    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_get_coplanar_face_group_centroid(vertex_count, ptr0, len0, face_index);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
+/**
+ * Edge-connected coplanar triangle indices as [count, i0, i1, ...].
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @param {number} face_index
+ * @returns {Float64Array}
+ */
+export function mesh_get_coplanar_face_indices(vertex_count, buffer, face_index) {
+    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_get_coplanar_face_indices(vertex_count, ptr0, len0, face_index);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
+/**
+ * Coplanar connected face region projected to a plane basis.
+ * Output format:
+ * [faceCount, faceIndex0, faceIndex1, ..., uMin, uMax, vMin, vMax]
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @param {number} face_index
+ * @param {number} ox
+ * @param {number} oy
+ * @param {number} oz
+ * @param {number} ux
+ * @param {number} uy
+ * @param {number} uz
+ * @param {number} vx
+ * @param {number} vy
+ * @param {number} vz
+ * @param {number} margin_scale
+ * @param {number} min_margin
+ * @returns {Float64Array}
+ */
+export function mesh_get_coplanar_face_region(vertex_count, buffer, face_index, ox, oy, oz, ux, uy, uz, vx, vy, vz, margin_scale, min_margin) {
+    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_get_coplanar_face_region(vertex_count, ptr0, len0, face_index, ox, oy, oz, ux, uy, uz, vx, vy, vz, margin_scale, min_margin);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
+/**
+ * Unique undirected triangle edges as [edgeCount, v0a, v0b, v1a, v1b, ...].
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @returns {Float64Array}
+ */
+export function mesh_get_edge_vertex_pairs(vertex_count, buffer) {
+    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_get_edge_vertex_pairs(vertex_count, ptr0, len0);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
+/**
+ * Face area.
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @param {number} face_index
+ * @returns {number}
+ */
+export function mesh_get_face_area(vertex_count, buffer, face_index) {
+    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_get_face_area(vertex_count, ptr0, len0, face_index);
+    return ret;
+}
+
+/**
+ * Face centroid as [x, y, z].
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @param {number} face_index
+ * @returns {Float64Array}
+ */
+export function mesh_get_face_centroid(vertex_count, buffer, face_index) {
+    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_get_face_centroid(vertex_count, ptr0, len0, face_index);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
+/**
+ * Face normal as [x, y, z].
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @param {number} face_index
+ * @returns {Float64Array}
+ */
+export function mesh_get_face_normal(vertex_count, buffer, face_index) {
+    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_get_face_normal(vertex_count, ptr0, len0, face_index);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
 /**
  * Get mesh statistics
  * Returns [vertex_count, face_count, edge_count]
@@ -682,6 +986,34 @@ export function mesh_import_obj(obj_data) {
     return v2;
 }
 
+/**
+ * Check if triangulated mesh is a closed volume (no welded boundary edges).
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @returns {boolean}
+ */
+export function mesh_is_closed_volume(vertex_count, buffer) {
+    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_is_closed_volume(vertex_count, ptr0, len0);
+    return ret !== 0;
+}
+
+/**
+ * Merge multiple mesh buffers while preserving per-mesh vertex order and index remapping.
+ * Input format: [mesh_count, len1, mesh1..., len2, mesh2..., ...]
+ * @param {Float64Array} mesh_data
+ * @returns {Float64Array}
+ */
+export function mesh_merge(mesh_data) {
+    const ptr0 = passArrayF64ToWasm0(mesh_data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_merge(ptr0, len0);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
 /**
  * Intersect two meshes, returning intersection polyline points.
  * Returns: [num_polylines, n1, x,y,z,..., n2, x,y,z,...]
@@ -702,6 +1034,23 @@ export function mesh_mesh_intersect(va_count, buffer_a, vb_count, buffer_b) {
     return v3;
 }
 
+/**
+ * Create a planar patch mesh from boundary points using CDT.
+ * Correctly handles concave polygons (unlike fan triangulation).
+ * Input: flat coordinate array [x1,y1,z1, x2,y2,z2, ...]
+ * Output: mesh buffer [vertexCount, x1,y1,z1,..., i0,i1,i2, ...]
+ * @param {Float64Array} coords
+ * @returns {Float64Array}
+ */
+export function mesh_patch_from_points(coords) {
+    const ptr0 = passArrayF64ToWasm0(coords, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_patch_from_points(ptr0, len0);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
 /**
  * Intersect a mesh with a plane, returning polyline points.
  * Input: vertex_count, mesh_buffer..., nx, ny, nz, d
@@ -723,6 +1072,95 @@ export function mesh_plane_intersect(vertex_count, buffer, nx, ny, nz, d) {
     return v2;
 }
 
+/**
+ * Shift closed boolean cutter curve and adjust height.
+ * Returns [height, epsilon, pointCount, x,y,z,...]
+ * @param {Float64Array} coords
+ * @param {boolean} closed
+ * @param {number} nx
+ * @param {number} ny
+ * @param {number} nz
+ * @param {number} height
+ * @returns {Float64Array}
+ */
+export function mesh_prepare_boolean_cutter_curve(coords, closed, nx, ny, nz, height) {
+    const ptr0 = passArrayF64ToWasm0(coords, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_prepare_boolean_cutter_curve(ptr0, len0, closed, nx, ny, nz, height);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
+/**
+ * Raycast against mesh and return closest hit.
+ * Output: [] when no hit, otherwise [pointX,pointY,pointZ, normalX,normalY,normalZ, faceIndex, distance]
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @param {number} ox
+ * @param {number} oy
+ * @param {number} oz
+ * @param {number} dx
+ * @param {number} dy
+ * @param {number} dz
+ * @param {number} max_distance
+ * @returns {Float64Array}
+ */
+export function mesh_raycast(vertex_count, buffer, ox, oy, oz, dx, dy, dz, max_distance) {
+    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_raycast(vertex_count, ptr0, len0, ox, oy, oz, dx, dy, dz, max_distance);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
+/**
+ * Raycast against mesh and return all hits sorted by distance.
+ * Output: [hitCount, (point, normal, faceIndex, distance)*]
+ * @param {number} vertex_count
+ * @param {Float64Array} buffer
+ * @param {number} ox
+ * @param {number} oy
+ * @param {number} oz
+ * @param {number} dx
+ * @param {number} dy
+ * @param {number} dz
+ * @param {number} max_distance
+ * @returns {Float64Array}
+ */
+export function mesh_raycast_all(vertex_count, buffer, ox, oy, oz, dx, dy, dz, max_distance) {
+    const ptr0 = passArrayF64ToWasm0(buffer, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_raycast_all(vertex_count, ptr0, len0, ox, oy, oz, dx, dy, dz, max_distance);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
+/**
+ * Raycast against many meshes packed as:
+ * [meshCount, meshLen0, meshRaw0..., meshLen1, meshRaw1..., ...]
+ * Output: [hitCount, meshIndex, pointX,pointY,pointZ, normalX,normalY,normalZ, faceIndex, distance, ...]
+ * @param {Float64Array} mesh_data
+ * @param {number} ox
+ * @param {number} oy
+ * @param {number} oz
+ * @param {number} dx
+ * @param {number} dy
+ * @param {number} dz
+ * @param {number} max_distance
+ * @returns {Float64Array}
+ */
+export function mesh_raycast_many(mesh_data, ox, oy, oz, dx, dy, dz, max_distance) {
+    const ptr0 = passArrayF64ToWasm0(mesh_data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mesh_raycast_many(ptr0, len0, ox, oy, oz, dx, dy, dz, max_distance);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+}
+
 /**
  * Rotate a mesh around an arbitrary axis and return new buffers
  * Axis is defined by (ax, ay, az), angle in radians