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

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

@@ -1,179 +0,0 @@
-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/network-simplex.ts

@@ -1,282 +0,0 @@
-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

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