Alex de Mulder
9 years ago
15 changed files with 1752 additions and 486 deletions
Split View
Diff Options
-
+9 -1HISTORY.md
-
+920 -241dist/vis.js
-
+2 -0docs/network/layout.html
-
+3 -1docs/network/physics.html
-
+9 -2lib/network/Network.js
-
+3 -0lib/network/gephiParser.js
-
+35 -1lib/network/modules/Canvas.js
-
+235 -177lib/network/modules/Clustering.js
-
+219 -0lib/network/modules/KamadaKawai.js
-
+82 -6lib/network/modules/LayoutEngine.js
-
+143 -34lib/network/modules/PhysicsEngine.js
-
+46 -0lib/network/modules/components/algorithms/FloydWarshall.js
-
+3 -0lib/network/modules/components/edges/BezierEdgeDynamic.js
-
+5 -1lib/network/options.js
-
+38 -22test/networkTest.html
+ 9
- 1
HISTORY.md
View File
+ 920
- 241
dist/vis.js
File diff suppressed because it is too large
View File
+ 2
- 0
docs/network/layout.html
View File
+ 3
- 1
docs/network/physics.html
View File
+ 9
- 2
lib/network/Network.js
View File
+ 3
- 0
lib/network/gephiParser.js
View File
+ 35
- 1
lib/network/modules/Canvas.js
View File
+ 235
- 177
lib/network/modules/Clustering.js
View File
+ 219
- 0
lib/network/modules/KamadaKawai.js
View File
| @ -0,0 +1,219 @@ | |||
| /** | |||
| * Created by Alex on 8/7/2015. | |||
| */ | |||
| // distance finding algorithm | |||
| import FloydWarshall from "./components/algorithms/FloydWarshall.js" | |||
| /** | |||
| * KamadaKawai positions the nodes initially based on | |||
| * | |||
| * "AN ALGORITHM FOR DRAWING GENERAL UNDIRECTED GRAPHS" | |||
| * -- Tomihisa KAMADA and Satoru KAWAI in 1989 | |||
| * | |||
| * Possible optimizations in the distance calculation can be implemented. | |||
| */ | |||
| class KamadaKawai { | |||
| constructor(body, edgeLength, edgeStrength) { | |||
| this.body = body; | |||
| this.springLength = edgeLength; | |||
| this.springConstant = edgeStrength; | |||
| this.distanceSolver = new FloydWarshall(); | |||
| } | |||
| /** | |||
| * Not sure if needed but can be used to update the spring length and spring constant | |||
| * @param options | |||
| */ | |||
| setOptions(options) { | |||
| if (options) { | |||
| if (options.springLength) { | |||
| this.springLength = options.springLength; | |||
| } | |||
| if (options.springConstant) { | |||
| this.springConstant = options.springConstant; | |||
| } | |||
| } | |||
| } | |||
| /** | |||
| * Position the system | |||
| * @param nodesArray | |||
| * @param edgesArray | |||
| */ | |||
| solve(nodesArray, edgesArray, ignoreClusters = false) { | |||
| // get distance matrix | |||
| let D_matrix = this.distanceSolver.getDistances(this.body, nodesArray, edgesArray); // distance matrix | |||
| // get the L Matrix | |||
| this._createL_matrix(D_matrix); | |||
| // get the K Matrix | |||
| this._createK_matrix(D_matrix); | |||
| // calculate positions | |||
| let threshold = 0.01; | |||
| let innerThreshold = 1; | |||
| let iterations = 0; | |||
| let maxIterations = Math.max(1000,Math.min(10*this.body.nodeIndices.length,6000)); | |||
| let maxInnerIterations = 5; | |||
| let maxEnergy = 1e9; | |||
| let highE_nodeId = 0, dE_dx = 0, dE_dy = 0, delta_m = 0, subIterations = 0; | |||
| while (maxEnergy > threshold && iterations < maxIterations) { | |||
| iterations += 1; | |||
| [highE_nodeId, maxEnergy, dE_dx, dE_dy] = this._getHighestEnergyNode(ignoreClusters); | |||
| delta_m = maxEnergy; | |||
| subIterations = 0; | |||
| while(delta_m > innerThreshold && subIterations < maxInnerIterations) { | |||
| subIterations += 1; | |||
| this._moveNode(highE_nodeId, dE_dx, dE_dy); | |||
| [delta_m,dE_dx,dE_dy] = this._getEnergy(highE_nodeId); | |||
| } | |||
| } | |||
| } | |||
| /** | |||
| * get the node with the highest energy | |||
| * @returns {*[]} | |||
| * @private | |||
| */ | |||
| _getHighestEnergyNode(ignoreClusters) { | |||
| let nodesArray = this.body.nodeIndices; | |||
| let nodes = this.body.nodes; | |||
| let maxEnergy = 0; | |||
| let maxEnergyNodeId = nodesArray[0]; | |||
| let dE_dx_max = 0, dE_dy_max = 0; | |||
| for (let nodeIdx = 0; nodeIdx < nodesArray.length; nodeIdx++) { | |||
| let m = nodesArray[nodeIdx]; | |||
| // by not evaluating nodes with predefined positions we should only move nodes that have no positions. | |||
| if ((nodes[m].predefinedPosition === false || nodes[m].isCluster === true && ignoreClusters === true) || nodes[m].options.fixed.x === true || nodes[m].options.fixed.y === true) { | |||
| let [delta_m,dE_dx,dE_dy] = this._getEnergy(m); | |||
| if (maxEnergy < delta_m) { | |||
| maxEnergy = delta_m; | |||
| maxEnergyNodeId = m; | |||
| dE_dx_max = dE_dx; | |||
| dE_dy_max = dE_dy; | |||
| } | |||
| } | |||
| } | |||
| return [maxEnergyNodeId, maxEnergy, dE_dx_max, dE_dy_max]; | |||
| } | |||
| /** | |||
| * calculate the energy of a single node | |||
| * @param m | |||
| * @returns {*[]} | |||
| * @private | |||
| */ | |||
| _getEnergy(m) { | |||
| let nodesArray = this.body.nodeIndices; | |||
| let nodes = this.body.nodes; | |||
| let x_m = nodes[m].x; | |||
| let y_m = nodes[m].y; | |||
| let dE_dx = 0; | |||
| let dE_dy = 0; | |||
| for (let iIdx = 0; iIdx < nodesArray.length; iIdx++) { | |||
| let i = nodesArray[iIdx]; | |||
| if (i !== m) { | |||
| let x_i = nodes[i].x; | |||
| let y_i = nodes[i].y; | |||
| let denominator = 1.0 / Math.sqrt(Math.pow(x_m - x_i, 2) + Math.pow(y_m - y_i, 2)); | |||
| dE_dx += this.K_matrix[m][i] * ((x_m - x_i) - this.L_matrix[m][i] * (x_m - x_i) * denominator); | |||
| dE_dy += this.K_matrix[m][i] * ((y_m - y_i) - this.L_matrix[m][i] * (y_m - y_i) * denominator); | |||
| } | |||
| } | |||
| let delta_m = Math.sqrt(Math.pow(dE_dx, 2) + Math.pow(dE_dy, 2)); | |||
| return [delta_m, dE_dx, dE_dy]; | |||
| } | |||
| /** | |||
| * move the node based on it's energy | |||
| * the dx and dy are calculated from the linear system proposed by Kamada and Kawai | |||
| * @param m | |||
| * @param dE_dx | |||
| * @param dE_dy | |||
| * @private | |||
| */ | |||
| _moveNode(m, dE_dx, dE_dy) { | |||
| let nodesArray = this.body.nodeIndices; | |||
| let nodes = this.body.nodes; | |||
| let d2E_dx2 = 0; | |||
| let d2E_dxdy = 0; | |||
| let d2E_dy2 = 0; | |||
| let x_m = nodes[m].x; | |||
| let y_m = nodes[m].y; | |||
| for (let iIdx = 0; iIdx < nodesArray.length; iIdx++) { | |||
| let i = nodesArray[iIdx]; | |||
| if (i !== m) { | |||
| let x_i = nodes[i].x; | |||
| let y_i = nodes[i].y; | |||
| let denominator = 1.0 / Math.pow(Math.pow(x_m - x_i, 2) + Math.pow(y_m - y_i, 2), 1.5); | |||
| d2E_dx2 += this.K_matrix[m][i] * (1 - this.L_matrix[m][i] * Math.pow(y_m - y_i, 2) * denominator); | |||
| d2E_dxdy += this.K_matrix[m][i] * (this.L_matrix[m][i] * (x_m - x_i) * (y_m - y_i) * denominator); | |||
| d2E_dy2 += this.K_matrix[m][i] * (1 - this.L_matrix[m][i] * Math.pow(x_m - x_i, 2) * denominator); | |||
| } | |||
| } | |||
| // make the variable names easier to make the solving of the linear system easier to read | |||
| let A = d2E_dx2, B = d2E_dxdy, C = dE_dx, D = d2E_dy2, E = dE_dy; | |||
| // solve the linear system for dx and dy | |||
| let dy = (C / A + E / B) / (B / A - D / B); | |||
| let dx = -(B * dy + C) / A; | |||
| // move the node | |||
| nodes[m].x += dx; | |||
| nodes[m].y += dy; | |||
| } | |||
| /** | |||
| * Create the L matrix: edge length times shortest path | |||
| * @param D_matrix | |||
| * @private | |||
| */ | |||
| _createL_matrix(D_matrix) { | |||
| let nodesArray = this.body.nodeIndices; | |||
| let edgeLength = this.springLength; | |||
| this.L_matrix = []; | |||
| for (let i = 0; i < nodesArray.length; i++) { | |||
| this.L_matrix[nodesArray[i]] = {}; | |||
| for (let j = 0; j < nodesArray.length; j++) { | |||
| this.L_matrix[nodesArray[i]][nodesArray[j]] = edgeLength * D_matrix[nodesArray[i]][nodesArray[j]]; | |||
| } | |||
| } | |||
| } | |||
| /** | |||
| * Create the K matrix: spring constants times shortest path | |||
| * @param D_matrix | |||
| * @private | |||
| */ | |||
| _createK_matrix(D_matrix) { | |||
| let nodesArray = this.body.nodeIndices; | |||
| let edgeStrength = this.springConstant; | |||
| this.K_matrix = []; | |||
| for (let i = 0; i < nodesArray.length; i++) { | |||
| this.K_matrix[nodesArray[i]] = {}; | |||
| for (let j = 0; j < nodesArray.length; j++) { | |||
| this.K_matrix[nodesArray[i]][nodesArray[j]] = edgeStrength * Math.pow(D_matrix[nodesArray[i]][nodesArray[j]], -2); | |||
| } | |||
| } | |||
| } | |||
| } | |||
| export default KamadaKawai; | |||
+ 82
- 6
lib/network/modules/LayoutEngine.js
View File
+ 143
- 34
lib/network/modules/PhysicsEngine.js
View File
+ 46
- 0
lib/network/modules/components/algorithms/FloydWarshall.js
View File
| @ -0,0 +1,46 @@ | |||
| /** | |||
| * Created by Alex on 10-Aug-15. | |||
| */ | |||
| class FloydWarshall { | |||
| constructor(){} | |||
| getDistances(body, nodesArray, edgesArray) { | |||
| let D_matrix = {}; | |||
| let edges = body.edges; | |||
| // prepare matrix with large numbers | |||
| for (let i = 0; i < nodesArray.length; i++) { | |||
| D_matrix[nodesArray[i]] = {}; | |||
| D_matrix[nodesArray[i]] = {}; | |||
| for (let j = 0; j < nodesArray.length; j++) { | |||
| D_matrix[nodesArray[i]][nodesArray[j]] = (i == j ? 0 : 1e9); | |||
| D_matrix[nodesArray[i]][nodesArray[j]] = (i == j ? 0 : 1e9); | |||
| } | |||
| } | |||
| // put the weights for the edges in. This assumes unidirectionality. | |||
| for (let i = 0; i < edgesArray.length; i++) { | |||
| let edge = edges[edgesArray[i]]; | |||
| D_matrix[edge.fromId][edge.toId] = 1; | |||
| D_matrix[edge.toId][edge.fromId] = 1; | |||
| } | |||
| let nodeCount = nodesArray.length; | |||
| // Adapted FloydWarshall based on unidirectionality to greatly reduce complexity. | |||
| for (let k = 0; k < nodeCount; k++) { | |||
| for (let i = 0; i < nodeCount-1; i++) { | |||
| for (let j = i+1; j < nodeCount; j++) { | |||
| D_matrix[nodesArray[i]][nodesArray[j]] = Math.min(D_matrix[nodesArray[i]][nodesArray[j]],D_matrix[nodesArray[i]][nodesArray[k]] + D_matrix[nodesArray[k]][nodesArray[j]]) | |||
| D_matrix[nodesArray[j]][nodesArray[i]] = D_matrix[nodesArray[i]][nodesArray[j]]; | |||
| } | |||
| } | |||
| } | |||
| return D_matrix; | |||
| } | |||
| } | |||
| export default FloydWarshall; | |||