brian/d3-spring-model
1
0
Fork 0
Code Issues 3 Releases 4 Activity

แก้ coding style

Browse Source
This commit is contained in:
Pitchaya Boonsarngsuk
2018-03-22 16:02:45 +00:00
parent b601af68b4
commit 2256af7448
9 changed files with 866 additions and 873 deletions
Download Patch File Download Diff File Expand all files Collapse all files

216
src/link.js
View File

@@ -1,108 +1,108 @@
import constant from "./constant";
import jiggle from "./jiggle";
/**
* Modified link force algorithm
* - simplify calculations for parameters locked for spring model
* - replace the use of links {} with loop. greatly reduce memory usage
* - removed other unused functions
* Alpha should be constant 1 for accurate simulation
*/
export default function() {
var dataSizeFactor,
distance = constant(30),
distances = [],
nodes,
stableVelocity = 0,
stableVeloHandler = null,
latestVelocityDiff = 0,
iterations = 1;
function force(alpha) {
let n = nodes.length;
// Cache old velocity for comparison later
if (stableVeloHandler!==null && stableVelocity>=0) {
for (let i = n-1, node; i>=0; i--) {
node = nodes[i];
node.oldvx = node.vx;
node.oldvy = node.vy;
}
}
// Each iteration in a tick
for (var k = 0, source, target, i, j, x, y, l; k < iterations; ++k) {
// For each link
for (i = 1; i < n; i++) for (j = 0; j < i; j++) {
// jiggle so l won't be zero and divide by zero error after this
source = nodes[i];
target = nodes[j];
x = target.x + target.vx - source.x - source.vx || jiggle();
y = target.y + target.vy - source.y - source.vy || jiggle();
l = Math.sqrt(x * x + y * y);
l = (l - distances[i*(i-1)/2+j]) / l * dataSizeFactor * alpha;
x *= l, y *= l;
target.vx -= x;
target.vy -= y;
source.vx += x;
source.vy += y;
}
}
// Calculate velocity changes, aka force applied.
if (stableVeloHandler!==null && stableVelocity>=0) {
let velocityDiff = 0;
for (let i = n-1, node; i>=0; i--) {
node = nodes[i];
velocityDiff += Math.abs(Math.hypot(node.vx-node.oldvx, node.vy-node.oldvy));
}
velocityDiff /= n;
latestVelocityDiff = velocityDiff;
if(velocityDiff<stableVelocity){
stableVeloHandler();
}
}
}
function initialize() {
if (!nodes) return;
// 0.5 to divide the force to two part for source and target node
dataSizeFactor = 0.5/(nodes.length-1);
initializeDistance();
}
function initializeDistance() {
if (!nodes) return;
for (let i = 1, n = nodes.length; i < n; i++) {
for (let j = 0; j < i; j++) {
distances.push(distance(nodes[i], nodes[j]));
}
}
}
force.initialize = function(_) {
nodes = _;
initialize();
};
force.iterations = function(_) {
return arguments.length ? (iterations = +_, force) : iterations;
};
force.distance = function(_) {
return arguments.length ? (distance = typeof _ === "function" ? _ : constant(+_), initializeDistance(), force) : distance;
};
force.latestAccel = function () {
return latestVelocityDiff;
};
force.onStableVelo = function (_) {
return arguments.length ? (stableVeloHandler = _, force) : stableVeloHandler;
};
force.stableVelocity = function (_) {
return arguments.length ? (stableVelocity = _, force) : stableVelocity;
};
return force;
}
import constant from "./constant";
import jiggle from "./jiggle";
/**
* Modified link force algorithm
* - simplify calculations for parameters locked for spring model
* - replace the use of links {} with loop. greatly reduce memory usage
* - removed other unused functions
* Alpha should be constant 1 for accurate simulation
*/
export default function() {
var dataSizeFactor,
distance = constant(30),
distances = [],
nodes,
stableVelocity = 0,
stableVeloHandler = null,
latestVelocityDiff = 0,
iterations = 1;
function force(alpha) {
let n = nodes.length;
// Cache old velocity for comparison later
if (stableVeloHandler!==null && stableVelocity>=0) {
for (let i = n-1, node; i>=0; i--) {
node = nodes[i];
node.oldvx = node.vx;
node.oldvy = node.vy;
}
}
// Each iteration in a tick
for (var k = 0, source, target, i, j, x, y, l; k < iterations; ++k) {
// For each link
for (i = 1; i < n; i++) for (j = 0; j < i; j++) {
// jiggle so l won't be zero and divide by zero error after this
source = nodes[i];
target = nodes[j];
x = target.x + target.vx - source.x - source.vx || jiggle();
y = target.y + target.vy - source.y - source.vy || jiggle();
l = Math.sqrt(x * x + y * y);
l = (l - distances[i*(i-1)/2+j]) / l * dataSizeFactor * alpha;
x *= l, y *= l;
target.vx -= x;
target.vy -= y;
source.vx += x;
source.vy += y;
}
}
// Calculate velocity changes, aka force applied.
if (stableVeloHandler!==null && stableVelocity>=0) {
let velocityDiff = 0;
for (let i = n-1, node; i>=0; i--) {
node = nodes[i];
velocityDiff += Math.abs(Math.hypot(node.vx-node.oldvx, node.vy-node.oldvy));
}
velocityDiff /= n;
latestVelocityDiff = velocityDiff;
if(velocityDiff<stableVelocity){
stableVeloHandler();
}
}
}
function initialize() {
if (!nodes) return;
// 0.5 to divide the force to two part for source and target node
dataSizeFactor = 0.5/(nodes.length-1);
initializeDistance();
}
function initializeDistance() {
if (!nodes) return;
for (let i = 1, n = nodes.length; i < n; i++) {
for (let j = 0; j < i; j++) {
distances.push(distance(nodes[i], nodes[j]));
}
}
}
force.initialize = function(_) {
nodes = _;
initialize();
};
force.iterations = function(_) {
return arguments.length ? (iterations = +_, force) : iterations;
};
force.distance = function(_) {
return arguments.length ? (distance = typeof _ === "function" ? _ : constant(+_), initializeDistance(), force) : distance;
};
force.latestAccel = function () {
return latestVelocityDiff;
};
force.onStableVelo = function (_) {
return arguments.length ? (stableVeloHandler = _, force) : stableVeloHandler;
};
force.stableVelocity = function (_) {
return arguments.length ? (stableVelocity = _, force) : stableVelocity;
};
return force;
}