@woosh/meep-engine 2.48.20 → 2.48.21

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

@@ -1,162 +0,0 @@
-import { simplifyTopoMesh } from "../../../../../core/geom/3d/topology/simplify/simplifyTopoMesh.js";
-import { MICRON_PATCH_SIZE_MAX } from "../MICRON_PATCH_SIZE_MAX.js";
-
-
-/**
- *
- * @param {Set<number>} result
- * @param {TopoMesh} topology
- * @param {PatchRepresentation[]} cluster_nodes
- */
-export function compute_set_of_shared_vertices(result, topology, cluster_nodes) {
-    // build outer neighbour set
-
-    /**
-     *
-     * @type {Set<PatchRepresentation>}
-     */
-    const outer_neighbours = new Set();
-
-    const cluster_node_count = cluster_nodes.length;
-    for (let i = 0; i < cluster_node_count; i++) {
-        const node = cluster_nodes[i];
-
-        const node_neighbours = node.neighbours;
-        const node_neighbour_count = node_neighbours.length;
-        for (let j = 0; j < node_neighbour_count; j++) {
-            const neighbour = node_neighbours[j];
-
-            if (cluster_nodes.indexOf(neighbour) !== -1) {
-                // not an outer neighbour
-                continue;
-            }
-
-            outer_neighbours.add(neighbour);
-        }
-    }
-
-    // ingest topology vertices into a set for quick access
-    const topo_vertices = new Set();
-    const vertices = topology.vertices;
-    const topo_vertex_count = vertices.length;
-    for (let i = 0; i < topo_vertex_count; i++) {
-        const vertex = vertices[i];
-
-        topo_vertices.add(vertex.index);
-    }
-
-    // identify border vertices
-    for (const outerNeighbour of outer_neighbours) {
-        const neighbour_topo = outerNeighbour.topology_snapshot;
-
-        const n_vx = neighbour_topo.vertices;
-        const n_vx_count = n_vx.length;
-
-        for (let i = 0; i < n_vx_count; i++) {
-            const v = n_vx[i];
-
-            const vi = v.index;
-
-            if (topo_vertices.has(vi)) {
-                result.add(vi);
-            }
-        }
-    }
-}
-
-/**
- *
- * @param {Set<number>} result
- * @param {TopoMesh} topology
- */
-export function compute_set_of_border_vertex_indices(result, topology) {
-    const edges = topology.getEdges();
-
-    for (let edge of edges) {
-        const faces = edge.faces;
-        let included_face_count = 0;
-
-        if (!edge.isLinked()) {
-            // edge was removed
-            continue;
-        }
-
-        const face_count = faces.length;
-        for (let i = 0; i < face_count; i++) {
-            const face = faces[i];
-
-            if (topology.containsFace(face)) {
-                included_face_count++;
-            }
-        }
-
-        if (included_face_count <= 1) {
-            const v0 = edge.v0;
-            result.add(v0.index);
-
-            const v1 = edge.v1;
-            result.add(v1.index);
-            //
-            // if (!topology.containsVertex(v0) || !topology.containsVertex(v1)) {
-            //
-            //     console.log(edge);
-            //     debugger;
-            // }
-        }
-    }
-}
-
-/**
- *
- * @param {TopoMesh} result
- * @param {TopoMesh} a
- * @param {TopoMesh} b
- */
-export function compute_merged_topology(result, a, b) {
-
-    /**
-     *
-     * @type {Map<number, TopoVertex>}
-     */
-    const vertex_index_map = new Map();
-
-
-    // accumulate topology
-    result._addWithVertexMap(a, vertex_index_map);
-    result._addWithVertexMap(b, vertex_index_map);
-}
-
-/**
- *
- * @param {PatchRepresentation} patch
- */
-export function build_intermediate_patch_topology(patch) {
-    // figure out if patches are connected
-    const a = patch.children[0];
-    const b = patch.children[1];
-
-    // const children_connected = a.hasNeighbour(b);
-
-    compute_merged_topology(patch.topology_mask, a.topology_mask, b.topology_mask);
-
-    // r.traverse(p =>{
-    //    if(p.lod === 0){
-    //        r.topology._addWithVertexMap(p.topology,vertex_index_map);
-    //    }
-    // });
-
-    const restricted_vertices = new Set();
-
-    compute_set_of_border_vertex_indices(restricted_vertices, patch.topology_mask);
-
-    // remove discontinuities. move vertices in A to match B
-    // apply_collapsed_edges(b.simplified_points, r.topology);
-
-    // debugValidateMesh(r.topology);
-
-    simplifyTopoMesh(patch.topology_mask, MICRON_PATCH_SIZE_MAX, restricted_vertices);
-
-    // build mapping for simplified points
-    // build_vertex_mapping_from_simplification(patch.simplified_points, patch.reverse_simplified_points, patch.collapsed_edges);
-
-}

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

@@ -1,89 +0,0 @@
-import { Graph } from "../../../../../core/graph/v2/Graph.js";
-import { MultiNode } from "../../../../../core/graph/MultiNode.js";
-import { computePatchMergeScore } from "./computePatchMergeScore.js";
-import { WeightedEdge } from "../../../../../core/graph/WeightedEdge.js";
-import { assert } from "../../../../../core/assert.js";
-
-/**
- *
- * @param {PatchRepresentation[]} leaves
- * @returns {Graph<MultiNode<PatchRepresentation>>}
- */
-export function build_merge_graph(leaves) {
-    /**
-     *
-     * @type {Graph<MultiNode<PatchRepresentation>>}
-     */
-    const graph = new Graph();
-
-    /**
-     *
-     * @type {Map<PatchRepresentation, MultiNode<PatchRepresentation>>}
-     */
-    const leaf_to_node_map = new Map();
-
-    // add nodes
-    const leaf_count = leaves.length;
-    for (let i = 0; i < leaf_count; i++) {
-        const leaf = leaves[i];
-
-        const node = MultiNode.fromOne(leaf);
-
-        graph.addNode(node);
-
-        leaf_to_node_map.set(leaf, node);
-    }
-
-    // create edges
-    for (let i = 0; i < leaf_count; i++) {
-        const leaf = leaves[i];
-
-        const neighbours = leaf.neighbours;
-        const neighbour_count = neighbours.length;
-
-        const node_leaf = leaf_to_node_map.get(leaf);
-
-        const node_container_leaf = graph.getNodeContainer(node_leaf);
-
-        const connected_edges = node_container_leaf.getEdges();
-
-        if (neighbour_count === 0 && connected_edges.length === 0) {
-            // no neighbours and not otherwise connected in the graph
-            // TODO address
-            // throw new Error('Disconnected node');
-            continue;
-        }
-
-        for (let j = 0; j < neighbour_count; j++) {
-            const neighbour = neighbours[j];
-
-            const node_neighbour = leaf_to_node_map.get(neighbour);
-
-            if (node_neighbour === undefined) {
-                // not in the input set
-                continue;
-            }
-
-            const existing_edge = node_container_leaf.getAnyEdgeWith(node_neighbour);
-
-            if (existing_edge !== undefined) {
-                // edge already exists
-                continue;
-            }
-
-            const connection_weight = computePatchMergeScore(leaf, neighbour);
-
-            assert.isNumber(connection_weight, 'connection_weight');
-            assert.notNaN(connection_weight, 'connection_weight');
-            assert.isFiniteNumber(connection_weight, 'connection_weight');
-
-            const edge = new WeightedEdge(node_leaf, node_neighbour);
-
-            edge.weight = connection_weight;
-
-            graph.addEdge(edge);
-        }
-    }
-
-    return graph;
-}

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

@@ -1,146 +0,0 @@
-import { ConicRay } from "../../../../../core/geom/ConicRay.js";
-import { compute_bounding_cone_of_2_cones } from "../../../../../core/geom/3d/cone/compute_bounding_cone_of_2_cones.js";
-import { compute_patches_shared_vertex_count } from "./compute_patches_shared_vertex_count.js";
-import {
-    compute_bounding_sphere_of_2_spheres
-} from "../../../../../core/geom/3d/compute_bounding_sphere_of_2_spheres.js";
-import { max2 } from "../../../../../core/math/max2.js";
-import { min2 } from "../../../../../core/math/min2.js";
-import { assert } from "../../../../../core/assert.js";
-
-
-/**
- * Assumes that neither array contains duplicated in it's own scope
- * @template T
- * @param {T[]} array_a
- * @param {T[]} array_b
- * @returns {number}
- */
-function array_compute_common_element_count(array_a, array_b) {
-
-    let result = 0;
-
-    const a_count = array_a.length;
-
-    for (let i = 0; i < a_count; i++) {
-        const a = array_a[i];
-
-        if (array_b.indexOf(a) !== -1) {
-            result++;
-        }
-    }
-
-    return result;
-}
-
-const scratch_cone = new ConicRay();
-
-/**
- *
- * @type {number[]}
- */
-const scratch_v4 = [];
-
-/**
- *
- * @param {ConicRay} a
- * @param {ConicRay} b
- * @returns {number}
- */
-function coneMergeCost_2(a, b) {
-    compute_bounding_cone_of_2_cones(scratch_cone, a, b);
-
-    return scratch_cone.angle;
-}
-
-/**
- * pi^2
- * @type {number}
- */
-const pi_sqr = 9.86960440109;
-
-/**
- *
- * @param {number} r radius
- * @return {number}
- */
-function compute_sphere_volume(r) {
-    const r3 = r * r * r;
-
-    return r3 * 4.18879020479;
-}
-
-/**
- *
- * @param {number} a
- * @param {number} b
- * @return {number}
- */
-function normalized_difference(a, b) {
-    assert.isNumber(a, 'a');
-    assert.isNumber(b, 'a');
-
-    assert.notNaN(a,'a');
-    assert.notNaN(b,'b');
-
-    return Math.abs(a - b) / (max2(a, b) + 0.0001);
-}
-
-/**
- *
- * @param {PatchRepresentation} a
- * @param {PatchRepresentation} b
- * @returns {number} higher score means better fitness
- */
-export function computePatchMergeScore(a, b) {
-    // compute common neighbours
-    const a_neighbours = a.neighbours;
-    const b_neighbours = b.neighbours;
-
-    const common_neighbours = array_compute_common_element_count(a_neighbours, b_neighbours);
-
-    // normalize neighbour count
-    const common_neighbour_score = common_neighbours / (min2(a_neighbours.length, b_neighbours.length) + 0.01);
-
-    // prefer merging patches of similar LOD level, this creates a more flat hierarchy
-    const lod_score = 1 - normalized_difference(a.lod, b.lod);
-
-    const merged_cone_angle = coneMergeCost_2(a.normal_cone, b.normal_cone);
-    /**
-     * Try to merge patches that have similar normals, that is they face in the same direction
-     * @type {number}
-     */
-    const normal_score = 1 - (merged_cone_angle * merged_cone_angle) / pi_sqr;
-
-    /*
-    prefer cluster of similar volume
-     */
-    const a_bounds_radius = a.bounding_sphere[3];
-    const b_bounds_radius = b.bounding_sphere[3];
-
-    const similar_volume_score = 1 - normalized_difference(a_bounds_radius, b_bounds_radius);
-    /*
-     prefer merging patches that have similar bounds, this ensures good spatial locality
-     */
-    compute_bounding_sphere_of_2_spheres(scratch_v4, a.bounding_sphere, b.bounding_sphere);
-
-    const merged_sphere_volume = compute_sphere_volume(scratch_v4[3]);
-
-    const summed_sphere_volume = compute_sphere_volume(a_bounds_radius) + compute_sphere_volume(b_bounds_radius)
-
-    const volume_score = summed_sphere_volume / (merged_sphere_volume + 0.01);
-
-    /*
-    Prefer patches that share more vertices
-     */
-    const shared_vertex_count = compute_patches_shared_vertex_count(a, b);
-
-    const result = similar_volume_score * 0.01
-        + shared_vertex_count
-        + normal_score * 0.001
-        + common_neighbour_score
-        + lod_score * 0.1
-        + volume_score;
-
-    return result;
-}

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

@@ -1,32 +0,0 @@
-/**
- *
- * @param {PatchRepresentation} a
- * @param {PatchRepresentation} b
- * @returns {number}
- */
-export function compute_patches_shared_vertex_count(a, b) {
-    let result = 0;
-
-    const seen_vertices = new Set();
-
-    const a_vertices = a.topology_snapshot.vertices;
-    const a_vertex_count = a_vertices.length;
-    for (let i = 0; i < a_vertex_count; i++) {
-        const v = a_vertices[i];
-
-        seen_vertices.add(v.index);
-    }
-
-
-    const b_vertices = b.topology_snapshot.vertices;
-    const b_vertex_count = b_vertices.length;
-    for (let i = 0; i < b_vertex_count; i++) {
-        const v = b_vertices[i];
-
-        if (seen_vertices.has(v.index)) {
-            result++;
-        }
-    }
-
-    return result;
-}

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

@@ -1,34 +0,0 @@
-/**
- *
- * @param {PatchRepresentation} a
- * @param {PatchRepresentation} b
- * @returns {Set<number>}
- */
-export function compute_patches_shared_vertices(a, b) {
-    const seen = new Set();
-    const result = new Set();
-
-    const a_vertices = a.topology_mask.vertices;
-
-    const a_vertex_count = a_vertices.length;
-
-    for (let i = 0; i < a_vertex_count; i++) {
-        const v = a_vertices[i];
-
-        seen.add(v.index);
-    }
-
-
-    const b_vertices = b.topology_mask.vertices;
-    const b_vertex_count = b_vertices.length;
-    for (let i = 0; i < b_vertex_count; i++) {
-        const v = b_vertices[i];
-        const v_index = v.index;
-        if (seen.add(v_index)) {
-            result.add(v_index);
-        }
-    }
-
-
-    return result;
-}