text: /**
   * Cesium - https://github.com/AnalyticalGraphicsInc/cesium
   *
   * Copyright 2011-2014 Cesium Contributors
   *
   * 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.
   *
   * Columbus View (Pat. Pend.)
   *
   * Portions licensed separately.
   * See https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md for full licensing details.
   */
  (function () {
  /*global define*/
  define('Core/defined',[],function() {
      "use strict";
  
      /**
       * Returns true if the object is defined, returns false otherwise.
       *
       * @exports defined
       *
       * @example
       * if (Cesium.defined(positions)) {
       *      doSomething();
       * } else {
       *      doSomethingElse();
       * }
       */
      var defined = function(value) {
          return value !== undefined;
      };
  
      return defined;
  });
  
  /*global define*/
  define('Core/freezeObject',[
          './defined'
      ], function(
          defined) {
      "use strict";
  
      /**
       * Freezes an object, using Object.freeze if available, otherwise returns
       * the object unchanged.  This function should be used in setup code to prevent
       * errors from completely halting JavaScript execution in legacy browsers.
       *
       * @private
       *
       * @exports freezeObject
       */
      var freezeObject = Object.freeze;
      if (!defined(freezeObject)) {
          freezeObject = function(o) {
              return o;
          };
      }
  
      return freezeObject;
  });
  /*global define*/
  define('Core/defaultValue',[
          './freezeObject'
      ], function(
          freezeObject) {
      "use strict";
  
      /**
       * Returns the first parameter if not undefined, otherwise the second parameter.
       * Useful for setting a default value for a parameter.
       *
       * @exports defaultValue
       *
       * @example
       * param = Cesium.defaultValue(param, 'default');
       */
      var defaultValue = function(a, b) {
          if (a !== undefined) {
              return a;
          }
          return b;
      };
  
      /**
       * A frozen empty object that can be used as the default value for options passed as
       * an object literal.
       */
      defaultValue.EMPTY_OBJECT = freezeObject({});
  
      return defaultValue;
  });
  /*global define*/
  define('Core/DeveloperError',[
          './defined'
      ], function(
          defined) {
      "use strict";
  
      /**
       * Constructs an exception object that is thrown due to a developer error, e.g., invalid argument,
       * argument out of range, etc.  This exception should only be thrown during development;
       * it usually indicates a bug in the calling code.  This exception should never be
       * caught; instead the calling code should strive not to generate it.
       * <br /><br />
       * On the other hand, a {@link RuntimeError} indicates an exception that may
       * be thrown at runtime, e.g., out of memory, that the calling code should be prepared
       * to catch.
       *
       * @alias DeveloperError
       * @constructor
       *
       * @param {String} [message] The error message for this exception.
       *
       * @see RuntimeError
       */
      var DeveloperError = function(message) {
          /**
           * 'DeveloperError' indicating that this exception was thrown due to a developer error.
           * @type {String}
           * @readonly
           */
          this.name = 'DeveloperError';
  
          /**
           * The explanation for why this exception was thrown.
           * @type {String}
           * @readonly
           */
          this.message = message;
  
          //Browsers such as IE don't have a stack property until you actually throw the error.
          var stack;
          try {
              throw new Error();
          } catch (e) {
              stack = e.stack;
          }
  
          /**
           * The stack trace of this exception, if available.
           * @type {String}
           * @readonly
           */
          this.stack = stack;
      };
  
      DeveloperError.prototype.toString = function() {
          var str = this.name + ': ' + this.message;
  
          if (defined(this.stack)) {
              str += '\n' + this.stack.toString();
          }
  
          return str;
      };
  
      /**
       * @private
       */
      DeveloperError.throwInstantiationError = function() {
          throw new DeveloperError('This function defines an interface and should not be called directly.');
      };
  
      return DeveloperError;
  });
  
  /*
    I've wrapped Makoto Matsumoto and Takuji Nishimura's code in a namespace
    so it's better encapsulated. Now you can have multiple random number generators
    and they won't stomp all over eachother's state.
  
    If you want to use this as a substitute for Math.random(), use the random()
    method like so:
  
    var m = new MersenneTwister();
    var randomNumber = m.random();
  
    You can also call the other genrand_{foo}() methods on the instance.
  
    If you want to use a specific seed in order to get a repeatable random
    sequence, pass an integer into the constructor:
  
    var m = new MersenneTwister(123);
  
    and that will always produce the same random sequence.
  
    Sean McCullough (banksean@gmail.com)
  */
  
  /*
     A C-program for MT19937, with initialization improved 2002/1/26.
     Coded by Takuji Nishimura and Makoto Matsumoto.
  
     Before using, initialize the state by using init_genrand(seed)
     or init_by_array(init_key, key_length).
  */
  /**
  @license
  mersenne-twister.js - https://gist.github.com/banksean/300494
  
     Copyright (C) 1997 - 2002, Makoto Matsumoto and Takuji Nishimura,
     All rights reserved.
  
     Redistribution and use in source and binary forms, with or without
     modification, are permitted provided that the following conditions
     are met:
  
       1. Redistributions of source code must retain the above copyright
          notice, this list of conditions and the following disclaimer.
  
       2. Redistributions in binary form must reproduce the above copyright
          notice, this list of conditions and the following disclaimer in the
          documentation and/or other materials provided with the distribution.
  
       3. The names of its contributors may not be used to endorse or promote
          products derived from this software without specific prior written
          permission.
  
     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
     "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
     LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
     A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
     EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
     PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
     PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
     LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
     NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
     SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
  /*
     Any feedback is very welcome.
     http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html
     email: m-mat @ math.sci.hiroshima-u.ac.jp (remove space)
  */
  define('ThirdParty/mersenne-twister',[],function() {
  var MersenneTwister = function(seed) {
    if (seed == undefined) {
      seed = new Date().getTime();
    }
    /* Period parameters */
    this.N = 624;
    this.M = 397;
    this.MATRIX_A = 0x9908b0df;   /* constant vector a */
    this.UPPER_MASK = 0x80000000; /* most significant w-r bits */
    this.LOWER_MASK = 0x7fffffff; /* least significant r bits */
  
    this.mt = new Array(this.N); /* the array for the state vector */
    this.mti=this.N+1; /* mti==N+1 means mt[N] is not initialized */
  
    this.init_genrand(seed);
  }
  
  /* initializes mt[N] with a seed */
  MersenneTwister.prototype.init_genrand = function(s) {
    this.mt[0] = s >>> 0;
    for (this.mti=1; this.mti<this.N; this.mti++) {
        var s = this.mt[this.mti-1] ^ (this.mt[this.mti-1] >>> 30);
     this.mt[this.mti] = (((((s & 0xffff0000) >>> 16) * 1812433253) << 16) + (s & 0x0000ffff) * 1812433253)
    + this.mti;
        /* See Knuth TAOCP Vol2. 3rd Ed. P.106 for multiplier. */
        /* In the previous versions, MSBs of the seed affect   */
        /* only MSBs of the array mt[].                        */
        /* 2002/01/09 modified by Makoto Matsumoto             */
        this.mt[this.mti] >>>= 0;
        /* for >32 bit machines */
    }
  }
  
  /* initialize by an array with array-length */
  /* init_key is the array for initializing keys */
  /* key_length is its length */
  /* slight change for C++, 2004/2/26 */
  //MersenneTwister.prototype.init_by_array = function(init_key, key_length) {
  //  var i, j, k;
  //  this.init_genrand(19650218);
  //  i=1; j=0;
  //  k = (this.N>key_length ? this.N : key_length);
  //  for (; k; k--) {
  //    var s = this.mt[i-1] ^ (this.mt[i-1] >>> 30)
  //    this.mt[i] = (this.mt[i] ^ (((((s & 0xffff0000) >>> 16) * 1664525) << 16) + ((s & 0x0000ffff) * 1664525)))
  //      + init_key[j] + j; /* non linear */
  //    this.mt[i] >>>= 0; /* for WORDSIZE > 32 machines */
  //    i++; j++;
  //    if (i>=this.N) { this.mt[0] = this.mt[this.N-1]; i=1; }
  //    if (j>=key_length) j=0;
  //  }
  //  for (k=this.N-1; k; k--) {
  //    var s = this.mt[i-1] ^ (this.mt[i-1] >>> 30);
  //    this.mt[i] = (this.mt[i] ^ (((((s & 0xffff0000) >>> 16) * 1566083941) << 16) + (s & 0x0000ffff) * 1566083941))
  //      - i; /* non linear */
  //    this.mt[i] >>>= 0; /* for WORDSIZE > 32 machines */
  //    i++;
  //    if (i>=this.N) { this.mt[0] = this.mt[this.N-1]; i=1; }
  //  }
  //
  //  this.mt[0] = 0x80000000; /* MSB is 1; assuring non-zero initial array */
  //}
  
  /* generates a random number on [0,0xffffffff]-interval */
  MersenneTwister.prototype.genrand_int32 = function() {
    var y;
    var mag01 = new Array(0x0, this.MATRIX_A);
    /* mag01[x] = x * MATRIX_A  for x=0,1 */
  
    if (this.mti >= this.N) { /* generate N words at one time */
      var kk;
  
      if (this.mti == this.N+1)   /* if init_genrand() has not been called, */
        this.init_genrand(5489); /* a default initial seed is used */
  
      for (kk=0;kk<this.N-this.M;kk++) {
        y = (this.mt[kk]&this.UPPER_MASK)|(this.mt[kk+1]&this.LOWER_MASK);
        this.mt[kk] = this.mt[kk+this.M] ^ (y >>> 1) ^ mag01[y & 0x1];
      }
      for (;kk<this.N-1;kk++) {
        y = (this.mt[kk]&this.UPPER_MASK)|(this.mt[kk+1]&this.LOWER_MASK);
        this.mt[kk] = this.mt[kk+(this.M-this.N)] ^ (y >>> 1) ^ mag01[y & 0x1];
      }
      y = (this.mt[this.N-1]&this.UPPER_MASK)|(this.mt[0]&this.LOWER_MASK);
      this.mt[this.N-1] = this.mt[this.M-1] ^ (y >>> 1) ^ mag01[y & 0x1];
  
      this.mti = 0;
    }
  
    y = this.mt[this.mti++];
  
    /* Tempering */
    y ^= (y >>> 11);
    y ^= (y << 7) & 0x9d2c5680;
    y ^= (y << 15) & 0xefc60000;
    y ^= (y >>> 18);
  
    return y >>> 0;
  }
  
  /* generates a random number on [0,0x7fffffff]-interval */
  //MersenneTwister.prototype.genrand_int31 = function() {
  //  return (this.genrand_int32()>>>1);
  //}
  
  /* generates a random number on [0,1]-real-interval */
  //MersenneTwister.prototype.genrand_real1 = function() {
  //  return this.genrand_int32()*(1.0/4294967295.0);
  //  /* divided by 2^32-1 */
  //}
  
  /* generates a random number on [0,1)-real-interval */
  MersenneTwister.prototype.random = function() {
    return this.genrand_int32()*(1.0/4294967296.0);
    /* divided by 2^32 */
  }
  
  /* generates a random number on (0,1)-real-interval */
  //MersenneTwister.prototype.genrand_real3 = function() {
  //  return (this.genrand_int32() + 0.5)*(1.0/4294967296.0);
  //  /* divided by 2^32 */
  //}
  
  /* generates a random number on [0,1) with 53-bit resolution*/
  //MersenneTwister.prototype.genrand_res53 = function() {
  //  var a=this.genrand_int32()>>>5, b=this.genrand_int32()>>>6;
  //  return(a*67108864.0+b)*(1.0/9007199254740992.0);
  //}
  
  /* These real versions are due to Isaku Wada, 2002/01/09 added */
  
  return MersenneTwister;
  });
  /*global define*/
  define('Core/Math',[
          '../ThirdParty/mersenne-twister',
          './defaultValue',
          './defined',
          './DeveloperError'
      ], function(
          MersenneTwister,
          defaultValue,
          defined,
          DeveloperError) {
      "use strict";
  
      /**
       * Math functions.
       *
       * @namespace
       * @alias CesiumMath
       */
      var CesiumMath = {};
  
      /**
       * 0.1
       * @type {Number}
       * @constant
       */
      CesiumMath.EPSILON1 = 0.1;
  
      /**
       * 0.01
       * @type {Number}
       * @constant
       */
      CesiumMath.EPSILON2 = 0.01;
  
      /**
       * 0.001
       * @type {Number}
       * @constant
       */
      CesiumMath.EPSILON3 = 0.001;
  
      /**
       * 0.0001
       * @type {Number}
       * @constant
       */
      CesiumMath.EPSILON4 = 0.0001;
  
      /**
       * 0.00001
       * @type {Number}
       * @constant
       */
      CesiumMath.EPSILON5 = 0.00001;
  
      /**
       * 0.000001
       * @type {Number}
       * @constant
       */
      CesiumMath.EPSILON6 = 0.000001;
  
      /**
       * 0.0000001
       * @type {Number}
       * @constant
       */
      CesiumMath.EPSILON7 = 0.0000001;
  
      /**
       * 0.00000001
       * @type {Number}
       * @constant
       */
      CesiumMath.EPSILON8 = 0.00000001;
  
      /**
       * 0.000000001
       * @type {Number}
       * @constant
       */
      CesiumMath.EPSILON9 = 0.000000001;
  
      /**
       * 0.0000000001
       * @type {Number}
       * @constant
       */
      CesiumMath.EPSILON10 = 0.0000000001;
  
      /**
       * 0.00000000001
       * @type {Number}
       * @constant
       */
      CesiumMath.EPSILON11 = 0.00000000001;
  
      /**
       * 0.000000000001
       * @type {Number}
       * @constant
       */
      CesiumMath.EPSILON12 = 0.000000000001;
  
      /**
       * 0.0000000000001
       * @type {Number}
       * @constant
       */
      CesiumMath.EPSILON13 = 0.0000000000001;
  
      /**
       * 0.00000000000001
       * @type {Number}
       * @constant
       */
      CesiumMath.EPSILON14 = 0.00000000000001;
  
      /**
       * 0.000000000000001
       * @type {Number}
       * @constant
       */
      CesiumMath.EPSILON15 = 0.000000000000001;
  
      /**
       * 0.0000000000000001
       * @type {Number}
       * @constant
       */
      CesiumMath.EPSILON16 = 0.0000000000000001;
  
      /**
       * 0.00000000000000001
       * @type {Number}
       * @constant
       */
      CesiumMath.EPSILON17 = 0.00000000000000001;
  
      /**
       * 0.000000000000000001
       * @type {Number}
       * @constant
       */
      CesiumMath.EPSILON18 = 0.000000000000000001;
  
      /**
       * 0.0000000000000000001
       * @type {Number}
       * @constant
       */
      CesiumMath.EPSILON19 = 0.0000000000000000001;
  
      /**
       * 0.00000000000000000001
       * @type {Number}
       * @constant
       */
      CesiumMath.EPSILON20 = 0.00000000000000000001;
  
      /**
       * 3.986004418e14
       * @type {Number}
       * @constant
       */
      CesiumMath.GRAVITATIONALPARAMETER = 3.986004418e14;
  
      /**
       * Radius of the sun in meters: 6.955e8
       * @type {Number}
       * @constant
       */
      CesiumMath.SOLAR_RADIUS = 6.955e8;
  
      /**
       * The mean radius of the moon, according to the "Report of the IAU/IAG Working Group on
       * Cartographic Coordinates and Rotational Elements of the Planets and satellites: 2000",
       * Celestial Mechanics 82: 83-110, 2002.
       * @type {Number}
       * @constant
       */
      CesiumMath.LUNAR_RADIUS = 1737400.0;
  
      /**
       * 64 * 1024
       * @type {Number}
       * @constant
       */
      CesiumMath.SIXTY_FOUR_KILOBYTES = 64 * 1024;
  
      /**
       * Returns the sign of the value; 1 if the value is positive, -1 if the value is
       * negative, or 0 if the value is 0.
       *
       * @param {Number} value The value to return the sign of.
       * @returns {Number} The sign of value.
       */
      CesiumMath.sign = function(value) {
          if (value > 0) {
              return 1;
          }
          if (value < 0) {
              return -1;
          }
  
          return 0;
      };
  
      /**
       * Returns 1.0 if the given value is positive or zero, and -1.0 if it is negative.
       * This is similar to {@link CesiumMath#sign} except that returns 1.0 instead of
       * 0.0 when the input value is 0.0.
       * @param {Number} value The value to return the sign of.
       * @returns {Number} The sign of value.
       */
      CesiumMath.signNotZero = function(value) {
          return value < 0.0 ? -1.0 : 1.0;
      };
  
      /**
       * Converts a scalar value in the range [-1.0, 1.0] to a 8-bit 2's complement number.
       * @param {Number} value The scalar value in the range [-1.0, 1.0]
       * @returns {Number} The 8-bit 2's complement number, where 0 maps to -1.0 and 255 maps to 1.0.
       *
       * @see CesiumMath.fromSNorm
       */
      CesiumMath.toSNorm = function(value) {
          return Math.round((CesiumMath.clamp(value, -1.0, 1.0) * 0.5 + 0.5) * 255.0);
      };
  
      /**
       * Converts a SNORM value in the range [0, 255] to a scalar in the range [-1.0, 1.0].
       * @param {Number} value SNORM value in the range [0, 255]
       * @returns {Number} Scalar in the range [-1.0, 1.0].
       *
       * @see CesiumMath.toSNorm
       */
      CesiumMath.fromSNorm = function(value) {
          return CesiumMath.clamp(value, 0.0, 255.0) / 255.0 * 2.0 - 1.0;
      };
  
      /**
       * Returns the hyperbolic sine of a number.
       * The hyperbolic sine of <em>value</em> is defined to be
       * (<em>e<sup>x</sup>&nbsp;-&nbsp;e<sup>-x</sup></em>)/2.0
       * where <i>e</i> is Euler's number, approximately 2.71828183.
       *
       * <p>Special cases:
       *   <ul>
       *     <li>If the argument is NaN, then the result is NaN.</li>
       *
       *     <li>If the argument is infinite, then the result is an infinity
       *     with the same sign as the argument.</li>
       *
       *     <li>If the argument is zero, then the result is a zero with the
       *     same sign as the argument.</li>
       *   </ul>
       *</p>
       *
       * @param {Number} value The number whose hyperbolic sine is to be returned.
       * @returns The hyperbolic sine of <code>value</code>.
       */
      CesiumMath.sinh = function(value) {
          var part1 = Math.pow(Math.E, value);
          var part2 = Math.pow(Math.E, -1.0 * value);
  
          return (part1 - part2) * 0.5;
      };
  
      /**
       * Returns the hyperbolic cosine of a number.
       * The hyperbolic cosine of <strong>value</strong> is defined to be
       * (<em>e<sup>x</sup>&nbsp;+&nbsp;e<sup>-x</sup></em>)/2.0
       * where <i>e</i> is Euler's number, approximately 2.71828183.
       *
       * <p>Special cases:
       *   <ul>
       *     <li>If the argument is NaN, then the result is NaN.</li>
       *
       *     <li>If the argument is infinite, then the result is positive infinity.</li>
       *
       *     <li>If the argument is zero, then the result is 1.0.</li>
       *   </ul>
       *</p>
       *
       * @param {Number} value The number whose hyperbolic cosine is to be returned.
       * @returns The hyperbolic cosine of <code>value</code>.
       */
      CesiumMath.cosh = function(value) {
          var part1 = Math.pow(Math.E, value);
          var part2 = Math.pow(Math.E, -1.0 * value);
  
          return (part1 + part2) * 0.5;
      };
  
      /**
       * Computes the linear interpolation of two values.
       *
       * @param {Number} p The start value to interpolate.
       * @param {Number} q The end value to interpolate.
       * @param {Number} time The time of interpolation generally in the range <code>[0.0, 1.0]</code>.
       * @returns {Number} The linearly interpolated value.
       *
       * @example
       * var n = Cesium.Math.lerp(0.0, 2.0, 0.5); // returns 1.0
       */
      CesiumMath.lerp = function(p, q, time) {
          return ((1.0 - time) * p) + (time * q);
      };
  
      /**
       * pi
       *
       * @type {Number}
       * @constant
       */
      CesiumMath.PI = Math.PI;
  
      /**
       * 1/pi
       *
       * @type {Number}
       * @constant
       */
      CesiumMath.ONE_OVER_PI = 1.0 / Math.PI;
  
      /**
       * pi/2
       *
       * @type {Number}
       * @constant
       */
      CesiumMath.PI_OVER_TWO = Math.PI * 0.5;
  
      /**
       * pi/3
       *
       * @type {Number}
       * @constant
       */
      CesiumMath.PI_OVER_THREE = Math.PI / 3.0;
  
      /**
       * pi/4
       *
       * @type {Number}
       * @constant
       */
      CesiumMath.PI_OVER_FOUR = Math.PI / 4.0;
  
      /**
       * pi/6
       *
       * @type {Number}
       * @constant
       */
      CesiumMath.PI_OVER_SIX = Math.PI / 6.0;
  
      /**
       * 3pi/2
       *
       * @type {Number}
       * @constant
       */
      CesiumMath.THREE_PI_OVER_TWO = (3.0 * Math.PI) * 0.5;
  
      /**
       * 2pi
       *
       * @type {Number}
       * @constant
       */
      CesiumMath.TWO_PI = 2.0 * Math.PI;
  
      /**
       * 1/2pi
       *
       * @type {Number}
       * @constant
       */
      CesiumMath.ONE_OVER_TWO_PI = 1.0 / (2.0 * Math.PI);
  
      /**
       * The number of radians in a degree.
       *
       * @type {Number}
       * @constant
       * @default Math.PI / 180.0
       */
      CesiumMath.RADIANS_PER_DEGREE = Math.PI / 180.0;
  
      /**
       * The number of degrees in a radian.
       *
       * @type {Number}
       * @constant
       * @default 180.0 / Math.PI
       */
      CesiumMath.DEGREES_PER_RADIAN = 180.0 / Math.PI;
  
      /**
       * The number of radians in an arc second.
       *
       * @type {Number}
       * @constant
       * @default {@link CesiumMath.RADIANS_PER_DEGREE} / 3600.0
       */
      CesiumMath.RADIANS_PER_ARCSECOND = CesiumMath.RADIANS_PER_DEGREE / 3600.0;
  
      /**
       * Converts degrees to radians.
       * @param {Number} degrees The angle to convert in degrees.
       * @returns {Number} The corresponding angle in radians.
       */
      CesiumMath.toRadians = function(degrees) {
                  if (!defined(degrees)) {
              throw new DeveloperError('degrees is required.');
          }
                  return degrees * CesiumMath.RADIANS_PER_DEGREE;
      };
  
      /**
       * Converts radians to degrees.
       * @param {Number} radians The angle to convert in radians.
       * @returns {Number} The corresponding angle in degrees.
       */
      CesiumMath.toDegrees = function(radians) {
                  if (!defined(radians)) {
              throw new DeveloperError('radians is required.');
          }
                  return radians * CesiumMath.DEGREES_PER_RADIAN;
      };
  
      /**
       * Converts a longitude value, in radians, to the range [<code>-Math.PI</code>, <code>Math.PI</code>).
       *
       * @param {Number} angle The longitude value, in radians, to convert to the range [<code>-Math.PI</code>, <code>Math.PI</code>).
       * @returns {Number} The equivalent longitude value in the range [<code>-Math.PI</code>, <code>Math.PI</code>).
       *
       * @example
       * // Convert 270 degrees to -90 degrees longitude
       * var longitude = Cesium.Math.convertLongitudeRange(Cesium.Math.toRadians(270.0));
       */
      CesiumMath.convertLongitudeRange = function(angle) {
                  if (!defined(angle)) {
              throw new DeveloperError('angle is required.');
          }
                  var twoPi = CesiumMath.TWO_PI;
  
          var simplified = angle - Math.floor(angle / twoPi) * twoPi;
  
          if (simplified < -Math.PI) {
              return simplified + twoPi;
          }
          if (simplified >= Math.PI) {
              return simplified - twoPi;
          }
  
          return simplified;
      };
  
      /**
       * Produces an angle in the range -Pi <= angle <= Pi which is equivalent to the provided angle.
       *
       * @param {Number} angle in radians
       * @returns {Number} The angle in the range [<code>-CesiumMath.PI</code>, <code>CesiumMath.PI</code>].
       */
      CesiumMath.negativePiToPi = function(x) {
                  if (!defined(x)) {
              throw new DeveloperError('x is required.');
          }
                  var epsilon10 = CesiumMath.EPSILON10;
          var pi = CesiumMath.PI;
          var two_pi = CesiumMath.TWO_PI;
          while (x < -(pi + epsilon10)) {
              x += two_pi;
          }
          if (x < -pi) {
              return -pi;
          }
          while (x > pi + epsilon10) {
              x -= two_pi;
          }
          return x > pi ? pi : x;
      };
  
      /**
       * Produces an angle in the range 0 <= angle <= 2Pi which is equivalent to the provided angle.
       *
       * @param {Number} angle in radians
       * @returns {Number} The angle in the range [0, <code>CesiumMath.TWO_PI</code>].
       */
      CesiumMath.zeroToTwoPi = function(x) {
                  if (!defined(x)) {
              throw new DeveloperError('x is required.');
          }
                  var value = x % CesiumMath.TWO_PI;
          // We do a second modules here if we add 2Pi to ensure that we don't have any numerical issues with very
          // small negative values.
          return (value < 0.0) ? (value + CesiumMath.TWO_PI) % CesiumMath.TWO_PI : value;
      };
  
      /**
       * Determines if two values are equal within the provided epsilon.  This is useful
       * to avoid problems due to roundoff error when comparing floating-point values directly.
       *
       * @param {Number} left The first value to compare.
       * @param {Number} right The other value to compare.
       * @param {Number} [epsilon=0.0] The maximum inclusive delta between <code>left</code> and <code>right</code> where they will be considered equal.
       * @returns {Boolean} <code>true</code> if the values are equal within the epsilon; otherwise, <code>false</code>.
       *
       * @example
       * var b = Cesium.Math.equalsEpsilon(0.0, 0.01, Cesium.Math.EPSILON2); // true
       * var b = Cesium.Math.equalsEpsilon(0.0, 0.1, Cesium.Math.EPSILON2);  // false
       */
      CesiumMath.equalsEpsilon = function(left, right, epsilon) {
                  if (!defined(left)) {
              throw new DeveloperError('left is required.');
          }
  
          if (!defined(right)) {
              throw new DeveloperError('right is required.');
          }
                  epsilon = defaultValue(epsilon, 0.0);
          return Math.abs(left - right) <= epsilon;
      };
  
      var factorials = [1];
  
      /**
       * Computes the factorial of the provided number.
       *
       * @param {Number} n The number whose factorial is to be computed.
       * @returns {Number} The factorial of the provided number or undefined if the number is less than 0.
       *
       * @exception {DeveloperError} A number greater than or equal to 0 is required.
       *
       * @see {@link http://en.wikipedia.org/wiki/Factorial|Factorial on Wikipedia}
       *
       * @example
       * //Compute 7!, which is equal to 5040
       * var computedFactorial = Cesium.Math.factorial(7);
       */
      CesiumMath.factorial = function(n) {
                  if (typeof n !== 'number' || n < 0) {
              throw new DeveloperError('A number greater than or equal to 0 is required.');
          }
          
          var length = factorials.length;
          if (n >= length) {
              var sum = factorials[length - 1];
              for (var i = length; i <= n; i++) {
                  factorials.push(sum * i);
              }
          }
          return factorials[n];
      };
  
      /**
       * Increments a number with a wrapping to a minimum value if the number exceeds the maximum value.
       *
       * @param {Number} [n] The number to be incremented.
       * @param {Number} [maximumValue] The maximum incremented value before rolling over to the minimum value.
       * @param {Number} [minimumValue=0.0] The number reset to after the maximum value has been exceeded.
       * @returns {Number} The incremented number.
       *
       * @exception {DeveloperError} Maximum value must be greater than minimum value.
       *
       * @example
       * var n = Cesium.Math.incrementWrap(5, 10, 0); // returns 6
       * var n = Cesium.Math.incrementWrap(10, 10, 0); // returns 0
       */
      CesiumMath.incrementWrap = function(n, maximumValue, minimumValue) {
          minimumValue = defaultValue(minimumValue, 0.0);
  
                  if (!defined(n)) {
              throw new DeveloperError('n is required.');
          }
          if (maximumValue <= minimumValue) {
              throw new DeveloperError('maximumValue must be greater than minimumValue.');
          }
          
          ++n;
          if (n > maximumValue) {
              n = minimumValue;
          }
          return n;
      };
  
      /**
       * Determines if a positive integer is a power of two.
       *
       * @param {Number} n The positive integer to test.
       * @returns {Boolean} <code>true</code> if the number if a power of two; otherwise, <code>false</code>.
       *
       * @exception {DeveloperError} A number greater than or equal to 0 is required.
       *
       * @example
       * var t = Cesium.Math.isPowerOfTwo(16); // true
       * var f = Cesium.Math.isPowerOfTwo(20); // false
       */
      CesiumMath.isPowerOfTwo = function(n) {
                  if (typeof n !== 'number' || n < 0) {
              throw new DeveloperError('A number greater than or equal to 0 is required.');
          }
          
          return (n !== 0) && ((n & (n - 1)) === 0);
      };
  
      /**
       * Computes the next power-of-two integer greater than or equal to the provided positive integer.
       *
       * @param {Number} n The positive integer to test.
       * @returns {Number} The next power-of-two integer.
       *
       * @exception {DeveloperError} A number greater than or equal to 0 is required.
       *
       * @example
       * var n = Cesium.Math.nextPowerOfTwo(29); // 32
       * var m = Cesium.Math.nextPowerOfTwo(32); // 32
       */
      CesiumMath.nextPowerOfTwo = function(n) {
                  if (typeof n !== 'number' || n < 0) {
              throw new DeveloperError('A number greater than or equal to 0 is required.');
          }
          
          // From http://graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2
          --n;
          n |= n >> 1;
          n |= n >> 2;
          n |= n >> 4;
          n |= n >> 8;
          n |= n >> 16;
          ++n;
  
          return n;
      };
  
      /**
       * Constraint a value to lie between two values.
       *
       * @param {Number} value The value to constrain.
       * @param {Number} min The minimum value.
       * @param {Number} max The maximum value.
       * @returns The value clamped so that min <= value <= max.
       */
      CesiumMath.clamp = function(value, min, max) {
                  if (!defined(value)) {
              throw new DeveloperError('value is required');
          }
          if (!defined(min)) {
              throw new DeveloperError('min is required.');
          }
          if (!defined(max)) {
              throw new DeveloperError('max is required.');
          }
                  return value < min ? min : value > max ? max : value;
      };
  
      var randomNumberGenerator = new MersenneTwister();
  
      /**
       * Sets the seed used by the random number generator
       * in {@link CesiumMath#nextRandomNumber}.
       *
       * @param {Number} seed An integer used as the seed.
       */
      CesiumMath.setRandomNumberSeed = function(seed) {
                  if (!defined(seed)) {
              throw new DeveloperError('seed is required.');
          }
          
          randomNumberGenerator = new MersenneTwister(seed);
      };
  
      /**
       * Generates a random number in the range of [0.0, 1.0)
       * using a Mersenne twister.
       *
       * @returns A random number in the range of [0.0, 1.0).
       *
       * @see CesiumMath.setRandomNumberSeed
       * @see {@link http://en.wikipedia.org/wiki/Mersenne_twister|Mersenne twister on Wikipedia}
       */
      CesiumMath.nextRandomNumber = function() {
          return randomNumberGenerator.random();
      };
  
      /**
       * Computes <code>Math.acos(value)</acode>, but first clamps <code>value</code> to the range [-1.0, 1.0]
       * so that the function will never return NaN.
       *
       * @param value The value for which to compute acos.
       * @returns {number} The acos of the value if the value is in the range [-1.0, 1.0], or the acos of -1.0 or 1.0,
       *          whichever is closer, if the value is outside the range.
       */
      CesiumMath.acosClamped = function(value) {
          return Math.acos(CesiumMath.clamp(value, -1.0, 1.0));
      };
  
      /**
       * Computes <code>Math.asin(value)</acode>, but first clamps <code>value</code> to the range [-1.0, 1.0]
       * so that the function will never return NaN.
       *
       * @param value The value for which to compute asin.
       * @returns {number} The asin of the value if the value is in the range [-1.0, 1.0], or the asin of -1.0 or 1.0,
       *          whichever is closer, if the value is outside the range.
       */
      CesiumMath.asinClamped = function(value) {
          return Math.asin(CesiumMath.clamp(value, -1.0, 1.0));
      };
  
      return CesiumMath;
  });
  
  /*global define*/
  define('Core/Cartesian2',[
          './defaultValue',
          './defined',
          './DeveloperError',
          './freezeObject',
          './Math'
      ], function(
          defaultValue,
          defined,
          DeveloperError,
          freezeObject,
          CesiumMath) {
      "use strict";
  
      /**
       * A 2D Cartesian point.
       * @alias Cartesian2
       * @constructor
       *
       * @param {Number} [x=0.0] The X component.
       * @param {Number} [y=0.0] The Y component.
       *
       * @see Cartesian3
       * @see Cartesian4
       * @see Packable
       */
      var Cartesian2 = function(x, y) {
          /**
           * The X component.
           * @type {Number}
           * @default 0.0
           */
          this.x = defaultValue(x, 0.0);
  
          /**
           * The Y component.
           * @type {Number}
           * @default 0.0
           */
          this.y = defaultValue(y, 0.0);
      };
  
      /**
       * Creates a Cartesian2 instance from x and y coordinates.
       *
       * @param {Number} x The x coordinate.
       * @param {Number} y The y coordinate.
       * @param {Cartesian2} [result] The object onto which to store the result.
       * @returns {Cartesian2} The modified result parameter or a new Cartesian2 instance if one was not provided.
       */
      Cartesian2.fromElements = function(x, y, result) {
          if (!defined(result)) {
              return new Cartesian2(x, y);
          }
  
          result.x = x;
          result.y = y;
          return result;
      };
  
      /**
       * Duplicates a Cartesian2 instance.
       *
       * @param {Cartesian2} cartesian The Cartesian to duplicate.
       * @param {Cartesian2} [result] The object onto which to store the result.
       * @returns {Cartesian2} The modified result parameter or a new Cartesian2 instance if one was not provided. (Returns undefined if cartesian is undefined)
       */
      Cartesian2.clone = function(cartesian, result) {
          if (!defined(cartesian)) {
              return undefined;
          }
          if (!defined(result)) {
              return new Cartesian2(cartesian.x, cartesian.y);
          }
  
          result.x = cartesian.x;
          result.y = cartesian.y;
          return result;
      };
  
      /**
       * Creates a Cartesian2 instance from an existing Cartesian3.  This simply takes the
       * x and y properties of the Cartesian3 and drops z.
       * @function
       *
       * @param {Cartesian3} cartesian The Cartesian3 instance to create a Cartesian2 instance from.
       * @param {Cartesian2} [result] The object onto which to store the result.
       * @returns {Cartesian2} The modified result parameter or a new Cartesian2 instance if one was not provided.
       */
      Cartesian2.fromCartesian3 = Cartesian2.clone;
  
      /**
       * Creates a Cartesian2 instance from an existing Cartesian4.  This simply takes the
       * x and y properties of the Cartesian4 and drops z and w.
       * @function
       *
       * @param {Cartesian4} cartesian The Cartesian4 instance to create a Cartesian2 instance from.
       * @param {Cartesian2} [result] The object onto which to store the result.
       * @returns {Cartesian2} The modified result parameter or a new Cartesian2 instance if one was not provided.
       */
      Cartesian2.fromCartesian4 = Cartesian2.clone;
  
      /**
       * The number of elements used to pack the object into an array.
       * @type {Number}
       */
      Cartesian2.packedLength = 2;
  
      /**
       * Stores the provided instance into the provided array.
       *
       * @param {Cartesian2} value The value to pack.
       * @param {Number[]} array The array to pack into.
       * @param {Number} [startingIndex=0] The index into the array at which to start packing the elements.
       */
      Cartesian2.pack = function(value, array, startingIndex) {
                  if (!defined(value)) {
              throw new DeveloperError('value is required');
          }
          if (!defined(array)) {
              throw new DeveloperError('array is required');
          }
          
          startingIndex = defaultValue(startingIndex, 0);
  
          array[startingIndex++] = value.x;
          array[startingIndex] = value.y;
      };
  
      /**
       * Retrieves an instance from a packed array.
       *
       * @param {Number[]} array The packed array.
       * @param {Number} [startingIndex=0] The starting index of the element to be unpacked.
       * @param {Cartesian2} [result] The object into which to store the result.
       */
      Cartesian2.unpack = function(array, startingIndex, result) {
                  if (!defined(array)) {
              throw new DeveloperError('array is required');
          }
          
          startingIndex = defaultValue(startingIndex, 0);
  
          if (!defined(result)) {
              result = new Cartesian2();
          }
          result.x = array[startingIndex++];
          result.y = array[startingIndex];
          return result;
      };
  
      /**
       * Creates a Cartesian2 from two consecutive elements in an array.
       * @function
       *
       * @param {Number[]} array The array whose two consecutive elements correspond to the x and y components, respectively.
       * @param {Number} [startingIndex=0] The offset into the array of the first element, which corresponds to the x component.
       * @param {Cartesian2} [result] The object onto which to store the result.
       * @returns {Cartesian2} The modified result parameter or a new Cartesian2 instance if one was not provided.
       *
       * @example
       * // Create a Cartesian2 with (1.0, 2.0)
       * var v = [1.0, 2.0];
       * var p = Cesium.Cartesian2.fromArray(v);
       *
       * // Create a Cartesian2 with (1.0, 2.0) using an offset into an array
       * var v2 = [0.0, 0.0, 1.0, 2.0];
       * var p2 = Cesium.Cartesian2.fromArray(v2, 2);
       */
      Cartesian2.fromArray = Cartesian2.unpack;
  
      /**
       * Computes the value of the maximum component for the supplied Cartesian.
       *
       * @param {Cartesian2} cartesian The cartesian to use.
       * @returns {Number} The value of the maximum component.
       */
      Cartesian2.maximumComponent = function(cartesian) {
                  if (!defined(cartesian)) {
              throw new DeveloperError('cartesian is required');
          }
          
          return Math.max(cartesian.x, cartesian.y);
      };
  
      /**
       * Computes the value of the minimum component for the supplied Cartesian.
       *
       * @param {Cartesian2} cartesian The cartesian to use.
       * @returns {Number} The value of the minimum component.
       */
      Cartesian2.minimumComponent = function(cartesian) {
                  if (!defined(cartesian)) {
              throw new DeveloperError('cartesian is required');
          }
          
          return Math.min(cartesian.x, cartesian.y);
      };
  
      /**
       * Compares two Cartesians and computes a Cartesian which contains the minimum components of the supplied Cartesians.
       *
       * @param {Cartesian2} first A cartesian to compare.
       * @param {Cartesian2} second A cartesian to compare.
       * @param {Cartesian2} result The object into which to store the result.
       * @returns {Cartesian2} A cartesian with the minimum components.
       */
      Cartesian2.minimumByComponent = function(first, second, result) {
                  if (!defined(first)) {
              throw new DeveloperError('first is required.');
          }
          if (!defined(second)) {
              throw new DeveloperError('second is required.');
          }
          if (!defined(result)) {
              throw new DeveloperError('result is required.');
          }
          
  
          result.x = Math.min(first.x, second.x);
          result.y = Math.min(first.y, second.y);
  
          return result;
      };
  
      /**
       * Compares two Cartesians and computes a Cartesian which contains the maximum components of the supplied Cartesians.
       *
       * @param {Cartesian2} first A cartesian to compare.
       * @param {Cartesian2} second A cartesian to compare.
       * @param {Cartesian2} result The object into which to store the result.
       * @returns {Cartesian2} A cartesian with the maximum components.
       */
      Cartesian2.maximumByComponent = function(first, second, result) {
                  if (!defined(first)) {
              throw new DeveloperError('first is required.');
          }
          if (!defined(second)) {
              throw new DeveloperError('second is required.');
          }
          if (!defined(result)) {
              throw new DeveloperError('result is required.');
          }
          
          result.x = Math.max(first.x, second.x);
          result.y = Math.max(first.y, second.y);
          return result;
      };
  
      /**
       * Computes the provided Cartesian's squared magnitude.
       *
       * @param {Cartesian2} cartesian The Cartesian instance whose squared magnitude is to be computed.
       * @returns {Number} The squared magnitude.
       */
      Cartesian2.magnitudeSquared = function(cartesian) {
                  if (!defined(cartesian)) {
              throw new DeveloperError('cartesian is required');
          }
          
          return cartesian.x * cartesian.x + cartesian.y * cartesian.y;
      };
  
      /**
       * Computes the Cartesian's magnitude (length).
       *
       * @param {Cartesian2} cartesian The Cartesian instance whose magnitude is to be computed.
       * @returns {Number} The magnitude.
       */
      Cartesian2.magnitude = function(cartesian) {
          return Math.sqrt(Cartesian2.magnitudeSquared(cartesian));
      };
  
      var distanceScratch = new Cartesian2();
  
      /**
       * Computes the distance between two points
       *
       * @param {Cartesian2} left The first point to compute the distance from.
       * @param {Cartesian2} right The second point to compute the distance to.
       * @returns {Number} The distance between two points.
       *
       * @example
       * // Returns 1.0
       * var d = Cesium.Cartesian2.distance(new Cesium.Cartesian2(1.0, 0.0), new Cesium.Cartesian2(2.0, 0.0));
       */
      Cartesian2.distance = function(left, right) {
                  if (!defined(left) || !defined(right)) {
              throw new DeveloperError('left and right are required.');
          }
          
          Cartesian2.subtract(left, right, distanceScratch);
          return Cartesian2.magnitude(distanceScratch);
      };
  
      /**
       * Computes the normalized form of the supplied Cartesian.
       *
       * @param {Cartesian2} cartesian The Cartesian to be normalized.
       * @param {Cartesian2} result The object onto which to store the result.
       * @returns {Cartesian2} The modified result parameter.
       */
      Cartesian2.normalize = function(cartesian, result) {
                  if (!defined(cartesian)) {
              throw new DeveloperError('cartesian is required');
          }
          if (!defined(result)) {
              throw new DeveloperError('result is required');
          }
          
          var magnitude = Cartesian2.magnitude(cartesian);
  
          result.x = cartesian.x / magnitude;
          result.y = cartesian.y / magnitude;
          return result;
      };
  
      /**
       * Computes the dot (scalar) product of two Cartesians.
       *
       * @param {Cartesian2} left The first Cartesian.
       * @param {Cartesian2} right The second Cartesian.
       * @returns {Number} The dot product.
       */
      Cartesian2.dot = function(left, right) {
                  if (!defined(left)) {
              throw new DeveloperError('left is required');
          }
          if (!defined(right)) {
              throw new DeveloperError('right is required');
          }
          
          return left.x * right.x + left.y * right.y;
      };
  
      /**
       * Computes the componentwise product of two Cartesians.
       *
       * @param {Cartesian2} left The first Cartesian.
       * @param {Cartesian2} right The second Cartesian.
       * @param {Cartesian2} result The object onto which to store the result.
       * @returns {Cartesian2} The modified result parameter.
       */
      Cartesian2.multiplyComponents = function(left, right, result) {
                  if (!defined(left)) {
              throw new DeveloperError('left is required');
          }
          if (!defined(right)) {
              throw new DeveloperError('right is required');
          }
          if (!defined(result)) {
              throw new DeveloperError('result is required');
          }
          
          result.x = left.x * right.x;
          result.y = left.y * right.y;
          return result;
      };
  
      /**
       * Computes the componentwise sum of two Cartesians.
       *
       * @param {Cartesian2} left The first Cartesian.
       * @param {Cartesian2} right The second Cartesian.
       * @param {Cartesian2} result The object onto which to store the result.
       * @returns {Cartesian2} The modified result parameter.
       */
      Cartesian2.add = function(left, right, result) {
                  if (!defined(left)) {
              throw new DeveloperError('left is required');
          }
          if (!defined(right)) {
              throw new DeveloperError('right is required');
          }
          if (!defined(result)) {
              throw new DeveloperError('result is required');
          }
          
          result.x = left.x + right.x;
          result.y = left.y + right.y;
          return result;
      };
  
      /**
       * Computes the componentwise difference of two Cartesians.
       *
       * @param {Cartesian2} left The first Cartesian.
       * @param {Cartesian2} right The second Cartesian.
       * @param {Cartesian2} result The object onto which to store the result.
       * @returns {Cartesian2} The modified result parameter.
       */
      Cartesian2.subtract = function(left, right, result) {
                  if (!defined(left)) {
              throw new DeveloperError('left is required');
          }
          if (!defined(right)) {
              throw new DeveloperError('right is required');
          }
          if (!defined(result)) {
              throw new DeveloperError('result is required');
          }
          
          result.x = left.x - right.x;
          result.y = left.y - right.y;
          return result;
      };
  
      /**
       * Multiplies the provided Cartesian componentwise by the provided scalar.
       *
       * @param {Cartesian2} cartesian The Cartesian to be scaled.
       * @param {Number} scalar The scalar to multiply with.
       * @param {Cartesian2} result The object onto which to store the result.
       * @returns {Cartesian2} The modified result parameter.
       */
      Cartesian2.multiplyByScalar = function(cartesian, scalar, result) {
                  if (!defined(cartesian)) {
              throw new DeveloperError('cartesian is required');
          }
          if (typeof scalar !== 'number') {
              throw new DeveloperError('scalar is required and must be a number.');
          }
          if (!defined(result)) {
              throw new DeveloperError('result is required');
          }
          
          result.x = cartesian.x * scalar;
          result.y = cartesian.y * scalar;
          return result;
      };
  
      /**
       * Divides the provided Cartesian componentwise by the provided scalar.
       *
       * @param {Cartesian2} cartesian The Cartesian to be divided.
       * @param {Number} scalar The scalar to divide by.
       * @param {Cartesian2} result The object onto which to store the result.
       * @returns {Cartesian2} The modified result parameter.
       */
      Cartesian2.divideByScalar = function(cartesian, scalar, result) {
                  if (!defined(cartesian)) {
              throw new DeveloperError('cartesian is required');
          }
          if (typeof scalar !== 'number') {
              throw new DeveloperError('scalar is required and must be a number.');
          }
          if (!defined(result)) {
              throw new DeveloperError('result is required');
          }
          
          result.x = cartesian.x / scalar;
          result.y = cartesian.y / scalar;
          return result;
      };
  
      /**
       * Negates the provided Cartesian.
       *
       * @param {Cartesian2} cartesian The Cartesian to be negated.
       * @param {Cartesian2} result The object onto which to store the result.
       * @returns {Cartesian2} The modified result parameter.
       */
      Cartesian2.negate = function(cartesian, result) {
                  if (!defined(cartesian)) {
              throw new DeveloperError('cartesian is required');
          }
          if (!defined(result)) {
              throw new DeveloperError('result is required');
          }
          
          result.x = -cartesian.x;
          result.y = -cartesian.y;
          return result;
      };
  
      /**
       * Computes the absolute value of the provided Cartesian.
       *
       * @param {Cartesian2} cartesian The Cartesian whose absolute value is to be computed.
       * @param {Cartesian2} result The object onto which to store the result.
       * @returns {Cartesian2} The modified result parameter.
       */
      Cartesian2.abs = function(cartesian, result) {
                  if (!defined(cartesian)) {
              throw new DeveloperError('cartesian is required');
          }
          if (!defined(result)) {
              throw new DeveloperError('result is required');
          }
          
          result.x = Math.abs(cartesian.x);
          result.y = Math.abs(cartesian.y);
          return result;
      };
  
      var lerpScratch = new Cartesian2();
      /**
       * Computes the linear interpolation or extrapolation at t using the provided cartesians.
       *
       * @param {Cartesian2} start The value corresponding to t at 0.0.
       * @param {Cartesian2} end The value corresponding to t at 1.0.
       * @param {Number} t The point along t at which to interpolate.
       * @param {Cartesian2} result The object onto which to store the result.
       * @returns {Cartesian2} The modified result parameter.
       */
      Cartesian2.lerp = function(start, end, t, result) {
                  if (!defined(start)) {
              throw new DeveloperError('start is required.');
          }
          if (!defined(end)) {
              throw new DeveloperError('end is required.');
          }
          if (typeof t !== 'number') {
              throw new DeveloperError('t is required and must be a number.');
          }
          if (!defined(result)) {
              throw new DeveloperError('result is required.');
          }
          
          Cartesian2.multiplyByScalar(end, t, lerpScratch);
          result = Cartesian2.multiplyByScalar(start, 1.0 - t, result);
          return Cartesian2.add(lerpScratch, result, result);
      };
  
      var angleBetweenScratch = new Cartesian2();
      var angleBetweenScratch2 = new Cartesian2();
      /**
       * Returns the angle, in radians, between the provided Cartesians.
       *
       * @param {Cartesian2} left The first Cartesian.
       * @param {Cartesian2} right The second Cartesian.
       * @returns {Number} The angle between the Cartesians.
       */
      Cartesian2.angleBetween = function(left, right) {
                  if (!defined(left)) {
              throw new DeveloperError('left is required');
          }
          if (!defined(right)) {
              throw new DeveloperError('right is required');
          }
          
          Cartesian2.normalize(left, angleBetweenScratch);
          Cartesian2.normalize(right, angleBetweenScratch2);
          return CesiumMath.acosClamped(Cartesian2.dot(angleBetweenScratch, angleBetweenScratch2));
      };
  
      var mostOrthogonalAxisScratch = new Cartesian2();
      /**
       * Returns the axis that is most orthogonal to the provided Cartesian.
       *
       * @param {Cartesian2} cartesian The Cartesian on which to find the most orthogonal axis.
       * @param {Cartesian2} result The object onto which to store the result.
       * @returns {Cartesian2} The most orthogonal axis.
       */
      Cartesian2.mostOrthogonalAxis = function(cartesian, result) {
                  if (!defined(cartesian)) {
              throw new DeveloperError('cartesian is required.');
          }
          if (!defined(result)) {
              throw new DeveloperError('result is required.');
          }
          
          var f = Cartesian2.normalize(cartesian, mostOrthogonalAxisScratch);
          Cartesian2.abs(f, f);
  
          if (f.x <= f.y) {
              result = Cartesian2.clone(Cartesian2.UNIT_X, result);
          } else {
              result = Cartesian2.clone(Cartesian2.UNIT_Y, result);
          }
  
          return result;
      };
  
      /**
       * Compares the provided Cartesians componentwise and returns
       * <code>true</code> if they are equal, <code>false</code> otherwise.
       *
       * @param {Cartesian2} [left] The first Cartesian.
       * @param {Cartesian2} [right] The second Cartesian.
       * @returns {Boolean} <code>true</code> if left and right are equal, <code>false</code> otherwise.
       */
      Cartesian2.equals = function(left, right) {
          return (left === right) ||
                 ((defined(left)) &&
                  (defined(right)) &&
                  (left.x === right.x) &&
                  (left.y === right.y));
      };
  
      /**
       * Compares the provided Cartesians componentwise and returns
       * <code>true</code> if they are within the provided epsilon,
       * <code>false</code> otherwise.
       *
       * @param {Cartesian2} [left] The first Cartesian.
       * @param {Cartesian2} [right] The second Cartesian.
       * @param {Number} epsilon The epsilon to use for equality testing.
       * @returns {Boolean} <code>true</code> if left and right are within the provided epsilon, <code>false</code> otherwise.
       */
      Cartesian2.equalsEpsilon = function(left, right, epsilon) {
                  if (typeof epsilon !== 'number') {
              throw new DeveloperError('epsilon is required and must be a number.');
          }
          
          return (left === right) ||
                 ((defined(left)) &&
                  (defined(right)) &&
                  (Math.abs(left.x - right.x) <= epsilon) &&
                  (Math.abs(left.y - right.y) <= epsilon));
      };
  
      /**
       * An immutable Cartesian2 instance initialized to (0.0, 0.0).
       *
       * @type {Cartesian2}
       * @constant
       */
      Cartesian2.ZERO = freezeObject(new Cartesian2(0.0, 0.0));
  
      /**
       * An immutable Cartesian2 instance initialized to (1.0, 0.0).
       *
       * @type {Cartesian2}
       * @constant
       */
      Cartesian2.UNIT_X = freezeObject(new Cartesian2(1.0, 0.0));
  
      /**
       * An immutable Cartesian2 instance initialized to (0.0, 1.0).
       *
       * @type {Cartesian2}
       * @constant
       */
      Cartesian2.UNIT_Y = freezeObject(new Cartesian2(0.0, 1.0));
  
      /**
       * Duplicates this Cartesian2 instance.
       *
       * @param {Cartesian2} [result] The object onto which to store the result.
       * @returns {Cartesian2} The modified result parameter or a new Cartesian2 instance if one was not provided.
       */
      Cartesian2.prototype.clone = function(result) {
          return Cartesian2.clone(this, result);
      };
  
      /**
       * Compares this Cartesian against the provided Cartesian componentwise and returns
       * <code>true</code> if they are equal, <code>false</code> otherwise.
       *
       * @param {Cartesian2} [right] The right hand side Cartesian.
       * @returns {Boolean} <code>true</code> if they are equal, <code>false</code> otherwise.
       */
      Cartesian2.prototype.equals = function(right) {
          return Cartesian2.equals(this, right);
      };
  
      /**
       * Compares this Cartesian against the provided Cartesian componentwise and returns
       * <code>true</code> if they are within the provided epsilon,
       * <code>false</code> otherwise.
       *
       * @param {Cartesian2} [right] The right hand side Cartesian.
       * @param {Number} epsilon The epsilon to use for equality testing.
       * @returns {Boolean} <code>true</code> if they are within the provided epsilon, <code>false</code> otherwise.
       */
      Cartesian2.prototype.equalsEpsilon = function(right, epsilon) {
          return Cartesian2.equalsEpsilon(this, right, epsilon);
      };
  
      /**
       * Creates a string representing this Cartesian in the format '(x, y)'.
       *
       * @returns {String} A string representing the provided Cartesian in the format '(x, y)'.
       */
      Cartesian2.prototype.toString = function() {
          return '(' + this.x + ', ' + this.y + ')';
      };
  
      return Cartesian2;
  });
  
  /*global define*/
  define('Core/Cartesian3',[
          './defaultValue',
          './defined',
          './DeveloperError',
          './freezeObject',
          './Math'
      ], function(
          defaultValue,
          defined,
          DeveloperError,
          freezeObject,
          CesiumMath) {
      "use strict";
  
      /**
       * A 3D Cartesian point.
       * @alias Cartesian3
       * @constructor
       *
       * @param {Number} [x=0.0] The X component.
       * @param {Number} [y=0.0] The Y component.
       * @param {Number} [z=0.0] The Z component.
       *
       * @see Cartesian2
       * @see Cartesian4
       * @see Packable
       */
      var Cartesian3 = function(x, y, z) {
          /**
           * The X component.
           * @type {Number}
           * @default 0.0
           */
          this.x = defaultValue(x, 0.0);
  
          /**
           * The Y component.
           * @type {Number}
           * @default 0.0
           */
          this.y = defaultValue(y, 0.0);
  
          /**
           * The Z component.
           * @type {Number}
           * @default 0.0
           */
          this.z = defaultValue(z, 0.0);
      };
  
      /**
       * Converts the provided Spherical into Cartesian3 coordinates.
       *
       * @param {Spherical} spherical The Spherical to be converted to Cartesian3.
       * @param {Cartesian3} [result] The object onto which to store the result.
       * @returns {Cartesian3} The modified result parameter or a new Cartesian3 instance if one was not provided.
       */
      Cartesian3.fromSpherical = function(spherical, result) {
                  if (!defined(spherical)) {
              throw new DeveloperError('spherical is required');
          }
          
          if (!defined(result)) {
              result = new Cartesian3();
          }
  
          var clock = spherical.clock;
          var cone = spherical.cone;
          var magnitude = defaultValue(spherical.magnitude, 1.0);
          var radial = magnitude * Math.sin(cone);
          result.x = radial * Math.cos(clock);
          result.y = radial * Math.sin(clock);
          result.z = magnitude * Math.cos(cone);
          return result;
      };
  
      /**
       * Creates a Cartesian3 instance from x, y and z coordinates.
       *
       * @param {Number} x The x coordinate.
       * @param {Number} y The y coordinate.
       * @param {Number} z The z coordinate.
       * @param {Cartesian3} [result] The object onto which to store the result.
       * @returns {Cartesian3} The modified result parameter or a new Cartesian3 instance if one was not provided.
       */
      Cartesian3.fromElements = function(x, y, z, result) {
          if (!defined(result)) {
              return new Cartesian3(x, y, z);
          }
  
          result.x = x;
          result.y = y;
          result.z = z;
          return result;
      };
  
      /**
       * Duplicates a Cartesian3 instance.
       *
       * @param {Cartesian3} cartesian The Cartesian to duplicate.
       * @param {Cartesian3} [result] The object onto which to store the result.
       * @returns {Cartesian3} The modified result parameter or a new Cartesian3 instance if one was not provided. (Returns undefined if cartesian is undefined)
       */
      Cartesian3.clone = function(cartesian, result) {
          if (!defined(cartesian)) {
              return undefined;
          }
          if (!defined(result)) {
              return new Cartesian3(cartesian.x, cartesian.y, cartesian.z);
          }
  
          result.x = cartesian.x;
          result.y = cartesian.y;
          result.z = cartesian.z;
          return result;
      };
  
      /**
       * Creates a Cartesian3 instance from an existing Cartesian4.  This simply takes the
       * x, y, and z properties of the Cartesian4 and drops w.
       * @function
       *
       * @param {Cartesian4} cartesian The Cartesian4 instance to create a Cartesian3 instance from.
       * @param {Cartesian3} [result] The object onto which to store the result.
       * @returns {Cartesian3} The modified result parameter or a new Cartesian3 instance if one was not provided.
       */
      Cartesian3.fromCartesian4 = Cartesian3.clone;
  
      /**
       * The number of elements used to pack the object into an array.
       * @type {Number}
       */
      Cartesian3.packedLength = 3;
  
      /**
       * Stores the provided instance into the provided array.
       *
       * @param {Cartesian3} value The value to pack.
       * @param {Number[]} array The array to pack into.
       * @param {Number} [startingIndex=0] The index into the array at which to start packing the elements.
       */
      Cartesian3.pack = function(value, array, startingIndex) {
                  if (!defined(value)) {
              throw new DeveloperError('value is required');
          }
  
          if (!defined(array)) {
              throw new DeveloperError('array is required');
          }
          
          startingIndex = defaultValue(startingIndex, 0);
  
          array[startingIndex++] = value.x;
          array[startingIndex++] = value.y;
          array[startingIndex] = value.z;
      };
  
      /**
       * Retrieves an instance from a packed array.
       *
       * @param {Number[]} array The packed array.
       * @param {Number} [startingIndex=0] The starting index of the element to be unpacked.
       * @param {Cartesian3} [result] The object into which to store the result.
       */
      Cartesian3.unpack = function(array, startingIndex, result) {
                  if (!defined(array)) {
              throw new DeveloperError('array is required');
          }
          
          startingIndex = defaultValue(startingIndex, 0);
  
          if (!defined(result)) {
              result = new Cartesian3();
          }
          result.x = array[startingIndex++];
          result.y = array[startingIndex++];
          result.z = array[startingIndex];
          return result;
      };
  
      /**
       * Creates a Cartesian3 from three consecutive elements in an array.
       * @function
       *
       * @param {Number[]} array The array whose three consecutive elements correspond to the x, y, and z components, respectively.
       * @param {Number} [startingIndex=0] The offset into the array of the first element, which corresponds to the x component.
       * @param {Cartesian3} [result] The object onto which to store the result.
       * @returns {Cartesian3} The modified result parameter or a new Cartesian3 instance if one was not provided.
       *
       * @example
       * // Create a Cartesian3 with (1.0, 2.0, 3.0)
       * var v = [1.0, 2.0, 3.0];
       * var p = Cesium.Cartesian3.fromArray(v);
       *
       * // Create a Cartesian3 with (1.0, 2.0, 3.0) using an offset into an array
       * var v2 = [0.0, 0.0, 1.0, 2.0, 3.0];
       * var p2 = Cesium.Cartesian3.fromArray(v2, 2);
       */
      Cartesian3.fromArray = Cartesian3.unpack;
  
      /**
       * Computes the value of the maximum component for the supplied Cartesian.
       *
       * @param {Cartesian3} cartesian The cartesian to use.
       * @returns {Number} The value of the maximum component.
       */
      Cartesian3.maximumComponent = function(cartesian) {
                  if (!defined(cartesian)) {
              throw new DeveloperError('cartesian is required');
          }
          
          return Math.max(cartesian.x, cartesian.y, cartesian.z);
      };
  
      /**
       * Computes the value of the minimum component for the supplied Cartesian.
       *
       * @param {Cartesian3} cartesian The cartesian to use.
       * @returns {Number} The value of the minimum component.
       */
      Cartesian3.minimumComponent = function(cartesian) {
                  if (!defined(cartesian)) {
              throw new DeveloperError('cartesian is required');
          }
          
          return Math.min(cartesian.x, cartesian.y, cartesian.z);
      };
  
      /**
       * Compares two Cartesians and computes a Cartesian which contains the minimum components of the supplied Cartesians.
       *
       * @param {Cartesian3} first A cartesian to compare.
       * @param {Cartesian3} second A cartesian to compare.
       * @param {Cartesian3} result The object into which to store the result.
       * @returns {Cartesian3} A cartesian with the minimum components.
       */
      Cartesian3.minimumByComponent = function(first, second, result) {
                  if (!defined(first)) {
              throw new DeveloperError('first is required.');
          }
          if (!defined(second)) {
              throw new DeveloperError('second is required.');
          }
          if (!defined(result)) {
              throw new DeveloperError('result is required.');
          }
          
          result.x = Math.min(first.x, second.x);
          result.y = Math.min(first.y, second.y);
          result.z = Math.min(first.z, second.z);
  
          return result;
      };
  
      /**
       * Compares two Cartesians and computes a Cartesian which contains the maximum components of the supplied Cartesians.
       *
       * @param {Cartesian3} first A cartesian to compare.
       * @param {Cartesian3} second A cartesian to compare.
       * @param {Cartesian3} result The object into which to store the result.
       * @returns {Cartesian3} A cartesian with the maximum components.
       */
      Cartesian3.maximumByComponent = function(first, second, result) {
                  if (!defined(first)) {
              throw new DeveloperError('first is required.');
          }
          if (!defined(second)) {
              throw new DeveloperError('second is required.');
          }
          if (!defined(result)) {
              throw new DeveloperError('result is required.');
          }
          
          result.x = Math.max(first.x, second.x);
          result.y = Math.max(first.y, second.y);
          result.z = Math.max(first.z, second.z);
          return result;
      };
  
      /**
       * Computes the provided Cartesian's squared magnitude.
       *
       * @param {Cartesian3} cartesian The Cartesian instance whose squared magnitude is to be computed.
       * @returns {Number} The squared magnitude.
       */
      Cartesian3.magnitudeSquared = function(cartesian) {
                  if (!defined(cartesian)) {
              throw new DeveloperError('cartesian is required');
          }
          
          return cartesian.x * cartesian.x + cartesian.y * cartesian.y + cartesian.z * cartesian.z;
      };
  
      /**
       * Computes the Cartesian's magnitude (length).
       *
       * @param {Cartesian3} cartesian The Cartesian instance whose magnitude is to be computed.
       * @returns {Number} The magnitude.
       */
      Cartesian3.magnitude = function(cartesian) {
          return Math.sqrt(Cartesian3.magnitudeSquared(cartesian));
      };
  
      var distanceScratch = new Cartesian3();
  
      /**
       * Computes the distance between two points
       *
       * @param {Cartesian3} left The first point to compute the distance from.
       * @param {Cartesian3} right The second point to compute the distance to.
       * @returns {Number} The distance between two points.
       *
       * @example
       * // Returns 1.0
       * var d = Cesium.Cartesian3.distance(new Cesium.Cartesian3(1.0, 0.0, 0.0), new Cesium.Cartesian3(2.0, 0.0, 0.0));
       */
      Cartesian3.distance = function(left, right) {
                  if (!defined(left) || !defined(right)) {
              throw new DeveloperError('left and right are required.');
          }
          
          Cartesian3.subtract(left, right, distanceScratch);
          return Cartesian3.magnitude(distanceScratch);
      };
  
      /**
       * Computes the normalized form of the supplied Cartesian.
       *
       * @param {Cartesian3} cartesian The Cartesian to be normalized.
       * @param {Cartesian3} result The object onto which to store the result.
       * @returns {Cartesian3} The modified result parameter.
       */
      Cartesian3.normalize = function(cartesian, result) {
                  if (!defined(cartesian)) {
              throw new DeveloperError('cartesian is required');
          }
          if (!defined(result)) {
              throw new DeveloperError('result is required');
          }
          
          var magnitude = Cartesian3.magnitude(cartesian);
  
          result.x = cartesian.x / magnitude;
          result.y = cartesian.y / magnitude;
          result.z = cartesian.z / magnitude;
          return result;
      };
  
      /**
       * Computes the dot (scalar) product of two Cartesians.
       *
       * @param {Cartesian3} left The first Cartesian.
       * @param {Cartesian3} right The second Cartesian.
       * @returns {Number} The dot product.
       */
      Cartesian3.dot = function(left, right) {
                  if (!defined(left)) {
              throw new DeveloperError('left is required');
          }
          if (!defined(right)) {
              throw new DeveloperError('right is required');
          }
          
          return left.x * right.x + left.y * right.y + left.z * right.z;
      };
  
      /**
       * Computes the componentwise product of two Cartesians.
       *
       * @param {Cartesian3} left The first Cartesian.
       * @param {Cartesian3} right The second Cartesian.
       * @param {Cartesian3} result The object onto which to store the result.
       * @returns {Cartesian3} The modified result parameter.
       */
      Cartesian3.multiplyComponents = function(left, right, result) {
                  if (!defined(left)) {
              throw new DeveloperError('left is required');
          }
          if (!defined(right)) {
              throw new DeveloperError('right is required');
          }
          if (!defined(result)) {
              throw new DeveloperError('result is required');
          }
          
          result.x = left.x * right.x;
          result.y = left.y * right.y;
          result.z = left.z * right.z;
          return result;
      };
  
      /**
       * Computes the componentwise sum of two Cartesians.
       *
       * @param {Cartesian3} left The first Cartesian.
       * @param {Cartesian3} right The second Cartesian.
       * @param {Cartesian3} result The object onto which to store the result.
       * @returns {Cartesian3} The modified result parameter.
       */
      Cartesian3.add = function(left, right, result) {
                  if (!defined(left)) {
              throw new DeveloperError('left is required');
          }
          if (!defined(right)) {
              throw new DeveloperError('right is required');
          }
          if (!defined(result)) {
              throw new DeveloperError('result is required');
          }
          
          result.x = left.x + right.x;
          result.y = left.y + right.y;
          result.z = left.z + right.z;
          return result;
      };
  
      /**
       * Computes the componentwise difference of two Cartesians.
       *
       * @param {Cartesian3} left The first Cartesian.
       * @param {Cartesian3} right The second Cartesian.
       * @param {Cartesian3} result The object onto which to store the result.
       * @returns {Cartesian3} The modified result parameter.
       */
      Cartesian3.subtract = function(left, right, result) {
                  if (!defined(left)) {
              throw new DeveloperError('left is required');
          }
          if (!defined(right)) {
              throw new DeveloperError('right is required');
          }
          if (!defined(result)) {
              throw new DeveloperError('result is required');
          }
          
          result.x = left.x - right.x;
          result.y = left.y - right.y;
          result.z = left.z - right.z;
          return result;
      };
  
      /**
       * Multiplies the provided Cartesian componentwise by the provided scalar.
       *
       * @param {Cartesian3} cartesian The Cartesian to be scaled.
       * @param {Number} scalar The scalar to multiply with.
       * @param {Cartesian3} result The object onto which to store the result.
       * @returns {Cartesian3} The modified result parameter.
       */
      Cartesian3.multiplyByScalar = function(cartesian, scalar, result) {
                  if (!defined(cartesian)) {
              throw new DeveloperError('cartesian is required');
          }
          if (typeof scalar !== 'number') {
              throw new DeveloperError('scalar is required and must be a number.');
          }
          if (!defined(result)) {
              throw new DeveloperError('result is required');
          }
          
          result.x = cartesian.x * scalar;
          result.y = cartesian.y * scalar;
          result.z = cartesian.z * scalar;
          return result;
      };
  
      /**
       * Divides the provided Cartesian componentwise by the provided scalar.
       *
       * @param {Cartesian3} cartesian The Cartesian to be divided.
       * @param {Number} scalar The scalar to divide by.
       * @param {Cartesian3} result The object onto which to store the result.
       * @returns {Cartesian3} The modified result parameter.
       */
      Cartesian3.divideByScalar = function(cartesian, scalar, result) {
                  if (!defined(cartesian)) {
              throw new DeveloperError('cartesian is required');
          }
          if (typeof scalar !== 'number') {
              throw new DeveloperError('scalar is required and must be a number.');
          }
          if (!defined(result)) {
              throw new DeveloperError('result is required');
          }
          
          result.x = cartesian.x / scalar;
          result.y = cartesian.y / scalar;
          result.z = cartesian.z / scalar;
          return result;
      };
  
      /**
       * Negates the provided Cartesian.
       *
       * @param {Cartesian3} cartesian The Cartesian to be negated.
       * @param {Cartesian3} result The object onto which to store the result.
       * @returns {Cartesian3} The modified result parameter.
       */
      Cartesian3.negate = function(cartesian, result) {
                  if (!defined(cartesian)) {
              throw new DeveloperError('cartesian is required');
          }
          if (!defined(result)) {
              throw new DeveloperError('result is required');
          }
          
          result.x = -cartesian.x;
          result.y = -cartesian.y;
          result.z = -cartesian.z;
          return result;
      };
  
      /**
       * Computes the absolute value of the provided Cartesian.
       *
       * @param {Cartesian3} cartesian The Cartesian whose absolute value is to be computed.
       * @param {Cartesian3} result The object onto which to store the result.
       * @returns {Cartesian3} The modified result parameter.
       */
      Cartesian3.abs = function(cartesian, result) {
                  if (!defined(cartesian)) {
              throw new DeveloperError('cartesian is required');
          }
          if (!defined(result)) {
              throw new DeveloperError('result is required');
          }
          
          result.x = Math.abs(cartesian.x);
          result.y = Math.abs(cartesian.y);
          result.z = Math.abs(cartesian.z);
          return result;
      };
  
      var lerpScratch = new Cartesian3();
      /**
       * Computes the linear interpolation or extrapolation at t using the provided cartesians.
       *
       * @param {Cartesian3} start The value corresponding to t at 0.0.
       * @param {Cartesian3} end The value corresponding to t at 1.0.
       * @param {Number} t The point along t at which to interpolate.
       * @param {Cartesian3} result The object onto which to store the result.
       * @returns {Cartesian3} The modified result parameter.
       */
      Cartesian3.lerp = function(start, end, t, result) {
                  if (!defined(start)) {
              throw new DeveloperError('start is required.');
          }
          if (!defined(end)) {
              throw new DeveloperError('end is required.');
          }
          if (typeof t !== 'number') {
              throw new DeveloperError('t is required and must be a number.');
          }
          if (!defined(result)) {
              throw new DeveloperError('result is required.');
          }
          
          Cartesian3.multiplyByScalar(end, t, lerpScratch);
          result = Cartesian3.multiplyByScalar(start, 1.0 - t, result);
          return Cartesian3.add(lerpScratch, result, result);
      };
  
      var angleBetweenScratch = new Cartesian3();
      var angleBetweenScratch2 = new Cartesian3();
      /**
       * Returns the angle, in radians, between the provided Cartesians.
       *
       * @param {Cartesian3} left The first Cartesian.
       * @param {Cartesian3} right The second Cartesian.
       * @returns {Number} The angle between the Cartesians.
       */
      Cartesian3.angleBetween = function(left, right) {
                  if (!defined(left)) {
              throw new DeveloperError('left is required');
          }
          if (!defined(right)) {
              throw new DeveloperError('right is required');
          }
          
          Cartesian3.normalize(left, angleBetweenScratch);
          Cartesian3.normalize(right, angleBetweenScratch2);
          var cosine = Cartesian3.dot(angleBetweenScratch, angleBetweenScratch2);
          var sine = Cartesian3.magnitude(Cartesian3.cross(angleBetweenScratch, angleBetweenScratch2, angleBetweenScratch));
          return Math.atan2(sine, cosine);
      };
  
      var mostOrthogonalAxisScratch = new Cartesian3();
      /**
       * Returns the axis that is most orthogonal to the provided Cartesian.
       *
       * @param {Cartesian3} cartesian The Cartesian on which to find the most orthogonal axis.
       * @param {Cartesian3} result The object onto which to store the result.
       * @returns {Cartesian3} The most orthogonal axis.
       */
      Cartesian3.mostOrthogonalAxis = function(cartesian, result) {
                  if (!defined(cartesian)) {
              throw new DeveloperError('cartesian is required.');
          }
          if (!defined(result)) {
              throw new DeveloperError('result is required.');
          }
          
          var f = Cartesian3.normalize(cartesian, mostOrthogonalAxisScratch);
          Cartesian3.abs(f, f);
  
          if (f.x <= f.y) {
              if (f.x <= f.z) {
                  result = Cartesian3.clone(Cartesian3.UNIT_X, result);
              } else {
                  result = Cartesian3.clone(Cartesian3.UNIT_Z, result);
              }
          } else {
              if (f.y <= f.z) {
                  result = Cartesian3.clone(Cartesian3.UNIT_Y, result);
              } else {
                  result = Cartesian3.clone(Cartesian3.UNIT_Z, result);
              }
          }
  
          return result;
      };
  
      /**
       * Compares the provided Cartesians componentwise and returns
       * <code>true</code> if they are equal, <code>false</code> otherwise.
       *
       * @param {Cartesian3} [left] The first Cartesian.
       * @param {Cartesian3} [right] The second Cartesian.
       * @returns {Boolean} <code>true</code> if left and right are equal, <code>false</code> otherwise.
       */
      Cartesian3.equals = function(left, right) {
              return (left === right) ||
                ((defined(left)) &&
                 (defined(right)) &&
                 (left.x === right.x) &&
                 (left.y === right.y) &&
                 (left.z === right.z));
      };
  
      /**
       * Compares the provided Cartesians componentwise and returns
       * <code>true</code> if they are within the provided epsilon,
       * <code>false</code> otherwise.
       *
       * @param {Cartesian3} [left] The first Cartesian.
       * @param {Cartesian3} [right] The second Cartesian.
       * @param {Number} epsilon The epsilon to use for equality testing.
       * @returns {Boolean} <code>true</code> if left and right are within the provided epsilon, <code>false</code> otherwise.
       */
      Cartesian3.equalsEpsilon = function(left, right, epsilon) {
                  if (typeof epsilon !== 'number') {
              throw new DeveloperError('epsilon is required and must be a number.');
          }
          
          return (left === right) ||
                 ((defined(left)) &&
                  (defined(right)) &&
                  (Math.abs(left.x - right.x) <= epsilon) &&
                  (Math.abs(left.y - right.y) <= epsilon) &&
                  (Math.abs(left.z - right.z) <= epsilon));
      };
  
      /**
       * Computes the cross (outer) product of two Cartesians.
       *
       * @param {Cartesian3} left The first Cartesian.
       * @param {Cartesian3} right The second Cartesian.
       * @param {Cartesian3} result The object onto which to store the result.
       * @returns {Cartesian3} The cross product.
       */
      Cartesian3.cross = function(left, right, result) {
                  if (!defined(left)) {
              throw new DeveloperError('left is required');
          }
          if (!defined(right)) {
              throw new DeveloperError('right is required');
          }
          if (!defined(result)) {
              throw new DeveloperError('result is required');
          }
          
          var leftX = left.x;
          var leftY = left.y;
          var leftZ = left.z;
          var rightX = right.x;
          var rightY = right.y;
          var rightZ = right.z;
  
          var x = leftY * rightZ - leftZ * rightY;
          var y = leftZ * rightX - leftX * rightZ;
          var z = leftX * rightY - leftY * rightX;
  
          result.x = x;
          result.y = y;
          result.z = z;
          return result;
      };
  
      /**
       * Returns a Cartesian3 position from longitude and latitude values given in degrees.
       *
       * @param {Number} longitude The longitude, in degrees
       * @param {Number} latitude The latitude, in degrees
       * @param {Number} [height=0.0] The height, in meters, above the ellipsoid.
       * @param {Ellipsoid} [ellipsoid=Ellipsoid.WGS84] The ellipsoid on which the position lies.
       * @param {Cartesian3} [result] The object onto which to store the result.
       * @returns {Cartesian3} The position
       *
       * @example
       * var position = Cesium.Cartesian3.fromDegrees(-115.0, 37.0);
       */
      Cartesian3.fromDegrees = function(longitude, latitude, height, ellipsoid, result) {
                  if (!defined(longitude)) {
              throw new DeveloperError('longitude is required');
          }
          if (!defined(latitude)) {
              throw new DeveloperError('latitude is required');
          }
          
          var lon = CesiumMath.toRadians(longitude);
          var lat = CesiumMath.toRadians(latitude);
          return Cartesian3.fromRadians(lon, lat, height, ellipsoid, result);
      };
  
      var scratchN = new Cartesian3();
      var scratchK = new Cartesian3();
      var wgs84RadiiSquared = new Cartesian3(6378137.0 * 6378137.0, 6378137.0 * 6378137.0, 6356752.3142451793 * 6356752.3142451793);
  
      /**
       * Returns a Cartesian3 position from longitude and latitude values given in radians.
       *
       * @param {Number} longitude The longitude, in radians
       * @param {Number} latitude The latitude, in radians
       * @param {Number} [height=0.0] The height, in meters, above the ellipsoid.
       * @param {Ellipsoid} [ellipsoid=Ellipsoid.WGS84] The ellipsoid on which the position lies.
       * @param {Cartesian3} [result] The object onto which to store the result.
       * @returns {Cartesian3} The position
       *
       * @example
       * var position = Cesium.Cartesian3.fromRadians(-2.007, 0.645);
       */
      Cartesian3.fromRadians = function(longitude, latitude, height, ellipsoid, result) {
                  if (!defined(longitude)) {
              throw new DeveloperError('longitude is required');
          }
          if (!defined(latitude)) {
              throw new DeveloperError('latitude is required');
          }
          
          height = defaultValue(height, 0.0);
          var radiiSquared = defined(ellipsoid) ? ellipsoid.radiiSquared : wgs84RadiiSquared;
  
          var cosLatitude = Math.cos(latitude);
          scratchN.x = cosLatitude * Math.cos(longitude);
          scratchN.y = cosLatitude * Math.sin(longitude);
          scratchN.z = Math.sin(latitude);
          scratchN = Cartesian3.normalize(scratchN, scratchN);
  
          Cartesian3.multiplyComponents(radiiSquared, scratchN, scratchK);
          var gamma = Math.sqrt(Cartesian3.dot(scratchN, scratchK));
          scratchK = Cartesian3.divideByScalar(scratchK, gamma, scratchK);
          scratchN = Cartesian3.multiplyByScalar(scratchN, height, scratchN);
  
          if (!defined(result)) {
              result = new Cartesian3();
          }
          return Cartesian3.add(scratchK, scratchN, result);
      };
  
      /**
       * Returns an array of Cartesian3 positions given an array of longitude and latitude values given in degrees.
       *
       * @param {Number[]} coordinates A list of longitude and latitude values. Values alternate [longitude, latitude, longitude, latitude...].
       * @param {Ellipsoid} [ellipsoid=Ellipsoid.WGS84] The ellipsoid on which the coordinates lie.
       * @param {Cartesian3[]} [result] An array of Cartesian3 objects to store the result.
       * @returns {Cartesian3[]} The array of positions.
       *
       * @example
       * var positions = Cesium.Cartesian3.fromDegreesArray([-115.0, 37.0, -107.0, 33.0]);
       */
      Cartesian3.fromDegreesArray = function(coordinates, ellipsoid, result) {
                  if (!defined(coordinates)) {
              throw new DeveloperError('positions is required.');
          }
          
          var pos = new Array(coordinates.length);
          for (var i = 0; i < coordinates.length; i++) {
              pos[i] = CesiumMath.toRadians(coordinates[i]);
          }
  
          return Cartesian3.fromRadiansArray(pos, ellipsoid, result);
      };
  
      /**
       * Returns an array of Cartesian3 positions given an array of longitude and latitude values given in radians.
       *
       * @param {Number[]} coordinates A list of longitude and latitude values. Values alternate [longitude, latitude, longitude, latitude...].
       * @param {Ellipsoid} [ellipsoid=Ellipsoid.WGS84] The ellipsoid on which the coordinates lie.
       * @param {Cartesian3[]} [result] An array of Cartesian3 objects to store the result.
       * @returns {Cartesian3[]} The array of positions.
       *
       * @example
       * var positions = Cesium.Cartesian3.fromRadiansArray([-2.007, 0.645, -1.867, .575]);
       */
      Cartesian3.fromRadiansArray = function(coordinates, ellipsoid, result) {
                  if (!defined(coordinates)) {
              throw new DeveloperError('positions is required.');
          }
          if (coordinates.length < 2) {
              throw new DeveloperError('positions length cannot be less than 2.');
          }
          if (coordinates.length % 2 !== 0) {
              throw new DeveloperError('positions length must be a multiple of 2.');
          }
          
          var length = coordinates.length;
          if (!defined(result)) {
              result = new Array(length/2);
          } else {
              result.length = length/2;
          }
  
          for ( var i = 0; i < length; i+=2) {
              var lon = coordinates[i];
              var lat = coordinates[i+1];
              result[i/2] = Cartesian3.fromRadians(lon, lat, 0, ellipsoid, result[i/2]);
          }
  
          return result;
      };
  
      /**
       * Returns an array of Cartesian3 positions given an array of longitude, latitude and height values where longitude and latitude are given in degrees.
       *
       * @param {Number[]} coordinates A list of longitude, latitude and height values. Values alternate [longitude, latitude, height,, longitude, latitude, height...].
       * @param {Ellipsoid} [ellipsoid=Ellipsoid.WGS84] The ellipsoid on which the position lies.
       * @param {Cartesian3[]} [result] An array of Cartesian3 objects to store the result.
       * @returns {Cartesian3[]} The array of positions.
       *
       * @example
       * var positions = Cesium.Cartesian3.fromDegreesArrayHeights([-115.0, 37.0, 100000.0, -107.0, 33.0, 150000.0]);
       */
      Cartesian3.fromDegreesArrayHeights = function(coordinates, ellipsoid, result) {
                  if (!defined(coordinates)) {
              throw new DeveloperError('positions is required.');
          }
          if (coordinates.length < 3) {
              throw new DeveloperError('positions length cannot be less than 3.');
          }
          if (coordinates.length % 3 !== 0) {
              throw new DeveloperError('positions length must be a multiple of 3.');
          }
          
          var pos = new Array(coordinates.length);
          for (var i = 0; i < coordinates.length; i+=3) {
              pos[i] = CesiumMath.toRadians(coordinates[i]);
              pos[i+1] = CesiumMath.toRadians(coordinates[i+1]);
              pos[i+2] = coordinates[i+2];
          }
  
          return Cartesian3.fromRadiansArrayHeights(pos, ellipsoid, result);
      };
  
      /**
       * Returns an array of Cartesian3 positions given an array of longitude, latitude and height values where longitude and latitude are given in radians.
       *
       * @param {Number[]} coordinates A list of longitude, latitude and height values. Values alternate [longitude, latitude, height,, longitude, latitude, height...].
       * @param {Ellipsoid} [ellipsoid=Ellipsoid.WGS84] The ellipsoid on which the position lies.
       * @param {Cartesian3[]} [result] An array of Cartesian3 objects to store the result.
       * @returns {Cartesian3[]} The array of positions.
       *
       * @example
       * var positions = Cesium.Cartesian3.fromRadiansArrayHeights([-2.007, 0.645, 100000.0, -1.867, .575, 150000.0]);
       */
      Cartesian3.fromRadiansArrayHeights = function(coordinates, ellipsoid, result) {
                  if (!defined(coordinates)) {
              throw new DeveloperError('positions is required.');
          }
          if (coordinates.length < 3) {
              throw new DeveloperError('positions length cannot be less than 3.');
          }
          if (coordinates.length % 3 !== 0) {
              throw new DeveloperError('positions length must be a multiple of 3.');
          }
          
          var length = coordinates.length;
          if (!defined(result)) {
              result = new Array(length/3);
          } else {
              result.length = length/3;
          }
  
          for ( var i = 0; i < length; i+=3) {
              var lon = coordinates[i];
              var lat = coordinates[i+1];
              var alt = coordinates[i+2];
              result[i/3] = Cartesian3.fromRadians(lon, lat, alt, ellipsoid, result[i/3]);
          }
  
          return result;
      };
  
      /**
       * An immutable Cartesian3 instance initialized to (0.0, 0.0, 0.0).
       *
       * @type {Cartesian3}
       * @constant
       */
      Cartesian3.ZERO = freezeObject(new Cartesian3(0.0, 0.0, 0.0));
  
      /**
       * An immutable Cartesian3 instance initialized to (1.0, 0.0, 0.0).
       *
       * @type {Cartesian3}
       * @constant
       */
      Cartesian3.UNIT_X = freezeObject(new Cartesian3(1.0, 0.0, 0.0));
  
      /**
       * An immutable Cartesian3 instance initialized to (0.0, 1.0, 0.0).
       *
       * @type {Cartesian3}
       * @constant
       */
      Cartesian3.UNIT_Y = freezeObject(new Cartesian3(0.0, 1.0, 0.0));
  
      /**
       * An immutable Cartesian3 instance initialized to (0.0, 0.0, 1.0).
       *
       * @type {Cartesian3}
       * @constant
       */
      Cartesian3.UNIT_Z = freezeObject(new Cartesian3(0.0, 0.0, 1.0));
  
      /**
       * Duplicates this Cartesian3 instance.
       *
       * @param {Cartesian3} [result] The object onto which to store the result.
       * @returns {Cartesian3} The modified result parameter or a new Cartesian3 instance if one was not provided.
       */
      Cartesian3.prototype.clone = function(result) {
          return Cartesian3.clone(this, result);
      };
  
      /**
       * Compares this Cartesian against the provided Cartesian componentwise and returns
       * <code>true</code> if they are equal, <code>false</code> otherwise.
       *
       * @param {Cartesian3} [right] The right hand side Cartesian.
       * @returns {Boolean} <code>true</code> if they are equal, <code>false</code> otherwise.
       */
      Cartesian3.prototype.equals = function(right) {
          return Cartesian3.equals(this, right);
      };
  
      /**
       * Compares this Cartesian against the provided Cartesian componentwise and returns
       * <code>true</code> if they are within the provided epsilon,
       * <code>false</code> otherwise.
       *
       * @param {Cartesian3} [right] The right hand side Cartesian.
       * @param {Number} epsilon The epsilon to use for equality testing.
       * @returns {Boolean} <code>true</code> if they are within the provided epsilon, <code>false</code> otherwise.
       */
      Cartesian3.prototype.equalsEpsilon = function(right, epsilon) {
          return Cartesian3.equalsEpsilon(this, right, epsilon);
      };
  
      /**
       * Creates a string representing this Cartesian in the format '(x, y, z)'.
       *
       * @returns {String} A string representing this Cartesian in the format '(x, y, z)'.
       */
      Cartesian3.prototype.toString = function() {
          return '(' + this.x + ', ' + this.y + ', ' + this.z + ')';
      };
  
      return Cartesian3;
  });
  
  /*global define*/
  define('Core/AttributeCompression',[
          './Cartesian2',
          './Cartesian3',
          './defined',
          './DeveloperError',
          './Math'
      ], function(
          Cartesian2,
          Cartesian3,
          defined,
          DeveloperError,
          CesiumMath) {
      "use strict";
  
      /**
       * Attribute compression and decompression functions.
       *
       * @namespace
       * @alias AttributeCompression
       *
       * @private
       */
      var AttributeCompression = {};
  
      /**
       * Encodes a normalized vector into 2 SNORM values in the range of [0-255] following the 'oct' encoding.
       *
       * Oct encoding is a compact representation of unit length vectors.  The encoding and decoding functions are low cost, and represent the normalized vector within 1 degree of error.
       * The 'oct' encoding is described in "A Survey of Efficient Representations of Independent Unit Vectors",
       * Cigolle et al 2014: {@link http://jcgt.org/published/0003/02/01/}
       *
       * @param {Cartesian3} vector The normalized vector to be compressed into 2 byte 'oct' encoding.
       * @param {Cartesian2} result The 2 byte oct-encoded unit length vector.
       * @returns {Cartesian2} The 2 byte oct-encoded unit length vector.
       *
       * @exception {DeveloperError} vector must be defined.
       * @exception {DeveloperError} result must be defined.
       * @exception {DeveloperError} vector must be normalized.
       *
       * @see AttributeCompression.octDecode
       */
      AttributeCompression.octEncode = function(vector, result) {
                  if (!defined(vector)) {
              throw new DeveloperError('vector is required.');
          }
          if (!defined(result)) {
              throw new DeveloperError('result is required.');
          }
          var magSquared = Cartesian3.magnitudeSquared(vector);
          if (Math.abs(magSquared - 1.0) > CesiumMath.EPSILON6) {
              throw new DeveloperError('vector must be normalized.');
          }
          
          result.x = vector.x / (Math.abs(vector.x) + Math.abs(vector.y) + Math.abs(vector.z));
          result.y = vector.y / (Math.abs(vector.x) + Math.abs(vector.y) + Math.abs(vector.z));
          if (vector.z < 0) {
              var x = result.x;
              var y = result.y;
              result.x = (1.0 - Math.abs(y)) * CesiumMath.signNotZero(x);
              result.y = (1.0 - Math.abs(x)) * CesiumMath.signNotZero(y);
          }
  
          result.x = CesiumMath.toSNorm(result.x);
          result.y = CesiumMath.toSNorm(result.y);
  
          return result;
      };
  
      /**
       * Decodes a unit-length vector in 'oct' encoding to a normalized 3-component vector.
       *
       * @param {Number} x The x component of the oct-encoded unit length vector.
       * @param {Number} y The y component of the oct-encoded unit length vector.
       * @param {Cartesian3} result The decoded and normalized vector
       * @returns {Cartesian3} The decoded and normalized vector.
       *
       * @exception {DeveloperError} result must be defined.
       * @exception {DeveloperError} x and y must be a signed normalized integer between 0 and 255.
       *
       * @see AttributeCompression.octEncode
       */
      AttributeCompression.octDecode = function(x, y, result) {
                  if (!defined(result)) {
              throw new DeveloperError('result is required.');
          }
          if (x < 0 || x > 255 || y < 0 || y > 255) {
              throw new DeveloperError('x and y must be a signed normalized integer between 0 and 255');
          }
          
          result.x = CesiumMath.fromSNorm(x);
          result.y = CesiumMath.fromSNorm(y);
          result.z = 1.0 - (Math.abs(result.x) + Math.abs(result.y));
  
          if (result.z < 0.0)
          {
              var oldVX = result.x;
              result.x = (1.0 - Math.abs(result.y)) * CesiumMath.signNotZero(oldVX);
              result.y = (1.0 - Math.abs(oldVX)) * CesiumMath.signNotZero(result.y);
          }
  
          return Cartesian3.normalize(result, result);
      };
  
      /**
       * Packs an oct encoded vector into a single floating-point number.
       *
       * @param {Cartesian2} encoded The oct encoded vector.
       * @returns {Number} The oct encoded vector packed into a single float.
       *
       * @exception {DeveloperError} encoded is required.
       */
      AttributeCompression.octPackFloat = function(encoded) {
                  if (!defined(encoded)) {
              throw new DeveloperError('encoded is required.');
          }
                  return 256.0 * encoded.x + encoded.y;
      };
  
      var scratchEncodeCart2 = new Cartesian2();
  
      /**
       * Encodes a normalized vector into 2 SNORM values in the range of [0-255] following the 'oct' encoding and
       * stores those values in a single float-point number.
       *
       * @param {Cartesian3} vector The normalized vector to be compressed into 2 byte 'oct' encoding.
       * @returns {Number} The 2 byte oct-encoded unit length vector.
       *
       * @exception {DeveloperError} vector must be defined.
       * @exception {DeveloperError} vector must be normalized.
       */
      AttributeCompression.octEncodeFloat = function(vector) {
          AttributeCompression.octEncode(vector, scratchEncodeCart2);
          return AttributeCompression.octPackFloat(scratchEncodeCart2);
      };
  
      /**
       * Decodes a unit-length vector in 'oct' encoding packed in a floating-point number to a normalized 3-component vector.
       *
       * @param {Number} value The oct-encoded unit length vector stored as a single floating-point number.
       * @param {Cartesian3} result The decoded and normalized vector
       * @returns {Cartesian3} The decoded and normalized vector.
       *
       * @exception {DeveloperError} value must be defined.
       * @exception {DeveloperError} result must be defined.
       */
      AttributeCompression.octDecodeFloat = function(value, result) {
                  if (!defined(value)) {
              throw new DeveloperError('value is required.');
          }
          
          var temp = value / 256.0;
          var x = Math.floor(temp);
          var y = (temp - x) * 256.0;
  
          return AttributeCompression.octDecode(x, y, result);
      };
  
      /**
       * Encodes three normalized vectors into 6 SNORM values in the range of [0-255] following the 'oct' encoding and
       * packs those into two floating-point numbers.
       *
       * @param {Cartesian3} v1 A normalized vector to be compressed.
       * @param {Cartesian3} v2 A normalized vector to be compressed.
       * @param {Cartesian3} v3 A normalized vector to be compressed.
       * @param {Cartesian2} result The 'oct' encoded vectors packed into two floating-point numbers.
       * @returns {Cartesian2} The 'oct' encoded vectors packed into two floating-point numbers.
       *
       * @exception {DeveloperError} v1 must be defined.
       * @exception {DeveloperError} v2 must be defined.
       * @exception {DeveloperError} v3 must be defined.
       * @exception {DeveloperError} result must be defined.
       */
      AttributeCompression.octPack = function(v1, v2, v3, result) {
                  if (!defined(v1)) {
              throw new DeveloperError('v1 is required.');
          }
          if (!defined(v2)) {
              throw new DeveloperError('v2 is required.');
          }
          if (!defined(v3)) {
              throw new DeveloperError('v3 is required.');
          }
          if (!defined(result)) {
              throw new DeveloperError('result is required.');
          }
          
          var encoded1 = AttributeCompression.octEncodeFloat(v1);
          var encoded2 = AttributeCompression.octEncodeFloat(v2);
  
          var encoded3 = AttributeCompression.octEncode(v3, scratchEncodeCart2);
          result.x = 65536.0 * encoded3.x + encoded1;
          result.y = 65536.0 * encoded3.y + encoded2;
          return result;
      };
  
      /**
       * Decodes three unit-length vectors in 'oct' encoding packed into a floating-point number to a normalized 3-component vector.
       *
       * @param {Cartesian2} packed The three oct-encoded unit length vectors stored as two floating-point number.
       * @param {Cartesian3} v1 One decoded and normalized vector.
       * @param {Cartesian3} v2 One decoded and normalized vector.
       * @param {Cartesian3} v3 One decoded and normalized vector.
       *
       * @exception {DeveloperError} packed must be defined.
       * @exception {DeveloperError} v1 must be defined.
       * @exception {DeveloperError} v2 must be defined.
       * @exception {DeveloperError} v3 must be defined.
       */
      AttributeCompression.octUnpack = function(packed, v1, v2, v3) {
                  if (!defined(packed)) {
              throw new DeveloperError('packed is required.');
          }
          if (!defined(v1)) {
              throw new DeveloperError('v1 is required.');
          }
          if (!defined(v2)) {
              throw new DeveloperError('v2 is required.');
          }
          if (!defined(v3)) {
              throw new DeveloperError('v3 is required.');
          }
          
          var temp = packed.x / 65536.0;
          var x = Math.floor(temp);
          var encodedFloat1 = (temp - x) * 65536.0;
  
          temp = packed.y / 65536.0;
          var y = Math.floor(temp);
          var encodedFloat2 = (temp - y) * 65536.0;
  
          AttributeCompression.octDecodeFloat(encodedFloat1, v1);
          AttributeCompression.octDecodeFloat(encodedFloat2, v2);
          AttributeCompression.octDecode(x, y, v3);
      };
  
      /**
       * Pack texture coordinates into a single float. The texture coordinates will only preserve 12 bits of precision.
       *
       * @param {Cartesian2} textureCoordinates The texture coordinates to compress
       * @returns {Number} The packed texture coordinates.
       *
       * @exception {DeveloperError} textureCoordinates is required.
       */
      AttributeCompression.compressTextureCoordinates = function(textureCoordinates) {
                  if (!defined(textureCoordinates)) {
              throw new DeveloperError('textureCoordinates is required.');
          }
          
          var x = textureCoordinates.x === 1.0 ? 4095.0 : (textureCoordinates.x * 4096.0) | 0;
          var y = textureCoordinates.y === 1.0 ? 4095.0 : (textureCoordinates.y * 4096.0) | 0;
          return 4096.0 * x + y;
      };
  
      /**
       * Decompresses texture coordinates that were packed into a single float.
       *
       * @param {Number} compressed The compressed texture coordinates.
       * @param {Cartesian2} result The decompressed texture coordinates.
       * @returns {Cartesian2} The modified result parameter.
       *
       * @exception {DeveloperError} compressed is required.
       * @exception {DeveloperError} result is required.
       */
      AttributeCompression.decompressTextureCoordinates = function(compressed, result) {
                  if (!defined(compressed)) {
              throw new DeveloperError('compressed is required.');
          }
          if (!defined(result)) {
              throw new DeveloperError('result is required.');
          }
          
          var temp = compressed / 4096.0;
          result.x = Math.floor(temp) / 4096.0;
          result.y = temp - Math.floor(temp);
          return result;
      };
  
      return AttributeCompression;
  });
  /*global define*/
  define('Core/Cartographic',[
          './defaultValue',
          './defined',
          './DeveloperError',
          './freezeObject',
          './Math'
      ], function(
          defaultValue,
          defined,
          DeveloperError,
          freezeObject,
          CesiumMath) {
      "use strict";
  
      /**
       * A position defined by longitude, latitude, and height.
       * @alias Cartographic
       * @constructor
       *
       * @param {Number} [longitude=0.0] The longitude, in radians.
       * @param {Number} [latitude=0.0] The latitude, in radians.
       * @param {Number} [height=0.0] The height, in meters, above the ellipsoid.
       *
       * @see Ellipsoid
       */
      var Cartographic = function(longitude, latitude, height) {
          /**
           * The longitude, in radians.
           * @type {Number}
           * @default 0.0
           */
          this.longitude = defaultValue(longitude, 0.0);
  
          /**
           * The latitude, in radians.
           * @type {Number}
           * @default 0.0
           */
          this.latitude = defaultValue(latitude, 0.0);
  
          /**
           * The height, in meters, above the ellipsoid.
           * @type {Number}
           * @default 0.0
           */
          this.height = defaultValue(height, 0.0);
      };
  
      /**
       * Creates a new Cartographic instance from longitude and latitude
       * specified in radians.
       *
       * @param {Number} longitude The longitude, in radians.
       * @param {Number} latitude The latitude, in radians.
       * @param {Number} [height=0.0] The height, in meters, above the ellipsoid.
       * @param {Cartographic} [result] The object onto which to store the result.
       * @returns {Cartographic} The modified result parameter or a new Cartographic instance if one was not provided.
       */
      Cartographic.fromRadians = function(longitude, latitude, height, result) {
                  if (!defined(longitude)) {
              throw new DeveloperError('longitude is required.');
          }
          if (!defined(latitude)) {
              throw new DeveloperError('latitude is required.');
          }
          
          height = defaultValue(height, 0.0);
  
          if (!defined(result)) {
              return new Cartographic(longitude, latitude, height);
          }
  
          result.longitude = longitude;
          result.latitude = latitude;
          result.height = height;
          return result;
      };
  
      /**
       * Creates a new Cartographic instance from longitude and latitude
       * specified in degrees.  The values in the resulting object will
       * be in radians.
       *
       * @param {Number} longitude The longitude, in degrees.
       * @param {Number} latitude The latitude, in degrees.
       * @param {Number} [height=0.0] The height, in meters, above the ellipsoid.
       * @param {Cartographic} [result] The object onto which to store the result.
       * @returns {Cartographic} The modified result parameter or a new Cartographic instance if one was not provided.
       */
      Cartographic.fromDegrees = function(longitude, latitude, height, result) {
                  if (!defined(longitude)) {
              throw new DeveloperError('longitude is required.');
          }
          if (!defined(latitude)) {
              throw new DeveloperError('latitude is required.');
          }
                  longitude = CesiumMath.toRadians(longitude);
          latitude = CesiumMath.toRadians(latitude);
  
          return Cartographic.fromRadians(longitude, latitude, height, result);
      };
  
      /**
       * Duplicates a Cartographic instance.
       *
       * @param {Cartographic} cartographic The cartographic to duplicate.
       * @param {Cartographic} [result] The object onto which to store the result.
       * @returns {Cartographic} The modified result parameter or a new Cartographic instance if one was not provided. (Returns undefined if cartographic is undefined)
       */
      Cartographic.clone = function(cartographic, result) {
          if (!defined(cartographic)) {
              return undefined;
          }
          if (!defined(result)) {
              return new Cartographic(cartographic.longitude, cartographic.latitude, cartographic.height);
          }
          result.longitude = cartographic.longitude;
          result.latitude = cartographic.latitude;
          result.height = cartographic.height;
          return result;
      };
  
      /**
       * Compares the provided cartographics componentwise and returns
       * <code>true</code> if they are equal, <code>false</code> otherwise.
       *
       * @param {Cartographic} [left] The first cartographic.
       * @param {Cartographic} [right] The second cartographic.
       * @returns {Boolean} <code>true</code> if left and right are equal, <code>false</code> otherwise.
       */
      Cartographic.equals = function(left, right) {
          return (left === right) ||
                  ((defined(left)) &&
                   (defined(right)) &&
                   (left.longitude === right.longitude) &&
                   (left.latitude === right.latitude) &&
                   (left.height === right.height));
      };
  
      /**
       * Compares the provided cartographics componentwise and returns
       * <code>true</code> if they are within the provided epsilon,
       * <code>false</code> otherwise.
       *
       * @param {Cartographic} [left] The first cartographic.
       * @param {Cartographic} [right] The second cartographic.
       * @param {Number} epsilon The epsilon to use for equality testing.
       * @returns {Boolean} <code>true</code> if left and right are within the provided epsilon, <code>false</code> otherwise.
       */
      Cartographic.equalsEpsilon = function(left, right, epsilon) {
                  if (typeof epsilon !== 'number') {
              throw new DeveloperError('epsilon is required and must be a number.');
          }
          
          return (left === right) ||
                 ((defined(left)) &&
                  (defined(right)) &&
                  (Math.abs(left.longitude - right.longitude) <= epsilon) &&
                  (Math.abs(left.latitude - right.latitude) <= epsilon) &&
                  (Math.abs(left.height - right.height) <= epsilon));
      };
  
      /**
       * An immutable Cartographic instance initialized to (0.0, 0.0, 0.0).
       *
       * @type {Cartographic}
       * @constant
       */
      Cartographic.ZERO = freezeObject(new Cartographic(0.0, 0.0, 0.0));
  
      /**
       * Duplicates this instance.
       *
       * @param {Cartographic} [result] The object onto which to store the result.
       * @returns {Cartographic} The modified result parameter or a new Cartographic instance if one was not provided.
       */
      Cartographic.prototype.clone = function(result) {
          return Cartographic.clone(this, result);
      };
  
      /**
       * Compares the provided against this cartographic componentwise and returns
       * <code>true</code> if they are equal, <code>false</code> otherwise.
       *
       * @param {Cartographic} [right] The second cartographic.
       * @returns {Boolean} <code>true</code> if left and right are equal, <code>false</code> otherwise.
       */
      Cartographic.prototype.equals = function(right) {
          return Cartographic.equals(this, right);
      };
  
      /**
       * Compares the provided against this cartographic componentwise and returns
       * <code>true</code> if they are within the provided epsilon,
       * <code>false</code> otherwise.
       *
       * @param {Cartographic} [right] The second cartographic.
       * @param {Number} epsilon The epsilon to use for equality testing.
       * @returns {Boolean} <code>true</code> if left and right are within the provided epsilon, <code>false</code> otherwise.
       */
      Cartographic.prototype.equalsEpsilon = function(right, epsilon) {
          return Cartographic.equalsEpsilon(this, right, epsilon);
      };
  
      /**
       * Creates a string representing this cartographic in the format '(longitude, latitude, height)'.
       *
       * @returns {String} A string representing the provided cartographic in the format '(longitude, latitude, height)'.
       */
      Cartographic.prototype.toString = function() {
          return '(' + this.longitude + ', ' + this.latitude + ', ' + this.height + ')';
      };
  
      return Cartographic;
  });
  
  /*global define*/
  define('Core/defineProperties',[
          './defined'
      ], function(
          defined) {
      "use strict";
  
      var definePropertyWorks = (function() {
          try {
              return 'x' in Object.defineProperty({}, 'x', {});
          } catch (e) {
              return false;
          }
      })();
  
      /**
       * Defines properties on an object, using Object.defineProperties if available,
       * otherwise returns the object unchanged.  This function should be used in
       * setup code to prevent errors from completely halting JavaScript execution
       * in legacy browsers.
       *
       * @private
       *
       * @exports defineProperties
       */
      var defineProperties = Object.defineProperties;
      if (!definePropertyWorks || !defined(defineProperties)) {
          defineProperties = function(o) {
              return o;
          };
      }
  
      return defineProperties;
  });
  /*global define*/
  define('Core/Ellipsoid',[
          './Cartesian3',
          './Cartographic',
          './defaultValue',
          './defined',
          './defineProperties',
          './DeveloperError',
          './freezeObject',
          './Math'
      ], function(
          Cartesian3,
          Cartographic,
          defaultValue,
          defined,
          defineProperties,
          DeveloperError,
          freezeObject,
          CesiumMath) {
      "use strict";
  
      function initialize(ellipsoid, x, y, z) {
          x = defaultValue(x, 0.0);
          y = defaultValue(y, 0.0);
          z = defaultValue(z, 0.0);
  
                  if (x < 0.0 || y < 0.0 || z < 0.0) {
              throw new DeveloperError('All radii components must be greater than or equal to zero.');
          }
          
          ellipsoid._radii = new Cartesian3(x, y, z);
  
          ellipsoid._radiiSquared = new Cartesian3(x * x,
                                              y * y,
                                              z * z);
  
          ellipsoid._radiiToTheFourth = new Cartesian3(x * x * x * x,
                                                  y * y * y * y,
                                                  z * z * z * z);
  
          ellipsoid._oneOverRadii = new Cartesian3(x === 0.0 ? 0.0 : 1.0 / x,
                                              y === 0.0 ? 0.0 : 1.0 / y,
                                              z === 0.0 ? 0.0 : 1.0 / z);
  
          ellipsoid._oneOverRadiiSquared = new Cartesian3(x === 0.0 ? 0.0 : 1.0 / (x * x),
                                                     y === 0.0 ? 0.0 : 1.0 / (y * y),
                                                     z === 0.0 ? 0.0 : 1.0 / (z * z));
  
          ellipsoid._minimumRadius = Math.min(x, y, z);
  
          ellipsoid._maximumRadius = Math.max(x, y, z);
  
          ellipsoid._centerToleranceSquared = CesiumMath.EPSILON1;
      }
  
      /**
       * A quadratic surface defined in Cartesian coordinates by the equation
       * <code>(x / a)^2 + (y / b)^2 + (z / c)^2 = 1</code>.  Primarily used
       * by Cesium to represent the shape of planetary bodies.
       *
       * Rather than constructing this object directly, one of the provided
       * constants is normally used.
       * @alias Ellipsoid
       * @constructor
       *
       * @param {Number} [x=0] The radius in the x direction.
       * @param {Number} [y=0] The radius in the y direction.
       * @param {Number} [z=0] The radius in the z direction.
       *
       * @exception {DeveloperError} All radii components must be greater than or equal to zero.
       *
       * @see Ellipsoid.fromCartesian3
       * @see Ellipsoid.WGS84
       * @see Ellipsoid.UNIT_SPHERE
       */
      var Ellipsoid = function(x, y, z) {
          this._radii = undefined;
          this._radiiSquared = undefined;
          this._radiiToTheFourth = undefined;
          this._oneOverRadii = undefined;
          this._oneOverRadiiSquared = undefined;
          this._minimumRadius = undefined;
          this._maximumRadius = undefined;
          this._centerToleranceSquared = undefined;
  
          initialize(this, x, y, z);
      };
  
      defineProperties(Ellipsoid.prototype, {
          /**
           * Gets the radii of the ellipsoid.
           * @memberof Ellipsoid.prototype
           * @type {Cartesian3}
           */
          radii : {
              get: function() {
                  return this._radii;
              }
          },
          /**
           * Gets the squared radii of the ellipsoid.
           * @memberof Ellipsoid.prototype
           * @type {Cartesian3}
           */
          radiiSquared : {
              get : function() {
                  return this._radiiSquared;
              }
          },
          /**
           * Gets the radii of the ellipsoid raise to the fourth power.
           * @memberof Ellipsoid.prototype
           * @type {Cartesian3}
           */
          radiiToTheFourth : {
              get : function() {
                  return this._radiiToTheFourth;
              }
          },
          /**
           * Gets one over the radii of the ellipsoid.
           * @memberof Ellipsoid.prototype
           * @type {Cartesian3}
           */
          oneOverRadii : {
              get : function() {
                  return this._oneOverRadii;
              }
          },
          /**
           * Gets one over the squared radii of the ellipsoid.
           * @memberof Ellipsoid.prototype
           * @type {Cartesian3}
           */
          oneOverRadiiSquared : {
              get : function() {
                  return this._oneOverRadiiSquared;
              }
          },
          /**
           * Gets the minimum radius of the ellipsoid.
           * @memberof Ellipsoid.prototype
           * @type {Number}
           */
          minimumRadius : {
              get : function() {
                  return this._minimumRadius;
              }
          },
          /**
           * Gets the maximum radius of the ellipsoid.
           * @memberof Ellipsoid.prototype
           * @type {Number}
           */
          maximumRadius : {
              get : function() {
                  return this._maximumRadius;
              }
          }
      });
  
      /**
       * Duplicates an Ellipsoid instance.
       *
       * @param {Ellipsoid} ellipsoid The ellipsoid to duplicate.
       * @param {Ellipsoid} [result] The object onto which to store the result, or undefined if a new
       *                    instance should be created.
       * @returns {Ellipsoid} The cloned Ellipsoid. (Returns undefined if ellipsoid is undefined)
       */
      Ellipsoid.clone = function(ellipsoid, result) {
          if (!defined(ellipsoid)) {
              return undefined;
          }
          var radii = ellipsoid._radii;
  
          if (!defined(result)) {
              return new Ellipsoid(radii.x, radii.y, radii.z);
          }
  
          Cartesian3.clone(radii, result._radii);
          Cartesian3.clone(ellipsoid._radiiSquared, result._radiiSquared);
          Cartesian3.clone(ellipsoid._radiiToTheFourth, result._radiiToTheFourth);
          Cartesian3.clone(ellipsoid._oneOverRadii, result._oneOverRadii);
          Cartesian3.clone(ellipsoid._oneOverRadiiSquared, result._oneOverRadiiSquared);
          result._minimumRadius = ellipsoid._minimumRadius;
          result._maximumRadius = ellipsoid._maximumRadius;
          result._centerToleranceSquared = ellipsoid._centerToleranceSquared;
  
          return result;
      };
  
      /**
       * Computes an Ellipsoid from a Cartesian specifying the radii in x, y, and z directions.
       *
       * @param {Cartesian3} [radii=Cartesian3.ZERO] The ellipsoid's radius in the x, y, and z directions.
       * @returns {Ellipsoid} A new Ellipsoid instance.
       *
       * @exception {DeveloperError} All radii components must be greater than or equal to zero.
       *
       * @see Ellipsoid.WGS84
       * @see Ellipsoid.UNIT_SPHERE
       */
      Ellipsoid.fromCartesian3 = function(cartesian, result) {
          if (!defined(result)) {
              result = new Ellipsoid();
          }
  
          if (!defined(cartesian)) {
              return result;
          }
  
          initialize(result, cartesian.x, cartesian.y, cartesian.z);
          return result;
      };
  
      /**
       * An Ellipsoid instance initialized to the WGS84 standard.
       *
       * @type {Ellipsoid}
       * @constant
       */
      Ellipsoid.WGS84 = freezeObject(new Ellipsoid(6378137.0, 6378137.0, 6356752.3142451793));
  
      /**
       * An Ellipsoid instance initialized to radii of (1.0, 1.0, 1.0).
       *
       * @type {Ellipsoid}
       * @constant
       */
      Ellipsoid.UNIT_SPHERE = freezeObject(new Ellipsoid(1.0, 1.0, 1.0));
  
      /**
       * An Ellipsoid instance initialized to a sphere with the lunar radius.
       *
       * @type {Ellipsoid}
       * @constant
       */
      Ellipsoid.MOON = freezeObject(new Ellipsoid(CesiumMath.LUNAR_RADIUS, CesiumMath.LUNAR_RADIUS, CesiumMath.LUNAR_RADIUS));
  
      /**
       * Duplicates an Ellipsoid instance.
       *
       * @param {Ellipsoid} [result] The object onto which to store the result, or undefined if a new
       *                    instance should be created.
       * @returns {Ellipsoid} The cloned Ellipsoid.
       */
      Ellipsoid.prototype.clone = function(result) {
          return Ellipsoid.clone(this, result);
      };
  
      /**
       * Computes the unit vector directed from the center of this ellipsoid toward the provided Cartesian position.
       * @function
       *
       * @param {Cartesian3} cartesian The Cartesian for which to to determine the geocentric normal.
       * @param {Cartesian3} [result] The object onto which to store the result.
       * @returns {Cartesian3} The modified result parameter or a new Cartesian3 instance if none was provided.
       */
      Ellipsoid.prototype.geocentricSurfaceNormal = Cartesian3.normalize;
  
      /**
       * Computes the normal of the plane tangent to the surface of the ellipsoid at the provided position.
       *
       * @param {Cartographic} cartographic The cartographic position for which to to determine the geodetic normal.
       * @param {Cartesian3} [result] The object onto which to store the result.
       * @returns {Cartesian3} The modified result parameter or a new Cartesian3 instance if none was provided.
       */
      Ellipsoid.prototype.geodeticSurfaceNormalCartographic = function(cartographic, result) {
                  if (!defined(cartographic)) {
              throw new DeveloperError('cartographic is required.');
          }
          
          var longitude = cartographic.longitude;
          var latitude = cartographic.latitude;
          var cosLatitude = Math.cos(latitude);
  
          var x = cosLatitude * Math.cos(longitude);
          var y = cosLatitude * Math.sin(longitude);
          var z = Math.sin(latitude);
  
          if (!defined(result)) {
              result = new Cartesian3();
          }
          result.x = x;
          result.y = y;
          result.z = z;
          return Cartesian3.normalize(result, result);
      };
  
      /**
       * Computes the normal of the plane tangent to the surface of the ellipsoid at the provided position.
       *
       * @param {Cartesian3} cartesian The Cartesian position for which to to determine the surface normal.
       * @param {Cartesian3} [result] The object onto which to store the result.
       * @returns {Cartesian3} The modified result parameter or a new Cartesian3 instance if none was provided.
       */
      Ellipsoid.prototype.geodeticSurfaceNormal = function(cartesian, result) {
          if (!defined(result)) {
              result = new Cartesian3();
          }
          result = Cartesian3.multiplyComponents(cartesian, this._oneOverRadiiSquared, result);
          return Cartesian3.normalize(result, result);
      };
  
      var cartographicToCartesianNormal = new Cartesian3();
      var cartographicToCartesianK = new Cartesian3();
  
      /**
       * Converts the provided cartographic to Cartesian representation.
       *
       * @param {Cartographic} cartographic The cartographic position.
       * @param {Cartesian3} [result] The object onto which to store the result.
       * @returns {Cartesian3} The modified result parameter or a new Cartesian3 instance if none was provided.
       *
       * @example
       * //Create a Cartographic and determine it's Cartesian representation on a WGS84 ellipsoid.
       * var position = new Cesium.Cartographic(Cesium.Math.toRadians(21), Cesium.Math.toRadians(78), 5000);
       * var cartesianPosition = Cesium.Ellipsoid.WGS84.cartographicToCartesian(position);
       */
      Ellipsoid.prototype.cartographicToCartesian = function(cartographic, result) {
          //`cartographic is required` is thrown from geodeticSurfaceNormalCartographic.
          var n = cartographicToCartesianNormal;
          var k = cartographicToCartesianK;
          this.geodeticSurfaceNormalCartographic(cartographic, n);
          Cartesian3.multiplyComponents(this._radiiSquared, n, k);
          var gamma = Math.sqrt(Cartesian3.dot(n, k));
          Cartesian3.divideByScalar(k, gamma, k);
          Cartesian3.multiplyByScalar(n, cartographic.height, n);
  
          if (!defined(result)) {
              result = new Cartesian3();
          }
          return Cartesian3.add(k, n, result);
      };
  
      /**
       * Converts the provided array of cartographics to an array of Cartesians.
       *
       * @param {Cartographic[]} cartographics An array of cartographic positions.
       * @param {Cartesian3[]} [result] The object onto which to store the result.
       * @returns {Cartesian3[]} The modified result parameter or a new Array instance if none was provided.
       *
       * @example
       * //Convert an array of Cartographics and determine their Cartesian representation on a WGS84 ellipsoid.
       * var positions = [new Cesium.Cartographic(Cesium.Math.toRadians(21), Cesium.Math.toRadians(78), 0),
       *                  new Cesium.Cartographic(Cesium.Math.toRadians(21.321), Cesium.Math.toRadians(78.123), 100),
       *                  new Cesium.Cartographic(Cesium.Math.toRadians(21.645), Cesium.Math.toRadians(78.456), 250)
       * var cartesianPositions = Cesium.Ellipsoid.WGS84.cartographicArrayToCartesianArray(positions);
       */
      Ellipsoid.prototype.cartographicArrayToCartesianArray = function(cartographics, result) {
                  if (!defined(cartographics)) {
              throw new DeveloperError('cartographics is required.');
          }
          
          var length = cartographics.length;
          if (!defined(result)) {
              result = new Array(length);
          } else {
              result.length = length;
          }
          for ( var i = 0; i < length; i++) {
              result[i] = this.cartographicToCartesian(cartographics[i], result[i]);
          }
          return result;
      };
  
      var cartesianToCartographicN = new Cartesian3();
      var cartesianToCartographicP = new Cartesian3();
      var cartesianToCartographicH = new Cartesian3();
  
      /**
       * Converts the provided cartesian to cartographic representation.
       * The cartesian is undefined at the center of the ellipsoid.
       *
       * @param {Cartesian3} cartesian The Cartesian position to convert to cartographic representation.
       * @param {Cartographic} [result] The object onto which to store the result.
       * @returns {Cartographic} The modified result parameter, new Cartographic instance if none was provided, or undefined if the cartesian is at the center of the ellipsoid.
       *
       * @example
       * //Create a Cartesian and determine it's Cartographic representation on a WGS84 ellipsoid.
       * var position = new Cesium.Cartesian(17832.12, 83234.52, 952313.73);
       * var cartographicPosition = Cesium.Ellipsoid.WGS84.cartesianToCartographic(position);
       */
      Ellipsoid.prototype.cartesianToCartographic = function(cartesian, result) {
          //`cartesian is required.` is thrown from scaleToGeodeticSurface
          var p = this.scaleToGeodeticSurface(cartesian, cartesianToCartographicP);
  
          if (!defined(p)) {
              return undefined;
          }
  
          var n = this.geodeticSurfaceNormal(p, cartesianToCartographicN);
          var h = Cartesian3.subtract(cartesian, p, cartesianToCartographicH);
  
          var longitude = Math.atan2(n.y, n.x);
          var latitude = Math.asin(n.z);
          var height = CesiumMath.sign(Cartesian3.dot(h, cartesian)) * Cartesian3.magnitude(h);
  
          if (!defined(result)) {
              return new Cartographic(longitude, latitude, height);
          }
          result.longitude = longitude;
          result.latitude = latitude;
          result.height = height;
          return result;
      };
  
      /**
       * Converts the provided array of cartesians to an array of cartographics.
       *
       * @param {Cartesian3[]} cartesians An array of Cartesian positions.
       * @param {Cartographic[]} [result] The object onto which to store the result.
       * @returns {Cartographic[]} The modified result parameter or a new Array instance if none was provided.
       *
       * @example
       * //Create an array of Cartesians and determine their Cartographic representation on a WGS84 ellipsoid.
       * var positions = [new Cesium.Cartesian3(17832.12, 83234.52, 952313.73),
       *                  new Cesium.Cartesian3(17832.13, 83234.53, 952313.73),
       *                  new Cesium.Cartesian3(17832.14, 83234.54, 952313.73)]
       * var cartographicPositions = Cesium.Ellipsoid.WGS84.cartesianArrayToCartographicArray(positions);
       */
      Ellipsoid.prototype.cartesianArrayToCartographicArray = function(cartesians, result) {
                  if (!defined(cartesians)) {
              throw new DeveloperError('cartesians is required.');
          }
          
          var length = cartesians.length;
          if (!defined(result)) {
              result = new Array(length);
          } else {
              result.length = length;
          }
          for ( var i = 0; i < length; ++i) {
              result[i] = this.cartesianToCartographic(cartesians[i], result[i]);
          }
          return result;
      };
  
      var scaleToGeodeticSurfaceIntersection = new Cartesian3();
      var scaleToGeodeticSurfaceGradient = new Cartesian3();
  
      /**
       * Scales the provided Cartesian position along the geodetic surface normal
       * so that it is on the surface of this ellipsoid.  If the position is
       * at the center of the ellipsoid, this function returns undefined.
       *
       * @param {Cartesian3} cartesian The Cartesian position to scale.
       * @param {Cartesian3} [result] The object onto which to store the result.
       * @returns {Cartesian3} The modified result parameter, a new Cartesian3 instance if none was provided, or undefined if the position is at the center.
       */
      Ellipsoid.prototype.scaleToGeodeticSurface = function(cartesian, result) {
                  if (!defined(cartesian)) {
              throw new DeveloperError('cartesian is required.');
          }
          
          var positionX = cartesian.x;
          var positionY = cartesian.y;
          var positionZ = cartesian.z;
  
          var oneOverRadii = this._oneOverRadii;
          var oneOverRadiiX = oneOverRadii.x;
          var oneOverRadiiY = oneOverRadii.y;
          var oneOverRadiiZ = oneOverRadii.z;
  
          var x2 = positionX * positionX * oneOverRadiiX * oneOverRadiiX;
          var y2 = positionY * positionY * oneOverRadiiY * oneOverRadiiY;
          var z2 = positionZ * positionZ * oneOverRadiiZ * oneOverRadiiZ;
  
          // Compute the squared ellipsoid norm.
          var squaredNorm = x2 + y2 + z2;
          var ratio = Math.sqrt(1.0 / squaredNorm);
  
          // As an initial approximation, assume that the radial intersection is the projection point.
          var intersection = Cartesian3.multiplyByScalar(cartesian, ratio, scaleToGeodeticSurfaceIntersection);
  
          //* If the position is near the center, the iteration will not converge.
          if (squaredNorm < this._centerToleranceSquared) {
              return !isFinite(ratio) ? undefined : Cartesian3.clone(intersection, result);
          }
  
          var oneOverRadiiSquared = this._oneOverRadiiSquared;
          var oneOverRadiiSquaredX = oneOverRadiiSquared.x;
          var oneOverRadiiSquaredY = oneOverRadiiSquared.y;
          var oneOverRadiiSquaredZ = oneOverRadiiSquared.z;
  
          // Use the gradient at the intersection point in place of the true unit normal.
          // The difference in magnitude will be absorbed in the multiplier.
          var gradient = scaleToGeodeticSurfaceGradient;
          gradient.x = intersection.x * oneOverRadiiSquaredX * 2.0;
          gradient.y = intersection.y * oneOverRadiiSquaredY * 2.0;
          gradient.z = intersection.z * oneOverRadiiSquaredZ * 2.0;
  
          // Compute the initial guess at the normal vector multiplier, lambda.
          var lambda = (1.0 - ratio) * Cartesian3.magnitude(cartesian) / (0.5 * Cartesian3.magnitude(gradient));
          var correction = 0.0;
  
          var func;
          var denominator;
          var xMultiplier;
          var yMultiplier;
          var zMultiplier;
          var xMultiplier2;
          var yMultiplier2;
          var zMultiplier2;
          var xMultiplier3;
          var yMultiplier3;
          var zMultiplier3;
  
          do {
              lambda -= correction;
  
              xMultiplier = 1.0 / (1.0 + lambda * oneOverRadiiSquaredX);
              yMultiplier = 1.0 / (1.0 + lambda * oneOverRadiiSquaredY);
              zMultiplier = 1.0 / (1.0 + lambda * oneOverRadiiSquaredZ);
  
              xMultiplier2 = xMultiplier * xMultiplier;
              yMultiplier2 = yMultiplier * yMultiplier;
              zMultiplier2 = zMultiplier * zMultiplier;
  
              xMultiplier3 = xMultiplier2 * xMultiplier;
              yMultiplier3 = yMultiplier2 * yMultiplier;
              zMultiplier3 = zMultiplier2 * zMultiplier;
  
              func = x2 * xMultiplier2 + y2 * yMultiplier2 + z2 * zMultiplier2 - 1.0;
  
              // "denominator" here refers to the use of this expression in the velocity and acceleration
              // computations in the sections to follow.
              denominator = x2 * xMultiplier3 * oneOverRadiiSquaredX + y2 * yMultiplier3 * oneOverRadiiSquaredY + z2 * zMultiplier3 * oneOverRadiiSquaredZ;
  
              var derivative = -2.0 * denominator;
  
              correction = func / derivative;
          } while (Math.abs(func) > CesiumMath.EPSILON12);
  
          if (!defined(result)) {
              return new Cartesian3(positionX * xMultiplier, positionY * yMultiplier, positionZ * zMultiplier);
          }
          result.x = positionX * xMultiplier;
          result.y = positionY * yMultiplier;
          result.z = positionZ * zMultiplier;
          return result;
      };
  
      /**
       * Scales the provided Cartesian position along the geocentric surface normal
       * so that it is on the surface of this ellipsoid.
       *
       * @param {Cartesian3} cartesian The Cartesian position to scale.
       * @param {Cartesian3} [result] The object onto which to store the result.
       * @returns {Cartesian3} The modified result parameter or a new Cartesian3 instance if none was provided.
       */
      Ellipsoid.prototype.scaleToGeocentricSurface = function(cartesian, result) {
                  if (!defined(cartesian)) {
              throw new DeveloperError('cartesian is required.');
          }
          
          if (!defined(result)) {
              result = new Cartesian3();
          }
  
          var positionX = cartesian.x;
          var positionY = cartesian.y;
          var positionZ = cartesian.z;
          var oneOverRadiiSquared = this._oneOverRadiiSquared;
  
          var beta = 1.0 / Math.sqrt((positionX * positionX) * oneOverRadiiSquared.x +
                                     (positionY * positionY) * oneOverRadiiSquared.y +
                                     (positionZ * positionZ) * oneOverRadiiSquared.z);
  
          return Cartesian3.multiplyByScalar(cartesian, beta, result);
      };
  
      /**
       * Transforms a Cartesian X, Y, Z position to the ellipsoid-scaled space by multiplying
       * its components by the result of {@link Ellipsoid#oneOverRadii}.
       *
       * @param {Cartesian3} position The position to transform.
       * @param {Cartesian3} [result] The position to which to copy the result, or undefined to create and
       *        return a new instance.
       * @returns {Cartesian3} The position expressed in the scaled space.  The returned instance is the
       *          one passed as the result parameter if it is not undefined, or a new instance of it is.
       */
      Ellipsoid.prototype.transformPositionToScaledSpace = function(position, result) {
          if (!defined(result)) {
              result = new Cartesian3();
          }
  
          return Cartesian3.multiplyComponents(position, this._oneOverRadii, result);
      };
  
      /**
       * Transforms a Cartesian X, Y, Z position from the ellipsoid-scaled space by multiplying
       * its components by the result of {@link Ellipsoid#radii}.
       *
       * @param {Cartesian3} position The position to transform.
       * @param {Cartesian3} [result] The position to which to copy the result, or undefined to create and
       *        return a new instance.
       * @returns {Cartesian3} The position expressed in the unscaled space.  The returned instance is the
       *          one passed as the result parameter if it is not undefined, or a new instance of it is.
       */
      Ellipsoid.prototype.transformPositionFromScaledSpace = function(position, result) {
          if (!defined(result)) {
              result = new Cartesian3();
          }
  
          return Cartesian3.multiplyComponents(position, this._radii, result);
      };
  
      /**
       * Compares this Ellipsoid against the provided Ellipsoid componentwise and returns
       * <code>true</code> if they are equal, <code>false</code> otherwise.
       *
       * @param {Ellipsoid} [right] The other Ellipsoid.
       * @returns {Boolean} <code>true</code> if they are equal, <code>false</code> otherwise.
       */
      Ellipsoid.prototype.equals = function(right) {
          return (this === right) ||
                 (defined(right) &&
                  Cartesian3.equals(this._radii, right._radii));
      };
  
      /**
       * Creates a string representing this Ellipsoid in the format '(radii.x, radii.y, radii.z)'.
       *
       * @returns {String} A string representing this ellipsoid in the format '(radii.x, radii.y, radii.z)'.
       */
      Ellipsoid.prototype.toString = function() {
          return this._radii.toString();
      };
  
      return Ellipsoid;
  });
  
  /*global define*/
  define('Core/IndexDatatype',[
          './defined',
          './DeveloperError',
          './freezeObject',
          './Math'
      ], function(
          defined,
          DeveloperError,
          freezeObject,
          CesiumMath) {
      "use strict";
  
      /**
       * Constants for WebGL index datatypes.  These corresponds to the
       * <code>type</code> parameter of {@link http://www.khronos.org/opengles/sdk/docs/man/xhtml/glDrawElements.xml|drawElements}.
       *
       * @namespace
       * @alias IndexDatatype
       */
      var IndexDatatype = {
          /**
           * 0x1401.  8-bit unsigned byte corresponding to <code>UNSIGNED_BYTE</code> and the type
           * of an element in <code>Uint8Array</code>.
           *
           * @type {Number}
           * @constant
           */
          UNSIGNED_BYTE : 0x1401,
  
          /**
           * 0x1403.  16-bit unsigned short corresponding to <code>UNSIGNED_SHORT</code> and the type
           * of an element in <code>Uint16Array</code>.
           *
           * @type {Number}
           * @constant
           */
          UNSIGNED_SHORT : 0x1403,
  
          /**
           * 0x1405.  32-bit unsigned int corresponding to <code>UNSIGNED_INT</code> and the type
           * of an element in <code>Uint32Array</code>.
           *
           * @type {Number}
           * @constant
           */
          UNSIGNED_INT : 0x1405
      };
  
      /**
       * Returns the size, in bytes, of the corresponding datatype.
       *
       * @param {IndexDatatype} indexDatatype The index datatype to get the size of.
       * @returns {Number} The size in bytes.
       *
       * @example
       * // Returns 2
       * var size = Cesium.IndexDatatype.getSizeInBytes(Cesium.IndexDatatype.UNSIGNED_SHORT);
       */
      IndexDatatype.getSizeInBytes = function(indexDatatype) {
          switch(indexDatatype) {
              case IndexDatatype.UNSIGNED_BYTE:
                  return Uint8Array.BYTES_PER_ELEMENT;
              case IndexDatatype.UNSIGNED_SHORT:
                  return Uint16Array.BYTES_PER_ELEMENT;
              case IndexDatatype.UNSIGNED_INT:
                  return Uint32Array.BYTES_PER_ELEMENT;
          }
  
                  throw new DeveloperError('indexDatatype is required and must be a valid IndexDatatype constant.');
              };
  
      /**
       * Validates that the provided index datatype is a valid {@link IndexDatatype}.
       *
       * @param {IndexDatatype} indexDatatype The index datatype to validate.
       * @returns {Boolean} <code>true</code> if the provided index datatype is a valid value; otherwise, <code>false</code>.
       *
       * @example
       * if (!Cesium.IndexDatatype.validate(indexDatatype)) {
       *   throw new Cesium.DeveloperError('indexDatatype must be a valid value.');
       * }
       */
      IndexDatatype.validate = function(indexDatatype) {
          return defined(indexDatatype) &&
                 (indexDatatype === IndexDatatype.UNSIGNED_BYTE ||
                  indexDatatype === IndexDatatype.UNSIGNED_SHORT ||
                  indexDatatype === IndexDatatype.UNSIGNED_INT);
      };
  
      /**
       * Creates a typed array that will store indices, using either <code><Uint16Array</code>
       * or <code>Uint32Array</code> depending on the number of vertices.
       *
       * @param {Number} numberOfVertices Number of vertices that the indices will reference.
       * @param {Any} indicesLengthOrArray Passed through to the typed array constructor.
       * @returns {Uint16Aray|Uint32Array} A <code>Uint16Array</code> or <code>Uint32Array</code> constructed with <code>indicesLengthOrArray</code>.
       *
       * @example
       * this.indices = Cesium.IndexDatatype.createTypedArray(positions.length / 3, numberOfIndices);
       */
      IndexDatatype.createTypedArray = function(numberOfVertices, indicesLengthOrArray) {
                  if (!defined(numberOfVertices)) {
              throw new DeveloperError('numberOfVertices is required.');
          }
          
          if (numberOfVertices > CesiumMath.SIXTY_FOUR_KILOBYTES) {
              return new Uint32Array(indicesLengthOrArray);
          }
  
          return new Uint16Array(indicesLengthOrArray);
      };
  
      /**
       * Creates a typed array from a source array buffer.  The resulting typed array will store indices, using either <code><Uint16Array</code>
       * or <code>Uint32Array</code> depending on the number of vertices.
       *
       * @param {Number} numberOfVertices Number of vertices that the indices will reference.
       * @param {ArrayBuffer} sourceArray Passed through to the typed array constructor.
       * @param {byteOffset} byteOffset Passed through to the typed array constructor.
       * @param {length} length Passed through to the typed array constructor.
       * @returns {Uint16Aray|Uint32Array} A <code>Uint16Array</code> or <code>Uint32Array</code> constructed with <code>sourceArray</code>, <code>byteOffset</code>, and <code>length</code>.
       *
       */
      IndexDatatype.createTypedArrayFromArrayBuffer = function(numberOfVertices, sourceArray, byteOffset, length) {
                  if (!defined(numberOfVertices)) {
              throw new DeveloperError('numberOfVertices is required.');
          }
          if (!defined(sourceArray)) {
              throw new DeveloperError('sourceArray is required.');
          }
          if (!defined(byteOffset)) {
              throw new DeveloperError('byteOffset is required.');
          }
          
          if (numberOfVertices > CesiumMath.SIXTY_FOUR_KILOBYTES) {
              return new Uint32Array(sourceArray, byteOffset, length);
          }
  
          return new Uint16Array(sourceArray, byteOffset, length);
      };
  
      return freezeObject(IndexDatatype);
  });
  
  /*global define*/
  define('Core/formatError',[
          './defined'
      ], function(
          defined) {
      "use strict";
  
      /**
       * Formats an error object into a String.  If available, uses name, message, and stack
       * properties, otherwise, falls back on toString().
       *
       * @exports formatError
       *
       * @param {Object} object The item to find in the array.
       * @returns {String} A string containing the formatted error.
       */
      var formatError = function(object) {
          var result;
  
          var name = object.name;
          var message = object.message;
          if (defined(name) && defined(message)) {
              result = name + ': ' + message;
          } else {
              result = object.toString();
          }
  
          var stack = object.stack;
          if (defined(stack)) {
              result += '\n' + stack;
          }
  
          return result;
      };
  
      return formatError;
  });
  /*global define*/
  define('Workers/createTaskProcessorWorker',[
          '../Core/defaultValue',
          '../Core/defined',
          '../Core/formatError'
      ], function(
          defaultValue,
          defined,
          formatError) {
      "use strict";
  
      /**
       * Creates an adapter function to allow a calculation function to operate as a Web Worker,
       * paired with TaskProcessor, to receive tasks and return results.
       *
       * @exports createTaskProcessorWorker
       *
       * @param {createTaskProcessorWorker~WorkerFunction} workerFunction The calculation function,
       *        which takes parameters and returns a result.
       * @returns {createTaskProcessorWorker~TaskProcessorWorkerFunction} A function that adapts the
       *          calculation function to work as a Web Worker onmessage listener with TaskProcessor.
       *
       * @see TaskProcessor
       * @see {@link http://www.w3.org/TR/workers/|Web Workers}
       * @see {@link http://www.w3.org/TR/html5/common-dom-interfaces.html#transferable-objects|Transferable objects}
       *
       * @example
       * function doCalculation(parameters, transferableObjects) {
       *   // calculate some result using the inputs in parameters
       *   return result;
       * }
       *
       * return Cesium.createTaskProcessorWorker(doCalculation);
       * // the resulting function is compatible with TaskProcessor
       */
      var createTaskProcessorWorker = function(workerFunction) {
          var postMessage;
          var transferableObjects = [];
          var responseMessage = {
              id : undefined,
              result : undefined,
              error : undefined
          };
  
          return function(event) {
              /*global self*/
              var data = event.data;
  
              transferableObjects.length = 0;
              responseMessage.id = data.id;
              responseMessage.error = undefined;
              responseMessage.result = undefined;
  
              try {
                  responseMessage.result = workerFunction(data.parameters, transferableObjects);
              } catch (e) {
                  if (e instanceof Error) {
                      // Errors can't be posted in a message, copy the properties
                      responseMessage.error = {
                          name : e.name,
                          message : e.message,
                          stack : e.stack
                      };
                  } else {
                      responseMessage.error = e;
                  }
              }
  
              if (!defined(postMessage)) {
                  postMessage = defaultValue(self.webkitPostMessage, self.postMessage);
              }
  
              if (!data.canTransferArrayBuffer) {
                  transferableObjects.length = 0;
              }
  
              try {
                  postMessage(responseMessage, transferableObjects);
              } catch (e) {
                  // something went wrong trying to post the message, post a simpler
                  // error that we can be sure will be cloneable
                  responseMessage.result = undefined;
                  responseMessage.error = 'postMessage failed with error: ' + formatError(e) + '\n  with responseMessage: ' + JSON.stringify(responseMessage);
                  postMessage(responseMessage);
              }
          };
      };
  
      /**
       * A function that performs a calculation in a Web Worker.
       * @callback createTaskProcessorWorker~WorkerFunction
       *
       * @param {Object} parameters Parameters to the calculation.
       * @param {Array} transferableObjects An array that should be filled with references to objects inside
       *        the result that should be transferred back to the main document instead of copied.
       * @returns {Object} The result of the calculation.
       *
       * @example
       * function calculate(parameters, transferableObjects) {
       *   // perform whatever calculation is necessary.
       *   var typedArray = new Float32Array();
       *
       *   // typed arrays are transferable
       *   transferableObjects.push(typedArray)
       *
       *   return {
       *      typedArray : typedArray
       *   };
       * }
       */
  
      /**
       * A Web Worker message event handler function that handles the interaction with TaskProcessor,
       * specifically, task ID management and posting a response message containing the result.
       * @callback createTaskProcessorWorker~TaskProcessorWorkerFunction
       *
       * @param {Object} event The onmessage event object.
       */
  
      return createTaskProcessorWorker;
  });
  /*global define*/
  define('Workers/createVerticesFromQuantizedTerrainMesh',[
          '../Core/AttributeCompression',
          '../Core/Cartesian2',
          '../Core/Cartesian3',
          '../Core/Cartographic',
          '../Core/defined',
          '../Core/Ellipsoid',
          '../Core/IndexDatatype',
          '../Core/Math',
          './createTaskProcessorWorker'
      ], function(
          AttributeCompression,
          Cartesian2,
          Cartesian3,
          Cartographic,
          defined,
          Ellipsoid,
          IndexDatatype,
          CesiumMath,
          createTaskProcessorWorker) {
      "use strict";
  
      var maxShort = 32767;
  
      var xIndex = 0;
      var yIndex = 1;
      var zIndex = 2;
      var hIndex = 3;
      var uIndex = 4;
      var vIndex = 5;
      var nIndex = 6;
  
      var cartesian3Scratch = new Cartesian3();
      var cartographicScratch = new Cartographic();
      var toPack = new Cartesian2();
  
      function createVerticesFromQuantizedTerrainMesh(parameters, transferableObjects) {
          var quantizedVertices = parameters.quantizedVertices;
          var quantizedVertexCount = quantizedVertices.length / 3;
          var octEncodedNormals = parameters.octEncodedNormals;
          var edgeVertexCount = parameters.westIndices.length + parameters.eastIndices.length +
                                parameters.southIndices.length + parameters.northIndices.length;
          var minimumHeight = parameters.minimumHeight;
          var maximumHeight = parameters.maximumHeight;
          var center = parameters.relativeToCenter;
  
          var rectangle = parameters.rectangle;
          var west = rectangle.west;
          var south = rectangle.south;
          var east = rectangle.east;
          var north = rectangle.north;
  
          var ellipsoid = Ellipsoid.clone(parameters.ellipsoid);
  
          var uBuffer = quantizedVertices.subarray(0, quantizedVertexCount);
          var vBuffer = quantizedVertices.subarray(quantizedVertexCount, 2 * quantizedVertexCount);
          var heightBuffer = quantizedVertices.subarray(quantizedVertexCount * 2, 3 * quantizedVertexCount);
          var hasVertexNormals = defined(octEncodedNormals);
  
          var vertexStride = 6;
          if (hasVertexNormals) {
              vertexStride += 1;
          }
  
          var vertexBuffer = new Float32Array(quantizedVertexCount * vertexStride + edgeVertexCount * vertexStride);
  
          for (var i = 0, bufferIndex = 0, n = 0; i < quantizedVertexCount; ++i, bufferIndex += vertexStride, n += 2) {
              var u = uBuffer[i] / maxShort;
              var v = vBuffer[i] / maxShort;
              var height = CesiumMath.lerp(minimumHeight, maximumHeight, heightBuffer[i] / maxShort);
  
              cartographicScratch.longitude = CesiumMath.lerp(west, east, u);
              cartographicScratch.latitude = CesiumMath.lerp(south, north, v);
              cartographicScratch.height = height;
  
              ellipsoid.cartographicToCartesian(cartographicScratch, cartesian3Scratch);
  
              vertexBuffer[bufferIndex + xIndex] = cartesian3Scratch.x - center.x;
              vertexBuffer[bufferIndex + yIndex] = cartesian3Scratch.y - center.y;
              vertexBuffer[bufferIndex + zIndex] = cartesian3Scratch.z - center.z;
              vertexBuffer[bufferIndex + hIndex] = height;
              vertexBuffer[bufferIndex + uIndex] = u;
              vertexBuffer[bufferIndex + vIndex] = v;
              if (hasVertexNormals) {
                  toPack.x = octEncodedNormals[n];
                  toPack.y = octEncodedNormals[n + 1];
                  vertexBuffer[bufferIndex + nIndex] = AttributeCompression.octPackFloat(toPack);
              }
          }
  
          var edgeTriangleCount = Math.max(0, (edgeVertexCount - 4) * 2);
          var indexBufferLength = parameters.indices.length + edgeTriangleCount * 3;
          var indexBuffer = IndexDatatype.createTypedArray(quantizedVertexCount + edgeVertexCount, indexBufferLength);
          indexBuffer.set(parameters.indices, 0);
  
          // Add skirts.
          var vertexBufferIndex = quantizedVertexCount * vertexStride;
          var indexBufferIndex = parameters.indices.length;
          indexBufferIndex = addSkirt(vertexBuffer, vertexBufferIndex, indexBuffer, indexBufferIndex, parameters.westIndices, center, ellipsoid, rectangle, parameters.westSkirtHeight, true, hasVertexNormals);
          vertexBufferIndex += parameters.westIndices.length * vertexStride;
          indexBufferIndex = addSkirt(vertexBuffer, vertexBufferIndex, indexBuffer, indexBufferIndex, parameters.southIndices, center, ellipsoid, rectangle, parameters.southSkirtHeight, false, hasVertexNormals);
          vertexBufferIndex += parameters.southIndices.length * vertexStride;
          indexBufferIndex = addSkirt(vertexBuffer, vertexBufferIndex, indexBuffer, indexBufferIndex, parameters.eastIndices, center, ellipsoid, rectangle, parameters.eastSkirtHeight, false, hasVertexNormals);
          vertexBufferIndex += parameters.eastIndices.length * vertexStride;
          indexBufferIndex = addSkirt(vertexBuffer, vertexBufferIndex, indexBuffer, indexBufferIndex, parameters.northIndices, center, ellipsoid, rectangle, parameters.northSkirtHeight, true, hasVertexNormals);
          vertexBufferIndex += parameters.northIndices.length * vertexStride;
  
          transferableObjects.push(vertexBuffer.buffer, indexBuffer.buffer);
  
          return {
              vertices : vertexBuffer.buffer,
              indices : indexBuffer.buffer
          };
      }
  
      function addSkirt(vertexBuffer, vertexBufferIndex, indexBuffer, indexBufferIndex, edgeVertices, center, ellipsoid, rectangle, skirtLength, isWestOrNorthEdge, hasVertexNormals) {
          var start, end, increment;
          var vertexStride = 6;
          if (hasVertexNormals) {
              vertexStride += 1;
          }
          if (isWestOrNorthEdge) {
              start = edgeVertices.length - 1;
              end = -1;
              increment = -1;
          } else {
              start = 0;
              end = edgeVertices.length;
              increment = 1;
          }
  
          var previousIndex = -1;
  
          var vertexIndex = vertexBufferIndex / vertexStride;
  
          for (var i = start; i !== end; i += increment) {
              var index = edgeVertices[i];
              var offset = index * vertexStride;
              var u = vertexBuffer[offset + uIndex];
              var v = vertexBuffer[offset + vIndex];
              var h = vertexBuffer[offset + hIndex];
  
              cartographicScratch.longitude = CesiumMath.lerp(rectangle.west, rectangle.east, u);
              cartographicScratch.latitude = CesiumMath.lerp(rectangle.south, rectangle.north, v);
              cartographicScratch.height = h - skirtLength;
  
              var position = ellipsoid.cartographicToCartesian(cartographicScratch, cartesian3Scratch);
              Cartesian3.subtract(position, center, position);
  
              vertexBuffer[vertexBufferIndex++] = position.x;
              vertexBuffer[vertexBufferIndex++] = position.y;
              vertexBuffer[vertexBufferIndex++] = position.z;
              vertexBuffer[vertexBufferIndex++] = cartographicScratch.height;
              vertexBuffer[vertexBufferIndex++] = u;
              vertexBuffer[vertexBufferIndex++] = v;
              if (hasVertexNormals) {
                  vertexBuffer[vertexBufferIndex++] = vertexBuffer[offset + nIndex];
              }
  
              if (previousIndex !== -1) {
                  indexBuffer[indexBufferIndex++] = previousIndex;
                  indexBuffer[indexBufferIndex++] = vertexIndex - 1;
                  indexBuffer[indexBufferIndex++] = index;
  
                  indexBuffer[indexBufferIndex++] = vertexIndex - 1;
                  indexBuffer[indexBufferIndex++] = vertexIndex;
                  indexBuffer[indexBufferIndex++] = index;
              }
  
              previousIndex = index;
              ++vertexIndex;
          }
  
          return indexBufferIndex;
      }
  
      return createTaskProcessorWorker(createVerticesFromQuantizedTerrainMesh);
  });
  }());