Start again

vendors/echarts/src/scale/Interval.js

@@ -0,0 +1,201 @@
+/**
+ * Interval scale
+ * @module echarts/scale/Interval
+ */
+
+define(function (require) {
+
+    var numberUtil = require('../util/number');
+    var formatUtil = require('../util/format');
+    var Scale = require('./Scale');
+
+    var mathFloor = Math.floor;
+    var mathCeil = Math.ceil;
+    /**
+     * @alias module:echarts/coord/scale/Interval
+     * @constructor
+     */
+    var IntervalScale = Scale.extend({
+
+        type: 'interval',
+
+        _interval: 0,
+
+        setExtent: function (start, end) {
+            var thisExtent = this._extent;
+            //start,end may be a Number like '25',so...
+            if (!isNaN(start)) {
+                thisExtent[0] = parseFloat(start);
+            }
+            if (!isNaN(end)) {
+                thisExtent[1] = parseFloat(end);
+            }
+        },
+
+        unionExtent: function (other) {
+            var extent = this._extent;
+            other[0] < extent[0] && (extent[0] = other[0]);
+            other[1] > extent[1] && (extent[1] = other[1]);
+
+            // unionExtent may called by it's sub classes
+            IntervalScale.prototype.setExtent.call(this, extent[0], extent[1]);
+        },
+        /**
+         * Get interval
+         */
+        getInterval: function () {
+            if (!this._interval) {
+                this.niceTicks();
+            }
+            return this._interval;
+        },
+
+        /**
+         * Set interval
+         */
+        setInterval: function (interval) {
+            this._interval = interval;
+            // Dropped auto calculated niceExtent and use user setted extent
+            // We assume user wan't to set both interval, min, max to get a better result
+            this._niceExtent = this._extent.slice();
+        },
+
+        /**
+         * @return {Array.<number>}
+         */
+        getTicks: function () {
+            if (!this._interval) {
+                this.niceTicks();
+            }
+            var interval = this._interval;
+            var extent = this._extent;
+            var ticks = [];
+
+            // Consider this case: using dataZoom toolbox, zoom and zoom.
+            var safeLimit = 10000;
+
+            if (interval) {
+                var niceExtent = this._niceExtent;
+                if (extent[0] < niceExtent[0]) {
+                    ticks.push(extent[0]);
+                }
+                var tick = niceExtent[0];
+                while (tick <= niceExtent[1]) {
+                    ticks.push(tick);
+                    // Avoid rounding error
+                    tick = numberUtil.round(tick + interval);
+                    if (ticks.length > safeLimit) {
+                        return [];
+                    }
+                }
+                if (extent[1] > niceExtent[1]) {
+                    ticks.push(extent[1]);
+                }
+            }
+
+            return ticks;
+        },
+
+        /**
+         * @return {Array.<string>}
+         */
+        getTicksLabels: function () {
+            var labels = [];
+            var ticks = this.getTicks();
+            for (var i = 0; i < ticks.length; i++) {
+                labels.push(this.getLabel(ticks[i]));
+            }
+            return labels;
+        },
+
+        /**
+         * @param {number} n
+         * @return {number}
+         */
+        getLabel: function (data) {
+            return formatUtil.addCommas(data);
+        },
+
+        /**
+         * Update interval and extent of intervals for nice ticks
+         *
+         * @param {number} [splitNumber = 5] Desired number of ticks
+         */
+        niceTicks: function (splitNumber) {
+            splitNumber = splitNumber || 5;
+            var extent = this._extent;
+            var span = extent[1] - extent[0];
+            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();
+            }
+
+            // From "Nice Numbers for Graph Labels" of Graphic Gems
+            // var niceSpan = numberUtil.nice(span, false);
+            var step = numberUtil.nice(span / splitNumber, true);
+
+            // Niced extent inside original extent
+            var niceExtent = [
+                numberUtil.round(mathCeil(extent[0] / step) * step),
+                numberUtil.round(mathFloor(extent[1] / step) * step)
+            ];
+
+            this._interval = step;
+            this._niceExtent = niceExtent;
+        },
+
+        /**
+         * Nice extent.
+         * @param {number} [splitNumber = 5] Given approx tick number
+         * @param {boolean} [fixMin=false]
+         * @param {boolean} [fixMax=false]
+         */
+        niceExtent: function (splitNumber, fixMin, fixMax) {
+            var extent = this._extent;
+            // If extent start and end are same, expand them
+            if (extent[0] === extent[1]) {
+                if (extent[0] !== 0) {
+                    // Expand extent
+                    var expandSize = extent[0] / 2;
+                    extent[0] -= expandSize;
+                    extent[1] += expandSize;
+                }
+                else {
+                    extent[1] = 1;
+                }
+            }
+            var 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.niceTicks(splitNumber);
+
+            // var extent = this._extent;
+            var interval = this._interval;
+
+            if (!fixMin) {
+                extent[0] = numberUtil.round(mathFloor(extent[0] / interval) * interval);
+            }
+            if (!fixMax) {
+                extent[1] = numberUtil.round(mathCeil(extent[1] / interval) * interval);
+            }
+        }
+    });
+
+    /**
+     * @return {module:echarts/scale/Time}
+     */
+    IntervalScale.create = function () {
+        return new IntervalScale();
+    };
+
+    return IntervalScale;
+});

vendors/echarts/src/scale/Log.js

@@ -0,0 +1,130 @@
+/**
+ * Log scale
+ * @module echarts/scale/Log
+ */
+define(function (require) {
+
+    var zrUtil = require('zrender/core/util');
+    var Scale = require('./Scale');
+    var numberUtil = require('../util/number');
+
+    // Use some method of IntervalScale
+    var IntervalScale = require('./Interval');
+
+    var scaleProto = Scale.prototype;
+    var intervalScaleProto = IntervalScale.prototype;
+
+    var mathFloor = Math.floor;
+    var mathCeil = Math.ceil;
+    var mathPow = Math.pow;
+
+    var LOG_BASE = 10;
+    var mathLog = Math.log;
+
+    var LogScale = Scale.extend({
+
+        type: 'log',
+
+        /**
+         * @return {Array.<number>}
+         */
+        getTicks: function () {
+            return zrUtil.map(intervalScaleProto.getTicks.call(this), function (val) {
+                return numberUtil.round(mathPow(LOG_BASE, val));
+            });
+        },
+
+        /**
+         * @param {number} val
+         * @return {string}
+         */
+        getLabel: intervalScaleProto.getLabel,
+
+        /**
+         * @param  {number} val
+         * @return {number}
+         */
+        scale: function (val) {
+            val = scaleProto.scale.call(this, val);
+            return mathPow(LOG_BASE, val);
+        },
+
+        /**
+         * @param {number} start
+         * @param {number} end
+         */
+        setExtent: function (start, end) {
+            start = mathLog(start) / mathLog(LOG_BASE);
+            end = mathLog(end) / mathLog(LOG_BASE);
+            intervalScaleProto.setExtent.call(this, start, end);
+        },
+
+        /**
+         * @return {number} end
+         */
+        getExtent: function () {
+            var extent = scaleProto.getExtent.call(this);
+            extent[0] = mathPow(LOG_BASE, extent[0]);
+            extent[1] = mathPow(LOG_BASE, extent[1]);
+            return extent;
+        },
+
+        /**
+         * @param  {Array.<number>} extent
+         */
+        unionExtent: function (extent) {
+            extent[0] = mathLog(extent[0]) / mathLog(LOG_BASE);
+            extent[1] = mathLog(extent[1]) / mathLog(LOG_BASE);
+            scaleProto.unionExtent.call(this, extent);
+        },
+
+        /**
+         * Update interval and extent of intervals for nice ticks
+         * @param  {number} [approxTickNum = 10] Given approx tick number
+         */
+        niceTicks: function (approxTickNum) {
+            approxTickNum = approxTickNum || 10;
+            var extent = this._extent;
+            var span = extent[1] - extent[0];
+            if (span === Infinity || span <= 0) {
+                return;
+            }
+
+            var interval = mathPow(10, mathFloor(mathLog(span / approxTickNum) / Math.LN10));
+            var err = approxTickNum / span * interval;
+
+            // Filter ticks to get closer to the desired count.
+            if (err <= 0.5) {
+                interval *= 10;
+            }
+            var niceExtent = [
+                numberUtil.round(mathCeil(extent[0] / interval) * interval),
+                numberUtil.round(mathFloor(extent[1] / interval) * interval)
+            ];
+
+            this._interval = interval;
+            this._niceExtent = niceExtent;
+        },
+
+        /**
+         * Nice extent.
+         * @param {number} [approxTickNum = 10] Given approx tick number
+         * @param {boolean} [fixMin=false]
+         * @param {boolean} [fixMax=false]
+         */
+        niceExtent: intervalScaleProto.niceExtent
+    });
+
+    zrUtil.each(['contain', 'normalize'], function (methodName) {
+        LogScale.prototype[methodName] = function (val) {
+            val = mathLog(val) / mathLog(LOG_BASE);
+            return scaleProto[methodName].call(this, val);
+        };
+    });
+
+    LogScale.create = function () {
+        return new LogScale();
+    };
+
+    return LogScale;
+});

vendors/echarts/src/scale/Ordinal.js

@@ -0,0 +1,95 @@
+/**
+ * Linear continuous scale
+ * @module echarts/coord/scale/Ordinal
+ *
+ * http://en.wikipedia.org/wiki/Level_of_measurement
+ */
+
+// FIXME only one data
+define(function (require) {
+
+    var zrUtil = require('zrender/core/util');
+    var Scale = require('./Scale');
+
+    var scaleProto = Scale.prototype;
+
+    var OrdinalScale = Scale.extend({
+
+        type: 'ordinal',
+
+        init: function (data, extent) {
+            this._data = data;
+            this._extent = extent || [0, data.length - 1];
+        },
+
+        parse: function (val) {
+            return typeof val === 'string'
+                ? zrUtil.indexOf(this._data, val)
+                // val might be float.
+                : Math.round(val);
+        },
+
+        contain: function (rank) {
+            rank = this.parse(rank);
+            return scaleProto.contain.call(this, rank)
+                && this._data[rank] != null;
+        },
+
+        /**
+         * Normalize given rank or name to linear [0, 1]
+         * @param {number|string} [val]
+         * @return {number}
+         */
+        normalize: function (val) {
+            return scaleProto.normalize.call(this, this.parse(val));
+        },
+
+        scale: function (val) {
+            return Math.round(scaleProto.scale.call(this, val));
+        },
+
+        /**
+         * @return {Array}
+         */
+        getTicks: function () {
+            var ticks = [];
+            var extent = this._extent;
+            var rank = extent[0];
+
+            while (rank <= extent[1]) {
+                ticks.push(rank);
+                rank++;
+            }
+
+            return ticks;
+        },
+
+        /**
+         * Get item on rank n
+         * @param {number} n
+         * @return {string}
+         */
+        getLabel: function (n) {
+            return this._data[n];
+        },
+
+        /**
+         * @return {number}
+         */
+        count: function () {
+            return this._extent[1] - this._extent[0] + 1;
+        },
+
+        niceTicks: zrUtil.noop,
+        niceExtent: zrUtil.noop
+    });
+
+    /**
+     * @return {module:echarts/scale/Time}
+     */
+    OrdinalScale.create = function () {
+        return new OrdinalScale();
+    };
+
+    return OrdinalScale;
+});

vendors/echarts/src/scale/Scale.js

@@ -0,0 +1,123 @@
+/**
+ * // Scale class management
+ * @module echarts/scale/Scale
+ */
+define(function (require) {
+
+    var clazzUtil = require('../util/clazz');
+
+    function Scale() {
+        /**
+         * Extent
+         * @type {Array.<number>}
+         * @protected
+         */
+        this._extent = [Infinity, -Infinity];
+
+        /**
+         * Step is calculated in adjustExtent
+         * @type {Array.<number>}
+         * @protected
+         */
+        this._interval = 0;
+
+        this.init && this.init.apply(this, arguments);
+    }
+
+    var scaleProto = Scale.prototype;
+
+    /**
+     * Parse input val to valid inner number.
+     * @param {*} val
+     * @return {number}
+     */
+    scaleProto.parse = function (val) {
+        // Notice: This would be a trap here, If the implementation
+        // of this method depends on extent, and this method is used
+        // before extent set (like in dataZoom), it would be wrong.
+        // Nevertheless, parse does not depend on extent generally.
+        return val;
+    };
+
+    scaleProto.contain = function (val) {
+        var extent = this._extent;
+        return val >= extent[0] && val <= extent[1];
+    };
+
+    /**
+     * Normalize value to linear [0, 1], return 0.5 if extent span is 0
+     * @param {number} val
+     * @return {number}
+     */
+    scaleProto.normalize = function (val) {
+        var extent = this._extent;
+        if (extent[1] === extent[0]) {
+            return 0.5;
+        }
+        return (val - extent[0]) / (extent[1] - extent[0]);
+    };
+
+    /**
+     * Scale normalized value
+     * @param {number} val
+     * @return {number}
+     */
+    scaleProto.scale = function (val) {
+        var extent = this._extent;
+        return val * (extent[1] - extent[0]) + extent[0];
+    };
+
+    /**
+     * Set extent from data
+     * @param {Array.<number>} other
+     */
+    scaleProto.unionExtent = function (other) {
+        var extent = this._extent;
+        other[0] < extent[0] && (extent[0] = other[0]);
+        other[1] > extent[1] && (extent[1] = other[1]);
+        // not setExtent because in log axis it may transformed to power
+        // this.setExtent(extent[0], extent[1]);
+    };
+
+    /**
+     * Get extent
+     * @return {Array.<number>}
+     */
+    scaleProto.getExtent = function () {
+        return this._extent.slice();
+    };
+
+    /**
+     * Set extent
+     * @param {number} start
+     * @param {number} end
+     */
+    scaleProto.setExtent = function (start, end) {
+        var thisExtent = this._extent;
+        if (!isNaN(start)) {
+            thisExtent[0] = start;
+        }
+        if (!isNaN(end)) {
+            thisExtent[1] = end;
+        }
+    };
+
+    /**
+     * @return {Array.<string>}
+     */
+    scaleProto.getTicksLabels = function () {
+        var labels = [];
+        var ticks = this.getTicks();
+        for (var i = 0; i < ticks.length; i++) {
+            labels.push(this.getLabel(ticks[i]));
+        }
+        return labels;
+    };
+
+    clazzUtil.enableClassExtend(Scale);
+    clazzUtil.enableClassManagement(Scale, {
+        registerWhenExtend: true
+    });
+
+    return Scale;
+});

vendors/echarts/src/scale/Time.js

@@ -0,0 +1,161 @@
+/**
+ * Interval scale
+ * @module echarts/coord/scale/Time
+ */
+
+define(function (require) {
+
+    var zrUtil = require('zrender/core/util');
+    var numberUtil = require('../util/number');
+    var formatUtil = require('../util/format');
+
+    var IntervalScale = require('./Interval');
+
+    var intervalScaleProto = IntervalScale.prototype;
+
+    var mathCeil = Math.ceil;
+    var mathFloor = Math.floor;
+    var ONE_SECOND = 1000;
+    var ONE_MINUTE = ONE_SECOND * 60;
+    var ONE_HOUR = ONE_MINUTE * 60;
+    var ONE_DAY = ONE_HOUR * 24;
+
+    // FIXME 公用？
+    var bisect = function (a, x, lo, hi) {
+        while (lo < hi) {
+            var mid = lo + hi >>> 1;
+            if (a[mid][2] < x) {
+                lo = mid + 1;
+            }
+            else {
+                hi  = mid;
+            }
+        }
+        return lo;
+    };
+
+    /**
+     * @alias module:echarts/coord/scale/Time
+     * @constructor
+     */
+    var TimeScale = IntervalScale.extend({
+        type: 'time',
+
+        // Overwrite
+        getLabel: function (val) {
+            var stepLvl = this._stepLvl;
+
+            var date = new Date(val);
+
+            return formatUtil.formatTime(stepLvl[0], date);
+        },
+
+        // Overwrite
+        niceExtent: function (approxTickNum, fixMin, fixMax) {
+            var extent = this._extent;
+            // If extent start and end are same, expand them
+            if (extent[0] === extent[1]) {
+                // Expand extent
+                extent[0] -= ONE_DAY;
+                extent[1] += ONE_DAY;
+            }
+            // If there are no data and extent are [Infinity, -Infinity]
+            if (extent[1] === -Infinity && extent[0] === Infinity) {
+                var d = new Date();
+                extent[1] = new Date(d.getFullYear(), d.getMonth(), d.getDate());
+                extent[0] = extent[1] - ONE_DAY;
+            }
+
+            this.niceTicks(approxTickNum);
+
+            // var extent = this._extent;
+            var interval = this._interval;
+
+            if (!fixMin) {
+                extent[0] = numberUtil.round(mathFloor(extent[0] / interval) * interval);
+            }
+            if (!fixMax) {
+                extent[1] = numberUtil.round(mathCeil(extent[1] / interval) * interval);
+            }
+        },
+
+        // Overwrite
+        niceTicks: function (approxTickNum) {
+            approxTickNum = approxTickNum || 10;
+
+            var extent = this._extent;
+            var span = extent[1] - extent[0];
+            var approxInterval = span / approxTickNum;
+            var scaleLevelsLen = scaleLevels.length;
+            var idx = bisect(scaleLevels, approxInterval, 0, scaleLevelsLen);
+
+            var level = scaleLevels[Math.min(idx, scaleLevelsLen - 1)];
+            var interval = level[2];
+            // Same with interval scale if span is much larger than 1 year
+            if (level[0] === 'year') {
+                var yearSpan = span / interval;
+
+                // From "Nice Numbers for Graph Labels" of Graphic Gems
+                // var niceYearSpan = numberUtil.nice(yearSpan, false);
+                var yearStep = numberUtil.nice(yearSpan / approxTickNum, true);
+
+                interval *= yearStep;
+            }
+
+            var niceExtent = [
+                mathCeil(extent[0] / interval) * interval,
+                mathFloor(extent[1] / interval) * interval
+            ];
+
+            this._stepLvl = level;
+            // Interval will be used in getTicks
+            this._interval = interval;
+            this._niceExtent = niceExtent;
+        },
+
+        parse: function (val) {
+            // val might be float.
+            return +numberUtil.parseDate(val);
+        }
+    });
+
+    zrUtil.each(['contain', 'normalize'], function (methodName) {
+        TimeScale.prototype[methodName] = function (val) {
+            return intervalScaleProto[methodName].call(this, this.parse(val));
+        };
+    });
+
+    // Steps from d3
+    var scaleLevels = [
+        // Format       step    interval
+        ['hh:mm:ss',    1,      ONE_SECOND],           // 1s
+        ['hh:mm:ss',    5,      ONE_SECOND * 5],       // 5s
+        ['hh:mm:ss',    10,     ONE_SECOND * 10],      // 10s
+        ['hh:mm:ss',    15,     ONE_SECOND * 15],      // 15s
+        ['hh:mm:ss',    30,     ONE_SECOND * 30],      // 30s
+        ['hh:mm\nMM-dd',1,      ONE_MINUTE],          // 1m
+        ['hh:mm\nMM-dd',5,      ONE_MINUTE * 5],      // 5m
+        ['hh:mm\nMM-dd',10,     ONE_MINUTE * 10],     // 10m
+        ['hh:mm\nMM-dd',15,     ONE_MINUTE * 15],     // 15m
+        ['hh:mm\nMM-dd',30,     ONE_MINUTE * 30],     // 30m
+        ['hh:mm\nMM-dd',1,      ONE_HOUR],        // 1h
+        ['hh:mm\nMM-dd',2,      ONE_HOUR * 2],    // 2h
+        ['hh:mm\nMM-dd',6,      ONE_HOUR * 6],    // 6h
+        ['hh:mm\nMM-dd',12,     ONE_HOUR * 12],   // 12h
+        ['MM-dd\nyyyy', 1,      ONE_DAY],   // 1d
+        ['week',        7,      ONE_DAY * 7],        // 7d
+        ['month',       1,      ONE_DAY * 31],       // 1M
+        ['quarter',     3,      ONE_DAY * 380 / 4],  // 3M
+        ['half-year',   6,      ONE_DAY * 380 / 2],  // 6M
+        ['year',        1,      ONE_DAY * 380]       // 1Y
+    ];
+
+    /**
+     * @return {module:echarts/scale/Time}
+     */
+    TimeScale.create = function () {
+        return new TimeScale();
+    };
+
+    return TimeScale;
+});