@fusion.dev/helix-graph 0.122.0 → 0.124.0

package/dist/three/surface.js

@@ -0,0 +1,112 @@
+const CELLS = 72;
+export const surfaceOf = (field, { at = 0, cells = CELLS, } = {}) => {
+    const { depth, height, width } = field;
+    const cell = Math.max(width, height, depth) / cells;
+    const nx = Math.ceil(width / cell) + 3;
+    const ny = Math.ceil(height / cell) + 3;
+    const nz = Math.ceil(depth / cell) + 3;
+    const value = new Float32Array(nx * ny * nz);
+    const spot = (x, y, z) => (z * ny + y) * nx + x;
+    for (let z = 0; z < nz; z++) {
+        for (let y = 0; y < ny; y++) {
+            for (let x = 0; x < nx; x++) {
+                value[spot(x, y, z)] = field.distance((x - 1) * cell, (y - 1) * cell, (z - 1) * cell) - at;
+            }
+        }
+    }
+    const cornerOf = new Int32Array((nx - 1) * (ny - 1) * (nz - 1)).fill(-1);
+    const cellSpot = (x, y, z) => (z * (ny - 1) + y) * (nx - 1) + x;
+    const corners = [];
+    const edges = [
+        [0, 1],
+        [2, 3],
+        [4, 5],
+        [6, 7],
+        [0, 2],
+        [1, 3],
+        [4, 6],
+        [5, 7],
+        [0, 4],
+        [1, 5],
+        [2, 6],
+        [3, 7],
+    ];
+    const offsets = [
+        [0, 0, 0],
+        [1, 0, 0],
+        [0, 1, 0],
+        [1, 1, 0],
+        [0, 0, 1],
+        [1, 0, 1],
+        [0, 1, 1],
+        [1, 1, 1],
+    ];
+    const values = new Float32Array(8);
+    for (let z = 0; z < nz - 1; z++) {
+        for (let y = 0; y < ny - 1; y++) {
+            for (let x = 0; x < nx - 1; x++) {
+                let inside = 0;
+                for (let corner = 0; corner < 8; corner++) {
+                    const [dx, dy, dz] = offsets[corner];
+                    const sample = value[spot(x + dx, y + dy, z + dz)];
+                    values[corner] = sample;
+                    if (sample < 0) {
+                        inside += 1;
+                    }
+                }
+                if (inside === 0 || inside === 8) {
+                    continue;
+                }
+                let sx = 0;
+                let sy = 0;
+                let sz = 0;
+                let crossed = 0;
+                for (const [from, to] of edges) {
+                    const a = values[from];
+                    const b = values[to];
+                    if (a < 0 === b < 0) {
+                        continue;
+                    }
+                    const t = a / (a - b);
+                    const [ax, ay, az] = offsets[from];
+                    const [bx, by, bz] = offsets[to];
+                    sx += ax + (bx - ax) * t;
+                    sy += ay + (by - ay) * t;
+                    sz += az + (bz - az) * t;
+                    crossed += 1;
+                }
+                cornerOf[cellSpot(x, y, z)] = corners.length / 3;
+                corners.push((x + sx / crossed - 1) * cell, (y + sy / crossed - 1) * cell, (z + sz / crossed - 1) * cell);
+            }
+        }
+    }
+    const triangles = [];
+    const quad = (a, b, c, d, flip) => {
+        if (a < 0 || b < 0 || c < 0 || d < 0) {
+            return;
+        }
+        if (flip) {
+            triangles.push(a, c, b, a, d, c);
+        }
+        else {
+            triangles.push(a, b, c, a, c, d);
+        }
+    };
+    for (let z = 1; z < nz - 1; z++) {
+        for (let y = 1; y < ny - 1; y++) {
+            for (let x = 1; x < nx - 1; x++) {
+                const here = value[spot(x, y, z)] < 0;
+                if (x < nx - 1 && here !== value[spot(x + 1, y, z)] < 0) {
+                    quad(cornerOf[cellSpot(x, y - 1, z - 1)], cornerOf[cellSpot(x, y, z - 1)], cornerOf[cellSpot(x, y, z)], cornerOf[cellSpot(x, y - 1, z)], here);
+                }
+                if (y < ny - 1 && here !== value[spot(x, y + 1, z)] < 0) {
+                    quad(cornerOf[cellSpot(x - 1, y, z - 1)], cornerOf[cellSpot(x - 1, y, z)], cornerOf[cellSpot(x, y, z)], cornerOf[cellSpot(x, y, z - 1)], here);
+                }
+                if (z < nz - 1 && here !== value[spot(x, y, z + 1)] < 0) {
+                    quad(cornerOf[cellSpot(x - 1, y - 1, z)], cornerOf[cellSpot(x, y - 1, z)], cornerOf[cellSpot(x, y, z)], cornerOf[cellSpot(x - 1, y, z)], here);
+                }
+            }
+        }
+    }
+    return { corners: new Float32Array(corners), triangles: new Uint32Array(triangles) };
+};