parcoords squashed

Author: monfera

lib/index.js

@@ -18,6 +18,7 @@ Plotly.register([
     require('./histogram'),
     require('./histogram2d'),
     require('./histogram2dcontour'),
+    require('./parcoords'),
     require('./pie'),
     require('./contour'),
     require('./scatterternary'),

lib/parcoords.js

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

package.json

@@ -79,10 +79,11 @@
     "mapbox-gl": "^0.22.0",
     "mouse-change": "^1.1.1",
     "mouse-wheel": "^1.0.2",
-    "ndarray": "^1.0.16",
+    "ndarray": "^1.0.18",
     "ndarray-fill": "^1.0.1",
     "ndarray-homography": "^1.0.0",
     "ndarray-ops": "^1.2.2",
+    "regl": "^1.3.0",
     "right-now": "^1.0.0",
     "robust-orientation": "^1.1.3",
     "sane-topojson": "^2.0.0",
@@ -103,6 +104,7 @@
     "fs-extra": "^1.0.0",
     "fuse.js": "^2.2.0",
     "glob": "^7.0.0",
+    "glslify": "^4.0.0",
     "gzip-size": "^3.0.0",
     "image-size": "^0.5.0",
     "jasmine-core": "^2.4.1",

src/components/updatemenus/defaults.js

@@ -62,6 +62,8 @@ function menuDefaults(menuIn, menuOut, layoutOut) {
     coerce('borderwidth');
 }
 
+// todo consider unifying it with other similar array coercions
+// - though `Array.isArray(buttonIn.args)` is quite spedific...
 function buttonsDefaults(menuIn, menuOut) {
     var buttonsIn = menuIn.buttons || [],
         buttonsOut = menuOut.buttons = [];

src/traces/heatmap/colorbar.js

@@ -16,7 +16,7 @@ var Plots = require('../../plots/plots');
 var Colorscale = require('../../components/colorscale');
 var drawColorbar = require('../../components/colorbar/draw');
 
-
+// TODO unify parcoords, scatter and heatmap colorbar
 module.exports = function colorbar(gd, cd) {
     var trace = cd[0].trace,
         cbId = 'cb' + trace.uid,

src/traces/parcoords/attributes.js

@@ -0,0 +1,266 @@
+/**
+* Copyright 2012-2016, 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 colorAttributes = require('../../components/colorscale/color_attributes');
+var colorbarAttrs = require('../../components/colorbar/attributes');
+
+var extendFlat = require('../../lib/extend').extendFlat;
+
+/*
+todo comments (some of them relating to items that should be unexposed anyway):
+- `domain` should be DRYed up across other plots
+- add attribute to `dimensions` for switching dimensions on/off
+- add attribute to `dimensions` for initial filter domain
+- clarify what the actual use of `_isLinkedToArray: 'dimension'` - esp. the value - is below
+- add attribute for color clamping
+- switch to ploty standard color notation rather than RGB tuple
+- switch to 0..1 for opacity rather than 0..255
+- tie pixelratio to window.devicePixelRatio in `defaults.js`
+- consider if we need a `focusopacity` attribute besides focusalphablending; making settings more symmetric between
+      focus and context
+- hardcode verticalpadding
+- this minor but ergonomic `integerpadding` isn't fully working yet - either finish it or remove it
+*/
+
+module.exports = {
+
+    domain: {
+        x: {
+            valType: 'info_array',
+            role: 'info',
+            items: [
+                {valType: 'number', min: 0, max: 1},
+                {valType: 'number', min: 0, max: 1}
+            ],
+            dflt: [0, 1],
+            description: [
+                'Sets the horizontal domain of this `parcoords` trace',
+                '(in plot fraction).'
+            ].join(' ')
+        },
+        y: {
+            valType: 'info_array',
+            role: 'info',
+            items: [
+                {valType: 'number', min: 0, max: 1},
+                {valType: 'number', min: 0, max: 1}
+            ],
+            dflt: [0, 1],
+            description: [
+                'Sets the vertical domain of this `parcoords` trace',
+                '(in plot fraction).'
+            ].join(' ')
+        }
+    },
+
+    dimensions: {
+        _isLinkedToArray: 'dimension',
+        id: {
+            valType: 'string',
+            role: 'info',
+            description: 'Identifier of a dimension. Must be a unique string across all dimensions.'
+        },
+        label: {
+            valType: 'string',
+            role: 'info',
+            description: 'The shown name of the dimension.'
+        },
+        integer: {
+            valType: 'boolean',
+            dflt: false,
+            role: 'info',
+            description: 'The shown name of the dimension.'
+        },
+        values: {
+            valType: 'data_array',
+            role: 'info',
+            description: [
+                'Dimension values. `values[n]` represents the value of the `n`th point in the dataset,',
+                'therefore the `values` vector for all dimensions must be the same (longer vectors',
+                'will be truncated). Each value must be a finite number.'
+            ].join(' ')
+        },
+        description: 'The dimensions (variables) of the parallel coordinates chart.'
+    },
+
+    tickdistance: {
+        valType: 'number',
+        dflt: 50,
+        min: 32,
+        role: 'style',
+        description: 'The desired approximate tick distance (in pixels) between axis ticks on an axis.'
+    },
+
+    line: extendFlat({},
+        colorAttributes('line'),
+        {
+            showscale: {
+                valType: 'boolean',
+                role: 'info',
+                dflt: false,
+                description: [
+                    'Has an effect only if `marker.color` is set to a numerical array.',
+                    'Determines whether or not a colorbar is displayed.'
+                ].join(' ')
+            },
+            colorbar: colorbarAttrs
+        }
+    ),
+
+    lines: {
+        contextcolor: {
+            valType: 'data_array',
+            dflt: [0, 0, 0],
+            role: 'style',
+            description: 'Color of the context line layer as an RGB triplet where each number is 0..255.'
+        },
+
+        contextopacity: {
+            valType: 'number',
+            dflt: 16,
+            min: 0,
+            max: 255,
+            role: 'style',
+            description: 'Opacity of the context lines, on a scale of 0 (invisible) to 255 (fully opaque).'
+        },
+
+        pixelratio: {
+            valType: 'number',
+            dflt: 1,
+            min: 0.25,
+            max: 4,
+            role: 'style',
+            description: 'Line rendering pixel ratio. A lower value yields faster rendering but blockier lines.'
+        },
+
+        blocklinecount: {
+            valType: 'number',
+            dflt: 5000,
+            min: 1,
+            role: 'info',
+            description: [
+                'The number of lines rendered in one 16ms rendering frame. Use 2000-5000 on low-end hardware to remain',
+                'responsive, and 10000 .. 100000 on strong hardware for faster rendering.'
+            ].join(' ')
+        },
+
+        focusalphablending: {
+            valType: 'boolean',
+            dflt: false,
+            role: 'style',
+            description: [
+                'By default, the rendered lines are opaque. Setting it to `true` is necessary if opacity is needed.'
+            ].join(' ')
+        },
+
+        verticalpadding: {
+            valType: 'number',
+            dflt: 2,
+            min: 0,
+            max: 4,
+            role: 'style',
+            description: 'Lines have thickness, and without padding, horizontal lines at extreme values appear thinner.'
+        },
+
+        integerpadding: {
+            valType: 'number',
+            dflt: 0,
+            min: 0,
+            max: 1,
+            role: 'style',
+            description: 'Setting it to `1` offsets the extreme points on integer axes by half pitch.'
+        }
+    },
+
+    filterbar: {
+
+        width: {
+            valType: 'number',
+            dflt: 4,
+            min: 2,
+            max: 20,
+            role: 'style',
+            description: 'Visible width of the filter bar.'
+        },
+
+        fillcolor: {
+            valType: 'color',
+            dflt: 'magenta',
+            role: 'style',
+            description: 'Color of the filter bar fill.'
+        },
+
+        fillopacity: {
+            valType: 'number',
+            dflt: 1,
+            min: 0,
+            max: 1,
+            role: 'style',
+            description: 'Filter bar fill opacity.'
+        },
+
+        strokecolor: {
+            valType: 'color',
+            dflt: 'white',
+            role: 'style',
+            description: 'Color of the filter bar side lines.'
+        },
+
+        strokeopacity: {
+            valType: 'number',
+            dflt: 1,
+            min: 0,
+            max: 1,
+            arrayOk: true,
+            role: 'style',
+            description: 'Filter bar side stroke opacity.'
+        },
+
+        strokewidth: {
+            valType: 'number',
+            dflt: 1,
+            min: 0,
+            max: 2,
+            role: 'style',
+            description: 'Filter bar side stroke width.'
+        },
+
+        handleheight: {
+            valType: 'number',
+            dflt: 16,
+            min: 2,
+            max: 20,
+            role: 'style',
+            description: 'Height of the filter bar vertical resize areas on top and bottom.'
+        },
+
+        handleopacity: {
+            valType: 'number',
+            dflt: 1,
+            min: 0,
+            max: 1,
+            arrayOk: true,
+            role: 'style',
+            description: 'Opacity of the filter bar vertical resize areas on top and bottom.'
+        },
+
+        handleoverlap: {
+            valType: 'number',
+            dflt: 0,
+            min: 0,
+            max: 4,
+            role: 'style',
+            description: [
+                'If zero, the vertical resize areas on top and bottom are just above and below the filter bar itself.',
+                'A larger than zero value causes overlaps with the filter bar. The overlap is represented as pixels.'
+            ].join(' ')
+        }
+    }
+};

src/traces/parcoords/base_plot.js

@@ -0,0 +1,45 @@
+/**
+* Copyright 2012-2016, 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 Registry = require('../../registry');
+
+
+exports.name = 'paroords';
+
+exports.plot = function(gd) {
+    var Parcoords = Registry.getModule('parcoords');
+    var cdParcoords = getCdModule(gd.calcdata, Parcoords);
+
+    if(cdParcoords.length) Parcoords.plot(gd, cdParcoords);
+};
+
+exports.clean = function(newFullData, newFullLayout, oldFullData, oldFullLayout) {
+    var hadParcoords = (oldFullLayout._has && oldFullLayout._has('parcoords'));
+    var hasParcoords = (newFullLayout._has && newFullLayout._has('parcoords'));
+
+    if(hadParcoords && !hasParcoords) {
+        oldFullLayout._parcoordslayer.selectAll('g.trace').remove();
+    }
+};
+
+function getCdModule(calcdata, _module) {
+    var cdModule = [];
+
+    for(var i = 0; i < calcdata.length; i++) {
+        var cd = calcdata[i];
+        var trace = cd[0].trace;
+
+        if((trace._module === _module) && (trace.visible === true)) {
+            cdModule.push(cd);
+        }
+    }
+
+    return cdModule;
+}