@antv/layout 0.3.1 → 0.3.3

package/src/layout/force2/index.ts

@@ -69,7 +69,7 @@ export class Force2Layout extends Base {
   public damping: number = 0.9;
 
   /** 最大速度 */
-  public maxSpeed: number = 1000;
+  public maxSpeed: number = 100;
 
   /** 一次迭代的平均移动距离小于该值时停止迭代 */
   public minMovement: number = 0.4;
@@ -93,7 +93,7 @@ export class Force2Layout extends Base {
   public linkDistance: number | ((edge?: any, source?: any, target?: any) => number) | undefined = 200;
 
   /** 理想边长，兼容 graphin-force */
-  public defSpringLen: number | ((edge?: any, source?: any, target?: any) => number) | undefined
+  public defSpringLen: number | ((edge?: any, source?: any, target?: any) => number) | undefined;
 
   /** 重力大小 */
   public gravity: number = 0;
@@ -194,7 +194,7 @@ export class Force2Layout extends Base {
     // 如果传入了需要叶子节点聚类
     if (leafCluster) {
       sameTypeLeafMap = this.getSameTypeLeafMap() || {};
-      const relativeNodesType = Array.from(new Set(nodes?.map(node => node[nodeClusterBy]))) || [];
+      const relativeNodesType = Array.from(new Set(nodes?.map((node) => node[nodeClusterBy]))) || [];
       centripetalOptions = {
         single: 100,
         leaf: (node, nodes, edges) => {
@@ -245,18 +245,18 @@ export class Force2Layout extends Base {
       const clusters: string[] = Array.from(new Set(nodes.map((node, i) => {
         return node[nodeClusterBy];
       }))).filter(
-        item => item !== undefined,
+        (item) => item !== undefined,
       );
       const centerNodeInfo: { [key: string]: { x: number; y: number } } = {};
-      clusters.forEach(cluster => {
-        const sameTypeNodes = nodes.filter(item => item[nodeClusterBy] === cluster).map(node => nodeMap[node.id]);
+      clusters.forEach((cluster) => {
+        const sameTypeNodes = nodes.filter((item) => item[nodeClusterBy] === cluster).map((node) => nodeMap[node.id]);
         // 找出同类型节点平均位置节点的距离最近的节点作为中心节点
         centerNodeInfo[cluster] = getAvgNodePosition(sameTypeNodes);
       });
       centripetalOptions = {
-        single: node => getClusterNodeStrength(node),
-        leaf: node => getClusterNodeStrength(node),
-        others: node => getClusterNodeStrength(node),
+        single: (node) => getClusterNodeStrength(node),
+        leaf: (node) => getClusterNodeStrength(node),
+        others: (node) => getClusterNodeStrength(node),
         center: (node, nodes, edges) => {
           // 找出同类型节点平均位置节点的距离最近的节点作为中心节点
           const centerNode = centerNodeInfo[node[nodeClusterBy]];
@@ -407,7 +407,7 @@ export class Force2Layout extends Base {
 
 
     self.edgeInfos = [];
-    edges?.forEach(edge => {
+    edges?.forEach((edge) => {
       const sourceNode = nodeMap[edge.source];
       const targetNode = nodeMap[edge.target];
       if (!sourceNode || !targetNode) {
@@ -424,9 +424,9 @@ export class Force2Layout extends Base {
             sourceNode,
             targetNode
           ) : self.linkDistance(edge, sourceNode, targetNode) || 1 + ((nodeSize(sourceNode) + nodeSize(sourceNode)) || 0) / 2
-        })
+        });
       }
-    })
+    });
 
     this.getCentripetalOptions();
 
@@ -506,7 +506,7 @@ export class Force2Layout extends Base {
     });
 
     return energy;
-  };
+  }
 
   // coulombs law
   public calRepulsive(accArray: number[]) {
@@ -617,7 +617,7 @@ export class Force2Layout extends Base {
         }
 
         /** others */
-        const othersStrength = others(node)
+        const othersStrength = others(node);
         if (!othersStrength) continue;
         accArray[idx] -= othersStrength * vx;
         accArray[idx + 1] -= othersStrength * vy;
@@ -731,11 +731,11 @@ export class Force2Layout extends Base {
     // eslint-disable-next-line
     const sameTypeLeafMap: { [nodeId: string]: any } = {};
     nodes.forEach((node, i) => {
-      const degree = degreesMap[node.id].all
+      const degree = degreesMap[node.id].all;
       if (degree === 1) {
         sameTypeLeafMap[node.id] = getCoreNodeAndRelativeLeafNodes('leaf', node, edges, nodeClusterBy, degreesMap, nodeMap);
       }
     });
     return sameTypeLeafMap;
-  };
+  }
 }

package/src/layout/gForce.ts

@@ -379,7 +379,7 @@ export class GForceLayout extends Base {
       const vecLength = Math.sqrt(vecX * vecX + vecY * vecY);
       const direX = vecX / vecLength;
       const direY = vecY / vecLength;
-      const length = (linkDistance as Function)(edge, sourceNode, targetNode) || 1 + ((nodeSize(sourceNode) + nodeSize(sourceNode)) || 0) / 2;
+      const length = (linkDistance as Function)(edge, sourceNode, targetNode) || 1 + ((nodeSize(sourceNode) + nodeSize(targetNode)) || 0) / 2;
       const diff = length - vecLength;
       const param = diff * (edgeStrength as Function)(edge);
       const sourceIdx = nodeIdxMap[source];
@@ -485,4 +485,4 @@ export class GForceLayout extends Base {
   public getType() {
     return "gForce";
   }
-}
+}

package/src/layout/gpu/gForce.ts

@@ -221,7 +221,7 @@ export class GForceGPULayout extends Base {
     );
 
     // init degree for mass
-    self.degrees = getDegree(nodes.length, self.nodeIdxMap, edges).map(degree => degree.all);
+    self.degrees = getDegree(nodes.length, self.nodeIdxMap, edges).map((degree) => degree.all);
     const masses: number[] = [];
     const nodeStrengths: number[] = [];
     const centerXs: number[] = [];

package/src/layout/layout.ts

@@ -1,5 +1,5 @@
 import { Base } from "./base";
-import { Model, ILayout } from "./types";
+import { Model, ILayout, Node } from "./types";
 import { getLayoutByName } from "../registy";
 import { GridLayout } from "./grid";
 import { RandomLayout } from "./random";
@@ -19,6 +19,12 @@ import { ComboCombinedLayout } from "./comboCombined";
 import { ForceAtlas2Layout } from "./forceAtlas2";
 import { ERLayout } from "./er";
 import { DagreCompoundLayout } from "./dagreCompound";
+import { isString } from "../util";
+
+interface DagreNodeData extends Node {
+  layer?: number;
+}
+
 export class Layout {
   public readonly layoutInstance: Base;
 
@@ -36,9 +42,36 @@ export class Layout {
   }
 
   init(data: Model) {
+    this.correctLayers(data.nodes);
     this.layoutInstance.init(data);
   }
 
+  /**
+   * correcting the layers on the node data
+   * if min(layer) <= 0, layers should begin from abs(min(layer)) + 1
+   * @param nodes 
+   * @returns 
+   */
+   correctLayers(nodes: DagreNodeData[] | undefined) {
+    if (!nodes?.length) return;
+    let minLayer = Infinity;
+    const hasLayerNodes: DagreNodeData[] = [];
+    nodes.forEach((node) => {
+      if (isString(node.layer)) {
+        node.layer = parseInt(node.layer, 10);
+      }
+      // keep node.layer === undefined for TS problem
+      if (node.layer === undefined || isNaN(node.layer)) return;
+      hasLayerNodes.push(node);
+      if (node.layer < minLayer) minLayer = node.layer;
+    });
+    if (minLayer <= 0) {
+      const layerOffset = Math.abs(minLayer) + 1;
+      // @ts-ignore
+      hasLayerNodes.forEach((node) => node.layer += layerOffset);
+    }
+  }
+
   execute() {
     this.layoutInstance.execute();
   }

package/src/layout/types.ts

@@ -268,7 +268,7 @@ export interface Force2LayoutOptions {
   gravity?: number;
   factor?: number;
   workerEnabled?: boolean;
-  centripetalOptions?: CentripetalOptions
+  centripetalOptions?: CentripetalOptions;
   leafCluster?: boolean;
   clustering?: boolean;
   nodeClusterBy?: string;

package/src/util/gpu.ts

@@ -63,7 +63,6 @@ export const buildTextureData = (nodes: OutNode[], edges: Edge[]): {
     const offset: number = dataArray.length;
     const dests = nodeDict[i];
     const len = dests.length;
-    console.log('dests', dests, len)
     dataArray[i * 4 + 2] = offset;
     dataArray[i * 4 + 3] = len;
     maxEdgePerVetex = Math.max(maxEdgePerVetex, len);

package/src/util/math.ts

@@ -35,14 +35,14 @@ export const getDegree = (n: number, nodeIdxMap: IndexMap, edges: Edge[] | null)
 };
 
 export const getDegreeMap = (nodes: Node[], edges: Edge[] | null) => {
-  const degreesMap: { [id: string]: Degree } = {}
-  nodes.forEach(node => {
+  const degreesMap: { [id: string]: Degree } = {};
+  nodes.forEach((node) => {
     degreesMap[node.id] = {
       in: 0,
       out: 0,
       all: 0
-    }
-  })
+    };
+  });
 
   if (!edges) return degreesMap;
   edges.forEach((e) => {
@@ -111,19 +111,17 @@ export const getAdjMatrix = (data: Model, directed: boolean): Matrix[] => {
     });
   }
 
-  if (edges) {
-    edges.forEach((e) => {
-      const source = getEdgeTerminal(e, 'source');
-      const target = getEdgeTerminal(e, 'target');
-      const sIndex = nodeMap[source as string];
-      const tIndex = nodeMap[target as string];
-      matrix[sIndex][tIndex] = 1;
-      if (!directed) {
-        matrix[tIndex][sIndex] = 1;
-      }
-    });
-  }
-
+  edges?.forEach((e) => {
+    const source = getEdgeTerminal(e, 'source');
+    const target = getEdgeTerminal(e, 'target');
+    const sIndex = nodeMap[source as string];
+    const tIndex = nodeMap[target as string];
+    if (sIndex === undefined || tIndex === undefined) return;
+    matrix[sIndex][tIndex] = 1;
+    if (!directed) {
+      matrix[tIndex][sIndex] = 1;
+    }
+  });
   return matrix;
 };
 
@@ -195,8 +193,8 @@ export const findMinMaxNodeXY = (nodes: OutNode[]) => {
  * @returns 平局内置
  */
 export const getAvgNodePosition = (nodes: OutNode[]) => {
-  let totalNodes = { x: 0, y: 0 };
-  nodes.forEach(node => {
+  const totalNodes = { x: 0, y: 0 };
+  nodes.forEach((node) => {
     totalNodes.x += node.x || 0;
     totalNodes.y += node.y || 0;
   });
@@ -211,26 +209,26 @@ export const getAvgNodePosition = (nodes: OutNode[]) => {
 // 找出指定节点关联的边的起点或终点
 const getCoreNode = (type: 'source' | 'target', node: Node, edges: Edge[]) => {
   if (type === 'source') {
-    return (edges?.find(edge => edge.target === node.id)?.source || {}) as Node;
+    return (edges?.find((edge) => edge.target === node.id)?.source || {}) as Node;
   }
-  return (edges?.find(edge => edge.source === node.id)?.target || {}) as Node;
+  return (edges?.find((edge) => edge.source === node.id)?.target || {}) as Node;
 };
 
 // 找出指定节点为起点或终点的所有一度叶子节点
 const getRelativeNodeIds = (type: 'source' | 'target' | 'both', coreNode: Node, edges: Edge[]) => {
-  let relativeNodes: string[] = []
+  let relativeNodes: string[] = [];
   switch (type) {
     case 'source':
-      relativeNodes = edges?.filter(edge => edge.source === coreNode.id).map(edge => edge.target);
+      relativeNodes = edges?.filter((edge) => edge.source === coreNode.id).map((edge) => edge.target);
       break;
     case 'target':
-      relativeNodes = edges?.filter(edge => edge.target === coreNode.id).map(edge => edge.source);
+      relativeNodes = edges?.filter((edge) => edge.target === coreNode.id).map((edge) => edge.source);
       break;
     case 'both':
       relativeNodes = edges
-        ?.filter(edge => edge.source === coreNode.id)
-        .map(edge => edge.target)
-        .concat(edges?.filter(edge => edge.target === coreNode.id).map(edge => edge.source));
+        ?.filter((edge) => edge.source === coreNode.id)
+        .map((edge) => edge.target)
+        .concat(edges?.filter((edge) => edge.target === coreNode.id).map((edge) => edge.source));
       break;
     default:
       break;
@@ -244,9 +242,9 @@ const getSameTypeNodes = (type: 'leaf' | 'all', nodeClusterBy: string, node: Nod
   // @ts-ignore
   const typeName = node[nodeClusterBy] || '';
   // @ts-ignore
-  let sameTypeNodes = relativeNodes?.filter(item => item[nodeClusterBy] === typeName) || [];
+  let sameTypeNodes = relativeNodes?.filter((item) => item[nodeClusterBy] === typeName) || [];
   if (type === 'leaf') {
-    sameTypeNodes = sameTypeNodes.filter(node => degreesMap[node.id]?.in === 0 ||degreesMap[node.id]?.out === 0);
+    sameTypeNodes = sameTypeNodes.filter((node) => degreesMap[node.id]?.in === 0 ||degreesMap[node.id]?.out === 0);
   }
   return sameTypeNodes;
 };
@@ -260,14 +258,14 @@ export const getCoreNodeAndRelativeLeafNodes = (type: 'leaf' | 'all', node: Node
   if (inDegree === 0) {
     // 如果为没有出边的叶子节点，则找出与它关联的边的起点出发的所有一度节点
     coreNode = getCoreNode('source', node, edges);
-    relativeLeafNodes = getRelativeNodeIds('both', coreNode, edges).map(nodeId => nodeMap[nodeId]);
+    relativeLeafNodes = getRelativeNodeIds('both', coreNode, edges).map((nodeId) => nodeMap[nodeId]);
   } else if (outDegree === 0) {
     // 如果为没有入边边的叶子节点，则找出与它关联的边的起点出发的所有一度节点
     coreNode = getCoreNode('target', node, edges);
-    relativeLeafNodes = getRelativeNodeIds('both', coreNode, edges).map(nodeId => nodeMap[nodeId]);
+    relativeLeafNodes = getRelativeNodeIds('both', coreNode, edges).map((nodeId) => nodeMap[nodeId]);
   }
   relativeLeafNodes = relativeLeafNodes.filter(
-    node => degreesMap[node.id] && (degreesMap[node.id].in === 0 || degreesMap[node.id].out === 0),
+    (node) => degreesMap[node.id] && (degreesMap[node.id].in === 0 || degreesMap[node.id].out === 0),
   );
   const sameTypeLeafNodes = getSameTypeNodes(type, nodeClusterBy, node, relativeLeafNodes, degreesMap);
   return { coreNode, relativeLeafNodes, sameTypeLeafNodes };

package/src/util/object.ts

@@ -15,7 +15,7 @@ export const clone = <T>(target: T): T => {
     });
     return cp.map((n: any) => clone<any>(n)) as any;
   }
-  if (typeof target === 'object' && target !== {}) {
+  if (typeof target === 'object' && Object.keys(target).length) {
     const cp = { ...(target as { [key: string]: any }) } as {
       [key: string]: any
     };