@antv/layout 1.2.14-beta.9 → 2.0.0-alpha.2

package/src/algorithm/antv-dagre/nesting-graph.ts

@@ -0,0 +1,184 @@
+import type { ID } from '../../types';
+import { DagreGraph } from './graph';
+import { addBorderNode, addDummyNode } from './util';
+
+/*
+ * A nesting graph creates dummy nodes for the tops and bottoms of subgraphs,
+ * adds appropriate edges to ensure that all cluster nodes are placed between
+ * these boundries, and ensures that the graph is connected.
+ *
+ * In addition we ensure, through the use of the minlen property, that nodes
+ * and subgraph border nodes to not end up on the same rank.
+ *
+ * Preconditions:
+ *
+ *    1. Input graph is a DAG
+ *    2. Nodes in the input graph has a minlen attribute
+ *
+ * Postconditions:
+ *
+ *    1. Input graph is connected.
+ *    2. Dummy nodes are added for the tops and bottoms of subgraphs.
+ *    3. The minlen attribute for nodes is adjusted to ensure nodes do not
+ *       get placed on the same rank as subgraph border nodes.
+ *
+ * The nesting graph idea comes from Sander, "Layout of Compound Directed
+ * Graphs."
+ */
+const run = (g: DagreGraph) => {
+  const root = addDummyNode(g, 'root', {}, '_root');
+  const depths = treeDepths(g);
+  let maxDepth = Math.max(...Object.values(depths));
+
+  if (Math.abs(maxDepth) === Infinity) {
+    maxDepth = 1;
+  }
+
+  const height = maxDepth - 1; // Note: depths is an Object not an array
+  const nodeSep = 2 * height + 1;
+
+  // g.graph().nestingRoot = root;
+
+  // Multiply minlen by nodeSep to align nodes on non-border ranks.
+  g.getAllEdges().forEach((e) => {
+    e.data.minlen! *= nodeSep;
+  });
+
+  // Calculate a weight that is sufficient to keep subgraphs vertically compact
+  const weight = sumWeights(g) + 1;
+
+  // Create border nodes and link them up
+  // g.children()?.forEach((child) => {
+  //   dfs(g, root, nodeSep, weight, height, depths, child);
+  // });
+  g.getRoots().forEach((child) => {
+    dfs(g, root, nodeSep, weight, height, depths, child.id);
+  });
+
+  // Save the multiplier for node layers for later removal of empty border
+  // layers.
+  // g.graph().nodeRankFactor = nodeSep;
+
+  return {
+    nestingRoot: root,
+    nodeRankFactor: nodeSep,
+  };
+};
+
+const dfs = (
+  g: DagreGraph,
+  root: ID,
+  nodeSep: number,
+  weight: number,
+  height: number,
+  depths: Record<string, number>,
+  v: ID,
+) => {
+  const children = g.getChildren(v);
+  if (!children?.length) {
+    if (v !== root) {
+      // g.setEdge(root, v, { weight: 0, minlen: nodeSep });
+      g.addEdge({
+        id: `e${Math.random()}`,
+        source: root,
+        target: v,
+        data: { weight: 0, minlen: nodeSep },
+      });
+    }
+    return;
+  }
+
+  const top = addBorderNode(g, '_bt');
+  const bottom = addBorderNode(g, '_bb');
+  const label = g.getNode(v)!;
+
+  g.setParent(top, v);
+  label.data.borderTop = top;
+  g.setParent(bottom, v);
+  label.data.borderBottom = bottom;
+
+  children?.forEach((childNode) => {
+    dfs(g, root, nodeSep, weight, height, depths, childNode.id);
+
+    const childTop = childNode.data.borderTop
+      ? (childNode.data.borderTop as ID)
+      : childNode.id;
+    const childBottom = childNode.data.borderBottom
+      ? (childNode.data.borderBottom as ID)
+      : childNode.id;
+    const thisWeight = childNode.data.borderTop ? weight : 2 * weight;
+    const minlen = childTop !== childBottom ? 1 : height - depths[v] + 1;
+
+    g.addEdge({
+      id: `e${Math.random()}`,
+      source: top,
+      target: childTop,
+      data: {
+        minlen,
+        weight: thisWeight,
+        nestingEdge: true,
+      },
+    });
+
+    g.addEdge({
+      id: `e${Math.random()}`,
+      source: childBottom,
+      target: bottom,
+      data: {
+        minlen,
+        weight: thisWeight,
+        nestingEdge: true,
+      },
+    });
+  });
+
+  if (!g.getParent(v)) {
+    g.addEdge({
+      id: `e${Math.random()}`,
+      source: root,
+      target: top,
+      data: {
+        weight: 0,
+        minlen: height + depths[v],
+      },
+    });
+  }
+};
+
+const treeDepths = (g: DagreGraph) => {
+  const depths: Record<ID, number> = {};
+  const dfs = (v: ID, depth: number) => {
+    const children = g.getChildren(v);
+    children?.forEach((child) => dfs(child.id, depth + 1));
+    depths[v] = depth;
+  };
+  // g.children()?.forEach((v) => dfs(v, 1));
+
+  g.getRoots().forEach((v) => dfs(v.id, 1));
+  return depths;
+};
+
+const sumWeights = (g: DagreGraph) => {
+  let result = 0;
+  g.getAllEdges().forEach((e) => {
+    result += e.data.weight!;
+  });
+  return result;
+};
+
+const cleanup = (g: DagreGraph, nestingRoot?: ID) => {
+  // const graphLabel = g.graph();
+  // graphLabel.nestingRoot && g.removeNode(graphLabel.nestingRoot);
+  // delete graphLabel.nestingRoot;
+  if (nestingRoot) {
+    g.removeNode(nestingRoot);
+  }
+
+  g.getAllEdges().forEach((e) => {
+    if (e.data.nestingEdge) {
+      g.removeEdge(e.id);
+    }
+  });
+};
+
+export { run, cleanup };

package/src/algorithm/antv-dagre/normalize.ts

@@ -0,0 +1,125 @@
+import type { ID } from '../../types';
+import { EdgeData } from '../../types';
+import { DagreGraph, GraphEdge } from './graph';
+import { addDummyNode } from './util';
+
+/*
+ * Breaks any long edges in the graph into short segments that span 1 layer
+ * each. This operation is undoable with the denormalize function.
+ *
+ * Pre-conditions:
+ *
+ *    1. The input graph is a DAG.
+ *    2. Each node in the graph has a "rank" property.
+ *
+ * Post-condition:
+ *
+ *    1. All edges in the graph have a length of 1.
+ *    2. Dummy nodes are added where edges have been split into segments.
+ *    3. The graph is augmented with a "dummyChains" attribute which contains
+ *       the first dummy in each chain of dummy nodes produced.
+ */
+
+const DUMMY_NODE_EDGE = 'edge';
+const DUMMY_NODE_EDGE_LABEL = 'edge-label';
+
+const run = (g: DagreGraph, dummyChains: ID[]) => {
+  g.getAllEdges().forEach((edge) => normalizeEdge(g, edge, dummyChains));
+};
+
+const normalizeEdge = (
+  g: DagreGraph,
+  e: GraphEdge<EdgeData>,
+  dummyChains: ID[],
+) => {
+  let v = e.source;
+  let vRank = g.getNode(v)!.data.rank!;
+  const w = e.target;
+  const wRank = g.getNode(w)!.data.rank!;
+  const labelRank = e.data.labelRank;
+
+  if (wRank === vRank + 1) return;
+
+  g.removeEdge(e.id);
+
+  let dummy: ID;
+  let nodeData: {
+    width: number;
+    height: number;
+    originalEdge: GraphEdge<EdgeData>;
+    rank: number;
+    dummy?: string;
+    labelpos?: string;
+  };
+  let i;
+  for (i = 0, ++vRank; vRank < wRank; ++i, ++vRank) {
+    e.data.points = [];
+    nodeData = {
+      originalEdge: e,
+      width: 0,
+      height: 0,
+      rank: vRank,
+    };
+
+    dummy = addDummyNode(g, DUMMY_NODE_EDGE, nodeData, '_d');
+
+    if (vRank === labelRank) {
+      nodeData.width = e.data.width!;
+      nodeData.height = e.data.height!;
+      nodeData.dummy = DUMMY_NODE_EDGE_LABEL;
+      nodeData.labelpos = e.data.labelpos as string;
+    }
+
+    g.addEdge({
+      id: `e${Math.random()}`,
+      source: v,
+      target: dummy,
+      data: { weight: e.data.weight },
+    });
+    if (i === 0) {
+      dummyChains.push(dummy);
+    }
+    v = dummy;
+  }
+
+  g.addEdge({
+    id: `e${Math.random()}`,
+    source: v,
+    target: w,
+    data: { weight: e.data.weight },
+  });
+};
+
+const undo = (g: DagreGraph, dummyChains: ID[]) => {
+  dummyChains.forEach((v) => {
+    let node = g.getNode(v)!;
+    const { data } = node;
+    const originalEdge = data.originalEdge as GraphEdge<EdgeData>;
+
+    let w;
+    // Restore original edge.
+    if (originalEdge) {
+      g.addEdge(originalEdge);
+    }
+
+    let currentV = v;
+    while (node.data.dummy) {
+      w = g.getSuccessors(currentV)![0];
+      g.removeNode(currentV);
+      originalEdge.data.points!.push({
+        x: node.data.x!,
+        y: node.data.y!,
+      });
+      if (node.data.dummy === DUMMY_NODE_EDGE_LABEL) {
+        originalEdge.data.x = node.data.x;
+        originalEdge.data.y = node.data.y;
+        originalEdge.data.width = node.data.width;
+        originalEdge.data.height = node.data.height;
+      }
+      currentV = w.id;
+      node = g.getNode(currentV)!;
+    }
+  });
+};
+
+export { run, undo };

package/src/algorithm/antv-dagre/order/add-subgraph-constraints.ts

@@ -0,0 +1,51 @@
+import type { ID } from '../../../types';
+import { DagreGraph } from '../graph';
+
+export const addSubgraphConstraints = (
+  g: DagreGraph,
+  cg: DagreGraph,
+  vs: ID[],
+) => {
+  const prev: Record<ID, ID> = {};
+  let rootPrev: ID;
+
+  vs?.forEach((v) => {
+    let child = g.getParent(v);
+    let parent;
+    let prevChild: ID;
+    while (child) {
+      parent = g.getParent(child.id);
+      if (parent) {
+        prevChild = prev[parent.id];
+        prev[parent.id] = child.id;
+      } else {
+        prevChild = rootPrev;
+        rootPrev = child.id;
+      }
+      if (prevChild && prevChild !== child.id) {
+        if (!cg.hasNode(prevChild)) {
+          cg.addNode({
+            id: prevChild,
+            data: {},
+          });
+        }
+        if (!cg.hasNode(child.id)) {
+          cg.addNode({
+            id: child.id,
+            data: {},
+          });
+        }
+        if (!cg.hasEdge(`e${prevChild}-${child.id}`)) {
+          cg.addEdge({
+            id: `e${prevChild}-${child.id}`,
+            source: prevChild,
+            target: child.id,
+            data: {},
+          });
+        }
+        return;
+      }
+      child = parent;
+    }
+  });
+};

package/src/algorithm/antv-dagre/order/barycenter.ts

@@ -0,0 +1,26 @@
+import type { ID } from '../../../types';
+import { DagreGraph } from '../graph';
+
+/**
+ * TODO: The median method consistently performs better than the barycenter method and has a slight theoretical advantage
+ */
+export const barycenter = (g: DagreGraph, movable: ID[]) => {
+  return movable.map((v) => {
+    const inV = g.getRelatedEdges(v, 'in');
+    if (!inV?.length) {
+      return { v };
+    }
+
+    const result = { sum: 0, weight: 0 };
+    inV?.forEach((e) => {
+      const nodeU = g.getNode(e.source)!;
+      result.sum += e.data.weight! * nodeU.data.order!;
+      result.weight += e.data.weight!;
+    });
+    return {
+      v,
+      barycenter: result.sum / result.weight,
+      weight: result.weight,
+    };
+  });
+};

package/src/algorithm/antv-dagre/order/build-layer-graph.ts

@@ -0,0 +1,109 @@
+import type { EdgeData, ID, NodeData } from '../../../types';
+import { DagreGraph } from '../graph';
+
+/*
+ * Constructs a graph that can be used to sort a layer of nodes. The graph will
+ * contain all base and subgraph nodes from the request layer in their original
+ * hierarchy and any edges that are incident on these nodes and are of the type
+ * requested by the "relationship" parameter.
+ *
+ * Nodes from the requested rank that do not have parents are assigned a root
+ * node in the output graph, which is set in the root graph attribute. This
+ * makes it easy to walk the hierarchy of movable nodes during ordering.
+ *
+ * Pre-conditions:
+ *
+ *    1. Input graph is a DAG
+ *    2. Base nodes in the input graph have a rank attribute
+ *    3. Subgraph nodes in the input graph has minRank and maxRank attributes
+ *    4. Edges have an assigned weight
+ *
+ * Post-conditions:
+ *
+ *    1. Output graph has all nodes in the movable rank with preserved
+ *       hierarchy.
+ *    2. Root nodes in the movable layer are made children of the node
+ *       indicated by the root attribute of the graph.
+ *    3. Non-movable nodes incident on movable nodes, selected by the
+ *       relationship parameter, are included in the graph (without hierarchy).
+ *    4. Edges incident on movable nodes, selected by the relationship
+ *       parameter, are added to the output graph.
+ *    5. The weights for copied edges are aggregated as need, since the output
+ *       graph is not a multi-graph.
+ */
+export const buildLayerGraph = (
+  g: DagreGraph,
+  rank: number,
+  direction: 'in' | 'out',
+) => {
+  const root = createRootNode(g);
+  const result = new DagreGraph<NodeData, EdgeData>();
+
+  result.addNode({ id: root, data: {} });
+
+  g.getAllNodes().forEach((v) => {
+    const parent = g.getParent(v.id);
+
+    if (
+      v.data.rank === rank ||
+      (v.data.minRank! <= rank && rank <= v.data.maxRank!)
+    ) {
+      if (!result.hasNode(v.id)) {
+        result.addNode({ ...v });
+      }
+
+      if (parent?.id && !result.hasNode(parent?.id)) {
+        result.addNode({ ...parent });
+      }
+
+      result.setParent(v.id, parent?.id || root);
+
+      // This assumes we have only short edges!
+      g.getRelatedEdges(v.id, direction).forEach((e) => {
+        const u = e.source === v.id ? e.target : e.source;
+        if (!result.hasNode(u)) {
+          result.addNode({ ...g.getNode(u) });
+        }
+
+        const edge = result
+          .getRelatedEdges(u, 'out')
+          .find(({ target }) => target === v.id);
+        const weight = edge !== undefined ? edge.data.weight! : 0;
+
+        if (!edge) {
+          result.addEdge({
+            id: e.id,
+            source: u,
+            target: v.id,
+            data: {
+              weight: e.data.weight! + weight,
+            },
+          });
+        } else {
+          result.updateEdgeData(edge.id, {
+            ...edge.data,
+            weight: e.data.weight! + weight,
+          });
+        }
+      });
+
+      // console.log(v);
+
+      if (v.data.hasOwnProperty('minRank')) {
+        result.updateNodeData(v.id, {
+          ...v.data,
+          borderLeft: [(v.data.borderLeft as ID[])?.[rank - v.data.minRank!]],
+          borderRight: [(v.data.borderRight as ID[])?.[rank - v.data.minRank!]],
+        });
+      }
+    }
+  });
+
+  return result;
+};
+
+const createRootNode = (g: DagreGraph) => {
+  let v;
+  while (g.hasNode((v = `_root${Math.random()}`)));
+  return v;
+};

package/src/algorithm/antv-dagre/order/cross-count.ts

@@ -0,0 +1,76 @@
+/*
+ * A function that takes a layering (an array of layers, each with an array of
+ * ordererd nodes) and a graph and returns a weighted crossing count.
+ *
+ * Pre-conditions:
+ *
+ *    1. Input graph must be simple (not a multigraph), directed, and include
+ *       only simple edges.
+ *    2. Edges in the input graph must have assigned weights.
+ *
+ * Post-conditions:
+ *
+ *    1. The graph and layering matrix are left unchanged.
+ *
+ * This algorithm is derived from Barth, et al., "Bilayer Cross Counting."
+ */
+
+import type { ID } from '../../../types';
+import { DagreGraph } from '../graph';
+import { zipObject } from '../util';
+
+const twoLayerCrossCount = (
+  g: DagreGraph,
+  northLayer: ID[],
+  southLayer: ID[],
+) => {
+  // Sort all of the edges between the north and south layers by their position
+  // in the north layer and then the south. Map these edges to the position of
+  // their head in the south layer.
+  const southPos = zipObject(
+    southLayer,
+    southLayer.map((v, i) => i),
+  );
+  const unflat = northLayer.map((v) => {
+    const unsort = g.getRelatedEdges(v, 'out').map((e) => {
+      return { pos: southPos[e.target] || 0, weight: e.data.weight };
+    });
+    return unsort?.sort((a, b) => a.pos - b.pos);
+  });
+  const southEntries = unflat.flat().filter((entry) => entry !== undefined);
+
+  // Build the accumulator tree
+  let firstIndex = 1;
+  while (firstIndex < southLayer.length) firstIndex <<= 1;
+  const treeSize = 2 * firstIndex - 1;
+  firstIndex -= 1;
+  const tree = Array(treeSize).fill(0, 0, treeSize);
+
+  // Calculate the weighted crossings
+  let cc = 0;
+  southEntries?.forEach((entry) => {
+    if (entry) {
+      let index = entry.pos + firstIndex;
+      tree[index] += entry.weight;
+      let weightSum = 0;
+      while (index > 0) {
+        if (index % 2) {
+          weightSum += tree[index + 1];
+        }
+        index = (index - 1) >> 1;
+        tree[index] += entry.weight;
+      }
+      cc += entry.weight! * weightSum;
+    }
+  });
+
+  return cc;
+};
+
+export const crossCount = (g: DagreGraph, layering: ID[][]) => {
+  let cc = 0;
+  for (let i = 1; i < layering?.length; i += 1) {
+    cc += twoLayerCrossCount(g, layering[i - 1], layering[i]);
+  }
+  return cc;
+};

package/src/algorithm/antv-dagre/order/index.ts

@@ -0,0 +1,123 @@
+import { clone } from '@antv/util';
+import type { ID } from '../../../types';
+import { DagreGraph } from '../graph';
+import { buildLayerMatrix, maxRank } from '../util';
+import { addSubgraphConstraints } from './add-subgraph-constraints';
+import { buildLayerGraph } from './build-layer-graph';
+import { crossCount } from './cross-count';
+import { initOrder } from './init-order';
+import { sortSubgraph } from './sort-subgraph';
+
+/*
+ * Applies heuristics to minimize edge crossings in the graph and sets the best
+ * order solution as an order attribute on each node.
+ *
+ * Pre-conditions:
+ *
+ *    1. Graph must be DAG
+ *    2. Graph nodes must be objects with a "rank" attribute
+ *    3. Graph edges must have the "weight" attribute
+ *
+ * Post-conditions:
+ *
+ *    1. Graph nodes will have an "order" attribute based on the results of the
+ *       algorithm.
+ */
+export const order = (g: DagreGraph, keepNodeOrder?: boolean) => {
+  const mxRank = maxRank(g);
+  const range1 = [];
+  const range2 = [];
+  for (let i = 1; i < mxRank + 1; i++) range1.push(i);
+  for (let i = mxRank - 1; i > -1; i--) range2.push(i);
+  const downLayerGraphs = buildLayerGraphs(g, range1, 'in');
+  const upLayerGraphs = buildLayerGraphs(g, range2, 'out');
+
+  let layering = initOrder(g);
+  assignOrder(g, layering);
+
+  let bestCC = Number.POSITIVE_INFINITY;
+  let best: string[][];
+  for (let i = 0, lastBest = 0; lastBest < 4; ++i, ++lastBest) {
+    sweepLayerGraphs(
+      i % 2 ? downLayerGraphs : upLayerGraphs,
+      i % 4 >= 2,
+      false,
+      keepNodeOrder,
+    );
+
+    layering = buildLayerMatrix(g);
+    const cc = crossCount(g, layering);
+    if (cc < bestCC) {
+      lastBest = 0;
+      best = clone(layering);
+      bestCC = cc;
+    }
+  }
+
+  // consider use previous result, maybe somewhat reduendant
+  layering = initOrder(g);
+  assignOrder(g, layering);
+  for (let i = 0, lastBest = 0; lastBest < 4; ++i, ++lastBest) {
+    sweepLayerGraphs(
+      i % 2 ? downLayerGraphs : upLayerGraphs,
+      i % 4 >= 2,
+      true,
+      keepNodeOrder,
+    );
+
+    layering = buildLayerMatrix(g);
+    const cc = crossCount(g, layering);
+    if (cc < bestCC) {
+      lastBest = 0;
+      best = clone(layering);
+      bestCC = cc;
+    }
+  }
+  assignOrder(g, best!);
+};
+
+const buildLayerGraphs = (
+  g: DagreGraph,
+  ranks: number[],
+  direction: 'in' | 'out',
+) => {
+  return ranks.map((rank) => {
+    return buildLayerGraph(g, rank, direction);
+  });
+};
+
+const sweepLayerGraphs = (
+  layerGraphs: DagreGraph[],
+  biasRight: boolean,
+  usePrev?: boolean,
+  keepNodeOrder?: boolean,
+) => {
+  const cg = new DagreGraph();
+  layerGraphs?.forEach((lg) => {
+    // const root = lg.graph().root as string;
+    const root = lg.getRoots()[0].id;
+    const sorted = sortSubgraph(
+      lg,
+      root,
+      cg,
+      biasRight,
+      usePrev,
+      keepNodeOrder,
+    );
+    for (let i = 0; i < sorted.vs?.length || 0; i++) {
+      const lnode = lg.getNode(sorted.vs[i]);
+      if (lnode) {
+        lnode.data.order = i;
+      }
+    }
+    addSubgraphConstraints(lg, cg, sorted.vs);
+  });
+};
+
+const assignOrder = (g: DagreGraph, layering: ID[][]) => {
+  layering?.forEach((layer) => {
+    layer?.forEach((v: ID, i: number) => {
+      g.getNode(v).data.order = i;
+    });
+  });
+};