/*
|
* 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.
|
*/
|
|
// TODO clockwise
|
|
import IndicatorAxis from './IndicatorAxis';
|
import IntervalScale from '../../scale/Interval';
|
import * as numberUtil from '../../util/number';
|
import {
|
getScaleExtent,
|
niceScaleExtent
|
} from '../axisHelper';
|
import CoordinateSystemManager from '../../core/CoordinateSystem';
|
import { CoordinateSystemMaster, CoordinateSystem } from '../CoordinateSystem';
|
import RadarModel from './RadarModel';
|
import GlobalModel from '../../model/Global';
|
import ExtensionAPI from '../../core/ExtensionAPI';
|
import { ScaleDataValue } from '../../util/types';
|
import { ParsedModelFinder } from '../../util/model';
|
import { parseAxisModelMinMax } from '../scaleRawExtentInfo';
|
import { map, each } from 'zrender/src/core/util';
|
|
|
class Radar implements CoordinateSystem, CoordinateSystemMaster {
|
|
readonly type: 'radar';
|
/**
|
*
|
* Radar dimensions
|
*/
|
readonly dimensions: string[] = [];
|
|
cx: number;
|
|
cy: number;
|
|
r: number;
|
|
r0: number;
|
|
startAngle: number;
|
|
private _model: RadarModel;
|
|
private _indicatorAxes: IndicatorAxis[];
|
|
constructor(radarModel: RadarModel, ecModel: GlobalModel, api: ExtensionAPI) {
|
this._model = radarModel;
|
|
this._indicatorAxes = map(radarModel.getIndicatorModels(), function (indicatorModel, idx) {
|
const dim = 'indicator_' + idx;
|
const indicatorAxis = new IndicatorAxis(dim,
|
new IntervalScale()
|
// (indicatorModel.get('axisType') === 'log') ? new LogScale() : new IntervalScale()
|
);
|
indicatorAxis.name = indicatorModel.get('name');
|
// Inject model and axis
|
indicatorAxis.model = indicatorModel;
|
indicatorModel.axis = indicatorAxis;
|
this.dimensions.push(dim);
|
return indicatorAxis;
|
}, this);
|
|
this.resize(radarModel, api);
|
}
|
|
getIndicatorAxes() {
|
return this._indicatorAxes;
|
}
|
|
dataToPoint(value: ScaleDataValue, indicatorIndex: number) {
|
const indicatorAxis = this._indicatorAxes[indicatorIndex];
|
|
return this.coordToPoint(indicatorAxis.dataToCoord(value), indicatorIndex);
|
}
|
|
// TODO: API should be coordToPoint([coord, indicatorIndex])
|
coordToPoint(coord: number, indicatorIndex: number) {
|
const indicatorAxis = this._indicatorAxes[indicatorIndex];
|
const angle = indicatorAxis.angle;
|
const x = this.cx + coord * Math.cos(angle);
|
const y = this.cy - coord * Math.sin(angle);
|
return [x, y];
|
}
|
|
pointToData(pt: number[]) {
|
let dx = pt[0] - this.cx;
|
let dy = pt[1] - this.cy;
|
const radius = Math.sqrt(dx * dx + dy * dy);
|
dx /= radius;
|
dy /= radius;
|
|
const radian = Math.atan2(-dy, dx);
|
|
// Find the closest angle
|
// FIXME index can calculated directly
|
let minRadianDiff = Infinity;
|
let closestAxis;
|
let closestAxisIdx = -1;
|
for (let i = 0; i < this._indicatorAxes.length; i++) {
|
const indicatorAxis = this._indicatorAxes[i];
|
const diff = Math.abs(radian - indicatorAxis.angle);
|
if (diff < minRadianDiff) {
|
closestAxis = indicatorAxis;
|
closestAxisIdx = i;
|
minRadianDiff = diff;
|
}
|
}
|
|
return [closestAxisIdx, +(closestAxis && closestAxis.coordToData(radius))];
|
}
|
|
resize(radarModel: RadarModel, api: ExtensionAPI) {
|
const center = radarModel.get('center');
|
const viewWidth = api.getWidth();
|
const viewHeight = api.getHeight();
|
const viewSize = Math.min(viewWidth, viewHeight) / 2;
|
this.cx = numberUtil.parsePercent(center[0], viewWidth);
|
this.cy = numberUtil.parsePercent(center[1], viewHeight);
|
|
this.startAngle = radarModel.get('startAngle') * Math.PI / 180;
|
|
// radius may be single value like `20`, `'80%'`, or array like `[10, '80%']`
|
let radius = radarModel.get('radius');
|
if (typeof radius === 'string' || typeof radius === 'number') {
|
radius = [0, radius];
|
}
|
this.r0 = numberUtil.parsePercent(radius[0], viewSize);
|
this.r = numberUtil.parsePercent(radius[1], viewSize);
|
|
each(this._indicatorAxes, function (indicatorAxis, idx) {
|
indicatorAxis.setExtent(this.r0, this.r);
|
let angle = (this.startAngle + idx * Math.PI * 2 / this._indicatorAxes.length);
|
// Normalize to [-PI, PI]
|
angle = Math.atan2(Math.sin(angle), Math.cos(angle));
|
indicatorAxis.angle = angle;
|
}, this);
|
}
|
|
update(ecModel: GlobalModel, api: ExtensionAPI) {
|
const indicatorAxes = this._indicatorAxes;
|
const radarModel = this._model;
|
each(indicatorAxes, function (indicatorAxis) {
|
indicatorAxis.scale.setExtent(Infinity, -Infinity);
|
});
|
ecModel.eachSeriesByType('radar', function (radarSeries, idx) {
|
if (radarSeries.get('coordinateSystem') !== 'radar'
|
// @ts-ignore
|
|| ecModel.getComponent('radar', radarSeries.get('radarIndex')) !== radarModel
|
) {
|
return;
|
}
|
const data = radarSeries.getData();
|
each(indicatorAxes, function (indicatorAxis) {
|
indicatorAxis.scale.unionExtentFromData(data, data.mapDimension(indicatorAxis.dim));
|
});
|
}, this);
|
|
const splitNumber = radarModel.get('splitNumber');
|
|
function increaseInterval(interval: number) {
|
const exp10 = Math.pow(10, Math.floor(Math.log(interval) / Math.LN10));
|
// Increase interval
|
let f = interval / exp10;
|
if (f === 2) {
|
f = 5;
|
}
|
else { // f is 2 or 5
|
f *= 2;
|
}
|
return f * exp10;
|
}
|
// Force all the axis fixing the maxSplitNumber.
|
each(indicatorAxes, function (indicatorAxis, idx) {
|
const rawExtent = getScaleExtent(indicatorAxis.scale, indicatorAxis.model).extent;
|
niceScaleExtent(indicatorAxis.scale, indicatorAxis.model);
|
|
const axisModel = indicatorAxis.model;
|
const scale = indicatorAxis.scale as IntervalScale;
|
const fixedMin = parseAxisModelMinMax(scale, axisModel.get('min', true) as ScaleDataValue);
|
const fixedMax = parseAxisModelMinMax(scale, axisModel.get('max', true) as ScaleDataValue);
|
let interval = scale.getInterval();
|
|
if (fixedMin != null && fixedMax != null) {
|
// User set min, max, divide to get new interval
|
scale.setExtent(+fixedMin, +fixedMax);
|
scale.setInterval(
|
(fixedMax - fixedMin) / splitNumber
|
);
|
}
|
else if (fixedMin != null) {
|
let max;
|
// User set min, expand extent on the other side
|
do {
|
max = fixedMin + interval * splitNumber;
|
scale.setExtent(+fixedMin, max);
|
// Interval must been set after extent
|
// FIXME
|
scale.setInterval(interval);
|
|
interval = increaseInterval(interval);
|
} while (max < rawExtent[1] && isFinite(max) && isFinite(rawExtent[1]));
|
}
|
else if (fixedMax != null) {
|
let min;
|
// User set min, expand extent on the other side
|
do {
|
min = fixedMax - interval * splitNumber;
|
scale.setExtent(min, +fixedMax);
|
scale.setInterval(interval);
|
interval = increaseInterval(interval);
|
} while (min > rawExtent[0] && isFinite(min) && isFinite(rawExtent[0]));
|
}
|
else {
|
const nicedSplitNumber = scale.getTicks().length - 1;
|
if (nicedSplitNumber > splitNumber) {
|
interval = increaseInterval(interval);
|
}
|
// TODO
|
const max = Math.ceil(rawExtent[1] / interval) * interval;
|
const min = numberUtil.round(max - interval * splitNumber);
|
scale.setExtent(min, max);
|
scale.setInterval(interval);
|
}
|
});
|
}
|
|
convertToPixel(ecModel: GlobalModel, finder: ParsedModelFinder, value: ScaleDataValue[]): never {
|
console.warn('Not implemented.');
|
return null as never;
|
}
|
convertFromPixel(ecModel: GlobalModel, finder: ParsedModelFinder, pixel: number[]): never {
|
console.warn('Not implemented.');
|
return null as never;
|
}
|
containPoint(point: number[]): boolean {
|
console.warn('Not implemented.');
|
return false;
|
}
|
/**
|
* Radar dimensions is based on the data
|
*/
|
static dimensions: string[] = [];
|
|
static create(ecModel: GlobalModel, api: ExtensionAPI) {
|
const radarList: Radar[] = [];
|
ecModel.eachComponent('radar', function (radarModel: RadarModel) {
|
const radar = new Radar(radarModel, ecModel, api);
|
radarList.push(radar);
|
radarModel.coordinateSystem = radar;
|
});
|
ecModel.eachSeriesByType('radar', function (radarSeries) {
|
if (radarSeries.get('coordinateSystem') === 'radar') {
|
// Inject coordinate system
|
// @ts-ignore
|
radarSeries.coordinateSystem = radarList[radarSeries.get('radarIndex') || 0];
|
}
|
});
|
return radarList;
|
}
|
}
|
|
|
export default Radar;
|
