add @dc-modules/imagery

modules/imagery/ImageryLayerFactory.js

@@ -0,0 +1,164 @@
+/**
+ * @Author: Caven
+ * @Date: 2020-01-21 15:54:56
+ */
+
+import ImageryType from './ImageryType'
+import AmapImageryProvider from './provider/AmapImageryProvider'
+import BaiduImageryProvider from './provider/BaiduImageryProvider'
+import GoogleImageryProvider from './provider/GoogleImageryProvider'
+import TdtImageryProvider from './provider/TdtImageryProvider'
+import TencentImageryProvider from './provider/TencentImageryProvider'
+
+const { Cesium } = DC.Namespace
+
+class ImageryLayerFactory {
+  /**
+   * Create amap image layer
+   * @param options
+   * @returns {AmapImageryProvider}
+   */
+  static createAmapImageryLayer(options) {
+    return new AmapImageryProvider(options)
+  }
+
+  /**
+   * Create baidu image layer
+   * @param options
+   * @returns {BaiduImageryProvider}
+   */
+  static createBaiduImageryLayer(options) {
+    return new BaiduImageryProvider(options)
+  }
+
+  /**
+   * Create google image layer
+   * @param options
+   * @returns {GoogleImageryProvider}
+   */
+  static createGoogleImageryLayer(options) {
+    return new GoogleImageryProvider(options)
+  }
+
+  /**
+   * Create tdt image layer
+   * @param options
+   * @returns {TdtImageryProvider}
+   */
+  static createTdtImageryLayer(options) {
+    return new TdtImageryProvider(options)
+  }
+
+  /**
+   * Create tencent image layer
+   * @param options
+   * @returns {TencentImageryProvider}
+   */
+  static createTencentImageryLayer(options) {
+    return new TencentImageryProvider(options)
+  }
+
+  /**
+   * Create arcgis image layer
+   * @param options
+   * @returns {module:cesium.ArcGisMapServerImageryProvider}
+   */
+  static createArcGisImageryLayer(options) {
+    return new Cesium.ArcGisMapServerImageryProvider(options)
+  }
+
+  /**
+   * Create single tile image layer
+   * @param options
+   * @returns {module:cesium.SingleTileImageryProvider}
+   */
+  static createSingleTileImageryLayer(options) {
+    return new Cesium.SingleTileImageryProvider(options)
+  }
+
+  /**
+   * Create WMS image layer
+   * @param options
+   * @returns {module:cesium.WebMapServiceImageryProvider}
+   */
+  static createWMSImageryLayer(options) {
+    return new Cesium.WebMapServiceImageryProvider(options)
+  }
+
+  /**
+   * Create WMTS image layer
+   * @param options
+   * @returns {module:cesium.WebMapTileServiceImageryProvider}
+   */
+  static createWMTSImageryLayer(options) {
+    return new Cesium.WebMapTileServiceImageryProvider(options)
+  }
+
+  /**
+   * Create xyz image layer
+   * @param options
+   * @returns {module:cesium.UrlTemplateImageryProvider}
+   */
+  static createXYZImageryLayer(options) {
+    return new Cesium.UrlTemplateImageryProvider(options)
+  }
+
+  /**
+   * Create coord image layer
+   * @param options
+   * @returns {module:cesium.TileCoordinatesImageryProvider}
+   */
+  static createCoordImageryLayer(options) {
+    return new Cesium.TileCoordinatesImageryProvider(options)
+  }
+
+  /**
+   * Create Imagery Layer
+   * @param type
+   * @param options
+   * @returns {any}
+   */
+  static createImageryLayer(type, options) {
+    let imageryLayer = undefined
+    switch (type) {
+      case ImageryType.AMAP:
+        imageryLayer = this.createAmapImageryLayer(options)
+        break
+      case ImageryType.BAIDU:
+        imageryLayer = this.createBaiduImageryLayer(options)
+        break
+      case ImageryType.GOOGLE:
+        imageryLayer = this.createGoogleImageryLayer(options)
+        break
+      case ImageryType.TDT:
+        imageryLayer = this.createTdtImageryLayer(options)
+        break
+      case ImageryType.TENCENT:
+        imageryLayer = this.createTencentImageryLayer(options)
+        break
+      case ImageryType.ARCGIS:
+        imageryLayer = this.createArcGisImageryLayer(options)
+        break
+      case ImageryType.SINGLE_TILE:
+        imageryLayer = this.createSingleTileImageryLayer(options)
+        break
+      case ImageryType.WMS:
+        imageryLayer = this.createWMSImageryLayer(options)
+        break
+      case ImageryType.WMTS:
+        imageryLayer = this.createWMTSImageryLayer(options)
+        break
+      case ImageryType.XYZ:
+        imageryLayer = this.createXYZImageryLayer(options)
+        break
+      case ImageryType.COORD:
+        imageryLayer = this.createCoordImageryLayer(options)
+        break
+      default:
+        break
+    }
+    return imageryLayer
+  }
+}
+
+export default ImageryLayerFactory

modules/imagery/ImageryType.js

@@ -0,0 +1,15 @@
+/**
+ * @Author: Caven
+ * @Date: 2020-05-10 08:15:36
+ */
+
+let ImageryType = {
+  ARCGIS: 'arcgis',
+  SINGLE_TILE: 'single_tile',
+  WMS: 'wms',
+  WMTS: 'wmts',
+  XYZ: 'xyz',
+  COORD: 'coord'
+}
+
+export default ImageryType

modules/imagery/index.js

@@ -0,0 +1,7 @@
+/**
+ * @Author: Caven
+ * @Date: 2021-03-14 00:31:46
+ */
+
+export { default as ImageryType } from './ImageryType'
+export { default as ImageryLayerFactory } from './ImageryLayerFactory'

modules/imagery/projection/BaiduMercatorProjection.js

@@ -0,0 +1,498 @@
+/**
+ * @Author: Caven
+ * @Date: 2021-01-30 22:41:41
+ */
+
+const EARTH_RADIUS = 6370996.81
+const MC_BAND = [12890594.86, 8362377.87, 5591021, 3481989.83, 1678043.12, 0]
+const LL_BAND = [75, 60, 45, 30, 15, 0]
+const MC2LL = [
+  [
+    1.410526172116255e-8,
+    8.98305509648872e-6,
+    -1.9939833816331,
+    2.009824383106796e2,
+    -1.872403703815547e2,
+    91.6087516669843,
+    -23.38765649603339,
+    2.57121317296198,
+    -0.03801003308653,
+    1.73379812e7
+  ],
+  [
+    -7.435856389565537e-9,
+    8.983055097726239e-6,
+    -0.78625201886289,
+    96.32687599759846,
+    -1.85204757529826,
+    -59.36935905485877,
+    47.40033549296737,
+    -16.50741931063887,
+    2.28786674699375,
+    1.026014486e7
+  ],
+  [
+    -3.030883460898826e-8,
+    8.98305509983578e-6,
+    0.30071316287616,
+    59.74293618442277,
+    7.357984074871,
+    -25.38371002664745,
+    13.45380521110908,
+    -3.29883767235584,
+    0.32710905363475,
+    6.85681737e6
+  ],
+  [
+    -1.981981304930552e-8,
+    8.983055099779535e-6,
+    0.03278182852591,
+    40.31678527705744,
+    0.65659298677277,
+    -4.44255534477492,
+    0.85341911805263,
+    0.12923347998204,
+    -0.04625736007561,
+    4.48277706e6
+  ],
+  [
+    3.09191371068437e-9,
+    8.983055096812155e-6,
+    0.00006995724062,
+    23.10934304144901,
+    -0.00023663490511,
+    -0.6321817810242,
+    -0.00663494467273,
+    0.03430082397953,
+    -0.00466043876332,
+    2.5551644e6
+  ],
+  [
+    2.890871144776878e-9,
+    8.983055095805407e-6,
+    -0.00000003068298,
+    7.47137025468032,
+    -0.00000353937994,
+    -0.02145144861037,
+    -0.00001234426596,
+    0.00010322952773,
+    -0.00000323890364,
+    8.260885e5
+  ]
+]
+const LL2MC = [
+  [
+    -0.0015702102444,
+    1.113207020616939e5,
+    1.704480524535203e15,
+    -1.033898737604234e16,
+    2.611266785660388e16,
+    -3.51496691766537e16,
+    2.659570071840392e16,
+    -1.072501245418824e16,
+    1.800819912950474e15,
+    82.5
+  ],
+  [
+    8.277824516172526e-4,
+    1.113207020463578e5,
+    6.477955746671608e8,
+    -4.082003173641316e9,
+    1.077490566351142e10,
+    -1.517187553151559e10,
+    1.205306533862167e10,
+    -5.124939663577472e9,
+    9.133119359512032e8,
+    67.5
+  ],
+  [
+    0.00337398766765,
+    1.113207020202162e5,
+    4.481351045890365e6,
+    -2.339375119931662e7,
+    7.968221547186455e7,
+    -1.159649932797253e8,
+    9.723671115602145e7,
+    -4.366194633752821e7,
+    8.477230501135234e6,
+    52.5
+  ],
+  [
+    0.00220636496208,
+    1.113207020209128e5,
+    5.175186112841131e4,
+    3.796837749470245e6,
+    9.920137397791013e5,
+    -1.22195221711287e6,
+    1.340652697009075e6,
+    -6.209436990984312e5,
+    1.444169293806241e5,
+    37.5
+  ],
+  [
+    -3.441963504368392e-4,
+    1.113207020576856e5,
+    2.782353980772752e2,
+    2.485758690035394e6,
+    6.070750963243378e3,
+    5.482118345352118e4,
+    9.540606633304236e3,
+    -2.71055326746645e3,
+    1.405483844121726e3,
+    22.5
+  ],
+  [
+    -3.218135878613132e-4,
+    1.113207020701615e5,
+    0.00369383431289,
+    8.237256402795718e5,
+    0.46104986909093,
+    2.351343141331292e3,
+    1.58060784298199,
+    8.77738589078284,
+    0.37238884252424,
+    7.45
+  ]
+]
+
+class BaiduMercatorProjection {
+  constructor() {
+    this.isWgs84 = false
+  }
+
+  /**
+   *
+   * @param point1
+   * @param point2
+   * @returns {number}
+   */
+  getDistanceByMC(point1, point2) {
+    if (!point1 || !point2) {
+      return 0
+    }
+    point1 = this.convertMC2LL(point1)
+    if (!point1) {
+      return 0
+    }
+    let x1 = this.toRadians(point1['lng'])
+    let y1 = this.toRadians(point1['lat'])
+    point2 = this.convertMC2LL(point2)
+    if (!point2) {
+      return 0
+    }
+    let x2 = this.toRadians(point2['lng'])
+    let y2 = this.toRadians(point2['lat'])
+    return this.getDistance(x1, x2, y1, y2)
+  }
+
+  /**
+   * Calculate the distance between two points according to the latitude and longitude coordinates
+   * @param point1
+   * @param point2
+   * @returns {number|*}
+   */
+  getDistanceByLL(point1, point2) {
+    if (!point1 || !point2) {
+      return 0
+    }
+    point1['lng'] = this.getLoop(point1['lng'], -180, 180)
+    point1['lat'] = this.getRange(point1['lat'], -74, 74)
+    point2['lng'] = this.getLoop(point2['lng'], -180, 180)
+    point2['lat'] = this.getRange(point2['lat'], -74, 74)
+    let x1 = this.toRadians(point1['lng'])
+    let y1 = this.toRadians(point1['lat'])
+    let x2 = this.toRadians(point2['lng'])
+    let y2 = this.toRadians(point2['lat'])
+    return this.getDistance(x1, x2, y1, y2)
+  }
+
+  /**
+   * The plane cartesian coordinates are converted to latitude and longitude coordinates
+   * @param point
+   * @returns {Point|{lng: number, lat: number}}
+   */
+  convertMC2LL(point) {
+    if (!point) {
+      return { lng: 0, lat: 0 }
+    }
+    let lnglat = {}
+    if (this.isWgs84) {
+      lnglat.lng = (point.lng / 20037508.34) * 180
+      let mmy = (point.lat / 20037508.34) * 180
+      lnglat.lat =
+        (180 / Math.PI) *
+        (2 * Math.atan(Math.exp((mmy * Math.PI) / 180)) - Math.PI / 2)
+      return {
+        lng: lnglat['lng'].toFixed(6),
+        lat: lnglat['lat'].toFixed(6)
+      }
+    }
+
+    let temp = {
+      lng: Math.abs(point['lng']),
+      lat: Math.abs(point['lat'])
+    }
+
+    let factor = undefined
+    for (let i = 0; i < MC_BAND.length; i++) {
+      if (temp['lat'] >= MC_BAND[i]) {
+        factor = MC2LL[i]
+        break
+      }
+    }
+    lnglat = this.convertor(point, factor)
+    return {
+      lng: lnglat['lng'].toFixed(6),
+      lat: lnglat['lat'].toFixed(6)
+    }
+  }
+
+  /**
+   * The latitude and longitude coordinates are converted to plane cartesian coordinates
+   * @param point
+   * @returns {{lng: number, lat: number}|*}
+   */
+  convertLL2MC(point) {
+    if (!point) {
+      return { lng: 0, lat: 0 }
+    }
+    if (
+      point['lng'] > 180 ||
+      point['lng'] < -180 ||
+      point['lat'] > 90 ||
+      point['lat'] < -90
+    ) {
+      return point
+    }
+
+    if (this.isWgs84) {
+      let mercator = {}
+      let earthRad = 6378137.0
+      mercator.lng = ((point.lng * Math.PI) / 180) * earthRad
+      let a = (point.lat * Math.PI) / 180
+      mercator.lat =
+        (earthRad / 2) * Math.log((1.0 + Math.sin(a)) / (1.0 - Math.sin(a)))
+
+      return {
+        lng: parseFloat(mercator['lng'].toFixed(2)),
+        lat: parseFloat(mercator['lat'].toFixed(2))
+      }
+    }
+
+    point['lng'] = this.getLoop(point['lng'], -180, 180)
+    point['lat'] = this.getRange(point['lat'], -74, 74)
+    let temp = { lng: point['lng'], lat: point['lat'] }
+    let factor = undefined
+    for (let i = 0; i < LL_BAND.length; i++) {
+      if (temp['lat'] >= LL_BAND[i]) {
+        factor = LL2MC[i]
+        break
+      }
+    }
+    if (!factor) {
+      for (let i = 0; i < LL_BAND.length; i++) {
+        if (temp['lat'] <= -LL_BAND[i]) {
+          factor = LL2MC[i]
+          break
+        }
+      }
+    }
+    let mc = this.convertor(point, factor)
+    return {
+      lng: parseFloat(mc['lng'].toFixed(2)),
+      lat: parseFloat(mc['lat'].toFixed(2))
+    }
+  }
+
+  /**
+   *
+   * @param fromPoint
+   * @param factor
+   * @returns {{lng: *, lat: *}}
+   */
+  convertor(fromPoint, factor) {
+    if (!fromPoint || !factor) {
+      return { lng: 0, lat: 0 }
+    }
+    let x = factor[0] + factor[1] * Math.abs(fromPoint['lng'])
+    let temp = Math.abs(fromPoint['lat']) / factor[9]
+    let y =
+      factor[2] +
+      factor[3] * temp +
+      factor[4] * temp * temp +
+      factor[5] * temp * temp * temp +
+      factor[6] * temp * temp * temp * temp +
+      factor[7] * temp * temp * temp * temp * temp +
+      factor[8] * temp * temp * temp * temp * temp * temp
+    x *= fromPoint['lng'] < 0 ? -1 : 1
+    y *= fromPoint['lat'] < 0 ? -1 : 1
+    return {
+      lng: x,
+      lat: y
+    }
+  }
+
+  /**
+   *
+   * @param x1
+   * @param x2
+   * @param y1
+   * @param y2
+   * @returns {number}
+   */
+  getDistance(x1, x2, y1, y2) {
+    return (
+      EARTH_RADIUS *
+      Math.acos(
+        Math.sin(y1) * Math.sin(y2) +
+          Math.cos(y1) * Math.cos(y2) * Math.cos(x2 - x1)
+      )
+    )
+  }
+
+  /**
+   *
+   * @param deg
+   * @returns {number}
+   */
+  toRadians(deg) {
+    return (Math.PI * deg) / 180
+  }
+
+  /**
+   *
+   * @param rad
+   * @returns {number}
+   */
+  toDegrees(rad) {
+    return (180 * rad) / Math.PI
+  }
+
+  /**
+   *
+   * @param v
+   * @param a
+   * @param b
+   * @returns {number}
+   */
+  getRange(v, a, b) {
+    if (a != null) {
+      v = Math.max(v, a)
+    }
+    if (b != null) {
+      v = Math.min(v, b)
+    }
+    return v
+  }
+
+  /**
+   *
+   * @param v
+   * @param a
+   * @param b
+   * @returns {*}
+   */
+  getLoop(v, a, b) {
+    while (v > b) {
+      v -= b - a
+    }
+    while (v < a) {
+      v += b - a
+    }
+    return v
+  }
+
+  /**
+   *
+   * @param point
+   * @returns {{lng: number, lat: number}|*}
+   */
+  lngLatToMercator(point) {
+    return this.convertLL2MC(point)
+  }
+
+  /**
+   *
+   * @param point
+   * @returns {{x: (number|*), y: (number|*)}}
+   */
+  lngLatToPoint(point) {
+    let mercator = this.convertLL2MC(point)
+    return {
+      x: mercator['lng'],
+      y: mercator['lat']
+    }
+  }
+
+  /**
+   * WebMercator transforms to latitude and longitude
+   * @param point
+   * @returns {Point|{lng: number, lat: number}}
+   */
+  mercatorToLngLat(point) {
+    return this.convertMC2LL(point)
+  }
+
+  /**
+   *
+   * @param point
+   * @returns {Point|{lng: number, lat: number}}
+   */
+  pointToLngLat(point) {
+    let mercator = { lng: point.x, lat: point.y }
+    return this.convertMC2LL(mercator)
+  }
+
+  /**
+   * Latitude and longitude coordinates  transforms to  pixel coordinates
+   * @param point
+   * @param zoom
+   * @param mapCenter
+   * @param mapSize
+   * @returns {{x: number, y: number}}
+   */
+  pointToPixel(point, zoom, mapCenter, mapSize) {
+    if (!point) {
+      return { x: 0, y: 0 }
+    }
+    point = this.lngLatToMercator(point)
+    let zoomUnits = this.getZoomUnits(zoom)
+    let x = Math.round(
+      (point['lng'] - mapCenter['lng']) / zoomUnits + mapSize.width / 2
+    )
+    let y = Math.round(
+      (mapCenter['lat'] - point['lat']) / zoomUnits + mapSize.height / 2
+    )
+    return { x, y }
+  }
+
+  /**
+   * Pixel coordinates transforms to latitude and longitude coordinates
+   * @param pixel
+   * @param zoom
+   * @param mapCenter
+   * @param mapSize
+   * @returns {Point|{lng: number, lat: number}}
+   */
+  pixelToPoint(pixel, zoom, mapCenter, mapSize) {
+    if (!pixel) {
+      return { lng: 0, lat: 0 }
+    }
+    let zoomUnits = this.getZoomUnits(zoom)
+    let lng = mapCenter['lng'] + zoomUnits * (pixel.x - mapSize.width / 2)
+    let lat = mapCenter['lat'] - zoomUnits * (pixel.y - mapSize.height / 2)
+    let point = { lng, lat }
+    return this.mercatorToLngLat(point)
+  }
+
+  /**
+   *
+   * @param zoom
+   * @returns {number}
+   */
+  getZoomUnits(zoom) {
+    return Math.pow(2, 18 - zoom)
+  }
+}
+
+export default BaiduMercatorProjection

modules/imagery/provider/AmapImageryProvider.js

@@ -0,0 +1,38 @@
+/**
+ * @Author: Caven
+ * @Date: 2020-01-15 20:31:28
+ */
+
+import ImageryType from '../ImageryType'
+import AmapMercatorTilingScheme from '../tiling-scheme/AmapMercatorTilingScheme'
+
+const { Cesium } = DC.Namespace
+
+const IMG_URL =
+  'https://webst{s}.is.autonavi.com/appmaptile?style=6&x={x}&y={y}&z={z}'
+
+const ELEC_URL =
+  'http://webrd{s}.is.autonavi.com/appmaptile?lang=zh_cn&size=1&scale=1&style=8&x={x}&y={y}&z={z}'
+
+const LOAD_MARK_URL =
+  'https://webst{s}.is.autonavi.com/appmaptile?lang=zh_cn&size=1&scale=1&style=8&x={x}&y={y}&z={z}'
+
+class AmapImageryProvider extends Cesium.UrlTemplateImageryProvider {
+  constructor(options = {}) {
+    options['url'] =
+      options.style === 'img'
+        ? IMG_URL
+        : options.style === 'load'
+        ? LOAD_MARK_URL
+        : ELEC_URL
+    options['subdomains'] = options.subdomains || ['01', '02', '03', '04']
+    if (options.crs === 'WGS84') {
+      options['tilingScheme'] = new AmapMercatorTilingScheme()
+    }
+    super(options)
+  }
+}
+
+ImageryType.AMAP = 'amap'
+
+export default AmapImageryProvider

modules/imagery/provider/BaiduImageryProvider.js

@@ -0,0 +1,177 @@
+/**
+ * @Author: Caven
+ * @Date: 2020-01-15 20:27:27
+ */
+
+import ImageryType from '../ImageryType'
+import BaiduMercatorTilingScheme from '../tiling-scheme/BaiduMercatorTilingScheme'
+
+const { Cesium } = DC.Namespace
+
+const IMG_URL =
+  'http://shangetu{s}.map.bdimg.com/it/u=x={x};y={y};z={z};v=009;type=sate&fm=46'
+
+const VEC_URL =
+  'http://online{s}.map.bdimg.com/tile/?qt=tile&x={x}&y={y}&z={z}&styles=sl&v=020'
+
+const CUSTOM_URL =
+  'http://api{s}.map.bdimg.com/customimage/tile?&x={x}&y={y}&z={z}&scale=1&customid={style}'
+
+const TRAFFIC_URL =
+  'http://its.map.baidu.com:8002/traffic/TrafficTileService?time={time}&label={labelStyle}&v=016&level={z}&x={x}&y={y}&scaler=2'
+
+class BaiduImageryProvider {
+  constructor(options = {}) {
+    this._url =
+      options.style === 'img'
+        ? IMG_URL
+        : options.style === 'vec'
+        ? VEC_URL
+        : options.style === 'traffic'
+        ? TRAFFIC_URL
+        : CUSTOM_URL
+    this._labelStyle = options.labelStyle || 'web2D'
+    this._tileWidth = 256
+    this._tileHeight = 256
+    this._maximumLevel = 18
+    this._crs = options.crs || 'BD09'
+    if (options.crs === 'WGS84') {
+      let resolutions = []
+      for (let i = 0; i < 19; i++) {
+        resolutions[i] = 256 * Math.pow(2, 18 - i)
+      }
+      this._tilingScheme = new BaiduMercatorTilingScheme({
+        resolutions,
+        rectangleSouthwestInMeters: new Cesium.Cartesian2(
+          -20037726.37,
+          -12474104.17
+        ),
+        rectangleNortheastInMeters: new Cesium.Cartesian2(
+          20037726.37,
+          12474104.17
+        )
+      })
+    } else {
+      this._tilingScheme = new Cesium.WebMercatorTilingScheme({
+        rectangleSouthwestInMeters: new Cesium.Cartesian2(-33554054, -33746824),
+        rectangleNortheastInMeters: new Cesium.Cartesian2(33554054, 33746824)
+      })
+    }
+    this._rectangle = this._tilingScheme.rectangle
+    this._credit = undefined
+    this._token = undefined
+    this._style = options.style || 'normal'
+  }
+
+  get url() {
+    return this._url
+  }
+
+  get token() {
+    return this._token
+  }
+
+  get tileWidth() {
+    if (!this.ready) {
+      throw new Cesium.DeveloperError(
+        'tileWidth must not be called before the imagery provider is ready.'
+      )
+    }
+    return this._tileWidth
+  }
+
+  get tileHeight() {
+    if (!this.ready) {
+      throw new Cesium.DeveloperError(
+        'tileHeight must not be called before the imagery provider is ready.'
+      )
+    }
+    return this._tileHeight
+  }
+
+  get maximumLevel() {
+    if (!this.ready) {
+      throw new Cesium.DeveloperError(
+        'maximumLevel must not be called before the imagery provider is ready.'
+      )
+    }
+    return this._maximumLevel
+  }
+
+  get minimumLevel() {
+    if (!this.ready) {
+      throw new Cesium.DeveloperError(
+        'minimumLevel must not be called before the imagery provider is ready.'
+      )
+    }
+    return 0
+  }
+
+  get tilingScheme() {
+    if (!this.ready) {
+      throw new Cesium.DeveloperError(
+        'tilingScheme must not be called before the imagery provider is ready.'
+      )
+    }
+    return this._tilingScheme
+  }
+
+  get rectangle() {
+    if (!this.ready) {
+      throw new Cesium.DeveloperError(
+        'rectangle must not be called before the imagery provider is ready.'
+      )
+    }
+    return this._rectangle
+  }
+
+  get ready() {
+    return !!this._url
+  }
+
+  get credit() {
+    return this._credit
+  }
+
+  get hasAlphaChannel() {
+    return true
+  }
+
+  getTileCredits(x, y, level) {}
+
+  /**
+   * Request Image
+   * @param x
+   * @param y
+   * @param level
+   * @returns {Promise<HTMLImageElement | HTMLCanvasElement>}
+   */
+  requestImage(x, y, level) {
+    if (!this.ready) {
+      throw new Cesium.DeveloperError(
+        'requestImage must not be called before the imagery provider is ready.'
+      )
+    }
+    let xTiles = this._tilingScheme.getNumberOfXTilesAtLevel(level)
+    let yTiles = this._tilingScheme.getNumberOfYTilesAtLevel(level)
+    let url = this._url
+      .replace('{z}', level)
+      .replace('{s}', String(1))
+      .replace('{style}', this._style)
+      .replace('{labelStyle}', this._labelStyle)
+      .replace('{time}', String(new Date().getTime()))
+
+    if (this._crs === 'WGS84') {
+      url = url.replace('{x}', String(x)).replace('{y}', String(-y))
+    } else {
+      url = url
+        .replace('{x}', String(x - xTiles / 2))
+        .replace('{y}', String(yTiles / 2 - y - 1))
+    }
+    return Cesium.ImageryProvider.loadImage(this, url)
+  }
+}
+
+ImageryType.BAIDU = 'baidu'
+
+export default BaiduImageryProvider

modules/imagery/provider/GoogleImageryProvider.js

@@ -0,0 +1,34 @@
+/**
+ * @Author: Caven
+ * @Date: 2020-01-21 16:06:14
+ */
+
+import ImageryType from '../ImageryType'
+
+const { Cesium } = DC.Namespace
+
+const ELEC_URL =
+  'http://mt{s}.google.cn/vt/lyrs=m@207000000&hl=zh-CN&gl=CN&src=app&x={x}&y={y}&z={z}&s=Galile'
+
+const IMG_URL =
+  'http://mt{s}.google.cn/vt/lyrs=s&hl=zh-CN&x={x}&y={y}&z={z}&s=Gali'
+
+const TER_URL =
+  'http://mt{s}.google.cn/vt/lyrs=t@131,r@227000000&hl=zh-CN&gl=cn&x={x}&y={y}&z={z}&s=Galile'
+
+class GoogleImageryProvider extends Cesium.UrlTemplateImageryProvider {
+  constructor(options = {}) {
+    options['url'] =
+      options.style === 'img'
+        ? IMG_URL
+        : options.style === 'ter'
+        ? TER_URL
+        : ELEC_URL
+    options['subdomains'] = options.subdomains || ['1', '2', '3']
+    super(options)
+  }
+}
+
+ImageryType.GOOGLE = 'google'
+
+export default GoogleImageryProvider

modules/imagery/provider/TdtImageryProvider.js

@@ -0,0 +1,29 @@
+/**
+ * @Author: Caven
+ * @Date: 2020-01-15 20:31:46
+ */
+
+import ImageryType from '../ImageryType'
+
+const { Cesium } = DC.Namespace
+
+const MAP_URL =
+  'https://t{s}.tianditu.gov.cn/DataServer?T={style}_w&x={x}&y={y}&l={z}&tk={key}'
+
+class TdtImageryProvider extends Cesium.UrlTemplateImageryProvider {
+  constructor(options = {}) {
+    super({
+      url: MAP_URL.replace(/\{style\}/g, options.style || 'vec').replace(
+        /\{key\}/g,
+        options.key || ''
+      ),
+      subdomains: ['0', '1', '2', '3', '4', '5', '6', '7'],
+      tilingScheme: new Cesium.WebMercatorTilingScheme(),
+      maximumLevel: 18
+    })
+  }
+}
+
+ImageryType.TDT = 'tdt'
+
+export default TdtImageryProvider

modules/imagery/provider/TencentImageryProvider.js

@@ -0,0 +1,37 @@
+/**
+ * @Author: Caven
+ * @Date: 2020-01-21 18:10:47
+ */
+
+import ImageryType from '../ImageryType'
+
+const { Cesium } = DC.Namespace
+
+const IMG_URL =
+  'https://p{s}.map.gtimg.com/sateTiles/{z}/{sx}/{sy}/{x}_{reverseY}.jpg?version=400'
+
+const ELEC_URL =
+  'https://rt{s}.map.gtimg.com/tile?z={z}&x={x}&y={reverseY}&styleid={style}&scene=0&version=347'
+
+class TencentImageryProvider extends Cesium.UrlTemplateImageryProvider {
+  constructor(options = {}) {
+    let url = options.style === 'img' ? IMG_URL : ELEC_URL
+    options['url'] = url.replace('{style}', options.style || 1)
+    options['subdomains'] = options.subdomains || ['1', '2', '3']
+    if (options.style === 'img') {
+      options['customTags'] = {
+        sx: (imageryProvider, x, y, level) => {
+          return x >> 4
+        },
+        sy: (imageryProvider, x, y, level) => {
+          return ((1 << level) - y) >> 4
+        }
+      }
+    }
+    super(options)
+  }
+}
+
+ImageryType.TENCENT = 'tencent'
+
+export default TencentImageryProvider

modules/imagery/tiling-scheme/AmapMercatorTilingScheme.js

@@ -0,0 +1,41 @@
+/**
+ * @Author: Caven
+ * @Date: 2021-01-31 22:07:05
+ */
+
+import { CoordTransform } from '@dc-modules/transform'
+
+const { Cesium } = DC.Namespace
+
+class AmapMercatorTilingScheme extends Cesium.WebMercatorTilingScheme {
+  constructor(options) {
+    super(options)
+    let projection = new Cesium.WebMercatorProjection()
+    this._projection.project = function(cartographic, result) {
+      result = CoordTransform.WGS84ToGCJ02(
+        Cesium.Math.toDegrees(cartographic.longitude),
+        Cesium.Math.toDegrees(cartographic.latitude)
+      )
+      result = projection.project(
+        new Cesium.Cartographic(
+          Cesium.Math.toRadians(result[0]),
+          Cesium.Math.toRadians(result[1])
+        )
+      )
+      return new Cesium.Cartesian2(result.x, result.y)
+    }
+    this._projection.unproject = function(cartesian, result) {
+      let cartographic = projection.unproject(cartesian)
+      result = CoordTransform.GCJ02ToWGS84(
+        Cesium.Math.toDegrees(cartographic.longitude),
+        Cesium.Math.toDegrees(cartographic.latitude)
+      )
+      return new Cesium.Cartographic(
+        Cesium.Math.toRadians(result[0]),
+        Cesium.Math.toRadians(result[1])
+      )
+    }
+  }
+}
+
+export default AmapMercatorTilingScheme

modules/imagery/tiling-scheme/BaiduMercatorTilingScheme.js

@@ -0,0 +1,103 @@
+/**
+ * @Author: Caven
+ * @Date: 2021-01-31 19:22:04
+ */
+
+import { CoordTransform } from '@dc-modules/transform'
+import BaiduMercatorProjection from '../projection/BaiduMercatorProjection'
+
+const { Cesium } = DC.Namespace
+
+class BaiduMercatorTilingScheme extends Cesium.WebMercatorTilingScheme {
+  constructor(options) {
+    super(options)
+    let projection = new BaiduMercatorProjection()
+    this._projection.project = function(cartographic, result) {
+      result = result || {}
+      result = CoordTransform.WGS84ToGCJ02(
+        Cesium.Math.toDegrees(cartographic.longitude),
+        Cesium.Math.toDegrees(cartographic.latitude)
+      )
+      result = CoordTransform.GCJ02ToBD09(result[0], result[1])
+      result[0] = Math.min(result[0], 180)
+      result[0] = Math.max(result[0], -180)
+      result[1] = Math.min(result[1], 74.000022)
+      result[1] = Math.max(result[1], -71.988531)
+      result = projection.lngLatToPoint({
+        lng: result[0],
+        lat: result[1]
+      })
+      return new Cesium.Cartesian2(result.x, result.y)
+    }
+    this._projection.unproject = function(cartesian, result) {
+      result = result || {}
+      result = projection.mercatorToLngLat({
+        lng: cartesian.x,
+        lat: cartesian.y
+      })
+      result = CoordTransform.BD09ToGCJ02(result.lng, result.lat)
+      result = CoordTransform.GCJ02ToWGS84(result[0], result[1])
+      return new Cesium.Cartographic(
+        Cesium.Math.toRadians(result[0]),
+        Cesium.Math.toRadians(result[1])
+      )
+    }
+    this.resolutions = options.resolutions || []
+  }
+
+  /**
+   *
+   * @param x
+   * @param y
+   * @param level
+   * @param result
+   * @returns {module:cesium.Rectangle|*}
+   */
+  tileXYToNativeRectangle(x, y, level, result) {
+    const tileWidth = this.resolutions[level]
+    const west = x * tileWidth
+    const east = (x + 1) * tileWidth
+    const north = ((y = -y) + 1) * tileWidth
+    const south = y * tileWidth
+
+    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
+  }
+
+  /**
+   *
+   * @param position
+   * @param level
+   * @param result
+   * @returns {undefined|*}
+   */
+  positionToTileXY(position, level, result) {
+    const rectangle = this._rectangle
+    if (!Cesium.Rectangle.contains(rectangle, position)) {
+      return undefined
+    }
+    const projection = this._projection
+    const webMercatorPosition = projection.project(position)
+    if (!Cesium.defined(webMercatorPosition)) {
+      return undefined
+    }
+    const tileWidth = this.resolutions[level]
+    const xTileCoordinate = Math.floor(webMercatorPosition.x / tileWidth)
+    const yTileCoordinate = -Math.floor(webMercatorPosition.y / tileWidth)
+    if (!Cesium.defined(result)) {
+      return new Cesium.Cartesian2(xTileCoordinate, yTileCoordinate)
+    }
+    result.x = xTileCoordinate
+    result.y = yTileCoordinate
+    return result
+  }
+}
+
+export default BaiduMercatorTilingScheme