@woosh/meep-engine 2.43.22 → 2.43.23

package/core/geom/3d/tetrahedra/delaunay/compute_delaunay_tetrahedral_mesh.js

@@ -17,10 +17,10 @@ import { assert } from "../../../../assert.js";
  * @see [1] "One machine, one minute, three billion tetrahedra" by Célestin Marot et al
  * @param {TetrahedralMesh} mesh
  * @param {number[]} input serialized set of 3d points (x,y,z)
- * @param {number} n number of points in the input
+ * @param {number} [n] number of points in the input
  * @returns {boolean}
  */
-export function compute_delaunay_tetrahedral_mesh(mesh, input, n) {
+export function compute_delaunay_tetrahedral_mesh(mesh, input, n = input.length / 3) {
     assert.notNull(mesh, 'mesh');
     assert.defined(mesh, 'mesh');
 

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

@@ -1,6 +1,6 @@
-import { max3 } from "../../../../math/max3.js";
-import { assert } from "../../../../assert.js";
-import { typed_array_copy } from "../../../../collection/array/typed/typed_array_copy.js";
+import { max3 } from "../../../../../math/max3.js";
+import { assert } from "../../../../../assert.js";
+import { typed_array_copy } from "../../../../../collection/array/typed/typed_array_copy.js";
 
 /**
  * How many items to reserve by default
@@ -74,7 +74,7 @@ export class BinaryElementPool {
         this.__data_uint8 = new Uint8Array(this.__data_buffer);
         this.__data_uint32 = new Uint32Array(this.__data_buffer);
         this.__data_float32 = new Float32Array(this.__data_buffer);
-        this.__data_view = new DataView(this.__data_buffer);
+        this.data_view = new DataView(this.__data_buffer);
 
         this.__capacity = initial_capacity;
 
@@ -119,10 +119,6 @@ export class BinaryElementPool {
         return this.__data_float32;
     }
 
-    get data_view() {
-        return this.__data_view;
-    }
-
     /**
      * Get rid of excess capacity
      */
@@ -187,7 +183,7 @@ export class BinaryElementPool {
         this.__data_uint8 = new Uint8Array(new_data_buffer);
         this.__data_uint32 = new Uint32Array(this.__data_buffer);
         this.__data_float32 = new Float32Array(this.__data_buffer);
-        this.__data_view = new DataView(new_data_buffer);
+        this.data_view = new DataView(new_data_buffer);
 
         // copy old data
         typed_array_copy(old_data_uint8, this.__data_uint8);
@@ -241,7 +237,7 @@ export class BinaryElementPool {
             this.__grow_capacity(this.__size);
         }
 
-        assert.greaterThan(this.__data_buffer.byteLength, result * this.__item_size, 'memory underflow');
+        // assert.greaterThan(this.__data_buffer.byteLength, result * this.__item_size, 'memory underflow');
 
         return result;
     }
@@ -260,7 +256,7 @@ export class BinaryElementPool {
             this.__grow_capacity(this.__size);
         }
 
-        assert.greaterThanOrEqual(this.__data_buffer.byteLength, (offset + count) * this.__item_size, 'memory underflow');
+        // assert.greaterThanOrEqual(this.__data_buffer.byteLength, (offset + count) * this.__item_size, 'memory underflow');
 
         return offset;
     }

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

@@ -1,6 +1,6 @@
 import { BinaryElementPool } from "./BinaryElementPool.js";
-import { array_copy } from "../../../../collection/array/copyArray.js";
-import { assert } from "../../../../assert.js";
+import { array_copy } from "../../../../../collection/array/copyArray.js";
+import { assert } from "../../../../../assert.js";
 
 /**
  * Byte size of FLOAT_32
@@ -254,6 +254,7 @@ export class BinaryTopology {
         pool.data_view.setUint32(address + UINT_32_SIZE, value);
     }
 
+
     /**
      * @param {number} id edge ID
      * @returns {number}
@@ -281,6 +282,122 @@ export class BinaryTopology {
         pool.data_view.setUint32(address + 2 * UINT_32_SIZE, value);
     }
 
+    /**
+     * @param {number} id edge ID
+     * @returns {number}
+     */
+    edge_read_v1_disk_next(id) {
+        assert.isNonNegativeInteger(id, 'id');
+        const pool = this.__edge_pool;
+
+        // assert.equal(pool.is_allocated(id), true, 'element is not allocated');
+
+        const address = pool.element_address(id);
+        return pool.data_view.getUint32(address + 3 * UINT_32_SIZE);
+
+    }
+
+    /**
+     *
+     * @param {number} value
+     * @param {number} id edge ID
+     */
+    edge_write_v1_disk_next(id, value) {
+        const pool = this.__edge_pool;
+
+        // assert.equal(pool.is_allocated(id), true, 'element is not allocated');
+
+        const address = pool.element_address(id);
+        pool.data_view.setUint32(address + 3 * UINT_32_SIZE, value);
+    }
+
+    /**
+     * @param {number} id edge ID
+     * @returns {number}
+     */
+    edge_read_v1_disk_prev(id) {
+        assert.isNonNegativeInteger(id, 'id');
+        const pool = this.__edge_pool;
+
+        // assert.equal(pool.is_allocated(id), true, 'element is not allocated');
+
+        const address = pool.element_address(id);
+        return pool.data_view.getUint32(address + 4 * UINT_32_SIZE);
+
+    }
+
+    /**
+     *
+     * @param {number} value
+     * @param {number} id edge ID
+     */
+    edge_write_v1_disk_prev(id, value) {
+        const pool = this.__edge_pool;
+
+        // assert.equal(pool.is_allocated(id), true, 'element is not allocated');
+
+        const address = pool.element_address(id);
+        pool.data_view.setUint32(address + 4 * UINT_32_SIZE, value);
+    }
+
+    /**
+     * @param {number} id edge ID
+     * @returns {number}
+     */
+    edge_read_v2_disk_next(id) {
+        assert.isNonNegativeInteger(id, 'id');
+        const pool = this.__edge_pool;
+
+        // assert.equal(pool.is_allocated(id), true, 'element is not allocated');
+
+        const address = pool.element_address(id);
+        return pool.data_view.getUint32(address + 5 * UINT_32_SIZE);
+
+    }
+
+    /**
+     *
+     * @param {number} value
+     * @param {number} id edge ID
+     */
+    edge_write_v2_disk_next(id, value) {
+        const pool = this.__edge_pool;
+
+        // assert.equal(pool.is_allocated(id), true, 'element is not allocated');
+
+        const address = pool.element_address(id);
+        pool.data_view.setUint32(address + 5 * UINT_32_SIZE, value);
+    }
+
+    /**
+     * @param {number} id edge ID
+     * @returns {number}
+     */
+    edge_read_v2_disk_prev(id) {
+        assert.isNonNegativeInteger(id, 'id');
+        const pool = this.__edge_pool;
+
+        // assert.equal(pool.is_allocated(id), true, 'element is not allocated');
+
+        const address = pool.element_address(id);
+        return pool.data_view.getUint32(address + 6 * UINT_32_SIZE);
+
+    }
+
+    /**
+     *
+     * @param {number} value
+     * @param {number} id edge ID
+     */
+    edge_write_v2_disk_prev(id, value) {
+        const pool = this.__edge_pool;
+
+        // assert.equal(pool.is_allocated(id), true, 'element is not allocated');
+
+        const address = pool.element_address(id);
+        pool.data_view.setUint32(address + 6 * UINT_32_SIZE, value);
+    }
+
     loop_create() {
         const id = this.__loop_pool.allocate();
 
@@ -294,10 +411,10 @@ export class BinaryTopology {
      * @param {number} id
      */
     loop_initialize(id) {
-        this.loop_write_radial_next(id, NULL_POINTER);
-        this.loop_write_radial_prev(id, NULL_POINTER);
-        this.loop_write_next(id, NULL_POINTER);
-        this.loop_write_prev(id, NULL_POINTER);
+        this.loop_write_radial_next(id, id);
+        this.loop_write_radial_prev(id, id);
+        this.loop_write_next(id, id);
+        this.loop_write_prev(id, id);
     }
 
     /**

package/core/geom/3d/topology/struct/binary/io/OrderedEdge.js

@@ -0,0 +1,66 @@
+import { split_by_2 } from "../../../../morton/mortonEncode_magicbits.js";
+
+export class OrderedEdge {
+    /**
+     *
+     * @param {number} v1
+     * @param {number} v2
+     */
+    constructor(v1, v2) {
+        if (v1 < v2) {
+            this.v_low = v1;
+            this.v_high = v2;
+        } else {
+            this.v_low = v2;
+            this.v_high = v1;
+        }
+    }
+
+    /**
+     *
+     * @param {number} v1
+     * @param {number} v2
+     */
+    set(v1, v2) {
+        if (v1 < v2) {
+            this.v_low = v1;
+            this.v_high = v2;
+        } else {
+            this.v_low = v2;
+            this.v_high = v1;
+        }
+    }
+
+    /**
+     *
+     * @param {OrderedEdge} other
+     */
+    copy(other) {
+        this.v_low = other.v_low;
+        this.v_high = other.v_high;
+    }
+
+    clone() {
+        return new OrderedEdge(this.v_low, this.v_high);
+    }
+
+    /**
+     *
+     * @return {number}
+     */
+    hash() {
+        // resulting hashes are close by
+        return split_by_2(this.v_low) | (split_by_2(this.v_high) << 1);
+    }
+
+    /**
+     *
+     * @param {OrderedEdge} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        return this.v_low === other.v_low
+            && this.v_high === other.v_high
+            ;
+    }
+}

package/core/geom/3d/topology/struct/binary/io/bt_index_geometry_to_topology.js

@@ -0,0 +1,188 @@
+import { NULL_POINTER } from "../BinaryTopology.js";
+import { create_edge } from "./create_edge.js";
+
+
+/**
+ * Populates supplied topology with data from supplied indexed geometry
+ * @see https://github.com/blender/blender/blob/9cb061f4f0119e647173e7d354e1457e97632333/source/blender/blenkernel/intern/mesh_calc_edges.cc
+ * @see https://github.com/blender/blender/blob/9cb061f4f0119e647173e7d354e1457e97632333/source/blender/io/stl/importer/stl_import_mesh.cc#L63
+ * @param {BinaryTopology} out
+ * @param {number[]} indices
+ * @param {number[]} vertex_positions
+ * @param {number[]} [vertex_normals]
+ */
+export function bt_index_geometry_to_topology(
+    out,
+    indices,
+    vertex_positions,
+    vertex_normals
+) {
+
+    // remove any existing data
+    out.clear();
+
+    /*
+    NOTES:
+        - we use {@link BinaryElementPool#allocate_continuous} to avoid having to allocate additional mapping structure
+     */
+
+    // ingest all vertices
+    const vertex_count = vertex_positions.length / 3;
+
+    const vertex_allocation_offset = out.vertices.allocate_continuous(vertex_count);
+
+    for (let i = 0; i < vertex_count; i++) {
+        const i3 = i * 3;
+
+        const vertex_id = i + vertex_allocation_offset;
+
+        out.vertex_write_coordinate(vertex_id, vertex_positions, i3);
+
+        if (vertex_normals !== undefined) {
+            out.vertex_write_normal(vertex_id, vertex_normals, i3);
+        }
+
+        // initialize edge to NULL
+        out.vertex_write_edge(vertex_id, NULL_POINTER);
+    }
+
+    const face_count = indices.length / 3;
+
+    // create faces
+    const face_allocation_offset = out.faces.allocate_continuous(face_count);
+
+    // reserve some memory to avoid extra allocations
+    out.loops.ensure_capacity(face_count * 3);
+    out.edges.ensure_capacity(face_count * 1.6);
+
+    for (let i = 0; i < face_count; i++) {
+        const i3 = i * 3;
+
+        const a = indices[i3];
+        const b = indices[i3 + 1];
+        const c = indices[i3 + 2];
+
+        const vertex_a = a + vertex_allocation_offset;
+        const vertex_b = b + vertex_allocation_offset;
+        const vertex_c = c + vertex_allocation_offset;
+
+        const face_id = i + face_allocation_offset;
+
+        // create edges
+        const edge_ab = get_or_create_edge_2(vertex_a, vertex_b, out);
+        const edge_bc = get_or_create_edge_2(vertex_b, vertex_c, out);
+        const edge_ca = get_or_create_edge_2(vertex_c, vertex_a, out);
+
+        // allocate loops
+        const loop_a = out.loop_create();
+        const loop_b = out.loop_create();
+        const loop_c = out.loop_create();
+
+        // write loops
+        out.loop_write_vertex(loop_a, vertex_a);
+        out.loop_write_vertex(loop_b, vertex_b);
+        out.loop_write_vertex(loop_c, vertex_c);
+
+        // link loops to edges
+        link_loop_to_edge(loop_a, edge_ab, out);
+        link_loop_to_edge(loop_b, edge_bc, out);
+        link_loop_to_edge(loop_c, edge_ca, out);
+
+        out.loop_write_face(loop_a, face_id);
+        out.loop_write_face(loop_b, face_id);
+        out.loop_write_face(loop_c, face_id);
+
+        /*
+        NOTE: Vertices (#BMLoop.v & #BMLoop.next.v) always contain vertices from (#BMEdge.v1 & #BMEdge.v2).
+         */
+        // link up loops around the face
+        out.loop_write_next(loop_a, loop_b);
+        out.loop_write_prev(loop_a, loop_c);
+
+        out.loop_write_next(loop_b, loop_c);
+        out.loop_write_prev(loop_b, loop_a);
+
+        out.loop_write_next(loop_c, loop_a);
+        out.loop_write_prev(loop_c, loop_b);
+
+        // update face
+        out.face_write_loop(face_id, loop_a);
+
+    }
+}
+
+/**
+ *
+ * @param {number} loop_id
+ * @param {number} edge_id
+ * @param {BinaryTopology} mesh
+ */
+function link_loop_to_edge(loop_id, edge_id, mesh) {
+    mesh.loop_write_edge(loop_id, edge_id);
+
+    /**
+     * First loop attached to the edge
+     * @type {number}
+     */
+    const existing_loop = mesh.edge_read_loop(edge_id);
+
+    if (existing_loop === NULL_POINTER) {
+        // no loops connected yet
+        mesh.edge_write_loop(edge_id, loop_id);
+
+
+    } else {
+        // insert loop between existing loop and the next one
+        const next = mesh.loop_read_radial_next(existing_loop);
+
+        mesh.loop_write_radial_next(existing_loop, loop_id);
+        mesh.loop_write_radial_prev(next, loop_id);
+
+        mesh.loop_write_radial_next(loop_id, next);
+        mesh.loop_write_radial_prev(loop_id, existing_loop);
+    }
+
+}
+
+
+/**
+ * Ensure an edge between two vertices
+ * NOTE: works without having to use a separate hash map, resulting in faster execution and smaller RAM requirement
+ * @param {number} v0
+ * @param {number} v1
+ * @param {BinaryTopology} mesh
+ */
+function get_or_create_edge_2(v0, v1, mesh) {
+    const first_edge = mesh.vertex_read_edge(v0);
+
+    if (first_edge !== NULL_POINTER) {
+
+        // iterate over all edges around the vertex
+        let edge = first_edge;
+
+        do {
+            const edge_v1 = mesh.edge_read_vertex1(edge);
+            const edge_v2 = mesh.edge_read_vertex2(edge);
+
+            if (edge_v1 === v1 || edge_v2 === v1) {
+                // found edge that connects between v0 and v1
+                return edge;
+            }
+
+            if (edge_v1 === v0) {
+                edge = mesh.edge_read_v1_disk_next(edge);
+            } else if (edge_v2 === v0) {
+                edge = mesh.edge_read_v2_disk_next(edge);
+            } else {
+                // invalid edge connection
+                throw new Error('Invalid edge, not connected to first vertex');
+            }
+
+        } while (edge !== first_edge);
+
+    }
+
+    // if match is found - return the match, else create a new edge and assign
+
+    return create_edge(mesh, v0, v1);
+}

package/core/geom/3d/topology/struct/binary/io/bt_index_geometry_to_topology.spec.js

@@ -0,0 +1,84 @@
+import { bt_index_geometry_to_topology } from "./bt_index_geometry_to_topology.js";
+import { BinaryTopology } from "../BinaryTopology.js";
+import { bt_mesh_edge_has_vertex } from "../query/bt_mesh_edge_has_vertex.js";
+
+test('Empty geometry work as expected', () => {
+    const mesh = new BinaryTopology();
+    bt_index_geometry_to_topology(mesh, [], []);
+
+    expect(mesh.faces.size).toBe(0);
+    expect(mesh.vertices.size).toBe(0);
+    expect(mesh.edges.size).toBe(0);
+    expect(mesh.loops.size).toBe(0);
+});
+
+test('Single triangle', () => {
+    const mesh = new BinaryTopology();
+    bt_index_geometry_to_topology(mesh, [0, 1, 2], [
+        1, 3, 7,
+        11, 13, 17,
+        23, 27, -1
+    ]);
+
+    expect(mesh.faces.size).toBe(1);
+    expect(mesh.loops.size).toBe(3);
+    expect(mesh.edges.size).toBe(3);
+    expect(mesh.vertices.size).toBe(3);
+
+    // validate loops
+    for (let loop_id = 0; loop_id < 3; loop_id++) {
+        const face = mesh.loop_read_face(loop_id);
+        expect(face).toEqual(0);
+
+        const loop_next = mesh.loop_read_next(loop_id);
+        expect(loop_next).not.toEqual(loop_id);
+        expect(mesh.loop_read_prev(loop_next)).toEqual(loop_id);
+
+        const loop_prev = mesh.loop_read_prev(loop_id);
+        expect(loop_prev).not.toEqual(loop_id);
+        expect(mesh.loop_read_next(loop_prev)).toEqual(loop_id);
+
+        expect(loop_prev).not.toEqual(loop_next);
+
+        // should loop around
+        expect(mesh.loop_read_next(loop_next)).toEqual(loop_prev);
+        expect(mesh.loop_read_prev(loop_prev)).toEqual(loop_next);
+    }
+
+
+    // validate edges
+    for (let edge_id = 0; edge_id < 3; edge_id++) {
+        const v1 = mesh.edge_read_vertex1(edge_id);
+        const v2 = mesh.edge_read_vertex2(edge_id);
+
+        // different vertices
+        expect(v1).not.toEqual(v2);
+
+        // validate disk links
+        const disk_v1_next = mesh.edge_read_v1_disk_next(edge_id);
+
+        expect(disk_v1_next).not.toEqual(edge_id);
+
+        expect(bt_mesh_edge_has_vertex(mesh, disk_v1_next, v1)).toBe(true);
+
+        const disk_v1_prev = mesh.edge_read_v1_disk_prev(edge_id);
+
+        expect(disk_v1_prev).not.toEqual(edge_id);
+
+        expect(bt_mesh_edge_has_vertex(mesh, disk_v1_prev, v1)).toBe(true);
+
+        const disk_v2_next = mesh.edge_read_v2_disk_next(edge_id);
+
+        expect(disk_v2_next).not.toEqual(edge_id);
+
+        expect(bt_mesh_edge_has_vertex(mesh, disk_v2_next, v2)).toBe(true);
+
+        const disk_v2_prev = mesh.edge_read_v2_disk_prev(edge_id);
+
+        expect(disk_v2_prev).not.toEqual(edge_id);
+
+        expect(bt_mesh_edge_has_vertex(mesh, disk_v2_prev, v2)).toBe(true);
+
+    }
+
+});

package/core/geom/3d/topology/struct/binary/io/bt_mesh_calc_edges.js

@@ -0,0 +1,51 @@
+import { OrderedEdge } from "./OrderedEdge.js";
+import { HashMap } from "../../../../../../collection/HashMap.d.ts";
+
+/**
+ * @see https://github.com/blender/blender/blob/9cb061f4f0119e647173e7d354e1457e97632333/source/blender/blenkernel/intern/mesh_calc_edges.cc#L209
+ * @param {BinaryTopology} mesh
+ */
+function bt_mesh_calc_edges(mesh) {
+    /**
+     *
+     * @type {HashMap<OrderedEdge, unknown>}
+     */
+    const map = new HashMap();
+
+    add_polygon_edges_to_map(mesh, map);
+}
+
+/**
+ * @see https://github.com/blender/blender/blob/9cb061f4f0119e647173e7d354e1457e97632333/source/blender/blenkernel/intern/mesh_calc_edges.cc#L96
+ * @param {BinaryTopology} mesh
+ * @param {HashMap<OrderedEdge,*>} edge_map
+ */
+function add_polygon_edges_to_map(mesh, edge_map) {
+
+    const faces = mesh.faces;
+    const face_count = faces.size;
+
+    for (let i = 0; i < face_count; i++) {
+        if (!faces.is_allocated(i)) {
+            continue;
+        }
+
+        const first_loop = mesh.face_read_loop(i);
+        let prev_loop = first_loop + j;
+
+        for (let j = 0; j < 3; j++) {
+            const loop = first_loop + j;
+
+
+            const prev_v = mesh.loop_read_vertex(prev_loop);
+            const next_v = mesh.loop_read_vertex(loop);
+
+            const edge = new OrderedEdge(prev_v, next_v);
+
+            edge_map.getOrSet(edge, null);
+
+            prev_loop = loop;
+        }
+    }
+
+}