calc.js

/**
* 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 Lib = require('../../lib');
var colorscaleCalc = require('../../components/colorscale/calc');

module.exports = function calc(gd, trace) {
    var i, j, k;

    var u = trace.u;
    var v = trace.v;
    var w = trace.w;
    var x = trace.x;
    var y = trace.y;
    var z = trace.z;
    var len = Math.min(x.length, y.length, z.length, u.length, v.length, w.length);

    var slen = 0;
    var startx, starty, startz;
    if(trace.starts) {
        startx = trace.starts.x || [];
        starty = trace.starts.y || [];
        startz = trace.starts.z || [];
        slen = Math.min(startx.length, starty.length, startz.length);
    }

    var normMax = 0;
    var normMin = Infinity;

    for(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);

        normMax = Math.max(normMax, norm);
        normMin = Math.min(normMin, norm);
    }

    colorscaleCalc(gd, trace, {
        vals: [normMin, normMax],
        containerStr: '',
        cLetter: 'c'
    });

    var xMax = -Infinity;
    var xMin = Infinity;
    var yMax = -Infinity;
    var yMin = Infinity;
    var zMax = -Infinity;
    var zMin = Infinity;

    var gridFill = '';
    var filledX;
    var filledY;
    var filledZ;
    var firstX;
    var firstY;
    var firstZ;
    if(len) {
        firstX = x[0];
        firstY = y[0];
        firstZ = z[0];
    }

    for(i = 0; i < len; i++) {
        xMax = Math.max(xMax, x[i]);
        xMin = Math.min(xMin, x[i]);

        yMax = Math.max(yMax, y[i]);
        yMin = Math.min(yMin, y[i]);

        zMax = Math.max(zMax, z[i]);
        zMin = Math.min(zMin, z[i]);

        if(!filledX && x[i] !== firstX) {
            filledX = true;
            gridFill += 'x';
        } else if(!filledY && y[i] !== firstY) {
            filledY = true;
            gridFill += 'y';
        } else if(!filledZ && z[i] !== firstZ) {
            filledZ = true;
            gridFill += 'z';
        }
    }
    // fill if not filled - case of having dimension(s) with one item
    if(!filledX) gridFill += 'x';
    if(!filledY) gridFill += 'y';
    if(!filledZ) gridFill += 'z';

    var valsx = distinctVals(trace.x.slice(0, len));
    var valsy = distinctVals(trace.y.slice(0, len));
    var valsz = distinctVals(trace.z.slice(0, len));

    var getArray = function(c) { return c === 'x' ? x : c === 'y' ? y : z; };
    var getVals = function(c) { return c === 'x' ? valsx : c === 'y' ? valsy : valsz; };
    var getLength = function(c) { return getVals(c).length; };
    var getDir = function(c) { return (+(c[c.length - 1] - c[0])) * 2 + 1; };

    var arrK = getArray(gridFill[0]);
    var arrJ = getArray(gridFill[1]);
    var arrI = getArray(gridFill[2]);
    var nk = getLength(gridFill[0]);
    var nj = getLength(gridFill[1]);
    var ni = getLength(gridFill[2]);

    var arbitrary = false;

    var getIndex = function(_i, _j, _k) {
        return nk * (nj * _i + _j) + _k;
    };

    var dirK = getDir(getArray(gridFill[0]));
    var dirJ = getDir(getArray(gridFill[1]));
    var dirI = getDir(getArray(gridFill[2]));

    for(i = 0; i < ni - 1; i++) {
        for(j = 0; j < nj - 1; j++) {
            for(k = 0; k < nk - 1; k++) {
                var q000 = getIndex(i, j, k);
                var q001 = getIndex(i, j, k + 1);
                var q010 = getIndex(i, j + 1, k);
                var q100 = getIndex(i + 1, j, k);

                if(
                    !(arrK[q000] * dirK < arrK[q001] * dirK) ||
                    !(arrJ[q000] * dirJ < arrJ[q010] * dirJ) ||
                    !(arrI[q000] * dirI < arrI[q100] * dirI)
                ) {
                    arbitrary = true;
                }

                if(arbitrary) break;
            }
            if(arbitrary) break;
        }
        if(arbitrary) break;
    }

    if(arbitrary) {
        Lib.warn('Encountered arbitrary coordinates! Unable to input data grid.');
        len = 0;
    }

    for(i = 0; i < slen; i++) {
        var sx = startx[i];
        xMax = Math.max(xMax, sx);
        xMin = Math.min(xMin, sx);

        var sy = starty[i];
        yMax = Math.max(yMax, sy);
        yMin = Math.min(yMin, sy);

        var sz = startz[i];
        zMax = Math.max(zMax, sz);
        zMin = Math.min(zMin, sz);
    }

    trace._len = len;
    trace._slen = slen;
    trace._normMax = normMax;
    trace._xbnds = [xMin, xMax];
    trace._ybnds = [yMin, yMax];
    trace._zbnds = [zMin, zMax];
    trace._valsx = valsx;
    trace._valsy = valsy;
    trace._valsz = valsz;
    trace._gridFill = gridFill;
};

function distinctVals(col) {
    return Lib.distinctVals(col).vals;
}