cesium 0.13.0

data/app/assets/javascripts/Core/Cartographic.js

@@ -0,0 +1,211 @@
+/*global define*/
+define([
+        './defaultValue',
+        './DeveloperError',
+        './freezeObject',
+        './Math'
+    ], function(
+        defaultValue,
+        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
+         */
+        this.longitude = defaultValue(longitude, 0.0);
+
+        /**
+         * The latitude, in radians.
+         * @type Number
+         */
+        this.latitude = defaultValue(latitude, 0.0);
+
+        /**
+         * The height, in meters, above the ellipsoid.
+         * @type Number
+         */
+        this.height = defaultValue(height, 0.0);
+    };
+
+    /**
+     * Creates a new Cartographic instance from longitude and latitude
+     * specified in degrees.  The values in the resulting object will
+     * be in radians.
+     * @memberof Cartographic
+     *
+     * @param {Number} [longitude=0.0] The longitude, in degrees.
+     * @param {Number} [latitude=0.0] 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.
+     * @return {Cartographic} The modified result parameter or a new Cartographic instance if one was not provided.
+     */
+    Cartographic.fromDegrees = function(longitude, latitude, height, result) {
+        longitude = CesiumMath.toRadians(defaultValue(longitude, 0.0));
+        latitude = CesiumMath.toRadians(defaultValue(latitude, 0.0));
+        height = defaultValue(height, 0.0);
+
+        if (typeof result === 'undefined') {
+            return new Cartographic(longitude, latitude, height);
+        }
+
+        result.longitude = longitude;
+        result.latitude = latitude;
+        result.height = height;
+        return result;
+    };
+
+    /**
+     * Duplicates a Cartographic instance.
+     * @memberof Cartographic
+     *
+     * @param {Cartographic} cartographic The cartographic to duplicate.
+     * @param {Cartographic} [result] The object onto which to store the result.
+     * @return {Cartographic} The modified result parameter or a new Cartographic instance if one was not provided.
+     *
+     * @exception {DeveloperError} cartographic is required.
+     */
+    Cartographic.clone = function(cartographic, result) {
+        if (typeof cartographic === 'undefined') {
+            throw new DeveloperError('cartographic is required');
+        }
+        if (typeof result === 'undefined') {
+            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.
+     * @memberof Cartographic
+     *
+     * @param {Cartographic} [left] The first cartographic.
+     * @param {Cartographic} [right] The second cartographic.
+     * @return {Boolean} <code>true</code> if left and right are equal, <code>false</code> otherwise.
+     */
+    Cartographic.equals = function(left, right) {
+        return (left === right) ||
+                ((typeof left !== 'undefined') &&
+                 (typeof right !== 'undefined') &&
+                 (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.
+     * @memberof Cartographic
+     *
+     * @param {Cartographic} [left] The first cartographic.
+     * @param {Cartographic} [right] The second cartographic.
+     * @param {Number} epsilon The epsilon to use for equality testing.
+     * @return {Boolean} <code>true</code> if left and right are within the provided epsilon, <code>false</code> otherwise.
+     *
+     * @exception {DeveloperError} epsilon is required and must be a number.
+     */
+    Cartographic.equalsEpsilon = function(left, right, epsilon) {
+        if (typeof epsilon !== 'number') {
+            throw new DeveloperError('epsilon is required and must be a number.');
+        }
+        return (left === right) ||
+               ((typeof left !== 'undefined') &&
+                (typeof right !== 'undefined') &&
+                (Math.abs(left.longitude - right.longitude) <= epsilon) &&
+                (Math.abs(left.latitude - right.latitude) <= epsilon) &&
+                (Math.abs(left.height - right.height) <= epsilon));
+    };
+
+    /**
+     * Creates a string representing the provided cartographic in the format '(longitude, latitude, height)'.
+     * @memberof Cartographic
+     *
+     * @param {Cartographic} cartographic The cartographic to stringify.
+     * @return {String} A string representing the provided cartographic in the format '(longitude, latitude, height)'.
+     *
+     * @exception {DeveloperError} cartographic is required.
+     */
+    Cartographic.toString = function(cartographic) {
+        if (typeof cartographic === 'undefined') {
+            throw new DeveloperError('cartographic is required');
+        }
+        return '(' + cartographic.longitude + ', ' + cartographic.latitude + ', ' + cartographic.height + ')';
+    };
+
+    /**
+     * An immutable Cartographic instance initialized to (0.0, 0.0, 0.0).
+     *
+     * @memberof Cartographic
+     */
+    Cartographic.ZERO = freezeObject(new Cartographic(0.0, 0.0, 0.0));
+
+    /**
+     * Duplicates this instance.
+     * @memberof Cartographic
+     *
+     * @param {Cartographic} [result] The object onto which to store the result.
+     * @return {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.
+     * @memberof Cartographic
+     *
+     * @param {Cartographic} [right] The second cartographic.
+     * @return {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.
+     * @memberof Cartographic
+     *
+     * @param {Cartographic} [right] The second cartographic.
+     * @param {Number} epsilon The epsilon to use for equality testing.
+     * @return {Boolean} <code>true</code> if left and right are within the provided epsilon, <code>false</code> otherwise.
+     *
+     * @exception {DeveloperError} epsilon is required and must be a number.
+     */
+    Cartographic.prototype.equalsEpsilon = function(right, epsilon) {
+        return Cartographic.equalsEpsilon(this, right, epsilon);
+    };
+
+    /**
+     * Creates a string representing this cartographic in the format '(longitude, latitude, height)'.
+     * @memberof Cartographic
+     *
+     * @return {String} A string representing the provided cartographic in the format '(longitude, latitude, height)'.
+     */
+    Cartographic.prototype.toString = function() {
+        return Cartographic.toString(this);
+    };
+
+    return Cartographic;
+});

data/app/assets/javascripts/Core/CatmullRomSpline.js

@@ -0,0 +1,232 @@
+/*global define*/
+define([
+        './DeveloperError',
+        './Matrix4',
+        './Cartesian3',
+        './Cartesian4',
+        './HermiteSpline'
+    ],
+    function(
+        DeveloperError,
+        Matrix4,
+        Cartesian3,
+        Cartesian4,
+        HermiteSpline) {
+    "use strict";
+
+    /**
+     * A Catmull-Rom spline is a cubic spline where the tangent at control points,
+     * except the first and last, are computed using the previous and next control points.
+     * Catmull-Rom splines are in the class C<sup>1</sup>.
+     *
+     * @alias CatmullRomSpline
+     * @constructor
+     *
+     * @param {Array} controlPoints The array of control points. Each element of the array should be an object with <code>point</code> and <code>time</code> properties.
+     * @param {Cartesian3} firstTangent The tangent of the curve at the first control point.
+     * If the tangent is not given, it will be estimated.
+     * @param {Cartesian3} lastTangent The tangent of the curve at the last control point.
+     * If the tangent is not given, it will be estimated.
+     *
+     * @exception {DeveloperError} controlPoints is required.
+     * @exception {DeveloperError} controlPoints must be an array of at least length 3.
+     *
+     * @see HermiteSpline
+     *
+     * @example
+     * // spline above the earth from Philadelphia to Los Angeles
+     * var controlPoints = [
+     *     {point: new Cartesian3(1235398.0, -4810983.0, 4146266.0), time: 0.0},
+     *     {point: new Cartesian3(1372574.0, -5345182.0, 4606657.0), time: 1.5},
+     *     {point: new Cartesian3(-757983.0, -5542796.0, 4514323.0), time: 3.0},
+     *     {point: new Cartesian3(-2821260.0, -5248423.0, 4021290.0), time: 4.5},
+     *     {point: new Cartesian3(-2539788.0, -4724797.0, 3620093.0), time: 6.0}
+     * ];
+     * var spline = new CatmullRomSpline(controlPoints);
+     */
+    var CatmullRomSpline = function(controlPoints, firstTangent, lastTangent) {
+        if (!controlPoints || !(controlPoints instanceof Array) || controlPoints.length < 3) {
+            throw new DeveloperError('controlPoints is required and must be an array of objects with point and time properties, with a length of at least 3.');
+        }
+
+        this._points = controlPoints;
+        this._lastTimeIndex = 0;
+
+        if (firstTangent) {
+            this._ti = Cartesian3.clone(firstTangent);
+        } else {
+            var controlPoint0 = Cartesian3.clone(controlPoints[0].point);
+            var controlPoint1 = Cartesian3.clone(controlPoints[1].point);
+            var controlPoint2 = Cartesian3.clone(controlPoints[2].point);
+
+            this._ti = controlPoint1
+                           .multiplyByScalar(2.0)
+                           .subtract(controlPoint2)
+                           .subtract(controlPoint0)
+                           .multiplyByScalar(0.5);
+        }
+
+        if (firstTangent) {
+            this._to = Cartesian3.clone(lastTangent);
+        } else {
+            var n = controlPoints.length - 1;
+
+            var controlPointn0 = Cartesian3.clone(controlPoints[n].point);
+            var controlPointn1 = Cartesian3.clone(controlPoints[n - 1].point);
+            var controlPointn2 = Cartesian3.clone(controlPoints[n - 2].point);
+
+            this._to = controlPointn0
+                           .subtract(controlPointn1.multiplyByScalar(2.0))
+                           .add(controlPointn2)
+                           .multiplyByScalar(0.5);
+        }
+    };
+
+    CatmullRomSpline.catmullRomCoefficientMatrix = new Matrix4(
+            -0.5,  1.0, -0.5,  0.0,
+             1.5, -2.5,  0.0,  1.0,
+            -1.5,  2.0,  0.5,  0.0,
+             0.5, -0.5,  0.0,  0.0);
+
+    /**
+     * Returns the array of control points.
+     *
+     * @memberof CatmullRomSpline
+     * @return {Array} The array of control points.
+     */
+    CatmullRomSpline.prototype.getControlPoints = function() {
+        return this._points;
+    };
+
+    /**
+     * Returns the tangent of the first control point.
+     *
+     * @memberof CatmullRomSpline
+     *
+     * @return {Cartesian3} The tangent of the first control point.
+     *
+     * @see CatmullRomSpline#getEndTangent
+     */
+    CatmullRomSpline.prototype.getStartTangent = function() {
+        return this._ti;
+    };
+
+    /**
+     * Returns the tangent of the last control point.
+     *
+     * @memberof CatmullRomSpline
+     *
+     * @return {Cartesian3} The tangent of the last control point.
+     *
+     * @see CatmullRomSpline#getStartTangent
+     */
+    CatmullRomSpline.prototype.getEndTangent = function() {
+        return this._to;
+    };
+
+    CatmullRomSpline.prototype._findIndex = function(time) {
+        // Take advantage of temporal coherence by checking current, next and previous intervals
+        // for containment of time.
+        var i = this._lastTimeIndex || 0;
+        if (time >= this._points[i].time) {
+            if (i + 1 < this._points.length && time < this._points[i + 1].time) {
+                return i;
+            } else if (i + 2 < this._points.length && time < this._points[i + 2].time) {
+                this._lastTimeIndex = i + 1;
+                return this._lastTimeIndex;
+            }
+        } else if (i - 1 >= 0 && time >= this._points[i - 1].time) {
+            this._lastTimeIndex = i - 1;
+            return this._lastTimeIndex;
+        }
+
+        // The above failed so do a linear search. For the use cases so far, the
+        // length of the list is less than 10. In the future, if there is a bottle neck,
+        // it might be here.
+        for (i = 0; i < this._points.length - 1; ++i) {
+            if (time >= this._points[i].time && time < this._points[i + 1].time) {
+                break;
+            }
+        }
+
+        if (i === this._points.length - 1) {
+            i = this._points.length - 2;
+        }
+
+        this._lastTimeIndex = i;
+        return this._lastTimeIndex;
+    };
+
+    /**
+     * Evaluates the curve at a given time.
+     *
+     * @memberof CatmullRomSpline
+     *
+     * @param {Number} time The time at which to evaluate the curve.
+     *
+     * @exception {DeveloperError} time is required.
+     * @exception {DeveloperError} time must be in the range <code>[a<sub>0</sub>, a<sub>n</sub>]</code>,
+     * where <code>a<sub>0</sub></code> and <code>a<sub>n</sub></code> are the time properties of first and
+     * last elements in the array given during construction, respectively.
+     *
+     * @return {Cartesian3} The point on the curve at the given <code>time</code>.
+     *
+     * @example
+     * // spline above the earth from Philadelphia to Los Angeles
+     * var controlPoints = [
+     *     {point: new Cartesian3(1235398.0, -4810983.0, 4146266.0), time: 0.0},
+     *     {point: new Cartesian3(1372574.0, -5345182.0, 4606657.0), time: 1.5},
+     *     {point: new Cartesian3(-757983.0, -5542796.0, 4514323.0), time: 3.0},
+     *     {point: new Cartesian3(-2821260.0, -5248423.0, 4021290.0), time: 4.5},
+     *     {point: new Cartesian3(-2539788.0, -4724797.0, 3620093.0), time: 6.0}
+     * ];
+     * var spline = new CatmullRomSpline(controlPoints);
+     *
+     * // some position above Los Angeles
+     * var position = spline.evaluate(5.0);
+     */
+    CatmullRomSpline.prototype.evaluate = function(time) {
+        if (typeof time === 'undefined') {
+            throw new DeveloperError('time is required.');
+        }
+
+        if (time < this._points[0].time || time > this._points[this._points.length - 1].time) {
+            throw new DeveloperError('time is out of range.');
+        }
+
+        var i = this._findIndex(time);
+        var u = (time - this._points[i].time) / (this._points[i + 1].time - this._points[i].time);
+
+        var timeVec = new Cartesian3(0.0, u * u, u);
+        timeVec.x = timeVec.y * u;
+
+        var p0, p1, p2, p3, coefs;
+        if (i === 0) {
+            p0 = this._points[0].point;
+            p1 = this._points[1].point;
+            p2 = this._ti;
+            p3 = this._points[2].point.subtract(p0).multiplyByScalar(0.5);
+            coefs = HermiteSpline.hermiteCoefficientMatrix.multiplyByPoint(timeVec);
+        } else if (i === this._points.length - 2) {
+            p0 = this._points[i].point;
+            p1 = this._points[i + 1].point;
+            p2 = p1.subtract(this._points[i - 1].point).multiplyByScalar(0.5);
+            p3 = this._to;
+            coefs = HermiteSpline.hermiteCoefficientMatrix.multiplyByPoint(timeVec);
+        } else {
+            p0 = this._points[i - 1].point;
+            p1 = this._points[i].point;
+            p2 = this._points[i + 1].point;
+            p3 = this._points[i + 2].point;
+            coefs = CatmullRomSpline.catmullRomCoefficientMatrix.multiplyByPoint(timeVec);
+        }
+        p0 = p0.multiplyByScalar(coefs.x);
+        p1 = p1.multiplyByScalar(coefs.y);
+        p2 = p2.multiplyByScalar(coefs.z);
+        p3 = p3.multiplyByScalar(coefs.w);
+
+        return p0.add(p1.add(p2.add(p3)));
+    };
+
+    return CatmullRomSpline;
+});

data/app/assets/javascripts/Core/Clock.js

@@ -0,0 +1,195 @@
+/*global define*/
+define([
+        './DeveloperError',
+        './JulianDate',
+        './ClockStep',
+        './ClockRange'
+       ], function(
+         DeveloperError,
+         JulianDate,
+         ClockStep,
+         ClockRange) {
+    "use strict";
+
+    /**
+     * A simple clock for keeping track of simulated time.
+     * @alias Clock
+     * @constructor
+     *
+     * @param {Object} [template] The template object containing the properties to be set on the clock.
+     * @exception {DeveloperError} startTime must come before stopTime.
+     *
+     * @see ClockStep
+     * @see ClockRange
+     * @see JulianDate
+     * @see AnimationController
+     *
+     * @example
+     * //Create a clock that loops on Christmas day 2012 and runs
+     * //in real-time.  currentTime will default to startTime.
+     * var clock = new Clock({
+     *    startTime : JulianDate.fromIso8601("12-25-2012");
+     *    stopTime : JulianDate.fromIso8601("12-26-2012");
+     *    clockRange : ClockRange.LOOP;
+     * });
+     */
+    var Clock = function(template) {
+        var t = template;
+        if (typeof t === 'undefined') {
+            t = {};
+        }
+
+        var startTime = t.startTime;
+        var startTimeUndefined = typeof startTime === 'undefined';
+
+        var stopTime = t.stopTime;
+        var stopTimeUndefined = typeof stopTime === 'undefined';
+
+        var currentTime = t.currentTime;
+        var currentTimeUndefined = typeof currentTime === 'undefined';
+
+        if (startTimeUndefined && stopTimeUndefined && currentTimeUndefined) {
+            currentTime = new JulianDate();
+            startTime = currentTime.clone();
+            stopTime = currentTime.addDays(1.0);
+        } else if (startTimeUndefined && stopTimeUndefined) {
+            startTime = currentTime.clone();
+            stopTime = currentTime.addDays(1.0);
+        } else if (startTimeUndefined && currentTimeUndefined) {
+            startTime = stopTime.addDays(-1.0);
+            currentTime = startTime.clone();
+        } else if (currentTimeUndefined && stopTimeUndefined) {
+            currentTime = startTime.clone();
+            stopTime = startTime.addDays(1.0);
+        } else if (currentTimeUndefined) {
+            currentTime = startTime.clone();
+        } else if (stopTimeUndefined) {
+            stopTime = currentTime.addDays(1.0);
+        } else if (startTimeUndefined) {
+            startTime = currentTime.clone();
+        }
+
+        if (startTime.greaterThan(stopTime)) {
+            throw new DeveloperError('startTime must come before stopTime.');
+        }
+
+        var multiplier = t.multiplier;
+        if (typeof multiplier === 'undefined') {
+            multiplier = 1.0;
+        }
+
+        var clockStep = t.clockStep;
+        if (typeof clockStep === 'undefined') {
+            clockStep = ClockStep.SYSTEM_CLOCK_DEPENDENT;
+        }
+
+        var clockRange = t.clockRange;
+        if (typeof clockRange === 'undefined') {
+            clockRange = ClockRange.UNBOUNDED;
+        }
+
+        /**
+         * The start time of the clock.
+         * @type JulianDate
+         */
+        this.startTime = startTime;
+
+        /**
+         * The stop time of the clock.
+         * @type JulianDate
+         */
+        this.stopTime = stopTime;
+
+        /**
+         * The current time.
+         * @type JulianDate
+         */
+        this.currentTime = currentTime;
+
+        /**
+         * Determines how much time advances when tick is called, negative values allow for advancing backwards.
+         * If <code>clockStep</code> is set to ClockStep.TICK_DEPENDENT this is the number of seconds to advance.
+         * If <code>clockStep</code> is set to ClockStep.SYSTEM_CLOCK_DEPENDENT this value is multiplied by the
+         * elapsed system time since the last call to tick.
+         * @type Number
+         */
+        this.multiplier = multiplier;
+
+        /**
+         * Determines if calls to <code>tick</code> are frame dependent or system clock dependent.
+         * @type ClockStep
+         */
+        this.clockStep = clockStep;
+
+        /**
+         * Determines how tick should behave when <code>startTime</code> or <code>stopTime</code> is reached.
+         * @type ClockRange
+         */
+        this.clockRange = clockRange;
+
+        this._lastCpuTime = new Date().getTime();
+    };
+
+    /**
+     * Advances the clock from the currentTime based on the current configuration options.
+     * @memberof Clock
+     *
+     * @param {Number} [secondsToTick] optional parameter to force the clock to tick the provided number of seconds,
+     * regardless of the value of <code>clockStep</code> and <code>multiplier</code>.
+     * @returns {JulianDate} The new value of the <code>currentTime</code> property.
+     */
+    Clock.prototype.tick = function(secondsToTick) {
+        return this._tick(secondsToTick, this.multiplier);
+    };
+
+    /**
+     * Advances the clock in the opposite direction of the current <code>multiplier</code>.
+     * If <code>multiplier</code> is positive this will advance the clock backwards one tick.
+     * If <code>multiplier</code> is negative this will advance the clock forward one tick.
+     * @memberof Clock
+     *
+     * @returns {JulianDate} The new value of Clock.currentTime
+     */
+    Clock.prototype.reverseTick = function() {
+        return this._tick(undefined, -this.multiplier);
+    };
+
+    Clock.prototype._tick = function(secondsToTick, multiplier) {
+        var startTime = this.startTime;
+        var stopTime = this.stopTime;
+        var currentTime = this.currentTime;
+        var currentCpuTime = new Date().getTime();
+
+        if (typeof secondsToTick === 'undefined') {
+            if (this.clockStep === ClockStep.TICK_DEPENDENT) {
+                currentTime = currentTime.addSeconds(multiplier);
+            } else {
+                var milliseconds = currentCpuTime - this._lastCpuTime;
+                currentTime = currentTime.addSeconds(multiplier * (milliseconds / 1000.0));
+            }
+        } else {
+            currentTime = currentTime.addSeconds(secondsToTick);
+        }
+
+        if (this.clockRange === ClockRange.CLAMPED) {
+            if (currentTime.lessThan(startTime)) {
+                currentTime = startTime;
+            } else if (currentTime.greaterThan(stopTime)) {
+                currentTime = stopTime;
+            }
+        } else if (this.clockRange === ClockRange.LOOP) {
+            while (currentTime.lessThan(startTime)) {
+                currentTime = stopTime.addSeconds(startTime.getSecondsDifference(currentTime));
+            }
+            while (currentTime.greaterThan(stopTime)) {
+                currentTime = startTime.addSeconds(stopTime.getSecondsDifference(currentTime));
+            }
+        }
+
+        this.currentTime = currentTime;
+        this._lastCpuTime = currentCpuTime;
+        return currentTime;
+    };
+
+    return Clock;
+});