@anov/3d-ability 0.0.142 → 0.0.143

package/dist/business/HeatMap/HeatMap.js

@@ -1,13 +1,32 @@
+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";
-const defaultGradient = {
+var defaultGradient = {
   0.25: 'rgb(0,0,255)',
   0.55: 'rgb(0,255,0)',
   0.85: 'yellow',
@@ -17,407 +36,475 @@ const defaultGradient = {
 /**
  * 区域热力图
  */
-
-class HeatMap extends Object3D {
-  get defaultMax() {
-    return Math.max(...this.data.map(item => item.value));
-  }
-  get url() {
-    return this._url;
-  }
-  constructor(options) {
+var HeatMap = /*#__PURE__*/function (_Object3D) {
+  _inherits(HeatMap, _Object3D);
+  var _super = _createSuper(HeatMap);
+  function HeatMap(options) {
     var _options$radius, _options$height, _options$isPixel;
-    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;
+    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;
 
     // this.initSupercluster()
+    return _this;
   }
-  initSupercluster() {
-    this._supercluster = new Supercluster({
-      radius: 40,
-      minZoom: 1,
-      maxZoom: 16
-    });
-  }
-
-  /**
-   * 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
-   */
-  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));
-  }
+  _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
+      });
+    }
 
-  /**
-   * 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;
-  }
+    /**
+     * 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);
+    }
 
-  /**
-   * 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
-    };
-  }
+    /**
+     * 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));
+    }
 
-  /**
-   * 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
-    };
-  }
+    /**
+     * 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;
+    }
 
-  /**
-   * 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
-    };
-  }
+    /**
+     * 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
+      };
+    }
 
-  /**
-   * 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
-      });
-    });
-  }
+    /**
+     * 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
+      };
+    }
 
-  /**
-   * 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;
+    /**
+     * 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: 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
+        x: (maxX + minX) / 2,
+        z: (maxZ + minZ) / 2
       };
-    });
+    }
 
-    // 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)
+    /**
+     * 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
+        });
+      });
+    }
 
-    return result;
-  }
+    /**
+     * 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
+        };
+      });
 
-  /**
-   * 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;
-  }
+      // 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)
 
-  /**
-   * 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;
-  }
+      return result;
+    }
 
-  /**
-   * 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);
+    /**
+     * 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;
     }
-    if (max <= 5000) {
-      const scale = (5000 - max) / 5000 * 5 + 1;
-      return Math.floor(maxRadius < 40 ? scale : 1);
+
+    /**
+     * 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;
     }
-    return 1;
-  }
 
-  /**
-   * 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
-        },
-        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
+    /**
+     * 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;
+    }
+
+    /**
+     * 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)
+          }
         },
-        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);
-  }
+        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);
+    }
 
-  /**
-   * 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();
+    /**
+     * 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();
 
-    // 聚类暂时不实现
-    // 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);
+      // 聚类暂时不实现
+      // 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);
 
-      // @ts-ignore
-      (_this$_attachmentMesh = this._attachmentMesh) === null || _this$_attachmentMesh === void 0 || _this$_attachmentMesh.material.dispose();
+        // @ts-ignore
+        (_this$_attachmentMesh = this._attachmentMesh) === null || _this$_attachmentMesh === void 0 || _this$_attachmentMesh.material.dispose();
+      }
+      return this;
     }
-    return this;
-  }
-}
+  }]);
+  return HeatMap;
+}(Object3D);
 export default HeatMap;
 //# sourceMappingURL=HeatMap.js.map