@woosh/meep-engine 2.48.20 → 2.48.21

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

@@ -1,515 +0,0 @@
-import { graph_k_means_cluster_detailed } from "../../../../../core/graph/graph_k_means_cluster.js";
-import { array_remove_first } from "../../../../../core/collection/array/array_remove_first.js";
-
-/**
- *
- * @param {number[]} G
- * @param {number[]} T
- * @param {number[]} C
- * @param {number} k
- * @param {number[]} node_cluster_assignment
- * @param {number[][]} parts
- * @returns {number}
- */
-function process_cycle(
-    G,
-    T,
-    C,
-    k,
-    node_cluster_assignment,
-    parts
-) {
-    let ops = 0;
-    let j = 0;
-    for (let i = 0; i < k; i++, j = i) {
-        if (C[i] !== 255 || T[j] < 0) {
-            continue;
-        }
-
-        while (C[j] === 255 && T[j] >= 0) {
-            C[j] = i;
-            j = T[j];
-        }
-
-        if (C[j] === i && T[j] >= 0) {
-            do {
-                const node_index = G[j];
-                const destination_cluster_index = T[j];
-
-                const source_cluster_index = node_cluster_assignment[node_index];
-
-                if (source_cluster_index !== destination_cluster_index) {
-
-                    // rewrite assignment
-                    node_cluster_assignment[node_index] = destination_cluster_index;
-
-                    // move between part arrays
-                    array_remove_first(parts[source_cluster_index], node_index);
-                    parts[destination_cluster_index].push(node_index);
-
-                    ops++;
-                } else {
-                    // no movement
-                    // break;
-                }
-
-                j = destination_cluster_index;
-            } while (C[j] === i);
-        }
-    }
-
-    return ops;
-}
-
-const move_suggestion = {
-    t: 0,
-    g: 0
-};
-
-/**
- * Algorithm GreedyCompute for a part to compute which node to go and where
- * @param {number} part_index
- * @param {number[][]} parts part
- * @param {number} k number of partitions
- * @param {Graph<T>} graph
- * @param {T[]} node_array
- * @param {number[]} node_cluster_assignment
- * @param {Float32Array} pressure_vector
- * @param {Uint8Array} visited_vector
- * @param {Map<T, number>} node_index_map
- */
-function greedy_compute(
-    part_index,
-    parts,
-    k,
-    graph,
-    node_array,
-    node_cluster_assignment,
-    node_index_map,
-    pressure_vector,
-    visited_vector
-) {
-
-
-    let best_node_pressure = 1;
-    let best_overall_gain = Number.NEGATIVE_INFINITY
-
-    let i, j;
-
-    const part = parts[part_index];
-
-    const part_size = part.length;
-
-    for (i = 0; i < k; i++) {
-
-        if (i === part_index) {
-            // skip self
-            continue;
-        }
-
-        const cluster_size = parts[i].length;
-
-        pressure_vector[i] = part_size / (cluster_size + 0.01);
-    }
-
-    for (i = 0; i < part_size; i++) {
-        // reset gain vector
-        visited_vector.fill(0);
-
-        const node_index = part[i];
-
-        // de-reference actual node
-        const node = node_array[node_index];
-
-        // get neighbours of node
-        const node_container = graph.getNodeContainer(node);
-        const edges = node_container.getEdges();
-
-        // lets consider where this node might move
-        const edge_count = edges.length;
-
-        for (let i1 = 0; i1 < edge_count; i1++) {
-            const edge = edges[i1];
-
-            const neighbour = edge.other(node);
-
-            const neighbour_index = node_index_map.get(neighbour);
-
-            const neighbour_cluster_index = node_cluster_assignment[neighbour_index];
-
-            visited_vector[neighbour_cluster_index] = 1;
-        }
-
-        // find X such that Gv[x] is highest value
-
-        for (j = 0; j < k; j++) {
-
-            if (j === part_index) {
-                continue;
-            }
-
-            if (visited_vector[j] === 0) {
-                continue;
-            }
-
-            const pressure = pressure_vector[j];
-
-            if (pressure < best_node_pressure) {
-                continue;
-            } else {
-                best_node_pressure = pressure;
-            }
-
-            const gain = compute_node_move_cost(
-                graph,
-                node_container,
-                part_index,
-                j,
-                node_array,
-                node_cluster_assignment,
-                node_index_map
-            );
-
-            if (gain > best_overall_gain) {
-                // update gain
-                move_suggestion.g = node_index;
-                move_suggestion.t = j;
-
-                best_overall_gain = gain;
-            }
-        }
-
-    }
-
-    return best_overall_gain;
-}
-
-/**
- *
- * @param {number} node_index
- * @param {number} destination_cluster_index
- * @param {number} source_cluster_index
- * @param {number[]} node_cluster_assignment
- * @param {number[][]} parts
- */
-function pass_node(
-    node_index,
-    destination_cluster_index,
-    source_cluster_index,
-    node_cluster_assignment,
-    parts
-) {
-
-    // rewrite assignment
-    node_cluster_assignment[node_index] = destination_cluster_index;
-
-    // move between part arrays
-    array_remove_first(parts[source_cluster_index], node_index);
-    parts[destination_cluster_index].push(node_index);
-
-}
-
-/**
- * @template T
- * @param {number} k
- * @param {number[][]} parts
- * @param {Graph<T>} graph
- * @param {T[]} node_array
- * @param {number[]} node_cluster_assignment
- * @param {Map<T, number>} node_index_map
- */
-function greedy_cycle(
-    k,
-    parts,
-    graph,
-    node_array,
-    node_cluster_assignment,
-    node_index_map
-) {
-    if (k > 127) {
-        throw new Error('Too many parts, algorithm only supports 127');
-    }
-
-    const n = node_array.length;
-
-    const pressure_vector = new Float32Array(k);
-    const visited_vector = new Uint8Array(k);
-
-    const balance_lower_limit = Math.floor(n / k);
-    const balance_upper_limit = Math.ceil(n / k);
-
-    let step_op_count, i, balanced;
-
-    move_suggestion.g = -1;
-    move_suggestion.t = -1;
-
-    do {
-        balanced = true;
-
-        for (i = 0; i < k; i++) {
-            const cluster = parts[i];
-            const cluster_size = cluster.length;
-            if (cluster_size < balance_lower_limit || cluster_size > balance_upper_limit) {
-                balanced = false;
-            }
-        }
-
-        if (balanced) {
-            // already balanced, stop here
-            break;
-        }
-
-        step_op_count = 0;
-
-        for (i = 0; i < k; i++) {
-
-            greedy_compute(
-                i,
-                parts,
-                k,
-                graph,
-                node_array,
-                node_cluster_assignment,
-                node_index_map,
-                pressure_vector,
-                visited_vector
-            );
-
-            const target_cluster = move_suggestion.t;
-
-            if (target_cluster === -1) {
-                // no target
-                continue;
-            }
-
-            const node_index = move_suggestion.g;
-
-            pass_node(node_index, target_cluster, i, node_cluster_assignment, parts);
-
-            move_suggestion.g = -1;
-            move_suggestion.t = -1;
-
-            step_op_count++;
-        }
-
-    }
-    while (step_op_count > 0);
-}
-
-/**
- * compute total weight of edges that will be fully within the target cluster
- * @template T
- * @param {Graph<T,WeightedEdge<T>>} graph
- * @param {NodeContainer<T>} node_container
- * @param {number} source_cluster
- * @param {number} target_cluster
- * @param {T[]} node_array
- * @param {number[]} node_cluster_assignments Node to cluster references
- * @returns {number} lower is better
- * @param {Map<T, number>} node_index_map
- */
-function compute_node_move_cost(
-    graph,
-    node_container,
-    source_cluster,
-    target_cluster,
-    node_array,
-    node_cluster_assignments,
-    node_index_map
-) {
-    let weight_gain = 0;
-
-    const existing_edges = node_container.getEdges();
-
-    const node = node_container.node;
-
-    // find edges that make up the current cut
-    const existing_edge_count = existing_edges.length;
-
-    for (let i = 0; i < existing_edge_count; i++) {
-        const edge = existing_edges[i];
-
-        const node_neighbour = edge.other(node);
-
-        const neighbour_index = node_index_map.get(node_neighbour);
-
-        const neighbour_cluster_index = node_cluster_assignments[neighbour_index];
-
-        if (neighbour_cluster_index === target_cluster) {
-            // this edge will be consumed by the new cluster and will be removed from current cut
-            weight_gain += edge.weight;
-        } else if (neighbour_cluster_index === source_cluster) {
-            weight_gain -= edge.weight;
-        }
-    }
-
-    return weight_gain;
-}
-
-/**
- * Based on GreedyCycle algorithm
- * @see Fast Approximate Graph Partitioning Algorithms
- * @template T
- * @param {Graph<T>} graph
- * @param {T[][]} parts
- * @param {T[]} node_array
- * @param {number[]} node_cluster_assignments Node to cluster references
- */
-function optimize_graph_partitioning_balance(
-    graph,
-    parts,
-    node_array,
-    node_cluster_assignments
-) {
-    let optimization_op_count_step = 0;
-
-    const node_count = node_array.length;
-
-    const partition_count = parts.length;
-
-    const upper_cluster_size_bound = Math.ceil(node_count / partition_count);
-    const lower_cluster_size_bound = Math.floor(node_count / partition_count);
-
-    // quick check if partitions are already optimal
-    let optimal_cluster_sizes = true;
-    for (let i = 0; i < partition_count; i++) {
-        const part = parts[i];
-
-        const cluster_size = part.length;
-        if (cluster_size < lower_cluster_size_bound || cluster_size > upper_cluster_size_bound) {
-            optimal_cluster_sizes = false;
-            break;
-        }
-    }
-
-    if (optimal_cluster_sizes) {
-        return;
-    }
-
-    // compute current cut weight
-
-    do {
-        optimization_op_count_step = 0;
-
-        let best_source_cluster = -1;
-        let best_cost = 0;
-        let best_target_node = -1;
-        let best_target_node_origin_cluster = -1;
-
-        // TODO we can compute multiple moves in a single pass
-
-        for (let i = 0; i < node_count; i++) {
-            const node = node_array[i];
-
-            const node_partition_index = node_cluster_assignments[i];
-
-            const source_part = parts[node_partition_index];
-            const source_part_size = source_part.length;
-            if (source_part_size >= upper_cluster_size_bound) {
-                // partition is already full, skip
-                continue;
-            }
-
-            const container = graph.getNodeContainer(node);
-
-            const edges = container.getEdges();
-
-            // lets consider where this node might move
-            const edge_count = edges.length;
-            for (let i1 = 0; i1 < edge_count; i1++) {
-                const edge = edges[i1];
-
-                const neighbour = edge.other(node);
-
-                const neighbour_index = node_array.indexOf(neighbour);
-
-                const neighbour_partition_index = node_cluster_assignments[neighbour_index];
-
-                if (neighbour_partition_index === node_partition_index) {
-                    // belongs to the same cluster, no swap/move opportunity
-                    continue;
-                }
-
-                // if (parts[neighbour_partition_index].length <= upper_cluster_size_bound) {
-                // neighbour partition would have too few elements
-                // continue;
-                // }
-
-                const cost = compute_node_move_cost(graph, neighbour, neighbour_partition_index, node_partition_index, node_array, node_cluster_assignments);
-
-                if (cost < best_cost) {
-
-                    best_source_cluster = node_partition_index;
-                    best_target_node = neighbour_index;
-                    best_cost = cost;
-                    best_target_node_origin_cluster = neighbour_partition_index;
-                }
-
-
-            }
-        }
-
-        if (best_source_cluster !== -1) {
-            // do move
-            node_cluster_assignments[best_target_node] = best_source_cluster;
-
-            array_remove_first(parts[best_target_node_origin_cluster], best_target_node);
-            parts[best_source_cluster].push(best_target_node);
-
-            optimization_op_count_step++;
-        } else {
-            for (let i = 0; i < parts.length; i++) {
-                if (parts[i].length > upper_cluster_size_bound) {
-
-                    debugger;
-                }
-            }
-        }
-
-    } while (optimization_op_count_step > 0);
-}
-
-/**
- * @template T
- * @param {T[]} node_array
- * @param {number} k
- * @param {Graph<T>} graph
- * @returns {number[][]}
- */
-export function optimize_graph_partitioning_balance_detailed(node_array, k, graph) {
-    const node_count = node_array.length;
-    /**
-     *
-     * @type {number[]}
-     */
-    const node_cluster_assignments = new Uint8Array(node_count);
-    // fill with "UNASSIGNED" value
-    node_cluster_assignments.fill(255);
-
-    /**
-     * build node index
-     * @type {Map<T, number>}
-     */
-    const node_index_map = new Map();
-
-    for (let i = 0; i < node_count; i++) {
-        node_index_map.set(node_array[i], i);
-    }
-
-    const clusters = graph_k_means_cluster_detailed(node_array, k, 1249, node_cluster_assignments, node_index_map, graph);
-
-    greedy_cycle(k, clusters, graph, node_array, node_cluster_assignments, node_index_map);
-
-    return clusters;
-}
-
-/**
- * @template T
- * @param {Graph<T>} graph
- * @param {number} k
- * @returns {number[][]}
- */
-export function graph_build_balanced_partitions(graph, k) {
-    const node_array = Array.from(graph.getNodes());
-    return optimize_graph_partitioning_balance_detailed(node_array, k, graph);
-}

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

@@ -1,180 +0,0 @@
-import { PatchRepresentation } from "../PatchRepresentation.js";
-import { array_copy } from "../../../../../core/collection/array/copyArray.js";
-import { array_copy_unique } from "../../../../../core/collection/array/array_copy_unique.js";
-import { array_remove_first } from "../../../../../core/collection/array/array_remove_first.js";
-import { max2 } from "../../../../../core/math/max2.js";
-import { array_push_if_unique } from "../../../../../core/collection/array/array_push_if_unique.js";
-import {
-    compute_bounding_sphere_of_2_spheres
-} from "../../../../../core/geom/3d/compute_bounding_sphere_of_2_spheres.js";
-import { compute_bounding_cone_of_2_cones } from "../../../../../core/geom/3d/cone/compute_bounding_cone_of_2_cones.js";
-import { ConicRay } from "../../../../../core/geom/ConicRay.js";
-import { passThrough } from "../../../../../core/function/Functions.js";
-
-/**
- *
- * @param {PatchRepresentation} r
- */
-export function compute_neighbours_from_children(r) {
-
-    const this_neighbours = r.neighbours;
-
-    const children = r.children;
-
-    const child_count = children.length;
-
-    const child_0 = children[0];
-
-    array_copy(child_0.neighbours, 0, this_neighbours, 0, child_0.neighbours.length);
-    for (let i = 1; i < child_count; i++) {
-        const child = children[i];
-        array_copy_unique(child.neighbours, 0, this_neighbours, this_neighbours.length, child.neighbours.length)
-    }
-
-    // remove children from own neighbourhood set
-    for (let i = 0; i < child_count; i++) {
-        const child = children[i];
-        array_remove_first(this_neighbours, child);
-    }
-
-    // add self to neighbours
-    let this_neighbour_count = this_neighbours.length;
-    for (let i = 0; i < this_neighbour_count; i++) {
-        const neighbour = this_neighbours[i];
-
-        // remove neighbours that are part of the hierarchy
-        if (neighbour.isDescendantOf(r)) {
-
-            this_neighbours.splice(i, 1);
-
-            i--;
-            this_neighbour_count--;
-
-            continue;
-        }
-
-        // link back from neighbour to this new patch
-        array_push_if_unique(neighbour.neighbours, r);
-    }
-
-
-}
-
-/**
- * @template T
- * @param {ConicRay} result
- * @param {T[]} inputs
- * @param {function(T):ConicRay} extract
- */
-function compute_bounding_cone_of_cones(result, inputs, extract = passThrough) {
-    const open = inputs.map(extract);
-
-    while (open.length > 1) {
-        const r0 = open.shift();
-        const r1 = open.shift();
-
-        const out = new ConicRay();
-
-        compute_bounding_cone_of_2_cones(out, r0, r1);
-
-        open.push(out);
-    }
-
-    result.copy(open[0]);
-}
-
-/**
- * @template T
- * @param {number[]|vec4} result
- * @param {T[]} inputs
- * @param {function(T):(number[]|vec4)} extract
- */
-function compute_bounding_sphere_of_spheres(result, inputs, extract) {
-    const open = inputs.map(extract);
-
-    while (open.length > 1) {
-        const r0 = open.shift();
-        const r1 = open.shift();
-
-        const out = [];
-
-        compute_bounding_sphere_of_2_spheres(out, r0, r1);
-
-        open.push(out);
-    }
-
-    array_copy(open[0], 0, result, 0, 4);
-}
-
-/**
- *
- * @param {PatchRepresentation[]} children
- * @returns {PatchRepresentation}
- */
-export function patch_build_parent(children) {
-
-    const r = new PatchRepresentation();
-
-    r.children = children;
-
-    for (let i = 0; i < children.length; i++) {
-        const child = children[i];
-        // set parent
-        child.parents.push(r);
-
-        //figure out lod
-        r.lod = max2(r.lod, child.lod + 1);
-
-        // combine bounds
-        // r.bounding_box.expandToFit(child.bounding_box);
-    }
-
-    // combine bounds
-    // compute_bounding_cone_of_cones(r.normal_cone, children, c => c.normal_cone);
-    // compute_bounding_sphere_of_spheres(r.bounding_sphere, children, t => t.bounding_sphere);
-
-
-    return r;
-}
-
-/**
- *
- * @return {PatchRepresentation}
- * @param {PatchRepresentation} a
- * @param {PatchRepresentation} b
- * @param {boolean} is_connected are patches neighbours?
- */
-export function patch_combine(a, b, is_connected) {
-
-    const r = new PatchRepresentation();
-
-    //figure out lod
-    r.lod = max2(a.lod, b.lod) + 1;
-
-    r.children = [a, b];
-
-    // set parent
-    a.parent = r;
-    b.parent = r;
-
-    // patch neighbours
-    compute_neighbours_from_children(r);
-
-    //combine bounds
-    r.bounding_box.expandToFit(a.bounding_box);
-    r.bounding_box.expandToFit(b.bounding_box);
-
-    compute_bounding_cone_of_2_cones(r.normal_cone, a.normal_cone, b.normal_cone);
-    compute_bounding_sphere_of_2_spheres(r.bounding_sphere, a.bounding_sphere, b.bounding_sphere);
-
-    // const errors = [];
-    // const is_valid = r.validate(errors.push, errors);
-    //
-    // if (!is_valid) {
-    //     debugger;
-    // }
-
-    // build_intermediate_patch_topology(r);
-
-    return r;
-}