summaryrefslogtreecommitdiff
path: root/includes/js/dojox/gfx/arc.js
diff options
context:
space:
mode:
Diffstat (limited to 'includes/js/dojox/gfx/arc.js')
-rw-r--r--includes/js/dojox/gfx/arc.js122
1 files changed, 122 insertions, 0 deletions
diff --git a/includes/js/dojox/gfx/arc.js b/includes/js/dojox/gfx/arc.js
new file mode 100644
index 0000000..4a0eade
--- /dev/null
+++ b/includes/js/dojox/gfx/arc.js
@@ -0,0 +1,122 @@
+if(!dojo._hasResource["dojox.gfx.arc"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
+dojo._hasResource["dojox.gfx.arc"] = true;
+dojo.provide("dojox.gfx.arc");
+
+dojo.require("dojox.gfx.matrix");
+
+(function(){
+ var m = dojox.gfx.matrix,
+ 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
+ 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}
+ };
+ },
+ twoPI = 2 * Math.PI, pi4 = Math.PI / 4, pi8 = Math.PI / 8,
+ pi48 = pi4 + pi8, curvePI4 = unitArcAsBezier(pi8);
+
+ dojo.mixin(dojox.gfx.arc, {
+ unitArcAsBezier: unitArcAsBezier,
+ curvePI4: curvePI4,
+ 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 elliptic_transform = 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(elliptic_transform),
+ 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 c1, c2, e,
+ M = m.normalize([elliptic_transform, 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; // Object
+ }
+ });
+})();
+
+}