@kitware/vtk.js 28.10.2 → 28.11.1

package/Rendering/Core/AnnotatedCubeActor.js

@@ -1,5 +1,4 @@
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkActor from './Actor.js';
 import vtkMapper from './Mapper.js';
 import vtkTexture from './Texture.js';
@@ -7,80 +6,100 @@ import vtkCubeSource from '../../Filters/Sources/CubeSource.js';
 import ImageHelper from '../../Common/Core/ImageHelper.js';
 import AnnotatedCubePresets from './AnnotatedCubeActor/Presets.js';
 
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); 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 = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-var FACE_TO_INDEX = {
+const FACE_TO_INDEX = {
   xPlus: 0,
   xMinus: 1,
   yPlus: 2,
   yMinus: 3,
   zPlus: 4,
   zMinus: 5
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 // vtkAnnotatedCubeActor
 // ----------------------------------------------------------------------------
 
 function vtkAnnotatedCubeActor(publicAPI, model) {
   // Set our className
-  model.classHierarchy.push('vtkAnnotatedCubeActor'); // Make sure face properties are not references to the default value
+  model.classHierarchy.push('vtkAnnotatedCubeActor');
+
+  // Make sure face properties are not references to the default value
+  model.xPlusFaceProperty = {
+    ...model.xPlusFaceProperty
+  };
+  model.xMinusFaceProperty = {
+    ...model.xMinusFaceProperty
+  };
+  model.yPlusFaceProperty = {
+    ...model.yPlusFaceProperty
+  };
+  model.yMinusFaceProperty = {
+    ...model.yMinusFaceProperty
+  };
+  model.zPlusFaceProperty = {
+    ...model.zPlusFaceProperty
+  };
+  model.zMinusFaceProperty = {
+    ...model.zMinusFaceProperty
+  };
 
-  model.xPlusFaceProperty = _objectSpread({}, model.xPlusFaceProperty);
-  model.xMinusFaceProperty = _objectSpread({}, model.xMinusFaceProperty);
-  model.yPlusFaceProperty = _objectSpread({}, model.yPlusFaceProperty);
-  model.yMinusFaceProperty = _objectSpread({}, model.yMinusFaceProperty);
-  model.zPlusFaceProperty = _objectSpread({}, model.zPlusFaceProperty);
-  model.zMinusFaceProperty = _objectSpread({}, model.zMinusFaceProperty); // private variables
+  // private variables
 
-  var cubeSource = null;
-  var canvas = document.createElement('canvas');
-  var mapper = vtkMapper.newInstance();
-  var texture = vtkTexture.newInstance();
-  texture.setInterpolate(true); // private methods
+  let cubeSource = null;
+  const canvas = document.createElement('canvas');
+  const mapper = vtkMapper.newInstance();
+  const texture = vtkTexture.newInstance();
+  texture.setInterpolate(true);
 
-  function updateFaceTexture(faceName) {
-    var newProp = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+  // private methods
 
+  function updateFaceTexture(faceName) {
+    let newProp = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
     if (newProp) {
-      Object.assign(model["".concat(faceName, "FaceProperty")], newProp);
+      Object.assign(model[`${faceName}FaceProperty`], newProp);
     }
+    const prop = {
+      ...model.defaultStyle,
+      ...model[`${faceName}FaceProperty`]
+    };
 
-    var prop = _objectSpread(_objectSpread({}, model.defaultStyle), model["".concat(faceName, "FaceProperty")]); // set canvas resolution
-
-
+    // set canvas resolution
     canvas.width = prop.resolution;
     canvas.height = prop.resolution;
-    var ctxt = canvas.getContext('2d'); // set background color
+    const ctxt = canvas.getContext('2d');
 
+    // set background color
     ctxt.fillStyle = prop.faceColor;
-    ctxt.fillRect(0, 0, canvas.width, canvas.height); // draw edge
+    ctxt.fillRect(0, 0, canvas.width, canvas.height);
 
+    // draw edge
     if (prop.edgeThickness > 0) {
       ctxt.strokeStyle = prop.edgeColor;
       ctxt.lineWidth = prop.edgeThickness * canvas.width;
       ctxt.strokeRect(0, 0, canvas.width, canvas.height);
-    } // set face rotation
-
+    }
 
-    ctxt.save(); // vertical flip
+    // set face rotation
+    ctxt.save();
 
+    // vertical flip
     ctxt.translate(0, canvas.height);
     ctxt.scale(1, -1);
     ctxt.translate(canvas.width / 2, canvas.height / 2);
-    ctxt.rotate(-Math.PI * (prop.faceRotation / 180.0)); // set foreground text
+    ctxt.rotate(-Math.PI * (prop.faceRotation / 180.0));
 
-    var textSize = prop.fontSizeScale(prop.resolution);
+    // set foreground text
+    const textSize = prop.fontSizeScale(prop.resolution);
     ctxt.fillStyle = prop.fontColor;
     ctxt.textAlign = 'center';
     ctxt.textBaseline = 'middle';
-    ctxt.font = "".concat(prop.fontStyle, " ").concat(textSize, "px \"").concat(prop.fontFamily, "\"");
+    ctxt.font = `${prop.fontStyle} ${textSize}px "${prop.fontFamily}"`;
     ctxt.fillText(prop.text, 0, 0);
     ctxt.restore();
-    var vtkImage = ImageHelper.canvasToImageData(canvas);
+    const vtkImage = ImageHelper.canvasToImageData(canvas);
     texture.setInputData(vtkImage, FACE_TO_INDEX[faceName]);
     publicAPI.modified();
   }
-
   function updateAllFaceTextures() {
     cubeSource = vtkCubeSource.newInstance({
       generate3DTextureCoordinates: true
@@ -92,51 +111,41 @@ function vtkAnnotatedCubeActor(publicAPI, model) {
     updateFaceTexture('yMinus');
     updateFaceTexture('zPlus');
     updateFaceTexture('zMinus');
-  } // public methods
+  }
 
+  // public methods
 
-  publicAPI.setDefaultStyle = function (style) {
-    model.defaultStyle = _objectSpread(_objectSpread({}, model.defaultStyle), style);
+  publicAPI.setDefaultStyle = style => {
+    model.defaultStyle = {
+      ...model.defaultStyle,
+      ...style
+    };
     updateAllFaceTextures();
   };
+  publicAPI.setXPlusFaceProperty = prop => updateFaceTexture('xPlus', prop);
+  publicAPI.setXMinusFaceProperty = prop => updateFaceTexture('xMinus', prop);
+  publicAPI.setYPlusFaceProperty = prop => updateFaceTexture('yPlus', prop);
+  publicAPI.setYMinusFaceProperty = prop => updateFaceTexture('yMinus', prop);
+  publicAPI.setZPlusFaceProperty = prop => updateFaceTexture('zPlus', prop);
+  publicAPI.setZMinusFaceProperty = prop => updateFaceTexture('zMinus', prop);
 
-  publicAPI.setXPlusFaceProperty = function (prop) {
-    return updateFaceTexture('xPlus', prop);
-  };
-
-  publicAPI.setXMinusFaceProperty = function (prop) {
-    return updateFaceTexture('xMinus', prop);
-  };
-
-  publicAPI.setYPlusFaceProperty = function (prop) {
-    return updateFaceTexture('yPlus', prop);
-  };
-
-  publicAPI.setYMinusFaceProperty = function (prop) {
-    return updateFaceTexture('yMinus', prop);
-  };
-
-  publicAPI.setZPlusFaceProperty = function (prop) {
-    return updateFaceTexture('zPlus', prop);
-  };
-
-  publicAPI.setZMinusFaceProperty = function (prop) {
-    return updateFaceTexture('zMinus', prop);
-  }; // constructor
-
+  // constructor
 
-  updateAllFaceTextures(); // set mapper
+  updateAllFaceTextures();
 
+  // set mapper
   mapper.setInputConnection(cubeSource.getOutputPort());
-  publicAPI.setMapper(mapper); // set texture
+  publicAPI.setMapper(mapper);
 
+  // set texture
   publicAPI.addTexture(texture);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   defaultStyle: {
     text: '',
     faceColor: 'white',
@@ -144,36 +153,42 @@ var DEFAULT_VALUES = {
     fontFamily: 'Arial',
     fontColor: 'black',
     fontStyle: 'normal',
-    fontSizeScale: function fontSizeScale(resolution) {
-      return resolution / 1.8;
-    },
+    fontSizeScale: resolution => resolution / 1.8,
     edgeThickness: 0.1,
     edgeColor: 'black',
     resolution: 200
-  } // xPlusFaceProperty: null,
+  }
+  // xPlusFaceProperty: null,
   // xMinusFaceProperty: null,
   // yPlusFaceProperty: null,
   // yMinusFaceProperty: null,
   // zPlusFaceProperty: null,
   // zMinusFaceProperty: null,
+};
 
-}; // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues); // Inheritance
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
 
+  // Inheritance
   vtkActor.extend(publicAPI, model, initialValues);
-  macro.get(publicAPI, model, ['defaultStyle', 'xPlusFaceProperty', 'xMinusFaceProperty', 'yPlusFaceProperty', 'yMinusFaceProperty', 'zPlusFaceProperty', 'zMinusFaceProperty']); // Object methods
+  macro.get(publicAPI, model, ['defaultStyle', 'xPlusFaceProperty', 'xMinusFaceProperty', 'yPlusFaceProperty', 'yMinusFaceProperty', 'zPlusFaceProperty', 'zMinusFaceProperty']);
 
+  // Object methods
   vtkAnnotatedCubeActor(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 
-var newInstance = macro.newInstance(extend, 'vtkAnnotatedCubeActor'); // ----------------------------------------------------------------------------
+const newInstance = macro.newInstance(extend, 'vtkAnnotatedCubeActor');
+
+// ----------------------------------------------------------------------------
 
 var vtkAnnotatedCubeActor$1 = {
-  newInstance: newInstance,
-  extend: extend,
+  newInstance,
+  extend,
   Presets: AnnotatedCubePresets
 };
 

package/Rendering/Core/AxesActor.js

@@ -1,6 +1,4 @@
-import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkMatrixBuilder from '../../Common/Core/MatrixBuilder.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
 import vtkActor from './Actor.js';
@@ -8,155 +6,127 @@ import vtkMapper from './Mapper.js';
 import vtkArrowSource from '../../Filters/Sources/ArrowSource.js';
 import vtkAppendPolyData from '../../Filters/General/AppendPolyData.js';
 
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); 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 = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+// ----------------------------------------------------------------------------
 
 function centerDataSet(ds) {
-  var _vtkMatrixBuilder$bui;
-
-  var bounds = ds.getPoints().getBounds();
-  var center = [-(bounds[0] + bounds[1]) * 0.5, -(bounds[2] + bounds[3]) * 0.5, -(bounds[4] + bounds[5]) * 0.5];
-
-  (_vtkMatrixBuilder$bui = vtkMatrixBuilder.buildFromDegree()).translate.apply(_vtkMatrixBuilder$bui, center).apply(ds.getPoints().getData());
+  const bounds = ds.getPoints().getBounds();
+  const center = [-(bounds[0] + bounds[1]) * 0.5, -(bounds[2] + bounds[3]) * 0.5, -(bounds[4] + bounds[5]) * 0.5];
+  vtkMatrixBuilder.buildFromDegree().translate(...center).apply(ds.getPoints().getData());
 }
-
 function shiftDataset(ds, axis) {
-  var _vtkMatrixBuilder$bui2;
-
-  var bounds = ds.getPoints().getBounds();
-  var center = [0, 0, 0];
+  const bounds = ds.getPoints().getBounds();
+  const center = [0, 0, 0];
   center[axis] = -bounds[axis * 2];
+  vtkMatrixBuilder.buildFromDegree().translate(...center).apply(ds.getPoints().getData());
+}
 
-  (_vtkMatrixBuilder$bui2 = vtkMatrixBuilder.buildFromDegree()).translate.apply(_vtkMatrixBuilder$bui2, center).apply(ds.getPoints().getData());
-} // ----------------------------------------------------------------------------
-
+// ----------------------------------------------------------------------------
 
 function addColor(ds, r, g, b) {
-  var size = ds.getPoints().getData().length;
-  var rgbArray = new Uint8Array(size);
-  var offset = 0;
-
+  const size = ds.getPoints().getData().length;
+  const rgbArray = new Uint8Array(size);
+  let offset = 0;
   while (offset < size) {
     rgbArray[offset++] = r;
     rgbArray[offset++] = g;
     rgbArray[offset++] = b;
   }
-
   ds.getPointData().setScalars(vtkDataArray.newInstance({
     name: 'color',
     numberOfComponents: 3,
     values: rgbArray
   }));
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // vtkAxesActor
 // ----------------------------------------------------------------------------
 
-
 function vtkAxesActor(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkAxesActor');
-
-  var _mapper = vtkMapper.newInstance();
-
+  const _mapper = vtkMapper.newInstance();
   publicAPI.setMapper(_mapper);
-
-  publicAPI.update = function () {
-    var xAxis = vtkArrowSource.newInstance(_objectSpread({
-      direction: [1, 0, 0]
-    }, model.config)).getOutputData();
-
+  publicAPI.update = () => {
+    const xAxis = vtkArrowSource.newInstance({
+      direction: [1, 0, 0],
+      ...model.config
+    }).getOutputData();
     if (model.config.recenter) {
       centerDataSet(xAxis);
     } else {
       shiftDataset(xAxis, 0);
     }
-
-    addColor.apply(void 0, [xAxis].concat(_toConsumableArray(model.xAxisColor)));
-    var yAxis = vtkArrowSource.newInstance(_objectSpread({
-      direction: [0, 1, 0]
-    }, model.config)).getOutputData();
-
+    addColor(xAxis, ...model.xAxisColor);
+    const yAxis = vtkArrowSource.newInstance({
+      direction: [0, 1, 0],
+      ...model.config
+    }).getOutputData();
     if (model.config.recenter) {
       centerDataSet(yAxis);
     } else {
       shiftDataset(yAxis, 1);
     }
-
-    addColor.apply(void 0, [yAxis].concat(_toConsumableArray(model.yAxisColor)));
-    var zAxis = vtkArrowSource.newInstance(_objectSpread({
-      direction: [0, 0, 1]
-    }, model.config)).getOutputData();
-
+    addColor(yAxis, ...model.yAxisColor);
+    const zAxis = vtkArrowSource.newInstance({
+      direction: [0, 0, 1],
+      ...model.config
+    }).getOutputData();
     if (model.config.recenter) {
       centerDataSet(zAxis);
     } else {
       shiftDataset(zAxis, 2);
     }
-
-    addColor.apply(void 0, [zAxis].concat(_toConsumableArray(model.zAxisColor)));
-    var source = vtkAppendPolyData.newInstance();
+    addColor(zAxis, ...model.zAxisColor);
+    const source = vtkAppendPolyData.newInstance();
     source.setInputData(xAxis);
     source.addInputData(yAxis);
     source.addInputData(zAxis);
-
     _mapper.setInputConnection(source.getOutputPort());
   };
-
   publicAPI.update();
-
-  var _debouncedUpdate = macro.debounce(publicAPI.update, 0);
-
-  var setConfig = publicAPI.setConfig,
-      setXAxisColor = publicAPI.setXAxisColor,
-      setYAxisColor = publicAPI.setYAxisColor,
-      setZAxisColor = publicAPI.setZAxisColor;
-
-  publicAPI.setConfig = function (c) {
+  const _debouncedUpdate = macro.debounce(publicAPI.update, 0);
+  const {
+    setConfig,
+    setXAxisColor,
+    setYAxisColor,
+    setZAxisColor
+  } = publicAPI;
+  publicAPI.setConfig = c => {
     if (setConfig(c)) {
       _debouncedUpdate();
-
       return true;
     }
-
     return false;
   };
-
-  publicAPI.setXAxisColor = function (c) {
+  publicAPI.setXAxisColor = c => {
     if (setXAxisColor(c)) {
       _debouncedUpdate();
-
       return true;
     }
-
     return false;
   };
-
-  publicAPI.setYAxisColor = function (c) {
+  publicAPI.setYAxisColor = c => {
     if (setYAxisColor(c)) {
       _debouncedUpdate();
-
       return true;
     }
-
     return false;
   };
-
-  publicAPI.setZAxisColor = function (c) {
+  publicAPI.setZAxisColor = c => {
     if (setZAxisColor(c)) {
       _debouncedUpdate();
-
       return true;
     }
-
     return false;
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   config: {
     recenter: true,
     tipResolution: 60,
@@ -169,24 +139,32 @@ var DEFAULT_VALUES = {
   xAxisColor: [255, 0, 0],
   yAxisColor: [255, 255, 0],
   zAxisColor: [0, 128, 0]
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues); // Inheritance
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
 
+  // Inheritance
   vtkActor.extend(publicAPI, model, initialValues);
   macro.setGet(publicAPI, model, ['config']);
-  macro.setGetArray(publicAPI, model, ['xAxisColor', 'yAxisColor', 'zAxisColor'], 3, 255); // Object methods
+  macro.setGetArray(publicAPI, model, ['xAxisColor', 'yAxisColor', 'zAxisColor'], 3, 255);
 
+  // Object methods
   vtkAxesActor(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkAxesActor');
 
-var newInstance = macro.newInstance(extend, 'vtkAxesActor'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 var vtkAxesActor$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { DEFAULT_VALUES, vtkAxesActor$1 as default, extend, newInstance };