okgeometry-api 1.14.0 → 1.15.0

package/dist/Mesh.js

@@ -2159,6 +2159,151 @@ export class Mesh {
         const outside = readGroup();
         return { inside, outside };
     }
+    /**
+     * Compute all transversal crossing points of a polyline with this mesh.
+     * Works on OPEN meshes (sheets) — unlike `clipPolyline`, the mesh is NOT
+     * required to be a closed volume.
+     *
+     * Hits are deduplicated (shared-edge / shared-vertex crossings merge into
+     * one, keeping the smallest triangle index) and sorted by
+     * (segmentIndex, segmentT). Coplanar sliding overlaps yield no hits.
+     * Segment `i` runs from point `i` to point `(i + 1) % n`; open polylines
+     * have n − 1 segments, closed ones n (the wrap segment).
+     *
+     * @param polyline - Polyline (closedness inferred) or raw point list
+     * @param closed - Treat the points as a closed loop (defaults to the
+     *   polyline's own closedness; required when passing a raw point list)
+     * @returns Crossings with the 3D point, segment index/parameter, and
+     *   triangle index
+     */
+    intersectPolyline(polyline, closed) {
+        ensureInit();
+        const { flat, isClosed } = Mesh.flattenPolylineArg(polyline, closed, "Mesh.intersectPolyline");
+        const buf = wasm.mesh_polyline_intersection_points(this._vertexCount, this._buffer, flat, isClosed);
+        if (buf.length === 0) {
+            throw new Error("Mesh.intersectPolyline failed — the mesh and polyline must be non-degenerate.");
+        }
+        const count = buf[0];
+        const hits = [];
+        for (let i = 0; i < count; i++) {
+            const off = 1 + i * 6;
+            hits.push({
+                point: new Point(buf[off], buf[off + 1], buf[off + 2]),
+                segmentIndex: buf[off + 3],
+                segmentT: buf[off + 4],
+                triangleIndex: buf[off + 5],
+            });
+        }
+        return hits;
+    }
+    /**
+     * Split a polyline into pieces at every crossing with this mesh (open
+     * sheets allowed). Hit points become the shared endpoints of adjacent
+     * pieces; a closed loop is opened at the first crossing (N crossings → N
+     * pieces), an open polyline yields N + 1 pieces. With no crossings the
+     * original polyline comes back as one piece. Pieces are NOT classified —
+     * use `clipPolyline` (closed volume, containment) or
+     * `clipPolylineBySheet` (oriented sheet, signed side) for classification.
+     *
+     * @param polyline - Polyline (closedness inferred) or raw point list
+     * @param closed - Treat the points as a closed loop (defaults to the
+     *   polyline's own closedness; required when passing a raw point list)
+     * @returns Polyline pieces in order along the input
+     */
+    splitPolyline(polyline, closed) {
+        ensureInit();
+        const { flat, isClosed } = Mesh.flattenPolylineArg(polyline, closed, "Mesh.splitPolyline");
+        const buf = wasm.mesh_split_polyline(this._vertexCount, this._buffer, flat, isClosed);
+        if (buf.length === 0) {
+            throw new Error("Mesh.splitPolyline failed — the mesh and polyline must be non-degenerate.");
+        }
+        return parsePolylineBuf(buf).map(pts => new Polyline(pts));
+    }
+    /**
+     * Clip a polyline by this mesh treated as an OPEN oriented sheet: the
+     * polyline is split at every crossing and each piece is classified by the
+     * SIGNED SIDE of the sheet — `inside` = in FRONT of the sheet normal,
+     * `outside` = behind it (the mesh's stored winding defines the normals).
+     *
+     * This is side classification, NOT containment — unlike `clipPolyline`,
+     * which requires a CLOSED volume: the sheet may be open, and pieces far
+     * from it still classify deterministically by the nearest facet's normal.
+     * Pieces lying ON the sheet default to `inside`. Adjacent same-side pieces
+     * (e.g. from a touch, not a crossing) merge back into one run; closed
+     * loops merge the run spanning the seam.
+     *
+     * @param polyline - Polyline (closedness inferred) or raw point list
+     * @param closed - Treat the points as a closed loop (defaults to the
+     *   polyline's own closedness; required when passing a raw point list)
+     */
+    clipPolylineBySheet(polyline, closed) {
+        ensureInit();
+        const { flat, isClosed } = Mesh.flattenPolylineArg(polyline, closed, "Mesh.clipPolylineBySheet");
+        const buf = wasm.mesh_clip_polyline_by_sheet(this._vertexCount, this._buffer, flat, isClosed);
+        if (buf.length === 0) {
+            throw new Error("Mesh.clipPolylineBySheet failed — the sheet and polyline must be non-degenerate.");
+        }
+        // Two concatenated polyline groups: inside first, then outside — same
+        // packing as clipPolyline.
+        let idx = 0;
+        const readGroup = () => {
+            const group = [];
+            const count = buf[idx++];
+            for (let i = 0; i < count; i++) {
+                const n = buf[idx++];
+                const points = [];
+                for (let k = 0; k < n; k++) {
+                    points.push(new Point(buf[idx], buf[idx + 1], buf[idx + 2]));
+                    idx += 3;
+                }
+                if (points.length >= 2)
+                    group.push(new Polyline(points));
+            }
+            return group;
+        };
+        const inside = readGroup();
+        const outside = readGroup();
+        return { inside, outside };
+    }
+    /**
+     * Flatten a Polyline-or-points argument into WASM coords + closed flag.
+     *
+     * Closed inputs following the duplicated-seam convention (terminal point
+     * repeating the first) have the duplicate STRIPPED before crossing the
+     * boundary — the kernel's closed-polyline encoding is seam-free (the wrap
+     * segment is implicit), and a duplicated seam would add a zero-length wrap
+     * segment / doubled seam vertex to split pieces.
+     */
+    static flattenPolylineArg(polyline, closed, context) {
+        let pts = Array.isArray(polyline) ? polyline : polyline.points;
+        if (pts.length < 2) {
+            throw new Error(`${context} needs at least 2 polyline points`);
+        }
+        const isClosed = closed ?? (!Array.isArray(polyline) && polyline.isClosed());
+        if (isClosed && pts.length > 2) {
+            // Scale-relative epsilon for the duplicate-seam test.
+            let maxAbs = 0;
+            for (const p of pts) {
+                maxAbs = Math.max(maxAbs, Math.abs(p.x), Math.abs(p.y), Math.abs(p.z));
+            }
+            const eps = (1 + maxAbs) * 1e-12;
+            const first = pts[0];
+            const last = pts[pts.length - 1];
+            const dx = first.x - last.x;
+            const dy = first.y - last.y;
+            const dz = first.z - last.z;
+            if (Math.sqrt(dx * dx + dy * dy + dz * dz) <= eps) {
+                pts = pts.slice(0, -1);
+            }
+        }
+        const flat = new Float64Array(pts.length * 3);
+        for (let i = 0; i < pts.length; i++) {
+            flat[i * 3] = pts[i].x;
+            flat[i * 3 + 1] = pts[i].y;
+            flat[i * 3 + 2] = pts[i].z;
+        }
+        return { flat, isClosed };
+    }
     /**
      * Apply a 4x4 transformation matrix.
      * @param matrix - Row-major flat array of 16 numbers