cesium 0.16.0 → 0.17.0

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

@@ -106,7 +106,7 @@ define([
         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]);
+                updateObject(this, time, dynamicObjects[i]);
             }
         }
     };
@@ -170,7 +170,7 @@ define([
     };
 
     var cachedPosition = new Cartesian3();
-    DynamicPolylineVisualizer.prototype._updateObject = function(time, dynamicObject) {
+    function updateObject(dynamicPolylineVisualizer, time, dynamicObject) {
         var dynamicPolyline = dynamicObject.polyline;
         if (typeof dynamicPolyline === 'undefined') {
             return;
@@ -189,24 +189,24 @@ define([
            (typeof ellipseProperty === 'undefined' || typeof positionProperty === 'undefined'))) {
             //Remove the existing primitive if we have one
             if (typeof polylineVisualizerIndex !== 'undefined') {
-                polyline = this._polylineCollection.get(polylineVisualizerIndex);
+                polyline = dynamicPolylineVisualizer._polylineCollection.get(polylineVisualizerIndex);
                 polyline.setShow(false);
                 dynamicObject._polylineVisualizerIndex = undefined;
-                this._unusedIndexes.push(polylineVisualizerIndex);
+                dynamicPolylineVisualizer._unusedIndexes.push(polylineVisualizerIndex);
             }
             return;
         }
 
         var uniforms;
         if (typeof polylineVisualizerIndex === 'undefined') {
-            var unusedIndexes = this._unusedIndexes;
+            var unusedIndexes = dynamicPolylineVisualizer._unusedIndexes;
             var length = unusedIndexes.length;
             if (length > 0) {
                 polylineVisualizerIndex = unusedIndexes.pop();
-                polyline = this._polylineCollection.get(polylineVisualizerIndex);
+                polyline = dynamicPolylineVisualizer._polylineCollection.get(polylineVisualizerIndex);
             } else {
-                polylineVisualizerIndex = this._polylineCollection.getLength();
-                polyline = this._polylineCollection.add();
+                polylineVisualizerIndex = dynamicPolylineVisualizer._polylineCollection.getLength();
+                polyline = dynamicPolylineVisualizer._polylineCollection.add();
             }
             dynamicObject._polylineVisualizerIndex = polylineVisualizerIndex;
             polyline.dynamicObject = dynamicObject;
@@ -215,7 +215,7 @@ define([
             polyline.setWidth(1);
             var material = polyline.getMaterial();
             if (typeof material === 'undefined' || (material.type !== Material.PolylineOutlineType)) {
-                material = Material.fromType(this._scene.getContext(), Material.PolylineOutlineType);
+                material = Material.fromType(dynamicPolylineVisualizer._scene.getContext(), Material.PolylineOutlineType);
                 polyline.setMaterial(material);
             }
             uniforms = material.uniforms;
@@ -223,7 +223,7 @@ define([
             Color.clone(Color.BLACK, uniforms.outlineColor);
             uniforms.outlineWidth = 0;
         } else {
-            polyline = this._polylineCollection.get(polylineVisualizerIndex);
+            polyline = dynamicPolylineVisualizer._polylineCollection.get(polylineVisualizerIndex);
             uniforms = polyline.getMaterial().uniforms;
         }
 
@@ -253,7 +253,7 @@ define([
 
         property = dynamicPolyline.outlineWidth;
         if (typeof property !== 'undefined') {
-            uniforms.outlineWidth = property.getValue(time, uniforms.outlineWidth);
+            uniforms.outlineWidth = property.getValue(time);
         }
 
         property = dynamicPolyline.width;
@@ -263,7 +263,7 @@ define([
                 polyline.setWidth(width);
             }
         }
-    };
+    }
 
     DynamicPolylineVisualizer.prototype._onObjectsRemoved = function(dynamicObjectCollection, dynamicObjects) {
         var thisPolylineCollection = this._polylineCollection;

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

@@ -1,7 +1,5 @@
 /*global define*/
 define([
-        '../Core/Cartesian3',
-        '../Core/Cartographic',
         '../Core/DeveloperError',
         '../Core/Ellipsoid',
         '../Core/Iso8601',
@@ -14,8 +12,6 @@ define([
         './CzmlPosition',
         './DynamicProperty'
     ], function(
-        Cartesian3,
-        Cartographic,
         DeveloperError,
         Ellipsoid,
         Iso8601,

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

@@ -111,7 +111,7 @@ define([
         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]);
+                updateObject(this, time, dynamicObjects[i]);
             }
         }
     };
@@ -178,8 +178,8 @@ define([
 
     var position;
     var orientation;
-    DynamicPyramidVisualizer.prototype._updateObject = function(time, dynamicObject) {
-        var context = this._scene.getContext();
+    function updateObject(dynamicPyramidVisualizer, time, dynamicObject) {
+        var context = dynamicPyramidVisualizer._scene.getContext();
         var dynamicPyramid = dynamicObject.pyramid;
         if (typeof dynamicPyramid === 'undefined') {
             return;
@@ -208,26 +208,26 @@ define([
         if (!show) {
             //don't bother creating or updating anything else
             if (typeof pyramidVisualizerIndex !== 'undefined') {
-                pyramid = this._pyramidCollection[pyramidVisualizerIndex];
+                pyramid = dynamicPyramidVisualizer._pyramidCollection[pyramidVisualizerIndex];
                 pyramid.show = false;
                 dynamicObject._pyramidVisualizerIndex = undefined;
-                this._unusedIndexes.push(pyramidVisualizerIndex);
+                dynamicPyramidVisualizer._unusedIndexes.push(pyramidVisualizerIndex);
             }
             return;
         }
 
         if (typeof pyramidVisualizerIndex === 'undefined') {
-            var unusedIndexes = this._unusedIndexes;
+            var unusedIndexes = dynamicPyramidVisualizer._unusedIndexes;
             var length = unusedIndexes.length;
             if (length > 0) {
                 pyramidVisualizerIndex = unusedIndexes.pop();
-                pyramid = this._pyramidCollection[pyramidVisualizerIndex];
+                pyramid = dynamicPyramidVisualizer._pyramidCollection[pyramidVisualizerIndex];
             } else {
-                pyramidVisualizerIndex = this._pyramidCollection.length;
+                pyramidVisualizerIndex = dynamicPyramidVisualizer._pyramidCollection.length;
                 pyramid = new CustomSensorVolume();
 
-                this._pyramidCollection.push(pyramid);
-                this._primitives.add(pyramid);
+                dynamicPyramidVisualizer._pyramidCollection.push(pyramid);
+                dynamicPyramidVisualizer._primitives.add(pyramid);
             }
             dynamicObject._pyramidVisualizerIndex = pyramidVisualizerIndex;
             pyramid.dynamicObject = dynamicObject;
@@ -238,7 +238,7 @@ define([
             pyramid.intersectionColor = Color.YELLOW;
             pyramid.material = Material.fromType(context, Material.ColorType);
         } else {
-            pyramid = this._pyramidCollection[pyramidVisualizerIndex];
+            pyramid = dynamicPyramidVisualizer._pyramidCollection[pyramidVisualizerIndex];
         }
 
         pyramid.show = true;
@@ -281,7 +281,7 @@ define([
                 pyramid.radius = radius;
             }
         }
-    };
+    }
 
     DynamicPyramidVisualizer.prototype._onObjectsRemoved = function(dynamicObjectCollection, dynamicObjects) {
         var thisPyramidCollection = this._pyramidCollection;

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

@@ -0,0 +1,184 @@
+/*global define*/
+define([
+        '../Core/TimeInterval',
+        '../Core/defaultValue',
+        './CzmlBoolean',
+        './CzmlDirection',
+        './CzmlNumber',
+        './CzmlColor',
+        './DynamicProperty'],
+function(
+        TimeInterval,
+        defaultValue,
+        CzmlBoolean,
+        CzmlDirection,
+        CzmlNumber,
+        CzmlColor,
+        DynamicProperty) {
+    "use strict";
+
+    /**
+     * Represents a time-dynamic vector, typically used in conjunction with DynamicVectorVisualizer and
+     * DynamicObjectCollection to visualize CZML.
+     *
+     * @alias DynamicVector
+     * @constructor
+     *
+     * @see DynamicObject
+     * @see DynamicProperty
+     * @see DynamicObjectCollection
+     * @see DynamicVectorVisualizer
+     * @see VisualizerCollection
+     * @see CzmlDefaults
+     */
+    var DynamicVector = function() {
+        /**
+         * A DynamicProperty of type CzmlColor which determines the vector's color.
+         * @type DynamicProperty
+         */
+        this.color = undefined;
+        /**
+         * A DynamicProperty of type CzmlBoolean which determines the vector's visibility.
+         * @type DynamicProperty
+         */
+        this.show = undefined;
+        /**
+         * A DynamicProperty of type CzmlNumber which determines the vector's width.
+         * @type DynamicProperty
+         */
+        this.width = undefined;
+        /**
+         * A DynamicProperty of type CzmlDirection which determines the vector's direction.
+         * @type DynamicProperty
+         */
+        this.direction = undefined;
+        /**
+         * A DynamicProperty of type CzmlNumber which determines the vector's graphical length.
+         * @type DynamicProperty
+         */
+        this.length = undefined;
+    };
+
+    /**
+     * Processes a single CZML packet and merges its data into the provided DynamicObject's vector.
+     * If the DynamicObject does not have a vector, 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 vector 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
+     */
+    DynamicVector.processCzmlPacket = function(dynamicObject, packet) {
+        var vectorData = packet.vector;
+        if (typeof vectorData === 'undefined') {
+            return false;
+        }
+
+        var vectorUpdated = false;
+        var vector = dynamicObject.vector;
+        vectorUpdated = typeof vector === 'undefined';
+        if (vectorUpdated) {
+            dynamicObject.vector = vector = new DynamicVector();
+        }
+
+        var interval = vectorData.interval;
+        if (typeof interval !== 'undefined') {
+            interval = TimeInterval.fromIso8601(interval);
+        }
+
+        if (typeof vectorData.color !== 'undefined') {
+            var color = vector.color;
+            if (typeof color === 'undefined') {
+                vector.color = color = new DynamicProperty(CzmlColor);
+                vectorUpdated = true;
+            }
+            color.processCzmlIntervals(vectorData.color, interval);
+        }
+
+        if (typeof vectorData.width !== 'undefined') {
+            var width = vector.width;
+            if (typeof width === 'undefined') {
+                vector.width = width = new DynamicProperty(CzmlNumber);
+                vectorUpdated = true;
+            }
+            width.processCzmlIntervals(vectorData.width, interval);
+        }
+
+        if (typeof vectorData.direction !== 'undefined') {
+            var direction = vector.direction;
+            if (typeof direction === 'undefined') {
+                vector.direction = direction = new DynamicProperty(CzmlDirection);
+                vectorUpdated = true;
+            }
+            direction.processCzmlIntervals(vectorData.direction, interval);
+        }
+
+        if (typeof vectorData.length !== 'undefined') {
+            var length = vector.length;
+            if (typeof length === 'undefined') {
+                vector.length = length = new DynamicProperty(CzmlNumber);
+                vectorUpdated = true;
+            }
+            length.processCzmlIntervals(vectorData.length, interval);
+        }
+
+        if (typeof vectorData.show !== 'undefined') {
+            var show = vector.show;
+            if (typeof show === 'undefined') {
+                vector.show = show = new DynamicProperty(CzmlBoolean);
+                vectorUpdated = true;
+            }
+            show.processCzmlIntervals(vectorData.show, interval);
+        }
+        return vectorUpdated;
+    };
+
+    /**
+     * Given two DynamicObjects, takes the vector 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
+     */
+    DynamicVector.mergeProperties = function(targetObject, objectToMerge) {
+        var vectorToMerge = objectToMerge.vector;
+        if (typeof vectorToMerge !== 'undefined') {
+
+            var targetVector = targetObject.vector;
+            if (typeof targetVector === 'undefined') {
+                targetObject.vector = targetVector = new DynamicVector();
+            }
+
+            targetVector.color = defaultValue(targetVector.color, vectorToMerge.color);
+            targetVector.width = defaultValue(targetVector.width, vectorToMerge.width);
+            targetVector.direction = defaultValue(targetVector.direction, vectorToMerge.direction);
+            targetVector.length = defaultValue(targetVector.length, vectorToMerge.length);
+            targetVector.show = defaultValue(targetVector.show, vectorToMerge.show);
+        }
+    };
+
+    /**
+     * Given a DynamicObject, undefines the vector 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 vector from.
+     *
+     * @see CzmlDefaults
+     */
+    DynamicVector.undefineProperties = function(dynamicObject) {
+        dynamicObject.vector = undefined;
+    };
+
+    return DynamicVector;
+});

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

@@ -0,0 +1,267 @@
+/*global define*/
+define([
+        '../Core/DeveloperError',
+        '../Core/destroyObject',
+        '../Core/Cartesian3',
+        '../Core/Color',
+        '../Scene/Material',
+        '../Scene/PolylineCollection'
+       ], function(
+         DeveloperError,
+         destroyObject,
+         Cartesian3,
+         Color,
+         Material,
+         PolylineCollection) {
+    "use strict";
+
+    /**
+     * A DynamicObject visualizer which maps the DynamicPolyline instance
+     * in DynamicObject.vector to a Polyline primitive.
+     * @alias DynamicVectorVisualizer
+     * @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 DynamicVectorVisualizer = 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.
+     */
+    DynamicVectorVisualizer.prototype.getScene = function() {
+        return this._scene;
+    };
+
+    /**
+     * Gets the DynamicObjectCollection being visualized.
+     *
+     * @returns {DynamicObjectCollection} The DynamicObjectCollection being visualized.
+     */
+    DynamicVectorVisualizer.prototype.getDynamicObjectCollection = function() {
+        return this._dynamicObjectCollection;
+    };
+
+    /**
+     * Sets the DynamicObjectCollection to visualize.
+     *
+     * @param dynamicObjectCollection The DynamicObjectCollection to visualizer.
+     */
+    DynamicVectorVisualizer.prototype.setDynamicObjectCollection = function(dynamicObjectCollection) {
+        var oldCollection = this._dynamicObjectCollection;
+        if (oldCollection !== dynamicObjectCollection) {
+            if (typeof oldCollection !== 'undefined') {
+                oldCollection.objectsRemoved.removeEventListener(DynamicVectorVisualizer.prototype._onObjectsRemoved, this);
+                this.removeAllPrimitives();
+            }
+            this._dynamicObjectCollection = dynamicObjectCollection;
+            if (typeof dynamicObjectCollection !== 'undefined') {
+                dynamicObjectCollection.objectsRemoved.addEventListener(DynamicVectorVisualizer.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.
+     */
+    DynamicVectorVisualizer.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++) {
+                updateObject(this, time, dynamicObjects[i]);
+            }
+        }
+    };
+
+    /**
+     * Removes all primitives from the scene.
+     */
+    DynamicVectorVisualizer.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]._vectorVisualizerIndex = 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 DynamicVectorVisualizer
+     *
+     * @return {Boolean} True if this object was destroyed; otherwise, false.
+     *
+     * @see DynamicVectorVisualizer#destroy
+     */
+    DynamicVectorVisualizer.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 DynamicVectorVisualizer
+     *
+     * @return {undefined}
+     *
+     * @exception {DeveloperError} This object was destroyed, i.e., destroy() was called.
+     *
+     * @see DynamicVectorVisualizer#isDestroyed
+     *
+     * @example
+     * visualizer = visualizer && visualizer.destroy();
+     */
+    DynamicVectorVisualizer.prototype.destroy = function() {
+        this.removeAllPrimitives();
+        this._scene.getPrimitives().remove(this._polylineCollection);
+        return destroyObject(this);
+    };
+
+    function updateObject(dynamicVectorVisualizer, time, dynamicObject) {
+        var dynamicVector = dynamicObject.vector;
+        if (typeof dynamicVector === 'undefined') {
+            return;
+        }
+
+        var polyline;
+        var showProperty = dynamicVector.show;
+        var positionProperty = dynamicObject.position;
+        var directionProperty = dynamicVector.direction;
+        var lengthProperty = dynamicVector.length;
+        var vectorVisualizerIndex = dynamicObject._vectorVisualizerIndex;
+        var show = dynamicObject.isAvailable(time) && (typeof showProperty === 'undefined' || showProperty.getValue(time));
+
+        if (!show || //
+           (typeof directionProperty === 'undefined' || typeof positionProperty === 'undefined' || typeof lengthProperty === 'undefined')) {
+            //Remove the existing primitive if we have one
+            if (typeof vectorVisualizerIndex !== 'undefined') {
+                polyline = dynamicVectorVisualizer._polylineCollection.get(vectorVisualizerIndex);
+                polyline.setShow(false);
+                dynamicObject._vectorVisualizerIndex = undefined;
+                dynamicVectorVisualizer._unusedIndexes.push(vectorVisualizerIndex);
+            }
+            return;
+        }
+
+        var uniforms;
+        if (typeof vectorVisualizerIndex === 'undefined') {
+            var unusedIndexes = dynamicVectorVisualizer._unusedIndexes;
+            if (unusedIndexes.length > 0) {
+                vectorVisualizerIndex = unusedIndexes.pop();
+                polyline = dynamicVectorVisualizer._polylineCollection.get(vectorVisualizerIndex);
+            } else {
+                vectorVisualizerIndex = dynamicVectorVisualizer._polylineCollection.getLength();
+                polyline = dynamicVectorVisualizer._polylineCollection.add();
+                polyline._visualizerPositions = [new Cartesian3(), new Cartesian3()];
+            }
+            dynamicObject._vectorVisualizerIndex = vectorVisualizerIndex;
+            polyline.dynamicObject = dynamicObject;
+
+            // CZML_TODO Determine official defaults
+            polyline.setWidth(1);
+            var material = polyline.getMaterial();
+            if (typeof material === 'undefined' || (material.type !== Material.PolylineArrowType)) {
+                material = Material.fromType(dynamicVectorVisualizer._scene.getContext(), Material.PolylineArrowType);
+                polyline.setMaterial(material);
+            }
+            uniforms = material.uniforms;
+            Color.clone(Color.WHITE, uniforms.color);
+        } else {
+            polyline = dynamicVectorVisualizer._polylineCollection.get(vectorVisualizerIndex);
+            uniforms = polyline.getMaterial().uniforms;
+        }
+
+        polyline.setShow(true);
+
+        var positions = polyline._visualizerPositions;
+        var position = positionProperty.getValueCartesian(time, positions[0]);
+        var direction = directionProperty.getValue(time, positions[1]);
+        var length = lengthProperty.getValue(time);
+        if (typeof position !== 'undefined' && typeof direction !== 'undefined' && typeof length !== 'undefined') {
+            Cartesian3.add(position, direction.normalize(direction).multiplyByScalar(length, direction), direction);
+            polyline.setPositions(positions);
+        }
+
+        var property = dynamicVector.color;
+        if (typeof property !== 'undefined') {
+            uniforms.color = property.getValue(time, uniforms.color);
+        }
+
+        property = dynamicVector.width;
+        if (typeof property !== 'undefined') {
+            var width = property.getValue(time);
+            if (typeof width !== 'undefined') {
+                polyline.setWidth(width);
+            }
+        }
+    }
+
+    DynamicVectorVisualizer.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 vectorVisualizerIndex = dynamicObject._vectorVisualizerIndex;
+            if (typeof vectorVisualizerIndex !== 'undefined') {
+                var polyline = thisPolylineCollection.get(vectorVisualizerIndex);
+                polyline.setShow(false);
+                thisUnusedIndexes.push(vectorVisualizerIndex);
+                dynamicObject._vectorVisualizerIndex = undefined;
+            }
+        }
+    };
+
+    return DynamicVectorVisualizer;
+});