@kitware/vtk.js 27.2.1 → 27.3.1

package/IO/Misc/OBJReader.js

@@ -349,7 +349,9 @@ function vtkOBJReader(publicAPI, model) {
 
   publicAPI.loadData = function () {
     var option = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    return fetchData(model.url, option).then(publicAPI.parseAsText);
+    return fetchData(model.url, option).then(function (content) {
+      return publicAPI.isDeleted() ? false : publicAPI.parseAsText(content);
+    });
   };
 
   publicAPI.parseAsText = function (content) {

package/Interaction/Manipulators/MouseCameraAxisRotateManipulator.js

@@ -1,10 +1,8 @@
-import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
-import { mat4, vec3 } from 'gl-matrix';
+import { vec3, mat4 } from 'gl-matrix';
 import macro from '../../macros.js';
 import vtkCompositeCameraManipulator from './CompositeCameraManipulator.js';
 import vtkCompositeMouseManipulator from './CompositeMouseManipulator.js';
 import { r as radiansFromDegrees, j as cross } from '../../Common/Core/Math/index.js';
-import vtkMatrixBuilder from '../../Common/Core/MatrixBuilder.js';
 
 // vtkMouseCameraAxisRotateManipulator methods
 // ----------------------------------------------------------------------------
@@ -12,14 +10,15 @@ import vtkMatrixBuilder from '../../Common/Core/MatrixBuilder.js';
 function vtkMouseCameraAxisRotateManipulator(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkMouseCameraAxisRotateManipulator');
+  var negCameraDir = new Float64Array(3);
   var newCamPos = new Float64Array(3);
-  var newFp = new Float64Array(3); // const newViewUp = new Float64Array(3);
-
+  var newFp = new Float64Array(3);
+  var newViewUp = new Float64Array(3);
   var trans = new Float64Array(16);
+  var rotation = new Float64Array(16);
   var v2 = new Float64Array(3);
   var centerNeg = new Float64Array(3);
-  var direction = new Float64Array(3);
-  var fpDirection = new Float64Array(3);
+  var negRotationAxis = new Float64Array(3);
 
   publicAPI.onButtonDown = function (interactor, renderer, position) {
     model.previousPosition = position;
@@ -35,83 +34,53 @@ function vtkMouseCameraAxisRotateManipulator(publicAPI, model) {
     var cameraFp = camera.getFocalPoint();
     var cameraViewUp = camera.getViewUp();
     var cameraDirection = camera.getDirectionOfProjection();
+    vec3.negate(negCameraDir, cameraDirection);
     mat4.identity(trans);
+    mat4.identity(rotation);
     var center = model.center,
         rotationFactor = model.rotationFactor,
-        rotationAxis = model.rotationAxis; // Translate to center
-
-    mat4.translate(trans, trans, center);
+        rotationAxis = model.rotationAxis;
+    vec3.negate(negRotationAxis, rotationAxis);
     var dx = model.previousPosition.x - position.x;
     var dy = model.previousPosition.y - position.y;
     var size = interactor.getView().getViewportSize(renderer); // Azimuth
 
-    mat4.rotate(trans, trans, radiansFromDegrees(360.0 * dx / size[0] * rotationFactor), rotationAxis); // Elevation
+    var azimuthDelta = radiansFromDegrees(360.0 * dx / size[0] * rotationFactor);
+    mat4.rotate(rotation, rotation, azimuthDelta, rotationAxis); // Elevation
 
     cross(cameraDirection, cameraViewUp, v2);
-    mat4.rotate(trans, trans, radiansFromDegrees(-360.0 * dy / size[1] * rotationFactor), v2); // Translate back
-
-    centerNeg[0] = -center[0];
-    centerNeg[1] = -center[1];
-    centerNeg[2] = -center[2];
-    mat4.translate(trans, trans, centerNeg); // Apply transformation to camera position, focal point, and view up
+    var elevationDelta = radiansFromDegrees(-360.0 * dy / size[1] * rotationFactor); // angle of camera to rotation axis on the positive or negative half,
+    // relative to the origin.
 
-    vec3.transformMat4(newCamPos, cameraPos, trans);
-    vec3.transformMat4(newFp, cameraFp, trans); // what is the current direction from the fp
-    // to the camera
+    var angleToPosHalf = Math.acos(vec3.dot(negCameraDir, rotationAxis));
+    var angleToNegHalf = Math.acos(vec3.dot(negCameraDir, negRotationAxis)); // whether camera is in positive half of the rotation axis or neg half
 
-    vec3.subtract(fpDirection, newCamPos, newFp);
-    vec3.normalize(fpDirection, fpDirection); // make the top sticky to avoid accidental flips
+    var inPosHalf = angleToPosHalf <= angleToNegHalf;
+    var elevationToAxis = Math.min(angleToPosHalf, angleToNegHalf);
 
-    if (Math.abs(vec3.dot(fpDirection, rotationAxis)) > 0.95) {
-      // this can be smarter where it still allows Azimuth here
-      // but prevents the elevation part
-      model.previousPosition = position;
-      return;
+    if (model.useHalfAxis && !inPosHalf) {
+      elevationDelta = Math.PI / 2 - angleToPosHalf;
+    } else if (inPosHalf && elevationToAxis + elevationDelta < 0) {
+      elevationDelta = -elevationToAxis; // } else if (!inPosHalf && elevationToAxis - elevationDelta < 0) {
+    } else if (!inPosHalf && angleToPosHalf + elevationDelta > Math.PI) {
+      elevationDelta = elevationToAxis;
     }
 
-    if (model.useHalfAxis) {
-      // what is the current distance from pos to center of rotation
-      var distance = vec3.distance(newCamPos, center); // what is the current direction from the center of rotation
-      // to the camera
-
-      vec3.subtract(direction, newCamPos, center);
-      vec3.normalize(direction, direction); // project the rotation axis onto the direction
-      // so we know how much below the half plane we are
-
-      var dotP = vec3.dot(rotationAxis, direction);
+    mat4.rotate(rotation, rotation, elevationDelta, v2); // Translate from origin
 
-      if (dotP < 0) {
-        // adjust the new camera position to bring it up to the half plane
-        vec3.scaleAndAdd(newCamPos, newCamPos, rotationAxis, -dotP * distance); // the above step will change the distance which might feel odd
-        // so the next couple lines restore the distance to the center
-        // what is the new direction from the center of rotation
-        // to the camera
+    mat4.translate(trans, trans, center); // apply rotation
 
-        vec3.subtract(direction, newCamPos, center);
-        vec3.normalize(direction, direction);
-        vec3.scaleAndAdd(newCamPos, center, direction, distance); // compute original cam direction to center
+    mat4.multiply(trans, trans, rotation); // Translate to origin
 
-        vec3.subtract(v2, cameraPos, center);
-        vec3.normalize(v2, v2); // const rAngle = 0.0;
-
-        var acosR = Math.min(1.0, Math.max(-1.0, vec3.dot(direction, v2)));
-        var rAngle = Math.acos(acosR); // 0 to pi
-
-        vec3.cross(v2, v2, direction);
-        vec3.normalize(v2, v2);
-        vec3.subtract(newFp, cameraFp, center);
-        var fpDist = vec3.length(newFp); // Note it normalizes the vector to be rotated
-
-        var result = _toConsumableArray(newFp);
-
-        vtkMatrixBuilder.buildFromRadian().rotate(rAngle, v2).apply(result);
-        vec3.scaleAndAdd(newFp, center, result, fpDist);
-      }
-    }
+    vec3.negate(centerNeg, center);
+    mat4.translate(trans, trans, centerNeg); // Apply transformation to camera position, focal point, and view up
 
+    vec3.transformMat4(newCamPos, cameraPos, trans);
+    vec3.transformMat4(newFp, cameraFp, trans);
+    vec3.transformMat4(newViewUp, cameraViewUp, rotation);
     camera.setPosition(newCamPos[0], newCamPos[1], newCamPos[2]);
     camera.setFocalPoint(newFp[0], newFp[1], newFp[2]);
-    camera.setViewUp(rotationAxis);
+    camera.setViewUp(newViewUp);
     renderer.resetCameraClippingRange();
 
     if (interactor.getLightFollowCamera()) {

package/Rendering/Core/Actor2D.d.ts

@@ -2,6 +2,7 @@ import vtkProp, { IPropInitialValues } from './Prop';
 import vtkCoordinate from './Coordinate';
 import vtkMapper from './Mapper';
 import vtkProperty2D, { IProperty2DInitialValues } from './Property2D';
+import vtkMapper2D from './Mapper2D';
 import { Bounds } from './../../types';
 
 /**
@@ -44,6 +45,16 @@ export interface vtkActor2D extends vtkProp {
 	 */
 	 makeProperty(initialValues?: IProperty2DInitialValues): vtkProperty2D;
 
+	/**
+	 * Sets the 2D mapper.
+	 */
+	setMapper(mapper: vtkMapper2D): boolean;
+
+	/**
+	 * Gets the 2D mapper.
+	 */
+	getMapper(): vtkMapper2D;
+
 	/**
 	 * 
 	 */

package/Rendering/OpenGL/ImageResliceMapper.js

@@ -126,9 +126,6 @@ function vtkOpenGLImageResliceMapper(publicAPI, model) {
     });
     model.renderable.update();
     model.currentInput = model.renderable.getInputData();
-    publicAPI.invokeEvent({
-      type: 'EndEvent'
-    });
 
     if (!model.currentInput) {
       vtkErrorMacro('No input!');
@@ -139,6 +136,9 @@ function vtkOpenGLImageResliceMapper(publicAPI, model) {
     publicAPI.renderPieceStart(ren, actor);
     publicAPI.renderPieceDraw(ren, actor);
     publicAPI.renderPieceFinish(ren, actor);
+    publicAPI.invokeEvent({
+      type: 'EndEvent'
+    });
   };
 
   publicAPI.renderPieceStart = function (ren, actor) {

package/Rendering/OpenGL/Texture.js

@@ -16,7 +16,8 @@ var Wrap = Constants.Wrap,
 var VtkDataTypes = vtkDataArray.VtkDataTypes;
 var vtkDebugMacro = vtkDebugMacro$1,
     vtkErrorMacro = vtkErrorMacro$1,
-    vtkWarningMacro = vtkWarningMacro$1; // ----------------------------------------------------------------------------
+    vtkWarningMacro = vtkWarningMacro$1;
+var toHalf = HalfFloat.toHalf; // ----------------------------------------------------------------------------
 // vtkOpenGLTexture methods
 // ----------------------------------------------------------------------------
 
@@ -610,9 +611,10 @@ function vtkOpenGLTexture(publicAPI, model) {
       for (var _idx2 = 0; _idx2 < data.length; _idx2++) {
         if (data[_idx2]) {
           var newArray = new Uint16Array(pixCount);
+          var src = data[_idx2];
 
           for (var i = 0; i < pixCount; i++) {
-            newArray[i] = HalfFloat.toHalf(data[_idx2][i]);
+            newArray[i] = toHalf(src[i]);
           }
 
           pixData.push(newArray);

package/Widgets/Core/WidgetManager.d.ts

@@ -82,6 +82,13 @@ export interface vtkWidgetManager extends vtkObject {
    */
   getWidgets(): vtkAbstractWidget[];
 
+  /**
+   * Get the active widget.
+   *
+   * If no widget is active, returns null.
+   */
+  getActiveWidget(): Nullable<vtkAbstractWidget>;
+
   /**
    * Get the view id.
    */

package/Widgets/Core/WidgetManager.js

@@ -190,10 +190,12 @@ function vtkWidgetManager(publicAPI, model) {
               // Default cursor behavior
               model._apiSpecificRenderWindow.setCursor(widget ? 'pointer' : 'default');
 
+              model.activeWidget = null;
               wantRender = false;
 
               if (model.widgetInFocus === widget && widget.hasFocus()) {
                 activateHandle(widget);
+                model.activeWidget = widget;
                 wantRender = true;
               } else {
                 for (i = 0; i < model.widgets.length; i++) {
@@ -214,7 +216,7 @@ function vtkWidgetManager(publicAPI, model) {
                 model._interactor.render();
               }
 
-            case 15:
+            case 16:
             case "end":
               return _context3.stop();
           }
@@ -614,6 +616,7 @@ var DEFAULT_VALUES = {
   // _currentUpdateSelectionCallID: null,
   viewId: null,
   widgets: [],
+  activeWidget: null,
   renderer: null,
   viewType: ViewTypes.DEFAULT,
   isAnimating: false,
@@ -633,7 +636,7 @@ function extend(publicAPI, model) {
     name: 'viewType',
     enum: ViewTypes
   }]);
-  macro.get(publicAPI, model, ['selections', 'widgets', 'viewId', 'pickingEnabled']); // Object specific methods
+  macro.get(publicAPI, model, ['selections', 'widgets', 'viewId', 'pickingEnabled', 'activeWidget']); // Object specific methods
 
   vtkWidgetManager(publicAPI, model);
 } // ----------------------------------------------------------------------------

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kitware/vtk.js",
-  "version": "27.2.1",
+  "version": "27.3.1",
   "description": "Visualization Toolkit for the Web",
   "keywords": [
     "3d",