|
/*
|
* 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 };
|
