@kitware/vtk.js 28.10.2 → 28.11.1

package/Proxy/Representations/VolumeRepresentationProxy.js

@@ -1,6 +1,4 @@
-import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
-import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';
 import vtkImageCropFilter from '../../Filters/General/ImageCropFilter.js';
 import vtkImageMapper from '../../Rendering/Core/ImageMapper.js';
@@ -9,35 +7,37 @@ import vtkVolume from '../../Rendering/Core/Volume.js';
 import vtkVolumeMapper from '../../Rendering/Core/VolumeMapper.js';
 import vtkAbstractRepresentationProxy from '../Core/AbstractRepresentationProxy.js';
 
+// ----------------------------------------------------------------------------
+
 function sum(a, b) {
   return a + b;
-} // ----------------------------------------------------------------------------
+}
 
+// ----------------------------------------------------------------------------
 
 function mean() {
   for (var _len = arguments.length, array = new Array(_len), _key = 0; _key < _len; _key++) {
     array[_key] = arguments[_key];
   }
-
   return array.reduce(sum, 0) / array.length;
-} // ----------------------------------------------------------------------------
+}
 
+// ----------------------------------------------------------------------------
 
 function updateDomains(dataset, dataArray, model, updateProp) {
-  var dataRange = dataArray.getRange();
-  var spacing = dataset.getSpacing();
-  var bounds = dataset.getBounds();
-
-  var _model$mapperX$getClo = model.mapperX.getClosestIJKAxis(),
-      xIJKAxis = _model$mapperX$getClo.ijkMode;
-
-  var _model$mapperY$getClo = model.mapperY.getClosestIJKAxis(),
-      yIJKAxis = _model$mapperY$getClo.ijkMode;
-
-  var _model$mapperZ$getClo = model.mapperZ.getClosestIJKAxis(),
-      zIJKAxis = _model$mapperZ$getClo.ijkMode;
-
-  var propToUpdate = {
+  const dataRange = dataArray.getRange();
+  const spacing = dataset.getSpacing();
+  const bounds = dataset.getBounds();
+  const {
+    ijkMode: xIJKAxis
+  } = model.mapperX.getClosestIJKAxis();
+  const {
+    ijkMode: yIJKAxis
+  } = model.mapperY.getClosestIJKAxis();
+  const {
+    ijkMode: zIJKAxis
+  } = model.mapperZ.getClosestIJKAxis();
+  const propToUpdate = {
     xSlice: {
       domain: {
         min: bounds[0],
@@ -86,59 +86,63 @@ function updateDomains(dataset, dataArray, model, updateProp) {
     windowWidth: propToUpdate.windowWidth.domain.max,
     windowLevel: Math.floor(mean(propToUpdate.windowLevel.domain.min, propToUpdate.windowLevel.domain.max))
   };
-} // ----------------------------------------------------------------------------
+}
 
+// ----------------------------------------------------------------------------
 
 function updateConfiguration(dataset, dataArray, _ref) {
-  _ref.mapper;
-      var property = _ref.property;
+  let {
+    mapper,
+    property
+  } = _ref;
   // Configuration
   // actor.getProperty().setInterpolationTypeToFastLinear();
   property.setInterpolationTypeToLinear();
-  var numberOfComponents = dataArray.getNumberOfComponents();
-  var scalarOpacityUnitDistance = vtkBoundingBox.getDiagonalLength(dataset.getBounds()) / Math.max.apply(Math, _toConsumableArray(dataset.getDimensions()));
-
-  for (var component = 0; component < numberOfComponents; component++) {
+  const numberOfComponents = dataArray.getNumberOfComponents();
+  const scalarOpacityUnitDistance = vtkBoundingBox.getDiagonalLength(dataset.getBounds()) / Math.max(...dataset.getDimensions());
+  for (let component = 0; component < numberOfComponents; component++) {
     // For better looking volume rendering
     // - distance in world coordinates a scalar opacity of 1.0
     property.setScalarOpacityUnitDistance(component, scalarOpacityUnitDistance);
-    var dataRange = dataArray.getRange(component); // - control how we emphasize surface boundaries
+    const dataRange = dataArray.getRange(component);
+    // - control how we emphasize surface boundaries
     //  => max should be around the average gradient magnitude for the
     //     volume or maybe average plus one std dev of the gradient magnitude
     //     (adjusted for spacing, this is a world coordinate gradient, not a
     //     pixel gradient)
     //  => max hack: (dataRange[1] - dataRange[0]) * 0.05
-
     property.setGradientOpacityMinimumValue(component, 0);
-    property.setGradientOpacityMaximumValue(component, (dataRange[1] - dataRange[0]) * 0.05); // - Use shading based on gradient
-
+    property.setGradientOpacityMaximumValue(component, (dataRange[1] - dataRange[0]) * 0.05);
+    // - Use shading based on gradient
     property.setShade(true);
-    property.setUseGradientOpacity(component, true); // - generic good default
-
+    property.setUseGradientOpacity(component, true);
+    // - generic good default
     property.setGradientOpacityMinimumOpacity(component, 0.0);
     property.setGradientOpacityMaximumOpacity(component, 1.0);
   }
-
   property.setAmbient(0.2);
   property.setDiffuse(0.7);
   property.setSpecular(0.3);
   property.setSpecularPower(8.0);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // vtkVolumeRepresentationProxy methods
 // ----------------------------------------------------------------------------
 
-
 function vtkVolumeRepresentationProxy(publicAPI, model) {
   // Set our className
-  model.classHierarchy.push('vtkVolumeRepresentationProxy'); // Volume
+  model.classHierarchy.push('vtkVolumeRepresentationProxy');
 
+  // Volume
   model.mapper = vtkVolumeMapper.newInstance();
   model.volume = vtkVolume.newInstance();
   model.property = model.volume.getProperty();
   model.cropFilter = vtkImageCropFilter.newInstance();
   model.mapper.setInputConnection(model.cropFilter.getOutputPort());
-  model.sourceDependencies.push(model.cropFilter); // Slices
+  model.sourceDependencies.push(model.cropFilter);
 
+  // Slices
   model.mapperX = vtkImageMapper.newInstance({
     slicingMode: vtkImageMapper.SlicingMode.X
   });
@@ -162,81 +166,68 @@ function vtkVolumeRepresentationProxy(publicAPI, model) {
   });
   model.mapperX.setInputConnection(model.cropFilter.getOutputPort());
   model.mapperY.setInputConnection(model.cropFilter.getOutputPort());
-  model.mapperZ.setInputConnection(model.cropFilter.getOutputPort()); // model.sourceDependencies.push(model.mapperX);
+  model.mapperZ.setInputConnection(model.cropFilter.getOutputPort());
+  // model.sourceDependencies.push(model.mapperX);
   // model.sourceDependencies.push(model.mapperY);
   // model.sourceDependencies.push(model.mapperZ);
-  // connect rendering pipeline
 
+  // connect rendering pipeline
   model.volume.setMapper(model.mapper);
-  model.volumes.push(model.volume); // Connect slice pipeline
+  model.volumes.push(model.volume);
 
+  // Connect slice pipeline
   model.actorX.setMapper(model.mapperX);
   model.actors.push(model.actorX);
   model.actorY.setMapper(model.mapperY);
   model.actors.push(model.actorY);
   model.actorZ.setMapper(model.mapperZ);
   model.actors.push(model.actorZ);
-
   function setInputData(inputDataset) {
-    var _publicAPI$getColorBy = publicAPI.getColorBy(),
-        _publicAPI$getColorBy2 = _slicedToArray(_publicAPI$getColorBy, 2),
-        name = _publicAPI$getColorBy2[0],
-        location = _publicAPI$getColorBy2[1];
-
+    const [name, location] = publicAPI.getColorBy();
     publicAPI.rescaleTransferFunctionToDataRange(name, location);
-    var lutProxy = publicAPI.getLookupTableProxy(name);
-    var pwfProxy = publicAPI.getPiecewiseFunctionProxy(name);
+    const lutProxy = publicAPI.getLookupTableProxy(name);
+    const pwfProxy = publicAPI.getPiecewiseFunctionProxy(name);
     model.property.setRGBTransferFunction(0, lutProxy.getLookupTable());
     model.property.setScalarOpacity(0, pwfProxy.getPiecewiseFunction());
     updateConfiguration(inputDataset, publicAPI.getDataArray(), model);
-
     if (model.sampleDistance < 0 || model.sampleDistance > 1) {
       publicAPI.setSampleDistance();
     }
-
     if (model.edgeGradient < 0 || model.edgeGradient > 1) {
       publicAPI.setEdgeGradient();
-    } // Update domains
-
-
-    var state = updateDomains(inputDataset, publicAPI.getDataArray(), model, publicAPI.updateProxyProperty);
-    publicAPI.set(state); // Check for 2D volumes
+    }
 
-    var numberOfDimensions = inputDataset.getDimensions().reduce(function (number, dimension) {
-      return number + (dimension > 1 ? 1 : 0);
-    }, 0);
+    // Update domains
+    const state = updateDomains(inputDataset, publicAPI.getDataArray(), model, publicAPI.updateProxyProperty);
+    publicAPI.set(state);
 
+    // Check for 2D volumes
+    const numberOfDimensions = inputDataset.getDimensions().reduce((number, dimension) => number + (dimension > 1 ? 1 : 0), 0);
     if (numberOfDimensions === 2) {
       publicAPI.setIs2DVolume(true);
     }
   }
-
   model.sourceDependencies.push({
-    setInputData: setInputData
-  }); // API ----------------------------------------------------------------------
+    setInputData
+  });
+
+  // API ----------------------------------------------------------------------
 
   /**
    *  Choose whether the input volume should be treated as a 2D volume
    *  (no volume rendering).
    */
-
-  publicAPI.setIs2DVolume = function (is2D) {
+  publicAPI.setIs2DVolume = is2D => {
     model.is2DVolume = is2D;
-
     if (is2D) {
       if (publicAPI.getVisibility()) {
         publicAPI.setSliceVisibility(true);
       }
-
       model.volume.setVisibility(false);
     }
   };
-
-  publicAPI.isVisible = function () {
-    return model.volume.getVisibility();
-  };
-
-  publicAPI.setVisibility = function (isVisible) {
+  publicAPI.isVisible = () => model.volume.getVisibility();
+  publicAPI.setVisibility = isVisible => {
     if (isVisible) {
       if (model.is2DVolume) {
         publicAPI.setSliceVisibility(true);
@@ -249,108 +240,88 @@ function vtkVolumeRepresentationProxy(publicAPI, model) {
       publicAPI.setSliceVisibility(false);
     }
   };
-
-  publicAPI.getVisibility = function () {
-    return model.volume.getVisibility() || publicAPI.getSliceVisibility();
-  };
-
+  publicAPI.getVisibility = () => model.volume.getVisibility() || publicAPI.getSliceVisibility();
   publicAPI.isVisible = publicAPI.getVisibility;
-
-  publicAPI.setSliceVisibility = function (isVisible) {
+  publicAPI.setSliceVisibility = isVisible => {
     if (isVisible && model.is2DVolume) {
-      var normalAxis = publicAPI.getInputDataSet().getDimensions().indexOf(1);
-
+      const normalAxis = publicAPI.getInputDataSet().getDimensions().indexOf(1);
       if (model.actors[normalAxis]) {
         model.actors[normalAxis].setVisibility(true);
       }
     } else {
-      model.actors.forEach(function (actor) {
-        return actor.setVisibility(isVisible);
-      });
+      model.actors.forEach(actor => actor.setVisibility(isVisible));
     }
   };
-
-  publicAPI.getSliceVisibility = function () {
-    return model.actorX.getVisibility() || model.actorY.getVisibility() || model.actorZ.getVisibility();
-  };
-
+  publicAPI.getSliceVisibility = () => model.actorX.getVisibility() || model.actorY.getVisibility() || model.actorZ.getVisibility();
   publicAPI.setSampleDistance = function () {
-    var distance = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0.4;
-
+    let distance = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0.4;
     if (model.sampleDistance !== distance) {
       model.sampleDistance = distance;
-      var sourceDS = publicAPI.getInputDataSet();
-      var sampleDistance = 0.7 * Math.sqrt(sourceDS.getSpacing().map(function (v) {
-        return v * v;
-      }).reduce(function (a, b) {
-        return a + b;
-      }, 0));
-      model.mapper.setSampleDistance(sampleDistance * Math.pow(2, distance * 3.0 - 1.5));
+      const sourceDS = publicAPI.getInputDataSet();
+      const sampleDistance = 0.7 * Math.sqrt(sourceDS.getSpacing().map(v => v * v).reduce((a, b) => a + b, 0));
+      model.mapper.setSampleDistance(sampleDistance * 2 ** (distance * 3.0 - 1.5));
       publicAPI.modified();
     }
   };
-
   publicAPI.setEdgeGradient = function () {
-    var edgeGradient = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0.2;
-
+    let edgeGradient = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0.2;
     if (model.edgeGradient !== edgeGradient) {
       model.edgeGradient = edgeGradient;
-      var dataArray = publicAPI.getDataArray();
-      var numberOfComponents = dataArray.getNumberOfComponents();
-
+      const dataArray = publicAPI.getDataArray();
+      const numberOfComponents = dataArray.getNumberOfComponents();
       if (edgeGradient === 0) {
-        for (var component = 0; component < numberOfComponents; component++) {
+        for (let component = 0; component < numberOfComponents; component++) {
           model.volume.getProperty().setUseGradientOpacity(component, false);
         }
       } else {
-        for (var _component = 0; _component < numberOfComponents; _component++) {
-          var dataRange = dataArray.getRange(_component);
-          model.volume.getProperty().setUseGradientOpacity(_component, true);
-          var minV = Math.max(0.0, edgeGradient - 0.3) / 0.7;
-
+        for (let component = 0; component < numberOfComponents; component++) {
+          const dataRange = dataArray.getRange(component);
+          model.volume.getProperty().setUseGradientOpacity(component, true);
+          const minV = Math.max(0.0, edgeGradient - 0.3) / 0.7;
           if (minV > 0.0) {
-            model.volume.getProperty().setGradientOpacityMinimumValue(_component, Math.exp(Math.log((dataRange[1] - dataRange[0]) * 0.2) * minV * minV));
+            model.volume.getProperty().setGradientOpacityMinimumValue(component, Math.exp(Math.log((dataRange[1] - dataRange[0]) * 0.2) * minV * minV));
           } else {
-            model.volume.getProperty().setGradientOpacityMinimumValue(_component, 0.0);
+            model.volume.getProperty().setGradientOpacityMinimumValue(component, 0.0);
           }
-
-          model.volume.getProperty().setGradientOpacityMaximumValue(_component, Math.exp(Math.log((dataRange[1] - dataRange[0]) * 1.0) * edgeGradient * edgeGradient));
+          model.volume.getProperty().setGradientOpacityMaximumValue(component, Math.exp(Math.log((dataRange[1] - dataRange[0]) * 1.0) * edgeGradient * edgeGradient));
         }
       }
-
       publicAPI.modified();
     }
   };
-
-  var parentSetColorBy = publicAPI.setColorBy;
-
+  const parentSetColorBy = publicAPI.setColorBy;
   publicAPI.setColorBy = function (arrayName, arrayLocation) {
-    var componentIndex = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : -1;
+    let componentIndex = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : -1;
     parentSetColorBy(arrayName, arrayLocation, componentIndex);
-    var lutProxy = publicAPI.getLookupTableProxy(arrayName);
-    var pwfProxy = publicAPI.getPiecewiseFunctionProxy(arrayName);
+    const lutProxy = publicAPI.getLookupTableProxy(arrayName);
+    const pwfProxy = publicAPI.getPiecewiseFunctionProxy(arrayName);
     model.property.setRGBTransferFunction(0, lutProxy.getLookupTable());
     model.property.setScalarOpacity(0, pwfProxy.getPiecewiseFunction());
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   sampleDistance: -1,
   edgeGradient: -1,
   disableSolidColor: true,
   is2DVolume: false
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues); // Object methods
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
 
+  // Object methods
   vtkAbstractRepresentationProxy.extend(publicAPI, model, initialValues);
-  macro.get(publicAPI, model, ['sampleDistance', 'edgeGradient', 'cropFilter', 'is2DVolume']); // Object specific methods
+  macro.get(publicAPI, model, ['sampleDistance', 'edgeGradient', 'cropFilter', 'is2DVolume']);
 
+  // Object specific methods
   vtkVolumeRepresentationProxy(publicAPI, model);
   macro.proxyPropertyMapping(publicAPI, model, {
     xSlice: {
@@ -398,14 +369,18 @@ function extend(publicAPI, model) {
       property: 'croppingPlanes'
     }
   });
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkVolumeRepresentationProxy'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkVolumeRepresentationProxy');
+
+// ----------------------------------------------------------------------------
 
 var vtkVolumeRepresentationProxy$1 = {
-  newInstance: newInstance,
-  extend: extend,
-  updateConfiguration: updateConfiguration
+  newInstance,
+  extend,
+  updateConfiguration
 };
 
 export { vtkVolumeRepresentationProxy$1 as default, extend, newInstance };

package/Proxy/Representations.js

@@ -7,13 +7,13 @@ import vtkSlicedGeometryRepresentationProxy from './Representations/SlicedGeomet
 import vtkVolumeRepresentationProxy from './Representations/VolumeRepresentationProxy.js';
 
 var Representations = {
-  vtkGeometryRepresentationProxy: vtkGeometryRepresentationProxy,
-  vtkGlyphRepresentationProxy: vtkGlyphRepresentationProxy,
-  vtkMoleculeRepresentationProxy: vtkMoleculeRepresentationProxy,
-  vtkSkyboxRepresentationProxy: vtkSkyboxRepresentationProxy,
-  vtkSliceRepresentationProxy: vtkSliceRepresentationProxy,
-  vtkSlicedGeometryRepresentationProxy: vtkSlicedGeometryRepresentationProxy,
-  vtkVolumeRepresentationProxy: vtkVolumeRepresentationProxy
+  vtkGeometryRepresentationProxy,
+  vtkGlyphRepresentationProxy,
+  vtkMoleculeRepresentationProxy,
+  vtkSkyboxRepresentationProxy,
+  vtkSliceRepresentationProxy,
+  vtkSlicedGeometryRepresentationProxy,
+  vtkVolumeRepresentationProxy
 };
 
 export { Representations as default };

package/Proxy/index.js

@@ -2,8 +2,8 @@ import Core from './Core.js';
 import Representations from './Representations.js';
 
 var VTKProxy = {
-  Core: Core,
-  Representations: Representations
+  Core,
+  Representations
 };
 
 export { VTKProxy as default };

package/README.md

@@ -35,7 +35,7 @@ vtk.js aims to be a subset of VTK and provide 3D rendering using WebGL (+WebGPU)
 VTK.js is a complete rewrite of VTK/C++ using plain JavaScript (ES6).
 The focus of the rewrite, so far, has been the rendering pipeline for ImageData and PolyData, the pipeline infrastructure, and frequently used readers (obj, stl, vtp, vti). Some filters are also provided as demonstrations. We are not aiming for vtk.js to provide the same set of filters that is available in VTK/C++, but vtk.js does provide the infrastructure needed to define pipelines and filters.
 
-We have also started to explore a path where you can compile some bits of VTK/C++ into WebAssembly and to enable them to interact with vtk.js. With such interaction, you can pick and choose what you need to extract from VTK and enable it inside your web application. VTK/C++ WebAssembly can even be used for rendering, and examples can be found in [VTK repository](https://github.com/Kitware/VTK/tree/master/Examples/Emscripten/Cxx). Additionally [itk.js](https://insightsoftwareconsortium.github.io/itk-js/index.html) (which is ITK via WebAssembly) also provides proven implementations for several image filters and data readers.  There are, however, some additional costs in terms of the size of the WebAssembly file that will have to be downloaded when visiting a VTK or ITK WebAssembly webpage; and we still have some work to do to streamline the vtk.js + VTK WebAssembly integrations.
+We have also started to explore a path where you can compile some bits of VTK/C++ into WebAssembly and to enable them to interact with vtk.js. With such interaction, you can pick and choose what you need to extract from VTK and enable it inside your web application. VTK/C++ WebAssembly can even be used for rendering, and examples can be found in [VTK repository](https://github.com/Kitware/VTK/tree/master/Examples/Emscripten/Cxx). Additionally [itk-wasm](https://github.com/InsightSoftwareConsortium/itk-wasm) (which is ITK via WebAssembly) also provides proven implementations for several image filters and data readers.  There are, however, some additional costs in terms of the size of the WebAssembly file that will have to be downloaded when visiting a VTK or ITK WebAssembly webpage; and we still have some work to do to streamline the vtk.js + VTK WebAssembly integrations.
 
 In general if you want to stay in the pure JavaScript land, then vtk.js is perhaps the ideal solution for you. We welcome your feedback, including your contributions for new visualization filters, bug fixes, and examples.
 

package/Rendering/Core/AbstractImageMapper/helper.js

@@ -9,50 +9,47 @@ import vtkPlane from '../../../Common/DataModel/Plane.js';
  * @param {Vector3} p2
  * @param {vtkImageMapper|vtkImageArrayMapper} mapper
  */
-
 function doPicking(p1, p2, mapper) {
-  var imageData = mapper.getCurrentImage();
-  var extent = imageData.getExtent(); // Slice origin
-
-  var ijk = [extent[0], extent[2], extent[4]];
-
-  var _mapper$getClosestIJK = mapper.getClosestIJKAxis(),
-      ijkMode = _mapper$getClosestIJK.ijkMode;
-
-  var nSlice = mapper.isA('vtkImageArrayMapper') ? mapper.getSubSlice() : mapper.getSlice();
-
+  const imageData = mapper.getCurrentImage();
+  const extent = imageData.getExtent();
+
+  // Slice origin
+  const ijk = [extent[0], extent[2], extent[4]];
+  const {
+    ijkMode
+  } = mapper.getClosestIJKAxis();
+  let nSlice = mapper.isA('vtkImageArrayMapper') ? mapper.getSubSlice() : mapper.getSlice();
   if (ijkMode !== mapper.getSlicingMode()) {
     // If not IJK slicing, get the IJK slice from the XYZ position/slice
     nSlice = mapper.getSliceAtPosition(nSlice);
   }
-
   ijk[ijkMode] += nSlice;
-  var worldOrigin = [0, 0, 0];
-  imageData.indexToWorld(ijk, worldOrigin); // Normal computation
+  const worldOrigin = [0, 0, 0];
+  imageData.indexToWorld(ijk, worldOrigin);
 
+  // Normal computation
   ijk[ijkMode] += 1;
-  var worldNormal = [0, 0, 0];
+  const worldNormal = [0, 0, 0];
   imageData.indexToWorld(ijk, worldNormal);
   worldNormal[0] -= worldOrigin[0];
   worldNormal[1] -= worldOrigin[1];
   worldNormal[2] -= worldOrigin[2];
   vec3.normalize(worldNormal, worldNormal);
-  var intersect = vtkPlane.intersectWithLine(p1, p2, worldOrigin, worldNormal);
-
+  const intersect = vtkPlane.intersectWithLine(p1, p2, worldOrigin, worldNormal);
   if (intersect.intersection) {
-    var point = intersect.x;
-    var absoluteIJK = [0, 0, 0];
-    imageData.worldToIndex(point, absoluteIJK); // `t` is the parametric position along the line
+    const point = intersect.x;
+    const absoluteIJK = [0, 0, 0];
+    imageData.worldToIndex(point, absoluteIJK);
+    // `t` is the parametric position along the line
     // defined in Plane.intersectWithLine
-
     return {
       t: intersect.t,
-      absoluteIJK: absoluteIJK
+      absoluteIJK
     };
   }
-
   return null;
 }
+
 /**
  * Implement point picking for image plane.
  * The plane is defined by the imageData and current slice number,
@@ -62,30 +59,28 @@ function doPicking(p1, p2, mapper) {
  * @param {Vector3} p2
  * @param {vtkImageMapper|vtkImageArrayMapper} mapper
  */
-
-
 function intersectWithLineForPointPicking(p1, p2, mapper) {
-  var pickingData = doPicking(p1, p2, mapper);
-
+  const pickingData = doPicking(p1, p2, mapper);
   if (pickingData) {
-    var imageData = mapper.getCurrentImage();
-    var extent = imageData.getExtent(); // Get closer integer ijk
-    // NB: point picking means closest slice, means rounding
+    const imageData = mapper.getCurrentImage();
+    const extent = imageData.getExtent();
 
-    var ijk = [Math.round(pickingData.absoluteIJK[0]), Math.round(pickingData.absoluteIJK[1]), Math.round(pickingData.absoluteIJK[2])]; // Are we outside our actual extent
+    // Get closer integer ijk
+    // NB: point picking means closest slice, means rounding
+    const ijk = [Math.round(pickingData.absoluteIJK[0]), Math.round(pickingData.absoluteIJK[1]), Math.round(pickingData.absoluteIJK[2])];
 
+    // Are we outside our actual extent
     if (ijk[0] < extent[0] || ijk[0] > extent[1] || ijk[1] < extent[2] || ijk[1] > extent[3] || ijk[2] < extent[4] || ijk[2] > extent[5]) {
       return null;
     }
-
     return {
       t: pickingData.t,
-      ijk: ijk
+      ijk
     };
   }
-
   return null;
 }
+
 /**
  * Implement cell picking for image plane.
  * The plane is defined by the imageData and current slice number,
@@ -95,32 +90,32 @@ function intersectWithLineForPointPicking(p1, p2, mapper) {
  * @param {Vector3} p2
  * @param {vtkImageMapper|vtkImageArrayMapper} mapper
  */
-
 function intersectWithLineForCellPicking(p1, p2, mapper) {
-  var pickingData = doPicking(p1, p2, mapper);
-
+  const pickingData = doPicking(p1, p2, mapper);
   if (pickingData) {
-    var imageData = mapper.getCurrentImage();
-    var extent = imageData.getExtent();
-    var absIJK = pickingData.absoluteIJK; // Get closer integer ijk
-    // NB: cell picking means closest voxel, means flooring
+    const imageData = mapper.getCurrentImage();
+    const extent = imageData.getExtent();
+    const absIJK = pickingData.absoluteIJK;
 
-    var ijk = [Math.floor(absIJK[0]), Math.floor(absIJK[1]), Math.floor(absIJK[2])]; // Are we outside our actual extent
+    // Get closer integer ijk
+    // NB: cell picking means closest voxel, means flooring
+    const ijk = [Math.floor(absIJK[0]), Math.floor(absIJK[1]), Math.floor(absIJK[2])];
 
-    if (ijk[0] < extent[0] || ijk[0] > extent[1] - 1 || ijk[1] < extent[2] || ijk[1] > extent[3] - 1 || ijk[2] < extent[4] || // handle single-slice images
+    // Are we outside our actual extent
+    if (ijk[0] < extent[0] || ijk[0] > extent[1] - 1 || ijk[1] < extent[2] || ijk[1] > extent[3] - 1 || ijk[2] < extent[4] ||
+    // handle single-slice images
     ijk[2] > (extent[5] ? extent[5] - 1 : extent[5])) {
       return null;
-    } // Parametric coordinates within cell
-
+    }
 
-    var pCoords = [absIJK[0] - ijk[0], absIJK[1] - ijk[1], absIJK[2] - ijk[2]];
+    // Parametric coordinates within cell
+    const pCoords = [absIJK[0] - ijk[0], absIJK[1] - ijk[1], absIJK[2] - ijk[2]];
     return {
       t: pickingData.t,
-      ijk: ijk,
-      pCoords: pCoords
+      ijk,
+      pCoords
     };
   }
-
   return null;
 }