@woosh/meep-engine 2.168.0 → 2.169.0

package/src/core/geom/3d/triangle/tri3_compute_signed_volume.js

@@ -3,6 +3,38 @@ const ONE_OVER_SIX = 1.0 / 6.0;
 /**
  * Compute signed volume of a tetrahedron with the last point at the origin
  * Triangle is defined by points A,B,C
+ *
+ * Evaluated as `p · ((q - p) × (r - p))` where `(p, q, r)` is the cyclic
+ * rotation of `(a, b, c)` that puts the vertex nearest the origin first. Both
+ * steps are exact rewrites of `a · (b × c)`: a cyclic rotation leaves a 3×3
+ * determinant unchanged, and the two extra terms the edge form introduces,
+ * `p · (q × p)` and `p · (p × r)`, are identically zero.
+ *
+ * The rotation is not cosmetic — the two forms fail in opposite regimes, and
+ * picking the apex is what makes the result well conditioned in both. The
+ * error behaves like `eps · |p| · |q - p| · |r - p|`:
+ *
+ *   - the expanded determinant of absolute coordinates loses everything for a
+ *     SMALL triangle FAR from the origin. Summed over a unit cube translated to
+ *     (1e6, 1e6, 1e6) it returned 256, and −262144 at 1e7;
+ *   - anchoring unconditionally on `a` instead loses everything for a LARGE
+ *     triangle reaching IN toward the origin, where `|b - a|` and `|c - a|` are
+ *     both as large as `|a|`. `(1e8, 1e8, 1e8), (1, 0, 0), (0, 1, 0)` returned
+ *     0 for a true volume of 16666666.67, and flipped the sign of a needle
+ *     tetrahedron often enough to break callers using this as an orientation
+ *     predicate.
+ *
+ * Anchoring on the vertex nearest the origin is exact in both, and measured at
+ * a worst relative error of 8e-13 over 400k triangles with each vertex drawn
+ * from an independent magnitude decade up to 1e9.
+ *
+ * Distance is compared by largest absolute component rather than by squared
+ * length, which is cheaper and cannot overflow for coordinates above ~1e154.
+ *
+ * A caller summing over a whole mesh should still subtract a reference point,
+ * as {@link tri3_mesh_compute_signed_volume} does: this conditions each term,
+ * but only the caller can stop the terms themselves from being enormous.
+ *
  * @see "EFFICIENT FEATURE EXTRACTION FOR 2D/3D OBJECTS IN MESH REPRESENTATION" by Cha Zhang and Tsuhan Chen
  * @param {number} ax
  * @param {number} ay
@@ -21,13 +53,40 @@ export function tri3_compute_signed_volume(
     cx, cy, cz
 ) {
 
-    const v321 = cx * by * az;
-    const v231 = bx * cy * az;
-    const v312 = cx * ay * bz;
-    const v132 = ax * cy * bz;
-    const v213 = bx * ay * cz;
-    const v123 = ax * by * cz;
+    const ea = Math.max(Math.abs(ax), Math.abs(ay), Math.abs(az));
+    const eb = Math.max(Math.abs(bx), Math.abs(by), Math.abs(bz));
+    const ec = Math.max(Math.abs(cx), Math.abs(cy), Math.abs(cz));
 
-    return ONE_OVER_SIX * (-v321 + v231 + v312 - v132 - v213 + v123);
+    // (p, q, r) is a CYCLIC rotation of (a, b, c) — swapping any two would
+    // negate the determinant.
+    let px, py, pz, qx, qy, qz, rx, ry, rz;
+
+    if (eb <= ea && eb <= ec) {
+        px = bx; py = by; pz = bz;
+        qx = cx; qy = cy; qz = cz;
+        rx = ax; ry = ay; rz = az;
+    } else if (ec <= ea && ec <= eb) {
+        px = cx; py = cy; pz = cz;
+        qx = ax; qy = ay; qz = az;
+        rx = bx; ry = by; rz = bz;
+    } else {
+        px = ax; py = ay; pz = az;
+        qx = bx; qy = by; qz = bz;
+        rx = cx; ry = cy; rz = cz;
+    }
+
+    const e1x = qx - px;
+    const e1y = qy - py;
+    const e1z = qz - pz;
+
+    const e2x = rx - px;
+    const e2y = ry - py;
+    const e2z = rz - pz;
+
+    const nx = e1y * e2z - e1z * e2y;
+    const ny = e1z * e2x - e1x * e2z;
+    const nz = e1x * e2y - e1y * e2x;
+
+    return ONE_OVER_SIX * (px * nx + py * ny + pz * nz);
 
 }

package/src/core/geom/3d/triangle/tri3_mesh_compute_signed_volume.d.ts

@@ -11,10 +11,31 @@
  * tetrahedralized version of the same closed surface should have a total tet
  * volume close to this value (small discretization gap aside).
  *
+ * Two things make the sum trustworthy away from the origin.
+ *
+ * The apex of every tetrahedron is the mesh's own first referenced vertex
+ * rather than the origin. For a closed mesh the total is invariant to that
+ * choice, but the conditioning is not: with the origin as apex, a mesh sitting
+ * at 1e7 produces per-triangle terms around 1e21 that must cancel down to the
+ * enclosed volume, and there is no precision left to cancel with. Anchored to
+ * the mesh itself, each term is on the scale of the mesh, not of its distance
+ * from the origin.
+ *
+ * The terms are then accumulated with Neumaier compensation, which recovers the
+ * low-order bits lost whenever a term is added to a running total of a very
+ * different magnitude — the situation for any shape whose bounding box dwarfs
+ * its volume, such as a thin shell.
+ *
+ * Note this changes what an OPEN mesh reports, which was already documented as
+ * not being an enclosed volume: the cone is now measured from the first
+ * referenced vertex instead of the origin, so the number is at least a property
+ * of the mesh rather than of where the mesh happens to be. For a closed mesh
+ * nothing changes but the accuracy.
+ *
  * @param {ArrayLike<number>} positions flat (x,y,z,…) array
  * @param {ArrayLike<number>} indices   3 entries per triangle
  * @returns {number} signed volume — positive for CCW-from-outside winding,
- *                   negative if flipped, zero for an open or self-cancelling mesh
+ *                   negative if flipped, zero for an empty or self-cancelling mesh
  */
 export function tri3_mesh_compute_signed_volume(positions: ArrayLike<number>, indices: ArrayLike<number>): number;
 //# sourceMappingURL=tri3_mesh_compute_signed_volume.d.ts.map

package/src/core/geom/3d/triangle/tri3_mesh_compute_signed_volume.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tri3_mesh_compute_signed_volume.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/triangle/tri3_mesh_compute_signed_volume.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;GAiBG;AACH,2DALW,UAAU,MAAM,CAAC,WACjB,UAAU,MAAM,CAAC,GACf,MAAM,CAoBlB"}
+{"version":3,"file":"tri3_mesh_compute_signed_volume.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/triangle/tri3_mesh_compute_signed_volume.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,2DALW,UAAU,MAAM,CAAC,WACjB,UAAU,MAAM,CAAC,GACf,MAAM,CA4ClB"}

package/src/core/geom/3d/triangle/tri3_mesh_compute_signed_volume.js

@@ -1,38 +1,83 @@
-import { tri3_compute_signed_volume } from "./tri3_compute_signed_volume.js";
-
-/**
- * Compute the signed volume enclosed by a triangle surface mesh given as
- * flat positions + indices, via the divergence theorem.
- *
- * For every triangle (a, b, c) this sums the signed volume of the
- * tetrahedron (origin, a, b, c); when the mesh is closed and consistently
- * wound (CCW from outside → positive volume), the per-triangle contributions
- * cancel everywhere except inside the surface, leaving the enclosed volume.
- *
- * Useful as a ground truth for validating volumetric mesh generation: the
- * tetrahedralized version of the same closed surface should have a total tet
- * volume close to this value (small discretization gap aside).
- *
- * @param {ArrayLike<number>} positions flat (x,y,z,…) array
- * @param {ArrayLike<number>} indices   3 entries per triangle
- * @returns {number} signed volume — positive for CCW-from-outside winding,
- *                   negative if flipped, zero for an open or self-cancelling mesh
- */
-export function tri3_mesh_compute_signed_volume(positions, indices) {
-    let total = 0;
-
-    const n = indices.length;
-    for (let i = 0; i < n; i += 3) {
-        const a3 = indices[i] * 3;
-        const b3 = indices[i + 1] * 3;
-        const c3 = indices[i + 2] * 3;
-
-        total += tri3_compute_signed_volume(
-            positions[a3],     positions[a3 + 1], positions[a3 + 2],
-            positions[b3],     positions[b3 + 1], positions[b3 + 2],
-            positions[c3],     positions[c3 + 1], positions[c3 + 2],
-        );
-    }
-
-    return total;
-}
+import { tri3_compute_signed_volume } from "./tri3_compute_signed_volume.js";
+
+/**
+ * Compute the signed volume enclosed by a triangle surface mesh given as
+ * flat positions + indices, via the divergence theorem.
+ *
+ * For every triangle (a, b, c) this sums the signed volume of the
+ * tetrahedron (origin, a, b, c); when the mesh is closed and consistently
+ * wound (CCW from outside → positive volume), the per-triangle contributions
+ * cancel everywhere except inside the surface, leaving the enclosed volume.
+ *
+ * Useful as a ground truth for validating volumetric mesh generation: the
+ * tetrahedralized version of the same closed surface should have a total tet
+ * volume close to this value (small discretization gap aside).
+ *
+ * Two things make the sum trustworthy away from the origin.
+ *
+ * The apex of every tetrahedron is the mesh's own first referenced vertex
+ * rather than the origin. For a closed mesh the total is invariant to that
+ * choice, but the conditioning is not: with the origin as apex, a mesh sitting
+ * at 1e7 produces per-triangle terms around 1e21 that must cancel down to the
+ * enclosed volume, and there is no precision left to cancel with. Anchored to
+ * the mesh itself, each term is on the scale of the mesh, not of its distance
+ * from the origin.
+ *
+ * The terms are then accumulated with Neumaier compensation, which recovers the
+ * low-order bits lost whenever a term is added to a running total of a very
+ * different magnitude — the situation for any shape whose bounding box dwarfs
+ * its volume, such as a thin shell.
+ *
+ * Note this changes what an OPEN mesh reports, which was already documented as
+ * not being an enclosed volume: the cone is now measured from the first
+ * referenced vertex instead of the origin, so the number is at least a property
+ * of the mesh rather than of where the mesh happens to be. For a closed mesh
+ * nothing changes but the accuracy.
+ *
+ * @param {ArrayLike<number>} positions flat (x,y,z,…) array
+ * @param {ArrayLike<number>} indices   3 entries per triangle
+ * @returns {number} signed volume — positive for CCW-from-outside winding,
+ *                   negative if flipped, zero for an empty or self-cancelling mesh
+ */
+export function tri3_mesh_compute_signed_volume(positions, indices) {
+    const n = indices.length;
+
+    if (n === 0) {
+        return 0;
+    }
+
+    // Anchor the tetrahedra at the mesh instead of at the origin.
+    const origin3 = indices[0] * 3;
+
+    const ox = positions[origin3];
+    const oy = positions[origin3 + 1];
+    const oz = positions[origin3 + 2];
+
+    let total = 0;
+    // Neumaier compensation: the bits that fell off the bottom of `total`.
+    let compensation = 0;
+
+    for (let i = 0; i < n; i += 3) {
+        const a3 = indices[i] * 3;
+        const b3 = indices[i + 1] * 3;
+        const c3 = indices[i + 2] * 3;
+
+        const term = tri3_compute_signed_volume(
+            positions[a3] - ox, positions[a3 + 1] - oy, positions[a3 + 2] - oz,
+            positions[b3] - ox, positions[b3 + 1] - oy, positions[b3 + 2] - oz,
+            positions[c3] - ox, positions[c3 + 1] - oy, positions[c3 + 2] - oz,
+        );
+
+        const sum = total + term;
+
+        if (Math.abs(total) >= Math.abs(term)) {
+            compensation += (total - sum) + term;
+        } else {
+            compensation += (term - sum) + total;
+        }
+
+        total = sum;
+    }
+
+    return total + compensation;
+}