You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
804 lines
31 KiB
804 lines
31 KiB
// MIT License: |
|
// |
|
// Copyright (c) 2010-2013, Joe Walnes |
|
// 2013-2014, Drew Noakes |
|
// |
|
// Permission is hereby granted, free of charge, to any person obtaining a copy |
|
// of this software and associated documentation files (the "Software"), to deal |
|
// in the Software without restriction, including without limitation the rights |
|
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
|
// copies of the Software, and to permit persons to whom the Software is |
|
// furnished to do so, subject to the following conditions: |
|
// |
|
// The above copyright notice and this permission notice shall be included in |
|
// all copies or substantial portions of the Software. |
|
// |
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
|
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
|
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
|
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
|
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
|
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN |
|
// THE SOFTWARE. |
|
|
|
/** |
|
* Smoothie Charts - http://smoothiecharts.org/ |
|
* (c) 2010-2013, Joe Walnes |
|
* 2013-2014, Drew Noakes |
|
* |
|
* v1.0: Main charting library, by Joe Walnes |
|
* v1.1: Auto scaling of axis, by Neil Dunn |
|
* v1.2: fps (frames per second) option, by Mathias Petterson |
|
* v1.3: Fix for divide by zero, by Paul Nikitochkin |
|
* v1.4: Set minimum, top-scale padding, remove timeseries, add optional timer to reset bounds, by Kelley Reynolds |
|
* v1.5: Set default frames per second to 50... smoother. |
|
* .start(), .stop() methods for conserving CPU, by Dmitry Vyal |
|
* options.interpolation = 'bezier' or 'line', by Dmitry Vyal |
|
* options.maxValue to fix scale, by Dmitry Vyal |
|
* v1.6: minValue/maxValue will always get converted to floats, by Przemek Matylla |
|
* v1.7: options.grid.fillStyle may be a transparent color, by Dmitry A. Shashkin |
|
* Smooth rescaling, by Kostas Michalopoulos |
|
* v1.8: Set max length to customize number of live points in the dataset with options.maxDataSetLength, by Krishna Narni |
|
* v1.9: Display timestamps along the bottom, by Nick and Stev-io |
|
* (https://groups.google.com/forum/?fromgroups#!topic/smoothie-charts/-Ywse8FCpKI%5B1-25%5D) |
|
* Refactored by Krishna Narni, to support timestamp formatting function |
|
* v1.10: Switch to requestAnimationFrame, removed the now obsoleted options.fps, by Gergely Imreh |
|
* v1.11: options.grid.sharpLines option added, by @drewnoakes |
|
* Addressed warning seen in Firefox when seriesOption.fillStyle undefined, by @drewnoakes |
|
* v1.12: Support for horizontalLines added, by @drewnoakes |
|
* Support for yRangeFunction callback added, by @drewnoakes |
|
* v1.13: Fixed typo (#32), by @alnikitich |
|
* v1.14: Timer cleared when last TimeSeries removed (#23), by @davidgaleano |
|
* Fixed diagonal line on chart at start/end of data stream, by @drewnoakes |
|
* v1.15: Support for npm package (#18), by @dominictarr |
|
* Fixed broken removeTimeSeries function (#24) by @davidgaleano |
|
* Minor performance and tidying, by @drewnoakes |
|
* v1.16: Bug fix introduced in v1.14 relating to timer creation/clearance (#23), by @drewnoakes |
|
* TimeSeries.append now deals with out-of-order timestamps, and can merge duplicates, by @zacwitte (#12) |
|
* Documentation and some local variable renaming for clarity, by @drewnoakes |
|
* v1.17: Allow control over font size (#10), by @drewnoakes |
|
* Timestamp text won't overlap, by @drewnoakes |
|
* v1.18: Allow control of max/min label precision, by @drewnoakes |
|
* Added 'borderVisible' chart option, by @drewnoakes |
|
* Allow drawing series with fill but no stroke (line), by @drewnoakes |
|
* v1.19: Avoid unnecessary repaints, and fixed flicker in old browsers having multiple charts in document (#40), by @asbai |
|
* v1.20: Add SmoothieChart.getTimeSeriesOptions and SmoothieChart.bringToFront functions, by @drewnoakes |
|
* v1.21: Add 'step' interpolation mode, by @drewnoakes |
|
* v1.22: Add support for different pixel ratios. Also add optional y limit formatters, by @copacetic |
|
* v1.23: Fix bug introduced in v1.22 (#44), by @drewnoakes |
|
* v1.24: Fix bug introduced in v1.23, re-adding parseFloat to y-axis formatter defaults, by @siggy_sf |
|
* v1.25: Fix bug seen when adding a data point to TimeSeries which is older than the current data, by @Nking92 |
|
* Draw time labels on top of series, by @comolosabia |
|
* Add TimeSeries.clear function, by @drewnoakes |
|
* v1.26: Add support for resizing on high device pixel ratio screens, by @copacetic |
|
* v1.27: Fix bug introduced in v1.26 for non whole number devicePixelRatio values, by @zmbush |
|
* v1.28: Add 'minValueScale' option, by @megawac |
|
*/ |
|
|
|
;(function(exports) { |
|
|
|
var Util = { |
|
extend: function() { |
|
arguments[0] = arguments[0] || {}; |
|
for (var i = 1; i < arguments.length; i++) |
|
{ |
|
for (var key in arguments[i]) |
|
{ |
|
if (arguments[i].hasOwnProperty(key)) |
|
{ |
|
if (typeof(arguments[i][key]) === 'object') { |
|
if (arguments[i][key] instanceof Array) { |
|
arguments[0][key] = arguments[i][key]; |
|
} else { |
|
arguments[0][key] = Util.extend(arguments[0][key], arguments[i][key]); |
|
} |
|
} else { |
|
arguments[0][key] = arguments[i][key]; |
|
} |
|
} |
|
} |
|
} |
|
return arguments[0]; |
|
} |
|
}; |
|
|
|
/** |
|
* Initialises a new <code>TimeSeries</code> with optional data options. |
|
* |
|
* Options are of the form (defaults shown): |
|
* |
|
* <pre> |
|
* { |
|
* resetBounds: true, // enables/disables automatic scaling of the y-axis |
|
* resetBoundsInterval: 3000 // the period between scaling calculations, in millis |
|
* } |
|
* </pre> |
|
* |
|
* Presentation options for TimeSeries are specified as an argument to <code>SmoothieChart.addTimeSeries</code>. |
|
* |
|
* @constructor |
|
*/ |
|
function TimeSeries(options) { |
|
this.options = Util.extend({}, TimeSeries.defaultOptions, options); |
|
this.clear(); |
|
} |
|
|
|
TimeSeries.defaultOptions = { |
|
resetBoundsInterval: 3000, |
|
resetBounds: true |
|
}; |
|
|
|
/** |
|
* Clears all data and state from this TimeSeries object. |
|
*/ |
|
TimeSeries.prototype.clear = function() { |
|
this.data = []; |
|
this.maxValue = Number.NaN; // The maximum value ever seen in this TimeSeries. |
|
this.minValue = Number.NaN; // The minimum value ever seen in this TimeSeries. |
|
}; |
|
|
|
/** |
|
* Recalculate the min/max values for this <code>TimeSeries</code> object. |
|
* |
|
* This causes the graph to scale itself in the y-axis. |
|
*/ |
|
TimeSeries.prototype.resetBounds = function() { |
|
if (this.data.length) { |
|
// Walk through all data points, finding the min/max value |
|
this.maxValue = this.data[0][1]; |
|
this.minValue = this.data[0][1]; |
|
for (var i = 1; i < this.data.length; i++) { |
|
var value = this.data[i][1]; |
|
if (value > this.maxValue) { |
|
this.maxValue = value; |
|
} |
|
if (value < this.minValue) { |
|
this.minValue = value; |
|
} |
|
} |
|
} else { |
|
// No data exists, so set min/max to NaN |
|
this.maxValue = Number.NaN; |
|
this.minValue = Number.NaN; |
|
} |
|
}; |
|
|
|
/** |
|
* Adds a new data point to the <code>TimeSeries</code>, preserving chronological order. |
|
* |
|
* @param timestamp the position, in time, of this data point |
|
* @param value the value of this data point |
|
* @param sumRepeatedTimeStampValues if <code>timestamp</code> has an exact match in the series, this flag controls |
|
* whether it is replaced, or the values summed (defaults to false.) |
|
*/ |
|
TimeSeries.prototype.append = function(timestamp, value, sumRepeatedTimeStampValues) { |
|
// Rewind until we hit an older timestamp |
|
var i = this.data.length - 1; |
|
while (i >= 0 && this.data[i][0] > timestamp) { |
|
i--; |
|
} |
|
|
|
if (i === -1) { |
|
// This new item is the oldest data |
|
this.data.splice(0, 0, [timestamp, value]); |
|
} else if (this.data.length > 0 && this.data[i][0] === timestamp) { |
|
// Update existing values in the array |
|
if (sumRepeatedTimeStampValues) { |
|
// Sum this value into the existing 'bucket' |
|
this.data[i][1] += value; |
|
value = this.data[i][1]; |
|
} else { |
|
// Replace the previous value |
|
this.data[i][1] = value; |
|
} |
|
} else if (i < this.data.length - 1) { |
|
// Splice into the correct position to keep timestamps in order |
|
this.data.splice(i + 1, 0, [timestamp, value]); |
|
} else { |
|
// Add to the end of the array |
|
this.data.push([timestamp, value]); |
|
} |
|
|
|
this.maxValue = isNaN(this.maxValue) ? value : Math.max(this.maxValue, value); |
|
this.minValue = isNaN(this.minValue) ? value : Math.min(this.minValue, value); |
|
}; |
|
|
|
TimeSeries.prototype.dropOldData = function(oldestValidTime, maxDataSetLength) { |
|
// We must always keep one expired data point as we need this to draw the |
|
// line that comes into the chart from the left, but any points prior to that can be removed. |
|
var removeCount = 0; |
|
while (this.data.length - removeCount >= maxDataSetLength && this.data[removeCount + 1][0] < oldestValidTime) { |
|
removeCount++; |
|
} |
|
if (removeCount !== 0) { |
|
this.data.splice(0, removeCount); |
|
} |
|
}; |
|
|
|
/** |
|
* Initialises a new <code>SmoothieChart</code>. |
|
* |
|
* Options are optional, and should be of the form below. Just specify the values you |
|
* need and the rest will be given sensible defaults as shown: |
|
* |
|
* <pre> |
|
* { |
|
* minValue: undefined, // specify to clamp the lower y-axis to a given value |
|
* maxValue: undefined, // specify to clamp the upper y-axis to a given value |
|
* maxValueScale: 1, // allows proportional padding to be added above the chart. for 10% padding, specify 1.1. |
|
* minValueScale: 1, // allows proportional padding to be added below the chart. for 10% padding, specify 1.1. |
|
* yRangeFunction: undefined, // function({min: , max: }) { return {min: , max: }; } |
|
* scaleSmoothing: 0.125, // controls the rate at which y-value zoom animation occurs |
|
* millisPerPixel: 20, // sets the speed at which the chart pans by |
|
* enableDpiScaling: true, // support rendering at different DPI depending on the device |
|
* yMinFormatter: function(min, precision) { // callback function that formats the min y value label |
|
* return parseFloat(min).toFixed(precision); |
|
* }, |
|
* yMaxFormatter: function(max, precision) { // callback function that formats the max y value label |
|
* return parseFloat(max).toFixed(precision); |
|
* }, |
|
* maxDataSetLength: 2, |
|
* interpolation: 'bezier' // one of 'bezier', 'linear', or 'step' |
|
* timestampFormatter: null, // optional function to format time stamps for bottom of chart |
|
* // you may use SmoothieChart.timeFormatter, or your own: function(date) { return ''; } |
|
* scrollBackwards: false, // reverse the scroll direction of the chart |
|
* horizontalLines: [], // [ { value: 0, color: '#ffffff', lineWidth: 1 } ] |
|
* grid: |
|
* { |
|
* fillStyle: '#000000', // the background colour of the chart |
|
* lineWidth: 1, // the pixel width of grid lines |
|
* strokeStyle: '#777777', // colour of grid lines |
|
* millisPerLine: 1000, // distance between vertical grid lines |
|
* sharpLines: false, // controls whether grid lines are 1px sharp, or softened |
|
* verticalSections: 2, // number of vertical sections marked out by horizontal grid lines |
|
* borderVisible: true // whether the grid lines trace the border of the chart or not |
|
* }, |
|
* labels |
|
* { |
|
* disabled: false, // enables/disables labels showing the min/max values |
|
* fillStyle: '#ffffff', // colour for text of labels, |
|
* fontSize: 15, |
|
* fontFamily: 'sans-serif', |
|
* precision: 2 |
|
* } |
|
* } |
|
* </pre> |
|
* |
|
* @constructor |
|
*/ |
|
function SmoothieChart(options) { |
|
this.options = Util.extend({}, SmoothieChart.defaultChartOptions, options); |
|
this.seriesSet = []; |
|
this.currentValueRange = 1; |
|
this.currentVisMinValue = 0; |
|
this.lastRenderTimeMillis = 0; |
|
} |
|
|
|
SmoothieChart.defaultChartOptions = { |
|
millisPerPixel: 20, |
|
enableDpiScaling: true, |
|
yMinFormatter: function(min, precision) { |
|
return parseFloat(min).toFixed(precision); |
|
}, |
|
yMaxFormatter: function(max, precision) { |
|
return parseFloat(max).toFixed(precision); |
|
}, |
|
maxValueScale: 1, |
|
minValueScale: 1, |
|
interpolation: 'bezier', |
|
scaleSmoothing: 0.125, |
|
maxDataSetLength: 2, |
|
scrollBackwards: false, |
|
grid: { |
|
fillStyle: '#000000', |
|
strokeStyle: '#777777', |
|
lineWidth: 1, |
|
sharpLines: false, |
|
millisPerLine: 1000, |
|
verticalSections: 2, |
|
borderVisible: true |
|
}, |
|
labels: { |
|
fillStyle: '#ffffff', |
|
disabled: false, |
|
fontSize: 10, |
|
fontFamily: 'monospace', |
|
precision: 2 |
|
}, |
|
horizontalLines: [] |
|
}; |
|
|
|
// Based on http://inspirit.github.com/jsfeat/js/compatibility.js |
|
SmoothieChart.AnimateCompatibility = (function() { |
|
var requestAnimationFrame = function(callback, element) { |
|
var requestAnimationFrame = |
|
window.requestAnimationFrame || |
|
window.webkitRequestAnimationFrame || |
|
window.mozRequestAnimationFrame || |
|
window.oRequestAnimationFrame || |
|
window.msRequestAnimationFrame || |
|
function(callback) { |
|
return window.setTimeout(function() { |
|
callback(new Date().getTime()); |
|
}, 16); |
|
}; |
|
return requestAnimationFrame.call(window, callback, element); |
|
}, |
|
cancelAnimationFrame = function(id) { |
|
var cancelAnimationFrame = |
|
window.cancelAnimationFrame || |
|
function(id) { |
|
clearTimeout(id); |
|
}; |
|
return cancelAnimationFrame.call(window, id); |
|
}; |
|
|
|
return { |
|
requestAnimationFrame: requestAnimationFrame, |
|
cancelAnimationFrame: cancelAnimationFrame |
|
}; |
|
})(); |
|
|
|
SmoothieChart.defaultSeriesPresentationOptions = { |
|
lineWidth: 1, |
|
strokeStyle: '#ffffff' |
|
}; |
|
|
|
/** |
|
* Adds a <code>TimeSeries</code> to this chart, with optional presentation options. |
|
* |
|
* Presentation options should be of the form (defaults shown): |
|
* |
|
* <pre> |
|
* { |
|
* lineWidth: 1, |
|
* strokeStyle: '#ffffff', |
|
* fillStyle: undefined |
|
* } |
|
* </pre> |
|
*/ |
|
SmoothieChart.prototype.addTimeSeries = function(timeSeries, options) { |
|
this.seriesSet.push({timeSeries: timeSeries, options: Util.extend({}, SmoothieChart.defaultSeriesPresentationOptions, options)}); |
|
if (timeSeries.options.resetBounds && timeSeries.options.resetBoundsInterval > 0) { |
|
timeSeries.resetBoundsTimerId = setInterval( |
|
function() { |
|
timeSeries.resetBounds(); |
|
}, |
|
timeSeries.options.resetBoundsInterval |
|
); |
|
} |
|
}; |
|
|
|
/** |
|
* Removes the specified <code>TimeSeries</code> from the chart. |
|
*/ |
|
SmoothieChart.prototype.removeTimeSeries = function(timeSeries) { |
|
// Find the correct timeseries to remove, and remove it |
|
var numSeries = this.seriesSet.length; |
|
for (var i = 0; i < numSeries; i++) { |
|
if (this.seriesSet[i].timeSeries === timeSeries) { |
|
this.seriesSet.splice(i, 1); |
|
break; |
|
} |
|
} |
|
// If a timer was operating for that timeseries, remove it |
|
if (timeSeries.resetBoundsTimerId) { |
|
// Stop resetting the bounds, if we were |
|
clearInterval(timeSeries.resetBoundsTimerId); |
|
} |
|
}; |
|
|
|
/** |
|
* Gets render options for the specified <code>TimeSeries</code>. |
|
* |
|
* As you may use a single <code>TimeSeries</code> in multiple charts with different formatting in each usage, |
|
* these settings are stored in the chart. |
|
*/ |
|
SmoothieChart.prototype.getTimeSeriesOptions = function(timeSeries) { |
|
// Find the correct timeseries to remove, and remove it |
|
var numSeries = this.seriesSet.length; |
|
for (var i = 0; i < numSeries; i++) { |
|
if (this.seriesSet[i].timeSeries === timeSeries) { |
|
return this.seriesSet[i].options; |
|
} |
|
} |
|
}; |
|
|
|
/** |
|
* Brings the specified <code>TimeSeries</code> to the top of the chart. It will be rendered last. |
|
*/ |
|
SmoothieChart.prototype.bringToFront = function(timeSeries) { |
|
// Find the correct timeseries to remove, and remove it |
|
var numSeries = this.seriesSet.length; |
|
for (var i = 0; i < numSeries; i++) { |
|
if (this.seriesSet[i].timeSeries === timeSeries) { |
|
var set = this.seriesSet.splice(i, 1); |
|
this.seriesSet.push(set[0]); |
|
break; |
|
} |
|
} |
|
}; |
|
|
|
/** |
|
* Instructs the <code>SmoothieChart</code> to start rendering to the provided canvas, with specified delay. |
|
* |
|
* @param canvas the target canvas element |
|
* @param delayMillis an amount of time to wait before a data point is shown. This can prevent the end of the series |
|
* from appearing on screen, with new values flashing into view, at the expense of some latency. |
|
*/ |
|
SmoothieChart.prototype.streamTo = function(canvas, delayMillis) { |
|
this.canvas = canvas; |
|
this.delay = delayMillis; |
|
this.start(); |
|
}; |
|
|
|
/** |
|
* Make sure the canvas has the optimal resolution for the device's pixel ratio. |
|
*/ |
|
SmoothieChart.prototype.resize = function() { |
|
// TODO this function doesn't handle the value of enableDpiScaling changing during execution |
|
if (!this.options.enableDpiScaling || !window || window.devicePixelRatio === 1) |
|
return; |
|
|
|
var dpr = window.devicePixelRatio; |
|
var width = parseInt(this.canvas.getAttribute('width')); |
|
var height = parseInt(this.canvas.getAttribute('height')); |
|
|
|
if (!this.originalWidth || (Math.floor(this.originalWidth * dpr) !== width)) { |
|
this.originalWidth = width; |
|
this.canvas.setAttribute('width', (Math.floor(width * dpr)).toString()); |
|
this.canvas.style.width = width + 'px'; |
|
this.canvas.getContext('2d').scale(dpr, dpr); |
|
} |
|
|
|
if (!this.originalHeight || (Math.floor(this.originalHeight * dpr) !== height)) { |
|
this.originalHeight = height; |
|
this.canvas.setAttribute('height', (Math.floor(height * dpr)).toString()); |
|
this.canvas.style.height = height + 'px'; |
|
this.canvas.getContext('2d').scale(dpr, dpr); |
|
} |
|
}; |
|
|
|
/** |
|
* Starts the animation of this chart. |
|
*/ |
|
SmoothieChart.prototype.start = function() { |
|
if (this.frame) { |
|
// We're already running, so just return |
|
return; |
|
} |
|
|
|
// Renders a frame, and queues the next frame for later rendering |
|
var animate = function() { |
|
this.frame = SmoothieChart.AnimateCompatibility.requestAnimationFrame(function() { |
|
this.render(); |
|
animate(); |
|
}.bind(this)); |
|
}.bind(this); |
|
|
|
animate(); |
|
}; |
|
|
|
/** |
|
* Stops the animation of this chart. |
|
*/ |
|
SmoothieChart.prototype.stop = function() { |
|
if (this.frame) { |
|
SmoothieChart.AnimateCompatibility.cancelAnimationFrame(this.frame); |
|
delete this.frame; |
|
} |
|
}; |
|
|
|
SmoothieChart.prototype.updateValueRange = function() { |
|
// Calculate the current scale of the chart, from all time series. |
|
var chartOptions = this.options, |
|
chartMaxValue = Number.NaN, |
|
chartMinValue = Number.NaN; |
|
|
|
for (var d = 0; d < this.seriesSet.length; d++) { |
|
// TODO(ndunn): We could calculate / track these values as they stream in. |
|
var timeSeries = this.seriesSet[d].timeSeries; |
|
if (!isNaN(timeSeries.maxValue)) { |
|
chartMaxValue = !isNaN(chartMaxValue) ? Math.max(chartMaxValue, timeSeries.maxValue) : timeSeries.maxValue; |
|
} |
|
|
|
if (!isNaN(timeSeries.minValue)) { |
|
chartMinValue = !isNaN(chartMinValue) ? Math.min(chartMinValue, timeSeries.minValue) : timeSeries.minValue; |
|
} |
|
} |
|
|
|
// Scale the chartMaxValue to add padding at the top if required |
|
if (chartOptions.maxValue != null) { |
|
chartMaxValue = chartOptions.maxValue; |
|
} else { |
|
chartMaxValue *= chartOptions.maxValueScale; |
|
} |
|
|
|
// Set the minimum if we've specified one |
|
if (chartOptions.minValue != null) { |
|
chartMinValue = chartOptions.minValue; |
|
} else { |
|
chartMinValue -= Math.abs(chartMinValue * chartOptions.minValueScale - chartMinValue); |
|
} |
|
|
|
// If a custom range function is set, call it |
|
if (this.options.yRangeFunction) { |
|
var range = this.options.yRangeFunction({min: chartMinValue, max: chartMaxValue}); |
|
chartMinValue = range.min; |
|
chartMaxValue = range.max; |
|
} |
|
|
|
if (!isNaN(chartMaxValue) && !isNaN(chartMinValue)) { |
|
var targetValueRange = chartMaxValue - chartMinValue; |
|
var valueRangeDiff = (targetValueRange - this.currentValueRange); |
|
var minValueDiff = (chartMinValue - this.currentVisMinValue); |
|
this.isAnimatingScale = Math.abs(valueRangeDiff) > 0.1 || Math.abs(minValueDiff) > 0.1; |
|
this.currentValueRange += chartOptions.scaleSmoothing * valueRangeDiff; |
|
this.currentVisMinValue += chartOptions.scaleSmoothing * minValueDiff; |
|
} |
|
|
|
this.valueRange = { min: chartMinValue, max: chartMaxValue }; |
|
}; |
|
|
|
SmoothieChart.prototype.render = function(canvas, time) { |
|
var nowMillis = new Date().getTime(); |
|
|
|
if (!this.isAnimatingScale) { |
|
// We're not animating. We can use the last render time and the scroll speed to work out whether |
|
// we actually need to paint anything yet. If not, we can return immediately. |
|
|
|
// Render at least every 1/6th of a second. The canvas may be resized, which there is |
|
// no reliable way to detect. |
|
var maxIdleMillis = Math.min(1000/6, this.options.millisPerPixel); |
|
|
|
if (nowMillis - this.lastRenderTimeMillis < maxIdleMillis) { |
|
return; |
|
} |
|
} |
|
|
|
this.resize(); |
|
|
|
this.lastRenderTimeMillis = nowMillis; |
|
|
|
canvas = canvas || this.canvas; |
|
time = time || nowMillis - (this.delay || 0); |
|
|
|
// Round time down to pixel granularity, so motion appears smoother. |
|
time -= time % this.options.millisPerPixel; |
|
|
|
var context = canvas.getContext('2d'), |
|
chartOptions = this.options, |
|
dimensions = { top: 0, left: 0, width: canvas.clientWidth, height: canvas.clientHeight }, |
|
// Calculate the threshold time for the oldest data points. |
|
oldestValidTime = time - (dimensions.width * chartOptions.millisPerPixel), |
|
valueToYPixel = function(value) { |
|
var offset = value - this.currentVisMinValue; |
|
return this.currentValueRange === 0 |
|
? dimensions.height |
|
: dimensions.height - (Math.round((offset / this.currentValueRange) * dimensions.height)); |
|
}.bind(this), |
|
timeToXPixel = function(t) { |
|
if(chartOptions.scrollBackwards) { |
|
return Math.round((time - t) / chartOptions.millisPerPixel); |
|
} |
|
return Math.round(dimensions.width - ((time - t) / chartOptions.millisPerPixel)); |
|
}; |
|
|
|
this.updateValueRange(); |
|
|
|
context.font = chartOptions.labels.fontSize + 'px ' + chartOptions.labels.fontFamily; |
|
|
|
// Save the state of the canvas context, any transformations applied in this method |
|
// will get removed from the stack at the end of this method when .restore() is called. |
|
context.save(); |
|
|
|
// Move the origin. |
|
context.translate(dimensions.left, dimensions.top); |
|
|
|
// Create a clipped rectangle - anything we draw will be constrained to this rectangle. |
|
// This prevents the occasional pixels from curves near the edges overrunning and creating |
|
// screen cheese (that phrase should need no explanation). |
|
context.beginPath(); |
|
context.rect(0, 0, dimensions.width, dimensions.height); |
|
context.clip(); |
|
|
|
// Clear the working area. |
|
context.save(); |
|
context.fillStyle = chartOptions.grid.fillStyle; |
|
context.clearRect(0, 0, dimensions.width, dimensions.height); |
|
context.fillRect(0, 0, dimensions.width, dimensions.height); |
|
context.restore(); |
|
|
|
// Grid lines... |
|
context.save(); |
|
context.lineWidth = chartOptions.grid.lineWidth; |
|
context.strokeStyle = chartOptions.grid.strokeStyle; |
|
// Vertical (time) dividers. |
|
if (chartOptions.grid.millisPerLine > 0) { |
|
context.beginPath(); |
|
for (var t = time - (time % chartOptions.grid.millisPerLine); |
|
t >= oldestValidTime; |
|
t -= chartOptions.grid.millisPerLine) { |
|
var gx = timeToXPixel(t); |
|
if (chartOptions.grid.sharpLines) { |
|
gx -= 0.5; |
|
} |
|
context.moveTo(gx, 0); |
|
context.lineTo(gx, dimensions.height); |
|
} |
|
context.stroke(); |
|
context.closePath(); |
|
} |
|
|
|
// Horizontal (value) dividers. |
|
for (var v = 1; v < chartOptions.grid.verticalSections; v++) { |
|
var gy = Math.round(v * dimensions.height / chartOptions.grid.verticalSections); |
|
if (chartOptions.grid.sharpLines) { |
|
gy -= 0.5; |
|
} |
|
context.beginPath(); |
|
context.moveTo(0, gy); |
|
context.lineTo(dimensions.width, gy); |
|
context.stroke(); |
|
context.closePath(); |
|
} |
|
// Bounding rectangle. |
|
if (chartOptions.grid.borderVisible) { |
|
context.beginPath(); |
|
context.strokeRect(0, 0, dimensions.width, dimensions.height); |
|
context.closePath(); |
|
} |
|
context.restore(); |
|
|
|
// Draw any horizontal lines... |
|
if (chartOptions.horizontalLines && chartOptions.horizontalLines.length) { |
|
for (var hl = 0; hl < chartOptions.horizontalLines.length; hl++) { |
|
var line = chartOptions.horizontalLines[hl], |
|
hly = Math.round(valueToYPixel(line.value)) - 0.5; |
|
context.strokeStyle = line.color || '#ffffff'; |
|
context.lineWidth = line.lineWidth || 1; |
|
context.beginPath(); |
|
context.moveTo(0, hly); |
|
context.lineTo(dimensions.width, hly); |
|
context.stroke(); |
|
context.closePath(); |
|
} |
|
} |
|
|
|
// For each data set... |
|
for (var d = 0; d < this.seriesSet.length; d++) { |
|
context.save(); |
|
var timeSeries = this.seriesSet[d].timeSeries, |
|
dataSet = timeSeries.data, |
|
seriesOptions = this.seriesSet[d].options; |
|
|
|
// Delete old data that's moved off the left of the chart. |
|
timeSeries.dropOldData(oldestValidTime, chartOptions.maxDataSetLength); |
|
|
|
// Set style for this dataSet. |
|
context.lineWidth = seriesOptions.lineWidth; |
|
context.strokeStyle = seriesOptions.strokeStyle; |
|
// Draw the line... |
|
context.beginPath(); |
|
// Retain lastX, lastY for calculating the control points of bezier curves. |
|
var firstX = 0, lastX = 0, lastY = 0; |
|
for (var i = 0; i < dataSet.length && dataSet.length !== 1; i++) { |
|
var x = timeToXPixel(dataSet[i][0]), |
|
y = valueToYPixel(dataSet[i][1]); |
|
|
|
if (i === 0) { |
|
firstX = x; |
|
context.moveTo(x, y); |
|
} else { |
|
switch (chartOptions.interpolation) { |
|
case "linear": |
|
case "line": { |
|
context.lineTo(x,y); |
|
break; |
|
} |
|
case "bezier": |
|
default: { |
|
// Great explanation of Bezier curves: http://en.wikipedia.org/wiki/Bezier_curve#Quadratic_curves |
|
// |
|
// Assuming A was the last point in the line plotted and B is the new point, |
|
// we draw a curve with control points P and Q as below. |
|
// |
|
// A---P |
|
// | |
|
// | |
|
// | |
|
// Q---B |
|
// |
|
// Importantly, A and P are at the same y coordinate, as are B and Q. This is |
|
// so adjacent curves appear to flow as one. |
|
// |
|
context.bezierCurveTo( // startPoint (A) is implicit from last iteration of loop |
|
Math.round((lastX + x) / 2), lastY, // controlPoint1 (P) |
|
Math.round((lastX + x)) / 2, y, // controlPoint2 (Q) |
|
x, y); // endPoint (B) |
|
break; |
|
} |
|
case "step": { |
|
context.lineTo(x,lastY); |
|
context.lineTo(x,y); |
|
break; |
|
} |
|
} |
|
} |
|
|
|
lastX = x; lastY = y; |
|
} |
|
|
|
if (dataSet.length > 1) { |
|
if (seriesOptions.fillStyle) { |
|
// Close up the fill region. |
|
context.lineTo(dimensions.width + seriesOptions.lineWidth + 1, lastY); |
|
context.lineTo(dimensions.width + seriesOptions.lineWidth + 1, dimensions.height + seriesOptions.lineWidth + 1); |
|
context.lineTo(firstX, dimensions.height + seriesOptions.lineWidth); |
|
context.fillStyle = seriesOptions.fillStyle; |
|
context.fill(); |
|
} |
|
|
|
if (seriesOptions.strokeStyle && seriesOptions.strokeStyle !== 'none') { |
|
context.stroke(); |
|
} |
|
context.closePath(); |
|
} |
|
context.restore(); |
|
} |
|
|
|
// Draw the axis values on the chart. |
|
if (!chartOptions.labels.disabled && !isNaN(this.valueRange.min) && !isNaN(this.valueRange.max)) { |
|
var maxValueString = chartOptions.yMaxFormatter(this.valueRange.max, chartOptions.labels.precision), |
|
minValueString = chartOptions.yMinFormatter(this.valueRange.min, chartOptions.labels.precision), |
|
labelPos = chartOptions.scrollBackwards ? 0 : dimensions.width - context.measureText(maxValueString).width - 2; |
|
context.fillStyle = chartOptions.labels.fillStyle; |
|
context.fillText(maxValueString, labelPos, chartOptions.labels.fontSize); |
|
context.fillText(minValueString, labelPos, dimensions.height - 2); |
|
} |
|
|
|
// Display timestamps along x-axis at the bottom of the chart. |
|
if (chartOptions.timestampFormatter && chartOptions.grid.millisPerLine > 0) { |
|
var textUntilX = chartOptions.scrollBackwards |
|
? context.measureText(minValueString).width |
|
: dimensions.width - context.measureText(minValueString).width + 4; |
|
for (var t = time - (time % chartOptions.grid.millisPerLine); |
|
t >= oldestValidTime; |
|
t -= chartOptions.grid.millisPerLine) { |
|
var gx = timeToXPixel(t); |
|
// Only draw the timestamp if it won't overlap with the previously drawn one. |
|
if ((!chartOptions.scrollBackwards && gx < textUntilX) || (chartOptions.scrollBackwards && gx > textUntilX)) { |
|
// Formats the timestamp based on user specified formatting function |
|
// SmoothieChart.timeFormatter function above is one such formatting option |
|
var tx = new Date(t), |
|
ts = chartOptions.timestampFormatter(tx), |
|
tsWidth = context.measureText(ts).width; |
|
|
|
textUntilX = chartOptions.scrollBackwards |
|
? gx + tsWidth + 2 |
|
: gx - tsWidth - 2; |
|
|
|
context.fillStyle = chartOptions.labels.fillStyle; |
|
if(chartOptions.scrollBackwards) { |
|
context.fillText(ts, gx, dimensions.height - 2); |
|
} else { |
|
context.fillText(ts, gx - tsWidth, dimensions.height - 2); |
|
} |
|
} |
|
} |
|
} |
|
|
|
context.restore(); // See .save() above. |
|
}; |
|
|
|
// Sample timestamp formatting function |
|
SmoothieChart.timeFormatter = function(date) { |
|
function pad2(number) { return (number < 10 ? '0' : '') + number } |
|
return pad2(date.getHours()) + ':' + pad2(date.getMinutes()) + ':' + pad2(date.getSeconds()); |
|
}; |
|
|
|
exports.TimeSeries = TimeSeries; |
|
exports.SmoothieChart = SmoothieChart; |
|
|
|
})(typeof exports === 'undefined' ? this : exports); |
|
|
|
|