@woosh/meep-engine 2.43.3 → 2.43.4

package/core/geom/3d/sphere/harmonics/sh3_sample_irradiance_by_direction.js

@@ -0,0 +1,53 @@
+/**
+ *
+ *
+ * c1 = 0.42904276540489171563379376569857;    // 4 * Â2.Y22 = 1/4 * sqrt(15.PI)
+ * c2 = 0.51166335397324424423977581244463;    // 0.5 * Â1.Y10 = 1/2 * sqrt(PI/3)
+ * c3 = 0.24770795610037568833406429782001;    // Â2.Y20 = 1/16 * sqrt(5.PI)
+ * c4 = 0.88622692545275801364908374167057;    // Â0.Y00 = 1/2 * sqrt(PI)
+ *
+ * @see https://github.com/mrdoob/three.js/blob/d081c5a3501d272d19375fab1b01fedf9df29b22/src/math/SphericalHarmonics3.js#L85
+ * @see https://graphics.stanford.edu/papers/envmap/envmap.pdf
+ * @see https://www.ppsloan.org/publications/StupidSH36.pdf
+ *
+ * @param {number[]} result Result will be written here
+ * @param {number} result_offset
+ * @param {number[]} harmonics coefficients are read from here
+ * @param {number} harmonics_offset offset into coefficients array where to start reading the data
+ * @param {number} dimension_count number of encoded dimensions, this is essentially a shortcut for multiple harmonics being read at the same time, such as with RGB values
+ * @param {number[]} direction 3d vector read from here, we will read 3 values from here to sample spherical harmonic, direction is assumed to be normalized
+ * @param {number} direction_offset offset into direction array
+ */
+export function sh3_sample_irradiance_by_direction(
+    result, result_offset,
+    harmonics, harmonics_offset,
+    dimension_count,
+    direction, direction_offset
+) {
+    const x = direction[direction_offset];
+    const y = direction[direction_offset + 1];
+    const z = direction[direction_offset + 2];
+
+    let channel_value;
+
+    for (let i = 0; i < dimension_count; i++) {
+
+        // band 0
+        channel_value = harmonics[harmonics_offset + i] * 0.88622692545275801364908374167057;
+
+        // band 1
+        channel_value += harmonics[harmonics_offset + dimension_count + i] * 2.0 * 0.51166335397324424423977581244463 * y;
+        channel_value += harmonics[harmonics_offset + dimension_count * 2 + i] * 2.0 * 0.51166335397324424423977581244463 * z;
+        channel_value += harmonics[harmonics_offset + dimension_count * 3 + i] * 2.0 * 0.51166335397324424423977581244463 * x;
+
+        // band 2
+        channel_value += harmonics[harmonics_offset + dimension_count * 4 + i] * 2.0 * 0.42904276540489171563379376569857 * x * y;
+        channel_value += harmonics[harmonics_offset + dimension_count * 5 + i] * 2.0 * 0.42904276540489171563379376569857 * y * z;
+        channel_value += harmonics[harmonics_offset + dimension_count * 6 + i] * (3 * z * z - 1) * 0.24770795610037568833406429782001;
+        channel_value += harmonics[harmonics_offset + dimension_count * 7 + i] * 2.0 * 0.42904276540489171563379376569857 * x * z;
+        channel_value += harmonics[harmonics_offset + dimension_count * 8 + i] * 0.42904276540489171563379376569857 * (x * x - y * y);
+
+        // write out
+        result[result_offset + i] = channel_value;
+    }
+}

package/core/geom/3d/tetrahedra/TetrahedralMesh.js

@@ -1,15 +1,25 @@
 import { tetrahedron_contains_point } from "./tetrahedron_contains_point.js";
-import { BitSet } from "../../../binary/BitSet.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 { array_copy } from "../../../collection/array/copyArray.js";
+import { array_quick_sort_by_comparator } from "../../../collection/array/arrayQuickSort.js";
+import { compareNumbersDescending } from "../../../function/Functions.js";
+import { BinaryBuffer } from "../../../binary/BinaryBuffer.js";
+import { Base64 } from "../../../binary/Base64.js";
+
+/**
+ * @readonly
+ * @type {number}
+ */
+const LAYOUT_TETRA_WORD_COUNT = 8;
 
 /**
  * Size in bytes of a single tetrahedron record
  * @readonly
  * @type {number}
  */
-export const LAYOUT_TETRA_BYTE_SIZE = 8 * 4;
+export const LAYOUT_TETRA_BYTE_SIZE = LAYOUT_TETRA_WORD_COUNT * 4;
 
 /**
  * @readonly
@@ -80,6 +90,13 @@ export class TetrahedralMesh {
          */
         this.__buffer = new ArrayBuffer(initial_size * LAYOUT_TETRA_BYTE_SIZE);
 
+        /**
+         *
+         * @type {Uint32Array}
+         * @private
+         */
+        this.__data_uint32 = new Uint32Array(this.__buffer);
+
         /**
          *
          * @type {DataView}
@@ -99,15 +116,21 @@ export class TetrahedralMesh {
          * @type {number}
          * @private
          */
-        this.__length = 0;
+        this.__used_end = 0;
 
+        /**
+         * Unused slots
+         * @type {number[]}
+         * @private
+         */
+        this.__free = [];
 
         /**
-         * Marks which indices are in use
-         * @type {BitSet}
+         *
+         * @type {number}
          * @private
          */
-        this.__occupancy = new BitSet();
+        this.__free_pointer = 0;
     }
 
     /**
@@ -116,8 +139,11 @@ export class TetrahedralMesh {
      * @param {*} [thisArg]
      */
     forEach(visitor, thisArg) {
-        const occupancy = this.__occupancy;
-        for (let i = occupancy.nextSetBit(0); i !== -1; i = occupancy.nextSetBit(i + 1)) {
+        for (let i = 0; i < this.__used_end; i++) {
+            if (!this.exists(i)) {
+                continue;
+            }
+
             visitor.call(thisArg, i, this);
         }
     }
@@ -134,7 +160,7 @@ export class TetrahedralMesh {
             return;
         }
 
-        if (capacity < this.__capacity && capacity < this.__occupancy.size()) {
+        if (capacity < this.__capacity && capacity < this.__used_end) {
             throw new Error('Reducing capacity would result in dropping information. This is an illegal operation. If you need to reduce capacity - either drop data or compact the layout first.');
         }
 
@@ -150,6 +176,7 @@ export class TetrahedralMesh {
         // set new buffer
         this.__buffer = new_buffer;
         this.__view = new DataView(new_buffer);
+        this.__data_uint32 = new Uint32Array(new_buffer);
 
         // write new capacity
         this.__capacity = capacity;
@@ -168,20 +195,20 @@ export class TetrahedralMesh {
      * @return {number}
      */
     size() {
-        return this.__length;
+        return this.__used_end;
     }
 
     /**
-     *
+     * Grow capacity to at least the specified size
      * @param {number} capacity
      */
-    ensureCapacity(capacity) {
+    growCapacity(capacity) {
 
         const existing_capacity = this.__capacity;
 
         const new_capacity = max3(
             capacity,
-            existing_capacity * CAPACITY_GROW_MULTIPLIER,
+            Math.ceil(existing_capacity * CAPACITY_GROW_MULTIPLIER),
             existing_capacity + CAPACITY_GROW_MIN_STEP
         );
 
@@ -189,23 +216,36 @@ export class TetrahedralMesh {
     }
 
     /**
-     *
+     * NOTE: this method can be quite slow in cases of sparse allocation, please prefer not to use it
      * @param {number} tet
      * @return {boolean}
      */
     exists(tet) {
-        return this.__occupancy.get(tet);
+
+        if (tet < 0 || tet >= this.__used_end) {
+            return false;
+        }
+
+        for (let i = 0; i < this.__free_pointer; i++) {
+            const free = this.__free[i];
+
+            if (tet === free) {
+                return false;
+            }
+        }
+
+        return true;
     }
 
     /**
      * NOTE: the neighbour value must be encoded, see format specification for details
      * @param {number} tetra_index
      * @param {number} neighbour_index
-     * @returns {number}
+     * @returns {number} index of the neighbour encoded with the opposite corner
      */
     getNeighbour(tetra_index, neighbour_index) {
         assert.isNonNegativeInteger(tetra_index, 'tetra_index');
-        assert.ok(this.__occupancy.get(tetra_index), 'tetrahedron does not exist');
+        assert.ok(this.exists(tetra_index), 'tetrahedron does not exist');
 
         assert.isNonNegativeInteger(neighbour_index, 'neighbour_index');
 
@@ -219,12 +259,12 @@ export class TetrahedralMesh {
      * NOTE: the neighbour value must be encoded, see format specification for details
      * @param {number} tetra_index
      * @param {number} neighbour_index which neighbour to set (0..11)
-     * @param {number} neighbour index of the neighbour
+     * @param {number} neighbour index of the neighbour encoded with the opposite corner
      */
     setNeighbour(tetra_index, neighbour_index, neighbour) {
 
         assert.isNonNegativeInteger(tetra_index, 'tetra_index');
-        assert.ok(this.__occupancy.get(tetra_index), 'tetrahedron does not exist');
+        assert.ok(this.exists(tetra_index), 'tetrahedron does not exist');
 
         assert.isNonNegativeInteger(neighbour_index, 'neighbour_index');
         assert.isNonNegativeInteger(neighbour, 'neighbour');
@@ -245,7 +285,7 @@ export class TetrahedralMesh {
     getVertexIndex(tet_index, point_index) {
         assert.isNonNegativeInteger(tet_index, 'tet_index');
         assert.lessThanOrEqual(tet_index, MAX_TET_INDEX, 'max index exceeded');
-        assert.ok(this.__occupancy.get(tet_index), 'tetrahedron does not exist');
+        //assert.ok(this.exists(tet_index), 'tetrahedron does not exist');
 
         assert.isNonNegativeInteger(point_index, 'point_index');
         assert.lessThan(point_index, 4, 'point_index must be less than 4');
@@ -263,7 +303,7 @@ export class TetrahedralMesh {
     setVertexIndex(tet_index, point_index, vertex) {
         assert.isNonNegativeInteger(tet_index, 'tet_index');
         assert.lessThanOrEqual(tet_index, MAX_TET_INDEX, 'max index exceeded');
-        assert.ok(this.__occupancy.get(tet_index), 'tetrahedron does not exist');
+        //assert.ok(this.exists(tet_index), 'tetrahedron does not exist');
 
         assert.isNonNegativeInteger(point_index, 'point_index');
         assert.lessThan(point_index, 4, 'point_index must be less than 4');
@@ -293,24 +333,6 @@ export class TetrahedralMesh {
         return false;
     }
 
-    validateLength() {
-        return this.countOccupancy() === this.__length;
-    }
-
-    /**
-     * DEBUG method
-     * Counts number of occupied(used) elements in the pool
-     * Should be the same as __length
-     * @return {number}
-     */
-    countOccupancy() {
-        let r = 0;
-        for (let i = this.__occupancy.nextSetBit(0); i !== -1; i = this.__occupancy.nextSetBit(i + 1)) {
-            r++;
-        }
-
-        return r;
-    }
 
     /**
      * Allocate empty tet
@@ -318,17 +340,20 @@ export class TetrahedralMesh {
      * @return {number} index of allocated tetrahedron
      */
     allocate() {
-        const tetra_index = this.__occupancy.nextClearBit(0);
+        if (this.__free_pointer > 0) {
+            this.__free_pointer--;
+            return this.__free[this.__free_pointer];
+        }
+
+        const tetra_index = this.__used_end;
 
-        const required_capacity = tetra_index + 1;
+        this.__used_end++;
 
-        if (required_capacity > this.__capacity) {
+        if (tetra_index >= this.__capacity) {
             // needs to be increased in size
-            this.ensureCapacity(required_capacity);
+            this.growCapacity(tetra_index);
         }
 
-        this.__occupancy.set(tetra_index, true);
-
         // initialize neighbours
         for (let i = 0; i < 4; i++) {
             this.setNeighbour(tetra_index, i, INVALID_NEIGHBOUR);
@@ -336,7 +361,6 @@ export class TetrahedralMesh {
 
         //assert(this.validateLength());
 
-        this.__length++;
 
         // assert(this.validateLength());
 
@@ -374,13 +398,11 @@ export class TetrahedralMesh {
     }
 
     /**
-     * Remove tetrahedron
+     * Sets back-links on neighbours to this tet to INVALID_NEIGHBOUR basically making them into mesh surface
+     * This is a useful method for when you want to completely remove a given tet from the mesh to make sure that no dangling references will remain
      * @param {number} tetra_index
      */
-    remove(tetra_index) {
-        assert.isNonNegativeInteger(tetra_index, 'tera_index');
-        assert.equal(this.__occupancy.get(tetra_index), true, 'tetrahedron does not exist');
-
+    disconnect(tetra_index) {
         // find neighbours and remove reference to self
         for (let i = 0; i < 4; i++) {
             const neighbour_encoded = this.getNeighbour(tetra_index, i);
@@ -397,43 +419,60 @@ export class TetrahedralMesh {
             // clear reference to self
             this.setNeighbour(neighbour_index, neighbour_point, INVALID_NEIGHBOUR);
         }
+    }
 
-        //assert(this.validateLength());
+    /**
+     * Remove tetrahedron
+     * Please note that if there are any dangling references in the mesh neighbourhood - you will need to take care of that separately
+     * @param {number} tetra_index
+     */
+    delete(tetra_index) {
+        assert.isNonNegativeInteger(tetra_index, 'tera_index');
+        assert.lessThan(tetra_index, this.__used_end, 'attempting to remove tet outside of valid region');
+        // assert.equal(this.__occupancy.get(tetra_index), true, 'tetrahedron does not exist');
+
+
+        if (tetra_index === this.__used_end - 1) {
+            // tet was at the end of the allocated space
+            this.__used_end--;
+        } else {
+            // mark as dead
+            this.__free[this.__free_pointer++] = tetra_index;
+        }
 
-        // mark as dead
-        this.__occupancy.clear(tetra_index);
-        this.__length--;
+        //assert(this.validateLength());
 
         //assert(this.validateLength());
     }
 
     /**
-     * Remove tetrahedrons who's points touch the "super-tetrahedron's" points that was inserted originally
+     * Used mainly to remove tetrahedrons whos points touch the "super-tetrahedron's" points that was inserted originally
      * These points are identified by an offset + count parameters
-     * @param {number[]|Float32Array} points
      * @param {number} range_start
      * @param {number} range_end
      */
-    removeTetrasConnectedToPoints(points, range_start, range_end) {
-        const data_view = this.__view;
+    removeTetrasConnectedToPoints(range_start, range_end) {
 
-        let j = 0;
+        for (let i = this.__used_end - 1; i >= 0; i--) {
 
-        const occupancy = this.__occupancy;
-        for (let i = occupancy.nextSetBit(0); i !== -1; i = occupancy.nextSetBit(i + 1)) {
+            for (let j = 0; j < 4; j++) {
+                const point_index = this.getVertexIndex(i, j);
 
-            const tet_address = i * LAYOUT_TETRA_BYTE_SIZE;
+                if (point_index >= range_start && point_index <= range_end) {
 
-            for (j = 0; j < 4; j++) {
-                const point_index = data_view.getUint32(tet_address + 4 * j);
+                    if (!this.exists(i)) {
+                        // tet doesn't actually exist (deallocated)
+                        break;
+                    }
 
-                if (point_index >= range_start && point_index <= range_end) {
                     // point index is in range, tetra should be removed
-                    this.remove(i);
+                    this.disconnect(i);
+                    this.delete(i);
                     break;
                 }
             }
         }
+
     }
 
     /**
@@ -446,7 +485,7 @@ export class TetrahedralMesh {
         const data_view = this.__view;
 
         // TODO improve this
-        const n = this.__length;
+        const n = this.__used_end;
         for (let i = 0; i < n; i++) {
 
             const tet_address = i * LAYOUT_TETRA_BYTE_SIZE;
@@ -464,4 +503,148 @@ export class TetrahedralMesh {
         return -1;
     }
 
+
+    /**
+     * Relocate tetrahedron in memory, patches neighbourhood links as well
+     * NOTE: The destination slot will be overwritten. This is a dangerous method that can break the topology, make sure you fully understand what you are doing when using it
+     * @param {number} source_index index of source tetrahedron
+     * @param {number} destination_index new index, where the source tetrahedron is to be moved
+     */
+    relocate(source_index, destination_index) {
+        // validate_tetrahedron_neighbourhood(this, source_index, console.error);
+
+        // patch neighbours
+        for (let i = 0; i < 4; i++) {
+            const encoded_neighbour = this.getNeighbour(source_index, i);
+
+            if (encoded_neighbour === INVALID_NEIGHBOUR) {
+                // no neighbour
+                continue;
+            }
+
+            const neighbour_index = encoded_neighbour >> 2;
+            const neighbour_vertex = encoded_neighbour & 3;
+
+            const encoded_tet = (destination_index << 2) | (i & 3);
+
+            assert.equal(this.getNeighbour(neighbour_index, neighbour_vertex), (source_index << 2) | (i & 3), 'invalid source state');
+
+            this.setNeighbour(neighbour_index, neighbour_vertex, encoded_tet);
+        }
+
+
+        const layout_word_size = LAYOUT_TETRA_BYTE_SIZE >> 2;
+        array_copy(this.__data_uint32, source_index * layout_word_size, this.__data_uint32, destination_index * layout_word_size, layout_word_size);
+
+        // validate_tetrahedron_neighbourhood(this, destination_index, console.error);
+    }
+
+    /**
+     * Perform compaction, removing unused memory slots
+     * NOTE: existing tetrahedron indices can become invalidated as tets are moved into free slots
+     * @returns {number} number of relocated elements
+     */
+    compact() {
+        // sort free
+        array_quick_sort_by_comparator(this.__free, compareNumbersDescending, null, 0, this.__free_pointer - 1);
+
+        let relocation_count = 0;
+        let free_head_pointer = 0;
+
+        while (this.__free_pointer > free_head_pointer) {
+            const last_used = this.__used_end - 1;
+
+            if (this.__free[free_head_pointer] >= last_used) {
+                /*
+                 The slot is actually free.
+                 As we have sorted the free slots, it's expected to be at the start of the list
+                 Adjust pointers and continue onto the next slot
+                 */
+                free_head_pointer++
+                this.__used_end = last_used;
+                continue;
+            }
+
+            const free_slot = this.__free[this.__free_pointer - 1];
+
+            this.__free_pointer--;
+
+            if (last_used <= free_slot) {
+                continue;
+            }
+
+
+            this.relocate(last_used, free_slot);
+            relocation_count++;
+
+            this.__used_end--;
+
+        }
+
+        this.__free.splice(0, this.__free.length); // release memory
+        this.__free_pointer = 0;
+
+        return relocation_count;
+    }
+
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     */
+    serialize(buffer) {
+        buffer.writeUint32(1); // format version
+        buffer.writeUintVar(this.__used_end);
+        buffer.writeUintVar(this.__free_pointer);
+
+        // record main buffer
+        buffer.writeUint32Array(this.__data_uint32, 0, this.__used_end * LAYOUT_TETRA_WORD_COUNT);
+        buffer.writeUint32Array(this.__free, 0, this.__free_pointer);
+    }
+
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     */
+    deserialize(buffer) {
+        const version_number = buffer.readUint32();
+
+        if (version_number !== 1) {
+            throw new Error(`Unsupported version number, expected ${1}, instead got ${version_number}`);
+        }
+
+        this.__used_end = buffer.readUintVar();
+        this.__free_pointer = buffer.readUintVar();
+
+        this.growCapacity(this.__used_end);
+
+        buffer.readUint32Array(this.__data_uint32, 0, this.__used_end);
+
+        buffer.readUint32Array(this.__free, 0, this.__free_pointer);
+    }
+
+    /**
+     *
+     * @return {string}
+     */
+    serialize_base64() {
+        const buffer = new BinaryBuffer();
+
+        this.serialize(buffer);
+
+        buffer.trim();
+
+        return Base64.encode(buffer.data);
+    }
+
+    /**
+     *
+     * @param {string} str
+     */
+    deserialize_base64(str) {
+        const arrayBuffer = Base64.decode(str);
+
+        const binaryBuffer = BinaryBuffer.fromArrayBuffer(arrayBuffer);
+
+        this.deserialize(binaryBuffer);
+    }
 }

package/core/geom/3d/tetrahedra/TetrahedralMesh.spec.js

@@ -120,7 +120,7 @@ test("remove method reduces size", () => {
 
     expect(mesh.size()).toBe(1);
 
-    mesh.remove(tet);
+    mesh.delete(tet);
 
     expect(mesh.size()).toBe(0);
 });
@@ -141,7 +141,7 @@ test("forEach visits all allocated tets", () => {
     expect(mock).toHaveBeenCalledWith(t1, mesh);
 });
 
-test("exists method", () => {
+test("'exists' method", () => {
     const mesh = new TetrahedralMesh();
 
     expect(mesh.exists(0)).toBe(false);
@@ -149,8 +149,85 @@ test("exists method", () => {
     const tet = mesh.allocate();
 
     expect(mesh.exists(tet)).toBe(true);
+    expect(mesh.exists(tet + 1)).toBe(false);
 
-    mesh.remove(tet);
+    mesh.delete(tet);
 
     expect(mesh.exists(tet)).toBe(false);
+    expect(mesh.exists(tet + 1)).toBe(false);
+});
+
+
+test("after calling 'removeTetrasConnectedToPoints' matching points are no logner indexed by live tetrahedrons", () => {
+
+
+    const tetrahedra = new TetrahedralMesh();
+
+    /*
+     * This "magic" mesh is a result of tetrahedral mesh generator with following input:  0, 0, 0, 10, 0, 0, 10, 0, 10, 0, 0, 10, 0, 10, 0,
+     * The mesh was generated on 27/10/2022
+     * It's a very small example with 21 total tets that was failing this test
+     *
+     */
+    tetrahedra.deserialize_base64('AAAAARUAAQAAAAAAAAAFAAAABgAAAAsAAAAUAAAAHwAAADQAAAADAAAABwAAAAUAAAAIAAAA/////yoAAABAAAAALgAAAAAAAAAFAAAABgAAAAgAAAD/////HAAAACgAAAAAAAAAAgAAAAUAAAAHAAAABgAAAP////8TAAAAFQAAACwAAAACAAAABgAAAAcAAAAIAAAA/////zwAAAAwAAAADQAAAAIAAAABAAAABQAAAAYAAAABAAAADgAAACAAAAA4AAAABAAAAAEAAAAGAAAACAAAAB0AAAAyAAAASQAAACEAAAABAAAAAAAAAAYAAAAIAAAACQAAABgAAABIAAAAAgAAAAQAAAACAAAABgAAAAEAAAAWAAAAGwAAACUAAAAzAAAABAAAAAMAAAACAAAAAQAAADsAAAAiAAAAUwAAAEYAAAADAAAABQAAAAAAAAAIAAAACgAAAEwAAAAFAAAANQAAAAMAAAAHAAAAAgAAAAUAAAAPAAAAOgAAAAcAAABEAAAABAAAAAYAAAACAAAACAAAABIAAAA+AAAAGQAAACMAAAADAAAAAQAAAAAAAAAFAAAAAwAAACsAAAA5AAAAUAAAAAMAAAACAAAAAQAAAAUAAAAXAAAANgAAAC0AAAAkAAAABAAAAAIAAAAHAAAACAAAABEAAABCAAAAMQAAAEUAAAAEAAAABwAAAAMAAAAIAAAABgAAAE4AAAA9AAAARwAAAAQAAAADAAAABwAAAAIAAAAvAAAAPwAAACcAAABDAAAABAAAAAAAAAABAAAACAAAAB4AAAAaAAAATQAAAFEAAAAEAAAAAwAAAAAAAAAIAAAAKQAAAEoAAABBAAAAUgAAAAQAAAADAAAAAQAAAAAAAAA3AAAASwAAAE8AAAAmAAAA');
+
+    tetrahedra.removeTetrasConnectedToPoints(5, 8);
+
+    //The mesh should contain only 5 vertices
+
+    tetrahedra.forEach((tet, mesh) => {
+
+        for (let i = 0; i < 4; i++) {
+            expect(mesh.getVertexIndex(tet, i)).toBeLessThan(5);
+        }
+
+    });
+});
+
+test('relocate operation copies tet data and updates back-links correctly', () => {
+    const mesh = new TetrahedralMesh();
+
+    const a = mesh.allocate();
+    const b = mesh.allocate();
+    const dest = mesh.allocate();
+
+    mesh.setVertexIndex(a, 0, 3);
+    mesh.setVertexIndex(a, 1, 7);
+    mesh.setVertexIndex(a, 2, 11);
+    mesh.setVertexIndex(a, 3, 13);
+
+    mesh.setNeighbour(a, 0, b << 2);
+    mesh.setNeighbour(b, 0, a << 2);
+
+    mesh.relocate(a, dest);
+
+    expect(mesh.getVertexIndex(dest, 0)).toBe(3);
+    expect(mesh.getVertexIndex(dest, 1)).toBe(7);
+    expect(mesh.getVertexIndex(dest, 2)).toBe(11);
+    expect(mesh.getVertexIndex(dest, 3)).toBe(13);
+
+    expect(mesh.getNeighbour(dest, 0)).toBe(b << 2);
+
+    // check back-link
+    expect(mesh.getNeighbour(b, 0)).toBe(dest << 2);
+});
+
+test('Compaction is non-destructive when moving resident data from the very end of the allocated region', () => {
+    const mesh = new TetrahedralMesh();
+
+    const a = mesh.allocate();
+    const b = mesh.allocate();
+
+    // force move "a" to free set
+    mesh.__free[mesh.__free_pointer++] = a;
+
+    expect(mesh.exists(b)).toBe(true);
+    expect(mesh.exists(a)).toBe(false);
+
+    mesh.compact();
+
+    expect(mesh.size()).toBe(1);
+
+    expect(mesh.exists(0)).toBe(true);
+    expect(mesh.exists(1)).toBe(false);
 });