Add tickmode "proportional"

src/plot_api/plot_api.js

@@ -2945,7 +2945,11 @@ function getDiffFlags(oldContainer, newContainer, outerparts, opts) {
         // so newContainer won't have them.
         if((key === 'tick0' || key === 'dtick') && outerparts[0] !== 'geo') {
             var tickMode = newContainer.tickmode;
-            if(tickMode === 'auto' || tickMode === 'array' || !tickMode) continue;
+            if(tickMode === 'auto' ||
+              tickMode === 'array' ||
+              tickMode === 'domain array' ||
+              tickMode === 'full domain' ||
+              !tickMode) continue;
         }
         // FIXME: Similarly for axis ranges for 3D
         // contourcarpet doesn't HAVE zmin/zmax, they're just auto-added. It needs them.

src/plots/cartesian/axes.js

@@ -682,10 +682,13 @@ axes.prepTicks = function(ax, opts) {
             if(ax._name === 'radialaxis') nt *= 2;
         }
 
-        if(!(ax.minor && ax.minor.tickmode !== 'array')) {
+        if(!(ax.minor &&
+          (ax.minor.tickmode !== 'array' &&
+            ax.minor.tickmode !== 'domain array' &&
+            ax.minor.tickmode !== 'full domain'))) {
             // add a couple of extra digits for filling in ticks when we
             // have explicit tickvals without tick text
-            if(ax.tickmode === 'array') nt *= 100;
+            if(ax.tickmode === 'array' || ax.tickmode === 'domain array' || ax.tickmode === 'full domain') nt *= 100;
         }
 
         ax._roughDTick = Math.abs(rng[1] - rng[0]) / nt;
@@ -915,7 +918,6 @@ axes.calcTicks = function calcTicks(ax, opts) {
     var maxRange = Math.max(rng[0], rng[1]);
 
     var maxTicks = Math.max(1000, ax._length || 0);
-
     var ticksOut = [];
     var minorTicks = [];
 
@@ -944,15 +946,54 @@ axes.calcTicks = function calcTicks(ax, opts) {
             axes.prepTicks(mockAx, opts);
         }
 
-        // now that we've figured out the auto values for formatting
-        // in case we're missing some ticktext, we can break out for array ticks
-        if(mockAx.tickmode === 'array') {
+
+        if(mockAx.tickmode === 'array' || mockAx.tickmode === 'domain array' || mockAx.tickmode === 'full domain') {
+            var fractionalTickvals = [];
+            if(mockAx.tickmode === 'full domain') { // TODO: Change for minor, note: if minor we already have major
+                var nt = mockAx.nticks;
+                if(nt === undefined) nt = 0;
+                if(nt === 0) {
+                    // pass
+                } else if(nt === 1) {
+                    fractionalTickvals = [0.5];
+                } else if(nt === 2) {
+                    fractionalTickvals = [0, 1];
+                } else {
+                    var increment = 1 / (nt - 1); // (nt-2) + 1
+                    fractionalTickvals = [0];
+                    for(var tickIndex = 0; tickIndex < nt - 2; tickIndex++) {
+                        fractionalTickvals.push((tickIndex + 1) * increment);
+                    }
+                    fractionalTickvals.push(1);
+                }
+            }
+            if(mockAx.tickmode === 'domain array') {
+                fractionalTickvals = (major ? ax : ax.minor).tickvals;
+            }
+
+            if(mockAx.tickmode !== 'array') {
+                var width = (maxRange - minRange); // TODO: inspect this value for log, it shouldn't work!
+                if(axrev) width *= -1;
+                var offset = !axrev ? minRange : maxRange; // TODO: inspect this value for log
+                var mappedVals = Lib.simpleMap(fractionalTickvals,
+                    function(fraction, offset, width, type) {
+                        var mapped = offset + (width * fraction);
+                        return (type === 'log') ? Math.pow(10, mapped) : mapped;
+                    }, offset, width, type);
+                // reminder: ranges w/ type log use the exponent whereas ticks use the absolute value
+                // TODO: do some inspection here: it freaks me out doin arithmetic on possible exponents
+                (major ? ax : ax.minor)._mappedTickvals = mappedVals;
+            }
+            // now that we've figured out the auto values for formatting
+            // in case we're missing some ticktext, we can break out for array ticks
+
+            // Original 'array' only code
             if(major) {
                 tickVals = [];
-                ticksOut = arrayTicks(ax, !isMinor);
+                ticksOut = arrayTicks(ax, !isMinor); // ie arrayTicks(ax, majorOnly = !False)
             } else {
                 minorTickVals = [];
-                minorTicks = arrayTicks(ax, !isMinor);
+                minorTicks = arrayTicks(ax, !isMinor); // ie arrayTicks(ax, majorOnly = !True)
             }
             continue;
         }
@@ -1204,6 +1245,7 @@ axes.calcTicks = function calcTicks(ax, opts) {
             ticksOut.push(t);
         }
     }
+
     ticksOut = ticksOut.concat(minorTicks);
 
     ax._inCalcTicks = false;
@@ -1281,7 +1323,10 @@ function arrayTicks(ax, majorOnly) {
     for(var isMinor = 0; isMinor <= 1; isMinor++) {
         if((majorOnly !== undefined) && ((majorOnly && isMinor) || (majorOnly === false && !isMinor))) continue;
         if(isMinor && !ax.minor) continue;
-        var vals = !isMinor ? ax.tickvals : ax.minor.tickvals;
+
+        var targetAxis = (!isMinor ? ax : ax.minor);
+        var vals = (targetAxis.tickmode === 'array') ? targetAxis.tickvals : targetAxis._mappedTickvals;
+
         var text = !isMinor ? ax.ticktext : [];
         if(!vals) continue;
 
@@ -1618,18 +1663,23 @@ axes.tickFirst = function(ax, opts) {
 axes.tickText = function(ax, x, hover, noSuffixPrefix) {
     var out = tickTextObj(ax, x);
     var arrayMode = ax.tickmode === 'array';
+    var fractionalMode = (ax.tickmode === 'domain array' || ax.tickmode === 'full domain');
     var extraPrecision = hover || arrayMode;
     var axType = ax.type;
     // TODO multicategory, if we allow ticktext / tickvals
     var tickVal2l = axType === 'category' ? ax.d2l_noadd : ax.d2l;
     var i;
 
-    if(arrayMode && Lib.isArrayOrTypedArray(ax.ticktext)) {
+    if((arrayMode || fractionalMode) && Lib.isArrayOrTypedArray(ax.ticktext)) {
         var rng = Lib.simpleMap(ax.range, ax.r2l);
         var minDiff = (Math.abs(rng[1] - rng[0]) - (ax._lBreaks || 0)) / 10000;
 
         for(i = 0; i < ax.ticktext.length; i++) {
-            if(Math.abs(x - tickVal2l(ax.tickvals[i])) < minDiff) break;
+            if(arrayMode) {
+                if(Math.abs(x - tickVal2l(ax.tickvals[i])) < minDiff) break;
+            } else {
+                if(Math.abs(x - tickVal2l(ax._mappedTickvals[i])) < minDiff) break;
+            }
         }
         if(i < ax.ticktext.length) {
             out.text = String(ax.ticktext[i]);
@@ -3333,7 +3383,7 @@ axes.drawGrid = function(gd, ax, opts) {
 
     var counterAx = opts.counterAxis;
     if(counterAx && axes.shouldShowZeroLine(gd, ax, counterAx)) {
-        var isArrayMode = ax.tickmode === 'array';
+        var isArrayMode = (ax.tickmode === 'array' || ax.tickmode === 'domain array' || ax.tickmode === 'full domain');
         for(var i = 0; i < majorVals.length; i++) {
             var xi = majorVals[i].x;
             if(isArrayMode ? !xi : (Math.abs(xi) < ax.dtick / 100)) {

src/plots/cartesian/layout_attributes.js

@@ -14,7 +14,7 @@ var DAY_OF_WEEK = constants.WEEKDAY_PATTERN;
 
 var minorTickmode = {
     valType: 'enumerated',
-    values: ['auto', 'linear', 'array'],
+    values: ['auto', 'linear', 'array', 'domain array', 'full domain'],
     editType: 'ticks',
     impliedEdits: {tick0: undefined, dtick: undefined},
     description: [
@@ -23,9 +23,16 @@ var minorTickmode = {
         'If *linear*, the placement of the ticks is determined by',
         'a starting position `tick0` and a tick step `dtick`',
         '(*linear* is the default value if `tick0` and `dtick` are provided).',
-        'If *array*, the placement of the ticks is set via `tickvals`',
-        'and the tick text is `ticktext`.',
-        '(*array* is the default value if `tickvals` is provided).'
+        'If *array*, the placement of the ticks is set via `tickvals`,',
+        'which are actual values, and the tick text is `ticktext`.',
+        '(*array* is the default value if `tickvals` is provided).',
+        'If *full domain*, the number of ticks is set bia `nticks` but ticks',
+        'are placed first at both axis ends and then at equal proportions',
+        'between the axis. So `nticks=5` would put ticks at both ends and',
+        'every quarter.',
+        'If *domain array*, the placement is similiar to *array* except that',
+        '`tickvals` are fractions between 0 and 1 representing distance on',
+        'the corresponding axis.'
     ].join(' ')
 };
 

src/plots/cartesian/tick_value_defaults.js

@@ -29,8 +29,7 @@ module.exports = function handleTickValueDefaults(containerIn, containerOut, coe
         _dtick ? 'linear' :
         'auto';
     var tickmode = coerce(prefix + 'tickmode', tickmodeDefault);
-
-    if(tickmode === 'auto' || tickmode === 'sync') {
+    if(tickmode === 'auto' || tickmode === 'sync' || tickmode === 'full domain') {
         coerce(prefix + 'nticks');
     } else if(tickmode === 'linear') {
         // dtick is usually a positive number, but there are some