cesium 0.13.0

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

@@ -0,0 +1,235 @@
+/*global define*/
+define([
+        './DeveloperError'
+    ], function(
+        DeveloperError) {
+    "use strict";
+
+    var _supportsFullscreen;
+    var _names = {
+        requestFullscreen : undefined,
+        exitFullscreen : undefined,
+        fullscreenEnabled : undefined,
+        fullscreenElement : undefined,
+        fullscreenchange : undefined,
+        fullscreenerror : undefined
+    };
+
+    /**
+     * Browser-independent functions for working with the standard fullscreen API.
+     *
+     * @exports Fullscreen
+     *
+     * @see <a href='http://dvcs.w3.org/hg/fullscreen/raw-file/tip/Overview.html'>W3C Fullscreen Living Specification</a>
+     */
+    var Fullscreen = {};
+
+    /**
+     * Detects whether the browser supports the standard fullscreen API.
+     *
+     * @returns <code>true</code> if the browser supports the standard fullscreen API,
+     * <code>false</code> otherwise.
+     */
+    Fullscreen.supportsFullscreen = function() {
+        if (typeof _supportsFullscreen !== 'undefined') {
+            return _supportsFullscreen;
+        }
+
+        _supportsFullscreen = false;
+
+        var body = document.body;
+        if (typeof body.requestFullscreen === 'function') {
+            // go with the unprefixed, standard set of names
+            _names.requestFullscreen = 'requestFullscreen';
+            _names.exitFullscreen = 'exitFullscreen';
+            _names.fullscreenEnabled = 'fullscreenEnabled';
+            _names.fullscreenElement = 'fullscreenElement';
+            _names.fullscreenchange = 'fullscreenchange';
+            _names.fullscreenerror = 'fullscreenerror';
+            _supportsFullscreen = true;
+            return _supportsFullscreen;
+        }
+
+        //check for the correct combination of prefix plus the various names that browsers use
+        var prefixes = ['webkit', 'moz', 'o', 'ms', 'khtml'];
+        var name;
+        for ( var i = 0, len = prefixes.length; i < len; ++i) {
+            var prefix = prefixes[i];
+
+            // casing of Fullscreen differs across browsers
+            name = prefix + 'RequestFullscreen';
+            if (typeof body[name] === 'function') {
+                _names.requestFullscreen = name;
+                _supportsFullscreen = true;
+            } else {
+                name = prefix + 'RequestFullScreen';
+                if (typeof body[name] === 'function') {
+                    _names.requestFullscreen = name;
+                    _supportsFullscreen = true;
+                }
+            }
+
+            // disagreement about whether it's "exit" as per spec, or "cancel"
+            name = prefix + 'ExitFullscreen';
+            if (typeof document[name] === 'function') {
+                _names.exitFullscreen = name;
+            } else {
+                name = prefix + 'CancelFullScreen';
+                if (typeof document[name] === 'function') {
+                    _names.exitFullscreen = name;
+                }
+            }
+
+            // casing of Fullscreen differs across browsers
+            name = prefix + 'FullscreenEnabled';
+            if (typeof document[name] !== 'undefined') {
+                _names.fullscreenEnabled = name;
+            } else {
+                name = prefix + 'FullScreenEnabled';
+                if (typeof document[name] !== 'undefined') {
+                    _names.fullscreenEnabled = name;
+                }
+            }
+
+            // casing of Fullscreen differs across browsers
+            name = prefix + 'FullscreenElement';
+            if (typeof document[name] !== 'undefined') {
+                _names.fullscreenElement = name;
+            } else {
+                name = prefix + 'FullScreenElement';
+                if (typeof document[name] !== 'undefined') {
+                    _names.fullscreenElement = name;
+                }
+            }
+
+            // thankfully, event names are all lowercase per spec
+            name = prefix + 'fullscreenchange';
+            // event names do not have 'on' in the front, but the property on the document does
+            if (typeof document['on' + name] !== 'undefined') {
+                _names.fullscreenchange = name;
+            }
+
+            name = prefix + 'fullscreenerror';
+            if (typeof document['on' + name] !== 'undefined') {
+                _names.fullscreenerror = name;
+            }
+        }
+
+        return _supportsFullscreen;
+    };
+
+    /**
+     * Asynchronously requests the browser to enter fullscreen mode on the given element.
+     * If fullscreen mode is not supported by the browser, does nothing.
+     *
+     * @param {Object} element The HTML element which will be placed into fullscreen mode.
+     *
+     * @example
+     * // Put the entire page into fullscreen.
+     * Fullscreen.requestFullscreen(document.body)
+     *
+     * // Place only the Cesium canvas into fullscreen.
+     * Fullscreen.requestFullscreen(scene.getCanvas())
+     */
+    Fullscreen.requestFullscreen = function(element) {
+        if (!Fullscreen.supportsFullscreen()) {
+            return;
+        }
+
+        element[_names.requestFullscreen]();
+    };
+
+    /**
+     * Asynchronously exits fullscreen mode.  If the browser is not currently
+     * in fullscreen, or if fullscreen mode is not supported by the browser, does nothing.
+     */
+    Fullscreen.exitFullscreen = function() {
+        if (!Fullscreen.supportsFullscreen()) {
+            return;
+        }
+
+        document[_names.exitFullscreen]();
+    };
+
+    /**
+     * Determine whether the browser will allow an element to be made fullscreen, or not.
+     * For example, by default, iframes cannot go fullscreen unless the containing page
+     * adds an "allowfullscreen" attribute (or prefixed equivalent).
+     *
+     * @returns {Boolean} <code>true</code> if the browser is able to enter fullscreen mode,
+     * <code>false</code> if not, and <code>undefined</code> if the browser does not
+     * support fullscreen mode.
+     */
+    Fullscreen.isFullscreenEnabled = function() {
+        if (!Fullscreen.supportsFullscreen()) {
+            return undefined;
+        }
+
+        return document[_names.fullscreenEnabled];
+    };
+
+    /**
+     * Gets the element that is currently fullscreen, if any.  To simply check if the
+     * browser is in fullscreen mode or not, use {@link Fullscreen#isFullscreen}.
+     *
+     * @returns {Object} the element that is currently fullscreen, or <code>null</code> if the browser is
+     * not in fullscreen mode, or <code>undefined</code> if the browser does not support fullscreen
+     * mode.
+     */
+    Fullscreen.getFullscreenElement = function() {
+        if (!Fullscreen.supportsFullscreen()) {
+            return undefined;
+        }
+
+        return document[_names.fullscreenElement];
+    };
+
+    /**
+     * Determines if the browser is currently in fullscreen mode.
+     *
+     * @returns {Boolean} <code>true</code> if the browser is currently in fullscreen mode, <code>false</code>
+     * if it is not, or <code>undefined</code> if the browser does not support fullscreen mode.
+     */
+    Fullscreen.isFullscreen = function() {
+        if (!Fullscreen.supportsFullscreen()) {
+            return undefined;
+        }
+
+        return Fullscreen.getFullscreenElement() !== null;
+    };
+
+    /**
+     * Gets the name of the event on the document that is fired when fullscreen is
+     * entered or exited.  This event name is intended for use with addEventListener.
+     *
+     * In your event handler, to determine if the browser is in fullscreen mode or not,
+     * use {@link Fullscreen#isFullscreen}.
+     *
+     * @returns {String} the name of the event that is fired when fullscreen is entered or
+     * exited, or <code>undefined</code> if fullscreen is not supported.
+     */
+    Fullscreen.getFullscreenChangeEventName = function() {
+        if (!Fullscreen.supportsFullscreen()) {
+            return undefined;
+        }
+
+        return _names.fullscreenchange;
+    };
+
+    /**
+     * Gets the name of the event that is fired when a fullscreen error
+     * occurs.  This event name is intended for use with addEventListener.
+     *
+     * @returns {String} the name of the event that is fired when a fullscreen error occurs,
+     * or <code>undefined</code> if fullscreen is not supported.
+     */
+    Fullscreen.getFullscreenErrorEventName = function() {
+        if (!Fullscreen.supportsFullscreen()) {
+            return undefined;
+        }
+
+        return _names.fullscreenerror;
+    };
+
+    return Fullscreen;
+});

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

@@ -0,0 +1,107 @@
+/*global define*/
+define([
+        './defaultValue',
+        './Cartesian3',
+        './Cartographic',
+        './Ellipsoid'
+    ], function(
+        defaultValue,
+        Cartesian3,
+        Cartographic,
+        Ellipsoid) {
+    "use strict";
+
+    /**
+     * A simple map projection where longitude and latitude are linearly mapped to X and Y by multiplying
+     * them by the {@link Ellipsoid#getMaximumRadius}.  This projection
+     * is commonly known as geographic, equirectangular, equidistant cylindrical, or plate carrée.  It
+     * is also known as EPSG:4326.
+     *
+     * @alias GeographicProjection
+     * @constructor
+     * @immutable
+     *
+     * @param {Ellipsoid} [ellipsoid=Ellipsoid.WGS84] The ellipsoid.
+     *
+     * @see WebMercatorProjection
+     */
+    var GeographicProjection = function(ellipsoid) {
+        this._ellipsoid = defaultValue(ellipsoid, Ellipsoid.WGS84);
+        this._semimajorAxis = this._ellipsoid.getMaximumRadius();
+        this._oneOverSemimajorAxis = 1.0 / this._semimajorAxis;
+    };
+
+    /**
+     * Gets the {@link Ellipsoid}.
+     *
+     * @memberof GeographicProjection
+     *
+     * @returns {Ellipsoid} The ellipsoid.
+     */
+    GeographicProjection.prototype.getEllipsoid = function() {
+        return this._ellipsoid;
+    };
+
+    /**
+     * Projects a set of {@link Cartographic} coordinates, in radians, to map coordinates, in meters.
+     * X and Y are the longitude and latitude, respectively, multiplied by the maximum radius of the
+     * ellipsoid.  Z is the unmodified height.
+     *
+     * @memberof GeographicProjection
+     *
+     * @param {Cartographic} cartographic The coordinates to project.
+     * @param {Cartesian3} [result] An instance into which to copy the result.  If this parameter is
+     *        undefined, a new instance is created and returned.
+     * @returns {Cartesian3} The projected coordinates.  If the result parameter is not undefined, the
+     *          coordinates are copied there and that instance is returned.  Otherwise, a new instance is
+     *          created and returned.
+     */
+    GeographicProjection.prototype.project = function(cartographic, result) {
+        // Actually this is the special case of equidistant cylindrical called the plate carree
+        var semimajorAxis = this._semimajorAxis;
+        var x = cartographic.longitude * semimajorAxis;
+        var y = cartographic.latitude * semimajorAxis;
+        var z = cartographic.height;
+
+        if (typeof result === 'undefined') {
+            return new Cartesian3(x, y, z);
+        }
+
+        result.x = x;
+        result.y = y;
+        result.z = z;
+        return result;
+    };
+
+    /**
+     * Unprojects a set of projected {@link Cartesian3} coordinates, in meters, to {@link Cartographic}
+     * coordinates, in radians.  Longitude and Latitude are the X and Y coordinates, respectively,
+     * divided by the maximum radius of the ellipsoid.  Height is the unmodified Z coordinate.
+     *
+     * @memberof GeographicProjection
+     *
+     * @param {Cartesian3} cartesian The coordinate to unproject.
+     * @param {Cartographic} [result] An instance into which to copy the result.  If this parameter is
+     *        undefined, a new instance is created and returned.
+     * @returns {Cartographic} The unprojected coordinates.  If the result parameter is not undefined, the
+     *          coordinates are copied there and that instance is returned.  Otherwise, a new instance is
+     *          created and returned.
+     */
+    GeographicProjection.prototype.unproject = function(cartesian, result) {
+        var oneOverEarthSemimajorAxis = this._oneOverSemimajorAxis;
+        var longitude = cartesian.x * oneOverEarthSemimajorAxis;
+        var latitude = cartesian.y * oneOverEarthSemimajorAxis;
+        var height = cartesian.z;
+
+        if (typeof result === 'undefined') {
+            return new Cartographic(longitude, latitude, height);
+        }
+
+        result.longitude = longitude;
+        result.latitude = latitude;
+        result.height = height;
+        return result;
+    };
+
+    return GeographicProjection;
+});

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

@@ -0,0 +1,176 @@
+/*global define*/
+define(['./Math'
+       ], function(
+        CesiumMath) {
+    "use strict";
+
+    var factorial = CesiumMath.factorial;
+
+    function calculateCoefficientTerm(x, zIndices, xTable, derivOrder, termOrder, reservedIndices) {
+        var result = 0;
+        var reserved;
+        var i;
+        var j;
+
+        if (derivOrder > 0) {
+            for (i = 0; i < termOrder; i++) {
+                reserved = false;
+                for (j = 0; j < reservedIndices.length && !reserved; j++) {
+                    if (i === reservedIndices[j]) {
+                        reserved = true;
+                    }
+                }
+
+                if (!reserved) {
+                    reservedIndices.push(i);
+                    result += calculateCoefficientTerm(x, zIndices, xTable, derivOrder - 1, termOrder, reservedIndices);
+                    reservedIndices.splice(reservedIndices.length - 1, 1);
+                }
+            }
+
+            return result;
+        }
+
+        result = 1;
+        for (i = 0; i < termOrder; i++) {
+            reserved = false;
+            for (j = 0; j < reservedIndices.length && !reserved; j++) {
+                if (i === reservedIndices[j]) {
+                    reserved = true;
+                }
+            }
+
+            if (!reserved) {
+                result *= x - xTable[zIndices[i]];
+            }
+        }
+
+        return result;
+    }
+
+    /**
+     * Functions for performing Hermite interpolation.
+     * @exports HermitePolynomialApproximation
+     *
+     * @see LinearApproximation
+     * @see LagrangePolynomialApproximation
+     */
+    var HermitePolynomialApproximation = {
+        type : 'Hermite'
+    };
+
+    /**
+     * Given the desired degree, returns the number of data points required for interpolation.
+     *
+     * @memberof HermitePolynomialApproximation
+     *
+     * @param degree The desired degree of interpolation.
+     *
+     * @returns The number of required data points needed for the desired degree of interpolation.
+     */
+    HermitePolynomialApproximation.getRequiredDataPoints = function(degree) {
+        return Math.max(degree + 1, 2);
+    };
+
+    /**
+     * <p>
+     * Interpolates values using the supplied interpolation algorithm.  The appropriate subset of input
+     * values to use for the interpolation is determined automatically from an interpolation given
+     * degree.
+     * </p>
+     * <p>
+     * The xTable array can contain any number of elements, and the appropriate subset will be
+     * selected according to the degree of interpolation requested.  For example, if degree is 5,
+     * the 6 elements surrounding x will be used for interpolation.  When using
+     * {@link LinearApproximation} the degree should be 1 since it always deals with only 2 elements
+     * surrounding x. The yTable array should contain a number of elements equal to:
+     * <code>xTable.length * yStride</code>.  If insufficient elements are provided
+     * to perform the requested degree of interpolation, the highest possible degree of interpolation
+     * will be performed.
+     * </p>
+     *
+     * @param {Number} x The independent variable for which the dependent variables will be interpolated.
+     *
+     * @param {Array} xTable The array of independent variables to use to interpolate.  The values
+     * in this array must be in increasing order and the same value must not occur twice in the array.
+     *
+     * @param {Array} yTable The array of dependent variables to use to interpolate.  For a set of three
+     * dependent values (p,q,w) and their derivatives (dp, dq, dw) at time 1 and time 2 this should be
+     * as follows: {p1, q1, w1, dp1, dq1, dw1, p2, q2, w2, dp2, dq2, dw2}.
+     *
+     * @param {Number} yStride The number of dependent variable values in yTable corresponding to
+     * each independent variable value in xTable.
+     *
+     * @returns An array of interpolated values.  The array contains at least yStride elements, each
+     * of which is an interpolated dependent variable value.
+     *
+     * @see LinearApproximation
+     * @see LagrangePolynomialApproximation
+     *
+     * @memberof HermitePolynomialApproximation
+     */
+    HermitePolynomialApproximation.interpolateOrderZero = function(x, xTable, yTable, yStride) {
+        var length = xTable.length, i, j, d, s, len, index, result = new Array(yStride), coefficients = new Array(yStride);
+
+        for (i = 0; i < yStride; i++) {
+            result[i] = 0;
+
+            var l = new Array(length);
+            coefficients[i] = l;
+            for (j = 0; j < length; j++) {
+                l[j] = [];
+            }
+        }
+
+        var zIndicesLength = length, zIndices = new Array(zIndicesLength);
+
+        for (i = 0; i < zIndicesLength; i++) {
+            zIndices[i] = i;
+        }
+
+        var highestNonZeroCoef = length - 1;
+        for (s = 0; s < yStride; s++) {
+            for (j = 0; j < zIndicesLength; j++) {
+                index = zIndices[j] * yStride + s;
+                coefficients[s][0].push(yTable[index]);
+            }
+
+            for (i = 1; i < zIndicesLength; i++) {
+                var nonZeroCoefficients = false;
+                for (j = 0; j < zIndicesLength - i; j++) {
+                    var zj = xTable[zIndices[j]];
+                    var zn = xTable[zIndices[j + i]];
+
+                    var numerator;
+                    if (zn - zj <= 0) {
+                        index = zIndices[j] * yStride + yStride * i + s;
+                        numerator = yTable[index];
+                        coefficients[s][i].push(numerator / factorial(i));
+                    } else {
+                        numerator = (coefficients[s][i - 1][j + 1] - coefficients[s][i - 1][j]);
+                        coefficients[s][i].push(numerator / (zn - zj));
+                    }
+                    nonZeroCoefficients = nonZeroCoefficients || (numerator !== 0);
+                }
+
+                if (!nonZeroCoefficients) {
+                    highestNonZeroCoef = i - 1;
+                }
+            }
+        }
+
+        for (d = 0, len = 0; d <= len; d++) {
+            for (i = d; i <= highestNonZeroCoef; i++) {
+                var tempTerm = calculateCoefficientTerm(x, zIndices, xTable, d, i, []);
+                for (s = 0; s < yStride; s++) {
+                    var coeff = coefficients[s][i][0];
+                    result[s + d * yStride] += coeff * tempTerm;
+                }
+            }
+        }
+
+        return result;
+    };
+
+    return HermitePolynomialApproximation;
+});