@kitware/vtk.js 28.10.2 → 28.11.1

package/Rendering/Core/ScalarBarActor.js

@@ -1,8 +1,6 @@
-import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import * as d3 from 'd3-scale';
 import { N as nearestPowerOfTwo } from '../../Common/Core/Math/index.js';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkActor from './Actor.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
 import vtkScalarsToColors from '../../Common/Core/ScalarsToColors.js';
@@ -10,10 +8,11 @@ import vtkMapper from './Mapper.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';
 import vtkTexture from './Texture.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; }
+const {
+  VectorMode
+} = vtkScalarsToColors;
 
-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; }
-var VectorMode = vtkScalarsToColors.VectorMode; // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 // vtkScalarBarActor
 //
 // Note log scales are currently not supported
@@ -33,10 +32,13 @@ function applyTextStyle(ctx, style) {
   ctx.strokeStyle = style.strokeColor;
   ctx.lineWidth = style.strokeSize;
   ctx.fillStyle = style.fontColor;
-  ctx.font = "".concat(style.fontStyle, " ").concat(style.fontSize, "px ").concat(style.fontFamily);
-} // ----------------------------------------------------------------------------
+  ctx.font = `${style.fontStyle} ${style.fontSize}px ${style.fontFamily}`;
+}
+
+// ----------------------------------------------------------------------------
 // Default autoLayout function
 // ----------------------------------------------------------------------------
+
 // compute good values to use based on window size etc a bunch of heuristics
 // here with hand tuned constants These values worked for me but really this
 // method could be redically changed. The basic gist is
@@ -53,41 +55,42 @@ function applyTextStyle(ctx, style) {
 // instance that is provided as those values are the ones that will be used
 // for rendering.
 //
-
-
 function defaultAutoLayout(publicAPI, model) {
-  return function (helper) {
+  return helper => {
     // we don't do a linear scale, the proportions for
     // a 700 pixel window differ from a 1400
-    var lastSize = helper.getLastSize();
-    var xAxisAdjust = Math.pow(lastSize[0] / 700, 0.8);
-    var yAxisAdjust = Math.pow(lastSize[1] / 700, 0.8);
-    var minAdjust = Math.min(xAxisAdjust, yAxisAdjust);
-    var axisTextStyle = helper.getAxisTextStyle();
-    var tickTextStyle = helper.getTickTextStyle();
+    const lastSize = helper.getLastSize();
+    const xAxisAdjust = (lastSize[0] / 700) ** 0.8;
+    const yAxisAdjust = (lastSize[1] / 700) ** 0.8;
+    const minAdjust = Math.min(xAxisAdjust, yAxisAdjust);
+    const axisTextStyle = helper.getAxisTextStyle();
+    const tickTextStyle = helper.getTickTextStyle();
     Object.assign(axisTextStyle, model.axisTextStyle);
-    Object.assign(tickTextStyle, model.tickTextStyle); // compute a reasonable font size first
+    Object.assign(tickTextStyle, model.tickTextStyle);
 
+    // compute a reasonable font size first
     axisTextStyle.fontSize = Math.max(24 * minAdjust, 12);
-
     if (helper.getLastAspectRatio() > 1.0) {
       tickTextStyle.fontSize = Math.max(20 * minAdjust, 10);
     } else {
       tickTextStyle.fontSize = Math.max(16 * minAdjust, 10);
-    } // rebuild the text atlas
+    }
 
+    // rebuild the text atlas
+    const textSizes = helper.updateTextureAtlas();
 
-    var textSizes = helper.updateTextureAtlas(); // now compute the boxSize and pixel offsets, different algorithm
+    // now compute the boxSize and pixel offsets, different algorithm
     // for horizonal versus vertical
-
     helper.setTopTitle(false);
-    var boxSize = helper.getBoxSizeByReference(); // if vertical
+    const boxSize = helper.getBoxSizeByReference();
 
+    // if vertical
     if (helper.getLastAspectRatio() > 1.0) {
-      helper.setTickLabelPixelOffset(0.3 * tickTextStyle.fontSize); // if the title will fit within the width of the bar then that looks
+      helper.setTickLabelPixelOffset(0.3 * tickTextStyle.fontSize);
+
+      // if the title will fit within the width of the bar then that looks
       // nicer to put it at the top (helper.topTitle), otherwise rotate it
       // and place it sideways
-
       if (textSizes.titleWidth <= textSizes.tickWidth + helper.getTickLabelPixelOffset() + 0.8 * tickTextStyle.fontSize) {
         helper.setTopTitle(true);
         helper.setAxisTitlePixelOffset(0.2 * tickTextStyle.fontSize);
@@ -98,60 +101,59 @@ function defaultAutoLayout(publicAPI, model) {
         boxSize[0] = 2.0 * (textSizes.titleHeight + helper.getAxisTitlePixelOffset() + textSizes.tickWidth + helper.getTickLabelPixelOffset() + 0.8 * tickTextStyle.fontSize) / lastSize[0];
         helper.setBoxPosition([0.99 - boxSize[0], -0.92]);
       }
-
       boxSize[1] = Math.max(1.2, Math.min(1.84 / yAxisAdjust, 1.84));
     } else {
       // horizontal
       helper.setAxisTitlePixelOffset(1.2 * tickTextStyle.fontSize);
       helper.setTickLabelPixelOffset(0.1 * tickTextStyle.fontSize);
-      var titleHeight = // total offset from top of bar (includes ticks)
+      const titleHeight =
+      // total offset from top of bar (includes ticks)
       2.0 * (0.8 * tickTextStyle.fontSize + textSizes.titleHeight + helper.getAxisTitlePixelOffset()) / lastSize[1];
-      var tickWidth = 2.0 * textSizes.tickWidth / lastSize[0];
+      const tickWidth = 2.0 * textSizes.tickWidth / lastSize[0];
       boxSize[0] = Math.min(1.9, Math.max(1.4, 1.4 * tickWidth * (helper.getTicks().length + 3)));
       boxSize[1] = titleHeight;
       helper.setBoxPosition([-0.5 * boxSize[0], -0.97]);
-    } // recomute bar segments based on positioning
-
+    }
 
+    // recomute bar segments based on positioning
     helper.recomputeBarSegments(textSizes);
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Default generateTicks function
 // ----------------------------------------------------------------------------
+
 // This function returns the default function used to generate vtkScalarBarActor ticks.
 // The default function makes use of d3.scaleLinear() to generate 5 tick marks between
 // the minimum and maximum values of the scalar bar. Customize this behavior by passing
 // a function to vtkScalarBarActor.newInstance({ generateTicks: customGenerateTicks })
 // or by calling scalarBarActor.setGenerateTicks(customGenerateTicks).
-
-
 function defaultGenerateTicks(publicApi, model) {
-  return function (helper) {
-    var lastTickBounds = helper.getLastTickBounds();
-    var scale = d3.scaleLinear().domain([lastTickBounds[0], lastTickBounds[1]]);
-    var ticks = scale.ticks(5);
-    var format = scale.tickFormat(5);
+  return helper => {
+    const lastTickBounds = helper.getLastTickBounds();
+    const scale = d3.scaleLinear().domain([lastTickBounds[0], lastTickBounds[1]]);
+    const ticks = scale.ticks(5);
+    const format = scale.tickFormat(5);
     helper.setTicks(ticks);
     helper.setTickStrings(ticks.map(format));
   };
-} // many properties of this actor depend on the API specific view The main
+}
+
+// many properties of this actor depend on the API specific view The main
 // dependency being the resolution as that drives what font sizes to use.
 // Bacause of this we need to do some of the calculations in a API specific
 // subclass. But... we don't want a lot of duplicated code between WebGL and
 // WebGPU for example so we have this helper class, that is designed to be
 // fairly API independent so that API specific views can call this to do
 // most of the work.
-
-
 function vtkScalarBarActorHelper(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkScalarBarActorHelper');
-
-  publicAPI.setRenderable = function (renderable) {
+  publicAPI.setRenderable = renderable => {
     if (model.renderable === renderable) {
       return;
     }
-
     model.renderable = renderable;
     model.barActor.setProperty(renderable.getProperty());
     model.barActor.setParentProp(renderable);
@@ -160,12 +162,15 @@ function vtkScalarBarActorHelper(publicAPI, model) {
     model.tmActor.setParentProp(renderable);
     model.tmActor.setCoordinateSystemToDisplay();
     model.generateTicks = renderable.generateTicks;
-    model.axisTextStyle = _objectSpread({}, renderable.getAxisTextStyle());
-    model.tickTextStyle = _objectSpread({}, renderable.getTickTextStyle());
+    model.axisTextStyle = {
+      ...renderable.getAxisTextStyle()
+    };
+    model.tickTextStyle = {
+      ...renderable.getTickTextStyle()
+    };
     publicAPI.modified();
   };
-
-  publicAPI.updateAPISpecificData = function (size, camera, renderWindow) {
+  publicAPI.updateAPISpecificData = (size, camera, renderWindow) => {
     // has the size changed?
     if (model.lastSize[0] !== size[0] || model.lastSize[1] !== size[1]) {
       model.lastSize[0] = size[0];
@@ -173,68 +178,74 @@ function vtkScalarBarActorHelper(publicAPI, model) {
       model.lastAspectRatio = size[0] / size[1];
       model.forceUpdate = true;
     }
-
-    var scalarsToColors = model.renderable.getScalarsToColors();
-
+    const scalarsToColors = model.renderable.getScalarsToColors();
     if (!scalarsToColors || !model.renderable.getVisibility()) {
       return;
-    } // make sure the lut is assigned to our mapper
-
+    }
 
-    model.barMapper.setLookupTable(scalarsToColors); // camera should be the same for all views
+    // make sure the lut is assigned to our mapper
+    model.barMapper.setLookupTable(scalarsToColors);
 
+    // camera should be the same for all views
     model.camera = camera;
-    model.renderWindow = renderWindow; // did something significant change? If so rebuild a lot of things
+    model.renderWindow = renderWindow;
 
+    // did something significant change? If so rebuild a lot of things
     if (model.forceUpdate || Math.max(scalarsToColors.getMTime(), publicAPI.getMTime(), model.renderable.getMTime()) > model.lastRebuildTime.getMTime()) {
-      var range = scalarsToColors.getMappingRange();
-      model.lastTickBounds = _toConsumableArray(range); // compute tick marks for axes (update for log scale)
+      const range = scalarsToColors.getMappingRange();
+      model.lastTickBounds = [...range];
 
+      // compute tick marks for axes (update for log scale)
       model.renderable.getGenerateTicks()(publicAPI);
-
       if (model.renderable.getAutomated()) {
         model.renderable.getAutoLayout()(publicAPI);
       } else {
         // copy values from renderable
-        model.axisTextStyle = _objectSpread({}, model.renderable.getAxisTextStyle());
-        model.tickTextStyle = _objectSpread({}, model.renderable.getTickTextStyle());
-        model.barPosition = _toConsumableArray(model.renderable.getBarPosition());
-        model.barSize = _toConsumableArray(model.renderable.getBarSize());
-        model.boxPosition = _toConsumableArray(model.renderable.getBoxPosition());
-        model.boxSize = _toConsumableArray(model.renderable.getBoxSize());
+        model.axisTextStyle = {
+          ...model.renderable.getAxisTextStyle()
+        };
+        model.tickTextStyle = {
+          ...model.renderable.getTickTextStyle()
+        };
+        model.barPosition = [...model.renderable.getBarPosition()];
+        model.barSize = [...model.renderable.getBarSize()];
+        model.boxPosition = [...model.renderable.getBoxPosition()];
+        model.boxSize = [...model.renderable.getBoxSize()];
         model.axisTitlePixelOffset = model.renderable.getAxisTitlePixelOffset();
-        model.tickLabelPixelOffset = model.renderable.getTickLabelPixelOffset(); // rebuild the texture only when force or changed bounds, face
-        // visibility changes do to change the atlas
+        model.tickLabelPixelOffset = model.renderable.getTickLabelPixelOffset();
 
-        var textSizes = publicAPI.updateTextureAtlas(); // recompute bar segments based on positioning
+        // rebuild the texture only when force or changed bounds, face
+        // visibility changes do to change the atlas
+        const textSizes = publicAPI.updateTextureAtlas();
 
+        // recompute bar segments based on positioning
         publicAPI.recomputeBarSegments(textSizes);
       }
-
       publicAPI.updatePolyDataForLabels();
       publicAPI.updatePolyDataForBarSegments();
       model.lastRebuildTime.modified();
       model.forceUpdate = false;
     }
-  }; // create the texture map atlas that contains the rendering of
+  };
+
+  // create the texture map atlas that contains the rendering of
   // all the text strings. Only needs to be called when the text strings
   // have changed (labels and ticks)
-
-
-  publicAPI.updateTextureAtlas = function () {
+  publicAPI.updateTextureAtlas = () => {
     // set the text properties
     model.tmContext.textBaseline = 'bottom';
-    model.tmContext.textAlign = 'left'; // return some factors about the text atlas
-
-    var results = {}; // first the axislabel
+    model.tmContext.textAlign = 'left';
 
-    var newTmAtlas = new Map();
-    var maxWidth = 0;
-    var totalHeight = 1; // start one pixel in so we have a border
+    // return some factors about the text atlas
+    const results = {};
 
+    // first the axislabel
+    const newTmAtlas = new Map();
+    let maxWidth = 0;
+    let totalHeight = 1; // start one pixel in so we have a border
     applyTextStyle(model.tmContext, model.axisTextStyle);
-    var metrics = model.tmContext.measureText(model.renderable.getAxisLabel());
-    var entry = {
+    let metrics = model.tmContext.measureText(model.renderable.getAxisLabel());
+    let entry = {
       height: metrics.actualBoundingBoxAscent + 2,
       startingHeight: totalHeight,
       width: metrics.width + 2,
@@ -244,14 +255,14 @@ function vtkScalarBarActorHelper(publicAPI, model) {
     totalHeight += entry.height;
     maxWidth = entry.width;
     results.titleWidth = entry.width;
-    results.titleHeight = entry.height; // and the ticks, NaN Below and Above
+    results.titleHeight = entry.height;
 
+    // and the ticks, NaN Below and Above
     results.tickWidth = 0;
     results.tickHeight = 0;
     applyTextStyle(model.tmContext, model.tickTextStyle);
-    var strings = [].concat(_toConsumableArray(publicAPI.getTickStrings()), ['NaN', 'Below', 'Above']);
-
-    for (var t = 0; t < strings.length; t++) {
+    const strings = [...publicAPI.getTickStrings(), 'NaN', 'Below', 'Above'];
+    for (let t = 0; t < strings.length; t++) {
       if (!newTmAtlas.has(strings[t])) {
         metrics = model.tmContext.measureText(strings[t]);
         entry = {
@@ -262,85 +273,82 @@ function vtkScalarBarActorHelper(publicAPI, model) {
         };
         newTmAtlas.set(strings[t], entry);
         totalHeight += entry.height;
-
         if (maxWidth < entry.width) {
           maxWidth = entry.width;
         }
-
         if (results.tickWidth < entry.width) {
           results.tickWidth = entry.width;
         }
-
         if (results.tickHeight < entry.height) {
           results.tickHeight = entry.height;
         }
       }
-    } // always use power of two to avoid interpolation
-    // in cases where PO2 is required
-
+    }
 
+    // always use power of two to avoid interpolation
+    // in cases where PO2 is required
     maxWidth = nearestPowerOfTwo(maxWidth);
-    totalHeight = nearestPowerOfTwo(totalHeight); // set the tcoord values
+    totalHeight = nearestPowerOfTwo(totalHeight);
 
-    newTmAtlas.forEach(function (value) {
+    // set the tcoord values
+    newTmAtlas.forEach(value => {
       value.tcoords = [0.0, (totalHeight - value.startingHeight - value.height) / totalHeight, value.width / maxWidth, (totalHeight - value.startingHeight - value.height) / totalHeight, value.width / maxWidth, (totalHeight - value.startingHeight) / totalHeight, 0.0, (totalHeight - value.startingHeight) / totalHeight];
-    }); // make sure we have power of two dimensions
+    });
 
+    // make sure we have power of two dimensions
     model.tmCanvas.width = maxWidth;
     model.tmCanvas.height = totalHeight;
     model.tmContext.textBaseline = 'bottom';
     model.tmContext.textAlign = 'left';
-    model.tmContext.clearRect(0, 0, maxWidth, totalHeight); // draw the text onto the texture
+    model.tmContext.clearRect(0, 0, maxWidth, totalHeight);
 
-    newTmAtlas.forEach(function (value, key) {
+    // draw the text onto the texture
+    newTmAtlas.forEach((value, key) => {
       applyTextStyle(model.tmContext, value.textStyle);
       model.tmContext.fillText(key, 1, value.startingHeight + value.height - 1);
     });
-    model.tmTexture.setCanvas(model.tmCanvas); // mark as modified since the canvas typically doesn't change
-
+    model.tmTexture.setCanvas(model.tmCanvas);
+    // mark as modified since the canvas typically doesn't change
     model.tmTexture.modified();
     model._tmAtlas = newTmAtlas;
     return results;
   };
-
-  publicAPI.computeBarSize = function (textSizes) {
+  publicAPI.computeBarSize = textSizes => {
     // compute orientation
     model.vertical = model.boxSize[1] > model.boxSize[0];
-    var tickHeight = 2.0 * textSizes.tickHeight / model.lastSize[1];
-    var segSize = [1, 1]; // horizontal and vertical have different astetics so adjust based on
-    // orientation
+    const tickHeight = 2.0 * textSizes.tickHeight / model.lastSize[1];
+    const segSize = [1, 1];
 
+    // horizontal and vertical have different astetics so adjust based on
+    // orientation
     if (model.vertical) {
-      var tickWidth = 2.0 * (textSizes.tickWidth + model.tickLabelPixelOffset) / model.lastSize[0];
-
+      const tickWidth = 2.0 * (textSizes.tickWidth + model.tickLabelPixelOffset) / model.lastSize[0];
       if (model.topTitle) {
-        var titleHeight = 2.0 * (textSizes.titleHeight + model.axisTitlePixelOffset) / model.lastSize[1];
+        const titleHeight = 2.0 * (textSizes.titleHeight + model.axisTitlePixelOffset) / model.lastSize[1];
         model.barSize[0] = model.boxSize[0] - tickWidth;
         model.barSize[1] = model.boxSize[1] - titleHeight;
       } else {
         // rotated title so width is based off height
-        var titleWidth = 2.0 * (textSizes.titleHeight + model.axisTitlePixelOffset) / model.lastSize[0];
+        const titleWidth = 2.0 * (textSizes.titleHeight + model.axisTitlePixelOffset) / model.lastSize[0];
         model.barSize[0] = model.boxSize[0] - titleWidth - tickWidth;
         model.barSize[1] = model.boxSize[1];
       }
-
       model.barPosition[0] = model.boxPosition[0] + tickWidth;
       model.barPosition[1] = model.boxPosition[1];
       segSize[1] = tickHeight;
     } else {
-      var _tickWidth = (2.0 * textSizes.tickWidth - 8) / model.lastSize[0];
-
-      var _titleHeight = 2.0 * (textSizes.titleHeight + model.axisTitlePixelOffset) / model.lastSize[1];
-
+      const tickWidth = (2.0 * textSizes.tickWidth - 8) / model.lastSize[0];
+      const titleHeight = 2.0 * (textSizes.titleHeight + model.axisTitlePixelOffset) / model.lastSize[1];
       model.barSize[0] = model.boxSize[0];
       model.barPosition[0] = model.boxPosition[0];
-      model.barSize[1] = model.boxSize[1] - _titleHeight;
+      model.barSize[1] = model.boxSize[1] - titleHeight;
       model.barPosition[1] = model.boxPosition[1];
-      segSize[0] = _tickWidth;
+      segSize[0] = tickWidth;
     }
-
     return segSize;
-  }; // based on all the settins compute a barSegments array
+  };
+
+  // based on all the settins compute a barSegments array
   // containing the segments of the scalar bar
   // each segment contains
   //   corners[4][2]
@@ -349,89 +357,81 @@ function vtkScalarBarActorHelper(publicAPI, model) {
   //
   // Note that the bar consumes the space in the box that remains after
   // leaving room for the text labels
-
-
-  publicAPI.recomputeBarSegments = function (textSizes) {
-    var _model$renderable$get, _model$renderable$get2, _model$renderable$get3, _model$renderable$get4;
-
+  publicAPI.recomputeBarSegments = textSizes => {
     // first compute the barSize/Position
-    var segSize = publicAPI.computeBarSize(textSizes);
+    const segSize = publicAPI.computeBarSize(textSizes);
     model.barSegments = [];
-    var startPos = [0.0, 0.0]; // horizontal and vertical have different astetics so adjust based on
-    // orientation
-
-    var barAxis = model.vertical ? 1 : 0;
-    var segSpace = model.vertical ? 0.01 : 0.02;
+    const startPos = [0.0, 0.0];
 
+    // horizontal and vertical have different astetics so adjust based on
+    // orientation
+    const barAxis = model.vertical ? 1 : 0;
+    const segSpace = model.vertical ? 0.01 : 0.02;
     function pushSeg(title, scalars) {
       model.barSegments.push({
-        corners: [[].concat(startPos), [startPos[0] + segSize[0], startPos[1]], [startPos[0] + segSize[0], startPos[1] + segSize[1]], [startPos[0], startPos[1] + segSize[1]]],
-        scalars: scalars,
-        title: title
+        corners: [[...startPos], [startPos[0] + segSize[0], startPos[1]], [startPos[0] + segSize[0], startPos[1] + segSize[1]], [startPos[0], startPos[1] + segSize[1]]],
+        scalars,
+        title
       });
       startPos[barAxis] += segSize[barAxis] + segSpace;
     }
-
     if (model.renderable.getDrawNanAnnotation() && model.renderable.getScalarsToColors().getNanColor()) {
       pushSeg('NaN', [NaN, NaN, NaN, NaN]);
     }
-
-    if (model.renderable.getDrawBelowRangeSwatch() && (_model$renderable$get = (_model$renderable$get2 = model.renderable.getScalarsToColors()).getUseBelowRangeColor) !== null && _model$renderable$get !== void 0 && _model$renderable$get.call(_model$renderable$get2)) {
+    if (model.renderable.getDrawBelowRangeSwatch() && model.renderable.getScalarsToColors().getUseBelowRangeColor?.()) {
       pushSeg('Below', [-0.1, -0.1, -0.1, -0.1]);
     }
+    const haveAbove = model.renderable.getScalarsToColors().getUseAboveRangeColor?.();
 
-    var haveAbove = (_model$renderable$get3 = (_model$renderable$get4 = model.renderable.getScalarsToColors()).getUseAboveRangeColor) === null || _model$renderable$get3 === void 0 ? void 0 : _model$renderable$get3.call(_model$renderable$get4); // extra space around the ticks section
-
+    // extra space around the ticks section
     startPos[barAxis] += segSpace;
-    var oldSegSize = segSize[barAxis];
+    const oldSegSize = segSize[barAxis];
     segSize[barAxis] = haveAbove ? 1.0 - 2.0 * segSpace - segSize[barAxis] - startPos[barAxis] : 1.0 - segSpace - startPos[barAxis];
     pushSeg('ticks', model.vertical ? [0, 0, 0.995, 0.995] : [0, 0.995, 0.995, 0]);
-
     if (model.renderable.getDrawAboveRangeSwatch() && haveAbove) {
       segSize[barAxis] = oldSegSize;
       startPos[barAxis] += segSpace;
       pushSeg('Above', [1.1, 1.1, 1.1, 1.1]);
     }
-  }; // called by updatePolyDataForLabels
-  // modifies class constants tmp2v3
+  };
 
+  // called by updatePolyDataForLabels
+  // modifies class constants tmp2v3
+  const tmp2v3 = new Float64Array(3);
 
-  var tmp2v3 = new Float64Array(3); // anchor point = pos
+  // anchor point = pos
   // H alignment = left, middle, right
   // V alignment = bottom, middle, top
   // Text Orientation = horizontal, vertical
   // orientation
-
-  publicAPI.createPolyDataForOneLabel = function (text, pos, alignment, orientation, offset, results) {
-    var value = model._tmAtlas.get(text);
-
+  publicAPI.createPolyDataForOneLabel = (text, pos, alignment, orientation, offset, results) => {
+    const value = model._tmAtlas.get(text);
     if (!value) {
       return;
-    } // have to find the four corners of the texture polygon for this label
-
-
-    var ptIdx = results.ptIdx;
-    var cellIdx = results.cellIdx; // get achor point in pixels
+    }
+    // have to find the four corners of the texture polygon for this label
+    let ptIdx = results.ptIdx;
+    let cellIdx = results.cellIdx;
 
+    // get achor point in pixels
     tmp2v3[0] = (0.5 * pos[0] + 0.5) * model.lastSize[0];
     tmp2v3[1] = (0.5 * pos[1] + 0.5) * model.lastSize[1];
     tmp2v3[2] = pos[2];
     tmp2v3[0] += offset[0];
-    tmp2v3[1] += offset[1]; // get text size in display pixels
-
-    var textSize = [];
-    var textAxes = orientation === 'vertical' ? [1, 0] : [0, 1];
+    tmp2v3[1] += offset[1];
 
+    // get text size in display pixels
+    const textSize = [];
+    const textAxes = orientation === 'vertical' ? [1, 0] : [0, 1];
     if (orientation === 'vertical') {
       textSize[0] = value.width;
-      textSize[1] = -value.height; // update anchor point based on alignment
-
+      textSize[1] = -value.height;
+      // update anchor point based on alignment
       if (alignment[0] === 'middle') {
         tmp2v3[1] -= value.width / 2.0;
       } else if (alignment[0] === 'right') {
         tmp2v3[1] -= value.width;
       }
-
       if (alignment[1] === 'middle') {
         tmp2v3[0] += value.height / 2.0;
       } else if (alignment[1] === 'top') {
@@ -439,21 +439,19 @@ function vtkScalarBarActorHelper(publicAPI, model) {
       }
     } else {
       textSize[0] = value.width;
-      textSize[1] = value.height; // update anchor point based on alignment
-
+      textSize[1] = value.height;
+      // update anchor point based on alignment
       if (alignment[0] === 'middle') {
         tmp2v3[0] -= value.width / 2.0;
       } else if (alignment[0] === 'right') {
         tmp2v3[0] -= value.width;
       }
-
       if (alignment[1] === 'middle') {
         tmp2v3[1] -= value.height / 2.0;
       } else if (alignment[1] === 'top') {
         tmp2v3[1] -= value.height;
       }
     }
-
     results.points[ptIdx * 3] = tmp2v3[0];
     results.points[ptIdx * 3 + 1] = tmp2v3[1];
     results.points[ptIdx * 3 + 2] = tmp2v3[2];
@@ -480,8 +478,9 @@ function vtkScalarBarActorHelper(publicAPI, model) {
     results.points[ptIdx * 3 + 2] = tmp2v3[2];
     results.tcoords[ptIdx * 2] = value.tcoords[6];
     results.tcoords[ptIdx * 2 + 1] = value.tcoords[7];
-    ptIdx++; // add the two triangles to represent the quad
+    ptIdx++;
 
+    // add the two triangles to represent the quad
     results.polys[cellIdx * 4] = 3;
     results.polys[cellIdx * 4 + 1] = ptIdx - 4;
     results.polys[cellIdx * 4 + 2] = ptIdx - 3;
@@ -493,53 +492,52 @@ function vtkScalarBarActorHelper(publicAPI, model) {
     results.polys[cellIdx * 4 + 3] = ptIdx - 1;
     results.ptIdx += 4;
     results.cellIdx += 2;
-  }; // update the polydata associated with drawing the text labels
+  };
+
+  // update the polydata associated with drawing the text labels
   // specifically the quads used for each label and their associated tcoords
   // etc. This changes every time the camera viewpoint changes
-
-
-  var tmpv3 = new Float64Array(3);
-
-  publicAPI.updatePolyDataForLabels = function () {
+  const tmpv3 = new Float64Array(3);
+  publicAPI.updatePolyDataForLabels = () => {
     // update the polydata
-    var numLabels = publicAPI.getTickStrings().length + model.barSegments.length;
-    var numPts = numLabels * 4;
-    var numTris = numLabels * 2;
-    var points = new Float64Array(numPts * 3);
-    var polys = new Uint16Array(numTris * 4);
-    var tcoords = new Float32Array(numPts * 2);
-    var results = {
+    const numLabels = publicAPI.getTickStrings().length + model.barSegments.length;
+    const numPts = numLabels * 4;
+    const numTris = numLabels * 2;
+    const points = new Float64Array(numPts * 3);
+    const polys = new Uint16Array(numTris * 4);
+    const tcoords = new Float32Array(numPts * 2);
+    const results = {
       ptIdx: 0,
       cellIdx: 0,
-      polys: polys,
-      points: points,
-      tcoords: tcoords
-    }; // compute the direction vector
+      polys,
+      points,
+      tcoords
+    };
 
-    var offsetAxis = model.vertical ? 0 : 1;
-    var spacedAxis = model.vertical ? 1 : 0;
+    // compute the direction vector
+    const offsetAxis = model.vertical ? 0 : 1;
+    const spacedAxis = model.vertical ? 1 : 0;
     tmpv3[2] = -0.99; // near plane
-    // draw the title
-
-    var alignment = model.vertical ? ['right', 'middle'] : ['middle', 'bottom'];
-    var dir = [0, 1];
-    var tickOffsets = [0, 0];
 
+    // draw the title
+    const alignment = model.vertical ? ['right', 'middle'] : ['middle', 'bottom'];
+    let dir = [0, 1];
+    const tickOffsets = [0, 0];
     if (model.vertical) {
       tickOffsets[0] = -model.tickLabelPixelOffset;
-
       if (model.topTitle) {
         tmpv3[0] = model.boxPosition[0] + 0.5 * model.boxSize[0];
-        tmpv3[1] = model.barPosition[1] + model.barSize[1]; // write the axis label
+        tmpv3[1] = model.barPosition[1] + model.barSize[1];
 
+        // write the axis label
         publicAPI.createPolyDataForOneLabel(model.renderable.getAxisLabel(), tmpv3, ['middle', 'bottom'], 'horizontal', [0, model.axisTitlePixelOffset], results);
       } else {
         tmpv3[0] = model.barPosition[0] + model.barSize[0];
-        tmpv3[1] = model.barPosition[1] + 0.5 * model.barSize[1]; // write the axis label
+        tmpv3[1] = model.barPosition[1] + 0.5 * model.barSize[1];
 
+        // write the axis label
         publicAPI.createPolyDataForOneLabel(model.renderable.getAxisLabel(), tmpv3, ['middle', 'top'], 'vertical', [model.axisTitlePixelOffset, 0], results);
       }
-
       dir = [-1, 0];
     } else {
       tickOffsets[1] = model.tickLabelPixelOffset;
@@ -547,15 +545,13 @@ function vtkScalarBarActorHelper(publicAPI, model) {
       tmpv3[1] = model.barPosition[1] + model.barSize[1];
       publicAPI.createPolyDataForOneLabel(model.renderable.getAxisLabel(), tmpv3, ['middle', 'bottom'], 'horizontal', [0, model.axisTitlePixelOffset], results);
     }
-
     tmpv3[offsetAxis] = model.barPosition[offsetAxis] + (0.5 * dir[offsetAxis] + 0.5) * model.barSize[offsetAxis];
-    tmpv3[spacedAxis] = model.barPosition[spacedAxis] + model.barSize[spacedAxis] * 0.5; // draw bar segment labels
-
-    var tickSeg = null;
-
-    for (var i = 0; i < model.barSegments.length; i++) {
-      var seg = model.barSegments[i];
+    tmpv3[spacedAxis] = model.barPosition[spacedAxis] + model.barSize[spacedAxis] * 0.5;
 
+    // draw bar segment labels
+    let tickSeg = null;
+    for (let i = 0; i < model.barSegments.length; i++) {
+      const seg = model.barSegments[i];
       if (seg.title === 'ticks') {
         // handle ticks below
         tickSeg = seg;
@@ -563,21 +559,19 @@ function vtkScalarBarActorHelper(publicAPI, model) {
         tmpv3[spacedAxis] = model.barPosition[spacedAxis] + 0.5 * model.barSize[spacedAxis] * (seg.corners[2][spacedAxis] + seg.corners[0][spacedAxis]);
         publicAPI.createPolyDataForOneLabel(seg.title, tmpv3, alignment, 'horizontal', tickOffsets, results);
       }
-    } // write the tick labels
-
-
-    var tickSegmentStart = model.barPosition[spacedAxis] + model.barSize[spacedAxis] * tickSeg.corners[0][spacedAxis];
-    var tickSegmentSize = model.barSize[spacedAxis] * (tickSeg.corners[2][spacedAxis] - tickSeg.corners[0][spacedAxis]);
-    var ticks = publicAPI.getTicks();
-    var tickStrings = publicAPI.getTickStrings();
+    }
 
-    for (var t = 0; t < ticks.length; t++) {
-      var tickPos = (ticks[t] - model.lastTickBounds[0]) / (model.lastTickBounds[1] - model.lastTickBounds[0]);
+    // write the tick labels
+    const tickSegmentStart = model.barPosition[spacedAxis] + model.barSize[spacedAxis] * tickSeg.corners[0][spacedAxis];
+    const tickSegmentSize = model.barSize[spacedAxis] * (tickSeg.corners[2][spacedAxis] - tickSeg.corners[0][spacedAxis]);
+    const ticks = publicAPI.getTicks();
+    const tickStrings = publicAPI.getTickStrings();
+    for (let t = 0; t < ticks.length; t++) {
+      const tickPos = (ticks[t] - model.lastTickBounds[0]) / (model.lastTickBounds[1] - model.lastTickBounds[0]);
       tmpv3[spacedAxis] = tickSegmentStart + tickSegmentSize * tickPos;
       publicAPI.createPolyDataForOneLabel(tickStrings[t], tmpv3, alignment, 'horizontal', tickOffsets, results);
     }
-
-    var tcoordDA = vtkDataArray.newInstance({
+    const tcoordDA = vtkDataArray.newInstance({
       numberOfComponents: 2,
       values: tcoords,
       name: 'TextureCoordinates'
@@ -589,58 +583,46 @@ function vtkScalarBarActorHelper(publicAPI, model) {
     model.tmPolyData.getPolys().modified();
     model.tmPolyData.modified();
   };
-
-  publicAPI.updatePolyDataForBarSegments = function () {
-    var _scalarsToColors$getU, _scalarsToColors$getU2;
-
-    var scalarsToColors = model.renderable.getScalarsToColors();
-    var numberOfExtraColors = 0;
-
+  publicAPI.updatePolyDataForBarSegments = () => {
+    const scalarsToColors = model.renderable.getScalarsToColors();
+    let numberOfExtraColors = 0;
     if (model.renderable.getDrawNanAnnotation() && scalarsToColors.getNanColor()) {
       numberOfExtraColors += 1;
     }
-
-    if (model.renderable.getDrawBelowRangeSwatch() && (_scalarsToColors$getU = scalarsToColors.getUseBelowRangeColor) !== null && _scalarsToColors$getU !== void 0 && _scalarsToColors$getU.call(scalarsToColors)) {
+    if (model.renderable.getDrawBelowRangeSwatch() && scalarsToColors.getUseBelowRangeColor?.()) {
       numberOfExtraColors += 1;
     }
-
-    if (model.renderable.getDrawAboveRangeSwatch() && (_scalarsToColors$getU2 = scalarsToColors.getUseAboveRangeColor) !== null && _scalarsToColors$getU2 !== void 0 && _scalarsToColors$getU2.call(scalarsToColors)) {
+    if (model.renderable.getDrawAboveRangeSwatch() && scalarsToColors.getUseAboveRangeColor?.()) {
       numberOfExtraColors += 1;
     }
+    const numPts = 4 * (1 + numberOfExtraColors);
+    const numQuads = numPts;
 
-    var numPts = 4 * (1 + numberOfExtraColors);
-    var numQuads = numPts; // handle vector component mode
-
-    var numComps = 1;
-
+    // handle vector component mode
+    let numComps = 1;
     if (scalarsToColors.getVectorMode() === VectorMode.COMPONENT) {
       numComps = scalarsToColors.getVectorComponent() + 1;
-    } // create the colored bars
-
-
-    var points = new Float64Array(numPts * 3);
-    var cells = new Uint16Array(numQuads * 5);
-    var scalars = new Float32Array(numPts * numComps);
-    var ptIdx = 0;
-    var cellIdx = 0;
-
-    for (var i = 0; i < model.barSegments.length; i++) {
-      var seg = model.barSegments[i];
+    }
 
-      for (var e = 0; e < 4; e++) {
+    // create the colored bars
+    const points = new Float64Array(numPts * 3);
+    const cells = new Uint16Array(numQuads * 5);
+    const scalars = new Float32Array(numPts * numComps);
+    let ptIdx = 0;
+    let cellIdx = 0;
+    for (let i = 0; i < model.barSegments.length; i++) {
+      const seg = model.barSegments[i];
+      for (let e = 0; e < 4; e++) {
         tmpv3[0] = model.barPosition[0] + seg.corners[e][0] * model.barSize[0];
         tmpv3[1] = model.barPosition[1] + seg.corners[e][1] * model.barSize[1];
         points[ptIdx * 3] = (0.5 * tmpv3[0] + 0.5) * model.lastSize[0];
         points[ptIdx * 3 + 1] = (0.5 * tmpv3[1] + 0.5) * model.lastSize[1];
         points[ptIdx * 3 + 2] = tmpv3[2];
-
-        for (var nc = 0; nc < numComps; nc++) {
+        for (let nc = 0; nc < numComps; nc++) {
           scalars[ptIdx * numComps + nc] = model.lastTickBounds[0] + seg.scalars[e] * (model.lastTickBounds[1] - model.lastTickBounds[0]);
         }
-
         ptIdx++;
       }
-
       cells[cellIdx * 5] = 4;
       cells[cellIdx * 5 + 1] = ptIdx - 4;
       cells[cellIdx * 5 + 2] = ptIdx - 3;
@@ -648,8 +630,7 @@ function vtkScalarBarActorHelper(publicAPI, model) {
       cells[cellIdx * 5 + 4] = ptIdx - 1;
       cellIdx++;
     }
-
-    var scalarsDA = vtkDataArray.newInstance({
+    const scalarsDA = vtkDataArray.newInstance({
       numberOfComponents: numComps,
       values: scalars,
       name: 'Scalars'
@@ -662,13 +643,13 @@ function vtkScalarBarActorHelper(publicAPI, model) {
     model.polyData.modified();
   };
 }
-
-var newScalarBarActorHelper = macro.newInstance(function (publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {
+const newScalarBarActorHelper = macro.newInstance(function (publicAPI, model) {
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {
     renderable: null
   };
-  Object.assign(model, {}, initialValues); // Inheritance
+  Object.assign(model, {}, initialValues);
 
+  // Inheritance
   macro.obj(publicAPI, model);
   macro.setGet(publicAPI, model, ['axisTitlePixelOffset', 'tickLabelPixelOffset', 'renderable', 'topTitle', 'ticks', 'tickStrings']);
   macro.get(publicAPI, model, ['lastSize', 'lastAspectRatio', 'lastTickBounds', 'axisTextStyle', 'tickTextStyle', 'barActor', 'tmActor']);
@@ -689,8 +670,9 @@ var newScalarBarActorHelper = macro.newInstance(function (publicAPI, model) {
   model.polyData = vtkPolyData.newInstance();
   model.barMapper.setInputData(model.polyData);
   model.barActor = vtkActor.newInstance();
-  model.barActor.setMapper(model.barMapper); // for texture atlas
+  model.barActor.setMapper(model.barMapper);
 
+  // for texture atlas
   model.tmPolyData = vtkPolyData.newInstance();
   model.tmMapper = vtkMapper.newInstance();
   model.tmMapper.setInputData(model.tmPolyData);
@@ -706,45 +688,50 @@ var newScalarBarActorHelper = macro.newInstance(function (publicAPI, model) {
   model.barPosition = [0, 0];
   model.barSize = [0, 0];
   model.boxPosition = [0.88, -0.92];
-  model.boxSize = [0.1, 1.1]; // internal variables
+  model.boxSize = [0.1, 1.1];
 
+  // internal variables
   model.lastTickBounds = [];
   vtkScalarBarActorHelper(publicAPI, model);
-}, 'vtkScalarBarActorHelper'); //
+}, 'vtkScalarBarActorHelper');
+
+//
 // Now we define the public class that the application sets view independent
 // properties on. This class is fairly small as it mainly just holds
 // properties setter and getters leaving all calculations to the helper
 // class.
 //
-
 function vtkScalarBarActor(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkScalarBarActor');
-
-  publicAPI.setTickTextStyle = function (tickStyle) {
-    model.tickTextStyle = _objectSpread(_objectSpread({}, model.tickTextStyle), tickStyle);
+  publicAPI.setTickTextStyle = tickStyle => {
+    model.tickTextStyle = {
+      ...model.tickTextStyle,
+      ...tickStyle
+    };
     publicAPI.modified();
   };
-
-  publicAPI.setAxisTextStyle = function (axisStyle) {
-    model.axisTextStyle = _objectSpread(_objectSpread({}, model.axisTextStyle), axisStyle);
+  publicAPI.setAxisTextStyle = axisStyle => {
+    model.axisTextStyle = {
+      ...model.axisTextStyle,
+      ...axisStyle
+    };
     publicAPI.modified();
   };
-
-  publicAPI.resetAutoLayoutToDefault = function () {
+  publicAPI.resetAutoLayoutToDefault = () => {
     publicAPI.setAutoLayout(defaultAutoLayout(publicAPI, model));
   };
-
-  publicAPI.resetGenerateTicksToDefault = function () {
+  publicAPI.resetGenerateTicksToDefault = () => {
     publicAPI.setGenerateTicks(defaultGenerateTicks());
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
 function defaultValues(initialValues) {
-  return _objectSpread({
+  return {
     automated: true,
     autoLayout: null,
     axisLabel: 'Scalar Value',
@@ -770,34 +757,42 @@ function defaultValues(initialValues) {
     generateTicks: null,
     drawNanAnnotation: true,
     drawBelowRangeSwatch: true,
-    drawAboveRangeSwatch: true
-  }, initialValues);
-} // ----------------------------------------------------------------------------
+    drawAboveRangeSwatch: true,
+    ...initialValues
+  };
+}
 
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
   Object.assign(model, defaultValues(initialValues));
   if (!model.autoLayout) model.autoLayout = defaultAutoLayout(publicAPI, model);
-  if (!model.generateTicks) model.generateTicks = defaultGenerateTicks(); // Inheritance
+  if (!model.generateTicks) model.generateTicks = defaultGenerateTicks();
 
+  // Inheritance
   vtkActor.extend(publicAPI, model, initialValues);
   publicAPI.getProperty().setDiffuse(0.0);
   publicAPI.getProperty().setAmbient(1.0);
   macro.setGet(publicAPI, model, ['automated', 'autoLayout', 'axisTitlePixelOffset', 'axisLabel', 'scalarsToColors', 'tickLabelPixelOffset', 'generateTicks', 'drawNanAnnotation', 'drawBelowRangeSwatch', 'drawAboveRangeSwatch']);
   macro.get(publicAPI, model, ['axisTextStyle', 'tickTextStyle']);
   macro.getArray(publicAPI, model, ['barPosition', 'barSize', 'boxPosition', 'boxSize']);
-  macro.setArray(publicAPI, model, ['barPosition', 'barSize', 'boxPosition', 'boxSize'], 2); // Object methods
+  macro.setArray(publicAPI, model, ['barPosition', 'barSize', 'boxPosition', 'boxSize'], 2);
 
+  // Object methods
   vtkScalarBarActor(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkScalarBarActor'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkScalarBarActor');
+
+// ----------------------------------------------------------------------------
 
 var vtkScalarBarActor$1 = {
-  newInstance: newInstance,
-  extend: extend,
-  newScalarBarActorHelper: newScalarBarActorHelper
+  newInstance,
+  extend,
+  newScalarBarActorHelper
 };
 
 export { vtkScalarBarActor$1 as default, extend, newInstance };