/*
 * @Author: hisense.fanchunxiang
 * @Date: 2021-12-15 17:28:49
 * @LastEditors: hisense.fanchunxiang
 * @LastEditTime: 2021-12-16 09:42:28
 * @Description: file content
 */
/*
 (c) 2014, Vladimir Agafonkin
 simpleheat, a tiny JavaScript library for drawing heatmaps with Canvas
 https://github.com/mourner/simpleheat
*/
!(function () {
  'use strict'
  function t(i) {
    return this instanceof t
      ? ((this._canvas = i =
          'string' == typeof i ? document.getElementById(i) : i),
        (this._ctx = i.getContext('2d')),
        (this._width = i.width),
        (this._height = i.height),
        (this._max = 1),
        void this.clear())
      : new t(i)
  }
  ;(t.prototype = {
    defaultRadius: 25,
    defaultGradient: {
      0.4: 'blue',
      0.6: 'cyan',
      0.7: 'lime',
      0.8: 'yellow',
      1: 'red',
    },
    data: function (t, i) {
      return (this._data = t), this
    },
    max: function (t) {
      return (this._max = t), this
    },
    add: function (t) {
      return this._data.push(t), this
    },
    clear: function () {
      return (this._data = []), this
    },
    radius: function (t, i) {
      i = i || 15
      var a = (this._circle = document.createElement('canvas')),
        s = a.getContext('2d'),
        e = (this._r = t + i)
      return (
        (a.width = a.height = 2 * e),
        (s.shadowOffsetX = s.shadowOffsetY = 200),
        (s.shadowBlur = i),
        (s.shadowColor = 'black'),
        s.beginPath(),
        s.arc(e - 200, e - 200, t, 0, 2 * Math.PI, !0),
        s.closePath(),
        s.fill(),
        this
      )
    },
    gradient: function (t) {
      var i = document.createElement('canvas'),
        a = i.getContext('2d'),
        s = a.createLinearGradient(0, 0, 0, 256)
      ;(i.width = 1), (i.height = 256)
      for (var e in t) s.addColorStop(e, t[e])
      return (
        (a.fillStyle = s),
        a.fillRect(0, 0, 1, 256),
        (this._grad = a.getImageData(0, 0, 1, 256).data),
        this
      )
    },
    draw: function (t) {
      this._circle || this.radius(this.defaultRadius),
        this._grad || this.gradient(this.defaultGradient)
      var i = this._ctx
      i.clearRect(0, 0, this._width, this._height)
      for (var a, s = 0, e = this._data.length; e > s; s++)
        (a = this._data[s]),
          (i.globalAlpha = Math.max(a[2] / this._max, t || 0.05)),
          i.drawImage(this._circle, a[0] - this._r, a[1] - this._r)
      var n = i.getImageData(0, 0, this._width, this._height)
      return this._colorize(n.data, this._grad), i.putImageData(n, 0, 0), this
    },
    _colorize: function (t, i) {
      for (var a, s = 3, e = t.length; e > s; s += 4)
        (a = 4 * t[s]),
          a && ((t[s - 3] = i[a]), (t[s - 2] = i[a + 1]), (t[s - 1] = i[a + 2]))
    },
  }),
    (window.simpleheat = t)
})() /*
 (c) 2014, Vladimir Agafonkin
 Leaflet.heat, a tiny and fast heatmap plugin for Leaflet.
 https://github.com/Leaflet/Leaflet.heat
*/,
  (L.HeatLayer = (L.Layer ? L.Layer : L.Class).extend({
    initialize: function (t, i) {
      ;(this._latlngs = t), L.setOptions(this, i)
    },
    setLatLngs: function (t) {
      return (this._latlngs = t), this.redraw()
    },
    addLatLng: function (t) {
      return this._latlngs.push(t), this.redraw()
    },
    setOptions: function (t) {
      return (
        L.setOptions(this, t),
        this._heat && this._updateOptions(),
        this.redraw()
      )
    },
    redraw: function () {
      return (
        !this._heat ||
          this._frame ||
          this._map._animating ||
          (this._frame = L.Util.requestAnimFrame(this._redraw, this)),
        this
      )
    },
    onAdd: function (t) {
      ;(this._map = t),
        this._canvas || this._initCanvas(),
        t._panes.overlayPane.appendChild(this._canvas),
        t.on('moveend', this._reset, this),
        t.options.zoomAnimation &&
          L.Browser.any3d &&
          t.on('zoomanim', this._animateZoom, this),
        this._reset()
    },
    onRemove: function (t) {
      t.getPanes().overlayPane.removeChild(this._canvas),
        t.off('moveend', this._reset, this),
        t.options.zoomAnimation && t.off('zoomanim', this._animateZoom, this)
    },
    addTo: function (t) {
      return t.addLayer(this), this
    },
    _initCanvas: function () {
      var t = (this._canvas = L.DomUtil.create(
          'canvas',
          'leaflet-heatmap-layer leaflet-layer'
        )),
        i = L.DomUtil.testProp([
          'transformOrigin',
          'WebkitTransformOrigin',
          'msTransformOrigin',
        ])
      t.style[i] = '50% 50%'
      var a = this._map.getSize()
      ;(t.width = a.x), (t.height = a.y)
      var s = this._map.options.zoomAnimation && L.Browser.any3d
      L.DomUtil.addClass(t, 'leaflet-zoom-' + (s ? 'animated' : 'hide')),
        (this._heat = simpleheat(t)),
        this._updateOptions()
    },
    _updateOptions: function () {
      this._heat.radius(
        this.options.radius || this._heat.defaultRadius,
        this.options.blur
      ),
        this.options.gradient && this._heat.gradient(this.options.gradient),
        this.options.max && this._heat.max(this.options.max)
    },
    _reset: function () {
      var t = this._map.containerPointToLayerPoint([0, 0])
      L.DomUtil.setPosition(this._canvas, t)
      var i = this._map.getSize()
      this._heat._width !== i.x &&
        (this._canvas.width = this._heat._width = i.x),
        this._heat._height !== i.y &&
          (this._canvas.height = this._heat._height = i.y),
        this._redraw()
    },
    _redraw: function () {
      var t,
        i,
        a,
        s,
        e,
        n,
        h,
        o,
        r,
        d = [],
        _ = this._heat._r,
        l = this._map.getSize(),
        m = new L.Bounds(L.point([-_, -_]), l.add([_, _])),
        c = void 0 === this.options.max ? 1 : this.options.max,
        u =
          void 0 === this.options.maxZoom
            ? this._map.getMaxZoom()
            : this.options.maxZoom,
        f = 1 / Math.pow(2, Math.max(0, Math.min(u - this._map.getZoom(), 12))),
        g = _ / 2,
        p = [],
        v = this._map._getMapPanePos(),
        w = v.x % g,
        y = v.y % g
      for (t = 0, i = this._latlngs.length; i > t; t++)
        if (
          ((a = this._map.latLngToContainerPoint(this._latlngs[t])),
          m.contains(a))
        ) {
          ;(e = Math.floor((a.x - w) / g) + 2),
            (n = Math.floor((a.y - y) / g) + 2)
          var x =
            void 0 !== this._latlngs[t].alt
              ? this._latlngs[t].alt
              : void 0 !== this._latlngs[t][2]
              ? +this._latlngs[t][2]
              : 1
          ;(r = x * f),
            (p[n] = p[n] || []),
            (s = p[n][e]),
            s
              ? ((s[0] = (s[0] * s[2] + a.x * r) / (s[2] + r)),
                (s[1] = (s[1] * s[2] + a.y * r) / (s[2] + r)),
                (s[2] += r))
              : (p[n][e] = [a.x, a.y, r])
        }
      for (t = 0, i = p.length; i > t; t++)
        if (p[t])
          for (h = 0, o = p[t].length; o > h; h++)
            (s = p[t][h]),
              s &&
                d.push([Math.round(s[0]), Math.round(s[1]), Math.min(s[2], c)])
      this._heat.data(d).draw(this.options.minOpacity), (this._frame = null)
    },
    _animateZoom: function (t) {
      var i = this._map.getZoomScale(t.zoom),
        a = this._map
          ._getCenterOffset(t.center)
          ._multiplyBy(-i)
          .subtract(this._map._getMapPanePos())
      L.DomUtil.setTransform
        ? L.DomUtil.setTransform(this._canvas, a, i)
        : (this._canvas.style[L.DomUtil.TRANSFORM] =
            L.DomUtil.getTranslateString(a) + ' scale(' + i + ')')
    },
  })),
  (L.heatLayer = function (t, i) {
    return new L.HeatLayer(t, i)
  })