| /* |
| * 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. |
| */ |
| |
| /** |
| * Grid is a region which contains at most 4 cartesian systems |
| * |
| * TODO Default cartesian |
| */ |
| |
| import {isObject, each, indexOf, retrieve3} from 'zrender/src/core/util'; |
| import {getLayoutRect, LayoutRect} from '../../util/layout'; |
| import { |
| createScaleByModel, |
| ifAxisCrossZero, |
| niceScaleExtent, |
| estimateLabelUnionRect, |
| getDataDimensionsOnAxis |
| } from '../../coord/axisHelper'; |
| import Cartesian2D, {cartesian2DDimensions} from './Cartesian2D'; |
| import Axis2D from './Axis2D'; |
| import {ParsedModelFinder, ParsedModelFinderKnown, SINGLE_REFERRING} from '../../util/model'; |
| |
| // Depends on GridModel, AxisModel, which performs preprocess. |
| import GridModel from './GridModel'; |
| import CartesianAxisModel from './AxisModel'; |
| import GlobalModel from '../../model/Global'; |
| import ExtensionAPI from '../../core/ExtensionAPI'; |
| import { Dictionary } from 'zrender/src/core/types'; |
| import {CoordinateSystemMaster} from '../CoordinateSystem'; |
| import { ScaleDataValue } from '../../util/types'; |
| import List from '../../data/List'; |
| import OrdinalScale from '../../scale/Ordinal'; |
| import { isCartesian2DSeries, findAxisModels } from './cartesianAxisHelper'; |
| |
| |
| type Cartesian2DDimensionName = 'x' | 'y'; |
| |
| type FinderAxisIndex = {xAxisIndex?: number, yAxisIndex?: number}; |
| type AxesMap = {x: Axis2D[], y: Axis2D[]}; |
| |
| class Grid implements CoordinateSystemMaster { |
| |
| // FIXME:TS where used (different from registered type 'cartesian2d')? |
| readonly type: string = 'grid'; |
| |
| private _coordsMap: Dictionary<Cartesian2D> = {}; |
| private _coordsList: Cartesian2D[] = []; |
| private _axesMap: AxesMap = {} as AxesMap; |
| private _axesList: Axis2D[] = []; |
| private _rect: LayoutRect; |
| |
| readonly model: GridModel; |
| readonly axisPointerEnabled = true; |
| |
| // Injected: |
| name: string; |
| |
| // For deciding which dimensions to use when creating list data |
| static dimensions = cartesian2DDimensions; |
| readonly dimensions = cartesian2DDimensions; |
| |
| constructor(gridModel: GridModel, ecModel: GlobalModel, api: ExtensionAPI) { |
| this._initCartesian(gridModel, ecModel, api); |
| this.model = gridModel; |
| } |
| |
| getRect(): LayoutRect { |
| return this._rect; |
| } |
| |
| update(ecModel: GlobalModel, api: ExtensionAPI): void { |
| |
| const axesMap = this._axesMap; |
| |
| this._updateScale(ecModel, this.model); |
| |
| each(axesMap.x, function (xAxis) { |
| niceScaleExtent(xAxis.scale, xAxis.model); |
| }); |
| each(axesMap.y, function (yAxis) { |
| niceScaleExtent(yAxis.scale, yAxis.model); |
| }); |
| |
| // Key: axisDim_axisIndex, value: boolean, whether onZero target. |
| const onZeroRecords = {} as Dictionary<boolean>; |
| |
| each(axesMap.x, function (xAxis) { |
| fixAxisOnZero(axesMap, 'y', xAxis, onZeroRecords); |
| }); |
| each(axesMap.y, function (yAxis) { |
| fixAxisOnZero(axesMap, 'x', yAxis, onZeroRecords); |
| }); |
| |
| // Resize again if containLabel is enabled |
| // FIXME It may cause getting wrong grid size in data processing stage |
| this.resize(this.model, api); |
| } |
| |
| /** |
| * Resize the grid |
| */ |
| resize(gridModel: GridModel, api: ExtensionAPI, ignoreContainLabel?: boolean): void { |
| |
| const boxLayoutParams = gridModel.getBoxLayoutParams(); |
| const isContainLabel = !ignoreContainLabel && gridModel.get('containLabel'); |
| |
| const gridRect = getLayoutRect( |
| boxLayoutParams, { |
| width: api.getWidth(), |
| height: api.getHeight() |
| }); |
| |
| this._rect = gridRect; |
| |
| const axesList = this._axesList; |
| |
| adjustAxes(); |
| |
| // Minus label size |
| if (isContainLabel) { |
| each(axesList, function (axis) { |
| if (!axis.model.get(['axisLabel', 'inside'])) { |
| const labelUnionRect = estimateLabelUnionRect(axis); |
| if (labelUnionRect) { |
| const dim: 'height' | 'width' = axis.isHorizontal() ? 'height' : 'width'; |
| const margin = axis.model.get(['axisLabel', 'margin']); |
| gridRect[dim] -= labelUnionRect[dim] + margin; |
| if (axis.position === 'top') { |
| gridRect.y += labelUnionRect.height + margin; |
| } |
| else if (axis.position === 'left') { |
| gridRect.x += labelUnionRect.width + margin; |
| } |
| } |
| } |
| }); |
| |
| adjustAxes(); |
| } |
| |
| each(this._coordsList, function (coord) { |
| // Calculate affine matrix to accelerate the data to point transform. |
| // If all the axes scales are time or value. |
| coord.calcAffineTransform(); |
| }); |
| |
| function adjustAxes() { |
| each(axesList, function (axis) { |
| const isHorizontal = axis.isHorizontal(); |
| const extent = isHorizontal ? [0, gridRect.width] : [0, gridRect.height]; |
| const idx = axis.inverse ? 1 : 0; |
| axis.setExtent(extent[idx], extent[1 - idx]); |
| updateAxisTransform(axis, isHorizontal ? gridRect.x : gridRect.y); |
| }); |
| } |
| } |
| |
| getAxis(dim: Cartesian2DDimensionName, axisIndex?: number): Axis2D { |
| const axesMapOnDim = this._axesMap[dim]; |
| if (axesMapOnDim != null) { |
| return axesMapOnDim[axisIndex || 0]; |
| // if (axisIndex == null) { |
| // Find first axis |
| // for (let name in axesMapOnDim) { |
| // if (axesMapOnDim.hasOwnProperty(name)) { |
| // return axesMapOnDim[name]; |
| // } |
| // } |
| // } |
| // return axesMapOnDim[axisIndex]; |
| } |
| } |
| |
| getAxes(): Axis2D[] { |
| return this._axesList.slice(); |
| } |
| |
| /** |
| * Usage: |
| * grid.getCartesian(xAxisIndex, yAxisIndex); |
| * grid.getCartesian(xAxisIndex); |
| * grid.getCartesian(null, yAxisIndex); |
| * grid.getCartesian({xAxisIndex: ..., yAxisIndex: ...}); |
| * |
| * When only xAxisIndex or yAxisIndex given, find its first cartesian. |
| */ |
| getCartesian(finder: FinderAxisIndex): Cartesian2D; |
| getCartesian(xAxisIndex?: number, yAxisIndex?: number): Cartesian2D; |
| getCartesian(xAxisIndex?: number | FinderAxisIndex, yAxisIndex?: number) { |
| if (xAxisIndex != null && yAxisIndex != null) { |
| const key = 'x' + xAxisIndex + 'y' + yAxisIndex; |
| return this._coordsMap[key]; |
| } |
| |
| if (isObject(xAxisIndex)) { |
| yAxisIndex = (xAxisIndex as FinderAxisIndex).yAxisIndex; |
| xAxisIndex = (xAxisIndex as FinderAxisIndex).xAxisIndex; |
| } |
| for (let i = 0, coordList = this._coordsList; i < coordList.length; i++) { |
| if (coordList[i].getAxis('x').index === xAxisIndex |
| || coordList[i].getAxis('y').index === yAxisIndex |
| ) { |
| return coordList[i]; |
| } |
| } |
| } |
| |
| getCartesians(): Cartesian2D[] { |
| return this._coordsList.slice(); |
| } |
| |
| /** |
| * @implements |
| */ |
| convertToPixel( |
| ecModel: GlobalModel, finder: ParsedModelFinder, value: ScaleDataValue | ScaleDataValue[] |
| ): number | number[] { |
| const target = this._findConvertTarget(finder); |
| |
| return target.cartesian |
| ? target.cartesian.dataToPoint(value as ScaleDataValue[]) |
| : target.axis |
| ? target.axis.toGlobalCoord(target.axis.dataToCoord(value as ScaleDataValue)) |
| : null; |
| } |
| |
| /** |
| * @implements |
| */ |
| convertFromPixel( |
| ecModel: GlobalModel, finder: ParsedModelFinder, value: number | number[] |
| ): number | number[] { |
| const target = this._findConvertTarget(finder); |
| |
| return target.cartesian |
| ? target.cartesian.pointToData(value as number[]) |
| : target.axis |
| ? target.axis.coordToData(target.axis.toLocalCoord(value as number)) |
| : null; |
| } |
| |
| private _findConvertTarget(finder: ParsedModelFinderKnown): { |
| cartesian: Cartesian2D, |
| axis: Axis2D |
| } { |
| const seriesModel = finder.seriesModel; |
| const xAxisModel = finder.xAxisModel |
| || (seriesModel && seriesModel.getReferringComponents('xAxis', SINGLE_REFERRING).models[0]); |
| const yAxisModel = finder.yAxisModel |
| || (seriesModel && seriesModel.getReferringComponents('yAxis', SINGLE_REFERRING).models[0]); |
| const gridModel = finder.gridModel; |
| const coordsList = this._coordsList; |
| let cartesian: Cartesian2D; |
| let axis; |
| |
| if (seriesModel) { |
| cartesian = seriesModel.coordinateSystem as Cartesian2D; |
| indexOf(coordsList, cartesian) < 0 && (cartesian = null); |
| } |
| else if (xAxisModel && yAxisModel) { |
| cartesian = this.getCartesian(xAxisModel.componentIndex, yAxisModel.componentIndex); |
| } |
| else if (xAxisModel) { |
| axis = this.getAxis('x', xAxisModel.componentIndex); |
| } |
| else if (yAxisModel) { |
| axis = this.getAxis('y', yAxisModel.componentIndex); |
| } |
| // Lowest priority. |
| else if (gridModel) { |
| const grid = gridModel.coordinateSystem; |
| if (grid === this) { |
| cartesian = this._coordsList[0]; |
| } |
| } |
| |
| return {cartesian: cartesian, axis: axis}; |
| } |
| |
| /** |
| * @implements |
| */ |
| containPoint(point: number[]): boolean { |
| const coord = this._coordsList[0]; |
| if (coord) { |
| return coord.containPoint(point); |
| } |
| } |
| |
| /** |
| * Initialize cartesian coordinate systems |
| */ |
| private _initCartesian( |
| gridModel: GridModel, ecModel: GlobalModel, api: ExtensionAPI |
| ): void { |
| const grid = this; |
| const axisPositionUsed = { |
| left: false, |
| right: false, |
| top: false, |
| bottom: false |
| }; |
| |
| const axesMap = { |
| x: {}, |
| y: {} |
| } as AxesMap; |
| const axesCount = { |
| x: 0, |
| y: 0 |
| }; |
| |
| /// Create axis |
| ecModel.eachComponent('xAxis', createAxisCreator('x'), this); |
| ecModel.eachComponent('yAxis', createAxisCreator('y'), this); |
| |
| if (!axesCount.x || !axesCount.y) { |
| // Roll back when there no either x or y axis |
| this._axesMap = {} as AxesMap; |
| this._axesList = []; |
| return; |
| } |
| |
| this._axesMap = axesMap; |
| |
| /// Create cartesian2d |
| each(axesMap.x, (xAxis, xAxisIndex) => { |
| each(axesMap.y, (yAxis, yAxisIndex) => { |
| const key = 'x' + xAxisIndex + 'y' + yAxisIndex; |
| const cartesian = new Cartesian2D(key); |
| |
| cartesian.master = this; |
| cartesian.model = gridModel; |
| |
| this._coordsMap[key] = cartesian; |
| this._coordsList.push(cartesian); |
| |
| cartesian.addAxis(xAxis); |
| cartesian.addAxis(yAxis); |
| }); |
| }); |
| |
| function createAxisCreator(dimName: Cartesian2DDimensionName) { |
| return function (axisModel: CartesianAxisModel, idx: number): void { |
| if (!isAxisUsedInTheGrid(axisModel, gridModel)) { |
| return; |
| } |
| |
| let axisPosition = axisModel.get('position'); |
| if (dimName === 'x') { |
| // Fix position |
| if (axisPosition !== 'top' && axisPosition !== 'bottom') { |
| // Default bottom of X |
| axisPosition = axisPositionUsed.bottom ? 'top' : 'bottom'; |
| } |
| } |
| else { |
| // Fix position |
| if (axisPosition !== 'left' && axisPosition !== 'right') { |
| // Default left of Y |
| axisPosition = axisPositionUsed.left ? 'right' : 'left'; |
| } |
| } |
| axisPositionUsed[axisPosition] = true; |
| |
| const axis = new Axis2D( |
| dimName, |
| createScaleByModel(axisModel), |
| [0, 0], |
| axisModel.get('type'), |
| axisPosition |
| ); |
| |
| const isCategory = axis.type === 'category'; |
| axis.onBand = isCategory && axisModel.get('boundaryGap'); |
| axis.inverse = axisModel.get('inverse'); |
| |
| // Inject axis into axisModel |
| axisModel.axis = axis; |
| |
| // Inject axisModel into axis |
| axis.model = axisModel; |
| |
| // Inject grid info axis |
| axis.grid = grid; |
| |
| // Index of axis, can be used as key |
| axis.index = idx; |
| |
| grid._axesList.push(axis); |
| |
| axesMap[dimName][idx] = axis; |
| axesCount[dimName]++; |
| }; |
| } |
| } |
| |
| /** |
| * Update cartesian properties from series. |
| */ |
| private _updateScale(ecModel: GlobalModel, gridModel: GridModel): void { |
| // Reset scale |
| each(this._axesList, function (axis) { |
| axis.scale.setExtent(Infinity, -Infinity); |
| if (axis.type === 'category') { |
| const categorySortInfo = axis.model.get('categorySortInfo'); |
| (axis.scale as OrdinalScale).setSortInfo(categorySortInfo); |
| } |
| }); |
| |
| ecModel.eachSeries(function (seriesModel) { |
| if (isCartesian2DSeries(seriesModel)) { |
| const axesModelMap = findAxisModels(seriesModel); |
| const xAxisModel = axesModelMap.xAxisModel; |
| const yAxisModel = axesModelMap.yAxisModel; |
| |
| if (!isAxisUsedInTheGrid(xAxisModel, gridModel) |
| || !isAxisUsedInTheGrid(yAxisModel, gridModel) |
| ) { |
| return; |
| } |
| |
| const cartesian = this.getCartesian( |
| xAxisModel.componentIndex, yAxisModel.componentIndex |
| ); |
| const data = seriesModel.getData(); |
| const xAxis = cartesian.getAxis('x'); |
| const yAxis = cartesian.getAxis('y'); |
| |
| if (data.type === 'list') { |
| unionExtent(data, xAxis); |
| unionExtent(data, yAxis); |
| } |
| } |
| }, this); |
| |
| function unionExtent(data: List, axis: Axis2D): void { |
| each(getDataDimensionsOnAxis(data, axis.dim), function (dim) { |
| axis.scale.unionExtentFromData(data, dim); |
| }); |
| } |
| } |
| |
| /** |
| * @param dim 'x' or 'y' or 'auto' or null/undefined |
| */ |
| getTooltipAxes(dim: Cartesian2DDimensionName | 'auto'): { |
| baseAxes: Axis2D[], otherAxes: Axis2D[] |
| } { |
| const baseAxes = [] as Axis2D[]; |
| const otherAxes = [] as Axis2D[]; |
| |
| each(this.getCartesians(), function (cartesian) { |
| const baseAxis = (dim != null && dim !== 'auto') |
| ? cartesian.getAxis(dim) : cartesian.getBaseAxis(); |
| const otherAxis = cartesian.getOtherAxis(baseAxis); |
| indexOf(baseAxes, baseAxis) < 0 && baseAxes.push(baseAxis); |
| indexOf(otherAxes, otherAxis) < 0 && otherAxes.push(otherAxis); |
| }); |
| |
| return {baseAxes: baseAxes, otherAxes: otherAxes}; |
| } |
| |
| |
| static create(ecModel: GlobalModel, api: ExtensionAPI): Grid[] { |
| const grids = [] as Grid[]; |
| ecModel.eachComponent('grid', function (gridModel: GridModel, idx) { |
| const grid = new Grid(gridModel, ecModel, api); |
| grid.name = 'grid_' + idx; |
| // dataSampling requires axis extent, so resize |
| // should be performed in create stage. |
| grid.resize(gridModel, api, true); |
| |
| gridModel.coordinateSystem = grid; |
| |
| grids.push(grid); |
| }); |
| |
| // Inject the coordinateSystems into seriesModel |
| ecModel.eachSeries(function (seriesModel) { |
| if (!isCartesian2DSeries(seriesModel)) { |
| return; |
| } |
| |
| const axesModelMap = findAxisModels(seriesModel); |
| const xAxisModel = axesModelMap.xAxisModel; |
| const yAxisModel = axesModelMap.yAxisModel; |
| |
| const gridModel = xAxisModel.getCoordSysModel(); |
| |
| if (__DEV__) { |
| if (!gridModel) { |
| throw new Error( |
| 'Grid "' + retrieve3( |
| xAxisModel.get('gridIndex'), |
| xAxisModel.get('gridId'), |
| 0 |
| ) + '" not found' |
| ); |
| } |
| if (xAxisModel.getCoordSysModel() !== yAxisModel.getCoordSysModel()) { |
| throw new Error('xAxis and yAxis must use the same grid'); |
| } |
| } |
| |
| const grid = gridModel.coordinateSystem as Grid; |
| |
| seriesModel.coordinateSystem = grid.getCartesian( |
| xAxisModel.componentIndex, yAxisModel.componentIndex |
| ); |
| }); |
| |
| return grids; |
| } |
| |
| } |
| |
| /** |
| * Check if the axis is used in the specified grid. |
| */ |
| function isAxisUsedInTheGrid(axisModel: CartesianAxisModel, gridModel: GridModel): boolean { |
| return axisModel.getCoordSysModel() === gridModel; |
| } |
| |
| function fixAxisOnZero( |
| axesMap: AxesMap, |
| otherAxisDim: Cartesian2DDimensionName, |
| axis: Axis2D, |
| // Key: see `getOnZeroRecordKey` |
| onZeroRecords: Dictionary<boolean> |
| ): void { |
| |
| axis.getAxesOnZeroOf = function () { |
| // TODO: onZero of multiple axes. |
| return otherAxisOnZeroOf ? [otherAxisOnZeroOf] : []; |
| }; |
| |
| // onZero can not be enabled in these two situations: |
| // 1. When any other axis is a category axis. |
| // 2. When no axis is cross 0 point. |
| const otherAxes = axesMap[otherAxisDim]; |
| |
| let otherAxisOnZeroOf: Axis2D; |
| const axisModel = axis.model; |
| const onZero = axisModel.get(['axisLine', 'onZero']); |
| const onZeroAxisIndex = axisModel.get(['axisLine', 'onZeroAxisIndex']); |
| |
| if (!onZero) { |
| return; |
| } |
| |
| // If target axis is specified. |
| if (onZeroAxisIndex != null) { |
| if (canOnZeroToAxis(otherAxes[onZeroAxisIndex])) { |
| otherAxisOnZeroOf = otherAxes[onZeroAxisIndex]; |
| } |
| } |
| else { |
| // Find the first available other axis. |
| for (const idx in otherAxes) { |
| if (otherAxes.hasOwnProperty(idx) |
| && canOnZeroToAxis(otherAxes[idx]) |
| // Consider that two Y axes on one value axis, |
| // if both onZero, the two Y axes overlap. |
| && !onZeroRecords[getOnZeroRecordKey(otherAxes[idx])] |
| ) { |
| otherAxisOnZeroOf = otherAxes[idx]; |
| break; |
| } |
| } |
| } |
| |
| if (otherAxisOnZeroOf) { |
| onZeroRecords[getOnZeroRecordKey(otherAxisOnZeroOf)] = true; |
| } |
| |
| function getOnZeroRecordKey(axis: Axis2D) { |
| return axis.dim + '_' + axis.index; |
| } |
| } |
| |
| function canOnZeroToAxis(axis: Axis2D): boolean { |
| return axis && axis.type !== 'category' && axis.type !== 'time' && ifAxisCrossZero(axis); |
| } |
| |
| function updateAxisTransform(axis: Axis2D, coordBase: number) { |
| const axisExtent = axis.getExtent(); |
| const axisExtentSum = axisExtent[0] + axisExtent[1]; |
| |
| // Fast transform |
| axis.toGlobalCoord = axis.dim === 'x' |
| ? function (coord) { |
| return coord + coordBase; |
| } |
| : function (coord) { |
| return axisExtentSum - coord + coordBase; |
| }; |
| axis.toLocalCoord = axis.dim === 'x' |
| ? function (coord) { |
| return coord - coordBase; |
| } |
| : function (coord) { |
| return axisExtentSum - coord + coordBase; |
| }; |
| } |
| |
| export default Grid; |