@kitware/vtk.js 28.10.2 → 28.11.0

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/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;
 }