3D streamtube traces

lib/index-gl3d.js

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

lib/index.js

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

lib/streamtube.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/streamtube');

package.json

@@ -83,6 +83,7 @@
     "gl-select-box": "^1.0.2",
     "gl-spikes2d": "^1.0.1",
     "gl-surface3d": "^1.3.4",
+    "gl-streamtube3d": "[email protected]:gl-vis/gl-streamtube3d#ad17c0af85eda664297d881d5743ed19b7509dc0",
     "glslify": "^6.1.1",
     "has-hover": "^1.0.1",
     "has-passive-events": "^1.0.0",

src/lib/zip3.js

@@ -0,0 +1,17 @@
+/**
+* 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 = function zip3(x, y, z) {
+    var result = new Array(x.length);
+    for(var i = 0; i < x.length; i++) {
+        result[i] = [x[i], y[i], z[i]];
+    }
+    return result;
+};

src/plots/gl3d/scene.js

@@ -88,24 +88,27 @@ function render(scene) {
 
         var tx;
 
-        if(trace.type === 'cone') {
-            var coneTx = [];
+        if(trace.type === 'cone' || trace.type === 'streamtube') {
+            var vectorTx = [];
             if(isHoverinfoAll || hoverinfoParts.indexOf('u') !== -1) {
-                coneTx.push('u: ' + formatter('xaxis', selection.traceCoordinate[3]));
+                vectorTx.push('u: ' + formatter('xaxis', selection.traceCoordinate[3]));
             }
             if(isHoverinfoAll || hoverinfoParts.indexOf('v') !== -1) {
-                coneTx.push('v: ' + formatter('yaxis', selection.traceCoordinate[4]));
+                vectorTx.push('v: ' + formatter('yaxis', selection.traceCoordinate[4]));
             }
             if(isHoverinfoAll || hoverinfoParts.indexOf('w') !== -1) {
-                coneTx.push('w: ' + formatter('zaxis', selection.traceCoordinate[5]));
+                vectorTx.push('w: ' + formatter('zaxis', selection.traceCoordinate[5]));
             }
             if(isHoverinfoAll || hoverinfoParts.indexOf('norm') !== -1) {
-                coneTx.push('norm: ' + selection.traceCoordinate[6].toPrecision(3));
+                vectorTx.push('norm: ' + selection.traceCoordinate[6].toPrecision(3));
+            }
+            if(isHoverinfoAll || hoverinfoParts.indexOf('divergence') !== -1) {
+                vectorTx.push('divergence: ' + selection.traceCoordinate[7].toPrecision(3));
             }
             if(selection.textLabel) {
-                coneTx.push(selection.textLabel);
+                vectorTx.push(selection.textLabel);
             }
-            tx = coneTx.join('<br>');
+            tx = vectorTx.join('<br>');
         } else {
             tx = selection.textLabel;
         }
@@ -130,6 +133,7 @@ function render(scene) {
             });
         }
 
+        // TODO not sure if streamtube x/y/z should be emitted as x/y/z
         var pointData = {
             x: selection.traceCoordinate[0],
             y: selection.traceCoordinate[1],
@@ -140,6 +144,10 @@ function render(scene) {
             pointNumber: ptNumber
         };
 
+        if(trace._module.eventData) {
+            pointData = trace._module.eventData(pointData, selection, trace, {}, ptNumber);
+        }
+
         Fx.appendArrayPointValue(pointData, trace, ptNumber);
 
         var eventData = {points: [pointData]};
@@ -448,7 +456,13 @@ proto.plot = function(sceneData, fullLayout, layout) {
         }
         trace = this.traces[data.uid];
         if(trace) {
-            trace.update(data);
+            if(trace.data.type === data.type) {
+                trace.update(data);
+            } else {
+                trace.dispose();
+                trace = data._module.plot(this, data);
+                this.traces[data.uid] = trace;
+            }
         } else {
             trace = data._module.plot(this, data);
             this.traces[data.uid] = trace;

src/traces/cone/convert.js

@@ -14,6 +14,7 @@ var createConeMesh = require('gl-cone3d').createConeMesh;
 
 var simpleMap = require('../../lib').simpleMap;
 var parseColorScale = require('../../lib/gl_format_color').parseColorScale;
+var zip3 = require('../../lib/zip3');
 
 function Cone(scene, uid) {
     this.scene = scene;
@@ -52,14 +53,6 @@ proto.handlePick = function(selection) {
     }
 };
 
-function zip3(x, y, z) {
-    var result = new Array(x.length);
-    for(var i = 0; i < x.length; i++) {
-        result[i] = [x[i], y[i], z[i]];
-    }
-    return result;
-}
-
 var axisName2scaleIndex = {xaxis: 0, yaxis: 1, zaxis: 2};
 var sizeMode2sizeKey = {scaled: 'coneSize', absolute: 'absoluteConeSize'};
 var anchor2coneOffset = {tip: 1, tail: 0, cm: 0.25, center: 0.5};

src/traces/mesh3d/convert.js

@@ -16,6 +16,7 @@ var convexHull = require('convex-hull');
 
 var parseColorScale = require('../../lib/gl_format_color').parseColorScale;
 var str2RgbaArray = require('../../lib/str2rgbarray');
+var zip3 = require('../../lib/zip3');
 
 function Mesh3DTrace(scene, mesh, uid) {
     this.scene = scene;
@@ -54,14 +55,6 @@ function parseColorArray(colors) {
     return colors.map(str2RgbaArray);
 }
 
-function zip3(x, y, z) {
-    var result = new Array(x.length);
-    for(var i = 0; i < x.length; ++i) {
-        result[i] = [x[i], y[i], z[i]];
-    }
-    return result;
-}
-
 proto.update = function(data) {
     var scene = this.scene,
         layout = scene.fullSceneLayout;

src/traces/streamtube/attributes.js

@@ -0,0 +1,151 @@
+/**
+* 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';
+
+var colorAttrs = require('../../components/colorscale/color_attributes');
+var colorscaleAttrs = require('../../components/colorscale/attributes');
+var colorbarAttrs = require('../../components/colorbar/attributes');
+var mesh3dAttrs = require('../mesh3d/attributes');
+var baseAttrs = require('../../plots/attributes');
+
+var extendFlat = require('../../lib/extend').extendFlat;
+
+var attrs = {
+    x: {
+        valType: 'data_array',
+        role: 'info',
+        editType: 'calc+clearAxisTypes',
+        description: 'Sets the x coordinates of the vector field.'
+    },
+    y: {
+        valType: 'data_array',
+        role: 'info',
+        editType: 'calc+clearAxisTypes',
+        description: 'Sets the y coordinates of the vector field.'
+    },
+    z: {
+        valType: 'data_array',
+        role: 'info',
+        editType: 'calc+clearAxisTypes',
+        description: 'Sets the z coordinates of the vector field.'
+    },
+
+    u: {
+        valType: 'data_array',
+        editType: 'calc',
+        description: 'Sets the x components of the vector field.'
+    },
+    v: {
+        valType: 'data_array',
+        editType: 'calc',
+        description: 'Sets the y components of the vector field.'
+    },
+    w: {
+        valType: 'data_array',
+        editType: 'calc',
+        description: 'Sets the z components of the vector field.'
+    },
+
+    startx: {
+        valType: 'data_array',
+        editType: 'calc',
+        description: [
+            'Sets the x components of the starting position of the streamtubes',
+        ].join(' ')
+    },
+    starty: {
+        valType: 'data_array',
+        editType: 'calc',
+        description: [
+            'Sets the y components of the starting position of the streamtubes',
+        ].join(' ')
+    },
+    startz: {
+        valType: 'data_array',
+        editType: 'calc',
+        description: [
+            'Sets the z components of the starting position of the streamtubes',
+        ].join(' ')
+    },
+
+    maxdisplayed: {
+        valType: 'integer',
+        min: 0,
+        dflt: 1000,
+        role: 'info',
+        editType: 'calc',
+        description: [
+            'The maximum number of displayed segments in a streamtube.'
+        ].join(' ')
+    },
+
+    // TODO
+    //
+    // Should add 'absolute' (like cone traces have), but currently gl-streamtube3d's
+    // `absoluteTubeSize` doesn't behave well enough for our needs.
+    //
+    // 'fixed' would be a nice addition to plot stream 'lines', see
+    // https://github.com/plotly/plotly.js/commit/812be20750e21e0a1831975001c248d365850f73#r29129877
+    //
+    // sizemode: {
+    //     valType: 'enumerated',
+    //     values: ['scaled', 'absolute', 'fixed'],
+    //     dflt: 'scaled',
+    //     role: 'info',
+    //     editType: 'calc',
+    //     description: [
+    //         'Sets the mode by which the streamtubes are sized.'
+    //     ].join(' ')
+    // },
+
+    sizeref: {
+        valType: 'number',
+        role: 'info',
+        editType: 'calc',
+        min: 0,
+        dflt: 1,
+        description: [
+            'The scaling factor for the streamtubes.',
+            'The default is 1, which avoids two max divergence tubes from touching',
+            'at adjacent starting positions.'
+        ].join(' ')
+    },
+
+    text: {
+        valType: 'string',
+        role: 'info',
+        dflt: '',
+        editType: 'calc',
+        description: [
+            'Sets a text element associated with this trace.',
+            'If trace `hoverinfo` contains a *text* flag,',
+            'this text element will be seen in all hover labels.',
+            'Note that streamtube traces do not support array `text` values.'
+        ].join(' ')
+    }
+};
+
+extendFlat(attrs, colorAttrs('', 'calc', true), {
+    showscale: colorscaleAttrs.showscale,
+    colorbar: colorbarAttrs
+});
+delete attrs.color;
+
+var fromMesh3d = ['opacity', 'lightposition', 'lighting'];
+fromMesh3d.forEach(function(k) {
+    attrs[k] = mesh3dAttrs[k];
+});
+
+attrs.hoverinfo = extendFlat({}, baseAttrs.hoverinfo, {
+    editType: 'calc',
+    flags: ['x', 'y', 'z', 'u', 'v', 'w', 'norm', 'divergence', 'text', 'name'],
+    dflt: 'x+y+z+norm+text+name'
+});
+
+module.exports = attrs;