cesium 0.13.0

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

@@ -0,0 +1,21 @@
+/*global define*/
+define(function() {
+    "use strict";
+
+    function clone(object) {
+        if (object === null || typeof object !== 'object') {
+            return object;
+        }
+
+        var temp = new object.constructor();
+        for ( var key in object) {
+            if (object.hasOwnProperty(key)) {
+                temp[key] = clone(object[key]);
+            }
+        }
+
+        return temp;
+    }
+
+    return clone;
+});

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

@@ -0,0 +1,81 @@
+/*global define*/
+define([
+        './DeveloperError',
+        './defaultValue'
+    ], function(
+        DeveloperError,
+        defaultValue) {
+    "use strict";
+
+    /**
+     * Merges object properties into a new combined object. When two objects have the same
+     * property, the value of the object that comes earlier in the array is used.
+     *
+     * @example
+     * var object1 = {
+     *     one : 1,
+     *     deep : {
+     *         value1 : 10
+     *     }
+     * }
+     * var object2 = {
+     *     two : 2
+     * }
+     * var object3 = {
+     *     deep : {
+     *         value1 : 5,
+     *         value2 : 11
+     *     }
+     * }
+     * var final = combine([object1,object2, object3], true, true);
+     *
+     * // final === {
+     * //     one : 1,
+     * //     two : 2,
+     * //     deep : {
+     * //         value1 : 10,
+     * //         value2 : 11
+     * //     }
+     * // }
+     *
+     * @param {Array} objects Array of objects that get merged together.
+     * @param {Boolean} [deep = true] Perform a recursive merge.
+     * @param {Boolean} [allowDuplicates = true] An error gets thrown if allowDuplicates is false and two objects contain the same property.
+     *
+     * @returns {Object} combined object
+     *
+     * @exports combine
+     *
+     * @exception {DeveloperError} Duplicate member.
+     */
+
+    var combine = function(objects, deep, allowDuplicates) {
+        deep = defaultValue(deep, true);
+        allowDuplicates = defaultValue(allowDuplicates, true);
+
+        var combined = {};
+        for (var i = 0; i < objects.length; i++) {
+            combineTwoObjects(combined, objects[i], deep, allowDuplicates);
+        }
+        return combined;
+    };
+    var combineTwoObjects = function(object1, object2, deep, allowDuplicates) {
+        for (var property in object2) {
+            if (object2.hasOwnProperty(property)) {
+                if (object1.hasOwnProperty(property) && (typeof object1[property] !== 'undefined')) {
+                    if (!allowDuplicates) {
+                        throw new DeveloperError('Duplicate member: ' + property);
+                    }
+                    if (deep && typeof object1[property] === 'object' && typeof object2[property] === 'object') {
+                        combineTwoObjects(object1[property], object2[property], deep, allowDuplicates);
+                    }
+                }
+                else {
+                    object1[property] = object2[property];
+                }
+            }
+        }
+    };
+
+    return combine;
+});

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

@@ -0,0 +1,116 @@
+/*global define*/
+define([
+        './isLeapYear',
+        './DeveloperError',
+        './Math',
+        './Cartesian3',
+        './Cartographic',
+        './Matrix3',
+        './JulianDate'
+    ],
+    function(
+        isLeapYear,
+        DeveloperError,
+        CesiumMath,
+        Cartesian3,
+        Cartographic,
+        Matrix3,
+        JulianDate) {
+    "use strict";
+
+    var offSets = [0,  // January
+                   31, // February
+                   59, // March
+                   90, // April
+                   120,// May
+                   151,// June
+                   181,// July
+                   212,// August
+                   243,// September
+                   273,// October
+                   304,// November
+                   334 // December
+                  ];
+
+    var scratch = new Cartesian3();
+    var transform = new Matrix3(0.0, 0.0, 0.0,
+                                0.0, 1.0, 0.0,
+                                0.0, 0.0, 0.0);
+
+    var AU_TO_METERS = 149597870700.0;
+
+    var direction = new Cartesian3();
+
+    /**
+     * Computes the position of the Sun in Earth's fixed frame.
+     * @exports computeSunPosition
+     *
+     * @param {JulianDate} [julianDate] The time at which to compute the Sun's position, if not provided the current system time is used.
+     * @param {Cartesian3} [result] The object onto which to store the result.
+     * @return {Cartesian3} The modified result parameter or a new Cartesian3 instance if none was provided.
+     *
+     * @exception {DeveloperError} julianDate is required.
+     *
+     * @example
+     * var sunPosition = computeSunPosition(new JulianDate());
+     */
+    var computeSunPosition = function(julianDate, result) {
+        if (typeof julianDate === 'undefined') {
+            julianDate = new JulianDate();
+        }
+
+        var T = (julianDate.getTotalDays() - 2451545.0) / 36525;
+        var meanAnomaly = CesiumMath.convertLongitudeRange(CesiumMath.toRadians(357.5277233 + 35999.05034 * T));
+        var distanceToSunInAU = 1.000140612 - 0.016708617 * Math.cos(meanAnomaly) - 0.000139589 * Math.cos(2 * meanAnomaly);
+
+        var date = julianDate.toDate();
+        var month = date.getUTCMonth();
+        var dayOfYear = date.getUTCDate() + offSets[month];
+
+        if (isLeapYear(date.getUTCFullYear()) && month > 1) {
+            dayOfYear++;
+        }
+
+        var temp = CesiumMath.toRadians((360.0 / 365.0) * (dayOfYear - 81.0));
+        var equationOfTime = 9.87 * Math.sin(2 * temp) - 7.53 * Math.cos(temp) - 1.5 * Math.sin(temp);
+        var timeFraction = julianDate.getJulianTimeFraction();
+        var localTime;
+        if (timeFraction >= 0.5) {
+            localTime = timeFraction * 24.0 - 12.0;
+        } else {
+            localTime = 12.0 + timeFraction * 24.0;
+        }
+        var localSolarTime = localTime + (equationOfTime / 60.0);
+        var hourAngle = CesiumMath.toRadians(15.0 * (12.0 - localSolarTime));
+        var declinationAngle = Math.asin(0.39795 * Math.cos(CesiumMath.toRadians(0.98563 * (dayOfYear - 173.0))));
+
+        var latitudeAngle = 0.0;
+
+        var cosLatitudeAngle = Math.cos(latitudeAngle);
+        var sinLatitudeAngle = Math.sin(latitudeAngle);
+
+        //Since some of these are constant,
+        //there's no need to set them every time.
+        transform[0] = cosLatitudeAngle;
+        //transform[1] = 0.0;
+        transform[2] = -sinLatitudeAngle;
+        //transform[3] = 0.0;
+        //transform[4] = 1.0;
+        //transform[5] = 0.0;
+        transform[6] = sinLatitudeAngle;
+        //transform[7] = 0.0;
+        transform[8] = cosLatitudeAngle;
+
+        var cosDeclinationAngle = Math.cos(declinationAngle);
+        scratch.x = cosDeclinationAngle * Math.cos(hourAngle);
+        scratch.y = cosDeclinationAngle * Math.sin(hourAngle);
+        scratch.z = Math.sin(declinationAngle);
+
+        Matrix3.multiplyByVector(transform, scratch, direction);
+        var distance = distanceToSunInAU * AU_TO_METERS;
+
+        return direction.multiplyByScalar(distance, result);
+    };
+
+    return computeSunPosition;
+});

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

@@ -0,0 +1,25 @@
+/*global define*/
+define(function() {
+    "use strict";
+
+    /**
+     * Creates a Globally unique identifier (GUID) string.  A GUID is 128 bits long, and can guarantee uniqueness across space and time.
+     *
+     * @exports createGuid
+     *
+     * @see <a href='http://www.ietf.org/rfc/rfc4122.txt'>RFC 4122 A Universally Unique IDentifier (UUID) URN Namespace</a>
+     *
+     * @example
+     * this.guid = createGuid();
+     */
+    var createGuid = function() {
+        // http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript
+        return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
+            var r = Math.random() * 16 | 0;
+            var v = c === 'x' ? r : (r & 0x3 | 0x8);
+            return v.toString(16);
+        });
+    };
+
+    return createGuid;
+});

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

@@ -0,0 +1,22 @@
+/*global define*/
+define(function() {
+    "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 = defaultValue(param, 'default');
+     */
+    var defaultValue = function(a, b) {
+        if (typeof a !== 'undefined') {
+            return a;
+        }
+        return b;
+    };
+
+    return defaultValue;
+});

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

@@ -0,0 +1,61 @@
+/*global define*/
+define([
+        './defaultValue',
+        './DeveloperError'
+    ], function(
+        defaultValue,
+        DeveloperError) {
+    "use strict";
+
+    function returnTrue() {
+        return true;
+    }
+
+    /**
+     * Destroys an object.  Each of the object's functions, including functions in its prototype,
+     * is replaced with a function that throws a {@link DeveloperError}, except for the object's
+     * <code>isDestroyed</code> function, which is set to a function that returns <code>true</code>.
+     * The object's properties are removed with <code>delete</code>.
+     * <br /><br />
+     * This function is used by objects that hold native resources, e.g., WebGL resources, which
+     * need to be explicitly released.  Client code calls an object's <code>destroy</code> function,
+     * which then releases the native resource and calls <code>destroyObject</code> to put itself
+     * in a destroyed state.
+     *
+     * @exports destroyObject
+     *
+     * @param {Object} object The object to destroy.
+     * @param {String} [message] The message to include in the exception that is thrown if
+     *                           a destroyed object's function is called.
+     *
+     * @see DeveloperError
+     *
+     * @example
+     * // How a texture would destroy itself.
+     * this.destroy = function () {
+     *     _gl.deleteTexture(_texture);
+     *     return destroyObject(this);
+     * };
+     */
+    var destroyObject = function(object, message) {
+        message = defaultValue(message, 'This object was destroyed, i.e., destroy() was called.');
+
+        function throwOnDestroyed() {
+            throw new DeveloperError(message);
+        }
+
+        for ( var key in object) {
+            if (typeof object[key] === 'function') {
+                object[key] = throwOnDestroyed;
+            } else {
+                delete object[key];
+            }
+        }
+
+        object.isDestroyed = returnTrue;
+
+        return undefined;
+    };
+
+    return destroyObject;
+});

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

@@ -0,0 +1,20 @@
+/*global define*/
+define(function() {
+    "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.
+     *
+     * @exports freezeObject
+     */
+    var freezeObject = Object.freeze;
+    if (typeof freezeObject === 'undefined') {
+        freezeObject = function(o) {
+            return o;
+        };
+    }
+
+    return freezeObject;
+});

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

@@ -0,0 +1,46 @@
+/*global define*/
+define(function() {
+    "use strict";
+
+    var context2DsByWidthAndHeight = {};
+
+    /**
+     * Extract a pixel array from a loaded image.  Draws the image
+     * into a canvas so it can read the pixels back.
+     *
+     * @exports getImagePixels
+     *
+     * @param {Image} image The image to extract pixels from.
+     *
+     * @returns {CanvasPixelArray} The pixels of the image.
+     */
+    var getImagePixels = function(image, width, height) {
+        if (typeof width === 'undefined') {
+            width = image.width;
+        }
+        if (typeof height === 'undefined') {
+            height = image.height;
+        }
+
+        var context2DsByHeight = context2DsByWidthAndHeight[width];
+        if (typeof context2DsByHeight === 'undefined') {
+            context2DsByHeight = {};
+            context2DsByWidthAndHeight[width] = context2DsByHeight;
+        }
+
+        var context2d = context2DsByHeight[height];
+        if (typeof context2d === 'undefined') {
+            var canvas = document.createElement('canvas');
+            canvas.width = width;
+            canvas.height = height;
+            context2d = canvas.getContext('2d');
+            context2d.globalCompositeOperation = 'copy';
+            context2DsByHeight[height] = context2d;
+        }
+
+        context2d.drawImage(image, 0, 0, width, height);
+        return context2d.getImageData(0, 0, width, height).data;
+    };
+
+    return getImagePixels;
+});

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

@@ -0,0 +1,30 @@
+/*global define*/
+define([
+        './DeveloperError'
+    ], function(
+        DeveloperError) {
+    "use strict";
+
+    /**
+     * Determines if a given date is a leap year.
+     *
+     * @exports isLeapYear
+     *
+     * @param {Number} year The year to be tested.
+     *
+     * @return {Boolean} True if <code>year</code> is a leap yer.
+     *
+     * @exception {DeveloperError} year is required and must be a number.
+     *
+     * @example
+     * var leapYear = isLeapYear(2000); // true
+     */
+    function isLeapYear(year) {
+        if (year === null || isNaN(year)) {
+            throw new DeveloperError('year is required and must be a number.');
+        }
+        return ((year % 4 === 0) && (year % 100 !== 0)) || (year % 400 === 0);
+    }
+
+    return isLeapYear;
+});

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

@@ -0,0 +1,116 @@
+/*global define*/
+define([
+        './defaultValue',
+        './DeveloperError',
+        '../ThirdParty/when'
+    ], function(
+        defaultValue,
+        DeveloperError,
+        when) {
+    "use strict";
+
+    function pushQueryParameter(array, name, value) {
+        array.push(encodeURIComponent(name) + '=' + encodeURIComponent(value));
+    }
+
+    /**
+     * Requests a resource using JSONP.
+     *
+     * @exports jsonp
+     *
+     * @param {String} url The URL to request.
+     * @param {Object} [options.parameters] Any extra query parameters to append to the URL.
+     * @param {String} [options.callbackParameterName='callback'] The callback parameter name that the server expects.
+     * @param {Object} [options.proxy] A proxy to use for the request. This object is expected to have a getURL function which returns the proxied URL, if needed.
+     *
+     * @returns {Object} a promise that will resolve to the requested data when loaded.
+     *
+     * @see <a href='http://wiki.commonjs.org/wiki/Promises/A'>CommonJS Promises/A</a>
+     *
+     * @example
+     * // load a data asynchronously
+     * jsonp('some/webservice').then(function(data) {
+     *     // use the loaded data
+     * }, function() {
+     *     // an error occurred
+     * });
+     */
+    var jsonp = function(url, options) {
+        if (typeof url === 'undefined') {
+            throw new DeveloperError('url is required.');
+        }
+
+        options = defaultValue(options, {});
+
+        var deferred = when.defer();
+
+        //generate a unique function name
+        var functionName;
+        do {
+            functionName = 'jsonp' + Math.random().toString().substring(2, 8);
+        } while (typeof window[functionName] !== 'undefined');
+
+        //assign a function with that name in the global scope
+        window[functionName] = function(data) {
+            deferred.resolve(data);
+
+            try {
+                delete window[functionName];
+            } catch (e) {
+                window[functionName] = undefined;
+            }
+        };
+
+        var callbackParameterName = defaultValue(options.callbackParameterName, 'callback');
+        var queryParts = [];
+        pushQueryParameter(queryParts, callbackParameterName, functionName);
+
+        var parameters = defaultValue(options.parameters, {});
+        for ( var name in parameters) {
+            if (parameters.hasOwnProperty(name)) {
+                pushQueryParameter(queryParts, name, parameters[name]);
+            }
+        }
+
+        if (queryParts.length > 0) {
+            if (url.indexOf('?') === -1) {
+                url += '?';
+            } else {
+                url += '&';
+            }
+
+            url += queryParts.join('&');
+        }
+
+        var proxy = options.proxy;
+        if (typeof proxy !== 'undefined') {
+            url = proxy.getURL(url);
+        }
+
+        jsonp.loadAndExecuteScript(url, functionName, deferred);
+
+        return deferred.promise;
+    };
+
+    // This is broken out into a separate function so that it can be mocked for testing purposes.
+    jsonp.loadAndExecuteScript = function(url, functionName, deferred) {
+        var script = document.createElement('script');
+        script.async = true;
+        script.src = url;
+
+        var head = document.getElementsByTagName('head')[0];
+        script.onload = function() {
+            script.onload = undefined;
+            head.removeChild(script);
+        };
+        script.onerror = function(e) {
+            deferred.reject(e);
+        };
+
+        head.appendChild(script);
+    };
+
+    jsonp.defaultLoadAndExecuteScript = jsonp.loadAndExecuteScript;
+
+    return jsonp;
+});