高德地图, 根据长/宽/角度 绘制矩形 polygon

   created(){
      map.off('click', this.drawPolygon)
    },
    methods: {
      // 点击地图绘制矩形polygon
      drawPolygon(e) {
        // 地图点击坐标
        const lnglat = {
          lon: e.lnglat.getLng(),
          lat: e.lnglat.getLat()
        }
        // 宽度/2
        const dist = Math.sqrt(
          Math.pow(polygonWidth / 2, 2)
        )
        // 获取到绘制的polygon路径
        const path = this.getPlocat(lnglat, this.angle, dist)
        // 展示出绘制的polygon
        var polygon = new AMap.Polygon({
          path: path,
          strokeDasharray: [30, 10],
          strokeColor: '#00A81B',
          strokeOpacity: 0.5,
          fillOpacity: 0.3,
          fillColor: '#00A81BC9',
          zIndex: 99999,
          strokeStyle: 'solid',
          draggable: true
        })
        polygon.setMap(map)
        map.setFitView(polygon)
        return polygon
      },

      // 修改角度
      changeAngle() {
        this.changePolygon()
      },
      // 修改长度
      changeLength() {
        this.changePolygon()
      },
      // 修改宽度
      changeWidth() {
        this.changePolygon()
      },
      // 根据长宽角度,变更polygon
      changePolygon() {
        if (polygon) {
          // 获取矩形旋转点
          const center = polygon.getPath()
          const lonlat = {
            lon: (center[0].lat + center[3].lat) / 2,
            lat: (center[0].lng + center[3].lng) / 2
          }
          const dist = Math.sqrt(
            Math.pow(polygonWidth / 2, 2)
          )
          // 获取变更后的polygon
          const path = this.getPlocat(lonlat, angle, dist)
          polygon.setOptions({
            path: path
          })
        }
      },
      // 根据绘制中心点,角度,长宽,求四个角点的坐标
      getPlocat(lonlat, roat, dist) {
        var marr = []
        var pob1 = [
          this.creatP(lonlat, roat, dist).lon,
          this.creatP(lonlat, roat, dist).lat
        ]
        var pob2 = [
          this.creatP(
            { lon: pob1[0], lat: pob1[1] },
            roat + 90,
            polygonWidth
          ).lon,
          this.creatP(
            { lon: pob1[0], lat: pob1[1] },
            roat + 90,
            polygonLength
          ).lat
        ]
        var pob3 = [
          this.creatP(
            { lon: pob2[0], lat: pob2[1] },
            roat + 180,
            polygonWidth
          ).lon,
          this.creatP(
            { lon: pob2[0], lat: pob2[1] },
            roat + 180,
            polygonWidth
          ).lat
        ]
        var pob4 = [
          this.creatP(
            lonlat,
            roat +
            (2 * Math.asin(polygonWidth / 2 / dist) * 180) / Math.PI,
            dist
          ).lon,
          this.creatP(
            lonlat,
            roat +
            (2 * Math.asin(polygonWidth / 2 / dist) * 180) / Math.PI,
            dist
          ).lat
        ]
        marr[0] = pob1
        marr[1] = pob2
        marr[2] = pob3
        marr[3] = pob4
        return marr
      },
      creatP(lonlat, roat, dist) {
        var top = this.destinationVincenty(lonlat, roat, dist)
        return top
      },
      // 根据一个经纬度及距离角度，算出另外一个经纬度
      destinationVincenty(lonlat, brng, dist) {
        var that = this
        var ct = {
          a: 6378137,
          b: 6356752.3142,
          f: 1 / 298.257223563
        }
        var a = ct.a
        var b = ct.b
        var f = ct.f
        var lon1 = parseFloat(lonlat.lon)
        var lat1 = parseFloat(lonlat.lat)
        var s = dist
        var alpha1 = that.rad(brng)
        var sinAlpha1 = Math.sin(alpha1)
        var cosAlpha1 = Math.cos(alpha1)
        var tanU1 = (1 - f) * Math.tan(that.rad(lat1))
        var cosU1 = 1 / Math.sqrt(1 + tanU1 * tanU1)
        var sinU1 = tanU1 * cosU1
        var sigma1 = Math.atan2(tanU1, cosAlpha1)
        var sinAlpha = cosU1 * sinAlpha1
        var cosSqAlpha = 1 - sinAlpha * sinAlpha
        var uSq = (cosSqAlpha * (a * a - b * b)) / (b * b)
        var A =
          1 + (uSq / 16384) * (4096 + uSq * (-768 + uSq * (320 - 175 * uSq)))
        var B = (uSq / 1024) * (256 + uSq * (-128 + uSq * (74 - 47 * uSq)))
        var sigma = s / (b * A)
        var sigmaP = 2 * Math.PI
        while (Math.abs(sigma - sigmaP) > 1e-12) {
          var cos2SigmaM = Math.cos(2 * sigma1 + sigma)
          var sinSigma = Math.sin(sigma)
          var cosSigma = Math.cos(sigma)
          var deltaSigma =
            B *
            sinSigma *
            (cos2SigmaM +
              (B / 4) *
              (cosSigma * (-1 + 2 * cos2SigmaM * cos2SigmaM) -
                (B / 6) *
                cos2SigmaM *
                (-3 + 4 * sinSigma * sinSigma) *
                (-3 + 4 * cos2SigmaM * cos2SigmaM)))
          sigmaP = sigma
          sigma = s / (b * A) + deltaSigma
        }
        var tmp = sinU1 * sinSigma - cosU1 * cosSigma * cosAlpha1
        var lat2 = Math.atan2(
          sinU1 * cosSigma + cosU1 * sinSigma * cosAlpha1,
          (1 - f) * Math.sqrt(sinAlpha * sinAlpha + tmp * tmp)
        )
        var lambda = Math.atan2(
          sinSigma * sinAlpha1,
          cosU1 * cosSigma - sinU1 * sinSigma * cosAlpha1
        )
        var C = (f / 16) * cosSqAlpha * (4 + f * (4 - 3 * cosSqAlpha))
        var L =
          lambda -
          (1 - C) *
          f *
          sinAlpha *
          (sigma +
            C *
            sinSigma *
            (cos2SigmaM + C * cosSigma * (-1 + 2 * cos2SigmaM * cos2SigmaM)))
        // eslint-disable-next-line no-unused-vars
        var revAz = Math.atan2(sinAlpha, -tmp) // final bearing
        var lon_destina = lon1 * 1 + that.deg(L)
        var lonlat_destination = { lon: lon_destina, lat: that.deg(lat2) }
        return lonlat_destination
      },

      rad(d) {
        return (d * Math.PI) / 180.0
      },

      deg(x) {
        return (x * 180) / Math.PI
      },
    }