hole.js

// Generated by CoffeeScript 1.10.0

/*
The MIT License

Copyright (c) 2016 Jason S. Ku

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.

TO DO
[ ] restrict to flat filling
[ ] impliment collision detection
[ ] add resizing for mobile devices
[ ] add interface (touch) for mobile devices

2016-01-05
[x] make talk examples

2016-01-04
[x] impiment edge insetting

2015-12-22
[x] fix OBJ to fit specification

2015-11-25 to 2015-12-19
[x] refactor code for polyhedron viewing/selection
[x] impliment direction/critical selection
[x] impliment random hole generation
[x] add interface buttons
[x] import/export obj file

2015-11-24
[x] adjust scale to actual diameter
[x] test crease directions methods
[x] impliment hole splitting navigation
[x] impliment non-critical hole splitting
[x] impliment auto-fill holes
[x] added flat example

2015-11-23
[x] fix scale/center for view
[x] fix @points
[x] fully test visibility
[x] figure out static properties
[x] general refactorization
[x] associate selected with each hole
 */


/*
Global Variables
 */

(function() {
  var AppHandler, BLACK, BLUE, BinaryTreeNode, COMMA, DELETE, DOWN, EPS, Face, GREEN, Hole, HolePoint, HoleView, INPUT, KEY_A, KEY_C, KEY_H, KEY_J, KEY_K, KEY_L, KEY_N, KEY_S, KEY_T, LEFT, PERIOD, Point, RED, RETURN, RIGHT, Rotator, SLIDE_TEXT, SPACE, TAB, TILDE, UP, View, YELLOW, i,
    extend = 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; },
    hasProp = {}.hasOwnProperty;

  EPS = Math.pow(10, -13);

  DELETE = 8;

  TAB = 9;

  RETURN = 13;

  SPACE = 32;

  LEFT = 37;

  UP = 38;

  RIGHT = 39;

  DOWN = 40;

  KEY_A = 65;

  KEY_C = 67;

  KEY_H = 72;

  KEY_J = 74;

  KEY_K = 75;

  KEY_L = 76;

  KEY_N = 78;

  KEY_S = 83;

  KEY_T = 84;

  COMMA = 188;

  PERIOD = 190;

  TILDE = 192;

  BLACK = '#000000';

  RED = '#ff0000';

  GREEN = '#00ff00';

  BLUE = '#0000ff';

  YELLOW = '#ffff00';

  INPUT = [
    {
      vertices: [[11, 5, 9, 4, 0], [11, 2.5, 9, 2, 1.5], [11, 0, 7.5, 0, 1.5], [11, -2.5, 9, -2, 1.5], [11, -5, 9, -4, 0], [6, -5, 5, -1, 0], [1, -5, 1, -4, 0], [0, -5, 2, -4, 0], [1, 0, 1, 0, 3], [-1, 0, -1, 0, 3], [-1, -5, -1, -4, 0], [-6, -5, -5, -1, 0], [-11, -5, -9, -4, 0], [-11, 0, -9, 0, 3], [-11, 5, -9, 4, 0], [-6, 5, -5, 1, 0], [-1, 5, -1, 4, 0], [1, 5, 1, 4, 0], [6, 5, 5, 1, 0]],
      faces: [[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18]]
    }, {
      vertices: [[0, 0, 0, 0, 0], [0, 1, 1, 0, 0], [1, 1, 0, 0, 0], [1, 0, 1, 0, 0]],
      faces: [[0, 1, 2, 3]]
    }, {
      vertices: [[0, 2, 0, 2, 0], [2, 0, 2, 0, 0], [1, -3, 1, 3 / Math.sqrt(2), 3 / Math.sqrt(2)], [0, 0, 0, 0, 0], [-5, 1, 5 / Math.sqrt(2), 1, 5 / Math.sqrt(2)]],
      faces: [[0, 1, 2, 3, 4]]
    }, {
      vertices: [[0, 0, 0, 0, 0], [0, 3, 2, 2, 1], [3, 3, 0, 0, 2], [3, 0, 2, -2, 1]],
      faces: [[0, 1, 2, 3]]
    }, {
      vertices: [[0, 1, 0, 1, 0], [1, 1, 1, 1, 0], [3, 1, 1 - 2 / Math.sqrt(2), 1, 2 / Math.sqrt(2)], [1, 0, 1, 0, 0], [0, 0, 0, 0, 0], [-2, 0, 2 / Math.sqrt(2), 0, 2 / Math.sqrt(2)]],
      faces: [[0, 1, 2, 3, 4, 5]]
    }, {
      vertices: [[5, 5, 4, 4, 0], [5, 0, 4, 0, 3], [5, -5, 4, -4, 0], [0, -5, 0, -1, 0], [-5, -5, -4, -4, 0], [-5, 0, -4, 0, 3], [-5, 5, -4, 4, 0], [0, 5, 0, 1, 0]],
      faces: [[0, 1, 2, 3, 4, 5, 6, 7]]
    }, {
      vertices: [[5, 5, 4, 4, 0], [5, 0, 4, 0, 3], [5, -5, 4, -4, 0], [0, -5, 0, -1, 0], [-5, -5, -4, -4, 0], [-5, 0, -4, 0, 3], [-5, 5, -4, 4, 0], [0, 5, 0, 1, 0]],
      faces: [[0, 1, 2, 3, 4, 5, 6, 7]]
    }, {
      vertices: [[0, 0, 0, 0, 0], [0, 3, 2, 2, 1], [3, 3, 0, 0, 2], [3, 0, 2, -2, 1]],
      faces: [[0, 1, 2, 3]]
    }, {
      vertices: [[2, 0, 1, 0, 1], [1, -1, 1, -1, 0], [0, -2, 0, -1, -1], [-1, -1, -1, -1, 0], [-2, 0, -1, 0, 1], [-1, 1, -1, 1, 0], [0, 2, 0, 1, -1], [1, 1, 1, 1, 0]],
      faces: [[0, 1, 2, 3, 4, 5, 6, 7]]
    }, {
      vertices: [[1, 2, 1, 2, 0], [2, 1, 1, 1, 1], [1, 0, 1, 0, 0], [0, 1, 0, 1, 0]],
      faces: [[0, 1, 2, 3]]
    }, {
      vertices: [[1, 1, 1, 1, 0], [1, 0, 1, 0, 0], [1, -1, 1, -1, 0], [0, -1, 0, -1, 0], [-1, -1, -1, -1, 0], [-1, 0, -1, 0, 0], [-1, 1, -1, 1, 0], [0, 1, 0, 1, 0]],
      faces: [[0, 1, 2, 3, 4, 5, 6, 7]]
    }, {
      vertices: [[0, 0, 0, 0, 0], [0, 1, 0, 1, 0], [1, 0, 1, 0, 0]],
      faces: [[0, 1, 2]]
    }
  ];


  /*
    {vertices:
       [[ 0, 0, 0, 0, 0]
        [ 0, 2, 0, 2, 0]
        [ 0, 3, 0, 1, 0]
        [ 0, 5, 0, 3, 0]
        [ 2, 3, 2, 1, 0]
        [ 3, 2, 1, 2, 0]
        [ 5, 0, 3, 0, 0]
        [ 3, 0, 1, 0, 0]
        [ 2, 0, 2, 0, 0]]
     faces: [[0..8]]}
    {vertices:
       [[0,0,0,0,0]
        [0,2,2,0,0]
        [2,2,0,0,0]
        [2,1,1,0,0]
        [2,0,0,0,0]
        [1,0,1,0,0]]
     faces: [[0..5]]}
    {vertices:
       [[ 0, 0, 0, 0, 0]
        [-2, 2, -Math.sqrt(2), Math.sqrt(6), 0]
        [-2 + 1/Math.sqrt(3), 2 + 1/Math.sqrt(3), -1/Math.sqrt(2), 1/Math.sqrt(6) + Math.sqrt(6), 0]
        [-2 + 2/Math.sqrt(3), 2 + 2/Math.sqrt(3), 0, Math.sqrt(6), 0]
        [0, 4, 0, Math.sqrt(6) - 2 * (Math.sqrt(2) - 2 / Math.sqrt(6)), 0]
        [ 2 - 2/Math.sqrt(3), 2 + 2/Math.sqrt(3), 0, Math.sqrt(6), 0]
        [ 2 - 1/Math.sqrt(3), 2 + 1/Math.sqrt(3),  1/Math.sqrt(2), 1/Math.sqrt(6) + Math.sqrt(6), 0]
        [ 2, 2,  Math.sqrt(2), Math.sqrt(6), 0]]
     faces: [[0..8]]}
   */

  SLIDE_TEXT = (function() {
    var k, len, ref, results;
    ref = INPUT.concat(INPUT);
    results = [];
    for (k = 0, len = ref.length; k < len; k++) {
      i = ref[k];
      results.push('');
    }
    return results;
  })();

  SLIDE_TEXT[INPUT.length - 1] = 'JMM 2016/01/06 --- Interface --- Problem --- Motivation --- Past Work --- Necessary Condition  ---  New Work (1) 3D Implimentation (2) All Isometries (3) Intersection';

  SLIDE_TEXT[0] = 'Nonexpansive triangle: isometry always exists and is unique';

  SLIDE_TEXT[1] = 'Flat maps: isometry always exists and is unique';

  SLIDE_TEXT[2] = 'Critical maps: isometry always exists and is unique';

  SLIDE_TEXT[3] = 'Can choose among options';

  SLIDE_TEXT[4] = 'Contractive maps: infinite isometries exist --- Idea: locally satisfy vertex and recurse --- One dimension of local single crease solutions';

  SLIDE_TEXT[5] = 'Repeat procedure with more complex boundaries --- Implimentation can construct random isometries';

  SLIDE_TEXT[6] = 'Edge insetting, parameterized space of all triangles that can bound an edge';

  SLIDE_TEXT[7] = 'Self intersection: Map must be unknot --- Necessary/sufficient conditions seem nontrivial';

  SLIDE_TEXT[8] = 'Proposition: All paper boundaries folded at only four points can fold without intersection';

  SLIDE_TEXT[9] = 'Some paper boundaries folded at five points cannot be folded without intersection';

  SLIDE_TEXT[10] = 'Future Approach: Search space of solutions to find isometries free from intersection --- This example unique up to embedding with old method';


  /*
  GENERAL POLYHEDRA VIEWER CLASSES
   */

  Point = (function() {
    Point.free = 0;

    function Point(x1, y1, z1) {
      this.x = x1;
      this.y = y1;
      this.z = z1 != null ? z1 : 0;
      this.id = Point.free++;
    }

    Point.prototype.add = function(v) {
      return new Point(this.x + v.x, this.y + v.y, this.z + v.z);
    };

    Point.prototype.plus = function(s) {
      return new Point(this.x + s, this.y + s, this.z + s);
    };

    Point.prototype.mul = function(s) {
      return new Point(this.x * s, this.y * s, this.z * s);
    };

    Point.prototype.div = function(s) {
      return this.mul(1.0 / s);
    };

    Point.prototype.sub = function(v) {
      return this.add(v.mul(-1));
    };

    Point.prototype.dot = function(v) {
      return (this.x * v.x) + (this.y * v.y) + (this.z * v.z);
    };

    Point.prototype.dist = function(v) {
      return Math.sqrt(this.dist_sq(v));
    };

    Point.prototype.dist_sq = function(v) {
      return this.sub(v).mag_sq();
    };

    Point.prototype.is_zero = function() {
      return this.mag() === 0;
    };

    Point.prototype.neg_y = function() {
      return new Point(this.x, -this.y, this.z);
    };

    Point.prototype.mag_sq = function() {
      return this.dot(this);
    };

    Point.prototype.mag = function() {
      return Math.sqrt(this.mag_sq());
    };

    Point.prototype.dir = function() {
      return this.div(this.mag());
    };

    Point.prototype.cross = function(v) {
      return new Point((this.y * v.z) - (this.z * v.y), (this.z * v.x) - (this.x * v.z), (this.x * v.y) - (this.y * v.x));
    };

    Point.prototype.angle = function(u, v) {
      u = u.sub(this).dir();
      v = v.sub(this).dir();
      return Math.acos(u.dot(v));
    };

    Point.prototype.rotate = function(axis, ang) {
      return this.mul(Math.cos(ang)).add(axis.cross(this).mul(Math.sin(ang))).add(axis.mul(this.dot(axis)).mul(1 - Math.cos(ang)));
    };

    Point.prototype.perp = function() {
      var p;
      p = new Point(1, 0, 0);
      if (this.cross(p).is_zero()) {
        p = new Point(0, 1, 0);
      }
      return this.cross(p).dir();
    };

    Point.prototype.local_normal = function(next, prev) {
      var normal;
      normal = next.sub(this).cross(prev.sub(this));
      if (normal.mag_sq() > EPS) {
        return normal.dir();
      }
      return next.sub(this).perp();
    };

    Point.prototype.turns_right = function(u, v, n) {
      if (n == null) {
        n = new Point(0, 0, 1);
      }
      return u.sub(this).cross(v.sub(this)).dot(n) > 0;
    };

    Point.prototype.exterior_straddle = function(next, prev, q, normal) {
      return (this.turns_right(next, q, normal)) && (this.turns_right(q, prev, normal));
    };

    Point.prototype.exterior_right = function(next, prev, q, normal) {
      return (this.turns_right(q, prev, normal)) && (this.turns_right(prev, next, normal));
    };

    Point.prototype.exterior_left = function(next, prev, q, normal) {
      return (this.turns_right(next, q, normal)) && (this.turns_right(prev, next, normal));
    };

    Point.prototype.between = function(u, v) {
      var a, b;
      a = this.sub(u);
      b = this.sub(v);
      if ((a.mag() < EPS) || (b.mag() < EPS)) {
        return true;
      }
      return a.dir().dot(b.dir()) + 1 < EPS;
    };

    Point.prototype.intersects = function(q, u, v, normal) {
      return (this.turns_right(u, q, normal) === this.turns_right(q, v, normal)) && (u.turns_right(this, v, normal) === u.turns_right(v, q, normal));
    };

    Point.centroid = function(ps) {
      var k, len, out, p;
      out = new Point(0, 0, 0);
      for (k = 0, len = ps.length; k < len; k++) {
        p = ps[k];
        out = out.add(p);
      }
      return out.div(ps.length);
    };

    Point.center = function(ps) {
      var c, k, len, len1, len2, m, max, min, p, ref, ref1, t;
      max = (new Point(1, 1, 1)).div(-EPS);
      min = (new Point(1, 1, 1)).div(EPS);
      for (k = 0, len = ps.length; k < len; k++) {
        p = ps[k];
        ref = ['x', 'y', 'z'];
        for (m = 0, len1 = ref.length; m < len1; m++) {
          c = ref[m];
          max[c] = Math.max(p[c], max[c]);
        }
        ref1 = ['x', 'y', 'z'];
        for (t = 0, len2 = ref1.length; t < len2; t++) {
          c = ref1[t];
          min[c] = Math.min(p[c], min[c]);
        }
      }
      return max.add(min).div(2);
    };

    Point.normal = function(ps) {
      var k, len, next, normal, p, prev, temp;
      normal = null;
      for (i = k = 0, len = ps.length; k < len; i = ++k) {
        p = ps[i];
        next = ps[(i + 1) % ps.length];
        prev = ps[(i - 1 + ps.length) % ps.length];
        temp = p.local_normal(next, prev);
        if (temp != null) {
          if ((normal != null) && (1 - Math.abs(normal.dot(temp)) > EPS)) {
            return null;
          }
          normal = temp;
        }
      }
      return normal;
    };

    Point.visible = function(ps, i, p, normal) {

      /*
      returns if line from p to ps[i] is interior to ps projected on normal
       */
      var j, k, len, next, prev, q;
      next = ps[(i + 1) % ps.length];
      prev = ps[(i - 1 + ps.length) % ps.length];
      if (p.sub(ps[i]).mag() < EPS) {
        return false;
      }
      if (p.sub(next).mag() < EPS) {
        return false;
      }
      if (p.sub(prev).mag() < EPS) {
        return false;
      }
      if (ps[i].exterior_straddle(next, prev, p, normal)) {
        return false;
      }
      if (ps[i].exterior_left(next, prev, p, normal)) {
        return false;
      }
      if (ps[i].exterior_right(next, prev, p, normal)) {
        return false;
      }
      for (j = k = 0, len = ps.length; k < len; j = ++k) {
        q = ps[j];
        if (!((q !== ps[i]) && (q.sub(p).mag() > EPS))) {
          continue;
        }
        if (q.between(ps[i], p)) {
          return false;
        }
        next = ps[(j + 1) % ps.length];
        if ((next !== ps[i]) && (next.sub(p).mag() > EPS)) {
          if (q.intersects(next, ps[i], p, normal)) {
            return false;
          }
        }
      }
      return true;
    };

    return Point;

  })();

  BinaryTreeNode = (function() {
    function BinaryTreeNode() {
      this.parent = null;
      this.left = null;
      this.right = null;
    }

    BinaryTreeNode.prototype.add_children = function(l, r) {
      this.left = l;
      this.right = r;
      this.left.parent = this;
      return this.right.parent = this;
    };

    BinaryTreeNode.prototype.remove_children = function() {
      this.left = null;
      return this.right = null;
    };

    BinaryTreeNode.prototype.has_children = function() {
      return this.left != null;
    };

    BinaryTreeNode.prototype.is_left_child = function() {
      var ref;
      return this === ((ref = this.parent) != null ? ref.left : void 0);
    };

    BinaryTreeNode.prototype.is_right_child = function() {
      var ref;
      return this === ((ref = this.parent) != null ? ref.right : void 0);
    };

    BinaryTreeNode.prototype.leftmost_descendent = function() {
      var out;
      out = this;
      while (out.has_children()) {
        out = out.left;
      }
      return out;
    };

    BinaryTreeNode.prototype.rightmost_descendent = function() {
      var out;
      out = this;
      while (out.has_children()) {
        out = out.right;
      }
      return out;
    };

    BinaryTreeNode.prototype.next_child = function() {
      var old;
      if (this.has_children()) {
        return this.leftmost_descendent();
      } else {
        old = this;
        while (old.is_right_child()) {
          old = old.parent;
        }
        if (old.parent == null) {
          return old.leftmost_descendent();
        } else {
          return old.parent.right.leftmost_descendent();
        }
      }
    };

    BinaryTreeNode.prototype.prev_child = function() {
      var old;
      if (this.has_children()) {
        return this.rightmost_descendent();
      } else {
        old = this;
        while (old.is_left_child()) {
          old = old.parent;
        }
        if (old.parent == null) {
          return old.rightmost_descendent();
        } else {
          return old.parent.left.rightmost_descendent();
        }
      }
    };

    BinaryTreeNode.prototype.leaves = function() {
      var out;
      out = [this.leftmost_descendent()];
      while (out[out.length - 1].next_child() !== out[0]) {
        out.push(out[out.length - 1].next_child());
      }
      return out;
    };

    BinaryTreeNode.prototype.rooted_descendents = function() {
      var front, out, temp;
      out = [this];
      front = [this];
      while (front.length > 0) {
        temp = front.pop();
        if (temp.has_children()) {
          out.push(temp.left);
          out.push(temp.right);
          front.push(temp.left);
          front.push(temp.right);
        }
      }
      return out;
    };

    return BinaryTreeNode;

  })();

  Face = (function(superClass) {
    extend(Face, superClass);

    Face.free = 0;

    function Face(points) {
      this.points = points;
      Face.__super__.constructor.call(this);
      this.id = Face.free++;
      this.head = this.points[0];
      this.connections = {};
      this.neighbors = {};
      this.index = {};
      this.connect_points();
      this.assign_indices();
    }

    Face.prototype.idx = function(p) {
      return this.index[p.id];
    };

    Face.prototype.next = function(p) {
      var ref;
      return (ref = this.connections[p.id]) != null ? ref.next : void 0;
    };

    Face.prototype.prev = function(p) {
      var ref;
      return (ref = this.connections[p.id]) != null ? ref.prev : void 0;
    };

    Face.prototype.neighbor = function(p) {
      return this.neighbors[p.id];
    };

    Face.prototype.head_next = function() {
      return this.head = this.next(this.head);
    };

    Face.prototype.head_prev = function() {
      return this.head = this.prev(this.head);
    };

    Face.prototype.normal = function() {
      return Point.normal(this.points);
    };

    Face.prototype.points_between = function(p, q) {
      var out;
      if ((this.next(p) != null) && (this.next(q) != null)) {
        out = [p];
        while (out[out.length - 1] !== q) {
          out.push(this.next(out[out.length - 1]));
        }
        return out;
      }
    };

    Face.prototype.connect_points = function() {
      var k, len, n, p, ref, results;
      n = this.points.length;
      ref = this.points;
      results = [];
      for (i = k = 0, len = ref.length; k < len; i = ++k) {
        p = ref[i];
        results.push(this.connections[p.id] = {
          next: this.points[(i + 1) % n],
          prev: this.points[(i - 1 + n) % n]
        });
      }
      return results;
    };

    Face.prototype.assign_indices = function() {
      var k, len, n, p, ref, results;
      n = this.points.length;
      ref = this.points;
      results = [];
      for (i = k = 0, len = ref.length; k < len; i = ++k) {
        p = ref[i];
        results.push(this.index[p.id] = i);
      }
      return results;
    };

    Face.prototype.points_in_descendents = function() {
      return Face.points_in_faces(this.rooted_descendents());
    };

    Face.prototype.triangle = function() {
      return this.points.length === 3;
    };

    Face.prototype.all_triangles = function() {
      var k, l, len, ref;
      ref = this.leaves();
      for (k = 0, len = ref.length; k < len; k++) {
        l = ref[k];
        if (!l.triangle()) {
          return false;
        }
      }
      return true;
    };

    Face.points_in_faces = function(fs) {
      var f, found, k, len, len1, m, p, ps, ref;
      ps = [];
      found = {};
      for (k = 0, len = fs.length; k < len; k++) {
        f = fs[k];
        ref = f.points;
        for (m = 0, len1 = ref.length; m < len1; m++) {
          p = ref[m];
          if (found[p.id] == null) {
            found[p.id] = true;
            ps.push(p);
          }
        }
      }
      return ps;
    };

    Face.connect_faces = function(fs) {
      var f, f1, f2, k, len, len1, len2, m, p, p1, p2, ref, results, t;
      for (k = 0, len = fs.length; k < len; k++) {
        f = fs[k];
        ref = f.points;
        for (m = 0, len1 = ref.length; m < len1; m++) {
          p = ref[m];
          f.neighbors[p.id] = null;
        }
      }
      results = [];
      for (i = t = 0, len2 = fs.length; t < len2; i = ++t) {
        f1 = fs[i];
        results.push((function() {
          var len3, ref1, results1, w;
          ref1 = f1.points;
          results1 = [];
          for (w = 0, len3 = ref1.length; w < len3; w++) {
            p1 = ref1[w];
            results1.push((function() {
              var aa, len4, ref2, results2;
              ref2 = fs.slice(i + 1);
              results2 = [];
              for (aa = 0, len4 = ref2.length; aa < len4; aa++) {
                f2 = ref2[aa];
                results2.push((function() {
                  var ab, len5, ref3, results3;
                  ref3 = f2.points;
                  results3 = [];
                  for (ab = 0, len5 = ref3.length; ab < len5; ab++) {
                    p2 = ref3[ab];
                    if ((p1 === p2) && (f1.next(p1) === f2.prev(p2))) {
                      f1.neighbors[p1.id] = f2;
                      results3.push(f2.neighbors[f2.prev(p2).id] = f1);
                    } else {
                      results3.push(void 0);
                    }
                  }
                  return results3;
                })());
              }
              return results2;
            })());
          }
          return results1;
        })());
      }
      return results;
    };

    return Face;

  })(BinaryTreeNode);

  View = (function() {
    function View(id1) {
      this.id = id1;
      this.center = null;
      this.scale = null;
      this.dx = new Point(1, 0, 0);
      this.dy = new Point(0, 1, 0);
      this.inset_factor = 0.9;
      this.view_size = 150;
      this.svg = SVG(this.id);
      this.svg.viewbox(0, 0, this.view_size, this.view_size);
    }

    View.prototype.clear = function() {
      return this.svg.clear();
    };

    View.prototype.scale_points = function(ps) {
      var k, len, p;
      this.center = Point.center(ps);
      this.scale = EPS;
      for (k = 0, len = ps.length; k < len; k++) {
        p = ps[k];
        this.scale = Math.max(this.scale, this.center.sub(p).mag());
      }
      return this.scale = this.view_size * this.inset_factor / this.scale / 2;
    };

    View.prototype.set_frame = function(dx, dz) {
      this.dx = dx;
      if (dz == null) {
        dz = this.dx.perp();
      }
      return this.dy = dz.cross(this.dx);
    };

    View.prototype.location = function(p) {
      var q;
      q = new Point(p.sub(this.center).dot(this.dx), p.sub(this.center).dot(this.dy));
      return q.mul(this.scale).neg_y().plus(0.5 * this.view_size);
    };

    View.prototype.draw_point = function(p) {
      var q;
      q = this.location(p);
      return this.svg.circle(1).center(q.x, q.y);
    };

    View.prototype.draw_point_text = function(p, label) {
      var q;
      q = this.location(p);
      return this.svg.text(label).move(q.x, q.y);
    };

    View.prototype.draw_polyline = function(ps) {
      var p, q, qs;
      qs = (function() {
        var k, len, results;
        results = [];
        for (k = 0, len = ps.length; k < len; k++) {
          p = ps[k];
          results.push(this.location(p));
        }
        return results;
      }).call(this);
      return this.svg.polyline((function() {
        var k, len, results;
        results = [];
        for (k = 0, len = qs.length; k < len; k++) {
          q = qs[k];
          results.push([q.x, q.y]);
        }
        return results;
      })());
    };

    View.prototype.draw_polygon = function(ps) {
      var p, q, qs;
      qs = (function() {
        var k, len, results;
        results = [];
        for (k = 0, len = ps.length; k < len; k++) {
          p = ps[k];
          results.push(this.location(p));
        }
        return results;
      }).call(this);
      return this.svg.polygon((function() {
        var k, len, results;
        results = [];
        for (k = 0, len = qs.length; k < len; k++) {
          q = qs[k];
          results.push([q.x, q.y]);
        }
        return results;
      })());
    };

    return View;

  })();

  Rotator = (function() {
    function Rotator(view, draw) {
      this.view = view;
      this.draw = draw;
      this.yaw = Math.PI / 3;
      this.pitch = Math.PI / 4;
      this.pitch_lim = 0.42;
      this.ang_scale = 0.002;
      this.set_frame(this.yaw, this.pitch);
      this.start = null;
      this.current = null;
      this.view.svg.on('contextmenu', function(e) {
        return e.preventDefault();
      });
      this.view.svg.on('selectstart', function(e) {
        return e.preventDefault();
      });
      this.view.svg.on('dragstart', function(e) {
        return e.preventDefault();
      });
      this.view.svg.mousedown((function(_this) {
        return function(e) {
          return _this.start_spin(e);
        };
      })(this));
      this.view.svg.mouseup((function(_this) {
        return function(e) {
          return _this.stop_spin();
        };
      })(this));
      this.view.svg.mousemove((function(_this) {
        return function(e) {
          return _this.spin(e);
        };
      })(this));
      this.view.svg.mouseout((function(_this) {
        return function(e) {
          var top;
          top = (e.target.id != null) && e.target.id === _this.view.id ? e.relatedTarget : e.target;
          while ((top != null) && (top.id !== _this.view.id) && (top.nodeName !== 'BODY')) {
            top = top.parentNode;
          }
          if ((top == null) || top.nodeName === 'BODY') {
            return _this.stop_spin();
          }
        };
      })(this));
    }

    Rotator.prototype.refresh = function() {
      this.set_frame(this.yaw, this.pitch);
      return this.draw();
    };

    Rotator.prototype.set_frame = function(yaw, pitch) {
      var dx, dz;
      dz = new Point(Math.cos(pitch) * Math.cos(yaw), Math.cos(pitch) * Math.sin(yaw), Math.sin(pitch));
      dx = dz.cross(new Point(0, 0, -1)).dir();
      return this.view.set_frame(dx, dz);
    };

    Rotator.prototype.stop_spin = function() {
      if ((this.start != null) && (this.current != null)) {
        this.yaw = this.get_yaw();
        this.pitch = this.get_pitch();
        this.refresh();
      }
      this.start = null;
      return this.current = null;
    };

    Rotator.prototype.start_spin = function(e) {
      return this.start = this.screen_pt(e);
    };

    Rotator.prototype.step_yaw = function(d) {
      return (this.yaw + d * this.ang_scale * Math.PI) % (2 * Math.PI);
    };

    Rotator.prototype.step_pitch = function(d) {
      var pitch;
      pitch = this.pitch - d * this.ang_scale * Math.PI;
      if (!(Math.abs(pitch) < this.pitch_lim * Math.PI)) {
        pitch *= this.pitch_lim * Math.PI / Math.abs(pitch);
      }
      return pitch;
    };

    Rotator.prototype.get_yaw = function() {
      return this.step_yaw(this.start.x - this.current.x);
    };

    Rotator.prototype.get_pitch = function() {
      return this.step_pitch(this.start.y - this.current.y);
    };

    Rotator.prototype.increment_yaw = function() {
      this.yaw = this.step_yaw(10);
      return this.refresh();
    };

    Rotator.prototype.decrement_yaw = function() {
      this.yaw = this.step_yaw(-10);
      return this.refresh();
    };

    Rotator.prototype.increment_pitch = function() {
      this.pitch = this.step_pitch(10);
      return this.refresh();
    };

    Rotator.prototype.decrement_pitch = function() {
      this.pitch = this.step_pitch(-10);
      return this.refresh();
    };

    Rotator.prototype.spin = function(e) {
      if (this.start != null) {
        this.current = this.screen_pt(e);
        this.set_frame(this.get_yaw(), this.get_pitch());
        return this.draw();
      }
    };

    Rotator.prototype.screen_pt = function(e) {
      var p;
      p = this.view.svg.node.createSVGPoint();
      p.x = e.clientX;
      p.y = e.clientY;
      p.matrixTransform(this.view.svg.node.getScreenCTM().inverse());
      return new Point(p.x, p.y);
    };

    return Rotator;

  })();


  /*
  Hole Specific Code
   */

  HolePoint = (function() {
    HolePoint.free = 0;

    function HolePoint(flat, fold) {
      this.flat = flat;
      this.fold = fold;
      this.id = HolePoint.free++;
    }

    HolePoint.prototype.expansive = function(p) {
      return this.fold.dist_sq(p.fold) - this.flat.dist_sq(p.flat) > 10 * EPS;
    };

    HolePoint.prototype.contractive = function(p) {
      return this.flat.dist_sq(p.flat) - this.fold.dist_sq(p.fold) > 10 * EPS;
    };

    HolePoint.prototype.critical = function(p) {
      return Math.abs(this.flat.dist_sq(p.flat) - this.fold.dist_sq(p.fold) < 10 * EPS);
    };

    HolePoint.prototype.add = function(p) {
      return new HolePoint(this.flat.add(p.flat), this.fold.add(p.fold));
    };

    HolePoint.prototype.mul = function(s) {
      return new HolePoint(this.flat.mul(s), this.fold.mul(s));
    };

    HolePoint.prototype.sub = function(p) {
      return this.add(p.mul(-1));
    };

    return HolePoint;

  })();

  Hole = (function(superClass) {
    var CHOICE_N;

    extend(Hole, superClass);

    CHOICE_N = [60, 20, 20];

    function Hole(points) {
      this.points = points;
      Hole.__super__.constructor.call(this, this.points);
      this.selected = null;
      this.space = null;
      this.choice_mode = 0;
      this.choice_idx = [0, 0, 0];
    }

    Hole.prototype.select_next = function() {
      if (this.selected != null) {
        this.selected = this.selected.next_child();
        return this.generate_choices();
      }
    };

    Hole.prototype.select_prev = function() {
      if (this.selected != null) {
        this.selected = this.selected.prev_child();
        return this.generate_choices();
      }
    };

    Hole.prototype.select_neighbor = function() {
      if ((this.selected != null) && (this.selected.neighbor(this.selected.head) != null)) {
        this.selected = this.selected.neighbor(this.selected.head);
        return this.generate_choices();
      }
    };

    Hole.prototype.visible = function(p, q) {
      var v;
      return Point.visible((function() {
        var k, len, ref, results;
        ref = this.points;
        results = [];
        for (k = 0, len = ref.length; k < len; k++) {
          v = ref[k];
          results.push(v.flat);
        }
        return results;
      }).call(this), this.idx(p), q.flat, new Point(0, 0, 1));
    };

    Hole.prototype.has_visible_vertex = function(p) {
      var q;
      return ((function() {
        var k, len, ref, results;
        ref = this.points;
        results = [];
        for (k = 0, len = ref.length; k < len; k++) {
          q = ref[k];
          if (this.visible(p, q)) {
            results.push(q);
          }
        }
        return results;
      }).call(this)).length > 0;
    };

    Hole.prototype.is_contractive = function(p) {
      return this.prev(p).contractive(this.next(p));
    };

    Hole.prototype.flat_angle = function(p) {
      return Math.abs(p.flat.angle(this.prev(p).flat, this.next(p).flat) - (p.flat.turns_right(this.prev(p).flat, this.next(p).flat) ? 0 : 2 * Math.PI));
    };

    Hole.prototype.fold_angle = function(p) {
      return p.fold.angle(this.prev(p).fold, this.next(p).fold);
    };

    Hole.prototype.choice = function() {
      if (this.space != null) {
        if (this.space[0].length != null) {
          return this.space[this.choice_idx[0]][this.choice_idx[1]][this.choice_idx[2]];
        } else {
          return this.space[this.choice_idx[0]];
        }
      }
    };

    Hole.prototype.toggle_choice_mode = function() {
      return this.choice_mode = (this.choice_mode + 1) % 3;
    };

    Hole.prototype.choose_next = function() {
      var n;
      if (this.space != null) {
        n = (this.space[0].length != null ? CHOICE_N[this.choice_mode] : this.space.length);
        i = (this.space[0].length != null ? this.choice_mode : 0);
        return this.choice_idx[i] = (this.choice_idx[i] + 1) % n;
      }
    };

    Hole.prototype.choose_prev = function() {
      var n;
      if (this.space != null) {
        n = (this.space[0].length != null ? CHOICE_N[this.choice_mode] : this.space.length);
        i = (this.space[0].length != null ? this.choice_mode : 0);
        return this.choice_idx[i] = (this.choice_idx[i] + n - 1) % n;
      }
    };

    Hole.prototype.choose_random = function() {
      if (this.space != null) {
        if (this.space[0].length != null) {
          return this.choice_idx = [Math.floor(Math.random() * CHOICE_N[0]), 0, 0];
        } else {
          return this.choice_idx[0] = Math.floor(Math.random() * this.space.length);
        }
      }
    };

    Hole.prototype.get_critical = function(p) {
      var k, len, q, ref, results;
      ref = this.points;
      results = [];
      for (k = 0, len = ref.length; k < len; k++) {
        q = ref[k];
        if (this.visible(p, q) && p.critical(q)) {
          results.push(q);
        }
      }
      return results;
    };

    Hole.prototype.get_visible = function(p) {
      var k, len, q, ref, results;
      ref = this.points;
      results = [];
      for (k = 0, len = ref.length; k < len; k++) {
        q = ref[k];
        if (this.visible(p, q)) {
          results.push(q);
        }
      }
      return results;
    };

    Hole.prototype.direction_from_angle = function(p, a, up) {
      var ang_flat, ang_fold, b1, b2, q2, q3, u, v, x, y, z, zmag;
      ang_flat = this.flat_angle(p);
      ang_fold = this.fold_angle(p);
      if (Math.abs(a - ang_flat / 2) <= ang_fold) {
        b1 = Math.cos(a) + Math.cos(ang_flat - a);
        b2 = Math.cos(a) - Math.cos(ang_flat - a);
        u = this.prev(p).fold.sub(p.fold).dir();
        v = this.next(p).fold.sub(p.fold).dir();
        x = u.add(v);
        y = u.sub(v);
        z = x.cross(y).dir();
        x = x.mul(b1 / x.mag_sq());
        y = y.mul(b2 / y.mag_sq());
        zmag = Math.sqrt(1 - x.mag_sq() - y.mag_sq());
        z = z.mul(up * (zmag > 0 ? zmag : 0));
        q3 = x.add(y).add(z);
        q2 = this.prev(p).flat.sub(p.flat).dir().rotate(new Point(0, 0, 1), a);
        return new HolePoint(new Point(q2.x, q2.y), new Point(q3.x, q3.y, q3.z));
      }
    };

    Hole.prototype.get_directions = function(p, n) {
      var a, ang_flat, ang_fold, angles, normal, q1, q2, u, v;
      ang_flat = this.flat_angle(p);
      ang_fold = this.fold_angle(p);
      if (ang_fold > EPS) {
        n = n / 2;
        angles = (function() {
          var k, ref, results;
          results = [];
          for (i = k = 0, ref = n; 0 <= ref ? k <= ref : k >= ref; i = 0 <= ref ? ++k : --k) {
            results.push(i / n * ang_fold + (ang_flat - ang_fold) / 2);
          }
          return results;
        })();
        q1 = (function() {
          var k, len, ref, results;
          ref = angles.slice(0, n);
          results = [];
          for (k = 0, len = ref.length; k < len; k++) {
            a = ref[k];
            results.push(this.direction_from_angle(p, a, 1));
          }
          return results;
        }).call(this);
        q2 = (function() {
          var k, ref, results;
          ref = angles.slice(1, +n + 1 || 9e9);
          results = [];
          for (k = ref.length - 1; k >= 0; k += -1) {
            a = ref[k];
            results.push(this.direction_from_angle(p, a, -1));
          }
          return results;
        }).call(this);
        return q1.concat(q2);
      }
      u = this.prev(p).sub(p).flat.rotate(new Point(0, 0, 1), ang_flat / 2).dir();
      v = this.next(p).sub(p).fold.dir();
      normal = p.fold.local_normal(this.prev(p).fold, this.next(p).fold);
      return (function() {
        var k, ref, results;
        results = [];
        for (i = k = 0, ref = n; 0 <= ref ? k < ref : k > ref; i = 0 <= ref ? ++k : --k) {
          results.push(new HolePoint(u, v.rotate(normal, ang_flat / 2).rotate(v, i / n * 2 * Math.PI)));
        }
        return results;
      })();
    };

    Hole.prototype.get_space = function(p, arg, n) {
      var angle, d, flat_normal, fold_normal, ispace, k, len, results, x;
      d = arg[0], x = arg[1];
      angle = p.flat.angle(d.flat, this.next(p).flat);
      ispace = (function() {
        var k, ref, results;
        results = [];
        for (i = k = 0, ref = n; 0 <= ref ? k < ref : k > ref; i = 0 <= ref ? ++k : --k) {
          results.push(angle * i / n);
        }
        return results;
      })();
      flat_normal = new Point(0, 0, 1);
      fold_normal = Point.normal([d.fold, this.next(p).fold, p.fold]);
      d = d.sub(p);
      results = [];
      for (k = 0, len = ispace.length; k < len; k++) {
        i = ispace[k];
        results.push(new HolePoint(d.flat.rotate(flat_normal, i), d.fold.rotate(fold_normal, i)));
      }
      return results;
    };

    Hole.prototype.split_from_direction = function(p, u) {
      var denom, k, len, mag, min, q, ref, v, vf, x;
      min = null;
      x = null;
      ref = this.points;
      for (k = 0, len = ref.length; k < len; k++) {
        q = ref[k];
        v = q.flat.sub(p.flat);
        vf = q.fold.sub(p.fold);
        denom = u.flat.dot(v) - u.fold.dot(vf);
        if (Math.abs(denom) > EPS) {
          mag = (v.mag_sq() - vf.mag_sq()) / 2 / denom;
          if (((min == null) || min > mag) && this.visible(q, u.mul(mag).add(p))) {
            min = mag;
            x = q;
          }
        }
      }
      return [u.mul(min).add(p), x];
    };

    Hole.prototype.generate_choices = function() {
      var c, choices, cs, extreme, n, s, u, us, v;
      this.space = null;
      this.choice_idx = [0, 0, 0];
      if (this.selected != null) {
        s = this.selected;
        cs = s.get_critical(s.head);
        if (cs.length > 0) {
          this.space = cs;
        } else if (s.is_contractive(s.head)) {
          n = CHOICE_N[0];
          us = s.get_directions(s.head, n);
          choices = (function() {
            var k, len, results;
            results = [];
            for (k = 0, len = us.length; k < len; k++) {
              u = us[k];
              results.push(s.split_from_direction(s.head, u));
            }
            return results;
          })();
          n = CHOICE_N[1];
          us = (function() {
            var k, len, results;
            results = [];
            for (k = 0, len = choices.length; k < len; k++) {
              c = choices[k];
              results.push(s.get_space(s.head, c, n));
            }
            return results;
          })();
          extreme = (function() {
            var k, len, results;
            results = [];
            for (k = 0, len = us.length; k < len; k++) {
              u = us[k];
              results.push((function() {
                var len1, m, results1;
                results1 = [];
                for (m = 0, len1 = u.length; m < len1; m++) {
                  v = u[m];
                  results1.push(s.split_from_direction(s.head, v));
                }
                return results1;
              })());
            }
            return results;
          })();
          n = CHOICE_N[2];
          this.space = (function() {
            var k, len, results;
            results = [];
            for (k = 0, len = extreme.length; k < len; k++) {
              u = extreme[k];
              results.push((function() {
                var len1, m, results1;
                results1 = [];
                for (m = 0, len1 = u.length; m < len1; m++) {
                  v = u[m];
                  results1.push((function() {
                    var ref, results2, t;
                    results2 = [];
                    for (i = t = 0, ref = n; 0 <= ref ? t < ref : t > ref; i = 0 <= ref ? ++t : --t) {
                      results2.push([v[0].sub(s.head).mul(1 - i / n).add(s.head), (i === 0 ? v[1] : s.next(s.head))]);
                    }
                    return results2;
                  })());
                }
                return results1;
              })());
            }
            return results;
          })();
        }
      }
    };

    Hole.prototype.split_critical = function(p, q) {
      this.add_children(new Hole(this.points_between(p, q)), new Hole(this.points_between(q, p)));
      return this.left;
    };

    Hole.prototype.split_noncritical = function(p, arg) {
      var h1, h2, q, s;
      s = arg[0], q = arg[1];
      h1 = this.points_between(p, q).concat(s);
      h2 = this.points_between(q, p).concat(s);
      this.add_children(new Hole(h1), new Hole(h2));
      return this.left;
    };

    Hole.prototype.split_next = function() {
      if (this.selected != null) {
        if (this.selected.triangle() || this.selected.has_children()) {
          this.select_next();
        } else {
          if (this.space != null) {
            if (this.choice().length != null) {
              this.selected = this.selected.split_noncritical(this.selected.head, this.choice());
            } else {
              this.selected = this.selected.split_critical(this.selected.head, this.choice());
            }
          } else {
            this.selected.head_next();
          }
        }
        return this.generate_choices();
      }
    };

    Hole.prototype.fully_split_random = function() {
      var results;
      if (this.selected != null) {
        this.selected.remove_children();
        results = [];
        while (true) {
          this.choose_random();
          this.split_next();
          if (this.all_triangles()) {
            break;
          } else {
            results.push(void 0);
          }
        }
        return results;
      }
    };


    /*
    Obj Methods
     */

    Hole.prototype.get_index = function(os) {
      var index, k, len, o;
      index = {};
      for (i = k = 0, len = os.length; k < len; i = ++k) {
        o = os[i];
        if (index[o.id] == null) {
          index[o.id] = i;
        }
      }
      return index;
    };

    Hole.prototype.v_line = function(v) {
      return "v " + v.fold.x + " " + v.fold.y + " " + v.fold.z + "\n# vf " + v.flat.x + " " + v.flat.y + "\n";
    };

    Hole.prototype.f_line = function(f, vi, fi) {
      var id, k, left, len, line, parent, ref, right, v;
      line = (f.triangle() ? "f" : "# f");
      ref = f.points;
      for (k = 0, len = ref.length; k < len; k++) {
        v = ref[k];
        line += " " + (vi[v.id] + 1);
      }
      id = f.id;
      parent = (f.parent != null ? f.parent.id : f.id);
      left = (f.left != null ? f.left.id : f.id);
      right = (f.right != null ? f.right.id : f.id);
      line += "\n# fc " + fi[id] + " " + fi[parent] + " " + fi[left] + " " + fi[right] + "\n";
      return line;
    };

    Hole.prototype.obj_from_root = function() {
      var f, fi, fs, k, len, len1, m, obj, v, vi, vs;
      vs = this.points_in_descendents();
      fs = this.rooted_descendents();
      vi = this.get_index(vs);
      fi = this.get_index(fs);
      obj = "# This file was created by hole.coffee (c) Jason Ku 2015\n";
      for (k = 0, len = vs.length; k < len; k++) {
        v = vs[k];
        obj += this.v_line(v);
      }
      obj += "# " + vs.length + " vertices\n";
      obj += "# comment vf contains flat vertex location\n";
      for (m = 0, len1 = fs.length; m < len1; m++) {
        f = fs[m];
        obj += this.f_line(f, vi, fi);
      }
      obj += "# " + fs.length + " faces\n";
      obj += "# comment fc contains index/parent/left/right connections\n";
      return obj;
    };

    Hole.obj_err = function(vs, vfs, fs, fcs) {
      var f, k, len, len1, len2, m, t, v;
      if (vs.length !== vfs.length) {
        return "flat and fold vertices not all defined";
      } else if (fs.length !== fcs.length) {
        return "face connections not all defined";
      } else {
        for (i = k = 0, len = vs.length; k < len; i = ++k) {
          v = vs[i];
          if (v.length !== 3) {
            return "size of fold vertex " + i + " is not 3";
          }
        }
        for (i = m = 0, len1 = vfs.length; m < len1; i = ++m) {
          v = vfs[i];
          if (v.length !== 2) {
            return "size of flat vertex " + i + " is not 2";
          }
        }
        for (i = t = 0, len2 = fcs.length; t < len2; i = ++t) {
          f = fcs[i];
          if (f.length !== 4) {
            return "size of face connection " + i + " is not 4";
          }
        }
      }
    };

    Hole.root_from_obj = function(obj) {
      var aa, ab, c, err, f, fcs, fs, h, hs, hvs, k, l, left, len, len1, len2, len3, len4, len5, lines, ls, m, p, parent, ps, ref, ref1, ref2, right, t, v, vfs, vs, w;
      lines = obj.split("\n");
      for (i = k = 0, len = lines.length; k < len; i = ++k) {
        l = lines[i];
        if (l.startsWith('# f ')) {
          lines[i] = l.slice(2);
        }
      }
      ref = [[], [], [], []], vs = ref[0], vfs = ref[1], fs = ref[2], fcs = ref[3];
      for (m = 0, len1 = lines.length; m < len1; m++) {
        l = lines[m];
        if (l.startsWith('v ')) {
          vs.push(l.slice(2).split(' '));
        }
        if (l.startsWith('# vf ')) {
          vfs.push(l.slice(5).split(' '));
        }
        if (l.startsWith('f ')) {
          fs.push(l.slice(2).split(' '));
        }
        if (l.startsWith('# fc ')) {
          fcs.push(l.slice(5).split(' '));
        }
      }
      err = this.obj_err(vs, vfs, fs, fcs);
      if (err != null) {
        console.log("Obj Import Error: " + err);
        return;
      }
      ref1 = (function() {
        var len2, ref1, results, t;
        ref1 = [vs, vfs, fs, fcs];
        results = [];
        for (t = 0, len2 = ref1.length; t < len2; t++) {
          ls = ref1[t];
          results.push((function() {
            var len3, results1, w;
            results1 = [];
            for (w = 0, len3 = ls.length; w < len3; w++) {
              l = ls[w];
              results1.push((function() {
                var aa, len4, results2;
                results2 = [];
                for (aa = 0, len4 = l.length; aa < len4; aa++) {
                  c = l[aa];
                  results2.push(+c);
                }
                return results2;
              })());
            }
            return results1;
          })());
        }
        return results;
      })(), vs = ref1[0], vfs = ref1[1], fs = ref1[2], fcs = ref1[3];
      fs = (function() {
        var len2, results, t;
        results = [];
        for (t = 0, len2 = fs.length; t < len2; t++) {
          f = fs[t];
          results.push((function() {
            var len3, results1, w;
            results1 = [];
            for (w = 0, len3 = f.length; w < len3; w++) {
              i = f[w];
              results1.push(i - 1);
            }
            return results1;
          })());
        }
        return results;
      })();
      vs = (function() {
        var len2, results, t;
        results = [];
        for (t = 0, len2 = vs.length; t < len2; t++) {
          v = vs[t];
          results.push(new Point(v[0], v[1], v[2]));
        }
        return results;
      })();
      vfs = (function() {
        var len2, results, t;
        results = [];
        for (t = 0, len2 = vfs.length; t < len2; t++) {
          v = vfs[t];
          results.push(new Point(v[0], v[1]));
        }
        return results;
      })();
      hvs = (function() {
        var ref2, results, t;
        results = [];
        for (i = t = 0, ref2 = vs.length; 0 <= ref2 ? t < ref2 : t > ref2; i = 0 <= ref2 ? ++t : --t) {
          results.push(new HolePoint(vfs[i], vs[i]));
        }
        return results;
      })();
      hs = [];
      for (t = 0, len2 = fs.length; t < len2; t++) {
        f = fs[t];
        ps = (function() {
          var len3, results, w;
          results = [];
          for (w = 0, len3 = f.length; w < len3; w++) {
            i = f[w];
            results.push(hvs[i]);
          }
          return results;
        })();
        for (w = 0, len3 = ps.length; w < len3; w++) {
          p = ps[w];
          if (p == null) {
            return;
          }
        }
        hs.push(new Hole(ps));
      }
      for (aa = 0, len4 = fcs.length; aa < len4; aa++) {
        ref2 = fcs[aa], i = ref2[0], parent = ref2[1], left = ref2[2], right = ref2[3];
        if (left !== i) {
          hs[i].left = hs[left];
        }
        if (right !== i) {
          hs[i].right = hs[right];
        }
        if (parent !== i) {
          hs[i].parent = hs[parent];
        }
      }
      for (ab = 0, len5 = hs.length; ab < len5; ab++) {
        h = hs[ab];
        if (h.parent == null) {
          return h;
        }
      }
    };

    return Hole;

  })(Face);

  HoleView = (function(superClass) {
    extend(HoleView, superClass);

    function HoleView(id1) {
      this.id = id1;
      HoleView.__super__.constructor.call(this, this.id);
      this.show_text = false;
      this.show_visible = false;
      this.show_choice = false;
      this.show_aux = false;
      this.show_space = false;
    }

    HoleView.prototype.toggle_aux = function() {
      if (this.show_visible) {
        if (!this.show_choice) {
          return this.show_choice = true;
        } else if (!this.show_aux) {
          return this.show_aux = true;
        } else if (!this.show_space) {
          return this.show_space = true;
        } else {
          this.show_choice = false;
          this.show_aux = false;
          return this.show_space = false;
        }
      }
    };

    HoleView.prototype.toggle_visible = function() {
      if (this.show_visible) {
        this.show_choice = false;
        this.show_visible = false;
        this.show_aux = false;
        return this.show_space = false;
      } else {
        return this.show_visible = true;
      }
    };

    HoleView.prototype.scale_root = function(r) {
      var p;
      return this.scale_points((function() {
        var k, len, ref, results;
        ref = r.points_in_descendents();
        results = [];
        for (k = 0, len = ref.length; k < len; k++) {
          p = ref[k];
          results.push(p[this.id]);
        }
        return results;
      }).call(this));
    };

    HoleView.prototype.draw_hole_point = function(p, s) {
      if (p === s.head && this.show_visible) {
        return this.draw_point(p[this.id]).fill(YELLOW).stroke({
          color: RED,
          linecap: 'round',
          width: 0.4
        });
      } else if (p === s.choice() && this.show_choice) {
        return this.draw_point(s.choice()[this.id]).fill(YELLOW).stroke({
          color: BLUE,
          linecap: 'round',
          width: 0.4
        });
      } else {
        return this.draw_point(p[this.id]).fill({
          color: RED,
          opacity: 0.7
        }).stroke('none');
      }
    };

    HoleView.prototype.draw_hole_point_label = function(p, label) {
      return this.draw_point_text(p[this.id], "" + label).fill(RED).font({
        size: '3',
        anchor: 'end'
      });
    };

    HoleView.prototype.draw_hole_fill = function(h, s) {
      var p;
      if (h.triangle() && ((h !== s) || !this.show_visible)) {
        return this.draw_polygon((function() {
          var k, len, ref, results;
          ref = h.points;
          results = [];
          for (k = 0, len = ref.length; k < len; k++) {
            p = ref[k];
            results.push(p[this.id]);
          }
          return results;
        }).call(this)).fill({
          color: BLUE,
          opacity: 0.3
        }).stroke('none');
      } else if (this.show_visible && (h === s) && ((this.id === 'flat') || h.triangle())) {
        return this.draw_polygon((function() {
          var k, len, ref, results;
          ref = h.points;
          results = [];
          for (k = 0, len = ref.length; k < len; k++) {
            p = ref[k];
            results.push(p[this.id]);
          }
          return results;
        }).call(this)).fill({
          color: YELLOW,
          opacity: 0.5
        }).stroke('none');
      }
    };

    HoleView.prototype.draw_hole_label = function(h, label) {
      var c, p;
      if (h.triangle()) {
        c = Point.centroid((function() {
          var k, len, ref, results;
          ref = h.points;
          results = [];
          for (k = 0, len = ref.length; k < len; k++) {
            p = ref[k];
            results.push(p[this.id]);
          }
          return results;
        }).call(this));
        this.draw_point(c).fill(BLUE).stroke('none');
        return this.draw_point_text(c, "" + label).fill(BLUE).font({
          size: 3,
          anchor: 'end'
        });
      }
    };

    HoleView.prototype.draw_hole_stroke = function(h) {
      var p;
      return this.draw_polygon((function() {
        var k, len, ref, results;
        ref = h.points;
        results = [];
        for (k = 0, len = ref.length; k < len; k++) {
          p = ref[k];
          results.push(p[this.id]);
        }
        return results;
      }).call(this)).fill('none').stroke({
        color: BLACK,
        linecap: 'round',
        width: 0.2,
        opacity: 0.3
      });
    };

    HoleView.prototype.draw_selected_edge = function(s) {
      var p, q;
      p = s.head;
      q = s.next(p);
      return this.draw_polyline([p[this.id], q[this.id]]).fill('none').stroke({
        color: RED,
        linecap: 'round',
        width: 0.5
      });
    };

    HoleView.prototype.draw_visible_paths = function(s) {
      var k, len, q, qs, results;
      if (this.id === 'flat') {
        qs = s.get_visible(s.head);
        results = [];
        for (k = 0, len = qs.length; k < len; k++) {
          q = qs[k];
          results.push(this.draw_polyline([s.head[this.id], q[this.id]]).fill('none').stroke({
            color: GREEN,
            linecap: 'round',
            width: 0.2,
            opacity: 0.7
          }));
        }
        return results;
      }
    };

    HoleView.prototype.draw_critical_paths = function(r) {
      var k, len, p, ref, results;
      if ((r.space != null) && (r.choice().length == null)) {
        ref = r.space;
        results = [];
        for (k = 0, len = ref.length; k < len; k++) {
          p = ref[k];
          if (p !== r.choice()) {
            results.push(this.draw_polyline([r.selected.head[this.id], p[this.id]]).fill('none').stroke({
              color: BLUE,
              linecap: 'round',
              width: 0.2,
              opacity: 0.7
            }));
          }
        }
        return results;
      }
    };

    HoleView.prototype.draw_directions = function(r) {
      var c, k, len, p, ps, ref, s, sp, tail, x;
      if ((r.space != null) && (r.choice().length != null)) {
        tail = [r.selected.next(r.selected.head), r.selected.head];
        if (this.show_space) {
          ref = r.space;
          for (i = k = 0, len = ref.length; k < len; i = ++k) {
            sp = ref[i];
            ps = ((function() {
              var len1, m, ref1, ref2, results;
              ref1 = (function() {
                var len1, results1, t;
                results1 = [];
                for (t = 0, len1 = sp.length; t < len1; t++) {
                  p = sp[t];
                  results1.push(p[0]);
                }
                return results1;
              })();
              results = [];
              for (m = 0, len1 = ref1.length; m < len1; m++) {
                ref2 = ref1[m], s = ref2[0], x = ref2[1];
                results.push(s);
              }
              return results;
            })()).concat(tail);
            this.draw_polygon((function() {
              var len1, m, results;
              results = [];
              for (m = 0, len1 = ps.length; m < len1; m++) {
                s = ps[m];
                results.push(s[this.id]);
              }
              return results;
            }).call(this)).fill('none').stroke({
              color: BLACK,
              linecap: 'round',
              width: 0.2,
              opacity: 0.1
            });
          }
        }
        this.draw_polygon((function() {
          var len1, m, ref1, ref2, results;
          ref1 = (function() {
            var len1, ref1, results1, t;
            ref1 = r.space;
            results1 = [];
            for (t = 0, len1 = ref1.length; t < len1; t++) {
              c = ref1[t];
              results1.push(c[0][0]);
            }
            return results1;
          })();
          results = [];
          for (m = 0, len1 = ref1.length; m < len1; m++) {
            ref2 = ref1[m], s = ref2[0], x = ref2[1];
            results.push(s[this.id]);
          }
          return results;
        }).call(this)).fill('none').stroke({
          color: (r.choice_mode === 0 ? RED : BLUE),
          linecap: 'round',
          width: 0.3,
          opacity: 0.7
        });
        ps = ((function() {
          var len1, m, ref1, ref2, results;
          ref1 = (function() {
            var len1, ref1, results1, t;
            ref1 = r.space[r.choice_idx[0]];
            results1 = [];
            for (t = 0, len1 = ref1.length; t < len1; t++) {
              c = ref1[t];
              results1.push(c[0]);
            }
            return results1;
          })();
          results = [];
          for (m = 0, len1 = ref1.length; m < len1; m++) {
            ref2 = ref1[m], s = ref2[0], x = ref2[1];
            results.push(s);
          }
          return results;
        })()).concat(tail);
        ps.pop();
        this.draw_polyline((function() {
          var len1, m, results;
          results = [];
          for (m = 0, len1 = ps.length; m < len1; m++) {
            s = ps[m];
            results.push(s[this.id]);
          }
          return results;
        }).call(this)).fill('none').stroke({
          color: (r.choice_mode === 1 ? RED : BLUE),
          linecap: 'round',
          width: 0.3,
          opacity: 0.7
        });
        return this.draw_polygon((function() {
          var len1, m, ref1, results;
          ref1 = [r.space[r.choice_idx[0]][r.choice_idx[1]][0][0], r.selected.head];
          results = [];
          for (m = 0, len1 = ref1.length; m < len1; m++) {
            s = ref1[m];
            results.push(s[this.id]);
          }
          return results;
        }).call(this)).fill('none').stroke({
          color: (r.choice_mode === 2 ? RED : BLUE),
          linecap: 'round',
          width: 0.3,
          opacity: 0.7
        });
      }
    };

    HoleView.prototype.draw_choice = function(r) {
      var p, ps;
      if (r.space != null) {
        ps = [r.selected.head, r.choice()];
        if (r.choice().length != null) {
          ps = [r.selected.head].concat(r.choice()[0]);
          this.draw_polygon((function() {
            var k, len, ref, results;
            ref = ps.concat(r.selected.next(r.selected.head));
            results = [];
            for (k = 0, len = ref.length; k < len; k++) {
              p = ref[k];
              results.push(p[this.id]);
            }
            return results;
          }).call(this)).fill({
            color: RED,
            opacity: 0.5
          }).stroke('none');
          if (r.choice_idx[1] === 0) {
            this.draw_polygon((function() {
              var k, len, ref, results;
              ref = ps.concat(r.selected.prev(r.selected.head));
              results = [];
              for (k = 0, len = ref.length; k < len; k++) {
                p = ref[k];
                results.push(p[this.id]);
              }
              return results;
            }).call(this)).fill({
              color: RED,
              opacity: 0.5
            }).stroke('none');
          }
        }
        this.draw_polyline((function() {
          var k, len, results;
          results = [];
          for (k = 0, len = ps.length; k < len; k++) {
            p = ps[k];
            results.push(p[this.id]);
          }
          return results;
        }).call(this)).fill('none').stroke({
          color: BLUE,
          linecap: 'round',
          width: 0.5,
          opacity: 1
        });
        if (r.choice().length != null) {
          if (r.choice_idx[2] === 0) {
            this.draw_polyline((function() {
              var k, len, ref, results;
              ref = r.choice();
              results = [];
              for (k = 0, len = ref.length; k < len; k++) {
                p = ref[k];
                results.push(p[this.id]);
              }
              return results;
            }).call(this)).fill('none').stroke({
              color: BLUE,
              linecap: 'round',
              width: 0.3,
              opacity: 1
            });
          }
          return this.draw_point(r.choice()[0][this.id]).fill(YELLOW).stroke({
            color: BLUE,
            linecap: 'round',
            width: 0.4
          });
        }
      }
    };

    HoleView.prototype.draw_root = function(r) {
      var aa, h, holes, k, len, len1, len2, len3, len4, m, p, ps, results, s, t, w;
      this.clear();
      this.scale_root(r);
      holes = r.leaves();
      s = r.selected;
      for (k = 0, len = holes.length; k < len; k++) {
        h = holes[k];
        this.draw_hole_fill(h, s);
      }
      for (m = 0, len1 = holes.length; m < len1; m++) {
        h = holes[m];
        this.draw_hole_stroke(h);
      }
      if (this.show_visible) {
        this.draw_visible_paths(s);
      }
      if (this.show_aux) {
        this.draw_critical_paths(r);
        this.draw_directions(r);
      }
      if (this.show_choice) {
        this.draw_choice(r);
      }
      if (this.show_visible) {
        this.draw_selected_edge(s);
      }
      ps = r.points_in_descendents();
      for (t = 0, len2 = ps.length; t < len2; t++) {
        p = ps[t];
        this.draw_hole_point(p, s);
      }
      if (this.show_text) {
        for (i = w = 0, len3 = ps.length; w < len3; i = ++w) {
          p = ps[i];
          this.draw_hole_point_label(p, i);
        }
        results = [];
        for (i = aa = 0, len4 = holes.length; aa < len4; i = ++aa) {
          h = holes[i];
          results.push(this.draw_hole_label(h, i));
        }
        return results;
      }
    };

    return HoleView;

  })(View);

  AppHandler = (function() {
    function AppHandler() {
      var cs, h, k;
      this.root_idx = 0;
      this.roots = [];
      for (k = INPUT.length - 1; k >= 0; k += -1) {
        h = INPUT[k];
        this.add_root(new Hole((function() {
          var len, m, ref, results;
          ref = h.vertices;
          results = [];
          for (m = 0, len = ref.length; m < len; m++) {
            cs = ref[m];
            results.push(new HolePoint(new Point(cs[0], cs[1]), new Point(cs[2], cs[3], cs[4])));
          }
          return results;
        })()));
      }
      this.view2D = new HoleView('flat');
      this.view3D = new HoleView('fold');
      this.rotator = new Rotator(this.view3D, (function(_this) {
        return function() {
          return _this.view3D.draw_root(_this.root());
        };
      })(this));
      this.draw();
      this.console_dump();
      $("#KEY_H").click((function(_this) {
        return function(e) {
          return _this.rotator.increment_yaw();
        };
      })(this));
      $("#KEY_J").click((function(_this) {
        return function(e) {
          return _this.rotator.decrement_pitch();
        };
      })(this));
      $("#KEY_K").click((function(_this) {
        return function(e) {
          return _this.rotator.increment_pitch();
        };
      })(this));
      $("#KEY_L").click((function(_this) {
        return function(e) {
          return _this.rotator.decrement_yaw();
        };
      })(this));
      $("#create").click((function(_this) {
        return function(e) {
          return _this.write_obj();
        };
      })(this));
      $("#input").change((function(_this) {
        return function(e) {
          return _this.read_obj(e);
        };
      })(this));
      $("#TAB").click((function(_this) {
        return function(e) {
          return _this.root_next();
        };
      })(this));
      $("#TILDE").click((function(_this) {
        return function(e) {
          return _this.root_prev();
        };
      })(this));
      $("#RIGHT").click((function(_this) {
        return function(e) {
          return _this.head_next();
        };
      })(this));
      $("#LEFT").click((function(_this) {
        return function(e) {
          return _this.head_prev();
        };
      })(this));
      $("#PERIOD").click((function(_this) {
        return function(e) {
          return _this.choose_next();
        };
      })(this));
      $("#COMMA").click((function(_this) {
        return function(e) {
          return _this.choose_prev();
        };
      })(this));
      $("#UP").click((function(_this) {
        return function(e) {
          return _this.hole_next();
        };
      })(this));
      $("#DOWN").click((function(_this) {
        return function(e) {
          return _this.hole_prev();
        };
      })(this));
      $("#KEY_A").click((function(_this) {
        return function(e) {
          return _this.toggle_visible();
        };
      })(this));
      $("#KEY_C").click((function(_this) {
        return function(e) {
          return _this.toggle_choice();
        };
      })(this));
      $("#KEY_N").click((function(_this) {
        return function(e) {
          return _this.hole_neighbor();
        };
      })(this));
      $("#KEY_T").click((function(_this) {
        return function(e) {
          return _this.toggle_text();
        };
      })(this));
      $("#KEY_S").click((function(_this) {
        return function(e) {
          return _this.toggle_aux();
        };
      })(this));
      $("#RETURN").click((function(_this) {
        return function(e) {
          return _this.split_next();
        };
      })(this));
      $("#DELETE").click((function(_this) {
        return function(e) {
          return _this.delete_selected();
        };
      })(this));
      $("#SPACE").click((function(_this) {
        return function(e) {
          return _this.clear_or_full_random();
        };
      })(this));
      $(document).on('keydown', (function(_this) {
        return function(e) {
          if ([TAB, TILDE, RIGHT, LEFT, UP, DOWN, RETURN, DELETE, SPACE, KEY_A, KEY_C, KEY_H, KEY_J, KEY_K, KEY_L, KEY_S, KEY_T, KEY_N, PERIOD, COMMA].indexOf(e.which) !== -1) {
            e.preventDefault();
          }
          switch (e.which) {
            case TAB:
              return _this.root_next();
            case TILDE:
              return _this.root_prev();
            case RIGHT:
              return _this.head_next();
            case LEFT:
              return _this.head_prev();
            case PERIOD:
              return _this.choose_next();
            case COMMA:
              return _this.choose_prev();
            case UP:
              return _this.hole_next();
            case DOWN:
              return _this.hole_prev();
            case KEY_A:
              return _this.toggle_visible();
            case KEY_C:
              return _this.toggle_choice();
            case KEY_H:
              return _this.rotator.increment_yaw();
            case KEY_J:
              return _this.rotator.decrement_pitch();
            case KEY_K:
              return _this.rotator.increment_pitch();
            case KEY_L:
              return _this.rotator.decrement_yaw();
            case KEY_N:
              return _this.hole_neighbor();
            case KEY_T:
              return _this.toggle_text();
            case KEY_S:
              return _this.toggle_aux();
            case RETURN:
              return _this.split_next();
            case DELETE:
              return _this.delete_selected();
            case SPACE:
              return _this.clear_or_full_random();
          }
        };
      })(this));
    }

    AppHandler.prototype.root = function() {
      return this.roots[this.root_idx];
    };

    AppHandler.prototype.selected = function() {
      return this.root().selected;
    };

    AppHandler.prototype.add_root = function(r) {
      this.roots.push(r);
      this.root_idx = this.roots.length - 1;
      this.root().selected = this.root().next_child();
      this.root().generate_choices();
      Face.connect_faces(this.root().leaves());
      return this.write_slide_text();
    };

    AppHandler.prototype.draw = function() {
      this.view2D.draw_root(this.root());
      return this.view3D.draw_root(this.root());
    };

    AppHandler.prototype.choose_next = function() {
      this.root().choose_next();
      return this.draw();
    };

    AppHandler.prototype.choose_prev = function() {
      this.root().choose_prev();
      return this.draw();
    };

    AppHandler.prototype.hole_next = function() {
      this.root().select_next();
      return this.draw();
    };

    AppHandler.prototype.hole_prev = function() {
      this.root().select_prev();
      return this.draw();
    };

    AppHandler.prototype.hole_neighbor = function() {
      this.root().select_neighbor();
      return this.draw();
    };

    AppHandler.prototype.root_next = function() {
      this.root_idx = (this.root_idx + 1) % this.roots.length;
      this.write_slide_text();
      return this.draw();
    };

    AppHandler.prototype.root_prev = function() {
      this.root_idx = (this.root_idx + this.roots.length - 1) % this.roots.length;
      this.write_slide_text();
      return this.draw();
    };

    AppHandler.prototype.head_next = function() {
      this.selected().head_next();
      this.root().generate_choices();
      return this.draw();
    };

    AppHandler.prototype.head_prev = function() {
      this.selected().head_prev();
      this.root().generate_choices();
      return this.draw();
    };

    AppHandler.prototype.toggle_choice = function() {
      this.root().toggle_choice_mode();
      return this.draw();
    };

    AppHandler.prototype.toggle_text = function() {
      var k, len, ref, v;
      ref = [this.view2D, this.view3D];
      for (k = 0, len = ref.length; k < len; k++) {
        v = ref[k];
        v.show_text = !v.show_text;
      }
      return this.draw();
    };

    AppHandler.prototype.toggle_aux = function() {
      var k, len, ref, v;
      ref = [this.view2D, this.view3D];
      for (k = 0, len = ref.length; k < len; k++) {
        v = ref[k];
        v.toggle_aux();
      }
      return this.draw();
    };

    AppHandler.prototype.toggle_visible = function() {
      var k, len, ref, v;
      ref = [this.view2D, this.view3D];
      for (k = 0, len = ref.length; k < len; k++) {
        v = ref[k];
        v.toggle_visible();
      }
      return this.draw();
    };

    AppHandler.prototype.write_slide_text = function() {};

    AppHandler.prototype.console_dump = function() {
      return console.log(this);
    };

    AppHandler.prototype.split_next = function() {
      this.root().split_next();
      Face.connect_faces(this.root().leaves());
      this.draw();
      return this.console_dump();
    };

    AppHandler.prototype.delete_selected = function() {
      if (this.selected().parent != null) {
        this.root().selected = this.selected().parent;
        this.selected().remove_children();
        Face.connect_faces(this.root().leaves());
        this.root().generate_choices();
        this.draw();
        return this.console_dump();
      }
    };

    AppHandler.prototype.clear_or_full_random = function() {
      if (this.root().has_children()) {
        this.root().selected = this.root();
        this.selected().remove_children();
        this.root().generate_choices();
      } else {
        this.root().fully_split_random();
      }
      Face.connect_faces(this.root().leaves());
      this.draw();
      return this.console_dump();
    };

    AppHandler.prototype.write_obj = function() {
      var data;
      data = new Blob([this.root().obj_from_root()], {
        type: 'text/plain'
      });
      window.URL.revokeObjectURL($("#viewlink"));
      $("#viewlink").attr("href", window.URL.createObjectURL(data));
      return $("#viewlink").attr("style", {
        display: 'block'
      });
    };

    AppHandler.prototype.read_obj = function(e) {
      var file_reader;
      file_reader = new FileReader();
      file_reader.onload = (function(_this) {
        return function(e) {
          var h;
          h = Hole.root_from_obj(e.target.result);
          if (h != null) {
            _this.add_root(h);
            _this.draw();
            return _this.console_dump();
          }
        };
      })(this);
      return file_reader.readAsText(e.target.files[0]);
    };

    return AppHandler;

  })();

  if (typeof window !== "undefined" && window !== null) {
    window.onload = function() {
      var app_handler;
      return app_handler = new AppHandler();
    };
  }

}).call(this);