class RepulsionSolver { constructor(body, physicsBody, options) { this.body = body; this.physicsBody = physicsBody; this.setOptions(options); } setOptions(options) { this.options = options; } /** * Calculate the forces the nodes apply on each other based on a repulsion field. * This field is linearly approximated. * * @private */ solve() { var dx, dy, distance, fx, fy, repulsingForce, node1, node2; var nodes = this.body.nodes; var nodeIndices = this.physicsBody.physicsNodeIndices; var forces = this.physicsBody.forces; // repulsing forces between nodes var nodeDistance = this.options.nodeDistance; // approximation constants var a = (-2 / 3) / nodeDistance; var b = 4 / 3; // we loop from i over all but the last entree in the array // j loops from i+1 to the last. This way we do not double count any of the indices, nor i === j for (let i = 0; i < nodeIndices.length - 1; i++) { node1 = nodes[nodeIndices[i]]; for (let j = i + 1; j < nodeIndices.length; j++) { node2 = nodes[nodeIndices[j]]; dx = node2.x - node1.x; dy = node2.y - node1.y; distance = Math.sqrt(dx * dx + dy * dy); // same condition as BarnesHutSolver, making sure nodes are never 100% overlapping. if (distance === 0) { distance = 0.1*Math.random(); dx = distance; } if (distance < 2 * nodeDistance) { if (distance < 0.5 * nodeDistance) { repulsingForce = 1.0; } else { repulsingForce = a * distance + b; // linear approx of 1 / (1 + Math.exp((distance / nodeDistance - 1) * steepness)) } repulsingForce = repulsingForce / distance; fx = dx * repulsingForce; fy = dy * repulsingForce; forces[node1.id].x -= fx; forces[node1.id].y -= fy; forces[node2.id].x += fx; forces[node2.id].y += fy; } } } } } export default RepulsionSolver;