cesium 0.21 → 0.21.1

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

@@ -127,9 +127,9 @@ define(['Core/Cartesian3', 'Core/defaultValue', 'Core/defined', 'Core/DeveloperE
             w = 0.5 * root;
             root = 0.5 / root; // 1/(4w)
 
-            x = (matrix[Matrix3.COLUMN2ROW1] - matrix[Matrix3.COLUMN1ROW2]) * root;
-            y = (matrix[Matrix3.COLUMN0ROW2] - matrix[Matrix3.COLUMN2ROW0]) * root;
-            z = (matrix[Matrix3.COLUMN1ROW0] - matrix[Matrix3.COLUMN0ROW1]) * root;
+            x = (matrix[Matrix3.COLUMN1ROW2] - matrix[Matrix3.COLUMN2ROW1]) * root;
+            y = (matrix[Matrix3.COLUMN2ROW0] - matrix[Matrix3.COLUMN0ROW2]) * root;
+            z = (matrix[Matrix3.COLUMN0ROW1] - matrix[Matrix3.COLUMN1ROW0]) * root;
         } else {
             // |w| <= 1/2
             var next = fromRotationMatrixNext;
@@ -153,9 +153,9 @@ define(['Core/Cartesian3', 'Core/defaultValue', 'Core/defined', 'Core/DeveloperE
             quat[j] = (matrix[Matrix3.getElementIndex(j, i)] + matrix[Matrix3.getElementIndex(i, j)]) * root;
             quat[k] = (matrix[Matrix3.getElementIndex(k, i)] + matrix[Matrix3.getElementIndex(i, k)]) * root;
 
-            x = quat[0];
-            y = quat[1];
-            z = quat[2];
+            x = -quat[0];
+            y = -quat[1];
+            z = -quat[2];
         }
 
         if (!defined(result)) {
@@ -291,9 +291,7 @@ define(['Core/Cartesian3', 'Core/defaultValue', 'Core/defined', 'Core/DeveloperE
         if (!defined(result)) {
             result = new Quaternion();
         }
-        sampledQuaternionRotation.x = array[0];
-        sampledQuaternionRotation.y = array[1];
-        sampledQuaternionRotation.z = array[2];
+        Cartesian3.fromArray(array, 0, sampledQuaternionRotation);
         var magnitude = Cartesian3.magnitude(sampledQuaternionRotation);
 
         Quaternion.unpack(sourceArray, lastIndex * 4, sampledQuaternionQuaternion0);
@@ -304,7 +302,8 @@ define(['Core/Cartesian3', 'Core/defaultValue', 'Core/defined', 'Core/DeveloperE
             Quaternion.fromAxisAngle(sampledQuaternionRotation, magnitude, sampledQuaternionTempQuaternion);
         }
 
-        return Quaternion.multiply(sampledQuaternionTempQuaternion, sampledQuaternionQuaternion0, result);
+        Quaternion.multiply(sampledQuaternionTempQuaternion, sampledQuaternionQuaternion0, result);
+        return Quaternion.conjugate(result, result);
     };
 
     /**
@@ -839,6 +838,34 @@ define(['Core/Cartesian3', 'Core/defaultValue', 'Core/defined', 'Core/DeveloperE
         return Quaternion.clone(this, result);
     };
 
+    /**
+     * Compares this and the provided quaternion componentwise and returns
+     * <code>true</code> if they are equal, <code>false</code> otherwise.
+     * @memberof Quaternion
+     *
+     * @param {Quaternion} [right] The right hand side quaternion.
+     * @returns {Boolean} <code>true</code> if left and right are equal, <code>false</code> otherwise.
+     */
+    Quaternion.prototype.equals = function(right) {
+        return Quaternion.equals(this, right);
+    };
+
+    /**
+     * Compares this and the provided quaternion componentwise and returns
+     * <code>true</code> if they are within the provided epsilon,
+     * <code>false</code> otherwise.
+     * @memberof Quaternion
+     *
+     * @param {Quaternion} [right] The right hand side quaternion.
+     * @param {Number} epsilon The epsilon to use for equality testing.
+     * @returns {Boolean} <code>true</code> if left and right are within the provided epsilon, <code>false</code> otherwise.
+     *
+     * @exception {DeveloperError} epsilon is required and must be a number.
+     */
+    Quaternion.prototype.equalsEpsilon = function(right, epsilon) {
+        return Quaternion.equalsEpsilon(this, right, epsilon);
+    };
+
     /**
      * Returns a string representing this quaternion in the format (x, y, z, w).
      * @memberof Quaternion

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

@@ -1,9 +1,10 @@
 /*global define*/
-define(['Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'Core/Math', 'Core/Cartesian3', 'Core/Quaternion', 'Core/Matrix3'], function(
+define(['Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'Core/Math', 'Core/Cartesian2', 'Core/Cartesian3', 'Core/Quaternion', 'Core/Matrix3'], function(
         defaultValue,
         defined,
         DeveloperError,
         CesiumMath,
+        Cartesian2,
         Cartesian3,
         Quaternion,
         Matrix3) {
@@ -49,7 +50,7 @@ define(['Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'Core/Math',
             var unitQuat = Quaternion.normalize(new Quaternion(rotAxis.x * temp, rotAxis.y * temp, rotAxis.z * temp, Math.cos(angle / 2.0)));
             var rotMtx = Matrix3.fromQuaternion(unitQuat);
 
-            var tmpEllipsePts = rotMtx.multiplyByVector(unitPos);
+            var tmpEllipsePts = Matrix3.multiplyByVector(rotMtx, unitPos);
             var unitCart = Cartesian3.normalize(tmpEllipsePts);
             tmpEllipsePts = Cartesian3.multiplyByScalar(unitCart, cbRadius);
             ellipsePts[ellipsePtsIndex] = tmpEllipsePts;
@@ -219,6 +220,29 @@ define(['Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'Core/Math',
             ellipsePts.push(Cartesian3.clone(ellipsePts[0])); // Duplicates first and last point for polyline
 
             return ellipsePts;
+        },
+
+        /**
+         * Computes a 2D circle about the origin.
+         *
+         * @param {Number} [radius = 1.0] The radius of the circle
+         * @param {Number} [granularity = Cesium.RADIANS_PER_DEGREE*2] The radius of the circle
+         *
+         * @returns The set of points that form the ellipse's boundary.
+         *
+         * @example
+         * var circle = Shapes.compute2DCircle(100000.0);
+         */
+        compute2DCircle : function(radius, granularity) {
+            radius = defaultValue(radius, 1.0);
+            granularity = defaultValue(granularity, CesiumMath.RADIANS_PER_DEGREE*2);
+            var positions = [];
+            var theta = CesiumMath.toRadians(1.0);
+            var posCount = Math.PI*2/theta;
+            for (var i = 0; i < posCount; i++) {
+                positions.push(new Cartesian2(radius * Math.cos(theta * i), radius * Math.sin(theta * i)));
+            }
+            return positions;
         }
     };
 

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

@@ -100,7 +100,7 @@ define(['Core/Cartesian3', 'Core/defined', 'Core/DeveloperError', 'Core/JulianDa
             result.z = 0.0;
         }
 
-        return perifocalToEquatorial.multiplyByVector(result, result);
+        return Matrix3.multiplyByVector(perifocalToEquatorial, result, result);
     }
 
     function chooseOrbit(eccentricity, tolerance) {
@@ -485,7 +485,7 @@ define(['Core/Cartesian3', 'Core/defined', 'Core/DeveloperError', 'Core/JulianDa
         computeSimonEarth(date, translation);
 
         Cartesian3.subtract(result, translation, result);
-        axesTransformation.multiplyByVector(result, result);
+        Matrix3.multiplyByVector(axesTransformation, result, result);
 
         return result;
     };
@@ -502,7 +502,7 @@ define(['Core/Cartesian3', 'Core/defined', 'Core/DeveloperError', 'Core/JulianDa
             date = new JulianDate();
         }
         result = computeSimonMoon(date, result);
-        axesTransformation.multiplyByVector(result, result);
+        Matrix3.multiplyByVector(axesTransformation, result, result);
 
         return result;
     };

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

@@ -105,23 +105,27 @@ define(['Core/defined', 'Core/DeveloperError', 'Core/freezeObject', 'Core/Julian
     };
 
     /**
-     * Compares the provided TimeIntervals componentwise and returns
+     * Compares the provided TimeIntervals and returns
      * <code>true</code> if they are equal, <code>false</code> otherwise.
      * @memberof TimeInterval
      *
-     * @param {TimeInterval} [left] The first Cartesian.
-     * @param {TimeInterval} [right] The second Cartesian.
+     * @param {TimeInterval} [left] The first interval.
+     * @param {TimeInterval} [right] The second interval.
+     * @param {Function} [dataComparer] A function which compares the data of the two intervals.  If ommitted, reference equality is used.
+     *
      * @returns {Boolean} <code>true</code> if left and right are equal, <code>false</code> otherwise.
      */
-    TimeInterval.equals = function(left, right) {
+    TimeInterval.equals = function(left, right, dataComparer) {
         return left === right ||
                defined(left) &&
                defined(right) &&
                (left.isEmpty && right.isEmpty ||
                 left.isStartIncluded === right.isStartIncluded &&
                 left.isStopIncluded === right.isStopIncluded &&
-                left.start.equals(right.start) &&
-                left.stop.equals(right.stop));
+                JulianDate.equals(left.start, right.start) &&
+                JulianDate.equals(left.stop, right.stop) &&
+                (left.data === right.data ||
+                 (defined(dataComparer) && dataComparer(left.data, right.data))));
     };
 
     /**
@@ -133,12 +137,13 @@ define(['Core/defined', 'Core/DeveloperError', 'Core/freezeObject', 'Core/Julian
      * @param {TimeInterval} [left] The first TimeInterval.
      * @param {TimeInterval} [right] The second TimeInterval.
      * @param {Number} epsilon The epsilon to use for equality testing.
+     * @param {Function} [dataComparer] A function which compares the data of the two intervals.  If ommitted, reference equality is used.
      *
      * @returns {Boolean} <code>true</code> if left and right are within the provided epsilon, <code>false</code> otherwise.
      *
      * @exception {DeveloperError} epsilon is required and must be number.
      */
-    TimeInterval.equalsEpsilon = function(left, right, epsilon) {
+    TimeInterval.equalsEpsilon = function(left, right, epsilon, dataComparer) {
         if (typeof epsilon !== 'number') {
             throw new DeveloperError('epsilon is required and must be a number.');
         }
@@ -149,8 +154,10 @@ define(['Core/defined', 'Core/DeveloperError', 'Core/freezeObject', 'Core/Julian
                (left.isEmpty && right.isEmpty ||
                 left.isStartIncluded === right.isStartIncluded &&
                 left.isStopIncluded === right.isStopIncluded &&
-                left.start.equalsEpsilon(right.start, epsilon) &&
-                left.stop.equalsEpsilon(right.stop, epsilon));
+                JulianDate.equalsEpsilon(left.start, right.start, epsilon) &&
+                JulianDate.equalsEpsilon(left.stop, right.stop, epsilon) &&
+                (left.data === right.data ||
+                 (defined(dataComparer) && dataComparer(left.data, right.data))));
     };
 
     /**
@@ -205,14 +212,14 @@ define(['Core/defined', 'Core/DeveloperError', 'Core/freezeObject', 'Core/Julian
 
         if (otherStart.greaterThanOrEquals(thisStart) && thisStop.greaterThanOrEquals(otherStart)) {
 
-            isStartIncluded = (!otherStart.equals(thisStart) && otherIsStartIncluded) || (thisIsStartIncluded && otherIsStartIncluded);
+            isStartIncluded = (!JulianDate.equals(otherStart, thisStart) && otherIsStartIncluded) || (thisIsStartIncluded && otherIsStartIncluded);
 
             isStopIncluded = thisIsStopIncluded && otherIsStopIncluded;
 
             outputData = defined(mergeCallback) ? mergeCallback(this.data, other.data) : this.data;
 
             if (thisStop.greaterThanOrEquals(otherStop)) {
-                isStopIncluded = isStopIncluded || (!otherStop.equals(thisStop) && otherIsStopIncluded);
+                isStopIncluded = isStopIncluded || (!JulianDate.equals(otherStop, thisStop) && otherIsStopIncluded);
                 return new TimeInterval(otherStart, otherStop, isStartIncluded, isStopIncluded, outputData);
             }
 
@@ -222,13 +229,13 @@ define(['Core/defined', 'Core/DeveloperError', 'Core/freezeObject', 'Core/Julian
 
         if (otherStart.lessThanOrEquals(thisStart) && thisStart.lessThanOrEquals(otherStop)) {
 
-            isStartIncluded = (otherStart.equals(thisStart) === false && thisIsStartIncluded) || (thisIsStartIncluded && otherIsStartIncluded);
+            isStartIncluded = (JulianDate.equals(otherStart, thisStart) === false && thisIsStartIncluded) || (thisIsStartIncluded && otherIsStartIncluded);
 
             isStopIncluded = thisIsStopIncluded && otherIsStopIncluded;
 
             outputData = defined(mergeCallback) ? mergeCallback(this.data, other.data) : this.data;
             if (thisStop.greaterThanOrEquals(otherStop)) {
-                isStopIncluded = isStopIncluded || (otherStop.equals(thisStop) === false && otherIsStopIncluded);
+                isStopIncluded = isStopIncluded || (JulianDate.equals(otherStop, thisStop) === false && otherIsStopIncluded);
                 return new TimeInterval(thisStart, otherStop, isStartIncluded, isStopIncluded, outputData);
             }
 
@@ -275,10 +282,12 @@ define(['Core/defined', 'Core/DeveloperError', 'Core/freezeObject', 'Core/Julian
      * @memberof TimeInterval
      *
      * @param {TimeInterval} [right] The right hand side Cartesian.
+     * @param {Function} [dataComparer] A function which compares the data of the two intervals.  If ommitted, reference equality is used.
+     *
      * @returns {Boolean} <code>true</code> if they are equal, <code>false</code> otherwise.
      */
-    TimeInterval.prototype.equals = function(other) {
-        return TimeInterval.equals(this, other);
+    TimeInterval.prototype.equals = function(other, dataComparer) {
+        return TimeInterval.equals(this, other, dataComparer);
     };
 
     /**
@@ -289,12 +298,14 @@ define(['Core/defined', 'Core/DeveloperError', 'Core/freezeObject', 'Core/Julian
      *
      * @param {TimeInterval} [right] The right hand side Cartesian.
      * @param {Number} epsilon The epsilon to use for equality testing.
+     * @param {Function} [dataComparer] A function which compares the data of the two intervals.  If ommitted, reference equality is used.
+     *
      * @returns {Boolean} <code>true</code> if they are within the provided epsilon, <code>false</code> otherwise.
      *
      * @exception {DeveloperError} epsilon is required and must be a number.
      */
-    TimeInterval.prototype.equalsEpsilon = function(other, epsilon) {
-        return TimeInterval.equalsEpsilon(this, other, epsilon);
+    TimeInterval.prototype.equalsEpsilon = function(other, epsilon, dataComparer) {
+        return TimeInterval.equalsEpsilon(this, other, epsilon, dataComparer);
     };
 
     return TimeInterval;

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

@@ -25,6 +25,36 @@ define(['Core/defined', 'Core/DeveloperError', 'Core/binarySearch', 'Core/TimeIn
         this._intervals = [];
     };
 
+    /**
+     * Compares the provided TimeIntervalCollections and returns
+     * <code>true</code> if they are equal, <code>false</code> otherwise.
+     * @memberof TimeIntervalCollection
+     *
+     * @param {TimeInterval} [right] The right hand side collection.
+     * @param {Function} [dataComparer] A function which compares the data for each interval in the collection.  If ommitted, reference equality is used.
+     * @returns {Boolean} <code>true</code> if left and right are equal, <code>false</code> otherwise.
+     */
+    TimeIntervalCollection.prototype.equals = function(right, dataComparer) {
+        if (this === right) {
+            return true;
+        }
+        if (!(right instanceof TimeIntervalCollection)) {
+            return false;
+        }
+        var intervals = this._intervals;
+        var rightIntervals = right._intervals;
+        var length = intervals.length;
+        if (length !== rightIntervals.length) {
+            return false;
+        }
+        for ( var i = 0; i < length; i++) {
+            if (!TimeInterval.equals(intervals[i], rightIntervals[i], dataComparer)) {
+                return false;
+            }
+        }
+        return true;
+    };
+
     /**
      * Gets the interval at the specified index.
      *

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

@@ -416,7 +416,7 @@ define(['Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'Core/Iau200
             return undefined;
         }
 
-        return fixedToIcrfMtx.transpose(result);
+        return Matrix3.transpose(fixedToIcrfMtx, result);
     };
 
     var xysScratch = new Iau2006XysSample(0.0, 0.0, 0.0);
@@ -449,7 +449,7 @@ define(['Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'Core/Iau200
      * var fixedToIcrf = Transforms.computeIcrfToFixedMatrix(now);
      * var pointInInertial;
      * if (defined(fixedToIcrf)) {
-     *     pointInInertial = fixedToIcrf.multiplyByVector(pointInFixed);
+     *     pointInInertial = Matrix3.multiplyByVector(fixedToIcrf, pointInFixed);
      * }
      */
     Transforms.computeFixedToIcrfMatrix = function(date, result) {
@@ -494,7 +494,7 @@ define(['Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'Core/Iau200
         rotation1[8] = 1 - a * (x * x + y * y);
 
         var rotation2 = Matrix3.fromRotationZ(-xys.s, rotation2Scratch);
-        var matrixQ = rotation1.multiply(rotation2, rotation1Scratch);
+        var matrixQ = Matrix3.multiply(rotation1, rotation2, rotation1Scratch);
 
         // Similar to TT conversions above
         // It's possible here that secondTT could roll over 86400
@@ -520,7 +520,7 @@ define(['Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'Core/Iau200
         var earthRotation = Matrix3.fromRotationZ(era, rotation2Scratch);
 
         // pseudoFixed to ICRF
-        var pfToIcrf = matrixQ.multiply(earthRotation, rotation1Scratch);
+        var pfToIcrf = Matrix3.multiply(matrixQ, earthRotation, rotation1Scratch);
 
         // Compute pole wander matrix
         var cosxp = Math.cos(eop.xPoleWander);
@@ -547,7 +547,7 @@ define(['Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'Core/Iau200
         fToPfMtx[7] = sinyp * cossp - cosyp * sinxp * sinsp;
         fToPfMtx[8] = cosyp * cosxp;
 
-        return pfToIcrf.multiply(fToPfMtx, result);
+        return Matrix3.multiply(pfToIcrf, fToPfMtx, result);
     };
 
     var pointToWindowCoordinatesTemp = new Cartesian4();

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

@@ -84,7 +84,7 @@ define(['Core/defined', 'Core/Cartographic', 'Core/Cartesian3', 'Core/DeveloperE
                 cleanedTopHeights[i-1] = c1.height;
             }
 
-            c0 = c1.clone(c0);
+            Cartographic.clone(c1, c0);
         }
 
         return {
@@ -173,4 +173,4 @@ define(['Core/defined', 'Core/Cartographic', 'Core/Cartesian3', 'Core/DeveloperE
     };
 
     return WallGeometryLibrary;
-});
+});

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

@@ -0,0 +1,37 @@
+/*global define*/
+define(['Core/defined', 'Core/DeveloperError', 'ThirdParty/Uri'], function(
+        defined,
+        DeveloperError,
+        Uri) {
+    "use strict";
+
+    /**
+     * Given a URI, returns the last segment of the URI, removing any path or query information.
+     * @exports getFilenameFromUri
+     *
+     * @param {String} uri The Uri.
+     * @returns {String} The last segment of the Uri.
+     *
+     * @exception {DeveloperError} uri is required.
+     *
+     * @example
+     * //fileName will be"simple.czml";
+     * var fileName = getFilenameFromUri('/Gallery/simple.czml?value=true&example=false');
+     */
+    var getFilenameFromUri = function(uri) {
+        if (!defined(uri)) {
+            throw new DeveloperError('uri is required.');
+        }
+
+        var uriObject = new Uri(uri);
+        uriObject.normalize();
+        var path = uriObject.path;
+        var index = path.lastIndexOf('/');
+        if (index !== -1) {
+            path = path.substr(index + 1);
+        }
+        return path;
+    };
+
+    return getFilenameFromUri;
+});

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

@@ -21,7 +21,7 @@ define(['Core/Color', 'Core/defined', 'DynamicScene/ConstantProperty'], function
 
     /**
      * Gets the {@link Material} type at the provided time.
-     * @memberof MaterialProperty
+     * @memberof ColorMaterialProperty
      *
      * @param {JulianDate} time The time for which to retrieve the type.
      * @type {String} The type of material.
@@ -32,7 +32,7 @@ define(['Core/Color', 'Core/defined', 'DynamicScene/ConstantProperty'], function
 
     /**
      * Gets the value of the property at the provided time.
-     * @memberof MaterialProperty
+     * @memberof ColorMaterialProperty
      *
      * @param {JulianDate} time The time for which to retrieve the value.
      * @param {Object} [result] The object to store the value into, if omitted, a new instance is created and returned.

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

@@ -1,5 +1,5 @@
 /*global define*/
-define(['Core/Cartesian2', 'Core/Cartesian3', 'Core/Cartographic', 'Core/Color', 'Core/ClockRange', 'Core/ClockStep', 'Core/createGuid', 'Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'Core/Ellipsoid', 'Core/Event', 'Core/HermitePolynomialApproximation', 'Core/Iso8601', 'Core/JulianDate', 'Core/LagrangePolynomialApproximation', 'Core/LinearApproximation', 'Core/loadJson', 'Core/Math', 'Core/Quaternion', 'Core/ReferenceFrame', 'Core/RuntimeError', 'Core/Spherical', 'Core/TimeInterval', 'Scene/HorizontalOrigin', 'Scene/LabelStyle', 'Scene/VerticalOrigin', 'DynamicScene/CompositeMaterialProperty', 'DynamicScene/CompositePositionProperty', 'DynamicScene/CompositeProperty', 'DynamicScene/ConstantPositionProperty', 'DynamicScene/ConstantProperty', 'DynamicScene/DynamicBillboard', 'DynamicScene/DynamicClock', 'DynamicScene/ColorMaterialProperty', 'DynamicScene/DynamicCone', 'DynamicScene/DynamicLabel', 'DynamicScene/DynamicDirectionsProperty', 'DynamicScene/DynamicEllipse', 'DynamicScene/DynamicEllipsoid', 'DynamicScene/GridMaterialProperty', 'DynamicScene/ImageMaterialProperty', 'DynamicScene/DynamicObjectCollection', 'DynamicScene/DynamicPath', 'DynamicScene/DynamicPoint', 'DynamicScene/DynamicPolyline', 'DynamicScene/DynamicPolygon', 'DynamicScene/DynamicPyramid', 'DynamicScene/DynamicVector', 'DynamicScene/DynamicVertexPositionsProperty', 'DynamicScene/SampledPositionProperty', 'DynamicScene/SampledProperty', 'DynamicScene/TimeIntervalCollectionPositionProperty', 'DynamicScene/TimeIntervalCollectionProperty', 'ThirdParty/Uri', 'ThirdParty/when'], function(
+define(['Core/Cartesian2', 'Core/Cartesian3', 'Core/Cartographic', 'Core/Color', 'Core/ClockRange', 'Core/ClockStep', 'Core/createGuid', 'Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'Core/Ellipsoid', 'Core/Event', 'Core/getFilenameFromUri', 'Core/HermitePolynomialApproximation', 'Core/Iso8601', 'Core/JulianDate', 'Core/LagrangePolynomialApproximation', 'Core/LinearApproximation', 'Core/loadJson', 'Core/Math', 'Core/Quaternion', 'Core/ReferenceFrame', 'Core/RuntimeError', 'Core/Spherical', 'Core/TimeInterval', 'Scene/HorizontalOrigin', 'Scene/LabelStyle', 'Scene/VerticalOrigin', 'DynamicScene/CompositeMaterialProperty', 'DynamicScene/CompositePositionProperty', 'DynamicScene/CompositeProperty', 'DynamicScene/ConstantPositionProperty', 'DynamicScene/ConstantProperty', 'DynamicScene/DynamicBillboard', 'DynamicScene/DynamicClock', 'DynamicScene/ColorMaterialProperty', 'DynamicScene/PolylineOutlineMaterialProperty', 'DynamicScene/DynamicCone', 'DynamicScene/DynamicLabel', 'DynamicScene/DynamicDirectionsProperty', 'DynamicScene/DynamicEllipse', 'DynamicScene/DynamicEllipsoid', 'DynamicScene/GridMaterialProperty', 'DynamicScene/ImageMaterialProperty', 'DynamicScene/DynamicObject', 'DynamicScene/DynamicObjectCollection', 'DynamicScene/DynamicPath', 'DynamicScene/DynamicPoint', 'DynamicScene/DynamicPolyline', 'DynamicScene/DynamicPolygon', 'DynamicScene/DynamicPyramid', 'DynamicScene/DynamicVector', 'DynamicScene/DynamicVertexPositionsProperty', 'DynamicScene/SampledPositionProperty', 'DynamicScene/SampledProperty', 'DynamicScene/TimeIntervalCollectionPositionProperty', 'DynamicScene/TimeIntervalCollectionProperty', 'ThirdParty/Uri', 'ThirdParty/when'], function(
         Cartesian2,
         Cartesian3,
         Cartographic,
@@ -12,6 +12,7 @@ define(['Core/Cartesian2', 'Core/Cartesian3', 'Core/Cartographic', 'Core/Color',
         DeveloperError,
         Ellipsoid,
         Event,
+        getFilenameFromUri,
         HermitePolynomialApproximation,
         Iso8601,
         JulianDate,
@@ -35,6 +36,7 @@ define(['Core/Cartesian2', 'Core/Cartesian3', 'Core/Cartographic', 'Core/Color',
         DynamicBillboard,
         DynamicClock,
         ColorMaterialProperty,
+        PolylineOutlineMaterialProperty,
         DynamicCone,
         DynamicLabel,
         DynamicDirectionsProperty,
@@ -42,6 +44,7 @@ define(['Core/Cartesian2', 'Core/Cartesian3', 'Core/Cartographic', 'Core/Color',
         DynamicEllipsoid,
         GridMaterialProperty,
         ImageMaterialProperty,
+        DynamicObject,
         DynamicObjectCollection,
         DynamicPath,
         DynamicPoint,
@@ -209,12 +212,16 @@ define(['Core/Cartesian2', 'Core/Cartesian3', 'Core/Cartographic', 'Core/Color',
             return HorizontalOrigin[defaultValue(czmlInterval.horizontalOrigin, czmlInterval)];
         case Image:
             return unwrapImageInterval(czmlInterval, sourceUri);
+        case JulianDate:
+            return JulianDate.fromIso8601(defaultValue(czmlInterval.date, czmlInterval));
         case LabelStyle:
             return LabelStyle[defaultValue(czmlInterval.labelStyle, czmlInterval)];
         case Number:
-            return defaultValue(czmlInterval['number'], czmlInterval);
+            return defaultValue(czmlInterval.number, czmlInterval);
         case String:
-            return defaultValue(czmlInterval['string'], czmlInterval);
+            return defaultValue(czmlInterval.string, czmlInterval);
+        case Array:
+            return czmlInterval.array;
         case Quaternion:
             return czmlInterval.unitQuaternion;
         case VerticalOrigin:
@@ -256,7 +263,7 @@ define(['Core/Cartesian2', 'Core/Cartesian3', 'Core/Cartographic', 'Core/Color',
         var hasInterval = defined(combinedInterval) && !combinedInterval.equals(Iso8601.MAXIMUM_INTERVAL);
         var packedLength = defaultValue(type.packedLength, 1);
         var unwrappedIntervalLength = defaultValue(unwrappedInterval.length, 1);
-        var isSampled = (typeof unwrappedInterval !== 'string') && unwrappedIntervalLength > packedLength;
+        var isSampled = !defined(packetData.array) && (typeof unwrappedInterval !== 'string') && unwrappedIntervalLength > packedLength;
 
         //Any time a constant value is assigned, it completely blows away anything else.
         if (!isSampled && !hasInterval) {
@@ -637,6 +644,10 @@ define(['Core/Cartesian2', 'Core/Cartesian3', 'Core/Cartographic', 'Core/Color',
         }
     }
 
+    function processName(dynamicObject, packet, dynamicObjectCollection, sourceUri) {
+        dynamicObject.name = defaultValue(packet.name, dynamicObject.name);
+    }
+
     function processPosition(dynamicObject, packet, dynamicObjectCollection, sourceUri) {
         var positionData = packet.position;
         if (defined(positionData)) {
@@ -936,11 +947,39 @@ define(['Core/Cartesian2', 'Core/Cartesian3', 'Core/Cartographic', 'Core/Color',
             dynamicObject.polyline = polyline = new DynamicPolyline();
         }
 
-        processPacketData(Color, polyline, 'color', polylineData.color, interval, sourceUri);
-        processPacketData(Number, polyline, 'width', polylineData.width, interval, sourceUri);
-        processPacketData(Color, polyline, 'outlineColor', polylineData.outlineColor, interval, sourceUri);
-        processPacketData(Number, polyline, 'outlineWidth', polylineData.outlineWidth, interval, sourceUri);
+        //Since CZML does not support PolylineOutlineMaterial, we map it's properties into one.
+        var materialToProcess = polyline.material;
+        if (defined(interval)) {
+            var materialInterval;
+            var composite = materialToProcess;
+            if (!(composite instanceof CompositeMaterialProperty)) {
+                composite = new CompositeMaterialProperty();
+                polyline.material = composite;
+                if (defined(materialToProcess)) {
+                    materialInterval = Iso8601.MAXIMUM_INTERVAL.clone();
+                    materialInterval.data = materialToProcess;
+                    composite.intervals.addInterval(materialInterval);
+                }
+            }
+            materialInterval = composite.intervals.findInterval(interval.start, interval.stop, interval.isStartIncluded, interval.isStopIncluded);
+            if (defined(materialInterval)) {
+                materialToProcess = materialInterval.data;
+            } else {
+                materialToProcess = new PolylineOutlineMaterialProperty();
+                materialInterval = interval.clone();
+                materialInterval.data = materialToProcess;
+                composite.intervals.addInterval(materialInterval);
+            }
+        } else if (!(materialToProcess instanceof PolylineOutlineMaterialProperty)) {
+            materialToProcess = new PolylineOutlineMaterialProperty();
+            polyline.material = materialToProcess;
+        }
+
         processPacketData(Boolean, polyline, 'show', polylineData.show, interval, sourceUri);
+        processPacketData(Number, polyline, 'width', polylineData.width, interval, sourceUri);
+        processPacketData(Color, materialToProcess, 'color', polylineData.color, interval, sourceUri);
+        processPacketData(Color, materialToProcess, 'outlineColor', polylineData.outlineColor, interval, sourceUri);
+        processPacketData(Number, materialToProcess, 'outlineWidth', polylineData.outlineWidth, interval, sourceUri);
     }
 
     function processPyramid(dynamicObject, packet, dynamicObjectCollection, sourceUri) {
@@ -998,7 +1037,7 @@ define(['Core/Cartesian2', 'Core/Cartesian3', 'Core/Cartographic', 'Core/Color',
         processPacketData(Number, vector, 'length', vectorData.length, interval, sourceUri);
     }
 
-    function processCzmlPacket(packet, dynamicObjectCollection, updaterFunctions, sourceUri) {
+    function processCzmlPacket(packet, dynamicObjectCollection, updaterFunctions, sourceUri, dataSource) {
         var objectId = packet.id;
         if (!defined(objectId)) {
             objectId = createGuid();
@@ -1007,20 +1046,31 @@ define(['Core/Cartesian2', 'Core/Cartesian3', 'Core/Cartographic', 'Core/Color',
         if (packet['delete'] === true) {
             dynamicObjectCollection.removeById(objectId);
         } else {
-            var object = dynamicObjectCollection.getOrCreateObject(objectId);
-            for ( var i = updaterFunctions.length - 1; i > -1; i--) {
-                updaterFunctions[i](object, packet, dynamicObjectCollection, sourceUri);
+            var dynamicObject;
+            if (objectId === 'document') {
+                dynamicObject = dataSource._document;
+            } else {
+                dynamicObject = dynamicObjectCollection.getOrCreateObject(objectId);
+            }
+
+            var parentId = packet.parent;
+            if (defined(parentId)) {
+                dynamicObject.parent = dynamicObjectCollection.getOrCreateObject(parentId);
+            }
+
+            for (var i = updaterFunctions.length - 1; i > -1; i--) {
+                updaterFunctions[i](dynamicObject, packet, dynamicObjectCollection, sourceUri);
             }
         }
     }
 
     function loadCzml(dataSource, czml, sourceUri) {
         var dynamicObjectCollection = dataSource._dynamicObjectCollection;
-        CzmlDataSource._processCzml(czml, dynamicObjectCollection, sourceUri);
+        CzmlDataSource._processCzml(czml, dynamicObjectCollection, sourceUri, undefined, dataSource);
         var availability = dynamicObjectCollection.computeAvailability();
 
         var clock;
-        var documentObject = dynamicObjectCollection.getById('document');
+        var documentObject = dataSource._document;
         if (defined(documentObject) && defined(documentObject.clock)) {
             clock = new DynamicClock();
             clock.startTime = documentObject.clock.startTime;
@@ -1040,6 +1090,18 @@ define(['Core/Cartesian2', 'Core/Cartesian3', 'Core/Cartographic', 'Core/Color',
             clock.currentTime = clock.startTime;
             clock.clockStep = ClockStep.SYSTEM_CLOCK_MULTIPLIER;
         }
+
+        var name;
+        if (defined(documentObject) && defined(documentObject.name)) {
+            name = documentObject.name;
+        }
+
+        if (!defined(name) && defined(sourceUri)) {
+            name = getFilenameFromUri(sourceUri);
+        }
+
+        dataSource._name = name;
+
         return clock;
     }
 
@@ -1047,13 +1109,17 @@ define(['Core/Cartesian2', 'Core/Cartesian3', 'Core/Cartographic', 'Core/Color',
      * A {@link DataSource} which processes CZML.
      * @alias CzmlDataSource
      * @constructor
+     *
+     * @param {String} [name] An optional name for the data source.  This value will be overwritten if a loaded document contains a name.
      */
-    var CzmlDataSource = function() {
+    var CzmlDataSource = function(name) {
+        this._name = name;
         this._changed = new Event();
         this._error = new Event();
         this._clock = undefined;
         this._dynamicObjectCollection = new DynamicObjectCollection();
         this._timeVarying = true;
+        this._document = new DynamicObject();
     };
 
     /**
@@ -1067,6 +1133,7 @@ define(['Core/Cartesian2', 'Core/Cartesian3', 'Core/Cartographic', 'Core/Color',
     processEllipsoid, //
     processCone, //
     processLabel, //
+    processName, //
     processPath, //
     processPoint, //
     processPolygon, //
@@ -1079,6 +1146,16 @@ define(['Core/Cartesian2', 'Core/Cartesian3', 'Core/Cartographic', 'Core/Color',
     processVertexPositions, //
     processAvailability];
 
+    /**
+     * Gets the name of this data source.
+     * @memberof CzmlDataSource
+     *
+     * @returns {String} The name.
+     */
+    CzmlDataSource.prototype.getName = function() {
+        return this._name;
+    };
+
     /**
      * Gets an event that will be raised when non-time-varying data changes
      * or if the return value of getIsTimeVarying changes.
@@ -1162,6 +1239,7 @@ define(['Core/Cartesian2', 'Core/Cartesian3', 'Core/Cartographic', 'Core/Color',
             throw new DeveloperError('czml is required.');
         }
 
+        this._document = new DynamicObject('document');
         this._dynamicObjectCollection.removeAll();
         this._clock = loadCzml(this, czml, source);
     };
@@ -1255,15 +1333,15 @@ define(['Core/Cartesian2', 'Core/Cartesian3', 'Core/Cartographic', 'Core/Color',
      */
     CzmlDataSource.processMaterialPacketData = processMaterialPacketData;
 
-    CzmlDataSource._processCzml = function(czml, dynamicObjectCollection, sourceUri, updaterFunctions) {
+    CzmlDataSource._processCzml = function(czml, dynamicObjectCollection, sourceUri, updaterFunctions, dataSource) {
         updaterFunctions = defined(updaterFunctions) ? updaterFunctions : CzmlDataSource.updaters;
 
         if (Array.isArray(czml)) {
             for ( var i = 0, len = czml.length; i < len; i++) {
-                processCzmlPacket(czml[i], dynamicObjectCollection, updaterFunctions, sourceUri);
+                processCzmlPacket(czml[i], dynamicObjectCollection, updaterFunctions, sourceUri, dataSource);
             }
         } else {
-            processCzmlPacket(czml, dynamicObjectCollection, updaterFunctions, sourceUri);
+            processCzmlPacket(czml, dynamicObjectCollection, updaterFunctions, sourceUri, dataSource);
         }
     };