Merge pull request #2641 from plotly/cone-traces

3D cone traces

Author: etpinard

lib/cone.js

@@ -0,0 +1,11 @@
+/**
+* Copyright 2012-2018, Plotly, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+
+'use strict';
+
+module.exports = require('../src/traces/cone');

lib/index-gl3d.js

@@ -13,7 +13,8 @@ var Plotly = require('./core');
 Plotly.register([
     require('./scatter3d'),
     require('./surface'),
-    require('./mesh3d')
+    require('./mesh3d'),
+    require('./cone')
 ]);
 
 module.exports = Plotly;

lib/index.js

@@ -26,6 +26,7 @@ Plotly.register([
     require('./scatter3d'),
     require('./surface'),
     require('./mesh3d'),
+    require('./cone'),
 
     require('./scattergeo'),
     require('./choropleth'),

package-lock.json

@@ -70,6 +70,7 @@
     "es6-promise": "^3.0.2",
     "fast-isnumeric": "^1.1.1",
     "font-atlas-sdf": "^1.3.3",
+    "gl-cone3d": "^v1.0.0",
     "gl-contour2d": "^1.1.4",
     "gl-error3d": "^1.0.7",
     "gl-heatmap2d": "^1.0.4",

package.json

@@ -10,6 +10,7 @@
 'use strict';
 
 var isNumeric = require('fast-isnumeric');
+var tinycolor = require('tinycolor2');
 var rgba = require('color-normalize');
 
 var Colorscale = require('../components/colorscale');
@@ -85,4 +86,21 @@ function formatColor(containerIn, opacityIn, len) {
     return colorOut;
 }
 
-module.exports = formatColor;
+function parseColorScale(colorscale, alpha) {
+    if(alpha === undefined) alpha = 1;
+
+    return colorscale.map(function(elem) {
+        var index = elem[0];
+        var color = tinycolor(elem[1]);
+        var rgb = color.toRgb();
+        return {
+            index: index,
+            rgb: [rgb.r, rgb.g, rgb.b, alpha]
+        };
+    });
+}
+
+module.exports = {
+    formatColor: formatColor,
+    parseColorScale: parseColorScale
+};

src/lib/gl_format_color.js

@@ -71,28 +71,53 @@ function render(scene) {
         trace = lastPicked.data;
         var ptNumber = selection.index;
         var hoverinfo = Fx.castHoverinfo(trace, scene.fullLayout, ptNumber);
+        var hoverinfoParts = hoverinfo.split('+');
+        var isHoverinfoAll = hoverinfo === 'all';
 
-        var xVal = formatter('xaxis', selection.traceCoordinate[0]),
-            yVal = formatter('yaxis', selection.traceCoordinate[1]),
-            zVal = formatter('zaxis', selection.traceCoordinate[2]);
+        var xVal = formatter('xaxis', selection.traceCoordinate[0]);
+        var yVal = formatter('yaxis', selection.traceCoordinate[1]);
+        var zVal = formatter('zaxis', selection.traceCoordinate[2]);
 
-        if(hoverinfo !== 'all') {
-            var hoverinfoParts = hoverinfo.split('+');
+        if(!isHoverinfoAll) {
             if(hoverinfoParts.indexOf('x') === -1) xVal = undefined;
             if(hoverinfoParts.indexOf('y') === -1) yVal = undefined;
             if(hoverinfoParts.indexOf('z') === -1) zVal = undefined;
             if(hoverinfoParts.indexOf('text') === -1) selection.textLabel = undefined;
             if(hoverinfoParts.indexOf('name') === -1) lastPicked.name = undefined;
         }
 
+        var tx;
+
+        if(trace.type === 'cone') {
+            var coneTx = [];
+            if(isHoverinfoAll || hoverinfoParts.indexOf('u') !== -1) {
+                coneTx.push('u: ' + formatter('xaxis', selection.traceCoordinate[3]));
+            }
+            if(isHoverinfoAll || hoverinfoParts.indexOf('v') !== -1) {
+                coneTx.push('v: ' + formatter('yaxis', selection.traceCoordinate[4]));
+            }
+            if(isHoverinfoAll || hoverinfoParts.indexOf('w') !== -1) {
+                coneTx.push('w: ' + formatter('zaxis', selection.traceCoordinate[5]));
+            }
+            if(isHoverinfoAll || hoverinfoParts.indexOf('norm') !== -1) {
+                coneTx.push('norm: ' + selection.traceCoordinate[6].toPrecision(3));
+            }
+            if(selection.textLabel) {
+                coneTx.push(selection.textLabel);
+            }
+            tx = coneTx.join('<br>');
+        } else {
+            tx = selection.textLabel;
+        }
+
         if(scene.fullSceneLayout.hovermode) {
             Fx.loneHover({
                 x: (0.5 + 0.5 * pdata[0] / pdata[3]) * width,
                 y: (0.5 - 0.5 * pdata[1] / pdata[3]) * height,
                 xLabel: xVal,
                 yLabel: yVal,
                 zLabel: zVal,
-                text: selection.textLabel,
+                text: tx,
                 name: lastPicked.name,
                 color: Fx.castHoverOption(trace, ptNumber, 'bgcolor') || lastPicked.color,
                 borderColor: Fx.castHoverOption(trace, ptNumber, 'bordercolor'),
@@ -306,41 +331,44 @@ proto.recoverContext = function() {
 
 var axisProperties = [ 'xaxis', 'yaxis', 'zaxis' ];
 
-function coordinateBound(axis, coord, len, d, bounds, calendar) {
-    var x;
-    if(!Lib.isArrayOrTypedArray(coord)) {
-        bounds[0][d] = Math.min(bounds[0][d], 0);
-        bounds[1][d] = Math.max(bounds[1][d], len - 1);
-        return;
-    }
+function computeTraceBounds(scene, trace, bounds) {
+    var sceneLayout = scene.fullSceneLayout;
 
-    for(var i = 0; i < (len || coord.length); ++i) {
-        if(Lib.isArrayOrTypedArray(coord[i])) {
-            for(var j = 0; j < coord[i].length; ++j) {
-                x = axis.d2l(coord[i][j], 0, calendar);
-                if(!isNaN(x) && isFinite(x)) {
-                    bounds[0][d] = Math.min(bounds[0][d], x);
-                    bounds[1][d] = Math.max(bounds[1][d], x);
+    for(var d = 0; d < 3; d++) {
+        var axisName = axisProperties[d];
+        var axLetter = axisName.charAt(0);
+        var ax = sceneLayout[axisName];
+        var coords = trace[axLetter];
+        var calendar = trace[axLetter + 'calendar'];
+        var len = trace['_' + axLetter + 'length'];
+
+        if(!Lib.isArrayOrTypedArray(coords)) {
+            bounds[0][d] = Math.min(bounds[0][d], 0);
+            bounds[1][d] = Math.max(bounds[1][d], len - 1);
+        } else {
+            var v;
+
+            for(var i = 0; i < (len || coords.length); i++) {
+                if(Lib.isArrayOrTypedArray(coords[i])) {
+                    for(var j = 0; j < coords[i].length; ++j) {
+                        v = ax.d2l(coords[i][j], 0, calendar);
+                        if(!isNaN(v) && isFinite(v)) {
+                            bounds[0][d] = Math.min(bounds[0][d], v);
+                            bounds[1][d] = Math.max(bounds[1][d], v);
+                        }
+                    }
+                } else {
+                    v = ax.d2l(coords[i], 0, calendar);
+                    if(!isNaN(v) && isFinite(v)) {
+                        bounds[0][d] = Math.min(bounds[0][d], v);
+                        bounds[1][d] = Math.max(bounds[1][d], v);
+                    }
                 }
             }
         }
-        else {
-            x = axis.d2l(coord[i], 0, calendar);
-            if(!isNaN(x) && isFinite(x)) {
-                bounds[0][d] = Math.min(bounds[0][d], x);
-                bounds[1][d] = Math.max(bounds[1][d], x);
-            }
-        }
     }
 }
 
-function computeTraceBounds(scene, trace, bounds) {
-    var sceneLayout = scene.fullSceneLayout;
-    coordinateBound(sceneLayout.xaxis, trace.x, trace._xlength, 0, bounds, trace.xcalendar);
-    coordinateBound(sceneLayout.yaxis, trace.y, trace._ylength, 1, bounds, trace.ycalendar);
-    coordinateBound(sceneLayout.zaxis, trace.z, trace._zlength, 2, bounds, trace.zcalendar);
-}
-
 proto.plot = function(sceneData, fullLayout, layout) {
 
     // Save parameters
@@ -477,9 +505,12 @@ proto.plot = function(sceneData, fullLayout, layout) {
             var axLetter = axis._name.charAt(0);
 
             for(j = 0; j < objects.length; j++) {
-                var objBounds = objects[j].bounds;
-                sceneBounds[0][i] = Math.min(sceneBounds[0][i], objBounds[0][i] / dataScale[i]);
-                sceneBounds[1][i] = Math.max(sceneBounds[1][i], objBounds[1][i] / dataScale[i]);
+                var obj = objects[j];
+                var objBounds = obj.bounds;
+                var pad = obj._trace.data._pad || 0;
+
+                sceneBounds[0][i] = Math.min(sceneBounds[0][i], objBounds[0][i] / dataScale[i] - pad);
+                sceneBounds[1][i] = Math.max(sceneBounds[1][i], objBounds[1][i] / dataScale[i] + pad);
             }
 
             for(j = 0; j < annotations.length; j++) {