vis.js is a dynamic, browser-based visualization library
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

649 lines
21 KiB

  1. let util = require("../../util");
  2. import Cluster from './components/nodes/Cluster'
  3. class ClusterEngine {
  4. constructor(body) {
  5. this.body = body;
  6. this.clusteredNodes = {};
  7. this.options = {};
  8. this.defaultOptions = {};
  9. util.extend(this.options, this.defaultOptions);
  10. this.body.emitter.on('_resetData', () => {this.clusteredNodes = {};})
  11. }
  12. setOptions(options) {
  13. if (options !== undefined) {
  14. }
  15. }
  16. /**
  17. *
  18. * @param hubsize
  19. * @param options
  20. */
  21. clusterByHubsize(hubsize, options) {
  22. if (hubsize === undefined) {
  23. hubsize = this._getHubSize();
  24. }
  25. else if (typeof(hubsize) === "object") {
  26. options = this._checkOptions(hubsize);
  27. hubsize = this._getHubSize();
  28. }
  29. let nodesToCluster = [];
  30. for (let i = 0; i < this.body.nodeIndices.length; i++) {
  31. let node = this.body.nodes[this.body.nodeIndices[i]];
  32. if (node.edges.length >= hubsize) {
  33. nodesToCluster.push(node.id);
  34. }
  35. }
  36. for (let i = 0; i < nodesToCluster.length; i++) {
  37. this.clusterByConnection(nodesToCluster[i],options,false);
  38. }
  39. this.body.emitter.emit('_dataChanged');
  40. }
  41. /**
  42. * loop over all nodes, check if they adhere to the condition and cluster if needed.
  43. * @param options
  44. * @param refreshData
  45. */
  46. cluster(options = {}, refreshData = true) {
  47. if (options.joinCondition === undefined) {throw new Error("Cannot call clusterByNodeData without a joinCondition function in the options.");}
  48. // check if the options object is fine, append if needed
  49. options = this._checkOptions(options);
  50. let childNodesObj = {};
  51. let childEdgesObj = {};
  52. // collect the nodes that will be in the cluster
  53. for (let i = 0; i < this.body.nodeIndices.length; i++) {
  54. let nodeId = this.body.nodeIndices[i];
  55. let node = this.body.nodes[nodeId];
  56. let clonedOptions = this._cloneOptions(node);
  57. if (options.joinCondition(clonedOptions) === true) {
  58. childNodesObj[nodeId] = this.body.nodes[nodeId];
  59. // collect the nodes that will be in the cluster
  60. for (let i = 0; i < node.edges.length; i++) {
  61. let edge = node.edges[i];
  62. childEdgesObj[edge.id] = edge;
  63. }
  64. }
  65. }
  66. this._cluster(childNodesObj, childEdgesObj, options, refreshData);
  67. }
  68. /**
  69. * Cluster all nodes in the network that have only 1 edge
  70. * @param options
  71. * @param refreshData
  72. */
  73. clusterOutliers(options, refreshData = true) {
  74. options = this._checkOptions(options);
  75. let clusters = [];
  76. // collect the nodes that will be in the cluster
  77. for (let i = 0; i < this.body.nodeIndices.length; i++) {
  78. let childNodesObj = {};
  79. let childEdgesObj = {};
  80. let nodeId = this.body.nodeIndices[i];
  81. let visibleEdges = 0;
  82. let edge;
  83. for (let j = 0; j < this.body.nodes[nodeId].edges.length; j++) {
  84. if (this.body.nodes[nodeId].edges[j].options.hidden === false) {
  85. visibleEdges++;
  86. edge = this.body.nodes[nodeId].edges[j];
  87. }
  88. }
  89. if (visibleEdges === 1) {
  90. // this is an outlier
  91. let childNodeId = this._getConnectedId(edge, nodeId);
  92. if (childNodeId !== nodeId) {
  93. if (options.joinCondition === undefined) {
  94. if (this._checkIfUsed(clusters,nodeId,edge.id) === false && this._checkIfUsed(clusters,childNodeId,edge.id) === false) {
  95. childEdgesObj[edge.id] = edge;
  96. childNodesObj[nodeId] = this.body.nodes[nodeId];
  97. childNodesObj[childNodeId] = this.body.nodes[childNodeId];
  98. }
  99. }
  100. else {
  101. let clonedOptions = this._cloneOptions(this.body.nodes[nodeId]);
  102. if (options.joinCondition(clonedOptions) === true && this._checkIfUsed(clusters,nodeId,edge.id) === false) {
  103. childEdgesObj[edge.id] = edge;
  104. childNodesObj[nodeId] = this.body.nodes[nodeId];
  105. }
  106. clonedOptions = this._cloneOptions(this.body.nodes[childNodeId]);
  107. if (options.joinCondition(clonedOptions) === true && this._checkIfUsed(clusters,nodeId,edge.id) === false) {
  108. childEdgesObj[edge.id] = edge;
  109. childNodesObj[childNodeId] = this.body.nodes[childNodeId];
  110. }
  111. }
  112. if (Object.keys(childNodesObj).length > 0 && Object.keys(childEdgesObj).length > 0) {
  113. clusters.push({nodes: childNodesObj, edges: childEdgesObj})
  114. }
  115. }
  116. }
  117. }
  118. for (let i = 0; i < clusters.length; i++) {
  119. this._cluster(clusters[i].nodes, clusters[i].edges, options, false)
  120. }
  121. if (refreshData === true) {
  122. this.body.emitter.emit('_dataChanged');
  123. }
  124. }
  125. _checkIfUsed(clusters, nodeId, edgeId) {
  126. for (let i = 0; i < clusters.length; i++) {
  127. let cluster = clusters[i];
  128. if (cluster.nodes[nodeId] !== undefined || cluster.edges[edgeId] !== undefined) {
  129. return true;
  130. }
  131. }
  132. return false;
  133. }
  134. /**
  135. * suck all connected nodes of a node into the node.
  136. * @param nodeId
  137. * @param options
  138. * @param refreshData
  139. */
  140. clusterByConnection(nodeId, options, refreshData = true) {
  141. // kill conditions
  142. if (nodeId === undefined) {throw new Error("No nodeId supplied to clusterByConnection!");}
  143. if (this.body.nodes[nodeId] === undefined) {throw new Error("The nodeId given to clusterByConnection does not exist!");}
  144. let node = this.body.nodes[nodeId];
  145. options = this._checkOptions(options, node);
  146. if (options.clusterNodeProperties.x === undefined) {options.clusterNodeProperties.x = node.x;}
  147. if (options.clusterNodeProperties.y === undefined) {options.clusterNodeProperties.y = node.y;}
  148. if (options.clusterNodeProperties.fixed === undefined) {
  149. options.clusterNodeProperties.fixed = {};
  150. options.clusterNodeProperties.fixed.x = node.options.fixed.x;
  151. options.clusterNodeProperties.fixed.y = node.options.fixed.y;
  152. }
  153. let childNodesObj = {};
  154. let childEdgesObj = {};
  155. let parentNodeId = node.id;
  156. let parentClonedOptions = this._cloneOptions(node);
  157. childNodesObj[parentNodeId] = node;
  158. // collect the nodes that will be in the cluster
  159. for (let i = 0; i < node.edges.length; i++) {
  160. let edge = node.edges[i];
  161. let childNodeId = this._getConnectedId(edge, parentNodeId);
  162. if (childNodeId !== parentNodeId) {
  163. if (options.joinCondition === undefined) {
  164. childEdgesObj[edge.id] = edge;
  165. childNodesObj[childNodeId] = this.body.nodes[childNodeId];
  166. }
  167. else {
  168. // clone the options and insert some additional parameters that could be interesting.
  169. let childClonedOptions = this._cloneOptions(this.body.nodes[childNodeId]);
  170. if (options.joinCondition(parentClonedOptions, childClonedOptions) === true) {
  171. childEdgesObj[edge.id] = edge;
  172. childNodesObj[childNodeId] = this.body.nodes[childNodeId];
  173. }
  174. }
  175. }
  176. else {
  177. childEdgesObj[edge.id] = edge;
  178. }
  179. }
  180. this._cluster(childNodesObj, childEdgesObj, options, refreshData);
  181. }
  182. /**
  183. * This returns a clone of the options or options of the edge or node to be used for construction of new edges or check functions for new nodes.
  184. * @param objId
  185. * @param type
  186. * @returns {{}}
  187. * @private
  188. */
  189. _cloneOptions(item, type) {
  190. let clonedOptions = {};
  191. if (type === undefined || type === 'node') {
  192. util.deepExtend(clonedOptions, item.options, true);
  193. clonedOptions.x = item.x;
  194. clonedOptions.y = item.y;
  195. clonedOptions.amountOfConnections = item.edges.length;
  196. }
  197. else {
  198. util.deepExtend(clonedOptions, item.options, true);
  199. }
  200. return clonedOptions;
  201. }
  202. /**
  203. * This function creates the edges that will be attached to the cluster.
  204. *
  205. * @param childNodesObj
  206. * @param childEdgesObj
  207. * @param newEdges
  208. * @param options
  209. * @private
  210. */
  211. _createClusterEdges (childNodesObj, childEdgesObj, newEdges, clusterNodeProperties, clusterEdgeProperties) {
  212. let edge, childNodeId, childNode, toId, fromId, otherNodeId;
  213. let childKeys = Object.keys(childNodesObj);
  214. for (let i = 0; i < childKeys.length; i++) {
  215. childNodeId = childKeys[i];
  216. childNode = childNodesObj[childNodeId];
  217. // construct new edges from the cluster to others
  218. for (let j = 0; j < childNode.edges.length; j++) {
  219. edge = childNode.edges[j];
  220. childEdgesObj[edge.id] = edge;
  221. // childNodeId position will be replaced by the cluster.
  222. if (edge.toId == childNodeId) { // this is a double equals because ints and strings can be interchanged here.
  223. toId = clusterNodeProperties.id;
  224. fromId = edge.fromId;
  225. otherNodeId = fromId;
  226. }
  227. else {
  228. toId = edge.toId;
  229. fromId = clusterNodeProperties.id;
  230. otherNodeId = toId;
  231. }
  232. // if the node connected to the cluster is also in the cluster we do not need a new edge.
  233. if (childNodesObj[otherNodeId] === undefined) {
  234. let clonedOptions = this._cloneOptions(edge, 'edge');
  235. util.deepExtend(clonedOptions, clusterEdgeProperties);
  236. clonedOptions.from = fromId;
  237. clonedOptions.to = toId;
  238. clonedOptions.id = 'clusterEdge:' + util.randomUUID();
  239. newEdges.push(this.body.functions.createEdge(clonedOptions))
  240. }
  241. }
  242. }
  243. }
  244. /**
  245. * This function checks the options that can be supplied to the different cluster functions
  246. * for certain fields and inserts defaults if needed
  247. * @param options
  248. * @returns {*}
  249. * @private
  250. */
  251. _checkOptions(options = {}) {
  252. if (options.clusterEdgeProperties === undefined) {options.clusterEdgeProperties = {};}
  253. if (options.clusterNodeProperties === undefined) {options.clusterNodeProperties = {};}
  254. return options;
  255. }
  256. /**
  257. *
  258. * @param {Object} childNodesObj | object with node objects, id as keys, same as childNodes except it also contains a source node
  259. * @param {Object} childEdgesObj | object with edge objects, id as keys
  260. * @param {Array} options | object with {clusterNodeProperties, clusterEdgeProperties, processProperties}
  261. * @param {Boolean} refreshData | when true, do not wrap up
  262. * @private
  263. */
  264. _cluster(childNodesObj, childEdgesObj, options, refreshData = true) {
  265. // kill condition: no children so cant cluster
  266. if (Object.keys(childNodesObj).length === 0) {return;}
  267. let clusterNodeProperties = util.deepExtend({},options.clusterNodeProperties);
  268. // construct the clusterNodeProperties
  269. if (options.processProperties !== undefined) {
  270. // get the childNode options
  271. let childNodesOptions = [];
  272. for (let nodeId in childNodesObj) {
  273. let clonedOptions = this._cloneOptions(childNodesObj[nodeId]);
  274. childNodesOptions.push(clonedOptions);
  275. }
  276. // get clusterproperties based on childNodes
  277. let childEdgesOptions = [];
  278. for (let edgeId in childEdgesObj) {
  279. let clonedOptions = this._cloneOptions(childEdgesObj[edgeId], 'edge');
  280. childEdgesOptions.push(clonedOptions);
  281. }
  282. clusterNodeProperties = options.processProperties(clusterNodeProperties, childNodesOptions, childEdgesOptions);
  283. if (!clusterNodeProperties) {
  284. throw new Error("The processProperties function does not return properties!");
  285. }
  286. }
  287. // check if we have an unique id;
  288. if (clusterNodeProperties.id === undefined) {clusterNodeProperties.id = 'cluster:' + util.randomUUID();}
  289. let clusterId = clusterNodeProperties.id;
  290. if (clusterNodeProperties.label === undefined) {
  291. clusterNodeProperties.label = 'cluster';
  292. }
  293. // give the clusterNode a postion if it does not have one.
  294. let pos = undefined;
  295. if (clusterNodeProperties.x === undefined) {
  296. pos = this._getClusterPosition(childNodesObj);
  297. clusterNodeProperties.x = pos.x;
  298. }
  299. if (clusterNodeProperties.y === undefined) {
  300. if (pos === undefined) {
  301. pos = this._getClusterPosition(childNodesObj);
  302. }
  303. clusterNodeProperties.y = pos.y;
  304. }
  305. // force the ID to remain the same
  306. clusterNodeProperties.id = clusterId;
  307. // create the clusterNode
  308. let clusterNode = this.body.functions.createNode(clusterNodeProperties, Cluster);
  309. clusterNode.isCluster = true;
  310. clusterNode.containedNodes = childNodesObj;
  311. clusterNode.containedEdges = childEdgesObj;
  312. // cache a copy from the cluster edge properties if we have to reconnect others later on
  313. clusterNode.clusterEdgeProperties = options.clusterEdgeProperties;
  314. // finally put the cluster node into global
  315. this.body.nodes[clusterNodeProperties.id] = clusterNode;
  316. // create the new edges that will connect to the cluster
  317. let newEdges = [];
  318. this._createClusterEdges(childNodesObj, childEdgesObj, newEdges, clusterNodeProperties, options.clusterEdgeProperties);
  319. // disable the childEdges
  320. for (let edgeId in childEdgesObj) {
  321. if (childEdgesObj.hasOwnProperty(edgeId)) {
  322. if (this.body.edges[edgeId] !== undefined) {
  323. let edge = this.body.edges[edgeId];
  324. edge.togglePhysics(false);
  325. edge.options.hidden = true;
  326. }
  327. }
  328. }
  329. // disable the childNodes
  330. for (let nodeId in childNodesObj) {
  331. if (childNodesObj.hasOwnProperty(nodeId)) {
  332. this.clusteredNodes[nodeId] = {clusterId:clusterNodeProperties.id, node: this.body.nodes[nodeId]};
  333. this.body.nodes[nodeId].togglePhysics(false);
  334. this.body.nodes[nodeId].options.hidden = true;
  335. }
  336. }
  337. // push new edges to global
  338. for (let i = 0; i < newEdges.length; i++) {
  339. this.body.edges[newEdges[i].id] = newEdges[i];
  340. this.body.edges[newEdges[i].id].connect();
  341. }
  342. // set ID to undefined so no duplicates arise
  343. clusterNodeProperties.id = undefined;
  344. // wrap up
  345. if (refreshData === true) {
  346. this.body.emitter.emit('_dataChanged');
  347. }
  348. }
  349. /**
  350. * Check if a node is a cluster.
  351. * @param nodeId
  352. * @returns {*}
  353. */
  354. isCluster(nodeId) {
  355. if (this.body.nodes[nodeId] !== undefined) {
  356. return this.body.nodes[nodeId].isCluster === true;
  357. }
  358. else {
  359. console.log("Node does not exist.");
  360. return false;
  361. }
  362. }
  363. /**
  364. * get the position of the cluster node based on what's inside
  365. * @param {object} childNodesObj | object with node objects, id as keys
  366. * @returns {{x: number, y: number}}
  367. * @private
  368. */
  369. _getClusterPosition(childNodesObj) {
  370. let childKeys = Object.keys(childNodesObj);
  371. let minX = childNodesObj[childKeys[0]].x;
  372. let maxX = childNodesObj[childKeys[0]].x;
  373. let minY = childNodesObj[childKeys[0]].y;
  374. let maxY = childNodesObj[childKeys[0]].y;
  375. let node;
  376. for (let i = 1; i < childKeys.length; i++) {
  377. node = childNodesObj[childKeys[i]];
  378. minX = node.x < minX ? node.x : minX;
  379. maxX = node.x > maxX ? node.x : maxX;
  380. minY = node.y < minY ? node.y : minY;
  381. maxY = node.y > maxY ? node.y : maxY;
  382. }
  383. return {x: 0.5*(minX + maxX), y: 0.5*(minY + maxY)};
  384. }
  385. /**
  386. * Open a cluster by calling this function.
  387. * @param {String} clusterNodeId | the ID of the cluster node
  388. * @param {Boolean} refreshData | wrap up afterwards if not true
  389. */
  390. openCluster(clusterNodeId, refreshData = true) {
  391. // kill conditions
  392. if (clusterNodeId === undefined) {throw new Error("No clusterNodeId supplied to openCluster.");}
  393. if (this.body.nodes[clusterNodeId] === undefined) {throw new Error("The clusterNodeId supplied to openCluster does not exist.");}
  394. if (this.body.nodes[clusterNodeId].containedNodes === undefined) {
  395. console.log("The node:" + clusterNodeId + " is not a cluster.");
  396. return
  397. }
  398. let clusterNode = this.body.nodes[clusterNodeId];
  399. let containedNodes = clusterNode.containedNodes;
  400. let containedEdges = clusterNode.containedEdges;
  401. // release nodes
  402. for (let nodeId in containedNodes) {
  403. if (containedNodes.hasOwnProperty(nodeId)) {
  404. let containedNode = this.body.nodes[nodeId];
  405. containedNode = containedNodes[nodeId];
  406. // inherit position
  407. containedNode.x = clusterNode.x;
  408. containedNode.y = clusterNode.y;
  409. // inherit speed
  410. containedNode.vx = clusterNode.vx;
  411. containedNode.vy = clusterNode.vy;
  412. containedNode.options.hidden = false;
  413. containedNode.togglePhysics(true);
  414. delete this.clusteredNodes[nodeId];
  415. }
  416. }
  417. // release edges
  418. for (let edgeId in containedEdges) {
  419. if (containedEdges.hasOwnProperty(edgeId)) {
  420. let edge = containedEdges[edgeId];
  421. // if this edge was a temporary edge and it's connected nodes do not exist anymore, we remove it from the data
  422. if (this.body.nodes[edge.fromId] === undefined || this.body.nodes[edge.toId] === undefined) {
  423. edge.edgeType.cleanup();
  424. // this removes the edge from node.edges, which is why edgeIds is formed
  425. edge.disconnect();
  426. delete this.body.edges[edgeId];
  427. }
  428. else {
  429. // one of the nodes connected to this edge is in a cluster. We give the edge to that cluster so it will be released when that cluster is opened.
  430. if (this.clusteredNodes[edge.fromId] !== undefined || this.clusteredNodes[edge.toId] !== undefined) {
  431. let fromId, toId;
  432. let clusteredNode = this.clusteredNodes[edge.fromId] || this.clusteredNodes[edge.toId];
  433. let clusterId = clusteredNode.clusterId;
  434. let clusterNode = this.body.nodes[clusterId];
  435. clusterNode.containedEdges[edgeId] = edge;
  436. if (this.clusteredNodes[edge.fromId] !== undefined) {
  437. fromId = clusterId;
  438. toId = edge.toId;
  439. }
  440. else {
  441. fromId = edge.fromId;
  442. toId = clusterId;
  443. }
  444. // if both from and to nodes are visible, we create a new temporary edge
  445. if (this.body.nodes[fromId].options.hidden !== true && this.body.nodes[toId].options.hidden !== true) {
  446. let clonedOptions = this._cloneOptions(edge, 'edge');
  447. let id = 'clusterEdge:' + util.randomUUID();
  448. util.deepExtend(clonedOptions, clusterNode.clusterEdgeProperties);
  449. util.deepExtend(clonedOptions, {from: fromId, to: toId, hidden: false, physics: true, id: id});
  450. let newEdge = this.body.functions.createEdge(clonedOptions);
  451. this.body.edges[id] = newEdge;
  452. this.body.edges[id].connect();
  453. }
  454. }
  455. else {
  456. edge.options.hidden = false;
  457. edge.togglePhysics(true);
  458. }
  459. }
  460. }
  461. }
  462. // remove all temporary edges
  463. for (let i = 0; i < clusterNode.edges.length; i++) {
  464. let edgeId = clusterNode.edges[i].id;
  465. this.body.edges[edgeId].edgeType.cleanup();
  466. // this removes the edge from node.edges, which is why edgeIds is formed
  467. this.body.edges[edgeId].disconnect();
  468. delete this.body.edges[edgeId];
  469. }
  470. // remove clusterNode
  471. delete this.body.nodes[clusterNodeId];
  472. if (refreshData === true) {
  473. this.body.emitter.emit('_dataChanged');
  474. }
  475. }
  476. getNodesInCluster(clusterId) {
  477. let nodesArray = []
  478. if (this.isCluster(clusterId) === true) {
  479. let containedNodes = this.body.nodes[clusterId].containedNodes;
  480. for (let nodeId in containedNodes) {
  481. if (containedNodes.hasOwnProperty(nodeId)) {
  482. nodesArray.push(nodeId)
  483. }
  484. }
  485. }
  486. return nodesArray;
  487. }
  488. /**
  489. * Get the stack clusterId's that a certain node resides in. cluster A -> cluster B -> cluster C -> node
  490. * @param nodeId
  491. * @returns {Array}
  492. * @private
  493. */
  494. findNode(nodeId) {
  495. let stack = [];
  496. let max = 100;
  497. let counter = 0;
  498. while (this.clusteredNodes[nodeId] !== undefined && counter < max) {
  499. stack.push(this.clusteredNodes[nodeId].node);
  500. nodeId = this.clusteredNodes[nodeId].clusterId;
  501. counter++;
  502. }
  503. stack.push(this.body.nodes[nodeId]);
  504. return stack;
  505. }
  506. /**
  507. * Get the Id the node is connected to
  508. * @param edge
  509. * @param nodeId
  510. * @returns {*}
  511. * @private
  512. */
  513. _getConnectedId(edge, nodeId) {
  514. if (edge.toId != nodeId) {
  515. return edge.toId;
  516. }
  517. else if (edge.fromId != nodeId) {
  518. return edge.fromId;
  519. }
  520. else {
  521. return edge.fromId;
  522. }
  523. }
  524. /**
  525. * We determine how many connections denote an important hub.
  526. * We take the mean + 2*std as the important hub size. (Assuming a normal distribution of data, ~2.2%)
  527. *
  528. * @private
  529. */
  530. _getHubSize() {
  531. let average = 0;
  532. let averageSquared = 0;
  533. let hubCounter = 0;
  534. let largestHub = 0;
  535. for (let i = 0; i < this.body.nodeIndices.length; i++) {
  536. let node = this.body.nodes[this.body.nodeIndices[i]];
  537. if (node.edges.length > largestHub) {
  538. largestHub = node.edges.length;
  539. }
  540. average += node.edges.length;
  541. averageSquared += Math.pow(node.edges.length,2);
  542. hubCounter += 1;
  543. }
  544. average = average / hubCounter;
  545. averageSquared = averageSquared / hubCounter;
  546. let letiance = averageSquared - Math.pow(average,2);
  547. let standardDeviation = Math.sqrt(letiance);
  548. let hubThreshold = Math.floor(average + 2*standardDeviation);
  549. // always have at least one to cluster
  550. if (hubThreshold > largestHub) {
  551. hubThreshold = largestHub;
  552. }
  553. return hubThreshold;
  554. };
  555. }
  556. export default ClusterEngine;