Volume - new gl3d trace

lib/index.js

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

lib/volume4d.js

@@ -0,0 +1,11 @@
+/**
+* Copyright 2012-2019, 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/volume4d');

package.json

@@ -77,7 +77,7 @@
     "gl-heatmap2d": "^1.0.5",
     "gl-line3d": "^1.1.8",
     "gl-mat4": "^1.2.0",
-    "gl-mesh3d": "^2.0.7",
+    "gl-mesh3d": "git://github.com/gl-vis/gl-mesh3d.git#2ad87fb6d6329638a975a1db003b798e9698b930",
     "gl-plot2d": "^1.4.2",
     "gl-plot3d": "^1.6.3",
     "gl-pointcloud2d": "^1.0.2",

src/components/opacityscale/attributes.js

@@ -0,0 +1,59 @@
+/**
+* Copyright 2012-2019, 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 palettes = require('./scales.js').scales;
+var paletteStr = Object.keys(palettes);
+
+/**
+ * Make opacityscale attribute declarations for
+ *
+ * - opacityscale,
+ *
+ * @param {string} context (dflt: '', i.e. from trace root):
+ *     the container this is in ('', *marker*, *marker.line* etc)
+ *
+ * @param {object} opts:
+ *   - opacityscaleDflt {string}:
+ *     overrides the opacityscale dflt
+ *
+ *   - editTypeOverride {boolean} (dflt: ''):
+ *     most of these attributes already require a recalc, but the ones that do not
+ *     have editType *style* or *plot* unless you override (presumably with *calc*)
+ *
+ * @return {object}
+ */
+module.exports = function opacityScaleAttrs(context, opts) {
+    context = context || '';
+    opts = opts || {};
+
+    var opacityscaleDflt = typeof opts.opacityscaleDflt === 'string' ? palettes[opts.opacityscaleDflt] : null;
+
+    var attrs = {};
+
+    attrs.opacityscale = {
+        valType: 'opacityscale',
+        role: 'style',
+        editType: 'calc',
+        dflt: opacityscaleDflt,
+        description: [
+            'Sets the opacityscale.',
+            ' The opacityscale must be an array containing',
+            ' arrays mapping a normalized value to an opacity value.',
+            ' At minimum, a mapping for the lowest (0) and highest (1)',
+            ' values are required. For example,',
+            ' `[[0, 1], [0.5, 0.2], [1, 1]]` means that higher/lower values would have',
+            ' higher opacity values and those in the middle would be more transparent',
+            ' Alternatively, `opacityscale` may be a palette name string',
+            ' of the following list: ' + paletteStr + '.'
+        ].join('')
+    };
+
+    return attrs;
+};

src/components/opacityscale/defaults.js

@@ -0,0 +1,15 @@
+/**
+* Copyright 2012-2019, 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 opacityScaleDefaults(traceIn, traceOut, layout, coerce, opts) {
+    var prefix = opts.prefix;
+
+    coerce(prefix + 'opacityscale');
+};

src/components/opacityscale/scales.js

@@ -0,0 +1,98 @@
+/**
+* Copyright 2012-2019, 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';
+
+function createWave(n, minOpacity) {
+    var arr = [];
+    var steps = 32; // Max: 256
+    for(var i = 0; i < steps; i++) {
+        var u = i / (steps - 1);
+        var v = minOpacity + (1 - minOpacity) * (1 - Math.pow(Math.sin(n * u * Math.PI), 2));
+        arr.push([
+            u,
+            Math.max(1, Math.min(0, v))
+        ]);
+    }
+    return arr;
+}
+
+var min = 0.2;
+
+var scales = {
+    'max': [
+        [0, min], [1, 1]
+    ],
+
+    'min': [
+        [0, 1], [1, min]
+    ],
+
+    'extremes': createWave(1, min),
+
+    'zigzag': createWave(8, min)
+};
+
+var defaultScale = scales.uniform;
+
+function getScale(scl, dflt) {
+    if(!dflt) dflt = defaultScale;
+    if(!scl) return dflt;
+
+    function parseScale() {
+        try {
+            scl = scales[scl] || JSON.parse(scl);
+        } catch(e) {
+            scl = dflt;
+        }
+    }
+
+    if(typeof scl === 'string') {
+        parseScale();
+        // occasionally scl is double-JSON encoded...
+        if(typeof scl === 'string') parseScale();
+    }
+
+    if(!isValidScaleArray(scl)) return dflt;
+    return scl;
+}
+
+function isValidScaleArray(scl) {
+    var highestVal = 0;
+
+    if(!Array.isArray(scl) || scl.length < 2) return false;
+
+    if(!scl[0] || !scl[scl.length - 1]) return false;
+
+    if(+scl[0][0] !== 0 || +scl[scl.length - 1][0] !== 1) return false;
+
+    for(var i = 0; i < scl.length; i++) {
+        var si = scl[i];
+
+        if(si.length !== 2 || +si[0] < highestVal) {
+            return false;
+        }
+
+        highestVal = +si[0];
+    }
+
+    return true;
+}
+
+function isValidScale(scl) {
+    if(scales[scl] !== undefined) return true;
+    else return isValidScaleArray(scl);
+}
+
+module.exports = {
+    scales: scales,
+    defaultScale: defaultScale,
+
+    get: getScale,
+    isValid: isValidScale
+};

src/lib/coerce.js

@@ -12,7 +12,8 @@ var isNumeric = require('fast-isnumeric');
 var tinycolor = require('tinycolor2');
 
 var baseTraceAttrs = require('../plots/attributes');
-var scales = require('../components/colorscale/scales');
+var colorscales = require('../components/colorscale/scales');
+var opacityscales = require('../components/opacityscale/scales');
 var DESELECTDIM = require('../constants/interactions').DESELECTDIM;
 
 var nestedProperty = require('./nested_property');
@@ -164,7 +165,7 @@ exports.valObjectMeta = {
     colorscale: {
         description: [
             'A Plotly colorscale either picked by a name:',
-            '(any of', Object.keys(scales.scales).join(', '), ')',
+            '(any of', Object.keys(colorscales.scales).join(', '), ')',
             'customized as an {array} of 2-element {arrays} where',
             'the first element is the normalized color level value',
             '(starting at *0* and ending at *1*),',
@@ -173,7 +174,22 @@ exports.valObjectMeta = {
         requiredOpts: [],
         otherOpts: ['dflt'],
         coerceFunction: function(v, propOut, dflt) {
-            propOut.set(scales.get(v, dflt));
+            propOut.set(colorscales.get(v, dflt));
+        }
+    },
+    opacityscale: {
+        description: [
+            'A Plotly opacityscale either picked by a name:',
+            '(any of', Object.keys(opacityscales.scales).join(', '), ')',
+            'customized as an {array} of 2-element {arrays} where',
+            'the first element is the normalized opacity level value',
+            '(starting at *0* and ending at *1*),',
+            'and the second item is a valid opacity value between 0 and 1.'
+        ].join(' '),
+        requiredOpts: [],
+        otherOpts: ['dflt'],
+        coerceFunction: function(v, propOut, dflt) {
+            propOut.set(opacityscales.get(v, dflt));
         }
     },
     angle: {

src/plots/gl3d/scene.js

@@ -110,7 +110,7 @@ function render(scene) {
                 vectorTx.push(selection.textLabel);
             }
             tx = vectorTx.join('<br>');
-        } else if(trace.type === 'isosurface') {
+        } else if(trace.type === 'isosurface' || trace.type === 'volume4d') {
             vectorTx.push('value: ' + Axes.tickText(scene.mockAxis, scene.mockAxis.d2l(selection.traceCoordinate[3]), 'hover').text);
             if(selection.textLabel) {
                 vectorTx.push(selection.textLabel);

src/traces/isosurface/attributes.js

@@ -9,8 +9,8 @@
 'use strict';
 
 var colorscaleAttrs = require('../../components/colorscale/attributes');
+var opacityscaleAttrs = require('../../components/opacityscale/attributes');
 var colorbarAttrs = require('../../components/colorbar/attributes');
-var surfaceAtts = require('../surface/attributes');
 var meshAttrs = require('../mesh3d/attributes');
 var baseAttrs = require('../../plots/attributes');
 
@@ -225,9 +225,13 @@ var attrs = module.exports = overrideAll(extendFlat({
             'If trace `hoverinfo` contains a *text* flag and *hovertext* is not set,',
             'these elements will be seen in the hover labels.'
         ].join(' ')
-    },
+    }
 },
 
+opacityscaleAttrs('', {
+    editTypeOverride: 'calc'
+}),
+
 colorscaleAttrs('', {
     colorAttr: '`value`',
     showScaleDflt: true,
@@ -236,34 +240,11 @@ colorscaleAttrs('', {
 
     colorbar: colorbarAttrs,
 
-    // Flat shaded mode
-    flatshading: {
-        valType: 'boolean',
-        role: 'style',
-        dflt: false,
-        description: [
-            'Determines whether or not normal smoothing is applied to the isosurfaces,',
-            'creating isosurfaces with an angular, low-poly look via flat reflections.'
-        ].join(' ')
-    },
-
-    contour: {
-        show: extendFlat({}, surfaceAtts.contours.x.show, {
-            description: [
-                'Sets whether or not dynamic contours are shown on hover.',
-                'Contours are more useful when hovering on caps and slices.'
-            ].join(' ')
-        }),
-        color: surfaceAtts.contours.x.color,
-        width: surfaceAtts.contours.x.width
-    },
-
-    lightposition: {
-        x: extendFlat({}, surfaceAtts.lightposition.x, {dflt: 1e5}),
-        y: extendFlat({}, surfaceAtts.lightposition.y, {dflt: 1e5}),
-        z: extendFlat({}, surfaceAtts.lightposition.z, {dflt: 0})
-    },
+    opacity: meshAttrs.opacity,
+    lightposition: meshAttrs.lightposition,
     lighting: meshAttrs.lighting,
+    flatshading: meshAttrs.flatshading,
+    contour: meshAttrs.contour,
 
     hoverinfo: extendFlat({}, baseAttrs.hoverinfo)
 }), 'calc', 'nested');