@woosh/meep-engine 2.37.20 → 2.38.2

package/core/geom/3d/topology/query/query_face_next_vertex.js

@@ -0,0 +1,19 @@
+/**
+ * Next vertex in the loop around the face
+ * @param {TopoTriangle} face
+ * @param {TopoVertex} vertex
+ * @returns {TopoVertex}
+ */
+export function query_face_next_vertex(face, vertex) {
+    const vertices = face.vertices;
+    const vertex_count = vertices.length;
+
+    for (let i = 0; i < vertex_count; i++) {
+        if (vertices[i] === vertex) {
+            return vertices[(i + 1) % vertex_count];
+        }
+    }
+
+    throw new Error('Vertex is not part of this face');
+}
+

package/core/geom/3d/topology/query/query_face_prev_vertex.js

@@ -0,0 +1,18 @@
+/**
+ * Next vertex in the loop around the face
+ * @param {TopoTriangle} face
+ * @param {TopoVertex} vertex
+ * @returns {TopoVertex}
+ */
+export function query_face_prev_vertex(face, vertex) {
+    const vertices = face.vertices;
+    const vertex_count = vertices.length;
+
+    for (let i = 0; i < vertex_count; i++) {
+        if (vertices[i] === vertex) {
+            return vertices[(vertex_count + i - 1) % vertex_count];
+        }
+    }
+
+    throw new Error('Vertex is not part of this face');
+}

package/core/geom/3d/topology/query/query_vertex_in_edge.js

@@ -0,0 +1,14 @@
+import { assert } from "../../../../assert.js";
+
+/**
+ *
+ * @param {TopoEdge} edge
+ * @param {TopoVertex} vertex
+ * @returns {boolean}
+ */
+export function query_vertex_in_edge(edge, vertex) {
+    assert.notNull(edge, 'edge');
+
+    return edge.v0 === vertex || edge.v1 === vertex;
+}
+

package/core/geom/3d/topology/query/query_vertex_pair_share_face.js

@@ -0,0 +1,24 @@
+/**
+ *
+ * @param {TopoVertex} a
+ * @param {TopoVertex} b
+ * @returns {boolean}
+ */
+export function query_vertex_pair_share_face(a, b) {
+    const a_faces = a.faces;
+    const b_faces = b.faces;
+
+    const a_face_count = a_faces.length;
+    const b_face_count = b_faces.length;
+
+    for (let i = 0; i < a_face_count; i++) {
+        for (let j = 0; j < b_face_count; j++) {
+
+            if (a_faces[i] === b_faces[j]) {
+                return true;
+            }
+        }
+    }
+
+    return false;
+}

package/core/geom/3d/topology/query/query_vertices_in_edge.js

@@ -0,0 +1,19 @@
+import { assert } from "../../../../assert.js";
+
+/**
+ *
+ * @param {TopoEdge} edge
+ * @param {TopoVertex} v2
+ * @param {TopoVertex} v1
+ * @returns {boolean}
+ */
+export function query_vertices_in_edge(edge, v1, v2) {
+    assert.notNull(edge, 'edge');
+    assert.notNull(v1, 'v1');
+    assert.notNull(v2, 'v2');
+
+    const a = edge.v0;
+    const b = edge.v1;
+
+    return (a === v1 || a === v2) && (b === v1 || b === v2);
+}

package/core/geom/3d/topology/simplify/collapseEdge.spec.js

@@ -1,7 +1,7 @@
 import { collapseEdge } from "./collapseEdge.js";
-import { TopoEdge } from "../TopoEdge.js";
-import { TopoMesh } from "../TopoMesh.js";
-import { TopoVertex } from "../TopoVertex.js";
+import { TopoEdge } from "../struct/TopoEdge.js";
+import { TopoMesh } from "../struct/TopoMesh.js";
+import { TopoVertex } from "../struct/TopoVertex.js";
 
 test("Collapse empty edge not attached to anything else", () => {
     const mesh = new TopoMesh();
@@ -21,6 +21,4 @@ test("Collapse empty edge not attached to anything else", () => {
     collapseEdge(mesh, edge, v0, v1);
 
     expect(mesh.containsEdge(edge)).toBe(false);
-    expect(mesh.containsVertex(v0)).toBe(false);
-    expect(mesh.containsVertex(v1)).toBe(true);
 });

package/core/geom/3d/topology/simplify/collapse_all_degenerate_edges.js

@@ -1,4 +1,4 @@
-import { collapse_degenerate_edge } from "./collapse_degenerate_edge.js";
+import { tm_edge_kill } from "../tm_edge_kill.js";
 
 /**
  *
@@ -6,30 +6,28 @@ import { collapse_degenerate_edge } from "./collapse_degenerate_edge.js";
  * @param {TopoMesh} mesh
  */
 export function collapse_all_degenerate_edges(edges, mesh) {
-    let pass_edge_count;
 
-    const dead_edges = new Set();
+    let pass_edge_count;
 
     do {
 
         pass_edge_count = 0;
 
         for (let edge of edges) {
-            if (dead_edges.has(edge)) {
-                continue;
-            }
 
             if (!edge.isLinked()) {
-                dead_edges.add(edge);
                 continue;
             }
 
             if (edge.isDegenerateEdge()) {
-                collapse_degenerate_edge(edge, mesh);
+                // collapse_degenerate_edge(edge, mesh);
 
-                pass_edge_count++;
+                tm_edge_kill(mesh,edge);
+
+                // edge.unlink();
+                // tm_kill_only_edge(mesh, edge);
 
-                dead_edges.add(edge);
+                pass_edge_count++;
             }
 
         }

package/core/geom/3d/topology/simplify/compute_face_normal_change_dot_product.js

@@ -1,4 +1,7 @@
 import { v3_dot } from "../../../v3_dot.js";
+import { compute_triangle_normal } from "../struct/TopoTriangle.js";
+
+const scratch_normal = new Float32Array(3);
 
 /**
  * Used to detect face normal flips for mesh optimization.
@@ -62,10 +65,17 @@ export function compute_face_normal_change_dot_product(face, vertex_old, vertex_
     const crossY = vCBz * vABx - vCBx * vABz;
     const crossZ = vCBx * vABy - vCBy * vABx;
 
-    const normal = face.normal;
+    // compute face normal
+    const vertices = face.vertices;
+
+    const vA = vertices[0];
+    const vB = vertices[1];
+    const vC = vertices[2];
+
+    compute_triangle_normal(scratch_normal, vA, vB, vC);
 
     return v3_dot(
         crossX, crossY, crossZ,
-        normal[0], normal[1], normal[2]
+        scratch_normal[0], scratch_normal[1], scratch_normal[2]
     );
 }

package/core/geom/3d/topology/simplify/decimate_edge_collapse_snap.js

@@ -0,0 +1,277 @@
+import { tm_edge_collapse } from "./edge_collapse_quadratic.js";
+import { query_edge_other_vertex } from "../query/query_edge_other_vertex.js";
+import { array_get_index_in_range } from "../../../../collection/array/array_get_index_in_range.js";
+import { compute_edge_collapse_cost_quadratic } from "./quadratic/compute_edge_collapse_cost_quadratic.js";
+import { tm_vertex_compute_normal } from "../tm_vertex_compute_normal.js";
+import { min2 } from "../../../../math/min2.js";
+import { vec3 } from "gl-matrix";
+import { EPSILON } from "../../../../math/MathUtils.js";
+import { tm_edge_collapse_is_degenerate_flip } from "./tm_edge_collapse_is_degenerate_flip.js";
+import { query_edge_is_boundary } from "../query/query_edge_is_boundary.js";
+import { tm_edge_kill } from "../tm_edge_kill.js";
+import { squirrel3 } from "../../../../math/hash/squirrel3.js";
+
+/**
+ *
+ * @type {TopoEdge[]}
+ */
+const scratch_edges = [];
+
+
+const scratch_v3_0 = [];
+const scratch_v3_1 = [];
+
+/**
+ *
+ * @param {TopoVertex} v
+ * @returns {number}
+ */
+function edge_collapse_vertex_removal_cost(v) {
+    let result = 0;
+
+    const edges = v.edges;
+    const edge_count = edges.length;
+
+    for (let i = 0; i < edge_count; i++) {
+        const edge = edges[i];
+
+        if (query_edge_is_boundary(edge)) {
+            result += 100;
+        } else {
+            // prefer not to remove vertices that have lots of faces attached. This is to prevent cases where more and more faces are aggregated around a single vertex
+            result += 1;
+        }
+    }
+
+    return result;
+}
+
+/**
+ *
+ * @param {TopoEdge} edge
+ * @returns {TopoVertex}
+ */
+export function pick_lowest_cost_edge_collapse_vertex(edge) {
+    const v0 = edge.v0;
+    const v1 = edge.v1;
+
+    if (squirrel3(v0.index) > squirrel3(v1.index)) {
+        return v0;
+    } else {
+        return v1;
+    }
+
+    if (edge_collapse_vertex_removal_cost(v0) > edge_collapse_vertex_removal_cost(v1)) {
+        return v0;
+    } else {
+        return v1;
+    }
+}
+
+/**
+ *
+ * @param {TopoEdge} edge
+ * @param {Set<number>} restricted_vertices locked vertices
+ * @returns {TopoVertex|undefined}
+ */
+export function edge_collapse_pick_target_vertex(edge, restricted_vertices) {
+
+    const v0 = edge.v0;
+    const v1 = edge.v1;
+
+    const v0_restricted = restricted_vertices.has(v0.index);
+    const v1_restricted = restricted_vertices.has(v1.index);
+
+    let expected_target;
+
+    if (v0_restricted && v1_restricted) {
+        return;
+    } else if (v0_restricted) {
+        if (tm_edge_collapse_is_degenerate_flip(edge, v0)) {
+            return;
+        } else {
+            expected_target = v0;
+        }
+    } else if (v1_restricted) {
+
+        if (tm_edge_collapse_is_degenerate_flip(edge, v1)) {
+            return;
+        } else {
+            expected_target = v1;
+        }
+    } else {
+        const v0_degenerate = tm_edge_collapse_is_degenerate_flip(edge, v0);
+        const v1_degenerate = tm_edge_collapse_is_degenerate_flip(edge, v1);
+        if (v0_degenerate && v1_degenerate) {
+            return;
+        } else if (v1_degenerate) {
+            expected_target = v0;
+        } else if (v0_degenerate) {
+            expected_target = v1;
+        } else {
+            expected_target = pick_lowest_cost_edge_collapse_vertex(edge);
+        }
+    }
+
+    return expected_target;
+}
+
+/**
+ *
+ * @param {TopoEdge} edge
+ * @returns {number}
+ */
+function build_edge_cost_squared_topology(edge) {
+    tm_vertex_compute_normal(scratch_v3_0, 0, edge.v0);
+    tm_vertex_compute_normal(scratch_v3_1, 0, edge.v1);
+
+    const distance_sqr = vec3.squaredDistance(edge.v0, edge.v1);
+
+    let cost = Math.abs(vec3.dot(scratch_v3_0, scratch_v3_1))
+        / min2(-distance_sqr, -EPSILON);
+
+    return cost;
+
+}
+
+
+/**
+ *
+ * @param {TopoEdge} edge
+ * @param {Map<number,Quadratic3>} quadratics
+ * @param {Set<number>} restricted_vertices
+ */
+export function compute_edge_collapse_cost(edge, quadratics, restricted_vertices) {
+    const expected_target = edge_collapse_pick_target_vertex(edge, restricted_vertices);
+
+    if (expected_target === undefined) {
+        return Number.POSITIVE_INFINITY;
+    }
+
+
+    const v0 = edge.v0;
+    const v1 = edge.v1;
+
+    let cost = compute_edge_collapse_cost_quadratic(v0, v1, expected_target, quadratics);
+
+    // fallback to topology is quadratics are noise
+    if (cost < 1e-5) {
+        // subtracting cost to introduce minor possible variation in cost, to produce stable order
+        cost = build_edge_cost_squared_topology(edge) - cost;
+    }
+
+    return cost;
+}
+
+/**
+ *
+ * @param {TopoEdge} edge
+ * @param {Map<number,Quadratic3>} quadratics
+ * @param {Uint32Heap} heap
+ * @param {Set<number>} restricted_vertices
+ */
+function tm_build_cost(edge, quadratics, heap, restricted_vertices) {
+    const index_in_heap = heap.find_index_by_id(edge.index);
+    if (index_in_heap === -1) {
+        // not in heap
+        return;
+    }
+
+    let cost = compute_edge_collapse_cost(edge, quadratics, restricted_vertices);
+
+    heap.__update_score_by_index(index_in_heap, cost);
+
+}
+
+/**
+ *
+ * @param {TopoMesh} mesh
+ * @param {TopoEdge}edge
+ * @param {TopoVertex} target
+ * @param {Map<number,Quadratic3>} quadratics
+ * @param {Uint32Heap} heap
+ * @param {Set<number>} restricted_vertices
+ * @returns {boolean}
+ */
+export function decimate_edge_collapse_snap(
+    mesh,
+    edge,
+    target,
+    quadratics,
+    heap,
+    restricted_vertices
+) {
+
+    if (!edge.isLinked()) {
+        // edge is not part of topology, this should never happen in practice
+        return false;
+    }
+
+    if (edge.v0 === edge.v1) {
+        // degenerate edge, don't touch
+        return false;
+    }
+
+    if (tm_edge_collapse_is_degenerate_flip(edge, target)) {
+        // re-insert into heap with very high cost
+        heap.insert(edge.index, Number.POSITIVE_INFINITY);
+        return false;
+    }
+
+    // update quadratics
+    const victim_vertex = query_edge_other_vertex(edge, target);
+
+    if (!tm_edge_collapse(mesh, edge, target)) {
+        // failed collapse
+        // re-insert into heap with very high cost
+        heap.insert(edge.index, Number.POSITIVE_INFINITY);
+        return false;
+    }
+
+
+    const q_a = quadratics.get(victim_vertex.index);
+    const q_b = quadratics.get(target.index);
+    q_b.add(q_a);
+
+    // TODO we can probably discount all original faces around the target vertex
+    // record affected edges
+    const attached_faces = target.faces;
+    const attached_face_count = attached_faces.length;
+
+    let dirty_edge_count = 0;
+
+    for (let i = 0; i < attached_face_count; i++) {
+        const face = attached_faces[i];
+
+        const edges = face.edges;
+        const edge_count = edges.length;
+
+        for (let j = 0; j < edge_count; j++) {
+
+            const topoEdge = edges[j];
+
+            if (array_get_index_in_range(scratch_edges, topoEdge, 0, dirty_edge_count) === -1) {
+                scratch_edges[dirty_edge_count++] = topoEdge;
+            }
+        }
+
+    }
+
+    // update costs
+    for (let i = 0; i < dirty_edge_count; i++) {
+        const dirty_edge = scratch_edges[i];
+
+        if (dirty_edge.isDegenerateEdge()) {
+            heap.remove(dirty_edge.index);
+
+            tm_edge_kill(mesh, dirty_edge);
+
+        } else {
+
+            tm_build_cost(dirty_edge, quadratics, heap, restricted_vertices);
+
+        }
+    }
+
+    return true;
+}

package/core/geom/3d/topology/simplify/edge_collapse_quadratic.js

@@ -0,0 +1,126 @@
+import { assert } from "../../../../assert.js";
+import { query_edge_other_vertex } from "../query/query_edge_other_vertex.js";
+import { tm_edge_kill } from "../tm_edge_kill.js";
+import { tm_vert_splice } from "../tm_vert_splice.js";
+import { tm_edge_splice } from "../tm_edge_splice.js";
+import { query_face_get_other_edges } from "../query/query_face_get_other_edges.js";
+
+/**
+ *
+ * @type {TopoEdge[]}
+ */
+const scratch_edges_0 = [];
+
+/**
+ *
+ * @param {TopoMesh} mesh
+ * @param {TopoEdge} edge
+ * @param {TopoVertex} other
+ * @returns {boolean}
+ */
+export function tm_edge_collapse(mesh, edge, other) {
+
+    const victim = query_edge_other_vertex(edge, other);
+
+    assert.notNull(other, 'other');
+    assert.notEqual(victim, other, 'degenerate edge');
+
+    const edge_faces = edge.faces;
+    const attached_face_count = edge_faces.length;
+
+    let recorded_splice_edge_count = 0;
+    for (let i = 0; i < attached_face_count; i++) {
+        const edge_face = edge_faces[i];
+
+        const rec_address = recorded_splice_edge_count * 2;
+        const got_tri_edges = query_face_get_other_edges(scratch_edges_0, rec_address, edge_face, edge);
+
+        if (!got_tri_edges) {
+            continue;
+        }
+
+        const a_v0 = scratch_edges_0[rec_address];
+        const a_v1 = scratch_edges_0[rec_address + 1];
+
+        for (let j = 0; j < rec_address; j++) {
+            const other_edge = scratch_edges_0[j];
+
+            if (other_edge === a_v0 || other_edge === a_v1) {
+                // rare case, triangles share edges, avoid
+                return false;
+            }
+        }
+
+        recorded_splice_edge_count++;
+    }
+
+    // debugValidateMesh(mesh);
+
+    tm_edge_kill(mesh, edge);
+
+    tm_vert_splice(mesh, other, victim);
+
+    for (let i = 0; i < recorded_splice_edge_count; i++) {
+        const i2 = i * 2;
+        tm_edge_splice(mesh, scratch_edges_0[i2], scratch_edges_0[i2 + 1]);
+    }
+
+    // debugValidateMesh(mesh);
+
+    return true;
+
+    // // if (query_edge_is_manifold(edge)) {
+    // if (attached_face_count === 2) {
+    //     // two triangles are to be removed
+    //
+    //
+    //     const a_face = edge_faces[0];
+    //     const b_face = edge_faces[1];
+    //
+    //
+    //     const a_other = scratch_edges_0;
+    //     const b_other = scratch_edges_1;
+    //
+    //     query_face_get_other_edges(a_other, 0, a_face, edge);
+    //     query_face_get_other_edges(b_other, 0, b_face, edge);
+    //
+    //     if (
+    //         a_other[0] === b_other[0] || a_other[0] === b_other[1]
+    //         || a_other[1] === b_other[0] || a_other[1] === b_other[1]
+    //     ) {
+    //         // triangles share edges, avoid
+    //         return false;
+    //     }
+    //
+    //     tm_edge_kill(mesh, edge);
+    //
+    //     tm_vert_splice(mesh, other, victim);
+    //
+    //     tm_edge_splice(mesh, a_other[0], a_other[1]);
+    //     tm_edge_splice(mesh, b_other[0], b_other[1]);
+    //
+    //     return true;
+    // }
+    //
+    // // if (query_edge_is_boundary(edge)) {
+    // if (attached_face_count === 1) {
+    //     // only one triangle is to be removed
+    //
+    //     const a_face = edge_faces[0];
+    //
+    //     const a_other = scratch_edges_0;
+    //
+    //     const got_tri_edges = query_face_get_other_edges(a_other, 0, a_face, edge);
+    //
+    //     tm_edge_kill(mesh, edge);
+    //     tm_vert_splice(mesh, other, victim);
+    //     if (got_tri_edges) {
+    //         tm_edge_splice(mesh, a_other[1], a_other[0]);
+    //     }
+    //
+    //     return true;
+    // }
+
+
+    return false;
+}