cesium 0.13.0

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

@@ -0,0 +1,149 @@
+/*global define*/
+define(['./Enumeration'], function(Enumeration) {
+    "use strict";
+
+    /**
+     * This enumerated type is for classifying mouse events: down, up, click, double click, move and move while a button is held down.
+     *
+     * @exports ScreenSpaceEventType
+     */
+    var ScreenSpaceEventType = {
+        /**
+         * Represents a mouse left button down event.
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        LEFT_DOWN : new Enumeration(0, 'LEFT_DOWN'),
+
+        /**
+         * Represents a mouse left button up event.
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        LEFT_UP : new Enumeration(1, 'LEFT_UP'),
+
+        /**
+         * Represents a mouse left click event.
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        LEFT_CLICK : new Enumeration(2, 'LEFT_CLICK'),
+
+        /**
+         * Represents a mouse left double click event.
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        LEFT_DOUBLE_CLICK : new Enumeration(3, 'LEFT_DOUBLE_CLICK'),
+
+        /**
+         * Represents a mouse left button down event.
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        RIGHT_DOWN : new Enumeration(5, 'RIGHT_DOWN'),
+
+        /**
+         * Represents a mouse right button up event.
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        RIGHT_UP : new Enumeration(6, 'RIGHT_UP'),
+
+        /**
+         * Represents a mouse right click event.
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        RIGHT_CLICK : new Enumeration(7, 'RIGHT_CLICK'),
+
+        /**
+         * Represents a mouse right double click event.
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        RIGHT_DOUBLE_CLICK : new Enumeration(8, 'RIGHT_DOUBLE_CLICK'),
+
+        /**
+         * Represents a mouse middle button down event.
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        MIDDLE_DOWN : new Enumeration(10, 'MIDDLE_DOWN'),
+
+        /**
+         * Represents a mouse middle button up event.
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        MIDDLE_UP : new Enumeration(11, 'MIDDLE_UP'),
+
+        /**
+         * Represents a mouse middle click event.
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        MIDDLE_CLICK : new Enumeration(12, 'MIDDLE_CLICK'),
+
+        /**
+         * Represents a mouse middle double click event.
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        MIDDLE_DOUBLE_CLICK : new Enumeration(13, 'MIDDLE_DOUBLE_CLICK'),
+
+        /**
+         * Represents a mouse move event.
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        MOUSE_MOVE : new Enumeration(15, 'MOUSE_MOVE'),
+
+        /**
+         * Represents a mouse wheel event.
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        WHEEL : new Enumeration(16, 'WHEEL'),
+
+        /**
+         * Represents the start of a two-finger event on a touch surface.
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        PINCH_START : new Enumeration(17, 'PINCH_START'),
+
+        /**
+         * Represents the end of a two-finger event on a touch surface.
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        PINCH_END : new Enumeration(18, 'PINCH_END'),
+
+        /**
+         * Represents a change of a two-finger event on a touch surface.
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        PINCH_MOVE : new Enumeration(19, 'PINCH_MOVE')
+    };
+
+    return ScreenSpaceEventType;
+});

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

@@ -0,0 +1,230 @@
+/*global define*/
+define([
+        './DeveloperError',
+        './Math',
+        './Cartesian2',
+        './Cartesian3',
+        './Quaternion',
+        './Matrix3'
+    ], function(
+        DeveloperError,
+        CesiumMath,
+        Cartesian2,
+        Cartesian3,
+        Quaternion,
+        Matrix3) {
+    "use strict";
+
+    function _computeEllipseQuadrant(cb, cbRadius, aSqr, bSqr, ab, ecc, mag, unitPos, eastVec, northVec, bearing,
+                                     thetaPts, thetaPtsIndex, offset, clockDir, ellipsePts, ellipsePtsIndex, numPts) {
+        var angle;
+        var theta;
+        var radius;
+        var azimuth;
+        var temp;
+        var temp2;
+        var rotAxis;
+        var tempVec;
+
+        for (var i = 0; i < numPts; i++, thetaPtsIndex += clockDir, ++ellipsePtsIndex) {
+            theta = (clockDir > 0) ? (thetaPts[thetaPtsIndex] + offset) : (offset - thetaPts[thetaPtsIndex]);
+
+            azimuth = theta + bearing;
+
+            temp = -Math.cos(azimuth);
+
+            rotAxis = eastVec.multiplyByScalar(temp);
+
+            temp = Math.sin(azimuth);
+            tempVec = northVec.multiplyByScalar(temp);
+
+            rotAxis = rotAxis.add(tempVec);
+
+            temp = Math.cos(theta);
+            temp = temp * temp;
+
+            temp2 = Math.sin(theta);
+            temp2 = temp2 * temp2;
+
+            radius = ab / Math.sqrt(bSqr * temp + aSqr * temp2);
+            angle = radius / cbRadius;
+
+            // Create the quaternion to rotate the position vector to the boundary of the ellipse.
+            temp = Math.sin(angle / 2.0);
+
+            var unitQuat = (new Quaternion(rotAxis.x * temp, rotAxis.y * temp, rotAxis.z * temp, Math.cos(angle / 2.0))).normalize();
+            var rotMtx = Matrix3.fromQuaternion(unitQuat);
+
+            var tmpEllipsePts = rotMtx.multiplyByVector(unitPos);
+            var unitCart = tmpEllipsePts.normalize();
+            tmpEllipsePts = unitCart.multiplyByScalar(mag);
+            ellipsePts[ellipsePtsIndex] = tmpEllipsePts;
+        }
+    }
+
+    /**
+     * Functions to compute the boundary positions for shapes, such as circles,
+     * drawn on the ellipsoid.
+     *
+     * @exports Shapes
+     */
+    var Shapes = {
+        /**
+         * Computes boundary points for a circle on the ellipsoid.
+         * <br /><br />
+         * The <code>granularity</code> determines the number of points
+         * in the boundary.  A lower granularity results in more points and a more
+         * exact circle.
+         * <br /><br />
+         * An outlined circle is rendered by passing the result of this function call to
+         * {@link Polyline#setPositions}.  A filled circle is rendered by passing
+         * the result to {@link Polygon#setPositions}.
+         *
+         * @param {Ellipsoid} ellipsoid The ellipsoid the circle will be on.
+         * @param {Cartesian3} center The circle's center point in the fixed frame.
+         * @param {Number} radius The radius in meters.
+         * @param {Number} [granularity] The angular distance between points on the circle.
+         *
+         * @exception {DeveloperError} ellipsoid, center, and radius are required.
+         * @exception {DeveloperError} radius must be greater than zero.
+         * @exception {DeveloperError} granularity must be greater than zero.
+         *
+         * @see Polyline#setPositions
+         * @see Polygon#setPositions
+         *
+         * @example
+         * // Create a polyline of a circle
+         * var polyline = new Polyline();
+         * polyline.setPositions(Shapes.computeCircleBoundary(
+         *   ellipsoid, ellipsoid.cartographicToCartesian(
+         *     Cartographic.fromDegrees(-75.59777, 40.03883, 0.0)), 100000.0));
+         */
+        computeCircleBoundary : function(ellipsoid, center, radius, granularity) {
+            if (!ellipsoid || !center || !radius) {
+                throw new DeveloperError('ellipsoid, center, and radius are required.');
+            }
+
+            if (radius <= 0.0) {
+                throw new DeveloperError('radius must be greater than zero.');
+            }
+
+            granularity = granularity || CesiumMath.toRadians(1.0);
+            if (granularity <= 0.0) {
+                throw new DeveloperError('granularity must be greater than zero.');
+            }
+
+            return this.computeEllipseBoundary(ellipsoid, center, radius, radius, 0, granularity);
+        },
+
+        /**
+         * Computes boundary points for an ellipse on the ellipsoid.
+         * <br /><br />
+         * The <code>granularity</code> determines the number of points
+         * in the boundary.  A lower granularity results in more points and a more
+         * exact circle.
+         * <br /><br />
+         * An outlined ellipse is rendered by passing the result of this function call to
+         * {@link Polyline#setPositions}.  A filled ellipse is rendered by passing
+         * the result to {@link Polygon#setPositions}.
+         *
+         * @param {Ellipsoid} ellipsoid The ellipsoid the ellipse will be on.
+         * @param {Cartesian3} center The ellipse's center point in the fixed frame.
+         * @param {Number} semiMajorAxis The length of the ellipse's semi-major axis in meters.
+         * @param {Number} semiMinorAxis The length of the ellipse's semi-minor axis in meters.
+         * @param {Number} [bearing] The angle from north (clockwise) in radians. The default is zero.
+         * @param {Number} [granularity] The angular distance between points on the circle.
+         *
+         * @exception {DeveloperError} ellipsoid, center, semiMajorAxis, and semiMinorAxis are required.
+         * @exception {DeveloperError} Semi-major and semi-minor axes must be greater than zero.
+         * @exception {DeveloperError} granularity must be greater than zero.
+         *
+         * @see Polyline#setPositions
+         * @see Polygon#setPositions
+         *
+         * @return The set of points that form the ellipse's boundary.
+         *
+         * @example
+         * // Create a filled ellipse.
+         * var polygon = new Polygon();
+         * polygon.setPositions(Shapes.computeEllipseBoundary(
+         *   ellipsoid, ellipsoid.cartographicToCartesian(
+         *      Cartographic.fromDegrees(-75.59777, 40.03883)), 500000.0, 300000.0, Math.toRadians(60)));
+         */
+        computeEllipseBoundary : function(ellipsoid, center, semiMajorAxis, semiMinorAxis, bearing, granularity) {
+            if (!ellipsoid || !center || !semiMajorAxis || !semiMinorAxis) {
+                throw new DeveloperError('ellipsoid, center, semiMajorAxis, and semiMinorAxis are required.');
+            }
+
+            if (semiMajorAxis <= 0.0 || semiMinorAxis <= 0.0) {
+                throw new DeveloperError('Semi-major and semi-minor axes must be greater than zero.');
+            }
+
+            bearing = bearing || 0.0;
+            granularity = granularity || CesiumMath.toRadians(1.0);
+
+            if (granularity <= 0.0) {
+                throw new DeveloperError('granularity must be greater than zero.');
+            }
+
+            if (semiMajorAxis < semiMinorAxis) {
+               var t = semiMajorAxis;
+               semiMajorAxis = semiMinorAxis;
+               semiMinorAxis = t;
+            }
+
+            var MAX_ANOMALY_LIMIT = 2.31;
+
+            var aSqr = semiMajorAxis * semiMajorAxis;
+            var bSqr = semiMinorAxis * semiMinorAxis;
+            var ab = semiMajorAxis * semiMinorAxis;
+
+            var value = 1.0 - (bSqr / aSqr);
+            var ecc = Math.sqrt(value);
+
+            var surfPos = Cartesian3.clone(center);
+            var mag = surfPos.magnitude();
+
+            var tempVec = new Cartesian3(0.0, 0.0, 1);
+            var temp = 1.0 / mag;
+
+            var unitPos = surfPos.multiplyByScalar(temp);
+            var eastVec = tempVec.cross(surfPos).normalize();
+            var northVec = unitPos.cross(eastVec);
+
+            var numQuadrantPts = 1 + Math.ceil(CesiumMath.PI_OVER_TWO / granularity);
+            var deltaTheta = MAX_ANOMALY_LIMIT / (numQuadrantPts - 1);
+            var thetaPts = [];
+            var thetaPtsIndex = 0;
+
+            var sampleTheta = 0.0;
+            for (var i = 0; i < numQuadrantPts; i++, sampleTheta += deltaTheta, ++thetaPtsIndex) {
+                thetaPts[thetaPtsIndex] = sampleTheta - ecc * Math.sin(sampleTheta);
+                if (thetaPts[thetaPtsIndex] >= CesiumMath.PI_OVER_TWO) {
+                    thetaPts[thetaPtsIndex] = CesiumMath.PI_OVER_TWO;
+                    numQuadrantPts = i + 1;
+                    break;
+                }
+            }
+
+            var ellipsePts = [];
+
+            _computeEllipseQuadrant(ellipsoid, surfPos.magnitude(), aSqr, bSqr, ab, ecc, mag, unitPos, eastVec, northVec, bearing,
+                                   thetaPts, 0.0, 0.0, 1, ellipsePts, 0, numQuadrantPts - 1);
+
+            _computeEllipseQuadrant(ellipsoid, surfPos.magnitude(), aSqr, bSqr, ab, ecc, mag, unitPos, eastVec, northVec, bearing,
+                                   thetaPts, numQuadrantPts - 1, Math.PI, -1, ellipsePts, numQuadrantPts - 1, numQuadrantPts - 1);
+
+            _computeEllipseQuadrant(ellipsoid, surfPos.magnitude(), aSqr, bSqr, ab, ecc, mag, unitPos, eastVec, northVec, bearing,
+                                   thetaPts, 0.0, Math.PI, 1, ellipsePts, (2 * numQuadrantPts) - 2, numQuadrantPts - 1);
+
+            _computeEllipseQuadrant(ellipsoid, surfPos.magnitude(), aSqr, bSqr, ab, ecc, mag, unitPos, eastVec, northVec, bearing,
+                                   thetaPts, numQuadrantPts - 1, CesiumMath.TWO_PI, -1, ellipsePts, (3 * numQuadrantPts) - 3, numQuadrantPts);
+
+            ellipsePts.push(ellipsePts[0].clone()); // Duplicates first and last point for polyline
+
+            return ellipsePts;
+        }
+    };
+
+    return Shapes;
+});

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

@@ -0,0 +1,192 @@
+/*global define*/
+define(function() {
+    "use strict";
+
+    /**
+     * A set of curvilinear 3-dimensional coordinates.
+     *
+     * @alias Spherical
+     * @constructor
+     *
+     * @param {Number} [clock=0.0] The angular coordinate lying in the xy-plane measured from the positive x-axis and toward the positive y-axis.
+     * @param {Number} [cone=0.0] The angular coordinate measured from the positive z-axis and toward the negative z-axis.
+     * @param {Number} [magnitude=1.0] The linear coordinate measured from the origin.
+     */
+    var Spherical = function(clock, cone, magnitude) {
+        this.clock = typeof clock === 'undefined' ? 0.0 : clock;
+        this.cone = typeof cone === 'undefined' ? 0.0 : cone;
+        this.magnitude = typeof magnitude === 'undefined' ? 1.0 : magnitude;
+    };
+
+    /**
+     * Converts the provided Cartesian3 into Spherical coordinates.
+     * @memberof Spherical
+     *
+     * @param {Cartesian3} cartesian3 The Cartesian3 to be converted to Spherical.
+     * @param {Spherical} [spherical] The object in which the result will be stored, if undefined a new instance will be created.
+     *
+     * @returns The modified result parameter, or a new instance if one was not provided.
+     */
+    Spherical.fromCartesian3 = function(cartesian3, result) {
+        if (typeof result === 'undefined') {
+            result = new Spherical();
+        }
+        var x = cartesian3.x;
+        var y = cartesian3.y;
+        var z = cartesian3.z;
+        var radialSquared = x * x + y * y;
+        result.clock = Math.atan2(y, x);
+        result.cone = Math.atan2(Math.sqrt(radialSquared), z);
+        result.magnitude = Math.sqrt(radialSquared + z * z);
+        return result;
+    };
+
+    /**
+     * Creates a duplicate of a Spherical.
+     * @memberof Spherical
+     *
+     * @param {Spherical} spherical The spherical to clone.
+     * @param {Spherical} [result] The object to store the result into, if undefined a new instance will be created.
+     *
+     * @return The modified result parameter or a new instance if result was undefined.
+     */
+    Spherical.clone = function(spherical, result) {
+        if (typeof result === 'undefined') {
+            result = new Spherical();
+        }
+        result.clock = spherical.clock;
+        result.cone = spherical.cone;
+        result.magnitude = spherical.magnitude;
+        return result;
+    };
+
+    /**
+     * Computes the normalized version of the provided spherical.
+     * @memberof Spherical
+     *
+     * @param {Spherical} spherical The spherical to be normalized.
+     * @param {Spherical} [result] The object to store the result into, if undefined a new instance will be created.
+     *
+     * @return The modified result parameter or a new instance if result was undefined.
+     */
+    Spherical.normalize = function(spherical, result) {
+        if (typeof result === 'undefined') {
+            result = new Spherical();
+        }
+        result.clock = spherical.clock;
+        result.cone = spherical.cone;
+        result.magnitude = 1.0;
+        return result;
+    };
+
+    /**
+     * Returns true if the first spherical is equal to the second spherical, false otherwise.
+     * @memberof Spherical
+     *
+     * @param {Spherical} left The first Spherical to be compared.
+     * @param {Spherical} right The second Spherical to be compared.
+     *
+     * @return true if the first spherical is equal to the second spherical, false otherwise.
+     */
+    Spherical.equals = function(left, right) {
+        return (left === right) ||
+               ((typeof left !== 'undefined') &&
+                (typeof right !== 'undefined') &&
+                (left.clock === right.clock) &&
+                (left.cone === right.cone) &&
+                (left.magnitude === right.magnitude));
+    };
+
+    /**
+     * Returns true if the first spherical is within the provided epsilon of the second spherical, false otherwise.
+     * @memberof Spherical
+     *
+     * @param {Spherical} left The first Spherical to be compared.
+     * @param {Spherical} right The second Spherical to be compared.
+     * @param {Number} [epsilon=0.0] The epsilon to compare against.
+     *
+     * @return true if the first spherical is within the provided epsilon of the second spherical, false otherwise.
+     */
+    Spherical.equalsEpsilon = function(left, right, epsilon) {
+        epsilon = typeof epsilon === 'undefined' ? 0.0 : epsilon;
+        return (left === right) ||
+               ((typeof left !== 'undefined') &&
+                (typeof right !== 'undefined') &&
+                (Math.abs(left.clock - right.clock) <= epsilon) &&
+                (Math.abs(left.cone - right.cone) <= epsilon) &&
+                (Math.abs(left.magnitude - right.magnitude) <= epsilon));
+    };
+
+    /**
+     * Returns a string representing the provided instance in the format (clock, cone, magnitude).
+     * @memberof Spherical
+     *
+     * @param {Spherical} spherical The object to be converted.
+     *
+     * @return A string representing the provided instance.
+     */
+    Spherical.toString = function(spherical) {
+        return '(' + spherical.clock + ', ' + spherical.cone + ', ' + spherical.magnitude + ')';
+    };
+
+    /**
+     * Creates a duplicate of this Spherical.
+     * @memberof Spherical
+     *
+     * @param {Spherical} [result] The object to store the result into, if undefined a new instance will be created.
+     *
+     * @return The modified result parameter or a new instance if result was undefined.
+     */
+    Spherical.prototype.clone = function(result) {
+        return Spherical.clone(this, result);
+    };
+
+    /**
+     * Computes the normalized version of this spherical.
+     * @memberof Spherical
+     *
+     * @param {Spherical} [result] The object to store the result into, if undefined a new instance will be created.
+     *
+     * @return The modified result parameter or a new instance if result was undefined.
+     */
+    Spherical.prototype.normalize = function(result) {
+        return Spherical.normalize(this, result);
+    };
+
+    /**
+     * Returns true if this spherical is equal to the provided spherical, false otherwise.
+     * @memberof Spherical
+     *
+     * @param {Spherical} other The Spherical to be compared.
+     *
+     * @return true if this spherical is equal to the provided spherical, false otherwise.
+     */
+    Spherical.prototype.equals = function(other) {
+        return Spherical.equals(this, other);
+    };
+
+    /**
+     * Returns true if this spherical is within the provided epsilon of the provided spherical, false otherwise.
+     * @memberof Spherical
+     *
+     * @param {Spherical} other The Spherical to be compared.
+     * @param {Number} epsilon The epsilon to compare against.
+     *
+     * @return true if this spherical is within the provided epsilon of the provided spherical, false otherwise.
+     */
+    Spherical.prototype.equalsEpsilon = function(other, epsilon) {
+        return Spherical.equalsEpsilon(this, other, epsilon);
+    };
+
+    /**
+     * Returns a string representing this instance in the format (clock, cone, magnitude).
+     * @memberof Spherical
+     *
+     * @return A string representing this instance.
+     */
+    Spherical.prototype.toString = function() {
+        return Spherical.toString(this);
+    };
+
+    return Spherical;
+});