|
/*
|
* 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";
|
import BoundingRect from 'zrender/lib/core/BoundingRect.js';
|
import Cartesian from './Cartesian.js';
|
import { invert } from 'zrender/lib/core/matrix.js';
|
import { applyTransform } from 'zrender/lib/core/vector.js';
|
export var cartesian2DDimensions = ['x', 'y'];
|
function canCalculateAffineTransform(scale) {
|
return scale.type === 'interval' || scale.type === 'time';
|
}
|
var Cartesian2D = /** @class */function (_super) {
|
__extends(Cartesian2D, _super);
|
function Cartesian2D() {
|
var _this = _super !== null && _super.apply(this, arguments) || this;
|
_this.type = 'cartesian2d';
|
_this.dimensions = cartesian2DDimensions;
|
return _this;
|
}
|
/**
|
* Calculate an affine transform matrix if two axes are time or value.
|
* It's mainly for accelartion on the large time series data.
|
*/
|
Cartesian2D.prototype.calcAffineTransform = function () {
|
this._transform = this._invTransform = null;
|
var xAxisScale = this.getAxis('x').scale;
|
var yAxisScale = this.getAxis('y').scale;
|
if (!canCalculateAffineTransform(xAxisScale) || !canCalculateAffineTransform(yAxisScale)) {
|
return;
|
}
|
var xScaleExtent = xAxisScale.getExtent();
|
var yScaleExtent = yAxisScale.getExtent();
|
var start = this.dataToPoint([xScaleExtent[0], yScaleExtent[0]]);
|
var end = this.dataToPoint([xScaleExtent[1], yScaleExtent[1]]);
|
var xScaleSpan = xScaleExtent[1] - xScaleExtent[0];
|
var yScaleSpan = yScaleExtent[1] - yScaleExtent[0];
|
if (!xScaleSpan || !yScaleSpan) {
|
return;
|
}
|
// Accelerate data to point calculation on the special large time series data.
|
var scaleX = (end[0] - start[0]) / xScaleSpan;
|
var scaleY = (end[1] - start[1]) / yScaleSpan;
|
var translateX = start[0] - xScaleExtent[0] * scaleX;
|
var translateY = start[1] - yScaleExtent[0] * scaleY;
|
var m = this._transform = [scaleX, 0, 0, scaleY, translateX, translateY];
|
this._invTransform = invert([], m);
|
};
|
/**
|
* Base axis will be used on stacking.
|
*/
|
Cartesian2D.prototype.getBaseAxis = function () {
|
return this.getAxesByScale('ordinal')[0] || this.getAxesByScale('time')[0] || this.getAxis('x');
|
};
|
Cartesian2D.prototype.containPoint = function (point) {
|
var axisX = this.getAxis('x');
|
var axisY = this.getAxis('y');
|
return axisX.contain(axisX.toLocalCoord(point[0])) && axisY.contain(axisY.toLocalCoord(point[1]));
|
};
|
Cartesian2D.prototype.containData = function (data) {
|
return this.getAxis('x').containData(data[0]) && this.getAxis('y').containData(data[1]);
|
};
|
Cartesian2D.prototype.containZone = function (data1, data2) {
|
var zoneDiag1 = this.dataToPoint(data1);
|
var zoneDiag2 = this.dataToPoint(data2);
|
var area = this.getArea();
|
var zone = new BoundingRect(zoneDiag1[0], zoneDiag1[1], zoneDiag2[0] - zoneDiag1[0], zoneDiag2[1] - zoneDiag1[1]);
|
return area.intersect(zone);
|
};
|
Cartesian2D.prototype.dataToPoint = function (data, clamp, out) {
|
out = out || [];
|
var xVal = data[0];
|
var yVal = data[1];
|
// Fast path
|
if (this._transform
|
// It's supported that if data is like `[Inifity, 123]`, where only Y pixel calculated.
|
&& xVal != null && isFinite(xVal) && yVal != null && isFinite(yVal)) {
|
return applyTransform(out, data, this._transform);
|
}
|
var xAxis = this.getAxis('x');
|
var yAxis = this.getAxis('y');
|
out[0] = xAxis.toGlobalCoord(xAxis.dataToCoord(xVal, clamp));
|
out[1] = yAxis.toGlobalCoord(yAxis.dataToCoord(yVal, clamp));
|
return out;
|
};
|
Cartesian2D.prototype.clampData = function (data, out) {
|
var xScale = this.getAxis('x').scale;
|
var yScale = this.getAxis('y').scale;
|
var xAxisExtent = xScale.getExtent();
|
var yAxisExtent = yScale.getExtent();
|
var x = xScale.parse(data[0]);
|
var y = yScale.parse(data[1]);
|
out = out || [];
|
out[0] = Math.min(Math.max(Math.min(xAxisExtent[0], xAxisExtent[1]), x), Math.max(xAxisExtent[0], xAxisExtent[1]));
|
out[1] = Math.min(Math.max(Math.min(yAxisExtent[0], yAxisExtent[1]), y), Math.max(yAxisExtent[0], yAxisExtent[1]));
|
return out;
|
};
|
Cartesian2D.prototype.pointToData = function (point, clamp) {
|
var out = [];
|
if (this._invTransform) {
|
return applyTransform(out, point, this._invTransform);
|
}
|
var xAxis = this.getAxis('x');
|
var yAxis = this.getAxis('y');
|
out[0] = xAxis.coordToData(xAxis.toLocalCoord(point[0]), clamp);
|
out[1] = yAxis.coordToData(yAxis.toLocalCoord(point[1]), clamp);
|
return out;
|
};
|
Cartesian2D.prototype.getOtherAxis = function (axis) {
|
return this.getAxis(axis.dim === 'x' ? 'y' : 'x');
|
};
|
/**
|
* Get rect area of cartesian.
|
* Area will have a contain function to determine if a point is in the coordinate system.
|
*/
|
Cartesian2D.prototype.getArea = function (tolerance) {
|
tolerance = tolerance || 0;
|
var xExtent = this.getAxis('x').getGlobalExtent();
|
var yExtent = this.getAxis('y').getGlobalExtent();
|
var x = Math.min(xExtent[0], xExtent[1]) - tolerance;
|
var y = Math.min(yExtent[0], yExtent[1]) - tolerance;
|
var width = Math.max(xExtent[0], xExtent[1]) - x + tolerance;
|
var height = Math.max(yExtent[0], yExtent[1]) - y + tolerance;
|
return new BoundingRect(x, y, width, height);
|
};
|
return Cartesian2D;
|
}(Cartesian);
|
;
|
export default Cartesian2D;
|
