cesium_dev_kit 1.0.50 → 1.0.51

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -1,559 +0,0 @@
1
- "use strict";
2
-
3
- Object.defineProperty(exports, "__esModule", {
4
- value: true
5
- });
6
- exports.Math2d = Math2d;
7
- let Cesium = {};
8
- /**
9
- * 平面数学工具
10
- * 二维模块
11
- * @param {*} viewer
12
- */
13
- function Math2d(viewer, cesiumGlobal) {
14
- if (viewer) {
15
- this._viewer = viewer;
16
- Cesium = cesiumGlobal;
17
- }
18
- }
19
- Math2d.prototype = {
20
- /**
21
- * 计算两个坐标之间的距离
22
- * @param pnt1
23
- * @param pnt2
24
- * @returns {number}
25
- * @constructor
26
- */
27
- mathDistance2d: function (pnt1, pnt2) {
28
- return Math.sqrt(Math.pow(pnt1[0] - pnt2[0], 2) + Math.pow(pnt1[1] - pnt2[1], 2));
29
- },
30
- /**
31
- * 求圆周上等分点的坐标
32
- * @param {*} r r为半径
33
- * @param {*} ox ox,oy为圆心坐标
34
- * @param {*} oy d
35
- * @param {*} count count为等分个数
36
- */
37
- getCirclePoints2d: function (r, ox, oy, count) {
38
- var point = []; //结果
39
- var radians = Math.PI / 180 * Math.round(360 / count),
40
- //弧度
41
- i = 0;
42
- for (; i < count; i++) {
43
- var x = ox + r * Math.sin(radians * i),
44
- y = oy + r * Math.cos(radians * i);
45
- point.unshift({
46
- x: x,
47
- y: y
48
- }); //为保持数据顺时针
49
- }
50
-
51
- return point;
52
- },
53
- /**
54
- * 计算点集合的总距离
55
- * @param points
56
- * @returns {number}
57
- */
58
- wholeDistance2d: function (points) {
59
- let distance = 0;
60
- if (points && Array.isArray(points) && points.length > 0) {
61
- points.forEach((item, index) => {
62
- if (index < points.length - 1) {
63
- distance += this.mathDistance2d(item, points[index + 1]);
64
- }
65
- });
66
- }
67
- return distance;
68
- },
69
- /**
70
- * 获取基础长度
71
- * @param points
72
- * @returns {number}
73
- */
74
- getBaseLength2d: function (points) {
75
- return Math.pow(this.wholeDistance2d(points), 0.99);
76
- },
77
- /**
78
- * 计算星型
79
- * @param {*} arms
80
- * @param {*} rOuter
81
- * @param {*} rInner
82
- */
83
- computeStar2d(arms, rOuter, rInner) {
84
- var angle = Math.PI / arms;
85
- var length = 2 * arms;
86
- var positions = new Array(length);
87
- for (var i = 0; i < length; i++) {
88
- var r = i % 2 === 0 ? rOuter : rInner;
89
- positions[i] = new Cesium.Cartesian2(Math.cos(i * angle) * r, Math.sin(i * angle) * r);
90
- }
91
- return positions;
92
- },
93
- /*
94
- * 计算圆型
95
- * @param {*} arms
96
- * @param {*} rOuter
97
- * @param {*} rInner
98
- */
99
- computeCircleShap(radius) {
100
- let positions = [];
101
- for (let i = 0; i < 360; i++) {
102
- let radians = Cesium.Math.toRadians(i);
103
- positions.push(new Cesium.Cartesian2(radius * Math.cos(radians), radius * Math.sin(radians)));
104
- }
105
- return positions;
106
- },
107
- /**
108
- * 求取两个坐标的中间值
109
- * @param point1
110
- * @param point2
111
- * @returns {[*,*]}
112
- * @constructor
113
- */
114
- mid2d: function (point1, point2) {
115
- return [(point1[0] + point2[0]) / 2, (point1[1] + point2[1]) / 2];
116
- },
117
- /**
118
- * 通过三个点确定一个圆的中心点
119
- * @param point1
120
- * @param point2
121
- * @param point3
122
- */
123
- getCircleCenterOfThreePoints2d: function (point1, point2, point3) {
124
- let pntA = [(point1[0] + point2[0]) / 2, (point1[1] + point2[1]) / 2];
125
- let pntB = [pntA[0] - point1[1] + point2[1], pntA[1] + point1[0] - point2[0]];
126
- let pntC = [(point1[0] + point3[0]) / 2, (point1[1] + point3[1]) / 2];
127
- let pntD = [pntC[0] - point1[1] + point3[1], pntC[1] + point1[0] - point3[0]];
128
- return this.getIntersectPoint2d(pntA, pntB, pntC, pntD);
129
- },
130
- /**
131
- * 获取交集的点
132
- * @param pntA
133
- * @param pntB
134
- * @param pntC
135
- * @param pntD
136
- * @returns {[*,*]}
137
- */
138
- getIntersectPoint2d: function (pntA, pntB, pntC, pntD) {
139
- if (pntA[1] === pntB[1]) {
140
- let f = (pntD[0] - pntC[0]) / (pntD[1] - pntC[1]);
141
- let x = f * (pntA[1] - pntC[1]) + pntC[0];
142
- let y = pntA[1];
143
- return [x, y];
144
- }
145
- if (pntC[1] === pntD[1]) {
146
- let e = (pntB[0] - pntA[0]) / (pntB[1] - pntA[1]);
147
- let x = e * (pntC[1] - pntA[1]) + pntA[0];
148
- let y = pntC[1];
149
- return [x, y];
150
- }
151
- let e = (pntB[0] - pntA[0]) / (pntB[1] - pntA[1]);
152
- let f = (pntD[0] - pntC[0]) / (pntD[1] - pntC[1]);
153
- let y = (e * pntA[1] - pntA[0] - f * pntC[1] + pntC[0]) / (e - f);
154
- let x = e * y - e * pntA[1] + pntA[0];
155
- return [x, y];
156
- },
157
- /**
158
- * 获取方位角(地平经度)
159
- * @param startPoint
160
- * @param endPoint
161
- * @returns {*}
162
- */
163
- getAzimuth2d: function (startPoint, endPoint) {
164
- let azimuth;
165
- let angle = Math.asin(Math.abs(endPoint[1] - startPoint[1]) / this.mathDistance2d(startPoint, endPoint));
166
- if (endPoint[1] >= startPoint[1] && endPoint[0] >= startPoint[0]) {
167
- azimuth = angle + Math.PI;
168
- } else if (endPoint[1] >= startPoint[1] && endPoint[0] < startPoint[0]) {
169
- azimuth = Math.PI * 2 - angle;
170
- } else if (endPoint[1] < startPoint[1] && endPoint[0] < startPoint[0]) {
171
- azimuth = angle;
172
- } else if (endPoint[1] < startPoint[1] && endPoint[0] >= startPoint[0]) {
173
- azimuth = Math.PI - angle;
174
- }
175
- return azimuth;
176
- },
177
- /**
178
- * 通过三个点获取方位角
179
- * @param pntA
180
- * @param pntB
181
- * @param pntC
182
- * @returns {number}
183
- */
184
- getAngleOfThreePoints2d: function (pntA, pntB, pntC) {
185
- let angle = this.getAzimuth2d(pntB, pntA) - this.getAzimuth2d(pntB, pntC);
186
- return angle < 0 ? angle + Math.PI * 2 : angle;
187
- },
188
- /**
189
- * 判断是否是顺时针
190
- * @param pnt1
191
- * @param pnt2
192
- * @param pnt3
193
- * @returns {boolean}
194
- */
195
- isClockWise2d: function (pnt1, pnt2, pnt3) {
196
- return (pnt3[1] - pnt1[1]) * (pnt2[0] - pnt1[0]) > (pnt2[1] - pnt1[1]) * (pnt3[0] - pnt1[0]);
197
- },
198
- /**
199
- * 获取线上的点
200
- * @param t
201
- * @param startPnt
202
- * @param endPnt
203
- * @returns {[*,*]}
204
- */
205
- getPointOnLine2d: function (t, startPnt, endPnt) {
206
- let x = startPnt[0] + t * (endPnt[0] - startPnt[0]);
207
- let y = startPnt[1] + t * (endPnt[1] - startPnt[1]);
208
- return [x, y];
209
- },
210
- /**
211
- * 获取立方值
212
- * @param t
213
- * @param startPnt
214
- * @param cPnt1
215
- * @param cPnt2
216
- * @param endPnt
217
- * @returns {[*,*]}
218
- */
219
- getCubicValue2d: function (t, startPnt, cPnt1, cPnt2, endPnt) {
220
- t = Math.max(Math.min(t, 1), 0);
221
- let [tp, t2] = [1 - t, t * t];
222
- let t3 = t2 * t;
223
- let tp2 = tp * tp;
224
- let tp3 = tp2 * tp;
225
- let x = tp3 * startPnt[0] + 3 * tp2 * t * cPnt1[0] + 3 * tp * t2 * cPnt2[0] + t3 * endPnt[0];
226
- let y = tp3 * startPnt[1] + 3 * tp2 * t * cPnt1[1] + 3 * tp * t2 * cPnt2[1] + t3 * endPnt[1];
227
- return [x, y];
228
- },
229
- /**
230
- * 根据起止点和旋转方向求取第三个点
231
- * @param startPnt
232
- * @param endPnt
233
- * @param angle
234
- * @param distance
235
- * @param clockWise
236
- * @returns {[*,*]}
237
- */
238
- getThirdPoint2d: function (startPnt, endPnt, angle, distance, clockWise) {
239
- let azimuth = this.getAzimuth2d(startPnt, endPnt);
240
- let alpha = clockWise ? azimuth + angle : azimuth - angle;
241
- let dx = distance * Math.cos(alpha);
242
- let dy = distance * Math.sin(alpha);
243
- return [endPnt[0] + dx, endPnt[1] + dy];
244
- },
245
- /**
246
- * 函数继承
247
- * @param childCtor
248
- * @param parentCtor
249
- */
250
- inherits2d: function (childCtor, parentCtor) {
251
- /** @constructor */
252
- function TempCtor() {}
253
- TempCtor.prototype = parentCtor.prototype;
254
- childCtor.superClass_ = parentCtor.prototype;
255
- childCtor.prototype = new TempCtor();
256
- /** @override */
257
- childCtor.prototype.constructor = childCtor;
258
- childCtor.base = function (me, methodName, varArgs) {
259
- let args = Array.prototype.slice.call(arguments, 2);
260
- return parentCtor.prototype[methodName].apply(me, args);
261
- };
262
- },
263
- /**
264
- * 插值弓形线段点
265
- * @param center
266
- * @param radius
267
- * @param startAngle
268
- * @param endAngle
269
- * @returns {null}
270
- */
271
- getArcPoints2d: function (center, radius, startAngle, endAngle) {
272
- let [x, y, pnts, angleDiff] = [null, null, [], endAngle - startAngle];
273
- angleDiff = angleDiff < 0 ? angleDiff + Math.PI * 2 : angleDiff;
274
- for (let i = 0; i <= 100; i++) {
275
- let angle = startAngle + angleDiff * i / 100;
276
- x = center[0] + radius * Math.cos(angle);
277
- y = center[1] + radius * Math.sin(angle);
278
- pnts.push([x, y]);
279
- }
280
- return pnts;
281
- },
282
- /**
283
- * getBisectorNormals
284
- * @param t
285
- * @param pnt1
286
- * @param pnt2
287
- * @param pnt3
288
- * @returns {[*,*]}
289
- */
290
- getBisectorNormals2d: function (t, pnt1, pnt2, pnt3) {
291
- let normal = this.getNormal2d(pnt1, pnt2, pnt3);
292
- let [bisectorNormalRight, bisectorNormalLeft, dt, x, y] = [null, null, null, null, null];
293
- let dist = Math.sqrt(normal[0] * normal[0] + normal[1] * normal[1]);
294
- let uX = normal[0] / dist;
295
- let uY = normal[1] / dist;
296
- let d1 = this.mathDistance2d(pnt1, pnt2);
297
- let d2 = this.mathDistance2d(pnt2, pnt3);
298
- if (dist > 0.0001) {
299
- if (this.isClockWise(pnt1, pnt2, pnt3)) {
300
- dt = t * d1;
301
- x = pnt2[0] - dt * uY;
302
- y = pnt2[1] + dt * uX;
303
- bisectorNormalRight = [x, y];
304
- dt = t * d2;
305
- x = pnt2[0] + dt * uY;
306
- y = pnt2[1] - dt * uX;
307
- bisectorNormalLeft = [x, y];
308
- } else {
309
- dt = t * d1;
310
- x = pnt2[0] + dt * uY;
311
- y = pnt2[1] - dt * uX;
312
- bisectorNormalRight = [x, y];
313
- dt = t * d2;
314
- x = pnt2[0] - dt * uY;
315
- y = pnt2[1] + dt * uX;
316
- bisectorNormalLeft = [x, y];
317
- }
318
- } else {
319
- x = pnt2[0] + t * (pnt1[0] - pnt2[0]);
320
- y = pnt2[1] + t * (pnt1[1] - pnt2[1]);
321
- bisectorNormalRight = [x, y];
322
- x = pnt2[0] + t * (pnt3[0] - pnt2[0]);
323
- y = pnt2[1] + t * (pnt3[1] - pnt2[1]);
324
- bisectorNormalLeft = [x, y];
325
- }
326
- return [bisectorNormalRight, bisectorNormalLeft];
327
- },
328
- /**
329
- * 获取默认三点的内切圆
330
- * @param pnt1
331
- * @param pnt2
332
- * @param pnt3
333
- * @returns {[*,*]}
334
- */
335
- getNormal2d: function (pnt1, pnt2, pnt3) {
336
- let dX1 = pnt1[0] - pnt2[0];
337
- let dY1 = pnt1[1] - pnt2[1];
338
- let d1 = Math.sqrt(dX1 * dX1 + dY1 * dY1);
339
- dX1 /= d1;
340
- dY1 /= d1;
341
- let dX2 = pnt3[0] - pnt2[0];
342
- let dY2 = pnt3[1] - pnt2[1];
343
- let d2 = Math.sqrt(dX2 * dX2 + dY2 * dY2);
344
- dX2 /= d2;
345
- dY2 /= d2;
346
- let uX = dX1 + dX2;
347
- let uY = dY1 + dY2;
348
- return [uX, uY];
349
- },
350
- /**
351
- * 获取左边控制点
352
- * @param controlPoints
353
- * @returns {[*,*]}
354
- */
355
- getLeftMostControlPoint2d: function (controlPoints, t) {
356
- let [pnt1, pnt2, pnt3, controlX, controlY] = [controlPoints[0], controlPoints[1], controlPoints[2], null, null];
357
- let pnts = this.getBisectorNormals2d(0, pnt1, pnt2, pnt3);
358
- let normalRight = pnts[0];
359
- let normal = this.getNormal2d(pnt1, pnt2, pnt3);
360
- let dist = Math.sqrt(normal[0] * normal[0] + normal[1] * normal[1]);
361
- if (dist > 0.0001) {
362
- let mid = this.mid2d(pnt1, pnt2);
363
- let pX = pnt1[0] - mid[0];
364
- let pY = pnt1[1] - mid[1];
365
- let d1 = this.mathDistance2d(pnt1, pnt2);
366
- let n = 2.0 / d1;
367
- let nX = -n * pY;
368
- let nY = n * pX;
369
- let a11 = nX * nX - nY * nY;
370
- let a12 = 2 * nX * nY;
371
- let a22 = nY * nY - nX * nX;
372
- let dX = normalRight[0] - mid[0];
373
- let dY = normalRight[1] - mid[1];
374
- controlX = mid[0] + a11 * dX + a12 * dY;
375
- controlY = mid[1] + a12 * dX + a22 * dY;
376
- } else {
377
- controlX = pnt1[0] + t * (pnt2[0] - pnt1[0]);
378
- controlY = pnt1[1] + t * (pnt2[1] - pnt1[1]);
379
- }
380
- return [controlX, controlY];
381
- },
382
- /**
383
- * 获取右边控制点
384
- * @param controlPoints
385
- * @param t
386
- * @returns {[*,*]}
387
- */
388
- getRightMostControlPoint2d: function (controlPoints, t) {
389
- let count = controlPoints.length;
390
- let pnt1 = controlPoints[count - 3];
391
- let pnt2 = controlPoints[count - 2];
392
- let pnt3 = controlPoints[count - 1];
393
- let pnts = this.getBisectorNormals2d(0, pnt1, pnt2, pnt3);
394
- let normalLeft = pnts[1];
395
- let normal = this.getNormal2d(pnt1, pnt2, pnt3);
396
- let dist = Math.sqrt(normal[0] * normal[0] + normal[1] * normal[1]);
397
- let [controlX, controlY] = [null, null];
398
- if (dist > 0.0001) {
399
- let mid = this.mid2d(pnt2, pnt3);
400
- let pX = pnt3[0] - mid[0];
401
- let pY = pnt3[1] - mid[1];
402
- let d1 = this.mathDistance2d(pnt2, pnt3);
403
- let n = 2.0 / d1;
404
- let nX = -n * pY;
405
- let nY = n * pX;
406
- let a11 = nX * nX - nY * nY;
407
- let a12 = 2 * nX * nY;
408
- let a22 = nY * nY - nX * nX;
409
- let dX = normalLeft[0] - mid[0];
410
- let dY = normalLeft[1] - mid[1];
411
- controlX = mid[0] + a11 * dX + a12 * dY;
412
- controlY = mid[1] + a12 * dX + a22 * dY;
413
- } else {
414
- controlX = pnt3[0] + t * (pnt2[0] - pnt3[0]);
415
- controlY = pnt3[1] + t * (pnt2[1] - pnt3[1]);
416
- }
417
- return [controlX, controlY];
418
- },
419
- /**
420
- * 插值曲线点
421
- * @param t
422
- * @param controlPoints
423
- * @returns {null}
424
- */
425
- getCurvePoints2d: function (t, controlPoints) {
426
- let leftControl = this.getLeftMostControlPoint2d(controlPoints, t);
427
- let [pnt1, pnt2, pnt3, normals, points] = [null, null, null, [leftControl], []];
428
- for (let i = 0; i < controlPoints.length - 2; i++) {
429
- [pnt1, pnt2, pnt3] = [controlPoints[i], controlPoints[i + 1], controlPoints[i + 2]];
430
- let normalPoints = this.getBisectorNormals2d(t, pnt1, pnt2, pnt3);
431
- normals = normals.concat(normalPoints);
432
- }
433
- let rightControl = this.getRightMostControlPoint2d(controlPoints, t);
434
- if (rightControl) {
435
- normals.push(rightControl);
436
- }
437
- for (let i = 0; i < controlPoints.length - 1; i++) {
438
- pnt1 = controlPoints[i];
439
- pnt2 = controlPoints[i + 1];
440
- points.push(pnt1);
441
- for (let t = 0; t < 100; t++) {
442
- let pnt = this.getCubicValue2d(t / 100, pnt1, normals[i * 2], normals[i * 2 + 1], pnt2);
443
- points.push(pnt);
444
- }
445
- points.push(pnt2);
446
- }
447
- return points;
448
- },
449
- /**
450
- * 贝塞尔曲线
451
- * @param points
452
- * @returns {*}
453
- */
454
- getBezierPoints2d: function (points) {
455
- if (points.length <= 2) {
456
- return points;
457
- } else {
458
- let bezierPoints = [];
459
- let n = points.length - 1;
460
- for (let t = 0; t <= 1; t += 0.01) {
461
- let [x, y] = [0, 0];
462
- for (let index = 0; index <= n; index++) {
463
- let factor = this.getBinomialFactor2d(n, index);
464
- let a = Math.pow(t, index);
465
- let b = Math.pow(1 - t, n - index);
466
- x += factor * a * b * points[index][0];
467
- y += factor * a * b * points[index][1];
468
- }
469
- bezierPoints.push([x, y]);
470
- }
471
- bezierPoints.push(points[n]);
472
- return bezierPoints;
473
- }
474
- },
475
- /**
476
- * 获取阶乘数据
477
- * @param n
478
- * @returns {number}
479
- */
480
- getFactorial2d: function (n) {
481
- let result = 1;
482
- switch (n) {
483
- case n <= 1:
484
- result = 1;
485
- break;
486
- case n === 2:
487
- result = 2;
488
- break;
489
- case n === 3:
490
- result = 6;
491
- break;
492
- case n === 24:
493
- result = 24;
494
- break;
495
- case n === 5:
496
- result = 120;
497
- break;
498
- default:
499
- for (let i = 1; i <= n; i++) {
500
- result *= i;
501
- }
502
- break;
503
- }
504
- return result;
505
- },
506
- /**
507
- * 获取二项分布
508
- * @param n
509
- * @param index
510
- * @returns {number}
511
- */
512
- getBinomialFactor2d: function (n, index) {
513
- return this.getFactorial2d(n) / (this.getFactorial2d(index) * this.getFactorial2d(n - index));
514
- },
515
- /**
516
- * 插值线性点
517
- * @param points
518
- * @returns {*}
519
- */
520
- getQBSplinePoints2d: function (points) {
521
- if (points.length <= 2) {
522
- return points;
523
- } else {
524
- let [n, bSplinePoints] = [2, []];
525
- let m = points.length - n - 1;
526
- bSplinePoints.push(points[0]);
527
- for (let i = 0; i <= m; i++) {
528
- for (let t = 0; t <= 1; t += 0.05) {
529
- let [x, y] = [0, 0];
530
- for (let k = 0; k <= n; k++) {
531
- let factor = this.getQuadricBSplineFactor2d(k, t);
532
- x += factor * points[i + k][0];
533
- y += factor * points[i + k][1];
534
- }
535
- bSplinePoints.push([x, y]);
536
- }
537
- }
538
- bSplinePoints.push(points[points.length - 1]);
539
- return bSplinePoints;
540
- }
541
- },
542
- /**
543
- * 得到二次线性因子
544
- * @param k
545
- * @param t
546
- * @returns {number}
547
- */
548
- getQuadricBSplineFactor2d: function (k, t) {
549
- let res = 0;
550
- if (k === 0) {
551
- res = Math.pow(t - 1, 2) / 2;
552
- } else if (k === 1) {
553
- res = (-2 * Math.pow(t, 2) + 2 * t + 1) / 2;
554
- } else if (k === 2) {
555
- res = Math.pow(t, 2) / 2;
556
- }
557
- return res;
558
- }
559
- };