cesium 0.13.0

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

@@ -0,0 +1,102 @@
+/*global define*/
+define(['./DeveloperError'], function(DeveloperError) {
+    "use strict";
+
+    /**
+     * Uses the Tridiagonal Matrix Algorithm, also known as the Thomas Algorithm, to solve
+     * a system of linear equations where the coefficient matrix is a tridiagonal matrix.
+     *
+     * @exports TridiagonalSystemSolver
+     */
+    var TridiagonalSystemSolver = {};
+
+    /**
+     * Solves a tridiagonal system of linear equations.
+     *
+     * @param {Array} diagonal An array with length <code>n</code> that contains the diagonal of the coefficient matrix.
+     * @param {Array} lower An array with length <code>n - 1</code> that contains the lower diagonal of the coefficient matrix.
+     * @param {Array} upper An array with length <code>n - 1</code> that contains the upper diagonal of the coefficient matrix.
+     * @param {Array} right An array of Cartesians with length <code>n</code> that is the right side of the system of equations.
+     *
+     * @exception {DeveloperError} The array lower is required.
+     * @exception {DeveloperError} The array diagonal is required.
+     * @exception {DeveloperError} The array upper is required.
+     * @exception {DeveloperError} The array right is required.
+     * @exception {DeveloperError} diagonal and right must have the same lengths.
+     * @exception {DeveloperError} lower and upper must have the same lengths.
+     * @exception {DeveloperError} lower and upper must be one less than the length of diagonal.
+     *
+     * @returns {Array} An array of Cartesians with length <code>n</code> that is the solution to the tridiagonal system of equations.
+     *
+     * @performance Linear time.
+     *
+     * @example
+     * var lowerDiagonal = [1.0, 1.0, 1.0, 1.0];
+     * var diagonal = [2.0, 4.0, 4.0, 4.0, 2.0];
+     * var upperDiagonal = [1.0, 1.0, 1.0, 1.0];
+     * var rightHandSide = [
+     *     new Cartesian3(410757.0, -1595711.0, 1375302.0),
+     *     new Cartesian3(-5986705.0, -2190640.0, 1099600.0),
+     *     new Cartesian3(-12593180.0, 288588.0, -1755549.0),
+     *     new Cartesian3(-5349898.0, 2457005.0, -2685438.0),
+     *     new Cartesian3(845820.0, 1573488.0, -1205591.0)
+     * ];
+     *
+     * var solution = TridiagonalSystemSolver.solve(lowerDiagonal, diagonal, upperDiagonal, rightHandSide);
+     */
+    TridiagonalSystemSolver.solve = function(lower, diagonal, upper, right) {
+        if (!lower || !(lower instanceof Array)) {
+            throw new DeveloperError('The array lower is required.');
+        }
+
+        if (!diagonal || !(diagonal instanceof Array)) {
+            throw new DeveloperError('The array diagonal is required.');
+        }
+
+        if (!upper || !(upper instanceof Array)) {
+            throw new DeveloperError('The array upper is required.');
+        }
+
+        if (!right || !(right instanceof Array)) {
+            throw new DeveloperError('The array right is required.');
+        }
+
+        if (diagonal.length !== right.length) {
+            throw new DeveloperError('diagonal and right must have the same lengths.');
+        }
+
+        if (lower.length !== upper.length) {
+            throw new DeveloperError('lower and upper must have the same lengths.');
+        } else if (lower.length !== diagonal.length - 1) {
+            throw new DeveloperError('lower and upper must be one less than the length of diagonal.');
+        }
+
+        var c = [], d = [], x = [];
+        c.length = upper.length;
+        d.length = x.length = right.length;
+
+        c[0] = upper[0] / diagonal[0];
+        d[0] = right[0].multiplyByScalar(1.0 / diagonal[0]);
+
+        var scalar, i = 1;
+        for (; i < c.length; ++i) {
+            scalar = 1.0 / (diagonal[i] - c[i - 1] * lower[i - 1]);
+            c[i] = upper[i] * scalar;
+            d[i] = right[i].subtract(d[i - 1].multiplyByScalar(lower[i - 1]));
+            d[i] = d[i].multiplyByScalar(scalar);
+        }
+
+        scalar = 1.0 / (diagonal[i] - c[i - 1] * lower[i - 1]);
+        d[i] = right[i].subtract(d[i - 1].multiplyByScalar(lower[i - 1]));
+        d[i] = d[i].multiplyByScalar(scalar);
+
+        x[x.length - 1] = d[d.length - 1];
+        for (i = x.length - 2; i >= 0; --i) {
+            x[i] = d[i].subtract(x[i + 1].multiplyByScalar(c[i]));
+        }
+
+        return x;
+    };
+
+    return TridiagonalSystemSolver;
+});

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

@@ -0,0 +1,38 @@
+/*global define*/
+define(['./Enumeration'], function(Enumeration) {
+    "use strict";
+
+    /**
+     * This enumerated type is used in determining to what extent an object, the occludee,
+     * is visible during horizon culling. An occluder may fully block an occludee, in which case
+     * it has no visibility, may partially block an occludee from view, or may not block it at all,
+     * leading to full visibility.
+     *
+     * @exports Visibility
+     */
+    var Visibility = {
+        /**
+         * Represents that no part of an object is visible.
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        NONE : new Enumeration(-1, 'NONE'),
+        /**
+        * Represents that part, but not all, of an object is visible
+        *
+        * @constant
+        * @type {Enumeration}
+        */
+        PARTIAL : new Enumeration(0, 'PARTIAL'),
+        /**
+        * Represents that an object is visible in its entirety.
+        *
+        * @constant
+        * @type {Enumeration}
+        */
+        FULL : new Enumeration(1, 'FULL')
+    };
+
+    return Visibility;
+});

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

@@ -0,0 +1,154 @@
+/*global define*/
+define([
+        './defaultValue',
+        './Cartesian3',
+        './Cartographic',
+        './Math',
+        './Ellipsoid'
+    ], function(
+        defaultValue,
+        Cartesian3,
+        Cartographic,
+        CesiumMath,
+        Ellipsoid) {
+    "use strict";
+
+    /**
+     * The map projection used by Google Maps, Bing Maps, and most of ArcGIS Online, EPSG:3857.  This
+     * projection use longitude and latitude expressed with the WGS84 and transforms them to Mercator using
+     * the spherical (rather than ellipsoidal) equations.
+     *
+     * @alias WebMercatorProjection
+     * @constructor
+     * @immutable
+     *
+     * @param {Ellipsoid} [ellipsoid=Ellipsoid.WGS84] The ellipsoid.
+     *
+     * @see GeographicProjection
+     */
+    var WebMercatorProjection = function(ellipsoid) {
+        this._ellipsoid = defaultValue(ellipsoid, Ellipsoid.WGS84);
+        this._semimajorAxis = this._ellipsoid.getMaximumRadius();
+        this._oneOverSemimajorAxis = 1.0 / this._semimajorAxis;
+    };
+
+    /**
+     * Converts a Mercator angle, in the range -PI to PI, to a geodetic latitude
+     * in the range -PI/2 to PI/2.
+     *
+     * @memberof WebMercatorProjection
+     *
+     * @param {Number} mercatorAngle The angle to convert.
+     * @returns {Number} The geodetic latitude in radians.
+     */
+    WebMercatorProjection.mercatorAngleToGeodeticLatitude = function(mercatorAngle) {
+        return CesiumMath.PI_OVER_TWO - (2.0 * Math.atan(Math.exp(-mercatorAngle)));
+    };
+
+    /**
+     * Converts a geodetic latitude in radians, in the range -PI/2 to PI/2, to a Mercator
+     * angle in the range -PI to PI.
+     *
+     * @memberof WebMercatorProjection
+     *
+     * @param {Number} latitude The geodetic latitude in radians.
+     * @returns {Number} The Mercator angle.
+     */
+    WebMercatorProjection.geodeticLatitudeToMercatorAngle = function(latitude) {
+        // Clamp the latitude coordinate to the valid Mercator bounds.
+        if (latitude > WebMercatorProjection.MaximumLatitude) {
+            latitude = WebMercatorProjection.MaximumLatitude;
+        } else if (latitude < -WebMercatorProjection.MaximumLatitude) {
+            latitude = -WebMercatorProjection.MaximumLatitude;
+        }
+        var sinLatitude = Math.sin(latitude);
+        return 0.5 * Math.log((1.0 + sinLatitude) / (1.0 - sinLatitude));
+    };
+
+    /**
+     * The maximum latitude (both North and South) supported by a Web Mercator
+     * (EPSG:3857) projection.  Technically, the Mercator projection is defined
+     * for any latitude up to (but not including) 90 degrees, but it makes sense
+     * to cut it off sooner because it grows exponentially with increasing latitude.
+     * The logic behind this particular cutoff value, which is the one used by
+     * Google Maps, Bing Maps, and Esri, is that it makes the projection
+     * square.  That is, the extent is equal in the X and Y directions.
+     *
+     * The constant value is computed by calling:
+     *    WebMercatorProjection.mercatorAngleToGeodeticLatitude(Math.PI)
+     *
+     * @memberof WebMercatorProjection
+     *
+     * @type {Number}
+     */
+    WebMercatorProjection.MaximumLatitude = WebMercatorProjection.mercatorAngleToGeodeticLatitude(Math.PI);
+
+    /**
+     * Gets the {@link Ellipsoid}.
+     *
+     * @memberof WebMercatorProjection
+     *
+     * @returns {Ellipsoid} The ellipsoid.
+     */
+    WebMercatorProjection.prototype.getEllipsoid = function() {
+        return this._ellipsoid;
+    };
+
+    /**
+     * Converts geodetic ellipsoid coordinates, in radians, to the equivalent Web Mercator
+     * X, Y, Z coordinates expressed in meters and returned in a {@link Cartesian3}.  The height
+     * is copied unmodified to the Z coordinate.
+     *
+     * @memberof WebMercatorProjection
+     *
+     * @param {Cartographic} cartographic The cartographic coordinates in radians.
+     * @param {Cartesian3} [result] The instance to which to copy the result, or undefined if a
+     *        new instance should be created.
+     * @returns {Cartesian3} The equivalent web mercator X, Y, Z coordinates, in meters.
+     */
+    WebMercatorProjection.prototype.project = function(cartographic, result) {
+        var semimajorAxis = this._semimajorAxis;
+        var x = cartographic.longitude * semimajorAxis;
+        var y = WebMercatorProjection.geodeticLatitudeToMercatorAngle(cartographic.latitude) * semimajorAxis;
+        var z = cartographic.height;
+
+        if (typeof result === 'undefined') {
+            return new Cartesian3(x, y, z);
+        }
+
+        result.x = x;
+        result.y = y;
+        result.z = z;
+        return result;
+    };
+
+    /**
+     * Converts Web Mercator X, Y coordinates, expressed in meters, to a {@link Cartographic}
+     * containing geodetic ellipsoid coordinates.  The Z coordinate is copied unmodified to the
+     * height.
+     *
+     * @memberof WebMercatorProjection
+     *
+     * @param {Cartesian2} cartesian The web mercator coordinates in meters.
+     * @param {Cartographic} [result] The instance to which to copy the result, or undefined if a
+     *        new instance should be created.
+     * @returns {Cartographic} The equivalent cartographic coordinates.
+     */
+    WebMercatorProjection.prototype.unproject = function(cartesian, result) {
+        var oneOverEarthSemimajorAxis = this._oneOverSemimajorAxis;
+        var longitude = cartesian.x * oneOverEarthSemimajorAxis;
+        var latitude = WebMercatorProjection.mercatorAngleToGeodeticLatitude(cartesian.y * oneOverEarthSemimajorAxis);
+        var height = cartesian.z;
+
+        if (typeof result === 'undefined') {
+            return new Cartographic(longitude, latitude, height);
+        }
+
+        result.longitude = longitude;
+        result.latitude = latitude;
+        result.height = height;
+        return result;
+    };
+
+    return WebMercatorProjection;
+});

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

@@ -0,0 +1,40 @@
+/*global define*/
+define(['./Enumeration'], function(Enumeration) {
+    "use strict";
+
+    /**
+     * DOC_TBA
+     *
+     * @exports WindingOrder
+     */
+    var WindingOrder = {
+        /**
+         * DOC_TBA
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        CLOCKWISE : new Enumeration(0x0900, 'CLOCKWISE'), // WebGL: CW
+        /**
+         * DOC_TBA
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        COUNTER_CLOCKWISE : new Enumeration(0x0901, 'COUNTER_CLOCKWISE'), // WebGL CCW
+
+        /**
+         * DOC_TBA
+         *
+         * @param windingOrder
+         *
+         * @returns {Boolean}
+         */
+        validate : function(windingOrder) {
+            return ((windingOrder === WindingOrder.CLOCKWISE) ||
+                    (windingOrder === WindingOrder.COUNTER_CLOCKWISE));
+        }
+    };
+
+    return WindingOrder;
+});

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

@@ -0,0 +1,69 @@
+/*global define*/
+define(['./DeveloperError'], function(DeveloperError) {
+    "use strict";
+
+    /**
+     * Finds an item in a sorted array.
+     *
+     * @exports binarySearch
+     *
+     * @param {Array} array The sorted array to search.
+     * @param {Object} itemToFind The item to find in the array.
+     *
+     * @param {Function} comparator The function to use to compare the item to elements in the array.
+     *        The first parameter passed to the comparator function is an item in the array, the
+     *        second is <code>itemToFind</code>.  If the array item is less than <code>itemToFind</code>,
+     *        the function should return a negative value.  If it is greater, the function should return
+     *        a positive value.  If the items are equal, it should return 0.
+     *
+     * @return {Number} The index of <code>itemToFind</code> in the array, if it exists.  If <code>itemToFind</code>
+     *        does not exist, the return value is a negative number which is the bitwise complement (~)
+     *        of the index before which the itemToFind should be inserted in order to maintain the
+     *        sorted order of the array.
+     *
+     * @exception {DeveloperError} <code>array</code> is required.
+     * @exception {DeveloperError} <code>toFind</code> is required.
+     * @exception {DeveloperError} <code>comparator</code> is required.
+     *
+     * @example
+     * // Create a comparator function to search through an array of numbers.
+     * var comparator = function (a, b) {
+     *     return a - b;
+     * };
+     * var numbers = [0, 2, 4, 6, 8];
+     * var index = binarySearch(numbers, 6, comparator); // 3
+     */
+    var binarySearch = function(array, itemToFind, comparator) {
+        if (!array) {
+            throw new DeveloperError('array is required.');
+        }
+        if (!itemToFind) {
+            throw new DeveloperError('itemToFind is required.');
+        }
+        if (!comparator) {
+            throw new DeveloperError('comparator is required.');
+        }
+
+        var low = 0;
+        var high = array.length - 1;
+        var i;
+        var comparison;
+
+        while (low <= high) {
+            i = ~~((low + high) / 2);
+            comparison = comparator(array[i], itemToFind);
+            if (comparison < 0) {
+                low = i + 1;
+                continue;
+            }
+            if (comparison > 0) {
+                high = i - 1;
+                continue;
+            }
+            return i;
+        }
+        return ~(high + 1);
+    };
+
+    return binarySearch;
+});

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

@@ -0,0 +1,77 @@
+/*global define*/
+define([
+        'require',
+        './DeveloperError'
+    ], function(
+        require,
+        DeveloperError) {
+    "use strict";
+    /*global CESIUM_BASE_URL*/
+
+    var baseUrl;
+    function getCesiumBaseUrl() {
+        if (typeof baseUrl !== 'undefined') {
+            return baseUrl;
+        }
+
+        if (typeof CESIUM_BASE_URL !== 'undefined') {
+            baseUrl = CESIUM_BASE_URL;
+        } else {
+            var cesiumScriptRegex = /(.*?)Cesium\w*\.js(?:\W|$)/i;
+            var scripts = document.getElementsByTagName('script');
+            for ( var i = 0, len = scripts.length; i < len; ++i) {
+                var src = scripts[i].getAttribute('src');
+                var result = cesiumScriptRegex.exec(src);
+                if (result !== null) {
+                    baseUrl = result[1];
+                    break;
+                }
+            }
+        }
+
+        if (typeof baseUrl === 'undefined') {
+            throw new DeveloperError('Unable to determine Cesium base URL automatically, try defining a global variable called CESIUM_BASE_URL.');
+        }
+
+        if (!/\/$/.test(baseUrl)) {
+            baseUrl += '/';
+        }
+
+        return baseUrl;
+    }
+
+    function buildModuleUrlFromRequireToUrl(moduleID) {
+        //moduleID will be non-relative, so require it relative to this module, in Core.
+        return require.toUrl('../' + moduleID);
+    }
+
+    function buildModuleUrlFromBaseUrl(moduleID) {
+        return getCesiumBaseUrl() + moduleID;
+    }
+
+    var implementation;
+
+    /**
+     * Given a non-relative moduleID, returns a URL to the file represented by that module ID,
+     * using, in order of preference, require.toUrl, the value of a global CESIUM_BASE_URL, or
+     * the base URL of the Cesium.js script.
+     *
+     * @private
+     */
+    var buildModuleUrl = function(moduleID) {
+        if (typeof implementation !== 'undefined') {
+            return implementation(moduleID);
+        }
+
+        //select implementation
+        if (typeof require.toUrl !== 'undefined') {
+            implementation = buildModuleUrlFromRequireToUrl;
+        } else {
+            implementation = buildModuleUrlFromBaseUrl;
+        }
+
+        return implementation(moduleID);
+    };
+
+    return buildModuleUrl;
+});