cesium 0.13.0

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

@@ -0,0 +1,137 @@
+/*global define*/
+define([
+        '../Core/Event',
+        '../Core/TimeInterval',
+        '../Core/Iso8601',
+        '../Core/DeveloperError',
+        './DynamicObject'
+       ], function(
+        Event,
+        TimeInterval,
+        Iso8601,
+        DeveloperError,
+        DynamicObject) {
+    "use strict";
+
+    /**
+     * A collection of DynamicObject instances.
+     * @alias DynamicObjectCollection
+     * @constructor
+     */
+    var DynamicObjectCollection = function() {
+        this._hash = {};
+        this._array = [];
+
+        /**
+         * The CompositeDynamicObjectCollection, if any, that this collection is in.
+         */
+        this.compositeCollection = undefined;
+
+        /**
+         * 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();
+    };
+
+    /**
+     * 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.
+     *
+     * @returns {TimeInterval} The availability of DynamicObjects in the collection.
+     */
+    DynamicObjectCollection.prototype.computeAvailability = function() {
+        var startTime = Iso8601.MAXIMUM_VALUE;
+        var stopTime = Iso8601.MINIMUM_VALUE;
+        var i;
+        var len;
+        var object;
+        var dynamicObjects = this._array;
+        for (i = 0, len = dynamicObjects.length; i < len; i++) {
+            object = dynamicObjects[i];
+            var availability = object.availability;
+            if (typeof availability !== 'undefined') {
+                var start = availability.start;
+                var stop = availability.stop;
+                if (start.lessThan(startTime) && !start.equals(Iso8601.MINIMUM_VALUE)) {
+                    startTime = object.availability.start;
+                }
+                if (stop.greaterThan(stopTime) && !stop.equals(Iso8601.MAXIMUM_VALUE)) {
+                    stopTime = object.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);
+    };
+
+    /**
+     * Gets an object with the specified id.
+     * @param {Object} id The id of the object to retrieve.
+     *
+     * @exception {DeveloperError} id is required.
+     *
+     * @returns The DynamicObject with the provided id, or undefined if no such object exists.
+     */
+    DynamicObjectCollection.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.
+     * @returns {Array} the array of DynamicObject instances in this composite collection.
+     */
+    DynamicObjectCollection.prototype.getObjects = function() {
+        return this._array;
+    };
+
+    /**
+     * Gets an object with the specified id or creates it and adds it to the collection if it does not exist.
+     * @param {Object} id The id of the object to retrieve.
+     *
+     * @exception {DeveloperError} id is required.
+     *
+     * @returns The DynamicObject with the provided id.
+     */
+    DynamicObjectCollection.prototype.getOrCreateObject = function(id) {
+        if (typeof id === 'undefined') {
+            throw new DeveloperError('id is required.');
+        }
+        var obj = this._hash[id];
+        if (!obj) {
+            obj = new DynamicObject(id);
+            this._hash[id] = obj;
+            this._array.push(obj);
+        }
+        return obj;
+    };
+
+    /**
+     * Removes all objects from the collection.
+     */
+    DynamicObjectCollection.prototype.clear = function() {
+        var removedObjects = this._array;
+        this._hash = {};
+        this._array = [];
+        if (removedObjects.length > 0) {
+            this.objectsRemoved.raiseEvent(this, removedObjects);
+        }
+    };
+
+    return DynamicObjectCollection;
+});

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

@@ -0,0 +1,299 @@
+/*global define*/
+define([
+        '../Core/defaultValue',
+        '../Core/DeveloperError',
+        '../Core/Math',
+        '../Core/Cartesian2',
+        '../Core/Cartesian3',
+        '../Core/Cartesian4',
+        '../Core/Cartographic',
+        '../Core/Quaternion',
+        '../Core/Matrix3',
+        '../Core/Ellipsoid',
+        '../Core/Transforms',
+        '../Scene/CameraColumbusViewMode',
+        '../Scene/SceneMode'
+       ], function(
+         defaultValue,
+         DeveloperError,
+         CesiumMath,
+         Cartesian2,
+         Cartesian3,
+         Cartesian4,
+         Cartographic,
+         Quaternion,
+         Matrix3,
+         Ellipsoid,
+         Transforms,
+         CameraColumbusViewMode,
+         SceneMode) {
+    "use strict";
+
+    function update2D(that, camera, objectChanged, offset, positionProperty, time, projection) {
+        var viewDistance;
+        var scene = that.scene;
+        var modeChanged = scene.mode !== that._mode;
+
+        if (modeChanged) {
+            that._mode = scene.mode;
+            that._screenSpaceCameraController.enableTranslate = false;
+            viewDistance = offset.magnitude();
+        } else if (objectChanged) {
+            viewDistance = offset.magnitude();
+        } else {
+            viewDistance = camera.position.z;
+        }
+
+        var cartographic = positionProperty.getValueCartographic(time, that._lastCartographic);
+        if (typeof cartographic !== 'undefined') {
+            //We are assigning the position of the camera, not of the object, so modify the height appropriately.
+            cartographic.height = viewDistance;
+            if (objectChanged || modeChanged) {
+                camera.controller.setPositionCartographic(cartographic);
+
+                //Set rotation to match offset.
+                Cartesian3.normalize(offset, camera.up);
+                Cartesian3.negate(camera.up, camera.up);
+                Cartesian3.cross(camera.direction, camera.up, camera.right);
+
+                //z is always zero in 2D for up and right
+                camera.up.z = 0;
+                Cartesian3.normalize(camera.up, camera.up);
+                camera.right.z = 0;
+                Cartesian3.normalize(camera.right, camera.right);
+
+                //Remember what up was when we started, so we
+                //can detect rotation when we are finished.
+                Cartesian2.clone(camera.right, that._first2dUp);
+            } else {
+                camera.position = projection.project(cartographic);
+            }
+
+            //Store last view distance and up vector.
+            that._lastDistance = camera.frustum.right - camera.frustum.left;
+            Cartesian2.clone(camera.right, that._last2dUp);
+        }
+    }
+
+    var update3DTransform;
+    function update3D(that, camera, objectChanged, offset, positionProperty, time, ellipsoid) {
+        update3DController(that, camera, objectChanged, offset);
+
+        var cartesian = positionProperty.getValueCartesian(time, that._lastCartesian);
+        if (typeof cartesian !== 'undefined') {
+            camera.transform = Transforms.eastNorthUpToFixedFrame(cartesian, ellipsoid, update3DTransform);
+            that._screenSpaceCameraController.setEllipsoid(Ellipsoid.UNIT_SPHERE);
+
+            var position = camera.position;
+            Cartesian3.clone(position, that._lastOffset);
+            that._lastDistance = Cartesian3.magnitude(position);
+        }
+    }
+
+    var updateColumbusCartesian4 = new Cartesian4(0.0, 0.0, 0.0, 1.0);
+    function updateColumbus(that, camera, objectChanged, offset, positionProperty, time, ellipsoid, projection) {
+        update3DController(that, camera, objectChanged, offset);
+
+        //The swizzling here is intentional because ColumbusView uses a different coordinate system.
+        var cartographic = positionProperty.getValueCartographic(time, that._lastCartographic);
+        if (typeof cartographic !== 'undefined') {
+            var projectedPosition = projection.project(cartographic);
+            updateColumbusCartesian4.x = projectedPosition.z;
+            updateColumbusCartesian4.y = projectedPosition.x;
+            updateColumbusCartesian4.z = projectedPosition.y;
+
+            var tranform = camera.transform;
+            tranform.setColumn(3, updateColumbusCartesian4, tranform);
+
+            var controller = that._screenSpaceCameraController;
+            controller.enableTranslate = false;
+            controller.setEllipsoid(Ellipsoid.UNIT_SPHERE);
+            controller.columbusViewMode = CameraColumbusViewMode.LOCKED;
+
+            camera.controller.constrainedAxis = Cartesian3.UNIT_Z;
+
+            var position = camera.position;
+            Cartesian3.clone(position, that._lastOffset);
+            that._lastDistance = Cartesian3.magnitude(position);
+        }
+    }
+
+    var update3DControllerQuaternion = new Quaternion();
+    var update3DControllerMatrix3 = new Matrix3();
+
+    function update3DController(that, camera, objectChanged, offset) {
+        var scene = that.scene;
+        that._screenSpaceCameraController.enableTilt = false;
+        camera.controller.constrainedAxis = Cartesian3.UNIT_Z;
+
+        if (objectChanged) {
+            camera.controller.lookAt(offset, Cartesian3.ZERO, Cartesian3.UNIT_Z);
+        } else if (scene.mode !== that._mode) {
+            that._mode = scene.mode;
+
+            //If we're switching from 2D and any rotation was applied to the camera,
+            //apply that same rotation to the last offset used in 3D or Columbus view.
+            var first2dUp = that._first2dUp;
+            var last2dUp = that._last2dUp;
+            if (!Cartesian2.equals(first2dUp, last2dUp)) {
+                var startTheta = Math.acos(first2dUp.x);
+                if (first2dUp.y < 0) {
+                    startTheta = CesiumMath.TWO_PI - startTheta;
+                }
+                var endTheta = Math.acos(last2dUp.x);
+                if (last2dUp.y < 0) {
+                    endTheta = CesiumMath.TWO_PI - endTheta;
+                }
+                last2dUp.x = 0.0;
+                last2dUp.y = 0.0;
+                first2dUp.x = 0.0;
+                first2dUp.y = 0.0;
+
+                var theta = startTheta - endTheta;
+                var rotation = Quaternion.fromAxisAngle(Cartesian3.UNIT_Z, theta, update3DControllerQuaternion);
+                Matrix3.fromQuaternion(rotation, update3DControllerMatrix3).multiplyByVector(offset, offset);
+            }
+            offset.normalize(offset).multiplyByScalar(that._lastDistance, offset);
+            camera.controller.lookAt(offset, Cartesian3.ZERO, Cartesian3.UNIT_Z);
+        }
+    }
+
+    var dynamicObjectViewDefaultOffset = new Cartesian3(10000, -10000, 10000);
+    var dynamicObjectViewCartesian3Scratch = new Cartesian3();
+
+    /**
+     * A utility object for tracking an object with the camera.
+     * @alias DynamicObject
+     * @constructor
+     *
+     * @param {DynamicObject} dynamicObject The object to track with the camera.
+     * @param {Scene} scene The scene to use.
+     * @param {Ellipsoid} [ellipsoid=Ellipsoid.WGS84] The ellipsoid to use for orienting the camera.
+     */
+    var DynamicObjectView = function(dynamicObject, scene, ellipsoid) {
+        /**
+         * The object to track with the camera.
+         * @type DynamicObject
+         */
+        this.dynamicObject = dynamicObject;
+
+        /**
+         * The scene in which to track the object.
+         * @type Scene
+         */
+        this.scene = scene;
+        this._lastScene = undefined;
+
+        /**
+         * The ellipsoid to use for orienting the camera.
+         * @type Ellipsoid
+         */
+        this.ellipsoid = defaultValue(ellipsoid, Ellipsoid.WGS84);
+
+        //Shadow copies of the objects so we can detect changes.
+        this._lastDynamicObject = undefined;
+        this._mode = undefined;
+
+        //Re-usable objects to be used for retrieving position.
+        this._lastCartesian = new Cartesian3();
+        this._lastCartographic = new Cartographic();
+
+        //Current distance of dynamicObject from camera so we can maintain view distance across scene modes.
+        this._lastDistance = undefined;
+
+        //Last viewing offset in 3D/Columbus view, this way we can restore to a sensible view across scene modes.
+        this._lastOffset = new Cartesian3();
+
+        //Scratch value for calculating offsets
+        this._offsetScratch = new Cartesian3();
+
+        //Tracks camera up so that we can detect 2D camera rotation and modify the 3D/Columbus view to match when switching modes.
+        this._first2dUp = new Cartesian2();
+        this._last2dUp = new Cartesian2();
+    };
+
+    /**
+    * Should be called each animation frame to update the camera
+    * to the latest settings.
+    * @param {JulianDate} time The current animation time.
+    *
+    * @exception {DeveloperError} time is required.
+    * @exception {DeveloperError} DynamicObjectView.scene is required.
+    * @exception {DeveloperError} DynamicObjectView.dynamicObject is required.
+    * @exception {DeveloperError} DynamicObjectView.ellipsoid is required.
+    * @exception {DeveloperError} DynamicObjectView.dynamicObject.position is required.
+    */
+    DynamicObjectView.prototype.update = function(time) {
+        if (typeof time === 'undefined') {
+            throw new DeveloperError('time is required.');
+        }
+
+        var scene = this.scene;
+        if (typeof scene === 'undefined') {
+            throw new DeveloperError('DynamicObjectView.scene is required.');
+        }
+
+        if (scene !== this._lastScene) {
+            this._lastScene = scene;
+            this._screenSpaceCameraController = scene.getScreenSpaceCameraController();
+        }
+
+        var dynamicObject = this.dynamicObject;
+        if (typeof dynamicObject === 'undefined') {
+            throw new DeveloperError('DynamicObjectView.dynamicObject is required.');
+        }
+
+        var ellipsoid = this.ellipsoid;
+        if (typeof ellipsoid === 'undefined') {
+            throw new DeveloperError('DynamicObjectView.ellipsoid is required.');
+        }
+
+        var positionProperty = this.dynamicObject.position;
+        if (typeof positionProperty === 'undefined') {
+            throw new DeveloperError('dynamicObject.position is required.');
+        }
+
+        var objectChanged = dynamicObject !== this._lastDynamicObject;
+
+        //Determine what the current camera offset should be, this is used
+        //to either set the default view when a new object is selected or
+        //maintain a similar view when changing scene modes.
+        var offset = this._offsetScratch;
+        if (objectChanged) {
+            this._lastDynamicObject = dynamicObject;
+
+            var viewFromProperty = this.dynamicObject.viewFrom;
+            if (typeof viewFromProperty === 'undefined' || typeof viewFromProperty.getValue(time, offset) === 'undefined') {
+                Cartesian3.clone(dynamicObjectViewDefaultOffset, offset);
+            }
+
+            //Reset object-based cached values.
+            var first2dUp = this._first2dUp;
+            var last2dUp = this._last2dUp;
+            first2dUp.x = first2dUp.y = 0;
+            last2dUp.x = last2dUp.y = 0;
+            Cartesian3.clone(offset, this._lastOffset);
+            this._lastDistance = offset.magnitude();
+
+            //If looking straight down, move the camera slightly south the avoid gimbal lock.
+            if (Cartesian3.equals(offset.normalize(dynamicObjectViewCartesian3Scratch), Cartesian3.UNIT_Z)) {
+                offset.y -= 0.01;
+            }
+        } else if (typeof this._lastOffset !== 'undefined') {
+            offset = this._lastOffset;
+        } else {
+            Cartesian3.clone(dynamicObjectViewDefaultOffset, offset);
+        }
+
+        var mode = scene.mode;
+        if (mode === SceneMode.SCENE2D) {
+            update2D(this, scene.getCamera(), objectChanged, offset, positionProperty, time, scene.scene2D.projection);
+        } else if (mode === SceneMode.SCENE3D) {
+            update3D(this, scene.getCamera(), objectChanged, offset, positionProperty, time, ellipsoid);
+        } else if (mode === SceneMode.COLUMBUS_VIEW) {
+            updateColumbus(this, scene.getCamera(), objectChanged, offset, positionProperty, time, ellipsoid, scene.scene2D.projection);
+        }
+    };
+
+    return DynamicObjectView;
+});

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

@@ -0,0 +1,214 @@
+/*global define*/
+define([
+        '../Core/TimeInterval',
+        '../Core/defaultValue',
+        './CzmlBoolean',
+        './CzmlNumber',
+        './CzmlColor',
+        './DynamicProperty'],
+function(
+        TimeInterval,
+        defaultValue,
+        CzmlBoolean,
+        CzmlNumber,
+        CzmlColor,
+        DynamicProperty) {
+    "use strict";
+
+    /**
+     * Represents a time-dynamic path, typically used in conjunction with DynamicPathVisualizer and
+     * DynamicObjectCollection to visualize CZML.
+     *
+     * @alias DynamicPath
+     * @constructor
+     *
+     * @see DynamicObject
+     * @see DynamicProperty
+     * @see DynamicObjectCollection
+     * @see DynamicPathVisualizer
+     * @see VisualizerCollection
+     * @see Polyline
+     * @see CzmlDefaults
+     */
+    var DynamicPath = function() {
+        /**
+         * A DynamicProperty of type CzmlColor which determines the line's color.
+         * @type DynamicProperty
+         */
+        this.color = undefined;
+        /**
+         * A DynamicProperty of type CzmlColor which determines the line's outline color.
+         * @type DynamicProperty
+         */
+        this.outlineColor = undefined;
+        /**
+         * A DynamicProperty of type CzmlNumber which determines the line's outline width.
+         * @type DynamicProperty
+         */
+        this.outlineWidth = undefined;
+        /**
+         * A DynamicProperty of type CzmlBoolean which determines the lines's visibility.
+         * @type DynamicProperty
+         */
+        this.show = undefined;
+        /**
+         * A DynamicProperty of type CzmlNumber which determines the line's width.
+         * @type DynamicProperty
+         */
+        this.width = undefined;
+        /**
+         * A DynamicProperty of type CzmlNumber which determines the number of seconds in front of the object to show.
+         * @type DynamicProperty
+         */
+        this.leadTime = undefined;
+        /**
+         * A DynamicProperty of type CzmlNumber which determines the the number of seconds behind the object to show.
+         * @type DynamicProperty
+         */
+        this.trailTime = undefined;
+    };
+
+    /**
+     * Processes a single CZML packet and merges its data into the provided DynamicObject's path.
+     * If the DynamicObject does not have a path, one is created.  This method is not
+     * normally called directly, but is part of the array of CZML processing functions that is
+     * passed into the DynamicObjectCollection constructor.
+     *
+     * @param {DynamicObject} dynamicObject The DynamicObject which will contain the path data.
+     * @param {Object} packet The CZML packet to process.
+     * @returns {Boolean} true if any new properties were created while processing the packet, false otherwise.
+     *
+     * @see DynamicObject
+     * @see DynamicProperty
+     * @see DynamicObjectCollection
+     * @see CzmlDefaults#updaters
+     */
+    DynamicPath.processCzmlPacket = function(dynamicObject, packet) {
+        var pathData = packet.path;
+        if (typeof pathData === 'undefined') {
+            return false;
+        }
+
+        var pathUpdated = false;
+        var path = dynamicObject.path;
+        pathUpdated = typeof path === 'undefined';
+        if (pathUpdated) {
+            dynamicObject.path = path = new DynamicPath();
+        }
+
+        var interval = pathData.interval;
+        if (typeof interval !== 'undefined') {
+            interval = TimeInterval.fromIso8601(interval);
+        }
+
+        if (typeof pathData.color !== 'undefined') {
+            var color = path.color;
+            if (typeof color === 'undefined') {
+                path.color = color = new DynamicProperty(CzmlColor);
+                pathUpdated = true;
+            }
+            color.processCzmlIntervals(pathData.color, interval);
+        }
+
+        if (typeof pathData.width !== 'undefined') {
+            var width = path.width;
+            if (typeof width === 'undefined') {
+                path.width = width = new DynamicProperty(CzmlNumber);
+                pathUpdated = true;
+            }
+            width.processCzmlIntervals(pathData.width, interval);
+        }
+
+        if (typeof pathData.outlineColor !== 'undefined') {
+            var outlineColor = path.outlineColor;
+            if (typeof outlineColor === 'undefined') {
+                path.outlineColor = outlineColor = new DynamicProperty(CzmlColor);
+                pathUpdated = true;
+            }
+            outlineColor.processCzmlIntervals(pathData.outlineColor, interval);
+        }
+
+        if (typeof pathData.outlineWidth !== 'undefined') {
+            var outlineWidth = path.outlineWidth;
+            if (typeof outlineWidth === 'undefined') {
+                path.outlineWidth = outlineWidth = new DynamicProperty(CzmlNumber);
+                pathUpdated = true;
+            }
+            outlineWidth.processCzmlIntervals(pathData.outlineWidth, interval);
+        }
+
+        if (typeof pathData.show !== 'undefined') {
+            var show = path.show;
+            if (typeof show === 'undefined') {
+                path.show = show = new DynamicProperty(CzmlBoolean);
+                pathUpdated = true;
+            }
+            show.processCzmlIntervals(pathData.show, interval);
+        }
+
+        if (typeof pathData.leadTime !== 'undefined') {
+            var leadTime = path.leadTime;
+            if (typeof leadTime === 'undefined') {
+                path.leadTime = leadTime = new DynamicProperty(CzmlNumber);
+                pathUpdated = true;
+            }
+            leadTime.processCzmlIntervals(pathData.leadTime, interval);
+        }
+
+        if (typeof pathData.trailTime !== 'undefined') {
+            var trailTime = path.trailTime;
+            if (typeof trailTime === 'undefined') {
+                path.trailTime = trailTime = new DynamicProperty(CzmlNumber);
+                pathUpdated = true;
+            }
+            trailTime.processCzmlIntervals(pathData.trailTime, interval);
+        }
+
+        return pathUpdated;
+    };
+
+    /**
+     * Given two DynamicObjects, takes the path properties from the second
+     * and assigns them to the first, assuming such a property did not already exist.
+     * This method is not normally called directly, but is part of the array of CZML processing
+     * functions that is passed into the CompositeDynamicObjectCollection constructor.
+     *
+     * @param {DynamicObject} targetObject The DynamicObject which will have properties merged onto it.
+     * @param {DynamicObject} objectToMerge The DynamicObject containing properties to be merged.
+     *
+     * @see CzmlDefaults
+     */
+    DynamicPath.mergeProperties = function(targetObject, objectToMerge) {
+        var pathToMerge = objectToMerge.path;
+        if (typeof pathToMerge !== 'undefined') {
+
+            var targetpath = targetObject.path;
+            if (typeof targetpath === 'undefined') {
+                targetObject.path = targetpath = new DynamicPath();
+            }
+
+            targetpath.color = defaultValue(targetpath.color, pathToMerge.color);
+            targetpath.width = defaultValue(targetpath.width, pathToMerge.width);
+            targetpath.outlineColor = defaultValue(targetpath.outlineColor, pathToMerge.outlineColor);
+            targetpath.outlineWidth = defaultValue(targetpath.outlineWidth, pathToMerge.outlineWidth);
+            targetpath.show = defaultValue(targetpath.show, pathToMerge.show);
+            targetpath.leadTime = defaultValue(targetpath.leadTime, pathToMerge.leadTime);
+            targetpath.trailTime = defaultValue(targetpath.trailTime, pathToMerge.trailTime);
+        }
+    };
+
+    /**
+     * Given a DynamicObject, undefines the path associated with it.
+     * This method is not normally called directly, but is part of the array of CZML processing
+     * functions that is passed into the CompositeDynamicObjectCollection constructor.
+     *
+     * @param {DynamicObject} dynamicObject The DynamicObject to remove the path from.
+     *
+     * @see CzmlDefaults
+     */
+    DynamicPath.undefineProperties = function(dynamicObject) {
+        dynamicObject.path = undefined;
+    };
+
+    return DynamicPath;
+});