@kitware/vtk.js 26.9.7 → 26.9.9

package/Proxy/Core/ProxyManager.d.ts

@@ -6,7 +6,7 @@ import vtkLookupTableProxy from './LookupTableProxy';
 import vtkPiecewiseFunctionProxy from './PiecewiseFunctionProxy';
 import { VtkProxy } from './../../macros';
 
-export type ProxyConfiguration = Object;
+export type ProxyConfiguration = object;
 
 export interface ProxyRegistrationChangeInfo {
   action: 'register' | 'unregister';
@@ -16,6 +16,10 @@ export interface ProxyRegistrationChangeInfo {
   proxy: VtkProxy;
 }
 
+export interface IProxyManagerInitialValues {
+  proxyConfiguration?: ProxyConfiguration;
+}
+
 export interface vtkProxyManager extends vtkObject {
   // core //
 
@@ -78,4 +82,34 @@ export interface vtkProxyManager extends vtkObject {
   ): void;
 }
 
+/**
+ * Decorates a given publicAPI + model with vtkProxyManager characteristics.
+ *
+ * @param publicAPI
+ * @param model
+ * @param {IProxyManagerInitialValues} [initialValues]
+ */
+export function extend(
+  publicAPI: object,
+  model: object,
+  initialValues?: IProxyManagerInitialValues
+): void;
+
+/**
+ * Creates a vtkProxyManager.
+ * @param {IProxyManagerInitialValues} [initialValues]
+ */
+export function newInstance(
+  initialValues?: IProxyManagerInitialValues
+): vtkProxyManager;
+
+/**
+ * vtkProxyManager is the central manager for managing proxy resources
+ * in vtk.js.
+ */
+export declare const vtkProxyManager: {
+  newInstance: typeof newInstance;
+  extend: typeof extend;
+};
+
 export default vtkProxyManager;

package/Rendering/Misc/SynchronizableRenderWindow/BehaviorManager/CameraSynchronizer.js

@@ -0,0 +1,129 @@
+import { newInstance as newInstance$1, obj, setGet, setGetArray, chain } from '../../../../macros.js';
+import { l as normalize } from '../../../../Common/Core/Math/index.js';
+
+var MODE_RESET_CAMERA = 'resetcamera';
+var MODE_ORIENTATION = 'orientation';
+var MODE_SAME = 'same';
+var SynchronizationMode = {
+  MODE_RESET_CAMERA: MODE_RESET_CAMERA,
+  MODE_ORIENTATION: MODE_ORIENTATION,
+  MODE_SAME: MODE_SAME
+};
+
+function vtkCameraSynchronizer(publicAPI, model) {
+  model.classHierarchy.push('vtkCameraSynchronizer');
+  var cameraState = new Float64Array(9);
+  var direction = new Float64Array(3);
+  var subscriptions = [];
+
+  function updateListeners() {
+    while (subscriptions.length) {
+      subscriptions.pop().unsubscribe();
+    }
+
+    if (!model.srcRenderer || !model.dstRenderer) {
+      return;
+    }
+
+    var srcCamera = model.srcRenderer.getActiveCamera();
+    var interactor = model.srcRenderer.getRenderWindow().getInteractor();
+    subscriptions.push(srcCamera.onModified(function () {
+      if (!interactor.isAnimating()) {
+        publicAPI.update();
+      }
+    }));
+    subscriptions.push(interactor.onAnimation(publicAPI.update));
+    subscriptions.push(interactor.onEndAnimation(publicAPI.update));
+  } // Update listeners automatically
+
+
+  model._srcRendererChanged = updateListeners;
+  model._dstRendererChanged = updateListeners;
+
+  function updatePreviousValues(position, focalPoint, viewUp) {
+    if (cameraState[0] !== position[0] || cameraState[1] !== position[1] || cameraState[2] !== position[2] || cameraState[3] !== focalPoint[0] || cameraState[4] !== focalPoint[1] || cameraState[5] !== focalPoint[2] || cameraState[6] !== viewUp[0] || cameraState[7] !== viewUp[1] || cameraState[8] !== viewUp[2]) {
+      cameraState[0] = position[0];
+      cameraState[1] = position[1];
+      cameraState[2] = position[2];
+      cameraState[3] = focalPoint[0];
+      cameraState[4] = focalPoint[1];
+      cameraState[5] = focalPoint[2];
+      cameraState[6] = viewUp[0];
+      cameraState[7] = viewUp[1];
+      cameraState[8] = viewUp[2];
+      return cameraState;
+    }
+
+    return false;
+  }
+
+  publicAPI.update = function () {
+    if (!model.active || !model.srcRenderer || !model.dstRenderer) {
+      return;
+    }
+
+    var srcCamera = model.srcRenderer.getActiveCamera();
+    var dstCamera = model.dstRenderer.getActiveCamera();
+    var position = srcCamera.getReferenceByName('position');
+    var focalPoint = srcCamera.getReferenceByName('focalPoint');
+    var viewUp = srcCamera.getReferenceByName('viewUp');
+    var change = updatePreviousValues(position, focalPoint, viewUp);
+
+    if (!change) {
+      return;
+    }
+
+    if (model.mode === MODE_ORIENTATION) {
+      direction[0] = change[0] - change[3];
+      direction[1] = change[1] - change[4];
+      direction[2] = change[2] - change[5];
+      normalize(direction);
+      dstCamera.setPosition(model.focalPoint[0] + model.distance * direction[0], model.focalPoint[1] + model.distance * direction[1], model.focalPoint[2] + model.distance * direction[2]);
+      dstCamera.setFocalPoint(model.focalPoint[0], model.focalPoint[1], model.focalPoint[2]);
+      dstCamera.setViewUp(change[6], change[7], change[8]);
+    } else {
+      dstCamera.setPosition(change[0], change[1], change[2]);
+      dstCamera.setFocalPoint(change[3], change[4], change[5]);
+      dstCamera.setViewUp(change[6], change[7], change[8]);
+    }
+
+    if (model.mode === MODE_RESET_CAMERA) {
+      model.dstRenderer.resetCamera();
+    }
+  };
+
+  publicAPI.delete = chain(function () {
+    return publicAPI.setSrcRenderer(null);
+  }, // Will clear any listener
+  publicAPI.delete); // If src/dstRenderer provided at constructor register listeners
+
+  updateListeners();
+}
+
+var DEFAULT_VALUES = {
+  mode: MODE_ORIENTATION,
+  focalPoint: [0, 0, 0],
+  distance: 6.8,
+  active: true // srcRenderer: null,
+  // dstRenderer: null,
+
+};
+function extend(publicAPI, model) {
+  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues); // Build VTK API
+
+  obj(publicAPI, model);
+  setGet(publicAPI, model, ['mode', 'active', 'srcRenderer', 'dstRenderer', 'distance']);
+  setGetArray(publicAPI, model, ['focalPoint'], 3, 0); // Object methods
+
+  vtkCameraSynchronizer(publicAPI, model);
+} // ----------------------------------------------------------------------------
+
+var newInstance = newInstance$1(extend, 'vtkCameraSynchronizer');
+var vtkCameraSynchronizer$1 = {
+  newInstance: newInstance,
+  extend: extend,
+  SynchronizationMode: SynchronizationMode
+};
+
+export { DEFAULT_VALUES, MODE_ORIENTATION, MODE_RESET_CAMERA, MODE_SAME, SynchronizationMode, vtkCameraSynchronizer$1 as default, extend, newInstance };

package/Rendering/Misc/SynchronizableRenderWindow/BehaviorManager.js

@@ -0,0 +1,55 @@
+import vtkCameraSynchronizer from './BehaviorManager/CameraSynchronizer.js';
+
+var BEHAVIORS = {};
+function applyBehaviors(renderWindow, state, context) {
+  if (!state.behaviors || !renderWindow.getSynchronizedViewId) {
+    return;
+  } // Apply auto behavior
+
+
+  var rwId = renderWindow.getSynchronizedViewId();
+
+  if (!BEHAVIORS[rwId]) {
+    BEHAVIORS[rwId] = {};
+  }
+
+  var localBehaviors = BEHAVIORS[rwId];
+
+  if (state.behaviors.autoOrientation) {
+    var renderers = renderWindow.getRenderers();
+
+    if (!localBehaviors.autoOrientationAxes && renderers.length === 2) {
+      var srcRenderer = null;
+      var dstRenderer = null;
+
+      for (var i = 0; i < renderers.length; i++) {
+        var renderer = renderers[i];
+
+        if (renderer.getInteractive()) {
+          srcRenderer = renderer;
+        } else {
+          dstRenderer = renderer;
+        }
+      }
+
+      if (srcRenderer && dstRenderer) {
+        localBehaviors.autoOrientationAxes = vtkCameraSynchronizer.newInstance({
+          srcRenderer: srcRenderer,
+          dstRenderer: dstRenderer
+        });
+      }
+    }
+
+    if (localBehaviors.autoOrientationAxes && renderers.length !== 2) {
+      localBehaviors.autoOrientationAxes.delete();
+      delete localBehaviors.autoOrientationAxes;
+    }
+  } // Process remaining behaviors...
+  // TODO - widgets(orientation, ...)
+
+}
+var BehaviorManager = {
+  applyBehaviors: applyBehaviors
+};
+
+export { applyBehaviors, BehaviorManager as default };

package/Rendering/Misc/SynchronizableRenderWindow/ObjectManager.js

@@ -28,6 +28,7 @@ import vtkPiecewiseFunction from '../../../Common/DataModel/PiecewiseFunction.js
 import vtkCubeAxesActor from '../../Core/CubeAxesActor.js';
 import vtkScalarBarActor from '../../Core/ScalarBarActor.js';
 import vtkAxesActor from '../../Core/AxesActor.js';
+import BehaviorManager from './BehaviorManager.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; }
 
@@ -424,7 +425,9 @@ function vtkRenderWindowUpdater(instance, state, context) {
 
   instance.render(); // Now just do normal update process
 
-  genericUpdater(instance, state, context);
+  genericUpdater(instance, state, context); // Manage any associated behaviors
+
+  BehaviorManager.applyBehaviors(instance, state, context);
 } // ----------------------------------------------------------------------------
 
 

package/package.json

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