@woosh/meep-engine 2.76.4 → 2.78.0

package/src/core/graph/Graph.js

@@ -1,564 +0,0 @@
-/**
- * Created by Alex on 29/01/14.
- */
-
-
-import Signal from "../events/signal/Signal.js";
-import { Edge, EdgeDirectionType } from "./Edge.js";
-
-/**
- * @callback Graph~visitor
- * @param {*} node
- * @param {Edge} edge
- * @returns {boolean|undefined} if false is returned, traversal should stop
- */
-
-/**
- * @template N
- */
-export class Graph {
-    /**
-     * @template N
-     * @constructor
-     */
-    constructor() {
-        /**
-         * @private
-         * @type {N[]}
-         */
-        this.__nodes = [];
-
-        /**
-         * Accelerated data structure for faster lookups
-         * @type {Set<any>}
-         * @private
-         */
-        this.__nodes_set = new Set();
-
-        /**
-         * @private
-         * @type {Edge<N>[]}
-         */
-        this.__edges = [];
-        this.onChange = new Signal();
-    }
-
-    /**
-     *
-     * @returns {N[]}
-     */
-    get nodes() {
-        return this.__nodes;
-    }
-
-    /**
-     *
-     * @returns {Edge<N>[]}
-     */
-    get edges() {
-        return this.__edges;
-    }
-
-    /**
-     * Converts this graph into a shallow copy of supplied graph
-     * @param {Graph<N>} other
-     */
-    copy(other) {
-        this.clear();
-
-        this.__nodes = other.__nodes.slice();
-        this.__edges = other.__edges.slice();
-
-        this.__nodes_set = new Set(this.__nodes);
-    }
-
-    /**
-     *
-     * @param {N} start
-     * @param {N} goal
-     * @returns {Array<N>|null} nodes from start to goal in the shortest path including both start and goal.
-     */
-    findPath(start, goal) {
-        const open = new Set();
-        open.add(start);
-
-        const closed = new Set();
-
-        const cameFrom = new Map();
-
-        function constructPath() {
-            const result = [];
-            let c = goal;
-            do {
-                result.unshift(c);
-                c = cameFrom.get(c);
-            } while (c !== undefined);
-
-            return result;
-        }
-
-        const graph = this;
-
-        function expandNode(current) {
-            graph.traverseSuccessors(current, function (node, edge) {
-                if (closed.has(node)) {
-                    return;
-                }
-                if (open.has(node)) {
-                    return;
-                }
-                open.add(node);
-                cameFrom.set(node, current);
-            });
-        }
-
-        while (open.size > 0) {
-            const current = open.values().next().value;
-            if (current === goal) {
-                //reached the goal
-                return constructPath();
-            }
-            open.delete(current);
-            closed.add(current);
-
-            //expand node
-            expandNode(current);
-        }
-
-        //no path found
-        return null;
-    }
-
-    /**
-     * Returns true if there is an edge between two given nodes on this graph
-     * @param {N} node1
-     * @param {N} node2
-     * @returns {boolean}
-     */
-    isEdgeBetween(node1, node2) {
-        if (!this.containsNode(node1) || !this.containsNode(node2)) {
-            return false; // one or both nodes are not part of the graph
-        }
-        const connectingEdge = this.findConnectingEdge(node1, node2);
-        return connectingEdge !== null;
-    }
-
-    /**
-     * Strictly traversable edge exists from source to target
-     * @param {N} source
-     * @param {N} target
-     * @returns {boolean}
-     */
-    edgeExists(source, target) {
-        if (!this.containsNode(source) || !this.containsNode(target)) {
-            return false; // one or both nodes are not part of the graph
-        }
-
-        return this.traversePredecessors(source, function (destination) {
-            if (destination === target) {
-                //terminate traversal, this will make "traversePredecessors" return true also
-                return false;
-            }
-        });
-    }
-
-    /**
-     *
-     * @param {function(node:N):boolean} visitor
-     * @param {*} [thisArg]
-     */
-    traverseNodes(visitor, thisArg) {
-        const nodes = this.__nodes;
-        const l = nodes.length;
-        for (let i = 0; i < l; i++) {
-            const node = nodes[i];
-            if (visitor.call(thisArg, node) === false) {
-                return;
-            }
-        }
-    }
-
-    /**
-     *
-     * @param {N} node
-     * @param {function(node:N, edge:Edge<N>):(boolean|void)} visitor
-     */
-    traverseSuccessors(node, visitor) {
-        const edges = this.__edges;
-        let i = 0;
-        const l = edges.length;
-
-        for (; i < l; i++) {
-            const edge = edges[i];
-            const first = edge.first;
-            const second = edge.second;
-
-            if (first === node && edge.traversableForward()) {
-                if (visitor(second, edge) === false) {
-                    //terminate traversal if visitor returns false
-                    return;
-                }
-            } else if (second === node && edge.traversableBackward()) {
-                if (visitor(first, edge) === false) {
-                    //terminate traversal if visitor returns false
-                    return;
-                }
-            }
-        }
-
-    }
-
-    /**
-     *
-     * @param {function(edge:Edge<N>):boolean} visitor
-     */
-    traverseEdges(visitor) {
-        const edges = this.__edges;
-        let i = 0;
-        const l = edges.length;
-        for (; i < l; i++) {
-            const edge = edges[i];
-            if (visitor(edge) === false) {
-                //terminate traversal if visitor returns false
-                return;
-            }
-        }
-    }
-
-    /**
-     *
-     * @param {N} node
-     * @param {function(N,Edge<N>)} visitor
-     */
-    traversePredecessors(node, visitor) {
-        const edges = this.__edges;
-        let i = 0;
-        const l = edges.length;
-        for (; i < l; i++) {
-            const edge = edges[i];
-            const first = edge.first;
-            const second = edge.second;
-
-            if (second === node && edge.traversableForward()) {
-                if (visitor(first, edge) === false) {
-                    //terminate traversal if visitor returns false
-                    return true;
-                }
-            } else if (first === node && edge.traversableBackward()) {
-                if (visitor(second, edge) === false) {
-                    //terminate traversal if visitor returns false
-                    return true;
-                }
-            }
-        }
-        return false;
-    }
-
-    /**
-     *
-     * @param {N} node
-     * @param {function(N,Edge):(boolean|void)} visitor
-     */
-    traverseAttachedEdges(node, visitor) {
-        const edges = this.__edges;
-        let i = 0;
-        const l = edges.length;
-        for (; i < l; i++) {
-            const edge = edges[i];
-            const first = edge.first;
-            const second = edge.second;
-
-            if (first === node) {
-                if (visitor(second, edge) === false) {
-                    //terminate traversal if visitor returns false
-                    return;
-                }
-            } else if (second === node) {
-                if (visitor(first, edge) === false) {
-                    //terminate traversal if visitor returns false
-                    return;
-                }
-            }
-        }
-    }
-
-    /**
-     *
-     * @param {N} source
-     * @param {N} target
-     * @return {Edge<N>|null}
-     */
-    findTraversableEdge(source, target) {
-
-        const edges = this.__edges;
-
-        const numEdges = edges.length;
-
-        for (let i = 0; i < numEdges; i++) {
-
-            /**
-             *
-             * @type {Edge<N>}
-             */
-            const edge = edges[i];
-
-            if (
-                (edge.first === source && edge.second === target && edge.direction !== EdgeDirectionType.Backward)
-                || (edge.second === source && edge.first === target && edge.direction !== EdgeDirectionType.Forward)
-            ) {
-                return edge;
-            }
-        }
-
-        return null;
-    }
-
-    /**
-     *
-     * @param {N} node1
-     * @param {N} node2
-     * @returns {Edge<N>|null}
-     */
-    findConnectingEdge(node1, node2) {
-        const edges = this.__edges;
-
-        const numEdges = edges.length;
-
-        for (let i = 0; i < numEdges; i++) {
-
-            const edge = edges[i];
-
-            if (edge.contains(node1) && edge.contains(node2)) {
-                return edge;
-            }
-
-        }
-
-        return null;
-    }
-
-    /**
-     *
-     * @param {N} source
-     * @param {N} target
-     * @param {function(Edge<N>):boolean} visitor
-     */
-    findTraversableEdges(source, target, visitor) {
-        const edges = this.__edges;
-        for (let i = 0; i < edges.length; i++) {
-            const edge = edges[i];
-            if (edge.validateTransition(source, target)) {
-
-                if (visitor(edge) === false) {
-                    return;
-                }
-            }
-        }
-    }
-
-    /**
-     *
-     * @param {N} node
-     * @returns {Edge<N>[]}
-     */
-    getAttachedEdges(node) {
-        let i = 0;
-
-        const result = [];
-
-        const edges = this.__edges;
-        const l = edges.length;
-
-        for (; i < l; i++) {
-            const edge = edges[i];
-
-            if (edge.contains(node)) {
-                result.push(edge);
-            }
-        }
-
-        return result;
-    }
-
-    /**
-     *
-     * @param {N} node
-     * @returns {N[]}
-     */
-    getNeighbours(node) {
-        const result = [];
-
-        const edges = this.edges;
-        const nEdges = edges.length;
-
-        for (let i = 0; i < nEdges; i++) {
-            const edge = edges[i];
-
-            const first = edge.first;
-            const second = edge.second;
-
-            if (first === node && (edge.direction === EdgeDirectionType.Forward || edge.direction === EdgeDirectionType.Undirected)) {
-                if (result.indexOf(second) === -1) {
-                    result.push(second);
-                }
-            } else if (second === node && (edge.direction === EdgeDirectionType.Backward || edge.direction === EdgeDirectionType.Undirected)) {
-                if (result.indexOf(first) === -1) {
-                    result.push(first);
-                }
-            }
-
-        }
-
-        return result;
-    }
-
-    /**
-     *
-     * @param {N} node
-     * @returns {boolean}
-     */
-    containsNode(node) {
-        return this.__nodes_set.has(node);
-    }
-
-    /**
-     * @deprecated
-     * @returns {number}
-     */
-    length() {
-        const edges = this.__edges;
-        let result = 0;
-        for (let i = 0; i < edges.length; i++) {
-            const edge = edges[i];
-            result += edge.length;
-        }
-        return result;
-    }
-
-    /**
-     *
-     * @param {N} node
-     */
-    addNode(node) {
-
-        this.__nodes_set.add(node);
-
-        this.__nodes.push(node);
-    }
-
-    /**
-     *
-     * @param {N} node
-     * @returns {boolean}
-     */
-    removeNode(node) {
-        if (!this.containsNode(node)) {
-            return false;
-        }
-
-        const i = this.__nodes.indexOf(node);
-
-        if (i === -1) {
-            // this should never happen
-            return false;
-        } else {
-            //remove attached connections
-            const attachedEdges = this.getAttachedEdges(node);
-
-            const n = attachedEdges.length;
-
-            for (let j = 0; j < n; j++) {
-                const edge = attachedEdges[j];
-
-                this.removeEdge(edge);
-            }
-
-            this.__nodes.splice(i, 1);
-            this.__nodes_set.delete(node);
-
-            return true;
-        }
-    }
-
-    /**
-     * Whether or not the graph contains given node
-     * NOTE: same as {@link #containsNode}
-     * @param {N} node
-     * @returns {boolean}
-     */
-    hasNode(node) {
-        return this.containsNode(node);
-    }
-
-    /**
-     *
-     * @param {Edge<N>} edge
-     */
-    addEdge(edge) {
-        //assert.ok(this.containsNode(edge.first), `Node Edge.first(=${edge.first}) is not present in the graph`);
-        //assert.ok(this.containsNode(edge.second), `Node Edge.second(=${edge.second}) is not present in the graph`);
-
-        this.__edges.push(edge);
-        this.onChange.send1(edge);
-    }
-
-    /**
-     *
-     * @param {N} source
-     * @param {N} target
-     * @param {EdgeDirectionType} [direction]
-     * @returns {Edge<N>}
-     */
-    createEdge(source, target, direction = EdgeDirectionType.Undirected) {
-        const edge = new Edge(source, target);
-
-        edge.direction = direction;
-
-        this.addEdge(edge);
-
-        return edge;
-    }
-
-    /**
-     *
-     * @param {Edge<N>} edge
-     * @returns {boolean}
-     */
-    removeEdge(edge) {
-        const edges = this.__edges;
-        const indexOf = edges.indexOf(edge);
-        if (indexOf >= 0) {
-            edges.splice(indexOf, 1);
-            this.onChange.send1(edge);
-
-            return true;
-        } else {
-            console.error("Edge was not found");
-
-            return false;
-        }
-    }
-
-    clear() {
-        this.__edges = [];
-        this.__nodes = [];
-        this.__nodes_set.clear();
-
-        this.onChange.send0();
-    }
-
-    /**
-     *
-     * @returns {Graph<N>}
-     */
-    clone() {
-        const graph = new Graph();
-
-        graph.copy(this);
-
-        return graph;
-    }
-}
-
-
-export default Graph;