@kitware/vtk.js 28.10.2 → 28.11.1

package/Common/Core/Endian.js

@@ -1,7 +1,7 @@
 function getEndianness() {
-  var a = new ArrayBuffer(4);
-  var b = new Uint8Array(a);
-  var c = new Uint32Array(a);
+  const a = new ArrayBuffer(4);
+  const b = new Uint8Array(a);
+  const c = new Uint32Array(a);
   b[0] = 0xa1;
   b[1] = 0xb2;
   b[2] = 0xc3;
@@ -10,30 +10,27 @@ function getEndianness() {
   if (c[0] === 0xa1b2c3d4) return 'BigEndian';
   return null;
 }
-var ENDIANNESS = getEndianness();
+const ENDIANNESS = getEndianness();
 function swapBytes(buffer, wordSize) {
   if (wordSize < 2) {
     return;
   }
-
-  var bytes = new Int8Array(buffer);
-  var size = bytes.length;
-  var tempBuffer = [];
-
-  for (var i = 0; i < size; i += wordSize) {
-    for (var j = 0; j < wordSize; j++) {
+  const bytes = new Int8Array(buffer);
+  const size = bytes.length;
+  const tempBuffer = [];
+  for (let i = 0; i < size; i += wordSize) {
+    for (let j = 0; j < wordSize; j++) {
       tempBuffer.push(bytes[i + j]);
     }
-
-    for (var _j = 0; _j < wordSize; _j++) {
-      bytes[i + _j] = tempBuffer.pop();
+    for (let j = 0; j < wordSize; j++) {
+      bytes[i + j] = tempBuffer.pop();
     }
   }
 }
 var Endian = {
-  ENDIANNESS: ENDIANNESS,
-  getEndianness: getEndianness,
-  swapBytes: swapBytes
+  ENDIANNESS,
+  getEndianness,
+  swapBytes
 };
 
 export { ENDIANNESS, Endian as default, getEndianness, swapBytes };

package/Common/Core/HalfFloat.js

@@ -1,80 +1,63 @@
 /* eslint-disable no-bitwise */
-var floatView = new Float32Array(1);
-var int32View = new Int32Array(floatView.buffer);
-/* eslint-disable no-bitwise */
 
+const floatView = new Float32Array(1);
+const int32View = new Int32Array(floatView.buffer);
+
+/* eslint-disable no-bitwise */
 /* This method is faster than the OpenEXR implementation (very often
  * used, eg. in Ogre), with the additional benefit of rounding, inspired
  * by James Tursa?s half-precision code. */
-
 function toHalf(val) {
   floatView[0] = val;
-  var x = int32View[0];
-  var bits = x >> 16 & 0x8000;
-  /* Get the sign */
-
-  var m = x >> 12 & 0x07ff;
-  /* Keep one extra bit for rounding */
-
-  var e = x >> 23 & 0xff;
-  /* Using int is faster here */
+  const x = int32View[0];
+  let bits = x >> 16 & 0x8000; /* Get the sign */
+  let m = x >> 12 & 0x07ff; /* Keep one extra bit for rounding */
+  const e = x >> 23 & 0xff; /* Using int is faster here */
 
   /* If zero, or denormal, or exponent underflows too much for a denormal
    * half, return signed zero. */
-
   if (e < 103) {
     return bits;
   }
-  /* If NaN, return NaN. If Inf or exponent overflow, return Inf. */
-
 
+  /* If NaN, return NaN. If Inf or exponent overflow, return Inf. */
   if (e > 142) {
     bits |= 0x7c00;
     /* If exponent was 0xff and one mantissa bit was set, it means NaN,
      * not Inf, so make sure we set one mantissa bit too. */
-
     bits |= (e === 255 ? 0 : 1) && x & 0x007fffff;
     return bits;
   }
-  /* If exponent underflows but not too much, return a denormal */
-
 
+  /* If exponent underflows but not too much, return a denormal */
   if (e < 113) {
     m |= 0x0800;
     /* Extra rounding may overflow and set mantissa to 0 and exponent
      * to 1, which is OK. */
-
     bits |= (m >> 114 - e) + (m >> 113 - e & 1);
     return bits;
   }
-
   bits |= e - 112 << 10 | m >> 1;
   /* Extra rounding. An overflow will set mantissa to 0 and increment
    * the exponent, which is OK. */
-
   bits += m & 1;
   return bits;
 }
-
 function fromHalf(h) {
-  var s = (h & 0x8000) >> 15;
-  var e = (h & 0x7c00) >> 10;
-  var f = h & 0x03ff;
-
+  const s = (h & 0x8000) >> 15;
+  const e = (h & 0x7c00) >> 10;
+  const f = h & 0x03ff;
   if (e === 0) {
-    return (s ? -1 : 1) * Math.pow(2, -14) * (f / Math.pow(2, 10));
+    return (s ? -1 : 1) * 2 ** -14 * (f / 2 ** 10);
   }
-
   if (e === 0x1f) {
     return f ? NaN : (s ? -1 : 1) * Infinity;
   }
-
-  return (s ? -1 : 1) * Math.pow(2, e - 15) * (1 + f / Math.pow(2, 10));
+  return (s ? -1 : 1) * 2 ** (e - 15) * (1 + f / 2 ** 10);
 }
-
 var HalfFloat = {
-  fromHalf: fromHalf,
-  toHalf: toHalf
+  fromHalf,
+  toHalf
 };
 
 export { HalfFloat as default };

package/Common/Core/ImageHelper.js

@@ -1,4 +1,3 @@
-import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
 import vtkImageData from '../DataModel/ImageData.js';
 import vtkDataArray from './DataArray.js';
 
@@ -10,25 +9,18 @@ import vtkDataArray from './DataArray.js';
  * @param canvas       The HTML canvas to convert
  * @param boundingBox  A bounding box of type [top, left, width, height]
  */
-
 function canvasToImageData(canvas) {
-  var boundingBox = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [0, 0, 0, 0];
-
-  var _boundingBox = _slicedToArray(boundingBox, 4),
-      top = _boundingBox[0],
-      left = _boundingBox[1],
-      width = _boundingBox[2],
-      height = _boundingBox[3];
-
-  var ctxt = canvas.getContext('2d');
-  var idata = ctxt.getImageData(top, left, width || canvas.width, height || canvas.height);
-  var imageData = vtkImageData.newInstance({
+  let boundingBox = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [0, 0, 0, 0];
+  const [top, left, width, height] = boundingBox;
+  const ctxt = canvas.getContext('2d');
+  const idata = ctxt.getImageData(top, left, width || canvas.width, height || canvas.height);
+  const imageData = vtkImageData.newInstance({
     type: 'vtkImageData'
   });
   imageData.setOrigin(0, 0, 0);
   imageData.setSpacing(1, 1, 1);
   imageData.setExtent(0, (width || canvas.width) - 1, 0, (height || canvas.height) - 1, 0, 0);
-  var scalars = vtkDataArray.newInstance({
+  const scalars = vtkDataArray.newInstance({
     numberOfComponents: 4,
     values: new Uint8Array(idata.data.buffer)
   });
@@ -36,34 +28,34 @@ function canvasToImageData(canvas) {
   imageData.getPointData().setScalars(scalars);
   return imageData;
 }
+
 /**
  * Converts an Image object to a vtkImageData.
  */
-
-
 function imageToImageData(image) {
-  var transform = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
+  let transform = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
     flipX: false,
     flipY: false,
     rotate: 0
   };
-  var canvas = document.createElement('canvas');
+  const canvas = document.createElement('canvas');
   canvas.width = image.width;
   canvas.height = image.height;
-  var ctx = canvas.getContext('2d');
-  var flipX = transform.flipX,
-      flipY = transform.flipY,
-      rotate = transform.rotate;
+  const ctx = canvas.getContext('2d');
+  const {
+    flipX,
+    flipY,
+    rotate
+  } = transform;
   ctx.translate(canvas.width / 2, canvas.height / 2);
   ctx.scale(flipX ? -1 : 1, flipY ? -1 : 1);
   ctx.rotate(rotate * Math.PI / 180);
   ctx.drawImage(image, -image.width / 2, -image.height / 2);
   return canvasToImageData(canvas);
 }
-
 var ImageHelper = {
-  canvasToImageData: canvasToImageData,
-  imageToImageData: imageToImageData
+  canvasToImageData,
+  imageToImageData
 };
 
 export { ImageHelper as default };