find min/max u/v/w norm in calc directly

... w/o using cone2mesh, and use that the find cmin & cmax
    which now correspond to "absolute" vector norm.

    This make cone/helpers.js obsolete.

Author: etpinard

src/traces/cone/calc.js

@@ -8,18 +8,25 @@
 
 'use strict';
 
-var cone2mesh = require('./helpers').cone2mesh;
 var colorscaleCalc = require('../../components/colorscale/calc');
 
 module.exports = function calc(gd, trace) {
-    var fullLayout = gd._fullLayout;
+    var u = trace.u;
+    var v = trace.v;
+    var w = trace.w;
+    var len = Math.min(u.length, v.length, w.length);
+    var normMax = -Infinity;
+    var normMin = Infinity;
 
-    // TODO skip when 'cmin' and 'cmax' are set
-    // TODO find way to "merge" this cone2mesh call with the one in convert.js
-    //
-    // TODO should show in absolute or normalize length?
+    for(var i = 0; i < len; i++) {
+        var uu = u[i];
+        var vv = v[i];
+        var ww = w[i];
+        var norm = Math.sqrt(uu * uu + vv * vv + ww * ww);
 
-    var meshData = cone2mesh(trace, fullLayout[trace.scene]);
+        normMax = Math.max(normMax, norm);
+        normMin = Math.min(normMin, norm);
+    }
 
-    colorscaleCalc(trace, meshData.vertexIntensity, '', 'c');
+    colorscaleCalc(trace, [normMin, normMax], '', 'c');
 };

src/traces/cone/convert.js

@@ -9,8 +9,11 @@
 'use strict';
 
 var createScatterPlot = require('gl-scatter3d');
+var conePlot = require('gl-cone3d');
 var createConeMesh = require('gl-cone3d').createConeMesh;
-var cone2mesh = require('./helpers').cone2mesh;
+
+var simpleMap = require('../../lib').simpleMap;
+var parseColorScale = require('../../lib/gl_format_color').parseColorScale;
 
 function Cone(scene, uid) {
     this.scene = scene;
@@ -43,8 +46,57 @@ 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'};
+
 function convert(scene, trace) {
-    return cone2mesh(trace, scene.fullSceneLayout, scene.dataScale);
+    var sceneLayout = scene.fullSceneLayout;
+    var dataScale = scene.dataScale;
+    var coneOpts = {};
+
+    function toDataCoords(arr, axisName) {
+        var ax = sceneLayout[axisName];
+        var scale = dataScale[axisName2scaleIndex[axisName]];
+        return simpleMap(arr, function(v) { return ax.d2l(v) * scale; });
+    }
+
+    coneOpts.vectors = zip3(
+        toDataCoords(trace.u, 'xaxis'),
+        toDataCoords(trace.v, 'yaxis'),
+        toDataCoords(trace.w, 'zaxis')
+    );
+
+    coneOpts.positions = zip3(
+        toDataCoords(trace.x, 'xaxis'),
+        toDataCoords(trace.y, 'yaxis'),
+        toDataCoords(trace.z, 'zaxis')
+    );
+
+    if(trace.vx && trace.vy && trace.vz) {
+        coneOpts.meshgrid = [
+            toDataCoords(trace.vx, 'xaxis'),
+            toDataCoords(trace.vy, 'yaxis'),
+            toDataCoords(trace.vz, 'zaxis')
+        ];
+    }
+
+    coneOpts.colormap = parseColorScale(trace.colorscale);
+    coneOpts.vertexIntensityBounds = [trace.cmin / trace.cmax, 1];
+
+    coneOpts[sizeMode2sizeKey[trace.sizemode]] = trace.sizeref;
+
+    var meshOpts = conePlot(coneOpts);
+    meshOpts._pts = coneOpts.positions;
+
+    return meshOpts;
 }
 
 proto.update = function(data) {