cesium 0.13.0

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

@@ -0,0 +1,42 @@
+/*global define*/
+define([
+        '../Core/DeveloperError'
+    ], function(
+        DeveloperError) {
+    "use strict";
+
+    /**
+     * A policy for discarding tile images according to some criteria.  This type describes an
+     * interface and is not intended to be instantiated directly.
+     *
+     * @alias TileDiscardPolicy
+     * @constructor
+     *
+     * @see DiscardMissingTileImagePolicy
+     * @see NeverTileDiscardPolicy
+     */
+    var TileDiscardPolicy = function(description) {
+        throw new DeveloperError('This type should not be instantiated directly.');
+    };
+
+    /**
+     * Determines if the discard policy is ready to process images.
+     * @returns {Boolean} True if the discard policy is ready to process images; otherwise, false.
+     */
+    TileDiscardPolicy.prototype.isReady = function() {
+        throw new DeveloperError('This type should not be instantiated directly.');
+    };
+
+    /**
+     * 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 {Boolean} A promise that will resolve to true if the tile should be discarded.
+     */
+    TileDiscardPolicy.prototype.shouldDiscardImage = function(image) {
+        throw new DeveloperError('This type should not be instantiated directly.');
+    };
+
+    return TileDiscardPolicy;
+});

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

@@ -0,0 +1,36 @@
+/*global define*/
+define(function() {
+    "use strict";
+
+    /**
+     * The assocation between a terrain tile and an imagery tile.
+     *
+     * @alias TileImagery
+     * @private
+     *
+     * @param {Imagery} imagery The imagery tile.
+     * @param {Cartesian4} textureCoordinateExtent The texture extent extent of the tile that is covered
+     *        by the imagery, where X=west, Y=south, Z=east, W=north.
+     */
+    var TileImagery = function(imagery, textureCoordinateExtent) {
+        this.imagery = imagery;
+        this.textureCoordinateExtent = textureCoordinateExtent;
+        this.originalImagery = undefined;
+        this.textureTranslationAndScale = undefined;
+    };
+
+    /**
+     * Frees the resources held by this instance.
+     *
+     * @memberof TileImagery
+     */
+    TileImagery.prototype.freeResources = function() {
+        this.imagery.releaseReference();
+
+        if (typeof this.originalImagery !== 'undefined') {
+            this.originalImagery.releaseReference();
+        }
+    };
+
+    return TileImagery;
+});

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

@@ -0,0 +1,123 @@
+/*global define*/
+define(function() {
+    "use strict";
+
+    /**
+     * A priority queue of tiles to be loaded, implemented as a linked list.
+     *
+     * @alias TileLoadQueue
+     * @private
+     */
+    var TileLoadQueue = function TileLoadQueue() {
+        this.head = undefined;
+        this.tail = undefined;
+        this._insertionPoint = undefined;
+    };
+
+    /**
+     * Removes a tile from the load queue.
+     *
+     * @memberof TileLoadQueue
+     *
+     * @param {Tile} item The tile to remove from the load queue.
+     */
+    TileLoadQueue.prototype.remove = function(item) {
+        var previous = item.loadPrevious;
+        var next = item.loadNext;
+
+        if (item === this.head) {
+            this.head = next;
+        } else {
+            previous.loadNext = next;
+        }
+
+        if (item === this.tail) {
+            this.tail = previous;
+        } else {
+            next.loadPrevious = previous;
+        }
+
+        item.loadPrevious = undefined;
+        item.loadNext = undefined;
+    };
+
+    /**
+     * Marks the point at which new tiles will be inserted into the queue, which is initially the
+     * head of the queue.  As each new tile is added to or repositioned in the queue, the insertion
+     * point represents the first tile that was not added or repositioned this frame.
+     *
+     * @memberof TileLoadQueue
+     */
+    TileLoadQueue.prototype.markInsertionPoint = function() {
+        this._insertionPoint = this.head;
+    };
+
+    /**
+     * Inserts (or repositions) a tile to place it just before the insertion point.
+     *
+     * @memberof TileLoadQueue
+     *
+     * @param {Tile} item The tile to insert or reposition.
+     */
+    TileLoadQueue.prototype.insertBeforeInsertionPoint = function(item) {
+        var insertionPoint = this._insertionPoint;
+        if (insertionPoint === item) {
+            return;
+        }
+
+        if (typeof this.head === 'undefined') {
+            // no other tiles in the list
+            item.loadPrevious = undefined;
+            item.loadNext = undefined;
+            this.head = item;
+            this.tail = item;
+            return;
+        }
+
+        if (typeof item.loadPrevious !== 'undefined' || typeof item.loadNext !== 'undefined') {
+            // tile already in the list, remove from its current location
+            this.remove(item);
+        }
+
+        if (typeof insertionPoint === 'undefined') {
+            item.loadPrevious = this.tail;
+            item.loadNext = undefined;
+            this.tail.loadNext = item;
+            this.tail = item;
+            return;
+        }
+
+        var insertAfter = insertionPoint.loadPrevious;
+        item.loadPrevious = insertAfter;
+        if (typeof insertAfter !== 'undefined') {
+            insertAfter.loadNext = item;
+        }
+
+        item.loadNext = insertionPoint;
+        insertionPoint.loadPrevious = item;
+
+        if (insertionPoint === this.head) {
+            this.head = item;
+        }
+    };
+
+    /**
+     * Clears the queue, removing all tiles.
+     *
+     * @memberof TileLoadQueue
+     */
+    TileLoadQueue.prototype.clear = function() {
+        var item = this.head;
+        while (typeof item !== 'undefined') {
+            var next = item.loadNext;
+            item.loadNext = undefined;
+            item.loadPrevious = undefined;
+            item = next;
+        }
+        this.head = undefined;
+        this.tail = undefined;
+        this._insertionPoint = undefined;
+    };
+
+    return TileLoadQueue;
+});

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

@@ -0,0 +1,337 @@
+/*global define*/
+define([
+        '../Core/defaultValue',
+        '../Core/Cartographic',
+        '../Core/DeveloperError',
+        '../Core/Event',
+        '../Core/loadXML',
+        '../Core/writeTextToCanvas',
+        '../Core/Extent',
+        './ImageryProvider',
+        './WebMercatorTilingScheme',
+        './GeographicTilingScheme'
+    ], function(
+        defaultValue,
+        Cartographic,
+        DeveloperError,
+        Event,
+        loadXML,
+        writeTextToCanvas,
+        Extent,
+        ImageryProvider,
+        WebMercatorTilingScheme,
+        GeographicTilingScheme) {
+    "use strict";
+
+    var trailingSlashRegex = /\/$/;
+
+    /**
+     * Provides tiled imagery as generated by <a href='http://www.maptiler.org/'>MapTiler</a> / <a href='http://www.klokan.cz/projects/gdal2tiles/'>GDDAL2Tiles</a> etc.
+     *
+     * @alias TileMapServiceImageryProvider
+     * @constructor
+     *
+     * @param {String} [description.url='.'] Path to image tiles on server.
+     * @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 {String} [description.credit=''] A string crediting the data source, which is displayed on the canvas.
+     * @param {Number} [description.maximumLevel=18] The maximum level-of-detail supported by the imagery provider.
+     * @param {Extent} [description.extent=Extent.MAX_VALUE] The extent, in radians, covered by the image.
+     * @param {TilingScheme} [description.tilingScheme] The tiling scheme specifying how the ellipsoidal
+     * surface is broken into tiles.  If this parameter is not provided, a {@link WebMercatorTilingScheme}
+     * is used.
+     * @param {Number} [description.tileWidth=256] Pixel width of image tiles.
+     * @param {Number} [description.tileHeight=256] Pixel height of image tiles.
+     *
+     * @see ArcGisMapServerImageryProvider
+     * @see BingMapsImageryProvider
+     * @see OpenStreetMapImageryProvider
+     * @see SingleTileImageryProvider
+     * @see WebMapServiceImageryProvider
+     *
+     * @see <a href='http://www.maptiler.org/'>MapTiler</a>
+     * @see <a href='http://www.klokan.cz/projects/gdal2tiles/'>GDDAL2Tiles</a>
+     * @see <a href='http://www.w3.org/TR/cors/'>Cross-Origin Resource Sharing</a>
+     *
+     * @example
+     * // TileMapService tile provider
+     * var tms = new TileMapServiceImageryProvider({
+     *    url : '../images/cesium_maptiler/Cesium_Logo_Color',
+     *    fileExtension: 'png',
+     *    maximumLevel: 4,
+     *    extent: new Cesium.Extent(
+     *        Cesium.Math.toRadians(-120.0),
+     *        Cesium.Math.toRadians(20.0),
+     *        Cesium.Math.toRadians(-60.0),
+     *        Cesium.Math.toRadians(40.0))
+     * });
+     */
+    var TileMapServiceImageryProvider = function TileMapServiceImageryProvider(description) {
+        description = defaultValue(description, {});
+
+        if (typeof description.url === 'undefined') {
+            throw new DeveloperError('description.url is required.');
+        }
+
+        var url = description.url;
+
+        if (!trailingSlashRegex.test(url)) {
+            url = url + '/';
+        }
+
+        this._url = url;
+        this._ready = false;
+
+        this._proxy = description.proxy;
+        this._tileDiscardPolicy = description.tileDiscardPolicy;
+
+        this._errorEvent = new Event();
+
+        var credit = description.credit;
+        if (typeof credit !== 'undefined') {
+            this._logo = writeTextToCanvas(credit, {
+                font : '12px sans-serif'
+            });
+        }
+
+        var that = this;
+
+        // Try to load remaing parameters from XML
+        loadXML(url + 'tilemapresource.xml').then(function(xml) {
+            // Allowing description properties to override XML values
+            var format = xml.getElementsByTagName('TileFormat')[0];
+            that._fileExtension = defaultValue(description.fileExtension, format.getAttribute('extension'));
+            that._tileWidth = defaultValue(description.tileWidth, parseInt(format.getAttribute('width'), 10));
+            that._tileHeight = defaultValue(description.tileHeight, parseInt(format.getAttribute('height'), 10));
+            var tilesets = xml.getElementsByTagName('TileSet');
+            that._maximumLevel = defaultValue(description.maximumLevel, parseInt(tilesets[tilesets.length - 1].getAttribute('order'), 10));
+
+            // extent handling
+            that._extent = description.extent;
+            if (typeof that._extent === 'undefined') {
+                var bbox = xml.getElementsByTagName('BoundingBox')[0];
+                var sw = Cartographic.fromDegrees(parseFloat(bbox.getAttribute('miny')), parseFloat(bbox.getAttribute('minx')));
+                var ne = Cartographic.fromDegrees(parseFloat(bbox.getAttribute('maxy')), parseFloat(bbox.getAttribute('maxx')));
+                that._extent = new Extent(sw.longitude, sw.latitude, ne.longitude, ne.latitude);
+            } else {
+                that._extent = that._extent.clone();
+            }
+
+            // tiling scheme handling
+            var tilingScheme = description.tilingScheme;
+            if (typeof tilingScheme === 'undefined') {
+                var tilingSchemeName = xml.getElementsByTagName('TileSets')[0].getAttribute('profile');
+                tilingScheme = tilingSchemeName === 'geodetic' ? new GeographicTilingScheme() : new WebMercatorTilingScheme();
+            }
+
+            // The extent must not be outside the bounds allowed by the tiling scheme.
+            if (that._extent.west < tilingScheme.getExtent().west) {
+                that._extent.west = tilingScheme.getExtent().west;
+            }
+            if (that._extent.east > tilingScheme.getExtent().east) {
+                that._extent.east = tilingScheme.getExtent().east;
+            }
+            if (that._extent.south < tilingScheme.getExtent().south) {
+                that._extent.south = tilingScheme.getExtent().south;
+            }
+            if (that._extent.north > tilingScheme.getExtent().north) {
+                that._extent.north = tilingScheme.getExtent().north;
+            }
+
+            that._tilingScheme = tilingScheme;
+            that._ready = true;
+        }, function(error) {
+            // Can't load XML, still allow description and defaults
+            that._fileExtension = defaultValue(description.fileExtension, 'png');
+            that._tileWidth = defaultValue(description.tileWidth, 256);
+            that._tileHeight = defaultValue(description.tileHeight, 256);
+            that._minimumLevel = defaultValue(description.minimumLevel, 0);
+            that._maximumLevel = defaultValue(description.maximumLevel, 18);
+            that._tilingScheme = defaultValue(description.tilingScheme, new WebMercatorTilingScheme());
+            that._extent = defaultValue(description.extent, that._tilingScheme.getExtent());
+            that._ready = true;
+        });
+
+    };
+
+    function buildImageUrl(imageryProvider, x, y, level) {
+        var yTiles = imageryProvider._tilingScheme.getNumberOfYTilesAtLevel(level);
+        var url = imageryProvider._url + level + '/' + x + '/' + (yTiles - y - 1) + '.' + 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 TileMapServiceImageryProvider
+     *
+     * @returns {String} The URL.
+     */
+    TileMapServiceImageryProvider.prototype.getUrl = function() {
+        return this._url;
+    };
+
+    /**
+     * Gets the width of each tile, in pixels.  This function should
+     * not be called before {@link TileMapServiceImageryProvider#isReady} returns true.
+     *
+     * @memberof TileMapServiceImageryProvider
+     *
+     * @returns {Number} The width.
+     */
+    TileMapServiceImageryProvider.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 TileMapServiceImageryProvider#isReady} returns true.
+     *
+     * @memberof TileMapServiceImageryProvider
+     *
+     * @returns {Number} The height.
+     */
+    TileMapServiceImageryProvider.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 TileMapServiceImageryProvider#isReady} returns true.
+     *
+     * @memberof TileMapServiceImageryProvider
+     *
+     * @returns {Number} The maximum level.
+     */
+    TileMapServiceImageryProvider.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 TileMapServiceImageryProvider#isReady} returns true.
+     *
+     * @memberof TileMapServiceImageryProvider
+     *
+     * @returns {TilingScheme} The tiling scheme.
+     * @see WebMercatorTilingScheme
+     * @see GeographicTilingScheme
+     */
+    TileMapServiceImageryProvider.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 TileMapServiceImageryProvider#isReady} returns true.
+     *
+     * @memberof TileMapServiceImageryProvider
+     *
+     * @returns {Extent} The extent.
+     */
+    TileMapServiceImageryProvider.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 TileMapServiceImageryProvider#isReady} returns true.
+     *
+     * @memberof TileMapServiceImageryProvider
+     *
+     * @returns {TileDiscardPolicy} The discard policy.
+     *
+     * @see DiscardMissingTileImagePolicy
+     * @see NeverTileDiscardPolicy
+     */
+    TileMapServiceImageryProvider.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 TileMapServiceImageryProvider
+     *
+     * @returns {Event} The event.
+     */
+    TileMapServiceImageryProvider.prototype.getErrorEvent = function() {
+        return this._errorEvent;
+    };
+
+    /**
+     * Gets a value indicating whether or not the provider is ready for use.
+     *
+     * @memberof TileMapServiceImageryProvider
+     *
+     * @returns {Boolean} True if the provider is ready to use; otherwise, false.
+     */
+    TileMapServiceImageryProvider.prototype.isReady = function() {
+        return this._ready;
+    };
+
+    /**
+     * Requests the image for a given tile.  This function should
+     * not be called before {@link TileMapServiceImageryProvider#isReady} returns true.
+     *
+     * @memberof TileMapServiceImageryProvider
+     *
+     * @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.
+     */
+    TileMapServiceImageryProvider.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 TileMapServiceImageryProvider#isReady} returns true.
+     *
+     * @memberof TileMapServiceImageryProvider
+     *
+     * @returns {Image|Canvas} A canvas or image containing the log to display, or undefined if there is no logo.
+     */
+    TileMapServiceImageryProvider.prototype.getLogo = function() {
+        return this._logo;
+    };
+
+    return TileMapServiceImageryProvider;
+});