zhanmingkan
2022-05-14 0fc43fe898d14895c97427801293edfb3a0c5bf1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
define(function () {
 
 
    /**
    *数学工具类
    *@memberof Cesium
    *@constructor
    */
    function MathUtil() { }
 
    /**
    *
    * 判断给定对象是否为数组
    *@param {Object|*}obj
    */
    MathUtil.isArray = function (obj) {
        return Object.prototype.toString.call(obj) === '[object Array]';
    }
 
    /**
    * 计算最大值
    * @function MathUtil.getMinMax
    * @param {Array.<Number>} arr 数组
    * @param {Number}invalidValue 无效值
    * @returns {Number}
    */
    MathUtil.getMinMax = function (arr, invalidValue) {
        //    if (!MathUtil.isArray(arr)) {
        //        throw new Error("参数不是数组");
        //    }
        var hasInvalidValueParams = typeof invalidValue !== 'undefined' && invalidValue != null;
        var min = Number.MAX_VALUE, max = -Number.MAX_VALUE;
        for (var i = 0; i < arr.length; i++) {
            if (!MathUtil.isArray(arr[i]) && !arr[i].length
                && (isNaN(arr[i]) || (hasInvalidValueParams && invalidValue == arr[i]))) {
                continue;
            }
            if (arr[i] instanceof Array || MathUtil.isArray(arr[i]) || arr[i].length) {
                var minMax = MathUtil.getMinMax(arr[i], invalidValue);
                min = Math.min(minMax[0], min);
                max = Math.max(minMax[1], max);
            } else {
                var v=parseFloat( arr[i])+0.0000001;
                min = Math.min(arr[i], min);
                if (v-max>0) {
                    max = v;
                }
               // max = Math.max(v, max);
            }
        }
        return [min, max];
    }
 
 
    /**
    *地球半径
    *@Object MathUtil.EARTH_RADIUS
    */
    MathUtil.EARTH_RADIUS = 6378.137; //地球半径
    /**
    *角度转弧度
    *@param {Number} d
    */
    MathUtil.rad = function (d) {
        return d * Math.PI / 180.0;
    }
    /**
    * 计算距离
    * @param {Array.<Number>} arr 数组
    * @returns {Number}
    */
    MathUtil.getDistance = function (lat1, lng1, lat2, lng2) {
        var radLat1 = MathUtil.rad(lat1);
        var radLat2 = MathUtil.rad(lat2);
        var a = radLat1 - radLat2;
        var b = MathUtil.rad(lng1) - MathUtil.rad(lng2);
 
        var s = 2 * Math.asin(Math.sqrt(Math.pow(Math.sin(a / 2), 2) +
        Math.cos(radLat1) * Math.cos(radLat2) * Math.pow(Math.sin(b / 2), 2)));
        s = s * MathUtil.EARTH_RADIUS;
        s = Math.round(s * 10000) / 10000;
        return s;
    }
    /**
    * 计算距离
    * @param {Array.<Number>} arr 数组
    * @returns {Number}
    */
    MathUtil.computeLength = function (Points_lc) {
        var len = 0;
        for (var i = 1; i < Points_lc.length; i++) {
            var p1 = Points_lc[i - 1], p2 = Points_lc[i];
            len += MathUtil.getDistance(p1.lat, p1.lon, p2.lat, p2.lon);
        }
        return len;
    }
    /**
    * 计算距离
    * @param {Array.<Number>} arr 数组
    * @returns {Number}
    */
    MathUtil.computeLength2 = function (Points_lc) {
        var len = 0;
        for (var i = 1; i < Points_lc.length; i++) {
            var p1 = Points_lc[i - 1], p2 = Points_lc[i];
            len += Cesium.Cartesian3.distance(p1, p2);
        }
        return len;
    }
 
    /**
    * 计算平均值
    * @param {Array.<Number>} arr 数组
    * @returns {Number}
    */
    MathUtil.avrage = function (arr) {
        /// <summary>计算平均值</summary>
        /// <param name="arr" type="Array">数组</param>
 
        var ret = 0;
        for (var i = 0; i < arr.length; i++) {
            ret += arr[i];
        }
        ret = ret / arr.length;
        return ret;
    }
 
    /**
    * 计算标准差
    * @param {Array.<Number>} arr 数组
    * @returns {Number}
    */
    MathUtil.standardDeviation = function (arr) {
        /// <summary>计算标准差</summary>
        /// <param name="arr" type="Array">数组</param>
 
        var u = MathUtil.avrage(arr);
        var ret = 0;
        for (var i = 0; i < arr.length; i++) {
            ret += (arr[i] - u) * (arr[i] - u);
        }
        ret = ret / arr.length;
        ret = Math.sqrt(ret);
        return ret;
    }
 
    /**
    *风场u、v分量转为风速大小(spr)和方向(dir)
    *@param {Number}u
    *@param {Number}v
    *@param {Array<Number>}outWin
    */
    MathUtil.uv2wind = function uv2wind(u, v, outWin) {
 
        var spd = Math.sqrt(u * u + v * v)
        var tmp = 0.0 - Math.atan2(v, u) * 180.0 / Map.PI
        var dir = tmp % 360.0;
        outWin[0] = spd;
        outWin[1] = dir;
    }
 
    /**
   *风速大小(spr)和方向(dir)转为风场u、v分量
   *@param {Number}spd
   *@param {Number}dir
   *@param {Array<Number>}outUV
   */
    MathUtil.wind2uv = function wind2uv(spd, dir, outUV) {
        var tmp = (0.0 - dir) * Math.PI / 180.0;
        outUV[0] = spd * Math.cos(tmp);
        outUV[1] = spd * Math.sin(tmp);
    }
    return MathUtil;
})