cesium 0.13.0

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

@@ -0,0 +1,131 @@
+/*global define*/
+define([
+        'require',
+        './buildModuleUrl',
+        './defaultValue',
+        '../ThirdParty/when'
+    ], function(
+        require,
+        buildModuleUrl,
+        defaultValue,
+        when) {
+    "use strict";
+
+    function completeTask(processor, event) {
+        --processor._activeTasks;
+
+        var data = event.data;
+        var id = data.id;
+        var result = data.result;
+
+        var deferreds = processor._deferreds;
+        var deferred = deferreds[id];
+
+        deferred.resolve(result);
+
+        delete deferreds[id];
+    }
+
+    var bootstrapperUrl = buildModuleUrl('Workers/cesiumWorkerBootstrapper.js');
+
+    function createWorker(processor) {
+        var worker = new Worker(bootstrapperUrl);
+        worker.postMessage = defaultValue(worker.webkitPostMessage, worker.postMessage);
+
+        //bootstrap
+        var bootstrapMessage = {
+            loaderConfig : {},
+            workerModule : 'Workers/' + processor._workerName
+        };
+
+        if (typeof require.toUrl !== 'undefined') {
+            bootstrapMessage.loaderConfig.baseUrl = '..';
+        } else {
+            bootstrapMessage.loaderConfig.paths = {
+                'Workers' : '.'
+            };
+        }
+
+        worker.postMessage(bootstrapMessage);
+
+        worker.onmessage = function(event) {
+            completeTask(processor, event);
+        };
+
+        processor._worker = worker;
+    }
+
+    /**
+     * A wrapper around a web worker that allows scheduling tasks for a given worker,
+     * returning results asynchronously via a promise.
+     *
+     * The Worker is not constructed until a task is scheduled.
+     *
+     * @alias TaskProcessor
+     * @constructor
+     *
+     * @param {String} workerName The name of the worker.  This is expected to be a script
+     *                            in the Workers folder.
+     * @param {Number} [maximumActiveTasks=5] The maximum number of active tasks.  Once exceeded,
+     *                                        scheduleTask will not queue any more tasks, allowing
+     *                                        work to be rescheduled in future frames.
+     */
+    var TaskProcessor = function(workerName, maximumActiveTasks) {
+        this._workerName = workerName;
+        this._maximumActiveTasks = defaultValue(maximumActiveTasks, 5);
+        this._activeTasks = 0;
+        this._deferreds = {};
+        this._nextID = 0;
+    };
+
+    /**
+     * Schedule a task to be processed by the web worker asynchronously.  If there are currently more
+     * tasks active than the maximum set by the constructor, will immediately return undefined.
+     * Otherwise, returns a promise that will resolve to the result posted back by the worker when
+     * finished.
+     *
+     * @param {*} parameters Any input data that will be posted to the worker.
+     * @param {Array} [transferableObjects] An array of objects contained in parameters that should be
+     *                                      transferred to the worker instead of copied.
+     * @returns {Promise} Either a promise that will resolve to the result when available, or undefined
+     *                    if there are too many active tasks,
+     *
+     * @example
+     * var taskProcessor = new TaskProcessor('myWorkerName');
+     * var promise = taskProcessor.scheduleTask({
+     *     someParameter : true,
+     *     another : 'hello'
+     * });
+     * if (typeof promise === 'undefined') {
+     *     // too many active tasks - try again later
+     * } else {
+     *     when(promise, function(result) {
+     *         // use the result of the task
+     *     });
+     * }
+     */
+    TaskProcessor.prototype.scheduleTask = function(parameters, transferableObjects) {
+        if (typeof this._worker === 'undefined') {
+            createWorker(this);
+        }
+
+        if (this._activeTasks >= this._maximumActiveTasks) {
+            return undefined;
+        }
+
+        ++this._activeTasks;
+
+        var id = this._nextID++;
+        var deferred = when.defer();
+        this._deferreds[id] = deferred;
+
+        this._worker.postMessage({
+            id : id,
+            parameters : parameters
+        }, transferableObjects);
+
+        return deferred.promise;
+    };
+
+    return TaskProcessor;
+});

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

@@ -0,0 +1,85 @@
+/*global define*/
+define(function() {
+    "use strict";
+
+    /**
+     * Constants for time conversions like those done by {@link JulianDate}.
+     *
+     * @exports TimeConstants
+     *
+     * @see JulianDate
+     */
+    var TimeConstants = {
+        /**
+         * The number of seconds in one millisecond: <code>0.001</code>
+         * @constant
+         * @type {Number}
+         */
+        SECONDS_PER_MILLISECOND : 0.001,
+
+        /**
+         * The number of seconds in one minute: <code>60</code>.
+         * @constant
+         * @type {Number}
+         */
+        SECONDS_PER_MINUTE : 60.0,
+
+        /**
+         * The number of minutes in one hour: <code>60</code>.
+         * @constant
+         * @type {Number}
+         */
+        MINUTES_PER_HOUR : 60.0,
+
+        /**
+         * The number of hours in one day: <code>24</code>.
+         * @constant
+         * @type {Number}
+         */
+        HOURS_PER_DAY : 24.0,
+
+        /**
+         * The number of seconds in one hour: <code>3600</code>.
+         * @constant
+         * @type {Number}
+         */
+        SECONDS_PER_HOUR : 3600.0,
+
+        /**
+         * The number of minutes in one day: <code>1440</code>.
+         * @constant
+         * @type {Number}
+         */
+        MINUTES_PER_DAY : 1440.0,
+
+        /**
+         * The number of seconds in one day, ignoring leap seconds: <code>86400</code>.
+         * @constant
+         * @type {Number}
+         */
+        SECONDS_PER_DAY : 86400.0,
+
+        /**
+         * The number of days in one Julian century: <code>36525</code>.
+         * @constant
+         * @type {Number}
+         */
+        DAYS_PER_JULIAN_CENTURY : 36525.0,
+
+        /**
+         * One trillionth of a second.
+         * @constant
+         * @type {Number}
+         */
+        PICOSECOND : 0.000000001,
+
+        /**
+         * DOC_TBA
+         * @constant
+         * @type {Number}
+         */
+        MODIFIED_JULIAN_DATE_DIFFERENCE : 2400000.5
+    };
+
+    return TimeConstants;
+});

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

@@ -0,0 +1,305 @@
+/*global define*/
+define([
+        './DeveloperError',
+        './freezeObject',
+        './JulianDate',
+        './TimeStandard'
+    ], function(
+        DeveloperError,
+        freezeObject,
+        JulianDate,
+        TimeStandard) {
+    "use strict";
+
+    /**
+     * An interval defined by a start date and a stop date.  The end points are optionally included
+     * in the interval.  The interval should be treated as immutable.
+     *
+     * @alias TimeInterval
+     * @constructor
+     *
+     * @param {JulianDate} start The start date of the interval.
+     * @param {JulianDate} stop The stop date of the interval.
+     * @param {Boolean} [isStartIncluded=true] <code>true</code> if the start date is included in the interval, <code>false</code> otherwise.
+     * @param {Boolean} [isStopIncluded=true] <code>true</code> if the stop date is included in the interval, <code>false</code> otherwise.
+     * @param {Object} [data The data associated with this interval.
+     *
+     * @exception {DeveloperError} start must be specified.
+     * @exception {DeveloperError} stop must be specified.
+     *
+     * @see TimeInterval.fromIso8601
+     * @see TimeIntervalCollection
+     * @see JulianDate
+     *
+     * @example
+     * // Construct an Timeinterval closed on one end with a Color payload.
+     * var interval = new TimeInterval(JulianDate.fromTotalDays(1000), JulianDate.fromTotalDays(1001), true, false, Color.WHITE);
+     */
+    var TimeInterval = function(start, stop, isStartIncluded, isStopIncluded, data) {
+        if (typeof start === 'undefined') {
+            throw new DeveloperError('start must be specified.');
+        }
+
+        if (typeof stop === 'undefined') {
+            throw new DeveloperError('stop must be specified.');
+        }
+
+        if (typeof isStartIncluded === 'undefined') {
+            isStartIncluded = true;
+        }
+
+        if (typeof isStopIncluded === 'undefined') {
+            isStopIncluded = true;
+        }
+
+        var stopComparedToStart = JulianDate.compare(stop, start);
+
+        /**
+         * The start time of the interval.
+         */
+        this.start = start;
+        /**
+         * The stop time of the interval.
+         */
+        this.stop = stop;
+        /**
+         * The data associated with this interval.
+         */
+        this.data = data;
+        /**
+         * Indicates if <code>start</code> is included in the interval or not.
+         */
+        this.isStartIncluded = isStartIncluded;
+        /**
+         * Indicates if <code>stop</code> is included in the interval or not.
+         */
+        this.isStopIncluded = isStopIncluded;
+        /**
+         * Indicates if the interval is empty.
+         */
+        this.isEmpty = stopComparedToStart < 0 || (stopComparedToStart === 0 && (!isStartIncluded || !isStopIncluded));
+    };
+
+    /**
+     * Creates an immutable TimeInterval from an ISO 8601 interval string.
+     *
+     * @memberof TimeInterval
+     *
+     * @param {String} iso8601String A valid ISO8601 interval.
+     * @param {Boolean} [isStartIncluded=true] <code>true</code> if the start date is included in the interval, <code>false</code> otherwise.
+     * @param {Boolean} [isStopIncluded=true] <code>true</code> if the stop date is included in the interval, <code>false</code> otherwise.
+     * @param {Object} [data] The data associated with this interval.
+     *
+     * @return {TimeInterval} The new {@Link TimeInterval} instance or <code>undefined</code> if an invalid ISO8601 string is provided.
+     *
+     * @see TimeInterval
+     * @see TimeIntervalCollection
+     * @see JulianDate
+     * @see <a href='http://en.wikipedia.org/wiki/ISO_8601'>ISO 8601 on Wikipedia</a>.
+     *
+     * @example
+     * // Construct an open Timeinterval with a Cartesian data payload.
+     * var interval = TimeInterval.fromIso8601('2012-03-15T11:02:24.55Z/2012-03-15T12:28:24.03Z', false, false, new Cartesian3(1,2,3));
+     */
+    TimeInterval.fromIso8601 = function(iso8601String, isStartIncluded, isStopIncluded, data) {
+        var iso8601Interval = iso8601String.split('/');
+        var intervalStart = JulianDate.fromIso8601(iso8601Interval[0]);
+        var intervalStop = JulianDate.fromIso8601(iso8601Interval[1]);
+        return new TimeInterval(intervalStart, intervalStop, isStartIncluded, isStopIncluded, data);
+    };
+
+    /**
+     * Compares the provided TimeIntervals componentwise and returns
+     * <code>true</code> if they are equal, <code>false</code> otherwise.
+     * @memberof TimeInterval
+     *
+     * @param {TimeInterval} [left] The first Cartesian.
+     * @param {TimeInterval} [right] The second Cartesian.
+     * @return {Boolean} <code>true</code> if left and right are equal, <code>false</code> otherwise.
+     */
+    TimeInterval.equals = function(left, right) {
+        return left === right ||
+               typeof left !== 'undefined' &&
+               typeof right !== 'undefined' &&
+               (left.isEmpty && right.isEmpty ||
+                left.isStartIncluded === right.isStartIncluded &&
+                left.isStopIncluded === right.isStopIncluded &&
+                left.start.equals(right.start) &&
+                left.stop.equals(right.stop));
+    };
+
+    /**
+     * Compares the provided TimeIntervals componentwise and returns
+     * <code>true</code> if they are within the provided epsilon,
+     * <code>false</code> otherwise.
+     * @memberof TimeInterval
+     *
+     * @param {TimeInterval} [left] The first TimeInterval.
+     * @param {TimeInterval} [right] The second TimeInterval.
+     * @param {Number} epsilon The epsilon to use for equality testing.
+     *
+     * @return {Boolean} <code>true</code> if left and right are within the provided epsilon, <code>false</code> otherwise.
+     *
+     * @exception {DeveloperError} epsilon is required and must be number.
+     */
+    TimeInterval.equalsEpsilon = function(left, right, epsilon) {
+        if (typeof epsilon !== 'number') {
+            throw new DeveloperError('epsilon is required and must be a number.');
+        }
+
+        return left === right ||
+               typeof left !== 'undefined' &&
+               typeof right !== 'undefined' &&
+               (left.isEmpty && right.isEmpty ||
+                left.isStartIncluded === right.isStartIncluded &&
+                left.isStopIncluded === right.isStopIncluded &&
+                left.start.equalsEpsilon(right.start, epsilon) &&
+                left.stop.equalsEpsilon(right.stop, epsilon));
+    };
+
+    /**
+     * Creates a copy of this TimeInterval.
+     *
+     * @returns A new TimeInterval that is equal to this interval.
+     *
+     * @memberof TimeInterval
+     */
+    TimeInterval.prototype.clone = function() {
+        return new TimeInterval(this.start, this.stop, this.isStartIncluded, this.isStopIncluded, this.data);
+    };
+
+    /**
+     * An empty interval.
+     *
+     * @memberof TimeInterval
+     */
+    TimeInterval.EMPTY = freezeObject(new TimeInterval(new JulianDate(0, 0, TimeStandard.TAI), new JulianDate(0, 0, TimeStandard.TAI), false, false));
+
+    /**
+     * Computes an interval which is the intersection of this interval with another while
+     * also providing a means to merge the data of the two intervals.
+     *
+     * @param {TimeInterval} other The interval to intersect with this interval.
+     * @param {Function} [mergeCallback] A callback which takes the data property from
+     * both intervals as input and merges it into a single new value. If the callback is undefined,
+     * this will intersect the two intervals and return the new interval with the data from this
+     * interval.
+     *
+     * @return {TimeInterval} The new {@Link TimeInterval} that is the intersection of the two intervals,
+     * with its data representing the merge of the data in the two existing intervals.
+     */
+    TimeInterval.prototype.intersect = function(other, mergeCallback) {
+        if (typeof other === 'undefined') {
+            return TimeInterval.EMPTY;
+        }
+
+        var otherStart = other.start;
+        var otherStop = other.stop;
+        var otherIsStartIncluded = other.isStartIncluded;
+        var otherIsStopIncluded = other.isStopIncluded;
+
+        var thisStart = this.start;
+        var thisStop = this.stop;
+        var thisIsStartIncluded = this.isStartIncluded;
+        var thisIsStopIncluded = this.isStopIncluded;
+
+        var outputData;
+        var isStartIncluded;
+        var isStopIncluded;
+
+        if (otherStart.greaterThanOrEquals(thisStart) && thisStop.greaterThanOrEquals(otherStart)) {
+
+            isStartIncluded = (!otherStart.equals(thisStart) && otherIsStartIncluded) || (thisIsStartIncluded && otherIsStartIncluded);
+
+            isStopIncluded = thisIsStopIncluded && otherIsStopIncluded;
+
+            outputData = typeof mergeCallback !== 'undefined' ? mergeCallback(this.data, other.data) : this.data;
+
+            if (thisStop.greaterThanOrEquals(otherStop)) {
+                isStopIncluded = isStopIncluded || (!otherStop.equals(thisStop) && otherIsStopIncluded);
+                return new TimeInterval(otherStart, otherStop, isStartIncluded, isStopIncluded, outputData);
+            }
+
+            isStopIncluded = isStopIncluded || thisIsStopIncluded;
+            return new TimeInterval(otherStart, thisStop, isStartIncluded, isStopIncluded, outputData);
+        }
+
+        if (otherStart.lessThanOrEquals(thisStart) && thisStart.lessThanOrEquals(otherStop)) {
+
+            isStartIncluded = (otherStart.equals(thisStart) === false && thisIsStartIncluded) || (thisIsStartIncluded && otherIsStartIncluded);
+
+            isStopIncluded = thisIsStopIncluded && otherIsStopIncluded;
+
+            outputData = typeof mergeCallback !== 'undefined' ? mergeCallback(this.data, other.data) : this.data;
+            if (thisStop.greaterThanOrEquals(otherStop)) {
+                isStopIncluded = isStopIncluded || (otherStop.equals(thisStop) === false && otherIsStopIncluded);
+                return new TimeInterval(thisStart, otherStop, isStartIncluded, isStopIncluded, outputData);
+            }
+
+            isStopIncluded = isStopIncluded || thisIsStopIncluded;
+            return new TimeInterval(thisStart, thisStop, isStartIncluded, isStopIncluded, outputData);
+        }
+
+        return TimeInterval.EMPTY;
+    };
+
+    /**
+     * Returns <code>true</code> if this interval contains the specified date.
+     *
+     * @memberof TimeInterval
+     *
+     * @param {JulianDate} date The date to check for.
+     *
+     * @return {Boolean} <code>true</code> if the TimeInterval contains the specified date, <code>false</code> otherwise.
+     */
+    TimeInterval.prototype.contains = function(date) {
+        if (this.isEmpty) {
+            return false;
+        }
+
+        var startComparedToDate = JulianDate.compare(this.start, date);
+        // if (start == date)
+        if (startComparedToDate === 0) {
+            return this.isStartIncluded;
+        }
+
+        var dateComparedToStop = JulianDate.compare(date, this.stop);
+        // if (date == stop)
+        if (dateComparedToStop === 0) {
+            return this.isStopIncluded;
+        }
+
+        // return start < date && date < stop
+        return startComparedToDate < 0 && dateComparedToStop < 0;
+    };
+
+    /**
+     * Compares this TimeInterval against the provided TimeInterval componentwise and returns
+     * <code>true</code> if they are equal, <code>false</code> otherwise.
+     * @memberof TimeInterval
+     *
+     * @param {TimeInterval} [right] The right hand side Cartesian.
+     * @return {Boolean} <code>true</code> if they are equal, <code>false</code> otherwise.
+     */
+    TimeInterval.prototype.equals = function(other) {
+        return TimeInterval.equals(this, other);
+    };
+
+    /**
+     * Compares this TimeInterval against the provided TimeInterval componentwise and returns
+     * <code>true</code> if they are within the provided epsilon,
+     * <code>false</code> otherwise.
+     * @memberof TimeInterval
+     *
+     * @param {TimeInterval} [right] The right hand side Cartesian.
+     * @param {Number} epsilon The epsilon to use for equality testing.
+     * @return {Boolean} <code>true</code> if they are within the provided epsilon, <code>false</code> otherwise.
+     *
+     * @exception {DeveloperError} epsilon is required and must be a number.
+     */
+    TimeInterval.prototype.equalsEpsilon = function(other, epsilon) {
+        return TimeInterval.equalsEpsilon(this, other, epsilon);
+    };
+
+    return TimeInterval;
+});