@woosh/meep-engine 2.48.20 → 2.48.22

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

@@ -1,60 +0,0 @@
-/**
- * Attempt to recursively fill the holes in topology by undoing simplifications
- * @param {PatchRepresentation} root
- * @param {Map<number,TopoVertex>} vertex_map
- */
-export function patch_fill_holes_by_uncollapse(root, vertex_map) {
-    const open_set = root.children.slice();
-    let restored_edge_count = 0;
-    let restored_face_count = 0;
-
-    /**
-     *
-     * @param {EdgeCollapseCandidate} edge
-     * @param {PatchRepresentation} source
-     */
-    function restoreEdge(edge, source) {
-
-        const removed_faces = edge.edge.faces;
-
-        const remove_face_count = removed_faces.length;
-        for (let i = 0; i < remove_face_count; i++) {
-            const face = removed_faces[i];
-
-            root.topology_mask.addFaceCopy(face, vertex_map);
-
-            restored_face_count++;
-        }
-    }
-
-
-    while (open_set.length > 0) {
-        const patch = open_set.shift();
-
-        const collapsed_edges = patch.collapsed_edges;
-        const collapsed_edge_count = collapsed_edges.length;
-
-        for (let i = collapsed_edge_count - 1; i >= 0; i--) {
-            const edge = collapsed_edges[i];
-
-            const victim_vertex_index = edge.victim_vertex.index;
-
-            if (edge.isBorderCollapse()) {
-                const already_done = vertex_map.has(victim_vertex_index);
-                if (!already_done) {
-                    // un-collapse
-                    restoreEdge(edge, patch);
-                    restored_edge_count++;
-                } else {
-                    // console.log('!');
-                }
-            }
-        }
-
-        // Array.prototype.push.apply(open_set, patch.children);
-    }
-
-    if (restored_edge_count > 0) {
-        console.log(`restored ${restored_edge_count}, restored_face_count ${restored_face_count}`);
-    }
-}

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

@@ -1,320 +0,0 @@
-import { isVertexConnectedToOutline } from "../../../../../core/geom/3d/topology/isVertexConnectedToOutline.js";
-import { Graph } from "../../../../../core/graph/v2/Graph.js";
-import { EdgeDirectionType } from "../../../../../core/graph/Edge.js";
-
-class V {
-    /**
-     *
-     * @param {number} index
-     */
-    constructor(index) {
-        this.path = 0;
-        this.index = index;
-        this.connected = false;
-
-        /**
-         *
-         * @type {TopoVertex|null}
-         */
-        this.topo = null;
-
-        /**
-         * Other vertices that this one can connect to
-         * @type {Set<V>}
-         */
-        this.connects_to = new Set();
-    }
-
-}
-
-/**
- *
- * @param {V} from
- * @param {V} to
- * @returns {number}
- */
-function computeVertexMoveCost(from, to) {
-    const topo_to = to.topo;
-    const topo_from = from.topo;
-
-    const distance = topo_from.distanceTo(topo_to);
-
-    return distance;
-}
-
-/**
- *
- * @param {TopoMesh} mesh
- * @param {PatchRepresentation} a
- * @param {PatchRepresentation} b
- * @param {Map<number,TopoVertex>} vertex_map
- */
-export function patch_stitch_parent_border(mesh, a, b, vertex_map) {
-
-    /**
-     *
-     * @type {Map<number, V>}
-     */
-    const edge_set = new Map();
-
-
-    /**
-     *
-     * @type {Graph<number>}
-     */
-    const graph = new Graph();
-
-    /**
-     *
-     * @type {Map<number, V>}
-     */
-    const vertex_registry = new Map();
-
-    // build a graph for all edge vertices
-
-    /**
-     *
-     * @param {PatchRepresentation} patch
-     * @param {number} source_id
-     */
-    function map_forward(patch, source_id) {
-        const topo = patch.topology_mask;
-        const vertices = topo.vertices;
-        const vertex_count = vertices.length;
-        for (let i = 0; i < vertex_count; i++) {
-            const v = vertices[i];
-
-            if (!isVertexConnectedToOutline(v)) {
-                continue;
-            }
-
-            const index = v.index;
-
-            let v_rep = edge_set.get(index);
-
-            if (v_rep !== undefined) {
-                // already connected
-                v_rep.connected = true;
-            } else {
-                v_rep = new V(index);
-                v_rep.topo = v;
-
-                edge_set.set(index, v_rep);
-
-                graph.addNode(index);
-            }
-
-            v_rep.path |= source_id;
-
-        }
-    }
-
-    /**
-     *
-     * @param {PatchRepresentation} patch
-     */
-    function map_back(patch) {
-
-        // do initial mapping
-        const collapsed_edges = patch.collapsed_edges;
-
-        for (let j = collapsed_edges.length - 1; j >= 0; j--) {
-            const collapsedEdge = collapsed_edges[j];
-
-            if (!collapsedEdge.isBorderCollapse()) {
-                // not a border collapse
-                continue;
-            }
-
-            const victim_vertex = collapsedEdge.victim_vertex;
-            const victim_index = victim_vertex.index;
-            if (!graph.hasNode(victim_index)) {
-                graph.addNode(victim_index);
-
-                const v = new V(victim_index);
-                v.topo = victim_vertex;
-                vertex_registry.set(victim_index, v);
-            }
-
-            const target_vertex = collapsedEdge.target_vertex;
-            const target_index = target_vertex.index;
-
-            if (!graph.hasNode(target_index)) {
-                // target is not part of the current edge, still need to record it
-                graph.addNode(target_index);
-
-                const rep_v_target = new V(target_index);
-                rep_v_target.topo = target_vertex;
-
-                vertex_registry.set(target_index, rep_v_target)
-            }
-
-            graph.createEdge(target_index, victim_index, EdgeDirectionType.Undirected);
-        }
-
-        const children = patch.children;
-        const child_count = children.length;
-
-        for (let i = 0; i < child_count; i++) {
-            const child = children[i];
-
-            map_back(child);
-        }
-    }
-
-    map_forward(a, 1);
-    map_forward(b, 2);
-
-    map_back(a);
-    map_back(b);
-
-    /**
-     *
-     * @type {Set<V>}
-     */
-    const mappable_vertices = new Set();
-
-    // identify mapping between vertices
-    const edge_values = edge_set.values();
-    for (const edge_vertex_0 of edge_values) {
-
-        for (const edge_vertex_1 of edge_values) {
-            if (edge_vertex_0 === edge_vertex_1) {
-                // skip self
-                continue;
-            }
-
-            if ((edge_vertex_0.path & edge_vertex_1.path) !== 0) {
-                // belongs to both loops or the same loop. skip
-                continue;
-            }
-
-            const v0_index = edge_vertex_0.index;
-            const v1_index = edge_vertex_1.index;
-
-            if (edge_vertex_0.connects_to.has(edge_vertex_1)) {
-                // already connected, skip
-                continue;
-            }
-
-            const path = graph.findPath(v0_index, v1_index);
-
-            if (path === null) {
-                continue;
-            }
-
-            // record connection
-            edge_vertex_0.connects_to.add(edge_vertex_1);
-            edge_vertex_1.connects_to.add(edge_vertex_0);
-
-            mappable_vertices.add(edge_vertex_0);
-            mappable_vertices.add(edge_vertex_1);
-
-        }
-
-        while (true) {
-            let move_count = 0;
-            // attempt remapping
-            for (const v0 of mappable_vertices) {
-                // compute the cost of mapping this vertex forward
-                if (v0.connected) {
-                    // already connected, skip
-                    continue;
-                }
-
-                let best_option_cost = Number.POSITIVE_INFINITY;
-                let best_map_cost = Number.POSITIVE_INFINITY;
-                /**
-                 * @type {V}
-                 */
-                let v_from;
-                /**
-                 * @type {V}
-                 */
-                let v_to;
-
-                const forward_option_count = v0.connects_to.size;
-
-                if (forward_option_count === 0) {
-                    // no forward options left
-                    continue;
-                }
-
-                for (const v1 of v0.connects_to) {
-
-                    if (vertex_map.get(v1.index) === undefined) {
-                        // vertex is gone, most likely mapped somewhere else already
-                        continue;
-                    }
-
-                    const backward_option_count = v1.connects_to.size;
-
-                    const forward_option_cost = forward_option_count - backward_option_count;
-
-                    if (best_option_cost >= forward_option_cost) {
-
-                        const map_cost_forward = computeVertexMoveCost(v0, v1);
-
-
-                        if (map_cost_forward < best_map_cost) {
-                            v_from = v0;
-                            v_to = v1;
-                            best_map_cost = map_cost_forward;
-                            best_option_cost = forward_option_cost;
-                        }
-
-                    }
-
-                    if (
-                        !v1.connected
-                        && best_option_cost >= -forward_option_cost
-                    ) {
-                        const map_cost_backward = computeVertexMoveCost(v1, v0);
-
-                        if (map_cost_backward < best_map_cost) {
-                            v_from = v1;
-                            v_to = v0;
-                            best_map_cost = map_cost_backward;
-                            best_option_cost = -forward_option_cost;
-                        }
-                    }
-
-                }
-
-                // execute op
-                const topo_v_from = vertex_map.get(v_from.index);
-                const topo_v_to = vertex_map.get(v_to.index);
-
-                topo_v_to.replaceAnotherVertex(topo_v_from);
-
-                mesh.removeVertex(topo_v_from);
-                // debugValidateMesh(mesh);
-
-                // erase from record
-                vertex_map.delete(v_from.index);
-
-                // mark moved vertex
-                // const v_from_rep = edge_set.get(v_from.index);
-
-                v_from.connected = true;
-
-                // patch neighbours of the removed vertex
-                v_to.connects_to.delete(v_from);
-
-                for (const v of v_from.connects_to) {
-                    if (v !== v_to) {
-                        v_to.connects_to.add(v);
-                        v.connects_to.delete(v_from);
-                        v.connects_to.add(v_to);
-                    }
-                }
-
-                move_count++;
-            }
-
-            if (move_count === 0) {
-                break;
-            }
-        }
-    }
-}