cesium 0.13.0

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

@@ -0,0 +1,251 @@
+/*global define*/
+define([
+        '../Core/DeveloperError',
+        '../Core/destroyObject',
+        '../Scene/Polygon',
+        '../Scene/Material'
+       ], function(
+         DeveloperError,
+         destroyObject,
+         Polygon,
+         Material) {
+    "use strict";
+
+    /**
+     * A DynamicObject visualizer which maps the DynamicPolygon instance
+     * in DynamicObject.polygon to a Polygon primitive.
+     * @alias DynamicPolygonVisualizer
+     * @constructor
+     *
+     * @param {Scene} scene The scene the primitives will be rendered in.
+     * @param {DynamicObjectCollection} [dynamicObjectCollection] The dynamicObjectCollection to visualize.
+     *
+     * @exception {DeveloperError} scene is required.
+     *
+     * @see DynamicPolygon
+     * @see Scene
+     * @see DynamicObject
+     * @see DynamicObjectCollection
+     * @see CompositeDynamicObjectCollection
+     * @see VisualizerCollection
+     * @see DynamicBillboardVisualizer
+     * @see DynamicConeVisualizer
+     * @see DynamicConeVisualizerUsingCustomSensorr
+     * @see DynamicLabelVisualizer
+     * @see DynamicPointVisualizer
+     * @see DynamicPolylineVisualizer
+     * @see DynamicPyramidVisualizer
+     *
+     */
+    var DynamicPolygonVisualizer = function(scene, dynamicObjectCollection) {
+        if (typeof scene === 'undefined') {
+            throw new DeveloperError('scene is required.');
+        }
+        this._scene = scene;
+        this._unusedIndexes = [];
+        this._primitives = scene.getPrimitives();
+        this._polygonCollection = [];
+        this._dynamicObjectCollection = undefined;
+        this.setDynamicObjectCollection(dynamicObjectCollection);
+    };
+
+    /**
+     * Returns the scene being used by this visualizer.
+     *
+     * @returns {Scene} The scene being used by this visualizer.
+     */
+    DynamicPolygonVisualizer.prototype.getScene = function() {
+        return this._scene;
+    };
+
+    /**
+     * Gets the DynamicObjectCollection being visualized.
+     *
+     * @returns {DynamicObjectCollection} The DynamicObjectCollection being visualized.
+     */
+    DynamicPolygonVisualizer.prototype.getDynamicObjectCollection = function() {
+        return this._dynamicObjectCollection;
+    };
+
+    /**
+     * Sets the DynamicObjectCollection to visualize.
+     *
+     * @param dynamicObjectCollection The DynamicObjectCollection to visualizer.
+     */
+    DynamicPolygonVisualizer.prototype.setDynamicObjectCollection = function(dynamicObjectCollection) {
+        var oldCollection = this._dynamicObjectCollection;
+        if (oldCollection !== dynamicObjectCollection) {
+            if (typeof oldCollection !== 'undefined') {
+                oldCollection.objectsRemoved.removeEventListener(DynamicPolygonVisualizer.prototype._onObjectsRemoved);
+                this.removeAllPrimitives();
+            }
+            this._dynamicObjectCollection = dynamicObjectCollection;
+            if (typeof dynamicObjectCollection !== 'undefined') {
+                dynamicObjectCollection.objectsRemoved.addEventListener(DynamicPolygonVisualizer.prototype._onObjectsRemoved, this);
+            }
+        }
+    };
+
+    /**
+     * Updates all of the primitives created by this visualizer to match their
+     * DynamicObject counterpart at the given time.
+     *
+     * @param {JulianDate} time The time to update to.
+     *
+     * @exception {DeveloperError} time is required.
+     */
+    DynamicPolygonVisualizer.prototype.update = function(time) {
+        if (typeof time === 'undefined') {
+            throw new DeveloperError('time is requied.');
+        }
+        if (typeof this._dynamicObjectCollection !== 'undefined') {
+            var dynamicObjects = this._dynamicObjectCollection.getObjects();
+            for ( var i = 0, len = dynamicObjects.length; i < len; i++) {
+                this._updateObject(time, dynamicObjects[i]);
+            }
+        }
+    };
+
+    /**
+     * Removes all primitives from the scene.
+     */
+    DynamicPolygonVisualizer.prototype.removeAllPrimitives = function() {
+        var i, len;
+        for (i = 0, len = this._polygonCollection.length; i < len; i++) {
+            this._primitives.remove(this._polygonCollection[i]);
+        }
+
+        if (typeof this._dynamicObjectCollection !== 'undefined') {
+            var dynamicObjects = this._dynamicObjectCollection.getObjects();
+            for (i = dynamicObjects.length - 1; i > -1; i--) {
+                dynamicObjects[i]._polygonVisualizerIndex = undefined;
+            }
+        }
+
+        this._unusedIndexes = [];
+        this._polygonCollection = [];
+    };
+
+    /**
+     * Returns true if this object was destroyed; otherwise, false.
+     * <br /><br />
+     * If this object was destroyed, it should not be used; calling any function other than
+     * <code>isDestroyed</code> will result in a {@link DeveloperError} exception.
+     *
+     * @memberof DynamicPolygonVisualizer
+     *
+     * @return {Boolean} True if this object was destroyed; otherwise, false.
+     *
+     * @see DynamicPolygonVisualizer#destroy
+     */
+    DynamicPolygonVisualizer.prototype.isDestroyed = function() {
+        return false;
+    };
+
+    /**
+     * Destroys the WebGL resources held by this object.  Destroying an object allows for deterministic
+     * release of WebGL resources, instead of relying on the garbage collector to destroy this object.
+     * <br /><br />
+     * Once an object is destroyed, it should not be used; calling any function other than
+     * <code>isDestroyed</code> will result in a {@link DeveloperError} exception.  Therefore,
+     * assign the return value (<code>undefined</code>) to the object as done in the example.
+     *
+     * @memberof DynamicPolygonVisualizer
+     *
+     * @return {undefined}
+     *
+     * @exception {DeveloperError} This object was destroyed, i.e., destroy() was called.
+     *
+     * @see DynamicPolygonVisualizer#isDestroyed
+     *
+     * @example
+     * visualizer = visualizer && visualizer.destroy();
+     */
+    DynamicPolygonVisualizer.prototype.destroy = function() {
+        this.removeAllPrimitives();
+        return destroyObject(this);
+    };
+
+    DynamicPolygonVisualizer.prototype._updateObject = function(time, dynamicObject) {
+        var context = this._scene.getContext();
+        var dynamicPolygon = dynamicObject.polygon;
+        if (typeof dynamicPolygon === 'undefined') {
+            return;
+        }
+
+        var vertexPositionsProperty = dynamicObject.vertexPositions;
+        if (typeof vertexPositionsProperty === 'undefined') {
+            return;
+        }
+
+        var vertexPositions = vertexPositionsProperty.getValueCartesian(time);
+
+        var polygon;
+        var showProperty = dynamicPolygon.show;
+        var polygonVisualizerIndex = dynamicObject._polygonVisualizerIndex;
+        var show = dynamicObject.isAvailable(time) && (typeof showProperty === 'undefined' || showProperty.getValue(time));
+
+
+        if (!show || typeof vertexPositions === 'undefined' || vertexPositions.length < 3) {
+            //don't bother creating or updating anything else
+            if (typeof polygonVisualizerIndex !== 'undefined') {
+                polygon = this._polygonCollection[polygonVisualizerIndex];
+                polygon.show = false;
+                dynamicObject._polygonVisualizerIndex = undefined;
+                this._unusedIndexes.push(polygonVisualizerIndex);
+            }
+            return;
+        }
+
+        if (typeof polygonVisualizerIndex === 'undefined') {
+            var unusedIndexes = this._unusedIndexes;
+            var length = unusedIndexes.length;
+            if (length > 0) {
+                polygonVisualizerIndex = unusedIndexes.pop();
+                polygon = this._polygonCollection[polygonVisualizerIndex];
+            } else {
+                polygonVisualizerIndex = this._polygonCollection.length;
+                polygon = new Polygon();
+                this._polygonCollection.push(polygon);
+                this._primitives.add(polygon);
+            }
+            dynamicObject._polygonVisualizerIndex = polygonVisualizerIndex;
+            polygon.dynamicObject = dynamicObject;
+
+            // CZML_TODO Determine official defaults
+            polygon.material = Material.fromType(context, Material.ColorType);
+
+        } else {
+            polygon = this._polygonCollection[polygonVisualizerIndex];
+        }
+
+        polygon.show = true;
+
+        if (polygon._visualizerPositions !== vertexPositions) {
+            polygon.setPositions(vertexPositions);
+            polygon._visualizerPositions = vertexPositions;
+        }
+
+        var material = dynamicPolygon.material;
+        if (typeof material !== 'undefined') {
+            polygon.material = material.getValue(time, context, polygon.material);
+        }
+    };
+
+    DynamicPolygonVisualizer.prototype._onObjectsRemoved = function(dynamicObjectCollection, dynamicObjects) {
+        var thisPolygonCollection = this._polygonCollection;
+        var thisUnusedIndexes = this._unusedIndexes;
+        for ( var i = dynamicObjects.length - 1; i > -1; i--) {
+            var dynamicObject = dynamicObjects[i];
+            var polygonVisualizerIndex = dynamicObject._polygonVisualizerIndex;
+            if (typeof polygonVisualizerIndex !== 'undefined') {
+                var polygon = thisPolygonCollection[polygonVisualizerIndex];
+                polygon.show = false;
+                thisUnusedIndexes.push(polygonVisualizerIndex);
+                dynamicObject._polygonVisualizerIndex = undefined;
+            }
+        }
+    };
+
+    return DynamicPolygonVisualizer;
+});

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

@@ -0,0 +1,183 @@
+/*global define*/
+define([
+        '../Core/TimeInterval',
+        '../Core/defaultValue',
+        './CzmlBoolean',
+        './CzmlNumber',
+        './CzmlColor',
+        './DynamicProperty'],
+function(
+        TimeInterval,
+        defaultValue,
+        CzmlBoolean,
+        CzmlNumber,
+        CzmlColor,
+        DynamicProperty) {
+    "use strict";
+
+    /**
+     * Represents a time-dynamic polyline, typically used in conjunction with DynamicPolylineVisualizer and
+     * DynamicObjectCollection to visualize CZML.
+     *
+     * @alias DynamicPolyline
+     * @constructor
+     *
+     * @see DynamicObject
+     * @see DynamicProperty
+     * @see DynamicObjectCollection
+     * @see DynamicPolylineVisualizer
+     * @see VisualizerCollection
+     * @see Polyline
+     * @see CzmlDefaults
+     */
+    var DynamicPolyline = 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;
+    };
+
+    /**
+     * Processes a single CZML packet and merges its data into the provided DynamicObject's polyline.
+     * If the DynamicObject does not have a polyline, 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 polyline 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
+     */
+    DynamicPolyline.processCzmlPacket = function(dynamicObject, packet) {
+        var polylineData = packet.polyline;
+        if (typeof polylineData === 'undefined') {
+            return false;
+        }
+
+        var polylineUpdated = false;
+        var polyline = dynamicObject.polyline;
+        polylineUpdated = typeof polyline === 'undefined';
+        if (polylineUpdated) {
+            dynamicObject.polyline = polyline = new DynamicPolyline();
+        }
+
+        var interval = polylineData.interval;
+        if (typeof interval !== 'undefined') {
+            interval = TimeInterval.fromIso8601(interval);
+        }
+
+        if (typeof polylineData.color !== 'undefined') {
+            var color = polyline.color;
+            if (typeof color === 'undefined') {
+                polyline.color = color = new DynamicProperty(CzmlColor);
+                polylineUpdated = true;
+            }
+            color.processCzmlIntervals(polylineData.color, interval);
+        }
+
+        if (typeof polylineData.width !== 'undefined') {
+            var width = polyline.width;
+            if (typeof width === 'undefined') {
+                polyline.width = width = new DynamicProperty(CzmlNumber);
+                polylineUpdated = true;
+            }
+            width.processCzmlIntervals(polylineData.width, interval);
+        }
+
+        if (typeof polylineData.outlineColor !== 'undefined') {
+            var outlineColor = polyline.outlineColor;
+            if (typeof outlineColor === 'undefined') {
+                polyline.outlineColor = outlineColor = new DynamicProperty(CzmlColor);
+                polylineUpdated = true;
+            }
+            outlineColor.processCzmlIntervals(polylineData.outlineColor, interval);
+        }
+
+        if (typeof polylineData.outlineWidth !== 'undefined') {
+            var outlineWidth = polyline.outlineWidth;
+            if (typeof outlineWidth === 'undefined') {
+                polyline.outlineWidth = outlineWidth = new DynamicProperty(CzmlNumber);
+                polylineUpdated = true;
+            }
+            outlineWidth.processCzmlIntervals(polylineData.outlineWidth, interval);
+        }
+
+        if (typeof polylineData.show !== 'undefined') {
+            var show = polyline.show;
+            if (typeof show === 'undefined') {
+                polyline.show = show = new DynamicProperty(CzmlBoolean);
+                polylineUpdated = true;
+            }
+            show.processCzmlIntervals(polylineData.show, interval);
+        }
+        return polylineUpdated;
+    };
+
+    /**
+     * Given two DynamicObjects, takes the polyline 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
+     */
+    DynamicPolyline.mergeProperties = function(targetObject, objectToMerge) {
+        var polylineToMerge = objectToMerge.polyline;
+        if (typeof polylineToMerge !== 'undefined') {
+
+            var targetPolyline = targetObject.polyline;
+            if (typeof targetPolyline === 'undefined') {
+                targetObject.polyline = targetPolyline = new DynamicPolyline();
+            }
+
+            targetPolyline.color = defaultValue(targetPolyline.color, polylineToMerge.color);
+            targetPolyline.width = defaultValue(targetPolyline.width, polylineToMerge.width);
+            targetPolyline.outlineColor = defaultValue(targetPolyline.outlineColor, polylineToMerge.outlineColor);
+            targetPolyline.outlineWidth = defaultValue(targetPolyline.outlineWidth, polylineToMerge.outlineWidth);
+            targetPolyline.show = defaultValue(targetPolyline.show, polylineToMerge.show);
+        }
+    };
+
+    /**
+     * Given a DynamicObject, undefines the polyline 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 polyline from.
+     *
+     * @see CzmlDefaults
+     */
+    DynamicPolyline.undefineProperties = function(dynamicObject) {
+        dynamicObject.polyline = undefined;
+    };
+
+    return DynamicPolyline;
+});

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

@@ -0,0 +1,268 @@
+/*global define*/
+define([
+        '../Core/DeveloperError',
+        '../Core/destroyObject',
+        '../Core/Color',
+        '../Scene/PolylineCollection'
+       ], function(
+         DeveloperError,
+         destroyObject,
+         Color,
+         PolylineCollection) {
+    "use strict";
+
+    /**
+     * A DynamicObject visualizer which maps the DynamicPolyline instance
+     * in DynamicObject.polyline to a Polyline primitive.
+     * @alias DynamicPolylineVisualizer
+     * @constructor
+     *
+     * @param {Scene} scene The scene the primitives will be rendered in.
+     * @param {DynamicObjectCollection} [dynamicObjectCollection] The dynamicObjectCollection to visualize.
+     *
+     * @exception {DeveloperError} scene is required.
+     *
+     * @see DynamicPolyline
+     * @see Scene
+     * @see DynamicObject
+     * @see DynamicObjectCollection
+     * @see CompositeDynamicObjectCollection
+     * @see VisualizerCollection
+     * @see DynamicBillboardVisualizer
+     * @see DynamicConeVisualizer
+     * @see DynamicConeVisualizerUsingCustomSensorr
+     * @see DynamicLabelVisualizer
+     * @see DynamicPointVisualizer
+     * @see DynamicPolygonVisualizer
+     * @see DynamicPyramidVisualizer
+     *
+     */
+    var DynamicPolylineVisualizer = function(scene, dynamicObjectCollection) {
+        if (typeof scene === 'undefined') {
+            throw new DeveloperError('scene is required.');
+        }
+        this._scene = scene;
+        this._unusedIndexes = [];
+        this._primitives = scene.getPrimitives();
+        var polylineCollection = this._polylineCollection = new PolylineCollection();
+        scene.getPrimitives().add(polylineCollection);
+        this._dynamicObjectCollection = undefined;
+        this.setDynamicObjectCollection(dynamicObjectCollection);
+    };
+
+    /**
+     * Returns the scene being used by this visualizer.
+     *
+     * @returns {Scene} The scene being used by this visualizer.
+     */
+    DynamicPolylineVisualizer.prototype.getScene = function() {
+        return this._scene;
+    };
+
+    /**
+     * Gets the DynamicObjectCollection being visualized.
+     *
+     * @returns {DynamicObjectCollection} The DynamicObjectCollection being visualized.
+     */
+    DynamicPolylineVisualizer.prototype.getDynamicObjectCollection = function() {
+        return this._dynamicObjectCollection;
+    };
+
+    /**
+     * Sets the DynamicObjectCollection to visualize.
+     *
+     * @param dynamicObjectCollection The DynamicObjectCollection to visualizer.
+     */
+    DynamicPolylineVisualizer.prototype.setDynamicObjectCollection = function(dynamicObjectCollection) {
+        var oldCollection = this._dynamicObjectCollection;
+        if (oldCollection !== dynamicObjectCollection) {
+            if (typeof oldCollection !== 'undefined') {
+                oldCollection.objectsRemoved.removeEventListener(DynamicPolylineVisualizer.prototype._onObjectsRemoved);
+                this.removeAllPrimitives();
+            }
+            this._dynamicObjectCollection = dynamicObjectCollection;
+            if (typeof dynamicObjectCollection !== 'undefined') {
+                dynamicObjectCollection.objectsRemoved.addEventListener(DynamicPolylineVisualizer.prototype._onObjectsRemoved, this);
+            }
+        }
+    };
+
+    /**
+     * Updates all of the primitives created by this visualizer to match their
+     * DynamicObject counterpart at the given time.
+     *
+     * @param {JulianDate} time The time to update to.
+     *
+     * @exception {DeveloperError} time is required.
+     */
+    DynamicPolylineVisualizer.prototype.update = function(time) {
+        if (typeof time === 'undefined') {
+            throw new DeveloperError('time is requied.');
+        }
+        if (typeof this._dynamicObjectCollection !== 'undefined') {
+            var dynamicObjects = this._dynamicObjectCollection.getObjects();
+            for ( var i = 0, len = dynamicObjects.length; i < len; i++) {
+                this._updateObject(time, dynamicObjects[i]);
+            }
+        }
+    };
+
+    /**
+     * Removes all primitives from the scene.
+     */
+    DynamicPolylineVisualizer.prototype.removeAllPrimitives = function() {
+        var i;
+        this._polylineCollection.removeAll();
+
+        if (typeof this._dynamicObjectCollection !== 'undefined') {
+            var dynamicObjects = this._dynamicObjectCollection.getObjects();
+            for (i = dynamicObjects.length - 1; i > -1; i--) {
+                dynamicObjects[i]._polylineVisualizerIndex = undefined;
+            }
+        }
+
+        this._unusedIndexes = [];
+    };
+
+    /**
+     * Returns true if this object was destroyed; otherwise, false.
+     * <br /><br />
+     * If this object was destroyed, it should not be used; calling any function other than
+     * <code>isDestroyed</code> will result in a {@link DeveloperError} exception.
+     *
+     * @memberof DynamicPolylineVisualizer
+     *
+     * @return {Boolean} True if this object was destroyed; otherwise, false.
+     *
+     * @see DynamicPolylineVisualizer#destroy
+     */
+    DynamicPolylineVisualizer.prototype.isDestroyed = function() {
+        return false;
+    };
+
+    /**
+     * Destroys the WebGL resources held by this object.  Destroying an object allows for deterministic
+     * release of WebGL resources, instead of relying on the garbage collector to destroy this object.
+     * <br /><br />
+     * Once an object is destroyed, it should not be used; calling any function other than
+     * <code>isDestroyed</code> will result in a {@link DeveloperError} exception.  Therefore,
+     * assign the return value (<code>undefined</code>) to the object as done in the example.
+     *
+     * @memberof DynamicPolylineVisualizer
+     *
+     * @return {undefined}
+     *
+     * @exception {DeveloperError} This object was destroyed, i.e., destroy() was called.
+     *
+     * @see DynamicPolylineVisualizer#isDestroyed
+     *
+     * @example
+     * visualizer = visualizer && visualizer.destroy();
+     */
+    DynamicPolylineVisualizer.prototype.destroy = function() {
+        this.removeAllPrimitives();
+        this._scene.getPrimitives().remove(this._polylineCollection);
+        return destroyObject(this);
+    };
+
+    DynamicPolylineVisualizer.prototype._updateObject = function(time, dynamicObject) {
+        var dynamicPolyline = dynamicObject.polyline;
+        if (typeof dynamicPolyline === 'undefined') {
+            return;
+        }
+
+        var vertexPositionsProperty = dynamicObject.vertexPositions;
+        if (typeof vertexPositionsProperty === 'undefined') {
+            return;
+        }
+
+        var polyline;
+        var showProperty = dynamicPolyline.show;
+        var polylineVisualizerIndex = dynamicObject._polylineVisualizerIndex;
+        var show = dynamicObject.isAvailable(time) && (typeof showProperty === 'undefined' || showProperty.getValue(time));
+
+        if (!show) {
+            //don't bother creating or updating anything else
+            if (typeof polylineVisualizerIndex !== 'undefined') {
+                polyline = this._polylineCollection.get(polylineVisualizerIndex);
+                polyline.setShow(false);
+                dynamicObject._polylineVisualizerIndex = undefined;
+                this._unusedIndexes.push(polylineVisualizerIndex);
+            }
+            return;
+        }
+
+        if (typeof polylineVisualizerIndex === 'undefined') {
+            var unusedIndexes = this._unusedIndexes;
+            var length = unusedIndexes.length;
+            if (length > 0) {
+                polylineVisualizerIndex = unusedIndexes.pop();
+                polyline = this._polylineCollection.get(polylineVisualizerIndex);
+            } else {
+                polylineVisualizerIndex = this._polylineCollection.getLength();
+                polyline = this._polylineCollection.add();
+            }
+            dynamicObject._polylineVisualizerIndex = polylineVisualizerIndex;
+            polyline.dynamicObject = dynamicObject;
+
+            // CZML_TODO Determine official defaults
+            polyline.setColor(Color.WHITE);
+            polyline.setOutlineColor(Color.BLACK);
+            polyline.setOutlineWidth(1);
+            polyline.setWidth(1);
+        } else {
+            polyline = this._polylineCollection.get(polylineVisualizerIndex);
+        }
+
+        polyline.setShow(true);
+
+        var vertexPositions = vertexPositionsProperty.getValueCartesian(time);
+        if (typeof vertexPositions !== 'undefined' && polyline._visualizerPositions !== vertexPositions) {
+            polyline.setPositions(vertexPositions);
+            polyline._visualizerPositions = vertexPositions;
+        }
+
+        var property = dynamicPolyline.color;
+        if (typeof property !== 'undefined') {
+            polyline.setColor(property.getValue(time, polyline.getColor()));
+        }
+
+        property = dynamicPolyline.outlineColor;
+        if (typeof property !== 'undefined') {
+            polyline.setOutlineColor(property.getValue(time, polyline.getOutlineColor()));
+        }
+
+        property = dynamicPolyline.outlineWidth;
+        if (typeof property !== 'undefined') {
+            var outlineWidth = property.getValue(time);
+            if (typeof outlineWidth !== 'undefined') {
+                polyline.setOutlineWidth(outlineWidth);
+            }
+        }
+
+        property = dynamicPolyline.width;
+        if (typeof property !== 'undefined') {
+            var width = property.getValue(time);
+            if (typeof width !== 'undefined') {
+                polyline.setWidth(width);
+            }
+        }
+    };
+
+    DynamicPolylineVisualizer.prototype._onObjectsRemoved = function(dynamicObjectCollection, dynamicObjects) {
+        var thisPolylineCollection = this._polylineCollection;
+        var thisUnusedIndexes = this._unusedIndexes;
+        for ( var i = dynamicObjects.length - 1; i > -1; i--) {
+            var dynamicObject = dynamicObjects[i];
+            var polylineVisualizerIndex = dynamicObject._polylineVisualizerIndex;
+            if (typeof polylineVisualizerIndex !== 'undefined') {
+                var polyline = thisPolylineCollection.get(polylineVisualizerIndex);
+                polyline.setShow(false);
+                thisUnusedIndexes.push(polylineVisualizerIndex);
+                dynamicObject._polylineVisualizerIndex = undefined;
+            }
+        }
+    };
+
+    return DynamicPolylineVisualizer;
+});