| Server IP : 49.231.201.246 / Your IP : 216.73.216.149 Web Server : Apache/2.4.18 (Ubuntu) System : Linux 246 4.4.0-210-generic #242-Ubuntu SMP Fri Apr 16 09:57:56 UTC 2021 x86_64 User : root ( 0) PHP Version : 7.0.33-0ubuntu0.16.04.16 Disable Function : exec,passthru,shell_exec,system,proc_open,popen,pcntl_exec MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : ON | Sudo : ON | Pkexec : ON Directory : /proc/11584/cwd/html/ppaobm/backend/web/assets/16c36a2e/es-modules/modules/networkgraph/ |
Upload File : |
/* *
* Networkgraph series
*
* (c) 2010-2019 Paweł Fus
*
* License: www.highcharts.com/license
*/
'use strict';
import H from '../../parts/Globals.js';
import 'integrations.js';
import 'QuadTree.js';
var pick = H.pick,
defined = H.defined,
addEvent = H.addEvent,
Chart = H.Chart;
H.layouts = {
'reingold-fruchterman': function () {
}
};
H.extend(
/**
* Reingold-Fruchterman algorithm from
* "Graph Drawing by Force-directed Placement" paper.
* @private
*/
H.layouts['reingold-fruchterman'].prototype,
{
init: function (options) {
this.options = options;
this.nodes = [];
this.links = [];
this.series = [];
this.box = {
x: 0,
y: 0,
width: 0,
height: 0
};
this.setInitialRendering(true);
this.integration = H.networkgraphIntegrations[options.integration];
this.attractiveForce = pick(
options.attractiveForce,
this.integration.attractiveForceFunction
);
this.repulsiveForce = pick(
options.repulsiveForce,
this.integration.repulsiveForceFunction
);
this.approximation = options.approximation;
},
start: function () {
var layout = this,
series = this.series,
options = this.options;
layout.currentStep = 0;
layout.forces = series[0] && series[0].forces || [];
if (layout.initialRendering) {
layout.initPositions();
// Render elements in initial positions:
series.forEach(function (s) {
s.render();
});
}
layout.setK();
layout.resetSimulation(options);
if (options.enableSimulation) {
layout.step();
}
},
step: function () {
var layout = this,
series = this.series,
options = this.options;
// Algorithm:
layout.currentStep++;
if (layout.approximation === 'barnes-hut') {
layout.createQuadTree();
layout.quadTree.calculateMassAndCenter();
}
layout.forces.forEach(function (forceName) {
layout[forceName + 'Forces'](layout.temperature);
});
// Limit to the plotting area and cool down:
layout.applyLimits(layout.temperature);
// Cool down the system:
layout.temperature = layout.coolDown(
layout.startTemperature,
layout.diffTemperature,
layout.currentStep
);
layout.prevSystemTemperature = layout.systemTemperature;
layout.systemTemperature = layout.getSystemTemperature();
if (options.enableSimulation) {
series.forEach(function (s) {
// Chart could be destroyed during the simulation
if (s.chart) {
s.render();
}
});
if (
layout.maxIterations-- &&
isFinite(layout.temperature) &&
!layout.isStable()
) {
if (layout.simulation) {
H.win.cancelAnimationFrame(layout.simulation);
}
layout.simulation = H.win.requestAnimationFrame(
function () {
layout.step();
}
);
} else {
layout.simulation = false;
}
}
},
stop: function () {
if (this.simulation) {
H.win.cancelAnimationFrame(this.simulation);
}
},
setArea: function (x, y, w, h) {
this.box = {
left: x,
top: y,
width: w,
height: h
};
},
setK: function () {
// Optimal distance between nodes,
// available space around the node:
this.k = this.options.linkLength || this.integration.getK(this);
},
addNodes: function (nodes) {
nodes.forEach(function (node) {
if (this.nodes.indexOf(node) === -1) {
this.nodes.push(node);
}
}, this);
},
removeNode: function (node) {
var index = this.nodes.indexOf(node);
if (index !== -1) {
this.nodes.splice(index, 1);
}
},
removeLink: function (link) {
var index = this.links.indexOf(link);
if (index !== -1) {
this.links.splice(index, 1);
}
},
addLinks: function (links) {
links.forEach(function (link) {
if (this.links.indexOf(link) === -1) {
this.links.push(link);
}
}, this);
},
addSeries: function (series) {
if (this.series.indexOf(series) === -1) {
this.series.push(series);
}
},
clear: function () {
this.nodes.length = 0;
this.links.length = 0;
this.series.length = 0;
this.resetSimulation();
},
resetSimulation: function () {
this.forcedStop = false;
this.systemTemperature = 0;
this.setMaxIterations();
this.setTemperature();
this.setDiffTemperature();
},
setMaxIterations: function (maxIterations) {
this.maxIterations = pick(
maxIterations,
this.options.maxIterations
);
},
setTemperature: function () {
this.temperature = this.startTemperature =
Math.sqrt(this.nodes.length);
},
setDiffTemperature: function () {
this.diffTemperature = this.startTemperature /
(this.options.maxIterations + 1);
},
setInitialRendering: function (enable) {
this.initialRendering = enable;
},
createQuadTree: function () {
this.quadTree = new H.QuadTree(
this.box.left,
this.box.top,
this.box.width,
this.box.height
);
this.quadTree.insertNodes(this.nodes);
},
initPositions: function () {
var initialPositions = this.options.initialPositions;
if (H.isFunction(initialPositions)) {
initialPositions.call(this);
this.nodes.forEach(function (node) {
if (!defined(node.prevX)) {
node.prevX = node.plotX;
}
if (!defined(node.prevY)) {
node.prevY = node.plotY;
}
node.dispX = 0;
node.dispY = 0;
});
} else if (initialPositions === 'circle') {
this.setCircularPositions();
} else {
this.setRandomPositions();
}
},
setCircularPositions: function () {
var box = this.box,
nodes = this.nodes,
nodesLength = nodes.length + 1,
angle = 2 * Math.PI / nodesLength,
rootNodes = nodes.filter(function (node) {
return node.linksTo.length === 0;
}),
sortedNodes = [],
visitedNodes = {},
radius = this.options.initialPositionRadius;
function addToNodes(node) {
node.linksFrom.forEach(function (link) {
if (!visitedNodes[link.toNode.id]) {
visitedNodes[link.toNode.id] = true;
sortedNodes.push(link.toNode);
addToNodes(link.toNode);
}
});
}
// Start with identified root nodes an sort the nodes by their
// hierarchy. In trees, this ensures that branches don't cross
// eachother.
rootNodes.forEach(function (rootNode) {
sortedNodes.push(rootNode);
addToNodes(rootNode);
});
// Cyclic tree, no root node found
if (!sortedNodes.length) {
sortedNodes = nodes;
// Dangling, cyclic trees
} else {
nodes.forEach(function (node) {
if (sortedNodes.indexOf(node) === -1) {
sortedNodes.push(node);
}
});
}
// Initial positions are laid out along a small circle, appearing
// as a cluster in the middle
sortedNodes.forEach(function (node, index) {
node.plotX = node.prevX = pick(
node.plotX,
box.width / 2 + radius * Math.cos(index * angle)
);
node.plotY = node.prevY = pick(
node.plotY,
box.height / 2 + radius * Math.sin(index * angle)
);
node.dispX = 0;
node.dispY = 0;
});
},
setRandomPositions: function () {
var box = this.box,
nodes = this.nodes,
nodesLength = nodes.length + 1;
// Return a repeatable, quasi-random number based on an integer
// input. For the initial positions
function unrandom(n) {
var rand = n * n / Math.PI;
rand = rand - Math.floor(rand);
return rand;
}
// Initial positions:
nodes.forEach(
function (node, index) {
node.plotX = node.prevX = pick(
node.plotX,
box.width * unrandom(index)
);
node.plotY = node.prevY = pick(
node.plotY,
box.height * unrandom(nodesLength + index)
);
node.dispX = 0;
node.dispY = 0;
}
);
},
force: function (name) {
this.integration[name].apply(
this,
Array.prototype.slice.call(arguments, 1)
);
},
barycenterForces: function () {
this.getBarycenter();
this.force('barycenter');
},
getBarycenter: function () {
var systemMass = 0,
cx = 0,
cy = 0;
this.nodes.forEach(function (node) {
cx += node.plotX * node.mass;
cy += node.plotY * node.mass;
systemMass += node.mass;
});
this.barycenter = {
x: cx,
y: cy,
xFactor: cx / systemMass,
yFactor: cy / systemMass
};
return this.barycenter;
},
barnesHutApproximation: function (node, quadNode) {
var layout = this,
distanceXY = layout.getDistXY(node, quadNode),
distanceR = layout.vectorLength(distanceXY),
goDeeper,
force;
if (node !== quadNode && distanceR !== 0) {
if (quadNode.isInternal) {
// Internal node:
if (
quadNode.boxSize / distanceR < layout.options.theta &&
distanceR !== 0
) {
// Treat as an external node:
force = layout.repulsiveForce(distanceR, layout.k);
layout.force(
'repulsive',
node,
force * quadNode.mass,
distanceXY,
distanceR
);
goDeeper = false;
} else {
// Go deeper:
goDeeper = true;
}
} else {
// External node, direct force:
force = layout.repulsiveForce(distanceR, layout.k);
layout.force(
'repulsive',
node,
force * quadNode.mass,
distanceXY,
distanceR
);
}
}
return goDeeper;
},
repulsiveForces: function () {
var layout = this;
if (layout.approximation === 'barnes-hut') {
layout.nodes.forEach(function (node) {
layout.quadTree.visitNodeRecursive(
null,
function (quadNode) {
return layout.barnesHutApproximation(
node,
quadNode
);
}
);
});
} else {
layout.nodes.forEach(function (node) {
layout.nodes.forEach(function (repNode) {
var force,
distanceR,
distanceXY;
if (
// Node can not repulse itself:
node !== repNode &&
// Only close nodes affect each other:
/* layout.getDistR(node, repNode) < 2 * k && */
// Not dragged:
!node.fixedPosition
) {
distanceXY = layout.getDistXY(node, repNode);
distanceR = layout.vectorLength(distanceXY);
force = layout.repulsiveForce(distanceR, layout.k);
layout.force(
'repulsive',
node,
force * repNode.mass,
distanceXY,
distanceR
);
}
});
});
}
},
attractiveForces: function () {
var layout = this,
distanceXY,
distanceR,
force;
layout.links.forEach(function (link) {
if (link.fromNode && link.toNode) {
distanceXY = layout.getDistXY(
link.fromNode,
link.toNode
);
distanceR = layout.vectorLength(distanceXY);
if (distanceR !== 0) {
force = layout.attractiveForce(distanceR, layout.k);
layout.force(
'attractive',
link,
force,
distanceXY,
distanceR
);
}
}
});
},
applyLimits: function () {
var layout = this,
nodes = layout.nodes;
nodes.forEach(function (node) {
if (node.fixedPosition) {
return;
}
layout.integration.integrate(layout, node);
layout.applyLimitBox(node, layout.box);
// Reset displacement:
node.dispX = 0;
node.dispY = 0;
});
},
/**
* External box that nodes should fall. When hitting an edge, node
* should stop or bounce.
* @private
*/
applyLimitBox: function (node, box) {
var radius = node.marker && node.marker.radius || 0;
/*
TO DO: Consider elastic collision instead of stopping.
o' means end position when hitting plotting area edge:
- "inelastic":
o
\
______
| o'
| \
| \
- "elastic"/"bounced":
o
\
______
| ^
| / \
|o' \
Euler sample:
if (plotX < 0) {
plotX = 0;
dispX *= -1;
}
if (plotX > box.width) {
plotX = box.width;
dispX *= -1;
}
*/
// Limit X-coordinates:
node.plotX = Math.max(
Math.min(
node.plotX,
box.width - radius
),
box.left + radius
);
// Limit Y-coordinates:
node.plotY = Math.max(
Math.min(
node.plotY,
box.height - radius
),
box.top + radius
);
},
/**
* From "A comparison of simulated annealing cooling strategies" by
* Nourani and Andresen work.
* @private
*/
coolDown: function (temperature, temperatureStep, currentStep) {
// Logarithmic:
/*
return Math.sqrt(this.nodes.length) -
Math.log(
currentStep * layout.diffTemperature
);
*/
// Exponential:
/*
var alpha = 0.1;
layout.temperature = Math.sqrt(layout.nodes.length) *
Math.pow(alpha, layout.diffTemperature);
*/
// Linear:
return temperature - temperatureStep * currentStep;
},
isStable: function () {
return Math.abs(
this.systemTemperature -
this.prevSystemTemperature
) < 0.00001 || this.temperature <= 0;
},
getSystemTemperature: function () {
return this.nodes.reduce(function (value, node) {
return value + node.temperature;
}, 0);
},
vectorLength: function (vector) {
return Math.sqrt(vector.x * vector.x + vector.y * vector.y);
},
getDistR: function (nodeA, nodeB) {
var distance = this.getDistXY(nodeA, nodeB);
return this.vectorLength(distance);
},
getDistXY: function (nodeA, nodeB) {
var xDist = nodeA.plotX - nodeB.plotX,
yDist = nodeA.plotY - nodeB.plotY;
return {
x: xDist,
y: yDist,
absX: Math.abs(xDist),
absY: Math.abs(yDist)
};
}
}
);
/*
* Multiple series support:
*/
// Clear previous layouts
addEvent(Chart, 'predraw', function () {
if (this.graphLayoutsLookup) {
this.graphLayoutsLookup.forEach(
function (layout) {
layout.stop();
}
);
}
});
addEvent(Chart, 'render', function () {
var systemsStable,
afterRender = false;
function layoutStep(layout) {
if (
layout.maxIterations-- &&
isFinite(layout.temperature) &&
!layout.isStable() &&
!layout.options.enableSimulation
) {
// Hook similar to build-in addEvent, but instead of
// creating whole events logic, use just a function.
// It's faster which is important for rAF code.
// Used e.g. in packed-bubble series for bubble radius
// calculations
if (layout.beforeStep) {
layout.beforeStep();
}
layout.step();
systemsStable = false;
afterRender = true;
}
}
if (this.graphLayoutsLookup) {
H.setAnimation(false, this);
// Start simulation
this.graphLayoutsLookup.forEach(
function (layout) {
layout.start();
}
);
// Just one sync step, to run different layouts similar to
// async mode.
while (!systemsStable) {
systemsStable = true;
this.graphLayoutsLookup.forEach(layoutStep);
}
if (afterRender) {
this.series.forEach(function (s) {
if (s && s.layout) {
s.render();
}
});
}
}
});