@woosh/meep-engine 2.48.20 → 2.48.21

package/src/engine/graphics/micron/build/clustering/build_leaf_patches.js

@@ -1,326 +0,0 @@
-import { computeMeshSurfaceArea } from "../../../geometry/computeMeshSurfaceArea.js";
-import { BitSet } from "../../../../../core/binary/BitSet.js";
-import { computeOpenFaceFreedom } from "./computeOpenFaceFreedom.js";
-import FastBinaryHeap from "../../../../../core/collection/heap/FastBinaryHeap.js";
-import { PatchRepresentation } from "../PatchRepresentation.js";
-import { MICRON_PATCH_SIZE_MAX } from "../MICRON_PATCH_SIZE_MAX.js";
-import { populateOpenFaceNeighboursForPatch } from "./populateOpenFaceNeighboursForPatch.js";
-import { update_topo_face_normals } from "../../../../../core/geom/3d/topology/update_topo_face_normals.js";
-import { computeBorderLengthChange } from "./computeBorderLengthChange.js";
-import { sign } from "../../../../../core/math/sign.js";
-import { vec3 } from "gl-matrix";
-import { TopoMesh } from "../../../../../core/geom/3d/topology/struct/TopoMesh.js";
-
-const scratch_set = new Set();
-
-/**
- *
- * @param {PatchRepresentation} patch
- * @param {TopoTriangle} face
- * @param {Map<number, PatchRepresentation[]>} vertex_to_patch_map
- * @returns {number}
- */
-function count_additional_neighbour_patches(patch, face, vertex_to_patch_map) {
-    const neighbours = patch.neighbours;
-
-    const face_vertices = face.vertices;
-
-    scratch_set.clear();
-    const unique_additions = scratch_set;
-
-    for (let i = 0; i < 3; i++) {
-
-        const vertex = face_vertices[i];
-
-        const adjacent_patches = vertex_to_patch_map.get(vertex.index);
-
-        if (adjacent_patches === undefined) {
-            continue;
-        }
-
-        for (let j = 0; j < adjacent_patches.length; j++) {
-            const adjacent_patch = adjacent_patches[j];
-
-            if (adjacent_patch === patch) {
-                continue;
-            }
-
-            if (!neighbours.includes(adjacent_patch)) {
-                unique_additions.add(adjacent_patch);
-            }
-        }
-
-    }
-
-    return unique_additions.size;
-}
-
-/**
- * @param {TopoMesh} topoMesh
- * @param {number[]|Uint8Array|Uint32Array} index_attribute
- * @param {number[]|Float32Array} position_attribute
- * @param {Map<number, PatchRepresentation>} face_to_patch_map
- * @param {Map<number, PatchRepresentation[]>} vertex_to_patch_map
- */
-export function build_leaf_patches(
-    topoMesh,
-    index_attribute,
-    position_attribute,
-    face_to_patch_map,
-    vertex_to_patch_map
-) {
-
-    // face normals are required by various metrics and for normal-cone calculation
-    const input_topology_face_count = topoMesh.getFaces().size;
-
-    /**
-     *
-     * @type {TopoTriangle[]}
-     */
-    const topo_mesh_faces_array = Array.from(topoMesh.getFaces());
-
-    update_topo_face_normals(topo_mesh_faces_array, input_topology_face_count);
-
-    const polygon_count = index_attribute.length / 3;
-
-    /**
-     * Areas of individual triangles
-     * @type {Float32Array}
-     */
-    const face_areas = new Float32Array(polygon_count);
-
-    computeMeshSurfaceArea(face_areas, position_attribute, index_attribute, polygon_count);
-
-    // organize initial geometry into first level patches
-
-    let open_set_size = input_topology_face_count;
-
-    const open_set = BitSet.fixedSize(open_set_size);
-
-    open_set.setRange(0, open_set_size - 1);
-    let min_open_set_index = -1;
-
-    let starting_face_index;
-    let target_polygon_area = 0;
-
-    /**
-     *
-     * @type {Map<number, number>}
-     */
-    const distances = new Map();
-
-
-    let patch;
-
-    /**
-     * Lower is better
-     * @param {number} face_index
-     * @returns {number}
-     */
-    function score_function(face_index) {
-
-        /**
-         *
-         * @type {number}
-         */
-        const previous_face_index = came_from_map.get(face_index);
-
-        if (previous_face_index === undefined) {
-            return 0;
-        }
-
-        // distance score serves to keep topology roughly circular around the starting face
-        const distance_cost = distances.get(face_index);
-
-
-        // polygon score serves to keep triangles in the patch roughly same area
-        const polygon_area = face_areas[face_index];
-
-        /**
-         *
-         * @type {TopoTriangle}
-         */
-        const topo_face = topo_mesh_faces_array[face_index];
-
-        /**
-         *
-         * @type {TopoTriangle}
-         */
-        const previous_face = topo_mesh_faces_array[previous_face_index];
-
-        const normal_dot_cost = -vec3.dot(topo_face.normal, previous_face.normal);
-
-        const freedom_cost = computeOpenFaceFreedom(topo_face, open_set, topoMesh);
-
-        // Try to avoid acquiring more neighbour patches
-        const added_neighbour_cost = count_additional_neighbour_patches(patch, topo_face, vertex_to_patch_map);
-
-        // perimeter score, tries to keep the outline of the patch smooth
-        const perimeter_change = computeBorderLengthChange(topo_face, patch, face_to_patch_map);
-
-        /*
-        Compute change to perimeter/area ratio of the patch
-        Using equilateral triangle as a basis for normalization
-        A = ( (√3)/4 )*a²
-         */
-        const area_perimeter_cost = sign(perimeter_change) * (perimeter_change * perimeter_change * 0.43301270189) / (polygon_area + 0.0001);
-
-        return distance_cost
-            + normal_dot_cost * 0.01
-            + area_perimeter_cost * 0.01
-            + added_neighbour_cost
-            + freedom_cost * 2.001
-            ;
-    }
-
-    /**
-     * Which face did we come to this face from?
-     * @type {Map<number, number>}
-     */
-    const came_from_map = new Map();
-
-    /**
-     *
-     * @type {BinaryHeap<number>}
-     */
-    const patch_face_candidates = new FastBinaryHeap(score_function);
-
-    /**
-     *
-     * @type {PatchRepresentation[]}
-     */
-    const patches = [];
-
-    while (open_set_size > 0) {
-
-        if (patch_face_candidates.isEmpty()) {
-            // pick any face
-            starting_face_index = open_set.nextSetBit(min_open_set_index);
-            min_open_set_index = starting_face_index + 1;
-        } else {
-            // pick next candidate
-            starting_face_index = patch_face_candidates.pop();
-        }
-
-        // set desired area
-        target_polygon_area = face_areas[starting_face_index];
-
-        patch = new PatchRepresentation();
-
-        came_from_map.clear();
-
-        distances.clear();
-        patch_face_candidates.clear();
-
-        // record starting face
-        distances.set(starting_face_index, 0);
-        patch_face_candidates.push(starting_face_index);
-
-        const patch_topology = new TopoMesh();
-
-        for (let i = 0; i < MICRON_PATCH_SIZE_MAX && !patch_face_candidates.isEmpty(); i++) {
-            // get next
-            const next_face_index = patch_face_candidates.pop();
-            const next_face = topo_mesh_faces_array[next_face_index];
-
-            patch_topology.injectFace(next_face);
-
-            face_to_patch_map.set(next_face_index, patch);
-
-            // remove from open set
-            open_set.clear(next_face_index);
-            open_set_size--;
-
-            // re-score face neighbours
-
-            const next_face_edges = next_face.edges;
-            const next_face_edge_count = next_face_edges.length;
-
-            for (let j = 0; j < next_face_edge_count; j++) {
-                const next_face_edge = next_face_edges[j];
-
-                const faces_x = next_face_edge.faces;
-                const faces_x_count = faces_x.length;
-
-                for (let k = 0; k < faces_x_count; k++) {
-                    const face_x = faces_x[k];
-
-                    if (face_x === next_face) {
-                        // skip self
-                        continue;
-                    }
-
-                    const neighbour_index = face_x.index;
-
-                    const index_in_heap = patch_face_candidates.data.indexOf(neighbour_index);
-                    if (index_in_heap !== -1) {
-                        // re-score face
-                        patch_face_candidates.bubbleDown(index_in_heap);
-                    }
-                }
-
-            }
-
-            const next_face_vertices = next_face.vertices;
-            vertex_loop: for (let j = 0; j < 3; j++) {
-                const v = next_face_vertices[j];
-
-                const vertex_index = v.index;
-
-                if (patch.vertices_included.has(vertex_index)) {
-                    // already included
-                    continue;
-                }
-
-                patch.vertices_included.add(vertex_index);
-
-                const existing_patches = vertex_to_patch_map.get(vertex_index);
-
-                if (existing_patches === undefined) {
-                    vertex_to_patch_map.set(vertex_index, [patch]);
-                } else {
-                    // has neighbours
-                    const existing_patch_count = existing_patches.length;
-                    for (let j = 0; j < existing_patch_count; j++) {
-                        const neighbour = existing_patches[j];
-
-                        if (neighbour === patch) {
-                            // already referenced
-                            continue vertex_loop;
-                        }
-
-                        if (patch.hasNeighbour(neighbour)) {
-                            continue;
-                        }
-
-                        patch.addNeighbour(neighbour);
-                        neighbour.addNeighbour(patch);
-                    }
-
-                    existing_patches.push(patch);
-                }
-            }
-
-            // get neighbours
-            populateOpenFaceNeighboursForPatch(
-                open_set,
-                patch_face_candidates,
-                distances,
-                next_face,
-                distances.get(next_face_index),
-                came_from_map
-            );
-        }
-
-        patch.topology_snapshot = new TopoMesh();
-        patch.topology_snapshot.add(patch_topology);
-
-        patch.computeBounds();
-        patch.computeNormalBoundingCone();
-
-
-        patches.push(patch);
-    }
-
-    return patches;
-}

package/src/engine/graphics/micron/build/clustering/build_leaf_patches_metis.js

@@ -1,76 +0,0 @@
-import { cluster_mesh_metis } from "../../../../../core/graph/cluster_mesh_metis.js";
-import { MICRON_PATCH_SIZE_MAX } from "../MICRON_PATCH_SIZE_MAX.js";
-import { PatchRepresentation } from "../PatchRepresentation.js";
-import { TopoMesh } from "../../../../../core/geom/3d/topology/struct/TopoMesh.js";
-import { assign_patch_neighbours_from_topology } from "./assign_patch_neighbours_from_topology.js";
-
-/**
- * @param {TopoMesh} topoMesh
- * @param {number[]|Uint8Array|Uint32Array} index_attribute
- * @param {number[]|Float32Array} position_attribute
- * @param {Map<number, PatchRepresentation>} face_to_patch_map
- * @param {Map<number, PatchRepresentation[]>} vertex_to_patch_map
- */
-export async function build_leaf_patches_metis(
-    topoMesh,
-    index_attribute,
-    position_attribute,
-    face_to_patch_map,
-    vertex_to_patch_map
-) {
-
-    const input_face_count = topoMesh.getFaces().size;
-    const face_array = Array.from(topoMesh.getFaces());
-
-    const partitioning = new Uint32Array(input_face_count);
-
-    const cluster_count = await cluster_mesh_metis(partitioning, topoMesh, MICRON_PATCH_SIZE_MAX);
-
-    const partition_map = [];
-    const result = [];
-    const vertex_maps = [];
-
-    function getPartitionPatch(index) {
-        const existing_patch = partition_map[index];
-
-        if (existing_patch !== undefined) {
-            return existing_patch;
-        }
-
-        const patch = new PatchRepresentation();
-        patch.topology_snapshot = new TopoMesh();
-        partition_map[index] = patch;
-
-        vertex_maps[index] = new Map();
-
-        result.push(patch);
-
-        return patch;
-    }
-
-
-    for (let i = 0; i < input_face_count; i++) {
-        const cluster_index = partitioning[i];
-
-        const patch = getPartitionPatch(cluster_index);
-        const vertex_map = vertex_maps[cluster_index];
-
-        const face = face_array[i];
-
-        patch.topology_snapshot.addFaceCopy(face, vertex_map);
-    }
-
-    for (let i = 0; i < cluster_count; i++) {
-
-        const patch = result[i];
-
-        patch.computeBounds();
-        patch.computeNormalBoundingCone();
-
-    }
-
-    // compute neighbours
-    assign_patch_neighbours_from_topology(result);
-
-    return result;
-}

package/src/engine/graphics/micron/build/clustering/computeBorderLengthChange.js

@@ -1,59 +0,0 @@
-/**
- * If a given face is added to the patch, how beneficial would that be?
- * @param {TopoTriangle} addition
- * @param {PatchRepresentation} patch
- * @param {Map<number, PatchRepresentation>} face_to_patch_map
- * @returns {number}
- */
-export function computeBorderLengthChange(addition, patch, face_to_patch_map) {
-    const candidate_edges = addition.edges;
-    const candidate_edge_count = candidate_edges.length;
-
-    let in_edge_count = 0;
-    let out_edge_count = 0;
-    let in_edge_length = 0;
-    let out_edge_length = 0;
-
-    let is_edge_in;
-
-    for (let i = 0; i < candidate_edge_count; i++) {
-        const edge = candidate_edges[i];
-
-        const neighbour_faces = edge.faces;
-        const neighbour_face_count = neighbour_faces.length;
-
-        is_edge_in = false;
-        for (let j = 0; j < neighbour_face_count; j++) {
-            const neighbour_face = neighbour_faces[j];
-
-            if (neighbour_face === addition) {
-                // skip self
-                continue;
-            }
-
-            const neighbour_face_index = neighbour_face.index;
-            const patch_assignment = face_to_patch_map.get(neighbour_face_index);
-
-            if (patch_assignment === patch) {
-                // neighbour is assigned to our patch
-                is_edge_in = true;
-                break;
-            }
-
-
-        }
-
-        // take edge length
-        const edge_length = edge.length;
-
-        if (is_edge_in) {
-            in_edge_count++;
-            in_edge_length += edge_length;
-        } else {
-            out_edge_count++;
-            out_edge_length += edge_length;
-        }
-    }
-
-    return (out_edge_length - in_edge_length);
-}

package/src/engine/graphics/micron/build/clustering/computeFaceCurvatureScore.js

@@ -1,57 +0,0 @@
-import { v3_dot } from "../../../../../core/geom/v3_dot.js";
-
-/**
- * If a given face is added to the patch, how beneficial would that be?
- * @param {TopoTriangle} addition
- * @param {PatchRepresentation} patch
- * @param {Map<number, PatchRepresentation>} face_to_patch_map
- * @returns {number}
- */
-export function computeFaceCurvatureScore(addition, patch, face_to_patch_map) {
-    const candidate_edges = addition.edges;
-    const candidate_edge_count = candidate_edges.length;
-
-
-    let neighbour_normal_accumulator_x = 0;
-    let neighbour_normal_accumulator_y = 0;
-    let neighbour_normal_accumulator_z = 0;
-
-    for (let i = 0; i < candidate_edge_count; i++) {
-        const edge = candidate_edges[i];
-
-        const neighbour_faces = edge.faces;
-        const neighbour_face_count = neighbour_faces.length;
-
-        for (let j = 0; j < neighbour_face_count; j++) {
-            const neighbour_face = neighbour_faces[j];
-
-            if (neighbour_face === addition) {
-                // skip self
-                continue;
-            }
-
-            const neighbour_face_index = neighbour_face.index;
-            const patch_assignment = face_to_patch_map.get(neighbour_face_index);
-
-            if (patch_assignment === patch) {
-                // neighbour is assigned to our patch
-
-                const normal = neighbour_face.normal;
-
-                neighbour_normal_accumulator_x += normal[0];
-                neighbour_normal_accumulator_y += normal[1];
-                neighbour_normal_accumulator_z += normal[2];
-
-                break;
-            }
-        }
-    }
-    const source_normal = addition.normal;
-
-    const curvature = v3_dot(
-        source_normal[0], source_normal[1], source_normal[2],
-        neighbour_normal_accumulator_x, neighbour_normal_accumulator_y, neighbour_normal_accumulator_z
-    );
-
-    return curvature;
-}

package/src/engine/graphics/micron/build/clustering/computeOpenFaceFreedom.js

@@ -1,35 +0,0 @@
-/**
- *
- * @param {TopoTriangle} topoFace
- * @param {BitSet} open_set
- * @param {TopoMesh} mesh
- * @returns {number} number of neighbours still in the open set
- */
-export function computeOpenFaceFreedom(topoFace, open_set, mesh) {
-    const edges = topoFace.edges;
-    const edge_count = edges.length;
-
-    let result = 0;
-
-    for (let i = 0; i < edge_count; i++) {
-        const topoEdge = edges[i];
-
-        const neighbours = topoEdge.faces;
-        const neighbour_count = neighbours.length;
-
-        for (let j = 0; j < neighbour_count; j++) {
-            const other_face = neighbours[j];
-
-            if (other_face === topoFace) {
-                // skip self
-                continue;
-            }
-
-            if (open_set.get(other_face.index)) {
-                result++;
-            }
-        }
-    }
-
-    return result;
-}

package/src/engine/graphics/micron/build/clustering/compute_face_connection_weight.js

@@ -1,35 +0,0 @@
-import { vec3 } from "gl-matrix";
-import { v3_distance_sqr } from "../../../../../core/geom/v3_distance_sqr.js";
-
-/**
- *
- * @param {TopoTriangle} f0
- * @param {TopoTriangle} f1
- * @returns {number}
- */
-export function compute_face_connection_weight(f0, f1) {
-    const vertices_0 = f0.vertices;
-    const vertices_1 = f1.vertices;
-
-    // compute center
-    const f0_center_x = (vertices_0[0].x + vertices_0[1].x + vertices_0[2].x) * 0.333;
-    const f0_center_y = (vertices_0[0].y + vertices_0[1].y + vertices_0[2].y) * 0.333;
-    const f0_center_z = (vertices_0[0].z + vertices_0[1].z + vertices_0[2].z) * 0.333;
-
-    const f1_center_x = (vertices_1[0].x + vertices_1[1].x + vertices_1[2].x) * 0.333;
-    const f1_center_y = (vertices_1[0].y + vertices_1[1].y + vertices_1[2].y) * 0.333;
-    const f1_center_z = (vertices_1[0].z + vertices_1[1].z + vertices_1[2].z) * 0.333;
-
-    const distance_sqr = v3_distance_sqr(
-        f0_center_x, f0_center_y, f0_center_z,
-        f1_center_x, f1_center_y, f1_center_z
-    );
-
-    // compute normal dot
-    const dot = vec3.dot(
-        f0.normal,
-        f1.normal
-    );
-
-    return 2 + (1 / distance_sqr) * 0.01 + dot * 0.1;
-}

package/src/engine/graphics/micron/build/clustering/populateOpenFaceNeighboursForPatch.js

@@ -1,56 +0,0 @@
-/**
- *
- * @param {BitSet} open_set
- * @param {BinaryHeap<number>} result
- * @param {Map<number,number>} distances
- * @param {TopoTriangle} face
- * @param {number} face_distance
- * @param {Map<number, number>} came_from_map
- */
-export function populateOpenFaceNeighboursForPatch(
-    open_set,
-    result,
-    distances,
-    face,
-    face_distance,
-    came_from_map) {
-
-    const edges = face.edges;
-    const edge_count = edges.length;
-
-    for (let i = 0; i < edge_count; i++) {
-        const edge = edges[i];
-
-        const edge_faces = edge.faces;
-        const edge_face_count = edge_faces.length;
-
-        for (let j = 0; j < edge_face_count; j++) {
-            const neighbour = edge_faces[j];
-
-            if (neighbour === face) {
-                // self
-                continue;
-            }
-
-            const index = neighbour.index;
-
-            if (open_set.get(index) === false) {
-                // not in the open set
-                continue;
-            }
-
-            if (result.contains(index)) {
-                // already in the set
-                continue;
-            }
-
-            distances.set(index, face_distance + 1);
-            came_from_map.set(index, face.index)
-
-            result.push(index);
-
-
-        }
-
-    }
-}

package/src/engine/graphics/micron/build/clustering/validate_leaf_patch_connectivity.js

@@ -1,44 +0,0 @@
-import { noop } from "../../../../../core/function/Functions.js";
-
-/**
- *
- * @param {PatchRepresentation[]} leaves
- * @param {function(string)} error_consumer
- */
-export function validate_leaf_patch_connectivity(leaves, error_consumer = noop) {
-    let result = true;
-    /**
-     *
-     * @type {Map<number, PatchRepresentation[]>}
-     */
-    const vertex_map = new Map();
-
-    for (let i = 0; i < leaves.length; i++) {
-        const leaf = leaves[i];
-
-        for (const vertex of leaf.vertices_included) {
-            const existing_patches = vertex_map.get(vertex);
-
-            if (existing_patches === undefined) {
-                vertex_map.set(vertex, [leaf]);
-            } else {
-                // shared vertex
-
-                // check neighbours
-                const existing_patch_count = existing_patches.length;
-                for (let j = 0; j < existing_patch_count; j++) {
-                    const neighbour = existing_patches[j];
-
-                    if (!leaf.hasNeighbour(neighbour)) {
-                        error_consumer(`No link between neighbours ${leaf.id} and ${neighbour.id} for vertex ${vertex}`);
-                        result = false;
-                    }
-                }
-
-                existing_patches.push(leaf);
-            }
-        }
-    }
-
-    return result;
-}