cesium 0.22.0 → 0.23.0

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

@@ -107,7 +107,7 @@ define(['Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'Core/Cartes
         var rightPos, leftPos;
         var halfLength = endPositionLength / 2;
 
-        var indices = IndexDatatype.createTypedArray(size/3, indicesLength);
+        var indices = IndexDatatype.createTypedArray(size / 3, indicesLength);
         var index = 0;
         if (addEndPositions) { // add rounded end
             leftPos = cartesian3;
@@ -568,7 +568,7 @@ define(['Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'Core/Cartes
         var i;
         var iLength = indices.length;
         var twoLength = length + length;
-        var newIndices = IndexDatatype.createTypedArray(newPositions.length/3, iLength * 2 + twoLength * 3);
+        var newIndices = IndexDatatype.createTypedArray(newPositions.length / 3, iLength * 2 + twoLength * 3);
         newIndices.set(indices);
         var index = iLength;
         for (i = 0; i < iLength; i += 3) { // bottom indices

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

@@ -556,6 +556,22 @@ define(['Core/freezeObject', 'Core/defaultValue', 'Core/defined', 'Core/Develope
         return Cartesian3.multiplyComponents(position, this._oneOverRadii, result);
     };
 
+    /**
+     * Transforms a Cartesian X, Y, Z position from the ellipsoid-scaled space by multiplying
+     * its components by the result of {@link Ellipsoid#getRadii}.
+     *
+     * @memberof Ellipsoid
+     *
+     * @param {Cartesian3} position The position to transform.
+     * @param {Cartesian3} [result] The position to which to copy the result, or undefined to create and
+     *        return a new instance.
+     * @returns {Cartesian3} The position expressed in the unscaled space.  The returned instance is the
+     *          one passed as the result parameter if it is not undefined, or a new instance of it is.
+     */
+    Ellipsoid.prototype.transformPositionFromScaledSpace = function(position, result) {
+        return Cartesian3.multiplyComponents(position, this._radii, result);
+    };
+
     /**
      * Compares this Ellipsoid against the provided Ellipsoid componentwise and returns
      * <code>true</code> if they are equal, <code>false</code> otherwise.

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

@@ -613,8 +613,8 @@ define(['Core/defaultValue', 'Core/defined', 'Core/BoundingSphere', 'Core/Cartes
      * @exception {DeveloperError} <code>options.extent.south</code> must be in the interval [<code>-Pi/2</code>, <code>Pi/2</code>].
      * @exception {DeveloperError} <code>options.extent.east</code> must be in the interval [<code>-Pi</code>, <code>Pi</code>].
      * @exception {DeveloperError} <code>options.extent.west</code> must be in the interval [<code>-Pi</code>, <code>Pi</code>].
-     * @exception {DeveloperError} <code>options.extent.north</code> must be greater than <code>extent.south</code>.
-     * @exception {DeveloperError} <code>options.extent.east</code> must be greater than <code>extent.west</code>.
+     * @exception {DeveloperError} <code>options.extent.north</code> must be greater than <code>options.extent.south</code>.
+     * @exception {DeveloperError} <code>options.extent.east</code> must be greater than <code>options.extent.west</code>.
      *
      * @see ExtentGeometry#createGeometry
      *
@@ -653,6 +653,13 @@ define(['Core/defaultValue', 'Core/defined', 'Core/BoundingSphere', 'Core/Cartes
         }
 
         extent.validate();
+        if (extent.east < extent.west) {
+            throw new DeveloperError('options.extent.east must be greater than options.extent.west');
+        }
+
+        if (extent.north < extent.south) {
+            throw new DeveloperError('options.extent.north must be greater than options.extent.south');
+        }
 
         this._extent = extent;
         this._granularity = granularity;

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

@@ -124,7 +124,7 @@ define(['Core/defaultValue', 'Core/defined', 'Core/BoundingSphere', 'Core/Cartes
             positions[posIndex++] = position.z;
         }
         var indicesSize = positions.length/3 * 2;
-        var indices = IndexDatatype.createTypedArray(positions.length/3, indicesSize);
+        var indices = IndexDatatype.createTypedArray(positions.length / 3, indicesSize);
 
         var index = 0;
         for(var i = 0; i < (positions.length/3)-1; i++) {
@@ -207,7 +207,7 @@ define(['Core/defaultValue', 'Core/defined', 'Core/BoundingSphere', 'Core/Cartes
         }
 
         var indicesSize = positions.length/3 * 2 + 8;
-        var indices = IndexDatatype.createTypedArray(positions.length/3, indicesSize);
+        var indices = IndexDatatype.createTypedArray(positions.length / 3, indicesSize);
         var length = positions.length/6;
         var index = 0;
         for (var i = 0; i < length - 1; i++) {

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

@@ -121,14 +121,14 @@ define(['Core/barycentricCoordinates', 'Core/defaultValue', 'Core/defined', 'Cor
 
         var indices = geometry.indices;
         if (defined(indices)) {
-            switch (geometry.primitiveType.value) {
-                case PrimitiveType.TRIANGLES.value:
+            switch (geometry.primitiveType) {
+                case PrimitiveType.TRIANGLES:
                     geometry.indices = trianglesToLines(indices);
                     break;
-                case PrimitiveType.TRIANGLE_STRIP.value:
+                case PrimitiveType.TRIANGLE_STRIP:
                     geometry.indices = triangleStripToLines(indices);
                     break;
-                case PrimitiveType.TRIANGLE_FAN.value:
+                case PrimitiveType.TRIANGLE_FAN:
                     geometry.indices = triangleFanToLines(indices);
                     break;
                 default:
@@ -396,7 +396,7 @@ define(['Core/barycentricCoordinates', 'Core/defaultValue', 'Core/defined', 'Cor
         }
 
         var indices = geometry.indices;
-        if ((geometry.primitiveType.value === PrimitiveType.TRIANGLES.value) && (defined(indices))) {
+        if ((geometry.primitiveType === PrimitiveType.TRIANGLES) && (defined(indices))) {
             var numIndices = indices.length;
             var maximumIndex = 0;
             for ( var j = 0; j < numIndices; j++) {
@@ -475,9 +475,9 @@ define(['Core/barycentricCoordinates', 'Core/defaultValue', 'Core/defined', 'Cor
         }
 
         if ((defined(geometry.indices)) &&
-            ((geometry.primitiveType.value !== PrimitiveType.TRIANGLES.value) &&
-             (geometry.primitiveType.value !== PrimitiveType.LINES.value) &&
-             (geometry.primitiveType.value !== PrimitiveType.POINTS.value))) {
+            ((geometry.primitiveType !== PrimitiveType.TRIANGLES) &&
+             (geometry.primitiveType !== PrimitiveType.LINES) &&
+             (geometry.primitiveType !== PrimitiveType.POINTS))) {
             throw new DeveloperError('geometry.primitiveType must equal to PrimitiveType.TRIANGLES, PrimitiveType.LINES, or PrimitiveType.POINTS.');
         }
 
@@ -497,11 +497,11 @@ define(['Core/barycentricCoordinates', 'Core/defaultValue', 'Core/defined', 'Cor
 
             var indicesPerPrimitive;
 
-            if (geometry.primitiveType.value === PrimitiveType.TRIANGLES.value) {
+            if (geometry.primitiveType === PrimitiveType.TRIANGLES) {
                 indicesPerPrimitive = 3;
-            } else if (geometry.primitiveType.value === PrimitiveType.LINES.value) {
+            } else if (geometry.primitiveType === PrimitiveType.LINES) {
                 indicesPerPrimitive = 2;
-            } else if (geometry.primitiveType.value === PrimitiveType.POINTS.value) {
+            } else if (geometry.primitiveType === PrimitiveType.POINTS) {
                 indicesPerPrimitive = 1;
             }
 
@@ -923,7 +923,7 @@ define(['Core/barycentricCoordinates', 'Core/defaultValue', 'Core/defined', 'Cor
                 throw new DeveloperError('All instance geometries must have an indices or not have one.');
             }
 
-            if (instances[i].geometry.primitiveType.value !== primitiveType.value) {
+            if (instances[i].geometry.primitiveType !== primitiveType) {
                 throw new DeveloperError('All instance geometries must have the same primitiveType.');
             }
         }
@@ -1063,7 +1063,7 @@ define(['Core/barycentricCoordinates', 'Core/defaultValue', 'Core/defined', 'Cor
             throw new DeveloperError('geometry.indices length must be greater than 0 and be a multiple of 3.');
         }
 
-        if (geometry.primitiveType.value !== PrimitiveType.TRIANGLES.value) {
+        if (geometry.primitiveType !== PrimitiveType.TRIANGLES) {
             throw new DeveloperError('geometry.primitiveType must be PrimitiveType.TRIANGLES.');
         }
 
@@ -1223,7 +1223,7 @@ define(['Core/barycentricCoordinates', 'Core/defaultValue', 'Core/defined', 'Cor
             throw new DeveloperError('geometry.indices length must be greater than 0 and be a multiple of 3.');
         }
 
-        if (geometry.primitiveType.value !== PrimitiveType.TRIANGLES.value) {
+        if (geometry.primitiveType !== PrimitiveType.TRIANGLES) {
             throw new DeveloperError('geometry.primitiveType must be PrimitiveType.TRIANGLES.');
         }
 
@@ -1471,18 +1471,18 @@ define(['Core/barycentricCoordinates', 'Core/defaultValue', 'Core/defined', 'Cor
     }
 
     function indexPrimitive(geometry) {
-        switch (geometry.primitiveType.value) {
-        case PrimitiveType.TRIANGLE_FAN.value:
+        switch (geometry.primitiveType) {
+        case PrimitiveType.TRIANGLE_FAN:
             return indexTriangleFan(geometry);
-        case PrimitiveType.TRIANGLE_STRIP.value:
+        case PrimitiveType.TRIANGLE_STRIP:
             return indexTriangleStrip(geometry);
-        case PrimitiveType.TRIANGLES.value:
+        case PrimitiveType.TRIANGLES:
             return indexTriangles(geometry);
-        case PrimitiveType.LINE_STRIP.value:
+        case PrimitiveType.LINE_STRIP:
             return indexLineStrip(geometry);
-        case PrimitiveType.LINE_LOOP.value:
+        case PrimitiveType.LINE_LOOP:
             return indexLineLoop(geometry);
-        case PrimitiveType.LINES.value:
+        case PrimitiveType.LINES:
             return indexLines(geometry);
         }
 
@@ -1895,9 +1895,9 @@ define(['Core/barycentricCoordinates', 'Core/defaultValue', 'Core/defined', 'Cor
         }
 
         indexPrimitive(geometry);
-        if (geometry.primitiveType.value === PrimitiveType.TRIANGLES.value) {
+        if (geometry.primitiveType === PrimitiveType.TRIANGLES) {
             wrapLongitudeTriangles(geometry);
-        } else if (geometry.primitiveType.value === PrimitiveType.LINES.value) {
+        } else if (geometry.primitiveType === PrimitiveType.LINES) {
             wrapLongitudeLines(geometry);
         }
 

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

@@ -1,14 +1,159 @@
 /*global define*/
-define(['Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'Core/Cartesian3', 'Core/Matrix4', 'Core/Cartesian4', 'Core/TridiagonalSystemSolver'], function(
+define(['Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'Core/Cartesian3', 'Core/Matrix4', 'Core/Cartesian4', 'Core/Spline', 'Core/TridiagonalSystemSolver'], function(
         defaultValue,
         defined,
         DeveloperError,
         Cartesian3,
         Matrix4,
         Cartesian4,
+        Spline,
         TridiagonalSystemSolver) {
     "use strict";
 
+    var scratchLower = [];
+    var scratchDiagonal = [];
+    var scratchUpper = [];
+    var scratchRight = [];
+
+    function generateClamped(points, firstTangent, lastTangent) {
+        var l = scratchLower;
+        var u = scratchUpper;
+        var d = scratchDiagonal;
+        var r = scratchRight;
+
+        l.length = u.length = points.length - 1;
+        d.length = r.length = points.length;
+
+        var i;
+        l[0] = d[0] = 1.0;
+        u[0] = 0.0;
+
+        var right = r[0];
+        if (!defined(right)) {
+            right = r[0] = new Cartesian3();
+        }
+        Cartesian3.clone(firstTangent, right);
+
+        for (i = 1; i < l.length - 1; ++i) {
+            l[i] = u[i] = 1.0;
+            d[i] = 4.0;
+
+            right = r[i];
+            if (!defined(right)) {
+                right = r[i] = new Cartesian3();
+            }
+            Cartesian3.subtract(points[i + 1], points[i - 1], right);
+            Cartesian3.multiplyByScalar(right, 3.0, right);
+        }
+
+        l[i] = 0.0;
+        u[i] = 1.0;
+        d[i] = 4.0;
+
+        right = r[i];
+        if (!defined(right)) {
+            right = r[i] = new Cartesian3();
+        }
+        Cartesian3.subtract(points[i + 1], points[i - 1], right);
+        Cartesian3.multiplyByScalar(right, 3.0, right);
+
+        d[i + 1] = 1.0;
+        right = r[i + 1];
+        if (!defined(right)) {
+            right = r[i + 1] = new Cartesian3();
+        }
+        Cartesian3.clone(lastTangent, right);
+
+        return TridiagonalSystemSolver.solve(l, d, u, r);
+    }
+
+    function generateNatural(points){
+        var l = scratchLower;
+        var u = scratchUpper;
+        var d = scratchDiagonal;
+        var r = scratchRight;
+
+        l.length = u.length = points.length - 1;
+        d.length = r.length = points.length;
+
+        var i;
+        l[0] = u[0] = 1.0;
+        d[0] = 2.0;
+
+        var right = r[0];
+        if (!defined(right)) {
+            right = r[0] = new Cartesian3();
+        }
+        Cartesian3.subtract(points[1], points[0], right);
+        Cartesian3.multiplyByScalar(right, 3.0, right);
+
+        for (i = 1; i < l.length; ++i) {
+            l[i] = u[i] = 1.0;
+            d[i] = 4.0;
+
+            right = r[i];
+            if (!defined(right)) {
+                right = r[i] = new Cartesian3();
+            }
+            Cartesian3.subtract(points[i + 1], points[i - 1], right);
+            Cartesian3.multiplyByScalar(right, 3.0, right);
+        }
+
+        d[i] = 2.0;
+
+        right = r[i];
+        if (!defined(right)) {
+            right = r[i] = new Cartesian3();
+        }
+        Cartesian3.subtract(points[i], points[i - 1], right);
+        Cartesian3.multiplyByScalar(right, 3.0, right);
+
+        return TridiagonalSystemSolver.solve(l, d, u, r);
+    }
+
+    var scratchTimeVec = new Cartesian4();
+    var scratchTemp = new Cartesian3();
+
+    function createEvaluateFunction(spline) {
+        var points = spline.points;
+        var times = spline.times;
+
+        if (points.length < 3) {
+            var t0 = times[0];
+            var invSpan = 1.0 / (times[1] - t0);
+
+            var p0 = points[0];
+            var p1 = points[1];
+
+            return function(time, result) {
+                var u = (time - t0) * invSpan;
+                return Cartesian3.lerp(p0, p1, u, result);
+            };
+        }
+
+        var tangents = spline.tangents;
+
+        return function(time, result) {
+            var i = spline._lastTimeIndex = spline.findTimeInterval(time, spline._lastTimeIndex);
+            var u = (time - times[i]) / (times[i + 1] - times[i]);
+
+            var timeVec = scratchTimeVec;
+            timeVec.z = u;
+            timeVec.y = u * u;
+            timeVec.x = timeVec.y * u;
+
+            var coefs = Matrix4.multiplyByPoint(HermiteSpline.hermiteCoefficientMatrix, timeVec, timeVec);
+
+            result = Cartesian3.multiplyByScalar(points[i], coefs.x, result);
+            Cartesian3.multiplyByScalar(points[i + 1], coefs.y, scratchTemp);
+            Cartesian3.add(result, scratchTemp, result);
+            Cartesian3.multiplyByScalar(tangents[i], coefs.z, scratchTemp);
+            Cartesian3.add(result, scratchTemp, result);
+            Cartesian3.multiplyByScalar(tangents[i + 1], coefs.w, scratchTemp);
+            return Cartesian3.add(result, scratchTemp, result);
+        };
+    }
+
     /**
      * A Hermite spline is a cubic interpolating spline. Positions, tangents, and times must be defined
      * for each control point. If no tangents are specified by the control points, the end and interior
@@ -21,210 +166,170 @@ define(['Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'Core/Cartes
      * @alias HermiteSpline
      * @constructor
      *
-     * @param {Array} controlPoints An array, of at least length 3, of objects with <code>point</code>,
-     * <code>time</code>, and <code>tangent</code> properties.
+     * @param {Array} options.times The array of control point times.
+     * @param {Array} options.points The array of control points.
+     * @param {Array} [options.tangents] The array of tangents at each control point.
+     * @param {Cartesian3} [options.firstTangent] The tangent of the curve at the first control point.
+     *                     If the tangent is not given, it will be estimated.
+     * @param {Cartesian3} [options.lastTangent] The tangent of the curve at the last control point.
+     *                     If the tangent is not given, it will be estimated.
      *
-     * @exception {DeveloperError} controlPoints is required.
-     * @exception {DeveloperError} controlPoints must be an array of at least length 3.
+     * @exception {DeveloperError} points is required.
+     * @exception {DeveloperError} points.length must be greater than or equal to 2.
+     * @exception {DeveloperError} times is required.
+     * @exception {DeveloperError} times.length must be equal to points.length.
      *
      * @see CatmullRomSpline
      *
      * @example
      * // Example 1.
      * // Create a natural cubic spline above the earth from Philadelphia to Los Angeles.
-     * var controlPoints = [
-     *     {point: new Cartesian3(1235398.0, -4810983.0, 4146266.0), time: 0.0},
-     *     {point: new Cartesian3(1372574.0, -5345182.0, 4606657.0), time: 1.5},
-     *     {point: new Cartesian3(-757983.0, -5542796.0, 4514323.0), time: 3.0},
-     *     {point: new Cartesian3(-2821260.0, -5248423.0, 4021290.0), time: 4.5},
-     *     {point: new Cartesian3(-2539788.0, -4724797.0, 3620093.0), time: 6.0}
-     * ];
-     * var spline = new HermiteSpline(controlPoints);
+     * var spline = new HermiteSpline({
+     *     times : [ 0.0, 1.5, 3.0, 4.5, 6.0 ],
+     *     points : [
+     *         new Cartesian3(1235398.0, -4810983.0, 4146266.0),
+     *         new Cartesian3(1372574.0, -5345182.0, 4606657.0),
+     *         new Cartesian3(-757983.0, -5542796.0, 4514323.0),
+     *         new Cartesian3(-2821260.0, -5248423.0, 4021290.0),
+     *         new Cartesian3(-2539788.0, -4724797.0, 3620093.0)
+     *     ]
+     * });
      *
      * // Example 2.
      * // Create a Catmull-Rom spline above the earth from Philadelphia to Los Angeles.
-     * var controlPoints = [
-     *     {point: new Cartesian3(1235398.0, -4810983.0, 4146266.0), time: 0.0},
-     *     {point: new Cartesian3(1372574.0, -5345182.0, 4606657.0), time: 1.5},
-     *     {point: new Cartesian3(-757983.0, -5542796.0, 4514323.0), time: 3.0},
-     *     {point: new Cartesian3(-2821260.0, -5248423.0, 4021290.0), time: 4.5},
-     *     {point: new Cartesian3(-2539788.0, -4724797.0, 3620093.0), time: 6.0}
+     * var times = [ 0.0, 1.5, 3.0, 4.5, 6.0 ];
+     * var points : [
+     *     new Cartesian3(1235398.0, -4810983.0, 4146266.0),
+     *     new Cartesian3(1372574.0, -5345182.0, 4606657.0),
+     *     new Cartesian3(-757983.0, -5542796.0, 4514323.0),
+     *     new Cartesian3(-2821260.0, -5248423.0, 4021290.0),
+     *     new Cartesian3(-2539788.0, -4724797.0, 3620093.0)
      * ];
      *
      * // Add tangents
-     * controlPoints[0].tangent = new Cartesian3(1125196, -161816, 270551);
-     * for (var i = 1; i < controlPoints.length - 1; ++i) {
-     *     controlPoints[i].tangent = Cartesian3.multiplyByScalar(Cartesian3.subtract(controlPoints[i + 1].point, controlPoints[i - 1].point), 0.5);
+     * var tangents = new Array(points.length);
+     * tangents[0] = new Cartesian3(1125196, -161816, 270551);
+     * for (var i = 1; i < tangents.length - 1; ++i) {
+     *     tangents[i] = Cartesian3.multiplyByScalar(Cartesian3.subtract(controlPoints[i + 1].point, controlPoints[i - 1].point), 0.5);
      * }
-     * controlPoints[controlPoints.length - 1].tangent = new Cartesian3(1165345, 112641, 47281);
+     * tangents[tangents.length - 1] = new Cartesian3(1165345, 112641, 47281);
      *
-     * var spline = new HermiteSpline(controlPoints);
+     * var spline = new HermiteSpline({
+     *     times : times,
+     *     points : points,
+     *     tangents : tangents
+     * });
      */
-    var HermiteSpline = function(controlPoints) {
-        if (!defined(controlPoints) || !(controlPoints instanceof Array) || controlPoints.length < 3) {
-            throw new DeveloperError('controlPoints is required. It must be an array with at least a length of 3.');
-        }
-
-        this._points = controlPoints;
+    var HermiteSpline = function(options) {
+        options = defaultValue(options, defaultValue.EMPTY_OBJECT);
 
-        this._lastTimeIndex = 0;
+        var points = options.points;
+        var times = options.times;
+        var tangents = options.tangents;
+        var firstTangent = options.firstTangent;
+        var lastTangent = options.lastTangent;
 
-        if (!defined(this._points[0].tangent) || !defined(this._points[this._points.length - 1].tangent)) {
-            generateNatural(this);
-        } else if (defined(this._points[0].tangent) && !defined(this._points[1].tangent) && defined(this._points[this._points.length - 1].tangent) && !defined(this._points[this._points.length - 2].tangent)) {
-            generateClamped(this);
+        if (!defined(points)) {
+            throw new DeveloperError('points is required.');
         }
-    };
-
-    HermiteSpline.hermiteCoefficientMatrix = new Matrix4(
-             2.0, -3.0,  0.0,  1.0,
-            -2.0,  3.0,  0.0,  0.0,
-             1.0, -2.0,  1.0,  0.0,
-             1.0, -1.0,  0.0,  0.0);
 
-    function findIndex(hermiteSpline, time) {
-        // Take advantage of temporal coherence by checking current, next and previous intervals
-        // for containment of time.
-        var i = defaultValue(hermiteSpline._lastTimeIndex, 0);
-        if (time >= hermiteSpline._points[i].time) {
-            if (i + 1 < hermiteSpline._points.length && time < hermiteSpline._points[i + 1].time) {
-                return i;
-            } else if (i + 2 < hermiteSpline._points.length && time < hermiteSpline._points[i + 2].time) {
-                hermiteSpline._lastTimeIndex = i + 1;
-                return hermiteSpline._lastTimeIndex;
-            }
-        } else if (i - 1 >= 0 && time >= hermiteSpline._points[i - 1].time) {
-            hermiteSpline._lastTimeIndex = i - 1;
-            return hermiteSpline._lastTimeIndex;
+        if (points.length < 2) {
+            throw new DeveloperError('points.length must be greater than or equal to 2.');
         }
 
-        // The above failed so do a linear search. For the use cases so far, the
-        // length of the list is less than 10. In the future, if there is a bottle neck,
-        // it might be here.
-        for (i = 0; i < hermiteSpline._points.length - 1; ++i) {
-            if (time >= hermiteSpline._points[i].time && time < hermiteSpline._points[i + 1].time) {
-                break;
-            }
+        if (!defined(times)) {
+            throw new DeveloperError('times is required.');
         }
 
-        if (i === hermiteSpline._points.length - 1) {
-            i = hermiteSpline._points.length - 2;
+        if (times.length !== points.length) {
+            throw new DeveloperError('times.length must be equal to points.length.');
         }
 
-        hermiteSpline._lastTimeIndex = i;
-        return hermiteSpline._lastTimeIndex;
-    }
-
-    function generateClamped(hermiteSpline) {
-        var l = [], d = [], u = [], r = [];
-        l.length = u.length = hermiteSpline._points.length - 1;
-        d.length = r.length = hermiteSpline._points.length;
-
-        var i;
-        l[0] = d[0] = 1.0;
-        u[0] = 0.0;
-        r[0] = hermiteSpline._points[0].tangent;
-        for (i = 1; i < l.length - 1; ++i) {
-            l[i] = u[i] = 1.0;
-            d[i] = 4.0;
-            r[i] = Cartesian3.multiplyByScalar(Cartesian3.subtract(hermiteSpline._points[i + 1].point, hermiteSpline._points[i - 1].point), 3.0);
+        if (!defined(tangents)) {
+            if (defined(firstTangent) && defined(lastTangent)) {
+                tangents = generateClamped(points, firstTangent, lastTangent);
+            } else {
+                tangents = generateNatural(points);
+            }
         }
-        l[i] = 0.0;
-        u[i] = 1.0;
-        d[i] = 4.0;
-        r[i] = Cartesian3.multiplyByScalar(Cartesian3.subtract(hermiteSpline._points[i + 1].point, hermiteSpline._points[i - 1].point), 3.0);
-        d[i + 1] = 1.0;
-        r[i + 1] = hermiteSpline._points[i + 1].tangent;
 
-        var tangents = TridiagonalSystemSolver.solve(l, d, u, r);
-        for (i = 0; i < hermiteSpline._points.length; ++i) {
-            hermiteSpline._points[i].tangent = tangents[i];
-        }
-    }
+        /**
+         * An array of times for the control points.
+         * @type {Array}
+         * @readonly
+         */
+        this.times = times;
 
-    function generateNatural(hermiteSpline){
-        var l = [], d = [], u = [], r = [];
-        l.length = u.length = hermiteSpline._points.length - 1;
-        d.length = r.length = hermiteSpline._points.length;
+        /**
+         * An array of {@link Cartesian3} control points.
+         * @type {Array}
+         * @readonly
+         */
+        this.points = points;
 
-        var i;
-        l[0] = u[0] = 1.0;
-        d[0] = 2.0;
-        r[0] = Cartesian3.multiplyByScalar(Cartesian3.subtract(hermiteSpline._points[1].point, hermiteSpline._points[0].point), 3.0);
-        for (i = 1; i < l.length; ++i) {
-            l[i] = u[i] = 1.0;
-            d[i] = 4.0;
-            r[i] = Cartesian3.multiplyByScalar(Cartesian3.subtract(hermiteSpline._points[i + 1].point, hermiteSpline._points[i - 1].point), 3.0);
-        }
-        d[i] = 2.0;
-        r[i] = Cartesian3.multiplyByScalar(Cartesian3.subtract(hermiteSpline._points[i].point, hermiteSpline._points[i - 1].point), 3.0);
+        /**
+         * An array of {@link Cartesian3} tangents at each control point.
+         * @type {Array}
+         * @readonly
+         */
+        this.tangents = tangents;
 
-        var tangents = TridiagonalSystemSolver.solve(l, d, u, r);
-        for (i = 0; i < hermiteSpline._points.length; ++i) {
-            hermiteSpline._points[i].tangent = tangents[i];
-        }
-    }
+        this._evaluateFunction = createEvaluateFunction(this);
+        this._lastTimeIndex = 0;
+    };
+
+    HermiteSpline.hermiteCoefficientMatrix = new Matrix4(
+             2.0, -3.0,  0.0,  1.0,
+            -2.0,  3.0,  0.0,  0.0,
+             1.0, -2.0,  1.0,  0.0,
+             1.0, -1.0,  0.0,  0.0);
 
     /**
-     * Returns the array of control points.
-     *
+     * Finds an index <code>i</code> in <code>times</code> such that the parameter
+     * <code>time</code> is in the interval <code>[times[i], times[i + 1]]</code>.
      * @memberof HermiteSpline
-     * @returns {Array} The array of control points.
+     *
+     * @param {Number} time The time.
+     * @returns {Number} The index for the element at the start of the interval.
+     *
+     * @exception {DeveloperError} time is required.
+     * @exception {DeveloperError} time must be in the range <code>[t<sub>0</sub>, t<sub>n</sub>]</code>, where <code>t<sub>0</sub></code>
+     *                             is the first element in the array <code>times</code> and <code>t<sub>n</sub></code> is the last element
+     *                             in the array <code>times</code>.
      */
-    HermiteSpline.prototype.getControlPoints = function() {
-        return this._points;
-    };
+    HermiteSpline.prototype.findTimeInterval = Spline.prototype.findTimeInterval;
 
     /**
      * Evaluates the curve at a given time.
-     *
      * @memberof HermiteSpline
      *
      * @param {Number} time The time at which to evaluate the curve.
+     * @param {Cartesian3} [result] The object onto which to store the result.
+     * @returns {Cartesian3} The modified result parameter or a new instance of the point on the curve at the given time.
      *
      * @exception {DeveloperError} time is required.
-     * @exception {DeveloperError} time must be in the range <code>[a<sub>0</sub>, a<sub>n</sub>]</code>,
-     * where <code>a<sub>0</sub></code> and <code>a<sub>n</sub></code> are the time properties of first and
-     * last elements in the array given during construction, respectively.
-     *
-     * @returns {Cartesian3} The point on the curve at the given <code>time</code>.
+     * @exception {DeveloperError} time must be in the range <code>[t<sub>0</sub>, t<sub>n</sub>]</code>, where <code>t<sub>0</sub></code>
+     *                             is the first element in the array <code>times</code> and <code>t<sub>n</sub></code> is the last element
+     *                             in the array <code>times</code>.
      *
      * @example
      * // spline above the earth from Philadelphia to Los Angeles
-     * var controlPoints = [
-     *     {point: new Cartesian3(1235398.0, -4810983.0, 4146266.0), time: 0.0},
-     *     {point: new Cartesian3(1372574.0, -5345182.0, 4606657.0), time: 1.5},
-     *     {point: new Cartesian3(-757983.0, -5542796.0, 4514323.0), time: 3.0},
-     *     {point: new Cartesian3(-2821260.0, -5248423.0, 4021290.0), time: 4.5},
-     *     {point: new Cartesian3(-2539788.0, -4724797.0, 3620093.0), time: 6.0}
-     * ];
-     * var spline = new HermiteSpline(controlPoints);
+     * var spline = new HermiteSpline({
+     *     times : [ 0.0, 1.5, 3.0, 4.5, 6.0 ],
+     *     points : [
+     *         new Cartesian3(1235398.0, -4810983.0, 4146266.0),
+     *         new Cartesian3(1372574.0, -5345182.0, 4606657.0),
+     *         new Cartesian3(-757983.0, -5542796.0, 4514323.0),
+     *         new Cartesian3(-2821260.0, -5248423.0, 4021290.0),
+     *         new Cartesian3(-2539788.0, -4724797.0, 3620093.0)
+     *     ]
+     * });
      *
      * // some position above Los Angeles
      * var position = spline.evaluate(5.0);
      */
-    HermiteSpline.prototype.evaluate = function(time) {
-        if (!defined(time)) {
-            throw new DeveloperError('time is required.');
-        }
-
-        if (time < this._points[0].time || time > this._points[this._points.length - 1].time) {
-            throw new DeveloperError('time is out of range.');
-        }
-
-        var i = findIndex(this, time);
-        var u = (time - this._points[i].time) / (this._points[i + 1].time - this._points[i].time);
-
-        var timeVec = new Cartesian4(0.0, u * u, u);
-        timeVec.x = timeVec.y * u;
-
-        var coefs = Matrix4.multiplyByPoint(HermiteSpline.hermiteCoefficientMatrix, timeVec);
-        var p0 = Cartesian3.multiplyByScalar(this._points[i].point,       coefs.x);
-        var p1 = Cartesian3.multiplyByScalar(this._points[i + 1].point,   coefs.y);
-        var p2 = Cartesian3.multiplyByScalar(this._points[i].tangent,     coefs.z);
-        var p3 = Cartesian3.multiplyByScalar(this._points[i + 1].tangent, coefs.w);
-
-        return Cartesian3.add(Cartesian3.add(Cartesian3.add(p0, p1), p2), p3);
+    HermiteSpline.prototype.evaluate = function(time, result) {
+        return this._evaluateFunction(time, result);
     };
 
     return HermiteSpline;