@woosh/meep-engine 2.48.20 → 2.48.21

package/src/engine/graphics/micron/build/hierarchy/merge_patches.js

@@ -1,581 +0,0 @@
-//
-
-import { TopoMesh } from "../../../../../core/geom/3d/topology/struct/TopoMesh.js";
-import { MICRON_PATCH_SIZE_MAX } from "../MICRON_PATCH_SIZE_MAX.js";
-import { compute_set_of_shared_vertices } from "./build_intermediate_patch_topology.js";
-import { max2 } from "../../../../../core/math/max2.js";
-import {
-    collapse_all_degenerate_edges
-} from "../../../../../core/geom/3d/topology/simplify/collapse_all_degenerate_edges.js";
-import {
-    deep_copy_vertex_quadratics
-} from "../../../../../core/geom/3d/topology/simplify/quadratic/build_vertex_quadratics.js";
-import { SquareMatrix } from "../../../../../core/graph/SquareMatrix.js";
-import { BinaryDataType } from "../../../../../core/binary/type/BinaryDataType.js";
-import { matrix_eigenvalues_in_place } from "../../../../../core/graph/eigen/eigen.js";
-import { min2 } from "../../../../../core/math/min2.js";
-import { PatchRepresentation } from "../PatchRepresentation.js";
-import {
-    build_face_graph_from_mesh,
-    graph_create_off_mesh_links
-} from "../../../../../core/graph/build_face_graph_from_mesh.js";
-import { optimize_graph_partitioning_balance_detailed } from "./optimize_graph_partitioning_balance.js";
-import { patch_build_parent } from "./patch_combine.js";
-import { array_copy } from "../../../../../core/collection/array/copyArray.js";
-import { ceilPowerOfTwo } from "../../../../../core/binary/operations/ceilPowerOfTwo.js";
-import { isPowerOfTwo } from "../../../../../core/math/isPowerOrTwo.js";
-import {
-    computeTopoMeshBoundiningBox
-} from "../../../../../core/geom/3d/topology/bounds/computeTopoMeshBoundiningBox.js";
-import { AABB3 } from "../../../../../core/bvh2/aabb3/AABB3.js";
-import {
-    computeTopoMeshBoundingSphere
-} from "../../../../../core/geom/3d/topology/bounds/computeTopoMeshBoundingSphere.js";
-import { Uint32Heap } from "../../../../../core/collection/heap/Uint32Heap.js";
-import {
-    edge_collapse_populate_heap,
-    edge_collapse_reduce_face_count
-} from "../../../../../core/geom/3d/topology/simplify/simplifyTopoMesh2.js";
-import { cluster_mesh_metis } from "../../../../../core/graph/cluster_mesh_metis.js";
-
-/**
- *
- * @param {SquareMatrix} result
- * @param {Iterable<TopoTriangle>} faces
- * @param {Map<TopoTriangle,number>} face_index_map
- */
-function build_face_degree_matrix(result, faces, face_index_map) {
-    for (const face of faces) {
-        const face_index = face_index_map.get(face);
-
-        const edges = face.edges;
-
-        const edge_count = edges.length;
-
-        let degree = 0;
-
-        for (let i = 0; i < edge_count; i++) {
-            const edge = edges[i];
-
-            degree += edge.faces.length - 1;
-        }
-
-        result.setCellValue(face_index, face_index, degree);
-    }
-}
-
-/**
- *
- * @param {SquareMatrix} result
- * @param {TopoMesh} mesh
- * @param {Map<TopoTriangle,number>} face_index_map
- */
-function build_face_adjacency_matrix(result, mesh, face_index_map) {
-    const edges = mesh.getEdges();
-
-    for (const edge of edges) {
-        const faces = edge.faces;
-
-        const n = faces.length;
-
-        for (let i = 0; i < n; i++) {
-            const f0 = faces[i];
-
-            const f0_index = face_index_map.get(f0);
-
-            for (let j = i + 1; j < n; j++) {
-                const f1 = faces[j];
-
-                const f1_index = face_index_map.get(f1);
-
-                result.setCellValue(f0_index, f1_index, 1);
-                result.setCellValue(f1_index, f0_index, 1);
-            }
-        }
-    }
-}
-
-/**
- *
- * @param {TopoMesh} mesh
- * @returns {Map<TopoTriangle, number>}
- */
-function build_face_index_map(mesh) {
-    let face_index = 0;
-    const face_set = mesh.getFaces();
-
-    const face_index_map = new Map();
-
-    for (const face of face_set) {
-        face_index_map.set(face, face_index++);
-    }
-
-    return face_index_map;
-
-}
-
-/**
- *
- * @param {TopoMesh} mesh
- * @param {number} k number of clusters to make
- * @returns {TopoTriangle[][]}
- */
-function cluster_mesh(mesh, k,) {
-
-    const face_index_map = new Map();
-    const face_set = mesh.getFaces();
-    const face_array = Array.from(face_set);
-
-    for (let i = 0; i < face_array.length; i++) {
-        const face = face_array[i];
-        face_index_map.set(face, i);
-    }
-
-    // build laplacian of the face graph
-
-    const face_count = face_set.size;
-
-    // build laplacian matrix
-    const m_adjacency = new SquareMatrix(face_count, BinaryDataType.Uint8);
-    const m_degree = new SquareMatrix(face_count, BinaryDataType.Uint8);
-
-    build_face_adjacency_matrix(m_adjacency, mesh, face_index_map);
-    build_face_degree_matrix(m_degree, face_set, face_index_map);
-
-    const mat_laplace = new SquareMatrix(face_count, BinaryDataType.Float64);
-
-    mat_laplace.subtractMatrices(m_degree, m_adjacency);
-
-    // compute eigen values
-    const eigen_values = matrix_eigenvalues_in_place(mat_laplace);
-
-    const mapped_eigen_values = Array.from(eigen_values).map((v, i) => {
-        return {
-            v, i
-        };
-    });
-
-    mapped_eigen_values.sort((a, b) => a.v - b.v);
-
-
-    // eigenvalues are a projection of closeness of nodes
-    const result = [];
-
-    let face_cursor = 0;
-    const step_size = Math.ceil(face_count / k);
-    for (let i = 0; i < k; i++) {
-        const end_index = min2(face_count, face_cursor + step_size);
-
-        const cluster = [];
-
-        for (let j = face_cursor; j < end_index; j++) {
-            const face_index = mapped_eigen_values[j].i;
-
-            const face = face_array[face_index];
-
-            cluster.push(face);
-        }
-
-        face_cursor = end_index;
-
-        result.push(cluster);
-    }
-
-    return result;
-}
-
-/**
- * @template N
- * @param {Graph<N>} graph
- * @returns {Map<N, number>}
- */
-function build_graph_node_index_map(graph) {
-    const r = new Map();
-
-
-    const nodes = graph.getNodes();
-
-    let i = 0;
-    for (const node of nodes) {
-        r.set(node, i);
-
-        i++;
-    }
-
-    return r;
-}
-
-/**
- *
- * @param {TopoMesh} mesh
- * @param {number} k
- * @param {number} per_cluster_triangle_limit
- * @returns {TopoMesh[]}
- */
-async function recursive_split_mesh_partition(mesh, k, per_cluster_triangle_limit) {
-    if (!isPowerOfTwo(k)) {
-        throw new Error(`k must be power of two, instead was '${k}'`);
-    }
-
-    const levels = Math.log2(k);
-
-    let meshes = [mesh];
-
-    for (let i = 0; i < levels; i++) {
-        const merge_target = per_cluster_triangle_limit * Math.pow(2, levels - i)
-        const output_meshes = [];
-        for (let j = 0; j < meshes.length; j++) {
-            const topoMesh = meshes[j];
-
-            const split = await partition_mesh(topoMesh, 2, merge_target);
-
-            Array.prototype.push.apply(output_meshes, split);
-        }
-
-        meshes = output_meshes;
-    }
-
-    return meshes;
-}
-
-/**
- *
- * @param {TopoMesh} mesh
- * @param {number} k
- * @param {number} per_cluster_triangle_limit
- * @returns {TopoMesh[]}
- */
-async function partition_mesh_advanced(mesh, k, per_cluster_triangle_limit) {
-    const metis_result = await partition_mesh_metis(mesh, k, per_cluster_triangle_limit);
-
-    if (metis_result !== undefined) {
-        return metis_result;
-    }
-
-    // fallback
-    return recursive_split_mesh_partition(mesh, k, per_cluster_triangle_limit);
-}
-
-/**
- *
- * @param {TopoMesh} mesh
- * @param {number} k
- * @param {number} per_cluster_triangle_limit
- * @returns {TopoMesh[]|undefined} Either returns the desired partitioning, or undefined in case of failure
- */
-async function partition_mesh_metis(mesh, k, per_cluster_triangle_limit) {
-
-    const input_face_count = mesh.getFaces().size;
-    const face_array = Array.from(mesh.getFaces());
-
-    const partitioning = new Uint32Array(input_face_count);
-
-    const cluster_count = await cluster_mesh_metis(partitioning, mesh, per_cluster_triangle_limit);
-
-    if (cluster_count !== k) {
-        return undefined;
-    }
-
-
-    const result = [];
-    const vertexMaps = [];
-
-    for (let i = 0; i < cluster_count; i++) {
-        result[i] = new TopoMesh();
-        vertexMaps[i] = new Map();
-    }
-
-    for (let i = 0; i < input_face_count; i++) {
-
-        const triangle = face_array[i];
-
-        const partition_index = partitioning[i];
-
-        const patition_mesh = result[partition_index];
-        const vertexMap = vertexMaps[partition_index];
-
-        patition_mesh.addFaceCopy(triangle, vertexMap)
-
-    }
-
-    return result;
-}
-
-/**
- *
- * @param {TopoMesh} mesh
- * @param {number} k
- * @param {number} per_cluster_triangle_limit
- * @returns {TopoMesh[]}
- */
-function partition_mesh(mesh, k, per_cluster_triangle_limit) {
-    if (k === 1) {
-        // special case, no partitioning required
-        return [mesh];
-    }
-
-    const graph = build_face_graph_from_mesh(mesh);
-
-    graph_create_off_mesh_links(graph);
-
-    const node_array = Array.from(graph.getNodes());
-    const clusters = optimize_graph_partitioning_balance_detailed(node_array, k, graph);
-
-    /**
-     *
-     * @type {TopoMesh[]}
-     */
-    const result = [];
-
-    for (let i = 0; i < k; i++) {
-        const cluster = clusters[i];
-
-        const cluster_size = cluster.length;
-
-        const mesh = new TopoMesh();
-
-        const vertexMap = new Map();
-
-        for (let j = 0; j < cluster_size; j++) {
-            const node_index = cluster[j];
-
-            const node = node_array[node_index];
-
-            const triangle = node.source_nodes[0];
-
-
-            mesh.addFaceCopy(triangle, vertexMap)
-        }
-
-        result[i] = mesh;
-    }
-
-    return result;
-}
-
-function partition_mesh_spectral(merged_mesh, up_count, nodes, output, output_offset) {
-    const face_clusters = cluster_mesh(merged_mesh, up_count);
-
-    const cluster_count = face_clusters.length;
-
-    for (let i = 0; i < cluster_count; i++) {
-        const rep = new PatchRepresentation();
-
-        const cluster = face_clusters[i];
-
-        const cluster_mesh = new TopoMesh();
-
-        for (let j = 0; j < cluster.length; j++) {
-            const face = cluster[j];
-
-            cluster_mesh.injectFace(face);
-        }
-
-        rep.topology_snapshot = cluster_mesh;
-
-        Array.prototype.push.apply(rep.children, nodes);
-
-        output[output_offset + i] = rep;
-    }
-
-    return cluster_count;
-}
-
-/**
- *
- * @param {PatchRepresentation[]} output
- * @param {{value:number}} output_offset
- * @param {PatchRepresentation[]} nodes
- * @param {number} up_count
- * @param {Map<number, Quadratic3>} quadratics accumulated quadratic errors for each vertex
- * @returns {number} number of patches added to output
- */
-async function many_to_many_merge(
-    output,
-    output_offset,
-    nodes,
-    up_count,
-    quadratics
-) {
-
-
-    // create a topology from source nodes
-    const merged_mesh = new TopoMesh();
-
-    /**
-     *
-     * @type {Map<number, TopoVertex>}
-     */
-    const vertex_map = new Map();
-
-    const input_node_count = nodes.length;
-
-    for (let i = 0; i < input_node_count; i++) {
-        const child = nodes[i];
-        merged_mesh._addWithVertexMap(child.topology_snapshot, vertex_map);
-    }
-
-    /**
-     *
-     * @type {Set<number>}
-     */
-    const restricted_vertices = new Set();
-
-    compute_set_of_shared_vertices(restricted_vertices, merged_mesh, nodes);
-
-    const target_face_count = up_count * MICRON_PATCH_SIZE_MAX;
-
-
-    const source_mesh_face_count = merged_mesh.getFaces().size;
-
-    const num_desired_faces_to_remove = max2(0, source_mesh_face_count - target_face_count);
-
-    /**
-     *
-     * @type {Map<number, Quadratic3>}
-     */
-    const vertex_quadratics = new Map();
-
-    /*
-     make a copy of relevant quadratics, simplification might be rejected if objectives are not met (face count too high)
-     So to keep simplification speculative, we make a copy of quadratics and apply any changes once the simplification is validated
-     */
-    deep_copy_vertex_quadratics(vertex_quadratics, quadratics, merged_mesh);
-
-    let actual_up_count = up_count;
-
-    // simplify topology
-    if (num_desired_faces_to_remove > 0) {
-
-        const heap = new Uint32Heap(merged_mesh.getEdges().size);
-        const edge_lookup = new Map();
-
-        // debugValidateMesh(merged_mesh);
-
-        edge_collapse_populate_heap(merged_mesh.getEdges(), restricted_vertices, heap, vertex_quadratics, edge_lookup);
-        edge_collapse_reduce_face_count(merged_mesh, num_desired_faces_to_remove, heap, edge_lookup, restricted_vertices, vertex_quadratics);
-
-        // debugValidateMesh(merged_mesh);
-
-        collapse_all_degenerate_edges(merged_mesh.getEdges(), merged_mesh);
-
-        // debugValidateMesh(merged_mesh);
-
-        const merged_mesh_face_count = merged_mesh.getFaces().size;
-
-
-        if (merged_mesh_face_count > target_face_count) {
-            // simplification failed, reject
-            const t = output_offset.value;
-            output_offset.value += input_node_count;
-            array_copy(nodes, 0, output, t, input_node_count);
-            return input_node_count;
-        }
-    }
-
-    // update source quadratics
-    const merged_mesh_vertices = merged_mesh.vertices;
-    const merged_mesh_vertex_count = merged_mesh_vertices.length;
-
-    let largest_squared_error = 0;
-
-    for (let i = 0; i < merged_mesh_vertex_count; i++) {
-        const vertex = merged_mesh_vertices[i];
-
-        const vertex_index = vertex.index;
-
-        const vertex_quadratic = vertex_quadratics.get(vertex_index);
-        //
-        const vertex_error_sqr = vertex_quadratic.evaluate(vertex.x, vertex.y, vertex.z);
-
-        if (vertex_error_sqr > largest_squared_error) {
-            largest_squared_error = vertex_error_sqr;
-        }
-
-        // copy back to the source
-        quadratics.set(vertex_index, vertex_quadratic);
-    }
-
-    const group_aabb = new AABB3();
-    computeTopoMeshBoundiningBox(group_aabb, merged_mesh);
-
-    const group_bounding_sphere = new Float32Array(4);
-    computeTopoMeshBoundingSphere(group_bounding_sphere, merged_mesh);
-
-    const group_inverse_polycount = 1 / merged_mesh.getFaces().size;
-
-    const group_bounding_sphere_radius = group_bounding_sphere[3];
-    const group_bounding_sphere_section_area = group_bounding_sphere_radius * group_bounding_sphere_radius;
-
-    const area_based_qem_error = largest_squared_error / group_bounding_sphere_section_area;
-
-    // const group_per_pixel_error = min2(
-    //     group_inverse_polycount,
-    //     area_based_qem_error
-    // );
-
-    const group_per_pixel_error = group_inverse_polycount;
-    // const group_per_pixel_error = Math.sqrt(largest_squared_error);
-
-    // split topology into desired number of pieces
-    const pieces = await partition_mesh_advanced(merged_mesh, actual_up_count, MICRON_PATCH_SIZE_MAX);
-
-    for (let i = 0; i < actual_up_count; i++) {
-        const rep = patch_build_parent(nodes);
-
-        const piece_mesh = pieces[i];
-
-        rep.topology_snapshot = piece_mesh;
-
-        rep.group_aabb.copy(group_aabb);
-        rep.group_bounding_sphere.set(group_bounding_sphere);
-
-        rep.computeBounds();
-
-        rep.group_error = group_per_pixel_error;
-
-        //
-        // if (piece_mesh.getFaces().size > MICRON_PATCH_SIZE_MAX) {
-        //     debugger;
-        // }
-
-        output[output_offset.value++] = rep;
-    }
-
-    return actual_up_count;
-}
-
-/**
- *
- * @param {PatchRepresentation[]} output
- * @param {{value:number}} output_offset
- * @param {PatchRepresentation[]} nodes
- * @param {Map<number, Quadratic3>} quadratics Vertex quadratic error set
- * @returns {number} number of patches added to output
- */
-export async function merge_patches(
-    output,
-    output_offset,
-    nodes,
-    quadratics
-) {
-    const node_count = nodes.length;
-
-    if (node_count === 0) {
-        // empty input
-        return 0;
-    } else if (node_count === 1) {
-        // only 1 patch, no merge opportunity, forward it to output directly
-        const node = nodes[0];
-
-        output[output_offset.value++] = node;
-        return 1;
-    } else {
-
-        const target_node_count = max2(1, Math.ceil(nodes.length / 2));
-
-        const clipped_node_count = ceilPowerOfTwo(target_node_count);
-
-        return await many_to_many_merge(output, output_offset, nodes, clipped_node_count, quadratics);
-    }
-}

package/src/engine/graphics/micron/build/hierarchy/metis_cluster_clusters.js

@@ -1,53 +0,0 @@
-//
-
-import { metis_cluster_bs } from "../../../../../core/graph/cluster_mesh_metis.js";
-
-/**
- *
- * @param {Uint32Array|Uint16Array|Uint8Array|number[]} result
- * @param {PatchRepresentation[]} clusters
- * @param {number} cluster_size
- */
-export async function metis_cluster_clusters(result, clusters, cluster_size) {
-
-    const node_count = clusters.length;
-
-    const edge_addresses = new Uint32Array(node_count + 1);
-    const adjacency = [];
-    const edge_weights = [];
-
-    // build node-to-index map
-    const node_index_map = new Map();
-    for (let i = 0; i < node_count; i++) {
-        const node = clusters[i];
-        node_index_map.set(node, i);
-    }
-
-    let offset = 0;
-    edge_addresses[0] = 0;
-
-    for (let i = 0; i < node_count; i++) {
-        const cluster = clusters[i];
-
-        const neighbours = cluster.neighbours;
-
-        const neighbour_count = neighbours.length;
-
-        for (let j = 0; j < neighbour_count; j++) {
-            const neighbour = neighbours[j];
-
-            adjacency[offset] = node_index_map.get(neighbour);
-            edge_weights[offset] = 1;
-
-            offset++;
-        }
-
-        edge_addresses[i + 1] = offset;
-    }
-
-    const adjecency_uint32 = new Uint32Array(adjacency);
-    const edge_weights_uint32 = new Uint32Array(edge_weights);
-
-    return await metis_cluster_bs(result, node_count, edge_addresses, adjecency_uint32, edge_weights_uint32, cluster_size);
-
-}