cesium 0.13.0

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

@@ -0,0 +1,74 @@
+/*global define*/
+define([
+        './defaultValue',
+        '../ThirdParty/when'
+    ], function(
+        defaultValue,
+        when) {
+    "use strict";
+
+    var maximumRequestsPerServer = 6;
+    var activeRequests = {};
+    var anchor;
+
+    function getServer(url) {
+        if (typeof anchor === 'undefined') {
+            anchor = document.createElement('a');
+        }
+        anchor.href = url;
+        return anchor.hostname + '%' + anchor.port;
+    }
+
+    /**
+     * Because browsers throttle the number of parallel requests allowed to each server,
+     * this function tracks the number of active requests that have been made, and
+     * returns undefined immediately if the request would exceed the maximum, allowing
+     * the caller to retry later.
+     *
+     * @exports throttleRequestByServer
+     *
+     * @param {String} url The URL to request.
+     * @param {Function} requestFunction The actual function that makes the request.
+     * This function is expected to return a Promise for the requested data.
+     *
+     * @return {Promise} Either undefined, meaning the request would exceed the maximum
+     * number of parallel requests, or a Promise that returns the requested data.
+     *
+     * @see <a href='http://wiki.commonjs.org/wiki/Promises/A'>CommonJS Promises/A</a>
+     *
+     * @example
+     * // throttle requests for an image
+     * var promise = throttleRequestsByServer(
+     *     'http://madeupserver.agi.com/myImage.png',
+     *     function(url) {
+     *        return loadImage(url);
+     *     });
+     * if (typeof promise === 'undefined') {
+     *     // too many active requests, try again later.
+     * } else {
+     *     when(promise, function(image) {
+     *         // handle loaded image
+     *     });
+     * }
+     */
+    function throttleRequestByServer(url, requestFunction) {
+        var server = getServer(url);
+
+        var activeRequestsForServer = defaultValue(activeRequests[server], 0);
+        if (activeRequestsForServer > maximumRequestsPerServer) {
+            return undefined;
+        }
+
+        activeRequests[server] = activeRequestsForServer + 1;
+
+        return when(requestFunction(url), function(result) {
+            activeRequests[server]--;
+            return result;
+        }, function(error) {
+            activeRequests[server]--;
+            return when.reject(error);
+        });
+    }
+
+    return throttleRequestByServer;
+});

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

@@ -0,0 +1,92 @@
+/*global define*/
+define([
+        './defaultValue',
+        './DeveloperError',
+        './Color',
+        '../ThirdParty/measureText'
+    ], function(
+        defaultValue,
+        DeveloperError,
+        Color,
+        measureText) {
+    "use strict";
+
+    var EMPTY_OBJECT = {};
+
+    /**
+     * Writes the given text into a new canvas.  The canvas will be sized to fit the text.
+     * If text is blank, returns undefined.
+     *
+     * @param {String} text The text to write.
+     * @param {String} [description.font='10px sans-serif'] The CSS font to use.
+     * @param {String} [description.textBaseline='bottom'] The baseline of the text.
+     * @param {Boolean} [description.fill=true] Whether to fill the text.
+     * @param {Boolean} [description.stroke=false] Whether to stroke the text.
+     * @param {Color} [description.fillColor=Color.WHITE] The fill color.
+     * @param {Color} [description.strokeColor=Color.BLACK] The stroke color.
+     *
+     * @returns {Canvas} A new canvas with the given text drawn into it.  The dimensions object
+     *                   from measureText will also be added to the returned canvas. If text is
+     *                   blank, returns undefined.
+     */
+    var writeTextToCanvas = function(text, description) {
+        if (typeof text === 'undefined') {
+            throw new DeveloperError('text is required.');
+        }
+
+        if (text === '') {
+            return undefined;
+        }
+
+        description = defaultValue(description, EMPTY_OBJECT);
+        var font = defaultValue(description.font, '10px sans-serif');
+
+        var canvas = document.createElement('canvas');
+        canvas.width = canvas.height = 1;
+        canvas.style.font = font;
+
+        var context2D = canvas.getContext('2d');
+        context2D.font = font;
+
+        // textBaseline needs to be set before the measureText call. It won't work otherwise.
+        // It's magic.
+        context2D.textBaseline = defaultValue(description.textBaseline, 'bottom');
+
+        // in order for measureText to calculate style, the canvas has to be
+        // (temporarily) added to the DOM.
+        canvas.style.visibility = 'hidden';
+        document.body.appendChild(canvas);
+
+        var dimensions = measureText(context2D, text);
+        canvas.dimensions = dimensions;
+
+        document.body.removeChild(canvas);
+        canvas.style.visibility = undefined;
+
+        var baseline = dimensions.height - dimensions.ascent;
+        canvas.width = dimensions.width;
+        canvas.height = dimensions.height;
+        var y = canvas.height - baseline;
+
+        // font must be explicitly set again after changing width and height
+        context2D.font = font;
+
+        var fill = defaultValue(description.fill, true);
+        if (fill) {
+            var fillColor = defaultValue(description.fillColor, Color.WHITE);
+            context2D.fillStyle = fillColor.toCssColorString();
+            context2D.fillText(text, 0, y);
+        }
+
+        var stroke = defaultValue(description.stroke, false);
+        if (stroke) {
+            var strokeColor = defaultValue(description.strokeColor, Color.BLACK);
+            context2D.strokeStyle = strokeColor.toCssColorString();
+            context2D.strokeText(text, 0, y);
+        }
+
+        return canvas;
+    };
+
+    return writeTextToCanvas;
+});

data/app/assets/javascripts/DynamicScene/CompositeDynamicObjectCollection.js

@@ -0,0 +1,254 @@
+/*global define*/
+define([
+        '../Core/Event',
+        '../Core/Iso8601',
+        '../Core/TimeInterval',
+        '../Core/DeveloperError',
+        './DynamicObject',
+        './DynamicObjectCollection',
+        './CzmlDefaults'
+    ], function(
+        Event,
+        Iso8601,
+        TimeInterval,
+        DeveloperError,
+        DynamicObject,
+        DynamicObjectCollection,
+        CzmlDefaults) {
+    "use strict";
+
+    /**
+     * Non-destructively composites multiple DynamicObjectCollection instances into a single collection.
+     * If a DynamicObject with the same ID exists in multiple collections, it is non-destructively
+     * merged into a single new object instance.  If an object has the same property in multiple
+     * collections, the property of the DynamicObject in the last collection of the list it
+     * belongs to is used.  CompositeDynamicObjectCollection can be used almost anywhere that a
+     * DynamicObjectCollection is used.
+     *
+     * @alias CompositeDynamicObjectCollection
+     * @constructor
+     *
+     * @param {Array} [collections] The initial list of DynamicObjectCollection instances to merge.
+     * @param {Array} [mergeFunctions] The list of CZML merge functions.
+     * @param {Array} [cleanFunctions] The list of CZML clean functions.
+     *
+     * @see DynamicObjectCollection
+     * @see DynamicObject
+     * @see CzmlDefaults
+     */
+    var CompositeDynamicObjectCollection = function(collections, mergeFunctions, cleanFunctions) {
+        this._hash = {};
+        this._array = [];
+        this._collections = [];
+
+        /**
+         * The array of functions which merge DynamicObject instances together.
+         */
+        this.mergeFunctions = typeof mergeFunctions === 'undefined' ? CzmlDefaults.mergers : mergeFunctions;
+
+        /**
+         * The array of functions which remove data from a DynamicObject instance.
+         */
+        this.cleanFunctions = typeof cleanFunctions === 'undefined' ? CzmlDefaults.cleaners : cleanFunctions;
+
+        /**
+         * An {@link Event} that is fired whenever DynamicObjects in the collection have properties added.
+         */
+        this.objectPropertiesChanged = new Event();
+
+        /**
+         * An {@link Event} that is fired whenever DynamicObjects are removed from the collection.
+         */
+        this.objectsRemoved = new Event();
+
+        this.setCollections(collections);
+    };
+
+    /**
+     * Computes the maximum availability of the DynamicObjects in the collection.
+     * If the collection contains a mix of infinitely available data and non-infinite data,
+     * It will return the interval pertaining to the non-infinite data only.  If all
+     * data is infinite, an infinite interval will be returned.
+     * @memberof CompositeDynamicObjectCollection
+     *
+     * @returns {TimeInterval} The availability of DynamicObjects in the collection.
+     */
+    CompositeDynamicObjectCollection.prototype.computeAvailability = function() {
+        var startTime = Iso8601.MAXIMUM_VALUE;
+        var stopTime = Iso8601.MINIMUM_VALUE;
+        var i;
+        var len;
+        var collection;
+        var collections = this._collections;
+        for (i = 0, len = collections.length; i < len; i++) {
+            collection = collections[i];
+            var availability = collection.computeAvailability();
+            var start = availability.start;
+            var stop = availability.stop;
+            if (start.lessThan(startTime) && !start.equals(Iso8601.MINIMUM_VALUE)) {
+                startTime = availability.start;
+            }
+            if (stop.greaterThan(stopTime) && !stop.equals(Iso8601.MAXIMUM_VALUE)) {
+                stopTime = availability.stop;
+            }
+        }
+
+        if (startTime === Iso8601.MAXIMUM_VALUE) {
+            startTime = Iso8601.MINIMUM_VALUE;
+        }
+        if (stopTime === Iso8601.MINIMUM_VALUE) {
+            stopTime = Iso8601.MAXIMUM_VALUE;
+        }
+        return new TimeInterval(startTime, stopTime, true, true);
+    };
+
+    /**
+     * Returns a copy of the current array of collections being composited.  Changes to this
+     * array will have no affect, to change which collections are being used, call setCollections.
+     * @memberof CompositeDynamicObjectCollection
+     *
+     * @see CompositeDynamicObjectCollection#setCollections
+     */
+    CompositeDynamicObjectCollection.prototype.getCollections = function() {
+        return this._collections.slice(0);
+    };
+
+    /**
+     * Sets the array of collections to be composited.  Collections are composited
+     * last to first, so higher indices into the array take precedence over lower indices.
+     * @memberof CompositeDynamicObjectCollection
+     *
+     * @param {Array} collections The collections to be composited.
+     */
+    CompositeDynamicObjectCollection.prototype.setCollections = function(collections) {
+        collections = typeof collections !== 'undefined' ? collections : [];
+
+        var thisCollections = this._collections;
+        if (collections !== thisCollections) {
+            var collection;
+            var iCollection;
+
+            //Unsubscribe from old collections.
+            for (iCollection = thisCollections.length - 1; iCollection > -1; iCollection--) {
+                collection = thisCollections[iCollection];
+                collection.compositeCollection = undefined;
+                collection.objectPropertiesChanged.removeEventListener(CompositeDynamicObjectCollection.prototype._onObjectPropertiesChanged);
+            }
+
+            //Make a copy of the new collections.
+            thisCollections = this._collections = collections;
+
+            //Clear all existing objects and rebuild the colleciton.
+            this._clearObjects();
+            var thisMergeFunctions = this.mergeFunctions;
+            for (iCollection = thisCollections.length - 1; iCollection > -1; iCollection--) {
+                collection = thisCollections[iCollection];
+
+                //Subscribe to the new collection.
+                collection.compositeCollection = this;
+                collection.objectPropertiesChanged.addEventListener(CompositeDynamicObjectCollection.prototype._onObjectPropertiesChanged, this);
+
+                //Merge all of the existing objects.
+                var objects = collection.getObjects();
+                for ( var iObjects = objects.length - 1; iObjects > -1; iObjects--) {
+                    var object = objects[iObjects];
+                    var compositeObject = this._getOrCreateObject(object.id);
+                    for ( var iMergeFuncs = thisMergeFunctions.length - 1; iMergeFuncs > -1; iMergeFuncs--) {
+                        var mergeFunc = thisMergeFunctions[iMergeFuncs];
+                        mergeFunc(compositeObject, object);
+                    }
+                }
+            }
+        }
+    };
+
+    /**
+     * Gets an object with the specified id.
+     * @memberof CompositeDynamicObjectCollection
+     *
+     * @param {Object} id The id of the object to retrieve.
+     * @returns The DynamicObject with the provided id, or undefined if no such object exists.
+     *
+     * @exception {DeveloperError} id is required.
+     */
+    CompositeDynamicObjectCollection.prototype.getObject = function(id) {
+        if (typeof id === 'undefined') {
+            throw new DeveloperError('id is required.');
+        }
+        return this._hash[id];
+    };
+
+    /**
+     * Gets the array of DynamicObject instances in this composite collection.
+     * @memberof CompositeDynamicObjectCollection
+     *
+     * @returns {Array} the array of DynamicObject instances in this composite collection.
+     */
+    CompositeDynamicObjectCollection.prototype.getObjects = function() {
+        return this._array;
+    };
+
+    /**
+     * Clears all collections and DynamicObjects from this collection.
+     * @memberof CompositeDynamicObjectCollection
+     */
+    CompositeDynamicObjectCollection.prototype.clear = function() {
+        this.setCollections([]);
+    };
+
+    CompositeDynamicObjectCollection.prototype._getOrCreateObject = function(id) {
+        var obj = this._hash[id];
+        if (!obj) {
+            obj = new DynamicObject(id);
+            this._hash[id] = obj;
+            this._array.push(obj);
+        }
+        return obj;
+    };
+
+    CompositeDynamicObjectCollection.prototype._clearObjects = function() {
+        var removedObjects = this._array;
+        this._hash = {};
+        this._array = [];
+        if (removedObjects.length > 0) {
+            this.objectsRemoved.raiseEvent(this, removedObjects);
+        }
+    };
+
+    CompositeDynamicObjectCollection.prototype._onObjectPropertiesChanged = function(dynamicObjectCollection, updatedObjects) {
+        var thisMergeFunctions = this.mergeFunctions;
+        var thisCleanFunctions = this.cleanFunctions;
+        var thisCollections = this._collections;
+
+        var updatedObject, compositeObject, compositeObjects = [];
+        for ( var i = updatedObjects.length - 1; i > -1; i--) {
+            updatedObject = updatedObjects[i];
+            compositeObject = this.getObject(updatedObject.id);
+            if (typeof compositeObject !== 'undefined') {
+                for ( var iDeleteFuncs = thisCleanFunctions.length - 1; iDeleteFuncs > -1; iDeleteFuncs--) {
+                    var deleteFunc = thisCleanFunctions[iDeleteFuncs];
+                    deleteFunc(compositeObject);
+                }
+            } else {
+                compositeObject = this._getOrCreateObject(updatedObject.id);
+            }
+
+            compositeObjects.push(compositeObject);
+            for ( var iCollection = thisCollections.length - 1; iCollection > -1; iCollection--) {
+                var currentCollection = thisCollections[iCollection];
+                var objectToUpdate = currentCollection.getObject(updatedObject.id);
+                if (typeof objectToUpdate !== 'undefined') {
+                    for ( var iMergeFuncs = thisMergeFunctions.length - 1; iMergeFuncs > -1; iMergeFuncs--) {
+                        var mergeFunc = thisMergeFunctions[iMergeFuncs];
+                        mergeFunc(compositeObject, objectToUpdate);
+                    }
+                }
+            }
+        }
+        if (compositeObjects.length > 0) {
+            this.objectPropertiesChanged.raiseEvent(this, compositeObjects);
+        }
+    };
+
+    return CompositeDynamicObjectCollection;
+});

data/app/assets/javascripts/DynamicScene/CzmlBoolean.js

@@ -0,0 +1,57 @@
+/*global define*/
+define(function() {
+    "use strict";
+
+    /**
+     * Provides methods for working with a boolean defined in CZML.
+     *
+     * @exports CzmlBoolean
+     *
+     * @see DynamicProperty
+     * @see CzmlCartesian2
+     * @see CzmlCartesian3
+     * @see CzmlCartographic
+     * @see CzmlColor
+     * @see CzmlHorizontalOrigin
+     * @see CzmlLabelStyle
+     * @see CzmlNumber
+     * @see CzmlString
+     * @see CzmlUnitCartesian3
+     * @see CzmlUnitQuaternion
+     * @see CzmlUnitSpherical
+     * @see CzmlVerticalOrigin
+     */
+    var CzmlBoolean = {
+        /**
+         * Returns the packed boolean representation contained within the provided CZML interval
+         * or undefined if the interval does not contain boolean data.
+         *
+         * @param {Object} czmlInterval The CZML interval to unwrap.
+         */
+        unwrapInterval : function(czmlInterval) {
+            /*jshint sub:true*/
+            var result = czmlInterval['boolean']; // boolean is a JS reserved word
+            return typeof result === 'undefined' ? czmlInterval : result;
+        },
+
+        /**
+         * Since CZML booleans can not be sampled, this method always returns false.
+         */
+        isSampled : function() {
+            return false;
+        },
+
+        /**
+         * Returns the boolean value contained within the unwrappedInterval.  For booleans
+         * this is the unwrappedInterval itself.
+         *
+         * @param {Object} unwrappedInterval The result of CzmlBoolean.unwrapInterval.
+         * @returns The boolean value.
+         */
+        getValue : function(unwrappedInterval) {
+            return unwrappedInterval;
+        }
+    };
+
+    return CzmlBoolean;
+});