@kitware/vtk.js 26.2.0 → 26.3.0

package/Proxy/Core/View2DProxy.js

@@ -1,7 +1,10 @@
+import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import macro from '../../macros.js';
 import vtkMouseRangeManipulator from '../../Interaction/Manipulators/MouseRangeManipulator.js';
 import vtkViewProxy from './ViewProxy.js';
-import { k as cross, F as getMajorAxisIndex } from '../../Common/Core/Math/index.js';
+import { j as cross, E as getMajorAxisIndex } from '../../Common/Core/Math/index.js';
+import { mat4, vec3 } from 'gl-matrix';
+import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';
 
 var DEFAULT_STEP_WIDTH = 512;
 
@@ -23,6 +26,40 @@ function formatAnnotationValue(value) {
   }
 
   return value;
+}
+/**
+ * Returns an array of points in world coordinates creating a coarse hull
+ * around the prop given in argument
+ * The returned array is empty if the prop is not visible or doesn't use bounds
+ *
+ * How it works: if possible, combine the mapper bounds corners with the prop matrix
+ * otherwise, returns the prop bounds corners
+ */
+
+
+function getPropCoarseHull(prop) {
+  var _prop$getMapper, _prop$getMapper$call, _prop$getMapper$call$;
+
+  if (!prop.getVisibility() || !prop.getUseBounds()) {
+    return [];
+  }
+
+  var mapperBounds = prop === null || prop === void 0 ? void 0 : (_prop$getMapper = prop.getMapper) === null || _prop$getMapper === void 0 ? void 0 : (_prop$getMapper$call = _prop$getMapper.call(prop)) === null || _prop$getMapper$call === void 0 ? void 0 : (_prop$getMapper$call$ = _prop$getMapper$call.getBounds) === null || _prop$getMapper$call$ === void 0 ? void 0 : _prop$getMapper$call$.call(_prop$getMapper$call);
+  var corners = [];
+
+  if (mapperBounds && vtkBoundingBox.isValid(mapperBounds) && prop.getMatrix) {
+    vtkBoundingBox.getCorners(mapperBounds, corners);
+    var matrix = prop.getMatrix().slice();
+    mat4.transpose(matrix, matrix);
+    corners.forEach(function (pt) {
+      return vec3.transformMat4(pt, pt, matrix);
+    });
+  } else {
+    var propBounds = prop.getBounds();
+    vtkBoundingBox.getCorners(propBounds, corners);
+  }
+
+  return corners;
 } // ----------------------------------------------------------------------------
 // vtkView2DProxy methods
 // ----------------------------------------------------------------------------
@@ -107,6 +144,81 @@ function vtkView2DProxy(publicAPI, model) {
         }
       }
     }
+  };
+
+  var superInternalResetCamera = model._resetCamera;
+  /**
+   * If fitProps is true, calling resetCamera will exactly fit the bounds in the view
+   * Exact fitting requires useParallelRendering, and an active camera
+   * Otherwise, the default renderer.resetCamera is used and it uses a larger bounding box
+   */
+
+  model._resetCamera = function () {
+    var bounds = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+    // Always reset camera first to set physicalScale, physicalTranslation and trigger events
+    var initialReset = superInternalResetCamera(bounds);
+
+    if (!model.fitProps || !model.useParallelRendering || !initialReset) {
+      return initialReset;
+    } // For each visible prop get the smallest possible convex hull using bounds corners
+
+
+    var visiblePoints = [];
+
+    if (bounds) {
+      // Bounds are given as argument, use their corners
+      vtkBoundingBox.getCorners(bounds, visiblePoints);
+    } else {
+      publicAPI.getRepresentations().forEach(function (representationProxy) {
+        return [representationProxy.getActors(), representationProxy.getVolumes()].flat().forEach(function (prop) {
+          return visiblePoints.push.apply(visiblePoints, _toConsumableArray(getPropCoarseHull(prop)));
+        });
+      });
+    } // Get the bounds in view coordinates
+
+
+    var viewBounds = vtkBoundingBox.reset([]);
+    var viewMatrix = model.camera.getViewMatrix();
+    mat4.transpose(viewMatrix, viewMatrix);
+
+    for (var i = 0; i < visiblePoints.length; ++i) {
+      var point = visiblePoints[i];
+      vec3.transformMat4(point, point, viewMatrix);
+      vtkBoundingBox.addPoint.apply(vtkBoundingBox, [viewBounds].concat(_toConsumableArray(point)));
+    } // Compute focal point and position
+
+
+    var viewFocalPoint = vtkBoundingBox.getCenter(viewBounds); // Camera position in view coordinates is the center of the bounds in XY
+    // and the maximum bound + 1 in Z
+
+    var viewPosition = [viewFocalPoint[0], viewFocalPoint[1], viewBounds[5] + 1];
+    var inverseViewMatrix = new Float64Array(16);
+    var worldFocalPoint = new Float64Array(3);
+    var worldPosition = new Float64Array(3);
+    mat4.invert(inverseViewMatrix, viewMatrix);
+    vec3.transformMat4(worldFocalPoint, viewFocalPoint, inverseViewMatrix);
+    vec3.transformMat4(worldPosition, viewPosition, inverseViewMatrix); // Compute parallel scale
+
+    var view = model.renderer.getRenderWindow().getViews()[0];
+    var dims = view.getViewportSize(model.renderer);
+    var aspect = dims[0] / dims[1];
+    var xLength = vtkBoundingBox.getLength(viewBounds, 0);
+    var yLength = vtkBoundingBox.getLength(viewBounds, 1);
+    var parallelScale = 0.5 * Math.max(yLength, xLength / aspect);
+
+    if (parallelScale <= 0) {
+      return initialReset;
+    } // Compute bounds in world coordinates
+
+
+    var worldBounds = vtkBoundingBox.transformBounds(viewBounds, inverseViewMatrix);
+    publicAPI.setCameraParameters({
+      position: worldPosition,
+      focalPoint: worldFocalPoint,
+      bounds: worldBounds,
+      parallelScale: parallelScale
+    });
+    return true;
   }; // --------------------------------------------------------------------------
   // Range Manipulator setup
   // -------------------------------------------------------------------------
@@ -243,14 +355,16 @@ var DEFAULT_VALUES = {
   orientation: -1,
   viewUp: [0, 1, 0],
   useParallelRendering: true,
-  sliceRepresentationSubscriptions: []
+  sliceRepresentationSubscriptions: [],
+  fitProps: false
 }; // ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
   var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
   Object.assign(model, DEFAULT_VALUES, initialValues);
   vtkViewProxy.extend(publicAPI, model, initialValues);
-  macro.get(publicAPI, model, ['axis']); // Object specific methods
+  macro.get(publicAPI, model, ['axis']);
+  macro.setGet(publicAPI, model, ['fitProps']); // Object specific methods
 
   vtkView2DProxy(publicAPI, model);
 } // ----------------------------------------------------------------------------

package/Proxy/Core/ViewProxy.js

@@ -1,6 +1,6 @@
-import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import _objectWithoutProperties from '@babel/runtime/helpers/objectWithoutProperties';
+import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
 import { newInstance as newInstance$1, obj, setGet, get, moveToProtected, event, proxy, proxyPropertyMapping, chain } from '../../macros.js';
 import vtkAnnotatedCubeActor from '../../Rendering/Core/AnnotatedCubeActor.js';
@@ -47,7 +47,16 @@ function vtkViewProxy(publicAPI, model) {
   model.interactor = vtkRenderWindowInteractor.newInstance();
   model.interactor.setView(model._openGLRenderWindow);
   model.interactorStyle3D = vtkInteractorStyleManipulator.newInstance();
-  model.interactorStyle2D = vtkInteractorStyleManipulator.newInstance(); // Apply default interaction styles
+  model.interactorStyle2D = vtkInteractorStyleManipulator.newInstance();
+  /**
+   * Internal function used by publicAPI.resetCamera()
+   */
+
+  model._resetCamera = function () {
+    var bounds = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+    return model.renderer.resetCamera(bounds);
+  }; // Apply default interaction styles
+
 
   InteractionPresets.applyPreset('3D', model.interactorStyle3D);
   InteractionPresets.applyPreset('2D', model.interactorStyle2D);
@@ -239,9 +248,44 @@ function vtkViewProxy(publicAPI, model) {
   }; // --------------------------------------------------------------------------
 
 
+  publicAPI.setCameraParameters = function (_ref) {
+    var position = _ref.position,
+        focalPoint = _ref.focalPoint,
+        bounds = _ref.bounds,
+        parallelScale = _ref.parallelScale,
+        viewAngle = _ref.viewAngle;
+
+    if (position != null) {
+      var _model$camera;
+
+      (_model$camera = model.camera).setPosition.apply(_model$camera, _toConsumableArray(position));
+    }
+
+    if (focalPoint != null) {
+      var _model$camera2;
+
+      (_model$camera2 = model.camera).setFocalPoint.apply(_model$camera2, _toConsumableArray(focalPoint));
+    }
+
+    if (bounds != null) {
+      model.renderer.resetCameraClippingRange(bounds);
+    } else {
+      model.renderer.resetCameraClippingRange();
+    }
+
+    if (parallelScale != null) {
+      model.camera.setParallelScale(parallelScale);
+    }
+
+    if (viewAngle != null) {
+      model.camera.setViewAngle(viewAngle);
+    }
+  }; // --------------------------------------------------------------------------
+
+
   publicAPI.resetCamera = function () {
-    model.renderer.resetCamera();
-    model.renderer.resetCameraClippingRange();
+    model._resetCamera();
+
     model.interactorStyle2D.setCenterOfRotation(model.camera.getFocalPoint());
     model.interactorStyle3D.setCenterOfRotation(model.camera.getFocalPoint());
     publicAPI.renderLater();
@@ -249,10 +293,10 @@ function vtkViewProxy(publicAPI, model) {
 
 
   publicAPI.captureImage = function () {
-    var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
-        _ref$format = _ref.format,
-        format = _ref$format === void 0 ? 'image/png' : _ref$format,
-        opts = _objectWithoutProperties(_ref, _excluded);
+    var _ref2 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+        _ref2$format = _ref2.format,
+        format = _ref2$format === void 0 ? 'image/png' : _ref2$format,
+        opts = _objectWithoutProperties(_ref2, _excluded);
 
     return model.renderWindow.captureImages(format, opts)[0];
   }; // --------------------------------------------------------------------------
@@ -326,7 +370,7 @@ function vtkViewProxy(publicAPI, model) {
 
 
   publicAPI.updateOrientation = function (axisIndex, orientation, viewUp) {
-    var _model$camera, _model$camera2, _model$camera3, _model$camera4, _model$camera5;
+    var _model$camera3, _model$camera4, _model$camera5, _model$camera6, _model$camera7;
 
     var animateSteps = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
 
@@ -343,20 +387,20 @@ function vtkViewProxy(publicAPI, model) {
     var position = model.camera.getFocalPoint();
     position[model.axis] += model.orientation;
 
-    (_model$camera = model.camera).setPosition.apply(_model$camera, _toConsumableArray(position));
+    (_model$camera3 = model.camera).setPosition.apply(_model$camera3, _toConsumableArray(position));
 
-    (_model$camera2 = model.camera).setViewUp.apply(_model$camera2, _toConsumableArray(viewUp));
+    (_model$camera4 = model.camera).setViewUp.apply(_model$camera4, _toConsumableArray(viewUp));
 
     model.renderer.resetCamera();
     var destFocalPoint = model.camera.getFocalPoint();
     var destPosition = model.camera.getPosition();
     var destViewUp = model.camera.getViewUp(); // Reset to original to prevent initial render flash
 
-    (_model$camera3 = model.camera).setFocalPoint.apply(_model$camera3, _toConsumableArray(originalFocalPoint));
+    (_model$camera5 = model.camera).setFocalPoint.apply(_model$camera5, _toConsumableArray(originalFocalPoint));
 
-    (_model$camera4 = model.camera).setPosition.apply(_model$camera4, _toConsumableArray(originalPosition));
+    (_model$camera6 = model.camera).setPosition.apply(_model$camera6, _toConsumableArray(originalPosition));
 
-    (_model$camera5 = model.camera).setViewUp.apply(_model$camera5, _toConsumableArray(originalViewUp));
+    (_model$camera7 = model.camera).setViewUp.apply(_model$camera7, _toConsumableArray(originalViewUp));
 
     return publicAPI.moveCamera(destFocalPoint, destPosition, destViewUp, animateSteps);
   }; // --------------------------------------------------------------------------
@@ -447,18 +491,18 @@ function vtkViewProxy(publicAPI, model) {
 
       var consumeAnimationStack = function consumeAnimationStack() {
         if (animationStack.length) {
-          var _model$camera6, _model$camera7, _model$camera8;
+          var _model$camera8, _model$camera9, _model$camera10;
 
           var _animationStack$pop = animationStack.pop(),
               cameraFocalPoint = _animationStack$pop.focalPoint,
               cameraPosition = _animationStack$pop.position,
               cameraViewUp = _animationStack$pop.viewUp;
 
-          (_model$camera6 = model.camera).setFocalPoint.apply(_model$camera6, _toConsumableArray(cameraFocalPoint));
+          (_model$camera8 = model.camera).setFocalPoint.apply(_model$camera8, _toConsumableArray(cameraFocalPoint));
 
-          (_model$camera7 = model.camera).setPosition.apply(_model$camera7, _toConsumableArray(cameraPosition));
+          (_model$camera9 = model.camera).setPosition.apply(_model$camera9, _toConsumableArray(cameraPosition));
 
-          (_model$camera8 = model.camera).setViewUp.apply(_model$camera8, _toConsumableArray(cameraViewUp));
+          (_model$camera10 = model.camera).setViewUp.apply(_model$camera10, _toConsumableArray(cameraViewUp));
 
           model.renderer.resetCameraClippingRange();
 
@@ -484,7 +528,7 @@ function vtkViewProxy(publicAPI, model) {
 
 
   publicAPI.rotate = function (angle) {
-    var _model$camera9;
+    var _model$camera11;
 
     var _model$camera$get = model.camera.get('viewUp', 'focalPoint', 'position'),
         viewUp = _model$camera$get.viewUp,
@@ -494,7 +538,7 @@ function vtkViewProxy(publicAPI, model) {
     var axis = [focalPoint[0] - position[0], focalPoint[1] - position[1], focalPoint[2] - position[2]];
     vtkMatrixBuilder.buildFromDegree().rotate(Number.isNaN(angle) ? 90 : angle, axis).apply(viewUp);
 
-    (_model$camera9 = model.camera).setViewUp.apply(_model$camera9, _toConsumableArray(viewUp));
+    (_model$camera11 = model.camera).setViewUp.apply(_model$camera11, _toConsumableArray(viewUp));
 
     model.camera.modified();
     model.orientationWidget.updateMarkerOrientation();

package/Rendering/Core/Camera.js

@@ -1,7 +1,7 @@
 import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import { mat4, vec4, vec3, quat } from 'gl-matrix';
 import macro from '../../macros.js';
-import { r as radiansFromDegrees, l as add, k as cross } from '../../Common/Core/Math/index.js';
+import { r as radiansFromDegrees, k as add, j as cross } from '../../Common/Core/Math/index.js';
 
 var vtkDebugMacro = macro.vtkDebugMacro;
 /* eslint-disable new-cap */

package/Rendering/Core/CellPicker.js

@@ -6,7 +6,7 @@ import vtkPicker from './Picker.js';
 import vtkPolyLine from '../../Common/DataModel/PolyLine.js';
 import vtkTriangle from '../../Common/DataModel/Triangle.js';
 import vtkQuad from '../../Common/DataModel/Quad.js';
-import { m as normalize } from '../../Common/Core/Math/index.js';
+import { l as normalize } from '../../Common/Core/Math/index.js';
 import { CellType } from '../../Common/DataModel/CellTypes/Constants.js';
 import { vec3 } from 'gl-matrix';
 

package/Rendering/Core/ColorTransferFunction.js

@@ -1,6 +1,6 @@
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import macro from '../../macros.js';
-import { h as hsv2rgb, i as isNan, G as isInf, H as rgb2hsv, I as rgb2lab, J as lab2rgb, K as floor } from '../../Common/Core/Math/index.js';
+import { h as hsv2rgb, i as isNan, F as isInf, G as rgb2hsv, H as rgb2lab, I as lab2rgb, J as floor } from '../../Common/Core/Math/index.js';
 import vtkScalarsToColors from '../../Common/Core/ScalarsToColors.js';
 import Constants from './ColorTransferFunction/Constants.js';
 

package/Rendering/Core/Coordinate.js

@@ -1,7 +1,7 @@
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import macro from '../../macros.js';
 import Constants from './Coordinate/Constants.js';
-import { L as round, K as floor } from '../../Common/Core/Math/index.js';
+import { K as round, J as floor } from '../../Common/Core/Math/index.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; }
 

package/Rendering/Core/CubeAxesActor.js

@@ -2,7 +2,7 @@ import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import { vec3, mat4 } from 'gl-matrix';
 import * as d3 from 'd3-scale';
-import { M as normalize2D, N as nearestPowerOfTwo } from '../../Common/Core/Math/index.js';
+import { L as normalize2D, M as nearestPowerOfTwo } from '../../Common/Core/Math/index.js';
 import macro from '../../macros.js';
 import vtkActor from './Actor.js';
 import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';

package/Rendering/Core/Glyph3DMapper.js

@@ -4,7 +4,7 @@ import { mat4, vec3, mat3 } from 'gl-matrix';
 import Constants from './Glyph3DMapper/Constants.js';
 import macro from '../../macros.js';
 import vtkMapper from './Mapper.js';
-import { O as createUninitializedBounds, n as norm } from '../../Common/Core/Math/index.js';
+import { N as createUninitializedBounds, n as norm } from '../../Common/Core/Math/index.js';
 import vtkBoundingBox from '../../Common/DataModel/BoundingBox.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; }

package/Rendering/Core/ImageMapper.js

@@ -2,7 +2,7 @@ import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import Constants from './ImageMapper/Constants.js';
 import macro from '../../macros.js';
 import vtkAbstractMapper from './AbstractMapper.js';
-import { D as clampValue, P as multiply3x3_vect3, O as createUninitializedBounds } from '../../Common/Core/Math/index.js';
+import { C as clampValue, O as multiply3x3_vect3, N as createUninitializedBounds } from '../../Common/Core/Math/index.js';
 import vtkPlane from '../../Common/DataModel/Plane.js';
 import CoincidentTopologyHelper from './Mapper/CoincidentTopologyHelper.js';
 import { vec3 } from 'gl-matrix';

package/Rendering/Core/Light.js

@@ -1,5 +1,5 @@
 import macro from '../../macros.js';
-import { m as normalize, r as radiansFromDegrees } from '../../Common/Core/Math/index.js';
+import { l as normalize, r as radiansFromDegrees } from '../../Common/Core/Math/index.js';
 import { vec3 } from 'gl-matrix';
 
 var LIGHT_TYPES = ['HeadLight', 'CameraLight', 'SceneLight']; // ----------------------------------------------------------------------------

package/Rendering/Core/Mapper.js

@@ -4,7 +4,7 @@ import vtkAbstractMapper3D from './AbstractMapper3D.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
 import vtkImageData from '../../Common/DataModel/ImageData.js';
 import vtkLookupTable from '../../Common/Core/LookupTable.js';
-import { O as createUninitializedBounds, i as isNan } from '../../Common/Core/Math/index.js';
+import { N as createUninitializedBounds, i as isNan } from '../../Common/Core/Math/index.js';
 import vtkScalarsToColors from '../../Common/Core/ScalarsToColors/Constants.js';
 import CoincidentTopologyHelper from './Mapper/CoincidentTopologyHelper.js';
 import Constants from './Mapper/Constants.js';

package/Rendering/Core/Picker.js

@@ -2,7 +2,7 @@ import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import macro from '../../macros.js';
 import vtkAbstractPicker from './AbstractPicker.js';
 import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';
-import { d as dot, m as normalize, n as norm, f as distance2BetweenPoints } from '../../Common/Core/Math/index.js';
+import { d as dot, l as normalize, n as norm, e as distance2BetweenPoints } from '../../Common/Core/Math/index.js';
 import { mat4, vec4 } from 'gl-matrix';
 
 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; }

package/Rendering/Core/Prop3D.js

@@ -1,7 +1,7 @@
 import { mat4, quat } from 'gl-matrix';
 import macro from '../../macros.js';
 import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';
-import { B as degreesFromRadians, r as radiansFromDegrees, a as areMatricesEqual } from '../../Common/Core/Math/index.js';
+import { A as degreesFromRadians, r as radiansFromDegrees, a as areMatricesEqual } from '../../Common/Core/Math/index.js';
 import vtkProp from './Prop.js';
 
 // vtkProp3D methods

package/Rendering/Core/RenderWindowInteractor.js

@@ -1,7 +1,7 @@
 import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import macro from '../../macros.js';
-import { B as degreesFromRadians } from '../../Common/Core/Math/index.js';
+import { A as degreesFromRadians } from '../../Common/Core/Math/index.js';
 import Constants from './RenderWindowInteractor/Constants.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; }

package/Rendering/Core/Renderer.js

@@ -2,7 +2,7 @@ import { mat4, vec3 } from 'gl-matrix';
 import { newInstance as newInstance$1, get, setGet, getArray, setGetArray, moveToProtected, vtkDebugMacro as vtkDebugMacro$1, vtkErrorMacro as vtkErrorMacro$1, vtkWarningMacro as vtkWarningMacro$1 } from '../../macros.js';
 import vtkCamera from './Camera.js';
 import vtkLight from './Light.js';
-import { Q as areBoundsInitialized, u as uninitializeBounds, r as radiansFromDegrees, d as dot, O as createUninitializedBounds } from '../../Common/Core/Math/index.js';
+import { P as areBoundsInitialized, u as uninitializeBounds, r as radiansFromDegrees, d as dot, N as createUninitializedBounds } from '../../Common/Core/Math/index.js';
 import vtkViewport from './Viewport.js';
 import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';
 

package/Rendering/Core/ScalarBarActor.js

@@ -1,7 +1,7 @@
 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 { M as nearestPowerOfTwo } from '../../Common/Core/Math/index.js';
 import macro from '../../macros.js';
 import vtkActor from './Actor.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';

package/Rendering/Core/VolumeMapper.js

@@ -1,6 +1,6 @@
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import macro from '../../macros.js';
-import { O as createUninitializedBounds, D as clampValue, K as floor } from '../../Common/Core/Math/index.js';
+import { N as createUninitializedBounds, C as clampValue, J as floor } from '../../Common/Core/Math/index.js';
 import Constants from './VolumeMapper/Constants.js';
 import vtkAbstractMapper from './AbstractMapper.js';
 import vtkPiecewiseFunction from '../../Common/DataModel/PiecewiseFunction.js';

package/Rendering/OpenGL/PolyDataMapper.js

@@ -4,7 +4,7 @@ import { mat3, mat4, vec3 } from 'gl-matrix';
 import { newInstance as newInstance$1, setGet, obj, vtkErrorMacro as vtkErrorMacro$1 } from '../../macros.js';
 import vtkHelper from './Helper.js';
 import vtkMapper from '../Core/Mapper.js';
-import { m as normalize, u as uninitializeBounds } from '../../Common/Core/Math/index.js';
+import { l as normalize, u as uninitializeBounds } from '../../Common/Core/Math/index.js';
 import vtkOpenGLTexture from './Texture.js';
 import vtkProp from '../Core/Prop.js';
 import vtkProperty from '../Core/Property.js';

package/Rendering/OpenGL/PolyDataMapper2D.js

@@ -8,7 +8,7 @@ import { v as vtkPolyData2DVS } from './glsl/vtkPolyData2DVS.glsl.js';
 import vtkReplacementShaderMapper from './ReplacementShaderMapper.js';
 import vtkShaderProgram from './ShaderProgram.js';
 import vtkViewNode from '../SceneGraph/ViewNode.js';
-import { L as round } from '../../Common/Core/Math/index.js';
+import { K as round } from '../../Common/Core/Math/index.js';
 import { DisplayLocation } from '../Core/Property2D/Constants.js';
 import { registerOverride } from './ViewNodeFactory.js';
 

package/Rendering/OpenGL/Texture.js

@@ -3,7 +3,7 @@ import Constants from './Texture/Constants.js';
 import HalfFloat from '../../Common/Core/HalfFloat.js';
 import { newInstance as newInstance$1, obj, set, setGet, get, moveToProtected, newTypedArray, vtkDebugMacro as vtkDebugMacro$1, vtkErrorMacro as vtkErrorMacro$1, vtkWarningMacro as vtkWarningMacro$1 } from '../../macros.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
-import { R as isPowerOfTwo, N as nearestPowerOfTwo } from '../../Common/Core/Math/index.js';
+import { Q as isPowerOfTwo, M as nearestPowerOfTwo } from '../../Common/Core/Math/index.js';
 import vtkViewNode from '../SceneGraph/ViewNode.js';
 import { registerOverride } from './ViewNodeFactory.js';