逐步完成前后端服务器
This commit is contained in:
353
frontend/node_modules/echarts/lib/chart/line/poly.js
generated
vendored
Normal file
353
frontend/node_modules/echarts/lib/chart/line/poly.js
generated
vendored
Normal file
@ -0,0 +1,353 @@
|
||||
|
||||
/*
|
||||
* Licensed to the Apache Software Foundation (ASF) under one
|
||||
* or more contributor license agreements. See the NOTICE file
|
||||
* distributed with this work for additional information
|
||||
* regarding copyright ownership. The ASF licenses this file
|
||||
* to you under the Apache License, Version 2.0 (the
|
||||
* "License"); you may not use this file except in compliance
|
||||
* with the License. You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing,
|
||||
* software distributed under the License is distributed on an
|
||||
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
||||
* KIND, either express or implied. See the License for the
|
||||
* specific language governing permissions and limitations
|
||||
* under the License.
|
||||
*/
|
||||
|
||||
|
||||
/**
|
||||
* AUTO-GENERATED FILE. DO NOT MODIFY.
|
||||
*/
|
||||
|
||||
/*
|
||||
* Licensed to the Apache Software Foundation (ASF) under one
|
||||
* or more contributor license agreements. See the NOTICE file
|
||||
* distributed with this work for additional information
|
||||
* regarding copyright ownership. The ASF licenses this file
|
||||
* to you under the Apache License, Version 2.0 (the
|
||||
* "License"); you may not use this file except in compliance
|
||||
* with the License. You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing,
|
||||
* software distributed under the License is distributed on an
|
||||
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
||||
* KIND, either express or implied. See the License for the
|
||||
* specific language governing permissions and limitations
|
||||
* under the License.
|
||||
*/
|
||||
import { __extends } from "tslib";
|
||||
// Poly path support NaN point
|
||||
import Path from 'zrender/lib/graphic/Path.js';
|
||||
import PathProxy from 'zrender/lib/core/PathProxy.js';
|
||||
import { cubicRootAt, cubicAt } from 'zrender/lib/core/curve.js';
|
||||
var mathMin = Math.min;
|
||||
var mathMax = Math.max;
|
||||
function isPointNull(x, y) {
|
||||
return isNaN(x) || isNaN(y);
|
||||
}
|
||||
/**
|
||||
* Draw smoothed line in non-monotone, in may cause undesired curve in extreme
|
||||
* situations. This should be used when points are non-monotone neither in x or
|
||||
* y dimension.
|
||||
*/
|
||||
function drawSegment(ctx, points, start, segLen, allLen, dir, smooth, smoothMonotone, connectNulls) {
|
||||
var prevX;
|
||||
var prevY;
|
||||
var cpx0;
|
||||
var cpy0;
|
||||
var cpx1;
|
||||
var cpy1;
|
||||
var idx = start;
|
||||
var k = 0;
|
||||
for (; k < segLen; k++) {
|
||||
var x = points[idx * 2];
|
||||
var y = points[idx * 2 + 1];
|
||||
if (idx >= allLen || idx < 0) {
|
||||
break;
|
||||
}
|
||||
if (isPointNull(x, y)) {
|
||||
if (connectNulls) {
|
||||
idx += dir;
|
||||
continue;
|
||||
}
|
||||
break;
|
||||
}
|
||||
if (idx === start) {
|
||||
ctx[dir > 0 ? 'moveTo' : 'lineTo'](x, y);
|
||||
cpx0 = x;
|
||||
cpy0 = y;
|
||||
} else {
|
||||
var dx = x - prevX;
|
||||
var dy = y - prevY;
|
||||
// Ignore tiny segment.
|
||||
if (dx * dx + dy * dy < 0.5) {
|
||||
idx += dir;
|
||||
continue;
|
||||
}
|
||||
if (smooth > 0) {
|
||||
var nextIdx = idx + dir;
|
||||
var nextX = points[nextIdx * 2];
|
||||
var nextY = points[nextIdx * 2 + 1];
|
||||
// Ignore duplicate point
|
||||
while (nextX === x && nextY === y && k < segLen) {
|
||||
k++;
|
||||
nextIdx += dir;
|
||||
idx += dir;
|
||||
nextX = points[nextIdx * 2];
|
||||
nextY = points[nextIdx * 2 + 1];
|
||||
x = points[idx * 2];
|
||||
y = points[idx * 2 + 1];
|
||||
dx = x - prevX;
|
||||
dy = y - prevY;
|
||||
}
|
||||
var tmpK = k + 1;
|
||||
if (connectNulls) {
|
||||
// Find next point not null
|
||||
while (isPointNull(nextX, nextY) && tmpK < segLen) {
|
||||
tmpK++;
|
||||
nextIdx += dir;
|
||||
nextX = points[nextIdx * 2];
|
||||
nextY = points[nextIdx * 2 + 1];
|
||||
}
|
||||
}
|
||||
var ratioNextSeg = 0.5;
|
||||
var vx = 0;
|
||||
var vy = 0;
|
||||
var nextCpx0 = void 0;
|
||||
var nextCpy0 = void 0;
|
||||
// Is last point
|
||||
if (tmpK >= segLen || isPointNull(nextX, nextY)) {
|
||||
cpx1 = x;
|
||||
cpy1 = y;
|
||||
} else {
|
||||
vx = nextX - prevX;
|
||||
vy = nextY - prevY;
|
||||
var dx0 = x - prevX;
|
||||
var dx1 = nextX - x;
|
||||
var dy0 = y - prevY;
|
||||
var dy1 = nextY - y;
|
||||
var lenPrevSeg = void 0;
|
||||
var lenNextSeg = void 0;
|
||||
if (smoothMonotone === 'x') {
|
||||
lenPrevSeg = Math.abs(dx0);
|
||||
lenNextSeg = Math.abs(dx1);
|
||||
var dir_1 = vx > 0 ? 1 : -1;
|
||||
cpx1 = x - dir_1 * lenPrevSeg * smooth;
|
||||
cpy1 = y;
|
||||
nextCpx0 = x + dir_1 * lenNextSeg * smooth;
|
||||
nextCpy0 = y;
|
||||
} else if (smoothMonotone === 'y') {
|
||||
lenPrevSeg = Math.abs(dy0);
|
||||
lenNextSeg = Math.abs(dy1);
|
||||
var dir_2 = vy > 0 ? 1 : -1;
|
||||
cpx1 = x;
|
||||
cpy1 = y - dir_2 * lenPrevSeg * smooth;
|
||||
nextCpx0 = x;
|
||||
nextCpy0 = y + dir_2 * lenNextSeg * smooth;
|
||||
} else {
|
||||
lenPrevSeg = Math.sqrt(dx0 * dx0 + dy0 * dy0);
|
||||
lenNextSeg = Math.sqrt(dx1 * dx1 + dy1 * dy1);
|
||||
// Use ratio of seg length
|
||||
ratioNextSeg = lenNextSeg / (lenNextSeg + lenPrevSeg);
|
||||
cpx1 = x - vx * smooth * (1 - ratioNextSeg);
|
||||
cpy1 = y - vy * smooth * (1 - ratioNextSeg);
|
||||
// cp0 of next segment
|
||||
nextCpx0 = x + vx * smooth * ratioNextSeg;
|
||||
nextCpy0 = y + vy * smooth * ratioNextSeg;
|
||||
// Smooth constraint between point and next point.
|
||||
// Avoid exceeding extreme after smoothing.
|
||||
nextCpx0 = mathMin(nextCpx0, mathMax(nextX, x));
|
||||
nextCpy0 = mathMin(nextCpy0, mathMax(nextY, y));
|
||||
nextCpx0 = mathMax(nextCpx0, mathMin(nextX, x));
|
||||
nextCpy0 = mathMax(nextCpy0, mathMin(nextY, y));
|
||||
// Reclaculate cp1 based on the adjusted cp0 of next seg.
|
||||
vx = nextCpx0 - x;
|
||||
vy = nextCpy0 - y;
|
||||
cpx1 = x - vx * lenPrevSeg / lenNextSeg;
|
||||
cpy1 = y - vy * lenPrevSeg / lenNextSeg;
|
||||
// Smooth constraint between point and prev point.
|
||||
// Avoid exceeding extreme after smoothing.
|
||||
cpx1 = mathMin(cpx1, mathMax(prevX, x));
|
||||
cpy1 = mathMin(cpy1, mathMax(prevY, y));
|
||||
cpx1 = mathMax(cpx1, mathMin(prevX, x));
|
||||
cpy1 = mathMax(cpy1, mathMin(prevY, y));
|
||||
// Adjust next cp0 again.
|
||||
vx = x - cpx1;
|
||||
vy = y - cpy1;
|
||||
nextCpx0 = x + vx * lenNextSeg / lenPrevSeg;
|
||||
nextCpy0 = y + vy * lenNextSeg / lenPrevSeg;
|
||||
}
|
||||
}
|
||||
ctx.bezierCurveTo(cpx0, cpy0, cpx1, cpy1, x, y);
|
||||
cpx0 = nextCpx0;
|
||||
cpy0 = nextCpy0;
|
||||
} else {
|
||||
ctx.lineTo(x, y);
|
||||
}
|
||||
}
|
||||
prevX = x;
|
||||
prevY = y;
|
||||
idx += dir;
|
||||
}
|
||||
return k;
|
||||
}
|
||||
var ECPolylineShape = /** @class */function () {
|
||||
function ECPolylineShape() {
|
||||
this.smooth = 0;
|
||||
this.smoothConstraint = true;
|
||||
}
|
||||
return ECPolylineShape;
|
||||
}();
|
||||
var ECPolyline = /** @class */function (_super) {
|
||||
__extends(ECPolyline, _super);
|
||||
function ECPolyline(opts) {
|
||||
var _this = _super.call(this, opts) || this;
|
||||
_this.type = 'ec-polyline';
|
||||
return _this;
|
||||
}
|
||||
ECPolyline.prototype.getDefaultStyle = function () {
|
||||
return {
|
||||
stroke: '#000',
|
||||
fill: null
|
||||
};
|
||||
};
|
||||
ECPolyline.prototype.getDefaultShape = function () {
|
||||
return new ECPolylineShape();
|
||||
};
|
||||
ECPolyline.prototype.buildPath = function (ctx, shape) {
|
||||
var points = shape.points;
|
||||
var i = 0;
|
||||
var len = points.length / 2;
|
||||
// const result = getBoundingBox(points, shape.smoothConstraint);
|
||||
if (shape.connectNulls) {
|
||||
// Must remove first and last null values avoid draw error in polygon
|
||||
for (; len > 0; len--) {
|
||||
if (!isPointNull(points[len * 2 - 2], points[len * 2 - 1])) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
for (; i < len; i++) {
|
||||
if (!isPointNull(points[i * 2], points[i * 2 + 1])) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
while (i < len) {
|
||||
i += drawSegment(ctx, points, i, len, len, 1, shape.smooth, shape.smoothMonotone, shape.connectNulls) + 1;
|
||||
}
|
||||
};
|
||||
ECPolyline.prototype.getPointOn = function (xOrY, dim) {
|
||||
if (!this.path) {
|
||||
this.createPathProxy();
|
||||
this.buildPath(this.path, this.shape);
|
||||
}
|
||||
var path = this.path;
|
||||
var data = path.data;
|
||||
var CMD = PathProxy.CMD;
|
||||
var x0;
|
||||
var y0;
|
||||
var isDimX = dim === 'x';
|
||||
var roots = [];
|
||||
for (var i = 0; i < data.length;) {
|
||||
var cmd = data[i++];
|
||||
var x = void 0;
|
||||
var y = void 0;
|
||||
var x2 = void 0;
|
||||
var y2 = void 0;
|
||||
var x3 = void 0;
|
||||
var y3 = void 0;
|
||||
var t = void 0;
|
||||
switch (cmd) {
|
||||
case CMD.M:
|
||||
x0 = data[i++];
|
||||
y0 = data[i++];
|
||||
break;
|
||||
case CMD.L:
|
||||
x = data[i++];
|
||||
y = data[i++];
|
||||
t = isDimX ? (xOrY - x0) / (x - x0) : (xOrY - y0) / (y - y0);
|
||||
if (t <= 1 && t >= 0) {
|
||||
var val = isDimX ? (y - y0) * t + y0 : (x - x0) * t + x0;
|
||||
return isDimX ? [xOrY, val] : [val, xOrY];
|
||||
}
|
||||
x0 = x;
|
||||
y0 = y;
|
||||
break;
|
||||
case CMD.C:
|
||||
x = data[i++];
|
||||
y = data[i++];
|
||||
x2 = data[i++];
|
||||
y2 = data[i++];
|
||||
x3 = data[i++];
|
||||
y3 = data[i++];
|
||||
var nRoot = isDimX ? cubicRootAt(x0, x, x2, x3, xOrY, roots) : cubicRootAt(y0, y, y2, y3, xOrY, roots);
|
||||
if (nRoot > 0) {
|
||||
for (var i_1 = 0; i_1 < nRoot; i_1++) {
|
||||
var t_1 = roots[i_1];
|
||||
if (t_1 <= 1 && t_1 >= 0) {
|
||||
var val = isDimX ? cubicAt(y0, y, y2, y3, t_1) : cubicAt(x0, x, x2, x3, t_1);
|
||||
return isDimX ? [xOrY, val] : [val, xOrY];
|
||||
}
|
||||
}
|
||||
}
|
||||
x0 = x3;
|
||||
y0 = y3;
|
||||
break;
|
||||
}
|
||||
}
|
||||
};
|
||||
return ECPolyline;
|
||||
}(Path);
|
||||
export { ECPolyline };
|
||||
var ECPolygonShape = /** @class */function (_super) {
|
||||
__extends(ECPolygonShape, _super);
|
||||
function ECPolygonShape() {
|
||||
return _super !== null && _super.apply(this, arguments) || this;
|
||||
}
|
||||
return ECPolygonShape;
|
||||
}(ECPolylineShape);
|
||||
var ECPolygon = /** @class */function (_super) {
|
||||
__extends(ECPolygon, _super);
|
||||
function ECPolygon(opts) {
|
||||
var _this = _super.call(this, opts) || this;
|
||||
_this.type = 'ec-polygon';
|
||||
return _this;
|
||||
}
|
||||
ECPolygon.prototype.getDefaultShape = function () {
|
||||
return new ECPolygonShape();
|
||||
};
|
||||
ECPolygon.prototype.buildPath = function (ctx, shape) {
|
||||
var points = shape.points;
|
||||
var stackedOnPoints = shape.stackedOnPoints;
|
||||
var i = 0;
|
||||
var len = points.length / 2;
|
||||
var smoothMonotone = shape.smoothMonotone;
|
||||
if (shape.connectNulls) {
|
||||
// Must remove first and last null values avoid draw error in polygon
|
||||
for (; len > 0; len--) {
|
||||
if (!isPointNull(points[len * 2 - 2], points[len * 2 - 1])) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
for (; i < len; i++) {
|
||||
if (!isPointNull(points[i * 2], points[i * 2 + 1])) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
while (i < len) {
|
||||
var k = drawSegment(ctx, points, i, len, len, 1, shape.smooth, smoothMonotone, shape.connectNulls);
|
||||
drawSegment(ctx, stackedOnPoints, i + k - 1, k, len, -1, shape.stackedOnSmooth, smoothMonotone, shape.connectNulls);
|
||||
i += k + 1;
|
||||
ctx.closePath();
|
||||
}
|
||||
};
|
||||
return ECPolygon;
|
||||
}(Path);
|
||||
export { ECPolygon };
|
||||
Reference in New Issue
Block a user