@antv/layout 0.3.12 → 1.0.0-alpha.0

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

@@ -1,165 +0,0 @@
-import { slack } from './util';
-import { minBy } from '../util';
-import { Graph } from '../../graph';
-
-/*
- * 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: Graph) => {
-  const t = new Graph({ directed: false });
-
-  // Choose arbitrary node from which to start our tree
-  const start = g.nodes()[0];
-  const size = g.nodeCount();
-  t.setNode(start, {});
-
-  let edge: any;
-  let delta: number;
-  while (tightTree(t, g) < size) {
-    edge = findMinSlackEdge(t, g);
-    delta = t.hasNode(edge.v) ? 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: Graph, g: Graph) => {
-  const dfs = (v: string) => {
-    g.nodeEdges(v)!.forEach((e) => {
-      const edgeV = e.v;
-      const w = (v === edgeV) ? e.w : edgeV;
-      if (!t.hasNode(w) && !slack(g, e)) {
-        t.setNode(w, {});
-        t.setEdge(v, w, {});
-        dfs(w);
-      }
-    });
-  };
-
-  t.nodes().forEach(dfs);
-  return t.nodeCount();
-};
-
-/*
- * 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: Graph) => {
-  const t = new Graph({ directed: false }) as any;
-
-  // Choose arbitrary node from which to start our tree
-  const start = g.nodes()[0];
-  const size = g.nodes().filter(n => !!g.node(n)).length;
-  t.setNode(start, {});
-
-  let edge: any;
-  let delta: number;
-  while (tightTreeWithLayer(t, g)! < size) {
-    edge = findMinSlackEdge(t, g);
-    delta = t.hasNode(edge.v) ? 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: Graph, g: Graph) => {
-  const dfs = (v: string) => {
-    g.nodeEdges(v)?.forEach((e) => {
-      const edgeV = e.v;
-      const w = (v === edgeV) ? e.w : edgeV;
-      // 对于指定layer的，直接加入tight-tree，不参与调整
-      if (!t.hasNode(w) && (g.node(w)!.layer !== undefined || !slack(g, e))) {
-        t.setNode(w, {});
-        t.setEdge(v, w, {});
-        dfs(w);
-      }
-    });
-  };
-
-  t.nodes().forEach(dfs);
-  return t.nodeCount();
-};
-
-/*
- * Finds the edge with the smallest slack that is incident on tree and returns
- * it.
- */
-const findMinSlackEdge = (t: Graph, g: Graph) => {
-  return minBy(g.edges(), (e: any) => {
-    if (t.hasNode(e.v) !== t.hasNode(e.w)) {
-      return slack(g, e);
-    }
-    return Infinity;
-  });
-};
-
-const shiftRanks = (t: Graph, g: Graph, delta: number) => {
-  t.nodes().forEach((v: string) => {
-    if (!g.node(v)!.rank) g.node(v)!.rank = 0;
-    (g.node(v)!.rank as number) += delta;
-  });
-};
-
-export {
-  feasibleTree,
-  feasibleTreeWithLayer
-};
-
-export default {
-  feasibleTree,
-  feasibleTreeWithLayer
-};

package/src/layout/dagre/src/rank/index.ts

@@ -1,54 +0,0 @@
-// "use strict";
-
-// var rankUtil = require("./util");
-// var longestPath = rankUtil.longestPathWithLayer;
-// var feasibleTree = require("./feasible-tree").feasibleTreeWithLayer;
-// var networkSimplex = require("./network-simplex");
-
-import { longestPath, longestPathWithLayer } from './util';
-import { feasibleTreeWithLayer as feasibleTree } from './feasible-tree';
-import networkSimplex from './network-simplex';
-import { Graph } from '../../graph';
-
-/*
- * 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.
- */
-const rank = (g: Graph) => {
-  switch(g.graph().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: Graph) => {
-  longestPathWithLayer(g);
-  feasibleTree(g);
-};
-
-const networkSimplexRanker = (g: Graph) => {
-  networkSimplex(g);
-};
-
-export default rank;

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

@@ -1,225 +0,0 @@
-import { feasibleTree } from './feasible-tree';
-import { slack, longestPath as initRank } from './util';
-import { minBy, simplify } from '../util';
-import { algorithm } from '@antv/graphlib';
-import { Edge, Graph } from '../../graph';
-
-
-const { preorder, postorder } = algorithm;
-
-
-/*
- * 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.
- */
-const networkSimplex = (og: Graph) => {
-  const g = simplify(og);
-  initRank(g);
-  const t = feasibleTree(g);
-  initLowLimValues(t);
-  initCutValues(t, g);
-
-  let e;
-  let f;
-  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: Graph, g: Graph) => {
-  let vs = postorder(t, t.nodes());
-  vs = vs?.slice(0, vs?.length - 1);
-  vs?.forEach((v: string) => {
-    assignCutValue(t, g, v);
-  });
-};
-
-const assignCutValue = (t: Graph, g: Graph, child: string) => {
-  const childLab = t.node(child)!;
-  const parent = childLab.parent!;
-  t.edgeFromArgs(child, parent)!.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: Graph, g: Graph, child: string) => {
-  const childLab = t.node(child)!;
-  const parent = childLab.parent as string;
-  // 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.edgeFromArgs(child, parent)!;
-  // The accumulated cut value for the edge between this node and its parent
-  let cutValue = 0;
-
-  if (!graphEdge) {
-    childIsTail = false;
-    graphEdge = g.edgeFromArgs(parent, child)!;
-  }
-
-  cutValue = graphEdge.weight!;
-
-  g.nodeEdges(child)?.forEach((e) => {
-    const isOutEdge = e.v === child;
-    const other = isOutEdge ? e.w : e.v;
-
-    if (other !== parent) {
-      const pointsToHead = isOutEdge === childIsTail;
-      const otherWeight = g.edge(e)!.weight!;
-
-      cutValue += pointsToHead ? otherWeight : -otherWeight;
-      if (isTreeEdge(t, child, other)) {
-        const otherCutValue = t.edgeFromArgs(child, other)!.cutvalue;
-        cutValue += pointsToHead ? -otherCutValue : otherCutValue;
-      }
-    }
-  });
-
-  return cutValue;
-};
-
-export const initLowLimValues = (tree: Graph, root: string = tree.nodes()[0]) => {
-  dfsAssignLowLim(tree, {}, 1, root);
-};
-
-const dfsAssignLowLim = (tree: Graph, visited: Record<string, boolean>, nextLim: number, v: string, parent?: string) => {
-  const low = nextLim;
-  let useNextLim = nextLim;
-  const label = tree.node(v)!;
-
-  visited[v] = true;
-  tree.neighbors(v)?.forEach((w) => {
-    if (!visited[w]) {
-      useNextLim = dfsAssignLowLim(tree, visited, useNextLim, w, v);
-    }
-  });
-
-  label.low = low;
-  label.lim = useNextLim++;
-  if (parent) {
-    label.parent = parent;
-  } else {
-    // TODO should be able to remove this when we incrementally update low lim
-    delete label.parent;
-  }
-
-  return useNextLim;
-};
-
-export const leaveEdge = (tree: Graph) => {
-  return tree.edges().find((e) => {
-    return tree.edge(e)!.cutvalue < 0;
-  });
-};
-
-export const enterEdge = (t: Graph, g: Graph, edge: any) => {
-  let v = edge.v;
-  let w = edge.w;
-
-  // 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.hasEdge(v, w)) {
-    v = edge.w;
-    w = edge.v;
-  }
-
-  const vLabel = t.node(v)!;
-  const wLabel = t.node(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.lim as number) > (wLabel.lim as number)) {
-    tailLabel = wLabel;
-    flip = true;
-  }
-
-  const candidates = g.edges().filter((edge) => {
-    return flip === isDescendant(t, t.node(edge.v), tailLabel) &&
-           flip !== isDescendant(t, t.node(edge.w), tailLabel);
-  });
-
-  return minBy(candidates, (edge) => { return slack(g, edge); });
-};
-
-export const exchangeEdges = (t: Graph, g: Graph, e: Edge, f: Edge) => {
-  const v = e.v;
-  const w = e.w;
-  t.removeEdge(v, w);
-  t.setEdge(f.v, f.w, {});
-  initLowLimValues(t);
-  initCutValues(t, g);
-  updateRanks(t, g);
-};
-
-const updateRanks = (t: Graph, g: Graph) => {
-  const root = t.nodes().find((v) =>{ return !g.node(v)?.parent; })!;
-  let vs = preorder(t, root);
-  vs = vs?.slice(1);
-  vs?.forEach((v: string) => {
-    const parent = t.node(v)!.parent as string;
-    let edge = g.edgeFromArgs(v, parent);
-    let flipped = false;
-
-    if (!edge) {
-      edge = g.edgeFromArgs(parent, v)!;
-      flipped = true;
-    }
-
-    g.node(v)!.rank = g.node(parent)!.rank! + (flipped ? edge.minlen! : -edge.minlen!);
-  });
-};
-
-/*
- * Returns true if the edge is in the tree.
- */
-const isTreeEdge = (tree: Graph, u: string, v: string) => {
-  return tree.hasEdge(u, 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 = (tree: Graph, vLabel: any, rootLabel: any) => {
-  return rootLabel.low <= vLabel.lim && vLabel.lim <= rootLabel.lim;
-};
-
-export default networkSimplex;

package/src/layout/dagre/src/rank/util.ts

@@ -1,166 +0,0 @@
-import { Edge, Graph } 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: Graph) => {
-  const visited: Record<string, boolean> = {};
-
-  const dfs = (v: string) => {
-    const label = g.node(v)!;
-    if (!label) return 0;
-    if (visited[v]) {
-      return label.rank!;
-    }
-    visited[v] = true;
-
-    let rank: number;
-
-    g.outEdges(v)?.forEach(
-      (edgeObj) => {
-        const wRank = dfs(edgeObj.w);
-        const minLen = g.edge(edgeObj)!.minlen!;
-        const r = wRank - minLen;
-        if (r) {
-          if (rank === undefined || r < rank) {
-            rank = r;
-          }
-        }
-      }
-    );
-
-
-    if (!rank!) {
-      rank = 0;
-    }
-
-    label.rank = rank;
-    return rank;
-  };
-
-  g.sources()?.forEach((source) => dfs(source));
-};
-
-const longestPathWithLayer = (g: Graph) => {
-  // 用longest path，找出最深的点
-  const visited: Record<string, boolean> = {};
-  let minRank: number;
-
-  const dfs = (v: string) => {
-    const label = g.node(v)!;
-    if (!label) return 0;
-    if (visited[v]) {
-      return label.rank!;
-    }
-    visited[v] = true;
-
-    let rank: number;
-
-    g.outEdges(v)?.forEach(
-      (edgeObj) => {
-        const wRank = dfs(edgeObj.w);
-        const minLen = g.edge(edgeObj)!.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.rank = rank;
-    return rank;
-  };
-
-  g.sources()?.forEach((source) => {
-    if (g.node(source)) dfs(source)
-  });
-
-  if (minRank! === undefined) {
-    minRank = 0;
-  }
-
-  // minRank += 1; // NOTE: 最小的层级是dummy root，+1
-
-  // forward一遍，赋值层级
-  const forwardVisited: Record<string, boolean> = {};
-  const dfsForward = (v: string, nextRank: number) => {
-    const label = g.node(v)!;
-
-    const currRank = (
-      !isNaN(label.layer as number) ? label.layer : nextRank
-    ) as number;
-
-    // 没有指定，取最大值
-    if (label.rank === undefined || label.rank < currRank) {
-      label.rank = currRank;
-    }
-
-    if (forwardVisited[v]) return;
-    forwardVisited[v] = true;
-
-    // DFS遍历子节点
-    g.outEdges(v)?.map((e) => {
-      dfsForward(e.w, currRank + g.edge(e)!.minlen!);
-    });
-  };
-
-  // 指定层级的，更新下游
-  g.nodes().forEach((n) => {
-    const label = g.node(n)!;
-    if(!label) return;
-    if (!isNaN(label.layer as number)) {
-      dfsForward(n, label.layer as number); // 默认的dummy root所在层的rank是-1
-    } else {
-      (label.rank as number) -= 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: Graph, e: Edge) => {
-  return (
-    (g.node(e.w)!.rank as number) -
-    (g.node(e.v)!.rank as number) -
-    (g.edge(e)!.minlen as number)
-  );
-};
-
-export { longestPath, longestPathWithLayer, slack };
-
-export default {
-  longestPath,
-  longestPathWithLayer,
-  slack,
-};