setScatterChart()

in zeppelin-web/src/app/visualization/builtins/visualization-scatterchart.js [100:242]
112 lines of code
42 McCabe index (conditional complexity)

  setScatterChart(data, refresh) {
    let xAxis = this.config.xAxis;
    let yAxis = this.config.yAxis;
    let group = this.config.group;
    let size = this.config.size;

    let xValues = [];
    let yValues = [];
    let rows = {};
    let d3g = [];

    let rowNameIndex = {};
    let colNameIndex = {};
    let grpNameIndex = {};
    let rowIndexValue = {};
    let colIndexValue = {};
    let grpIndexValue = {};
    let rowIdx = 0;
    let colIdx = 0;
    let grpIdx = 0;
    let grpName = '';

    let xValue;
    let yValue;
    let row;

    if (!xAxis && !yAxis) {
      return {
        d3g: [],
      };
    }

    for (let i = 0; i < data.rows.length; i++) {
      row = data.rows[i];
      if (xAxis) {
        xValue = row[xAxis.index];
        xValues[i] = xValue;
      }
      if (yAxis) {
        yValue = row[yAxis.index];
        yValues[i] = yValue;
      }
    }

    let isAllDiscrete = ((xAxis && yAxis && this.isDiscrete(xValues) && this.isDiscrete(yValues)) ||
    (!xAxis && this.isDiscrete(yValues)) ||
    (!yAxis && this.isDiscrete(xValues)));

    if (isAllDiscrete) {
      rows = this.setDiscreteScatterData(data);
    } else {
      rows = data.rows;
    }

    if (!group && isAllDiscrete) {
      grpName = 'count';
    } else if (!group && !size) {
      if (xAxis && yAxis) {
        grpName = '(' + xAxis.name + ', ' + yAxis.name + ')';
      } else if (xAxis && !yAxis) {
        grpName = xAxis.name;
      } else if (!xAxis && yAxis) {
        grpName = yAxis.name;
      }
    } else if (!group && size) {
      grpName = size.name;
    }

    let epsilon = 1e-4; // TODO remove after bump to nvd3 > 1.8.5

    for (let i = 0; i < rows.length; i++) {
      row = rows[i];
      if (xAxis) {
        xValue = row[xAxis.index];
      }
      if (yAxis) {
        yValue = row[yAxis.index];
      }
      if (group) {
        grpName = row[group.index];
      }
      let sz = (isAllDiscrete) ? row[row.length - 1] : ((size) ? row[size.index] : 1);

      if (grpNameIndex[grpName] === undefined) {
        grpIndexValue[grpIdx] = grpName;
        grpNameIndex[grpName] = grpIdx++;
      }

      if (xAxis && rowNameIndex[xValue] === undefined) {
        rowIndexValue[rowIdx] = xValue;
        rowNameIndex[xValue] = rowIdx++;
      }

      if (yAxis && colNameIndex[yValue] === undefined) {
        colIndexValue[colIdx] = yValue;
        colNameIndex[yValue] = colIdx++;
      }

      if (!d3g[grpNameIndex[grpName]]) {
        d3g[grpNameIndex[grpName]] = {
          key: grpName,
          values: [],
        };
      }

      // TODO remove epsilon jitter after bump to nvd3 > 1.8.5
      let xval = 0;
      let yval = 0;
      if (xAxis) {
        xval = (isNaN(xValue) ? rowNameIndex[xValue] : parseFloat(xValue)) + Math.random() * epsilon;
      }
      if (yAxis) {
        yval = (isNaN(yValue) ? colNameIndex[yValue] : parseFloat(yValue)) + Math.random() * epsilon;
      }

      d3g[grpNameIndex[grpName]].values.push({
        x: xval,
        y: yval,
        size: isNaN(parseFloat(sz)) ? 1 : parseFloat(sz),
      });
    }

    // TODO remove sort and dedup after bump to nvd3 > 1.8.5
    let d3gvalues = d3g[grpNameIndex[grpName]].values;
    d3gvalues.sort(function(a, b) {
      return ((a['x'] - b['x']) || (a['y'] - b['y']));
    });

    for (let i = 0; i < d3gvalues.length - 1;) {
      if ((Math.abs(d3gvalues[i]['x'] - d3gvalues[i + 1]['x']) < epsilon) &&
           (Math.abs(d3gvalues[i]['y'] - d3gvalues[i + 1]['y']) < epsilon)) {
        d3gvalues.splice(i + 1, 1);
      } else {
        i++;
      }
    }

    return {
      xLabels: rowIndexValue,
      yLabels: colIndexValue,
      d3g: d3g,
    };
  }