Merge pull request #512 from MatsSchrader/dynamic-graph-support

Dynamic graph support

Author: rustedgrail

lib/acyclic.ts

@@ -5,10 +5,10 @@ import type {Edge, EdgeLabel, GraphLabel, NodeLabel, WeightFunction} from "./typ
 
 export {run, undo};
 
-function run(graph: Graph<GraphLabel, NodeLabel, EdgeLabel>): void {
+function run(graph: Graph<GraphLabel, NodeLabel, EdgeLabel>, oldGraph: Graph| null): void {
     const fas = (graph.graph().acyclicer === "greedy"
         ? greedyFAS(graph, weightFn(graph))
-        : dfsFAS(graph));
+        : dfsFAS(graph, oldGraph));
     fas.forEach(e => {
         const label = graph.edge(e)!;
         graph.removeEdge(e);
@@ -24,7 +24,7 @@ function run(graph: Graph<GraphLabel, NodeLabel, EdgeLabel>): void {
     }
 }
 
-function dfsFAS(graph: Graph<GraphLabel, NodeLabel, EdgeLabel>): Edge[] {
+function dfsFAS(graph: Graph<GraphLabel, NodeLabel, EdgeLabel>, oldGraph: Graph|null): Edge[] {
     const fas: Edge[] = [];
     const stack: { [key: string]: boolean } = {};
     const visited: { [key: string]: boolean } = {};
@@ -45,7 +45,31 @@ function dfsFAS(graph: Graph<GraphLabel, NodeLabel, EdgeLabel>): Edge[] {
         delete stack[v];
     }
 
-    graph.nodes().forEach(dfs);
+    function dfsDynamic(v: string) {
+        if (Object.hasOwn(visited, v)) {
+            return;
+        }
+        visited[v] = true;
+        stack[v] = true;
+        graph.outEdges(v)?.forEach(e => {
+            if (Object.hasOwn(stack, e.w) ||
+                (oldGraph!.node(v)?.rank > oldGraph!.node(e.w)?.rank) && isReachedFromStartWithoutEdge(graph, e.w, e)) {
+                fas.push(e);
+            } else {
+                dfsDynamic(e.w);
+            }
+        });
+        delete stack[v];
+    }
+
+    let dfsFn = dfs;
+    if (oldGraph && typeof oldGraph.node === 'function') {
+        dfsFn = dfsDynamic;
+    }
+
+    graph.sources().forEach(dfsFn);
+    graph.nodes().forEach(dfsFn);
+
     return fas;
 }
 
@@ -62,3 +86,27 @@ function undo(graph: Graph<GraphLabel, NodeLabel, EdgeLabel>): void {
         }
     });
 }
+
+function isReachedFromStartWithoutEdge(graph: Graph, node: string, ignoreEdge: Edge) {
+    // reverse dfs from the given node to 'Start' without using edge e
+    const localVisited = new Set<string>();
+
+    function reverseDfs(v: string): boolean {
+        if (graph.sources().includes(v)) {
+            return true;
+        }
+        localVisited.add(v);
+        for (const e of graph.inEdges(v) ?? []) {
+            // do not use ignored edge
+            // do not visit the same node twice
+            if (!(e.v === ignoreEdge.v && e.w === ignoreEdge.w)
+                && !localVisited.has(e.v)) {
+                if (reverseDfs(e.v)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    return reverseDfs(node);
+}

lib/layout.ts

@@ -10,7 +10,7 @@ import * as coordinateSystem from "./coordinate-system";
 import order from "./order";
 import {position} from "./position";
 import {Graph} from "./graph-lib";
-import type {Edge, EdgeLabel, GraphLabel, LayoutOptions, NodeLabel, Point} from "./types";
+import type {Edge, EdgeLabel, GraphLabel, LayoutOptions, NodeCollection, NodeLabel, Point} from "./types";
 
 interface SelfEdge {
     e: Edge;
@@ -34,6 +34,8 @@ interface EdgeProxyNodeLabel extends Omit<NodeLabel, 'e'> {
     e: Edge;
 }
 
+let _oldGraph: Graph<GraphLabel, NodeLabel, EdgeLabel> | null = null;
+let _rawOldNodes: NodeCollection = null;
 
 export function layout(g: Graph<GraphLabel, NodeLabel, EdgeLabel>, opts: LayoutOptions = {}): Graph<GraphLabel, NodeLabel, EdgeLabel> {
     recursiveClusterLayout(g, util.notime, opts);
@@ -317,9 +319,13 @@ function runLayout(
     time: <T>(name: string, fn: () => T) => T,
     opts: LayoutOptions
 ): void {
+    if (opts?.useDynamic === false) {
+        _oldGraph = null;
+        _rawOldNodes = null;
+    }
     time("    makeSpaceForEdgeLabels", () => makeSpaceForEdgeLabels(g));
     time("    removeSelfEdges", () => removeSelfEdges(g));
-    time("    acyclic", () => acyclic.run(g));
+    time("    acyclic", () => acyclic.run(g, _oldGraph));
     time("    nestingGraph.run", () => nestingGraph.run(g));
     time("    rank", () => rank(util.asNonCompoundGraph(g)));
     time("    injectEdgeLabelProxies", () => injectEdgeLabelProxies(g));
@@ -331,11 +337,12 @@ function runLayout(
     time("    normalize.run", () => normalize.run(g));
     time("    parentDummyChains", () => parentDummyChains(g));
     time("    addBorderSegments", () => addBorderSegments(g));
-    time("    order", () => order(g, opts));
+    time("    order", () => order(g, opts, _rawOldNodes));
     time("    insertSelfEdges", () => insertSelfEdges(g));
     time("    adjustCoordinateSystem", () => coordinateSystem.adjust(g));
-    time("    position", () => position(g));
+    time("    position", () => position(g, opts.corePath));
     time("    positionSelfEdges", () => positionSelfEdges(g));
+    _rawOldNodes = JSON.parse(JSON.stringify(g._nodes));
     time("    removeBorderNodes", () => removeBorderNodes(g));
     time("    normalize.undo", () => normalize.undo(g));
     time("    fixupEdgeLabelCoords", () => fixupEdgeLabelCoords(g));
@@ -344,6 +351,7 @@ function runLayout(
     time("    assignNodeIntersects", () => assignNodeIntersects(g));
     time("    reversePoints", () => reversePointsForReversedEdges(g));
     time("    acyclic.undo", () => acyclic.undo(g));
+    _oldGraph = g;
 }
 
 /*

lib/order/index.ts

@@ -7,10 +7,10 @@ import buildLayerGraph from "./build-layer-graph";
 import addSubgraphConstraints from "./add-subgraph-constraints";
 import {Graph} from "../graph-lib";
 import * as util from "../util";
-import type {Graph as GraphType, OrderConstraint} from '../types';
+import type {Graph as GraphType, NodeCollection, OrderConstraint} from '../types';
 
 interface OrderOptions {
-    customOrder?: (graph: GraphType, order: (g: GraphType, opts: OrderOptions) => void) => void;
+    customOrder?: (graph: GraphType, order: (g: GraphType, opts: OrderOptions, oldNodes: NodeCollection) => void) => void;
     disableOptimalOrderHeuristic?: boolean;
     constraints?: OrderConstraint[];
 }
@@ -30,7 +30,7 @@ interface OrderOptions {
  *    1. Graph nodes will have an "order" attribute based on the results of the
  *       algorithm.
  */
-export default function order(graph: GraphType, opts: OrderOptions = {}): void {
+export default function order(graph: GraphType, opts: OrderOptions = {}, oldNodes: NodeCollection): void {
     if (typeof opts.customOrder === 'function') {
         opts.customOrder(graph, order);
         return;
@@ -40,7 +40,7 @@ export default function order(graph: GraphType, opts: OrderOptions = {}): void {
     const downLayerGraphs = buildLayerGraphs(graph, util.range(1, maxRank + 1), "inEdges");
     const upLayerGraphs = buildLayerGraphs(graph, util.range(maxRank - 1, -1, -1), "outEdges");
 
-    let layering = initOrder(graph);
+    let layering = initOrder(graph, oldNodes);
     assignOrder(graph, layering);
 
     if (opts.disableOptimalOrderHeuristic) {
@@ -52,7 +52,7 @@ export default function order(graph: GraphType, opts: OrderOptions = {}): void {
 
     const constraints = opts.constraints || [];
     for (let i = 0, lastBest = 0; lastBest < 4; ++i, ++lastBest) {
-        sweepLayerGraphs(i % 2 ? downLayerGraphs : upLayerGraphs, i % 4 >= 2, constraints);
+        sweepLayerGraphs(i % 2 ? downLayerGraphs : upLayerGraphs, i % 4 >= 2, constraints, oldNodes);
 
         layering = util.buildLayerMatrix(graph);
         const cc = crossCount(graph, layering);
@@ -104,13 +104,17 @@ function buildLayerGraphs(graph: GraphType, ranks: number[], relationship: "inEd
     });
 }
 
-function sweepLayerGraphs(layerGraphs: GraphType[], biasRight: boolean, constraints: OrderConstraint[]): void {
+function sweepLayerGraphs(layerGraphs: GraphType[], switchBias: boolean, constraints: OrderConstraint[], oldNodes: NodeCollection): void {
+    let biasRight: boolean = true;
     const cg = new Graph() as GraphType;
     layerGraphs.forEach(function (lg) {
         constraints.forEach(con => cg.setEdge(con.left, con.right));
 
         const root = (lg.graph() as { root: string }).root;
-        const sorted = sortSubgraph(lg, root, cg, biasRight);
+        const {result: sorted, usedBias} = sortSubgraph(lg, root, cg, oldNodes, biasRight);
+        if (switchBias && usedBias) {
+            biasRight = !biasRight;
+        }
         sorted.vs.forEach((v, i) => lg.node(v).order = i);
         addSubgraphConstraints(lg, cg, sorted.vs);
     });

lib/order/init-order.ts

@@ -1,5 +1,5 @@
 import * as util from "../util";
-import type {Graph} from '../types';
+import type {Graph, NodeCollection} from '../types';
 
 /*
  * Assigns an initial order value for each node by performing a DFS search
@@ -12,7 +12,7 @@ import type {Graph} from '../types';
  * Returns a layering matrix with an array per layer and each layer sorted by
  * the order of its nodes.
  */
-export default function initOrder(graph: Graph): string[][] {
+export default function initOrder(graph: Graph, oldNodes: NodeCollection): string[][] {
     const visited: { [key: string]: boolean } = {};
     const simpleNodes = graph.nodes().filter(v => !graph.children(v).length);
     const simpleNodesRanks = simpleNodes.map(v => graph.node(v).rank);
@@ -26,12 +26,20 @@ export default function initOrder(graph: Graph): string[][] {
         layers[node.rank]!.push(v);
         const successors = graph.successors(v);
         if (successors) {
-            successors.forEach(dfs);
+            const sortedSuccessors = [...successors].sort((a: string, b: string) => compareOldOrder(a, b));
+            sortedSuccessors.forEach(dfs);
         }
     }
 
     const orderedVs = simpleNodes.sort((a, b) => graph.node(a).rank - graph.node(b).rank);
     orderedVs.forEach(dfs);
 
+    function compareOldOrder(a: string, b: string) {
+        const nodeA = graph.node(a);
+        const nodeB = graph.node(b);
+
+        return util.compareByOldOrder(oldNodes, nodeA, nodeB);
+    }
+
     return layers;
 }

lib/order/sort-subgraph.ts

@@ -1,7 +1,7 @@
 import barycenter from "./barycenter";
-import resolveConflicts from "./resolve-conflicts";
+import resolveConflicts, {ResolvedEntry} from "./resolve-conflicts";
 import sort from "./sort";
-import type {Graph} from '../types';
+import type {Graph, NodeCollection} from '../types';
 
 interface SubgraphResult {
     vs: string[];
@@ -15,7 +15,7 @@ interface BarycenterEntry {
     weight?: number;
 }
 
-export default function sortSubgraph(graph: Graph, v: string, constraintGraph: Graph, biasRight?: boolean): SubgraphResult {
+export default function sortSubgraph(graph: Graph, v: string, constraintGraph: Graph, oldNodes: NodeCollection, biasRight?: boolean): {result: SubgraphResult, usedBias: boolean} {
     let movable = graph.children(v);
     const node = graph.node(v);
     const bl: string | undefined = node ? (node.borderLeft) : undefined;
@@ -29,7 +29,7 @@ export default function sortSubgraph(graph: Graph, v: string, constraintGraph: G
     const barycenters = barycenter(graph, movable);
     barycenters.forEach(entry => {
         if (graph.children(entry.v).length) {
-            const subgraphResult = sortSubgraph(graph, entry.v, constraintGraph, biasRight);
+            const {result: subgraphResult} = sortSubgraph(graph, entry.v, constraintGraph, oldNodes, biasRight);
             subgraphs[entry.v] = subgraphResult;
             if (Object.hasOwn(subgraphResult, "barycenter")) {
                 mergeBarycenters(entry, subgraphResult);
@@ -40,7 +40,41 @@ export default function sortSubgraph(graph: Graph, v: string, constraintGraph: G
     const entries = resolveConflicts(barycenters, constraintGraph);
     expandSubgraphs(entries, subgraphs);
 
-    const result = sort(entries, biasRight);
+    const reversedPairs: Record<string, ResolvedEntry> = {};
+    let usedBias = false;
+    for (let i = 0; i < entries.length; i++) {
+        for (let j = i + 1; j < entries.length; j++) {
+            if (!entries[i] || !entries[j] || !entries[i]?.barycenter || !entries[j]?.barycenter) {
+                continue;
+            }
+            if (entries[i]?.barycenter === entries[j]!.barycenter) {
+                const nameI = entries[i]?.vs[0] ?? "";
+                const nameJ = entries[j]?.vs[0] ?? "";
+                const nodeI = graph.node(nameI);
+                const nodeJ = graph.node(nameJ);
+
+                if (nodeI.dummy === "edge" && nodeJ.dummy === "edge" &&
+                    nodeI.edgeObj?.v === nodeJ.edgeObj?.v &&
+                    nodeI.edgeObj?.w === nodeJ.edgeObj?.w) {
+                    if (nodeI.edgeLabel.reversed) {
+                        reversedPairs[nameJ] = entries[i]!;
+                        entries.splice(i, 1);
+                        i--;
+                        break;
+                    } else {
+                        reversedPairs[nameI] = entries[j]!;
+                        entries.splice(j, 1);
+                        j--;
+                    }
+
+                } else {
+                    usedBias = true;
+                }
+            }
+        }
+    }
+
+    const result = sort(entries, reversedPairs, oldNodes, graph, biasRight);
 
     if (bl && br) {
         result.vs = [bl, result.vs, br].flat(1) as string[];
@@ -59,7 +93,7 @@ export default function sortSubgraph(graph: Graph, v: string, constraintGraph: G
         }
     }
 
-    return result;
+    return {result: result, usedBias: usedBias};
 }
 
 function expandSubgraphs(entries: { vs: string[] }[], subgraphs: { [key: string]: SubgraphResult }): void {

lib/order/sort.ts

@@ -1,4 +1,6 @@
 import * as util from "../util";
+import type {Graph, NodeCollection} from '../types';
+import {ResolvedEntry} from "./resolve-conflicts";
 
 interface SortEntry {
     vs: string[];
@@ -13,7 +15,7 @@ interface SortResult {
     weight?: number;
 }
 
-export default function sort(entries: SortEntry[], biasRight?: boolean): SortResult {
+export default function sort(entries: SortEntry[], reversedPairs: Record<string, ResolvedEntry>, oldNodes: NodeCollection, graph: Graph, biasRight?: boolean): SortResult {
     const parts = util.partition(entries, entry => {
         return Object.hasOwn(entry, "barycenter");
     });
@@ -24,7 +26,13 @@ export default function sort(entries: SortEntry[], biasRight?: boolean): SortRes
     let weight = 0;
     let vsIndex = 0;
 
-    sortable.sort(compareWithBias(!!biasRight));
+    sortable.sort(compareWithOldOrder(graph, oldNodes, !!biasRight));
+
+    // re-inserts the links, that are already in sortable but reversed, next to its reverse counterpart
+    for (const [key, value] of Object.entries(reversedPairs)) {
+        const keyIndex = sortable.findIndex(entry => entry.vs[0] === key);
+        sortable.splice(keyIndex + 1, 0, value);
+    }
 
     vsIndex = consumeUnsortable(vs, unsortable, vsIndex);
 
@@ -54,14 +62,23 @@ function consumeUnsortable(vs: string[][], unsortable: SortEntry[], index: numbe
     return index;
 }
 
-function compareWithBias(bias: boolean): (entryV: SortEntry, entryW: SortEntry) => number {
+function compareWithOldOrder(graph: Graph, oldNodes: NodeCollection, bias: boolean): (entryV: SortEntry, entryW: SortEntry) => number {
     return (entryV: SortEntry, entryW: SortEntry) => {
         if (entryV.barycenter! < entryW.barycenter!) {
             return -1;
         } else if (entryV.barycenter! > entryW.barycenter!) {
             return 1;
         }
 
+        if (typeof entryV.vs[0] === "string" || typeof entryW.vs[0] === "string") {
+            const nodeV = graph.node(entryV.vs[0]!);
+            const nodeW = graph.node(entryW.vs[0]!);
+            const byOldOrder = util.compareByOldOrder(oldNodes, nodeV, nodeW);
+            if (byOldOrder !== 0) {
+                return byOldOrder;
+            }
+        }
+
         return !bias ? entryV.i - entryW.i : entryW.i - entryV.i;
     };
 }