@kitware/vtk.js 26.9.8 → 26.9.11

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/Core/Renderer.d.ts

@@ -63,6 +63,12 @@ export interface vtkRenderer extends vtkViewport {
 	 */
 	addActor(actor: vtkProp): boolean;
 
+	/**
+	 * Check if the renderer already has the specified light.
+	 * @param {vtkLight} light The vtkLight instance.
+	 */
+	hasLight(light: vtkLight): boolean;
+
 	/**
 	 * Add a light to the list of lights.
 	 * @param {vtkLight} light The vtkLight instance.

package/Rendering/Core/Renderer.js

@@ -192,9 +192,15 @@ function vtkRenderer(publicAPI, model) {
     publicAPI.modified();
   };
 
+  publicAPI.hasLight = function (light) {
+    return model.lights.includes(light);
+  };
+
   publicAPI.addLight = function (light) {
-    model.lights = [].concat(model.lights, light);
-    publicAPI.modified();
+    if (light && !publicAPI.hasLight(light)) {
+      model.lights.push(light);
+      publicAPI.modified();
+    }
   };
 
   publicAPI.removeLight = function (light) {

package/Rendering/Core/Viewport.js

@@ -20,14 +20,12 @@ function vtkViewport(publicAPI, model) {
   };
 
   publicAPI.hasViewProp = function (prop) {
-    return !!model.props.filter(function (item) {
-      return item === prop;
-    }).length;
+    return model.props.includes(prop);
   };
 
   publicAPI.addViewProp = function (prop) {
     if (prop && !publicAPI.hasViewProp(prop)) {
-      model.props = model.props.concat(prop);
+      model.props.push(prop);
     }
   };
 

package/Rendering/Misc/SynchronizableRenderWindow/BehaviorManager.js

@@ -1,6 +1,54 @@
+import _classCallCheck from '@babel/runtime/helpers/classCallCheck';
+import _createClass from '@babel/runtime/helpers/createClass';
 import vtkCameraSynchronizer from './BehaviorManager/CameraSynchronizer.js';
 
 var BEHAVIORS = {};
+
+var CameraSync = /*#__PURE__*/function () {
+  function CameraSync(ctx, config) {
+    _classCallCheck(this, CameraSync);
+
+    this.ctx = ctx;
+    this.behavior = vtkCameraSynchronizer.newInstance(this.getProperties(config));
+    this.behavior.update();
+  }
+
+  _createClass(CameraSync, [{
+    key: "getProperties",
+    value: function getProperties(_ref) {
+      var actorBounds = _ref.actorBounds,
+          srcRenderer = _ref.srcRenderer,
+          dstRenderer = _ref.dstRenderer;
+      var distance = 3.4 * Math.max(actorBounds[1] - actorBounds[0], actorBounds[3] - actorBounds[2], actorBounds[5] - actorBounds[4]);
+      var focalPoint = [0.5 * (actorBounds[0] + actorBounds[1]), 0.5 * (actorBounds[2] + actorBounds[3]), 0.5 * (actorBounds[4] + actorBounds[5])];
+      var mode = vtkCameraSynchronizer.SynchronizationMode.MODE_ORIENTATION;
+      return {
+        distance: distance,
+        focalPoint: focalPoint,
+        mode: mode,
+        srcRenderer: this.ctx.getInstance(srcRenderer),
+        dstRenderer: this.ctx.getInstance(dstRenderer)
+      };
+    }
+  }, {
+    key: "update",
+    value: function update(config) {
+      this.behavior.set(this.getProperties(config));
+      this.behavior.update();
+    }
+  }, {
+    key: "delete",
+    value: function _delete() {
+      this.behavior.delete();
+    }
+  }]);
+
+  return CameraSync;
+}();
+
+var BEHAVIORS_TYPES = {
+  CameraSync: CameraSync
+};
 function applyBehaviors(renderWindow, state, context) {
   if (!state.behaviors || !renderWindow.getSynchronizedViewId) {
     return;
@@ -44,9 +92,37 @@ function applyBehaviors(renderWindow, state, context) {
       localBehaviors.autoOrientationAxes.delete();
       delete localBehaviors.autoOrientationAxes;
     }
-  } // Process remaining behaviors...
-  // TODO - widgets(orientation, ...)
+  }
+
+  var currentSets = Object.keys(state.behaviors);
+  var existingSets = Object.keys(localBehaviors);
+
+  for (var _i = 0; _i < currentSets.length; _i++) {
+    var key = currentSets[_i];
+
+    if (!localBehaviors[key]) {
+      var config = state.behaviors[key];
+
+      if (BEHAVIORS_TYPES[config.type]) {
+        localBehaviors[key] = new BEHAVIORS_TYPES[config.type](context, config);
+      } else {
+        console.log('No mapping for', config);
+      }
+    } else {
+      localBehaviors[key].update(state.behaviors[key]);
+    }
+  }
+
+  for (var _i2 = 0; _i2 < existingSets.length; _i2++) {
+    var _key = currentSets[_i2];
+
+    if (!state.behaviors[_key]) {
+      // Need to delete previously created behavior
+      localBehaviors[_key].delete();
 
+      delete localBehaviors[_key];
+    }
+  }
 }
 var BehaviorManager = {
   applyBehaviors: applyBehaviors

package/Rendering/Misc/SynchronizableRenderWindow/ObjectManager.js

@@ -416,9 +416,7 @@ function vtkRenderWindowUpdater(instance, state, context) {
           }
 
           context.unregisterInstance(context.getInstanceId(viewProp));
-        }); // Now just remove all the view props
-
-        renderer.removeAllViewProps();
+        });
       });
     });
   }

package/Rendering/Misc/SynchronizableRenderWindow.js

@@ -121,6 +121,9 @@ function createInstanceMap() {
 
   function registerInstance(id, instance) {
     instances[id] = instance;
+    instance.set({
+      remoteId: id
+    }, true, true);
   }
 
   function unregisterInstance(id) {

package/package.json

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