cesium_dev_kit 1.0.50 → 1.0.52
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.
- package/README.md +233 -0
- package/dist/index.js +13582 -68
- package/dist/index.min.js +1 -0
- package/index.js +2 -2
- package/package.json +15 -9
- package/.babelrc +0 -13
- package/dist/ColorDeal.js +0 -59
- package/dist/common.js +0 -40
- package/dist/initConf.js +0 -188
- package/dist/libs/Analysis.js +0 -779
- package/dist/libs/Base.js +0 -950
- package/dist/libs/ChartLayer.js +0 -24
- package/dist/libs/Control.js +0 -947
- package/dist/libs/CustomCesiumPlugin.js +0 -92
- package/dist/libs/DomUtil.js +0 -105
- package/dist/libs/Draw.js +0 -704
- package/dist/libs/Graphics.js +0 -734
- package/dist/libs/MapvLayer.js +0 -26
- package/dist/libs/Material.js +0 -590
- package/dist/libs/Math2d.js +0 -559
- package/dist/libs/Math3d.js +0 -646
- package/dist/libs/PassEffect.js +0 -154
- package/dist/libs/Plugin.js +0 -751
- package/dist/libs/Primitive.js +0 -1559
- package/dist/libs/Shaders.js +0 -298
- package/dist/libs/ThreeJs.js +0 -190
- package/dist/libs/cesium-plugin.js +0 -3387
- package/dist/libs/index.js +0 -117
- package/dist/libs/plot/AttackArrow.js +0 -266
- package/dist/libs/plot/BasePlot.js +0 -41
- package/dist/libs/plot/PincerArrow.js +0 -278
- package/dist/libs/plot/StraightArrow.js +0 -244
- package/dist/libs/plot/algorithm.js +0 -315
- package/dist/libs/plot/index.js +0 -19
- package/dist/libs/plot/plotUtil.js +0 -242
package/dist/libs/Math2d.js
DELETED
|
@@ -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
|
-
};
|