@antv/layout 0.3.12 → 1.0.0-alpha.1

package/src/layout/dagre/src/normalize.ts

@@ -1,96 +0,0 @@
-import { Edge, Graph, Node } 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 run = (g: Graph) => {
-  g.graph().dummyChains = [];
-  g.edges().forEach((edge) => normalizeEdge(g, edge));
-};
-
-const normalizeEdge = (g: Graph, e: Edge) => {
-  let v = e.v;
-  let vRank = g.node(v)!.rank as number;
-  const w = e.w;
-  const wRank = g.node(w)!.rank as number;
-  const name = e.name;
-  const edgeLabel = g.edge(e)!;
-  const labelRank = edgeLabel.labelRank;
-
-  if (wRank === vRank + 1) return;
-
-  g.removeEdgeObj(e);
-
-  const graph = g.graph();
-
-  let dummy: string;
-  let attrs: Node<Record<string, any>>;
-  let i;
-  for (i = 0, ++vRank; vRank < wRank; ++i, ++vRank) {
-    edgeLabel.points = [];
-    attrs = {
-      edgeLabel,
-      width: 0,
-      height: 0,
-      edgeObj: e,
-      rank: vRank,
-    };
-    dummy = addDummyNode(g, "edge", attrs, "_d");
-    if (vRank === labelRank) {
-      attrs.width = edgeLabel.width!;
-      attrs.height = edgeLabel.height!;
-      attrs.dummy = "edge-label";
-      attrs.labelpos = edgeLabel.labelpos;
-    }
-    g.setEdge(v, dummy, { weight: edgeLabel.weight }, name);
-    if (i === 0) {
-      if (!graph.dummyChains) graph.dummyChains = [];
-      graph.dummyChains!.push(dummy);
-    }
-    v = dummy;
-  }
-
-  g.setEdge(v, w, { weight: edgeLabel.weight }, name);
-};
-
-const undo = (g: Graph) => {
-  g.graph().dummyChains?.forEach((v) => {
-    let node = g.node(v)!;
-    const origLabel = node.edgeLabel;
-    let w;
-    if (node.edgeObj) {
-      g.setEdgeObj(node.edgeObj, origLabel);
-    }
-
-    let currentV  = v;
-    while (node.dummy) {
-      w = g.successors(currentV)![0];
-      g.removeNode(currentV);
-      origLabel.points.push({ x: node.x, y: node.y });
-      if (node.dummy === "edge-label") {
-        origLabel.x = node.x;
-        origLabel.y = node.y;
-        origLabel.width = node.width;
-        origLabel.height = node.height;
-      }
-      currentV = w;
-      node = g.node(currentV)!;
-    }
-  });
-};
-
-export default { run, undo };

package/src/layout/dagre/src/order/add-subgraph-constraints.ts

@@ -1,29 +0,0 @@
-import { Graph } from "../../graph";
-
-const addSubgraphConstraints = (g: Graph, cg: Graph, vs: string[]) => {
-  const prev: Record<string, string> = {};
-  let rootPrev: string;
-
-  vs?.forEach((v) => {
-    let child = g.parent(v);
-    let parent;
-    let prevChild;
-    while (child) {
-      parent = g.parent(child);
-      if (parent) {
-        prevChild = prev[parent];
-        prev[parent] = child;
-      } else {
-        prevChild = rootPrev;
-        rootPrev = child;
-      }
-      if (prevChild && prevChild !== child) {
-        cg.setEdge(prevChild, child);
-        return;
-      }
-      child = parent;
-    }
-  });
-};
-
-export default addSubgraphConstraints;

package/src/layout/dagre/src/order/barycenter.ts

@@ -1,26 +0,0 @@
-import { Graph } from "../../graph";
-
-const barycenter = (g: Graph, movable: string[]) => {
-  return movable.map((v) => {
-    const inV = g.inEdges(v);
-    if (!inV?.length) {
-      return { v };
-    }  {
-      const result = { sum: 0, weight: 0 };
-      inV?.forEach((e) => {
-        const edge = g.edge(e)!;
-        const nodeU = g.node(e.v)!;
-        result.sum += (edge.weight! * (nodeU.order as number));
-        result.weight += edge.weight!;
-      });
-      return {
-        v,
-        barycenter: result.sum / result.weight,
-        weight: result.weight
-      };
-    }
-  });
-};
-
-export default barycenter;
-

package/src/layout/dagre/src/order/build-layer-graph.ts

@@ -1,82 +0,0 @@
-import { Graph } 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.
- */
-const buildLayerGraph = (
-  g: Graph,
-  rank: number,
-  relationship: "inEdges" | "outEdges"
-) => {
-  const root = createRootNode(g);
-  const result = new Graph({ compound: true })
-    .setGraph({ root })
-    .setDefaultNodeLabel((v: string) => {
-      return g.node(v)!;
-    });
-
-  g.nodes().forEach((v) => {
-    const node = g.node(v)!;
-    const parent = g.parent(v);
-
-    if (
-      node.rank === rank ||
-      ((node.minRank as number) <= rank && rank <= (node.maxRank as number))
-    ) {
-      result.setNode(v);
-      result.setParent(v, parent || root);
-
-      // This assumes we have only short edges!
-      g[relationship](v)?.forEach((e) => {
-        const u = e.v === v ? e.w : e.v;
-        const edge = result.edgeFromArgs(u, v);
-        const weight = edge !== undefined ? edge.weight : 0;
-        result.setEdge(u, v, { weight: g.edge(e)!.weight! + weight! });
-      });
-
-      if (node.hasOwnProperty("minRank")) {
-        result.setNode(v, {
-          borderLeft: node.borderLeft[rank],
-          borderRight: node.borderRight[rank],
-        });
-      }
-    }
-  });
-
-  return result;
-};
-
-const createRootNode = (g: Graph) => {
-  let v;
-  while (g.hasNode((v = `_root${Math.random()}`)));
-  return v;
-};
-
-export default buildLayerGraph;

package/src/layout/dagre/src/order/cross-count.ts

@@ -1,77 +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 { Graph } from "../../graph";
-import { zipObject } from "../util";
-
-const twoLayerCrossCount = (
-  g: Graph,
-  northLayer: string[],
-  southLayer: string[]
-) => {
-  // 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.outEdges(v)?.map((e) => {
-      return { pos: southPos[e.w] || 0, weight: g.edge(e)!.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;
-};
-
-const crossCount = (g: Graph, layering: string[][]) => {
-  let cc = 0;
-  for (let i = 1; i < layering?.length; i += 1) {
-    cc += twoLayerCrossCount(g, layering[i - 1], layering[i]);
-  }
-  return cc;
-};
-
-export default crossCount;

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

@@ -1,105 +0,0 @@
-import initOrder from "./init-order";
-import crossCount from "./cross-count";
-import buildLayerGraph from "./build-layer-graph";
-import addSubgraphConstraints from "./add-subgraph-constraints";
-import sortSubgraph from "./sort-subgraph";
-import { clone } from "../../../../util";
-import { Graph } from "../../graph";
-import { buildLayerMatrix, maxRank } from "../util";
-
-/*
- * 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.
- */
-const order = (g: Graph) => {
-  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, "inEdges");
-  const upLayerGraphs = buildLayerGraphs(g, range2, "outEdges");
-
-  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);
-
-    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);
-
-    layering = buildLayerMatrix(g);
-    const cc = crossCount(g, layering);
-    if (cc < bestCC) {
-      lastBest = 0;
-      best = clone(layering);
-      bestCC = cc;
-    }
-  }
-  assignOrder(g, best!);
-};
-
-const buildLayerGraphs = (
-  g: Graph,
-  ranks: number[],
-  relationship: "inEdges" | "outEdges"
-) => {
-  return ranks.map((rank) => {
-    return buildLayerGraph(g, rank, relationship);
-  });
-};
-
-const sweepLayerGraphs = (
-  layerGraphs: Graph[],
-  biasRight: boolean,
-  usePrev?: boolean
-) => {
-  const cg = new Graph();
-  layerGraphs?.forEach((lg) => {
-    const root = lg.graph().root as string;
-    const sorted = sortSubgraph(lg, root, cg, biasRight, usePrev);
-    for (let i = 0; i < sorted.vs?.length || 0; i++) {
-      const lnode = lg.node(sorted.vs[i]);
-      if (lnode) {
-        lnode.order = i;
-      }
-    }
-    addSubgraphConstraints(lg, cg, sorted.vs);
-  });
-};
-
-const assignOrder = (g: Graph, layering: string[][]) => {
-  layering?.forEach((layer) => {
-    layer?.forEach((v: string, i: number) => {
-      g.node(v)!.order = i;
-    });
-  });
-};
-
-export default order;

package/src/layout/dagre/src/order/init-data-order.ts

@@ -1,27 +0,0 @@
-import { Graph } from "../../graph";
-
-/**
- * 按照数据中的结果设置fixorder
- */
-const initDataOrder = (g: Graph, nodeOrder: string[]) => {
-  const simpleNodes = g.nodes().filter((v) => {
-    return !g.children(v)?.length;
-  });
-  const ranks = simpleNodes.map((v) => g.node(v)!.rank as number);
-  const maxRank = Math.max(...ranks);
-  const layers: string[][] = Array(maxRank + 1).fill([]);
-
-  nodeOrder?.forEach((n) => {
-    const node = g.node(n);
-    // 只考虑原有节点，dummy节点需要按照后续算法排出
-    if (!node || node?.dummy) {
-      return;
-    }
-    if (!isNaN(node.rank as number)) {
-      node.fixorder = layers[node.rank as number].length; // 设置fixorder为当层的顺序
-      layers[node.rank as number].push(n);
-    }
-  });
-};
-
-export default initDataOrder;

package/src/layout/dagre/src/order/init-order.ts

@@ -1,56 +0,0 @@
-import { Graph } from "../../graph";
-
-/*
- * Assigns an initial order value for each node by performing a DFS search
- * starting from nodes in the first rank. Nodes are assigned an order in their
- * rank as they are first visited.
- *
- * This approach comes from Gansner, et al., "A Technique for Drawing Directed
- * Graphs."
- *
- * Returns a layering matrix with an array per layer and each layer sorted by
- * the order of its nodes.
- */
-const initOrder = (g: Graph) => {
-  const visited: Record<string, boolean> = {};
-  const simpleNodes = g.nodes().filter((v) => {
-    return !g.children(v)?.length;
-  });
-  const nodeRanks = simpleNodes.map((v) => (g.node(v)!.rank as number));
-  const maxRank = Math.max(...nodeRanks);
-  const layers: string[][] = [];
-  for (let i = 0; i < maxRank + 1; i++) {
-    layers.push([]);
-  }
-
-  const dfs = (v: string) => {
-    if (visited.hasOwnProperty(v)) return;
-    visited[v] = true;
-    const node = g.node(v)!;
-    if (!isNaN(node.rank as number)) {
-      layers[node.rank as number].push(v);
-    }
-    g.successors(v)?.forEach((child) => dfs(child as any));
-  };
-
-  const orderedVs = simpleNodes.sort((a, b) => (g.node(a)!.rank as number) - (g.node(b)!.rank as number));
-  // const orderedVs = _.sortBy(simpleNodes, function(v) { return g.node(v)!.rank; });
-
-  // 有fixOrder的，直接排序好放进去
-  const beforeSort = orderedVs.filter((n) => {
-    return g.node(n)!.fixorder !== undefined;
-  });
-  const fixOrderNodes = beforeSort.sort((a, b) => (g.node(a)!.fixorder as number) - (g.node(b)!.fixorder as number));
-  fixOrderNodes?.forEach((n) => {
-    if (!isNaN(g.node(n)!.rank as number)) {
-      layers[g.node(n)!.rank as number].push(n);
-    }
-    visited[n] = true;
-  });
-
-  orderedVs?.forEach(dfs);
-
-  return layers;
-};
-
-export default initOrder;

package/src/layout/dagre/src/order/resolve-conflicts.ts

@@ -1,152 +0,0 @@
-import { Graph } from "../../graph";
-
-/*
- * Given a list of entries of the form {v, barycenter, weight} and a
- * constraint graph this function will resolve any conflicts between the
- * constraint graph and the barycenters for the entries. If the barycenters for
- * an entry would violate a constraint in the constraint graph then we coalesce
- * the nodes in the conflict into a new node that respects the contraint and
- * aggregates barycenter and weight information.
- *
- * This implementation is based on the description in Forster, "A Fast and
- * Simple Hueristic for Constrained Two-Level Crossing Reduction," thought it
- * differs in some specific details.
- *
- * Pre-conditions:
- *
- *    1. Each entry has the form {v, barycenter, weight}, or if the node has
- *       no barycenter, then {v}.
- *
- * Returns:
- *
- *    A new list of entries of the form {vs, i, barycenter, weight}. The list
- *    `vs` may either be a singleton or it may be an aggregation of nodes
- *    ordered such that they do not violate constraints from the constraint
- *    graph. The property `i` is the lowest original index of any of the
- *    elements in `vs`.
- */
-
-export type ConflictEntry = {
-  i: number;
-  indegree?: number;
-  in?: ConflictEntry[];
-  out?: ConflictEntry[];
-  vs: string[];
-  barycenter?: number;
-  weight?: number;
-  merged?: boolean;
-  fixorder?: number;
-  order?: number;
-};
-
-const resolveConflicts = (
-  entries: {
-    v: string;
-    barycenter?: number;
-    weight?: number;
-  }[],
-  cg: Graph
-) => {
-  const mappedEntries: Record<string, ConflictEntry> = {};
-  entries?.forEach((entry, i: number) => {
-    mappedEntries[entry.v] = {
-      i,
-      indegree: 0,
-      in: [],
-      out: [],
-      vs: [entry.v],
-    };
-    const tmp = mappedEntries[entry.v];
-    if (entry.barycenter !== undefined) {
-      tmp.barycenter = entry.barycenter;
-      tmp.weight = entry.weight;
-    }
-  });
-
-  cg.edges()?.forEach((e) => {
-    const entryV = mappedEntries[e.v];
-    const entryW = mappedEntries[e.w];
-    if (entryV !== undefined && entryW !== undefined) {
-      entryW.indegree!++;
-      entryV.out!.push(mappedEntries[e.w]);
-    }
-  });
-
-  const sourceSet = Object.values(mappedEntries).filter?.(
-    (entry: ConflictEntry) => !entry.indegree
-  );
-
-  return doResolveConflicts(sourceSet);
-};
-
-const doResolveConflicts = (sourceSet: ConflictEntry[]) => {
-  const entries = [];
-
-  const handleIn = (vEntry: ConflictEntry) => {
-    return (uEntry: ConflictEntry) => {
-      if (uEntry.merged) return;
-      if (
-        uEntry.barycenter === undefined ||
-        vEntry.barycenter === undefined ||
-        uEntry.barycenter >= vEntry.barycenter
-      ) {
-        mergeEntries(vEntry, uEntry);
-      }
-    };
-  };
-
-  const handleOut = (vEntry: ConflictEntry) => {
-    return (wEntry: ConflictEntry) => {
-      wEntry["in"]!.push(vEntry);
-      if (--wEntry.indegree! === 0) {
-        sourceSet.push(wEntry);
-      }
-    };
-  };
-
-  while (sourceSet?.length) {
-    const entry = sourceSet.pop()!;
-    entries.push(entry);
-    entry["in"]!.reverse()?.forEach((e: ConflictEntry) => handleIn(entry)(e));
-    entry.out?.forEach((e: ConflictEntry) => handleOut(entry)(e));
-  }
-
-  const filtered = entries.filter((entry) => !entry.merged);
-  const keys: ("vs" | "i" | "barycenter" | "weight")[] = [
-    "vs",
-    "i",
-    "barycenter",
-    "weight",
-  ];
-  return filtered.map((entry) => {
-    const picked: Record<string, any> = {};
-    keys?.forEach((key) => {
-      if (entry[key] === undefined) return;
-      picked[key] = entry[key];
-    });
-    return picked as ConflictEntry;
-  });
-};
-
-const mergeEntries = (target: ConflictEntry, source: ConflictEntry) => {
-  let sum = 0;
-  let weight = 0;
-
-  if (target.weight) {
-    sum += target.barycenter! * target.weight;
-    weight += target.weight;
-  }
-
-  if (source.weight) {
-    sum += source.barycenter! * source.weight;
-    weight += source.weight;
-  }
-
-  target.vs = source.vs?.concat(target.vs);
-  target.barycenter = sum / weight;
-  target.weight = weight;
-  target.i = Math.min(source.i, target.i);
-  source.merged = true;
-};
-
-export default resolveConflicts;