import CustomMercatorProjection from './CustomMercatorProjection.js';
|
/**
|
* 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 BJ2000TilingScheme2
|
* @constructor
|
*
|
* @param {Object} [options] Object with the following properties:
|
* @param {Ellipsoid} [options.ellipsoid=Ellipsoid.WGS84] The ellipsoid whose surface is being tiled. Defaults to
|
* the WGS84 ellipsoid.
|
* @param {Number} [options.numberOfLevelZeroTilesX=1] The number of tiles in the X direction at level zero of
|
* the tile tree.
|
* @param {Number} [options.numberOfLevelZeroTilesY=1] The number of tiles in the Y direction at level zero of
|
* the tile tree.
|
* @param {Cartesian2} [options.rectangleSouthwestInMeters] The southwest corner of the rectangle covered by the
|
* tiling scheme, in meters. If this parameter or rectangleNortheastInMeters 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} [options.rectangleNortheastInMeters] The northeast corner of the rectangle covered by the
|
* tiling scheme, in meters. If this parameter or rectangleSouthwestInMeters 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 Cesium = null;
|
function Bj2000TilingScheme(options) {
|
Cesium = options.SmartEarth;
|
options = Cesium.defaultValue(options, Cesium.defaultValue.EMPTY_OBJECT);
|
this._ellipsoid = Cesium.defaultValue(options.ellipsoid, Cesium.Ellipsoid.WGS84);
|
this._numberOfLevelZeroTilesX = Cesium.defaultValue(
|
options.numberOfLevelZeroTilesX,
|
1
|
);
|
this._numberOfLevelZeroTilesY = Cesium.defaultValue(
|
options.numberOfLevelZeroTilesY,
|
1
|
);
|
if(options.customEPSG){
|
this._projection = new CustomMercatorProjection(options.customEPSG,this._ellipsoid,Cesium,options.proj);
|
}else {
|
this._projection = new Cesium.WebMercatorProjection(this._ellipsoid);
|
}
|
if (
|
Cesium.defined(options.rectangleSouthwestInMeters) &&
|
Cesium.defined(options.rectangleNortheastInMeters)
|
) {
|
this._rectangleSouthwestInMeters = options.rectangleSouthwestInMeters;
|
this._rectangleNortheastInMeters = options.rectangleNortheastInMeters;
|
} else {
|
const semimajorAxisTimesPi = this._ellipsoid.maximumRadius * Math.PI;
|
this._rectangleSouthwestInMeters = new Cesium.Cartesian2(
|
-semimajorAxisTimesPi,
|
-semimajorAxisTimesPi
|
);
|
this._rectangleNortheastInMeters = new Cesium.Cartesian2(
|
semimajorAxisTimesPi,
|
semimajorAxisTimesPi
|
);
|
}
|
|
const southwest = this._projection.unproject(
|
this._rectangleSouthwestInMeters
|
);
|
const northeast = this._projection.unproject(
|
this._rectangleNortheastInMeters
|
);
|
this._rectangle = new Cesium.Rectangle(
|
southwest.longitude,
|
southwest.latitude,
|
northeast.longitude,
|
northeast.latitude
|
);
|
this._resolutions = Cesium.defaultValue(options.resolutions,[0]);
|
this._origin = Cesium.defaultValue(options.origin, [0,0]);
|
this.tileWidth = Cesium.defaultValue(options.tileWidth, 256);
|
this.tileHeight = Cesium.defaultValue(options.tileHeight, 256);
|
}
|
|
Object.defineProperties(Bj2000TilingScheme.prototype, {
|
/**
|
* Gets the ellipsoid that is tiled by this tiling scheme.
|
* @memberof Bj2000TilingScheme.prototype
|
* @type {Ellipsoid}
|
*/
|
ellipsoid: {
|
get: function () {
|
return this._ellipsoid;
|
},
|
},
|
|
/**
|
* Gets the rectangle, in radians, covered by this tiling scheme.
|
* @memberof Bj2000TilingScheme.prototype
|
* @type {Rectangle}
|
*/
|
rectangle: {
|
get: function () {
|
return this._rectangle;
|
},
|
},
|
|
/**
|
* Gets the map projection used by this tiling scheme.
|
* @memberof Bj2000TilingScheme.prototype
|
* @type {MapProjection}
|
*/
|
projection: {
|
get: function () {
|
return this._projection;
|
},
|
},
|
rectangleNortheastInMeters:{
|
get: function() {
|
return this._rectangleNortheastInMeters;
|
}
|
},
|
rectangleSouthwestInMeters:{
|
get: function() {
|
return this._rectangleSouthwestInMeters;
|
}
|
},
|
});
|
|
/**
|
* Gets the total number of tiles in the X direction at a specified level-of-detail.
|
*
|
* @param {Number} level The level-of-detail.
|
* @returns {Number} The number of tiles in the X direction at the given level.
|
*/
|
Bj2000TilingScheme.prototype.getNumberOfXTilesAtLevel = function (level) {
|
return this._numberOfLevelZeroTilesX << level;
|
};
|
|
/**
|
* Gets the total number of tiles in the Y direction at a specified level-of-detail.
|
*
|
* @param {Number} level The level-of-detail.
|
* @returns {Number} The number of tiles in the Y direction at the given level.
|
*/
|
Bj2000TilingScheme.prototype.getNumberOfYTilesAtLevel = function (level) {
|
return this._numberOfLevelZeroTilesY << level;
|
};
|
|
/**
|
* Transforms a rectangle specified in geodetic radians to the native coordinate system
|
* of this tiling scheme.
|
*
|
* @param {Rectangle} rectangle The rectangle to transform.
|
* @param {Rectangle} [result] The instance to which to copy the result, or undefined if a new instance
|
* should be created.
|
* @returns {Rectangle} The specified 'result', or a new object containing the native rectangle if 'result'
|
* is undefined.
|
*/
|
Bj2000TilingScheme.prototype.rectangleToNativeRectangle = function (
|
rectangle,
|
result
|
) {
|
const projection = this._projection;
|
const southwest = projection.project(Cesium.Rectangle.southwest(rectangle));
|
const northeast = projection.project(Cesium.Rectangle.northeast(rectangle));
|
|
if (!Cesium.defined(result)) {
|
return new Cesium.Rectangle(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 a rectangle expressed in the native coordinates
|
* of the tiling scheme.
|
*
|
* @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 {Rectangle} The specified 'result', or a new object containing the rectangle
|
* if 'result' is undefined.
|
*/
|
Bj2000TilingScheme.prototype.tileXYToNativeRectangle = function (
|
x,
|
y,
|
level,
|
result
|
) {
|
level +=6;
|
const xTiles = this.getNumberOfXTilesAtLevel(level);
|
const yTiles = this.getNumberOfYTilesAtLevel(level);
|
|
const resolution = this._resolutions[level];
|
const eastFromOrigin = this._rectangleNortheastInMeters.x - this._origin[0];
|
const southFromOrigin = this._origin[1] - this._rectangleSouthwestInMeters.y;
|
const xTileWidth = eastFromOrigin / xTiles;
|
const yTileHeight = southFromOrigin / yTiles;
|
|
// let west = this._origin[0] + x * xTileWidth;
|
// let east = this._origin[0] + (x + 1) * xTileWidth;
|
// if(west < this._rectangleSouthwestInMeters.x){
|
// west = this._rectangleSouthwestInMeters.x;
|
// }
|
// if(east >= this._rectangleNortheastInMeters.x) {
|
// east = this._rectangleNortheastInMeters.x;
|
// }
|
const west = this._origin[0] + x * this.tileWidth * resolution;
|
const east = west + this.tileWidth * resolution;
|
|
// let north = this._origin[1] - y * yTileHeight;
|
// let south = this._origin[1] - (y + 1) * yTileHeight;
|
// if(south < this._rectangleSouthwestInMeters.y) {
|
// south = this._rectangleSouthwestInMeters.y;
|
// }
|
// if(north > this._rectangleNortheastInMeters.y) {
|
// north = this._rectangleNortheastInMeters.y;
|
// }
|
|
const south = this._origin[1] - (y + 1) * this.tileHeight * resolution;
|
const north = south + this.tileHeight * resolution;
|
|
if (!Cesium.defined(result)) {
|
return new Cesium.Rectangle(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 rectangle in radians.
|
*
|
* @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 {Rectangle} The specified 'result', or a new object containing the rectangle
|
* if 'result' is undefined.
|
*/
|
Bj2000TilingScheme.prototype.tileXYToRectangle = function (
|
x,
|
y,
|
level,
|
result
|
) {
|
const nativeRectangle = this.tileXYToNativeRectangle(x, y, level, result);
|
const projection = this._projection;
|
const southwest = projection.unproject(
|
new Cesium.Cartesian2(nativeRectangle.west, nativeRectangle.south)
|
);
|
const northeast = projection.unproject(
|
new Cesium.Cartesian2(nativeRectangle.east, nativeRectangle.north)
|
);
|
|
nativeRectangle.west = southwest.longitude;
|
nativeRectangle.south = southwest.latitude;
|
nativeRectangle.east = northeast.longitude;
|
nativeRectangle.north = northeast.latitude;
|
return nativeRectangle;
|
};
|
|
/**
|
* Calculates the tile x, y coordinates of the tile containing
|
* a given cartographic position.
|
*
|
* @param {Cartographic} position The position.
|
* @param {Number} level The tile level-of-detail. Zero is the least detailed.
|
* @param {Cartesian2} [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.
|
*/
|
Bj2000TilingScheme.prototype.positionToTileXY = function (
|
position,
|
level,
|
result
|
) {
|
const rectangle = this._rectangle;
|
if (!Cesium.Rectangle.contains(rectangle, position)) {
|
// outside the bounds of the tiling scheme
|
return undefined;
|
}
|
level +=6;
|
|
const xTiles = this.getNumberOfXTilesAtLevel(level);
|
const yTiles = this.getNumberOfYTilesAtLevel(level);
|
//
|
// const overallWidth =
|
// this._rectangleNortheastInMeters.x - this._rectangleSouthwestInMeters.x;
|
// const xTileWidth = overallWidth / xTiles;
|
// const overallHeight =
|
// this._rectangleNortheastInMeters.y - this._rectangleSouthwestInMeters.y;
|
// const yTileHeight = overallHeight / yTiles;
|
|
const projection = this._projection;
|
|
const webMercatorPosition = projection.project(position);
|
const resolution = this._resolutions[level];
|
const realTileWidth = resolution * this.tileWidth;
|
const realTileHeight = resolution * this.tileHeight;
|
|
let xTileCoordinate = (webMercatorPosition.x - this._origin[0]) / resolution / this.tileWidth;
|
let yTileCoordinate = (this._origin[1] - webMercatorPosition.y) / resolution / this.tileHeight;
|
xTileCoordinate = Math.floor(xTileCoordinate);
|
yTileCoordinate = Math.floor(yTileCoordinate);
|
|
// const westFromOrigin = this._rectangleSouthwestInMeters.x - this._origin[0];
|
// const eastFromOrigin = this._rectangleNortheastInMeters.x - this._origin[0];
|
// const northFromOrigin = this._origin[1] - this._rectangleNortheastInMeters.y;
|
// const southFromOrigin = this._origin[1] - this._rectangleSouthwestInMeters.y;
|
// const xTileWidth = eastFromOrigin / xTiles;
|
// const yTileHeight = southFromOrigin / yTiles;
|
// let xTileMin = Math.floor(westFromOrigin / realTileWidth) | 0;
|
// if (xTileMin >= xTiles) {
|
// xTileMin = xTiles - 1;
|
// }
|
// let xTileMax = Math.floor(eastFromOrigin / realTileWidth) | 0;
|
// if ( xTileMax >= xTiles) {
|
// xTileMax = xTiles - 1;
|
// }
|
// let yTileMin = Math.floor(northFromOrigin / realTileHeight) | 0;
|
// if (yTileMin >= yTiles) {
|
// yTileMin = yTiles - 1;
|
// }
|
// let yTileMax = Math.floor(southFromOrigin / realTileHeight) | 0;
|
// if(yTileMax >= yTiles) {
|
// yTileMax = yTiles - 1;
|
// }
|
|
// const distanceFromWest = webMercatorPosition.x - this._origin[0];
|
// const distanceFromNorth = this._origin[1] - webMercatorPosition.y;
|
// let xTileCoordinate = (distanceFromWest / xTileWidth) | 0;
|
// if (xTileCoordinate < xTileMin) {
|
// xTileCoordinate = xTileMin;
|
// // return undefined;
|
// }
|
// if ( xTileCoordinate > xTileMax ) {
|
// xTileCoordinate = xTileMax;
|
// // return undefined;
|
// }
|
// if (xTileCoordinate >= xTiles) {
|
// xTileCoordinate = xTiles - 1;
|
// }
|
|
// let yTileCoordinate = (distanceFromNorth / yTileHeight) | 0;
|
// if (yTileCoordinate < yTileMin) {
|
// yTileCoordinate = yTileMin;
|
// // return undefined;
|
// }
|
// if (yTileCoordinate > yTileMax) {
|
// yTileCoordinate = yTileMax;
|
// // return undefined;
|
// }
|
// if (yTileCoordinate >= yTiles) {
|
// yTileCoordinate = yTiles - 1;
|
// }
|
|
if (!Cesium.defined(result)) {
|
return new Cesium.Cartesian2(xTileCoordinate, yTileCoordinate);
|
}
|
|
result.x = xTileCoordinate;
|
result.y = yTileCoordinate;
|
return result;
|
};
|
export default Bj2000TilingScheme;
|
