@woosh/meep-engine 2.48.20 → 2.48.22

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

@@ -1,547 +0,0 @@
-import { array_push_if_unique } from "../../../../../core/collection/array/array_push_if_unique.js";
-import FastBinaryHeap from "../../../../../core/collection/heap/FastBinaryHeap.js";
-import {
-    build_vertex_quadratics
-} from "../../../../../core/geom/3d/topology/simplify/quadratic/build_vertex_quadratics.js";
-import { compute_set_of_border_vertex_indices } from "./build_intermediate_patch_topology.js";
-import { compute_patches_shared_vertices } from "./compute_patches_shared_vertices.js";
-import { max2 } from "../../../../../core/math/max2.js";
-import { MICRON_PATCH_SIZE_MAX } from "../MICRON_PATCH_SIZE_MAX.js";
-import { collapse_edges, extract_edge_cost } from "../../../../../core/geom/3d/topology/simplify/simplifyTopoMesh.js";
-import {
-    build_edge_collapse_candidates
-} from "../../../../../core/geom/3d/topology/simplify/build_edge_collapse_candidates.js";
-import {
-    collapse_all_degenerate_edges
-} from "../../../../../core/geom/3d/topology/simplify/collapse_all_degenerate_edges.js";
-import { compute_set_intersection } from "../../../../../core/collection/set/compute_set_intersection.js";
-
-/**
- * Cluster must share at least this many vertices for the vertex boundary constraint to be relaxed and allow them to be made dependent on each other
- * @type {number}
- */
-const BOUNDARY_RELAXATION_SHARED_VERTEX_THRESHOLD = 5;
-
-/**
- * Common ancestor between patches can be found in a given depth (up-traversal)
- * @param {PatchRepresentation} a
- * @param {PatchRepresentation} b
- * @param {number} depth
- */
-function patches_share_ancestor_within_depth(a, b, depth) {
-    let n0 = a.parent;
-    let n1;
-
-    let d0 = 1;
-    let d1 = 1;
-
-    while (n0 !== null) {
-
-        n1 = b.parent;
-
-        while (n1 !== null) {
-
-
-            if (n0 === n1) {
-                return true;
-            }
-
-            n1 = n1.parent;
-
-            d1++
-
-            if (d1 >= depth) {
-                break;
-            }
-        }
-
-        n0 = n0.parent;
-
-        d0++;
-
-        if (d0 >= depth) {
-            break;
-        }
-    }
-
-    // no common ancestor
-    return false;
-}
-
-/**
- * normalized difference in screen-space error between two patches
- * @param {PatchRepresentation} a
- * @param {PatchRepresentation} b
- * @returns {number}
- */
-function compute_patch_screen_error_difference(a, b) {
-
-    const a_radius = a.bounding_sphere[3];
-    const b_radius = b.bounding_sphere[3];
-
-    const abs_delta = Math.abs(a_radius - b_radius);
-
-    return abs_delta / max2(a_radius, b_radius);
-}
-
-/**
- * A dependency between A and B will not introduce a chain (unless all the clusters in the chain share vertices)
- * @param {PatchRepresentation} a
- * @param {PatchRepresentation} b
- * @returns {boolean}
- */
-function creates_dependency_chain(a, b) {
-    const a_dependencies = a.dependencies;
-    const a_dependencies_count = a_dependencies.length;
-    if (a_dependencies_count === 0 && b.dependencies.length === 0) {
-        return false;
-    }
-
-    // get all dependencies
-    const open = [a, b];
-
-    /**
-     *
-     * @type {Set<number>}
-     */
-    let shared_neighbours = compute_patches_shared_vertices(a, b);
-
-    const dependencies_in_chain = new Set();
-
-    while (open.length > 0) {
-        const link = open.pop();
-
-        dependencies_in_chain.add(link);
-
-        const link_dependencies = link.dependencies;
-
-        const link_dependency_count = link_dependencies.length;
-        for (let i = 0; i < link_dependency_count; i++) {
-            const dep = link_dependencies[i];
-
-            if (dependencies_in_chain.has(dep)) {
-                // already processed
-                continue;
-            }
-
-            if (open.indexOf(dep) !== -1) {
-                // already in the queue
-                continue;
-            }
-
-            // check dependency vertices
-            shared_neighbours = compute_set_intersection(shared_neighbours, dep.vertices_shared);
-
-            if (shared_neighbours.size === 0) {
-                // creates a chain, not all dependencies share vertices
-                return true;
-            }
-
-            open.push(dep);
-        }
-    }
-
-    return false;
-
-}
-
-/**
- * @param {TopoMesh} t
- */
-function cleanup_disconnected_faces(t) {
-
-    const faces = t.getFaces();
-
-    for (let face of faces) {
-
-        if (face.edges.length < 3) {
-            // cut
-            faces.delete(face);
-        }
-    }
-}
-
-/**
- *
- * @param {PatchRepresentation} patch
- */
-function build_patch_topology_mask_from_children(patch) {
-    const t = patch.topology_mask;
-
-    const child_a = patch.children[0];
-    const mask_a = child_a.topology_mask;
-    t.injectManyFaces(mask_a.getFaces());
-
-    const child_b = patch.children[1];
-    const mask_b = child_b.topology_mask;
-    t.injectManyFaces(mask_b.getFaces());
-
-
-    // cleanup disconnected faces
-    cleanup_disconnected_faces(t);
-}
-
-/**
- *
- * @param {PatchRepresentation} root
- * @param {Map<number,PatchRepresentation[]>} result
- */
-function map_hierarchy_vertices(root, result) {
-    const leaves = root.collectNodes(p => p.lod === 0);
-
-    for (let i = 0; i < leaves.length; i++) {
-        const leaf = leaves[i];
-
-        const vertices = leaf.topology_mask.vertices;
-
-        for (let j = 0; j < vertices.length; j++) {
-            const vertex = vertices[j];
-
-            const vertex_index = vertex.index;
-
-            let participants = result.get(vertex_index);
-
-            if (participants === undefined) {
-                participants = [];
-                result.set(vertex_index, participants);
-            }
-
-            let p = leaf;
-
-            while (p !== null) {
-                array_push_if_unique(participants, p);
-
-                p.vertices_included.add(vertex_index);
-
-                p = p.parent;
-            }
-
-        }
-    }
-}
-
-/**
- *
- * @param {PatchRepresentation} patch
- * @param {Map<number, PatchRepresentation[]>} vertex_patch_map
- */
-function compute_border_vertices(patch, vertex_patch_map) {
-
-    main:for (const v of patch.vertices_included) {
-
-        const containing_patches = vertex_patch_map.get(v);
-
-
-        for (const c of containing_patches) {
-            if (c.lod > patch.lod) {
-                continue;
-            }
-
-            if (!c.isDescendantOf(patch)) {
-                // interior
-                continue main;
-            }
-        }
-
-        //
-        patch.vertices_shared.add(v);
-    }
-}
-
-/**
- *
- * @param {PatchRepresentation} root
- * @param {TopoMesh} mesh
- */
-export function build_simplified_clusters(root, mesh) {
-    /**
-     *
-     * @type {PatchRepresentation[]}
-     */
-    const intermediate_nodes = [];
-
-    /**
-     *
-     * @type {PatchRepresentation[][]}
-     */
-    const lod_buckets = [];
-
-    /**
-     *
-     * @type {Map<number, PatchRepresentation[]>}
-     */
-    const vertex_patch_map = new Map();
-
-    map_hierarchy_vertices(root, vertex_patch_map);
-
-    root.traverse(n => {
-        const lod = n.lod;
-        if (lod > 0) {
-            intermediate_nodes.push(n);
-
-            compute_border_vertices(n, vertex_patch_map);
-        }
-
-        const bucket = lod_buckets[lod];
-
-        if (bucket !== undefined) {
-            bucket.push(n);
-        } else {
-            lod_buckets[lod] = [n];
-        }
-
-    });
-
-
-    /**
-     *
-     * @param {PatchRepresentation} patch
-     * @returns {number} lower = better fitness
-     */
-    function score_by_border(patch) {
-        let total_vertex_count = 0;
-        const shared_vertices = new Set();
-
-        for (let i = 0; i < patch.children.length; i++) {
-            const child = patch.children[i];
-
-            child.vertices_shared.forEach(s => {
-                if (shared_vertices.has(s)) {
-                    shared_vertices.delete(s);
-                } else {
-                    shared_vertices.add(s);
-                }
-            });
-
-            total_vertex_count += child.topology_mask.vertices.length;
-        }
-
-        // compute proportion of inner to outer vertices in the combined patch
-        const shared_vertex_count = shared_vertices.size;
-        const interior_vertices = total_vertex_count - shared_vertex_count;
-
-        return -shared_vertex_count / (interior_vertices + 0.01);
-    }
-
-    /**
-     *
-     * @type {BinaryHeap<PatchRepresentation>}
-     */
-    const heap = new FastBinaryHeap(score_by_border);
-
-    // TODO perform simplification directly on the source mesh
-
-
-    // keep global quadratics set
-
-    /**
-     *
-     * @type {Map<number, Quadratic3>}
-     */
-    const vertex_quadratics = new Map();
-
-    build_vertex_quadratics({ mesh: mesh, quadratics: vertex_quadratics });
-
-    let total_relaxed_vertex_count = 0;
-    let rejection_count_shared_vertices = 0;
-    let rejection_count_depth = 0;
-    let rejection_count_error = 0;
-    let rejection_count_chain = 0;
-
-    // build simplified meshes for each level of LOD
-    for (let i = 1; i < lod_buckets.length; i++) {
-        const lod_bucket = lod_buckets[i];
-
-        const bucket_size = lod_bucket.length;
-
-        // push children's topology
-        for (let j = 0; j < bucket_size; j++) {
-            const patch = lod_bucket[j];
-
-
-            // build face mask
-            build_patch_topology_mask_from_children(patch);
-        }
-
-
-        // push all patches to the queue
-        for (let j = 0; j < bucket_size; j++) {
-            const patch = lod_bucket[j];
-
-            heap.push(patch);
-        }
-
-        while (!heap.isEmpty()) {
-            /**
-             *
-             * @type {PatchRepresentation}
-             */
-            const patch = heap.pop();
-
-
-            /**
-             *
-             * @type {Set<number>}
-             */
-            const restricted_vertices = new Set();
-
-            compute_set_of_border_vertex_indices(restricted_vertices, patch.topology_mask);
-
-            const initial_restricted_vertex_count = restricted_vertices.size;
-
-            /*
-             consider relaxing boundary constraints for this patch
-             Relaxing constraints forces both patches to be refined together to assure crack-free boundaries,
-             which degrades runtime performance but allows for better mesh simplification
-             */
-            const neighbours = patch.neighbours;
-            const neighbour_count = neighbours.length;
-            const patch_dependencies = patch.dependencies;
-            for (let j = 0; j < neighbour_count; j++) {
-                // continue;
-                const neighbour = neighbours[j];
-
-                if (!heap.contains(neighbour)) {
-                    // neighbour is not at the same level in the hierarchy
-                    continue;
-                }
-
-                if (patch.dependencies.indexOf(neighbour) !== -1) {
-                    // already dependent
-                    continue;
-                }
-
-
-                if (compute_patch_screen_error_difference(patch, neighbour) > 0.2) {
-                    /*
-                    A and B have similar error-range
-                    condition discourages dependencies between those clusters that are
-                    unlikely to be simultaneously present in the ACL at runtime
-                     */
-                    rejection_count_error++;
-                    continue;
-                }
-
-                if (patches_share_ancestor_within_depth(patch, neighbour, 2)) {
-                    /*
-                     A and B will not be merged within a small number of levels up the cluster hierarchy.
-                     This condition avoids creating dependencies between clusters that are resolved within only a few additional hierarchy levels.
-                     */
-                    rejection_count_depth++;
-                    continue;
-                }
-
-
-                const shared_vertices = compute_patches_shared_vertices(patch, neighbour);
-                const shared_vertex_count = shared_vertices.size;
-
-                if (shared_vertex_count < BOUNDARY_RELAXATION_SHARED_VERTEX_THRESHOLD) {
-                    // too few vertices are shared, relaxing boundary constraint is not worth while
-                    rejection_count_shared_vertices++;
-                    continue;
-                }
-                if (creates_dependency_chain(patch, neighbour)) {
-                    // condition prevents long dependency chains and preserves selective refinement at the cluster level
-                    rejection_count_chain++;
-                    continue;
-                }
-
-                // register dependency
-                array_push_if_unique(patch_dependencies, neighbour);
-                array_push_if_unique(neighbour.dependencies, patch);
-
-            }
-
-            const dependency_count = patch_dependencies.length;
-
-            if (dependency_count > 0) {
-                // relax vertex constraints
-                const vs = [];
-                vertex_loop:for (const v of restricted_vertices) {
-                    const participating_patches = vertex_patch_map.get(v);
-
-                    for (let k = 0; k < dependency_count; k++) {
-                        const dependency = patch_dependencies[k];
-
-                        if (participating_patches.indexOf(dependency) === -1) {
-                            continue vertex_loop;
-                        }
-                    }
-
-
-                    // vertex is fully dependent, can relax
-                    restricted_vertices.delete(v);
-                    vs.push(v);
-                }
-
-                for (let j = 0; j < vs.length; j++) {
-                    const v = vs[j];
-
-                    restricted_vertices.delete(v);
-                }
-
-            }
-
-            const relaxed_restricted_vertices_count = restricted_vertices.size;
-
-            const relaxed_vertex_count = initial_restricted_vertex_count - relaxed_restricted_vertices_count;
-
-            total_relaxed_vertex_count += relaxed_vertex_count;
-
-
-            const num_desired_faces_to_remove = max2(0, patch.topology_mask.getFaces().size - MICRON_PATCH_SIZE_MAX);
-
-            if (num_desired_faces_to_remove > 0) {
-
-                /**
-                 *
-                 * @type {BinaryHeap<EdgeCollapseCandidate>}
-                 */
-                const open_set = new FastBinaryHeap(extract_edge_cost);
-
-                /**
-                 *
-                 * @type {Map<TopoEdge, EdgeCollapseCandidate>}
-                 */
-                const edge_to_collapse_map = new Map();
-
-                build_edge_collapse_candidates(
-                    patch.topology_mask,
-                    open_set,
-                    edge_to_collapse_map,
-                    vertex_quadratics,
-                    restricted_vertices
-                );
-
-                // execute mesh simplification
-
-                collapse_edges(
-                    num_desired_faces_to_remove,
-                    open_set,
-                    [],
-                    mesh,
-                    edge_to_collapse_map,
-                    vertex_quadratics,
-                    restricted_vertices
-                );
-                collapse_all_degenerate_edges(patch.topology_mask.getEdges(), mesh);
-
-            }
-
-        }
-
-        // snapshot patch topology
-        for (let j = 0; j < bucket_size; j++) {
-            const patch = lod_bucket[j];
-
-            // cleanup mask
-            cleanup_disconnected_faces(patch.topology_mask);
-            collapse_all_degenerate_edges(patch.topology_mask.getEdges(), patch.topology_mask);
-
-            // snapshot the mask
-            patch.snapshotTopology();
-        }
-
-    }
-
-}

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

@@ -1,140 +0,0 @@
-import { computePatchMergeScore } from "./computePatchMergeScore.js";
-import { array_remove_first } from "../../../../../core/collection/array/array_remove_first.js";
-import { patch_combine } from "./patch_combine.js";
-
-/**
- * Ok, so there is no neighbour. No connection between patches,
- * but we need to build a single hierarchy,
- * so let's find the most suitable candidate to merge with
- * @param {PatchRepresentation} source
- * @param {PatchRepresentation[]} pool
- * @returns {number} index of the best candidate
- */
-function synthesizeNeighbour(source, pool) {
-    const open_set_size = pool.length;
-
-    let best_score = Number.NEGATIVE_INFINITY;
-    let best_candidate = -1;
-
-    for (let i = 0; i < open_set_size; i++) {
-        const other = pool[i];
-
-        const score = computePatchMergeScore(source, other);
-
-        if (score > best_score) {
-            best_candidate = i;
-            best_score = score;
-        }
-    }
-
-
-    return best_candidate;
-}
-
-/**
- *
- * @param {PatchRepresentation} source
- * @param {PatchRepresentation[]} open_set
- * @returns {PatchRepresentation}
- */
-function pickBestNeighbourForMerge(source, open_set) {
-    const neighbours = source.neighbours;
-    const neighbour_count = neighbours.length;
-
-    let best_neighbour_score = Number.NEGATIVE_INFINITY;
-    let best_neighbour = undefined;
-
-    for (let i = 0; i < neighbour_count; i++) {
-        const neighbour = neighbours[i];
-
-        if (open_set.indexOf(neighbour) === -1) {
-            // not in open set, already part of the hierarchy
-            continue;
-        }
-
-        const score = computePatchMergeScore(source, neighbour);
-
-        if (score > best_neighbour_score) {
-            best_neighbour = neighbour;
-            best_neighbour_score = score;
-        }
-    }
-
-    return best_neighbour;
-}
-
-/**
- * @see QVDR paper
- * @returns {PatchRepresentation}
- * @param {PatchRepresentation[]} leaves
- */
-function build_tree(leaves) {
-    if (leaves.length === 0) {
-        throw new Error('Number of leaves must be at least 1, none were given');
-    }
-    //
-    // console.time('build merge graph');
-    // const leaf_cluster_weight_graph = build_merge_graph(leaves);
-    // console.timeEnd('build merge graph');
-
-
-    const open_set = leaves.slice();
-
-
-    /**
-     *
-     * @type {PatchRepresentation[]}
-     */
-    const neighbourless = [];
-
-    while (open_set.length > 1) {
-        const candidate_0 = open_set.shift();
-
-        // pick neighbour to combine with
-        const candidate_1 = pickBestNeighbourForMerge(candidate_0, open_set);
-
-        if (candidate_1 === undefined) {
-            // no neighbour
-            neighbourless.push(candidate_0);
-            continue;
-        }
-
-        // cut second node from open set
-        array_remove_first(open_set, candidate_1);
-
-        const merged = patch_combine(candidate_0, candidate_1, true);
-
-        // add to set
-        open_set.push(merged);
-    }
-
-    if (neighbourless.length > 0 && open_set.length > 0) {
-        // move conventional root to the neighbourless set
-        neighbourless.push(open_set[0]);
-
-        // handle patch groups without neighbours
-        while (neighbourless.length > 1) {
-            const candidate_0 = neighbourless.shift();
-
-            const candidate_1_index = synthesizeNeighbour(candidate_0, neighbourless);
-
-            if (candidate_1_index === -1) {
-                // this should never happen
-                throw new Error('No candidate found');
-            }
-            const candidate_1 = neighbourless[candidate_1_index];
-
-            neighbourless.splice(candidate_1_index, 1);
-
-            const merged = patch_combine(candidate_0, candidate_1, false);
-
-            open_set.push(merged);
-        }
-
-        // move to open set for return
-        open_set[0] = neighbourless[0];
-    }
-
-
-    return open_set[0];
-}