@kitware/vtk.js 28.10.2 → 28.11.1

package/Rendering/Misc/CanvasView.js

@@ -1,173 +1,174 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 
-var vtkErrorMacro = macro.vtkErrorMacro; // ----------------------------------------------------------------------------
+const {
+  vtkErrorMacro
+} = macro;
+
+// ----------------------------------------------------------------------------
 // vtkCanvasView methods
 // ----------------------------------------------------------------------------
 
 function vtkCanvasView(publicAPI, model) {
   // Set our className
-  model.classHierarchy.push('vtkCanvasView'); // Auto update style
+  model.classHierarchy.push('vtkCanvasView');
 
+  // Auto update style
   function updateWindow() {
     // Canvas size
     if (model._renderable) {
       model.canvas.setAttribute('width', model.size[0]);
       model.canvas.setAttribute('height', model.size[1]);
-    } // ImageStream size
-
+    }
 
+    // ImageStream size
     if (model.viewStream) {
       // If same size that's a NoOp
       model.viewStream.setSize(model.size[0], model.size[1]);
-    } // Offscreen ?
-
+    }
 
-    model.canvas.style.display = model.useOffScreen ? 'none' : 'block'; // Cursor type
+    // Offscreen ?
+    model.canvas.style.display = model.useOffScreen ? 'none' : 'block';
 
+    // Cursor type
     if (model.el) {
       model.el.style.cursor = model.cursorVisibility ? model.cursor : 'none';
     }
   }
-
   publicAPI.onModified(updateWindow);
-
-  publicAPI.setContainer = function (el) {
+  publicAPI.setContainer = el => {
     if (model.el && model.el !== el) {
       if (model.canvas.parentNode !== model.el) {
         vtkErrorMacro('Error: canvas parent node does not match container');
-      } // Remove canvas from previous container
+      }
 
+      // Remove canvas from previous container
+      model.el.removeChild(model.canvas);
 
-      model.el.removeChild(model.canvas); // If the renderer has previously added
+      // If the renderer has previously added
       // a background image, remove it from the DOM.
-
       if (model.el.contains(model.bgImage)) {
         model.el.removeChild(model.bgImage);
       }
     }
-
     if (model.el !== el) {
       model.el = el;
-
       if (model.el) {
         model.el.appendChild(model.canvas);
-      } // If the renderer is set to use a background
-      // image, attach it to the DOM.
-
+      }
 
+      // If the renderer is set to use a background
+      // image, attach it to the DOM.
       if (model.useBackgroundImage) {
         model.el.appendChild(model.bgImage);
-      } // Trigger modified()
-
+      }
 
+      // Trigger modified()
       publicAPI.modified();
     }
   };
-
-  publicAPI.setBackgroundImage = function (img) {
+  publicAPI.setBackgroundImage = img => {
     model.bgImage.src = img.src;
   };
+  publicAPI.setUseBackgroundImage = value => {
+    model.useBackgroundImage = value;
 
-  publicAPI.setUseBackgroundImage = function (value) {
-    model.useBackgroundImage = value; // Add or remove the background image from the
+    // Add or remove the background image from the
     // DOM as specified.
-
     if (model.useBackgroundImage && model.el && !model.el.contains(model.bgImage)) {
       model.el.appendChild(model.bgImage);
     } else if (!model.useBackgroundImage && model.el && model.el.contains(model.bgImage)) {
       model.el.removeChild(model.bgImage);
     }
   };
-
-  publicAPI.setViewStream = function (stream) {
+  publicAPI.setViewStream = stream => {
     if (model.viewStream === stream) {
       return false;
     }
-
     if (model.subscription) {
       model.subscription.unsubscribe();
       model.subscription = null;
     }
-
     model.viewStream = stream;
-
     if (model.viewStream) {
       // Enable display of the background image
-      publicAPI.setUseBackgroundImage(true); // Bind to remote stream
+      publicAPI.setUseBackgroundImage(true);
 
-      model.subscription = model.viewStream.onImageReady(function (e) {
-        return publicAPI.setBackgroundImage(e.image);
-      });
+      // Bind to remote stream
+      model.subscription = model.viewStream.onImageReady(e => publicAPI.setBackgroundImage(e.image));
       model.viewStream.setSize(model.size[0], model.size[1]);
       model.viewStream.invalidateCache();
       model.viewStream.render();
       publicAPI.modified();
     }
-
     return true;
   };
+  publicAPI.delete = macro.chain(publicAPI.setViewStream, publicAPI.delete);
 
-  publicAPI.delete = macro.chain(publicAPI.setViewStream, publicAPI.delete); // --------------------------------------------------------------------------
+  // --------------------------------------------------------------------------
   // Make us look like a View (i.e.: vtkOpenGLRenderWindow)
   // --------------------------------------------------------------------------
-
   model._renderable = publicAPI;
   model._renderers = [publicAPI];
+  publicAPI.traverseAllPasses = () => {};
+  publicAPI.isInViewport = () => true;
+  publicAPI.getInteractive = () => true;
+}
 
-  publicAPI.traverseAllPasses = function () {};
-
-  publicAPI.isInViewport = function () {
-    return true;
-  };
-
-  publicAPI.getInteractive = function () {
-    return true;
-  };
-} // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   canvas: null,
   size: [300, 300],
   cursorVisibility: true,
   cursor: 'pointer',
   useOffScreen: false,
   useBackgroundImage: false
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues); // Create internal instances
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
 
+  // Create internal instances
   model.canvas = document.createElement('canvas');
-  model.canvas.style.width = '100%'; // Create internal bgImage
+  model.canvas.style.width = '100%';
 
+  // Create internal bgImage
   model.bgImage = new Image();
   model.bgImage.style.position = 'absolute';
   model.bgImage.style.left = '0';
   model.bgImage.style.top = '0';
   model.bgImage.style.width = '100%';
   model.bgImage.style.height = '100%';
-  model.bgImage.style.zIndex = '-1'; // Inheritance
+  model.bgImage.style.zIndex = '-1';
 
-  macro.obj(publicAPI, model, initialValues); // Build VTK API
+  // Inheritance
+  macro.obj(publicAPI, model, initialValues);
 
+  // Build VTK API
   macro.get(publicAPI, model, ['useBackgroundImage', '_renderable']);
   macro.setGet(publicAPI, model, ['canvas', 'cursor', 'useOffScreen', 'interactor']);
   macro.setGetArray(publicAPI, model, ['size'], 2);
   macro.getArray(publicAPI, model, ['_renderers']);
-  macro.moveToProtected(publicAPI, model, ['renderable', 'renderers']); // Object methods
+  macro.moveToProtected(publicAPI, model, ['renderable', 'renderers']);
 
+  // Object methods
   vtkCanvasView(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 
-var newInstance = macro.newInstance(extend, 'vtkCanvasView'); // ----------------------------------------------------------------------------
+const newInstance = macro.newInstance(extend, 'vtkCanvasView');
+
+// ----------------------------------------------------------------------------
 
 var vtkCanvasView$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkCanvasView$1 as default, extend, newInstance };

package/Rendering/Misc/FullScreenRenderWindow.js

@@ -1,5 +1,4 @@
-import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkRenderer from '../Core/Renderer.js';
 import vtkRenderWindow from '../Core/RenderWindow.js';
 import vtkRenderWindowInteractor from '../Core/RenderWindowInteractor.js';
@@ -13,8 +12,9 @@ import '../Core/Mapper.js';
 import '../OpenGL/RenderWindow.js';
 import '../WebGPU/RenderWindow.js';
 
-var userParams = vtkURLExtract.extractURLParameters();
-var STYLE_CONTAINER = {
+// Process arguments from URL
+const userParams = vtkURLExtract.extractURLParameters();
+const STYLE_CONTAINER = {
   margin: '0',
   padding: '0',
   position: 'absolute',
@@ -24,7 +24,7 @@ var STYLE_CONTAINER = {
   height: '100%',
   overflow: 'hidden'
 };
-var STYLE_CONTROL_PANEL = {
+const STYLE_CONTROL_PANEL = {
   position: 'absolute',
   left: '25px',
   top: '25px',
@@ -39,63 +39,60 @@ var STYLE_CONTROL_PANEL = {
   maxHeight: 'calc(100% - 60px)',
   overflow: 'auto'
 };
-
 function applyStyle(el, style) {
-  Object.keys(style).forEach(function (key) {
+  Object.keys(style).forEach(key => {
     el.style[key] = style[key];
   });
 }
-
 function vtkFullScreenRenderWindow(publicAPI, model) {
   model.classHierarchy.push('vtkFullScreenRenderWindow');
-  var body = document.querySelector('body'); // Full screen DOM handler
+  const body = document.querySelector('body');
 
+  // Full screen DOM handler
   if (!model.rootContainer) {
     model.rootContainer = body;
   }
-
   if (!model.container) {
     model.container = document.createElement('div');
     applyStyle(model.container, model.containerStyle || STYLE_CONTAINER);
     model.rootContainer.appendChild(model.container);
-  } // apply 100% to html and body for fullscreen
-
+  }
 
+  // apply 100% to html and body for fullscreen
   if (model.rootContainer === body) {
     document.documentElement.style.height = '100%';
     body.style.height = '100%';
     body.style.padding = '0';
     body.style.margin = '0';
-  } // VTK renderWindow/renderer
-
+  }
 
+  // VTK renderWindow/renderer
   model.renderWindow = vtkRenderWindow.newInstance();
   model.renderer = vtkRenderer.newInstance();
-  model.renderWindow.addRenderer(model.renderer); // apiSpecificRenderWindow
+  model.renderWindow.addRenderer(model.renderer);
 
+  // apiSpecificRenderWindow
   model.apiSpecificRenderWindow = model.renderWindow.newAPISpecificView(userParams.viewAPI);
   model.apiSpecificRenderWindow.setContainer(model.container);
-  model.renderWindow.addView(model.apiSpecificRenderWindow); // Interactor
+  model.renderWindow.addView(model.apiSpecificRenderWindow);
 
+  // Interactor
   model.interactor = vtkRenderWindowInteractor.newInstance();
   model.interactor.setInteractorStyle(vtkInteractorStyleTrackballCamera.newInstance());
   model.interactor.setView(model.apiSpecificRenderWindow);
   model.interactor.initialize();
-  model.interactor.bindEvents(model.container); // Expose background
+  model.interactor.bindEvents(model.container);
 
+  // Expose background
   publicAPI.setBackground = model.renderer.setBackground;
-
-  publicAPI.removeController = function () {
-    var el = model.controlContainer;
-
+  publicAPI.removeController = () => {
+    const el = model.controlContainer;
     if (el) {
       el.parentNode.removeChild(el);
     }
   };
-
-  publicAPI.setControllerVisibility = function (visible) {
+  publicAPI.setControllerVisibility = visible => {
     model.controllerVisibility = visible;
-
     if (model.controlContainer) {
       if (visible) {
         model.controlContainer.style.display = 'block';
@@ -104,93 +101,94 @@ function vtkFullScreenRenderWindow(publicAPI, model) {
       }
     }
   };
-
-  publicAPI.toggleControllerVisibility = function () {
+  publicAPI.toggleControllerVisibility = () => {
     publicAPI.setControllerVisibility(!model.controllerVisibility);
   };
-
-  publicAPI.addController = function (html) {
+  publicAPI.addController = html => {
     model.controlContainer = document.createElement('div');
     applyStyle(model.controlContainer, model.controlPanelStyle || STYLE_CONTROL_PANEL);
     model.rootContainer.appendChild(model.controlContainer);
     model.controlContainer.innerHTML = html;
     publicAPI.setControllerVisibility(model.controllerVisibility);
-    model.rootContainer.addEventListener('keypress', function (e) {
+    model.rootContainer.addEventListener('keypress', e => {
       if (String.fromCharCode(e.charCode) === 'c') {
         publicAPI.toggleControllerVisibility();
       }
     });
-  }; // Update BG color
-
+  };
 
-  publicAPI.setBackground.apply(publicAPI, _toConsumableArray(model.background)); // Representation API
+  // Update BG color
+  publicAPI.setBackground(...model.background);
 
-  publicAPI.addRepresentation = function (representation) {
-    representation.getActors().forEach(function (actor) {
+  // Representation API
+  publicAPI.addRepresentation = representation => {
+    representation.getActors().forEach(actor => {
       model.renderer.addActor(actor);
     });
   };
+  publicAPI.removeRepresentation = representation => {
+    representation.getActors().forEach(actor => model.renderer.removeActor(actor));
+  };
 
-  publicAPI.removeRepresentation = function (representation) {
-    representation.getActors().forEach(function (actor) {
-      return model.renderer.removeActor(actor);
-    });
-  }; // Properly release GL context
-
-
-  publicAPI.delete = macro.chain(publicAPI.setContainer, model.apiSpecificRenderWindow.delete, publicAPI.delete); // Handle window resize
+  // Properly release GL context
+  publicAPI.delete = macro.chain(publicAPI.setContainer, model.apiSpecificRenderWindow.delete, publicAPI.delete);
 
-  publicAPI.resize = function () {
-    var dims = model.container.getBoundingClientRect();
-    var devicePixelRatio = window.devicePixelRatio || 1;
+  // Handle window resize
+  publicAPI.resize = () => {
+    const dims = model.container.getBoundingClientRect();
+    const devicePixelRatio = window.devicePixelRatio || 1;
     model.apiSpecificRenderWindow.setSize(Math.floor(dims.width * devicePixelRatio), Math.floor(dims.height * devicePixelRatio));
-
     if (model.resizeCallback) {
       model.resizeCallback(dims);
     }
-
     model.renderWindow.render();
   };
-
-  publicAPI.setResizeCallback = function (cb) {
+  publicAPI.setResizeCallback = cb => {
     model.resizeCallback = cb;
     publicAPI.resize();
   };
-
   if (model.listenWindowResize) {
     window.addEventListener('resize', publicAPI.resize);
   }
-
   publicAPI.resize();
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   background: [0.32, 0.34, 0.43],
   containerStyle: null,
   controlPanelStyle: null,
   listenWindowResize: true,
   resizeCallback: null,
   controllerVisibility: true
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues); // Object methods
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
 
+  // Object methods
   macro.obj(publicAPI, model);
-  macro.get(publicAPI, model, ['renderWindow', 'renderer', 'apiSpecificRenderWindow', 'interactor', 'rootContainer', 'container', 'controlContainer']); // Object specific methods
+  macro.get(publicAPI, model, ['renderWindow', 'renderer', 'apiSpecificRenderWindow', 'interactor', 'rootContainer', 'container', 'controlContainer']);
 
+  // Object specific methods
   vtkFullScreenRenderWindow(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend);
+
+// ----------------------------------------------------------------------------
 
 var vtkFullScreenRenderWindow$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkFullScreenRenderWindow$1 as default, extend, newInstance };

package/Rendering/Misc/GenericRenderWindow.js

@@ -1,5 +1,4 @@
-import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkRenderWindow$1 from '../OpenGL/RenderWindow.js';
 import vtkRenderer from '../Core/Renderer.js';
 import vtkRenderWindow from '../Core/RenderWindow.js';
@@ -13,90 +12,102 @@ import '../Core/Mapper.js';
 
 function vtkGenericRenderWindow(publicAPI, model) {
   // Capture resize trigger method to remove from publicAPI
-  var invokeResize = publicAPI.invokeResize;
-  delete publicAPI.invokeResize; // VTK renderWindow/renderer
+  const invokeResize = publicAPI.invokeResize;
+  delete publicAPI.invokeResize;
 
+  // VTK renderWindow/renderer
   model.renderWindow = vtkRenderWindow.newInstance();
   model.renderer = vtkRenderer.newInstance();
-  model.renderWindow.addRenderer(model.renderer); // OpenGLRenderWindow
+  model.renderWindow.addRenderer(model.renderer);
 
+  // OpenGLRenderWindow
   model._openGLRenderWindow = vtkRenderWindow$1.newInstance();
-  model.renderWindow.addView(model._openGLRenderWindow); // Interactor
+  model.renderWindow.addView(model._openGLRenderWindow);
 
+  // Interactor
   model.interactor = vtkRenderWindowInteractor.newInstance();
   model.interactor.setInteractorStyle(vtkInteractorStyleTrackballCamera.newInstance());
   model.interactor.setView(model._openGLRenderWindow);
-  model.interactor.initialize(); // Expose background
+  model.interactor.initialize();
 
-  publicAPI.setBackground = model.renderer.setBackground; // Update BG color
+  // Expose background
+  publicAPI.setBackground = model.renderer.setBackground;
 
-  publicAPI.setBackground.apply(publicAPI, _toConsumableArray(model.background)); // Handle window resize
+  // Update BG color
+  publicAPI.setBackground(...model.background);
 
-  publicAPI.resize = function () {
+  // Handle window resize
+  publicAPI.resize = () => {
     if (model.container) {
-      var dims = model.container.getBoundingClientRect();
-      var devicePixelRatio = window.devicePixelRatio || 1;
-
+      const dims = model.container.getBoundingClientRect();
+      const devicePixelRatio = window.devicePixelRatio || 1;
       model._openGLRenderWindow.setSize(Math.floor(dims.width * devicePixelRatio), Math.floor(dims.height * devicePixelRatio));
-
       invokeResize();
       model.renderWindow.render();
     }
-  }; // Handle DOM container relocation
-
+  };
 
-  publicAPI.setContainer = function (el) {
+  // Handle DOM container relocation
+  publicAPI.setContainer = el => {
     if (model.container) {
       model.interactor.unbindEvents(model.container);
-    } // Switch container
-
+    }
 
+    // Switch container
     model.container = el;
+    model._openGLRenderWindow.setContainer(model.container);
 
-    model._openGLRenderWindow.setContainer(model.container); // Bind to new container
-
-
+    // Bind to new container
     if (model.container) {
       model.interactor.bindEvents(model.container);
     }
-  }; // Properly release GL context
-
+  };
 
-  publicAPI.delete = macro.chain(publicAPI.setContainer, model._openGLRenderWindow.delete, publicAPI.delete); // Handle size
+  // Properly release GL context
+  publicAPI.delete = macro.chain(publicAPI.setContainer, model._openGLRenderWindow.delete, publicAPI.delete);
 
+  // Handle size
   if (model.listenWindowResize) {
     window.addEventListener('resize', publicAPI.resize);
   }
-
   publicAPI.resize();
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   background: [0.32, 0.34, 0.43],
   listenWindowResize: true,
   container: null
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues); // Object methods
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
 
+  // Object methods
   macro.obj(publicAPI, model);
   macro.get(publicAPI, model, ['renderWindow', 'renderer', '_openGLRenderWindow', 'interactor', 'container']);
   macro.moveToProtected(publicAPI, model, ['openGLRenderWindow']);
-  macro.event(publicAPI, model, 'resize'); // Object specific methods
+  macro.event(publicAPI, model, 'resize');
 
+  // Object specific methods
   vtkGenericRenderWindow(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend);
+
+// ----------------------------------------------------------------------------
 
 var vtkGenericRenderWindow$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkGenericRenderWindow$1 as default, extend, newInstance };