cesium 0.13.0

data/app/assets/javascripts/Scene/NeverTileDiscardPolicy.js

@@ -0,0 +1,38 @@
+/*global define*/
+define([
+    ], function(
+        ) {
+    "use strict";
+
+    /**
+     * A {@link TileDiscardPolicy} specifying that tile images should never be discard.
+     *
+     * @alias NeverTileDiscardPolicy
+     * @constructor
+     *
+     * @see DiscardMissingTileImagePolicy
+     */
+    var NeverTileDiscardPolicy = function(description) {
+    };
+
+    /**
+     * Determines if the discard policy is ready to process images.
+     * @returns True if the discard policy is ready to process images; otherwise, false.
+     */
+    NeverTileDiscardPolicy.prototype.isReady = function() {
+        return true;
+    };
+
+    /**
+     * Given a tile image, decide whether to discard that image.
+     *
+     * @param {Image|Promise} image An image, or a promise that will resolve to an image.
+     *
+     * @returns A promise that will resolve to true if the tile should be discarded.
+     */
+    NeverTileDiscardPolicy.prototype.shouldDiscardImage = function(image) {
+        return false;
+    };
+
+    return NeverTileDiscardPolicy;
+});

data/app/assets/javascripts/Scene/OpenStreetMapImageryProvider.js

@@ -0,0 +1,282 @@
+/*global define*/
+define([
+        '../Core/defaultValue',
+        '../Core/DeveloperError',
+        '../Core/Event',
+        '../Core/writeTextToCanvas',
+        './ImageryProvider',
+        './WebMercatorTilingScheme'
+    ], function(
+        defaultValue,
+        DeveloperError,
+        Event,
+        writeTextToCanvas,
+        ImageryProvider,
+        WebMercatorTilingScheme) {
+    "use strict";
+
+    var trailingSlashRegex = /\/$/;
+
+    /**
+     * Provides tiled imagery hosted by OpenStreetMap or another provider of Slippy tiles.  Please be aware
+     * that a default-constructed instance of this class will connect to OpenStreetMap's volunteer-run
+     * servers, so you must conform to their
+     * <a href='http://wiki.openstreetmap.org/wiki/Tile_usage_policy'>Tile Usage Policy</a>.
+     *
+     * @alias OpenStreetMapImageryProvider
+     * @constructor
+     *
+     * @param {String} [description.url='http://tile.openstreetmap.org'] The OpenStreetMap server url.
+     * @param {String} [description.fileExtension='png'] The file extension for images on the server.
+     * @param {Object} [description.proxy] A proxy to use for requests. This object is expected to have a getURL function which returns the proxied URL.
+     * @param {Extent} [description.extent=Extent.MAX_VALUE] The extent of the layer.
+     * @param {Number} [description.maximumLevel=18] The maximum level-of-detail supported by the imagery provider.
+     * @param {String} [description.credit='MapQuest, Open Street Map and contributors, CC-BY-SA'] A string crediting the data source, which is displayed on the canvas.
+     *
+     * @see ArcGisMapServerImageryProvider
+     * @see BingMapsImageryProvider
+     * @see SingleTileImageryProvider
+     * @see TileMapServiceImageryProvider
+     * @see WebMapServiceImageryProvider
+     *
+     * @see <a href='http://wiki.openstreetmap.org/wiki/Main_Page'>OpenStreetMap Wiki</a>
+     * @see <a href='http://www.w3.org/TR/cors/'>Cross-Origin Resource Sharing</a>
+     *
+     * @example
+     * // OpenStreetMap tile provider
+     * var osm = new OpenStreetMapImageryProvider({
+     *     url : 'http://tile.openstreetmap.org/'
+     * });
+     */
+    var OpenStreetMapImageryProvider = function OpenStreetMapImageryProvider(description) {
+        description = defaultValue(description, {});
+
+        var url = defaultValue(description.url, 'http://tile.openstreetmap.org/');
+
+        if (!trailingSlashRegex.test(url)) {
+            url = url + '/';
+        }
+
+        this._url = url;
+        this._fileExtension = defaultValue(description.fileExtension, 'png');
+        this._proxy = description.proxy;
+        this._tileDiscardPolicy = description.tileDiscardPolicy;
+
+        this._tilingScheme = new WebMercatorTilingScheme();
+
+        this._tileWidth = 256;
+        this._tileHeight = 256;
+
+        this._maximumLevel = defaultValue(description.maximumLevel, 18);
+
+        this._extent = defaultValue(description.extent, this._tilingScheme.getExtent());
+
+        this._errorEvent = new Event();
+
+        this._ready = true;
+
+        var credit = defaultValue(description.credit, 'MapQuest, Open Street Map and contributors, CC-BY-SA');
+        this._logo = writeTextToCanvas(credit, {
+            font : '12px sans-serif'
+        });
+    };
+
+    function buildImageUrl(imageryProvider, x, y, level) {
+        var url = imageryProvider._url + level + '/' + x + '/' + y + '.' + imageryProvider._fileExtension;
+
+        var proxy = imageryProvider._proxy;
+        if (typeof proxy !== 'undefined') {
+            url = proxy.getURL(url);
+        }
+
+        return url;
+    }
+
+    /**
+     * Gets the URL of the service hosting the imagery.
+     *
+     * @memberof OpenStreetMapImageryProvider
+     *
+     * @returns {String} The URL.
+     */
+    OpenStreetMapImageryProvider.prototype.getUrl = function() {
+        return this._url;
+    };
+
+    /**
+     * Gets the width of each tile, in pixels.  This function should
+     * not be called before {@link OpenStreetMapImageryProvider#isReady} returns true.
+     *
+     * @memberof OpenStreetMapImageryProvider
+     *
+     * @returns {Number} The width.
+     *
+     * @exception {DeveloperError} <code>getTileWidth</code> must not be called before the imagery provider is ready.
+     */
+    OpenStreetMapImageryProvider.prototype.getTileWidth = function() {
+        if (!this._ready) {
+            throw new DeveloperError('getTileWidth must not be called before the imagery provider is ready.');
+        }
+        return this._tileWidth;
+    };
+
+    /**
+     * Gets the height of each tile, in pixels.  This function should
+     * not be called before {@link OpenStreetMapImageryProvider#isReady} returns true.
+     *
+     * @memberof OpenStreetMapImageryProvider
+     *
+     * @returns {Number} The height.
+     *
+     * @exception {DeveloperError} <code>getTileHeight</code> must not be called before the imagery provider is ready.
+     */
+    OpenStreetMapImageryProvider.prototype.getTileHeight = function() {
+        if (!this._ready) {
+            throw new DeveloperError('getTileHeight must not be called before the imagery provider is ready.');
+        }
+        return this._tileHeight;
+    };
+
+    /**
+     * Gets the maximum level-of-detail that can be requested.  This function should
+     * not be called before {@link OpenStreetMapImageryProvider#isReady} returns true.
+     *
+     * @memberof OpenStreetMapImageryProvider
+     *
+     * @returns {Number} The maximum level.
+     *
+     * @exception {DeveloperError} <code>getMaximumLevel</code> must not be called before the imagery provider is ready.
+     */
+    OpenStreetMapImageryProvider.prototype.getMaximumLevel = function() {
+        if (!this._ready) {
+            throw new DeveloperError('getMaximumLevel must not be called before the imagery provider is ready.');
+        }
+        return this._maximumLevel;
+    };
+
+    /**
+     * Gets the tiling scheme used by this provider.  This function should
+     * not be called before {@link OpenStreetMapImageryProvider#isReady} returns true.
+     *
+     * @memberof OpenStreetMapImageryProvider
+     *
+     * @returns {TilingScheme} The tiling scheme.
+     * @see WebMercatorTilingScheme
+     * @see GeographicTilingScheme
+     *
+     * @exception {DeveloperError} <code>getTilingScheme</code> must not be called before the imagery provider is ready.
+     */
+    OpenStreetMapImageryProvider.prototype.getTilingScheme = function() {
+        if (!this._ready) {
+            throw new DeveloperError('getTilingScheme must not be called before the imagery provider is ready.');
+        }
+        return this._tilingScheme;
+    };
+
+    /**
+     * Gets the extent, in radians, of the imagery provided by this instance.  This function should
+     * not be called before {@link OpenStreetMapImageryProvider#isReady} returns true.
+     *
+     * @memberof OpenStreetMapImageryProvider
+     *
+     * @returns {Extent} The extent.
+     *
+     * @exception {DeveloperError} <code>getExtent</code> must not be called before the imagery provider is ready.
+     */
+    OpenStreetMapImageryProvider.prototype.getExtent = function() {
+        if (!this._ready) {
+            throw new DeveloperError('getExtent must not be called before the imagery provider is ready.');
+        }
+        return this._extent;
+    };
+
+    /**
+     * Gets the tile discard policy.  If not undefined, the discard policy is responsible
+     * for filtering out "missing" tiles via its shouldDiscardImage function.  If this function
+     * returns undefined, no tiles are filtered.  This function should
+     * not be called before {@link OpenStreetMapImageryProvider#isReady} returns true.
+     *
+     * @memberof OpenStreetMapImageryProvider
+     *
+     * @returns {TileDiscardPolicy} The discard policy.
+     *
+     * @see DiscardMissingTileImagePolicy
+     * @see NeverTileDiscardPolicy
+     *
+     * @exception {DeveloperError} <code>getTileDiscardPolicy</code> must not be called before the imagery provider is ready.
+     */
+    OpenStreetMapImageryProvider.prototype.getTileDiscardPolicy = function() {
+        if (!this._ready) {
+            throw new DeveloperError('getTileDiscardPolicy must not be called before the imagery provider is ready.');
+        }
+        return this._tileDiscardPolicy;
+    };
+
+    /**
+     * Gets an event that is raised when the imagery provider encounters an asynchronous error.  By subscribing
+     * to the event, you will be notified of the error and can potentially recover from it.  Event listeners
+     * are passed an instance of {@link ImageryProviderError}.
+     *
+     * @memberof OpenStreetMapImageryProvider
+     *
+     * @returns {Event} The event.
+     */
+    OpenStreetMapImageryProvider.prototype.getErrorEvent = function() {
+        return this._errorEvent;
+    };
+
+    /**
+     * Gets a value indicating whether or not the provider is ready for use.
+     *
+     * @memberof OpenStreetMapImageryProvider
+     *
+     * @returns {Boolean} True if the provider is ready to use; otherwise, false.
+     */
+    OpenStreetMapImageryProvider.prototype.isReady = function() {
+        return this._ready;
+    };
+
+    /**
+     * Requests the image for a given tile.  This function should
+     * not be called before {@link OpenStreetMapImageryProvider#isReady} returns true.
+     *
+     * @memberof OpenStreetMapImageryProvider
+     *
+     * @param {Number} x The tile X coordinate.
+     * @param {Number} y The tile Y coordinate.
+     * @param {Number} level The tile level.
+     *
+     * @returns {Promise} A promise for the image that will resolve when the image is available, or
+     *          undefined if there are too many active requests to the server, and the request
+     *          should be retried later.  The resolved image may be either an
+     *          Image or a Canvas DOM object.
+     *
+     * @exception {DeveloperError} <code>requestImage</code> must not be called before the imagery provider is ready.
+     */
+    OpenStreetMapImageryProvider.prototype.requestImage = function(x, y, level) {
+        if (!this._ready) {
+            throw new DeveloperError('requestImage must not be called before the imagery provider is ready.');
+        }
+        var url = buildImageUrl(this, x, y, level);
+        return ImageryProvider.loadImage(url);
+    };
+
+    /**
+     * Gets the logo to display when this imagery provider is active.  Typically this is used to credit
+     * the source of the imagery.  This function should not be called before {@link OpenStreetMapImageryProvider#isReady} returns true.
+     *
+     * @memberof OpenStreetMapImageryProvider
+     *
+     * @returns {Image|Canvas} A canvas or image containing the log to display, or undefined if there is no logo.
+     *
+     * @exception {DeveloperError} <code>getLogo</code> must not be called before the imagery provider is ready.
+     */
+    OpenStreetMapImageryProvider.prototype.getLogo = function() {
+        if (!this._ready) {
+            throw new DeveloperError('getLogo must not be called before the imagery provider is ready.');
+        }
+        return this._logo;
+    };
+
+    return OpenStreetMapImageryProvider;
+});

data/app/assets/javascripts/Scene/OrthographicFrustum.js

@@ -0,0 +1,345 @@
+/*global define*/
+define([
+        '../Core/DeveloperError',
+        '../Core/destroyObject',
+        '../Core/Cartesian2',
+        '../Core/Cartesian3',
+        '../Core/Cartesian4',
+        '../Core/Matrix4',
+        '../Scene/CullingVolume'
+    ], function(
+        DeveloperError,
+        destroyObject,
+        Cartesian2,
+        Cartesian3,
+        Cartesian4,
+        Matrix4,
+        CullingVolume) {
+    "use strict";
+
+    /**
+     * The viewing frustum is defined by 6 planes.
+     * Each plane is represented by a {Cartesian4} object, where the x, y, and z components
+     * define the unit vector normal to the plane, and the w component is the distance of the
+     * plane from the origin/camera position.
+     *
+     * @alias OrthographicFrustum
+     * @constructor
+     *
+     * @example
+     * var maxRadii = ellipsoid.getMaximumRadius();
+     *
+     * var frustum = new OrthographicFrustum();
+     * frustum.right = maxRadii * CesiumMath.PI;
+     * frustum.left = -c.frustum.right;
+     * frustum.top = c.frustum.right * (canvas.clientHeight / canvas.clientWidth);
+     * frustum.bottom = -c.frustum.top;
+     * frustum.near = 0.01 * maxRadii;
+     * frustum.far = 50.0 * maxRadii;
+     */
+    var OrthographicFrustum = function() {
+        /**
+         * The left clipping plane.
+         * @type {Number}
+         */
+        this.left = undefined;
+        this._left = undefined;
+
+        /**
+         * The right clipping plane.
+         * @type {Number}
+         */
+        this.right = undefined;
+        this._right = undefined;
+
+        /**
+         * The top clipping plane.
+         * @type {Number}
+         */
+        this.top = undefined;
+        this._top = undefined;
+
+        /**
+         * The bottom clipping plane.
+         * @type {Number}
+         */
+        this.bottom = undefined;
+        this._bottom = undefined;
+
+        /**
+         * The distance of the near plane.
+         * @type {Number}
+         */
+        this.near = 1.0;
+        this._near = this.near;
+
+        /**
+         * The distance of the far plane.
+         * @type {Number}
+         */
+        this.far = 500000000.0;
+        this._far = this.far;
+
+        this._cullingVolume = new CullingVolume();
+        this._orthographicMatrix = undefined;
+    };
+
+    /**
+     * Returns the orthographic projection matrix computed from the view frustum.
+     *
+     * @memberof OrthographicFrustum
+     *
+     * @return {Matrix4} The orthographic projection matrix.
+     */
+    OrthographicFrustum.prototype.getProjectionMatrix = function() {
+        update(this);
+        return this._orthographicMatrix;
+    };
+
+    function update(frustum) {
+        if (typeof frustum.right === 'undefined' || typeof frustum.left === 'undefined' ||
+                typeof frustum.top === 'undefined' || typeof frustum.bottom === 'undefined' ||
+                typeof frustum.near === 'undefined' || typeof frustum.far === 'undefined') {
+            throw new DeveloperError('right, left, top, bottom, near, or far parameters are not set.');
+        }
+
+        if (frustum.top !== frustum._top || frustum.bottom !== frustum._bottom ||
+                frustum.left !== frustum._left || frustum.right !== frustum._right ||
+                frustum.near !== frustum._near || frustum.far !== frustum._far) {
+
+            if (frustum.left > frustum.right) {
+                throw new DeveloperError('right must be greater than left.');
+            }
+
+            if (frustum.bottom > frustum.top) {
+                throw new DeveloperError('top must be greater than bottom.');
+            }
+
+            if (frustum.near <= 0 || frustum.near > frustum.far) {
+                throw new DeveloperError('near must be greater than zero and less than far.');
+            }
+
+            frustum._left = frustum.left;
+            frustum._right = frustum.right;
+            frustum._top = frustum.top;
+            frustum._bottom = frustum.bottom;
+            frustum._near = frustum.near;
+            frustum._far = frustum.far;
+            frustum._orthographicMatrix = Matrix4.computeOrthographicOffCenter(frustum.left, frustum.right, frustum.bottom, frustum.top, frustum.near, frustum.far);
+        }
+    }
+
+    var getPlanesRight = new Cartesian3();
+    var getPlanesNearCenter = new Cartesian3();
+    var getPlanesPoint = new Cartesian3();
+    /**
+     * Creates a culling volume for this frustum.
+     *
+     * @memberof OrthographicFrustum
+     *
+     * @param {Cartesian3} position The eye position.
+     * @param {Cartesian3} direction The view direction.
+     * @param {Cartesian3} up The up direction.
+     *
+     * @exception {DeveloperError} position is required.
+     * @exception {DeveloperError} direction is required.
+     * @exception {DeveloperError} up is required.
+     *
+     * @return {CullingVolume} A culling volume at the given position and orientation.
+     *
+     * @example
+     * // Check if a bounding volume intersects the frustum.
+     * var cullingVolume = frustum.computeCullingVolume(cameraPosition, cameraDirection, cameraUp);
+     * var intersect = cullingVolume.getVisibility(boundingVolume);
+     */
+    OrthographicFrustum.prototype.computeCullingVolume = function(position, direction, up) {
+        if (typeof position === 'undefined') {
+            throw new DeveloperError('position is required.');
+        }
+
+        if (typeof direction === 'undefined') {
+            throw new DeveloperError('direction is required.');
+        }
+
+        if (typeof up === 'undefined') {
+            throw new DeveloperError('up is required.');
+        }
+
+        var planes = this._cullingVolume.planes;
+
+        var t = this.top;
+        var b = this.bottom;
+        var r = this.right;
+        var l = this.left;
+        var n = this.near;
+        var f = this.far;
+
+        var right = Cartesian3.cross(direction, up, getPlanesRight);
+
+        var nearCenter = getPlanesNearCenter;
+        Cartesian3.multiplyByScalar(direction, n, nearCenter);
+        Cartesian3.add(position, nearCenter, nearCenter);
+
+        var point = getPlanesPoint;
+
+        // Left plane
+        Cartesian3.multiplyByScalar(right, l, point);
+        Cartesian3.add(nearCenter, point, point);
+
+        var plane = planes[0];
+        if (typeof plane === 'undefined') {
+            plane = planes[0] = new Cartesian4();
+        }
+        plane.x = right.x;
+        plane.y = right.y;
+        plane.z = right.z;
+        plane.w = -Cartesian3.dot(right, point);
+
+        // Right plane
+        Cartesian3.multiplyByScalar(right, r, point);
+        Cartesian3.add(nearCenter, point, point);
+
+        plane = planes[1];
+        if (typeof plane === 'undefined') {
+            plane = planes[1] = new Cartesian4();
+        }
+        plane.x = -right.x;
+        plane.y = -right.y;
+        plane.z = -right.z;
+        plane.w = -Cartesian3.dot(right.negate(), point);
+
+        // Bottom plane
+        Cartesian3.multiplyByScalar(up, b, point);
+        Cartesian3.add(nearCenter, point, point);
+
+        plane = planes[2];
+        if (typeof plane === 'undefined') {
+            plane = planes[2] = new Cartesian4();
+        }
+        plane.x = up.x;
+        plane.y = up.y;
+        plane.z = up.z;
+        plane.w = -Cartesian3.dot(up, point);
+
+        // Top plane
+        Cartesian3.multiplyByScalar(up, t, point);
+        Cartesian3.add(nearCenter, point, point);
+
+        plane = planes[3];
+        if (typeof plane === 'undefined') {
+            plane = planes[3] = new Cartesian4();
+        }
+        plane.x = -up.x;
+        plane.y = -up.y;
+        plane.z = -up.z;
+        plane.w = -Cartesian3.dot(up.negate(), point);
+
+        // Near plane
+        plane = planes[4];
+        if (typeof plane === 'undefined') {
+            plane = planes[4] = new Cartesian4();
+        }
+        plane.x = direction.x;
+        plane.y = direction.y;
+        plane.z = direction.z;
+        plane.w = -Cartesian3.dot(direction, nearCenter);
+
+        // Far plane
+        Cartesian3.multiplyByScalar(direction, f, point);
+        Cartesian3.add(position, point, point);
+
+        plane = planes[5];
+        if (typeof plane === 'undefined') {
+            plane = planes[5] = new Cartesian4();
+        }
+        plane.x = -direction.x;
+        plane.y = -direction.y;
+        plane.z = -direction.z;
+        plane.w = -Cartesian3.dot(direction.negate(), point);
+
+        return this._cullingVolume;
+    };
+
+    /**
+     * Returns the pixel's width and height in meters.
+     *
+     * @memberof OrthographicFrustum
+     *
+     * @param {Cartesian2} canvasDimensions A {@link Cartesian2} with width and height in the x and y properties, respectively.
+     *
+     * @exception {DeveloperError} canvasDimensions is required.
+     * @exception {DeveloperError} canvasDimensions.x must be greater than zero.
+     * @exception {DeveloperError} canvasDimensione.y must be greater than zero.
+     *
+     * @returns {Cartesian2} A {@link Cartesian2} with the pixel's width and height in the x and y properties, respectively.
+     *
+     * @example
+     * // Example 1
+     * // Get the width and height of a pixel.
+     * var pixelSize = camera.frustum.getPixelSize(new Cartesian2(canvas.clientWidth, canvas.clientHeight));
+     */
+    OrthographicFrustum.prototype.getPixelSize = function(canvasDimensions) {
+        update(this);
+
+        if (typeof canvasDimensions === 'undefined') {
+            throw new DeveloperError('canvasDimensions is required.');
+        }
+
+        var width = canvasDimensions.x;
+        var height = canvasDimensions.y;
+
+        if (width <= 0) {
+            throw new DeveloperError('canvasDimensions.x must be grater than zero.');
+        }
+
+        if (height <= 0) {
+            throw new DeveloperError('canvasDimensions.y must be grater than zero.');
+        }
+
+        var frustumWidth = this.right - this.left;
+        var frustumHeight = this.top - this.bottom;
+        var pixelWidth = frustumWidth / width;
+        var pixelHeight = frustumHeight / height;
+
+        return new Cartesian2(pixelWidth, pixelHeight);
+    };
+
+    /**
+     * Returns a duplicate of a OrthographicFrustum instance.
+     *
+     * @memberof OrthographicFrustum
+     *
+     * @return {OrthographicFrustum} A new copy of the OrthographicFrustum instance.
+     */
+    OrthographicFrustum.prototype.clone = function() {
+        var frustum = new OrthographicFrustum();
+        frustum.left = this.left;
+        frustum.right = this.right;
+        frustum.top = this.top;
+        frustum.bottom = this.bottom;
+        frustum.near = this.near;
+        frustum.far = this.far;
+        return frustum;
+    };
+
+    /**
+     * Compares the provided OrthographicFrustum componentwise and returns
+     * <code>true</code> if they are equal, <code>false</code> otherwise.
+     *
+     * @memberof OrthographicFrustum
+     *
+     * @param {OrthographicFrustum} [other] The right hand side OrthographicFrustum.
+     * @return {Boolean} <code>true</code> if they are equal, <code>false</code> otherwise.
+     */
+    OrthographicFrustum.prototype.equals = function(other) {
+        return (typeof other !== 'undefined' &&
+                this.right === other.right &&
+                this.left === other.left &&
+                this.top === other.top &&
+                this.bottom === other.bottom &&
+                this.near === other.near &&
+                this.far === other.far);
+    };
+
+    return OrthographicFrustum;
+});