cesium 0.13.0

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

@@ -0,0 +1,374 @@
+/*global define*/
+define([
+        '../Core/clone',
+        '../Core/defaultValue',
+        '../Core/freezeObject',
+        '../Core/writeTextToCanvas',
+        '../Core/DeveloperError',
+        '../Core/Event',
+        '../Core/Extent',
+        './ImageryProvider',
+        './WebMercatorTilingScheme',
+        './GeographicTilingScheme'
+    ], function(
+        clone,
+        defaultValue,
+        freezeObject,
+        writeTextToCanvas,
+        DeveloperError,
+        Event,
+        Extent,
+        ImageryProvider,
+        WebMercatorTilingScheme,
+        GeographicTilingScheme) {
+    "use strict";
+
+    /**
+     * Provides tiled imagery hosted by a Web Map Service (WMS) server.
+     *
+     * @alias WebMapServiceImageryProvider
+     * @constructor
+     *
+     * @param {String} description.url The URL of the WMS service.
+     * @param {String} description.layers The layers to include, separated by commas.
+     * @param {Object} [description.parameters=WebMapServiceImageryProvider.DefaultParameters] Additional parameters to pass to the WMS server in the GetMap URL.
+     * @param {Extent} [description.extent=Extent.MAX_VALUE] The extent of the layer.
+     * @param {Number} [description.maximumLevel] The maximum level-of-detail supported by the imagery provider.
+     *        If not specified, there is no limit.
+     * @param {String} [description.credit] A string crediting the data source, which is displayed on the canvas.
+     * @param {Object} [description.proxy] A proxy to use for requests. This object is
+     *        expected to have a getURL function which returns the proxied URL, if needed.
+     *
+     * @exception {DeveloperError} <code>description.url</code> is required.
+     * @exception {DeveloperError} <code>description.layers</code> is required.
+     *
+     * @see ArcGisMapServerImageryProvider
+     * @see BingMapsImageryProvider
+     * @see SingleTileImageryProvider
+     * @see TileMapServiceImageryProvider
+     * @see OpenStreetMapImageryProvider
+     *
+     * @see <a href='http://resources.esri.com/help/9.3/arcgisserver/apis/rest/'>ArcGIS Server REST API</a>
+     * @see <a href='http://www.w3.org/TR/cors/'>Cross-Origin Resource Sharing</a>
+     *
+     * @example
+     * var provider = new WebMapServiceImageryProvider({
+     *     url: 'http://sampleserver1.arcgisonline.com/ArcGIS/services/Specialty/ESRI_StatesCitiesRivers_USA/MapServer/WMSServer',
+     *     layers : '0',
+     *     proxy: new Cesium.DefaultProxy('/proxy/')
+     * });
+     */
+    var WebMapServiceImageryProvider = function WebMapServiceImageryProvider(description) {
+        description = defaultValue(description, {});
+
+        if (typeof description.url === 'undefined') {
+            throw new DeveloperError('description.url is required.');
+        }
+
+        if (typeof description.layers === 'undefined') {
+            throw new DeveloperError('description.layers is required.');
+        }
+
+        this._url = description.url;
+        this._tileDiscardPolicy = description.tileDiscardPolicy;
+        this._proxy = description.proxy;
+        this._layers = description.layers;
+
+        // Merge the parameters with the defaults, and make all parameter names lowercase
+        var parameters = clone(WebMapServiceImageryProvider.DefaultParameters);
+        if (typeof description.parameters !== 'undefined') {
+            for (var parameter in description.parameters) {
+                if (description.parameters.hasOwnProperty(parameter)) {
+                    var parameterLowerCase = parameter.toLowerCase();
+                    parameters[parameterLowerCase] = description.parameters[parameter];
+                }
+            }
+        }
+
+        this._parameters = parameters;
+
+        this._tileWidth = 256;
+        this._tileHeight = 256;
+        this._maximumLevel = description.maximumLevel; // undefined means no limit
+
+        var extent = defaultValue(description.extent, Extent.MAX_VALUE);
+        this._tilingScheme = new GeographicTilingScheme({
+            extent : extent
+        });
+
+        if (typeof description.credit !== 'undefined') {
+            this._logo = writeTextToCanvas(description.credit, {
+                font : '12px sans-serif'
+            });
+        }
+
+        this._errorEvent = new Event();
+
+        this._ready = true;
+    };
+
+    function buildImageUrl(imageryProvider, x, y, level) {
+        var url = imageryProvider._url;
+        var indexOfQuestionMark = url.indexOf('?');
+        if (indexOfQuestionMark >= 0 && indexOfQuestionMark < url.length - 1) {
+            if (url[url.length - 1] !== '&') {
+                url += '&';
+            }
+        } else if (indexOfQuestionMark < 0) {
+            url += '?';
+        }
+
+        var parameters = imageryProvider._parameters;
+        for (var parameter in parameters) {
+            if (parameters.hasOwnProperty(parameter)) {
+                url += parameter + '=' + parameters[parameter] + '&';
+            }
+        }
+
+        if (typeof parameters.layers === 'undefined') {
+            url += 'layers=' + imageryProvider._layers + '&';
+        }
+
+        if (typeof parameters.srs === 'undefined') {
+            url += 'srs=EPSG:4326&';
+        }
+
+        if (typeof parameters.bbox === 'undefined') {
+            var nativeExtent = imageryProvider._tilingScheme.tileXYToNativeExtent(x, y, level);
+            var bbox = nativeExtent.west + ',' + nativeExtent.south + ',' + nativeExtent.east + ',' + nativeExtent.north;
+            url += 'bbox=' + bbox + '&';
+        }
+
+        if (typeof parameters.width === 'undefined') {
+            url += 'width=256&';
+        }
+
+        if (typeof parameters.height === 'undefined') {
+            url += 'height=256&';
+        }
+
+        var proxy = imageryProvider._proxy;
+        if (typeof proxy !== 'undefined') {
+            url = proxy.getURL(url);
+        }
+
+        return url;
+    }
+
+    /**
+     * Gets the URL of the WMS server.
+     *
+     * @memberof WebMapServiceImageryProvider
+     *
+     * @returns {String} The URL.
+     */
+    WebMapServiceImageryProvider.prototype.getUrl = function() {
+        return this._url;
+    };
+
+    /**
+     * Gets the names of the WMS layers, separated by commas.
+     *
+     * @memberof WebMapServiceImageryProvider
+     *
+     * @returns {String} The layer names.
+     */
+    WebMapServiceImageryProvider.prototype.getLayers = function() {
+        return this._layers;
+    };
+
+    /**
+     * Gets the width of each tile, in pixels.  This function should
+     * not be called before {@link WebMapServiceImageryProvider#isReady} returns true.
+     *
+     * @memberof WebMapServiceImageryProvider
+     *
+     * @returns {Number} The width.
+     *
+     * @exception {DeveloperError} <code>getTileWidth</code> must not be called before the imagery provider is ready.
+     */
+    WebMapServiceImageryProvider.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 WebMapServiceImageryProvider#isReady} returns true.
+     *
+     * @memberof WebMapServiceImageryProvider
+     *
+     * @returns {Number} The height.
+     *
+     * @exception {DeveloperError} <code>getTileHeight</code> must not be called before the imagery provider is ready.
+     */
+    WebMapServiceImageryProvider.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 WebMapServiceImageryProvider#isReady} returns true.
+     *
+     * @memberof WebMapServiceImageryProvider
+     *
+     * @returns {Number} The maximum level.
+     *
+     * @exception {DeveloperError} <code>getMaximumLevel</code> must not be called before the imagery provider is ready.
+     */
+    WebMapServiceImageryProvider.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 WebMapServiceImageryProvider#isReady} returns true.
+     *
+     * @memberof WebMapServiceImageryProvider
+     *
+     * @returns {TilingScheme} The tiling scheme.
+     * @see WebMercatorTilingScheme
+     * @see GeographicTilingScheme
+     *
+     * @exception {DeveloperError} <code>getTilingScheme</code> must not be called before the imagery provider is ready.
+     */
+    WebMapServiceImageryProvider.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 WebMapServiceImageryProvider#isReady} returns true.
+     *
+     * @memberof WebMapServiceImageryProvider
+     *
+     * @returns {Extent} The extent.
+     *
+     * @exception {DeveloperError} <code>getExtent</code> must not be called before the imagery provider is ready.
+     */
+    WebMapServiceImageryProvider.prototype.getExtent = function() {
+        if (!this._ready) {
+            throw new DeveloperError('getExtent must not be called before the imagery provider is ready.');
+        }
+        return this._tilingScheme.getExtent();
+    };
+
+    /**
+     * 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 WebMapServiceImageryProvider#isReady} returns true.
+     *
+     * @memberof WebMapServiceImageryProvider
+     *
+     * @returns {TileDiscardPolicy} The discard policy.
+     *
+     * @see DiscardMissingTileImagePolicy
+     * @see NeverTileDiscardPolicy
+     *
+     * @exception {DeveloperError} <code>getTileDiscardPolicy</code> must not be called before the imagery provider is ready.
+     */
+    WebMapServiceImageryProvider.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 WebMapServiceImageryProvider
+     *
+     * @returns {Event} The event.
+     */
+    WebMapServiceImageryProvider.prototype.getErrorEvent = function() {
+        return this._errorEvent;
+    };
+
+    /**
+     * Gets a value indicating whether or not the provider is ready for use.
+     *
+     * @memberof WebMapServiceImageryProvider
+     *
+     * @returns {Boolean} True if the provider is ready to use; otherwise, false.
+     */
+    WebMapServiceImageryProvider.prototype.isReady = function() {
+        return this._ready;
+    };
+
+    /**
+     * Requests the image for a given tile.  This function should
+     * not be called before {@link WebMapServiceImageryProvider#isReady} returns true.
+     *
+     * @memberof WebMapServiceImageryProvider
+     *
+     * @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.
+     */
+    WebMapServiceImageryProvider.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 WebMapServiceImageryProvider#isReady} returns true.
+     *
+     * @memberof WebMapServiceImageryProvider
+     *
+     * @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.
+     */
+    WebMapServiceImageryProvider.prototype.getLogo = function() {
+        if (!this._ready) {
+            throw new DeveloperError('getLogo must not be called before the imagery provider is ready.');
+        }
+        return this._logo;
+    };
+
+    /**
+     * The default parameters to include in the WMS URL to obtain images.  The values are as follows:
+     *    service=WMS
+     *    version=1.1.1
+     *    request=GetMap
+     *    styles=
+     *    format=image/jpeg
+     *
+     * @memberof WebMapServiceImageryProvider
+     */
+    WebMapServiceImageryProvider.DefaultParameters = freezeObject({
+        service : 'WMS',
+        version : '1.1.1',
+        request : 'GetMap',
+        styles : '',
+        format : 'image/jpeg'
+    });
+
+    return WebMapServiceImageryProvider;
+});

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

@@ -0,0 +1,291 @@
+/*global define*/
+define([
+        '../Core/defaultValue',
+        '../Core/DeveloperError',
+        '../Core/Math',
+        '../Core/Ellipsoid',
+        '../Core/Extent',
+        '../Core/Cartesian2',
+        '../Core/Cartographic',
+        '../Core/WebMercatorProjection',
+        './TilingScheme'
+    ], function(
+        defaultValue,
+        DeveloperError,
+        CesiumMath,
+        Ellipsoid,
+        Extent,
+        Cartesian2,
+        Cartographic,
+        WebMercatorProjection,
+        TilingScheme) {
+    "use strict";
+
+    /**
+     * A tiling scheme for geometry referenced to a {@link WebMercatorProjection}, EPSG:3857.  This is
+     * the tiling scheme used by Google Maps, Microsoft Bing Maps, and most of ESRI ArcGIS Online.
+     *
+     * @alias WebMercatorTilingScheme
+     * @constructor
+     *
+     * @param {Ellipsoid} [description.ellipsoid=Ellipsoid.WGS84] The ellipsoid whose surface is being tiled. Defaults to
+     * the WGS84 ellipsoid.
+     * @param {Number} [description.numberOfLevelZeroTilesX=1] The number of tiles in the X direction at level zero of
+     *        the tile tree.
+     * @param {Number} [description.numberOfLevelZeroTilesY=1] The number of tiles in the Y direction at level zero of
+     *        the tile tree.
+     * @param {Cartesian2} [description.extentSouthwestInMeters] The southwest corner of the extent covered by the
+     *        tiling scheme, in meters.  If this parameter or extentNortheastInMeters is not specified, the entire
+     *        globe is covered in the longitude direction and an equal distance is covered in the latitude
+     *        direction, resulting in a square projection.
+     * @param {Cartesian2} [description.extentNortheastInMeters] The northeast corner of the extent covered by the
+     *        tiling scheme, in meters.  If this parameter or extentSouthwestInMeters is not specified, the entire
+     *        globe is covered in the longitude direction and an equal distance is covered in the latitude
+     *        direction, resulting in a square projection.
+     */
+    var WebMercatorTilingScheme = function WebMercatorTilingScheme(description) {
+        description = defaultValue(description, {});
+
+        this._ellipsoid = defaultValue(description.ellipsoid, Ellipsoid.WGS84);
+        this._numberOfLevelZeroTilesX = defaultValue(description.numberOfLevelZeroTilesX, 1);
+        this._numberOfLevelZeroTilesY = defaultValue(description.numberOfLevelZeroTilesY, 1);
+
+        this._projection = new WebMercatorProjection(this._ellipsoid);
+
+        if (typeof description.extentSouthwestInMeters !== 'undefined' &&
+            typeof description.extentNortheastInMeters !== 'undefined') {
+            this._extentSouthwestInMeters = description.extentSouthwestInMeters;
+            this._extentNortheastInMeters = description.extentNortheastInMeters;
+        } else {
+            var semimajorAxisTimesPi = this._ellipsoid.getMaximumRadius() * Math.PI;
+            this._extentSouthwestInMeters = new Cartesian2(-semimajorAxisTimesPi, -semimajorAxisTimesPi);
+            this._extentNortheastInMeters = new Cartesian2(semimajorAxisTimesPi, semimajorAxisTimesPi);
+        }
+
+        var southwest = this._projection.unproject(this._extentSouthwestInMeters);
+        var northeast = this._projection.unproject(this._extentNortheastInMeters);
+        this._extent = new Extent(southwest.longitude, southwest.latitude,
+                                  northeast.longitude, northeast.latitude);
+    };
+
+    /**
+     * Gets the ellipsoid that is tiled by this tiling scheme.
+     *
+     * @memberof WebMercatorTilingScheme
+     *
+     * @returns {Ellipsoid} The ellipsoid.
+     */
+    WebMercatorTilingScheme.prototype.getEllipsoid = function() {
+        return this._ellipsoid;
+    };
+
+    /**
+     * Gets the extent, in radians, covered by this tiling scheme.
+     *
+     * @memberof WebMercatorTilingScheme
+     *
+     * @returns {Extent} The extent.
+     */
+    WebMercatorTilingScheme.prototype.getExtent = function() {
+        return this._extent;
+    };
+
+    /**
+     * Gets the map projection used by this tiling scheme.
+     *
+     * @memberof WebMercatorTilingScheme
+     *
+     * @returns {Projection} The map projection.
+     */
+    WebMercatorTilingScheme.prototype.getProjection = function() {
+        return this._projection;
+    };
+
+    /**
+     * Gets the total number of tiles in the X direction at a specified level-of-detail.
+     *
+     * @memberof WebMercatorTilingScheme
+     *
+     * @param {Number} level The level-of-detail.
+     * @returns {Number} The number of tiles in the X direction at the given level.
+     */
+    WebMercatorTilingScheme.prototype.getNumberOfXTilesAtLevel = function(level) {
+        return this._numberOfLevelZeroTilesX << level;
+    };
+
+    /**
+     * Gets the total number of tiles in the Y direction at a specified level-of-detail.
+     *
+     * @memberof WebMercatorTilingScheme
+     *
+     * @param {Number} level The level-of-detail.
+     * @returns {Number} The number of tiles in the Y direction at the given level.
+     */
+    WebMercatorTilingScheme.prototype.getNumberOfYTilesAtLevel = function(level) {
+        return this._numberOfLevelZeroTilesY << level;
+    };
+
+    /**
+     * Creates the tile or tiles at level of detail zero, the coarsest, least detailed level.
+     *
+     * @memberof WebMercatorTilingScheme
+     *
+     * @returns {Array} An array containing the tiles at level of detail zero, starting with the
+     * tile in the northwest corner of the globe and followed by the tile (if any) to its east.
+     */
+    WebMercatorTilingScheme.prototype.createLevelZeroTiles = function() {
+        return TilingScheme.createRectangleOfLevelZeroTiles(this, this._numberOfLevelZeroTilesX, this._numberOfLevelZeroTilesY);
+    };
+
+    /**
+     * Transforms an extent specified in geodetic radians to the native coordinate system
+     * of this tiling scheme.
+     *
+     * @memberof WebMercatorTilingScheme
+     *
+     * @param {Extent} extent The extent to transform.
+     * @param {Extent} [result] The instance to which to copy the result, or undefined if a new instance
+     *        should be created.
+     * @returns {Extent} The specified 'result', or a new object containing the native extent if 'result'
+     *          is undefined.
+     */
+    WebMercatorTilingScheme.prototype.extentToNativeExtent = function(extent, result) {
+        var projection = this._projection;
+        var southwest = projection.project(extent.getSouthwest());
+        var northeast = projection.project(extent.getNortheast());
+
+        if (typeof result === 'undefined') {
+            return new Extent(southwest.x, southwest.y, northeast.x, northeast.y);
+        }
+
+        result.west = southwest.x;
+        result.south = southwest.y;
+        result.east = northeast.x;
+        result.north = northeast.y;
+        return result;
+    };
+
+    /**
+     * Converts tile x, y coordinates and level to an extent expressed in the native coordinates
+     * of the tiling scheme.
+     *
+     * @memberof WebMercatorTilingScheme
+     *
+     * @param {Number} x The integer x coordinate of the tile.
+     * @param {Number} y The integer y coordinate of the tile.
+     * @param {Number} level The tile level-of-detail.  Zero is the least detailed.
+     * @param {Object} [result] The instance to which to copy the result, or undefined if a new instance
+     *        should be created.
+     *
+     * @returns {Extent} The specified 'result', or a new object containing the extent
+     *          if 'result' is undefined.
+     */
+    WebMercatorTilingScheme.prototype.tileXYToNativeExtent = function(x, y, level, result) {
+        var xTiles = this.getNumberOfXTilesAtLevel(level);
+        var yTiles = this.getNumberOfYTilesAtLevel(level);
+
+        var xTileWidth = (this._extentNortheastInMeters.x - this._extentSouthwestInMeters.x) / xTiles;
+        var west = this._extentSouthwestInMeters.x + x * xTileWidth;
+        var east = this._extentSouthwestInMeters.x + (x + 1) * xTileWidth;
+
+        var yTileHeight = (this._extentNortheastInMeters.y - this._extentSouthwestInMeters.y) / yTiles;
+        var north = this._extentNortheastInMeters.y - y * yTileHeight;
+        var south = this._extentNortheastInMeters.y - (y + 1) * yTileHeight;
+
+        if (typeof result === 'undefined') {
+            return new Extent(west, south, east, north);
+        }
+
+        result.west = west;
+        result.south = south;
+        result.east = east;
+        result.north = north;
+        return result;
+    };
+
+    /**
+     * Converts tile x, y coordinates and level to a cartographic extent in radians.
+     *
+     * @memberof GeographicTilingScheme
+     *
+     * @param {Number} x The integer x coordinate of the tile.
+     * @param {Number} y The integer y coordinate of the tile.
+     * @param {Number} level The tile level-of-detail.  Zero is the least detailed.
+     * @param {Object} [result] The instance to which to copy the result, or undefined if a new instance
+     *        should be created.
+     *
+     * @returns {Extent} The specified 'result', or a new object containing the extent
+     *          if 'result' is undefined.
+     */
+    WebMercatorTilingScheme.prototype.tileXYToExtent = function(x, y, level, result) {
+        var nativeExtent = this.tileXYToNativeExtent(x, y, level, result);
+
+        var projection = this._projection;
+        var southwest = projection.unproject(new Cartesian2(nativeExtent.west, nativeExtent.south));
+        var northeast = projection.unproject(new Cartesian2(nativeExtent.east, nativeExtent.north));
+
+        nativeExtent.west = southwest.longitude;
+        nativeExtent.south = southwest.latitude;
+        nativeExtent.east = northeast.longitude;
+        nativeExtent.north = northeast.latitude;
+        return nativeExtent;
+    };
+
+    /**
+     * Calculates the tile x, y coordinates of the tile containing
+     * a given cartographic position.
+     *
+     * @memberof GeographicTilingScheme
+     *
+     * @param {Cartographic} position The position.
+     * @param {Number} level The tile level-of-detail.  Zero is the least detailed.
+     * @param {Cartesian} [result] The instance to which to copy the result, or undefined if a new instance
+     *        should be created.
+     *
+     * @returns {Cartesian2} The specified 'result', or a new object containing the tile x, y coordinates
+     *          if 'result' is undefined.
+     */
+    WebMercatorTilingScheme.prototype.positionToTileXY = function(position, level, result) {
+        var extent = this._extent;
+        if (position.latitude > extent.north ||
+            position.latitude < extent.south ||
+            position.longitude < extent.west ||
+            position.longitude > extent.east) {
+            // outside the bounds of the tiling scheme
+            return undefined;
+        }
+
+        var xTiles = this.getNumberOfXTilesAtLevel(level);
+        var yTiles = this.getNumberOfYTilesAtLevel(level);
+
+        var overallWidth = this._extentNortheastInMeters.x - this._extentSouthwestInMeters.x;
+        var xTileWidth = overallWidth / xTiles;
+        var overallHeight = this._extentNortheastInMeters.y - this._extentSouthwestInMeters.y;
+        var yTileHeight = overallHeight / yTiles;
+
+        var projection = this._projection;
+
+        var webMercatorPosition = projection.project(position);
+        var distanceFromWest = webMercatorPosition.x - this._extentSouthwestInMeters.x;
+        var distanceFromNorth = this._extentNortheastInMeters.y - webMercatorPosition.y;
+
+        var xTileCoordinate = distanceFromWest / xTileWidth | 0;
+        if (xTileCoordinate >= xTiles) {
+            xTileCoordinate = xTiles - 1;
+        }
+        var yTileCoordinate = distanceFromNorth / yTileHeight | 0;
+        if (yTileCoordinate >= yTiles) {
+            yTileCoordinate = yTiles - 1;
+        }
+
+        if (typeof result === 'undefined') {
+            return new Cartesian2(xTileCoordinate, yTileCoordinate);
+        }
+
+        result.x = xTileCoordinate;
+        result.y = yTileCoordinate;
+        return result;
+    };
+
+    return WebMercatorTilingScheme;
+});