cione-comp-lib
Version:
`$ yarn add cione-comp-lib` 或者 `$ npm i cione-comp-lib -S`
289 lines (288 loc) • 8.8 kB
JavaScript
import { __extends } from "../../../../tslib/tslib.es6.mjs";
import Path from "../../../../zrender/lib/graphic/Path.mjs";
import PathProxy from "../../../../zrender/lib/core/PathProxy.mjs";
import { cubicRootAt, cubicAt } from "../../../../zrender/lib/core/curve.mjs";
var mathMin = Math.min;
var mathMax = Math.max;
function isPointNull(x, y) {
return isNaN(x) || isNaN(y);
}
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;
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];
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) {
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;
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);
ratioNextSeg = lenNextSeg / (lenNextSeg + lenPrevSeg);
cpx1 = x - vx * smooth * (1 - ratioNextSeg);
cpy1 = y - vy * smooth * (1 - ratioNextSeg);
nextCpx0 = x + vx * smooth * ratioNextSeg;
nextCpy0 = y + vy * smooth * ratioNextSeg;
nextCpx0 = mathMin(nextCpx0, mathMax(nextX, x));
nextCpy0 = mathMin(nextCpy0, mathMax(nextY, y));
nextCpx0 = mathMax(nextCpx0, mathMin(nextX, x));
nextCpy0 = mathMax(nextCpy0, mathMin(nextY, y));
vx = nextCpx0 - x;
vy = nextCpy0 - y;
cpx1 = x - vx * lenPrevSeg / lenNextSeg;
cpy1 = y - vy * lenPrevSeg / lenNextSeg;
cpx1 = mathMin(cpx1, mathMax(prevX, x));
cpy1 = mathMin(cpy1, mathMax(prevY, y));
cpx1 = mathMax(cpx1, mathMin(prevX, x));
cpy1 = mathMax(cpy1, mathMin(prevY, y));
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 = function() {
function ECPolylineShape2() {
this.smooth = 0;
this.smoothConstraint = true;
}
return ECPolylineShape2;
}();
var ECPolyline = function(_super) {
__extends(ECPolyline2, _super);
function ECPolyline2(opts) {
var _this = _super.call(this, opts) || this;
_this.type = "ec-polyline";
return _this;
}
ECPolyline2.prototype.getDefaultStyle = function() {
return {
stroke: "#000",
fill: null
};
};
ECPolyline2.prototype.getDefaultShape = function() {
return new ECPolylineShape();
};
ECPolyline2.prototype.buildPath = function(ctx, shape) {
var points = shape.points;
var i = 0;
var len = points.length / 2;
if (shape.connectNulls) {
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;
}
};
ECPolyline2.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 ECPolyline2;
}(Path);
var ECPolygonShape = function(_super) {
__extends(ECPolygonShape2, _super);
function ECPolygonShape2() {
return _super !== null && _super.apply(this, arguments) || this;
}
return ECPolygonShape2;
}(ECPolylineShape);
var ECPolygon = function(_super) {
__extends(ECPolygon2, _super);
function ECPolygon2(opts) {
var _this = _super.call(this, opts) || this;
_this.type = "ec-polygon";
return _this;
}
ECPolygon2.prototype.getDefaultShape = function() {
return new ECPolygonShape();
};
ECPolygon2.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) {
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 ECPolygon2;
}(Path);
export { ECPolygon, ECPolyline };