@antv/layout 0.3.12 → 1.0.0-alpha.0

package/src/util/gpu.ts

@@ -1,256 +0,0 @@
-import { OutNode, Edge, IndexMap } from '../layout/types';
-import { isNumber } from './';
-import { getEdgeTerminal } from './math';
-
-
-/**
- * 将 number | Function 类型的参数转换为 return number 的 Function
- * @param  {number | Function}  value 需要被转换的值
- * @param  {number}  defaultV 返回函数的默认返回值
- * @return {Function} 转换后的函数 
- */
-export const proccessToFunc = (value: number | Function | undefined, defaultV?: number): ((d?: any) => number) => {
-  let func;
-  if (!value) {
-      func = () => {
-          return defaultV || 1;
-      };
-  } else if (isNumber(value)) {
-      func = () => {
-          return value;
-      };
-  } else {
-      func = value;
-  }
-  return func as ((d?: any) => number);
-};
-
-/**
- * 将节点和边数据转换为 GPU 可读的数组。并返回 maxEdgePerVetex，每个节点上最多的边数
- * @param  {NodeConfig[]}  nodes 需要被转换的值
- * @param  {EdgeConfig[]}  edges 返回函数的默认返回值
- * @return {Object} 转换后的数组及 maxEdgePerVetex 组成的对象
- */
-export const buildTextureData = (nodes: OutNode[], edges: Edge[]): {
-  array: Float32Array,
-  maxEdgePerVetex: number
-} => {
-  const dataArray = [];
-  const nodeDict: any = [];
-  const mapIdPos: IndexMap = {};
-  let i = 0;
-  for (i = 0; i < nodes.length; i++) {
-    const n = nodes[i];
-    mapIdPos[n.id] = i;
-    dataArray.push(n.x);
-    dataArray.push(n.y);
-    dataArray.push(0);
-    dataArray.push(0);
-    nodeDict.push([]);
-  }
-  for (i = 0; i < edges.length; i++) {
-    const e = edges[i];
-    const source = getEdgeTerminal(e, 'source');
-    const target = getEdgeTerminal(e, 'target');
-    if (!isNaN(mapIdPos[source]) && !isNaN(mapIdPos[target])) {
-      nodeDict[mapIdPos[source]].push(mapIdPos[target]);
-      nodeDict[mapIdPos[target]].push(mapIdPos[source]);
-    }
-  }
-
-  let maxEdgePerVetex = 0;
-  for (i = 0; i < nodes.length; i++) {
-    const offset: number = dataArray.length;
-    const dests = nodeDict[i];
-    const len = dests.length;
-    dataArray[i * 4 + 2] = offset;
-    dataArray[i * 4 + 3] = len;
-    maxEdgePerVetex = Math.max(maxEdgePerVetex, len);
-    for (let j = 0; j < len; ++j) {
-      const dest = dests[j];
-      dataArray.push(+dest);
-    }
-  }
-
-  while (dataArray.length % 4 !== 0) {
-      dataArray.push(0);
-  }
-  return {
-    maxEdgePerVetex,
-    array: new Float32Array(dataArray),
-  };
-};
-
-/**
-* 将节点和边数据转换为 GPU 可读的数组，每条边带有一个属性。并返回 maxEdgePerVetex，每个节点上最多的边数
-* @param  {NodeConfig[]}  nodes 节点数组
-* @param  {EdgeConfig[]}  edges 边数组
-* @param  {Function}  attrs 读取边属性的函数
-* @return {Object} 转换后的数组及 maxEdgePerVetex 组成的对象
-*/
-// export const buildTextureDataWithOneEdgeAttr = (nodes: OutNode[], edges: Edge[], attrs: Function): {
-//   array: Float32Array,
-//   maxEdgePerVetex: number
-// } => {
-//   const dataArray = [];
-//   const nodeDict: any = [];
-//   const mapIdPos: IndexMap = {};
-//   let i = 0;
-//   for (i = 0; i < nodes.length; i++) {
-//       const n = nodes[i];
-//       mapIdPos[n.id] = i;
-//       dataArray.push(n.x);
-//       dataArray.push(n.y);
-//       dataArray.push(0);
-//       dataArray.push(0);
-//       nodeDict.push([]);
-//   }
-//   for (i = 0; i < edges.length; i++) {
-//       const e = edges[i];
-//       nodeDict[mapIdPos[e.source]].push(mapIdPos[e.target]);
-//       nodeDict[mapIdPos[e.source]].push(attrs(e)); // 理想边长，后续可以改成每条边不同
-//       nodeDict[mapIdPos[e.target]].push(mapIdPos[e.source]);
-//       nodeDict[mapIdPos[e.target]].push(attrs(e)); // 理想边长，后续可以改成每条边不同
-//   }
-
-//   let maxEdgePerVetex = 0;
-//   for (i = 0; i < nodes.length; i++) {
-//       const offset: number = dataArray.length;
-//       const dests = nodeDict[i]; // dest 中节点 id 与边长间隔存储，即一位节点 id，一位边长……
-//       const len = dests.length;
-//       dataArray[i * 4 + 2] = offset;
-//       dataArray[i * 4 + 3] = len / 2; // 第四位存储与该节点相关的所有节点个数
-//       maxEdgePerVetex = Math.max(maxEdgePerVetex, len / 2);
-//       for (let j = 0; j < len; ++j) {
-//           const dest = dests[j];
-//           dataArray.push(+dest);
-//       }
-//   }
-
-//   // 不是 4 的倍数，填充 0
-//   while (dataArray.length % 4 !== 0) {
-//       dataArray.push(0);
-//   }
-//   return {
-//       array: new Float32Array(dataArray),
-//       maxEdgePerVetex
-//   }
-// }
-
-/**
-* 将节点和边数据转换为 GPU 可读的数组，每条边带有一个以上属性。并返回 maxEdgePerVetex，每个节点上最多的边数
-* @param  {NodeConfig[]}  nodes 节点数组
-* @param  {EdgeConfig[]}  edges 边数组
-* @param  {Function}  attrs 读取边属性的函数
-* @return {Object} 转换后的数组及 maxEdgePerVetex 组成的对象
-*/
-export const buildTextureDataWithTwoEdgeAttr = (nodes: OutNode[], edges: Edge[], attrs1: Function, attrs2: Function): {
-  array: Float32Array,
-  maxEdgePerVetex: number
-} => {
-  const dataArray = [];
-  const nodeDict: any = [];
-  const mapIdPos: IndexMap = {};
-  let i = 0;
-  for (i = 0; i < nodes.length; i++) {
-    const n = nodes[i];
-    mapIdPos[n.id] = i;
-    dataArray.push(n.x);
-    dataArray.push(n.y);
-    dataArray.push(0);
-    dataArray.push(0);
-    nodeDict.push([]);
-  }
-  for (i = 0; i < edges.length; i++) {
-    const e = edges[i];
-    const source = getEdgeTerminal(e, 'source');
-    const target = getEdgeTerminal(e, 'target');
-    nodeDict[mapIdPos[source]].push(mapIdPos[target]);
-    nodeDict[mapIdPos[source]].push(attrs1(e));
-    nodeDict[mapIdPos[source]].push(attrs2(e));
-    nodeDict[mapIdPos[source]].push(0);
-    nodeDict[mapIdPos[target]].push(mapIdPos[source]);
-    nodeDict[mapIdPos[target]].push(attrs1(e));
-    nodeDict[mapIdPos[target]].push(attrs2(e));
-    nodeDict[mapIdPos[target]].push(0);
-  }
-
-  let maxEdgePerVetex = 0;
-  for (i = 0; i < nodes.length; i++) {
-    const offset: number = dataArray.length;
-    const dests = nodeDict[i]; // dest 中节点 id 与边长间隔存储，即一位节点 id，一位边长……
-    const len = dests.length;
-    // dataArray[i * 4 + 2] = offset;
-    // dataArray[i * 4 + 3] = len / 4; // 第四位存储与该节点相关的所有节点个数
-    // pack offset & length into float32: offset 20bit, length 12bit
-    dataArray[i * 4 + 2] = offset + 1048576 * len / 4;
-    dataArray[i * 4 + 3] = 0; // 第四位存储与上一次的距离差值
-    maxEdgePerVetex = Math.max(maxEdgePerVetex, len / 4);
-    for (let j = 0; j < len; ++j) {
-    const dest = dests[j];
-    dataArray.push(+dest);
-    }
-  }
-
-  // 不是 4 的倍数，填充 0
-  while (dataArray.length % 4 !== 0) {
-    dataArray.push(0);
-  }
-  return {
-    maxEdgePerVetex,
-    array: new Float32Array(dataArray),
-  };
-};
-/**
-* transform the extended attributes of nodes or edges to a texture array
-* @param  {string[]}  attributeNames attributes' name to be read from items and put into output array
-* @param  {ModelConfig[]}  items the items to be read
-* @return {Float32Array} the attributes' value array to be read by GPU
-*/
-export const attributesToTextureData = (attributeNames: string[], items: any[]): { array: Float32Array, count: number } => {
-  const dataArray: any[] = [];
-  const attributeNum = attributeNames.length;
-  const attributteStringMap: any = {};
-  items.forEach((item: any) => {
-    attributeNames.forEach((name: string, i) => {
-        if (attributteStringMap[item[name]] === undefined) {
-            attributteStringMap[item[name]] = Object.keys(attributteStringMap).length;
-        }
-        dataArray.push(attributteStringMap[item[name]]);
-        // insure each node's attributes take inter number of grids
-        if (i === attributeNum - 1) {
-            while (dataArray.length % 4 !== 0) {
-                dataArray.push(0);
-            }
-        }
-    });
-  });
-  return {
-      array: new Float32Array(dataArray),
-      count: Object.keys(attributteStringMap).length
-  };
-};
-
-/**
-* transform the number array format of extended attributes of nodes or edges to a texture array
-* @param  {string[]}  attributeNames attributes' name to be read from items and put into output array
-* @return {Float32Array} the attributes' value array to be read by GPU
-*/
-export const arrayToTextureData = (valueArrays: number[][]): Float32Array => {
-  const dataArray: any[] = [];
-  const attributeNum = valueArrays.length;
-  const itemNum = valueArrays[0].length;
-  for (let j = 0; j < itemNum; j++) {
-      valueArrays.forEach((valueArray, i) => {
-          dataArray.push(valueArray[j]);
-          // insure each node's attributes take inter number of grids
-          if (i === attributeNum - 1) {
-              while (dataArray.length % 4 !== 0) {
-                  dataArray.push(0);
-              }
-          }
-      });
-  }
-
-  return new Float32Array(dataArray);
-};

package/src/util/index.ts

@@ -1,6 +0,0 @@
-export * from './string';
-export * from './array';
-export * from './number';
-export * from './math';
-export * from './object';
-export * from './function';

package/src/util/math.ts

@@ -1,294 +0,0 @@
-import { Matrix, Model, IndexMap, Edge, Node, OutNode, Degree, NodeMap } from '../layout/types';
-import { isArray } from './array';
-import { isNumber } from './number';
-import { isObject } from './object';
-
-export const getEdgeTerminal = (edge: Edge, type: 'source' | 'target') => {
-  const terminal = edge[type];
-  if (isObject(terminal)) {
-    return terminal.cell;
-  }
-  return terminal;
-};
-
-export const getDegree = (n: number, nodeIdxMap: IndexMap, edges: Edge[] | null) => {
-  const degrees: Degree[] = [];
-  for (let i = 0; i < n; i++) {
-    degrees[i] = {
-      in: 0,
-      out: 0,
-      all: 0
-    };
-  }
-  if (!edges) return degrees;
-  edges.forEach((e) => {
-    const source = getEdgeTerminal(e, 'source');
-    const target = getEdgeTerminal(e, 'target');
-    if (source && degrees[nodeIdxMap[source]]) {
-      degrees[nodeIdxMap[source]].out += 1;
-      degrees[nodeIdxMap[source]].all += 1;
-    }
-    if (target && degrees[nodeIdxMap[target]]) {
-      degrees[nodeIdxMap[target]].in += 1;
-      degrees[nodeIdxMap[target]].all += 1;
-    }
-  });
-  return degrees;
-};
-
-export const getDegreeMap = (nodes: Node[], edges: Edge[] | null) => {
-  const degreesMap: { [id: string]: Degree } = {};
-  nodes.forEach((node) => {
-    degreesMap[node.id] = {
-      in: 0,
-      out: 0,
-      all: 0
-    };
-  });
-
-  if (!edges) return degreesMap;
-  edges.forEach((e) => {
-    const source = getEdgeTerminal(e, 'source');
-    const target = getEdgeTerminal(e, 'target');
-    if (source) {
-      degreesMap[source].out += 1;
-      degreesMap[source].all += 1;
-    }
-    if (target) {
-      degreesMap[target].in += 1;
-      degreesMap[target].all += 1;
-    }
-  });
-  return degreesMap;
-};
-
-export const floydWarshall = (adjMatrix: Matrix[]): Matrix[] => {
-  // initialize
-  const dist: Matrix[] = [];
-  const size = adjMatrix.length;
-  for (let i = 0; i < size; i += 1) {
-    dist[i] = [];
-    for (let j = 0; j < size; j += 1) {
-      if (i === j) {
-        dist[i][j] = 0;
-      } else if (adjMatrix[i][j] === 0 || !adjMatrix[i][j]) {
-        dist[i][j] = Infinity;
-      } else {
-        dist[i][j] = adjMatrix[i][j];
-      }
-    }
-  }
-  // floyd
-  for (let k = 0; k < size; k += 1) {
-    for (let i = 0; i < size; i += 1) {
-      for (let j = 0; j < size; j += 1) {
-        if (dist[i][j] > dist[i][k] + dist[k][j]) {
-          dist[i][j] = dist[i][k] + dist[k][j];
-        }
-      }
-    }
-  }
-  return dist;
-};
-
-export const getAdjMatrix = (data: Model, directed: boolean): Matrix[] => {
-  const {
-    nodes,
-    edges
-  } = data;
-  const matrix: Matrix[] = [];
-  // map node with index in data.nodes
-  const nodeMap: {
-    [key: string]: number;
-  } = {};
-
-  if (!nodes) {
-    throw new Error('invalid nodes data!');
-  }
-  if (nodes) {
-    nodes.forEach((node, i) => {
-      nodeMap[node.id] = i;
-      const row: number[] = [];
-      matrix.push(row);
-    });
-  }
-
-  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;
-};
-
-/**
- * scale matrix
- * @param matrix [ [], [], [] ]
- * @param ratio
- */
-export const scaleMatrix = (matrix: Matrix[], ratio: number) => {
-  const result: Matrix[] = [];
-  matrix.forEach((row) => {
-    const newRow: number[] = [];
-    row.forEach((v) => {
-      newRow.push(v * ratio);
-    });
-    result.push(newRow);
-  });
-  return result;
-};
-
-/**
- * depth first traverse, from leaves to root, children in inverse order
- *  if the fn returns false, terminate the traverse
- */
-const traverseUp = <T extends { children?: T[] }>(data: T, fn: (param: T) => boolean) => {
-  if (data && data.children) {
-    for (let i = data.children.length - 1; i >= 0; i--) {
-      if (!traverseUp(data.children[i], fn)) return;
-    }
-  }
-
-  if (!fn(data)) {
-    return false;
-  }
-  return true;
-};
-
-/**
- * depth first traverse, from leaves to root, children in inverse order
- * if the fn returns false, terminate the traverse
- */
-export const traverseTreeUp = <T extends { children?: T[] }>(
-  data: T,
-  fn: (param: T) => boolean,
-) => {
-  if (typeof fn !== 'function') {
-    return;
-  }
-  traverseUp(data, fn);
-};
-
-/**
- * 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: OutNode[]) => {
-  let minX = Infinity;
-  let minY = Infinity;
-  let maxX = -Infinity;
-  let maxY = -Infinity;
-  nodes.forEach((node) => {
-    let size = node.size;
-    if (isArray(size)) {
-      if (size.length === 1) size = [size[0], size[0]];
-    }  else if (isNumber(size)) {
-      size = [size, size];
-    } else if (size === undefined || isNaN(size as any)) {
-      size = [30, 30];
-    }
-
-    const halfSize = [size[0] / 2, size[1] / 2];
-    const left = node.x - halfSize[0];
-    const right = node.x + halfSize[0];
-    const top = node.y - halfSize[1];
-    const bottom = node.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 };
-};
-
-/**
- * 获取节点集合的平均位置信息
- * @param nodes 节点集合
- * @returns 平局内置
- */
-export const getAvgNodePosition = (nodes: OutNode[]) => {
-  const totalNodes = { x: 0, y: 0 };
-  nodes.forEach((node) => {
-    totalNodes.x += node.x || 0;
-    totalNodes.y += node.y || 0;
-  });
-  // 获取均值向量
-  const length = nodes.length || 1;
-  return {
-    x: totalNodes.x / length,
-    y: totalNodes.y / length,
-  };
-};
-
-// 找出指定节点关联的边的起点或终点
-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.source === node.id)?.target || {}) as Node;
-};
-
-// 找出指定节点为起点或终点的所有一度叶子节点
-const getRelativeNodeIds = (type: 'source' | 'target' | 'both', coreNode: Node, edges: Edge[]) => {
-  let relativeNodes: string[] = [];
-  switch (type) {
-    case 'source':
-      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);
-      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));
-      break;
-    default:
-      break;
-  }
-  // 去重
-  const set = new Set(relativeNodes);
-  return Array.from(set);
-};
-// 找出同类型的节点
-const getSameTypeNodes = (type: 'leaf' | 'all', nodeClusterBy: string, node: Node, relativeNodes: Node[], degreesMap: { [id: string]: Degree }) => {
-  // @ts-ignore
-  const typeName = node[nodeClusterBy] || '';
-  // @ts-ignore
-  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);
-  }
-  return sameTypeNodes;
-};
-
-
-// 找出与指定节点关联的边的起点或终点出发的所有一度叶子节点
-export const getCoreNodeAndRelativeLeafNodes = (type: 'leaf' | 'all', node: Node, edges: Edge[], nodeClusterBy: string, degreesMap: { [id: string]: Degree }, nodeMap: NodeMap) => {
-  const { in: inDegree, out: outDegree } = degreesMap[node.id];
-  let coreNode: Node = node;
-  let relativeLeafNodes: Node[] = [];
-  if (inDegree === 0) {
-    // 如果为没有出边的叶子节点，则找出与它关联的边的起点出发的所有一度节点
-    coreNode = getCoreNode('source', node, edges);
-    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 = relativeLeafNodes.filter(
-    (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/number.ts

@@ -1,8 +0,0 @@
-export const isNumber = (val: unknown): val is Number => typeof val === 'number';
-
-export const isNaN = (num: unknown) => Number.isNaN(Number(num));
-
-export const toNumber = (val: any): any => {
-  const n = parseFloat(val);
-  return isNaN(n) ? val : n;
-};

package/src/util/object.ts

@@ -1,28 +0,0 @@
-export const isObject = (val: unknown): val is Record<any, any> =>
-  val !== null && typeof val === 'object';
-
-export const clone = <T>(target: T): T => {
-  if (target === null) {
-    return target;
-  }
-  if (target instanceof Date) {
-    return new Date(target.getTime()) as any;
-  }
-  if (target instanceof Array) {
-    const cp = [] as any[]
-    ;(target as any[]).forEach((v) => {
-      cp.push(v);
-    });
-    return cp.map((n: any) => clone<any>(n)) as any;
-  }
-  if (typeof target === 'object' && Object.keys(target).length) {
-    const cp = { ...(target as { [key: string]: any }) } as {
-      [key: string]: any
-    };
-    Object.keys(cp).forEach((k) => {
-      cp[k] = clone<any>(cp[k]);
-    });
-    return cp as T;
-  }
-  return target;
-};

package/src/util/string.ts

@@ -1,18 +0,0 @@
-export const isString = (val: unknown): val is string => typeof val === 'string';
-
-const cacheStringFunction = <T extends (str: string) => string>(fn: T): T => {
-  const cache: Record<string, string> = Object.create(null);
-  return ((str: string) => {
-    const hit = cache[str];
-    return hit || (cache[str] = fn(str));
-  }) as any;
-};
-
-const camelizeRE = /-(\w)/g;
-export const camelize = cacheStringFunction((str: string): string => {
-  return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : ''));
-});
-
-// export const capitalize = cacheStringFunction(
-//   (str: string) => str.charAt(0).toUpperCase() + str.slice(1),
-// )