bezierutils.js

define([
	"./_base"
], function (gfx) {

	var bu = gfx.bezierutils = {}, error = 0.1;

	bu.tAtLength = function (points, length) {
		// summary:
		//		Returns the t corresponding to the given length for the specified bezier curve.
		// points: Number[]
		//		The bezier points. Should be [p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y] for a cubic
		//		bezier curve or [p1x, p1y, cx, cy, p2x, p2y] for a quadratic bezier curve.
		// length: Number
		//		The length.
		var t = 0, quadratic = points.length === 6, currentLen = 0, splitCount = 0, splitFunc = quadratic ?
			splitQBezierAtT : splitBezierAtT;
		var _compute = function (p, error) {
			// control points polygon length
			var pLen = 0;
			for (var i = 0; i < p.length - 2; i += 2) {
				pLen += distance(p[i], p[i + 1], p[i + 2], p[i + 3]);
			}
			// chord length
			var chord = quadratic ? distance(points[0], points[1], points[4], points[5]) :
				distance(points[0], points[1], points[6], points[7]);
			// if needs more approx. or if currentLen is greater than the target length,
			// split the curve one more time
			if (pLen - chord > error || currentLen + pLen > length + error) {
				++splitCount;
				var newbezier = splitFunc(p, 0.5);
				// check 1st subpath
				_compute(newbezier[0], error);
				// the 1st subcurve was the good one, we stop
				if (Math.abs(currentLen - length) <= error) {
					return;
				}
				// need to continue with the 2nde subcurve
				_compute(newbezier[1], error);
				return;
			}
			currentLen += pLen;
			t += 1.0 / (1 << splitCount);
		};
		if (length) {
			_compute(points, 0.5);
		}
		return t;
	};

	var computeLength = bu.computeLength = function (/*Array*/points) {
		// summary:
		//		Returns the length of the given bezier curve.
		// points: Number[]
		//		The bezier points. Should be [p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y] for a cubic
		//		bezier curve or [p1x, p1y, cx, cy, p2x, p2y] for a quadratic bezier curve.

		var quadratic = points.length === 6, pLen = 0;
		// control points polygon length
		for (var i = 0; i < points.length - 2; i += 2) {
			pLen += distance(points[i], points[i + 1], points[i + 2], points[i + 3]);
		}
		// chord length
		var chord = quadratic ? distance(points[0], points[1], points[4], points[5]) :
			distance(points[0], points[1], points[6], points[7]);
		// split polygons until the polygon and the chord are "the same"
		if (pLen - chord > error) {
			var newBeziers = quadratic ? splitQBezierAtT(points, 0.5) : splitCBezierAtT(points, 0.5);
			var length = computeLength(newBeziers[0], quadratic);
			length += computeLength(newBeziers[1], quadratic);
			return length;
		}
		// pLen is close enough, done.
		return pLen;
	};

	var distance = bu.distance = function (x1, y1, x2, y2) {
		// summary:
		//		Returns the distance between the specified points.
		return Math.sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1));
	};

	var splitQBezierAtT = function (points, t) {
		// summary:
		//		Split a quadratic bezier curve into 2 sub-quadratic beziers at the specified t.

		// de Casteljau
		var r = 1 - t, r2 = r * r, t2 = t *
				t, p1x = points[0], p1y = points[1], cx = points[2], cy = points[3], p2x = points[4], p2y = points[5],

			ax = r * p1x + t * cx, ay = r * p1y + t * cy, bx = r * cx + t * p2x, by = r * cy + t * p2y, px = r2 * p1x +
				2 * r * t * cx + t2 * p2x, py = r2 * p1y + 2 * r * t * cy + t2 * p2y;

		return [
			[
				p1x, p1y, ax, ay, px, py
			],
			[
				px, py, bx, by, p2x, p2y
			]
		];
	};

	var splitCBezierAtT = function (points, t) {
		// summary:
		//		Split a cubic bezier curve into 2 sub-cubic beziers at the specified t.

		// de Casteljau
		var r = 1 - t, r2 = r * r, r3 = r2 * r, t2 = t * t, t3 = t2 *
				t, p1x = points[0], p1y = points[1], c1x = points[2], c1y = points[3],
			c2x = points[4], c2y = points[5], p2x = points[6], p2y = points[7],

			ax = r * p1x + t * c1x, ay = r * p1y + t * c1y, cx = r * c2x + t * p2x, cy = r * c2y + t * p2y, mx = r2 *
				p1x + 2 * r * t * c1x + t2 * c2x, my = r2 * p1y + 2 * r * t * c1y + t2 * c2y, nx = r2 * c1x +
				2 * r * t * c2x + t2 * p2x, ny = r2 * c1y + 2 * r * t * c2y + t2 * p2y, px = r3 * p1x +
				3 * r2 * t * c1x + 3 * r * t2 * c2x + t3 * p2x, py = r3 * p1y + 3 * r2 * t * c1y + 3 * r * t2 * c2y +
				t3 * p2y;

		return [
			[
				p1x, p1y, ax, ay, mx, my, px, py
			],
			[
				px, py, nx, ny, cx, cy, p2x, p2y
			]
		];
	};

	var splitBezierAtT = bu.splitBezierAtT = function (points, t) {
		return points.length === 6 ? splitQBezierAtT(points, t) : splitCBezierAtT(points, t);
	};
	return bu;
});