X-Git-Url: https://adrianiainlam.tk/git/?a=blobdiff_plain;f=dygraph-layout.js;h=ac1eca0ade8714177782893e333bbf0cf4fb849c;hb=7d1afbb93536f59e428f414d76514f25be4fffb6;hp=17de46700cd4095407f7b82220a88161702ac30c;hpb=88e95c462340958bdfd0ac4c0736b94c5fd21024;p=dygraphs.git diff --git a/dygraph-layout.js b/dygraph-layout.js index 17de467..ac1eca0 100644 --- a/dygraph-layout.js +++ b/dygraph-layout.js @@ -9,6 +9,10 @@ * dygraphs. */ +/*jshint globalstrict: true */ +/*global Dygraph:false */ +"use strict"; + /** * Creates a new DygraphLayout object. * @@ -25,10 +29,11 @@ * * @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; // TODO(danvk): it's odd that xTicks_ and yTicks_ are inputs, but xticks and @@ -42,7 +47,71 @@ 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); +}; + +DygraphLayout.prototype.getPlotArea = function() { + return this.computePlotArea_(); +}; + +// Compute the box which the chart should be drawn in. This is the canvas's +// box, less space needed for axis and chart labels. +DygraphLayout.prototype.computePlotArea_ = function() { + var area = { + // TODO(danvk): per-axis setting. + x: 0, + y: 0 + }; + if (this.attr_('drawYAxis')) { + area.x = this.attr_('yAxisLabelWidth') + 2 * this.attr_('axisTickSize'); + } + + area.w = this.dygraph_.width_ - area.x - this.attr_('rightGap'); + area.h = this.dygraph_.height_; + if (this.attr_('drawXAxis')) { + if (this.attr_('xAxisHeight')) { + area.h -= this.attr_('xAxisHeight'); + } else { + area.h -= this.attr_('axisLabelFontSize') + 2 * this.attr_('axisTickSize'); + } + } + + // Shrink the drawing area to accomodate additional y-axes. + if (this.dygraph_.numAxes() == 2) { + // TODO(danvk): per-axis setting. + area.w -= (this.attr_('yAxisLabelWidth') + 2 * this.attr_('axisTickSize')); + } else if (this.dygraph_.numAxes() > 2) { + this.dygraph_.error("Only two y-axes are supported at this time. (Trying " + + "to use " + this.dygraph_.numAxes() + ")"); + } + + // Add space for chart labels: title, xlabel and ylabel. + if (this.attr_('title')) { + area.h -= this.attr_('titleHeight'); + area.y += this.attr_('titleHeight'); + } + if (this.attr_('xlabel')) { + area.h -= this.attr_('xLabelHeight'); + } + if (this.attr_('ylabel')) { + // It would make sense to shift the chart here to make room for the y-axis + // label, but the default yAxisLabelWidth is large enough that this results + // in overly-padded charts. The y-axis label should fit fine. If it + // doesn't, the yAxisLabelWidth option can be increased. + } + + if (this.attr_('y2label')) { + // same logic applies here as for ylabel. + // TODO(danvk): make yAxisLabelWidth a per-axis property + } + + // Add space for range selector, if needed. + if (this.attr_('showRangeSelector')) { + area.h -= this.attr_('rangeSelectorHeight') + 4; + } + + return area; }; DygraphLayout.prototype.setAnnotations = function(ann) { @@ -95,31 +164,30 @@ DygraphLayout.prototype._evaluateLimits = function() { 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]; + for (var setIdx = 0; setIdx < this.datasets.length; ++setIdx) { + var series = this.datasets[setIdx]; 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); + this.xscale = (this.xrange !== 0 ? 1/this.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 [' + @@ -138,33 +206,49 @@ DygraphLayout._calcYNormal = function(axis, value) { }; DygraphLayout.prototype._evaluateLineCharts = function() { - // add all the rects - this.points = new Array(); // An array to keep track of how many points will be drawn for each set. // This will allow for the canvas renderer to not have to check every point // for every data set since the points are added in order of the sets in // datasets. - this.setPointsLengths = new Array(); - - for (var setName in this.datasets) { - if (!this.datasets.hasOwnProperty(setName)) continue; + this.setPointsLengths = []; + this.setPointsOffsets = []; + + var connectSeparated = this.attr_('connectSeparatedPoints'); + // 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 i = 0; + var setIdx; + + // Preallocating the size of points reduces reallocations, and therefore, + // calls to collect garbage. + var totalPoints = 0; + for (setIdx = 0; setIdx < this.datasets.length; ++setIdx) { + totalPoints += this.datasets[setIdx].length; + } + this.points = new Array(totalPoints); - var dataset = this.datasets[setName]; + for (setIdx = 0; setIdx < this.datasets.length; ++setIdx) { + this.setPointsOffsets.push(i); + var dataset = this.datasets[setIdx]; + var setName = this.setNames[setIdx]; var axis = this.dygraph_.axisPropertiesForSeries(setName); - var setPointsLength = 0; - for (var j = 0; j < dataset.length; j++) { var item = dataset[j]; - var xValue = parseFloat(dataset[j][0]); - var yValue = parseFloat(dataset[j][1]); + 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 xNormal = (xValue - this.minxval) * this.xscale; // Range from 0-1 where 0 represents top and 1 represents bottom var yNormal = DygraphLayout._calcYNormal(axis, yValue); - var point = { + if (connectSeparated && item[1] === null) { + yValue = null; + } + this.points[i] = { // TODO(danvk): here x: xNormal, y: yNormal, @@ -172,31 +256,45 @@ DygraphLayout.prototype._evaluateLineCharts = function() { yval: yValue, name: setName }; - this.points.push(point); - setPointsLength += 1; + i++; } - this.setPointsLengths.push(setPointsLength); + this.setPointsLengths.push(i - this.setPointsOffsets[setIdx]); } }; +/** + * 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]); } @@ -214,21 +312,21 @@ 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 j = 0; - var dataset = this.datasets[setName]; + var dataset = this.datasets[setIdx]; + var setName = this.setNames[setIdx]; var axis = this.dygraph_.axisPropertiesForSeries(setName); - for (var j = 0; j < dataset.length; j++, i++) { + 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) { - var errorMinus = parseFloat(item[2]); - var errorPlus = parseFloat(item[3]); + var errorMinus = DygraphLayout.parseFloat_(item[2]); + var errorPlus = DygraphLayout.parseFloat_(item[3]); var yv_minus = yv - errorMinus; var yv_plus = yv + errorPlus; @@ -242,8 +340,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,9 +353,9 @@ 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++) { + for (i = 0; i < this.points.length; i++) { var p = this.points[i]; var k = p.xval + "," + p.name; if (k in annotations) { @@ -271,7 +370,13 @@ 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 = []; }; /** @@ -280,25 +385,29 @@ DygraphLayout.prototype.removeAllDatasets = function() { */ DygraphLayout.prototype.unstackPointAtIndex = function(idx) { var point = this.points[idx]; - + // If the point is missing, no unstacking is necessary + if (!point.yval) { + 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; + if ((this.points[i].xval == point.xval) && this.points[i].yval) { + unstackedPoint.yval -= this.points[i].yval; break; } } - + return unstackedPoint; -} +};