@antv/layout 1.2.14-beta.8 → 2.0.0-alpha.1

package/src/antv-dagre/rank/feasible-tree.ts

@@ -0,0 +1,179 @@
+import type { EdgeData, ID } from '../../types';
+import { DagreGraph, GraphEdge } from '../graph';
+import { minBy } from '../util';
+import { slack } from './util';
+
+/*
+ * Constructs a spanning tree with tight edges and adjusted the input node's
+ * ranks to achieve this. A tight edge is one that is has a length that matches
+ * its "minlen" attribute.
+ *
+ * The basic structure for this function is derived from Gansner, et al., "A
+ * Technique for Drawing Directed Graphs."
+ *
+ * Pre-conditions:
+ *
+ *    1. Graph must be a DAG.
+ *    2. Graph must be connected.
+ *    3. Graph must have at least one node.
+ *    5. Graph nodes must have been previously assigned a "rank" property that
+ *       respects the "minlen" property of incident edges.
+ *    6. Graph edges must have a "minlen" property.
+ *
+ * Post-conditions:
+ *
+ *    - Graph nodes will have their rank adjusted to ensure that all edges are
+ *      tight.
+ *
+ * Returns a tree (undirected graph) that is constructed using only "tight"
+ * edges.
+ */
+const feasibleTree = (g: DagreGraph) => {
+  const t = new DagreGraph({
+    tree: [],
+  });
+
+  // Choose arbitrary node from which to start our tree
+  const start = g.getAllNodes()[0];
+  const size = g.getAllNodes().length;
+  t.addNode(start);
+
+  let edge: GraphEdge<EdgeData>;
+  let delta: number;
+  while (tightTree(t, g) < size) {
+    edge = findMinSlackEdge(t, g);
+    delta = t.hasNode(edge.source) ? slack(g, edge) : -slack(g, edge);
+    shiftRanks(t, g, delta);
+  }
+
+  return t;
+};
+
+/*
+ * Finds a maximal tree of tight edges and returns the number of nodes in the
+ * tree.
+ */
+const tightTree = (t: DagreGraph, g: DagreGraph) => {
+  const dfs = (v: ID) => {
+    g.getRelatedEdges(v, 'both').forEach((e) => {
+      const edgeV = e.source;
+      const w = v === edgeV ? e.target : edgeV;
+      if (!t.hasNode(w) && !slack(g, e)) {
+        t.addNode({
+          id: w,
+          data: {},
+        });
+        t.addEdge({
+          id: e.id,
+          source: v,
+          target: w,
+          data: {},
+        });
+        dfs(w);
+      }
+    });
+  };
+
+  t.getAllNodes().forEach((n) => dfs(n.id));
+  return t.getAllNodes().length;
+};
+
+/*
+ * Constructs a spanning tree with tight edges and adjusted the input node's
+ * ranks to achieve this. A tight edge is one that is has a length that matches
+ * its "minlen" attribute.
+ *
+ * The basic structure for this function is derived from Gansner, et al., "A
+ * Technique for Drawing Directed Graphs."
+ *
+ * Pre-conditions:
+ *
+ *    1. Graph must be a DAG.
+ *    2. Graph must be connected.
+ *    3. Graph must have at least one node.
+ *    5. Graph nodes must have been previously assigned a "rank" property that
+ *       respects the "minlen" property of incident edges.
+ *    6. Graph edges must have a "minlen" property.
+ *
+ * Post-conditions:
+ *
+ *    - Graph nodes will have their rank adjusted to ensure that all edges are
+ *      tight.
+ *
+ * Returns a tree (undirected graph) that is constructed using only "tight"
+ * edges.
+ */
+const feasibleTreeWithLayer = (g: DagreGraph) => {
+  const t = new DagreGraph({ tree: [] });
+
+  // Choose arbitrary node from which to start our tree
+  const start = g.getAllNodes()[0];
+  const size = g.getAllNodes().length;
+  t.addNode(start);
+
+  let edge: GraphEdge<EdgeData>;
+  let delta: number;
+  while (tightTreeWithLayer(t, g)! < size) {
+    edge = findMinSlackEdge(t, g);
+    delta = t.hasNode(edge.source) ? slack(g, edge) : -slack(g, edge);
+    shiftRanks(t, g, delta);
+  }
+
+  return t;
+};
+
+/*
+ * Finds a maximal tree of tight edges and returns the number of nodes in the
+ * tree.
+ */
+const tightTreeWithLayer = (t: DagreGraph, g: DagreGraph) => {
+  const dfs = (v: ID) => {
+    g.getRelatedEdges(v, 'both')?.forEach((e) => {
+      const edgeV = e.source;
+      const w = v === edgeV ? e.target : edgeV;
+      // 对于指定layer的，直接加入tight-tree，不参与调整
+      if (
+        !t.hasNode(w) &&
+        (g.getNode(w)!.data.layer !== undefined || !slack(g, e))
+      ) {
+        t.addNode({
+          id: w,
+          data: {},
+        });
+        t.addEdge({
+          id: e.id,
+          source: v,
+          target: w,
+          data: {},
+        });
+        dfs(w);
+      }
+    });
+  };
+
+  t.getAllNodes().forEach((n) => dfs(n.id));
+  return t.getAllNodes().length;
+};
+
+/*
+ * Finds the edge with the smallest slack that is incident on tree and returns
+ * it.
+ */
+const findMinSlackEdge = (t: DagreGraph, g: DagreGraph) => {
+  return minBy(g.getAllEdges(), (e) => {
+    if (t.hasNode(e.source) !== t.hasNode(e.target)) {
+      return slack(g, e);
+    }
+    return Infinity;
+  });
+};
+
+const shiftRanks = (t: DagreGraph, g: DagreGraph, delta: number) => {
+  t.getAllNodes().forEach((tn) => {
+    const v = g.getNode(tn.id);
+    if (!v.data.rank) v.data.rank = 0;
+    v.data.rank! += delta;
+  });
+};
+
+export { feasibleTree, feasibleTreeWithLayer };

package/src/antv-dagre/rank/index.ts

@@ -0,0 +1,55 @@
+import { DagreGraph } from '../graph';
+import { feasibleTreeWithLayer as feasibleTree } from './feasible-tree';
+import { networkSimplex } from './network-simplex';
+import { longestPath, longestPathWithLayer } from './util';
+
+/*
+ * Assigns a rank to each node in the input graph that respects the "minlen"
+ * constraint specified on edges between nodes.
+ *
+ * This basic structure is derived from Gansner, et al., "A Technique for
+ * Drawing Directed Graphs."
+ *
+ * Pre-conditions:
+ *
+ *    1. Graph must be a connected DAG
+ *    2. Graph nodes must be objects
+ *    3. Graph edges must have "weight" and "minlen" attributes
+ *
+ * Post-conditions:
+ *
+ *    1. Graph nodes will have a "rank" attribute based on the results of the
+ *       algorithm. Ranks can start at any index (including negative), we'll
+ *       fix them up later.
+ */
+export const rank = (
+  g: DagreGraph,
+  ranker: 'network-simplex' | 'tight-tree' | 'longest-path',
+) => {
+  switch (ranker) {
+    case 'network-simplex':
+      networkSimplexRanker(g);
+      break;
+    case 'tight-tree':
+      tightTreeRanker(g);
+      break;
+    case 'longest-path':
+      longestPathRanker(g);
+      break;
+    // default: networkSimplexRanker(g);
+    default:
+      tightTreeRanker(g);
+  }
+};
+
+// A fast and simple ranker, but results are far from optimal.
+const longestPathRanker = longestPath;
+
+const tightTreeRanker = (g: DagreGraph) => {
+  longestPathWithLayer(g);
+  feasibleTree(g);
+};
+
+const networkSimplexRanker = (g: DagreGraph) => {
+  networkSimplex(g);
+};

package/src/antv-dagre/rank/network-simplex.ts

@@ -0,0 +1,282 @@
+import type { EdgeData, ID, NodeData } from '../../types';
+import { DagreGraph } from '../graph';
+import { dfs, minBy, simplify } from '../util';
+import { feasibleTree } from './feasible-tree';
+import { longestPath as initRank, slack } from './util';
+
+/*
+ * The network simplex algorithm assigns ranks to each node in the input graph
+ * and iteratively improves the ranking to reduce the length of edges.
+ *
+ * Preconditions:
+ *
+ *    1. The input graph must be a DAG.
+ *    2. All nodes in the graph must have an object value.
+ *    3. All edges in the graph must have "minlen" and "weight" attributes.
+ *
+ * Postconditions:
+ *
+ *    1. All nodes in the graph will have an assigned "rank" attribute that has
+ *       been optimized by the network simplex algorithm. Ranks start at 0.
+ *
+ *
+ * A rough sketch of the algorithm is as follows:
+ *
+ *    1. Assign initial ranks to each node. We use the longest path algorithm,
+ *       which assigns ranks to the lowest position possible. In general this
+ *       leads to very wide bottom ranks and unnecessarily long edges.
+ *    2. Construct a feasible tight tree. A tight tree is one such that all
+ *       edges in the tree have no slack (difference between length of edge
+ *       and minlen for the edge). This by itself greatly improves the assigned
+ *       rankings by shorting edges.
+ *    3. Iteratively find edges that have negative cut values. Generally a
+ *       negative cut value indicates that the edge could be removed and a new
+ *       tree edge could be added to produce a more compact graph.
+ *
+ * Much of the algorithms here are derived from Gansner, et al., "A Technique
+ * for Drawing Directed Graphs." The structure of the file roughly follows the
+ * structure of the overall algorithm.
+ */
+export const networkSimplex = (og: DagreGraph) => {
+  const g = simplify(og);
+  initRank(g);
+  const t = feasibleTree(g);
+  initLowLimValues(t);
+  initCutValues(t, g);
+
+  let e: EdgeData | undefined;
+  let f: EdgeData;
+  while ((e = leaveEdge(t))) {
+    f = enterEdge(t, g, e);
+    exchangeEdges(t, g, e, f);
+  }
+};
+
+/*
+ * Initializes cut values for all edges in the tree.
+ */
+export const initCutValues = (t: DagreGraph, g: DagreGraph) => {
+  let vs = dfs(t, t.getAllNodes(), 'post', false);
+  vs = vs.slice(0, vs?.length - 1);
+  vs.forEach((v: ID) => {
+    assignCutValue(t, g, v);
+  });
+};
+
+const assignCutValue = (t: DagreGraph, g: DagreGraph, child: ID) => {
+  const childLab = t.getNode(child)!;
+  const parent = childLab.data.parent! as ID;
+
+  // FIXME: use undirected edge?
+  const edge = t
+    .getRelatedEdges(child, 'both')
+    .find((e) => e.target === parent || e.source === parent)!;
+  edge.data.cutvalue = calcCutValue(t, g, child);
+};
+
+/*
+ * Given the tight tree, its graph, and a child in the graph calculate and
+ * return the cut value for the edge between the child and its parent.
+ */
+export const calcCutValue = (t: DagreGraph, g: DagreGraph, child: ID) => {
+  const childLab = t.getNode(child)!;
+  const parent = childLab.data.parent as ID;
+  // True if the child is on the tail end of the edge in the directed graph
+  let childIsTail = true;
+  // The graph's view of the tree edge we're inspecting
+
+  let graphEdge = g
+    .getRelatedEdges(child, 'out')
+    .find((e) => e.target === parent)!;
+  // The accumulated cut value for the edge between this node and its parent
+  let cutValue = 0;
+
+  if (!graphEdge) {
+    childIsTail = false;
+    graphEdge = g
+      .getRelatedEdges(parent, 'out')
+      .find((e) => e.target === child)!;
+  }
+
+  cutValue = graphEdge.data.weight!;
+
+  g.getRelatedEdges(child, 'both').forEach((e) => {
+    const isOutEdge = e.source === child;
+    const other = isOutEdge ? e.target : e.source;
+
+    if (other !== parent) {
+      const pointsToHead = isOutEdge === childIsTail;
+      const otherWeight = e.data.weight!;
+
+      cutValue += pointsToHead ? otherWeight : -otherWeight;
+      if (isTreeEdge(t, child, other)) {
+        // FIXME: use undirected edge?
+        const otherCutValue = t
+          .getRelatedEdges(child, 'both')
+          .find((e) => e.source === other || e.target === other)!.data
+          .cutvalue!;
+        cutValue += pointsToHead ? -otherCutValue : otherCutValue;
+      }
+    }
+  });
+
+  return cutValue;
+};
+
+export const initLowLimValues = (
+  tree: DagreGraph,
+  root: ID = tree.getAllNodes()[0].id,
+) => {
+  dfsAssignLowLim(tree, {}, 1, root);
+};
+
+const dfsAssignLowLim = (
+  tree: DagreGraph,
+  visited: Record<ID, boolean>,
+  nextLim: number,
+  v: ID,
+  parent?: ID,
+) => {
+  const low = nextLim;
+  let useNextLim = nextLim;
+  const label = tree.getNode(v)!;
+
+  visited[v] = true;
+  tree.getNeighbors(v)?.forEach((w) => {
+    if (!visited[w.id]) {
+      useNextLim = dfsAssignLowLim(tree, visited, useNextLim, w.id, v);
+    }
+  });
+
+  label.data.low = low;
+  label.data.lim = useNextLim++;
+  if (parent) {
+    label.data.parent = parent;
+  } else {
+    // TODO should be able to remove this when we incrementally update low lim
+    delete label.data.parent;
+  }
+
+  return useNextLim;
+};
+
+export const leaveEdge = (tree: DagreGraph) => {
+  return tree.getAllEdges().find((e) => {
+    return e.data.cutvalue! < 0;
+  });
+};
+
+export const enterEdge = (t: DagreGraph, g: DagreGraph, edge: EdgeData) => {
+  let v = edge.source;
+  let w = edge.target;
+
+  // For the rest of this function we assume that v is the tail and w is the
+  // head, so if we don't have this edge in the graph we should flip it to
+  // match the correct orientation.
+  if (!g.getRelatedEdges(v, 'out').find((e) => e.target === w)) {
+    v = edge.target;
+    w = edge.source;
+  }
+
+  const vLabel = t.getNode(v)!;
+  const wLabel = t.getNode(w)!;
+  let tailLabel = vLabel;
+  let flip = false;
+
+  // If the root is in the tail of the edge then we need to flip the logic that
+  // checks for the head and tail nodes in the candidates function below.
+  if (vLabel.data.lim! > wLabel.data.lim!) {
+    tailLabel = wLabel;
+    flip = true;
+  }
+
+  const candidates = g.getAllEdges().filter((edge) => {
+    return (
+      flip === isDescendant(t.getNode(edge.source), tailLabel) &&
+      flip !== isDescendant(t.getNode(edge.target), tailLabel)
+    );
+  });
+
+  return minBy(candidates, (edge) => {
+    return slack(g, edge);
+  });
+};
+
+/**
+ *
+ * @param t
+ * @param g
+ * @param e edge to remove
+ * @param f edge to add
+ */
+export const exchangeEdges = (
+  t: DagreGraph,
+  g: DagreGraph,
+  e: EdgeData,
+  f: EdgeData,
+) => {
+  // FIXME: use undirected edge?
+  const existed = t
+    .getRelatedEdges(e.source, 'both')
+    .find((edge) => edge.source === e.target || edge.target === e.target);
+  if (existed) {
+    t.removeEdge(existed.id);
+  }
+
+  t.addEdge({
+    id: `e${Math.random()}`,
+    source: f.source,
+    target: f.target,
+    data: {},
+  });
+
+  initLowLimValues(t);
+  initCutValues(t, g);
+  updateRanks(t, g);
+};
+
+const updateRanks = (t: DagreGraph, g: DagreGraph) => {
+  const root = t.getAllNodes().find((v) => {
+    return !v.data.parent;
+  })!;
+
+  let vs = dfs(t, root, 'pre', false);
+  vs = vs.slice(1);
+  vs.forEach((v: ID) => {
+    const parent = t.getNode(v).data.parent as ID;
+    let edge = g.getRelatedEdges(v, 'out').find((e) => e.target === parent);
+    // let edge = g.edgeFromArgs(v, parent);
+    let flipped = false;
+
+    if (!edge && g.hasNode(parent)) {
+      // edge = g.edgeFromArgs(parent, v)!;
+      edge = g.getRelatedEdges(parent, 'out').find((e) => e.target === v);
+      flipped = true;
+    }
+
+    g.getNode(v).data.rank =
+      ((g.hasNode(parent) && g.getNode(parent).data.rank!) || 0) +
+      (flipped ? edge?.data.minlen! : -edge?.data.minlen!);
+  });
+};
+
+/*
+ * Returns true if the edge is in the tree.
+ */
+const isTreeEdge = (tree: DagreGraph, u: ID, v: ID) => {
+  // FIXME: use undirected edge?
+  return tree
+    .getRelatedEdges(u, 'both')
+    .find((e) => e.source === v || e.target === v);
+};
+
+/*
+ * Returns true if the specified node is descendant of the root node per the
+ * assigned low and lim attributes in the tree.
+ */
+const isDescendant = (vLabel: NodeData, rootLabel: NodeData) => {
+  return (
+    rootLabel.data.low! <= vLabel.data.lim! &&
+    vLabel.data.lim! <= rootLabel.data.lim!
+  );
+};

package/src/antv-dagre/rank/util.ts

@@ -0,0 +1,157 @@
+import type { EdgeData, ID } from '../../types';
+import { DagreGraph, GraphEdge } from '../graph';
+
+/*
+ * Initializes ranks for the input graph using the longest path algorithm. This
+ * algorithm scales well and is fast in practice, it yields rather poor
+ * solutions. Nodes are pushed to the lowest layer possible, leaving the bottom
+ * ranks wide and leaving edges longer than necessary. However, due to its
+ * speed, this algorithm is good for getting an initial ranking that can be fed
+ * into other algorithms.
+ *
+ * This algorithm does not normalize layers because it will be used by other
+ * algorithms in most cases. If using this algorithm directly, be sure to
+ * run normalize at the end.
+ *
+ * Pre-conditions:
+ *
+ *    1. Input graph is a DAG.
+ *    2. Input graph node labels can be assigned properties.
+ *
+ * Post-conditions:
+ *
+ *    1. Each node will be assign an (unnormalized) "rank" property.
+ */
+const longestPath = (g: DagreGraph) => {
+  const visited: Record<ID, boolean> = {};
+
+  const dfs = (v: ID) => {
+    const label = g.getNode(v)!;
+    if (!label) return 0;
+    if (visited[v]) {
+      return label.data.rank!;
+    }
+    visited[v] = true;
+
+    let rank: number;
+
+    g.getRelatedEdges(v, 'out')?.forEach((e) => {
+      const wRank = dfs(e.target);
+      const minLen = e.data.minlen!;
+      const r = wRank - minLen;
+      if (r) {
+        if (rank === undefined || r < rank) {
+          rank = r;
+        }
+      }
+    });
+
+    if (!rank!) {
+      rank = 0;
+    }
+
+    label.data.rank = rank;
+    return rank;
+  };
+
+  g.getAllNodes()
+    .filter((n) => g.getRelatedEdges(n.id, 'in').length === 0)
+    .forEach((source) => dfs(source.id));
+};
+
+const longestPathWithLayer = (g: DagreGraph) => {
+  // 用longest path，找出最深的点
+  const visited: Record<ID, boolean> = {};
+  let minRank: number;
+
+  const dfs = (v: ID) => {
+    const label = g.getNode(v)!;
+    if (!label) return 0;
+    if (visited[v]) {
+      return label.data.rank!;
+    }
+    visited[v] = true;
+
+    let rank: number;
+
+    g.getRelatedEdges(v, 'out')?.forEach((e) => {
+      const wRank = dfs(e.target);
+      const minLen = e.data.minlen!;
+      const r = wRank - minLen;
+      if (r) {
+        if (rank === undefined || r < rank) {
+          rank = r;
+        }
+      }
+    });
+
+    if (!rank!) {
+      rank = 0;
+    }
+
+    if (minRank === undefined || rank < minRank) {
+      minRank = rank;
+    }
+
+    label.data.rank = rank;
+    return rank;
+  };
+
+  g.getAllNodes()
+    .filter((n) => g.getRelatedEdges(n.id, 'in').length === 0)
+    .forEach((source) => {
+      if (source) dfs(source.id);
+    });
+
+  if (minRank! === undefined) {
+    minRank = 0;
+  }
+
+  // minRank += 1; // NOTE: 最小的层级是dummy root，+1
+
+  // forward一遍，赋值层级
+  const forwardVisited: Record<string, boolean> = {};
+  const dfsForward = (v: ID, nextRank: number) => {
+    const label = g.getNode(v)!;
+
+    const currRank = !isNaN(label.data.layer!) ? label.data.layer! : nextRank;
+
+    // 没有指定，取最大值
+    if (label.data.rank === undefined || label.data.rank! < currRank) {
+      label.data.rank = currRank;
+    }
+
+    if (forwardVisited[v]) return;
+    forwardVisited[v] = true;
+
+    // DFS遍历子节点
+    g.getRelatedEdges(v, 'out')?.forEach((e) => {
+      dfsForward(e.target, currRank + e.data.minlen!);
+    });
+  };
+
+  // 指定层级的，更新下游
+  g.getAllNodes().forEach((n) => {
+    const label = n.data;
+    if (!label) return;
+    if (!isNaN(label.layer!)) {
+      dfsForward(n.id, label.layer!); // 默认的dummy root所在层的rank是-1
+    } else {
+      label.rank! -= minRank;
+    }
+  });
+};
+
+/*
+ * Returns the amount of slack for the given edge. The slack is defined as the
+ * difference between the length of the edge and its minimum length.
+ */
+const slack = (g: DagreGraph, e: GraphEdge<EdgeData>) => {
+  return (
+    g.getNode(e.target).data.rank! -
+    g.getNode(e.source).data.rank! -
+    e.data.minlen!
+  );
+};
+
+export { longestPath, longestPathWithLayer, slack };