@woosh/meep-engine 2.37.18 → 2.38.0

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

@@ -0,0 +1,119 @@
+import { Uint32Heap } from "../../../../collection/heap/Uint32Heap.js";
+import { build_vertex_quadratics } from "./quadratic/build_vertex_quadratics.js";
+import {
+    compute_edge_collapse_cost,
+    decimate_edge_collapse_snap,
+    edge_collapse_pick_target_vertex
+} from "./decimate_edge_collapse_snap.js";
+import { max2 } from "../../../../math/max2.js";
+
+/**
+ *
+ * @param {Iterable<TopoEdge>} edges
+ * @param {Set<number>} restricted_vertices
+ * @param {Uint32Heap} heap
+ * @param {Map<number, Quadratic3>} vertex_quadratics
+ * @param {Map<number,TopoEdge>} edge_lookup
+ */
+export function edge_collapse_populate_heap(edges, restricted_vertices, heap, vertex_quadratics, edge_lookup) {
+
+    const edge_array = Array.from(edges);
+    const total_edge_count = edge_array.length;
+
+    for (let i = 0; i < total_edge_count; i++) {
+        const edge = edge_array[i];
+
+        if (
+            restricted_vertices.has(edge.v0.index)
+            && restricted_vertices.has(edge.v1.index)
+        ) {
+            // both vertices are fixed, can't simplify the edge
+            continue;
+        }
+
+        heap.insert(edge.index, compute_edge_collapse_cost(edge, vertex_quadratics, restricted_vertices));
+
+        edge_lookup.set(edge.index, edge);
+    }
+}
+
+/**
+ *
+ * @param {TopoMesh} mesh
+ * @param {number} num_faces_to_remove
+ * @param {Uint32Heap} heap
+ * @param {Map<number,TopoEdge>} edge_lookup
+ * @param {Set<number>} restricted_vertices
+ * @param {Map<number, Quadratic3>} vertex_quadratics
+ */
+export function edge_collapse_reduce_face_count(mesh, num_faces_to_remove, heap, edge_lookup, restricted_vertices, vertex_quadratics) {
+    const mesh_faces = mesh.getFaces();
+
+    const target_face_count = max2(0, mesh_faces.size - num_faces_to_remove);
+
+    let cycle_count = 0;
+    let cycle_limit = max2(heap.size, num_faces_to_remove * 4);
+
+    while (
+        !heap.is_empty()
+        && mesh_faces.size > target_face_count
+        && cycle_count < cycle_limit
+        ) {
+        const edge_index = heap.pop_min();
+
+        const edge = edge_lookup.get(edge_index);
+
+        let target;
+
+        target = edge_collapse_pick_target_vertex(edge, restricted_vertices);
+
+        if (target === undefined) {
+            // invalid collapse
+            continue;
+        }
+
+        decimate_edge_collapse_snap(mesh, edge, target, vertex_quadratics, heap, restricted_vertices);
+
+        cycle_count++;
+    }
+}
+
+/**
+ * Simplifies a given topology mesh by reducing number of faces. Preserves original vertices
+ * NOTE: preserves outline of the mesh, that is the open edge
+ * NOTE: assumes that face normals are set
+ * @param {TopoMesh} mesh
+ * @param {number} num_faces_to_remove desired number of faces to remove
+ * @param {Set<number>} [restricted_vertices] vertices that are not allowed to be removed
+ */
+export function simplifyTopoMesh2(mesh, num_faces_to_remove, restricted_vertices = new Set()) {
+
+    const mesh_faces = mesh.getFaces();
+    const face_count = mesh_faces.size;
+
+    if (num_faces_to_remove <= 0 || face_count <= 0) {
+        // we're already at the target
+        return;
+    }
+
+    const heap = new Uint32Heap(mesh.getEdges().size);
+    /**
+     *
+     * @type {Map<number, Quadratic3>}
+     */
+    const vertex_quadratics = new Map();
+
+    build_vertex_quadratics({ mesh: mesh, quadratics: vertex_quadratics });
+
+    const edge_lookup = new Map();
+    edge_collapse_populate_heap(mesh.getEdges(), restricted_vertices, heap, vertex_quadratics, edge_lookup);
+    edge_collapse_reduce_face_count(mesh, num_faces_to_remove, heap, edge_lookup, restricted_vertices, vertex_quadratics);
+
+
+    // debugValidateMesh(mesh);
+
+    // get rid of degenerate edges
+    // collapse_all_degenerate_edges(mesh.getEdges(), mesh);
+
+    // debugValidateMesh(mesh);
+}

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

@@ -0,0 +1,81 @@
+import { query_edge_other_vertex } from "../query/query_edge_other_vertex.js";
+import { query_face_next_vertex } from "../query/query_face_next_vertex.js";
+import { query_face_prev_vertex } from "../query/query_face_prev_vertex.js";
+import { v3_length_sqr } from "../../../v3_length_sqr.js";
+import { v3_dot } from "../../../v3_dot.js";
+
+/**
+ * @see https://github.com/blender/blender/blob/594f47ecd2d5367ca936cf6fc6ec8168c2b360d0/source/blender/bmesh/tools/bmesh_decimate_collapse.c#L164
+ * @param {TopoEdge} edge
+ * @param {TopoVertex} target
+ * @returns {boolean}
+ */
+export function tm_edge_collapse_is_degenerate_flip(edge, target) {
+    const victim = query_edge_other_vertex(edge, target);
+
+    const victim_faces = victim.faces;
+    const victim_face_count = victim_faces.length;
+
+    for (let i = 0; i < victim_face_count; i++) {
+        const face = victim_faces[i];
+
+        // get a vertex that's next after victim vertex in order
+        const next_vertex = query_face_next_vertex(face, victim);
+        const prev_vertex = query_face_prev_vertex(face, victim);
+
+        if (next_vertex === target || prev_vertex === target) {
+            // face attached to collapsing edge, ignore
+            continue;
+        }
+
+        const vo_x = prev_vertex.x - next_vertex.x;
+        const vo_y = prev_vertex.y - next_vertex.y;
+        const vo_z = prev_vertex.z - next_vertex.z;
+
+        const vv_x = prev_vertex.x - victim.x;
+        const vv_y = prev_vertex.y - victim.y;
+        const vv_z = prev_vertex.z - victim.z;
+
+        const vt_x = prev_vertex.x - target.x;
+        const vt_y = prev_vertex.y - target.y;
+        const vt_z = prev_vertex.z - target.z;
+
+        // cross( other, victim )
+        const vx_ov_x = vo_y * vv_z - vo_z * vv_y;
+        const vx_ov_y = vo_z * vv_x - vo_x * vv_z;
+        const vx_ov_z = vo_x * vv_y - vo_y * vv_x;
+
+        // cross( other, target )
+        const vx_ot_x = vo_y * vt_z - vo_z * vt_y;
+        const vx_ot_y = vo_z * vt_x - vo_x * vt_z;
+        const vx_ot_z = vo_x * vt_y - vo_y * vt_x;
+
+        const dot = v3_dot(vx_ov_x, vx_ov_y, vx_ov_z, vx_ot_x, vx_ot_y, vx_ot_z);
+
+        const squared_distance_sum = v3_length_sqr(vx_ov_x, vx_ov_y, vx_ov_z)
+            + v3_length_sqr(vx_ot_x, vx_ot_y, vx_ot_z);
+
+        /*
+
+        vec3.sub(vec_other, prev_vertex, next_vertex);
+        vec3.sub(vec_exist, prev_vertex, victim);
+        vec3.sub(vec_optim, prev_vertex, target);
+
+        vec3.cross(vec_exist, vec_other, vec_exist);
+        vec3.cross(vec_optim, vec_other, vec_optim);
+
+
+        // avoid normalization
+        const dot = vec3.dot(vec_exist, vec_optim);
+        const squared_distance_sum = vec3.squaredLength(vec_exist) + vec3.squaredLength(vec_other);
+         */
+
+        // if (dot <= squared_distance_sum * 0.000001) {
+        if (dot <= squared_distance_sum * 0.000001) {
+            return true;
+        }
+
+    }
+
+    return false;
+}

package/core/geom/3d/topology/{TopoEdge.js → struct/TopoEdge.js}

@@ -1,9 +1,21 @@
-import { assert } from "../../../assert.js";
-import { array_remove_first } from "../../../collection/array/array_remove_first.js";
-import { array_push_if_unique } from "../../../collection/array/array_push_if_unique.js";
+import { assert } from "../../../../assert.js";
+import { array_remove_first } from "../../../../collection/array/array_remove_first.js";
+import { array_push_if_unique } from "../../../../collection/array/array_push_if_unique.js";
+import { query_vertex_in_edge } from "../query/query_vertex_in_edge.js";
+import { query_edge_other_vertex } from "../query/query_edge_other_vertex.js";
+import { query_vertices_in_edge } from "../query/query_vertices_in_edge.js";
+import { query_edge_is_boundary } from "../query/query_edge_is_boundary.js";
+
+let index_counter = 0;
 
 export class TopoEdge {
     constructor() {
+        /**
+         * Unique ID
+         * @type {number}
+         */
+        this.index = index_counter++;
+
         /**
          *
          * @type {TopoVertex}
@@ -29,6 +41,21 @@ export class TopoEdge {
         this.lengthSqr = -1;
     }
 
+    /**
+     *
+     * @param {number} i
+     * @returns {TopoVertex}
+     */
+    getVertexByIndex(i) {
+        if (i === 0) {
+            return this.v0;
+        } else if (i === 1) {
+            return this.v1;
+        } else {
+            throw new Error('Index out of bounds');
+        }
+    }
+
     /**
      *
      * @param {TopoEdge} other
@@ -100,8 +127,15 @@ export class TopoEdge {
      * Remove self from the topology graph
      */
     unlink() {
-        this.v0.removeEdge(this);
-        this.v1.removeEdge(this);
+        const v0 = this.v0;
+        const v1 = this.v1;
+
+        v0.removeEdge(this);
+
+        if (v0 !== v1) {
+            // special check for degenerate edges where both vertices are the same
+            v1.removeEdge(this);
+        }
 
         const faces = this.faces;
         const face_count = faces.length;
@@ -120,14 +154,14 @@ export class TopoEdge {
         return this.v0 === this.v1;
     }
 
-
     /**
+     * @deprecated use {@link query_edge_is_boundary} instead
      * Is this a an edge of topology as a whole?
      * @return {boolean}
      */
     isTopologyBorder() {
         //attached to exactly one face
-        return this.faces.length === 1;
+        return query_edge_is_boundary(this);
     }
 
     /**
@@ -265,38 +299,31 @@ export class TopoEdge {
     }
 
     /**
-     *
+     * @deprecated use {@link query_edge_other_vertex} instead
      * @param {TopoVertex} v
      * @return {TopoVertex}
      */
     getOtherVertex(v) {
-        if (v === this.v0) {
-            return this.v1;
-        } else {
-            return this.v0;
-        }
+        return query_edge_other_vertex(this, v);
     }
 
     /**
-     *
+     * @deprecated use {@link @query_vertex_in_edge} instead
      * @param {TopoVertex} v
      * @return {boolean}
      */
     containsVertex(v) {
-        return v === this.v0 || v === this.v1;
+        return query_vertex_in_edge(this, v);
     }
 
     /**
-     *
+     @deprecated use {@link query_vertices_in_edge} instead
      * @param {TopoVertex} a
      * @param {TopoVertex} b
      * @return {boolean}
      */
     containsBothVertices(a, b) {
-        const v0 = this.v0;
-        const v1 = this.v1;
-
-        return (a === v0 || a === v1) && (b === v0 || b === v1);
+        return query_vertices_in_edge(this, a, b);
     }
 
     /**

package/core/geom/3d/topology/{TopoMesh.js → struct/TopoMesh.js}

@@ -1,10 +1,14 @@
-import { assert } from "../../../assert.js";
+import { assert } from "../../../../assert.js";
 import { TopoEdge } from "./TopoEdge.js";
 import { TopoTriangle } from "./TopoTriangle.js";
 import { TopoVertex } from "./TopoVertex.js";
-import { array_remove_first } from "../../../collection/array/array_remove_first.js";
-import { array_push_if_unique } from "../../../collection/array/array_push_if_unique.js";
+import { array_push_if_unique } from "../../../../collection/array/array_push_if_unique.js";
 import { vec3 } from "gl-matrix";
+import { tm_kill_only_vert } from "../tm_kill_only_vert.js";
+import { tm_kill_only_edge } from "../tm_kill_only_edge.js";
+import { tm_kill_only_face } from "../tm_kill_only_face.js";
+import { query_edge_other_vertex } from "../query/query_edge_other_vertex.js";
+import { formatNumberByThousands } from "../../../../NumberFormat.js";
 
 export class TopoMesh {
     constructor() {
@@ -305,14 +309,11 @@ export class TopoMesh {
     }
 
     /**
-     *
+     * @deprecated use {@link tm_kill_only_vert}
      * @param {TopoVertex} v
      */
     removeVertex(v) {
-        assert.equal(v.isTopoVertex, true, "v.isTopoVertex !== true");
-        assert.arrayHas(this.vertices, v, 'element not found');
-
-        array_remove_first(this.vertices, v);
+        tm_kill_only_vert(this, v);
     }
 
     /**
@@ -346,36 +347,11 @@ export class TopoMesh {
     }
 
     /**
-     *
+     * @deprecated use {@link tm_kill_only_edge}
      * @param {TopoEdge} e
      */
     removeEdge(e) {
-        assert.equal(e.isTopoEdge, true, "e.isTopoEdge !== true");
-
-        // validate that the edge does not have any live back links
-        // const vertices = this.vertices;
-        // const vertex_count = vertices.length;
-        // for (let i = 0; i < vertex_count; i++) {
-        //     const v = vertices[i];
-        //
-        //     if (v.containsEdge(e)) {
-        //         // live link to edge
-        //         debugger;
-        //     }
-        // }
-        //
-        // const faces = this.faces;
-        // const face_count = faces.length;
-        // for (let i = 0; i < face_count; i++) {
-        //     const face = faces[i];
-        //
-        //     if (face.containsEdge(e)) {
-        //         // live link to face
-        //         debugger;
-        //     }
-        // }
-
-        this.__edges.delete(e);
+        tm_kill_only_edge(this, e);
     }
 
     /**
@@ -441,13 +417,11 @@ export class TopoMesh {
     }
 
     /**
-     *
+     * @deprecated use {@link tm_kill_only_face} instead
      * @param {TopoTriangle} f
      */
     removeFace(f) {
-        assert.equal(f.isTopoFace, true, "f.isTopoFace !== true");
-
-        this.__faces.delete(f);
+        tm_kill_only_face(this, f);
     }
 
     /**
@@ -474,7 +448,8 @@ export class TopoMesh {
         assert.equal(a.isTopoVertex, true, 'a.isTopoVertex !== true');
         assert.equal(b.isTopoVertex, true, 'b.isTopoVertex !== true');
 
-        assert.notEqual(a, b, 'a === b, attempting to create an edge from vertex to itself');
+        // DEBUG degenerate edge check
+        // assert.notEqual(a, b, 'a === b, attempting to create an edge from vertex to itself');
 
         const aEdges = a.edges;
         const n = aEdges.length;
@@ -482,7 +457,7 @@ export class TopoMesh {
         for (let i = 0; i < n; i++) {
             const edge = aEdges[i];
 
-            if (edge.getOtherVertex(a) === b) {
+            if (query_edge_other_vertex(edge, a) === b) {
                 // found existing edge between A and B
                 return edge;
             }
@@ -618,6 +593,10 @@ export class TopoMesh {
             topoFaces.add(f);
         }
     }
+
+    toString() {
+        return `TopoMesh{ vertices: ${formatNumberByThousands(this.vertices.length)}, edges: ${formatNumberByThousands(this.getEdges().size)}, faces: ${formatNumberByThousands(this.getFaces().size)} }`;
+    }
 }
 
 

package/core/geom/3d/topology/{TopoTriangle.js → struct/TopoTriangle.js}

@@ -1,9 +1,9 @@
-import { array_replace_all } from "../../../collection/array/array_replace_all.js";
-import { array_push_if_unique } from "../../../collection/array/array_push_if_unique.js";
-import { assert } from "../../../assert.js";
-import { array_remove_first } from "../../../collection/array/array_remove_first.js";
+import { array_replace_all } from "../../../../collection/array/array_replace_all.js";
+import { array_push_if_unique } from "../../../../collection/array/array_push_if_unique.js";
+import { assert } from "../../../../assert.js";
+import { array_remove_first } from "../../../../collection/array/array_remove_first.js";
 import { vec3 } from "gl-matrix";
-import { v3_length } from "../../v3_length.js";
+import { v3_length_sqr } from "../../../v3_length_sqr.js";
 
 /**
  *
@@ -40,17 +40,19 @@ export function compute_triangle_normal(result, vA, vB, vC) {
     const crossY = vCBz * vABx - vCBx * vABz;
     const crossZ = vCBx * vABy - vCBy * vABx;
 
-    const l = v3_length(crossX, crossY, crossZ);
+    const l_sqr = v3_length_sqr(crossX, crossY, crossZ);
 
-    if (l === 0) {
+    if (l_sqr === 0) {
         // degenerate triangle, provide arbitrary invalid result
         vec3.set(result, 0, 0, 0);
         return;
     }
 
-    const x = crossX / l;
-    const y = crossY / l;
-    const z = crossZ / l;
+    const l_inv = 1 / Math.sqrt(l_sqr);
+
+    const x = crossX * l_inv;
+    const y = crossY * l_inv;
+    const z = crossZ * l_inv;
 
 
     vec3.set(
@@ -59,13 +61,15 @@ export function compute_triangle_normal(result, vA, vB, vC) {
     );
 }
 
+let index_counter = 0;
+
 export class TopoTriangle {
     constructor() {
         /**
          * Identifying index, can be used to link back to buffer-geometry face by index or any other useful ID purposes
          * @type {number}
          */
-        this.index = 0;
+        this.index = index_counter++;
         /**
          *
          * @type {TopoVertex[]}
@@ -82,20 +86,6 @@ export class TopoTriangle {
          * @type {number[]|vec3}
          */
         this.normal = [0, 0, 0];
-
-        /**
-         * Doubly-linked list pointer
-         * @type {TopoTriangle|null}
-         * @private
-         */
-        this.__link_previous = null;
-
-        /**
-         * Doubly-linked list pointer
-         * @type {TopoTriangle|null}
-         * @private
-         */
-        this.__link_next = null;
     }
 
     /**

package/core/geom/3d/topology/{TopoVertex.js → struct/TopoVertex.js}

@@ -1,7 +1,7 @@
-import { assert } from "../../../assert.js";
-import { array_push_if_unique } from "../../../collection/array/array_push_if_unique.js";
-import { array_remove_first } from "../../../collection/array/array_remove_first.js";
-import { v3_distance } from "../../v3_distance.js";
+import { assert } from "../../../../assert.js";
+import { array_push_if_unique } from "../../../../collection/array/array_push_if_unique.js";
+import { array_remove_first } from "../../../../collection/array/array_remove_first.js";
+import { v3_distance } from "../../../v3_distance.js";
 
 export class TopoVertex {
     constructor() {
@@ -40,6 +40,18 @@ export class TopoVertex {
         this.z = 0;
     }
 
+    get 0() {
+        return this.x;
+    }
+
+    get 1() {
+        return this.y;
+    }
+
+    get 2() {
+        return this.z;
+    }
+
     /**
      *
      * @param {TopoVertex} other
@@ -166,6 +178,7 @@ export class TopoVertex {
      * @param {TopoEdge} e
      */
     addEdge(e) {
+        assert.defined(e, 'e');
         assert.equal(e.isTopoEdge, true, "e.isTopoEdge !== true");
         assert.arrayHasNo(this.edges, e, 'already contains edge');
 
@@ -178,7 +191,9 @@ export class TopoVertex {
      * @return {boolean}
      */
     addUniqueEdge(e) {
+        assert.defined(e, 'e');
         assert.equal(e.isTopoEdge, true, "e.isTopoEdge !== true");
+
         return array_push_if_unique(this.edges, e);
     }
 
@@ -224,11 +239,13 @@ export class TopoVertex {
         const r = array_remove_first(this.edges, e);
 
         assert.arrayHasNo(this.edges, e, 'found an instance of removed edge');
+        assert.arrayHasNo(this.edges, undefined, 'found an instance of undefined');
 
         return r;
     }
 
     /**
+     * @deprecated use {@link tm_vert_splice} instead
      * Replaces another vertex with self, updates faces and edges of replaced victim
      * @param {TopoVertex} victim
      */

package/core/geom/3d/topology/tm_edge_kill.js

@@ -0,0 +1,24 @@
+import { tm_face_kill } from "./tm_face_kill.js";
+import { tm_kill_only_edge } from "./tm_kill_only_edge.js";
+
+/**
+ * Remove edge and all faces that use it
+ * NOTE: Loosely based on blender's code:  https://github.com/blender/blender/blob/594f47ecd2d5367ca936cf6fc6ec8168c2b360d0/source/blender/bmesh/intern/bmesh_core.c#L987
+ * @param {TopoMesh} mesh
+ * @param {TopoEdge} edge
+ */
+export function tm_edge_kill(mesh, edge) {
+
+    const faces = edge.faces;
+    const face_count = faces.length;
+
+    for (let i = face_count - 1; i >= 0; i--) {
+        tm_face_kill(mesh, faces[i]);
+    }
+
+    edge.unlink();
+
+    tm_kill_only_edge(mesh, edge);
+}
+
+

package/core/geom/3d/topology/tm_edge_splice.js

@@ -0,0 +1,42 @@
+import { query_vertex_in_edge } from "./query/query_vertex_in_edge.js";
+import { assert } from "../../../assert.js";
+import { tm_edge_kill } from "./tm_edge_kill.js";
+
+/**
+ * Splice Edge
+ * Splice two unique edges which share the same two vertices into one edge
+ * source onto destination, removing source
+ *
+ * PRECONDITION: Edges must share vertices
+ * @param {TopoMesh} mesh
+ * @param {TopoEdge} destination
+ * @param {TopoEdge} source
+ * @returns {boolean}
+ */
+export function tm_edge_splice(mesh, destination, source) {
+    if (!query_vertex_in_edge(source, destination.v0) || !query_vertex_in_edge(source, destination.v1)) {
+        // do not share vertices, can't splice
+
+        // the caller must make sure that this never happens
+        assert.ok(false);
+
+        return false;
+    }
+
+    // move faces
+    const source_faces = source.faces;
+    const source_face_count = source_faces.length;
+    for (let i = 0; i < source_face_count; i++) {
+        const a = source_faces.pop();
+
+        a.removeEdge(source);
+
+        a.addUniqueEdge(destination);
+        destination.addUniqueFace(a);
+    }
+
+
+    tm_edge_kill(mesh, source);
+
+    return true;
+}

package/core/geom/3d/topology/tm_face_area.js

@@ -0,0 +1,18 @@
+import { computeTriangleSurfaceArea } from "../../../../engine/graphics/geometry/computeMeshSurfaceArea.js";
+
+/**
+ *
+ * @param {TopoTriangle} face
+ * @returns {number}
+ */
+export function tm_face_area(face) {
+    const v0 = face.vertices[0];
+    const v1 = face.vertices[1];
+    const v2 = face.vertices[2];
+
+    return computeTriangleSurfaceArea(
+        v0.x, v0.y, v0.z,
+        v1.x, v1.y, v1.z,
+        v2.x, v2.y, v2.z
+    );
+}

package/core/geom/3d/topology/tm_face_kill.js

@@ -0,0 +1,12 @@
+import { tm_kill_only_face } from "./tm_kill_only_face.js";
+
+/**
+ *
+ * @param {TopoMesh} mesh
+ * @param {TopoTriangle} face
+ */
+export function tm_face_kill(mesh, face) {
+    face.unlink();
+
+    tm_kill_only_face(mesh, face);
+}