remove dataCenter var so zeroline shows at 0

Author: cldougl

src/plots/gl3d/layout/tick_marks.js

@@ -49,8 +49,8 @@ function computeTickMarks(scene) {
         if (Math.abs(axes._length) === Infinity) {
             ticks[i] = [];
         } else {
-            axes.range[0] = (glRange[i].lo + scene.dataCenter[i]) / scene.dataScale[i];
-            axes.range[1] = (glRange[i].hi + scene.dataCenter[i]) / scene.dataScale[i];
+            axes.range[0] = (glRange[i].lo) / scene.dataScale[i];
+            axes.range[1] = (glRange[i].hi) / scene.dataScale[i];
             axes._m       = 1.0 / (scene.dataScale[i] * glRange[i].pixelsPerDataUnit);
 
             if(axes.range[0] === axes.range[1]) {
@@ -69,7 +69,7 @@ function computeTickMarks(scene) {
             }
             var dataTicks = Plotly.Axes.calcTicks(axes);
             for(var j=0; j<dataTicks.length; ++j) {
-              dataTicks[j].x = dataTicks[j].x * scene.dataScale[i] - scene.dataCenter[i];
+              dataTicks[j].x = dataTicks[j].x * scene.dataScale[i];
               dataTicks[j].text = convertHTML(dataTicks[j].text);
             }
             ticks[i] = dataTicks;

src/plots/gl3d/scene.js

@@ -218,7 +218,6 @@ function Scene(options, fullLayout) {
 
     //Coordinate rescaling
     this.dataScale    = [1,1,1];
-    this.dataCenter   = [0,0,0];
 
     this.contourLevels = [ [], [], [] ];
 
@@ -334,24 +333,20 @@ proto.plot = function(sceneData, fullLayout, layout) {
       computeTraceBounds(this, data, dataBounds);
     }
     var dataScale = [1,1,1];
-    var dataCenter = [0,0,0];
     for(var j=0; j<3; ++j) {
       if(dataBounds[0][j] > dataBounds[1][j]) {
         dataScale[j] = 1.0;
-        dataCenter[j] = 0.0;
       } else {
         if(dataBounds[1][j] === dataBounds[0][j]) {
           dataScale[j] = 1.0;
         } else {
           dataScale[j] = 1.0/(dataBounds[1][j] - dataBounds[0][j]);
         }
-        dataCenter[j] = 0.5 * (dataBounds[0][j] + dataBounds[1][j]) * dataScale[j];
       }
     }
 
     //Save scale and offset factors
     this.dataScale = dataScale;
-    this.dataCenter = dataCenter;
 
     //Update traces
     for(var i = 0; i < sceneData.length; ++i) {
@@ -422,9 +417,9 @@ trace_id_loop:
             for(j = 0; j < this.glplot.objects.length; ++j) {
                 var objBounds = this.glplot.objects[j].bounds;
                 sceneBounds[0][i] = Math.min(sceneBounds[0][i],
-                  (objBounds[0][i] + dataCenter[i]) / dataScale[i]);
+                  objBounds[0][i] / dataScale[i]);
                 sceneBounds[1][i] = Math.max(sceneBounds[1][i],
-                  (objBounds[1][i] + dataCenter[i]) / dataScale[i]);
+                  objBounds[1][i] / dataScale[i]);
             }
             if('rangemode' in axis && axis.rangemode === 'tozero') {
                 sceneBounds[0][i] = Math.min(sceneBounds[0][i], 0);
@@ -450,8 +445,8 @@ trace_id_loop:
         axisDataRange[i] = sceneBounds[1][i] - sceneBounds[0][i];
 
         //Update plot bounds
-        this.glplot.bounds[0][i] = sceneBounds[0][i] * dataScale[i] - dataCenter[i];
-        this.glplot.bounds[1][i] = sceneBounds[1][i] * dataScale[i] - dataCenter[i];
+        this.glplot.bounds[0][i] = sceneBounds[0][i] * dataScale[i];
+        this.glplot.bounds[1][i] = sceneBounds[1][i] * dataScale[i];
     }
 
     var axesScaleRatio = [1, 1, 1];

src/traces/scatter3d/convert.js

@@ -169,7 +169,6 @@ function convertPlotlyOptions(scene, data) {
         points = [],
         sceneLayout = scene.fullSceneLayout,
         scaleFactor = scene.dataScale,
-        offset = scene.dataCenter,
         xaxis = sceneLayout.xaxis,
         yaxis = sceneLayout.yaxis,
         zaxis = sceneLayout.zaxis,
@@ -184,9 +183,9 @@ function convertPlotlyOptions(scene, data) {
     //Convert points
     for (i = 0; i < len; i++) {
         // sanitize numbers and apply transforms based on axes.type
-        xc = xaxis.d2l(x[i]) * scaleFactor[0] - offset[0];
-        yc = yaxis.d2l(y[i]) * scaleFactor[1] - offset[1];
-        zc = zaxis.d2l(z[i]) * scaleFactor[2] - offset[2];
+        xc = xaxis.d2l(x[i]) * scaleFactor[0];
+        yc = yaxis.d2l(y[i]) * scaleFactor[1];
+        zc = zaxis.d2l(z[i]) * scaleFactor[2];
 
         points[i] = [xc, yc, zc];
     }

src/traces/surface/convert.js

@@ -52,9 +52,9 @@ proto.handlePick = function(selection) {
 
     var sceneLayout = this.scene.fullSceneLayout;
     selection.dataCoordinate = [
-      sceneLayout.xaxis.d2l(traceCoordinate[0])*this.scene.dataScale[0] - this.scene.dataCenter[0],
-      sceneLayout.yaxis.d2l(traceCoordinate[1])*this.scene.dataScale[1] - this.scene.dataCenter[1],
-      sceneLayout.zaxis.d2l(traceCoordinate[2])*this.scene.dataScale[2] - this.scene.dataCenter[2]
+      sceneLayout.xaxis.d2l(traceCoordinate[0])*this.scene.dataScale[0],
+      sceneLayout.yaxis.d2l(traceCoordinate[1])*this.scene.dataScale[1],
+      sceneLayout.zaxis.d2l(traceCoordinate[2])*this.scene.dataScale[2]
     ];
 
     var text = this.data.text;
@@ -165,7 +165,6 @@ proto.update = function(data) {
         yaxis = sceneLayout.yaxis,
         zaxis = sceneLayout.zaxis,
         scaleFactor = scene.dataScale,
-        offset = scene.dataCenter,
         xlen = z[0].length,
         ylen = z.length,
         coords = [
@@ -188,30 +187,30 @@ proto.update = function(data) {
      * which is the transpose of 'gl-surface-plot'.
      */
     fill(coords[2], function(row, col) {
-        return zaxis.d2l(z[col][row]) * scaleFactor[2]  - offset[2];
+        return zaxis.d2l(z[col][row]) * scaleFactor[2];
     });
 
     // coords x
     if (Array.isArray(x[0])) {
         fill(xc, function(row, col) {
-            return xaxis.d2l(x[col][row]) * scaleFactor[0] - offset[0];
+            return xaxis.d2l(x[col][row]) * scaleFactor[0];
         });
     } else {
         // ticks x
         fill(xc, function(row) {
-            return xaxis.d2l(x[row]) * scaleFactor[0] - offset[0];
+            return xaxis.d2l(x[row]) * scaleFactor[0];
         });
     }
 
     // coords y
     if (Array.isArray(y[0])) {
         fill(yc, function(row, col) {
-            return yaxis.d2l(y[col][row]) * scaleFactor[1] - offset[1];
+            return yaxis.d2l(y[col][row]) * scaleFactor[1];
         });
     } else {
         // ticks y
         fill(yc, function(row, col) {
-            return yaxis.d2l(y[col]) * scaleFactor[1] - offset[1];
+            return yaxis.d2l(y[col]) * scaleFactor[1];
         });
     }