@kitware/vtk.js 28.10.2 → 28.11.1

package/Rendering/OpenGL/SurfaceLIC/SurfaceLICInterface.js

@@ -1,6 +1,4 @@
-import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
-import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
-import macro from '../../../macros.js';
+import { m as macro } from '../../../macros2.js';
 import vtkOpenGLTexture from '../Texture.js';
 import vtkDataArray from '../../../Common/Core/DataArray.js';
 import vtkHelper from '../Helper.js';
@@ -16,24 +14,25 @@ import seedrandom from 'seedrandom';
 import { NoiseType, ContrastEnhanceMode } from '../../Core/SurfaceLICInterface/Constants.js';
 import vtkSurfaceLICInterface from '../../Core/SurfaceLICInterface.js';
 
-var Representation = vtkProperty.Representation; // ----------------------------------------------------------------------------
+const {
+  Representation
+} = vtkProperty;
+
+// ----------------------------------------------------------------------------
 // vtkLICInterface methods
 // ----------------------------------------------------------------------------
-
 function getQuadPoly(openGLRenderWindow) {
-  var quad = vtkHelper.newInstance();
-  quad.setOpenGLRenderWindow(openGLRenderWindow); // build the CABO
-
-  var ptsArray = new Float32Array(12);
-
-  for (var i = 0; i < 4; i++) {
+  const quad = vtkHelper.newInstance();
+  quad.setOpenGLRenderWindow(openGLRenderWindow);
+  // build the CABO
+  const ptsArray = new Float32Array(12);
+  for (let i = 0; i < 4; i++) {
     ptsArray[i * 3] = i % 2 * 2 - 1.0;
     ptsArray[i * 3 + 1] = i > 1 ? 1.0 : -1.0;
     ptsArray[i * 3 + 2] = 0.0;
   }
-
-  var tCoord = new Float32Array([0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 1.0, 1.0]);
-  var cellArray = new Uint16Array(8);
+  const tCoord = new Float32Array([0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 1.0, 1.0]);
+  const cellArray = new Uint16Array(8);
   cellArray[0] = 3;
   cellArray[1] = 0;
   cellArray[2] = 1;
@@ -42,41 +41,37 @@ function getQuadPoly(openGLRenderWindow) {
   cellArray[5] = 0;
   cellArray[6] = 3;
   cellArray[7] = 2;
-  var points = vtkDataArray.newInstance({
+  const points = vtkDataArray.newInstance({
     numberOfComponents: 3,
     values: ptsArray
   });
   points.setName('points');
-  var cells = vtkDataArray.newInstance({
+  const cells = vtkDataArray.newInstance({
     numberOfComponents: 1,
     values: cellArray
   });
-  var tArray = vtkDataArray.newInstance({
+  const tArray = vtkDataArray.newInstance({
     numberOfComponents: 2,
     values: tCoord
   });
   quad.getCABO().createVBO(cells, 'polys', Representation.SURFACE, {
-    points: points,
+    points,
     cellOffset: 0,
     tcoords: tArray
   });
   return quad;
 }
-
 function vtkOpenGLSurfaceLICInterface(publicAPI, model) {
   model.classHierarchy.push('vtkOpenGLSurfaceLICInterface');
-
-  publicAPI.renderQuad = function (bounds, program) {
-    var poly = model.licQuad;
-    var gl = model.context;
-    var VAO = model.licQuadVAO;
-
+  publicAPI.renderQuad = (bounds, program) => {
+    const poly = model.licQuad;
+    const gl = model.context;
+    let VAO = model.licQuadVAO;
     if (!VAO) {
       VAO = vtkVertexArrayObject.newInstance();
       VAO.setOpenGLRenderWindow(model._openGLRenderWindow);
       model.licQuadVAO = VAO;
     }
-
     if (model.previousProgramHash !== program.getMd5Hash()) {
       VAO.shaderProgramChanged();
       poly.getCABO().bind();
@@ -84,149 +79,122 @@ function vtkOpenGLSurfaceLICInterface(publicAPI, model) {
       VAO.addAttributeArray(program, poly.getCABO(), 'tcoordDC', poly.getCABO().getTCoordOffset(), poly.getCABO().getStride(), model.context.FLOAT, 2, model.context.FALSE);
       model.previousProgramHash = program.getMd5Hash();
     }
-
     gl.drawArrays(gl.TRIANGLES, 0, poly.getCABO().getElementCount());
     VAO.release();
   };
-
   function generateGaussianNoise(length, numberOfNoiseLevels, noiseImpulseProbability, noiseImpulseBackgroundValue, min, max) {
-    var N = 2048;
-    var impulseProb = Math.max(0.0, Math.min(1.0, noiseImpulseProbability));
-    var noise = Float32Array.from({
+    const N = 2048;
+    const impulseProb = Math.max(0.0, Math.min(1.0, noiseImpulseProbability));
+    const noise = Float32Array.from({
       length: length * length
-    }, function () {
-      var val = 0;
-
+    }, () => {
+      let val = 0;
       if (impulseProb === 1.0 || Math.random() > 1.0 - impulseProb) {
-        for (var i = 0; i < N; ++i) {
+        for (let i = 0; i < N; ++i) {
           val += Math.random();
         }
       }
-
       return val;
-    }); // Normalize
-
-    var maxVal = 0.0;
-    var minVal = N + 1;
-    noise.forEach(function (val) {
+    });
+    // Normalize
+    let maxVal = 0.0;
+    let minVal = N + 1;
+    noise.forEach(val => {
       // Don't count 0s for minVal if impulseProb < 1.0
       if (impulseProb === 1.0) {
         minVal = val < minVal ? val : minVal;
       } else {
         minVal = val < minVal && val > 0.0 ? val : minVal;
       }
-
       maxVal = val > maxVal ? val : maxVal;
     });
-    var diff = maxVal - minVal;
-
+    let diff = maxVal - minVal;
     if (diff === 0.0) {
       minVal = 0.0;
-
       if (maxVal === 0.0) {
         diff = 1.0;
       } else {
         diff = maxVal;
       }
     }
-
-    var maxLevel = numberOfNoiseLevels - 1;
-    var delta = maxLevel !== 0 ? 1.0 / maxLevel : 0.0;
-    var noiseRange = max - min;
-    return noise.map(function (val) {
-      var normalized = val < minVal ? val : (val - minVal) / diff;
-      var l = Math.floor(normalized * numberOfNoiseLevels);
-      var quantized = l > maxLevel ? maxLevel : l;
-
+    const maxLevel = numberOfNoiseLevels - 1;
+    const delta = maxLevel !== 0 ? 1.0 / maxLevel : 0.0;
+    const noiseRange = max - min;
+    return noise.map(val => {
+      const normalized = val < minVal ? val : (val - minVal) / diff;
+      const l = Math.floor(normalized * numberOfNoiseLevels);
+      const quantized = l > maxLevel ? maxLevel : l;
       if (val >= minVal) {
         if (numberOfNoiseLevels === 1) {
           return max;
         }
-
         return min + quantized * delta * noiseRange;
       }
-
       return noiseImpulseBackgroundValue;
     });
   }
-
   function generateUniformNoise(_ref, numberOfNoiseLevels, min, max) {
-    var _ref2 = _slicedToArray(_ref, 2),
-        width = _ref2[0],
-        height = _ref2[1];
-
-    var diff = max - min;
+    let [width, height] = _ref;
+    const diff = max - min;
     return Float32Array.from({
       length: width * height
-    }, function () {
-      var r = Math.random();
+    }, () => {
+      let r = Math.random();
       r = Math.floor(r * numberOfNoiseLevels) / numberOfNoiseLevels;
       r = r * diff + min;
-
       if (r > 1.0) {
         return 1.0;
       }
-
       if (r < 0.0) {
         return 0.0;
       }
-
       return r;
     });
   }
-
-  publicAPI.generateNoiseTexture = function (length) {
+  publicAPI.generateNoiseTexture = length => {
     if (!model.noiseTexture || model.licInterface.getRebuildNoiseTexture()) {
       model.licInterface.setRebuildNoiseTexture(false);
-
       if (model.noiseTexture) {
         model.noiseTexture.releaseGraphicsResources();
-      } // Reseed RNG
-
-
+      }
+      // Reseed RNG
       seedrandom(model.noiseGeneratorSeed, {
         global: true
       });
-      var base = [];
-
-      var _model$licInterface$g = model.licInterface.get('noiseTextureType', 'noiseGrainSize', 'numberOfNoiseLevels', 'noiseImpulseProbability', 'noiseImpulseBackgroundValue', 'minNoiseValue', 'maxNoiseValue'),
-          noiseTextureType = _model$licInterface$g.noiseTextureType,
-          noiseGrainSize = _model$licInterface$g.noiseGrainSize,
-          numberOfNoiseLevels = _model$licInterface$g.numberOfNoiseLevels,
-          noiseImpulseProbability = _model$licInterface$g.noiseImpulseProbability,
-          noiseImpulseBackgroundValue = _model$licInterface$g.noiseImpulseBackgroundValue,
-          minNoiseValue = _model$licInterface$g.minNoiseValue,
-          maxNoiseValue = _model$licInterface$g.maxNoiseValue;
-
+      let base = [];
+      const {
+        noiseTextureType,
+        noiseGrainSize,
+        numberOfNoiseLevels,
+        noiseImpulseProbability,
+        noiseImpulseBackgroundValue,
+        minNoiseValue,
+        maxNoiseValue
+      } = model.licInterface.get('noiseTextureType', 'noiseGrainSize', 'numberOfNoiseLevels', 'noiseImpulseProbability', 'noiseImpulseBackgroundValue', 'minNoiseValue', 'maxNoiseValue');
       switch (noiseTextureType) {
         case NoiseType.GAUSSIAN:
           base = generateGaussianNoise(Math.floor(length / noiseGrainSize), numberOfNoiseLevels, noiseImpulseProbability, noiseImpulseBackgroundValue, minNoiseValue, maxNoiseValue);
           break;
-
         case NoiseType.UNIFORM:
         default:
           base = generateUniformNoise([Math.ceil(length / noiseGrainSize), Math.ceil(length / noiseGrainSize)], numberOfNoiseLevels, minNoiseValue, maxNoiseValue);
       }
-
-      var invGrainSize = 1.0 / noiseGrainSize;
-      var values = Float32Array.from({
+      const invGrainSize = 1.0 / noiseGrainSize;
+      const values = Float32Array.from({
         length: length * length * 4
-      }, function (val, index) {
-        var baseIndex = index / 4;
-
+      }, (val, index) => {
+        const baseIndex = index / 4;
         if (index % 4 === 0) {
-          var x = Math.floor(baseIndex % length * invGrainSize);
-          var y = Math.floor(baseIndex / length * invGrainSize);
+          const x = Math.floor(baseIndex % length * invGrainSize);
+          const y = Math.floor(baseIndex / length * invGrainSize);
           return base[y * (length / noiseGrainSize) + x];
         }
-
         if (index % 4 === 1 || index % 4 === 3) {
           return 1.0;
         }
-
         return 0.0;
       });
-      var texture = vtkOpenGLTexture.newInstance({
+      const texture = vtkOpenGLTexture.newInstance({
         wrapS: vtkOpenGLTexture.Wrap.REPEAT,
         wrapT: vtkOpenGLTexture.Wrap.REPEAT,
         minificationFilter: vtkOpenGLTexture.Filter.NEAREST,
@@ -245,48 +213,36 @@ function vtkOpenGLSurfaceLICInterface(publicAPI, model) {
       model.noiseTexture = texture;
     }
   };
-
-  publicAPI.buildAShader = function (fSource) {
-    return model._openGLRenderWindow.getShaderCache().readyShaderProgramArray(vtkLineIntegralConvolution2D_quadVS, fSource, '');
-  };
-
-  publicAPI.allocateTextures = function () {
-    var nearest = vtkOpenGLTexture.Filter.NEAREST;
-    var linear = vtkOpenGLTexture.Filter.LINEAR;
-    var rw = model._openGLRenderWindow;
-
+  publicAPI.buildAShader = fSource => model._openGLRenderWindow.getShaderCache().readyShaderProgramArray(vtkLineIntegralConvolution2D_quadVS, fSource, '');
+  publicAPI.allocateTextures = () => {
+    const nearest = vtkOpenGLTexture.Filter.NEAREST;
+    const linear = vtkOpenGLTexture.Filter.LINEAR;
+    const rw = model._openGLRenderWindow;
     if (!model.geometryImage) {
       model.geometryImage = publicAPI.allocateTexture(rw, nearest);
     }
-
     if (!model.vectorImage) {
       model.vectorImage = publicAPI.allocateTexture(rw, linear);
     }
-
     if (!model.maskVectorImage) {
       model.maskVectorImage = publicAPI.allocateTexture(rw, linear);
     }
-
     if (!model.LICImage) {
       model.LICImage = publicAPI.allocateTexture(rw, nearest);
     }
-
     if (!model.RGBColorImage) {
       model.RGBColorImage = publicAPI.allocateTexture(rw, nearest);
     }
-
     if (!model.HSLColorImage) {
       model.HSLColorImage = publicAPI.allocateTexture(rw, nearest);
     }
-
     if (!model.depthTexture) {
       model.depthTexture = publicAPI.allocateDepthTexture(rw);
     }
   };
-
-  publicAPI.allocateTexture = function (openGLRenderWindow, filter) {
-    var gl = model.context;
-    var texture = vtkOpenGLTexture.newInstance({
+  publicAPI.allocateTexture = (openGLRenderWindow, filter) => {
+    const gl = model.context;
+    const texture = vtkOpenGLTexture.newInstance({
       wrapS: vtkOpenGLTexture.Wrap.CLAMP_TO_EDGE,
       wrapT: vtkOpenGLTexture.Wrap.CLAMP_TO_EDGE,
       minificationFilter: filter,
@@ -299,45 +255,41 @@ function vtkOpenGLSurfaceLICInterface(publicAPI, model) {
     });
     texture.setOpenGLRenderWindow(openGLRenderWindow);
     texture.setInternalFormat(gl.RGBA32F);
-    texture.create2DFromRaw.apply(texture, _toConsumableArray(model.size).concat([4, 'Float32Array', null]));
+    texture.create2DFromRaw(...model.size, 4, 'Float32Array', null);
     texture.activate();
     texture.sendParameters();
     texture.deactivate();
     return texture;
   };
-
-  publicAPI.allocateDepthTexture = function (openGLRenderWindow) {
-    var gl = model.context;
-    var texture = vtkOpenGLTexture.newInstance({
+  publicAPI.allocateDepthTexture = openGLRenderWindow => {
+    const gl = model.context;
+    const texture = vtkOpenGLTexture.newInstance({
       generateMipmap: false,
       openGLDataType: gl.FLOAT,
       autoParameters: false
     });
     texture.setOpenGLRenderWindow(openGLRenderWindow);
-    texture.createDepthFromRaw.apply(texture, _toConsumableArray(model.size).concat(['Float32Array', null]));
+    texture.createDepthFromRaw(...model.size, 'Float32Array', null);
     texture.activate();
     texture.sendParameters();
     texture.deactivate();
     return texture;
   };
-
-  publicAPI.createFBO = function () {
+  publicAPI.createFBO = () => {
     if (!model.framebuffer) {
       model.licHelper = null; // All buffers need rebuilding
-
-      var fb = vtkOpenGLFramebuffer.newInstance();
+      const fb = vtkOpenGLFramebuffer.newInstance();
       fb.setOpenGLRenderWindow(model._openGLRenderWindow);
       fb.saveCurrentBindingsAndBuffers();
-      fb.create.apply(fb, _toConsumableArray(model.size));
+      fb.create(...model.size);
       fb.populateFramebuffer();
       model.framebuffer = fb;
       fb.restorePreviousBindingsAndBuffers();
     }
   };
-
-  publicAPI.completedGeometry = function () {
-    var gl = model.context;
-    var fb = model.framebuffer;
+  publicAPI.completedGeometry = () => {
+    const gl = model.context;
+    const fb = model.framebuffer;
     fb.removeColorBuffer(0);
     fb.removeColorBuffer(1);
     fb.removeColorBuffer(2);
@@ -345,8 +297,7 @@ function vtkOpenGLSurfaceLICInterface(publicAPI, model) {
     gl.drawBuffers([gl.NONE]);
     fb.restorePreviousBindingsAndBuffers();
   };
-
-  publicAPI.buildAllShaders = function () {
+  publicAPI.buildAllShaders = () => {
     if (model.shadersNeedBuilding) {
       model.licColorPass = publicAPI.buildAShader(vtkLineIntegralConvolution2D_SC);
       model.licCopyPass = publicAPI.buildAShader(vtkSurfaceLICInterface_DCpy);
@@ -354,32 +305,28 @@ function vtkOpenGLSurfaceLICInterface(publicAPI, model) {
       model.shadersNeedBuilding = false;
     }
   };
-
-  publicAPI.initializeResources = function () {
+  publicAPI.initializeResources = () => {
     publicAPI.createFBO();
     publicAPI.generateNoiseTexture(model.licInterface.getNoiseTextureSize());
     publicAPI.allocateTextures();
     publicAPI.buildAllShaders();
-
     if (!model.licQuad) {
       model.licQuad = getQuadPoly(model._openGLRenderWindow);
     }
-
     if (!model.licHelper) {
       model.licHelper = vtkLineIntegralConvolution2D.newInstance();
     }
   };
-
-  publicAPI.prepareForGeometry = function () {
-    var fb = model.framebuffer;
+  publicAPI.prepareForGeometry = () => {
+    const fb = model.framebuffer;
     fb.saveCurrentBindingsAndBuffers();
     fb.bind();
     model.geometryImage.activate();
     model.vectorImage.activate();
-    model.maskVectorImage.activate(); // Don't use location 1 as it can be used by order independant translucent pass
+    model.maskVectorImage.activate();
+    // Don't use location 1 as it can be used by order independant translucent pass
     // Translucent pass uses location 1 because of this line:
     // gl_FragData[1].r = weight;
-
     fb.removeColorBuffer(0);
     fb.removeColorBuffer(2);
     fb.removeColorBuffer(3);
@@ -387,34 +334,30 @@ function vtkOpenGLSurfaceLICInterface(publicAPI, model) {
     fb.setColorBuffer(model.vectorImage, 2);
     fb.setColorBuffer(model.maskVectorImage, 3);
     fb.setDepthBuffer(model.depthTexture);
-    var gl = model.context;
+    const gl = model.context;
     gl.drawBuffers([gl.COLOR_ATTACHMENT0, gl.NONE, gl.COLOR_ATTACHMENT2, gl.COLOR_ATTACHMENT3]);
-    gl.viewport.apply(gl, [0, 0].concat(_toConsumableArray(model.size)));
-    gl.scissor.apply(gl, [0, 0].concat(_toConsumableArray(model.size)));
+    gl.viewport(0, 0, ...model.size);
+    gl.scissor(0, 0, ...model.size);
     gl.disable(gl.BLEND);
     gl.disable(gl.DEPTH_TEST);
     gl.disable(gl.SCISSOR_TEST);
-    gl.clearColor(0.0, 0.0, 0.0, 0.0); // eslint-disable-next-line no-bitwise
-
+    gl.clearColor(0.0, 0.0, 0.0, 0.0);
+    // eslint-disable-next-line no-bitwise
     gl.clear(gl.DEPTH_BUFFER_BIT | gl.COLOR_BUFFER_BIT);
-  }; // Copies the LIC image to the renderWindow. Will try to upscale the image to match the rw's size.
-
+  };
 
-  publicAPI.copyToScreen = function (windowSize) {
+  // Copies the LIC image to the renderWindow. Will try to upscale the image to match the rw's size.
+  publicAPI.copyToScreen = windowSize => {
     model.RGBColorImage.activate();
     model.depthTexture.activate();
-
     if (!model.licCopyPass) {
       publicAPI.initializeResources();
     }
-
-    var copyPass = model.licCopyPass;
-
+    const copyPass = model.licCopyPass;
     model._openGLRenderWindow.getShaderCache().readyShaderProgram(copyPass);
-
-    var gl = model.context;
-    gl.viewport.apply(gl, [0, 0].concat(_toConsumableArray(windowSize)));
-    gl.scissor.apply(gl, [0, 0].concat(_toConsumableArray(windowSize)));
+    const gl = model.context;
+    gl.viewport(0, 0, ...windowSize);
+    gl.scissor(0, 0, ...windowSize);
     gl.disable(gl.BLEND);
     gl.enable(gl.DEPTH_TEST);
     gl.disable(gl.SCISSOR_TEST);
@@ -424,13 +367,12 @@ function vtkOpenGLSurfaceLICInterface(publicAPI, model) {
     model.RGBColorImage.deactivate();
     model.depthTexture.deactivate();
   };
-
-  publicAPI.combineColorsAndLIC = function () {
-    var gl = model.context;
-    var fb = model.framebuffer;
+  publicAPI.combineColorsAndLIC = () => {
+    const gl = model.context;
+    const fb = model.framebuffer;
     fb.saveCurrentBindingsAndBuffers();
     fb.bind();
-    fb.create.apply(fb, _toConsumableArray(model.size));
+    fb.create(...model.size);
     fb.removeColorBuffer(0);
     fb.removeColorBuffer(1);
     fb.setColorBuffer(model.RGBColorImage, 0);
@@ -442,34 +384,29 @@ function vtkOpenGLSurfaceLICInterface(publicAPI, model) {
     model.vectorImage.activate();
     model.geometryImage.activate();
     model.LICImage.activate();
-
     if (!model.licColorPass) {
       publicAPI.initializeResources();
     }
-
-    var colorPass = model.licColorPass;
-
+    const colorPass = model.licColorPass;
     model._openGLRenderWindow.getShaderCache().readyShaderProgram(colorPass);
-
     colorPass.setUniformi('texVectors', model.vectorImage.getTextureUnit());
     colorPass.setUniformi('texGeomColors', model.geometryImage.getTextureUnit());
-
-    var _model$licInterface$g2 = model.licInterface.get('colorMode', 'LICIntensity', 'mapModeBias', 'maskIntensity', 'maskColor', 'enhanceContrast', 'lowColorContrastEnhancementFactor', 'highColorContrastEnhancementFactor'),
-        colorMode = _model$licInterface$g2.colorMode,
-        LICIntensity = _model$licInterface$g2.LICIntensity,
-        mapModeBias = _model$licInterface$g2.mapModeBias,
-        maskIntensity = _model$licInterface$g2.maskIntensity,
-        maskColor = _model$licInterface$g2.maskColor,
-        enhanceContrast = _model$licInterface$g2.enhanceContrast,
-        lowColorContrastEnhancementFactor = _model$licInterface$g2.lowColorContrastEnhancementFactor,
-        highColorContrastEnhancementFactor = _model$licInterface$g2.highColorContrastEnhancementFactor;
-
+    const {
+      colorMode,
+      LICIntensity,
+      mapModeBias,
+      maskIntensity,
+      maskColor,
+      enhanceContrast,
+      lowColorContrastEnhancementFactor,
+      highColorContrastEnhancementFactor
+    } = model.licInterface.get('colorMode', 'LICIntensity', 'mapModeBias', 'maskIntensity', 'maskColor', 'enhanceContrast', 'lowColorContrastEnhancementFactor', 'highColorContrastEnhancementFactor');
     colorPass.setUniformi('texLIC', model.LICImage.getTextureUnit());
     colorPass.setUniformi('uScalarColorMode', colorMode);
     colorPass.setUniformf('uLICIntensity', LICIntensity);
     colorPass.setUniformf('uMapBias', mapModeBias);
     colorPass.setUniformf('uMaskIntensity', maskIntensity);
-    colorPass.setUniform3f.apply(colorPass, ['uMaskColor'].concat(_toConsumableArray(maskColor)));
+    colorPass.setUniform3f('uMaskColor', ...maskColor);
     publicAPI.renderQuad(model.size, colorPass);
     model.vectorImage.deactivate();
     model.geometryImage.deactivate();
@@ -477,12 +414,11 @@ function vtkOpenGLSurfaceLICInterface(publicAPI, model) {
     fb.removeColorBuffer(0);
     fb.removeColorBuffer(1);
     gl.drawBuffers([gl.NONE]);
-
     if (enhanceContrast === ContrastEnhanceMode.COLOR || enhanceContrast === ContrastEnhanceMode.BOTH) {
       // min and max luminance values. Most of the time close to 0 and 1
-      var min = 0.0;
-      var max = 1.0;
-      var lDiff = max - min;
+      let min = 0.0;
+      let max = 1.0;
+      let lDiff = max - min;
       min += lDiff * lowColorContrastEnhancementFactor;
       max -= lDiff * highColorContrastEnhancementFactor;
       lDiff = max - min;
@@ -491,15 +427,13 @@ function vtkOpenGLSurfaceLICInterface(publicAPI, model) {
       model.geometryImage.activate();
       model.HSLColorImage.activate();
       model.LICImage.activate();
-
       if (!model.enhanceContrastPass) {
         publicAPI.initializeResources();
       }
-
-      var enhanceContrastPass = model.enhanceContrastPass;
-
+      const {
+        enhanceContrastPass
+      } = model;
       model._openGLRenderWindow.getShaderCache().readyShaderProgram(enhanceContrastPass);
-
       enhanceContrastPass.setUniformi('texGeomColors', model.geometryImage.getTextureUnit());
       enhanceContrastPass.setUniformi('texHSLColors', model.HSLColorImage.getTextureUnit());
       enhanceContrastPass.setUniformi('texLIC', model.LICImage.getTextureUnit());
@@ -512,24 +446,19 @@ function vtkOpenGLSurfaceLICInterface(publicAPI, model) {
       fb.removeColorBuffer(0);
       gl.drawBuffers([gl.NONE]);
     }
-
     fb.restorePreviousBindingsAndBuffers();
   };
-
-  publicAPI.applyLIC = function () {
-    var options = model.licInterface.get('stepSize', 'numberOfSteps', 'enhancedLIC', 'enhanceContrast', 'lowLICContrastEnhancementFactor', 'highLICContrastEnhancementFactor', 'antiAlias', 'normalizeVectors', 'maskThreshold', 'transformVectors');
-    var resultTexture = model.licHelper.executeLIC(model.size, model.vectorImage, model.maskVectorImage, model.noiseTexture, model._openGLRenderWindow, options);
-
+  publicAPI.applyLIC = () => {
+    const options = model.licInterface.get('stepSize', 'numberOfSteps', 'enhancedLIC', 'enhanceContrast', 'lowLICContrastEnhancementFactor', 'highLICContrastEnhancementFactor', 'antiAlias', 'normalizeVectors', 'maskThreshold', 'transformVectors');
+    const resultTexture = model.licHelper.executeLIC(model.size, model.vectorImage, model.maskVectorImage, model.noiseTexture, model._openGLRenderWindow, options);
     if (!resultTexture) {
       console.error('Failed to compute image LIC');
       model.LICImage = null;
       return;
     }
-
     model.LICImage = resultTexture;
   };
-
-  publicAPI.setSize = function (size) {
+  publicAPI.setSize = size => {
     // If size changed, reallocate fb and textures
     if (Array.isArray(size) && size.length === 2) {
       if (!model.size || model.size[0] !== size[0] || model.size[1] !== size[1]) {
@@ -538,51 +467,42 @@ function vtkOpenGLSurfaceLICInterface(publicAPI, model) {
       }
     }
   };
-
-  publicAPI.releaseGraphicsResources = function () {
+  publicAPI.releaseGraphicsResources = () => {
     if (model.geometryImage) {
       model.geometryImage.releaseGraphicsResources();
       model.geometryImage = null;
     }
-
     if (model.vectorImage) {
       model.vectorImage.releaseGraphicsResources();
       model.vectorImage = null;
     }
-
     if (model.maskVectorImage) {
       model.maskVectorImage.releaseGraphicsResources();
       model.maskVectorImage = null;
     }
-
     if (model.LICImage) {
       model.LICImage.releaseGraphicsResources();
       model.LICImage = null;
     }
-
     if (model.RGBColorImage) {
       model.RGBColorImage.releaseGraphicsResources();
       model.RGBColorImage = null;
     }
-
     if (model.HSLColorImage) {
       model.HSLColorImage.releaseGraphicsResources();
       model.HSLColorImage = null;
     }
-
     if (model.depthTexture) {
       model.depthTexture.releaseGraphicsResources();
       model.depthTexture = null;
     }
-
     if (model.framebuffer) {
       model.framebuffer.releaseGraphicsResources();
       model.framebuffer = null;
     }
   };
 }
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   context: null,
   // _openGLRenderWindow: null,
   shadersNeedBuilding: true,
@@ -591,22 +511,28 @@ var DEFAULT_VALUES = {
   licInterface: null
 };
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues); // Inherit
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
 
+  // Inherit
   vtkSurfaceLICInterface.extend(publicAPI, model, initialValues);
   macro.obj(publicAPI, model);
   macro.setGet(publicAPI, model, ['context', '_openGLRenderWindow', 'reallocateTextures', 'licInterface', 'size']);
-  macro.moveToProtected(publicAPI, model, ['openGLRenderWindow']); // Object methods
+  macro.moveToProtected(publicAPI, model, ['openGLRenderWindow']);
 
+  // Object methods
   vtkOpenGLSurfaceLICInterface(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkSurfaceLICInterface');
 
-var newInstance = macro.newInstance(extend, 'vtkSurfaceLICInterface'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 var vtkOpenGLSurfaceLICInterface$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkOpenGLSurfaceLICInterface$1 as default, extend, newInstance };