cesium 0.13.0

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

@@ -0,0 +1,136 @@
+/*global define*/
+define([
+        './DynamicProperty',
+        './CzmlImage',
+        './CzmlNumber',
+        '../Scene/Material'
+    ], function(
+         DynamicProperty,
+         CzmlImage,
+         CzmlNumber,
+         Material) {
+    "use strict";
+
+    /**
+     * A utility class for processing CZML image materials.
+     * @alias DynamicImageMaterial
+     * @constructor
+     */
+    var DynamicImageMaterial = function() {
+        /**
+         * A DynamicProperty of type CzmlNumber which determines the material's image.
+         * @type DynamicProperty
+         */
+        this.image = undefined;
+        /**
+         * A DynamicProperty of type CzmlNumber which determines the material's vertical repeat.
+         * @type DynamicProperty
+         */
+        this.verticalRepeat = undefined;
+        /**
+         * A DynamicProperty of type CzmlNumber which determines the material's horizontal repeat.
+         *
+         * @type DynamicProperty
+         */
+        this.horizontalRepeat = undefined;
+    };
+
+    /**
+     * Returns true if the provided CZML interval contains image material data.
+     * @param czmlInterval The CZML interval to check.
+     * @returns {Boolean} true if the interval contains CZML image material data, false otherwise.
+     */
+    DynamicImageMaterial.isMaterial = function(czmlInterval) {
+        return typeof czmlInterval.image !== 'undefined';
+    };
+
+    /**
+     * Returns true if the provided CZML interval contains image material data.
+     * @param czmlInterval The CZML interval to check.
+     * @returns {Boolean} true if the interval contains CZML image material data, false otherwise.
+     */
+    DynamicImageMaterial.prototype.isMaterial = DynamicImageMaterial.isMaterial;
+
+    /**
+     * Provided a CZML interval containing image material data, processes the
+     * interval into a new or existing instance of this class.
+     *
+     * @param {Object} czmlInterval The interval to process.
+     * @param {String} [sourceUri] The originating url of the CZML being processed.
+     * @returns The modified existingMaterial parameter or a new DynamicImageMaterial instance if existingMaterial was undefined or not a DynamicImageMaterial.
+     */
+    DynamicImageMaterial.prototype.processCzmlIntervals = function(czmlInterval, sourceUri) {
+        var materialData = czmlInterval.image;
+        if (typeof materialData === 'undefined') {
+            return;
+        }
+
+        if (typeof materialData.image !== 'undefined') {
+            var image = this.image;
+            if (typeof image === 'undefined') {
+                this.image = image = new DynamicProperty(CzmlImage);
+            }
+            image.processCzmlIntervals(materialData.image, undefined, sourceUri);
+        }
+
+        if (typeof materialData.verticalRepeat !== 'undefined') {
+            var verticalRepeat = this.verticalRepeat;
+            if (typeof verticalRepeat === 'undefined') {
+                this.verticalRepeat = verticalRepeat = new DynamicProperty(CzmlNumber);
+            }
+            verticalRepeat.processCzmlIntervals(materialData.verticalRepeat);
+        }
+
+        if (typeof materialData.horizontalRepeat !== 'undefined') {
+            var horizontalRepeat = this.horizontalRepeat;
+            if (typeof horizontalRepeat === 'undefined') {
+                this.horizontalRepeat = horizontalRepeat = new DynamicProperty(CzmlNumber);
+            }
+            horizontalRepeat.processCzmlIntervals(materialData.horizontalRepeat);
+        }
+    };
+
+    /**
+     * Gets an Image Material that represents this dynamic material at the provided time.
+     *
+     * @param {JulianDate} time The desired time.
+     * @param {Context} context The context in which this material exists.
+     * @param {Material} [existingMaterial] An existing material to be modified.  If the material is undefined or not an Image Material, a new instance is created.
+     * @returns The modified existingMaterial parameter or a new Image Material instance if existingMaterial was undefined or not a Image Material.
+     */
+    DynamicImageMaterial.prototype.getValue = function(time, context, existingMaterial) {
+        if (typeof existingMaterial === 'undefined' || (existingMaterial.type !== Material.ImageType)) {
+            existingMaterial = Material.fromType(context, Material.ImageType);
+        }
+
+        var xRepeat;
+        var property = this.verticalRepeat;
+        if (typeof property !== 'undefined') {
+            xRepeat = property.getValue(time);
+            if (typeof xRepeat !== 'undefined') {
+                existingMaterial.uniforms.repeat.x = xRepeat;
+            }
+        }
+
+        var yRepeat;
+        property = this.horizontalRepeat;
+        if (typeof property !== 'undefined') {
+            yRepeat = property.getValue(time);
+            if (typeof yRepeat !== 'undefined') {
+                existingMaterial.uniforms.repeat.y = yRepeat;
+            }
+        }
+
+        property = this.image;
+        if (typeof property !== 'undefined') {
+            var url = this.image.getValue(time);
+            if (typeof url !== 'undefined' && existingMaterial.currentUrl !== url) {
+                existingMaterial.currentUrl = url;
+                existingMaterial.uniforms.image = url;
+            }
+        }
+        return existingMaterial;
+    };
+
+    return DynamicImageMaterial;
+});

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

@@ -0,0 +1,286 @@
+/*global define*/
+define([
+        '../Core/TimeInterval',
+        '../Core/defaultValue',
+        './CzmlBoolean',
+        './CzmlCartesian2',
+        './CzmlCartesian3',
+        './CzmlNumber',
+        './CzmlString',
+        './CzmlHorizontalOrigin',
+        './CzmlVerticalOrigin',
+        './CzmlLabelStyle',
+        './CzmlColor',
+        './DynamicProperty'
+       ], function(
+        TimeInterval,
+        defaultValue,
+        CzmlBoolean,
+        CzmlCartesian2,
+        CzmlCartesian3,
+        CzmlNumber,
+        CzmlString,
+        CzmlHorizontalOrigin,
+        CzmlVerticalOrigin,
+        CzmlLabelStyle,
+        CzmlColor,
+        DynamicProperty) {
+    "use strict";
+
+    /**
+     * Represents a time-dynamic label, typically used in conjunction with DynamicLabelVisualizer and
+     * DynamicObjectCollection to visualize CZML.
+     *
+     * @alias DynamicLabel
+     * @constructor
+     *
+     * @see DynamicObject
+     * @see DynamicProperty
+     * @see DynamicObjectCollection
+     * @see DynamicLabelVisualizer
+     * @see VisualizerCollection
+     * @see Label
+     * @see LabelCollection
+     * @see CzmlDefaults
+     */
+    var DynamicLabel = function() {
+        /**
+         * A DynamicProperty of type CzmlString which determines the label's text.
+         * @type DynamicProperty
+         */
+        this.text = undefined;
+        /**
+         * A DynamicProperty of type CzmlString which determines the label's font.
+         * @type DynamicProperty
+         */
+        this.font = undefined;
+        /**
+         * A DynamicProperty of type CzmlLabelStyle which determines the label's style.
+         * @type DynamicProperty
+         */
+        this.style = undefined;
+        /**
+         * A DynamicProperty of type CzmlColor which determines the label's fill color.
+         * @type DynamicProperty
+         */
+        this.fillColor = undefined;
+        /**
+         * A DynamicProperty of type CzmlColor which determines the label's outline color.
+         * @type DynamicProperty
+         */
+        this.outlineColor = undefined;
+        /**
+         * A DynamicProperty of type CzmlHorizontalOrigin which determines the label's horizontal origin.
+         * @type DynamicProperty
+         */
+        this.horizontalOrigin = undefined;
+        /**
+         * A DynamicProperty of type CzmlVerticalOrigin which determines the label's vertical origin.
+         * @type DynamicProperty
+         */
+        this.verticalOrigin = undefined;
+        /**
+         * A DynamicProperty of type CzmlCartesian3 which determines the label's eye offset.
+         * @type DynamicProperty
+         */
+        this.eyeOffset = undefined;
+        /**
+         * A DynamicProperty of type CzmlCartesian2 which determines the label's pixel offset.
+         * @type DynamicProperty
+         */
+        this.pixelOffset = undefined;
+        /**
+         * A DynamicProperty of type CzmlNumber which determines the label's scale.
+         * @type DynamicProperty
+         */
+        this.scale = undefined;
+        /**
+         * A DynamicProperty of type CzmlBoolean which determines the label's visibility.
+         * @type DynamicProperty
+         */
+        this.show = undefined;
+    };
+
+    /**
+     * Processes a single CZML packet and merges its data into the provided DynamicObject's label.
+     * If the DynamicObject does not have a label, 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 label 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
+     */
+    DynamicLabel.processCzmlPacket = function(dynamicObject, packet) {
+        var labelData = packet.label;
+        if (typeof labelData === 'undefined') {
+            return false;
+        }
+
+        var labelUpdated = false;
+        var label = dynamicObject.label;
+        labelUpdated = typeof label === 'undefined';
+        if (labelUpdated) {
+            dynamicObject.label = label = new DynamicLabel();
+        }
+
+        var interval = labelData.interval;
+        if (typeof interval !== 'undefined') {
+            interval = TimeInterval.fromIso8601(interval);
+        }
+
+        if (typeof labelData.fillColor !== 'undefined') {
+            var fillColor = label.fillColor;
+            if (typeof fillColor === 'undefined') {
+                label.fillColor = fillColor = new DynamicProperty(CzmlColor);
+                labelUpdated = true;
+            }
+            fillColor.processCzmlIntervals(labelData.fillColor, interval);
+        }
+
+        if (typeof labelData.outlineColor !== 'undefined') {
+            var outlineColor = label.outlineColor;
+            if (typeof outlineColor === 'undefined') {
+                label.outlineColor = outlineColor = new DynamicProperty(CzmlColor);
+                labelUpdated = true;
+            }
+            outlineColor.processCzmlIntervals(labelData.outlineColor, interval);
+        }
+
+        if (typeof labelData.eyeOffset !== 'undefined') {
+            var eyeOffset = label.eyeOffset;
+            if (typeof eyeOffset === 'undefined') {
+                label.eyeOffset = eyeOffset = new DynamicProperty(CzmlCartesian3);
+                labelUpdated = true;
+            }
+            eyeOffset.processCzmlIntervals(labelData.eyeOffset, interval);
+        }
+
+        if (typeof labelData.horizontalOrigin !== 'undefined') {
+            var horizontalOrigin = label.horizontalOrigin;
+            if (typeof horizontalOrigin === 'undefined') {
+                label.horizontalOrigin = horizontalOrigin = new DynamicProperty(CzmlHorizontalOrigin);
+                labelUpdated = true;
+            }
+            horizontalOrigin.processCzmlIntervals(labelData.horizontalOrigin, interval);
+        }
+
+        if (typeof labelData.text !== 'undefined') {
+            var text = label.text;
+            if (typeof text === 'undefined') {
+                label.text = text = new DynamicProperty(CzmlString);
+                labelUpdated = true;
+            }
+            text.processCzmlIntervals(labelData.text, interval);
+        }
+
+        if (typeof labelData.pixelOffset !== 'undefined') {
+            var pixelOffset = label.pixelOffset;
+            if (typeof pixelOffset === 'undefined') {
+                label.pixelOffset = pixelOffset = new DynamicProperty(CzmlCartesian2);
+                labelUpdated = true;
+            }
+            pixelOffset.processCzmlIntervals(labelData.pixelOffset, interval);
+        }
+
+        if (typeof labelData.scale !== 'undefined') {
+            var scale = label.scale;
+            if (typeof scale === 'undefined') {
+                label.scale = scale = new DynamicProperty(CzmlNumber);
+                labelUpdated = true;
+            }
+            scale.processCzmlIntervals(labelData.scale, interval);
+        }
+
+        if (typeof labelData.show !== 'undefined') {
+            var show = label.show;
+            if (typeof show === 'undefined') {
+                label.show = show = new DynamicProperty(CzmlBoolean);
+                labelUpdated = true;
+            }
+            show.processCzmlIntervals(labelData.show, interval);
+        }
+
+        if (typeof labelData.verticalOrigin !== 'undefined') {
+            var verticalOrigin = label.verticalOrigin;
+            if (typeof verticalOrigin === 'undefined') {
+                label.verticalOrigin = verticalOrigin = new DynamicProperty(CzmlVerticalOrigin);
+                labelUpdated = true;
+            }
+            verticalOrigin.processCzmlIntervals(labelData.verticalOrigin, interval);
+        }
+
+        if (typeof labelData.font !== 'undefined') {
+            var font = label.font;
+            if (typeof font === 'undefined') {
+                label.font = font = new DynamicProperty(CzmlString);
+                labelUpdated = true;
+            }
+            font.processCzmlIntervals(labelData.font, interval);
+        }
+
+        if (typeof labelData.style !== 'undefined') {
+            var style = label.style;
+            if (typeof style === 'undefined') {
+                label.style = style = new DynamicProperty(CzmlLabelStyle);
+                labelUpdated = true;
+            }
+            style.processCzmlIntervals(labelData.style, interval);
+        }
+        return labelUpdated;
+    };
+
+    /**
+     * Given two DynamicObjects, takes the label 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
+     */
+    DynamicLabel.mergeProperties = function(targetObject, objectToMerge) {
+        var labelToMerge = objectToMerge.label;
+        if (typeof labelToMerge !== 'undefined') {
+
+            var targetLabel = targetObject.label;
+            if (typeof targetLabel === 'undefined') {
+                targetObject.label = targetLabel = new DynamicLabel();
+            }
+
+            targetLabel.text = defaultValue(targetLabel.text, labelToMerge.text);
+            targetLabel.font = defaultValue(targetLabel.font, labelToMerge.font);
+            targetLabel.show = defaultValue(targetLabel.show, labelToMerge.show);
+            targetLabel.style = defaultValue(targetLabel.style, labelToMerge.style);
+            targetLabel.fillColor = defaultValue(targetLabel.fillColor, labelToMerge.fillColor);
+            targetLabel.outlineColor = defaultValue(targetLabel.outlineColor, labelToMerge.outlineColor);
+            targetLabel.scale = defaultValue(targetLabel.scale, labelToMerge.scale);
+            targetLabel.horizontalOrigin = defaultValue(targetLabel.horizontalOrigin, labelToMerge.horizontalOrigin);
+            targetLabel.verticalOrigin = defaultValue(targetLabel.verticalOrigin, labelToMerge.verticalOrigin);
+            targetLabel.eyeOffset = defaultValue(targetLabel.eyeOffset, labelToMerge.eyeOffset);
+            targetLabel.pixelOffset = defaultValue(targetLabel.pixelOffset, labelToMerge.pixelOffset);
+        }
+    };
+
+    /**
+     * Given a DynamicObject, undefines the label 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 label from.
+     *
+     * @see CzmlDefaults
+     */
+    DynamicLabel.undefineProperties = function(dynamicObject) {
+        dynamicObject.label = undefined;
+    };
+
+    return DynamicLabel;
+});

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

@@ -0,0 +1,341 @@
+/*global define*/
+define([
+        '../Core/DeveloperError',
+        '../Core/destroyObject',
+        '../Core/Color',
+        '../Core/Cartesian2',
+        '../Core/Cartesian3',
+        '../Scene/LabelCollection',
+        '../Scene/LabelStyle',
+        '../Scene/HorizontalOrigin',
+        '../Scene/VerticalOrigin'
+    ], function(
+        DeveloperError,
+        destroyObject,
+        Color,
+        Cartesian2,
+        Cartesian3,
+        LabelCollection,
+        LabelStyle,
+        HorizontalOrigin,
+        VerticalOrigin) {
+    "use strict";
+
+    /**
+     * A DynamicObject visualizer which maps the DynamicLabel instance
+     * in DynamicObject.label to a Label primitive.
+     * @alias DynamicLabelVisualizer
+     * @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 DynamicLabel
+     * @see Scene
+     * @see DynamicObject
+     * @see DynamicObjectCollection
+     * @see CompositeDynamicObjectCollection
+     * @see VisualizerCollection
+     * @see DynamicBillboardVisualizer
+     * @see DynamicConeVisualizer
+     * @see DynamicConeVisualizerUsingCustomSensorr
+     * @see DynamicPointVisualizer
+     * @see DynamicPolygonVisualizer
+     * @see DynamicPolylineVisualizer
+     * @see DynamicPyramidVisualizer
+     *
+     */
+    var DynamicLabelVisualizer = function(scene, dynamicObjectCollection) {
+        if (typeof scene === 'undefined') {
+            throw new DeveloperError('scene is required.');
+        }
+        this._scene = scene;
+        this._unusedIndexes = [];
+        this._dynamicObjectCollection = undefined;
+
+        var labelCollection = this._labelCollection = new LabelCollection();
+        scene.getPrimitives().add(labelCollection);
+        this.setDynamicObjectCollection(dynamicObjectCollection);
+    };
+
+    /**
+     * Returns the scene being used by this visualizer.
+     *
+     * @returns {Scene} The scene being used by this visualizer.
+     */
+    DynamicLabelVisualizer.prototype.getScene = function() {
+        return this._scene;
+    };
+
+    /**
+     * Gets the DynamicObjectCollection being visualized.
+     *
+     * @returns {DynamicObjectCollection} The DynamicObjectCollection being visualized.
+     */
+    DynamicLabelVisualizer.prototype.getDynamicObjectCollection = function() {
+        return this._dynamicObjectCollection;
+    };
+
+    /**
+     * Sets the DynamicObjectCollection to visualize.
+     *
+     * @param dynamicObjectCollection The DynamicObjectCollection to visualizer.
+     */
+    DynamicLabelVisualizer.prototype.setDynamicObjectCollection = function(dynamicObjectCollection) {
+        var oldCollection = this._dynamicObjectCollection;
+        if (oldCollection !== dynamicObjectCollection) {
+            if (typeof oldCollection !== 'undefined') {
+                oldCollection.objectsRemoved.removeEventListener(DynamicLabelVisualizer.prototype._onObjectsRemoved);
+                this.removeAllPrimitives();
+            }
+            this._dynamicObjectCollection = dynamicObjectCollection;
+            if (typeof dynamicObjectCollection !== 'undefined') {
+                dynamicObjectCollection.objectsRemoved.addEventListener(DynamicLabelVisualizer.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.
+     */
+    DynamicLabelVisualizer.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.
+     */
+    DynamicLabelVisualizer.prototype.removeAllPrimitives = function() {
+        this._unusedIndexes = [];
+        this._labelCollection.removeAll();
+        if (typeof this._dynamicObjectCollection !== 'undefined') {
+            var dynamicObjects = this._dynamicObjectCollection.getObjects();
+            for ( var i = dynamicObjects.length - 1; i > -1; i--) {
+                dynamicObjects[i]._labelVisualizerIndex = undefined;
+            }
+        }
+    };
+
+    /**
+     * 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 DynamicLabelVisualizer
+     *
+     * @return {Boolean} True if this object was destroyed; otherwise, false.
+     *
+     * @see DynamicLabelVisualizer#destroy
+     */
+    DynamicLabelVisualizer.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 DynamicLabelVisualizer
+     *
+     * @return {undefined}
+     *
+     * @exception {DeveloperError} This object was destroyed, i.e., destroy() was called.
+     *
+     * @see DynamicLabelVisualizer#isDestroyed
+     *
+     * @example
+     * visualizer = visualizer && visualizer.destroy();
+     */
+    DynamicLabelVisualizer.prototype.destroy = function() {
+        this.removeAllPrimitives();
+        this._scene.getPrimitives().remove(this._labelCollection);
+        return destroyObject(this);
+    };
+
+    var position;
+    var fillColor;
+    var outlineColor;
+    var eyeOffset;
+    var pixelOffset;
+    DynamicLabelVisualizer.prototype._updateObject = function(time, dynamicObject) {
+        var dynamicLabel = dynamicObject.label;
+        if (typeof dynamicLabel === 'undefined') {
+            return;
+        }
+
+        var textProperty = dynamicLabel.text;
+        if (typeof textProperty === 'undefined') {
+            return;
+        }
+
+        var positionProperty = dynamicObject.position;
+        if (typeof positionProperty === 'undefined') {
+            return;
+        }
+
+        var label;
+        var showProperty = dynamicLabel.show;
+        var labelVisualizerIndex = dynamicObject._labelVisualizerIndex;
+        var show = dynamicObject.isAvailable(time) && (typeof showProperty === 'undefined' || showProperty.getValue(time));
+
+        if (!show) {
+            //don't bother creating or updating anything else
+            if (typeof labelVisualizerIndex !== 'undefined') {
+                label = this._labelCollection.get(labelVisualizerIndex);
+                label.setShow(false);
+                this._unusedIndexes.push(labelVisualizerIndex);
+                dynamicObject._labelVisualizerIndex = undefined;
+            }
+            return;
+        }
+
+        if (typeof labelVisualizerIndex === 'undefined') {
+            var unusedIndexes = this._unusedIndexes;
+            var length = unusedIndexes.length;
+            if (length > 0) {
+                labelVisualizerIndex = unusedIndexes.pop();
+                label = this._labelCollection.get(labelVisualizerIndex);
+            } else {
+                labelVisualizerIndex = this._labelCollection.getLength();
+                label = this._labelCollection.add();
+            }
+            dynamicObject._labelVisualizerIndex = labelVisualizerIndex;
+            label.dynamicObject = dynamicObject;
+
+            // CZML_TODO Determine official defaults
+            label.setText('');
+            label.setScale(1.0);
+            label.setFont('30px sans-serif');
+            label.setFillColor(Color.WHITE);
+            label.setOutlineColor(Color.BLACK);
+            label.setStyle(LabelStyle.FILL);
+            label.setPixelOffset(Cartesian2.ZERO);
+            label.setEyeOffset(Cartesian3.ZERO);
+            label.setHorizontalOrigin(HorizontalOrigin.CENTER);
+            label.setVerticalOrigin(VerticalOrigin.CENTER);
+        } else {
+            label = this._labelCollection.get(labelVisualizerIndex);
+        }
+
+        label.setShow(show);
+
+        var text = textProperty.getValue(time);
+        if (typeof text !== 'undefined') {
+            label.setText(text);
+        }
+
+        position = positionProperty.getValueCartesian(time, position);
+        if (typeof position !== 'undefined') {
+            label.setPosition(position);
+        }
+
+        var property = dynamicLabel.scale;
+        if (typeof property !== 'undefined') {
+            var scale = property.getValue(time);
+            if (typeof scale !== 'undefined') {
+                label.setScale(scale);
+            }
+        }
+
+        property = dynamicLabel.font;
+        if (typeof property !== 'undefined') {
+            var font = property.getValue(time);
+            if (typeof font !== 'undefined') {
+                label.setFont(font);
+            }
+        }
+
+        property = dynamicLabel.fillColor;
+        if (typeof property !== 'undefined') {
+            fillColor = property.getValue(time, fillColor);
+            if (typeof fillColor !== 'undefined') {
+                label.setFillColor(fillColor);
+            }
+        }
+
+        property = dynamicLabel.outlineColor;
+        if (typeof property !== 'undefined') {
+            outlineColor = property.getValue(time, outlineColor);
+            if (typeof outlineColor !== 'undefined') {
+                label.setOutlineColor(outlineColor);
+            }
+        }
+
+        property = dynamicLabel.style;
+        if (typeof property !== 'undefined') {
+            var style = property.getValue(time);
+            if (typeof style !== 'undefined') {
+                label.setStyle(style);
+            }
+        }
+
+        property = dynamicLabel.pixelOffset;
+        if (typeof property !== 'undefined') {
+            pixelOffset = property.getValue(time, pixelOffset);
+            if (typeof pixelOffset !== 'undefined') {
+                label.setPixelOffset(pixelOffset);
+            }
+        }
+
+        property = dynamicLabel.eyeOffset;
+        if (typeof property !== 'undefined') {
+            eyeOffset = property.getValue(time, eyeOffset);
+            if (typeof eyeOffset !== 'undefined') {
+                label.setEyeOffset(eyeOffset);
+            }
+        }
+
+        property = dynamicLabel.horizontalOrigin;
+        if (typeof property !== 'undefined') {
+            var horizontalOrigin = property.getValue(time);
+            if (typeof horizontalOrigin !== 'undefined') {
+                label.setHorizontalOrigin(horizontalOrigin);
+            }
+        }
+
+        property = dynamicLabel.verticalOrigin;
+        if (typeof property !== 'undefined') {
+            var verticalOrigin = property.getValue(time);
+            if (typeof verticalOrigin !== 'undefined') {
+                label.setVerticalOrigin(verticalOrigin);
+            }
+        }
+    };
+
+    DynamicLabelVisualizer.prototype._onObjectsRemoved = function(dynamicObjectCollection, dynamicObjects) {
+        var thisLabelCollection = this._labelCollection;
+        var thisUnusedIndexes = this._unusedIndexes;
+        for ( var i = dynamicObjects.length - 1; i > -1; i--) {
+            var dynamicObject = dynamicObjects[i];
+            var labelVisualizerIndex = dynamicObject._labelVisualizerIndex;
+            if (typeof labelVisualizerIndex !== 'undefined') {
+                var label = thisLabelCollection.get(labelVisualizerIndex);
+                label.setShow(false);
+                thisUnusedIndexes.push(labelVisualizerIndex);
+                dynamicObject._labelVisualizerIndex = undefined;
+            }
+        }
+    };
+
+    return DynamicLabelVisualizer;
+});