aepnat / simpuskesmas

(function($) {

	var options = {

		series : {

			curvedLines : {

				Aktif : false,

				apply : false,

				monotonicFit : false,

				tension : 0.5,

				nrSplinePoints : 20,

				legacyOverride : undefined

			}

		}

	};

	function init(plot) {

		plot.hooks.processOptions.push(processOptions);

		//if the plugin is Aktif register processDatapoints method

		function processOptions(plot, options) {

			if (options.series.curvedLines.Aktif) {

				plot.hooks.processDatapoints.unshift(processDatapoints);

			}

		}

		//only if the plugin is Aktif

		function processDatapoints(plot, series, datapoints) {

			var nrPoints = datapoints.points.length / datapoints.pointsize;

			var EPSILON = 0.005;

			//detects missplaced legacy parameters (prior v1.x.x) in the options object

			//this can happen if somebody upgrades to v1.x.x without adjusting the parameters or uses old examples

            var invalidLegacyOptions = hasInvalidParameters(series.curvedLines);

			if (!invalidLegacyOptions && 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

					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;

		}

		// Creates an array of splines, one for each segment of the original curve. Algorithm based on the wikipedia articles: 

		//

		// http://de.wikipedia.org/w/index.php?title=Kubisch_Hermitescher_Spline&oldid=130168003 and 

		// http://en.wikipedia.org/w/index.php?title=Monotone_cubic_interpolation&oldid=622341725 and the description of Fritsch-Carlson from

		// http://math.stackexchange.com/questions/45218/implementation-of-monotone-cubic-interpolation

		// for a detailed description see https://github.com/MichaelZinsmaier/CurvedLines/docu

		function createHermiteSplines(datapoints, curvedLinesOptions, yPos) {

			var points = datapoints.points;

			var ps = datapoints.pointsize;

			// preparation get length (x_{k+1} - x_k) and slope s=(p_{k+1} - p_k) / (x_{k+1} - x_k) of the segments

			var segmentLengths = [];

			var segmentSlopes = [];

			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];

				segmentLengths.push(dx);

				segmentSlopes.push(dy / dx);

			}

			//get the values for the desired gradients  m_k for all points k

			//depending on the used method the formula is different

			var gradients = [segmentSlopes[0]];	

			if (curvedLinesOptions.monotonicFit) {

				// Fritsch Carlson

					var slope = segmentSlopes[i];

					var prev_slope = segmentSlopes[i - 1];

					if (slope * prev_slope <= 0) { // sign(prev_slope) != sign(slpe)

						gradients.push(0);

					} else {

						var length = segmentLengths[i];

						var prev_length = segmentLengths[i - 1];

						var common = length + prev_length;

						//m = 3 (prev_length + length) / ((2 length + prev_length) / prev_slope + (length + 2 prev_length) / slope)

						gradients.push(3 * common / ((common + length) / prev_slope + (common + prev_length) / slope));

					}

				}

			} else {

				// Cardinal spline with t € [0,1]

				// Catmull-Rom for t = 0

					gradients.push(Number(curvedLinesOptions.tension) * (points[curY + ps] - points[curY - ps]) / (points[curX + ps] - points[curX - ps]));

				}

			}

			gradients.push(segmentSlopes[segmentSlopes.length - 1]);

			//get the two major coefficients (c'_{oef1} and c'_{oef2}) for each segment spline

			var coefs1 = [];

			var coefs2 = [];

			for (i = 0; i < segmentLengths.length; i++) {

				var m_k = gradients[i];

				var m_k_plus = gradients[i + 1];

				var invLength = 1 / segmentLengths[i];

				coefs1.push(common * invLength * invLength);

				coefs2.push((slope - common - m_k) * invLength);

			}

			//create functions with from the coefficients and capture the parameters

			var ret = [];

				var spline = function (x_k, coef1, coef2, coef3, coef4) {

					// spline for a segment

					return function (x) {									

						var diff = x - x_k;

						var diffSq = diff * diff;

						return coef1 * diff * diffSq + coef2 * diffSq + coef3 * diff + coef4;

					};

				};			

				ret.push(spline(points[i * ps], coefs1[i], coefs2[i], gradients[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 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

					curX = i;

					curY = i + yPos;

					xdata[j] = points[curX];

					ydata[j] = points[curY];

					j++;

				}

			}

			var n = xdata.length;

			y2[0] = 0;

			y2[n - 1] = 0;

			delta[0] = 0;

				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;

			}

				y2[j] = y2[j] * y2[j + 1] + delta[j];

			}

			//   xmax  - xmin  / #points

			var step = (xdata[n - 1] - xdata[0]) / (num - 1);

			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;

		}

		function hasInvalidParameters(curvedLinesOptions) {

			if (typeof curvedLinesOptions.fit != 'undefined' ||

			    typeof curvedLinesOptions.curvePointFactor != 'undefined' ||

			    typeof curvedLinesOptions.fitPointDist != 'undefined') {

			    	throw new Error("CurvedLines detected illegal parameters. The CurvedLines API changed with version 1.0.0 please check the options object.");

			    }

			return false;

		}

	}//end init

	$.plot.plugins.push({

		init : init,

		options : options,

		name : 'curvedLines',

		version : '1.1.1'

	});

})(jQuery);