@kitware/vtk.js 28.10.2 → 28.11.1

package/Rendering/Core/Texture.js

@@ -1,259 +1,210 @@
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.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; }
+// ----------------------------------------------------------------------------
 // vtkTexture methods
 // ----------------------------------------------------------------------------
 
 function vtkTexture(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkTexture');
-
-  publicAPI.imageLoaded = function () {
+  publicAPI.imageLoaded = () => {
     model.image.removeEventListener('load', publicAPI.imageLoaded);
     model.imageLoaded = true;
     publicAPI.modified();
   };
-
-  publicAPI.setJsImageData = function (imageData) {
+  publicAPI.setJsImageData = imageData => {
     if (model.jsImageData === imageData) {
       return;
-    } // clear other entries
-
+    }
 
+    // clear other entries
     if (imageData !== null) {
       publicAPI.setInputData(null);
       publicAPI.setInputConnection(null);
       model.image = null;
       model.canvas = null;
     }
-
     model.jsImageData = imageData;
     model.imageLoaded = true;
     publicAPI.modified();
   };
-
-  publicAPI.setCanvas = function (canvas) {
+  publicAPI.setCanvas = canvas => {
     if (model.canvas === canvas) {
       return;
-    } // clear other entries
-
+    }
 
+    // clear other entries
     if (canvas !== null) {
       publicAPI.setInputData(null);
       publicAPI.setInputConnection(null);
       model.image = null;
       model.jsImageData = null;
     }
-
     model.canvas = canvas;
     publicAPI.modified();
   };
-
-  publicAPI.setImage = function (image) {
+  publicAPI.setImage = image => {
     if (model.image === image) {
       return;
-    } // clear other entries
-
+    }
 
+    // clear other entries
     if (image !== null) {
       publicAPI.setInputData(null);
       publicAPI.setInputConnection(null);
       model.canvas = null;
       model.jsImageData = null;
     }
-
     model.image = image;
     model.imageLoaded = false;
-
     if (image.complete) {
       publicAPI.imageLoaded();
     } else {
       image.addEventListener('load', publicAPI.imageLoaded);
     }
-
     publicAPI.modified();
   };
-
-  publicAPI.getDimensionality = function () {
-    var width = 0;
-    var height = 0;
-    var depth = 1;
-
+  publicAPI.getDimensionality = () => {
+    let width = 0;
+    let height = 0;
+    let depth = 1;
     if (publicAPI.getInputData()) {
-      var data = publicAPI.getInputData();
+      const data = publicAPI.getInputData();
       width = data.getDimensions()[0];
       height = data.getDimensions()[1];
       depth = data.getDimensions()[2];
     }
-
     if (model.jsImageData) {
       width = model.jsImageData.width;
       height = model.jsImageData.height;
     }
-
     if (model.canvas) {
       width = model.canvas.width;
       height = model.canvas.height;
     }
-
     if (model.image) {
       width = model.image.width;
       height = model.image.height;
     }
-
-    var dimensionality = (width > 1) + (height > 1) + (depth > 1);
+    const dimensionality = (width > 1) + (height > 1) + (depth > 1);
     return dimensionality;
   };
-
-  publicAPI.getInputAsJsImageData = function () {
+  publicAPI.getInputAsJsImageData = () => {
     if (!model.imageLoaded || publicAPI.getInputData()) return null;
-
     if (model.jsImageData) {
       return model.jsImageData();
     }
-
     if (model.canvas) {
-      var context = model.canvas.getContext('2d');
-      var imageData = context.getImageData(0, 0, model.canvas.width, model.canvas.height);
+      const context = model.canvas.getContext('2d');
+      const imageData = context.getImageData(0, 0, model.canvas.width, model.canvas.height);
       return imageData;
     }
-
     if (model.image) {
-      var canvas = document.createElement('canvas');
+      const canvas = document.createElement('canvas');
       canvas.width = model.image.width;
       canvas.height = model.image.height;
-
-      var _context = canvas.getContext('2d');
-
-      _context.translate(0, canvas.height);
-
-      _context.scale(1, -1);
-
-      _context.drawImage(model.image, 0, 0, model.image.width, model.image.height);
-
-      var _imageData = _context.getImageData(0, 0, canvas.width, canvas.height);
-
-      return _imageData;
+      const context = canvas.getContext('2d');
+      context.translate(0, canvas.height);
+      context.scale(1, -1);
+      context.drawImage(model.image, 0, 0, model.image.width, model.image.height);
+      const imageData = context.getImageData(0, 0, canvas.width, canvas.height);
+      return imageData;
     }
-
     return null;
   };
-} // Use nativeArray instead of self
+}
 
-
-var generateMipmaps = function generateMipmaps(nativeArray, width, height, level) {
+// Use nativeArray instead of self
+const generateMipmaps = (nativeArray, width, height, level) => {
   // TODO: FIX UNEVEN TEXTURE MIP GENERATION:
   // When textures don't have standard ratios, higher mip levels
   // result in their color chanels getting messed up and shifting
   // 3x3 gaussian kernel
-  var g3m = [1, 2, 1]; // eslint-disable-line
-
-  var g3w = 4; // eslint-disable-line
-
-  var kernel = g3m;
-  var kernelWeight = g3w;
-  var hs = nativeArray.length / (width * height); // TODO: support for textures with depth more than 1
-
-  var currentWidth = width;
-  var currentHeight = height;
-  var imageData = nativeArray;
-  var maps = [imageData];
-
-  for (var i = 0; i < level; i++) {
-    var oldData = _toConsumableArray(imageData);
-
+  const g3m = [1, 2, 1]; // eslint-disable-line
+  const g3w = 4; // eslint-disable-line
+
+  const kernel = g3m;
+  const kernelWeight = g3w;
+  const hs = nativeArray.length / (width * height); // TODO: support for textures with depth more than 1
+  let currentWidth = width;
+  let currentHeight = height;
+  let imageData = nativeArray;
+  const maps = [imageData];
+  for (let i = 0; i < level; i++) {
+    const oldData = [...imageData];
     currentWidth /= 2;
     currentHeight /= 2;
     imageData = new Uint8ClampedArray(currentWidth * currentHeight * hs);
-    var vs = hs * currentWidth; // Scale down
-
-    var shift = 0;
+    const vs = hs * currentWidth;
 
-    for (var p = 0; p < imageData.length; p += hs) {
+    // Scale down
+    let shift = 0;
+    for (let p = 0; p < imageData.length; p += hs) {
       if (p % vs === 0) {
         shift += 2 * hs * currentWidth;
       }
-
-      for (var c = 0; c < hs; c++) {
-        var sample = oldData[shift + c];
+      for (let c = 0; c < hs; c++) {
+        let sample = oldData[shift + c];
         sample += oldData[shift + hs + c];
         sample += oldData[shift - 2 * vs + c];
         sample += oldData[shift - 2 * vs + hs + c];
         sample /= 4;
         imageData[p + c] = sample;
       }
-
       shift += 2 * hs;
-    } // Horizontal Pass
-
-
-    var dataCopy = _toConsumableArray(imageData);
-
-    for (var _p = 0; _p < imageData.length; _p += hs) {
-      for (var _c = 0; _c < hs; _c++) {
-        var x = -(kernel.length - 1) / 2;
-        var kw = kernelWeight;
-        var value = 0.0;
+    }
 
-        for (var k = 0; k < kernel.length; k++) {
-          var index = _p + _c + x * hs;
-          var lineShift = index % vs - (_p + _c) % vs;
+    // Horizontal Pass
+    let dataCopy = [...imageData];
+    for (let p = 0; p < imageData.length; p += hs) {
+      for (let c = 0; c < hs; c++) {
+        let x = -(kernel.length - 1) / 2;
+        let kw = kernelWeight;
+        let value = 0.0;
+        for (let k = 0; k < kernel.length; k++) {
+          let index = p + c + x * hs;
+          const lineShift = index % vs - (p + c) % vs;
           if (lineShift > hs) index += vs;
           if (lineShift < -hs) index -= vs;
-
           if (dataCopy[index]) {
             value += dataCopy[index] * kernel[k];
           } else {
             kw -= kernel[k];
           }
-
           x += 1;
         }
-
-        imageData[_p + _c] = value / kw;
+        imageData[p + c] = value / kw;
       }
-    } // Vertical Pass
-
-
-    dataCopy = _toConsumableArray(imageData);
-
-    for (var _p2 = 0; _p2 < imageData.length; _p2 += hs) {
-      for (var _c2 = 0; _c2 < hs; _c2++) {
-        var _x = -(kernel.length - 1) / 2;
-
-        var _kw = kernelWeight;
-        var _value = 0.0;
-
-        for (var _k = 0; _k < kernel.length; _k++) {
-          var _index = _p2 + _c2 + _x * vs;
-
-          if (dataCopy[_index]) {
-            _value += dataCopy[_index] * kernel[_k];
+    }
+    // Vertical Pass
+    dataCopy = [...imageData];
+    for (let p = 0; p < imageData.length; p += hs) {
+      for (let c = 0; c < hs; c++) {
+        let x = -(kernel.length - 1) / 2;
+        let kw = kernelWeight;
+        let value = 0.0;
+        for (let k = 0; k < kernel.length; k++) {
+          const index = p + c + x * vs;
+          if (dataCopy[index]) {
+            value += dataCopy[index] * kernel[k];
           } else {
-            _kw -= kernel[_k];
+            kw -= kernel[k];
           }
-
-          _x += 1;
+          x += 1;
         }
-
-        imageData[_p2 + _c2] = _value / _kw;
+        imageData[p + c] = value / kw;
       }
     }
-
     maps.push(imageData);
   }
-
   return maps;
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   image: null,
   canvas: null,
   jsImageData: null,
@@ -263,28 +214,35 @@ var DEFAULT_VALUES = {
   edgeClamp: false,
   mipLevel: 0,
   resizable: false // must be set at construction time if the texture can be resizable
+};
 
-}; // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues); // Build VTK API
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
 
+  // Build VTK API
   macro.obj(publicAPI, model);
   macro.algo(publicAPI, model, 6, 0);
   macro.get(publicAPI, model, ['canvas', 'image', 'jsImageData', 'imageLoaded', 'resizable']);
   macro.setGet(publicAPI, model, ['repeat', 'edgeClamp', 'interpolate', 'mipLevel']);
   vtkTexture(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkTexture');
-var STATIC = {
-  generateMipmaps: generateMipmaps
-}; // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkTexture');
+const STATIC = {
+  generateMipmaps
+};
+
+// ----------------------------------------------------------------------------
 
-var vtkTexture$1 = _objectSpread({
-  newInstance: newInstance,
-  extend: extend
-}, STATIC);
+var vtkTexture$1 = {
+  newInstance,
+  extend,
+  ...STATIC
+};
 
 export { STATIC, vtkTexture$1 as default, extend, newInstance };

package/Rendering/Core/Viewport.js

@@ -1,139 +1,104 @@
-import macro from '../../macros.js';
-
-var vtkErrorMacro = macro.vtkErrorMacro;
+import { m as macro } from '../../macros2.js';
 
+const {
+  vtkErrorMacro
+} = macro;
 function notImplemented(method) {
-  return function () {
-    return vtkErrorMacro("vtkViewport::".concat(method, " - NOT IMPLEMENTED"));
-  };
-} // ----------------------------------------------------------------------------
+  return () => vtkErrorMacro(`vtkViewport::${method} - NOT IMPLEMENTED`);
+}
+
+// ----------------------------------------------------------------------------
 // vtkViewport methods
 // ----------------------------------------------------------------------------
 
-
 function vtkViewport(publicAPI, model) {
   // Set our className
-  model.classHierarchy.push('vtkViewport'); // Public API methods
-
-  publicAPI.getViewProps = function () {
-    return model.props;
-  };
-
-  publicAPI.hasViewProp = function (prop) {
-    return model.props.includes(prop);
-  };
+  model.classHierarchy.push('vtkViewport');
 
-  publicAPI.addViewProp = function (prop) {
+  // Public API methods
+  publicAPI.getViewProps = () => model.props;
+  publicAPI.hasViewProp = prop => model.props.includes(prop);
+  publicAPI.addViewProp = prop => {
     if (prop && !publicAPI.hasViewProp(prop)) {
       model.props.push(prop);
     }
   };
-
-  publicAPI.removeViewProp = function (prop) {
-    var newPropList = model.props.filter(function (item) {
-      return item !== prop;
-    });
-
+  publicAPI.removeViewProp = prop => {
+    const newPropList = model.props.filter(item => item !== prop);
     if (model.props.length !== newPropList.length) {
       model.props = newPropList;
     }
   };
-
-  publicAPI.removeAllViewProps = function () {
+  publicAPI.removeAllViewProps = () => {
     model.props = [];
-  }; // this method get all the props including any nested props
-
+  };
 
+  // this method get all the props including any nested props
   function gatherProps(prop) {
-    var allProps = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+    let allProps = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
     allProps.push(prop);
-    var children = prop.getNestedProps();
-
+    const children = prop.getNestedProps();
     if (children && children.length) {
-      for (var i = 0; i < children.length; i++) {
+      for (let i = 0; i < children.length; i++) {
         gatherProps(children[i], allProps);
       }
     }
-
     return allProps;
   }
-
-  publicAPI.getViewPropsWithNestedProps = function () {
-    var allPropsArray = [];
-
-    for (var i = 0; i < model.props.length; i++) {
+  publicAPI.getViewPropsWithNestedProps = () => {
+    const allPropsArray = [];
+    for (let i = 0; i < model.props.length; i++) {
       gatherProps(model.props[i], allPropsArray);
     }
-
     return allPropsArray;
   };
-
   publicAPI.addActor2D = publicAPI.addViewProp;
-
-  publicAPI.removeActor2D = function (prop) {
+  publicAPI.removeActor2D = prop => {
     // VTK way: model.actors2D.RemoveItem(prop);
     publicAPI.removeViewProp(prop);
   };
-
-  publicAPI.getActors2D = function () {
+  publicAPI.getActors2D = () => {
     model.actors2D = [];
-    model.props.forEach(function (prop) {
+    model.props.forEach(prop => {
       model.actors2D = model.actors2D.concat(prop.getActors2D());
     });
     return model.actors2D;
   };
-
-  publicAPI.displayToView = function () {
-    return vtkErrorMacro('call displayToView on your view instead');
-  };
-
-  publicAPI.viewToDisplay = function () {
-    return vtkErrorMacro('callviewtodisplay on your view instead');
-  };
-
-  publicAPI.getSize = function () {
-    return vtkErrorMacro('call getSize on your View instead');
-  };
-
-  publicAPI.normalizedDisplayToProjection = function (x, y, z) {
+  publicAPI.displayToView = () => vtkErrorMacro('call displayToView on your view instead');
+  publicAPI.viewToDisplay = () => vtkErrorMacro('callviewtodisplay on your view instead');
+  publicAPI.getSize = () => vtkErrorMacro('call getSize on your View instead');
+  publicAPI.normalizedDisplayToProjection = (x, y, z) => {
     // first to normalized viewport
-    var nvp = publicAPI.normalizedDisplayToNormalizedViewport(x, y, z); // then to view
+    const nvp = publicAPI.normalizedDisplayToNormalizedViewport(x, y, z);
 
+    // then to view
     return publicAPI.normalizedViewportToProjection(nvp[0], nvp[1], nvp[2]);
   };
-
-  publicAPI.normalizedDisplayToNormalizedViewport = function (x, y, z) {
-    var scale = [model.viewport[2] - model.viewport[0], model.viewport[3] - model.viewport[1]];
+  publicAPI.normalizedDisplayToNormalizedViewport = (x, y, z) => {
+    const scale = [model.viewport[2] - model.viewport[0], model.viewport[3] - model.viewport[1]];
     return [(x - model.viewport[0]) / scale[0], (y - model.viewport[1]) / scale[1], z];
   };
-
-  publicAPI.normalizedViewportToProjection = function (x, y, z) {
-    return [x * 2.0 - 1.0, y * 2.0 - 1.0, z * 2.0 - 1.0];
-  };
-
-  publicAPI.projectionToNormalizedDisplay = function (x, y, z) {
+  publicAPI.normalizedViewportToProjection = (x, y, z) => [x * 2.0 - 1.0, y * 2.0 - 1.0, z * 2.0 - 1.0];
+  publicAPI.projectionToNormalizedDisplay = (x, y, z) => {
     // first to nvp
-    var nvp = publicAPI.projectionToNormalizedViewport(x, y, z); // then to ndp
+    const nvp = publicAPI.projectionToNormalizedViewport(x, y, z);
 
+    // then to ndp
     return publicAPI.normalizedViewportToNormalizedDisplay(nvp[0], nvp[1], nvp[2]);
   };
-
-  publicAPI.normalizedViewportToNormalizedDisplay = function (x, y, z) {
-    var scale = [model.viewport[2] - model.viewport[0], model.viewport[3] - model.viewport[1]];
+  publicAPI.normalizedViewportToNormalizedDisplay = (x, y, z) => {
+    const scale = [model.viewport[2] - model.viewport[0], model.viewport[3] - model.viewport[1]];
     return [x * scale[0] + model.viewport[0], y * scale[1] + model.viewport[1], z];
   };
-
-  publicAPI.projectionToNormalizedViewport = function (x, y, z) {
-    return [(x + 1.0) * 0.5, (y + 1.0) * 0.5, (z + 1.0) * 0.5];
-  };
-
+  publicAPI.projectionToNormalizedViewport = (x, y, z) => [(x + 1.0) * 0.5, (y + 1.0) * 0.5, (z + 1.0) * 0.5];
   publicAPI.PickPropFrom = notImplemented('PickPropFrom');
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   // _vtkWindow: null,
   background: [0, 0, 0],
   background2: [0.2, 0.2, 0.2],
@@ -143,24 +108,31 @@ var DEFAULT_VALUES = {
   pixelAspect: [1, 1],
   props: [],
   actors2D: []
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues); // Build VTK API
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
 
+  // Build VTK API
   macro.obj(publicAPI, model);
   macro.event(publicAPI, model, 'event');
   macro.setGetArray(publicAPI, model, ['viewport'], 4);
   macro.setGetArray(publicAPI, model, ['background', 'background2'], 3);
   vtkViewport(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkViewport');
 
-var newInstance = macro.newInstance(extend, 'vtkViewport'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 var vtkViewport$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkViewport$1 as default, extend, newInstance };