If the 'errorBars' option is set in the constructor, the input should be of
the form
-
Date,SeriesA,SeriesB,...
YYYYMMDD,A1,sigmaA1,B1,sigmaB1,...
YYYYMMDD,A2,sigmaA2,B2,sigmaB2,...
context.isPanning = true;
var xRange = g.xAxisRange();
context.dateRange = xRange[1] - xRange[0];
+ context.initialLeftmostDate = xRange[0];
+ context.xUnitsPerPixel = context.dateRange / (g.plotter_.area.w - 1);
// Record the range of each y-axis at the start of the drag.
// If any axis has a valueRange or valueWindow, then we want a 2D pan.
for (var i = 0; i < g.axes_.length; i++) {
var axis = g.axes_[i];
var yRange = g.yAxisRange(i);
+ // TODO(konigsberg): These values should be in |context|.
axis.dragValueRange = yRange[1] - yRange[0];
- axis.draggingValue = g.toDataYCoord(context.dragStartY, i);
+ axis.initialTopValue = yRange[1];
+ axis.unitsPerPixel = axis.dragValueRange / (g.plotter_.area.h - 1);
if (axis.valueWindow || axis.valueRange) context.is2DPan = true;
}
-
- // TODO(konigsberg): Switch from all this math to toDataCoords?
- // Seems to work for the dragging value.
- context.draggingDate = (context.dragStartX / g.width_) * context.dateRange + xRange[0];
};
// Called in response to an interaction model operation that
context.dragEndX = g.dragGetX_(event, context);
context.dragEndY = g.dragGetY_(event, context);
- // TODO(danvk): update this comment
- // Want to have it so that:
- // 1. draggingDate appears at dragEndX, draggingValue appears at dragEndY.
- // 2. daterange = (dateWindow_[1] - dateWindow_[0]) is unaltered.
- // 3. draggingValue appears at dragEndY.
- // 4. valueRange is unaltered.
-
- var minDate = context.draggingDate - (context.dragEndX / g.width_) * context.dateRange;
+ var minDate = context.initialLeftmostDate -
+ (context.dragEndX - context.dragStartX) * context.xUnitsPerPixel;
var maxDate = minDate + context.dateRange;
g.dateWindow_ = [minDate, maxDate];
// y-axis scaling is automatic unless this is a full 2D pan.
if (context.is2DPan) {
// Adjust each axis appropriately.
- // NOTE(konigsberg): I don't think this computation for y_frac is correct.
- // I think it doesn't take into account the display of the x axis.
- // See, when I tested this with console.log(y_frac), and move the mouse
- // cursor to the botom, the largest y_frac was 0.94, and not 1.0. That
- // could also explain why panning tends to start with a small jumpy shift.
- var y_frac = context.dragEndY / g.height_;
-
for (var i = 0; i < g.axes_.length; i++) {
var axis = g.axes_[i];
- var maxValue = axis.draggingValue + y_frac * axis.dragValueRange;
+ var maxValue = axis.initialTopValue +
+ (context.dragEndY - context.dragStartY) * axis.unitsPerPixel;
var minValue = maxValue - axis.dragValueRange;
axis.valueWindow = [ minValue, maxValue ];
}
// panning behavior.
//
Dygraph.endPan = function(event, g, context) {
+ // TODO(konigsberg): Clear the context data from the axis.
+ // TODO(konigsberg): mouseup should just delete the
+ // context object, and mousedown should create a new one.
context.isPanning = false;
context.is2DPan = false;
- context.draggingDate = null;
+ context.initialLeftmostDate = null;
context.dateRange = null;
context.valueRange = null;
}
prevEndY: null,
prevDragDirection: null,
- // TODO(danvk): update this comment
- // draggingDate and draggingValue represent the [date,value] point on the
- // graph at which the mouse was pressed. As the mouse moves while panning,
- // the viewport must pan so that the mouse position points to
- // [draggingDate, draggingValue]
- draggingDate: null,
+ // The value on the left side of the graph when a pan operation starts.
+ initialLeftmostDate: null,
+
+ // The number of units each pixel spans. (This won't be valid for log
+ // scales)
+ xUnitsPerPixel: null,
// TODO(danvk): update this comment
// The range in second/value units that the viewport encompasses during a
}
};
+Dygraph.PREFERRED_LOG_TICK_VALUES = function() {
+ var vals = [];
+ for (var power = -39; power <= 39; power++) {
+ var range = Math.pow(10, power);
+ for (var mult = 1; mult <= 9; mult++) {
+ var val = range * mult;
+ vals.push(val);
+ }
+ }
+ return vals;
+}();
+
+// val is the value to search for
+// arry is the value over which to search
+// if abs > 0, find the lowest entry greater than val
+// if abs < 0, find the highest entry less than val
+// if abs == 0, find the entry that equals val.
+// Currently does not work when val is outside the range of arry's values.
+Dygraph.binarySearch = function(val, arry, abs, low, high) {
+ if (low == null || high == null) {
+ low = 0;
+ high = arry.length - 1;
+ }
+ if (low > high) {
+ return -1;
+ }
+ if (abs == null) {
+ abs = 0;
+ }
+ var validIndex = function(idx) {
+ return idx >= 0 && idx < arry.length;
+ }
+ var mid = parseInt((low + high) / 2);
+ var element = arry[mid];
+ if (element == val) {
+ return mid;
+ }
+ if (element > val) {
+ if (abs > 0) {
+ // Accept if element > val, but also if prior element < val.
+ var idx = mid - 1;
+ if (validIndex(idx) && arry[idx] < val) {
+ return mid;
+ }
+ }
+ return Dygraph.binarySearch(val, arry, abs, low, mid - 1);
+ }
+ if (element < val) {
+ if (abs < 0) {
+ // Accept if element < val, but also if prior element > val.
+ var idx = mid + 1;
+ if (validIndex(idx) && arry[idx] > val) {
+ return mid;
+ }
+ }
+ return Dygraph.binarySearch(val, arry, abs, mid + 1, high);
+ }
+}
+
/**
* Add ticks when the x axis has numbers on it (instead of dates)
* TODO(konigsberg): Update comment.
}
} else {
if (axis_props && attr("logscale")) {
- // As opposed to the other ways for computing ticks, we're just going
- // for nearby values. There's no reasonable way to scale the values
- // (unless we want to show strings like "log(" + x + ")") in which case
- // x can be integer values.
-
- // so compute height / pixelsPerTick and move on.
var pixelsPerTick = attr('pixelsPerYLabel');
// NOTE(konigsberg): Dan, should self.height_ be self.plotter_.area.h?
var nTicks = Math.floor(self.height_ / pixelsPerTick);
- var vv = minV;
- var lmv = Dygraph.log10(minV);
- var lxv = Dygraph.log10(maxV);
- var logMultiplier = (lxv - lmv) / nTicks;
- var multiplier = Math.pow(Dygraph.LOG_SCALE, logMultiplier);
- // Construct the set of ticks.
- for (var i = 0; i < nTicks; i++) {
- ticks.push( {v: vv} );
- vv = vv * multiplier;
+ var minIdx = Dygraph.binarySearch(minV, Dygraph.PREFERRED_LOG_TICK_VALUES, 1);
+ var maxIdx = Dygraph.binarySearch(maxV, Dygraph.PREFERRED_LOG_TICK_VALUES, -1);
+ if (minIdx == -1) {
+ minIdx = 0;
}
- } else {
+ if (maxIdx == -1) {
+ maxIdx = Dygraph.PREFERRED_LOG_TICK_VALUES.length - 1;
+ }
+ // Count the number of tick values would appear, if we can get at least
+ // nTicks / 4 accept them.
+ var lastDisplayed = null;
+ if (maxIdx - minIdx >= nTicks / 4) {
+ var axisId = axis_props.yAxisId;
+ for (var idx = maxIdx; idx >= minIdx; idx--) {
+ var tickValue = Dygraph.PREFERRED_LOG_TICK_VALUES[idx];
+ var domCoord = axis_props.g.toDomYCoord(tickValue, axisId);
+ var tick = { v: tickValue };
+ if (lastDisplayed == null) {
+ lastDisplayed = {
+ tickValue : tickValue,
+ domCoord : domCoord
+ };
+ } else {
+ if (domCoord - lastDisplayed.domCoord >= pixelsPerTick) {
+ lastDisplayed = {
+ tickValue : tickValue,
+ domCoord : domCoord
+ };
+ } else {
+ tick.label = "";
+ }
+ }
+ ticks.push(tick);
+ }
+ // Since we went in backwards order.
+ ticks.reverse();
+ }
+ }
+ // ticks.length won't be 0 if the log scale function finds values to insert.
+ if (ticks.length == 0) {
// Basic idea:
// Try labels every 1, 2, 5, 10, 20, 50, 100, etc.
// Calculate the resulting tick spacing (i.e. this.height_ / nTicks).
}
var formatter = attr('yAxisLabelFormatter') ? attr('yAxisLabelFormatter') : attr('yValueFormatter');
+ // Add labels to the ticks.
for (var i = 0; i < ticks.length; i++) {
- var tickV = ticks[i].v;
- var absTickV = Math.abs(tickV);
- var label;
- if (formatter != undefined) {
- label = formatter(tickV);
- } else {
- label = Dygraph.round_(tickV, 2);
- }
- if (k_labels.length) {
- // Round up to an appropriate unit.
- var n = k*k*k*k;
- for (var j = 3; j >= 0; j--, n /= k) {
- if (absTickV >= n) {
- label = Dygraph.round_(tickV / n, 1) + k_labels[j];
- break;
+ if (ticks[i].label == null) {
+ var tickV = ticks[i].v;
+ var absTickV = Math.abs(tickV);
+ var label;
+ if (formatter != undefined) {
+ label = formatter(tickV);
+ } else {
+ label = Dygraph.round_(tickV, 2);
+ }
+ if (k_labels.length) {
+ // Round up to an appropriate unit.
+ var n = k*k*k*k;
+ for (var j = 3; j >= 0; j--, n /= k) {
+ if (absTickV >= n) {
+ label = Dygraph.round_(tickV / n, 1) + k_labels[j];
+ break;
+ }
}
}
+ ticks[i].label = label;
}
- ticks[i].label = label;
}
return ticks;
};
* indices are into the axes_ array.
*/
Dygraph.prototype.computeYAxes_ = function() {
- this.axes_ = [{}]; // always have at least one y-axis.
+ this.axes_ = [{ yAxisId : 0, g : this }]; // always have at least one y-axis.
this.seriesToAxisMap_ = {};
// Get a list of series names.
var opts = {};
Dygraph.update(opts, this.axes_[0]);
Dygraph.update(opts, { valueRange: null }); // shouldn't inherit this.
+ var yAxisId = this.axes_.length;
+ opts.yAxisId = yAxisId;
+ opts.g = this;
Dygraph.update(opts, axis);
this.axes_.push(opts);
- this.seriesToAxisMap_[seriesName] = this.axes_.length - 1;
+ this.seriesToAxisMap_[seriesName] = yAxisId;
}
}