@kitware/vtk.js 28.10.2 → 28.11.0

package/Rendering/OpenGL.js

@@ -33,37 +33,37 @@ import vtkVolume from './OpenGL/Volume.js';
 import vtkVolumeMapper from './OpenGL/VolumeMapper.js';
 
 var OpenGL = {
-  vtkActor: vtkActor,
-  vtkActor2D: vtkActor2D,
-  vtkBufferObject: vtkBufferObject,
-  vtkCamera: vtkCamera,
-  vtkCellArrayBufferObject: vtkCellArrayBufferObject,
-  vtkConvolution2DPass: vtkConvolution2DPass,
-  vtkForwardPass: vtkForwardPass,
+  vtkActor,
+  vtkActor2D,
+  vtkBufferObject,
+  vtkCamera,
+  vtkCellArrayBufferObject,
+  vtkConvolution2DPass,
+  vtkForwardPass,
   vtkFramebuffer: vtkOpenGLFramebuffer,
-  vtkGlyph3DMapper: vtkGlyph3DMapper,
-  vtkHardwareSelector: vtkHardwareSelector,
-  vtkHelper: vtkHelper,
-  vtkImageMapper: vtkImageMapper,
-  vtkImageSlice: vtkImageSlice,
-  vtkPixelSpaceCallbackMapper: vtkPixelSpaceCallbackMapper,
+  vtkGlyph3DMapper,
+  vtkHardwareSelector,
+  vtkHelper,
+  vtkImageMapper,
+  vtkImageSlice,
+  vtkPixelSpaceCallbackMapper,
   vtkPolyDataMapper: vtkOpenGLPolyDataMapper,
-  vtkPolyDataMapper2D: vtkPolyDataMapper2D,
-  vtkRenderWindow: vtkRenderWindow,
-  vtkRenderer: vtkRenderer,
-  vtkImageResliceMapper: vtkImageResliceMapper,
-  vtkShader: vtkShader,
-  vtkShaderCache: vtkShaderCache,
-  vtkShaderProgram: vtkShaderProgram,
-  vtkSkybox: vtkSkybox,
-  vtkSphereMapper: vtkSphereMapper,
-  vtkStickMapper: vtkStickMapper,
+  vtkPolyDataMapper2D,
+  vtkRenderWindow,
+  vtkRenderer,
+  vtkImageResliceMapper,
+  vtkShader,
+  vtkShaderCache,
+  vtkShaderProgram,
+  vtkSkybox,
+  vtkSphereMapper,
+  vtkStickMapper,
   vtkTexture: vtkOpenGLTexture,
-  vtkTextureUnitManager: vtkTextureUnitManager,
-  vtkVertexArrayObject: vtkVertexArrayObject,
-  vtkViewNodeFactory: vtkViewNodeFactory,
-  vtkVolume: vtkVolume,
-  vtkVolumeMapper: vtkVolumeMapper
+  vtkTextureUnitManager,
+  vtkVertexArrayObject,
+  vtkViewNodeFactory,
+  vtkVolume,
+  vtkVolumeMapper
 };
 
 export { OpenGL as default };

package/Rendering/SceneGraph/RenderPass.js

@@ -1,77 +1,80 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
+
+// ----------------------------------------------------------------------------
 
 function vtkRenderPass(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkRenderPass');
-
-  publicAPI.getOperation = function () {
-    return model.currentOperation;
-  };
-
-  publicAPI.setCurrentOperation = function (val) {
+  publicAPI.getOperation = () => model.currentOperation;
+  publicAPI.setCurrentOperation = val => {
     model.currentOperation = val;
-    model.currentTraverseOperation = "traverse".concat(macro.capitalize(model.currentOperation));
+    model.currentTraverseOperation = `traverse${macro.capitalize(model.currentOperation)}`;
   };
+  publicAPI.getTraverseOperation = () => model.currentTraverseOperation;
 
-  publicAPI.getTraverseOperation = function () {
-    return model.currentTraverseOperation;
-  }; // by default this class will traverse all of its
+  // by default this class will traverse all of its
   // preDelegateOperations, then call its delegate render passes
   // the traverse all of its postDelegateOperations
   // any of those three arrays can be empty
-
-
   publicAPI.traverse = function (viewNode) {
-    var parent = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
-
+    let parent = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
     if (model.deleted) {
       return;
-    } // we just render our delegates in order
-
+    }
 
+    // we just render our delegates in order
     model._currentParent = parent;
-    model.preDelegateOperations.forEach(function (val) {
+    model.preDelegateOperations.forEach(val => {
       publicAPI.setCurrentOperation(val);
       viewNode.traverse(publicAPI);
     });
-    model.delegates.forEach(function (val) {
+    model.delegates.forEach(val => {
       val.traverse(viewNode, publicAPI);
     });
-    model.postDelegateOperations.forEach(function (val) {
+    model.postDelegateOperations.forEach(val => {
       publicAPI.setCurrentOperation(val);
       viewNode.traverse(publicAPI);
     });
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   delegates: [],
   currentOperation: null,
   preDelegateOperations: [],
   postDelegateOperations: [],
   currentParent: null
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues); // Build VTK API
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
 
+  // Build VTK API
   macro.obj(publicAPI, model);
   macro.get(publicAPI, model, ['currentOperation']);
   macro.setGet(publicAPI, model, ['delegates', '_currentParent', 'preDelegateOperations', 'postDelegateOperations']);
-  macro.moveToProtected(publicAPI, model, ['currentParent']); // Object methods
+  macro.moveToProtected(publicAPI, model, ['currentParent']);
 
+  // Object methods
   vtkRenderPass(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkRenderPass'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkRenderPass');
+
+// ----------------------------------------------------------------------------
 
 var vtkRenderPass$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkRenderPass$1 as default, extend, newInstance };

package/Rendering/SceneGraph/RenderWindowViewNode.js

@@ -1,12 +1,14 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkViewNode from './ViewNode.js';
 
+// ----------------------------------------------------------------------------
 // vtkRenderWindowViewNode is intended to be a superclass for all api specific
 // RenderWindows. It is intended to define a common API that can be invoked
 // upon an api specific render window and provide some common method
 // implementations. If your application requires communicating with an api specific
 // view try to limit such interactions to methods defined in this class.
 // ----------------------------------------------------------------------------
+
 // ----------------------------------------------------------------------------
 // vtkRenderWindowViewNode methods
 // ----------------------------------------------------------------------------
@@ -14,157 +16,129 @@ import vtkViewNode from './ViewNode.js';
 function vtkRenderWindowViewNode(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkRenderWindowViewNode');
-
-  publicAPI.getViewNodeFactory = function () {
-    return null;
-  };
-
-  publicAPI.getAspectRatio = function () {
-    return model.size[0] / model.size[1];
-  };
-
-  publicAPI.getAspectRatioForRenderer = function (renderer) {
-    var viewport = renderer.getViewportByReference();
+  publicAPI.getViewNodeFactory = () => null;
+  publicAPI.getAspectRatio = () => model.size[0] / model.size[1];
+  publicAPI.getAspectRatioForRenderer = renderer => {
+    const viewport = renderer.getViewportByReference();
     return model.size[0] * (viewport[2] - viewport[0]) / ((viewport[3] - viewport[1]) * model.size[1]);
   };
-
-  publicAPI.isInViewport = function (x, y, viewport) {
-    var vCoords = viewport.getViewportByReference();
-    var size = publicAPI.getFramebufferSize();
-
+  publicAPI.isInViewport = (x, y, viewport) => {
+    const vCoords = viewport.getViewportByReference();
+    const size = publicAPI.getFramebufferSize();
     if (vCoords[0] * size[0] <= x && vCoords[2] * size[0] >= x && vCoords[1] * size[1] <= y && vCoords[3] * size[1] >= y) {
       return true;
     }
-
     return false;
   };
-
-  publicAPI.getViewportSize = function (viewport) {
-    var vCoords = viewport.getViewportByReference();
-    var size = publicAPI.getFramebufferSize();
+  publicAPI.getViewportSize = viewport => {
+    const vCoords = viewport.getViewportByReference();
+    const size = publicAPI.getFramebufferSize();
     return [(vCoords[2] - vCoords[0]) * size[0], (vCoords[3] - vCoords[1]) * size[1]];
   };
-
-  publicAPI.getViewportCenter = function (viewport) {
-    var size = publicAPI.getViewportSize(viewport);
+  publicAPI.getViewportCenter = viewport => {
+    const size = publicAPI.getViewportSize(viewport);
     return [size[0] * 0.5, size[1] * 0.5];
   };
-
-  publicAPI.displayToNormalizedDisplay = function (x, y, z) {
-    var size = publicAPI.getFramebufferSize();
+  publicAPI.displayToNormalizedDisplay = (x, y, z) => {
+    const size = publicAPI.getFramebufferSize();
     return [x / size[0], y / size[1], z];
   };
-
-  publicAPI.normalizedDisplayToDisplay = function (x, y, z) {
-    var size = publicAPI.getFramebufferSize();
+  publicAPI.normalizedDisplayToDisplay = (x, y, z) => {
+    const size = publicAPI.getFramebufferSize();
     return [x * size[0], y * size[1], z];
   };
-
-  publicAPI.worldToView = function (x, y, z, renderer) {
-    return renderer.worldToView(x, y, z);
-  };
-
-  publicAPI.viewToWorld = function (x, y, z, renderer) {
-    return renderer.viewToWorld(x, y, z);
-  };
-
-  publicAPI.worldToDisplay = function (x, y, z, renderer) {
-    var val = renderer.worldToView(x, y, z);
-    var dims = publicAPI.getViewportSize(renderer);
-    var val2 = renderer.viewToProjection(val[0], val[1], val[2], dims[0] / dims[1]);
-    var val3 = renderer.projectionToNormalizedDisplay(val2[0], val2[1], val2[2]);
+  publicAPI.worldToView = (x, y, z, renderer) => renderer.worldToView(x, y, z);
+  publicAPI.viewToWorld = (x, y, z, renderer) => renderer.viewToWorld(x, y, z);
+  publicAPI.worldToDisplay = (x, y, z, renderer) => {
+    const val = renderer.worldToView(x, y, z);
+    const dims = publicAPI.getViewportSize(renderer);
+    const val2 = renderer.viewToProjection(val[0], val[1], val[2], dims[0] / dims[1]);
+    const val3 = renderer.projectionToNormalizedDisplay(val2[0], val2[1], val2[2]);
     return publicAPI.normalizedDisplayToDisplay(val3[0], val3[1], val3[2]);
   };
-
-  publicAPI.displayToWorld = function (x, y, z, renderer) {
-    var val = publicAPI.displayToNormalizedDisplay(x, y, z);
-    var val2 = renderer.normalizedDisplayToProjection(val[0], val[1], val[2]);
-    var dims = publicAPI.getViewportSize(renderer);
-    var val3 = renderer.projectionToView(val2[0], val2[1], val2[2], dims[0] / dims[1]);
+  publicAPI.displayToWorld = (x, y, z, renderer) => {
+    const val = publicAPI.displayToNormalizedDisplay(x, y, z);
+    const val2 = renderer.normalizedDisplayToProjection(val[0], val[1], val[2]);
+    const dims = publicAPI.getViewportSize(renderer);
+    const val3 = renderer.projectionToView(val2[0], val2[1], val2[2], dims[0] / dims[1]);
     return renderer.viewToWorld(val3[0], val3[1], val3[2]);
   };
-
-  publicAPI.normalizedDisplayToViewport = function (x, y, z, renderer) {
-    var vCoords = renderer.getViewportByReference();
+  publicAPI.normalizedDisplayToViewport = (x, y, z, renderer) => {
+    let vCoords = renderer.getViewportByReference();
     vCoords = publicAPI.normalizedDisplayToDisplay(vCoords[0], vCoords[1], 0.0);
-    var coords = publicAPI.normalizedDisplayToDisplay(x, y, z);
+    const coords = publicAPI.normalizedDisplayToDisplay(x, y, z);
     return [coords[0] - vCoords[0] - 0.5, coords[1] - vCoords[1] - 0.5, z];
   };
-
-  publicAPI.viewportToNormalizedViewport = function (x, y, z, renderer) {
-    var size = publicAPI.getViewportSize(renderer);
-
+  publicAPI.viewportToNormalizedViewport = (x, y, z, renderer) => {
+    const size = publicAPI.getViewportSize(renderer);
     if (size && size[0] !== 0 && size[1] !== 0) {
       return [x / (size[0] - 1.0), y / (size[1] - 1.0), z];
     }
-
     return [x, y, z];
   };
-
-  publicAPI.normalizedViewportToViewport = function (x, y, z, renderer) {
-    var size = publicAPI.getViewportSize(renderer);
+  publicAPI.normalizedViewportToViewport = (x, y, z, renderer) => {
+    const size = publicAPI.getViewportSize(renderer);
     return [x * (size[0] - 1.0), y * (size[1] - 1.0), z];
   };
-
-  publicAPI.displayToLocalDisplay = function (x, y, z) {
-    var size = publicAPI.getFramebufferSize();
+  publicAPI.displayToLocalDisplay = (x, y, z) => {
+    const size = publicAPI.getFramebufferSize();
     return [x, size[1] - y - 1, z];
   };
-
-  publicAPI.viewportToNormalizedDisplay = function (x, y, z, renderer) {
-    var vCoords = renderer.getViewportByReference();
+  publicAPI.viewportToNormalizedDisplay = (x, y, z, renderer) => {
+    let vCoords = renderer.getViewportByReference();
     vCoords = publicAPI.normalizedDisplayToDisplay(vCoords[0], vCoords[1], 0.0);
-    var x2 = x + vCoords[0] + 0.5;
-    var y2 = y + vCoords[1] + 0.5;
+    const x2 = x + vCoords[0] + 0.5;
+    const y2 = y + vCoords[1] + 0.5;
     return publicAPI.displayToNormalizedDisplay(x2, y2, z);
   };
-
-  publicAPI.getComputedDevicePixelRatio = function () {
-    return model.size[0] / publicAPI.getContainerSize()[0];
-  };
-
-  publicAPI.getContainerSize = function () {
+  publicAPI.getComputedDevicePixelRatio = () => model.size[0] / publicAPI.getContainerSize()[0];
+  publicAPI.getContainerSize = () => {
     macro.vtkErrorMacro('not implemented');
   };
-
-  publicAPI.getPixelData = function (x1, y1, x2, y2) {
+  publicAPI.getPixelData = (x1, y1, x2, y2) => {
     macro.vtkErrorMacro('not implemented');
   };
-
-  publicAPI.createSelector = function () {
+  publicAPI.createSelector = () => {
     macro.vtkErrorMacro('not implemented');
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   size: undefined,
   selector: undefined
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
   Object.assign(model, DEFAULT_VALUES, initialValues);
-
   if (!model.size) {
     model.size = [300, 300];
   }
-
   macro.getArray(publicAPI, model, ['size'], 2);
-  macro.get(publicAPI, model, ['selector']); // Inheritance
+  macro.get(publicAPI, model, ['selector']);
 
-  vtkViewNode.extend(publicAPI, model, initialValues); // Object methods
+  // Inheritance
+  vtkViewNode.extend(publicAPI, model, initialValues);
 
+  // Object methods
   vtkRenderWindowViewNode(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 
-var newInstance = macro.newInstance(extend, 'vtkRenderWindowViewNode'); // ----------------------------------------------------------------------------
+const newInstance = macro.newInstance(extend, 'vtkRenderWindowViewNode');
+
+// ----------------------------------------------------------------------------
 
 var vtkRenderWindowViewNode$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkRenderWindowViewNode$1 as default, extend, newInstance };