cesium 0.22.0 → 0.23.0

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

@@ -760,7 +760,7 @@ define(['Core/Cartesian3', 'Core/defaultValue', 'Core/defined', 'Core/DeveloperE
         // dot > 0, as the dot product approaches 1, the angle between the
         // quaternions vanishes. use linear interpolation.
         if (1.0 - dot < CesiumMath.EPSILON6) {
-            return Quaternion.lerp(start, r, t);
+            return Quaternion.lerp(start, r, t, result);
         }
 
         var theta = Math.acos(dot);
@@ -770,6 +770,152 @@ define(['Core/Cartesian3', 'Core/defaultValue', 'Core/defined', 'Core/DeveloperE
         return Quaternion.multiplyByScalar(result, 1.0 / Math.sin(theta), result);
     };
 
+    /**
+     * The logarithmic quaternion function.
+     * @memberof Quaternion
+     *
+     * @param {Quaternion} quaternion The unit quaternion.
+     * @param {Cartesian3} [result] The object onto which to store the result.
+     * @returns {Cartesian3} The modified result parameter or a new instance if one was not provided.
+     *
+     * @exception {DeveloperError} quaternion is required.
+     */
+    Quaternion.log = function(quaternion, result) {
+        if (!defined(quaternion)) {
+            throw new DeveloperError('quaternion is required.');
+        }
+
+        var theta = Math.acos(CesiumMath.clamp(quaternion.w, -1.0, 1.0));
+        var thetaOverSinTheta = 0.0;
+
+        if (theta !== 0.0) {
+            thetaOverSinTheta = theta / Math.sin(theta);
+        }
+
+        if (!defined(result)) {
+            result = new Cartesian3();
+        }
+
+        return Cartesian3.multiplyByScalar(quaternion, thetaOverSinTheta, result);
+    };
+
+    var expScratch = new Cartesian3();
+
+    /**
+     * The exponential quaternion function.
+     * @memberof Quaternion
+     *
+     * @param {Cartesian3} cartesian The cartesian.
+     * @param {Quaternion} [result] The object onto which to store the result.
+     * @returns {Quaternion} The modified result parameter or a new instance if one was not provided.
+     *
+     * @exception {DeveloperError} cartesian is required.
+     */
+    Quaternion.exp = function(cartesian, result) {
+        if (!defined(cartesian)) {
+            throw new DeveloperError('cartesian is required.');
+        }
+
+        var theta = Cartesian3.magnitude(cartesian);
+        var sinThetaOverTheta = 0.0;
+
+        if (theta !== 0.0) {
+            sinThetaOverTheta = Math.sin(theta) / theta;
+        }
+
+        if (!defined(result)) {
+            result = new Quaternion();
+        }
+
+        result.x = cartesian.x * sinThetaOverTheta;
+        result.y = cartesian.y * sinThetaOverTheta;
+        result.z = cartesian.z * sinThetaOverTheta;
+        result.w = Math.cos(theta);
+
+        return result;
+    };
+
+    var squadScratchCartesian0 = new Cartesian3();
+    var squadScratchCartesian1 = new Cartesian3();
+    var squadScratchQuaternion0 = new Quaternion();
+    var squadScratchQuaternion1 = new Quaternion();
+
+    /**
+     * Computes an inner quadrangle point.
+     * <p>This will compute quaternions that ensure a squad curve is C<sup>1</sup>.</p>
+     * @memberof Quaternion
+     *
+     * @param {Quaternion} q0 The first quaternion.
+     * @param {Quaternion} q1 The second quaternion.
+     * @param {Quaternion} q2 The third quaternion.
+     * @param {Quaternion} [result] The object onto which to store the result.
+     * @returns {Quaternion} The modified result parameter or a new instance if none was provided.
+     *
+     * @exception {DeveloperError} q0, q1, and q2 are required.
+     *
+     * @see Quaternion#squad
+     */
+    Quaternion.innerQuadrangle = function(q0, q1, q2, result) {
+        if (!defined(q0) || !defined(q1) || !defined(q2)) {
+            throw new DeveloperError('q0, q1, and q2 are required.');
+        }
+
+        var qInv = Quaternion.conjugate(q1, squadScratchQuaternion0);
+        Quaternion.multiply(qInv, q2, squadScratchQuaternion1);
+        var cart0 = Quaternion.log(squadScratchQuaternion1, squadScratchCartesian0);
+
+        Quaternion.multiply(qInv, q0, squadScratchQuaternion1);
+        var cart1 = Quaternion.log(squadScratchQuaternion1, squadScratchCartesian1);
+
+        Cartesian3.add(cart0, cart1, cart0);
+        Cartesian3.multiplyByScalar(cart0, 0.25, cart0);
+        Cartesian3.negate(cart0, cart0);
+        Quaternion.exp(cart0, squadScratchQuaternion0);
+
+        return Quaternion.multiply(q1, squadScratchQuaternion0, result);
+    };
+
+    /**
+     * Computes the spherical quadrangle interpolation between quaternions.
+     * @memberof Quaternion
+     *
+     * @param {Quaternion} q0 The first quaternion.
+     * @param {Quaternion} q1 The second quaternion.
+     * @param {Quaternion} s0 The first inner quadrangle.
+     * @param {Quaternion} s1 The second inner quadrangle.
+     * @param {Number} t The time in [0,1] used to interpolate.
+     * @param {Quaternion} [result] The object onto which to store the result.
+     * @returns {Quaternion} The modified result parameter or a new instance if none was provided.
+     *
+     * @exception {DeveloperError} q0, q1, s0, and s1 are required.
+     * @exception {DeveloperError} t is required and must be a number.
+     *
+     * @see Quaternion#innerQuadrangle
+     *
+     * @example
+     * // 1. compute the squad interpolation between two quaternions on a curve
+     * var s0 = Quaternion.innerQuadrangle(quaternions[i - 1], quaternions[i], quaternions[i + 1]);
+     * var s1 = Quaternion.innerQuadrangle(quaternions[i], quaternions[i + 1], quaternions[i + 2]);
+     * var q = Quaternion.squad(quaternions[i], quaternions[i + 1], s0, s1, t);
+     *
+     * // 2. compute the squad interpolation as above but where the first quaternion is a end point.
+     * var s1 = Quaternion.innerQuadrangle(quaternions[0], quaternions[1], quaternions[2]);
+     * var q = Quaternion.squad(quaternions[0], quaternions[1], quaternions[0], s1, t);
+     */
+    Quaternion.squad = function(q0, q1, s0, s1, t, result) {
+        if (!defined(q0) || !defined(q1) || !defined(s0) || !defined(s1)) {
+            throw new DeveloperError('q0, q1, s0, and s1 are required.');
+        }
+
+        if (typeof t !== 'number') {
+            throw new DeveloperError('t is required and must be a number.');
+        }
+
+        var slerp0 = Quaternion.slerp(q0, q1, t, squadScratchQuaternion0);
+        var slerp1 = Quaternion.slerp(s0, s1, t, squadScratchQuaternion1);
+        return Quaternion.slerp(slerp0, slerp1, 2.0 * t * (1.0 - t), result);
+    };
+
     /**
      * Compares the provided quaternions componentwise and returns
      * <code>true</code> if they are equal, <code>false</code> otherwise.

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

@@ -0,0 +1,160 @@
+/*global define*/
+define(['Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'Core/Spline', 'Core/Quaternion'], function(
+        defaultValue,
+        defined,
+        DeveloperError,
+        Spline,
+        Quaternion) {
+    "use strict";
+
+    function computeInnerQuadrangles(points, firstInnerQuadrangle, lastInnerQuadrangle) {
+        var length = points.length;
+        var quads = new Array(length);
+
+        quads[0] = defined(firstInnerQuadrangle) ? firstInnerQuadrangle : points[0];
+        quads[length - 1] = defined(lastInnerQuadrangle) ? lastInnerQuadrangle : points[length - 1];
+
+        for (var i = 1; i < length - 1; ++i) {
+            quads[i] = Quaternion.innerQuadrangle(points[i - 1], points[i], points[i + 1]);
+        }
+
+        return quads;
+    }
+
+    function createEvaluateFunction(spline) {
+        var points = spline.points;
+        var quads = spline.innerQuadrangles;
+        var times = spline.times;
+
+        // use slerp interpolation for 2 points
+        if (points.length < 3) {
+            var t0 = times[0];
+            var invSpan = 1.0 / (times[1] - t0);
+
+            var q0 = points[0];
+            var q1 = points[1];
+
+            return function(time, result) {
+                var u = (time - t0) * invSpan;
+                return Quaternion.slerp(q0, q1, u, result);
+            };
+        }
+
+        // use quad interpolation for more than 3 points
+        return function(time, result) {
+            var i = spline._lastTimeIndex = spline.findTimeInterval(time, spline._lastTimeIndex);
+            var u = (time - times[i]) / (times[i + 1] - times[i]);
+
+            var q0 = points[i];
+            var q1 = points[i + 1];
+            var s0 = quads[i];
+            var s1 = quads[i + 1];
+
+            return Quaternion.squad(q0, q1, s0, s1, u, result);
+        };
+    }
+
+    /**
+     * A spline that uses spherical quadrangle (squad) interpolation to create a quaternion curve.
+     * The generated curve is in the class C<sup>1</sup>.
+     *
+     * @alias QuaternionSpline
+     * @constructor
+     *
+     * @param {Array} options.times The array of control point times.
+     * @param {Array} options.points The array of control points.
+     * @param {Quaternion} [options.firstInnerQuadrangle] The inner quadrangle of the curve at the first control point.
+     *                     If the inner quadrangle is not given, it will be estimated.
+     * @param {Quaternion} [options.lastInnerQuadrangle] The inner quadrangle of the curve at the last control point.
+     *                     If the inner quadrangle is not given, it will be estimated.
+     *
+     * @exception {DeveloperError} points is required.
+     * @exception {DeveloperError} points.length must be greater than or equal to 2.
+     * @exception {DeveloperError} times is required.
+     * @exception {DeveloperError} times.length must be equal to points.length.
+     */
+    var QuaternionSpline = function(options) {
+        options = defaultValue(options, defaultValue.EMPTY_OBJECT);
+
+        var points = options.points;
+        var times = options.times;
+        var firstInnerQuadrangle = options.firstInnerQuadrangle;
+        var lastInnerQuadrangle = options.lastInnerQuadrangle;
+
+        if (!defined(points)) {
+            throw new DeveloperError('points is required.');
+        }
+
+        if (points.length < 2) {
+            throw new DeveloperError('points.length must be greater than or equal to 2.');
+        }
+
+        if (!defined(times)) {
+            throw new DeveloperError('times is required.');
+        }
+
+        if (times.length !== points.length) {
+            throw new DeveloperError('times.length must be equal to points.length.');
+        }
+
+        var innerQuadrangles = computeInnerQuadrangles(points, firstInnerQuadrangle, lastInnerQuadrangle);
+
+        /**
+         * An array of times for the control points.
+         * @type {Array}
+         * @readonly
+         */
+        this.times = times;
+
+        /**
+         * An array of {@link Quaternion} control points.
+         * @type {Array}
+         * @readonly
+         */
+        this.points = points;
+
+        /**
+         * An array of {@link Quaternion} inner qradrangles for the control points.
+         * @type {Array}
+         * @readonly
+         */
+        this.innerQuadrangles = innerQuadrangles;
+
+        this._evaluateFunction = createEvaluateFunction(this);
+        this._lastTimeIndex = 0;
+    };
+
+    /**
+     * Finds an index <code>i</code> in <code>times</code> such that the parameter
+     * <code>time</code> is in the interval <code>[times[i], times[i + 1]]</code>.
+     * @memberof QuaternionSpline
+     *
+     * @param {Number} time The time.
+     * @returns {Number} The index for the element at the start of the interval.
+     *
+     * @exception {DeveloperError} time is required.
+     * @exception {DeveloperError} time must be in the range <code>[t<sub>0</sub>, t<sub>n</sub>]</code>, where <code>t<sub>0</sub></code>
+     *                             is the first element in the array <code>times</code> and <code>t<sub>n</sub></code> is the last element
+     *                             in the array <code>times</code>.
+     */
+    QuaternionSpline.prototype.findTimeInterval = Spline.prototype.findTimeInterval;
+
+    /**
+     * Evaluates the curve at a given time.
+     * @memberof QuaternionSpline
+     *
+     * @param {Number} time The time at which to evaluate the curve.
+     * @param {Quaternion} [result] The object onto which to store the result.
+     * @returns {Quaternion} The modified result parameter or a new instance of the point on the curve at the given time.
+     *
+     * @exception {DeveloperError} time is required.
+     * @exception {DeveloperError} time must be in the range <code>[t<sub>0</sub>, t<sub>n</sub>]</code>, where <code>t<sub>0</sub></code>
+     *                             is the first element in the array <code>times</code> and <code>t<sub>n</sub></code> is the last element
+     *                             in the array <code>times</code>.
+     */
+    QuaternionSpline.prototype.evaluate = function(time, result) {
+        return this._evaluateFunction(time, result);
+    };
+
+    return QuaternionSpline;
+});

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

@@ -0,0 +1,121 @@
+/*global define*/
+define(['Core/defaultValue', 'Core/defined', 'Core/DeveloperError'], function(
+        defaultValue,
+        defined,
+        DeveloperError) {
+    "use strict";
+
+    /**
+     * Creates a curve parameterized and evaluated by time. This type describes an interface
+     * and is not intended to be instantiated directly.
+     *
+     * @alias Spline
+     * @constructor
+     *
+     * @see CatmullRomSpline
+     * @see HermiteSpline
+     */
+    var Spline = function() {
+        /**
+         * An array of times for the control points.
+         * @type {Array}
+         * @default undefined
+         */
+        this.times = undefined;
+
+        /**
+         * An array of control points.
+         * @type {Array}
+         * @default undefined
+         */
+        this.points = undefined;
+
+        throw new DeveloperError('This type should not be instantiated directly.');
+    };
+
+    /**
+     * Evaluates the curve at a given time.
+     * @memberof Spline
+     *
+     * @param {Number} time The time at which to evaluate the curve.
+     * @param {Cartesian3|Quaternion} [result] The object onto which to store the result.
+     *
+     * @returns {Cartesian3|Quaternion} The modified result parameter or a new instance of the point on the curve at the given time.
+     *
+     * @exception {DeveloperError} time is required.
+     * @exception {DeveloperError} time must be in the range <code>[t<sub>0</sub>, t<sub>n</sub>]</code>, where <code>t<sub>0</sub></code>
+     *                             is the first element in the array <code>times</code> and <code>t<sub>n</sub></code> is the last element
+     *                             in the array <code>times</code>.
+     */
+    Spline.prototype.evaluate = function(time, result) {
+        throw new DeveloperError('This type should not be instantiated directly.');
+    };
+
+    /**
+     * Finds an index <code>i</code> in <code>times</code> such that the parameter
+     * <code>time</code> is in the interval <code>[times[i], times[i + 1]]</code>.
+     * @memberof Spline
+     *
+     * @param {Number} time The time.
+     * @param {Number} startIndex The index from which to start the search.
+     * @returns {Number} The index for the element at the start of the interval.
+     *
+     * @exception {DeveloperError} time is required.
+     * @exception {DeveloperError} time must be in the range <code>[t<sub>0</sub>, t<sub>n</sub>]</code>, where <code>t<sub>0</sub></code>
+     *                             is the first element in the array <code>times</code> and <code>t<sub>n</sub></code> is the last element
+     *                             in the array <code>times</code>.
+     */
+    Spline.prototype.findTimeInterval = function(time, startIndex) {
+        if (!defined(time)) {
+            throw new DeveloperError('time is required.');
+        }
+
+        var times = this.times;
+        var length = times.length;
+
+        if (time < times[0] || time > times[length - 1]) {
+            throw new DeveloperError('time is out of range.');
+        }
+
+        // Take advantage of temporal coherence by checking current, next and previous intervals
+        // for containment of time.
+        startIndex = defaultValue(startIndex, 0);
+
+        if (time >= times[startIndex]) {
+            if (startIndex + 1 < length && time < times[startIndex + 1]) {
+                return startIndex;
+            } else if (startIndex + 2 < length && time < times[startIndex + 2]) {
+                return startIndex + 1;
+            }
+        } else if (startIndex - 1 >= 0 && time >= times[startIndex - 1]) {
+            return startIndex - 1;
+        }
+
+        // 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.
+
+        var i;
+        if (time > times[startIndex]) {
+            for (i = startIndex; i < length - 1; ++i) {
+                if (time >= times[i] && time < times[i + 1]) {
+                    break;
+                }
+            }
+        } else {
+            for (i = startIndex - 1; i >= 0; --i) {
+                if (time >= times[i] && time < times[i + 1]) {
+                    break;
+                }
+            }
+        }
+
+        if (i === length - 1) {
+            i = length - 2;
+        }
+
+        return i;
+    };
+
+    return Spline;
+});

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

@@ -258,7 +258,6 @@ define(['Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'Core/Iau200
      * function updateAndRender() {
      *     var now = new JulianDate();
      *     scene.initializeFrame();
-     *     scene.setSunPosition(Simon1994PlanetaryPositions.ComputeSunPositionInEarthInertialFrame(now));
      *     scene.getCamera().transform = Matrix4.fromRotationTranslation(Transforms.computeTemeToPseudoFixedMatrix(now), Cartesian3.ZERO);
      *     scene.render();
      *     requestAnimationFrame(updateAndRender);
@@ -396,7 +395,6 @@ define(['Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'Core/Iau200
      * function updateAndRender() {
      *     var now = new JulianDate();
      *     scene.initializeFrame();
-     *     scene.setSunPosition(Simon1994PlanetaryPositions.ComputeSunPositionInEarthInertialFrame(now));
      *     var icrfToFixed = Transforms.computeIcrfToFixedMatrix(now);
      *     if (defined(icrfToFixed)) {
      *         scene.getCamera().transform = Matrix4.fromRotationTranslation(icrfToFixed, Cartesian3.ZERO);