[TASK] add zoom animation again

lib/forcegraph.js

@@ -1,5 +1,5 @@
-define(['d3-selection', 'd3-force', 'd3-zoom', 'd3-drag', 'utils/math', 'forcegraph/draw'],
+define(['d3-selection', 'd3-force', 'd3-zoom', 'd3-drag', 'd3-timer', 'd3-ease', 'd3-interpolate', 'utils/math', 'forcegraph/draw'],
-  function (d3Selection, d3Force, d3Zoom, d3Drag, math, draw) {
+  function (d3Selection, d3Force, d3Zoom, d3Drag, d3Timer, d3Ease, d3Interpolate, math, draw) {
     'use strict';
 
     return function (config, linkScale, sidebar, router) {
@@ -9,6 +9,7 @@ define(['d3-selection', 'd3-force', 'd3-zoom', 'd3-drag', 'utils/math', 'forcegr
       var ctx;
       var force;
       var forceLink;
+      var animate = false;
 
       var transform = d3Zoom.zoomIdentity;
       var intNodes = [];
@@ -18,23 +19,58 @@ define(['d3-selection', 'd3-force', 'd3-zoom', 'd3-drag', 'utils/math', 'forcegr
       var NODE_RADIUS_DRAG = 10;
       var NODE_RADIUS_SELECT = 15;
       var LINK_RADIUS_SELECT = 12;
+      var ZOOM_ANIMATE_DURATION = 500;
 
       var ZOOM_MIN = 1 / 8;
       var ZOOM_MAX = 3;
 
       var FORCE_ALPHA = 0.3;
 
+
       draw.setTransform(transform);
 
+      function sleep(time) {
+        return new Promise(function (resolve) {
+          setTimeout(resolve, time);
+        });
+      }
+
       function resizeCanvas() {
         canvas.width = el.offsetWidth;
         canvas.height = el.offsetHeight;
         draw.setMaxArea(canvas.width, canvas.height);
       }
 
-      function moveTo(x, y) {
+      function moveTo(x, y, k) {
-        transform.x = (canvas.width + sidebar()) / 2 - x * transform.k;
+        function transformPosition(p) {
-        transform.y = canvas.height / 2 - y * transform.k;
+          transform.x = p.x;
+          transform.y = p.y;
+          transform.k = p.k;
+        }
+
+        var end = {k: k};
+        end.x = (canvas.width + sidebar()) / 2 - x * k;
+        end.y = canvas.height / 2 - y * k;
+
+        if (!animate) {
+          transformPosition(end);
+          redraw();
+        } else {
+          var start = { x: transform.x, y: transform.y, k: transform.k };
+
+          var interpolate = d3Interpolate.interpolateObject(start, end);
+
+          var timer = d3Timer.timer(function (t) {
+            if (t >= ZOOM_ANIMATE_DURATION) {
+              timer.stop();
+              return;
+            }
+
+            var v = interpolate(d3Ease.easeQuadInOut(t / ZOOM_ANIMATE_DURATION));
+            transformPosition(v);
+            window.requestAnimationFrame(redraw);
+          });
+        }
       }
 
       function onClick() {
@@ -111,7 +147,9 @@ define(['d3-selection', 'd3-force', 'd3-zoom', 'd3-drag', 'utils/math', 'forcegr
         .force('x', d3Force.forceX().strength(0.02))
         .force('y', d3Force.forceY().strength(0.02))
         .force('collide', d3Force.forceCollide())
-        .on('tick', redraw);
+        .on('tick', redraw)
+        .alphaDecay(0.01)
+        .velocityDecay(0.1);
 
       var drag = d3Drag.drag()
         .subject(function () {
@@ -188,41 +226,55 @@ define(['d3-selection', 'd3-force', 'd3-zoom', 'd3-drag', 'utils/math', 'forcegr
         forceLink.links(intLinks);
 
         force.alpha(1).restart();
+        force.alphaTarget(1);
         resizeCanvas();
+        sleep(1000).then(function () {
+          force.alphaTarget(0);
+          animate = true;
+        });
       };
 
       self.resetView = function resetView() {
         draw.setHighlight(null);
-        transform.k = (ZOOM_MIN + 1) / 2;
+        moveTo(0, 0, (ZOOM_MIN + 1) / 2);
-        moveTo(0, 0);
-        redraw();
       };
 
       self.gotoNode = function gotoNode(d) {
-        for (var i = 0; i < intNodes.length; i++) {
+        function getNode() {
-          var n = intNodes[i];
+          for (var i = 0; i < intNodes.length; i++) {
-          if (n.o.node.nodeinfo.node_id !== d.nodeinfo.node_id) {
+            var n = intNodes[i];
-            continue;
+            if (n.o.node.nodeinfo.node_id !== d.nodeinfo.node_id) {
+              continue;
+            }
+            draw.setHighlight({ type: 'node', o: n.o.node });
+            moveTo(n.x, n.y, (ZOOM_MAX + 1) / 2);
+            break;
           }
-          draw.setHighlight({ type: 'node', o: n.o.node });
-          transform.k = (ZOOM_MAX + 1) / 2;
-          moveTo(n.x, n.y);
-          break;
         }
-        redraw();
+        if (!animate) {
+          sleep(1500).then(getNode);
+        } else {
+          getNode();
+        }
       };
 
       self.gotoLink = function gotoLink(d) {
-        draw.setHighlight({ type: 'link', o: d });
+        function getLink() {
-        for (var i = 0; i < intLinks.length; i++) {
+          draw.setHighlight({ type: 'link', o: d });
-          var l = intLinks[i];
+          for (var i = 0; i < intLinks.length; i++) {
-          if (l.o !== d) {
+            var l = intLinks[i];
-            continue;
+            if (l.o !== d) {
+              continue;
+            }
+            moveTo((l.source.x + l.target.x) / 2, (l.source.y + l.target.y) / 2, transform.k);
+            break;
           }
-          moveTo((l.source.x + l.target.x) / 2, (l.source.y + l.target.y) / 2);
-          break;
         }
-        redraw();
+        if (!animate) {
+          sleep(1500).then(getLink);
+        } else {
+          getLink();
+        }
       };