319 lines
16 KiB
JavaScript
319 lines
16 KiB
JavaScript
|
|
/*
|
|
* 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 { getAcceptableTickPrecision, isNullableNumberFinite, mathAbs, mathCeil, mathFloor, mathMax, mathRound, nice, NICE_MODE_MIN, quantity, round } from '../util/number.js';
|
|
import IntervalScale from '../scale/Interval.js';
|
|
import LogScale from '../scale/Log.js';
|
|
import { updateIntervalOrLogScaleForNiceOrAligned } from './axisHelper.js';
|
|
import { warn } from '../util/log.js';
|
|
import { increaseInterval, isLogScale, getIntervalPrecision, intervalScaleEnsureValidExtent } from '../scale/helper.js';
|
|
import { assert } from 'zrender/lib/core/util.js';
|
|
import { adoptScaleRawExtentInfoAndPrepare } from './scaleRawExtentInfo.js';
|
|
import { hasBreaks } from '../scale/break.js';
|
|
/**
|
|
* NOTE: See the summary of the process of extent determination in the comment of `scaleMapper.setExtent`.
|
|
*
|
|
* @see SCALE_EXTENT_CONSTRUCTION for the full processing flow.
|
|
*/
|
|
export function scaleCalcAlign(targetAxis, alignToScale) {
|
|
var targetScale = targetAxis.scale;
|
|
var targetAxisModel = targetAxis.model;
|
|
if (process.env.NODE_ENV !== 'production') {
|
|
assert(targetScale && targetAxisModel && (targetScale instanceof IntervalScale || targetScale instanceof LogScale) && (alignToScale instanceof IntervalScale || alignToScale instanceof LogScale));
|
|
}
|
|
var targetExtentInfo = adoptScaleRawExtentInfoAndPrepare(targetScale, targetAxisModel, targetAxisModel.ecModel, targetAxis, null);
|
|
// FIXME:
|
|
// (1) Axis inverse is not considered yet.
|
|
// (2) `SCALE_EXTENT_KIND_MAPPING` is not considered yet.
|
|
var isTargetLogScale = isLogScale(targetScale);
|
|
var alignToScaleLinear = isLogScale(alignToScale) ? alignToScale.intervalStub : alignToScale;
|
|
var targetIntervalStub = isTargetLogScale ? targetScale.intervalStub : targetScale;
|
|
var targetLogScaleBase = targetScale.base;
|
|
var alignToTicks = alignToScaleLinear.getTicks();
|
|
var alignToExpNiceTicks = alignToScaleLinear.getTicks({
|
|
expandToNicedExtent: true
|
|
});
|
|
var alignToSegCount = alignToTicks.length - 1;
|
|
if (process.env.NODE_ENV !== 'production') {
|
|
// This is guards for future changes of `Interval#getTicks`.
|
|
assert(!hasBreaks(alignToScale) && !hasBreaks(targetScale));
|
|
assert(alignToSegCount > 0); // Ticks length >= 2 even on a blank scale.
|
|
assert(alignToExpNiceTicks.length === alignToTicks.length);
|
|
assert(alignToTicks[0].value <= alignToTicks[alignToSegCount].value);
|
|
assert(alignToExpNiceTicks[0].value <= alignToTicks[0].value && alignToTicks[alignToSegCount].value <= alignToExpNiceTicks[alignToSegCount].value);
|
|
if (alignToSegCount >= 2) {
|
|
assert(alignToExpNiceTicks[1].value === alignToTicks[1].value);
|
|
assert(alignToExpNiceTicks[alignToSegCount - 1].value === alignToTicks[alignToSegCount - 1].value);
|
|
}
|
|
}
|
|
// The Current strategy: Find a proper interval and an extent for the target scale to derive ticks
|
|
// matching exactly to ticks of `alignTo` scale.
|
|
// Adjust min, max based on the extent of alignTo. When min or max is set in alignTo scale
|
|
var t0; // diff ratio on min not-nice segment. 0 <= t0 < 1
|
|
var t1; // diff ratio on max not-nice segment. 0 <= t1 < 1
|
|
var alignToNiceSegCount; // >= 1
|
|
// Consider ticks of `alignTo`, only these cases below may occur:
|
|
if (alignToSegCount === 1) {
|
|
// `alignToTicks` is like:
|
|
// |--|
|
|
// In this case, we make the corresponding 2 target ticks "nice".
|
|
t0 = t1 = 0;
|
|
alignToNiceSegCount = 1;
|
|
} else if (alignToSegCount === 2) {
|
|
// `alignToTicks` is like:
|
|
// |-|-----| or
|
|
// |-----|-| or
|
|
// |-----|-----|
|
|
// Notices that nice ticks do not necessarily exist in this case.
|
|
// In this case, we choose the larger segment as the "nice segment" and
|
|
// the corresponding target ticks are made "nice".
|
|
var interval0 = mathAbs(alignToTicks[0].value - alignToTicks[1].value);
|
|
var interval1 = mathAbs(alignToTicks[1].value - alignToTicks[2].value);
|
|
t0 = t1 = 0;
|
|
if (interval0 === interval1) {
|
|
alignToNiceSegCount = 2;
|
|
} else {
|
|
alignToNiceSegCount = 1;
|
|
if (interval0 < interval1) {
|
|
t0 = interval0 / interval1;
|
|
} else {
|
|
t1 = interval1 / interval0;
|
|
}
|
|
}
|
|
} else {
|
|
// alignToSegCount >= 3
|
|
// `alignToTicks` is like:
|
|
// |-|-----|-----|-| or
|
|
// |-----|-----|-| or
|
|
// |-|-----|-----| or ...
|
|
// At least one nice segment is present, and not-nice segments are only present on
|
|
// the start and/or the end.
|
|
// In this case, ticks corresponding to nice segments are made "nice".
|
|
var alignToInterval = alignToScaleLinear.getConfig().interval;
|
|
t0 = (1 - (alignToTicks[0].value - alignToExpNiceTicks[0].value) / alignToInterval) % 1;
|
|
t1 = (1 - (alignToExpNiceTicks[alignToSegCount].value - alignToTicks[alignToSegCount].value) / alignToInterval) % 1;
|
|
alignToNiceSegCount = alignToSegCount - (t0 ? 1 : 0) - (t1 ? 1 : 0);
|
|
}
|
|
if (process.env.NODE_ENV !== 'production') {
|
|
assert(alignToNiceSegCount >= 1);
|
|
}
|
|
// NOTE:
|
|
// Consider a case:
|
|
// dataZoom controls all Y axes;
|
|
// dataZoom end is 90% (maxFixed: true, dataZoomFixMinMax[0]: true);
|
|
// but dataZoom start is 0% (minFixed: false, dataZoomFixMinMax[1]: false);
|
|
// In this case,
|
|
// - `Interval#calcNiceTicks` only uses `targetExtentInfo.max` as the upper bound, but expand the
|
|
// lower bound to a "nice" tick and can get an acceptable result.
|
|
// - `scaleCalcAlign` has to use both `targetExtentInfo.min/max` as the bounds without any expansion,
|
|
// otherwise the lower bound may become negative unexpectedly, especially for all positive series data.
|
|
var dataZoomFixMinMax = targetExtentInfo.zoomFixMM;
|
|
var hasDataZoomFixMinMax = dataZoomFixMinMax[0] || dataZoomFixMinMax[1];
|
|
var targetMinMaxFixed = [targetExtentInfo.fixMM[0] || hasDataZoomFixMinMax, targetExtentInfo.fixMM[1] || hasDataZoomFixMinMax];
|
|
// MEMO: When only `xxxAxis.min` or `xxxAxis.max` is fixed,
|
|
// - Even a "nice" interval can be calculated, ticks accumulated based on `min`/`max` can be "nice" only if
|
|
// `min` or `max` is a "nice" number.
|
|
// - Generating a "nice" interval may cause the extent have both positive and negative ticks, which may be
|
|
// not preferable for all positive (very common) or all negative series data. But it can be simply resolved
|
|
// by specifying `xxxAxis.min: 0`/`xxxAxis.max: 0`, so we do not specially handle this case here.
|
|
// Therefore, we prioritize generating "nice" interval over preventing from crossing zero.
|
|
// e.g., if series data are all positive and the max data is `11739`,
|
|
// If setting `yAxis.max: 'dataMax'`, ticks may be like:
|
|
// `11739, 8739, 5739, 2739, -1739` (not "nice" enough)
|
|
// If setting `yAxis.max: 'dataMax', yAxis.min: 0`, ticks may be like:
|
|
// `11739, 8805, 5870, 2935, 0` (not "nice" enough but may be acceptable)
|
|
// If setting `yAxis.max: 12000, yAxis.min: 0`, ticks may be like:
|
|
// `12000, 9000, 6000, 3000, 0` ("nice")
|
|
var targetOldOutermostExtent = targetScale.getExtent();
|
|
var targetOldIntervalExtent = targetIntervalStub.getExtent();
|
|
var targetExtent = intervalScaleEnsureValidExtent(targetOldIntervalExtent, targetMinMaxFixed);
|
|
var min;
|
|
var max;
|
|
var interval;
|
|
var intervalPrecision;
|
|
var maxNice;
|
|
var minNice;
|
|
function loopIncreaseInterval(cb) {
|
|
// Typically this loop runs less than 5 times. But we still
|
|
// use a fail-safe for future changes.
|
|
var LOOP_MAX = 50;
|
|
var loopGuard = 0;
|
|
for (; loopGuard < LOOP_MAX; loopGuard++) {
|
|
if (cb()) {
|
|
break;
|
|
}
|
|
interval = isTargetLogScale
|
|
// TODO: `mathMax(base, 2)` is a guardcode to avoid infinite loop,
|
|
// but probably it should be guranteed by `LogScale` itself.
|
|
? interval * mathMax(targetLogScaleBase, 2) : increaseInterval(interval);
|
|
intervalPrecision = getIntervalPrecision(interval);
|
|
}
|
|
if (process.env.NODE_ENV !== 'production') {
|
|
if (loopGuard >= LOOP_MAX) {
|
|
warn('incorrect impl in `scaleCalcAlign`.');
|
|
}
|
|
}
|
|
}
|
|
function updateMinFromMinNice() {
|
|
min = round(minNice - interval * t0, intervalPrecision);
|
|
}
|
|
function updateMaxFromMaxNice() {
|
|
max = round(maxNice + interval * t1, intervalPrecision);
|
|
}
|
|
function updateMinNiceFromMinT0Interval() {
|
|
minNice = t0 ? round(min + interval * t0, intervalPrecision) : min;
|
|
}
|
|
function updateMaxNiceFromMaxT1Interval() {
|
|
maxNice = t1 ? round(max - interval * t1, intervalPrecision) : max;
|
|
}
|
|
// NOTE: The new calculated `min`/`max` must NOT shrink the original extent; otherwise some series
|
|
// data may be outside of the extent. They can expand the original extent slightly to align with
|
|
// ticks of `alignTo`. In this case, more blank space is added but visually fine.
|
|
if (targetMinMaxFixed[0] && targetMinMaxFixed[1]) {
|
|
// Both `min` and `max` are specified (via dataZoom or ec option; consider both Cartesian, radar and
|
|
// other possible axes). In this case, "nice" ticks can hardly be calculated, but reasonable ticks should
|
|
// still be calculated whenever possible, especially `intervalPrecision` should be tuned for better
|
|
// appearance and lower cumulative error.
|
|
min = targetExtent[0];
|
|
max = targetExtent[1];
|
|
interval = (max - min) / (alignToNiceSegCount + t0 + t1);
|
|
// Typically axis pixel extent is ready here. See `create` in `Grid.ts`.
|
|
var axisPxExtent = targetAxis.getExtent();
|
|
// NOTICE: this pxSpan may be not accurate yet due to "outerBounds" logic, but acceptable so far.
|
|
var pxSpan = mathAbs(axisPxExtent[1] - axisPxExtent[0]);
|
|
// We imperically choose `pxDiffAcceptable` as `0.5 / alignToNiceSegCount` for reduce cumulative
|
|
// error, otherwise a discernible misalign (> 1px) may occur.
|
|
// PENDING: We do not find a acceptable precision for LogScale here.
|
|
// Theoretically it can be addressed but introduce more complexity. Is it necessary?
|
|
intervalPrecision = getAcceptableTickPrecision([max, min], pxSpan, 0.5 / alignToNiceSegCount);
|
|
updateMinNiceFromMinT0Interval();
|
|
updateMaxNiceFromMaxT1Interval();
|
|
if (isNullableNumberFinite(intervalPrecision)) {
|
|
interval = round(interval, intervalPrecision);
|
|
}
|
|
} else {
|
|
// Make a minimal enough `interval`, increase it later.
|
|
// It is a similar logic as `IntervalScale#calcNiceTicks` and `LogScale#calcNiceTicks`.
|
|
// Axis break is not supported, which is guranteed by the caller of this function.
|
|
var targetSpan = targetExtent[1] - targetExtent[0];
|
|
interval = isTargetLogScale ? mathMax(quantity(targetSpan), 1) : nice(targetSpan / alignToNiceSegCount, NICE_MODE_MIN);
|
|
intervalPrecision = getIntervalPrecision(interval);
|
|
if (targetMinMaxFixed[0]) {
|
|
min = targetExtent[0];
|
|
loopIncreaseInterval(function () {
|
|
updateMinNiceFromMinT0Interval();
|
|
maxNice = round(minNice + interval * alignToNiceSegCount, intervalPrecision);
|
|
updateMaxFromMaxNice();
|
|
if (max >= targetExtent[1]) {
|
|
return true;
|
|
}
|
|
});
|
|
} else if (targetMinMaxFixed[1]) {
|
|
max = targetExtent[1];
|
|
loopIncreaseInterval(function () {
|
|
updateMaxNiceFromMaxT1Interval();
|
|
minNice = round(maxNice - interval * alignToNiceSegCount, intervalPrecision);
|
|
updateMinFromMinNice();
|
|
if (min <= targetExtent[0]) {
|
|
return true;
|
|
}
|
|
});
|
|
} else {
|
|
loopIncreaseInterval(function () {
|
|
minNice = round(mathCeil(targetExtent[0] / interval) * interval, intervalPrecision);
|
|
maxNice = round(mathFloor(targetExtent[1] / interval) * interval, intervalPrecision);
|
|
// NOTE:
|
|
// - `maxNice - minNice >= -interval` here.
|
|
// - While `interval` increases, `currIntervalCount` decreases, minimum `-1`.
|
|
var currIntervalCount = mathRound((maxNice - minNice) / interval);
|
|
if (currIntervalCount <= alignToNiceSegCount) {
|
|
var moreCount = alignToNiceSegCount - currIntervalCount;
|
|
// Consider cases that negative tick do not make sense (or vice versa), users can simply
|
|
// specify `xxxAxis.min/max: 0` to avoid negative. But we still automatically handle it
|
|
// for some common cases whenever possible:
|
|
// - When ec option is `xxxAxis.scale: false` (the default), it is usually unexpected if
|
|
// negative (or positive) ticks are introduced.
|
|
// - In LogScale, series data are usually either all > 1 or all < 1, rather than both,
|
|
// that is, logarithm result is typically either all positive or all negative.
|
|
var moreCountPair = void 0;
|
|
var mayEnhanceZero = targetExtentInfo.incl0 || isTargetLogScale;
|
|
// `bounds < 0` or `bounds > 0` may require more complex handling, so we only auto handle
|
|
// `bounds === 0`.
|
|
if (mayEnhanceZero && targetExtent[0] === 0) {
|
|
// 0 has been included in extent and all positive.
|
|
moreCountPair = [0, moreCount];
|
|
} else if (mayEnhanceZero && targetExtent[1] === 0) {
|
|
// 0 has been included in extent and all negative.
|
|
moreCountPair = [moreCount, 0];
|
|
} else {
|
|
// Try to center ticks in axis space whenever possible, which is especially preferable
|
|
// in `LogScale`.
|
|
var lessHalfCount = mathFloor(moreCount / 2);
|
|
moreCountPair = moreCount % 2 === 0 ? [lessHalfCount, lessHalfCount] : min + max < targetExtent[0] + targetExtent[1] ? [lessHalfCount, lessHalfCount + 1] : [lessHalfCount + 1, lessHalfCount];
|
|
}
|
|
minNice = round(minNice - interval * moreCountPair[0], intervalPrecision);
|
|
maxNice = round(maxNice + interval * moreCountPair[1], intervalPrecision);
|
|
updateMinFromMinNice();
|
|
updateMaxFromMaxNice();
|
|
if (min <= targetExtent[0] && max >= targetExtent[1]) {
|
|
return true;
|
|
}
|
|
}
|
|
});
|
|
}
|
|
}
|
|
updateIntervalOrLogScaleForNiceOrAligned(targetScale, targetMinMaxFixed, targetOldIntervalExtent, [min, max], targetOldOutermostExtent, {
|
|
// NOTE: Even in LogScale, `interval` should not be in log space.
|
|
interval: interval,
|
|
// Force ticks count, otherwise cumulative error may cause more unexpected ticks to be generated.
|
|
// Though the overlapping tick labels may be auto-ignored, but probably unexpected, e.g., the min
|
|
// tick label is ignored but the secondary min tick label is shown, which is unexpected when
|
|
// `axis.min` is user-specified or dataZoom-specified.
|
|
intervalCount: alignToNiceSegCount,
|
|
intervalPrecision: intervalPrecision,
|
|
niceExtent: [minNice, maxNice]
|
|
});
|
|
if (process.env.NODE_ENV !== 'production') {
|
|
targetScale.freeze();
|
|
}
|
|
} |