geom2d.js

(function(/*! Stitch !*/) {
  if (!this.require) {
    var modules = {}, cache = {}, require = function(name, root) {
      var path = expand(root, name), module = cache[path], fn;
      if (module) {
        return module.exports;
      } else if (fn = modules[path] || modules[path = expand(path, './index')]) {
        module = {id: path, exports: {}};
        try {
          cache[path] = module;
          fn(module.exports, function(name) {
            return require(name, dirname(path));
          }, module);
          return module.exports;
        } catch (err) {
          delete cache[path];
          throw err;
        }
      } else {
        throw 'module \'' + name + '\' not found';
      }
    }, expand = function(root, name) {
      var results = [], parts, part;
      if (/^\.\.?(\/|$)/.test(name)) {
        parts = [root, name].join('/').split('/');
      } else {
        parts = name.split('/');
      }
      for (var i = 0, length = parts.length; i < length; i++) {
        part = parts[i];
        if (part == '..') {
          results.pop();
        } else if (part != '.' && part != '') {
          results.push(part);
        }
      }
      return results.join('/');
    }, dirname = function(path) {
      return path.split('/').slice(0, -1).join('/');
    };
    this.require = function(name) {
      return require(name, '');
    }
    this.require.define = function(bundle) {
      for (var key in bundle)
        modules[key] = bundle[key];
    };
  }
  return this.require.define;
}).call(this)({"affine": function(exports, require, module) {// Generated by IcedCoffeeScript 1.3.1b
(function() {
  var affine2d, flipX, flipY, reflection, reflectionUnit, rotation, scaling, translation,
    __slice = [].slice,
    __hasProp = {}.hasOwnProperty,
    __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor; child.__super__ = parent.prototype; return child; };

  exports.compose = function(a1, a2) {
    var res;
    res = a2.copy();
    res.rightComposeWith(a1);
    return res;
  };

  affine2d = (function() {

    affine2d.name = 'affine2d';

    function affine2d() {
      var args;
      args = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
      if (args.length === 0) {
        this.m00 = 1;
        this.m01 = 0;
        this.m10 = 0;
        this.m11 = 1;
        this.v0 = 0;
        this.v1 = 0;
      } else if (args.length === 1) {
        this.m00 = args[0].m00;
        this.m01 = args[0].m01;
        this.m10 = args[0].m10;
        this.m11 = args[0].m11;
        this.v0 = args[0].v0;
        this.v1 = args[0].v1;
      } else {
        this.m00 = args[0];
        this.m01 = args[1];
        this.m10 = args[2];
        this.m11 = args[3];
        this.v0 = args[4];
        this.v1 = args[5];
      }
    }

    affine2d.prototype.oneLineSummary = function() {
      return ("M = [" + (this.m00.toPrecision(3))) + (" " + (this.m01.toPrecision(3))) + (" " + (this.m10.toPrecision(3))) + (" " + (this.m11.toPrecision(3)) + "]   V = (") + ("" + (this.v0.toPrecision(3)) + ", ") + (" " + (this.v1.toPrecision(3)) + ")   scale = ") + this.getXScale().toPrecision(3) + " x " + this.getYScale().toPrecision(3);
    };

    affine2d.prototype.copy = function() {
      return new affine2d(this);
    };

    affine2d.prototype.transformPair = function(v0, v1) {
      var t0, t1;
      t0 = this.m00 * v0 + this.m01 * v1 + this.v0;
      t1 = this.m10 * v0 + this.m11 * v1 + this.v1;
      return [t0, t1];
    };

    affine2d.prototype.transformVec = function(a) {
      var t0, t1;
      t0 = this.m00 * a[0] + this.m01 * a[1] + this.v0;
      t1 = this.m10 * a[0] + this.m11 * a[1] + this.v1;
      a[0] = t0;
      return a[1] = t1;
    };

    affine2d.prototype.rightComposeWith = function(a) {
      /*
          Typically when you have an affine A and you want to 
          perform another affine on it, use this.
          In other words:
            A.rightComposeWith(B)
            performs the composition B(A) and replaces A with the results.
      */

      var t_m00, t_m01, t_m10, t_m11, t_v0, t_v1;
      t_m10 = a.m00 * this.m10 + a.m10 * this.m11;
      t_m11 = a.m01 * this.m10 + a.m11 * this.m11;
      t_v1 = a.v0 * this.m10 + a.v1 * this.m11 + this.v1;
      t_m00 = a.m00 * this.m00 + a.m10 * this.m01;
      t_m01 = a.m01 * this.m00 + a.m11 * this.m01;
      t_v0 = a.v0 * this.m00 + a.v1 * this.m01 + this.v0;
      this.m00 = t_m00;
      this.m01 = t_m01;
      this.m10 = t_m10;
      this.m11 = t_m11;
      this.v0 = t_v0;
      return this.v1 = t_v1;
    };

    affine2d.prototype.leftComposeWith = function(a) {
      /*
          A.leftComposeWith(B)
          performs the composition A(B) and replaces A with the results
      */

      var t_m00, t_m01, t_m10, t_m11, t_v0, t_v1;
      t_m10 = this.m00 * a.m10 + this.m10 * a.m11;
      t_m11 = this.m01 * a.m10 + this.m11 * a.m11;
      t_v1 = this.v0 * a.m10 + this.v1 * a.m11 + a.v1;
      t_m00 = this.m00 * a.m00 + this.m10 * a.m01;
      t_m01 = this.m01 * a.m00 + this.m11 * a.m01;
      t_v0 = this.v0 * a.m00 + this.v1 * a.m01 + a.v0;
      this.m00 = t_m00;
      this.m01 = t_m01;
      this.m10 = t_m10;
      this.m11 = t_m11;
      this.v0 = t_v0;
      return this.v1 = t_v1;
    };

    affine2d.prototype.getXScale = function() {
      return Math.sqrt(this.m00 * this.m00 + this.m10 * this.m10);
    };

    affine2d.prototype.getYScale = function() {
      return Math.sqrt(this.m01 * this.m01 + this.m11 * this.m11);
    };

    affine2d.prototype.getXCenter = function() {
      return this.v0;
    };

    affine2d.prototype.getYCenter = function() {
      return this.v1;
    };

    return affine2d;

  })();

  rotation = (function(_super) {

    __extends(rotation, _super);

    rotation.name = 'rotation';

    function rotation(r) {
      rotation.__super__.constructor.call(this, Math.cos(r), -Math.sin(r), Math.sin(r), Math.cos(r), 0, 0);
    }

    return rotation;

  })(affine2d);

  scaling = (function(_super) {

    __extends(scaling, _super);

    scaling.name = 'scaling';

    function scaling(sx, sy) {
      scaling.__super__.constructor.call(this, sx, 0, 0, sy, 0, 0);
    }

    return scaling;

  })(affine2d);

  translation = (function(_super) {

    __extends(translation, _super);

    translation.name = 'translation';

    function translation(x, y) {
      translation.__super__.constructor.call(this, 1, 0, 0, 1, x, y);
    }

    return translation;

  })(affine2d);

  reflectionUnit = (function(_super) {

    __extends(reflectionUnit, _super);

    reflectionUnit.name = 'reflectionUnit';

    function reflectionUnit(ux, uy) {
      reflectionUnit.__super__.constructor.call(this, 2.0 * ux * ux - 1.0, 2.0 * ux * uy, 2.0 * ux * uy, 2.0 * uy * uy - 1.0, 0.0, 0.0);
    }

    return reflectionUnit;

  })(affine2d);

  reflection = (function(_super) {

    __extends(reflection, _super);

    reflection.name = 'reflection';

    function reflection(r) {
      reflection.__super__.constructor.call(this, Math.cos(r, Math.sin(r)));
    }

    return reflection;

  })(reflectionUnit);

  flipX = (function(_super) {

    __extends(flipX, _super);

    flipX.name = 'flipX';

    function flipX() {
      flipX.__super__.constructor.call(this, -1, 0, 0, 1, 0, 0);
    }

    return flipX;

  })(affine2d);

  flipY = (function(_super) {

    __extends(flipY, _super);

    flipY.name = 'flipY';

    function flipY() {
      flipY.__super__.constructor.call(this, 1, 0, 0, -1, 0, 0);
    }

    return flipY;

  })(affine2d);

  exports.affine2d = affine2d;

  exports.rotation = rotation;

  exports.scaling = scaling;

  exports.translation = translation;

  exports.reflectionUnit = reflectionUnit;

  exports.reflection = reflection;

  exports.flipX = flipX;

  exports.flipY = flipY;

}).call(this);
}, "polygon": function(exports, require, module) {// Generated by IcedCoffeeScript 1.3.1b
(function() {
  var affine, polygon;

  affine = require('./affine');

  polygon = (function() {

    polygon.name = 'polygon';

    function polygon(vertices) {
      if (vertices != null) {
        this.vertices = vertices;
      } else {
        this.vertices = [];
      }
    }

    polygon.prototype.copy = function() {
      var new_v, v, _i, _len, _ref;
      new_v = [];
      _ref = this.vertices;
      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
        v = _ref[_i];
        new_v.push(v.copy());
      }
      return new polygon(new_v);
    };

    polygon.prototype.addVertex = function(v) {
      return this.vertices.push(v);
    };

    polygon.prototype.transform = function(aff) {
      var v, _i, _len, _ref, _results;
      _ref = this.vertices;
      _results = [];
      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
        v = _ref[_i];
        _results.push(aff.transformVec(v));
      }
      return _results;
    };

    polygon.prototype.getBoundingRectangle = function() {
      /*
          returns a pair of pairs; 
          for example: [[1,2],[3,5]] 
          means that  1 <= x <= 3
                  and 2 <= y <= 5
          for all points
      */

      var i, v, x, _i, _len, _ref;
      x = null;
      _ref = this.vertices;
      for (i = _i = 0, _len = _ref.length; _i < _len; i = ++_i) {
        v = _ref[i];
        if (i === 0) {
          x = [[v[0], v[1]], [v[0], v[1]]];
        } else {
          if (v[0] < x[0][0]) x[0][0] = v[0];
          if (v[0] > x[1][0]) x[1][0] = v[0];
          if (v[1] < x[0][1]) x[0][1] = v[1];
          if (v[1] > x[1][1]) x[1][1] = v[1];
        }
      }
      return x;
    };

    return polygon;

  })();

  exports.polygon = polygon;

  exports.factory = {
    unitSquare: function() {
      return new polygon([[0.5, 0.5], [-0.5, 0.5], [-0.5, -0.5], [0.5, -0.5]]);
    },
    unitCircleApprox: function(num) {
      var i, p, radian_increment, radians, _i;
      radian_increment = 2.0 * Math.PI / num;
      radians = 0;
      p = new polygon();
      for (i = _i = 0; 0 <= num ? _i < num : _i > num; i = 0 <= num ? ++_i : --_i) {
        radians += radian_increment;
        p.addVertex([0.5 * Math.cos(radians), 0.5 * Math.sin(radians)]);
      }
      return p;
    }
  };

}).call(this);
}});