closure 1.2.701 → 1.3.0

data/closure-library/closure/goog/math/bezier.js

@@ -1,244 +0,0 @@
-// Copyright 2007 The Closure Library Authors. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS-IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-
-/**
- * @fileoverview Represents a cubic Bezier curve.
- *
- * Uses the deCasteljau algorithm to compute points on the curve.
- * http://en.wikipedia.org/wiki/De_Casteljau's_algorithm
- *
- * Currently it uses an unrolled version of the algorithm for speed.  Eventually
- * it may be useful to use the loop form of the algorithm in order to support
- * curves of arbitrary degree.
- *
- * @author robbyw@google.com (Robby Walker)
- * @author wcrosby@google.com (Wayne Crosby)
- */
-
-goog.provide('goog.math.Bezier');
-
-goog.require('goog.math');
-goog.require('goog.math.Coordinate');
-
-
-
-/**
- * Object representing a cubic bezier curve.
- * @param {number} x0 X coordinate of the start point.
- * @param {number} y0 Y coordinate of the start point.
- * @param {number} x1 X coordinate of the first control point.
- * @param {number} y1 Y coordinate of the first control point.
- * @param {number} x2 X coordinate of the second control point.
- * @param {number} y2 Y coordinate of the second control point.
- * @param {number} x3 X coordinate of the end point.
- * @param {number} y3 Y coordinate of the end point.
- * @constructor
- */
-goog.math.Bezier = function(x0, y0, x1, y1, x2, y2, x3, y3) {
-  /**
-   * X coordinate of the first point.
-   * @type {number}
-   */
-  this.x0 = x0;
-
-  /**
-   * Y coordinate of the first point.
-   * @type {number}
-   */
-  this.y0 = y0;
-
-  /**
-   * X coordinate of the first control point.
-   * @type {number}
-   */
-  this.x1 = x1;
-
-  /**
-   * Y coordinate of the first control point.
-   * @type {number}
-   */
-  this.y1 = y1;
-
-  /**
-   * X coordinate of the second control point.
-   * @type {number}
-   */
-  this.x2 = x2;
-
-  /**
-   * Y coordinate of the second control point.
-   * @type {number}
-   */
-  this.y2 = y2;
-
-  /**
-   * X coordinate of the end point.
-   * @type {number}
-   */
-  this.x3 = x3;
-
-  /**
-   * Y coordinate of the end point.
-   * @type {number}
-   */
-  this.y3 = y3;
-};
-
-
-/**
- * Constant used to approximate ellipses.
- * See: http://canvaspaint.org/blog/2006/12/ellipse/
- * @type {number}
- */
-goog.math.Bezier.KAPPA = 4 * (Math.sqrt(2) - 1) / 3;
-
-
-/**
- * @return {!goog.math.Bezier} A copy of this curve.
- */
-goog.math.Bezier.prototype.clone = function() {
-  return new goog.math.Bezier(this.x0, this.y0, this.x1, this.y1, this.x2,
-      this.y2, this.x3, this.y3);
-};
-
-
-/**
- * Test if the given curve is exactly the same as this one.
- * @param {goog.math.Bezier} other The other curve.
- * @return {boolean} Whether the given curve is the same as this one.
- */
-goog.math.Bezier.prototype.equals = function(other) {
-  return this.x0 == other.x0 && this.y0 == other.y0 && this.x1 == other.x1 &&
-         this.y1 == other.y1 && this.x2 == other.x2 && this.y2 == other.y2 &&
-         this.x3 == other.x3 && this.y3 == other.y3;
-};
-
-
-/**
- * Modifies the curve in place to progress in the opposite direction.
- */
-goog.math.Bezier.prototype.flip = function() {
-  var temp = this.x0;
-  this.x0 = this.x3;
-  this.x3 = temp;
-  temp = this.y0;
-  this.y0 = this.y3;
-  this.y3 = temp;
-
-  temp = this.x1;
-  this.x1 = this.x2;
-  this.x2 = temp;
-  temp = this.y1;
-  this.y1 = this.y2;
-  this.y2 = temp;
-};
-
-
-/**
- * Computes the curve at a point between 0 and 1.
- * @param {number} t The point on the curve to find.
- * @return {!goog.math.Coordinate} The computed coordinate.
- */
-goog.math.Bezier.prototype.getPoint = function(t) {
-  // Special case start and end
-  if (t == 0) {
-    return new goog.math.Coordinate(this.x0, this.y0);
-  } else if (t == 1) {
-    return new goog.math.Coordinate(this.x3, this.y3);
-  }
-
-  // Step one - from 4 points to 3
-  var ix0 = goog.math.lerp(this.x0, this.x1, t);
-  var iy0 = goog.math.lerp(this.y0, this.y1, t);
-
-  var ix1 = goog.math.lerp(this.x1, this.x2, t);
-  var iy1 = goog.math.lerp(this.y1, this.y2, t);
-
-  var ix2 = goog.math.lerp(this.x2, this.x3, t);
-  var iy2 = goog.math.lerp(this.y2, this.y3, t);
-
-  // Step two - from 3 points to 2
-  ix0 = goog.math.lerp(ix0, ix1, t);
-  iy0 = goog.math.lerp(iy0, iy1, t);
-
-  ix1 = goog.math.lerp(ix1, ix2, t);
-  iy1 = goog.math.lerp(iy1, iy2, t);
-
-  // Final step - last point
-  return new goog.math.Coordinate(goog.math.lerp(ix0, ix1, t),
-      goog.math.lerp(iy0, iy1, t));
-};
-
-
-/**
- * Changes this curve in place to be the portion of itself from [t, 1].
- * @param {number} t The start of the desired portion of the curve.
- */
-goog.math.Bezier.prototype.subdivideLeft = function(t) {
-  if (t == 1) {
-    return;
-  }
-
-  // Step one - from 4 points to 3
-  var ix0 = goog.math.lerp(this.x0, this.x1, t);
-  var iy0 = goog.math.lerp(this.y0, this.y1, t);
-
-  var ix1 = goog.math.lerp(this.x1, this.x2, t);
-  var iy1 = goog.math.lerp(this.y1, this.y2, t);
-
-  var ix2 = goog.math.lerp(this.x2, this.x3, t);
-  var iy2 = goog.math.lerp(this.y2, this.y3, t);
-
-  // Collect our new x1 and y1
-  this.x1 = ix0;
-  this.y1 = iy0;
-
-  // Step two - from 3 points to 2
-  ix0 = goog.math.lerp(ix0, ix1, t);
-  iy0 = goog.math.lerp(iy0, iy1, t);
-
-  ix1 = goog.math.lerp(ix1, ix2, t);
-  iy1 = goog.math.lerp(iy1, iy2, t);
-
-  // Collect our new x2 and y2
-  this.x2 = ix0;
-  this.y2 = iy0;
-
-  // Final step - last point
-  this.x3 = goog.math.lerp(ix0, ix1, t);
-  this.y3 = goog.math.lerp(iy0, iy1, t);
-};
-
-
-/**
- * Changes this curve in place to be the portion of itself from [0, t].
- * @param {number} t The end of the desired portion of the curve.
- */
-goog.math.Bezier.prototype.subdivideRight = function(t) {
-  this.flip();
-  this.subdivideLeft(1 - t);
-  this.flip();
-};
-
-
-/**
- * Changes this curve in place to be the portion of itself from [s, t].
- * @param {number} s The start of the desired portion of the curve.
- * @param {number} t The end of the desired portion of the curve.
- */
-goog.math.Bezier.prototype.subdivide = function(s, t) {
-  this.subdivideRight(s);
-  this.subdivideLeft((t - s) / (1 - s));
-};

data/closure-library/closure/goog/math/bezier_test.html

@@ -1,70 +0,0 @@
-<!DOCTYPE html>
-<html>
-<!--
-Copyright 2007 The Closure Library Authors. All Rights Reserved.
-
-Use of this source code is governed by the Apache License, Version 2.0.
-See the COPYING file for details.
--->
-<head>
-<meta http-equiv="X-UA-Compatible" content="IE=edge">
-<title>Closure Unit Tests - goog.math.Bezier</title>
-<script src="../base.js"></script>
-<script>
-  goog.require('goog.math.Bezier');
-  goog.require('goog.testing.jsunit');
-</script>
-</head>
-<body>
-<script>
-
-  function testEquals() {
-    var input = new goog.math.Bezier(1, 2, 3, 4, 5, 6, 7, 8);
-
-    assert(input.equals(input));
-  }
-
-  function testClone() {
-    var input = new goog.math.Bezier(1, 2, 3, 4, 5, 6, 7, 8);
-
-    assertNotEquals('Clone returns a new object', input, input.clone())
-    assert('Contents of clone match original', input.equals(input.clone()));
-  }
-
-  function testFlip() {
-    var input = new goog.math.Bezier(1, 1, 2, 2, 3, 3, 4, 4);
-    var compare = new goog.math.Bezier(4, 4, 3, 3, 2, 2, 1, 1);
-
-    var flipped = input.clone();
-    flipped.flip();
-    assert('Flipped behaves as expected', compare.equals(flipped));
-
-    flipped.flip();
-    assert('Flipping twice gives original', input.equals(flipped));
-  }
-
-  function testGetPoint() {
-    var input = new goog.math.Bezier(0, 1, 1, 2, 2, 3, 3, 4);
-
-    assert(goog.math.Coordinate.equals(input.getPoint(0),
-        new goog.math.Coordinate(0, 1)));
-    assert(goog.math.Coordinate.equals(input.getPoint(1),
-        new goog.math.Coordinate(3, 4)));
-    assert(goog.math.Coordinate.equals(input.getPoint(0.5),
-        new goog.math.Coordinate(1.5, 2.5)));
-  }
-
-  function testSubdivide() {
-    var input = new goog.math.Bezier(0, 1, 1, 2, 2, 3, 3, 4);
-
-    input.subdivide(1/3, 2/3);
-
-    assert(goog.math.nearlyEquals(1, input.x0));
-    assert(goog.math.nearlyEquals(2, input.y0));
-    assert(goog.math.nearlyEquals(2, input.x3));
-    assert(goog.math.nearlyEquals(3, input.y3));    
-  }
-  
-</script>
-</body>
-</html>

data/closure-library/closure/goog/math/box.js

@@ -1,236 +0,0 @@
-// Copyright 2006 The Closure Library Authors. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS-IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-/**
- * @fileoverview A utility class for representing a numeric box.
- */
-
-
-goog.provide('goog.math.Box');
-
-goog.require('goog.math.Coordinate');
-
-
-
-/**
- * Class for representing a box. A box is specified as a top, right, bottom,
- * and left. A box is useful for representing margins and padding.
- *
- * @param {number} top Top.
- * @param {number} right Right.
- * @param {number} bottom Bottom.
- * @param {number} left Left.
- * @constructor
- */
-goog.math.Box = function(top, right, bottom, left) {
-  /**
-   * Top
-   * @type {number}
-   */
-  this.top = top;
-
-  /**
-   * Right
-   * @type {number}
-   */
-  this.right = right;
-
-  /**
-   * Bottom
-   * @type {number}
-   */
-  this.bottom = bottom;
-
-  /**
-   * Left
-   * @type {number}
-   */
-  this.left = left;
-};
-
-
-/**
- * Creates a Box by bounding a collection of goog.math.Coordinate objects
- * @param {...goog.math.Coordinate} var_args Coordinates to be included inside
- *     the box.
- * @return {!goog.math.Box} A Box containing all the specified Coordinates.
- */
-goog.math.Box.boundingBox = function(var_args) {
-  var box = new goog.math.Box(arguments[0].y, arguments[0].x,
-                              arguments[0].y, arguments[0].x);
-  for (var i = 1; i < arguments.length; i++) {
-    var coord = arguments[i];
-    box.top = Math.min(box.top, coord.y);
-    box.right = Math.max(box.right, coord.x);
-    box.bottom = Math.max(box.bottom, coord.y);
-    box.left = Math.min(box.left, coord.x);
-  }
-  return box;
-};
-
-
-/**
- * Creates a copy of the box with the same dimensions.
- * @return {!goog.math.Box} A clone of this Box.
- */
-goog.math.Box.prototype.clone = function() {
-  return new goog.math.Box(this.top, this.right, this.bottom, this.left);
-};
-
-
-if (goog.DEBUG) {
-  /**
-   * Returns a nice string representing the box.
-   * @return {string} In the form (50t, 73r, 24b, 13l).
-   */
-  goog.math.Box.prototype.toString = function() {
-    return '(' + this.top + 't, ' + this.right + 'r, ' + this.bottom + 'b, ' +
-           this.left + 'l)';
-  };
-}
-
-
-/**
- * Returns whether the box contains a coordinate or another box.
- *
- * @param {goog.math.Coordinate|goog.math.Box} other A Coordinate or a Box.
- * @return {boolean} Whether the box contains the coordinate or other box.
- */
-goog.math.Box.prototype.contains = function(other) {
-  return goog.math.Box.contains(this, other);
-};
-
-
-/**
- * Expands box with the given margins.
- *
- * @param {number|goog.math.Box} top Top margin or box with all margins.
- * @param {number=} opt_right Right margin.
- * @param {number=} opt_bottom Bottom margin.
- * @param {number=} opt_left Left margin.
- * @return {!goog.math.Box} A reference to this Box.
- */
-goog.math.Box.prototype.expand = function(top, opt_right, opt_bottom,
-    opt_left) {
-  if (goog.isObject(top)) {
-    this.top -= top.top;
-    this.right += top.right;
-    this.bottom += top.bottom;
-    this.left -= top.left;
-  } else {
-    this.top -= top;
-    this.right += opt_right;
-    this.bottom += opt_bottom;
-    this.left -= opt_left;
-  }
-
-  return this;
-};
-
-
-/**
- * Expand this box to include another box.
- * NOTE(user): This is used in code that needs to be very fast, please don't
- * add functionality to this function at the expense of speed (variable
- * arguments, accepting multiple argument types, etc).
- * @param {goog.math.Box} box The box to include in this one.
- */
-goog.math.Box.prototype.expandToInclude = function(box) {
-  this.left = Math.min(this.left, box.left);
-  this.top = Math.min(this.top, box.top);
-  this.right = Math.max(this.right, box.right);
-  this.bottom = Math.max(this.bottom, box.bottom);
-};
-
-
-/**
- * Compares boxes for equality.
- * @param {goog.math.Box} a A Box.
- * @param {goog.math.Box} b A Box.
- * @return {boolean} True iff the boxes are equal, or if both are null.
- */
-goog.math.Box.equals = function(a, b) {
-  if (a == b) {
-    return true;
-  }
-  if (!a || !b) {
-    return false;
-  }
-  return a.top == b.top && a.right == b.right &&
-         a.bottom == b.bottom && a.left == b.left;
-};
-
-
-/**
- * Returns whether a box contains a coordinate or another box.
- *
- * @param {goog.math.Box} box A Box.
- * @param {goog.math.Coordinate|goog.math.Box} other A Coordinate or a Box.
- * @return {boolean} Whether the box contains the coordinate or other box.
- */
-goog.math.Box.contains = function(box, other) {
-  if (!box || !other) {
-    return false;
-  }
-
-  if (other instanceof goog.math.Box) {
-    return other.left >= box.left && other.right <= box.right &&
-        other.top >= box.top && other.bottom <= box.bottom;
-  }
-
-  // other is a Coordinate.
-  return other.x >= box.left && other.x <= box.right &&
-         other.y >= box.top && other.y <= box.bottom;
-};
-
-
-/**
- * Returns the distance between a coordinate and the nearest corner/side of a
- * box. Returns zero if the coordinate is inside the box.
- *
- * @param {goog.math.Box} box A Box.
- * @param {goog.math.Coordinate} coord A Coordinate.
- * @return {number} The distance between {@code coord} and the nearest
- *     corner/side of {@code box}, or zero if {@code coord} is inside
- *     {@code box}.
- */
-goog.math.Box.distance = function(box, coord) {
-  if (coord.x >= box.left && coord.x <= box.right) {
-    if (coord.y >= box.top && coord.y <= box.bottom) {
-      return 0;
-    }
-    return coord.y < box.top ? box.top - coord.y : coord.y - box.bottom;
-  }
-
-  if (coord.y >= box.top && coord.y <= box.bottom) {
-    return coord.x < box.left ? box.left - coord.x : coord.x - box.right;
-  }
-
-  return goog.math.Coordinate.distance(coord,
-      new goog.math.Coordinate(coord.x < box.left ? box.left : box.right,
-                               coord.y < box.top ? box.top : box.bottom));
-};
-
-
-/**
- * Returns whether two boxes intersect.
- *
- * @param {goog.math.Box} a A Box.
- * @param {goog.math.Box} b A second Box.
- * @return {boolean} Whether the boxes intersect.
- */
-goog.math.Box.intersects = function(a, b) {
-  return (a.left <= b.right && b.left <= a.right &&
-          a.top <= b.bottom && b.top <= a.bottom);
-};

data/closure-library/closure/goog/math/box_test.html

@@ -1,139 +0,0 @@
-<!DOCTYPE html>
-<html>
-<!--
-Copyright 2006 The Closure Library Authors. All Rights Reserved.
-
-Use of this source code is governed by the Apache License, Version 2.0.
-See the COPYING file for details.
--->
-<head>
-<meta http-equiv="X-UA-Compatible" content="IE=edge">
-<title>Closure Unit Tests - goog.math.Box</title>
-<script src="../base.js"></script>
-<script>
-goog.require('goog.math.Box');
-goog.require('goog.math.Coordinate');
-goog.require('goog.testing.jsunit');
-</script>
-</head>
-<body>
-<script>
-
-function testBoxClone() {
-  var b = new goog.math.Box(0, 0, 0, 0);
-  assertTrue(goog.math.Box.equals(b, b.clone()));
-
-  b.left = 0;
-  b.top = 1;
-  b.right = 2;
-  b.bottom = 3;
-  assertTrue(goog.math.Box.equals(b, b.clone()));
-}
-
-function testBoxDistance() {
-  var box = new goog.math.Box(50, 100, 100, 50);
-
-  assertEquals(25,
-               goog.math.Box.distance(box, new goog.math.Coordinate(75, 25)));
-  assertEquals(10,
-               goog.math.Box.distance(box, new goog.math.Coordinate(40, 80)));
-  assertEquals(5,
-               goog.math.Box.distance(box, new goog.math.Coordinate(46, 47)));
-  assertEquals(10,
-               goog.math.Box.distance(box, new goog.math.Coordinate(106, 108)));
-}
-
-function testBoxContains() {
-  var box = new goog.math.Box(50, 100, 100, 50);
-
-  assertTrue(goog.math.Box.contains(box, new goog.math.Coordinate(75, 75)));
-  assertTrue(goog.math.Box.contains(box, new goog.math.Coordinate(50, 100)));
-  assertTrue(goog.math.Box.contains(box, new goog.math.Coordinate(100, 99)));
-  assertFalse(goog.math.Box.contains(box, new goog.math.Coordinate(100, 101)));
-  assertFalse(goog.math.Box.contains(box, new goog.math.Coordinate(49, 50)));
-  assertFalse(goog.math.Box.contains(box, new goog.math.Coordinate(25, 25)));
-}
-
-function testBoxContainsBox() {
-  var box = new goog.math.Box(50, 100, 100, 50);
-
-  function assertContains(boxB) {
-    assertTrue(box + ' expected to contain ' + boxB,
-        goog.math.Box.contains(box, boxB));
-  }
-
-  function assertNotContains(boxB) {
-    assertFalse(box + ' expected to not contain ' + boxB,
-        goog.math.Box.contains(box, boxB));
-  }
-
-  assertContains(new goog.math.Box(60, 90, 90, 60));
-  assertNotContains(new goog.math.Box(1, 3, 4, 2));
-  assertNotContains(new goog.math.Box(30, 90, 60, 60));
-  assertNotContains(new goog.math.Box(60, 110, 60, 60));
-  assertNotContains(new goog.math.Box(60, 90, 110, 60));
-  assertNotContains(new goog.math.Box(60, 90, 60, 40));
-}
-
-function testBoxesIntersect() {
-  var box = new goog.math.Box(50, 100, 100, 50);
-
-  function assertIntersects(boxB) {
-    assertTrue(box + ' expected to intersect ' + boxB,
-        goog.math.Box.intersects(box, boxB));
-  }
-  function assertNotIntersects(boxB) {
-    assertFalse(box + ' expected to not intersect ' + boxB,
-        goog.math.Box.intersects(box, boxB));
-  }
-
-  assertIntersects(box);
-  assertIntersects(new goog.math.Box(20, 80, 80, 20));
-  assertIntersects(new goog.math.Box(50, 80, 100, 20));
-  assertIntersects(new goog.math.Box(80, 80, 120, 20));
-  assertIntersects(new goog.math.Box(20, 100, 80, 50));
-  assertIntersects(new goog.math.Box(80, 100, 120, 50));
-  assertIntersects(new goog.math.Box(20, 120, 80, 80));
-  assertIntersects(new goog.math.Box(50, 120, 100, 80));
-  assertIntersects(new goog.math.Box(80, 120, 120, 80));
-  assertIntersects(new goog.math.Box(20, 120, 120, 20));
-  assertIntersects(new goog.math.Box(70, 80, 80, 70));
-  assertNotIntersects(new goog.math.Box(10, 30, 30, 10));
-  assertNotIntersects(new goog.math.Box(10, 70, 30, 30));
-  assertNotIntersects(new goog.math.Box(10, 100, 30, 50));
-  assertNotIntersects(new goog.math.Box(10, 120, 30, 80));
-  assertNotIntersects(new goog.math.Box(10, 140, 30, 120));
-  assertNotIntersects(new goog.math.Box(30, 30, 70, 10));
-  assertNotIntersects(new goog.math.Box(30, 140, 70, 120));
-  assertNotIntersects(new goog.math.Box(50, 30, 100, 10));
-  assertNotIntersects(new goog.math.Box(50, 140, 100, 120));
-  assertNotIntersects(new goog.math.Box(80, 30, 120, 10));
-  assertNotIntersects(new goog.math.Box(80, 140, 120, 120));
-  assertNotIntersects(new goog.math.Box(120, 30, 140, 10));
-  assertNotIntersects(new goog.math.Box(120, 70, 140, 30));
-  assertNotIntersects(new goog.math.Box(120, 100, 140, 50));
-  assertNotIntersects(new goog.math.Box(120, 120, 140, 80));
-  assertNotIntersects(new goog.math.Box(120, 140, 140, 120));
-}
-
-function testExpandToInclude() {
-  var box = new goog.math.Box(10, 50, 50, 10);
-  box.expandToInclude(new goog.math.Box(60, 70, 70, 60));
-  assertEquals(10, box.left);
-  assertEquals(10, box.top);
-  assertEquals(70, box.right);
-  assertEquals(70, box.bottom);
-  box.expandToInclude(new goog.math.Box(30, 40, 40, 30));
-  assertEquals(10, box.left);
-  assertEquals(10, box.top);
-  assertEquals(70, box.right);
-  assertEquals(70, box.bottom);
-  box.expandToInclude(new goog.math.Box(0, 100, 100, 0));
-  assertEquals(0, box.left);
-  assertEquals(0, box.top);
-  assertEquals(100, box.right);
-  assertEquals(100, box.bottom);
-}
-</script>
-</body>
-</html>