Optimize Interval#niceTicks

src/scale/Interval.js

@@ -118,51 +118,37 @@ define(function (require) {
 
         /**
          * Update interval and extent of intervals for nice ticks
-         * Algorithm from d3.js
-         * @param {number} [approxTickNum = 10] Given approx tick number
+         *
+         * @param {number} [splitNumber = 5] Desired number of ticks
          */
-        niceTicks: function (approxTickNum) {
-            approxTickNum = approxTickNum || 10;
+        niceTicks: function (splitNumber) {
+            splitNumber = splitNumber || 5;
             var extent = this._extent;
             var span = extent[1] - extent[0];
             if (span === Infinity || span <= 0) {
                 return;
             }
 
-            // Figure out step quantity, for example 0.1, 1, 10, 100
-            var interval = Math.pow(10, Math.floor(Math.log(span / approxTickNum) / Math.LN10));
-            var err = approxTickNum / span * interval;
-
-            // Filter ticks to get closer to the desired count.
-            if (err <= 0.15) {
-                interval *= 10;
-            }
-            else if (err <= 0.3) {
-                interval *= 5;
-            }
-            else if (err <= 0.45) {
-                interval *= 3;
-            }
-            else if (err <= 0.75) {
-                interval *= 2;
-            }
+            // From "Nice Numbers for Graph Labels" of Graphic Gems
+            // var niceSpan = numberUtil.nice(span, false);
+            var step = numberUtil.nice(span / splitNumber, true);
 
             var niceExtent = [
-                numberUtil.round(mathCeil(extent[0] / interval) * interval),
-                numberUtil.round(mathFloor(extent[1] / interval) * interval)
+                numberUtil.round(Math.floor(extent[0] / step) * step),
+                numberUtil.round(Math.ceil(extent[1] / step) * step)
             ];
 
-            this._interval = interval;
+            this._interval = step;
             this._niceExtent = niceExtent;
         },
 
         /**
          * Nice extent.
-         * @param {number} [approxTickNum = 10] Given approx tick number
+         * @param {number} [splitNumber = 5] Given approx tick number
          * @param {boolean} [fixMin=false]
          * @param {boolean} [fixMax=false]
          */
-        niceExtent: function (approxTickNum, fixMin, fixMax) {
+        niceExtent: function (splitNumber, fixMin, fixMax) {
             var extent = this._extent;
             // If extent start and end are same, expand them
             if (extent[0] === extent[1]) {
@@ -182,7 +168,7 @@ define(function (require) {
                 extent[1] = 1;
             }
 
-            this.niceTicks(approxTickNum, fixMin, fixMax);
+            this.niceTicks(splitNumber);
 
             // var extent = this._extent;
             var interval = this._interval;

src/scale/Time.js

@@ -90,20 +90,13 @@ define(function (require) {
             var interval = level[2];
             // Same with interval scale if span is much larger than 1 year
             if (level[0] === 'year') {
-                var year = span / interval;
-                var yearInterval = Math.pow(10, Math.floor(Math.log(year / approxTickNum) / Math.LN10));
-                var err = approxTickNum / year * yearInterval;
-                // Filter ticks to get closer to the desired count.
-                if (err <= 0.15) {
-                    yearInterval *= 10;
-                }
-                else if (err <= 0.3) {
-                    yearInterval *= 5;
-                }
-                else if (err <= 0.75) {
-                    yearInterval *= 2;
-                }
-                interval *= yearInterval;
+                var yearSpan = span / interval;
+
+                // From "Nice Numbers for Graph Labels" of Graphic Gems
+                var niceYearSpan = numberUtil.nice(yearSpan, false);
+                var yearStep = numberUtil.nice(niceYearSpan / approxTickNum, true);
+
+                interval *= yearStep;
             }
 
             var niceExtent = [

src/util/number.js

@@ -161,5 +161,33 @@ define(function (require) {
             );
     };
 
+    // "Nice Numbers for Graph Labels" of Graphic Gems
+    /**
+     * find a “nice” number approximately equal to x. Round the number if round = true, take ceiling if round = false
+     * The primary observation is that the “nicest” numbers in decimal are 1, 2, and 5, and all power-of-ten multiples of these numbers.
+     * @param  {number} val
+     * @param  {boolean} round
+     * @return {number}
+     */
+    number.nice = function (val, round) {
+        var exp = Math.floor(Math.log(val) / Math.LN10);
+        var exp10 = Math.pow(10, exp);
+        var f = val / exp10; // between 1 and 10
+        var nf;
+        if (round) {
+            if (f < 1.5) { nf = 1; }
+            else if (f < 3) { nf = 2; }
+            else if (f < 7) { nf = 5; }
+            else { nf = 10; }
+        }
+        else {
+            if (f < 1) { nf = 1; }
+            else if (f < 2) { nf = 2; }
+            else if (f < 5) { nf = 5; }
+            else { nf = 10; }
+        }
+        return nf * exp10;
+    };
+
     return number;
 });
\ No newline at end of file