X-Git-Url: https://adrianiainlam.tk/git/?a=blobdiff_plain;f=dygraph-layout.js;h=54496aa2cad402f4347723c4ba352c03b415ad2e;hb=c432a749fa6d9dba4dbdf25e4e56935b91f5a984;hp=266e3d0e0a5312105ac79579c7c78c2b581e4abf;hpb=4ab8db0c00008f89d9b9eb3247d7e933965ce9d5;p=dygraphs.git diff --git a/dygraph-layout.js b/dygraph-layout.js index 266e3d0..54496aa 100644 --- a/dygraph-layout.js +++ b/dygraph-layout.js @@ -1,11 +1,18 @@ -// Copyright 2011 Dan Vanderkam (danvdk@gmail.com) -// All Rights Reserved. +/** + * @license + * Copyright 2011 Dan Vanderkam (danvdk@gmail.com) + * MIT-licensed (http://opensource.org/licenses/MIT) + */ /** * @fileoverview Based on PlotKitLayout, but modified to meet the needs of * dygraphs. */ +/*jshint globalstrict: true */ +/*global Dygraph:false */ +"use strict"; + /** * Creates a new DygraphLayout object. * @@ -22,11 +29,13 @@ * * @constructor */ -DygraphLayout = function(dygraph) { +var DygraphLayout = function(dygraph) { this.dygraph_ = dygraph; - this.datasets = new Array(); - this.annotations = new Array(); + this.datasets = []; + this.setNames = []; + this.annotations = []; this.yAxes_ = null; + this.points = null; // TODO(danvk): it's odd that xTicks_ and yTicks_ are inputs, but xticks and // yticks are outputs. Clean this up. @@ -39,7 +48,85 @@ DygraphLayout.prototype.attr_ = function(name) { }; DygraphLayout.prototype.addDataset = function(setname, set_xy) { - this.datasets[setname] = set_xy; + this.datasets.push(set_xy); + this.setNames.push(setname); +}; + +/** + * Returns the box which the chart should be drawn in. This is the canvas's + * box, less space needed for the axis and chart labels. + * + * @return {{x: number, y: number, w: number, h: number}} + */ +DygraphLayout.prototype.getPlotArea = function() { + return this.area_; +}; + +// Compute the box which the chart should be drawn in. This is the canvas's +// box, less space needed for axis, chart labels, and other plug-ins. +// NOTE: This should only be called by Dygraph.predraw_(). +DygraphLayout.prototype.computePlotArea = function() { + var area = { + // TODO(danvk): per-axis setting. + x: 0, + y: 0 + }; + + area.w = this.dygraph_.width_ - area.x - this.attr_('rightGap'); + area.h = this.dygraph_.height_; + + // Let plugins reserve space. + var e = { + chart_div: this.dygraph_.graphDiv, + reserveSpaceLeft: function(px) { + var r = { + x: area.x, + y: area.y, + w: px, + h: area.h + }; + area.x += px; + area.w -= px; + return r; + }, + reserveSpaceRight: function(px) { + var r = { + x: area.x + area.w - px, + y: area.y, + w: px, + h: area.h + }; + area.w -= px; + return r; + }, + reserveSpaceTop: function(px) { + var r = { + x: area.x, + y: area.y, + w: area.w, + h: px + }; + area.y += px; + area.h -= px; + return r; + }, + reserveSpaceBottom: function(px) { + var r = { + x: area.x, + y: area.y + area.h - px, + w: area.w, + h: px + }; + area.h -= px; + return r; + }, + chartRect: function() { + return {x:area.x, y:area.y, w:area.w, h:area.h}; + } + }; + this.dygraph_.cascadeEvents_('layout', e); + + this.area_ = area; }; DygraphLayout.prototype.setAnnotations = function(ann) { @@ -49,7 +136,7 @@ DygraphLayout.prototype.setAnnotations = function(ann) { var parse = this.attr_('xValueParser') || function(x) { return x; }; for (var i = 0; i < ann.length; i++) { var a = {}; - if (!ann[i].xval && !ann[i].x) { + if (!ann[i].xval && ann[i].x === undefined) { this.dygraph_.error("Annotations must have an 'x' property"); return; } @@ -75,10 +162,6 @@ DygraphLayout.prototype.setYAxes = function (yAxes) { this.yAxes_ = yAxes; }; -DygraphLayout.prototype.setDateWindow = function(dateWindow) { - this.dateWindow_ = dateWindow; -}; - DygraphLayout.prototype.evaluate = function() { this._evaluateLimits(); this._evaluateLineCharts(); @@ -87,36 +170,22 @@ DygraphLayout.prototype.evaluate = function() { }; DygraphLayout.prototype._evaluateLimits = function() { - this.minxval = this.maxxval = null; - if (this.dateWindow_) { - this.minxval = this.dateWindow_[0]; - this.maxxval = this.dateWindow_[1]; - } else { - for (var name in this.datasets) { - if (!this.datasets.hasOwnProperty(name)) continue; - var series = this.datasets[name]; - if (series.length > 1) { - var x1 = series[0][0]; - if (!this.minxval || x1 < this.minxval) this.minxval = x1; - - var x2 = series[series.length - 1][0]; - if (!this.maxxval || x2 > this.maxxval) this.maxxval = x2; - } - } - } - this.xrange = this.maxxval - this.minxval; - this.xscale = (this.xrange != 0 ? 1/this.xrange : 1.0); + var xlimits = this.dygraph_.xAxisRange(); + this.minxval = xlimits[0]; + this.maxxval = xlimits[1]; + var xrange = xlimits[1] - xlimits[0]; + this.xscale = (xrange !== 0 ? 1 / xrange : 1.0); for (var i = 0; i < this.yAxes_.length; i++) { var axis = this.yAxes_[i]; axis.minyval = axis.computedValueRange[0]; axis.maxyval = axis.computedValueRange[1]; axis.yrange = axis.maxyval - axis.minyval; - axis.yscale = (axis.yrange != 0 ? 1.0 / axis.yrange : 1.0); + axis.yscale = (axis.yrange !== 0 ? 1.0 / axis.yrange : 1.0); if (axis.g.attr_("logscale")) { axis.ylogrange = Dygraph.log10(axis.maxyval) - Dygraph.log10(axis.minyval); - axis.ylogscale = (axis.ylogrange != 0 ? 1.0 / axis.ylogrange : 1.0); + axis.ylogscale = (axis.ylogrange !== 0 ? 1.0 / axis.ylogrange : 1.0); if (!isFinite(axis.ylogrange) || isNaN(axis.ylogrange)) { axis.g.error('axis ' + i + ' of graph at ' + axis.g + ' can\'t be displayed in log scale for range [' + @@ -126,83 +195,98 @@ DygraphLayout.prototype._evaluateLimits = function() { } }; +DygraphLayout._calcYNormal = function(axis, value, logscale) { + if (logscale) { + return 1.0 - ((Dygraph.log10(value) - Dygraph.log10(axis.minyval)) * axis.ylogscale); + } else { + return 1.0 - ((value - axis.minyval) * axis.yscale); + } +}; + DygraphLayout.prototype._evaluateLineCharts = function() { - // add all the rects - this.points = new Array(); - for (var setName in this.datasets) { - if (!this.datasets.hasOwnProperty(setName)) continue; + var connectSeparated = this.attr_('connectSeparatedPoints'); + + // series index -> point index in series -> |point| structure + this.points = new Array(this.datasets.length); - var dataset = this.datasets[setName]; + // TODO(bhs): these loops are a hot-spot for high-point-count charts. In fact, + // on chrome+linux, they are 6 times more expensive than iterating through the + // points and drawing the lines. The brunt of the cost comes from allocating + // the |point| structures. + var boundaryIdStart = this.dygraph_.getLeftBoundary_(); + for (var setIdx = 0; setIdx < this.datasets.length; setIdx++) { + var dataset = this.datasets[setIdx]; + var setName = this.setNames[setIdx]; var axis = this.dygraph_.axisPropertiesForSeries(setName); + // TODO (konigsberg): use optionsForAxis instead. + var logscale = this.dygraph_.attributes_.getForSeries("logscale", setName); - var graphWidth = this.dygraph_.width_; - var graphHeight = this.dygraph_.height_; - var prevXPx = NaN; - var prevYPx = NaN; - var currXPx = NaN; - var currYPx = NaN; - - var errorBars = this.attr_("errorBars") || this.attr_("customBars"); + // Preallocating the size of points reduces reallocations, and therefore, + // calls to collect garbage. + var seriesPoints = new Array(dataset.length); for (var j = 0; j < dataset.length; j++) { var item = dataset[j]; - var xValue = parseFloat(dataset[j][0]); - var yValue = parseFloat(dataset[j][1]); - - // Range from 0-1 where 0 represents top and 1 represents bottom - var xNormal = (xValue - this.minxval) * this.xscale; + var xValue = DygraphLayout.parseFloat_(item[0]); + var yValue = DygraphLayout.parseFloat_(item[1]); + // Range from 0-1 where 0 represents left and 1 represents right. - var yNormal; - if (axis.logscale) { - yNormal = 1.0 - ((Dygraph.log10(yValue) - Dygraph.log10(axis.minyval)) * axis.ylogscale); - } else { - yNormal = 1.0 - ((yValue - axis.minyval) * axis.yscale); - } - - // Current pixel coordinates that the data point would fill. - currXPx = Math.round(xNormal * graphWidth); - currYPx = Math.round(yNormal * graphHeight); - - // Skip over pushing points that lie on the same pixel. - // Ignore this optimization if there are error bars. - // TODO(antrob): optimize this for graphs with error bars. - if (prevXPx != currXPx || prevYPx != currYPx || errorBars) { - // TODO(antrob): skip over points that lie on a line that is already going to be drawn. - // There is no need to have more than 2 consecutive points that are collinear. - var point = { - // TODO(danvk): here - x: xNormal, - y: yNormal, - xval: xValue, - yval: yValue, - name: setName - }; - this.points.push(point); + var xNormal = (xValue - this.minxval) * this.xscale; + // Range from 0-1 where 0 represents top and 1 represents bottom + var yNormal = DygraphLayout._calcYNormal(axis, yValue, logscale); + + // TODO(danvk): drop the point in this case, don't null it. + // The nulls create complexity in DygraphCanvasRenderer._drawSeries. + if (connectSeparated && item[1] === null) { + yValue = null; } - prevXPx = currXPx; - prevYPx = currYPx; + seriesPoints[j] = { + x: xNormal, + y: yNormal, + xval: xValue, + yval: yValue, + name: setName, // TODO(danvk): is this really necessary? + idx: j + boundaryIdStart + }; } + + this.points[setIdx] = seriesPoints; } }; +/** + * Optimized replacement for parseFloat, which was way too slow when almost + * all values were type number, with few edge cases, none of which were strings. + */ +DygraphLayout.parseFloat_ = function(val) { + // parseFloat(null) is NaN + if (val === null) { + return NaN; + } + + // Assume it's a number or NaN. If it's something else, I'll be shocked. + return val; +}; + DygraphLayout.prototype._evaluateLineTicks = function() { - this.xticks = new Array(); - for (var i = 0; i < this.xTicks_.length; i++) { - var tick = this.xTicks_[i]; - var label = tick.label; - var pos = this.xscale * (tick.v - this.minxval); + var i, tick, label, pos; + this.xticks = []; + for (i = 0; i < this.xTicks_.length; i++) { + tick = this.xTicks_[i]; + label = tick.label; + pos = this.xscale * (tick.v - this.minxval); if ((pos >= 0.0) && (pos <= 1.0)) { this.xticks.push([pos, label]); } } - this.yticks = new Array(); - for (var i = 0; i < this.yAxes_.length; i++ ) { + this.yticks = []; + for (i = 0; i < this.yAxes_.length; i++ ) { var axis = this.yAxes_[i]; for (var j = 0; j < axis.ticks.length; j++) { - var tick = axis.ticks[j]; - var label = tick.label; - var pos = this.dygraph_.toPercentYCoord(tick.v, i); + tick = axis.ticks[j]; + label = tick.label; + pos = this.dygraph_.toPercentYCoord(tick.v, i); if ((pos >= 0.0) && (pos <= 1.0)) { this.yticks.push([i, pos, label]); } @@ -220,20 +304,30 @@ DygraphLayout.prototype.evaluateWithError = function() { if (!(this.attr_('errorBars') || this.attr_('customBars'))) return; // Copy over the error terms - var i = 0; // index in this.points - for (var setName in this.datasets) { - if (!this.datasets.hasOwnProperty(setName)) continue; + var i = 0; // index in this.points + for (var setIdx = 0; setIdx < this.datasets.length; ++setIdx) { + var points = this.points[setIdx]; var j = 0; - var dataset = this.datasets[setName]; - for (var j = 0; j < dataset.length; j++, i++) { + var dataset = this.datasets[setIdx]; + var setName = this.setNames[setIdx]; + var axis = this.dygraph_.axisPropertiesForSeries(setName); + // TODO (konigsberg): use optionsForAxis instead. + var logscale = this.dygraph_.attributes_.getForSeries("logscale", setName); + + for (j = 0; j < dataset.length; j++, i++) { var item = dataset[j]; - var xv = parseFloat(item[0]); - var yv = parseFloat(item[1]); + var xv = DygraphLayout.parseFloat_(item[0]); + var yv = DygraphLayout.parseFloat_(item[1]); - if (xv == this.points[i].xval && - yv == this.points[i].yval) { - this.points[i].errorMinus = parseFloat(item[2]); - this.points[i].errorPlus = parseFloat(item[3]); + if (xv == points[j].xval && + yv == points[j].yval) { + var errorMinus = DygraphLayout.parseFloat_(item[2]); + var errorPlus = DygraphLayout.parseFloat_(item[3]); + + var yv_minus = yv - errorMinus; + var yv_plus = yv + errorPlus; + points[j].y_top = DygraphLayout._calcYNormal(axis, yv_minus, logscale); + points[j].y_bottom = DygraphLayout._calcYNormal(axis, yv_plus, logscale); } } } @@ -242,8 +336,9 @@ DygraphLayout.prototype.evaluateWithError = function() { DygraphLayout.prototype._evaluateAnnotations = function() { // Add the annotations to the point to which they belong. // Make a map from (setName, xval) to annotation for quick lookups. + var i; var annotations = {}; - for (var i = 0; i < this.annotations.length; i++) { + for (i = 0; i < this.annotations.length; i++) { var a = this.annotations[i]; annotations[a.xval + "," + a.series] = a; } @@ -254,14 +349,17 @@ DygraphLayout.prototype._evaluateAnnotations = function() { if (!this.annotations || !this.annotations.length) { return; } - + // TODO(antrob): loop through annotations not points. - for (var i = 0; i < this.points.length; i++) { - var p = this.points[i]; - var k = p.xval + "," + p.name; - if (k in annotations) { - p.annotation = annotations[k]; - this.annotated_points.push(p); + for (var setIdx = 0; setIdx < this.points.length; setIdx++) { + var points = this.points[setIdx]; + for (i = 0; i < points.length; i++) { + var p = points[i]; + var k = p.xval + "," + p.name; + if (k in annotations) { + p.annotation = annotations[k]; + this.annotated_points.push(p); + } } } }; @@ -271,34 +369,48 @@ DygraphLayout.prototype._evaluateAnnotations = function() { */ DygraphLayout.prototype.removeAllDatasets = function() { delete this.datasets; - this.datasets = new Array(); + delete this.setNames; + delete this.setPointsLengths; + delete this.setPointsOffsets; + this.datasets = []; + this.setNames = []; + this.setPointsLengths = []; + this.setPointsOffsets = []; }; /** * Return a copy of the point at the indicated index, with its yval unstacked. * @param int index of point in layout_.points */ -DygraphLayout.prototype.unstackPointAtIndex = function(idx) { - var point = this.points[idx]; - +DygraphLayout.prototype.unstackPointAtIndex = function(setIdx, row) { + var point = this.points[setIdx][row]; + // If the point is missing, no unstacking is necessary + if (!Dygraph.isValidPoint(point)) { + return point; + } + // Clone the point since we modify it - var unstackedPoint = {}; - for (var i in point) { - unstackedPoint[i] = point[i]; + var unstackedPoint = {}; + for (var pt in point) { + unstackedPoint[pt] = point[pt]; } - + if (!this.attr_("stackedGraph")) { return unstackedPoint; } - - // The unstacked yval is equal to the current yval minus the yval of the + + // The unstacked yval is equal to the current yval minus the yval of the // next point at the same xval. - for (var i = idx+1; i < this.points.length; i++) { - if (this.points[i].xval == point.xval) { - unstackedPoint.yval -= this.points[i].yval; - break; + // We need to iterate over setIdx just in case some series have invalid values + // at current row + for(setIdx++; setIdx < this.points.length; setIdx++) { + var nextPoint = this.points[setIdx][row]; + if (nextPoint.xval == point.xval && // should always be true? + Dygraph.isValidPoint(nextPoint)) { + unstackedPoint.yval -= nextPoint.yval; + break; // stop at first valid point } } - + return unstackedPoint; -} +};