@antv/layout 1.2.14-beta.8 → 2.0.0-alpha.1

package/src/util/math.ts

@@ -0,0 +1,312 @@
+import { Graph } from '@antv/graphlib';
+import { isNumber } from '@antv/util';
+import type { Matrix, NodeData, PointObject } from '../types';
+import { isArray } from './array';
+import type { LayoutModel } from './model';
+
+/**
+ * Floyd-Warshall algorithm to find shortest paths (but with no negative cycles).
+ */
+export const floydWarshall = (adjMatrix: Matrix): Matrix => {
+  // initialize
+  const n = adjMatrix.length;
+  const dist = Array.from({ length: n }, () => new Array(n));
+
+  for (let i = 0; i < n; i++) {
+    const row = adjMatrix[i];
+    const drow = dist[i];
+    for (let j = 0; j < n; j++) {
+      drow[j] = i === j ? 0 : row[j] > 0 ? row[j] : Infinity;
+    }
+  }
+
+  // floyd
+  for (let k = 0; k < n; k++) {
+    const dk = dist[k];
+    for (let i = 0; i < n; i++) {
+      const di = dist[i];
+      const dik = di[k];
+      if (dik === Infinity) continue;
+
+      for (let j = 0; j < n; j++) {
+        const dkj = dk[j];
+        if (dkj === Infinity) continue;
+
+        const next = dik + dkj;
+        if (next < di[j]) {
+          di[j] = next;
+        }
+      }
+    }
+  }
+  return dist;
+};
+
+/**
+ * Get the adjacency matrix of the graph model.
+ */
+export const getAdjMatrix = (model: LayoutModel, directed: boolean): Matrix => {
+  const n = model.nodeCount();
+  const matrix: Matrix = Array.from({ length: n }, () => new Array(n));
+
+  // map node with index in data.nodes
+  const nodeMap: { [key: string]: number } = {};
+
+  let i = 0;
+  model.forEachNode((node) => {
+    nodeMap[node.id] = i++;
+  });
+
+  model.forEachEdge((e) => {
+    const sIndex = nodeMap[e.source];
+    const tIndex = nodeMap[e.target];
+    if (sIndex === undefined || tIndex === undefined) return;
+
+    matrix[sIndex][tIndex] = 1;
+    if (!directed) {
+      matrix[tIndex][sIndex] = 1;
+    }
+  });
+  return matrix;
+};
+
+/**
+ * Get the adjacency list of the graph model.
+ */
+export const getAdjList = (model: LayoutModel, directed: boolean): Matrix => {
+  const n = model.nodeCount();
+  const adjList: Matrix = Array.from({ length: n }, () => [] as number[]);
+
+  // map node with index
+  const nodeMap: Record<string, number> = {};
+  let idx = 0;
+  model.forEachNode((node) => {
+    nodeMap[node.id] = idx++;
+  });
+
+  model.forEachEdge((e) => {
+    const s = nodeMap[e.source];
+    const t = nodeMap[e.target];
+    if (s == null || t == null) return;
+
+    adjList[s].push(t);
+    if (!directed) adjList[t].push(s);
+  });
+
+  return adjList;
+};
+
+/**
+ * scale matrix
+ * @param matrix [ [], [], [] ]
+ * @param ratio
+ */
+export const scaleMatrix = (matrix: Matrix, ratio: number) => {
+  const n = matrix.length;
+  const result = new Array(n);
+
+  for (let i = 0; i < n; i++) {
+    const row = matrix[i];
+    const m = row.length;
+    const newRow = new Array(m);
+
+    for (let j = 0; j < m; j++) {
+      newRow[j] = row[j] * ratio;
+    }
+    result[i] = newRow;
+  }
+
+  return result;
+};
+
+/**
+ * calculate the bounding box for the nodes according to their x, y, and size
+ * @param nodes nodes in the layout
+ * @returns
+ */
+export const getLayoutBBox = (nodes: NodeData[]) => {
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  nodes.forEach((node) => {
+    let size = node.data.size;
+    if (isArray(size)) {
+      if (size.length === 1) size = [size[0], size[0]];
+    } else if (size === undefined || isNaN(size as any)) {
+      size = [30, 30];
+    } else if (isNumber(size)) {
+      size = [size, size];
+    }
+
+    const halfSize = [size[0] / 2, size[1] / 2];
+    const left = node.data.x - halfSize[0];
+    const right = node.data.x + halfSize[0];
+    const top = node.data.y - halfSize[1];
+    const bottom = node.data.y + halfSize[1];
+
+    if (minX > left) minX = left;
+    if (minY > top) minY = top;
+    if (maxX < right) maxX = right;
+    if (maxY < bottom) maxY = bottom;
+  });
+  return { minX, minY, maxX, maxY };
+};
+
+/**
+ * calculate the euclidean distance form p1 to p2
+ * @param p1
+ * @param p2
+ * @returns
+ */
+export const getEuclideanDistance = (p1: PointObject, p2: PointObject) =>
+  Math.sqrt((p1.x - p2.x) * (p1.x - p2.x) + (p1.y - p2.y) * (p1.y - p2.y));
+
+/**
+ * Depth first search begin from nodes in graphCore data.
+ * @param graphCore graphlib data structure
+ * @param nodes begin nodes
+ * @param fn will be called while visiting each node
+ * @param mode 'TB' - visit from top to bottom; 'BT' - visit from bottom to top;
+ * @returns
+ */
+export const graphTreeDfs = (
+  graph: Graph<any, any>,
+  nodes: NodeData[],
+  fn: (n: NodeData) => void,
+  mode: 'TB' | 'BT' = 'TB',
+  treeKey: string,
+  stopFns: {
+    stopBranchFn?: (node: NodeData) => boolean;
+    stopAllFn?: (node: NodeData) => boolean;
+  } = {},
+) => {
+  if (!nodes?.length) return;
+  const { stopBranchFn, stopAllFn } = stopFns;
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+    if (!graph.hasNode(node.id)) continue;
+    if (stopBranchFn?.(node)) continue; // Stop this branch
+    if (stopAllFn?.(node)) return; // Stop all
+    if (mode === 'TB') fn(node); // Traverse from top to bottom
+    graphTreeDfs(
+      graph,
+      graph.getChildren(node.id, treeKey),
+      fn,
+      mode,
+      treeKey,
+      stopFns,
+    );
+    if (mode !== 'TB') fn(node); // Traverse from bottom to top
+  }
+};
+
+/**
+ * Use Johnson + Dijkstra to compute APSP for sparse graph.
+ * Fully compatible with floydWarshall(adjMatrix).
+ */
+
+export function johnson(adjList: Matrix): Matrix {
+  const n = adjList.length;
+
+  // Step 1: add a dummy node q connected to all nodes with weight 0
+  const h = new Array(n).fill(0);
+
+  // Bellman-Ford to compute potentials h(v)
+  // 因为权重全是 1，无负边，可直接跳过 BF，h 全 0 即可
+
+  // Step 2: reweight edges
+  // 因为 h(u)=h(v)=0，reweight 后仍然是 1，省略 reweight 过程
+
+  // Step 3: run Dijkstra from each node
+  const distAll: Matrix = Array.from({ length: n }, () =>
+    new Array(n).fill(Infinity),
+  );
+
+  for (let s = 0; s < n; s++) {
+    distAll[s] = dijkstra(adjList, s);
+  }
+
+  return distAll;
+}
+
+/**
+ * Dijkstra algorithm to find shortest paths from source to all nodes.
+ */
+function dijkstra(adjList: number[][], source: number): number[] {
+  const n = adjList.length;
+  const dist = new Array(n).fill(Infinity);
+  dist[source] = 0;
+
+  // Minimal binary heap
+  const heap = new MinHeap();
+  heap.push([0, source]); // [distance, node]
+
+  while (!heap.empty()) {
+    const [d, u] = heap.pop();
+    if (d !== dist[u]) continue;
+
+    const neighbors = adjList[u];
+    for (let i = 0; i < neighbors.length; i++) {
+      const v = neighbors[i];
+      const nd = d + 1;
+      if (nd < dist[v]) {
+        dist[v] = nd;
+        heap.push([nd, v]);
+      }
+    }
+  }
+
+  return dist;
+}
+
+class MinHeap {
+  private data: [number, number][] = [];
+
+  push(item: [number, number]) {
+    this.data.push(item);
+    this.bubbleUp(this.data.length - 1);
+  }
+
+  pop(): [number, number] {
+    const top = this.data[0];
+    const end = this.data.pop()!;
+    if (this.data.length > 0) {
+      this.data[0] = end;
+      this.bubbleDown(0);
+    }
+    return top;
+  }
+
+  empty() {
+    return this.data.length === 0;
+  }
+
+  private bubbleUp(pos: number) {
+    const data = this.data;
+    while (pos > 0) {
+      const parent = (pos - 1) >> 1;
+      if (data[parent][0] <= data[pos][0]) break;
+      [data[parent], data[pos]] = [data[pos], data[parent]];
+      pos = parent;
+    }
+  }
+
+  private bubbleDown(pos: number) {
+    const data = this.data;
+    const length = data.length;
+
+    while (true) {
+      const left = pos * 2 + 1;
+      const right = pos * 2 + 2;
+      let min = pos;
+
+      if (left < length && data[left][0] < data[min][0]) min = left;
+      if (right < length && data[right][0] < data[min][0]) min = right;
+      if (min === pos) break;
+
+      [data[pos], data[min]] = [data[min], data[pos]];
+      pos = min;
+    }
+  }
+}

package/src/util/model.ts

@@ -0,0 +1,372 @@
+import { isNil } from '@antv/util';
+import type { LayoutModelOptions } from '../core/types';
+import type {
+  EdgeData,
+  GraphData,
+  ID,
+  LayoutData,
+  LayoutEdge,
+  LayoutNode,
+  NodeData,
+} from '../types';
+
+export class LayoutModel<
+  N extends NodeData = NodeData,
+  E extends EdgeData = EdgeData,
+> {
+  public nodeMap: Map<ID, LayoutNode<N>>;
+  public edgeMap: Map<ID, LayoutEdge<E>>;
+
+  private degreeCache?: Map<ID, { in: number; out: number; both: number }>;
+
+  private inAdjacencyCache?: Map<ID, Set<ID>>;
+  private outAdjacencyCache?: Map<ID, Set<ID>>;
+  private bothAdjacencyCache?: Map<ID, Set<ID>>;
+
+  private nodeIndexCache?: Map<ID, number>;
+  private indexNodeCache?: Map<number, ID>;
+
+  private edgeIdCounter: Map<string, number> = new Map();
+
+  constructor(data: GraphData<N, E>, options: LayoutModelOptions<N, E> = {}) {
+    this.nodeMap = extractNodeData<N>(data.nodes, options.node);
+    this.edgeMap = extractEdgeData<E>(
+      data.edges || [],
+      options.edge,
+      this.getEdgeId.bind(this),
+    );
+  }
+
+  public data(): LayoutData<N, E> {
+    return { nodes: this.nodeMap, edges: this.edgeMap };
+  }
+
+  public apply(result: LayoutData<N, E>): void {
+    this.nodeMap = result.nodes;
+    this.edgeMap = result.edges;
+
+    this.clearCache();
+  }
+
+  public nodes(): LayoutNode<N>[] {
+    return Array.from(this.nodeMap.values());
+  }
+
+  public node(id: ID): LayoutNode<N> | undefined {
+    return this.nodeMap.get(id);
+  }
+
+  public nodeAt(index: number): LayoutNode<N> | undefined {
+    if (!this.indexNodeCache) {
+      this.buildNodeIndexCache();
+    }
+    const nodeId = this.indexNodeCache!.get(index);
+    return nodeId ? this.nodeMap.get(nodeId) : undefined;
+  }
+
+  public nodeIndexOf(id: ID): number {
+    if (!this.nodeIndexCache) {
+      this.buildNodeIndexCache();
+    }
+    return this.nodeIndexCache!.get(id) ?? -1;
+  }
+
+  public firstNode(): LayoutNode<N> | undefined {
+    return this.nodeMap.values().next().value;
+  }
+
+  public forEachNode(
+    callback: (node: LayoutNode<N>, index: number) => void,
+  ): void {
+    let i = 0;
+    this.nodeMap.forEach((node) => callback(node, i++));
+  }
+
+  public originalNode(id: ID): N | undefined {
+    const node = this.nodeMap.get(id);
+    return node?._original;
+  }
+
+  public nodeCount(): number {
+    return this.nodeMap.size;
+  }
+
+  public edges(): LayoutEdge<E>[] {
+    return Array.from(this.edgeMap.values());
+  }
+
+  public edge(id: ID): LayoutEdge<E> | undefined {
+    return this.edgeMap.get(id);
+  }
+
+  public firstEdge(): LayoutEdge<E> | undefined {
+    return this.edgeMap.values().next().value;
+  }
+
+  public forEachEdge(
+    callback: (edge: LayoutEdge<E>, index: number) => void,
+  ): void {
+    let i = 0;
+    this.edgeMap.forEach((edge) => callback(edge, i++));
+  }
+
+  public originalEdge(id: ID): E | undefined {
+    const edge = this.edgeMap.get(id);
+    return edge?._original;
+  }
+
+  public edgeCount(): number {
+    return this.edgeMap.size;
+  }
+
+  public getEdgeId(edge: E): string {
+    if (edge.id) return edge.id;
+
+    const baseId = `${edge.source}-${edge.target}`;
+    const count = this.edgeIdCounter.get(baseId) || 0;
+    const id = count === 0 ? baseId : `${baseId}-${count}`;
+    this.edgeIdCounter.set(baseId, count + 1);
+
+    return id;
+  }
+
+  public degree(nodeId: ID, direction: 'in' | 'out' | 'both' = 'both'): number {
+    if (!this.degreeCache) {
+      this.buildDegreeCache();
+    }
+
+    const degree = this.degreeCache!.get(nodeId);
+    if (!degree) return 0;
+
+    return degree[direction];
+  }
+
+  public neighbors(
+    nodeId: ID,
+    direction: 'in' | 'out' | 'both' = 'both',
+  ): ID[] {
+    if (!this.outAdjacencyCache || !this.inAdjacencyCache) {
+      this.buildAdjacencyCache();
+    }
+
+    if (direction === 'out') {
+      return Array.from(this.outAdjacencyCache!.get(nodeId) || []);
+    }
+
+    if (direction === 'in') {
+      return Array.from(this.inAdjacencyCache!.get(nodeId) || []);
+    }
+
+    if (this.bothAdjacencyCache) {
+      return Array.from(this.bothAdjacencyCache.get(nodeId) || []);
+    }
+
+    const inSet = this.inAdjacencyCache!.get(nodeId);
+    const outSet = this.outAdjacencyCache!.get(nodeId);
+
+    if (!inSet && !outSet) return [];
+    if (!inSet) return Array.from(outSet!);
+    if (!outSet) return Array.from(inSet);
+
+    const merged = new Set<ID>();
+    inSet.forEach((id) => merged.add(id));
+    outSet.forEach((id) => merged.add(id));
+    return Array.from(merged);
+  }
+
+  public successors(nodeId: ID): ID[] {
+    return this.neighbors(nodeId, 'out');
+  }
+
+  public predecessors(nodeId: ID): ID[] {
+    return this.neighbors(nodeId, 'in');
+  }
+
+  public clearCache(): void {
+    this.degreeCache = undefined;
+    this.inAdjacencyCache = undefined;
+    this.outAdjacencyCache = undefined;
+    this.bothAdjacencyCache = undefined;
+    this.nodeIndexCache = undefined;
+    this.indexNodeCache = undefined;
+  }
+
+  private buildDegreeCache(): void {
+    this.degreeCache = new Map();
+
+    for (const edge of this.edges()) {
+      const { source, target } = edge;
+
+      if (edge.source === edge.target) continue;
+
+      if (!this.degreeCache.has(source)) {
+        this.degreeCache.set(source, { in: 0, out: 0, both: 0 });
+      }
+      const sourceDeg = this.degreeCache.get(edge.source);
+      if (sourceDeg) {
+        sourceDeg.out++;
+        sourceDeg.both++;
+      }
+
+      if (!this.degreeCache.has(target)) {
+        this.degreeCache.set(target, { in: 0, out: 0, both: 0 });
+      }
+      const targetDeg = this.degreeCache.get(edge.target);
+      if (targetDeg) {
+        targetDeg.in++;
+        targetDeg.both++;
+      }
+    }
+  }
+
+  private buildAdjacencyCache(): void {
+    this.inAdjacencyCache = new Map();
+    this.outAdjacencyCache = new Map();
+
+    for (const edge of this.edges()) {
+      if (!this.nodeMap.has(edge.source) || !this.nodeMap.has(edge.target))
+        continue;
+
+      if (!this.outAdjacencyCache!.has(edge.source)) {
+        this.outAdjacencyCache!.set(edge.source, new Set());
+      }
+      this.outAdjacencyCache.get(edge.source)!.add(edge.target);
+
+      if (!this.inAdjacencyCache!.has(edge.target)) {
+        this.inAdjacencyCache!.set(edge.target, new Set());
+      }
+      this.inAdjacencyCache.get(edge.target)!.add(edge.source);
+    }
+  }
+
+  private buildNodeIndexCache(): void {
+    this.nodeIndexCache = new Map();
+    this.indexNodeCache = new Map();
+
+    let index = 0;
+    this.nodeMap.forEach((_node, nodeId) => {
+      this.nodeIndexCache!.set(nodeId, index);
+      this.indexNodeCache!.set(index, nodeId);
+      index++;
+    });
+  }
+
+  public destroy(): void {
+    this.clearCache();
+    this.nodeMap.clear();
+    this.edgeMap.clear();
+    this.edgeIdCounter.clear();
+  }
+}
+
+const nodeFields = [
+  'id',
+  'x',
+  'y',
+  'z',
+  'vx',
+  'vy',
+  'vz',
+  'fx',
+  'fy',
+  'fz',
+  'parentId',
+];
+
+const edgeFields = ['id', 'source', 'target', 'points'];
+
+function extractNodeData<N extends NodeData = NodeData>(
+  nodes: N[],
+  node?: (datum: N) => Partial<LayoutNode>,
+): Map<ID, LayoutNode<N>> {
+  if (!nodes) {
+    throw new Error('Data.nodes is required');
+  }
+
+  const result = new Map<ID, LayoutNode<N>>();
+
+  for (const datum of nodes) {
+    const nodeData: LayoutNode<N> = { _original: datum } as LayoutNode<N>;
+
+    for (const field of nodeFields) {
+      const value = datum[field];
+      if (isNil(value)) continue;
+      nodeData[field] = value;
+    }
+
+    if (node) {
+      const customFields = node(datum);
+      for (const key in customFields) {
+        const value = customFields[key];
+        if (isNil(value)) continue;
+        nodeData[key] = value;
+      }
+    }
+
+    if (isNil(nodeData.id)) {
+      throw new Error(`Node is missing id field`);
+    }
+
+    result.set(nodeData.id, nodeData);
+  }
+
+  return result;
+}
+
+function extractEdgeData<E extends EdgeData = EdgeData>(
+  edges: E[],
+  edge?: (datum: E) => Partial<LayoutEdge>,
+  getEdgeId?: (datum: E) => ID,
+): Map<ID, LayoutEdge<E>> {
+  const result = new Map<ID, LayoutEdge<E>>();
+
+  for (const datum of edges) {
+    const edgeData: LayoutEdge<E> = { _original: datum } as LayoutEdge<E>;
+
+    for (const field of edgeFields) {
+      const value = datum[field];
+      if (isNil(value)) continue;
+      edgeData[field] = value;
+    }
+
+    if (edge) {
+      const customFields = edge(datum);
+      for (const key in customFields) {
+        const value = customFields[key];
+        if (isNil(value)) continue;
+        edgeData[key] = value;
+      }
+    }
+
+    if (isNil(edgeData.source) || isNil(edgeData.target)) {
+      throw new Error(`Edge is missing source or target field`);
+    }
+
+    if (isNil(edgeData.id)) {
+      edgeData.id = getEdgeId?.(datum) as ID;
+    }
+
+    result.set(edgeData.id, edgeData);
+  }
+
+  return result;
+}
+
+export function initModelNodePosition<N extends NodeData = NodeData>(
+  model: LayoutModel<N>,
+  width: number,
+  height: number,
+  dimensions: 2 | 3 = 2,
+): void {
+  model.forEachNode((node) => {
+    if (isNil(node.x)) {
+      node.x = Math.random() * width;
+    }
+    if (isNil(node.y)) {
+      node.y = Math.random() * height;
+    }
+    if (dimensions === 3 && isNil(node.z)) {
+      node.z = Math.random() * Math.min(width, height);
+    }
+  });
+}