githubmirror/echarts

src/scale/Interval.ts
374 строки13 KB
100pah
fix(scale): Fix that extreme small numbers can not be displayed in Cartesian due to the inappropriate rounding precision. Close #16266
22 июл 2025, 12:03
22 июл 2025, 12:0318b5db2
/*
* 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 * as numberUtil from '../util/number';
import * as formatUtil from '../util/format';
import Scale, { ScaleGetTicksOpt, ScaleSettingDefault } from './Scale';
import * as helper from './helper';
import {ScaleTick, ParsedAxisBreakList, ScaleDataValue} from '../util/types';
import { getScaleBreakHelper } from './break';

const roundNumber = numberUtil.round;

class IntervalScale<SETTING extends ScaleSettingDefault = ScaleSettingDefault> extends Scale<SETTING> {

    static type = 'interval';
    type = 'interval';

    // Step is calculated in adjustExtent.
    protected _interval: number = 0;
    protected _niceExtent: [number, number];
    protected _intervalPrecision: number = 2;


    parse(val: ScaleDataValue): number {
        // `Scale#parse` (and its overrids) are typically applied at the axis values input
        // in echarts option. e.g., `axis.min/max`, `dataZoom.min/max`, etc.
        // but `series.data` is not included, which uses `dataValueHelper.ts`#`parseDataValue`.
        // `Scale#parse` originally introduced in fb8c813215098b9d2458966229bb95c510883d5e
        // at 2016 for dataZoom start/end settings (See `parseAxisModelMinMax`).
        //
        // Historically `scale/Interval.ts` returns the input value directly. But numeric
        // values (such as a number-like string '123') effectively passed through here and
        // were involved in calculations, which was error-prone and inconsistent with the
        // declared TS return type. Previously such issues are fixed separately in different
        // places case by case (such as #2475).
        //
        // Now, we perform actual parse to ensure its `number` type here. The parsing rule
        // follows the series data parsing rule (`dataValueHelper.ts`#`parseDataValue`)
        // and maintains compatibility as much as possible (thus a more strict parsing
        // `number.ts`#`numericToNumber` is not used here.)
        //
        // FIXME: `ScaleDataValue` also need to be modified to include numeric string type,
        //  since it effectively does.
        return (val == null || val === '')
            ? NaN
            // If string (like '-'), using '+' parse to NaN
            // If object, also parse to NaN
            : Number(val);
    }

    contain(val: number): boolean {
        return helper.contain(val, this._extent);
    }

    normalize(val: number): number {
        return this._calculator.normalize(val, this._extent);
    }

    scale(val: number): number {
        return this._calculator.scale(val, this._extent);
    }

    getInterval(): number {
        return this._interval;
    }

    setInterval(interval: number): void {
        this._interval = interval;
        // Dropped auto calculated niceExtent and use user-set extent.
        // We assume user wants to set both interval, min, max to get a better result.
        this._niceExtent = this._extent.slice() as [number, number];

        this._intervalPrecision = helper.getIntervalPrecision(interval);
    }

    /**
     * @override
     */
    getTicks(opt?: ScaleGetTicksOpt): ScaleTick[] {
        opt = opt || {};
        const interval = this._interval;
        const extent = this._extent;
        const niceTickExtent = this._niceExtent;
        const intervalPrecision = this._intervalPrecision;
        const scaleBreakHelper = getScaleBreakHelper();

        const ticks = [] as ScaleTick[];
        // If interval is 0, return [];
        if (!interval) {
            return ticks;
        }

        if (opt.breakTicks === 'only_break' && scaleBreakHelper) {
            scaleBreakHelper.addBreaksToTicks(ticks, this._brkCtx!.breaks, this._extent);
            return ticks;
        }

        // Consider this case: using dataZoom toolbox, zoom and zoom.
        const safeLimit = 10000;

        if (extent[0] < niceTickExtent[0]) {
            if (opt.expandToNicedExtent) {
                ticks.push({
                    value: roundNumber(niceTickExtent[0] - interval, intervalPrecision)
                });
            }
            else {
                ticks.push({
                    value: extent[0]
                });
            }
        }

        const estimateNiceMultiple = (tickVal: number, targetTick: number) => {
            return Math.round((targetTick - tickVal) / interval);
        };

        let tick = niceTickExtent[0];
        while (tick <= niceTickExtent[1]) {
            ticks.push({
                value: tick
            });

            // Avoid rounding error
            tick = roundNumber(tick + interval, intervalPrecision);
            if (this._brkCtx) {
                const moreMultiple = this._brkCtx.calcNiceTickMultiple(tick, estimateNiceMultiple);
                if (moreMultiple >= 0) {
                    tick = roundNumber(tick + moreMultiple * interval, intervalPrecision);
                }
            }

            if (ticks.length > 0 && tick === ticks[ticks.length - 1].value) {
                // Consider out of safe float point, e.g.,
                // -3711126.9907707 + 2e-10 === -3711126.9907707
                break;
            }
            if (ticks.length > safeLimit) {
                return [];
            }
        }
        // Consider this case: the last item of ticks is smaller
        // than niceTickExtent[1] and niceTickExtent[1] === extent[1].
        const lastNiceTick = ticks.length ? ticks[ticks.length - 1].value : niceTickExtent[1];
        if (extent[1] > lastNiceTick) {
            if (opt.expandToNicedExtent) {
                ticks.push({
                    value: roundNumber(lastNiceTick + interval, intervalPrecision)
                });
            }
            else {
                ticks.push({
                    value: extent[1]
                });
            }
        }

        if (scaleBreakHelper) {
            scaleBreakHelper.pruneTicksByBreak(
                opt.pruneByBreak,
                ticks,
                this._brkCtx!.breaks,
                item => item.value,
                this._interval,
                this._extent
            );
        }
        if (opt.breakTicks !== 'none' && scaleBreakHelper) {
            scaleBreakHelper.addBreaksToTicks(ticks, this._brkCtx!.breaks, this._extent);
        }

        return ticks;
    }

    getMinorTicks(splitNumber: number): number[][] {
        const ticks = this.getTicks({
            expandToNicedExtent: true,
        });
        // NOTE: In log-scale, do not support minor ticks when breaks exist.
        //  because currently log-scale minor ticks is calculated based on raw values
        //  rather than log-transformed value, due to an odd effect when breaks exist.
        const minorTicks = [];
        const extent = this.getExtent();

        for (let i = 1; i < ticks.length; i++) {
            const nextTick = ticks[i];
            const prevTick = ticks[i - 1];

            if (prevTick.break || nextTick.break) {
                // Do not build minor ticks to the adjacent ticks to breaks ticks,
                // since the interval might be irregular.
                continue;
            }

            let count = 0;
            const minorTicksGroup = [];
            const interval = nextTick.value - prevTick.value;
            const minorInterval = interval / splitNumber;
            const minorIntervalPrecision = helper.getIntervalPrecision(minorInterval);

            while (count < splitNumber - 1) {
                const minorTick = roundNumber(prevTick.value + (count + 1) * minorInterval, minorIntervalPrecision);

                // For the first and last interval. The count may be less than splitNumber.
                if (minorTick > extent[0] && minorTick < extent[1]) {
                    minorTicksGroup.push(minorTick);
                }
                count++;
            }

            const scaleBreakHelper = getScaleBreakHelper();
            scaleBreakHelper && scaleBreakHelper.pruneTicksByBreak(
                'auto',
                minorTicksGroup,
                this._getNonTransBreaks(),
                value => value,
                this._interval,
                extent
            );
            minorTicks.push(minorTicksGroup);
        }

        return minorTicks;
    }

    protected _getNonTransBreaks(): ParsedAxisBreakList {
        return this._brkCtx ? this._brkCtx.breaks : [];
    }

    /**
     * @param opt.precision If 'auto', use nice presision.
     * @param opt.pad returns 1.50 but not 1.5 if precision is 2.
     */
    getLabel(
        data: ScaleTick,
        opt?: {
            precision?: 'auto' | number,
            pad?: boolean
        }
    ): string {
        if (data == null) {
            return '';
        }

        let precision = opt && opt.precision;

        if (precision == null) {
            precision = numberUtil.getPrecision(data.value) || 0;
        }
        else if (precision === 'auto') {
            // Should be more precise then tick.
            precision = this._intervalPrecision;
        }

        // (1) If `precision` is set, 12.005 should be display as '12.00500'.
        // (2) Use roundNumber (toFixed) to avoid scientific notation like '3.5e-7'.
        const dataNum = roundNumber(data.value, precision as number, true);

        return formatUtil.addCommas(dataNum);
    }

    /**
     * FIXME: refactor - disallow override, use composition instead.
     *
     * The override of `calcNiceTicks` should ensure these members are provided:
     *  this._intervalPrecision
     *  this._interval
     *
     * @param splitNumber By default `5`.
     */
    calcNiceTicks(splitNumber?: number, minInterval?: number, maxInterval?: number): void {
        splitNumber = splitNumber || 5;
        let extent = this._extent.slice() as [number, number];
        let span = this._getExtentSpanWithBreaks();
        if (!isFinite(span)) {
            return;
        }
        // User may set axis min 0 and data are all negative
        // FIXME If it needs to reverse ?
        if (span < 0) {
            span = -span;
            extent.reverse();
            this._innerSetExtent(extent[0], extent[1]);
            extent = this._extent.slice() as [number, number];
        }

        const result = helper.intervalScaleNiceTicks(
            extent, span, splitNumber, minInterval, maxInterval
        );

        this._intervalPrecision = result.intervalPrecision;
        this._interval = result.interval;
        this._niceExtent = result.niceTickExtent;
    }

    calcNiceExtent(opt: {
        splitNumber: number, // By default 5.
        fixMin?: boolean,
        fixMax?: boolean,
        minInterval?: number,
        maxInterval?: number
    }): void {
        let extent = this._extent.slice() as [number, number];
        // If extent start and end are same, expand them
        if (extent[0] === extent[1]) {
            if (extent[0] !== 0) {
                // Expand extent
                // Note that extents can be both negative. See #13154
                const expandSize = Math.abs(extent[0]);
                // In the fowllowing case
                //      Axis has been fixed max 100
                //      Plus data are all 100 and axis extent are [100, 100].
                // Extend to the both side will cause expanded max is larger than fixed max.
                // So only expand to the smaller side.
                if (!opt.fixMax) {
                    extent[1] += expandSize / 2;
                    extent[0] -= expandSize / 2;
                }
                else {
                    extent[0] -= expandSize / 2;
                }
            }
            else {
                extent[1] = 1;
            }
        }
        const span = extent[1] - extent[0];
        // If there are no data and extent are [Infinity, -Infinity]
        if (!isFinite(span)) {
            extent[0] = 0;
            extent[1] = 1;
        }
        this._innerSetExtent(extent[0], extent[1]);
        extent = this._extent.slice() as [number, number];

        this.calcNiceTicks(opt.splitNumber, opt.minInterval, opt.maxInterval);
        const interval = this._interval;
        const intervalPrecition = this._intervalPrecision;

        if (!opt.fixMin) {
            extent[0] = roundNumber(Math.floor(extent[0] / interval) * interval, intervalPrecition);
        }
        if (!opt.fixMax) {
            extent[1] = roundNumber(Math.ceil(extent[1] / interval) * interval, intervalPrecition);
        }
        this._innerSetExtent(extent[0], extent[1]);
    }

    setNiceExtent(min: number, max: number): void {
        this._niceExtent = [min, max];
    }

}

Scale.registerClass(IntervalScale);

export default IntervalScale;