@thewtex/vtk.js-esm/Proxy/Core/PiecewiseFunctionProxy.js

Visualization Toolkit for the Web

import _defineProperty from '@babel/runtime/helpers/defineProperty';
import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
import macro from '../../macro.js';
import vtkPiecewiseFunction from '../../Common/DataModel/PiecewiseFunction.js';
import vtkPiecewiseGaussianWidget from '../../Interaction/Widgets/PiecewiseGaussianWidget.js';
import Constants from './PiecewiseFunctionProxy/Constants.js';

function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
var Mode = Constants.Mode,
    Defaults = Constants.Defaults; // ----------------------------------------------------------------------------

function applyPointsToPiecewiseFunction(points, range, pwf) {
  var width = range[1] - range[0];
  var rescaled = points.map(function (_ref) {
    var _ref2 = _slicedToArray(_ref, 2),
        x = _ref2[0],
        y = _ref2[1];

    return [x * width + range[0], y];
  });
  pwf.removeAllPoints();
  rescaled.forEach(function (_ref3) {
    var _ref4 = _slicedToArray(_ref3, 2),
        x = _ref4[0],
        y = _ref4[1];

    return pwf.addPoint(x, y);
  });
} // ----------------------------------------------------------------------------


function applyNodesToPiecewiseFunction(nodes, range, pwf) {
  var width = range[1] - range[0];
  var rescaled = nodes.map(function (n) {
    return _objectSpread(_objectSpread({}, n), {}, {
      x: n.x * width + range[0]
    });
  });
  pwf.setNodes(rescaled);
} // ----------------------------------------------------------------------------


function copyGaussians(gaussians) {
  // gaussians is assumed to be an array of gaussian objects
  return gaussians.map(function (g) {
    return _objectSpread({}, g);
  });
} // ----------------------------------------------------------------------------
// vtkPiecewiseFunctionProxy methods
// ----------------------------------------------------------------------------


function vtkPiecewiseFunctionProxy(publicAPI, model) {
  // Set our className
  model.classHierarchy.push('vtkPiecewiseFunctionProxy');
  model.piecewiseFunction = model.piecewiseFunction || vtkPiecewiseFunction.newInstance(); // Takes an array of gaussians

  publicAPI.setGaussians = function (gaussians) {
    model.gaussians = copyGaussians(gaussians || []);

    if (model.gaussians.length === 0) {
      model.gaussians = copyGaussians(Defaults.Gaussians);
    }

    publicAPI.applyMode();
  }; // Takes an array of points [x, y]


  publicAPI.setPoints = function (points) {
    model.points = (points || []).slice();

    if (model.points.length === 0) {
      model.points = Defaults.Points.slice();
    }

    publicAPI.applyMode();
  }; // Takes an array of PiecewiseFunction nodes


  publicAPI.setNodes = function (nodes) {
    model.nodes = (nodes || []).slice();

    if (model.nodes.length === 0) {
      model.nodes = Defaults.Nodes.slice();
    }

    publicAPI.applyMode();
  };

  publicAPI.setMode = function (mode) {
    if (model.mode === mode) {
      return;
    }

    model.mode = mode;
    publicAPI.applyMode();
  };

  publicAPI.applyMode = function () {
    switch (model.mode) {
      case Mode.Gaussians:
        vtkPiecewiseGaussianWidget.applyGaussianToPiecewiseFunction(model.gaussians, 255, model.dataRange, model.piecewiseFunction);
        publicAPI.modified();
        break;

      case Mode.Points:
        applyPointsToPiecewiseFunction(model.points, model.dataRange, model.piecewiseFunction);
        publicAPI.modified();
        break;

      case Mode.Nodes:
        applyNodesToPiecewiseFunction(model.nodes, model.dataRange, model.piecewiseFunction);
        publicAPI.modified();
        break;

    }
  };

  publicAPI.getLookupTableProxy = function () {
    return model.proxyManager.getLookupTable(model.arrayName);
  };

  publicAPI.setDataRange = function (min, max) {
    if (model.dataRange[0] !== min || model.dataRange[1] !== max) {
      model.dataRange[0] = min;
      model.dataRange[1] = max;
      publicAPI.applyMode();
    }
  }; // Initialization ------------------------------------------------------------


  publicAPI.applyMode();
} // ----------------------------------------------------------------------------
// Object factory
// ----------------------------------------------------------------------------


var DEFAULT_VALUES = {
  mode: Mode.Gaussians,
  gaussians: Defaults.Gaussians,
  points: Defaults.Points,
  nodes: Defaults.Nodes,
  arrayName: 'No array associated',
  arrayLocation: 'pointData',
  dataRange: [0, 1]
}; // ----------------------------------------------------------------------------

function extend(publicAPI, model) {
  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
  Object.assign(model, DEFAULT_VALUES, initialValues);
  macro.obj(publicAPI, model);
  macro.setGet(publicAPI, model, ['arrayName']);
  macro.get(publicAPI, model, ['piecewiseFunction', 'gaussians', 'nodes', 'points', 'mode', 'dataRange']); // Object specific methods

  vtkPiecewiseFunctionProxy(publicAPI, model); // Proxy handling

  macro.proxy(publicAPI, model);
} // ----------------------------------------------------------------------------


var newInstance = macro.newInstance(extend, 'vtkPiecewiseFunctionProxy'); // ----------------------------------------------------------------------------

var vtkPiecewiseFunctionProxy$1 = {
  newInstance: newInstance,
  extend: extend,
  Mode: Mode,
  Defaults: Defaults
};

export default vtkPiecewiseFunctionProxy$1;
export { newInstance };