X-Git-Url: https://adrianiainlam.tk/git/?a=blobdiff_plain;ds=sidebyside;f=dygraph-canvas.js;h=915fd90e4a93b04d7159729a89886a588fe4ab23;hb=8722284b4b60821fa96cf0259b6986e7848da473;hp=0c44e8479ef4ba71ba5a3b535111725d2c9257d2;hpb=cbfcf21db4a2ef0f5db409591146f975ffe7b7f2;p=dygraphs.git

diff --git a/dygraph-canvas.js b/dygraph-canvas.js
index 0c44e84..915fd90 100644
--- a/dygraph-canvas.js
+++ b/dygraph-canvas.js
@@ -383,9 +383,17 @@ DygraphCanvasRenderer.prototype._renderAxis = function() {
     }
 
     // draw a vertical line on the left to separate the chart from the labels.
+    var axisX;
+    if (this.attr_('drawAxesAtZero')) {
+      var r = this.dygraph_.toPercentXCoord(0);
+      if (r > 1 || r < 0) r = 0;
+      axisX = halfUp(this.area.x + r * this.area.w);
+    } else {
+      axisX = halfUp(this.area.x);
+    }
     context.beginPath();
-    context.moveTo(halfUp(this.area.x), halfDown(this.area.y));
-    context.lineTo(halfUp(this.area.x), halfDown(this.area.y + this.area.h));
+    context.moveTo(axisX, halfDown(this.area.y));
+    context.lineTo(axisX, halfDown(this.area.y + this.area.h));
     context.closePath();
     context.stroke();
 
@@ -436,8 +444,16 @@ DygraphCanvasRenderer.prototype._renderAxis = function() {
     }
 
     context.beginPath();
-    context.moveTo(halfUp(this.area.x), halfDown(this.area.y + this.area.h));
-    context.lineTo(halfUp(this.area.x + this.area.w), halfDown(this.area.y + this.area.h));
+    var axisY;
+    if (this.attr_('drawAxesAtZero')) {
+      var r = this.dygraph_.toPercentYCoord(0, 0);
+      if (r > 1 || r < 0) r = 1;
+      axisY = halfDown(this.area.y + r * this.area.h);
+    } else {
+      axisY = halfDown(this.area.y + this.area.h);
+    }
+    context.moveTo(halfUp(this.area.x), axisY);
+    context.lineTo(halfUp(this.area.x + this.area.w), axisY);
     context.closePath();
     context.stroke();
   }
@@ -661,51 +677,71 @@ DygraphCanvasRenderer.prototype._renderAnnotations = function() {
   }
 };
 
-DygraphCanvasRenderer.makeNextPointStep_ = function(
-    connect, points, start, end) {
-  if (connect) {
-    return function(j) {
-      while (++j + start < end) {
-        if (!(points[start + j].yval === null)) break;
-      }
-      return j;
-    }
-  } else {
-    return function(j) { return j + 1 };
-  }
+/**
+ * Returns a predicate to be used with an iterator, which will
+ * iterate over points appropriately, depending on whether
+ * connectSeparatedPoints is true. When it's false, the predicate will
+ * skip over points with missing yVals.
+ */
+DygraphCanvasRenderer._getIteratorPredicate = function(connectSeparatedPoints) {
+  return connectSeparatedPoints ? DygraphCanvasRenderer._predicateThatSkipsEmptyPoints : null;
+}
+
+DygraphCanvasRenderer._predicateThatSkipsEmptyPoints =
+  function(array, idx) { return array[idx].yval !== null; }
+
+DygraphCanvasRenderer.isNullOrNaN_ = function(x) {
+  return (x === null || isNaN(x));
 };
 
 DygraphCanvasRenderer.prototype._drawStyledLine = function(
     ctx, i, setName, color, strokeWidth, strokePattern, drawPoints,
     drawPointCallback, pointSize) {
-  var isNullOrNaN = function(x) {
-    return (x === null || isNaN(x));
-  };
-
+  // TODO(konigsberg): Compute attributes outside this method call.
   var stepPlot = this.attr_("stepPlot");
   var firstIndexInSet = this.layout.setPointsOffsets[i];
   var setLength = this.layout.setPointsLengths[i];
-  var afterLastIndexInSet = firstIndexInSet + setLength;
   var points = this.layout.points;
-  var prevX = null;
-  var prevY = null;
-  var nextY = null;
-  var pointsOnLine = []; // Array of [canvasx, canvasy] pairs.
   if (!Dygraph.isArrayLike(strokePattern)) {
     strokePattern = null;
   }
   var drawGapPoints = this.dygraph_.attr_('drawGapEdgePoints', setName);
 
-  var point, nextPoint;
-  var next = DygraphCanvasRenderer.makeNextPointStep_(
-      this.attr_('connectSeparatedPoints'), points, firstIndexInSet,
-      afterLastIndexInSet);
   ctx.save();
-  for (var j = 0; j < setLength; j = next(j)) {
-    point = points[firstIndexInSet + j];
-    nextY = (next(j) < setLength) ?
-        points[firstIndexInSet + next(j)].canvasy : null;
-    if (isNullOrNaN(point.canvasy)) {
+
+  var iter = Dygraph.createIterator(points, firstIndexInSet, setLength,
+      DygraphCanvasRenderer._getIteratorPredicate(this.attr_("connectSeparatedPoints")));
+
+  if (strokeWidth && !stepPlot && (!strokePattern || strokePattern.length <= 1)) {
+    this._drawTrivialLine(ctx, iter, setName, color, strokeWidth, drawPointCallback, pointSize, drawPoints, drawGapPoints);
+  } else {
+    this._drawNonTrivialLine(ctx, iter, setName, color, strokeWidth, strokePattern, drawPointCallback, pointSize, drawPoints, drawGapPoints, stepPlot);
+  }
+  ctx.restore();
+};
+
+DygraphCanvasRenderer.prototype._drawPointsOnLine = function(ctx, pointsOnLine, drawPointCallback, setName, color, pointSize) {
+  for (var idx = 0; idx < pointsOnLine.length; idx++) {
+    var cb = pointsOnLine[idx];
+    ctx.save();
+    drawPointCallback(
+        this.dygraph_, setName, ctx, cb[0], cb[1], color, pointSize);
+    ctx.restore();
+  }
+}
+
+DygraphCanvasRenderer.prototype._drawNonTrivialLine = function(
+    ctx, iter, setName, color, strokeWidth, strokePattern, drawPointCallback, pointSize, drawPoints, drawGapPoints, stepPlot) {
+  var prevX = null;
+  var prevY = null;
+  var nextY = null;
+  var point;
+  var pointsOnLine = []; // Array of [canvasx, canvasy] pairs.
+  var first = true;
+  while(iter.hasNext()) {
+    point = iter.next();
+    nextY = iter.hasNext() ? iter.peek().canvasy : null;
+    if (DygraphCanvasRenderer.isNullOrNaN_(point.canvasy)) {
       if (stepPlot && prevX !== null) {
         // Draw a horizontal line to the start of the missing data
         ctx.beginPath();
@@ -719,12 +755,12 @@ DygraphCanvasRenderer.prototype._drawStyledLine = function(
     } else {
       // A point is "isolated" if it is non-null but both the previous
       // and next points are null.
-      var isIsolated = (!prevX && isNullOrNaN(nextY));
+      var isIsolated = (!prevX && DygraphCanvasRenderer.isNullOrNaN_(nextY));
       if (drawGapPoints) {
         // Also consider a point to be is "isolated" if it's adjacent to a
         // null point, excluding the graph edges.
-        if ((j > 0 && !prevX) ||
-            (next(j) < setLength && isNullOrNaN(nextY))) {
+        if ((!first && !prevX) ||
+            (iter.hasNext() && DygraphCanvasRenderer.isNullOrNaN_(nextY))) {
           isIsolated = true;
         }
       }
@@ -759,15 +795,51 @@ DygraphCanvasRenderer.prototype._drawStyledLine = function(
         pointsOnLine.push([point.canvasx, point.canvasy]);
       }
     }
+    first = false;
   }
-  for (var idx = 0; idx < pointsOnLine.length; idx++) {
-    var cb = pointsOnLine[idx];
-    ctx.save();
-    drawPointCallback(
-        this.dygraph_, setName, ctx, cb[0], cb[1], color, pointSize);
-    ctx.restore();
+  this._drawPointsOnLine(ctx, pointsOnLine, drawPointCallback, setName, color, pointSize);
+};
+
+DygraphCanvasRenderer.prototype._drawTrivialLine = function(
+    ctx, iter, setName, color, strokeWidth, drawPointCallback, pointSize, drawPoints, drawGapPoints) {
+  var prevX = null;
+  var prevY = null;
+  var nextY = null;
+  var pointsOnLine = []; // Array of [canvasx, canvasy] pairs.
+  ctx.beginPath();
+  ctx.strokeStyle = color;
+  ctx.lineWidth = strokeWidth;
+  var first = true;
+  while(iter.hasNext()) {
+    var point = iter.next();
+    nextY = iter.hasNext() ? iter.peek().canvasy : null;
+    if (DygraphCanvasRenderer.isNullOrNaN_(point.canvasy)) {
+      prevX = prevY = null;
+    } else {
+      var isIsolated = (!prevX && DygraphCanvasRenderer.isNullOrNaN_(nextY));
+      if (drawGapPoints) {
+        // Also consider a point to be is "isolated" if it's adjacent to a
+        // null point, excluding the graph edges.
+        if ((!first && !prevX) ||
+            (iter.hasNext() && DygraphCanvasRenderer.isNullOrNaN_(nextY))) {
+          isIsolated = true;
+        }
+      }
+      if (prevX === null) {
+        prevX = point.canvasx;
+        prevY = point.canvasy;
+        ctx.moveTo(point.canvasx, point.canvasy);
+      } else {
+        ctx.lineTo(point.canvasx, point.canvasy);
+      }
+      if (drawPoints || isIsolated) {
+        pointsOnLine.push([point.canvasx, point.canvasy]);
+      }
+    }
+    first = false;
   }
-  ctx.restore();
+  ctx.stroke();
+  this._drawPointsOnLine(ctx, pointsOnLine, drawPointCallback, setName, color, pointSize);
 };
 
 DygraphCanvasRenderer.prototype._drawLine = function(ctx, i) {
@@ -778,6 +850,8 @@ DygraphCanvasRenderer.prototype._drawLine = function(ctx, i) {
   var borderWidth = this.dygraph_.attr_("strokeBorderWidth", setName);
   var drawPointCallback = this.dygraph_.attr_("drawPointCallback", setName) ||
       Dygraph.Circles.DEFAULT;
+
+  // TODO(konigsberg): Turn this into one call, and then consider inlining drawStyledLine.
   if (borderWidth && strokeWidth) {
     this._drawStyledLine(ctx, i, setName,
         this.dygraph_.attr_("strokeBorderColor", setName),
@@ -812,7 +886,7 @@ DygraphCanvasRenderer.prototype._renderLineChart = function() {
   var stepPlot = this.attr_("stepPlot");
   var points = this.layout.points;
   var pointsLength = points.length;
-  var point, i, j, prevX, prevY, prevYs, color, setName, newYs, err_color, rgb, yscale, axis;
+  var point, i, prevX, prevY, prevYs, color, setName, newYs, err_color, rgb, yscale, axis;
 
   var setNames = this.layout.setNames;
   var setCount = setNames.length;
@@ -825,6 +899,10 @@ DygraphCanvasRenderer.prototype._renderLineChart = function() {
 
   // Update Points
   // TODO(danvk): here
+  //
+  // TODO(bhs): this loop is a hot-spot for high-point-count charts. These
+  // transformations can be pushed into the canvas via linear transformation
+  // matrices.
   for (i = pointsLength; i--;) {
     point = points[i];
     point.canvasx = this.area.w * point.x + this.area.x;
@@ -845,11 +923,9 @@ DygraphCanvasRenderer.prototype._renderLineChart = function() {
 
       var firstIndexInSet = this.layout.setPointsOffsets[i];
       var setLength = this.layout.setPointsLengths[i];
-      var afterLastIndexInSet = firstIndexInSet + setLength;
 
-      var next = DygraphCanvasRenderer.makeNextPointStep_(
-        this.attr_('connectSeparatedPoints'), points,
-        afterLastIndexInSet);
+      var iter = Dygraph.createIterator(points, firstIndexInSet, setLength,
+          DygraphCanvasRenderer._getIteratorPredicate(this.attr_("connectSeparatedPoints")));
 
       // setup graphics context
       prevX = NaN;
@@ -862,8 +938,8 @@ DygraphCanvasRenderer.prototype._renderLineChart = function() {
                             fillAlpha + ')';
       ctx.fillStyle = err_color;
       ctx.beginPath();
-      for (j = firstIndexInSet; j < afterLastIndexInSet; j = next(j)) {
-        point = points[j];
+      while (iter.hasNext()) {
+        point = iter.next();
         if (point.name == setName) { // TODO(klausw): this is always true
           if (!Dygraph.isOK(point.y)) {
             prevX = NaN;
@@ -917,11 +993,9 @@ DygraphCanvasRenderer.prototype._renderLineChart = function() {
       axisY = this.area.h * axisY + this.area.y;
       var firstIndexInSet = this.layout.setPointsOffsets[i];
       var setLength = this.layout.setPointsLengths[i];
-      var afterLastIndexInSet = firstIndexInSet + setLength;
 
-      var next = DygraphCanvasRenderer.makeNextPointStep_(
-        this.attr_('connectSeparatedPoints'), points,
-        afterLastIndexInSet);
+      var iter = Dygraph.createIterator(points, firstIndexInSet, setLength,
+          DygraphCanvasRenderer._getIteratorPredicate(this.attr_("connectSeparatedPoints")));
 
       // setup graphics context
       prevX = NaN;
@@ -933,8 +1007,8 @@ DygraphCanvasRenderer.prototype._renderLineChart = function() {
                             fillAlpha + ')';
       ctx.fillStyle = err_color;
       ctx.beginPath();
-      for (j = firstIndexInSet; j < afterLastIndexInSet; j = next(j)) {
-        point = points[j];
+      while(iter.hasNext()) {
+        point = iter.next();
         if (point.name == setName) { // TODO(klausw): this is always true
           if (!Dygraph.isOK(point.y)) {
             prevX = NaN;
@@ -953,7 +1027,7 @@ DygraphCanvasRenderer.prototype._renderLineChart = function() {
               }
             }
             newYs = [ point.canvasy, lastY ];
-            
+
             if(stepPlot) {
               // Step plots must keep track of the top and bottom of
               // the baseline at each point.
@@ -965,13 +1039,13 @@ DygraphCanvasRenderer.prototype._renderLineChart = function() {
             } else {
               baseline[point.canvasx] = point.canvasy;
             }
-            
+
           } else {
             newYs = [ point.canvasy, axisY ];
           }
           if (!isNaN(prevX)) {
             ctx.moveTo(prevX, prevYs[0]);
-            
+
             if (stepPlot) {
               ctx.lineTo(point.canvasx, prevYs[0]);
               if(currBaseline) {
@@ -984,7 +1058,7 @@ DygraphCanvasRenderer.prototype._renderLineChart = function() {
               ctx.lineTo(point.canvasx, newYs[0]);
               ctx.lineTo(point.canvasx, newYs[1]);
             }
-            
+
             ctx.lineTo(prevX, prevYs[1]);
             ctx.closePath();
           }