matterviz 0.3.0 → 0.3.2

package/dist/math.js

@@ -1,3 +1,15 @@
+// Generate all k-element combinations from an array.
+export function combinations(arr, k) {
+    if (k === 0)
+        return [[]];
+    if (arr.length < k)
+        return [];
+    const [first, ...rest] = arr;
+    return [
+        ...combinations(rest, k - 1).map((combo) => [first, ...combo]),
+        ...combinations(rest, k),
+    ];
+}
 export const LOG_EPS = 1e-9;
 export const EPS = 1e-10;
 export const RAD_TO_DEG = 180 / Math.PI;
@@ -130,16 +142,19 @@ function validate_matrix(mat, name) {
     return cols;
 }
 export function dot(vec1, vec2) {
+    const vec1_is_matrix = vec1.some((entry) => Array.isArray(entry));
+    const vec2_is_matrix = vec2.some((entry) => Array.isArray(entry));
     // Vector dot product
-    if (!Array.isArray(vec1[0]) && !Array.isArray(vec2[0])) {
-        const v1 = vec1;
-        const v2 = vec2;
-        if (v1.length !== v2.length)
+    if (!vec1_is_matrix && !vec2_is_matrix) {
+        const left_vec = vec1;
+        const right_vec = vec2;
+        if (left_vec.length !== right_vec.length) {
             throw new Error(`Vectors must be of same length`);
-        return v1.reduce((sum, val, idx) => sum + val * v2[idx], 0);
+        }
+        return left_vec.reduce((sum, val, idx) => sum + val * right_vec[idx], 0);
     }
     // Matrix-vector multiplication
-    if (Array.isArray(vec1[0]) && !Array.isArray(vec2[0])) {
+    if (vec1_is_matrix && !vec2_is_matrix) {
         const mat = vec1;
         const vec = vec2;
         const cols = validate_matrix(mat, `Matrix`);
@@ -149,7 +164,7 @@ export function dot(vec1, vec2) {
         return mat.map((row) => row.reduce((sum, val, idx) => sum + val * vec[idx], 0));
     }
     // Matrix-matrix multiplication
-    if (Array.isArray(vec1[0]) && Array.isArray(vec2[0])) {
+    if (vec1_is_matrix && vec2_is_matrix) {
         const mat1 = vec1;
         const mat2 = vec2;
         const mat1_cols = validate_matrix(mat1, `First matrix`);
@@ -353,6 +368,10 @@ export const centered_frac = (val) => {
         wrapped -= 1;
     return wrapped || 0; // normalize -0 to 0
 };
+// Element-wise equality check for two optional Vec3s.
+// Returns true if both are the same reference, or both are defined with equal components.
+export const vecs_equal = (vec_a, vec_b) => vec_a === vec_b || (!!vec_a && !!vec_b &&
+    vec_a[0] === vec_b[0] && vec_a[1] === vec_b[1] && vec_a[2] === vec_b[2]);
 // Normalize a Vec3 to unit length, returns zero vector if input is zero
 export function normalize_vec3(vec, fallback) {
     const len = Math.hypot(vec[0], vec[1], vec[2]);
@@ -360,6 +379,246 @@ export function normalize_vec3(vec, fallback) {
         return fallback ?? [0, 0, 0];
     return [vec[0] / len, vec[1] / len, vec[2] / len];
 }
+// Compute orthonormal basis vectors in a plane perpendicular to `normal`.
+// Uses Gram-Schmidt orthogonalization + cross product.
+export function compute_in_plane_basis(normal) {
+    let ref_vec = [1, 0, 0];
+    if (Math.abs(normal[0]) > 0.9)
+        ref_vec = [0, 1, 0];
+    const dot_nr = dot(normal, ref_vec);
+    const u_raw = [
+        ref_vec[0] - dot_nr * normal[0],
+        ref_vec[1] - dot_nr * normal[1],
+        ref_vec[2] - dot_nr * normal[2],
+    ];
+    const u_vec = normalize_vec3(u_raw, [0, 1, 0]);
+    const v_vec = cross_3d(normal, u_vec);
+    return [u_vec, v_vec];
+}
+// Check whether N 3D points all lie on the same plane within tolerance.
+// Fewer than 3 points are trivially coplanar.
+// Uses cross product to find a plane normal from non-collinear edges,
+// then checks all remaining points have zero distance to that plane.
+export function are_coplanar(points, tolerance = 1e-6) {
+    if (points.length < 3)
+        return true;
+    const origin = points[0];
+    // Find first pair of edges from origin that are not collinear
+    let normal = null;
+    for (let idx = 1; idx < points.length - 1; idx++) {
+        const edge_a = [
+            points[idx][0] - origin[0],
+            points[idx][1] - origin[1],
+            points[idx][2] - origin[2],
+        ];
+        for (let jdx = idx + 1; jdx < points.length; jdx++) {
+            const edge_b = [
+                points[jdx][0] - origin[0],
+                points[jdx][1] - origin[1],
+                points[jdx][2] - origin[2],
+            ];
+            const cross = cross_3d(edge_a, edge_b);
+            const len = Math.hypot(cross[0], cross[1], cross[2]);
+            if (len > tolerance) {
+                normal = [cross[0] / len, cross[1] / len, cross[2] / len];
+                break;
+            }
+        }
+        if (normal)
+            break;
+    }
+    // All edges are collinear -> all points lie on a line -> coplanar
+    if (!normal)
+        return true;
+    const plane_d = dot(normal, origin);
+    for (let idx = 1; idx < points.length; idx++) {
+        const dist = Math.abs(dot(normal, points[idx]) - plane_d);
+        if (dist > tolerance)
+            return false;
+    }
+    return true;
+}
+// Merge coplanar adjacent triangles in a flat non-indexed position array.
+// Takes 9 floats per triangle (3 vertices x 3 coords), groups adjacent coplanar
+// triangles via union-find, then re-triangulates each group with fan triangulation
+// to eliminate internal diagonal edges.
+export function merge_coplanar_triangles(positions, tolerance = 1e-4) {
+    const n_triangles = Math.floor(positions.length / 9);
+    if (n_triangles === 0)
+        return new Float32Array(positions);
+    const tri_planes = [];
+    for (let tri_idx = 0; tri_idx < n_triangles; tri_idx++) {
+        const base = tri_idx * 9;
+        const va = [positions[base], positions[base + 1], positions[base + 2]];
+        const vb = [positions[base + 3], positions[base + 4], positions[base + 5]];
+        const vc = [positions[base + 6], positions[base + 7], positions[base + 8]];
+        const edge_ab = [vb[0] - va[0], vb[1] - va[1], vb[2] - va[2]];
+        const edge_ac = [vc[0] - va[0], vc[1] - va[1], vc[2] - va[2]];
+        const raw_normal = cross_3d(edge_ab, edge_ac);
+        const len = Math.hypot(raw_normal[0], raw_normal[1], raw_normal[2]);
+        if (len < tolerance) {
+            tri_planes.push({
+                verts: [va, vb, vc],
+                normal: [0, 0, 0],
+                plane_d: 0,
+                degenerate: true,
+            });
+            continue;
+        }
+        // Normalize and canonicalize: first non-zero component must be positive
+        let normal = [raw_normal[0] / len, raw_normal[1] / len, raw_normal[2] / len];
+        const CANON_EPS = 1e-12;
+        const first_nonzero = Math.abs(normal[0]) > CANON_EPS
+            ? normal[0]
+            : Math.abs(normal[1]) > CANON_EPS
+                ? normal[1]
+                : normal[2];
+        if (first_nonzero < 0)
+            normal = [-normal[0], -normal[1], -normal[2]];
+        const plane_d = dot(normal, va);
+        tri_planes.push({ verts: [va, vb, vc], normal, plane_d, degenerate: false });
+    }
+    // === Step 2: Build adjacency via edge hash map ===
+    // Quantize vertex to integer grid for hashing (only used for equality, not coords)
+    const vert_key = (v) => `${Math.round(v[0] / tolerance)},${Math.round(v[1] / tolerance)},${Math.round(v[2] / tolerance)}`;
+    const edge_key = (va, vb) => {
+        const ka = vert_key(va);
+        const kb = vert_key(vb);
+        return ka < kb ? `${ka}|${kb}` : `${kb}|${ka}`;
+    };
+    // Map edge -> list of triangle indices sharing that edge
+    const edge_to_tris = new Map();
+    for (let tri_idx = 0; tri_idx < n_triangles; tri_idx++) {
+        const { verts, degenerate } = tri_planes[tri_idx];
+        if (degenerate)
+            continue;
+        const edges = [
+            edge_key(verts[0], verts[1]),
+            edge_key(verts[1], verts[2]),
+            edge_key(verts[0], verts[2]),
+        ];
+        for (const ek of edges) {
+            const existing = edge_to_tris.get(ek);
+            if (existing)
+                existing.push(tri_idx);
+            else
+                edge_to_tris.set(ek, [tri_idx]);
+        }
+    }
+    // === Step 3: Union-Find grouping of coplanar adjacent triangles ===
+    const parent = new Int32Array(n_triangles);
+    const rank = new Int32Array(n_triangles);
+    for (let idx = 0; idx < n_triangles; idx++)
+        parent[idx] = idx;
+    const find = (x) => {
+        while (parent[x] !== x) {
+            parent[x] = parent[parent[x]]; // path compression
+            x = parent[x];
+        }
+        return x;
+    };
+    const union = (a, b) => {
+        const ra = find(a), rb = find(b);
+        if (ra === rb)
+            return;
+        if (rank[ra] < rank[rb])
+            parent[ra] = rb;
+        else if (rank[ra] > rank[rb])
+            parent[rb] = ra;
+        else {
+            parent[rb] = ra;
+            rank[ra]++;
+        }
+    };
+    for (const tri_list of edge_to_tris.values()) {
+        if (tri_list.length !== 2)
+            continue;
+        const [idx_a, idx_b] = tri_list;
+        const pa = tri_planes[idx_a];
+        const pb = tri_planes[idx_b];
+        if (pa.degenerate || pb.degenerate)
+            continue;
+        // Check coplanarity: same canonical normal direction AND same plane distance
+        const normal_dot = pa.normal[0] * pb.normal[0] + pa.normal[1] * pb.normal[1] +
+            pa.normal[2] * pb.normal[2];
+        if (Math.abs(normal_dot) < 1 - tolerance)
+            continue;
+        if (Math.abs(pa.plane_d - pb.plane_d) > tolerance)
+            continue;
+        union(idx_a, idx_b);
+    }
+    // === Step 4: Collect groups ===
+    const groups = new Map();
+    for (let idx = 0; idx < n_triangles; idx++) {
+        const root = find(idx);
+        const group = groups.get(root);
+        if (group)
+            group.push(idx);
+        else
+            groups.set(root, [idx]);
+    }
+    // === Step 5: Merge each group and re-triangulate ===
+    const output = [];
+    // Push a triangle's 3 vertices (9 floats) to the output
+    const emit_tri = (va, vb, vc) => {
+        output.push(va[0], va[1], va[2], vb[0], vb[1], vb[2], vc[0], vc[1], vc[2]);
+    };
+    const emit_original = (members) => {
+        for (const tri_idx of members) {
+            const { verts } = tri_planes[tri_idx];
+            emit_tri(verts[0], verts[1], verts[2]);
+        }
+    };
+    for (const members of groups.values()) {
+        if (members.length === 1) {
+            emit_original(members);
+            continue;
+        }
+        const { normal } = tri_planes[members[0]];
+        // Collect all unique vertices from the group
+        const seen_keys = new Map();
+        for (const tri_idx of members) {
+            for (const vert of tri_planes[tri_idx].verts) {
+                const key = vert_key(vert);
+                if (!seen_keys.has(key))
+                    seen_keys.set(key, vert);
+            }
+        }
+        const unique_verts = [...seen_keys.values()];
+        if (unique_verts.length < 3) {
+            emit_original(members);
+            continue;
+        }
+        // Project to 2D using in-plane basis
+        const [u_vec, v_vec] = compute_in_plane_basis(normal);
+        const pts_2d = unique_verts.map((vert) => [dot(u_vec, vert), dot(v_vec, vert)]);
+        const hull = convex_hull_2d(pts_2d);
+        if (hull.length < 3) {
+            emit_original(members);
+            continue;
+        }
+        // Map 2D hull vertices back to nearest 3D vertex
+        const hull_3d = hull.map((pt) => {
+            let best_dist = Infinity;
+            let best_idx = 0;
+            for (let idx = 0; idx < pts_2d.length; idx++) {
+                const du = pts_2d[idx][0] - pt[0];
+                const dv = pts_2d[idx][1] - pt[1];
+                const dist = du * du + dv * dv;
+                if (dist < best_dist) {
+                    best_dist = dist;
+                    best_idx = idx;
+                }
+            }
+            return unique_verts[best_idx];
+        });
+        // Fan-triangulate from hull vertex 0
+        for (let idx = 1; idx < hull_3d.length - 1; idx++) {
+            emit_tri(hull_3d[0], hull_3d[idx], hull_3d[idx + 1]);
+        }
+    }
+    return new Float32Array(output);
+}
 // Compute axis-aligned bounding box of Vec3 vertices
 export function compute_bounding_box(vertices) {
     if (vertices.length === 0) {
@@ -461,3 +720,111 @@ export function polygon_centroid(vertices) {
     const factor = 1 / (6 * signed_area);
     return [cx * factor, cy * factor];
 }
+// Solve linear system Ax = b via LU decomposition with partial pivoting.
+// Returns null if the system is singular (no unique solution).
+// Fast-paths for 2x2 (Cramer's rule) and 3x3 (matrix inverse).
+export function solve_linear_system(A, // NxN coefficient matrix
+b) {
+    const n = A.length;
+    if (n === 0 || b.length !== n || !A.every((row) => row.length === n))
+        return null;
+    // 2x2 fast path via Cramer's rule
+    if (n === 2) {
+        const det = A[0][0] * A[1][1] - A[0][1] * A[1][0];
+        if (Math.abs(det) < EPS)
+            return null;
+        return [
+            (b[0] * A[1][1] - b[1] * A[0][1]) / det,
+            (A[0][0] * b[1] - A[1][0] * b[0]) / det,
+        ];
+    }
+    // 3x3 fast path via matrix inverse
+    if (n === 3) {
+        const det = det_3x3(A);
+        if (Math.abs(det) < EPS)
+            return null;
+        const inv = matrix_inverse_3x3(A);
+        return mat3x3_vec3_multiply(inv, b);
+    }
+    // General NxN: LU decomposition with partial pivoting + forward/back substitution
+    const lu = A.map((row) => [...row]);
+    const perm = Array.from({ length: n }, (_, idx) => idx);
+    for (let col = 0; col < n; col++) {
+        // Find pivot
+        let max_row = col;
+        let max_val = Math.abs(lu[col][col]);
+        for (let row = col + 1; row < n; row++) {
+            const val = Math.abs(lu[row][col]);
+            if (val > max_val) {
+                max_val = val;
+                max_row = row;
+            }
+        }
+        if (max_val < EPS)
+            return null; // singular
+        // Swap rows
+        if (max_row !== col) {
+            ;
+            [lu[col], lu[max_row]] = [lu[max_row], lu[col]];
+            [perm[col], perm[max_row]] = [perm[max_row], perm[col]];
+        }
+        // Eliminate below pivot
+        const pivot = lu[col][col];
+        for (let row = col + 1; row < n; row++) {
+            const factor = lu[row][col] / pivot;
+            lu[row][col] = factor; // store L factor in lower triangle
+            for (let k = col + 1; k < n; k++) {
+                lu[row][k] -= factor * lu[col][k];
+            }
+        }
+    }
+    // Apply permutation to b
+    const pb = perm.map((idx) => b[idx]);
+    // Forward substitution (Ly = Pb)
+    for (let row = 1; row < n; row++) {
+        for (let col = 0; col < row; col++) {
+            pb[row] -= lu[row][col] * pb[col];
+        }
+    }
+    // Back substitution (Ux = y)
+    const x = new Array(n).fill(0);
+    for (let row = n - 1; row >= 0; row--) {
+        let sum = pb[row];
+        for (let col = row + 1; col < n; col++) {
+            sum -= lu[row][col] * x[col];
+        }
+        x[row] = sum / lu[row][row];
+    }
+    return x;
+}
+// Full 2D convex hull via Andrew's monotone chain algorithm.
+// Returns vertices in counter-clockwise order.
+export function convex_hull_2d(points) {
+    if (points.length < 3)
+        return [...points];
+    const sorted = [...points].sort((a, b) => (a[0] - b[0]) || (a[1] - b[1]));
+    const cross = (o, a, b) => (a[0] - o[0]) * (b[1] - o[1]) - (a[1] - o[1]) * (b[0] - o[0]);
+    // Lower hull
+    const lower = [];
+    for (const pt of sorted) {
+        while (lower.length >= 2 &&
+            cross(lower[lower.length - 2], lower[lower.length - 1], pt) <= 0) {
+            lower.pop();
+        }
+        lower.push(pt);
+    }
+    // Upper hull
+    const upper = [];
+    for (let idx = sorted.length - 1; idx >= 0; idx--) {
+        const pt = sorted[idx];
+        while (upper.length >= 2 &&
+            cross(upper[upper.length - 2], upper[upper.length - 1], pt) <= 0) {
+            upper.pop();
+        }
+        upper.push(pt);
+    }
+    // Remove last point of each half (it's the first point of the other)
+    lower.pop();
+    upper.pop();
+    return [...lower, ...upper];
+}

package/dist/overlays/ContextMenu.svelte

@@ -15,7 +15,7 @@ function get_smart_position() {
 // Handle click outside to close
 function handle_click_outside(event) {
     const target = event.target;
-    if (visible) {
+    if (target instanceof Element && visible) {
         const menu = target.closest(`.context-menu`);
         if (!menu)
             on_close?.();
@@ -25,7 +25,8 @@ function handle_click_outside(event) {
 function handle_right_click_outside(event) {
     if (!visible)
         return;
-    const menu = event.target.closest(`.context-menu`);
+    const target = event.target;
+    const menu = target instanceof Element ? target.closest(`.context-menu`) : null;
     if (!menu) {
         event.preventDefault();
         on_close?.();