@antv/layout 0.2.2 → 0.2.5

package/src/layout/dagre/src/order/sort-subgraph.ts

@@ -0,0 +1,105 @@
+import { Graph } from "../../graph";
+import barycenter from "./barycenter";
+import resolveConflicts, { ConflictEntry } from "./resolve-conflicts";
+import sort from "./sort";
+
+const sortSubgraph = (
+  g: Graph,
+  v: string,
+  cg: Graph,
+  biasRight?: boolean,
+  usePrev?: boolean
+) => {
+  let movable = g.children(v);
+  // fixorder的点不参与排序（这个方案不合适，只排了新增节点，和原来的分离）
+  const node = g.node(v)!;
+  const bl = node ? node.borderLeft : undefined;
+  const br = node ? node.borderRight : undefined;
+  const subgraphs: Record<string, Partial<ConflictEntry>> = {};
+
+  if (bl) {
+    movable = movable?.filter((w) => {
+      return w !== bl && w !== br;
+    });
+  }
+
+  const barycenters = barycenter(g, movable || []);
+  barycenters?.forEach((entry) => {
+    if (g.children(entry.v)?.length) {
+      const subgraphResult = sortSubgraph(g, entry.v, cg, biasRight);
+      subgraphs[entry.v] = subgraphResult;
+      if (subgraphResult.hasOwnProperty("barycenter")) {
+        mergeBarycenters(entry, subgraphResult);
+      }
+    }
+  });
+
+  const entries = resolveConflicts(barycenters, cg);
+  expandSubgraphs(entries, subgraphs);
+
+  // 添加fixorder信息到entries里边
+  // TODO: 不考虑复合情况，只用第一个点的fixorder信息，后续考虑更完备的实现
+  entries
+    .filter((e) => e.vs.length > 0)
+    ?.forEach((e) => {
+      const node = g.node(e.vs[0])!;
+      if (node) {
+        e.fixorder = node.fixorder;
+        e.order = node.order;
+      }
+    });
+
+  const result = sort(entries, biasRight, usePrev);
+
+  if (bl) {
+    result.vs = [bl, result.vs, br].flat();
+    if (g.predecessors(bl)?.length) {
+      const blPred = g.node(g.predecessors(bl)?.[0] || "")!;
+      const brPred = g.node(g.predecessors(br)?.[0] || "")!;
+      if (!result.hasOwnProperty("barycenter")) {
+        result.barycenter = 0;
+        result.weight = 0;
+      }
+      result.barycenter =
+        (result.barycenter! * result.weight! +
+          (blPred.order as number) +
+          (brPred.order as number)) /
+        (result.weight! + 2);
+      result.weight! += 2;
+    }
+  }
+
+  return result;
+};
+
+const expandSubgraphs = (
+  entries: ConflictEntry[],
+  subgraphs: Record<string, Partial<ConflictEntry>>
+) => {
+  entries?.forEach((entry) => {
+    const vss = entry.vs?.map((v: string) => {
+      if (subgraphs[v]) {
+        return subgraphs[v].vs!;
+      }
+      return v;
+    });
+    entry.vs = vss.flat();
+  });
+};
+
+const mergeBarycenters = (
+  target: { weight?: number; barycenter?: number },
+  other: { weight?: number; barycenter?: number }
+) => {
+  if (target.barycenter !== undefined) {
+    target.barycenter =
+      (target.barycenter * target.weight! + other.barycenter! * other.weight!) /
+      (target.weight! + other.weight!);
+    target.weight! += other.weight!;
+  } else {
+    target.barycenter = other.barycenter;
+    target.weight = other.weight;
+  }
+};
+
+export default sortSubgraph;

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

@@ -0,0 +1,76 @@
+import { partition } from "../util";
+import { ConflictEntry } from "./resolve-conflicts";
+
+const sort = (entries: ConflictEntry[], biasRight?: boolean, usePrev?: boolean) => {
+  const parts = partition(entries, (entry) => {
+    // NOTE: 有fixorder的也可以排
+    return (entry.hasOwnProperty("fixorder") && !isNaN(entry.fixorder!)) || entry.hasOwnProperty("barycenter");
+  });
+  const sortable = parts.lhs;
+  const unsortable = parts.rhs.sort((a, b) => -a.i - (-b.i));
+  const vs: string[][] = [];
+  let sum = 0;
+  let weight = 0;
+  let vsIndex = 0;
+
+  sortable?.sort(compareWithBias(!!biasRight, !!usePrev));
+
+  vsIndex = consumeUnsortable(vs, unsortable, vsIndex);
+
+  sortable?.forEach((entry) => {
+    vsIndex += entry.vs?.length;
+    vs.push(entry.vs);
+    sum += entry.barycenter! * entry.weight!;
+    weight += entry.weight!;
+    vsIndex = consumeUnsortable(vs, unsortable, vsIndex);
+  });
+
+  const result: { vs: string[], barycenter?: number, weight?: number } = { vs: vs.flat() };
+  if (weight) {
+    result.barycenter = sum / weight;
+    result.weight = weight;
+  }
+  return result;
+};
+
+const consumeUnsortable = (vs: string[][], unsortable: ConflictEntry[], index: number) => {
+  let iindex = index;
+  let last;
+  while (unsortable.length && (last = unsortable[unsortable.length - 1]).i <= iindex) {
+    unsortable.pop();
+    vs?.push(last.vs);
+    iindex++;
+  }
+  return iindex;
+};
+
+/**
+ * 配置是否考虑使用之前的布局结果
+ */
+const compareWithBias = (bias: boolean, usePrev: boolean) => {
+  return (entryV: ConflictEntry, entryW: ConflictEntry) => {
+    // 排序的时候先判断fixorder，不行再判断重心
+    if (entryV.fixorder !== undefined && entryW.fixorder !== undefined) {
+      return entryV.fixorder - entryW.fixorder;
+    }
+    if (entryV.barycenter! < entryW.barycenter!) {
+      return -1;
+    }
+    if (entryV.barycenter! > entryW.barycenter!) {
+      return 1;
+    }
+    // 重心相同，考虑之前排好的顺序
+    if (usePrev && entryV.order !== undefined && entryW.order !== undefined) {
+      if (entryV.order < entryW.order) {
+        return -1;
+      }
+      if (entryV.order > entryW.order) {
+        return 1;
+      }
+    }
+
+    return !bias ? entryV.i - entryW.i : entryW.i - entryV.i;
+  };
+};
+
+export default sort;

package/src/layout/dagre/src/parent-dummy-chains.ts

@@ -0,0 +1,102 @@
+import { Graph } from "../graph";
+
+type OrderItem = { low: number; lim: number };
+
+// deep first search with both order low for pre, lim for post
+const dfsBothOrder = (g: Graph) => {
+  const result: Record<string, OrderItem> = {};
+  let lim = 0;
+
+  const dfs = (v: string) => {
+    const low = lim;
+    g.children(v)?.forEach(dfs);
+    result[v] = { low, lim: lim++ };
+  };
+  g.children()?.forEach(dfs);
+
+  return result;
+};
+
+// Find a path from v to w through the lowest common ancestor (LCA). Return the
+// full path and the LCA.
+const findPath = (
+  g: Graph,
+  postorderNums: Record<string, OrderItem>,
+  v: string,
+  w: string
+) => {
+  const vPath = [];
+  const wPath = [];
+  const low = Math.min(postorderNums[v].low, postorderNums[w].low);
+  const lim = Math.max(postorderNums[v].lim, postorderNums[w].lim);
+  let parent: string | undefined;
+  let lca: string | undefined;
+
+  // Traverse up from v to find the LCA
+  parent = v;
+  do {
+    parent = g.parent(parent);
+    vPath.push(parent);
+  } while (
+    parent &&
+    (postorderNums[parent].low > low || lim > postorderNums[parent].lim)
+  );
+  lca = parent;
+
+  // Traverse from w to LCA
+  parent = w;
+  while (parent && parent !== lca) {
+    wPath.push(parent);
+    parent = g.parent(parent);
+  }
+
+  return { lca, path: vPath.concat(wPath.reverse()) };
+};
+
+const parentDummyChains = (g: Graph) => {
+  const postorderNums = dfsBothOrder(g);
+
+  g.graph().dummyChains?.forEach((startV) => {
+    let v = startV; 
+    let node = g.node(v)!;
+    const edgeObj = node.edgeObj;
+    if (!edgeObj) return;
+    const pathData = findPath(g, postorderNums, edgeObj.v, edgeObj.w);
+    const path = pathData.path;
+    const lca = pathData.lca;
+    let pathIdx = 0;
+    let pathV = path[pathIdx]!;
+    let ascending = true;
+
+    while (v !== edgeObj.w) {
+      node = g.node(v)!;
+
+      if (ascending) {
+        while (pathV !== lca && g.node(pathV)?.maxRank! < node.rank!) {
+          pathIdx++;
+          pathV = path[pathIdx]!;
+        }
+
+        if (pathV === lca) {
+          ascending = false;
+        }
+      }
+
+      if (!ascending) {
+        while (
+          pathIdx < path.length - 1 &&
+          (g.node(path[pathIdx + 1]!)?.minRank as number) <=
+            (node.rank as number)
+        ) {
+          pathIdx++;
+        }
+        pathV = path[pathIdx]!;
+      }
+
+      g.setParent(v, pathV);
+      v = g.successors(v)![0];
+    }
+  });
+};
+
+export default parentDummyChains;