@anov/3d-ability 0.0.139 → 0.0.141

package/dist/business/HeatMap/HeatMap.js

@@ -1,32 +1,13 @@
-function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
 function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
 function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
-function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
-function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
-function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
-function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
-function _get() { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get.bind(); } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(arguments.length < 3 ? target : receiver); } return desc.value; }; } return _get.apply(this, arguments); }
-function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
-function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
-function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
-function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
-function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
-function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
-function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
 function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
-function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
 import { CanvasTexture, DoubleSide, Mesh, NearestFilter, Object3D, PlaneGeometry, ShaderMaterial, Vector2, use } from '@anov/3d-core';
 import h from 'anov-heat-map';
 import Supercluster from 'supercluster';
 import { heightFragmentShader, heightVertexShader } from "./shader";
-var defaultGradient = {
+const defaultGradient = {
   0.25: 'rgb(0,0,255)',
   0.55: 'rgb(0,255,0)',
   0.85: 'yellow',
@@ -36,475 +17,407 @@ var defaultGradient = {
 /**
  * 区域热力图
  */
-var HeatMap = /*#__PURE__*/function (_Object3D) {
-  _inherits(HeatMap, _Object3D);
-  var _super = _createSuper(HeatMap);
-  function HeatMap(options) {
+
+class HeatMap extends Object3D {
+  get defaultMax() {
+    return Math.max(...this.data.map(item => item.value));
+  }
+  get url() {
+    return this._url;
+  }
+  constructor(options) {
     var _options$radius, _options$height, _options$isPixel;
-    var _this;
-    _classCallCheck(this, HeatMap);
-    _this = _super.call(this);
-    _defineProperty(_assertThisInitialized(_this), "data", []);
-    _defineProperty(_assertThisInitialized(_this), "_height", void 0);
-    _defineProperty(_assertThisInitialized(_this), "_radius", void 0);
-    _defineProperty(_assertThisInitialized(_this), "_heatmap", void 0);
-    _defineProperty(_assertThisInitialized(_this), "_url", void 0);
-    _defineProperty(_assertThisInitialized(_this), "_colorMap", void 0);
-    _defineProperty(_assertThisInitialized(_this), "_isPixel", void 0);
-    _defineProperty(_assertThisInitialized(_this), "_canvasBox", void 0);
-    _defineProperty(_assertThisInitialized(_this), "_attachmentMesh", void 0);
-    _defineProperty(_assertThisInitialized(_this), "_supercluster", void 0);
-    _defineProperty(_assertThisInitialized(_this), "_range", void 0);
-    _this._colorMap = options.colorMap || defaultGradient;
-    _this._radius = (_options$radius = options.radius) !== null && _options$radius !== void 0 ? _options$radius : 40;
-    _this._height = (_options$height = options.height) !== null && _options$height !== void 0 ? _options$height : 70;
-    _this._isPixel = (_options$isPixel = options.isPixel) !== null && _options$isPixel !== void 0 ? _options$isPixel : false;
-    _this._range = options.range;
+    super();
+    _defineProperty(this, "data", []);
+    _defineProperty(this, "_height", void 0);
+    _defineProperty(this, "_radius", void 0);
+    _defineProperty(this, "_heatmap", void 0);
+    _defineProperty(this, "_url", void 0);
+    _defineProperty(this, "_colorMap", void 0);
+    _defineProperty(this, "_isPixel", void 0);
+    _defineProperty(this, "_canvasBox", void 0);
+    _defineProperty(this, "_attachmentMesh", void 0);
+    _defineProperty(this, "_supercluster", void 0);
+    _defineProperty(this, "_range", void 0);
+    this._colorMap = options.colorMap || defaultGradient;
+    this._radius = (_options$radius = options.radius) !== null && _options$radius !== void 0 ? _options$radius : 40;
+    this._height = (_options$height = options.height) !== null && _options$height !== void 0 ? _options$height : 70;
+    this._isPixel = (_options$isPixel = options.isPixel) !== null && _options$isPixel !== void 0 ? _options$isPixel : false;
+    this._range = options.range;
 
     // this.initSupercluster()
-    return _this;
   }
-  _createClass(HeatMap, [{
-    key: "defaultMax",
-    get: function get() {
-      return Math.max.apply(Math, _toConsumableArray(this.data.map(function (item) {
-        return item.value;
-      })));
-    }
-  }, {
-    key: "url",
-    get: function get() {
-      return this._url;
-    }
-  }, {
-    key: "initSupercluster",
-    value: function initSupercluster() {
-      this._supercluster = new Supercluster({
-        radius: 40,
-        minZoom: 1,
-        maxZoom: 16
-      });
-    }
+  initSupercluster() {
+    this._supercluster = new Supercluster({
+      radius: 40,
+      minZoom: 1,
+      maxZoom: 16
+    });
+  }
 
-    /**
-     * set supercluster data
-     */
-  }, {
-    key: "setSuperclusterData",
-    value: function setSuperclusterData() {
-      var featuresPoints = this.data.map(function (item) {
-        return {
-          type: 'Feature',
-          properties: {},
-          geometry: {
-            type: 'Point',
-            coordinates: [item.x, item.z]
-          }
-        };
-      });
-      console.log('正在加载点数据到supercluster:', featuresPoints.length);
-      this._supercluster.load(featuresPoints);
-    }
+  /**
+   * set supercluster data
+   */
+  setSuperclusterData() {
+    const featuresPoints = this.data.map(item => {
+      return {
+        type: 'Feature',
+        properties: {},
+        geometry: {
+          type: 'Point',
+          coordinates: [item.x, item.z]
+        }
+      };
+    });
+    console.log('正在加载点数据到supercluster:', featuresPoints.length);
+    this._supercluster.load(featuresPoints);
+  }
 
-    /**
-     * get zoom level
-     * @param camera
-     * @returns
-     */
-  }, {
-    key: "getZoomLevel",
-    value: function getZoomLevel(camera) {
-      var minZoom = 10;
-      var maxZoom = 16;
-      var minHeight = 10;
-      var maxHeight = 1000;
-      return Math.max(minZoom, Math.min(maxZoom, (maxHeight - camera.position.y) / (maxHeight - minHeight) * (maxZoom - minZoom) + minZoom));
-    }
+  /**
+   * get zoom level
+   * @param camera
+   * @returns
+   */
+  getZoomLevel(camera) {
+    const minZoom = 10;
+    const maxZoom = 16;
+    const minHeight = 10;
+    const maxHeight = 1000;
+    return Math.max(minZoom, Math.min(maxZoom, (maxHeight - camera.position.y) / (maxHeight - minHeight) * (maxZoom - minZoom) + minZoom));
+  }
 
-    /**
-     * get supercluster data
-     * @returns
-     */
-  }, {
-    key: "getSuperclusterData",
-    value: function getSuperclusterData() {
-      var _this$calDataMaxMin = this.calDataMaxMin(),
-        max = _this$calDataMaxMin.max;
-      var zoom = this.getZoomLevel(use.useScene().camera);
-      var clusters = this._supercluster.getClusters([-max, -max, max, max], zoom);
-      console.log('当前缩放级别:', zoom, '输入点数量:', this.data.length, '聚类后点数量:', clusters.length);
-      return clusters;
-    }
+  /**
+   * get supercluster data
+   * @returns
+   */
+  getSuperclusterData() {
+    const {
+      max
+    } = this.calDataMaxMin();
+    const zoom = this.getZoomLevel(use.useScene().camera);
+    const clusters = this._supercluster.getClusters([-max, -max, max, max], zoom);
+    console.log('当前缩放级别:', zoom, '输入点数量:', this.data.length, '聚类后点数量:', clusters.length);
+    return clusters;
+  }
 
-    /**
-     * calculate data max and min
-     * @returns
-     */
-  }, {
-    key: "calDataMaxMin",
-    value: function calDataMaxMin() {
-      var _this2 = this;
-      var maxX = Math.max.apply(Math, _toConsumableArray(this.data.map(function (item) {
-        return item.x;
-      })));
-      var minX = Math.min.apply(Math, _toConsumableArray(this.data.map(function (item) {
-        return item.x;
-      })));
-      var maxZ = Math.max.apply(Math, _toConsumableArray(this.data.map(function (item) {
-        return item.z;
-      })));
-      var minZ = Math.min.apply(Math, _toConsumableArray(this.data.map(function (item) {
-        return item.z;
-      })));
-      var max = Math.max(Math.abs(Math.ceil(maxX)), Math.abs(Math.ceil(minX)), Math.abs(Math.ceil(maxZ)), Math.abs(Math.ceil(minZ)), 60);
-      var maxRadius = Math.max.apply(Math, _toConsumableArray(this.data.map(function (item) {
-        var _item$radius;
-        return (_item$radius = item.radius) !== null && _item$radius !== void 0 ? _item$radius : _this2._radius;
-      })).concat([this._radius]));
-      var width = max * 2;
-      var height = max * 2;
-      var realShowWidth = maxX - minX;
-      var realShowHeight = maxZ - minZ;
-      var realShowMax = Math.max(Math.ceil(realShowWidth), Math.ceil(realShowHeight), 60);
-      return {
-        width: width,
-        height: height,
-        max: max,
-        minX: minX,
-        minZ: minZ,
-        maxX: maxX,
-        maxZ: maxZ,
-        realShowMax: realShowMax,
-        realShowWidth: realShowWidth,
-        realShowHeight: realShowHeight,
-        maxRadius: maxRadius
-      };
-    }
+  /**
+   * calculate data max and min
+   * @returns
+   */
+  calDataMaxMin() {
+    const maxX = Math.max(...this.data.map(item => item.x));
+    const minX = Math.min(...this.data.map(item => item.x));
+    const maxZ = Math.max(...this.data.map(item => item.z));
+    const minZ = Math.min(...this.data.map(item => item.z));
+    const max = Math.max(Math.abs(Math.ceil(maxX)), Math.abs(Math.ceil(minX)), Math.abs(Math.ceil(maxZ)), Math.abs(Math.ceil(minZ)), 60);
+    const maxRadius = Math.max(...this.data.map(item => {
+      var _item$radius;
+      return (_item$radius = item.radius) !== null && _item$radius !== void 0 ? _item$radius : this._radius;
+    }), this._radius);
+    const width = max * 2;
+    const height = max * 2;
+    const realShowWidth = maxX - minX;
+    const realShowHeight = maxZ - minZ;
+    const realShowMax = Math.max(Math.ceil(realShowWidth), Math.ceil(realShowHeight), 60);
+    return {
+      width,
+      height,
+      max,
+      minX,
+      minZ,
+      maxX,
+      maxZ,
+      realShowMax,
+      realShowWidth,
+      realShowHeight,
+      maxRadius
+    };
+  }
 
-    /**
-     * generateAsitePoints
-     * @param data
-     */
-  }, {
-    key: "generateAsitePoints",
-    value: function generateAsitePoints(data) {
-      var _this3 = this;
-      var maxX = Math.max.apply(Math, _toConsumableArray(data.map(function (item) {
-        return item.x;
-      })));
-      var minX = Math.min.apply(Math, _toConsumableArray(data.map(function (item) {
-        return item.x;
-      })));
-      var maxZ = Math.max.apply(Math, _toConsumableArray(data.map(function (item) {
-        return item.z;
-      })));
-      var minZ = Math.min.apply(Math, _toConsumableArray(data.map(function (item) {
-        return item.z;
-      })));
-      var maxRadius = 2 * Math.max.apply(Math, _toConsumableArray(data.map(function (item) {
-        var _item$radius2;
-        return (_item$radius2 = item.radius) !== null && _item$radius2 !== void 0 ? _item$radius2 : _this3._radius;
-      })).concat([this._radius]));
-      var boundaryPoints = [{
-        x: minX - maxRadius,
-        z: minZ - maxRadius,
-        value: 0,
-        y: 0,
-        isBoundary: true,
-        radius: 0.001
-      }, {
-        x: maxX + maxRadius,
-        z: minZ - maxRadius,
-        value: 0,
-        y: 0,
-        isBoundary: true,
-        radius: 0.001
-      }, {
-        x: minX - maxRadius,
-        z: maxZ + maxRadius,
-        value: 0,
-        y: 0,
-        isBoundary: true,
-        radius: 0.001
-      }, {
-        x: maxX + maxRadius,
-        z: maxZ + maxRadius,
-        value: 0,
-        y: 0,
-        isBoundary: true,
-        radius: 0.001
-      }];
-      return {
-        boundaryPoints: boundaryPoints,
-        maxRadius: maxRadius
-      };
-    }
+  /**
+   * generateAsitePoints
+   * @param data
+   */
+  generateAsitePoints(data) {
+    const maxX = Math.max(...data.map(item => item.x));
+    const minX = Math.min(...data.map(item => item.x));
+    const maxZ = Math.max(...data.map(item => item.z));
+    const minZ = Math.min(...data.map(item => item.z));
+    const maxRadius = 2 * Math.max(...data.map(item => {
+      var _item$radius2;
+      return (_item$radius2 = item.radius) !== null && _item$radius2 !== void 0 ? _item$radius2 : this._radius;
+    }), this._radius);
+    const boundaryPoints = [{
+      x: minX - maxRadius,
+      z: minZ - maxRadius,
+      value: 0,
+      y: 0,
+      isBoundary: true,
+      radius: 0.001
+    }, {
+      x: maxX + maxRadius,
+      z: minZ - maxRadius,
+      value: 0,
+      y: 0,
+      isBoundary: true,
+      radius: 0.001
+    }, {
+      x: minX - maxRadius,
+      z: maxZ + maxRadius,
+      value: 0,
+      y: 0,
+      isBoundary: true,
+      radius: 0.001
+    }, {
+      x: maxX + maxRadius,
+      z: maxZ + maxRadius,
+      value: 0,
+      y: 0,
+      isBoundary: true,
+      radius: 0.001
+    }];
+    return {
+      boundaryPoints,
+      maxRadius
+    };
+  }
 
-    /**
-     * generate new origin
-     * @returns
-     */
-  }, {
-    key: "newOrigin",
-    get: function get() {
-      // need to consider one point and multiple points
-      var _this$calDataMaxMin2 = this.calDataMaxMin(),
-        minX = _this$calDataMaxMin2.minX,
-        minZ = _this$calDataMaxMin2.minZ,
-        maxX = _this$calDataMaxMin2.maxX,
-        maxZ = _this$calDataMaxMin2.maxZ;
-      return {
-        x: (maxX + minX) / 2,
-        z: (maxZ + minZ) / 2
-      };
-    }
+  /**
+   * generate new origin
+   * @returns
+   */
+  get newOrigin() {
+    // need to consider one point and multiple points
+    const {
+      minX,
+      minZ,
+      maxX,
+      maxZ
+    } = this.calDataMaxMin();
+    return {
+      x: (maxX + minX) / 2,
+      z: (maxZ + minZ) / 2
+    };
+  }
 
-    /**
-     * coordinate 3D transformation
-     * @param data
-     * @returns
-     */
-  }, {
-    key: "coordinate3DTransformation",
-    value: function coordinate3DTransformation(data) {
-      var _this4 = this;
-      var _this$newOrigin = this.newOrigin,
-        x = _this$newOrigin.x,
-        z = _this$newOrigin.z;
-      return data.map(function (item) {
-        var _item$radius3;
-        return _objectSpread(_objectSpread({}, item), {}, {
-          x: item.x - x,
-          z: item.z - z,
-          radius: (_item$radius3 = item.radius) !== null && _item$radius3 !== void 0 ? _item$radius3 : _this4._radius
-        });
+  /**
+   * coordinate 3D transformation
+   * @param data
+   * @returns
+   */
+  coordinate3DTransformation(data) {
+    const {
+      x,
+      z
+    } = this.newOrigin;
+    return data.map(item => {
+      var _item$radius3;
+      return _objectSpread(_objectSpread({}, item), {}, {
+        x: item.x - x,
+        z: item.z - z,
+        radius: (_item$radius3 = item.radius) !== null && _item$radius3 !== void 0 ? _item$radius3 : this._radius
       });
-    }
+    });
+  }
 
-    /**
-     * coordinate transformation, to canvas coordinate
-     * @param data
-     * @returns
-     */
-  }, {
-    key: "coordinateTransformation",
-    value: function coordinateTransformation(data) {
-      var _this5 = this;
-      var hanldeData = this.coordinate3DTransformation(data);
-      var _this$calDataMaxMin3 = this.calDataMaxMin(),
-        width = _this$calDataMaxMin3.width,
-        height = _this$calDataMaxMin3.height,
-        realShowWidth = _this$calDataMaxMin3.realShowWidth,
-        realShowHeight = _this$calDataMaxMin3.realShowHeight;
-      var resolutionScale = this.calResolutionScale();
-      var result = hanldeData.map(function (item) {
-        var _item$radius4;
-        return {
-          x: Math.floor((item.x - -realShowWidth / 2) / (realShowWidth / 2 - -realShowWidth / 2) * width) * resolutionScale,
-          y: Math.floor((item.z - -realShowHeight / 2) / (realShowHeight / 2 - -realShowHeight / 2) * height) * resolutionScale,
-          value: item.value,
-          radius: ((_item$radius4 = item.radius) !== null && _item$radius4 !== void 0 ? _item$radius4 : _this5._radius) * resolutionScale * 2,
-          // @ts-ignore
-          isBoundary: item === null || item === void 0 ? void 0 : item.isBoundary
-        };
-      });
+  /**
+   * coordinate transformation, to canvas coordinate
+   * @param data
+   * @returns
+   */
+  coordinateTransformation(data) {
+    const hanldeData = this.coordinate3DTransformation(data);
+    const {
+      width,
+      height,
+      realShowWidth,
+      realShowHeight
+    } = this.calDataMaxMin();
+    const resolutionScale = this.calResolutionScale();
+    const result = hanldeData.map(item => {
+      var _item$radius4;
+      return {
+        x: Math.floor((item.x - -realShowWidth / 2) / (realShowWidth / 2 - -realShowWidth / 2) * width) * resolutionScale,
+        y: Math.floor((item.z - -realShowHeight / 2) / (realShowHeight / 2 - -realShowHeight / 2) * height) * resolutionScale,
+        value: item.value,
+        radius: ((_item$radius4 = item.radius) !== null && _item$radius4 !== void 0 ? _item$radius4 : this._radius) * resolutionScale * 2,
+        // @ts-ignore
+        isBoundary: item === null || item === void 0 ? void 0 : item.isBoundary
+      };
+    });
 
-      // console.log('原始', data, realShowWidth, realShowHeight)
-      // console.log('newOrigin', this.newOrigin)
-      // console.log('hanldeData', hanldeData)
-      // console.log('结果', result)
-      // console.log('resolutionScale', resolutionScale, realShowWidth, realShowHeight, realShowWidth * resolutionScale, realShowHeight * resolutionScale)
+    // console.log('原始', data, realShowWidth, realShowHeight)
+    // console.log('newOrigin', this.newOrigin)
+    // console.log('hanldeData', hanldeData)
+    // console.log('结果', result)
+    // console.log('resolutionScale', resolutionScale, realShowWidth, realShowHeight, realShowWidth * resolutionScale, realShowHeight * resolutionScale)
 
-      return result;
-    }
+    return result;
+  }
 
-    /**
-     * generate heatmap texture
-     * @param canvasBox
-     * @returns
-     */
-  }, {
-    key: "createHeatmapTool",
-    value: function createHeatmapTool() {
-      var heatmap = h.create({
-        container: this._canvasBox,
-        radius: this._radius,
-        gradient: this._colorMap,
-        maxOpacity: 1,
-        minOpacity: 0
-      });
-      return heatmap;
-    }
+  /**
+   * generate heatmap texture
+   * @param canvasBox
+   * @returns
+   */
+  createHeatmapTool() {
+    const heatmap = h.create({
+      container: this._canvasBox,
+      radius: this._radius,
+      gradient: this._colorMap,
+      maxOpacity: 1,
+      minOpacity: 0
+    });
+    return heatmap;
+  }
 
-    /**
-     * create heatmap container canvas
-     * @returns
-     */
-  }, {
-    key: "createCanvas",
-    value: function createCanvas(width, height) {
-      var canvasBox = document.createElement('div');
-      canvasBox.style.width = "".concat(width, "px");
-      canvasBox.style.height = "".concat(height, "px");
-      canvasBox.style.top = '0';
-      canvasBox.style.right = '0';
-      use.useScene().domElement.parentElement.appendChild(canvasBox);
-      return canvasBox;
-    }
+  /**
+   * create heatmap container canvas
+   * @returns
+   */
+  createCanvas(width, height) {
+    const canvasBox = document.createElement('div');
+    canvasBox.style.width = `${width}px`;
+    canvasBox.style.height = `${height}px`;
+    canvasBox.style.top = '0';
+    canvasBox.style.right = '0';
+    use.useScene().domElement.parentElement.appendChild(canvasBox);
+    return canvasBox;
+  }
 
-    /**
-     * calculate resolution scale
-     * @param width
-     * @returns
-     */
-  }, {
-    key: "calResolutionScale",
-    value: function calResolutionScale() {
-      var hanldeData = this.coordinate3DTransformation(this.data);
-      var _this$calDataMaxMin4 = this.calDataMaxMin(),
-        width = _this$calDataMaxMin4.width,
-        height = _this$calDataMaxMin4.height,
-        realShowWidth = _this$calDataMaxMin4.realShowWidth,
-        realShowHeight = _this$calDataMaxMin4.realShowHeight;
-      var result = hanldeData.map(function (item) {
-        return {
-          x: Math.floor((item.x - -realShowWidth / 2) / (realShowWidth / 2 - -realShowWidth / 2) * width),
-          y: Math.floor((item.z - -realShowHeight / 2) / (realShowHeight / 2 - -realShowHeight / 2) * height),
-          value: item.value,
-          radius: item.radius * 2
-        };
-      });
-      var maxRadius = Math.max.apply(Math, _toConsumableArray(result.map(function (item) {
-        return item.radius;
-      })));
-      var maxX = Math.max.apply(Math, _toConsumableArray(result.map(function (item) {
-        return item.x;
-      })));
-      var maxY = Math.max.apply(Math, _toConsumableArray(result.map(function (item) {
-        return item.y;
-      })));
-      var max = Math.max(maxX, maxY);
-      if (max <= 1000) {
-        var scale = (1000 - max) / 1000 * 15 + 1;
-        return Math.floor(maxRadius < 40 ? scale : 1);
-      }
-      if (max <= 5000) {
-        var _scale = (5000 - max) / 5000 * 5 + 1;
-        return Math.floor(maxRadius < 40 ? _scale : 1);
-      }
-      return 1;
+  /**
+   * calculate resolution scale
+   * @param width
+   * @returns
+   */
+  calResolutionScale() {
+    const hanldeData = this.coordinate3DTransformation(this.data);
+    const {
+      width,
+      height,
+      realShowWidth,
+      realShowHeight
+    } = this.calDataMaxMin();
+    const result = hanldeData.map(item => ({
+      x: Math.floor((item.x - -realShowWidth / 2) / (realShowWidth / 2 - -realShowWidth / 2) * width),
+      y: Math.floor((item.z - -realShowHeight / 2) / (realShowHeight / 2 - -realShowHeight / 2) * height),
+      value: item.value,
+      radius: item.radius * 2
+    }));
+    const maxRadius = Math.max(...result.map(item => item.radius));
+    const maxX = Math.max(...result.map(item => item.x));
+    const maxY = Math.max(...result.map(item => item.y));
+    const max = Math.max(maxX, maxY);
+    if (max <= 1000) {
+      const scale = (1000 - max) / 1000 * 15 + 1;
+      return Math.floor(maxRadius < 40 ? scale : 1);
+    }
+    if (max <= 5000) {
+      const scale = (5000 - max) / 5000 * 5 + 1;
+      return Math.floor(maxRadius < 40 ? scale : 1);
     }
+    return 1;
+  }
 
-    /**
-     * create attachment mesh
-     */
-  }, {
-    key: "createAttachmentMesh",
-    value: function createAttachmentMesh() {
-      if (this._attachmentMesh) this.remove(this._attachmentMesh);
-      var _this$calDataMaxMin5 = this.calDataMaxMin(),
-        realShowMax = _this$calDataMaxMin5.realShowMax,
-        max = _this$calDataMaxMin5.max,
-        realShowWidth = _this$calDataMaxMin5.realShowWidth,
-        realShowHeight = _this$calDataMaxMin5.realShowHeight;
-      var canvas = this._heatmap._renderer.canvas;
-      var texture = new CanvasTexture(canvas);
-      texture.minFilter = NearestFilter;
-      texture.magFilter = NearestFilter;
-      this._url = canvas.toDataURL('image/png');
-      var threshold = 0.3 / 1000 * realShowMax;
-      var shaderMaterial = new ShaderMaterial({
-        uniforms: {
-          map: {
-            value: texture
-          },
-          granularity: {
-            value: realShowMax / 3 < 300 ? 300 : realShowMax / 3
-          },
-          threshold: {
-            value: threshold > 0.6 ? 0.6 : threshold < 0.25 ? 0.25 : threshold
-          },
-          uOpacity: {
-            value: 2.0
-          },
-          uHeight: {
-            value: this._height
-          },
-          isPixel: {
-            value: this._isPixel
-          },
-          uRange: {
-            value: new Vector2(-max, max)
-          }
+  /**
+   * create attachment mesh
+   */
+  createAttachmentMesh() {
+    if (this._attachmentMesh) this.remove(this._attachmentMesh);
+    const {
+      realShowMax,
+      max,
+      realShowWidth,
+      realShowHeight
+    } = this.calDataMaxMin();
+    const canvas = this._heatmap._renderer.canvas;
+    const texture = new CanvasTexture(canvas);
+    texture.minFilter = NearestFilter;
+    texture.magFilter = NearestFilter;
+    this._url = canvas.toDataURL('image/png');
+    const threshold = 0.3 / 1000 * realShowMax;
+    const shaderMaterial = new ShaderMaterial({
+      uniforms: {
+        map: {
+          value: texture
         },
-        vertexShader: heightVertexShader,
-        fragmentShader: heightFragmentShader,
-        transparent: true,
-        side: DoubleSide,
-        depthTest: false
-      });
-      var mesh = new Mesh(new PlaneGeometry(realShowWidth, realShowHeight, 500, 500), shaderMaterial);
-      var _this$newOrigin2 = this.newOrigin,
-        x = _this$newOrigin2.x,
-        z = _this$newOrigin2.z;
-      mesh.rotation.x = -Math.PI / 2;
-      mesh.position.set(x, 0, z);
-      mesh.renderOrder = 1000;
-      this._attachmentMesh = mesh;
-      this.add(mesh);
-    }
+        granularity: {
+          value: realShowMax / 3 < 300 ? 300 : realShowMax / 3
+        },
+        threshold: {
+          value: threshold > 0.6 ? 0.6 : threshold < 0.25 ? 0.25 : threshold
+        },
+        uOpacity: {
+          value: 2.0
+        },
+        uHeight: {
+          value: this._height
+        },
+        isPixel: {
+          value: this._isPixel
+        },
+        uRange: {
+          value: new Vector2(-max, max)
+        }
+      },
+      vertexShader: heightVertexShader,
+      fragmentShader: heightFragmentShader,
+      transparent: true,
+      side: DoubleSide,
+      depthTest: false
+    });
+    const mesh = new Mesh(new PlaneGeometry(realShowWidth, realShowHeight, 500, 500), shaderMaterial);
+    const {
+      x,
+      z
+    } = this.newOrigin;
+    mesh.rotation.x = -Math.PI / 2;
+    mesh.position.set(x, 0, z);
+    mesh.renderOrder = 1000;
+    this._attachmentMesh = mesh;
+    this.add(mesh);
+  }
 
-    /**
-     * set heatmap data
-     * @param data
-     */
-  }, {
-    key: "setData",
-    value: function setData(data) {
-      var _this$_range$max, _this$_range, _this$_range$min, _this$_range2;
-      var _this$generateAsitePo = this.generateAsitePoints(data),
-        boundaryPoints = _this$generateAsitePo.boundaryPoints;
-      this.data = [].concat(_toConsumableArray(boundaryPoints), _toConsumableArray(data));
-      var heatmapData = this.coordinateTransformation(this.data);
-      this._canvasBox && use.useScene().domElement.parentElement.removeChild(this._canvasBox);
-      this._canvasBox = this.createCanvas(Math.max.apply(Math, _toConsumableArray(heatmapData.map(function (item) {
-        return item.x;
-      }))), Math.max.apply(Math, _toConsumableArray(heatmapData.map(function (item) {
-        return item.y;
-      }))));
-      this._heatmap = this.createHeatmapTool();
-      this._heatmap.setData({
-        data: heatmapData.filter(function (item) {
-          return !item.isBoundary;
-        }),
-        max: (_this$_range$max = (_this$_range = this._range) === null || _this$_range === void 0 ? void 0 : _this$_range.max) !== null && _this$_range$max !== void 0 ? _this$_range$max : this.defaultMax,
-        min: (_this$_range$min = (_this$_range2 = this._range) === null || _this$_range2 === void 0 ? void 0 : _this$_range2.min) !== null && _this$_range$min !== void 0 ? _this$_range$min : 0
-      });
-      this.createAttachmentMesh();
+  /**
+   * set heatmap data
+   * @param data
+   */
+  setData(data) {
+    var _this$_range$max, _this$_range, _this$_range$min, _this$_range2;
+    const {
+      boundaryPoints
+    } = this.generateAsitePoints(data);
+    this.data = [...boundaryPoints, ...data];
+    const heatmapData = this.coordinateTransformation(this.data);
+    this._canvasBox && use.useScene().domElement.parentElement.removeChild(this._canvasBox);
+    this._canvasBox = this.createCanvas(Math.max(...heatmapData.map(item => item.x)), Math.max(...heatmapData.map(item => item.y)));
+    this._heatmap = this.createHeatmapTool();
+    this._heatmap.setData({
+      data: heatmapData.filter(item => !item.isBoundary),
+      max: (_this$_range$max = (_this$_range = this._range) === null || _this$_range === void 0 ? void 0 : _this$_range.max) !== null && _this$_range$max !== void 0 ? _this$_range$max : this.defaultMax,
+      min: (_this$_range$min = (_this$_range2 = this._range) === null || _this$_range2 === void 0 ? void 0 : _this$_range2.min) !== null && _this$_range$min !== void 0 ? _this$_range$min : 0
+    });
+    this.createAttachmentMesh();
 
-      // 聚类暂时不实现
-      // this.setSuperclusterData()
-      // use.useScene().orbitControls.addEventListener('change', () => {
-      //   const clusters = this.getSuperclusterData()
-      //   console.log(clusters)
-      // })
-    }
-  }, {
-    key: "removeFromParent",
-    value: function removeFromParent() {
-      _get(_getPrototypeOf(HeatMap.prototype), "removeFromParent", this).call(this);
-      // todo: 升级three.js后，父对象变化，会触发此函数，重组内部引起关系
-      if (this.parent) {
-        var _this$_attachmentMesh;
-        use.useScene().domElement.parentElement.removeChild(this._canvasBox);
+    // 聚类暂时不实现
+    // this.setSuperclusterData()
+    // use.useScene().orbitControls.addEventListener('change', () => {
+    //   const clusters = this.getSuperclusterData()
+    //   console.log(clusters)
+    // })
+  }
+  removeFromParent() {
+    super.removeFromParent();
+    // todo: 升级three.js后，父对象变化，会触发此函数，重组内部引起关系
+    if (this.parent) {
+      var _this$_attachmentMesh;
+      use.useScene().domElement.parentElement.removeChild(this._canvasBox);
 
-        // @ts-ignore
-        (_this$_attachmentMesh = this._attachmentMesh) === null || _this$_attachmentMesh === void 0 || _this$_attachmentMesh.material.dispose();
-      }
-      return this;
+      // @ts-ignore
+      (_this$_attachmentMesh = this._attachmentMesh) === null || _this$_attachmentMesh === void 0 || _this$_attachmentMesh.material.dispose();
     }
-  }]);
-  return HeatMap;
-}(Object3D);
+    return this;
+  }
+}
 export default HeatMap;
 //# sourceMappingURL=HeatMap.js.map