Browse Source
first modularizing experiment. Made body object containing data nodes, emitter, support functions. ClusterEngine is the first module.
flowchartTest
Alex de Mulder
9 years ago
13 changed files with 7703 additions and 7269 deletions
Unified View
Diff Options
-
+6747 -6963dist/vis.js
-
+1 -1dist/vis.min.css
-
+4 -4examples/network/39_newClustering.html
-
+6 -6lib/network/Edge.js
-
+182 -133lib/network/Network.js
-
+0 -15lib/network/mixins/ClusterMixin.js
-
+27 -27lib/network/mixins/HierarchicalLayoutMixin.js
-
+33 -34lib/network/mixins/ManipulationMixin.js
-
+6 -6lib/network/mixins/MixinLoader.js
-
+52 -52lib/network/mixins/SectorsMixin.js
-
+8 -8lib/network/mixins/SelectionMixin.js
-
+17 -20lib/network/mixins/physics/PhysicsMixin.js
-
+620 -0lib/network/modules/Clustering.js
+ 6747
- 6963
dist/vis.js
File diff suppressed because it is too large
View File
+ 1
- 1
dist/vis.min.css
File diff suppressed because it is too large
View File
+ 4
- 4
examples/network/39_newClustering.html
View File
+ 6
- 6
lib/network/Edge.js
View File
+ 182
- 133
lib/network/Network.js
View File
+ 0
- 15
lib/network/mixins/ClusterMixin.js
View File
+ 27
- 27
lib/network/mixins/HierarchicalLayoutMixin.js
View File
+ 33
- 34
lib/network/mixins/ManipulationMixin.js
View File
+ 6
- 6
lib/network/mixins/MixinLoader.js
View File
+ 52
- 52
lib/network/mixins/SectorsMixin.js
View File
+ 8
- 8
lib/network/mixins/SelectionMixin.js
View File
+ 17
- 20
lib/network/mixins/physics/PhysicsMixin.js
View File
+ 620
- 0
lib/network/modules/Clustering.js
View File
| @ -0,0 +1,620 @@ | |||||
| /** | |||||
| * Created by Alex on 24-Feb-15. | |||||
| */ | |||||
| var util = require("../../util"); | |||||
| class ClusterEngine { | |||||
| constructor(body, options={}) { | |||||
| this.body = body; | |||||
| this.clusteredNodes = {}; | |||||
| } | |||||
| /** | |||||
| * | |||||
| * @param hubsize | |||||
| * @param options | |||||
| */ | |||||
| clusterByConnectionCount(hubsize, options) { | |||||
| if (hubsize === undefined) { | |||||
| hubsize = this._getHubSize(); | |||||
| } | |||||
| else if (tyepof(hubsize) == "object") { | |||||
| options = this._checkOptions(hubsize); | |||||
| hubsize = this._getHubSize(); | |||||
| } | |||||
| var nodesToCluster = []; | |||||
| for (var i = 0; i < this.body.nodeIndices.length; i++) { | |||||
| var node = this.body.nodes[this.body.nodeIndices[i]]; | |||||
| if (node.edges.length >= hubsize) { | |||||
| nodesToCluster.push(node.id); | |||||
| } | |||||
| } | |||||
| for (var i = 0; i < nodesToCluster.length; i++) { | |||||
| var node = this.body.nodes[nodesToCluster[i]]; | |||||
| this.clusterByConnection(node,options,{},{},true); | |||||
| } | |||||
| this.body.emitter.emit('_dataChanged'); | |||||
| } | |||||
| /** | |||||
| * loop over all nodes, check if they adhere to the condition and cluster if needed. | |||||
| * @param options | |||||
| * @param doNotUpdateCalculationNodes | |||||
| */ | |||||
| clusterByNodeData(options = {}, doNotUpdateCalculationNodes=false) { | |||||
| if (options.joinCondition === undefined) {throw new Error("Cannot call clusterByNodeData without a joinCondition function in the options.");} | |||||
| // check if the options object is fine, append if needed | |||||
| options = this._checkOptions(options); | |||||
| var childNodesObj = {}; | |||||
| var childEdgesObj = {} | |||||
| // collect the nodes that will be in the cluster | |||||
| for (var i = 0; i < this.body.nodeIndices.length; i++) { | |||||
| var nodeId = this.body.nodeIndices[i]; | |||||
| var clonedOptions = this._cloneOptions(nodeId); | |||||
| if (options.joinCondition(clonedOptions) == true) { | |||||
| childNodesObj[nodeId] = this.body.nodes[nodeId]; | |||||
| } | |||||
| } | |||||
| this._cluster(childNodesObj, childEdgesObj, options, doNotUpdateCalculationNodes); | |||||
| } | |||||
| /** | |||||
| * Cluster all nodes in the network that have only 1 edge | |||||
| * @param options | |||||
| * @param doNotUpdateCalculationNodes | |||||
| */ | |||||
| clusterOutliers(options, doNotUpdateCalculationNodes) { | |||||
| options = this._checkOptions(options); | |||||
| var clusters = [] | |||||
| // collect the nodes that will be in the cluster | |||||
| for (var i = 0; i < this.body.nodeIndices.length; i++) { | |||||
| var childNodesObj = {}; | |||||
| var childEdgesObj = {}; | |||||
| var nodeId = this.body.nodeIndices[i]; | |||||
| if (this.body.nodes[nodeId].edges.length == 1) { | |||||
| var edge = this.body.nodes[nodeId].edges[0]; | |||||
| var childNodeId = this._getConnectedId(edge, nodeId); | |||||
| if (childNodeId != nodeId) { | |||||
| if (options.joinCondition === undefined) { | |||||
| childNodesObj[nodeId] = this.body.nodes[nodeId]; | |||||
| childNodesObj[childNodeId] = this.body.nodes[childNodeId]; | |||||
| } | |||||
| else { | |||||
| var clonedOptions = this._cloneOptions(nodeId); | |||||
| if (options.joinCondition(clonedOptions) == true) { | |||||
| childNodesObj[nodeId] = this.body.nodes[nodeId]; | |||||
| } | |||||
| clonedOptions = this._cloneOptions(childNodeId); | |||||
| if (options.joinCondition(clonedOptions) == true) { | |||||
| childNodesObj[childNodeId] = this.body.nodes[childNodeId]; | |||||
| } | |||||
| } | |||||
| clusters.push({nodes:childNodesObj, edges:childEdgesObj}) | |||||
| } | |||||
| } | |||||
| } | |||||
| for (var i = 0; i < clusters.length; i++) { | |||||
| this._cluster(clusters[i].nodes, clusters[i].edges, options, true) | |||||
| } | |||||
| if (doNotUpdateCalculationNodes !== true) { | |||||
| this.body.emitter.emit('_dataChanged'); | |||||
| } | |||||
| } | |||||
| /** | |||||
| * | |||||
| * @param nodeId | |||||
| * @param options | |||||
| * @param doNotUpdateCalculationNodes | |||||
| */ | |||||
| clusterByConnection(nodeId, options, doNotUpdateCalculationNodes) { | |||||
| // kill conditions | |||||
| if (nodeId === undefined) {throw new Error("No nodeId supplied to clusterByConnection!");} | |||||
| if (this.body.nodes[nodeId] === undefined) {throw new Error("The nodeId given to clusterByConnection does not exist!");} | |||||
| var node = this.body.nodes[nodeId]; | |||||
| options = this._checkOptions(options, node); | |||||
| if (options.clusterNodeProperties.x === undefined) {options.clusterNodeProperties.x = node.x; options.clusterNodeProperties.allowedToMoveX = !node.xFixed;} | |||||
| if (options.clusterNodeProperties.y === undefined) {options.clusterNodeProperties.y = node.y; options.clusterNodeProperties.allowedToMoveY = !node.yFixed;} | |||||
| var childNodesObj = {}; | |||||
| var childEdgesObj = {} | |||||
| var parentNodeId = node.id; | |||||
| var parentClonedOptions = this._cloneOptions(parentNodeId); | |||||
| childNodesObj[parentNodeId] = node; | |||||
| // collect the nodes that will be in the cluster | |||||
| for (var i = 0; i < node.edges.length; i++) { | |||||
| var edge = node.edges[i]; | |||||
| var childNodeId = this._getConnectedId(edge, parentNodeId); | |||||
| if (childNodeId !== parentNodeId) { | |||||
| if (options.joinCondition === undefined) { | |||||
| childEdgesObj[edge.id] = edge; | |||||
| childNodesObj[childNodeId] = this.body.nodes[childNodeId]; | |||||
| } | |||||
| else { | |||||
| // clone the options and insert some additional parameters that could be interesting. | |||||
| var childClonedOptions = this._cloneOptions(childNodeId); | |||||
| if (options.joinCondition(parentClonedOptions, childClonedOptions) == true) { | |||||
| childEdgesObj[edge.id] = edge; | |||||
| childNodesObj[childNodeId] = this.body.nodes[childNodeId]; | |||||
| } | |||||
| } | |||||
| } | |||||
| else { | |||||
| childEdgesObj[edge.id] = edge; | |||||
| } | |||||
| } | |||||
| this._cluster(childNodesObj, childEdgesObj, options, doNotUpdateCalculationNodes); | |||||
| } | |||||
| /** | |||||
| * This returns a clone of the options or properties of the edge or node to be used for construction of new edges or check functions for new nodes. | |||||
| * @param objId | |||||
| * @param type | |||||
| * @returns {{}} | |||||
| * @private | |||||
| */ | |||||
| _cloneOptions(objId, type) { | |||||
| var clonedOptions = {}; | |||||
| if (type === undefined || type == 'node') { | |||||
| util.deepExtend(clonedOptions, this.body.nodes[objId].options, true); | |||||
| util.deepExtend(clonedOptions, this.body.nodes[objId].properties, true); | |||||
| clonedOptions.amountOfConnections = this.body.nodes[objId].edges.length; | |||||
| } | |||||
| else { | |||||
| util.deepExtend(clonedOptions, this.body.edges[objId].properties, true); | |||||
| } | |||||
| return clonedOptions; | |||||
| } | |||||
| /** | |||||
| * This function creates the edges that will be attached to the cluster. | |||||
| * | |||||
| * @param childNodesObj | |||||
| * @param childEdgesObj | |||||
| * @param newEdges | |||||
| * @param options | |||||
| * @private | |||||
| */ | |||||
| _createClusterEdges (childNodesObj, childEdgesObj, newEdges, options) { | |||||
| var edge, childNodeId, childNode; | |||||
| var childKeys = Object.keys(childNodesObj); | |||||
| for (var i = 0; i < childKeys.length; i++) { | |||||
| childNodeId = childKeys[i]; | |||||
| childNode = childNodesObj[childNodeId]; | |||||
| // mark all edges for removal from global and construct new edges from the cluster to others | |||||
| for (var j = 0; j < childNode.edges.length; j++) { | |||||
| edge = childNode.edges[j]; | |||||
| childEdgesObj[edge.id] = edge; | |||||
| var otherNodeId = edge.toId; | |||||
| var otherOnTo = true; | |||||
| if (edge.toId != childNodeId) { | |||||
| otherNodeId = edge.toId; | |||||
| otherOnTo = true; | |||||
| } | |||||
| else if (edge.fromId != childNodeId) { | |||||
| otherNodeId = edge.fromId; | |||||
| otherOnTo = false; | |||||
| } | |||||
| if (childNodesObj[otherNodeId] === undefined) { | |||||
| var clonedOptions = this._cloneOptions(edge.id, 'edge'); | |||||
| util.deepExtend(clonedOptions, options.clusterEdgeProperties); | |||||
| if (otherOnTo === true) { | |||||
| clonedOptions.from = options.clusterNodeProperties.id; | |||||
| clonedOptions.to = otherNodeId; | |||||
| } | |||||
| else { | |||||
| clonedOptions.from = otherNodeId; | |||||
| clonedOptions.to = options.clusterNodeProperties.id; | |||||
| } | |||||
| clonedOptions.id = 'clusterEdge:' + util.randomUUID(); | |||||
| newEdges.push(this.body.functions.createEdge(clonedOptions)) | |||||
| } | |||||
| } | |||||
| } | |||||
| } | |||||
| /** | |||||
| * This function checks the options that can be supplied to the different cluster functions | |||||
| * for certain fields and inserts defaults if needed | |||||
| * @param options | |||||
| * @returns {*} | |||||
| * @private | |||||
| */ | |||||
| _checkOptions(options = {}) { | |||||
| if (options.clusterEdgeProperties === undefined) {options.clusterEdgeProperties = {};} | |||||
| if (options.clusterNodeProperties === undefined) {options.clusterNodeProperties = {};} | |||||
| return options; | |||||
| } | |||||
| /** | |||||
| * | |||||
| * @param {Object} childNodesObj | object with node objects, id as keys, same as childNodes except it also contains a source node | |||||
| * @param {Object} childEdgesObj | object with edge objects, id as keys | |||||
| * @param {Array} options | object with {clusterNodeProperties, clusterEdgeProperties, processProperties} | |||||
| * @param {Boolean} doNotUpdateCalculationNodes | when true, do not wrap up | |||||
| * @private | |||||
| */ | |||||
| _cluster(childNodesObj, childEdgesObj, options, doNotUpdateCalculationNodes = false) { | |||||
| // kill condition: no children so cant cluster | |||||
| if (Object.keys(childNodesObj).length == 0) {return;} | |||||
| // check if we have an unique id; | |||||
| if (options.clusterNodeProperties.id === undefined) {options.clusterNodeProperties.id = 'cluster:' + util.randomUUID();} | |||||
| var clusterId = options.clusterNodeProperties.id; | |||||
| // create the new edges that will connect to the cluster | |||||
| var newEdges = []; | |||||
| this._createClusterEdges(childNodesObj, childEdgesObj, newEdges, options); | |||||
| // construct the clusterNodeProperties | |||||
| var clusterNodeProperties = options.clusterNodeProperties; | |||||
| if (options.processProperties !== undefined) { | |||||
| // get the childNode options | |||||
| var childNodesOptions = []; | |||||
| for (var nodeId in childNodesObj) { | |||||
| var clonedOptions = this._cloneOptions(nodeId); | |||||
| childNodesOptions.push(clonedOptions); | |||||
| } | |||||
| // get clusterproperties based on childNodes | |||||
| var childEdgesOptions = []; | |||||
| for (var edgeId in childEdgesObj) { | |||||
| var clonedOptions = this._cloneOptions(edgeId, 'edge'); | |||||
| childEdgesOptions.push(clonedOptions); | |||||
| } | |||||
| clusterNodeProperties = options.processProperties(clusterNodeProperties, childNodesOptions, childEdgesOptions); | |||||
| if (!clusterNodeProperties) { | |||||
| throw new Error("The processClusterProperties function does not return properties!"); | |||||
| } | |||||
| } | |||||
| if (clusterNodeProperties.label === undefined) { | |||||
| clusterNodeProperties.label = 'cluster'; | |||||
| } | |||||
| // give the clusterNode a postion if it does not have one. | |||||
| var pos = undefined; | |||||
| if (clusterNodeProperties.x === undefined) { | |||||
| pos = this._getClusterPosition(childNodesObj); | |||||
| clusterNodeProperties.x = pos.x; | |||||
| clusterNodeProperties.allowedToMoveX = true; | |||||
| } | |||||
| if (clusterNodeProperties.x === undefined) { | |||||
| if (pos === undefined) { | |||||
| pos = this._getClusterPosition(childNodesObj); | |||||
| } | |||||
| clusterNodeProperties.y = pos.y; | |||||
| clusterNodeProperties.allowedToMoveY = true; | |||||
| } | |||||
| // force the ID to remain the same | |||||
| clusterNodeProperties.id = clusterId; | |||||
| // create the clusterNode | |||||
| var clusterNode = this.body.functions.createNode(clusterNodeProperties); | |||||
| clusterNode.isCluster = true; | |||||
| clusterNode.containedNodes = childNodesObj; | |||||
| clusterNode.containedEdges = childEdgesObj; | |||||
| // delete contained edges from global | |||||
| for (var edgeId in childEdgesObj) { | |||||
| if (childEdgesObj.hasOwnProperty(edgeId)) { | |||||
| if (this.body.edges[edgeId] !== undefined) { | |||||
| if (this.body.edges[edgeId].via !== null) { | |||||
| var viaId = this.body.edges[edgeId].via.id; | |||||
| if (viaId) { | |||||
| this.body.edges[edgeId].via = null | |||||
| delete this.body.sectors['support']['nodes'][viaId]; | |||||
| } | |||||
| } | |||||
| this.body.edges[edgeId].disconnect(); | |||||
| delete this.body.edges[edgeId]; | |||||
| } | |||||
| } | |||||
| } | |||||
| // remove contained nodes from global | |||||
| for (var nodeId in childNodesObj) { | |||||
| if (childNodesObj.hasOwnProperty(nodeId)) { | |||||
| this.clusteredNodes[nodeId] = {clusterId:clusterNodeProperties.id, node: this.body.nodes[nodeId]}; | |||||
| delete this.body.nodes[nodeId]; | |||||
| } | |||||
| } | |||||
| // finally put the cluster node into global | |||||
| this.body.nodes[clusterNodeProperties.id] = clusterNode; | |||||
| // push new edges to global | |||||
| for (var i = 0; i < newEdges.length; i++) { | |||||
| this.body.edges[newEdges[i].id] = newEdges[i]; | |||||
| this.body.edges[newEdges[i].id].connect(); | |||||
| } | |||||
| // create bezier nodes for smooth curves if needed | |||||
| this.body.emitter.emit("_newEdgesCreated"); | |||||
| // set ID to undefined so no duplicates arise | |||||
| clusterNodeProperties.id = undefined; | |||||
| // wrap up | |||||
| if (doNotUpdateCalculationNodes !== true) { | |||||
| this.body.emitter.emit('_dataChanged'); | |||||
| } | |||||
| } | |||||
| /** | |||||
| * Check if a node is a cluster. | |||||
| * @param nodeId | |||||
| * @returns {*} | |||||
| */ | |||||
| isCluster(nodeId) { | |||||
| if (this.body.nodes[nodeId] !== undefined) { | |||||
| return this.body.nodes[nodeId].isCluster; | |||||
| } | |||||
| else { | |||||
| console.log("Node does not exist.") | |||||
| return false; | |||||
| } | |||||
| } | |||||
| /** | |||||
| * get the position of the cluster node based on what's inside | |||||
| * @param {object} childNodesObj | object with node objects, id as keys | |||||
| * @returns {{x: number, y: number}} | |||||
| * @private | |||||
| */ | |||||
| _getClusterPosition(childNodesObj) { | |||||
| var childKeys = Object.keys(childNodesObj); | |||||
| var minX = childNodesObj[childKeys[0]].x; | |||||
| var maxX = childNodesObj[childKeys[0]].x; | |||||
| var minY = childNodesObj[childKeys[0]].y; | |||||
| var maxY = childNodesObj[childKeys[0]].y; | |||||
| var node; | |||||
| for (var i = 0; i < childKeys.lenght; i++) { | |||||
| node = childNodesObj[childKeys[0]]; | |||||
| minX = node.x < minX ? node.x : minX; | |||||
| maxX = node.x > maxX ? node.x : maxX; | |||||
| minY = node.y < minY ? node.y : minY; | |||||
| maxY = node.y > maxY ? node.y : maxY; | |||||
| } | |||||
| return {x: 0.5*(minX + maxX), y: 0.5*(minY + maxY)}; | |||||
| } | |||||
| /** | |||||
| * Open a cluster by calling this function. | |||||
| * @param {String} clusterNodeId | the ID of the cluster node | |||||
| * @param {Boolean} doNotUpdateCalculationNodes | wrap up afterwards if not true | |||||
| */ | |||||
| openCluster(clusterNodeId, doNotUpdateCalculationNodes) { | |||||
| // kill conditions | |||||
| if (clusterNodeId === undefined) {throw new Error("No clusterNodeId supplied to openCluster.");} | |||||
| if (this.body.nodes[clusterNodeId] === undefined) {throw new Error("The clusterNodeId supplied to openCluster does not exist.");} | |||||
| if (this.body.nodes[clusterNodeId].containedNodes === undefined) {console.log("The node:" + clusterNodeId + " is not a cluster."); return}; | |||||
| var node = this.body.nodes[clusterNodeId]; | |||||
| var containedNodes = node.containedNodes; | |||||
| var containedEdges = node.containedEdges; | |||||
| // release nodes | |||||
| for (var nodeId in containedNodes) { | |||||
| if (containedNodes.hasOwnProperty(nodeId)) { | |||||
| this.body.nodes[nodeId] = containedNodes[nodeId]; | |||||
| // inherit position | |||||
| this.body.nodes[nodeId].x = node.x; | |||||
| this.body.nodes[nodeId].y = node.y; | |||||
| // inherit speed | |||||
| this.body.nodes[nodeId].vx = node.vx; | |||||
| this.body.nodes[nodeId].vy = node.vy; | |||||
| delete this.clusteredNodes[nodeId]; | |||||
| } | |||||
| } | |||||
| // release edges | |||||
| for (var edgeId in containedEdges) { | |||||
| if (containedEdges.hasOwnProperty(edgeId)) { | |||||
| this.body.edges[edgeId] = containedEdges[edgeId]; | |||||
| this.body.edges[edgeId].connect(); | |||||
| var edge = this.body.edges[edgeId]; | |||||
| if (edge.connected === false) { | |||||
| if (this.clusteredNodes[edge.fromId] !== undefined) { | |||||
| this._connectEdge(edge, edge.fromId, true); | |||||
| } | |||||
| if (this.clusteredNodes[edge.toId] !== undefined) { | |||||
| this._connectEdge(edge, edge.toId, false); | |||||
| } | |||||
| } | |||||
| } | |||||
| } | |||||
| this.body.emitter.emit("_newEdgesCreated",containedEdges); | |||||
| var edgeIds = []; | |||||
| for (var i = 0; i < node.edges.length; i++) { | |||||
| edgeIds.push(node.edges[i].id); | |||||
| } | |||||
| // remove edges in clusterNode | |||||
| for (var i = 0; i < edgeIds.length; i++) { | |||||
| var edge = this.body.edges[edgeIds[i]]; | |||||
| // if the edge should have been connected to a contained node | |||||
| if (edge.fromArray.length > 0 && edge.fromId == clusterNodeId) { | |||||
| // the node in the from array was contained in the cluster | |||||
| if (this.body.nodes[edge.fromArray[0].id] !== undefined) { | |||||
| this._connectEdge(edge, edge.fromArray[0].id, true); | |||||
| } | |||||
| } | |||||
| else if (edge.toArray.length > 0 && edge.toId == clusterNodeId) { | |||||
| // the node in the to array was contained in the cluster | |||||
| if (this.body.nodes[edge.toArray[0].id] !== undefined) { | |||||
| this._connectEdge(edge, edge.toArray[0].id, false); | |||||
| } | |||||
| } | |||||
| else { | |||||
| var edgeId = edgeIds[i]; | |||||
| var viaId = this.body.edges[edgeId].via.id; | |||||
| if (viaId) { | |||||
| this.body.edges[edgeId].via = null | |||||
| delete this.body.sectors['support']['nodes'][viaId]; | |||||
| } | |||||
| // this removes the edge from node.edges, which is why edgeIds is formed | |||||
| this.body.edges[edgeId].disconnect(); | |||||
| delete this.body.edges[edgeId]; | |||||
| } | |||||
| } | |||||
| // remove clusterNode | |||||
| delete this.body.nodes[clusterNodeId]; | |||||
| if (doNotUpdateCalculationNodes !== true) { | |||||
| this.body.emitter.emit('_dataChanged'); | |||||
| } | |||||
| } | |||||
| /** | |||||
| * Connect an edge that was previously contained from cluster A to cluster B if the node that it was originally connected to | |||||
| * is currently residing in cluster B | |||||
| * @param edge | |||||
| * @param nodeId | |||||
| * @param from | |||||
| * @private | |||||
| */ | |||||
| _connectEdge(edge, nodeId, from) { | |||||
| var clusterStack = this._getClusterStack(nodeId); | |||||
| if (from == true) { | |||||
| edge.from = clusterStack[clusterStack.length - 1]; | |||||
| edge.fromId = clusterStack[clusterStack.length - 1].id; | |||||
| clusterStack.pop() | |||||
| edge.fromArray = clusterStack; | |||||
| } | |||||
| else { | |||||
| edge.to = clusterStack[clusterStack.length - 1]; | |||||
| edge.toId = clusterStack[clusterStack.length - 1].id; | |||||
| clusterStack.pop(); | |||||
| edge.toArray = clusterStack; | |||||
| } | |||||
| edge.connect(); | |||||
| } | |||||
| /** | |||||
| * Get the stack clusterId's that a certain node resides in. cluster A -> cluster B -> cluster C -> node | |||||
| * @param nodeId | |||||
| * @returns {Array} | |||||
| * @private | |||||
| */ | |||||
| _getClusterStack(nodeId) { | |||||
| var stack = []; | |||||
| var max = 100; | |||||
| var counter = 0; | |||||
| while (this.clusteredNodes[nodeId] !== undefined && counter < max) { | |||||
| stack.push(this.clusteredNodes[nodeId].node); | |||||
| nodeId = this.clusteredNodes[nodeId].clusterId; | |||||
| counter++; | |||||
| } | |||||
| stack.push(this.body.nodes[nodeId]); | |||||
| return stack; | |||||
| } | |||||
| /** | |||||
| * Get the Id the node is connected to | |||||
| * @param edge | |||||
| * @param nodeId | |||||
| * @returns {*} | |||||
| * @private | |||||
| */ | |||||
| _getConnectedId(edge, nodeId) { | |||||
| if (edge.toId != nodeId) { | |||||
| return edge.toId; | |||||
| } | |||||
| else if (edge.fromId != nodeId) { | |||||
| return edge.fromId; | |||||
| } | |||||
| else { | |||||
| return edge.fromId; | |||||
| } | |||||
| } | |||||
| /** | |||||
| * We determine how many connections denote an important hub. | |||||
| * We take the mean + 2*std as the important hub size. (Assuming a normal distribution of data, ~2.2%) | |||||
| * | |||||
| * @private | |||||
| */ | |||||
| _getHubSize() { | |||||
| var average = 0; | |||||
| var averageSquared = 0; | |||||
| var hubCounter = 0; | |||||
| var largestHub = 0; | |||||
| for (var i = 0; i < this.body.nodeIndices.length; i++) { | |||||
| var node = this.body.nodes[this.body.nodeIndices[i]]; | |||||
| if (node.edges.length > largestHub) { | |||||
| largestHub = node.edges.length; | |||||
| } | |||||
| average += node.edges.length; | |||||
| averageSquared += Math.pow(node.edges.length,2); | |||||
| hubCounter += 1; | |||||
| } | |||||
| average = average / hubCounter; | |||||
| averageSquared = averageSquared / hubCounter; | |||||
| var variance = averageSquared - Math.pow(average,2); | |||||
| var standardDeviation = Math.sqrt(variance); | |||||
| var hubThreshold = Math.floor(average + 2*standardDeviation); | |||||
| // always have at least one to cluster | |||||
| if (hubThreshold > largestHub) { | |||||
| hubThreshold = largestHub; | |||||
| } | |||||
| return hubThreshold; | |||||
| }; | |||||
| } | |||||
| export { ClusterEngine }; | |||||