@hzab/map-combine 0.0.1 → 0.1.2

package/src/cesium/cesium-tile-covert/modules/tiling-scheme/CustomGeographicTilingScheme.js

@@ -0,0 +1,60 @@
+/**
+ * @Author: Caven Chen
+ * @Date: 2020-01-15
+ */
+
+const { GeographicTilingScheme, Math: CesiumMath, Cartesian2, Rectangle, defined } = Cesium;
+
+class CustomGeographicTilingScheme extends GeographicTilingScheme {
+  constructor(options = {}) {
+    super(options);
+    this._origin = options.origin || [-180, 90];
+    this._zoomOffset = options.zoomOffset || 0;
+    this._tileSize = options.tileSize || 256;
+    this._resolutions = options.resolutions || [];
+  }
+
+  get zoomOffset() {
+    return this._zoomOffset;
+  }
+
+  tileXYToRectangle(x, y, level, result) {
+    if (!this._resolutions || !this._resolutions[level + this._zoomOffset]) {
+      return Rectangle.MAX_VALUE;
+    }
+
+    const tileRes = this._resolutions[level + this._zoomOffset] * this._tileSize;
+    const west = CesiumMath.toRadians(this._origin[0] + x * tileRes);
+    const south = CesiumMath.toRadians(this._origin[1] - (y + 1) * tileRes);
+    const east = CesiumMath.toRadians(this._origin[0] + (x + 1) * tileRes);
+    const north = CesiumMath.toRadians(this._origin[1] - y * tileRes);
+    if (!defined(result)) {
+      return new Rectangle(west, south, east, north);
+    }
+    result.west = west;
+    result.south = south;
+    result.east = east;
+    result.north = north;
+    return result;
+  }
+
+  positionToTileXY(position, level, result) {
+    if (!this._resolutions || !this._resolutions[level + this._zoomOffset]) {
+      return new Cartesian2();
+    }
+    const tileRes = this._resolutions[level + this._zoomOffset] * this._tileSize;
+    const longitude = CesiumMath.toDegrees(position.longitude);
+    const latitude = CesiumMath.toDegrees(position.latitude);
+    // Calculate the tile row and column numbers in the current coordinate system
+    const xTileCoordinate = Math.floor((longitude - this._origin[0]) / tileRes);
+    const yTileCoordinate = Math.floor((this._origin[1] - latitude) / tileRes);
+    if (!defined(result)) {
+      return new Cartesian2(Math.max(0, xTileCoordinate), Math.max(0, yTileCoordinate));
+    }
+    result.x = xTileCoordinate;
+    result.y = yTileCoordinate;
+    return result;
+  }
+}
+
+export default CustomGeographicTilingScheme;

package/src/cesium/cesium-tile-covert/modules/tiling-scheme/CustomMercatorTilingScheme.js

@@ -0,0 +1,70 @@
+/**
+ * @Author: Caven Chen
+ * @Date: 2020-01-15
+ */
+
+const { WebMercatorTilingScheme, Cartesian2, Rectangle, defined } = Cesium;
+
+class CustomMercatorTilingScheme extends WebMercatorTilingScheme {
+  constructor(options = {}) {
+    super(options);
+    this._origin = options.origin || [-20037508.3427892, 20037508.3427892];
+    this._zoomOffset = options.zoomOffset || 0;
+    this._tileSize = options.tileSize || 256;
+    this._resolutions = options.resolutions || [];
+  }
+
+  get zoomOffset() {
+    return this._zoomOffset;
+  }
+
+  tileXYToNativeRectangle(x, y, level, result) {
+    if (!this._resolutions || !this._resolutions[level + this._zoomOffset]) {
+      return Rectangle.MAX_VALUE;
+    }
+
+    if (x < 0 || y < 0) {
+      return Rectangle.MAX_VALUE;
+    }
+    const tileRes = this._resolutions[level + this._zoomOffset] * this._tileSize;
+    let west = this._origin[0] + x * tileRes;
+    let south = this._origin[1] - (y + 1) * tileRes;
+    let east = this._origin[0] + (x + 1) * tileRes;
+    let north = this._origin[1] - y * tileRes;
+
+    if (!defined(result)) {
+      return new Rectangle(west, south, east, north);
+    }
+    result.west = west;
+    result.south = south;
+    result.east = east;
+    result.north = north;
+    return result;
+  }
+
+  positionToTileXY(position, level, result) {
+    const rectangle = this._rectangle;
+    if (!Rectangle.contains(rectangle, position)) {
+      return undefined;
+    }
+    if (!this._resolutions || !this._resolutions[level + this._zoomOffset]) {
+      return new Cartesian2();
+    }
+    const tileRes = this._resolutions[level + this._zoomOffset] * this._tileSize;
+    const projection = this._projection;
+    const webMercatorPosition = projection.project(position);
+
+    // Calculate the tile row and column numbers in the current coordinate system
+    const xTileCoordinate = Math.floor((webMercatorPosition.x - this._origin[0]) / tileRes);
+
+    const yTileCoordinate = Math.floor((this._origin[1] - webMercatorPosition.y) / tileRes);
+    if (!defined(result)) {
+      return new Cartesian2(Math.max(0, xTileCoordinate), Math.max(0, yTileCoordinate));
+    }
+    result.x = xTileCoordinate;
+    result.y = yTileCoordinate;
+    return result;
+  }
+}
+
+export default CustomMercatorTilingScheme;

package/src/cesium/cesium-tile-covert/modules/tiling-scheme/GCJ02TilingScheme.js

@@ -0,0 +1,33 @@
+/**
+ * @Author: Caven Chen
+ * @Date: 2020-01-15
+ */
+
+import CoordTransform from "../transform/CoordTransform.js";
+
+const { WebMercatorTilingScheme, WebMercatorProjection, Math: CesiumMath, Cartographic, Cartesian2 } = Cesium;
+
+class GCJ02TilingScheme extends WebMercatorTilingScheme {
+  constructor(options) {
+    super(options);
+    let projection = new WebMercatorProjection();
+    this._projection.project = function (cartographic, result) {
+      result = CoordTransform.WGS84ToGCJ02(
+        CesiumMath.toDegrees(cartographic.longitude),
+        CesiumMath.toDegrees(cartographic.latitude),
+      );
+      result = projection.project(new Cartographic(CesiumMath.toRadians(result[0]), CesiumMath.toRadians(result[1])));
+      return new Cartesian2(result.x, result.y);
+    };
+    this._projection.unproject = function (cartesian, result) {
+      let cartographic = projection.unproject(cartesian);
+      result = CoordTransform.GCJ02ToWGS84(
+        CesiumMath.toDegrees(cartographic.longitude),
+        CesiumMath.toDegrees(cartographic.latitude),
+      );
+      return new Cartographic(CesiumMath.toRadians(result[0]), CesiumMath.toRadians(result[1]));
+    };
+  }
+}
+
+export default GCJ02TilingScheme;

package/src/cesium/cesium-tile-covert/modules/transform/CoordTransform.js

@@ -0,0 +1,148 @@
+/**
+ * @Author: Caven
+ * @Date: 2021-01-31 20:40:25
+ */
+
+// eslint-disable-next-line no-loss-of-precision
+const BD_FACTOR = (3.14159265358979324 * 3000.0) / 180.0;
+// eslint-disable-next-line no-loss-of-precision
+const PI = 3.1415926535897932384626;
+const RADIUS = 6378245.0;
+// eslint-disable-next-line no-loss-of-precision
+const EE = 0.00669342162296594323;
+
+class CoordTransform {
+  /**
+   * BD-09 To GCJ-02
+   * @param lng
+   * @param lat
+   * @returns {number[]}
+   */
+  static BD09ToGCJ02(lng, lat) {
+    let x = +lng - 0.0065;
+    let y = +lat - 0.006;
+    let z = Math.sqrt(x * x + y * y) - 0.00002 * Math.sin(y * BD_FACTOR);
+    let theta = Math.atan2(y, x) - 0.000003 * Math.cos(x * BD_FACTOR);
+    let gg_lng = z * Math.cos(theta);
+    let gg_lat = z * Math.sin(theta);
+    return [gg_lng, gg_lat];
+  }
+
+  /**
+   * GCJ-02 To BD-09
+   * @param lng
+   * @param lat
+   * @returns {number[]}
+   * @constructor
+   */
+  static GCJ02ToBD09(lng, lat) {
+    lat = +lat;
+    lng = +lng;
+    let z = Math.sqrt(lng * lng + lat * lat) + 0.00002 * Math.sin(lat * BD_FACTOR);
+    let theta = Math.atan2(lat, lng) + 0.000003 * Math.cos(lng * BD_FACTOR);
+    let bd_lng = z * Math.cos(theta) + 0.0065;
+    let bd_lat = z * Math.sin(theta) + 0.006;
+    return [bd_lng, bd_lat];
+  }
+
+  /**
+   * WGS-84 To GCJ-02
+   * @param lng
+   * @param lat
+   * @returns {number[]}
+   */
+  static WGS84ToGCJ02(lng, lat) {
+    lat = +lat;
+    lng = +lng;
+    if (this.out_of_china(lng, lat)) {
+      return [lng, lat];
+    } else {
+      let d = this.delta(lng, lat);
+      return [lng + d[0], lat + d[1]];
+    }
+  }
+
+  /**
+   * GCJ-02 To WGS-84
+   * @param lng
+   * @param lat
+   * @returns {number[]}
+   * @constructor
+   */
+  static GCJ02ToWGS84(lng, lat) {
+    lat = +lat;
+    lng = +lng;
+    if (this.out_of_china(lng, lat)) {
+      return [lng, lat];
+    } else {
+      let d = this.delta(lng, lat);
+      let mgLng = lng + d[0];
+      let mgLat = lat + d[1];
+      return [lng * 2 - mgLng, lat * 2 - mgLat];
+    }
+  }
+
+  /**
+   *
+   * @param lng
+   * @param lat
+   * @returns {number[]}
+   */
+  static delta(lng, lat) {
+    let dLng = this.transformLng(lng - 105, lat - 35);
+    let dLat = this.transformLat(lng - 105, lat - 35);
+    const radLat = (lat / 180) * PI;
+    let magic = Math.sin(radLat);
+    magic = 1 - EE * magic * magic;
+    const sqrtMagic = Math.sqrt(magic);
+    dLng = (dLng * 180) / ((RADIUS / sqrtMagic) * Math.cos(radLat) * PI);
+    dLat = (dLat * 180) / (((RADIUS * (1 - EE)) / (magic * sqrtMagic)) * PI);
+    return [dLng, dLat];
+  }
+
+  /**
+   *
+   * @param lng
+   * @param lat
+   * @returns {number}
+   */
+  static transformLng(lng, lat) {
+    lat = +lat;
+    lng = +lng;
+    let ret = 300.0 + lng + 2.0 * lat + 0.1 * lng * lng + 0.1 * lng * lat + 0.1 * Math.sqrt(Math.abs(lng));
+    ret += ((20.0 * Math.sin(6.0 * lng * PI) + 20.0 * Math.sin(2.0 * lng * PI)) * 2.0) / 3.0;
+    ret += ((20.0 * Math.sin(lng * PI) + 40.0 * Math.sin((lng / 3.0) * PI)) * 2.0) / 3.0;
+    ret += ((150.0 * Math.sin((lng / 12.0) * PI) + 300.0 * Math.sin((lng / 30.0) * PI)) * 2.0) / 3.0;
+    return ret;
+  }
+
+  /**
+   *
+   * @param lng
+   * @param lat
+   * @returns {number}
+   */
+  static transformLat(lng, lat) {
+    lat = +lat;
+    lng = +lng;
+    let ret = -100.0 + 2.0 * lng + 3.0 * lat + 0.2 * lat * lat + 0.1 * lng * lat + 0.2 * Math.sqrt(Math.abs(lng));
+    ret += ((20.0 * Math.sin(6.0 * lng * PI) + 20.0 * Math.sin(2.0 * lng * PI)) * 2.0) / 3.0;
+    ret += ((20.0 * Math.sin(lat * PI) + 40.0 * Math.sin((lat / 3.0) * PI)) * 2.0) / 3.0;
+    ret += ((160.0 * Math.sin((lat / 12.0) * PI) + 320 * Math.sin((lat * PI) / 30.0)) * 2.0) / 3.0;
+    return ret;
+  }
+
+  /**
+   *
+   * @param lng
+   * @param lat
+   * @returns {boolean}
+   */
+  static out_of_china(lng, lat) {
+    lat = +lat;
+    lng = +lng;
+    return !(lng > 73.66 && lng < 135.05 && lat > 3.86 && lat < 53.55);
+  }
+}
+
+export default CoordTransform;

package/src/openlayer/OpenlayerMap.ts

@@ -1,6 +1,9 @@
 import { MapCombine } from "../basic/MapCombine";
 import { PointOption, Point } from "../basic/Point";
 import Map from "ol/Map.js";
+import View from "ol/View";
+import XYZ from "ol/source/XYZ";
+import Tile from "ol/layer/Tile";
 import DragPan from "ol/interaction/DragPan";
 import { Projection } from "../utils/Projection";
 import VectorSource from "ol/source/Vector";
@@ -15,19 +18,32 @@ import { drawPoint } from "./OpenlayerPoint";
 import { drawPolyline } from "./OpenlayerPolyline";
 import { drawPolygon } from "./OpenlayerPolygon";
 import { Tile3DOption, Tile3D } from "../basic/Tile3D";
+import { gcjMecator } from "./openlayer-tile-gcj02-wgs84";
+
+export interface IOpenlayerOption {
+  container;
+  url: string | string[];
+  center?: number[];
+  zoom?: number;
+  maxZoom?: number;
+  minZoom?: number;
+  /** 地图瓦片转换规则 GCJ02 转 WGS84 */
+  proj?: "GCJ02->WGS84";
+}
 
 export class OpenlayerMap extends MapCombine {
   viewer: Map;
   container: HTMLDivElement;
   dragPan: DragPan;
-  vectors: VectorSource
+  vectors: VectorSource;
+  option: IOpenlayerOption;
   offset: number[];
   fov = 0.9272952180016121;
   get cursor(): string {
-    return (this.container).style.cursor
+    return this.container.style.cursor;
   }
   set cursor(val: string) {
-    (this.container).style.cursor = val
+    this.container.style.cursor = val;
   }
   get moveable(): boolean {
     return this.dragPan.getActive();
@@ -36,8 +52,8 @@ export class OpenlayerMap extends MapCombine {
     this.dragPan.setActive(val);
   }
   get center(): number[] {
-    const center = this.viewer.getView().getCenter()!
-    return [Projection.xToLon(center[0]), Projection.yToLat(center[1]), 0]
+    const center = this.viewer.getView().getCenter()!;
+    return [Projection.xToLon(center[0]), Projection.yToLat(center[1]), 0];
   }
   set center(val: number[]) {
     const { viewer } = this;
@@ -45,19 +61,59 @@ export class OpenlayerMap extends MapCombine {
     view.setCenter([Projection.lonToX(val[0]), Projection.latToY(val[1])]);
   }
   get zoom(): number {
-    return this.viewer.getView().getZoom()
+    return this.viewer.getView().getZoom();
   }
   set zoom(val: number) {
     this.viewer.getView().setZoom(val);
   }
 
-  constructor(viewer: Map) {
-    super()
-    this.viewer = viewer
-    this.container = viewer.getViewport() as HTMLDivElement
-    this.container.appendChild(this.htmllayer)
+  constructor(viewer?: Map) {
+    super();
+    viewer && this._initParamsEvent(viewer);
+  }
+
+  init(opt: IOpenlayerOption) {
+    this.option = opt;
+    const { container, center = [120.2288892, 30.2349677, 0], zoom = 13, url, maxZoom, minZoom, proj } = opt || {};
+
+    const viewer = new Map({
+      target: container,
+      controls: [],
+      view: new View({
+        projection: "EPSG:3857",
+        center: fromLonLat(center),
+        zoom: zoom,
+        maxZoom: maxZoom ?? 18,
+        minZoom: minZoom ?? 3,
+      }),
+      layers: [
+        new Tile({
+          visible: true,
+          source: new XYZ({
+            projection: proj === "GCJ02->WGS84" ? gcjMecator : undefined,
+            urls: Array.isArray(url) ? url : [url],
+            crossOrigin: "anonymous",
+          }),
+        }),
+      ],
+    });
+
+    this._initParamsEvent(viewer);
+
+    return new OpenlayerMap(viewer);
+  }
+
+  private _initParamsEvent(viewer) {
+    if (!viewer) {
+      return;
+    }
+    this.viewer = viewer;
+    this.container = viewer.getViewport() as HTMLDivElement;
+    this.container.appendChild(this.htmllayer);
+    this.cursor = "default";
+
     const { center } = this;
-    this.offset = fromLonLat(center)
+    this.offset = fromLonLat(center);
 
     this.vectors = new VectorSource();
     this.viewer.addLayer(
@@ -71,29 +127,29 @@ export class OpenlayerMap extends MapCombine {
       .getArray()
       .find((interaction) => {
         if (interaction instanceof DoubleClickZoom) {
-          interaction.setActive(false)
+          interaction.setActive(false);
         }
         return interaction instanceof DragPan;
       }) as DragPan;
 
-    bindEvent(this)
+    bindEvent(this);
   }
 
   createPoint<K>(option?: Partial<PointOption<K>>): Point<K> {
-    const e = new Point(this, option)
-    drawPoint(this, e)
-    return e
+    const e = new Point(this, option);
+    drawPoint(this, e);
+    return e;
   }
 
   createPolyline<K>(option?: Partial<PolylineOption<K>>): Polyline<K> {
-    const e = new Polyline(this, option)
-    drawPolyline(this, e)
-    return e
+    const e = new Polyline(this, option);
+    drawPolyline(this, e);
+    return e;
   }
   createPolygon<K>(option?: Partial<PolygonOption<K>>): Polygon<K> {
-    const e = new Polygon(this, option)
-    drawPolygon(this, e)
-    return e
+    const e = new Polygon(this, option);
+    drawPolygon(this, e);
+    return e;
   }
 
   // protected _onFrame(): void {
@@ -116,9 +172,8 @@ export class OpenlayerMap extends MapCombine {
     if (pixel) {
       return [pixel[0], pixel[1]];
     } else {
-      return [0, 0]
+      return [0, 0];
     }
-
   }
   spaceTgeography(p: number[]): number[] {
     const { offset } = this;
@@ -144,6 +199,6 @@ export class OpenlayerMap extends MapCombine {
   }
 
   _onDestroy() {
-    this.viewer.dispose()
+    this.viewer.dispose();
   }
-}
+}

package/src/openlayer/openlayer-tile-gcj02-wgs84.js

@@ -0,0 +1,144 @@
+import { Projection, addProjection, addCoordinateTransforms } from "ol/proj";
+
+let projzh = {};
+projzh.ll2gmerc = function (input, opt_output, opt_dimension) {
+  let output = gcj02.fromWGS84(input, opt_output, opt_dimension);
+  return projzh.ll2smerc(output, output, opt_dimension);
+};
+projzh.gmerc2ll = function (input, opt_output, opt_dimension) {
+  let output = projzh.smerc2ll(input, input, opt_dimension);
+  return gcj02.toWGS84(output, opt_output, opt_dimension);
+};
+projzh.smerc2gmerc = function (input, opt_output, opt_dimension) {
+  let output = projzh.smerc2ll(input, input, opt_dimension);
+  output = gcj02.fromWGS84(output, output, opt_dimension);
+  return projzh.ll2smerc(output, output, opt_dimension);
+};
+projzh.gmerc2smerc = function (input, opt_output, opt_dimension) {
+  let output = projzh.smerc2ll(input, input, opt_dimension);
+  output = gcj02.toWGS84(output, output, opt_dimension);
+  return projzh.ll2smerc(output, output, opt_dimension);
+};
+
+function forEachPoint(func) {
+  return function (input, opt_output, opt_dimension) {
+    const len = input.length;
+    const dimension = opt_dimension ? opt_dimension : 2;
+    let output;
+    if (opt_output) {
+      output = opt_output;
+    } else {
+      if (dimension !== 2) {
+        output = input.slice();
+      } else {
+        output = new Array(len);
+      }
+    }
+    for (let offset = 0; offset < len; offset += dimension) {
+      func(input, output, offset);
+    }
+    return output;
+  };
+}
+
+let RADIUS = 6378137;
+let MAX_LATITUDE = 85.0511287798;
+let RAD_PER_DEG = Math.PI / 180;
+
+let sphericalMercator = {};
+sphericalMercator.forward = forEachPoint(function (input, output, offset) {
+  let lat = Math.max(Math.min(MAX_LATITUDE, input[offset + 1]), -MAX_LATITUDE);
+  let sin = Math.sin(lat * RAD_PER_DEG);
+
+  output[offset] = RADIUS * input[offset] * RAD_PER_DEG;
+  output[offset + 1] = (RADIUS * Math.log((1 + sin) / (1 - sin))) / 2;
+});
+
+sphericalMercator.inverse = forEachPoint(function (input, output, offset) {
+  output[offset] = input[offset] / RADIUS / RAD_PER_DEG;
+  output[offset + 1] = (2 * Math.atan(Math.exp(input[offset + 1] / RADIUS)) - Math.PI / 2) / RAD_PER_DEG;
+});
+
+projzh.ll2smerc = sphericalMercator.forward;
+projzh.smerc2ll = sphericalMercator.inverse;
+
+const gcj02 = {};
+const PI = Math.PI;
+const AXIS = 6378245.0;
+// eslint-disable-next-line @typescript-eslint/no-loss-of-precision
+const OFFSET = 0.00669342162296594323; // (a^2 - b^2) / a^2
+
+function delta(wgLon, wgLat) {
+  let dLat = transformLat(wgLon - 105.0, wgLat - 35.0);
+  let dLon = transformLon(wgLon - 105.0, wgLat - 35.0);
+  const radLat = (wgLat / 180.0) * PI;
+  let magic = Math.sin(radLat);
+  magic = 1 - OFFSET * magic * magic;
+  const sqrtMagic = Math.sqrt(magic);
+  dLat = (dLat * 180.0) / (((AXIS * (1 - OFFSET)) / (magic * sqrtMagic)) * PI);
+  dLon = (dLon * 180.0) / ((AXIS / sqrtMagic) * Math.cos(radLat) * PI);
+  return [dLon, dLat];
+}
+
+function outOfChina(lon, lat) {
+  if (lon < 72.004 || lon > 137.8347) {
+    return true;
+  }
+  if (lat < 0.8293 || lat > 55.8271) {
+    return true;
+  }
+  return false;
+}
+
+function transformLat(x, y) {
+  let ret = -100.0 + 2.0 * x + 3.0 * y + 0.2 * y * y + 0.1 * x * y + 0.2 * Math.sqrt(Math.abs(x));
+  ret += ((20.0 * Math.sin(6.0 * x * PI) + 20.0 * Math.sin(2.0 * x * PI)) * 2.0) / 3.0;
+  ret += ((20.0 * Math.sin(y * PI) + 40.0 * Math.sin((y / 3.0) * PI)) * 2.0) / 3.0;
+  ret += ((160.0 * Math.sin((y / 12.0) * PI) + 320 * Math.sin((y * PI) / 30.0)) * 2.0) / 3.0;
+  return ret;
+}
+
+function transformLon(x, y) {
+  let ret = 300.0 + x + 2.0 * y + 0.1 * x * x + 0.1 * x * y + 0.1 * Math.sqrt(Math.abs(x));
+  ret += ((20.0 * Math.sin(6.0 * x * PI) + 20.0 * Math.sin(2.0 * x * PI)) * 2.0) / 3.0;
+  ret += ((20.0 * Math.sin(x * PI) + 40.0 * Math.sin((x / 3.0) * PI)) * 2.0) / 3.0;
+  ret += ((150.0 * Math.sin((x / 12.0) * PI) + 300.0 * Math.sin((x / 30.0) * PI)) * 2.0) / 3.0;
+  return ret;
+}
+
+gcj02.toWGS84 = forEachPoint(function (input, output, offset) {
+  let lng = input[offset];
+  let lat = input[offset + 1];
+  if (!outOfChina(lng, lat)) {
+    let deltaD = delta(lng, lat);
+    lng = lng - deltaD[0];
+    lat = lat - deltaD[1];
+  }
+  output[offset] = lng;
+  output[offset + 1] = lat;
+});
+
+gcj02.fromWGS84 = forEachPoint(function (input, output, offset) {
+  let lng = input[offset];
+  let lat = input[offset + 1];
+  if (!outOfChina(lng, lat)) {
+    let deltaD = delta(lng, lat);
+    lng = lng + deltaD[0];
+    lat = lat + deltaD[1];
+  }
+  output[offset] = lng;
+  output[offset + 1] = lat;
+});
+
+const gcj02Extent = [-20037508.342789244, -20037508.342789244, 20037508.342789244, 20037508.342789244];
+const gcjMecator = new Projection({
+  code: "GCJ-02",
+  extent: gcj02Extent,
+  units: "m",
+});
+addProjection(gcjMecator);
+
+addCoordinateTransforms("EPSG:4326", gcjMecator, projzh.ll2gmerc, projzh.gmerc2ll);
+addCoordinateTransforms("EPSG:3857", gcjMecator, projzh.smerc2gmerc, projzh.gmerc2smerc);
+
+export { gcjMecator };

package/src/utils/index.ts

@@ -83,7 +83,6 @@ export function getUUID() {
   return (Date.now() + Math.random()).toString();
 }
 
-
 /**
  * 节流执行函数
  * @param func 目标函数
@@ -128,4 +127,18 @@ export function throttle<T extends (...args: any) => void>(func: T, time = 0, im
       }
     } as T;
   }
-}
+}
+
+export function arrayFillByLen(arr, len, item) {
+  let _arr = arr;
+  if (!Array.isArray(_arr)) {
+    throw new Error("请传入数组");
+  }
+  if (arr.length >= len) {
+    return arr;
+  }
+  const fillLen = len - arr.length;
+  for (let i = 0; i < fillLen; i++) {
+    arr.push(item);
+  }
+}