cesium 0.13.0

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

@@ -0,0 +1,234 @@
+/*global define*/
+define([
+        './DeveloperError',
+        './Matrix4',
+        './Cartesian4',
+        './TridiagonalSystemSolver'
+    ],
+    function(
+        DeveloperError,
+        Matrix4,
+        Cartesian4,
+        TridiagonalSystemSolver) {
+    "use strict";
+
+    /**
+     * A Hermite spline is a cubic interpolating spline. Positions, tangents, and times must be defined
+     * for each control point. If no tangents are specified by the control points, the end and interior
+     * tangents are generated, creating a natural cubic spline. If the only tangents specified are at
+     * the end control points, the interior tangents will be generated as well, creating a clamped cubic
+     * spline. Otherwise, it is assumed that each control point defines a tangent at that point.
+     *
+     * Natural and clamped cubic splines are in the class C<sup>2</sup>.
+     *
+     * @alias HermiteSpline
+     * @constructor
+     *
+     * @param {Array} controlPoints An array, of at least length 3, of objects with <code>point</code>,
+     * <code>time</code>, and <code>tangent</code> properties.
+     *
+     * @exception {DeveloperError} controlPoints is required.
+     * @exception {DeveloperError} controlPoints must be an array of at least length 3.
+     *
+     * @see CatmullRomSpline
+     *
+     * @example
+     * // Example 1.
+     * // Create a natural cubic 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 HermiteSpline(controlPoints);
+     *
+     * // Example 2.
+     * // Create a Catmull-Rom 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}
+     * ];
+     *
+     * // Add tangents
+     * controlPoints[0].tangent = new Cartesian3(1125196, -161816, 270551);
+     * for (var i = 1; i < controlPoints.length - 1; ++i) {
+     *     controlPoints[i].tangent = controlPoints[i + 1].point.subtract(controlPoints[i - 1].point).multiplyByScalar(0.5);
+     * }
+     * controlPoints[controlPoints.length - 1].tangent = new Cartesian3(1165345, 112641, 47281);
+     *
+     * var spline = new HermiteSpline(controlPoints);
+     */
+    var HermiteSpline = function(controlPoints) {
+        if (!controlPoints || !(controlPoints instanceof Array) || controlPoints.length < 3) {
+            throw new DeveloperError('controlPoints is required. It must be an array with at least a length of 3.');
+        }
+
+        this._points = controlPoints;
+
+        this._lastTimeIndex = 0;
+
+        if (!this._points[0].tangent || !this._points[this._points.length - 1].tangent) {
+            this._generateNatural();
+        } else if (this._points[0].tangent && !this._points[1].tangent && this._points[this._points.length - 1].tangent && !this._points[this._points.length - 2].tangent) {
+            this._generateClamped();
+        }
+    };
+
+    HermiteSpline.hermiteCoefficientMatrix = new Matrix4(
+             2.0, -3.0,  0.0,  1.0,
+            -2.0,  3.0,  0.0,  0.0,
+             1.0, -2.0,  1.0,  0.0,
+             1.0, -1.0,  0.0,  0.0);
+
+    HermiteSpline.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;
+    };
+
+    HermiteSpline.prototype._generateClamped = function() {
+        var l = [], d = [], u = [], r = [];
+        l.length = u.length = this._points.length - 1;
+        d.length = r.length = this._points.length;
+
+        var i;
+        l[0] = d[0] = 1.0;
+        u[0] = 0.0;
+        r[0] = this._points[0].tangent;
+        for (i = 1; i < l.length - 1; ++i) {
+            l[i] = u[i] = 1.0;
+            d[i] = 4.0;
+            r[i] = this._points[i + 1].point.subtract(this._points[i - 1].point).multiplyByScalar(3.0);
+        }
+        l[i] = 0.0;
+        u[i] = 1.0;
+        d[i] = 4.0;
+        r[i] = this._points[i + 1].point.subtract(this._points[i - 1].point).multiplyByScalar(3.0);
+        d[i + 1] = 1.0;
+        r[i + 1] = this._points[i + 1].tangent;
+
+        var tangents = TridiagonalSystemSolver.solve(l, d, u, r);
+        for (i = 0; i < this._points.length; ++i) {
+            this._points[i].tangent = tangents[i];
+        }
+    };
+
+    HermiteSpline.prototype._generateNatural = function() {
+        var l = [], d = [], u = [], r = [];
+        l.length = u.length = this._points.length - 1;
+        d.length = r.length = this._points.length;
+
+        var i;
+        l[0] = u[0] = 1.0;
+        d[0] = 2.0;
+        r[0] = this._points[1].point.subtract(this._points[0].point).multiplyByScalar(3.0);
+        for (i = 1; i < l.length; ++i) {
+            l[i] = u[i] = 1.0;
+            d[i] = 4.0;
+            r[i] = this._points[i + 1].point.subtract(this._points[i - 1].point).multiplyByScalar(3.0);
+        }
+        d[i] = 2.0;
+        r[i] = this._points[i].point.subtract(this._points[i - 1].point).multiplyByScalar(3.0);
+
+        var tangents = TridiagonalSystemSolver.solve(l, d, u, r);
+        for (i = 0; i < this._points.length; ++i) {
+            this._points[i].tangent = tangents[i];
+        }
+    };
+
+    /**
+     * Returns the array of control points.
+     *
+     * @memberof HermiteSpline
+     * @return {Array} The array of control points.
+     */
+    HermiteSpline.prototype.getControlPoints = function() {
+        return this._points;
+    };
+
+    /**
+     * Evaluates the curve at a given time.
+     *
+     * @memberof HermiteSpline
+     *
+     * @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 HermiteSpline(controlPoints);
+     *
+     * // some position above Los Angeles
+     * var position = spline.evaluate(5.0);
+     */
+    HermiteSpline.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 Cartesian4(0.0, u * u, u);
+        timeVec.x = timeVec.y * u;
+
+        var coefs = HermiteSpline.hermiteCoefficientMatrix.multiplyByPoint(timeVec);
+        var p0 = this._points[i].point.multiplyByScalar(coefs.x);
+        var p1 = this._points[i + 1].point.multiplyByScalar(coefs.y);
+        var p2 = this._points[i].tangent.multiplyByScalar(coefs.z);
+        var p3 = this._points[i + 1].tangent.multiplyByScalar(coefs.w);
+
+        return p0.add(p1.add(p2.add(p3)));
+    };
+
+    return HermiteSpline;
+});

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

@@ -0,0 +1,259 @@
+/*global define*/
+define([
+        './buildModuleUrl',
+        './defaultValue',
+        './loadJson',
+        './Iau2006XysSample',
+        './JulianDate',
+        './TimeStandard',
+        '../ThirdParty/when'
+    ],
+    function(
+        buildModuleUrl,
+        defaultValue,
+        loadJson,
+        Iau2006XysSample,
+        JulianDate,
+        TimeStandard,
+        when) {
+    "use strict";
+
+    /**
+     * A set of IAU2006 XYS data that is used to evaluate the transformation between the International
+     * Celestial Reference Frame (ICRF) and the International Terrestrial Reference Frame (ITRF).
+     *
+     * @alias Iau2006XysData
+     * @constructor
+     *
+     * @param {String} [description.xysFileUrlTemplate='Assets/IAU2006_XYS/IAU2006_XYS_{0}.json'] A template URL for obtaining the XYS data.  In the template,
+     *                 `{0}` will be replaced with the file index.
+     * @param {Number} [description.interpolationOrder=9] The order of interpolation to perform on the XYS data.
+     * @param {Number} [description.sampleZeroJulianEphemerisDate=2442396.5] The Julian ephemeris date (JED) of the
+     *                 first XYS sample.
+     * @param {Number} [description.stepSizeDays=1.0] The step size, in days, between successive XYS samples.
+     * @param {Number} [description.samplesPerXysFile=1000] The number of samples in each XYS file.
+     * @param {Number} [description.totalSamples=27426] The total number of samples in all XYS files.
+     */
+    var Iau2006XysData = function Iau2006XysData(description) {
+        description = description || {};
+
+        this._xysFileUrlTemplate = defaultValue(description.xysFileUrlTemplate, buildModuleUrl('Assets/IAU2006_XYS/IAU2006_XYS_{0}.json'));
+        this._interpolationOrder = defaultValue(description.interpolationOrder, 9);
+        this._sampleZeroJulianEphemerisDate = defaultValue(description.sampleZeroJulianEphemerisDate, 2442396.5);
+        this._sampleZeroDateTT = new JulianDate(this._sampleZeroJulianEphemerisDate, 0.0, TimeStandard.TAI);
+        this._stepSizeDays = defaultValue(description.stepSizeDays, 1.0);
+        this._samplesPerXysFile = defaultValue(description.samplesPerXysFile, 1000);
+        this._totalSamples = defaultValue(description.totalSamples, 27426);
+        this._samples = new Array(this._totalSamples * 3);
+        this._chunkDownloadsInProgress = [];
+
+        var order = this._interpolationOrder;
+
+        // Compute denominators and X values for interpolation.
+        var denom = this._denominators = new Array(order + 1);
+        var xTable = this._xTable = new Array(order + 1);
+
+        var stepN = Math.pow(this._stepSizeDays, order);
+
+        for ( var i = 0; i <= order; ++i) {
+            denom[i] = stepN;
+            xTable[i] = i * this._stepSizeDays;
+
+            for ( var j = 0; j <= order; ++j) {
+                if (j !== i) {
+                    denom[i] *= (i - j);
+                }
+            }
+
+            denom[i] = 1.0 / denom[i];
+        }
+
+        // Allocate scratch arrays for interpolation.
+        this._work = new Array(order + 1);
+        this._coef = new Array(order + 1);
+    };
+
+    var julianDateScratch = new JulianDate(0, 0.0, TimeStandard.TAI);
+
+    function getDaysSinceEpoch(xys, dayTT, secondTT) {
+        var dateTT = julianDateScratch;
+        dateTT._julianDayNumber = dayTT;
+        dateTT._secondsOfDay = secondTT;
+        return xys._sampleZeroDateTT.getDaysDifference(dateTT);
+    }
+
+    /**
+     * Preloads XYS data for a specified date range.
+     *
+     * @memberof Iau2006XysData
+     *
+     * @param {Number} startDayTT The Julian day number of the beginning of the interval to preload, expressed in
+     *                 the Terrestrial Time (TT) time standard.
+     * @param {Number} startSecondTT The seconds past noon of the beginning of the interval to preload, expressed in
+     *                 the Terrestrial Time (TT) time standard.
+     * @param {Number} stopDayTT The Julian day number of the end of the interval to preload, expressed in
+     *                 the Terrestrial Time (TT) time standard.
+     * @param {Number} stopSecondTT The seconds past noon of the end of the interval to preload, expressed in
+     *                 the Terrestrial Time (TT) time standard.
+
+     * @returns {Promise} A promise that, when resolved, indicates that the requested interval has been
+     *                    preloaded.
+     */
+    Iau2006XysData.prototype.preload = function(startDayTT, startSecondTT, stopDayTT, stopSecondTT) {
+        var startDaysSinceEpoch = getDaysSinceEpoch(this, startDayTT, startSecondTT);
+        var stopDaysSinceEpoch = getDaysSinceEpoch(this, stopDayTT, stopSecondTT);
+
+        var startIndex = (startDaysSinceEpoch / this._stepSizeDays - this._interpolationOrder / 2) | 0;
+        if (startIndex < 0) {
+            startIndex = 0;
+        }
+
+        var stopIndex = (stopDaysSinceEpoch / this._stepSizeDays - this._interpolationOrder / 2) | 0 + this._interpolationOrder;
+        if (stopIndex >= this._totalSamples) {
+            stopIndex = this._totalSamples - 1;
+        }
+
+        var startChunk = (startIndex / this._samplesPerXysFile) | 0;
+        var stopChunk = (stopIndex / this._samplesPerXysFile) | 0;
+
+        var promises = [];
+        for ( var i = startChunk; i <= stopChunk; ++i) {
+            promises.push(requestXysChunk(this, i));
+        }
+
+        return when.all(promises);
+    };
+
+    /**
+     * Computes the XYS values for a given date by interpolating.  If the required data is not yet downloaded,
+     * this method will return undefined.
+     *
+     * @memberof Iau2006XysData
+     *
+     * @param {Number} dayTT The Julian day number for which to compute the XYS value, expressed in
+     *                 the Terrestrial Time (TT) time standard.
+     * @param {Number} secondTT The seconds past noon of the date for which to compute the XYS value, expressed in
+     *                 the Terrestrial Time (TT) time standard.
+     * @param {Iau2006XysSample} [result] The instance to which to copy the interpolated result.  If this parameter
+     *                           is undefined, a new instance is allocated and returned.
+     * @returns {Iau2006XysSample} The interpolated XYS values, or undefined if the required data for this
+     *                             computation has not yet been downloaded.
+     *
+     * @see Iau2006XysData#preload
+     */
+    Iau2006XysData.prototype.computeXysRadians = function(dayTT, secondTT, result) {
+        var daysSinceEpoch = getDaysSinceEpoch(this, dayTT, secondTT);
+        if (daysSinceEpoch < 0.0) {
+            // Can't evaluate prior to the epoch of the data.
+            return undefined;
+        }
+
+        var centerIndex = (daysSinceEpoch / this._stepSizeDays) | 0;
+        if (centerIndex >= this._totalSamples) {
+            // Can't evaluate after the last sample in the data.
+            return undefined;
+        }
+
+        var degree = this._interpolationOrder;
+
+        var firstIndex = centerIndex - ((degree / 2) | 0);
+        if (firstIndex < 0) {
+            firstIndex = 0;
+        }
+        var lastIndex = firstIndex + degree;
+        if (lastIndex >= this._totalSamples) {
+            lastIndex = this._totalSamples - 1;
+            firstIndex = lastIndex - degree;
+            if (firstIndex < 0) {
+                firstIndex = 0;
+            }
+        }
+
+        // Are all the samples we need present?
+        // We can assume so if the first and last are present
+        var isDataMissing = false;
+        var samples = this._samples;
+        if (typeof samples[firstIndex * 3] === 'undefined') {
+            requestXysChunk(this, (firstIndex / this._samplesPerXysFile) | 0);
+            isDataMissing = true;
+        }
+
+        if (typeof samples[lastIndex * 3] === 'undefined') {
+            requestXysChunk(this, (lastIndex / this._samplesPerXysFile) | 0);
+            isDataMissing = true;
+        }
+
+        if (isDataMissing) {
+            return undefined;
+        }
+
+        if (typeof result === 'undefined') {
+            result = new Iau2006XysSample(0.0, 0.0, 0.0);
+        } else {
+            result.x = 0.0;
+            result.y = 0.0;
+            result.s = 0.0;
+        }
+
+        var x = daysSinceEpoch - firstIndex * this._stepSizeDays;
+
+        var work = this._work;
+        var denom = this._denominators;
+        var coef = this._coef;
+        var xTable = this._xTable;
+
+        var i, j;
+        for (i = 0; i <= degree; ++i) {
+            work[i] = x - xTable[i];
+        }
+
+        for (i = 0; i <= degree; ++i) {
+            coef[i] = 1.0;
+
+            for (j = 0; j <= degree; ++j) {
+                if (j !== i) {
+                    coef[i] *= work[j];
+                }
+            }
+
+            coef[i] *= denom[i];
+
+            var sampleIndex = (firstIndex + i) * 3;
+            result.x += coef[i] * samples[sampleIndex++];
+            result.y += coef[i] * samples[sampleIndex++];
+            result.s += coef[i] * samples[sampleIndex];
+        }
+
+        return result;
+    };
+
+    function requestXysChunk(xysData, chunkIndex) {
+        if (xysData._chunkDownloadsInProgress[chunkIndex]) {
+            // Chunk has already been requested.
+            return xysData._chunkDownloadsInProgress[chunkIndex];
+        }
+
+        var deferred = when.defer();
+
+        xysData._chunkDownloadsInProgress[chunkIndex] = deferred;
+
+        var chunkUrl = xysData._xysFileUrlTemplate.replace('{0}', chunkIndex);
+        when(loadJson(chunkUrl), function(chunk) {
+            xysData._chunkDownloadsInProgress[chunkIndex] = false;
+
+            var samples = xysData._samples;
+            var newSamples = chunk.samples;
+            var startIndex = chunkIndex * xysData._samplesPerXysFile * 3;
+
+            for ( var i = 0, len = newSamples.length; i < len; ++i) {
+                samples[startIndex + i] = newSamples[i];
+            }
+
+            deferred.resolve();
+        });
+
+        return deferred.promise;
+    }
+
+    return Iau2006XysData;
+});