arc.js

define(["./_base", "dojo/_base/lang", "./matrix"], function (g, lang, m) {
	var twoPI = 2 * Math.PI, pi4 = Math.PI / 4, pi8 = Math.PI / 8, pi48 = pi4 + pi8, curvePI4 = unitArcAsBezier(pi8);

	function unitArcAsBezier(alpha) {
		// summary:
		//		return a start point, 1st and 2nd control points, and an end point of
		//		a an arc, which is reflected on the x axis
		// alpha: Number
		//		angle in radians, the arc will be 2 * angle size
		var cosa = Math.cos(alpha), sina = Math.sin(alpha), p2 = {x: cosa + (4 / 3) * (1 - cosa), y: sina -
			(4 / 3) * cosa * (1 - cosa) / sina};
		return {	// Object
			s: {x: cosa, y: -sina},
			c1: {x: p2.x, y: -p2.y},
			c2: p2,
			e: {x: cosa, y: sina}
		};
	}

	var arc = g.arc = {
		// summary:
		//		This module contains the core graphics Arc functions.

		unitArcAsBezier: unitArcAsBezier,
		/*=====
		 unitArcAsBezier: function(alpha) {
		 // summary:
		 //		return a start point, 1st and 2nd control points, and an end point of
		 //		a an arc, which is reflected on the x axis
		 // alpha: Number
		 //		angle in radians, the arc will be 2 * angle size
		 },
		 =====*/

		// curvePI4: Object
		//		an object with properties of an arc around a unit circle from 0 to pi/4
		curvePI4: curvePI4,

		/* jshint maxcomplexity:12 */
		arcAsBezier: function (last, rx, ry, xRotg, large, sweep, x, y) {
			// summary:
			//		calculates an arc as a series of Bezier curves
			//		given the last point and a standard set of SVG arc parameters,
			//		it returns an array of arrays of parameters to form a series of
			//		absolute Bezier curves.
			// last: Object
			//		a point-like object as a start of the arc
			// rx: Number
			//		a horizontal radius for the virtual ellipse
			// ry: Number
			//		a vertical radius for the virtual ellipse
			// xRotg: Number
			//		a rotation of an x axis of the virtual ellipse in degrees
			// large: Boolean
			//		which part of the ellipse will be used (the larger arc if true)
			// sweep: Boolean
			//		direction of the arc (CW if true)
			// x: Number
			//		the x coordinate of the end point of the arc
			// y: Number
			//		the y coordinate of the end point of the arc

			// calculate parameters
			large = Boolean(large);
			sweep = Boolean(sweep);
			var xRot = m._degToRad(xRotg), rx2 = rx * rx, ry2 = ry * ry, pa = m.multiplyPoint(m.rotate(-xRot),
				{x: (last.x - x) / 2, y: (last.y - y) / 2}), pax2 = pa.x * pa.x, pay2 = pa.y *
				pa.y, c1 = Math.sqrt((rx2 * ry2 - rx2 * pay2 - ry2 * pax2) / (rx2 * pay2 + ry2 * pax2));
			if (isNaN(c1)) {
				c1 = 0;
			}
			var ca = {
				x: c1 * rx * pa.y / ry,
				y: -c1 * ry * pa.x / rx
			};
			if (large === sweep) {
				ca = {x: -ca.x, y: -ca.y};
			}
			// the center
			var c = m.multiplyPoint([
				m.translate((last.x + x) / 2, (last.y + y) / 2), m.rotate(xRot)
			], ca);
			// calculate the elliptic transformation
			var ellipticTransform = m.normalize([
				m.translate(c.x, c.y), m.rotate(xRot), m.scale(rx, ry)
			]);
			// start, end, and size of our arc
			var inversed = m.invert(ellipticTransform), sp = m.multiplyPoint(inversed,
				last), ep = m.multiplyPoint(inversed, x, y), startAngle = Math.atan2(sp.y,
				sp.x), endAngle = Math.atan2(ep.y, ep.x), theta = startAngle - endAngle; // size of our arc in radians
			if (sweep) {
				theta = -theta;
			}
			if (theta < 0) {
				theta += twoPI;
			} else if (theta > twoPI) {
				theta -= twoPI;
			}

			// draw curve chunks
			var alpha = pi8, curve = curvePI4, step = sweep ? alpha : -alpha, result = [];
			for (var angle = theta; angle > 0; angle -= pi4) {
				if (angle < pi48) {
					alpha = angle / 2;
					curve = unitArcAsBezier(alpha);
					step = sweep ? alpha : -alpha;
					angle = 0;	// stop the loop
				}
				var c2, e, M = m.normalize([ellipticTransform, m.rotate(startAngle + step)]);
				if (sweep) {
					c1 = m.multiplyPoint(M, curve.c1);
					c2 = m.multiplyPoint(M, curve.c2);
					e = m.multiplyPoint(M, curve.e);
				} else {
					c1 = m.multiplyPoint(M, curve.c2);
					c2 = m.multiplyPoint(M, curve.c1);
					e = m.multiplyPoint(M, curve.s);
				}
				// draw the curve
				result.push([c1.x, c1.y, c2.x, c2.y, e.x, e.y]);
				startAngle += 2 * step;
			}
			return result;	// Array
		}
	};

	return arc;
});