@antv/layout 2.0.0-alpha.1 → 2.0.0-alpha.3

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

@@ -1,184 +0,0 @@
-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/antv-dagre/normalize.ts

@@ -1,125 +0,0 @@
-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/antv-dagre/order/add-subgraph-constraints.ts

@@ -1,51 +0,0 @@
-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/antv-dagre/order/barycenter.ts

@@ -1,26 +0,0 @@
-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/antv-dagre/order/build-layer-graph.ts

@@ -1,109 +0,0 @@
-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/antv-dagre/order/cross-count.ts

@@ -1,76 +0,0 @@
-/*
- * 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/antv-dagre/order/index.ts

@@ -1,123 +0,0 @@
-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;
-    });
-  });
-};