@kitware/vtk.js 21.2.2 → 21.4.1

package/Rendering/Core/Mapper2D.js

@@ -0,0 +1,213 @@
+import macro from '../../macros.js';
+import vtkAbstractMapper from './AbstractMapper.js';
+import vtkLookupTable from '../../Common/Core/LookupTable.js';
+import Constants from './Mapper/Constants.js';
+
+var ColorMode = Constants.ColorMode,
+    ScalarMode = Constants.ScalarMode,
+    GetArray = Constants.GetArray; // ---------------------------------------------------------------------------
+// vtkMapper2D methods
+// ---------------------------------------------------------------------------
+
+function vtkMapper2D(publicAPI, model) {
+  // Set out className
+  model.classHierarchy.push('vtkMapper2D');
+
+  publicAPI.createDefaultLookupTable = function () {
+    model.lookupTable = vtkLookupTable.newInstance();
+  };
+
+  publicAPI.getColorModeAsString = function () {
+    return macro.enumToString(ColorMode, model.colorMode);
+  };
+
+  publicAPI.setColorModeToDefault = function () {
+    return publicAPI.setColorMode(0);
+  };
+
+  publicAPI.setColorModeToMapScalars = function () {
+    return publicAPI.setColorMode(1);
+  };
+
+  publicAPI.setColorModeToDirectScalars = function () {
+    return publicAPI.setColorMode(2);
+  };
+
+  publicAPI.getScalarModeAsString = function () {
+    return macro.enumToString(ScalarMode, model.scalarMode);
+  };
+
+  publicAPI.setScalarModeToDefault = function () {
+    return publicAPI.setScalarMode(0);
+  };
+
+  publicAPI.setScalarModeToUsePointData = function () {
+    return publicAPI.setScalarMode(1);
+  };
+
+  publicAPI.setScalarModeToUseCellData = function () {
+    return publicAPI.setScalarMode(2);
+  };
+
+  publicAPI.setScalarModeToUsePointFieldData = function () {
+    return publicAPI.setScalarMode(3);
+  };
+
+  publicAPI.setScalarModeToUseCellFieldData = function () {
+    return publicAPI.setScalarMode(4);
+  };
+
+  publicAPI.setScalarModeToUseFieldData = function () {
+    return publicAPI.setScalarMode(5);
+  };
+
+  publicAPI.getAbstractScalars = function (input, scalarMode, arrayAccessMode, arrayId, arrayName) {
+    // make sure we have an input
+    if (!input || !model.scalarVisibility) {
+      return {
+        scalars: null,
+        cellFLag: false
+      };
+    }
+
+    var scalars = null;
+    var cellFlag = false; // get scalar data and point/cell attribute according to scalar mode
+
+    if (scalarMode === ScalarMode.DEFAULT) {
+      scalars = input.getPointData().getScalars();
+
+      if (!scalars) {
+        scalars = input.getCellData().getScalars();
+        cellFlag = true;
+      }
+    } else if (scalarMode === ScalarMode.USE_POINT_DATA) {
+      scalars = input.getPointData().getScalars();
+    } else if (scalarMode === ScalarMode.USE_CELL_DATA) {
+      scalars = input.getCellData().getScalars();
+      cellFlag = true;
+    } else if (scalarMode === ScalarMode.USE_POINT_FIELD_DATA) {
+      var pd = input.getPointData();
+
+      if (arrayAccessMode === GetArray.BY_ID) {
+        scalars = pd.getArrayByIndex(arrayId);
+      } else {
+        scalars = pd.getArrayByName(arrayName);
+      }
+    } else if (scalarMode === ScalarMode.USE_CELL_FIELD_DATA) {
+      var cd = input.getCellData();
+      cellFlag = true;
+
+      if (arrayAccessMode === GetArray.BY_ID) {
+        scalars = cd.getArrayByIndex(arrayId);
+      } else {
+        scalars = cd.getArrayByName(arrayName);
+      }
+    } else if (scalarMode === ScalarMode.USE_FIELD_DATA) {
+      var fd = input.getFieldData();
+
+      if (arrayAccessMode === GetArray.BY_ID) {
+        scalars = fd.getArrayByIndex(arrayId);
+      } else {
+        scalars = fd.getArrayByName(arrayName);
+      }
+    }
+
+    return {
+      scalars: scalars,
+      cellFlag: cellFlag
+    };
+  };
+
+  publicAPI.getLookupTable = function () {
+    if (!model.lookupTable) {
+      publicAPI.createDefaultLookupTable();
+    }
+
+    return model.lookupTable;
+  };
+
+  publicAPI.getMTime = function () {
+    var mt = model.mtime;
+
+    if (model.lookupTable !== null) {
+      var time = model.lookupTable.getMTime();
+      mt = time > mt ? time : mt;
+    }
+
+    return mt;
+  };
+
+  publicAPI.mapScalars = function (input, alpha) {
+    var scalars = publicAPI.getAbstractScalars(input, model.scalarMode, model.arrayAccessMode, model.arrayId, model.colorByArrayName).scalars;
+
+    if (!scalars) {
+      model.colorMapColors = null;
+      return;
+    } // we want to only recompute when something has changed
+
+
+    var toString = "".concat(publicAPI.getMTime()).concat(scalars.getMTime()).concat(alpha);
+    if (model.colorBuildString === toString) return;
+
+    if (!model.useLookupTableScalarRange) {
+      publicAPI.getLookupTable().setRange(model.scalarRange[0], model.scalarRange[1]);
+    }
+
+    var lut = publicAPI.getLookupTable();
+
+    if (lut) {
+      // Ensure that the lookup table is built
+      lut.build();
+      model.colorMapColors = lut.mapScalars(scalars, model.colorMode, -1);
+    }
+
+    model.colorBuildString = "".concat(publicAPI.getMTime()).concat(scalars.getMTime()).concat(alpha);
+  };
+} // ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+
+var DEFAULT_VALUES = {
+  static: false,
+  lookupTable: null,
+  scalarVisibility: false,
+  scalarRange: [0, 1],
+  useLookupTableScalarRange: false,
+  colorMode: 0,
+  scalarMode: 0,
+  arrayAccessMode: 1,
+  // By_NAME
+  renderTime: 0,
+  colorByArrayName: null,
+  transformCoordinate: null,
+  viewSpecificProperties: null,
+  customShaderAttributes: []
+}; // ----------------------------------------------------------------------------
+
+function extend(publicAPI, model) {
+  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues); // Inheritance
+
+  vtkAbstractMapper.extend(publicAPI, model, initialValues);
+  macro.get(publicAPI, model, ['colorMapColors']);
+  macro.setGet(publicAPI, model, ['arrayAccessMode', 'colorByArrayName', 'colorMode', 'lookupTable', 'renderTime', 'scalarMode', 'scalarVisibility', 'static', 'transformCoordinate', 'useLookupTableScalarRange', 'viewSpecificProperties', 'customShaderAttributes' // point data array names that will be transferred to the VBO
+  ]);
+  macro.setGetArray(publicAPI, model, ['scalarRange'], 2);
+
+  if (!model.viewSpecificProperties) {
+    model.viewSpecificProperties = {};
+  } // Object methods
+
+
+  vtkMapper2D(publicAPI, model);
+} // ----------------------------------------------------------------------------
+
+var newInstance = macro.newInstance(extend, 'vtkMapper2D'); // ----------------------------------------------------------------------------
+
+var vtkMapper2D$1 = {
+  newInstance: newInstance,
+  extend: extend
+};
+
+export { vtkMapper2D$1 as default, extend, newInstance };

package/Rendering/Core/Property2D/Constants.js

@@ -0,0 +1,9 @@
+var DisplayLocation = {
+  BACKGROUND: 0,
+  FOREGROUND: 1
+};
+var Constants = {
+  DisplayLocation: DisplayLocation
+};
+
+export { DisplayLocation, Constants as default };

package/Rendering/Core/Property2D.js

@@ -1,11 +1,38 @@
 import macro from '../../macros.js';
+import Constants from './Property2D/Constants.js';
+import { Representation } from './Property/Constants.js';
 
+var DisplayLocation = Constants.DisplayLocation; // ----------------------------------------------------------------------------
 // vtkProperty2D methods
 // ----------------------------------------------------------------------------
 
 function vtkProperty2D(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkProperty2D');
+
+  publicAPI.setDisplayLocationToBackground = function () {
+    return publicAPI.setDisplayLocation(DisplayLocation.BACKGROUND);
+  };
+
+  publicAPI.setDisplayLocationToForeground = function () {
+    return publicAPI.setDisplayLocation(DisplayLocation.FOREGROUND);
+  };
+
+  publicAPI.setRepresentationToWireframe = function () {
+    return publicAPI.setRepresentation(Representation.WIREFRAME);
+  };
+
+  publicAPI.setRepresentationToSurface = function () {
+    return publicAPI.setRepresentation(Representation.SURFACE);
+  };
+
+  publicAPI.setRepresentationToPoints = function () {
+    return publicAPI.setRepresentation(Representation.POINTS);
+  };
+
+  publicAPI.getRepresentationAsString = function () {
+    return macro.enumToString(Representation, model.representation);
+  };
 } // ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
@@ -16,7 +43,8 @@ var DEFAULT_VALUES = {
   opacity: 1,
   pointSize: 1,
   lineWidth: 1,
-  displayLocation: 'Foreground'
+  representation: Representation.SURFACE,
+  displayLocation: DisplayLocation.FOREGROUND
 }; // ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
@@ -24,7 +52,7 @@ function extend(publicAPI, model) {
   Object.assign(model, DEFAULT_VALUES, initialValues); // Build VTK API
 
   macro.obj(publicAPI, model);
-  macro.setGet(publicAPI, model, ['opacity', 'lineWidth', 'pointSize', 'displayLocation']);
+  macro.setGet(publicAPI, model, ['opacity', 'lineWidth', 'pointSize', 'displayLocation', 'representation']);
   macro.setGetArray(publicAPI, model, ['color'], 3); // Object methods
 
   vtkProperty2D(publicAPI, model);

package/Rendering/Core/RenderWindowInteractor/Constants.js

@@ -8,11 +8,23 @@ var Input = {
   Trigger: 1,
   TrackPad: 2,
   Grip: 3,
-  ApplicationMenu: 4
+  Thumbstick: 4,
+  A: 5,
+  B: 6,
+  ApplicationMenu: 7 // Not exposed in WebXR API
+
+};
+var Axis = {
+  Unknown: 0,
+  TouchpadX: 1,
+  TouchpadY: 2,
+  ThumbstickX: 3,
+  ThumbstickY: 4
 };
 var Constants = {
   Device: Device,
-  Input: Input
+  Input: Input,
+  Axis: Axis
 };
 
-export { Device, Input, Constants as default };
+export { Axis, Device, Input, Constants as default };

package/Rendering/Core/RenderWindowInteractor.js

@@ -16,7 +16,7 @@ var vtkWarningMacro = macro.vtkWarningMacro,
 // ----------------------------------------------------------------------------
 
 var deviceInputMap = {
-  'OpenVR Gamepad': [Input.TrackPad, Input.Trigger, Input.Grip, Input.ApplicationMenu]
+  'xr-standard': [Input.Trigger, Input.Grip, Input.TrackPad, Input.Thumbstick, Input.A, Input.B]
 };
 var handledEvents = ['StartAnimation', 'Animation', 'EndAnimation', 'MouseEnter', 'MouseLeave', 'StartMouseMove', 'MouseMove', 'EndMouseMove', 'LeftButtonPress', 'LeftButtonRelease', 'MiddleButtonPress', 'MiddleButtonRelease', 'RightButtonPress', 'RightButtonRelease', 'KeyPress', 'KeyDown', 'KeyUp', 'StartMouseWheel', 'MouseWheel', 'EndMouseWheel', 'StartPinch', 'Pinch', 'EndPinch', 'StartPan', 'Pan', 'EndPan', 'StartRotate', 'Rotate', 'EndRotate', 'Button3D', 'Move3D', 'StartPointerLock', 'EndPointerLock', 'StartInteraction', 'Interaction', 'EndInteraction'];
 
@@ -378,47 +378,53 @@ function vtkRenderWindowInteractor(publicAPI, model) {
     }
   };
 
-  publicAPI.updateGamepads = function (displayId) {
-    var gamepads = navigator.getGamepads(); // watch for when buttons change state and fire events
+  publicAPI.updateXRGamepads = function (xrSession, xrFrame, xrRefSpace) {
+    // watch for when buttons change state and fire events
+    xrSession.inputSources.forEach(function (inputSource) {
+      var pose = xrFrame.getPose(inputSource.gripSpace, xrRefSpace);
+      var gp = inputSource.gamepad;
+      var hand = inputSource.handedness;
 
-    for (var i = 0; i < gamepads.length; ++i) {
-      var gp = gamepads[i];
-
-      if (gp && gp.displayId === displayId) {
+      if (gp) {
         if (!(gp.index in model.lastGamepadValues)) {
           model.lastGamepadValues[gp.index] = {
-            buttons: {}
+            left: {
+              buttons: {}
+            },
+            right: {
+              buttons: {}
+            }
           };
         }
 
         for (var b = 0; b < gp.buttons.length; ++b) {
-          if (!(b in model.lastGamepadValues[gp.index].buttons)) {
-            model.lastGamepadValues[gp.index].buttons[b] = false;
+          if (!(b in model.lastGamepadValues[gp.index][hand].buttons)) {
+            model.lastGamepadValues[gp.index][hand].buttons[b] = false;
           }
 
-          if (model.lastGamepadValues[gp.index].buttons[b] !== gp.buttons[b].pressed) {
+          if (model.lastGamepadValues[gp.index][hand].buttons[b] !== gp.buttons[b].pressed) {
             publicAPI.button3DEvent({
               gamepad: gp,
-              position: gp.pose.position,
-              orientation: gp.pose.orientation,
+              position: pose.transform.position,
+              orientation: pose.transform.orientation,
               pressed: gp.buttons[b].pressed,
-              device: gp.hand === 'left' ? Device.LeftController : Device.RightController,
-              input: deviceInputMap[gp.id] && deviceInputMap[gp.id][b] ? deviceInputMap[gp.id][b] : Input.Trigger
+              device: inputSource.handedness === 'left' ? Device.LeftController : Device.RightController,
+              input: deviceInputMap[gp.mapping] && deviceInputMap[gp.mapping][b] ? deviceInputMap[gp.mapping][b] : Input.Trigger
             });
-            model.lastGamepadValues[gp.index].buttons[b] = gp.buttons[b].pressed;
+            model.lastGamepadValues[gp.index][hand].buttons[b] = gp.buttons[b].pressed;
           }
 
-          if (model.lastGamepadValues[gp.index].buttons[b]) {
+          if (model.lastGamepadValues[gp.index][hand].buttons[b]) {
             publicAPI.move3DEvent({
               gamepad: gp,
-              position: gp.pose.position,
-              orientation: gp.pose.orientation,
-              device: gp.hand === 'left' ? Device.LeftController : Device.RightController
+              position: pose.transform.position,
+              orientation: pose.transform.orientation,
+              device: inputSource.handedness === 'left' ? Device.LeftController : Device.RightController
             });
           }
         }
       }
-    }
+    });
   };
 
   publicAPI.handleMouseMove = function (event) {

package/Rendering/Core.js

@@ -22,6 +22,7 @@ import vtkInteractorObserver from './Core/InteractorObserver.js';
 import vtkInteractorStyle from './Core/InteractorStyle.js';
 import vtkLight from './Core/Light.js';
 import vtkMapper from './Core/Mapper.js';
+import vtkMapper2D from './Core/Mapper2D.js';
 import vtkPicker from './Core/Picker.js';
 import vtkPixelSpaceCallbackMapper from './Core/PixelSpaceCallbackMapper.js';
 import vtkPointPicker from './Core/PointPicker.js';
@@ -70,6 +71,7 @@ var Core = {
   vtkInteractorStyle: vtkInteractorStyle,
   vtkLight: vtkLight,
   vtkMapper: vtkMapper,
+  vtkMapper2D: vtkMapper2D,
   vtkPicker: vtkPicker,
   vtkPixelSpaceCallbackMapper: vtkPixelSpaceCallbackMapper,
   vtkPointPicker: vtkPointPicker,

package/Rendering/OpenGL/Actor2D.js

@@ -21,52 +21,85 @@ function vtkOpenGLActor2D(publicAPI, model) {
       publicAPI.prepareNodes();
       publicAPI.addMissingNodes(model.renderable.getTextures());
       publicAPI.addMissingNode(model.renderable.getMapper());
-      publicAPI.removeUnusedNodes();
+      publicAPI.removeUnusedNodes(); // we store textures and mapper
+
+      model.ogltextures = null;
+      model.activeTextures = null;
+
+      for (var index = 0; index < model.children.length; index++) {
+        var child = model.children[index];
+
+        if (child.isA('vtkOpenGLTexture')) {
+          if (!model.ogltextures) {
+            model.ogltextures = [];
+          }
+
+          model.ogltextures.push(child);
+        } else {
+          model.oglmapper = child;
+        }
+      }
+    }
+  };
+
+  publicAPI.queryPass = function (prepass, renderPass) {
+    if (prepass) {
+      if (!model.renderable || !model.renderable.getVisibility()) {
+        return;
+      }
+
+      renderPass.incrementOverlayActorCount();
     }
   }; // we draw textures, then mapper, then post pass textures
 
 
   publicAPI.traverseOpaquePass = function (renderPass) {
-    if (!model.renderable || !model.renderable.getNestedVisibility() || !model.renderable.getIsOpaque() || model.openGLRenderer.getSelector() && !model.renderable.getNestedPickable()) {
+    if (!model.oglmapper || !model.renderable || !model.renderable.getNestedVisibility() || !model.renderable.getIsOpaque() || model.openGLRenderer.getSelector() && !model.renderable.getNestedPickable()) {
       return;
     }
 
     publicAPI.apply(renderPass, true);
-    model.children.forEach(function (child) {
-      if (!child.isA('vtkOpenGLTexture')) {
-        child.traverse(renderPass);
-      }
-    });
+    model.oglmapper.traverse(renderPass);
     publicAPI.apply(renderPass, false);
   }; // we draw textures, then mapper, then post pass textures
 
 
   publicAPI.traverseTranslucentPass = function (renderPass) {
-    if (!model.renderable || !model.renderable.getNestedVisibility() || model.renderable.getIsOpaque() || model.openGLRenderer.getSelector() && !model.renderable.getNestedPickable()) {
+    if (!model.oglmapper || !model.renderable || !model.renderable.getNestedVisibility() || model.renderable.getIsOpaque() || model.openGLRenderer.getSelector() && !model.renderable.getNestedPickable()) {
       return;
     }
 
     publicAPI.apply(renderPass, true);
-    model.children.forEach(function (child) {
-      if (!child.isA('vtkOpenGLTexture')) {
-        child.traverse(renderPass);
-      }
-    });
+    model.oglmapper.traverse(renderPass);
+    publicAPI.apply(renderPass, false);
+  };
+
+  publicAPI.traverseOverlayPass = function (renderPass) {
+    if (!model.oglmapper || !model.renderable || !model.renderable.getNestedVisibility() || model.openGLRenderer.getSelector() && !model.renderable.getNestedPickable) {
+      return;
+    }
+
+    publicAPI.apply(renderPass, true);
+    model.oglmapper.traverse(renderPass);
     publicAPI.apply(renderPass, false);
   };
 
   publicAPI.activateTextures = function () {
     // always traverse textures first, then mapper
+    if (!model.ogltextures) {
+      return;
+    }
+
     model.activeTextures = [];
-    model.children.forEach(function (child) {
-      if (child.isA('vtkOpenGLTexture')) {
-        child.render();
 
-        if (child.getHandle()) {
-          model.activeTextures.push(child);
-        }
+    for (var index = 0; index < model.ogltextures.length; index++) {
+      var child = model.ogltextures[index];
+      child.render();
+
+      if (child.getHandle()) {
+        model.activeTextures.push(child);
       }
-    });
+    }
   }; // Renders myself
 
 
@@ -74,11 +107,11 @@ function vtkOpenGLActor2D(publicAPI, model) {
     if (prepass) {
       model.context.depthMask(true);
       publicAPI.activateTextures();
-    } else {
+    } else if (model.activeTextures) {
       // deactivate textures
-      model.activeTextures.forEach(function (child) {
-        child.deactivate();
-      });
+      for (var index = 0; index < model.activeTextures.length; index++) {
+        model.activeTextures[index].deactivate();
+      }
     }
   }; // Renders myself
 
@@ -87,12 +120,23 @@ function vtkOpenGLActor2D(publicAPI, model) {
     if (prepass) {
       model.context.depthMask(false);
       publicAPI.activateTextures();
-    } else {
-      // deactivate textures
-      model.activeTextures.forEach(function (child) {
-        child.deactivate();
-      });
+    } else if (model.activeTextures) {
+      for (var index = 0; index < model.activeTextures.length; index++) {
+        model.activeTextures[index].deactivate();
+      }
+    }
+  }; // Renders myself
+
+
+  publicAPI.overlayPass = function (prepass, renderPass) {
+    if (prepass) {
       model.context.depthMask(true);
+      publicAPI.activateTextures();
+    } else if (model.activeTextures) {
+      // deactivate textures
+      for (var index = 0; index < model.activeTextures.length; index++) {
+        model.activeTextures[index].deactivate();
+      }
     }
   };
 } // ----------------------------------------------------------------------------
@@ -102,7 +146,7 @@ function vtkOpenGLActor2D(publicAPI, model) {
 
 var DEFAULT_VALUES = {
   context: null,
-  activeTextures: []
+  activeTextures: null
 }; // ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {

package/Rendering/OpenGL/ForwardPass.js

@@ -35,6 +35,7 @@ function vtkForwardPass(publicAPI, model) {
           model.opaqueActorCount = 0;
           model.translucentActorCount = 0;
           model.volumeCount = 0;
+          model.overlayActorCount = 0;
           publicAPI.setCurrentOperation('queryPass');
           renNode.traverse(publicAPI); // do we need to capture a zbuffer?
 
@@ -79,6 +80,11 @@ function vtkForwardPass(publicAPI, model) {
             publicAPI.setCurrentOperation('volumePass');
             renNode.traverse(publicAPI);
           }
+
+          if (model.overlayActorCount > 0) {
+            publicAPI.setCurrentOperation('overlayPass');
+            renNode.traverse(publicAPI);
+          }
         }
       }
     }
@@ -107,6 +113,10 @@ function vtkForwardPass(publicAPI, model) {
   publicAPI.incrementVolumeCount = function () {
     return model.volumeCount++;
   };
+
+  publicAPI.incrementOverlayActorCount = function () {
+    return model.overlayActorCount++;
+  };
 } // ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
@@ -116,6 +126,7 @@ var DEFAULT_VALUES = {
   opaqueActorCount: 0,
   translucentActorCount: 0,
   volumeCount: 0,
+  overlayActorCount: 0,
   framebuffer: null,
   depthRequested: false
 }; // ----------------------------------------------------------------------------

package/Rendering/OpenGL/PolyDataMapper.js

@@ -1269,9 +1269,10 @@ var newInstance = newInstance$1(extend, 'vtkOpenGLPolyDataMapper'); // ---------
 
 var vtkOpenGLPolyDataMapper$1 = {
   newInstance: newInstance,
-  extend: extend
+  extend: extend,
+  primTypes: primTypes
 }; // Register ourself to OpenGL backend if imported
 
 registerOverride('vtkMapper', newInstance);
 
-export { vtkOpenGLPolyDataMapper$1 as default, extend, newInstance };
+export { vtkOpenGLPolyDataMapper$1 as default, extend, newInstance, primTypes };