You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
455 lines
14 KiB
JavaScript
455 lines
14 KiB
JavaScript
/* The MIT License
|
|
|
|
Copyright (c) 2011 by Michael Zinsmaier and nergal.dev
|
|
Copyright (c) 2012 by Thomas Ritou
|
|
|
|
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.
|
|
*/
|
|
|
|
/*
|
|
|
|
____________________________________________________
|
|
|
|
what it is:
|
|
____________________________________________________
|
|
|
|
curvedLines is a plugin for flot, that tries to display lines in a smoother way.
|
|
This is achieved through adding of more data points. The plugin is a data processor and can thus be used
|
|
in combination with standard line / point rendering options.
|
|
|
|
=> 1) with large data sets you may get trouble
|
|
=> 2) if you want to display the points too, you have to plot them as 2nd data series over the lines
|
|
&& 3) consecutive x data points are not allowed to have the same value
|
|
|
|
Feel free to further improve the code
|
|
|
|
____________________________________________________
|
|
|
|
how to use it:
|
|
____________________________________________________
|
|
|
|
var d1 = [[5,5],[7,3],[9,12]];
|
|
|
|
var options = { series: { curvedLines: { active: true }}};
|
|
|
|
$.plot($("#placeholder"), [{data = d1, lines: { show: true}, curvedLines: {apply: true}}], options);
|
|
|
|
_____________________________________________________
|
|
|
|
options:
|
|
_____________________________________________________
|
|
|
|
active: bool true => plugin can be used
|
|
apply: bool true => series will be drawn as curved line
|
|
|
|
deprecated options from flot prior to 1.0.0:
|
|
------------------------------------------------
|
|
legacyOverride bool true => use old default OR
|
|
legacyOverride optionArray
|
|
{
|
|
fit: bool true => forces the max,mins of the curve to be on the datapoints
|
|
curvePointFactor int defines how many "virtual" points are used per "real" data point to
|
|
emulate the curvedLines (points total = real points * curvePointFactor)
|
|
fitPointDist: int defines the x axis distance of the additional two points that are used
|
|
} to enforce the min max condition.
|
|
*/
|
|
|
|
/*
|
|
* v0.1 initial commit
|
|
* v0.15 negative values should work now (outcommented a negative -> 0 hook hope it does no harm)
|
|
* v0.2 added fill option (thanks to monemihir) and multi axis support (thanks to soewono effendi)
|
|
* v0.3 improved saddle handling and added basic handling of Dates
|
|
* v0.4 rewritten fill option (thomas ritou) mostly from original flot code (now fill between points rather than to graph bottom), corrected fill Opacity bug
|
|
* v0.5 rewritten instead of implementing a own draw function CurvedLines is now based on the processDatapoints flot hook (credits go to thomas ritou).
|
|
* This change breakes existing code however CurvedLines are now just many tiny straight lines to flot and therefore all flot lines options (like gradient fill,
|
|
* shadow) are now supported out of the box
|
|
* v0.6 flot 0.8 compatibility and some bug fixes
|
|
* v0.6.x changed versioning schema
|
|
*
|
|
* v1.0.0 API Break marked existing implementation/options as deprecated
|
|
*/
|
|
|
|
(function($) {
|
|
|
|
var options = {
|
|
series : {
|
|
curvedLines : {
|
|
active : false,
|
|
apply : false,
|
|
monotonicFit : false,
|
|
tension : 0.0,
|
|
nrSplinePoints : 20,
|
|
legacyOverride : undefined
|
|
}
|
|
}
|
|
};
|
|
|
|
function init(plot) {
|
|
|
|
plot.hooks.processOptions.push(processOptions);
|
|
|
|
//if the plugin is active register processDatapoints method
|
|
function processOptions(plot, options) {
|
|
if (options.series.curvedLines.active) {
|
|
plot.hooks.processDatapoints.unshift(processDatapoints);
|
|
}
|
|
}
|
|
|
|
//only if the plugin is active
|
|
function processDatapoints(plot, series, datapoints) {
|
|
var nrPoints = datapoints.points.length / datapoints.pointsize;
|
|
var EPSILON = 0.005;
|
|
|
|
if (series.curvedLines.apply == true && series.originSeries === undefined && nrPoints > (1 + EPSILON)) {
|
|
if (series.lines.fill) {
|
|
|
|
var pointsTop = calculateCurvePoints(datapoints, series.curvedLines, 1);
|
|
var pointsBottom = calculateCurvePoints(datapoints, series.curvedLines, 2);
|
|
//flot makes sure for us that we've got a second y point if fill is true !
|
|
|
|
//Merge top and bottom curve
|
|
datapoints.pointsize = 3;
|
|
datapoints.points = [];
|
|
var j = 0;
|
|
var k = 0;
|
|
var i = 0;
|
|
var ps = 2;
|
|
while (i < pointsTop.length || j < pointsBottom.length) {
|
|
if (pointsTop[i] == pointsBottom[j]) {
|
|
datapoints.points[k] = pointsTop[i];
|
|
datapoints.points[k + 1] = pointsTop[i + 1];
|
|
datapoints.points[k + 2] = pointsBottom[j + 1];
|
|
j += ps;
|
|
i += ps;
|
|
|
|
} else if (pointsTop[i] < pointsBottom[j]) {
|
|
datapoints.points[k] = pointsTop[i];
|
|
datapoints.points[k + 1] = pointsTop[i + 1];
|
|
datapoints.points[k + 2] = k > 0 ? datapoints.points[k - 1] : null;
|
|
i += ps;
|
|
} else {
|
|
datapoints.points[k] = pointsBottom[j];
|
|
datapoints.points[k + 1] = k > 1 ? datapoints.points[k - 2] : null;
|
|
datapoints.points[k + 2] = pointsBottom[j + 1];
|
|
j += ps;
|
|
}
|
|
k += 3;
|
|
}
|
|
} else if (series.lines.lineWidth > 0) {
|
|
datapoints.points = calculateCurvePoints(datapoints, series.curvedLines, 1);
|
|
datapoints.pointsize = 2;
|
|
}
|
|
}
|
|
}
|
|
|
|
function calculateCurvePoints(datapoints, curvedLinesOptions, yPos) {
|
|
if ( typeof curvedLinesOptions.legacyOverride != 'undefined' && curvedLinesOptions.legacyOverride != false) {
|
|
var defaultOptions = {
|
|
fit : false,
|
|
curvePointFactor : 20,
|
|
fitPointDist : undefined
|
|
};
|
|
var legacyOptions = jQuery.extend(defaultOptions, curvedLinesOptions.legacyOverride);
|
|
return calculateLegacyCurvePoints(datapoints, legacyOptions, yPos);
|
|
}
|
|
|
|
return calculateSplineCurvePoints(datapoints, curvedLinesOptions, yPos);
|
|
}
|
|
|
|
function calculateSplineCurvePoints(datapoints, curvedLinesOptions, yPos) {
|
|
var points = datapoints.points;
|
|
var ps = datapoints.pointsize;
|
|
|
|
//create interpolant fuction
|
|
var splines = createHermiteSplines(datapoints, curvedLinesOptions, yPos);
|
|
var result = [];
|
|
|
|
//sample the function
|
|
// (the result is intependent from the input data =>
|
|
// it is ok to alter the input after this method)
|
|
var j = 0;
|
|
for (var i = 0; i < points.length - ps; i += ps) {
|
|
var curX = i;
|
|
var curY = i + yPos;
|
|
|
|
var xStart = points[curX];
|
|
var xEnd = points[curX + ps];
|
|
var xStep = (xEnd - xStart) / Number(curvedLinesOptions.nrSplinePoints);
|
|
|
|
//add point
|
|
result.push(points[curX]);
|
|
result.push(points[curY]);
|
|
|
|
//add curve point
|
|
for (var x = (xStart += xStep); x < xEnd; x += xStep) {
|
|
result.push(x);
|
|
result.push(splines[j](x));
|
|
}
|
|
|
|
j++;
|
|
}
|
|
|
|
//add last point
|
|
result.push(points[points.length - ps]);
|
|
result.push(points[points.length - ps + yPos]);
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
|
|
function createHermiteSplines(datapoints, curvedLinesOptions, yPos) {
|
|
var points = datapoints.points;
|
|
var ps = datapoints.pointsize;
|
|
|
|
// Get consecutive differences and slopes
|
|
var dxs = [];
|
|
var dys = [];
|
|
var ms = [];
|
|
|
|
for (var i = 0; i < points.length - ps; i += ps) {
|
|
var curX = i;
|
|
var curY = i + yPos;
|
|
var dx = points[curX + ps] - points[curX];
|
|
var dy = points[curY + ps] - points[curY];
|
|
|
|
dxs.push(dx);
|
|
dys.push(dy);
|
|
ms.push(dy / dx);
|
|
}
|
|
|
|
// Get degree-1 coefficients
|
|
var c1s = [ms[0]];
|
|
if (curvedLinesOptions.monotonicFit) {
|
|
// Fritsch Carlson
|
|
for (var i = 0; i < dxs.length - 1; i++) {
|
|
var m = ms[i];
|
|
var mNext = ms[i + 1];
|
|
if (m * mNext <= 0) {
|
|
c1s.push(0);
|
|
} else {
|
|
var dx = dxs[i];
|
|
var dxNext = dxs[i + 1];
|
|
var common = dx + dxNext;
|
|
c1s.push(3 * common / ((common + dxNext) / m + (common + dx) / mNext));
|
|
}
|
|
}
|
|
} else {
|
|
// Cardinal spline with t € [0,1]
|
|
// Catmull-Rom for t = 0
|
|
for (var i = ps; i < points.length - ps; i += ps) {
|
|
var curX = i;
|
|
var curY = i + yPos;
|
|
c1s.push(Number(curvedLinesOptions.tension) * (points[curY + ps] - points[curY - ps]) / (points[curX + ps] - points[curX - ps]));
|
|
}
|
|
}
|
|
c1s.push(ms[ms.length - 1]);
|
|
|
|
// Get degree-2 and degree-3 coefficients
|
|
var c2s = [], c3s = [];
|
|
for ( i = 0; i < c1s.length - 1; i++) {
|
|
var c1 = c1s[i];
|
|
var m = ms[i];
|
|
var invDx = 1 / dxs[i];
|
|
var common = c1 + c1s[i + 1] - m - m;
|
|
c2s.push((m - c1 - common) * invDx);
|
|
c3s.push(common * invDx * invDx);
|
|
}
|
|
|
|
//create functions with captured parameters
|
|
var ret = [];
|
|
for (var i = 0; i < c1s.length - 1; i ++) {
|
|
var spline = function (x0, a, b, c, d) {
|
|
// spline for a segment
|
|
return function (x) {
|
|
var diff = x - x0;
|
|
var diffSq = diff * diff;
|
|
return a * diff + b * diffSq + c * diff * diffSq + d;
|
|
};
|
|
};
|
|
|
|
ret.push(spline(points[i * ps], c1s[i], c2s[i], c3s[i], points[i * ps + yPos]));
|
|
}
|
|
|
|
return ret;
|
|
};
|
|
|
|
//no real idea whats going on here code mainly from https://code.google.com/p/flot/issues/detail?id=226
|
|
//if fit option is selected additional datapoints get inserted before the curve calculations in nergal.dev s code.
|
|
function calculateLegacyCurvePoints(datapoints, curvedLinesOptions, yPos) {
|
|
|
|
var points = datapoints.points;
|
|
var ps = datapoints.pointsize;
|
|
var num = Number(curvedLinesOptions.curvePointFactor) * (points.length / ps);
|
|
|
|
var xdata = new Array;
|
|
var ydata = new Array;
|
|
|
|
var curX = -1;
|
|
var curY = -1;
|
|
var j = 0;
|
|
|
|
if (curvedLinesOptions.fit) {
|
|
//insert a point before and after the "real" data point to force the line
|
|
//to have a max,min at the data point.
|
|
|
|
var fpDist;
|
|
if ( typeof curvedLinesOptions.fitPointDist == 'undefined') {
|
|
//estimate it
|
|
var minX = points[0];
|
|
var maxX = points[points.length - ps];
|
|
fpDist = (maxX - minX) / (500 * 100);
|
|
//x range / (estimated pixel length of placeholder * factor)
|
|
} else {
|
|
//use user defined value
|
|
fpDist = Number(curvedLinesOptions.fitPointDist);
|
|
}
|
|
|
|
for (var i = 0; i < points.length; i += ps) {
|
|
|
|
var frontX;
|
|
var backX;
|
|
curX = i;
|
|
curY = i + yPos;
|
|
|
|
//add point X s
|
|
frontX = points[curX] - fpDist;
|
|
backX = points[curX] + fpDist;
|
|
|
|
var factor = 2;
|
|
while (frontX == points[curX] || backX == points[curX]) {
|
|
//inside the ulp
|
|
frontX = points[curX] - (fpDist * factor);
|
|
backX = points[curX] + (fpDist * factor);
|
|
factor++;
|
|
}
|
|
|
|
//add curve points
|
|
xdata[j] = frontX;
|
|
ydata[j] = points[curY];
|
|
j++;
|
|
|
|
xdata[j] = points[curX];
|
|
ydata[j] = points[curY];
|
|
j++;
|
|
|
|
xdata[j] = backX;
|
|
ydata[j] = points[curY];
|
|
j++;
|
|
}
|
|
} else {
|
|
//just use the datapoints
|
|
for (var i = 0; i < points.length; i += ps) {
|
|
curX = i;
|
|
curY = i + yPos;
|
|
|
|
xdata[j] = points[curX];
|
|
ydata[j] = points[curY];
|
|
j++;
|
|
}
|
|
}
|
|
|
|
var n = xdata.length;
|
|
|
|
var y2 = new Array();
|
|
var delta = new Array();
|
|
y2[0] = 0;
|
|
y2[n - 1] = 0;
|
|
delta[0] = 0;
|
|
|
|
for (var i = 1; i < n - 1; ++i) {
|
|
var d = (xdata[i + 1] - xdata[i - 1]);
|
|
if (d == 0) {
|
|
//point before current point and after current point need some space in between
|
|
return [];
|
|
}
|
|
|
|
var s = (xdata[i] - xdata[i - 1]) / d;
|
|
var p = s * y2[i - 1] + 2;
|
|
y2[i] = (s - 1) / p;
|
|
delta[i] = (ydata[i + 1] - ydata[i]) / (xdata[i + 1] - xdata[i]) - (ydata[i] - ydata[i - 1]) / (xdata[i] - xdata[i - 1]);
|
|
delta[i] = (6 * delta[i] / (xdata[i + 1] - xdata[i - 1]) - s * delta[i - 1]) / p;
|
|
}
|
|
|
|
for (var j = n - 2; j >= 0; --j) {
|
|
y2[j] = y2[j] * y2[j + 1] + delta[j];
|
|
}
|
|
|
|
// xmax - xmin / #points
|
|
var step = (xdata[n - 1] - xdata[0]) / (num - 1);
|
|
|
|
var xnew = new Array;
|
|
var ynew = new Array;
|
|
var result = new Array;
|
|
|
|
xnew[0] = xdata[0];
|
|
ynew[0] = ydata[0];
|
|
|
|
result.push(xnew[0]);
|
|
result.push(ynew[0]);
|
|
|
|
for ( j = 1; j < num; ++j) {
|
|
//new x point (sampling point for the created curve)
|
|
xnew[j] = xnew[0] + j * step;
|
|
|
|
var max = n - 1;
|
|
var min = 0;
|
|
|
|
while (max - min > 1) {
|
|
var k = Math.round((max + min) / 2);
|
|
if (xdata[k] > xnew[j]) {
|
|
max = k;
|
|
} else {
|
|
min = k;
|
|
}
|
|
}
|
|
|
|
//found point one to the left and one to the right of generated new point
|
|
var h = (xdata[max] - xdata[min]);
|
|
|
|
if (h == 0) {
|
|
//similar to above two points from original x data need some space between them
|
|
return [];
|
|
}
|
|
|
|
var a = (xdata[max] - xnew[j]) / h;
|
|
var b = (xnew[j] - xdata[min]) / h;
|
|
|
|
ynew[j] = a * ydata[min] + b * ydata[max] + ((a * a * a - a) * y2[min] + (b * b * b - b) * y2[max]) * (h * h) / 6;
|
|
|
|
result.push(xnew[j]);
|
|
result.push(ynew[j]);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
}//end init
|
|
|
|
|
|
$.plot.plugins.push({
|
|
init : init,
|
|
options : options,
|
|
name : 'curvedLines',
|
|
version : '1.1.0'
|
|
});
|
|
|
|
})(jQuery);
|
|
|