@kitware/vtk.js 22.2.1 → 22.2.2

package/Rendering/OpenGL/RenderWindow.js

@@ -816,6 +816,12 @@ function vtkOpenGLRenderWindow(publicAPI, model) {
     return true;
   };
 
+  publicAPI.createSelector = function () {
+    var ret = vtkHardwareSelector.newInstance();
+    ret.setOpenGLRenderWindow(publicAPI);
+    return ret;
+  };
+
   publicAPI.delete = macro.chain(publicAPI.delete, publicAPI.setViewStream, deleteGLContext);
 } // ----------------------------------------------------------------------------
 // Object factory

package/Rendering/SceneGraph/RenderWindowViewNode.js

@@ -123,6 +123,11 @@ function vtkRenderWindowViewNode(publicAPI, model) {
     macro.vtkErrorMacro('not implemented');
     return undefined;
   };
+
+  publicAPI.createSelector = function () {
+    macro.vtkErrorMacro('not implemented');
+    return undefined;
+  };
 } // ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------

package/Rendering/WebGPU/RenderWindow.js

@@ -598,6 +598,13 @@ function vtkWebGPURenderWindow(publicAPI, model) {
       }
     }, _callee2);
   }));
+
+  publicAPI.createSelector = function () {
+    var ret = vtkWebGPUHardwareSelector.newInstance();
+    ret.setWebGPURenderWindow(publicAPI);
+    return ret;
+  };
+
   publicAPI.delete = macro.chain(publicAPI.delete, publicAPI.setViewStream);
 } // ----------------------------------------------------------------------------
 // Object factory

package/Widgets/Core/WidgetManager.js

@@ -1,4 +1,6 @@
+import _asyncToGenerator from '@babel/runtime/helpers/asyncToGenerator';
 import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
+import _regeneratorRuntime from '@babel/runtime/regenerator';
 import { r as radiansFromDegrees } from '../../Common/Core/Math/index.js';
 import { FieldAssociations } from '../../Common/DataModel/DataSet/Constants.js';
 import macro from '../../macros.js';
@@ -10,7 +12,8 @@ import { diff } from './WidgetManager/vdom.js';
 var ViewTypes = WidgetManagerConst.ViewTypes,
     RenderingTypes = WidgetManagerConst.RenderingTypes,
     CaptureOn = WidgetManagerConst.CaptureOn;
-var vtkErrorMacro = macro.vtkErrorMacro;
+var vtkErrorMacro = macro.vtkErrorMacro,
+    vtkWarningMacro = macro.vtkWarningMacro;
 var createSvgElement = vtkSVGRepresentation.createSvgElement,
     createSvgDomElement = vtkSVGRepresentation.createSvgDomElement;
 var viewIdCount = 1; // ----------------------------------------------------------------------------
@@ -267,17 +270,48 @@ function vtkWidgetManager(publicAPI, model) {
     model.widgets.forEach(updateWidgetForRender);
   }
 
-  function captureBuffers(x1, y1, x2, y2) {
-    renderPickingBuffer();
-    model.selector.setArea(x1, y1, x2, y2);
-    model.selector.releasePixBuffers();
-    model.previousSelectedData = null;
-    return model.selector.captureBuffers();
+  function captureBuffers(_x, _x2, _x3, _x4) {
+    return _captureBuffers.apply(this, arguments);
+  }
+
+  function _captureBuffers() {
+    _captureBuffers = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(x1, y1, x2, y2) {
+      return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+        while (1) {
+          switch (_context3.prev = _context3.next) {
+            case 0:
+              if (!model._captureInProgress) {
+                _context3.next = 2;
+                break;
+              }
+
+              return _context3.abrupt("return");
+
+            case 2:
+              model._captureInProgress = true;
+              renderPickingBuffer();
+              model._capturedBuffers = null;
+              _context3.next = 7;
+              return model.selector.getSourceDataAsync(model.renderer, x1, y1, x2, y2);
+
+            case 7:
+              model._capturedBuffers = _context3.sent;
+              model.previousSelectedData = null;
+              renderFrontBuffer();
+              model._captureInProgress = false;
+
+            case 11:
+            case "end":
+              return _context3.stop();
+          }
+        }
+      }, _callee3);
+    }));
+    return _captureBuffers.apply(this, arguments);
   }
 
   publicAPI.enablePicking = function () {
     model.pickingEnabled = true;
-    model.pickingAvailable = true;
     publicAPI.renderWidgets();
   };
 
@@ -288,7 +322,7 @@ function vtkWidgetManager(publicAPI, model) {
           w = _model$apiSpecificRen4[0],
           h = _model$apiSpecificRen4[1];
 
-      model.pickingAvailable = captureBuffers(0, 0, w, h);
+      captureBuffers(0, 0, w, h);
     }
 
     renderFrontBuffer();
@@ -297,7 +331,6 @@ function vtkWidgetManager(publicAPI, model) {
 
   publicAPI.disablePicking = function () {
     model.pickingEnabled = false;
-    model.pickingAvailable = false;
   };
 
   publicAPI.setRenderer = function (renderer) {
@@ -307,9 +340,8 @@ function vtkWidgetManager(publicAPI, model) {
       subscriptions.pop().unsubscribe();
     }
 
-    model.selector = model.apiSpecificRenderWindow.getSelector();
+    model.selector = model.apiSpecificRenderWindow.createSelector();
     model.selector.setFieldAssociation(FieldAssociations.FIELD_ASSOCIATION_POINTS);
-    model.selector.attach(model.apiSpecificRenderWindow, model.renderer);
     subscriptions.push(model.interactor.onRenderEvent(updateSvg));
     subscriptions.push(model.apiSpecificRenderWindow.onModified(setSvgSize));
     setSvgSize();
@@ -323,61 +355,90 @@ function vtkWidgetManager(publicAPI, model) {
       model.isAnimating = false;
       publicAPI.renderWidgets();
     }));
-    subscriptions.push(model.interactor.onMouseMove(function (_ref) {
-      var position = _ref.position;
-
-      if (model.isAnimating || !model.pickingAvailable) {
-        return;
-      }
-
-      publicAPI.updateSelectionFromXY(position.x, position.y);
-
-      var _publicAPI$getSelecte = publicAPI.getSelectedData(),
-          requestCount = _publicAPI$getSelecte.requestCount,
-          selectedState = _publicAPI$getSelecte.selectedState,
-          representation = _publicAPI$getSelecte.representation,
-          widget = _publicAPI$getSelecte.widget;
-
-      if (requestCount) {
-        // Call activate only once
-        return;
-      } // Default cursor behavior
-
-
-      model.apiSpecificRenderWindow.setCursor(widget ? 'pointer' : 'default');
-
-      if (model.widgetInFocus === widget && widget.hasFocus()) {
-        widget.activateHandle({
-          selectedState: selectedState,
-          representation: representation
-        }); // Ken FIXME
-
-        model.interactor.render();
-        model.interactor.render();
-      } else {
-        for (var i = 0; i < model.widgets.length; i++) {
-          var w = model.widgets[i];
-
-          if (w === widget && w.getNestedPickable()) {
-            w.activateHandle({
-              selectedState: selectedState,
-              representation: representation
-            });
-            model.activeWidget = w;
-          } else {
-            w.deactivateAllHandles();
+    subscriptions.push(model.interactor.onMouseMove( /*#__PURE__*/function () {
+      var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(_ref) {
+        var position, _yield$publicAPI$getS, requestCount, selectedState, representation, widget, i, w;
+
+        return _regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                position = _ref.position;
+
+                if (!(model.isAnimating || !model.pickingEnabled || model._selectionInProgress)) {
+                  _context.next = 3;
+                  break;
+                }
+
+                return _context.abrupt("return");
+
+              case 3:
+                model._selectionInProgress = true;
+                _context.next = 6;
+                return publicAPI.getSelectedDataForXY(position.x, position.y);
+
+              case 6:
+                _yield$publicAPI$getS = _context.sent;
+                requestCount = _yield$publicAPI$getS.requestCount;
+                selectedState = _yield$publicAPI$getS.selectedState;
+                representation = _yield$publicAPI$getS.representation;
+                widget = _yield$publicAPI$getS.widget;
+                model._selectionInProgress = false;
+
+                if (!requestCount) {
+                  _context.next = 14;
+                  break;
+                }
+
+                return _context.abrupt("return");
+
+              case 14:
+                // Default cursor behavior
+                model.apiSpecificRenderWindow.setCursor(widget ? 'pointer' : 'default');
+
+                if (model.widgetInFocus === widget && widget.hasFocus()) {
+                  widget.activateHandle({
+                    selectedState: selectedState,
+                    representation: representation
+                  }); // Ken FIXME
+
+                  model.interactor.render();
+                  model.interactor.render();
+                } else {
+                  for (i = 0; i < model.widgets.length; i++) {
+                    w = model.widgets[i];
+
+                    if (w === widget && w.getNestedPickable()) {
+                      w.activateHandle({
+                        selectedState: selectedState,
+                        representation: representation
+                      });
+                      model.activeWidget = w;
+                    } else {
+                      w.deactivateAllHandles();
+                    }
+                  } // Ken FIXME
+
+
+                  model.interactor.render();
+                  model.interactor.render();
+                }
+
+              case 16:
+              case "end":
+                return _context.stop();
+            }
           }
-        } // Ken FIXME
+        }, _callee);
+      }));
 
-
-        model.interactor.render();
-        model.interactor.render();
-      }
-    }));
+      return function (_x5) {
+        return _ref2.apply(this, arguments);
+      };
+    }()));
     publicAPI.modified();
 
     if (model.pickingEnabled) {
-      // also sets pickingAvailable
       publicAPI.enablePicking();
     }
 
@@ -453,7 +514,93 @@ function vtkWidgetManager(publicAPI, model) {
     }
   };
 
+  publicAPI.getSelectedDataForXY = /*#__PURE__*/function () {
+    var _ref3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(x, y) {
+      var i, widget, hoveredSVGReps, selection, capturedRegion;
+      return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+        while (1) {
+          switch (_context2.prev = _context2.next) {
+            case 0:
+              model.selections = null;
+
+              if (!model.pickingEnabled) {
+                _context2.next = 24;
+                break;
+              }
+
+              i = 0;
+
+            case 3:
+              if (!(i < model.widgets.length)) {
+                _context2.next = 16;
+                break;
+              }
+
+              widget = model.widgets[i];
+              hoveredSVGReps = widget.getRepresentations().filter(function (r) {
+                return r.isA('vtkSVGRepresentation') && r.getHover() != null;
+              });
+
+              if (!hoveredSVGReps.length) {
+                _context2.next = 13;
+                break;
+              }
+
+              selection = vtkSelectionNode.newInstance();
+              selection.getProperties().compositeID = hoveredSVGReps[0].getHover();
+              selection.getProperties().widget = widget;
+              selection.getProperties().representation = hoveredSVGReps[0];
+              model.selections = [selection];
+              return _context2.abrupt("return", publicAPI.getSelectedData());
+
+            case 13:
+              ++i;
+              _context2.next = 3;
+              break;
+
+            case 16:
+              if (!(!model._capturedBuffers || model.captureOn === CaptureOn.MOUSE_MOVE)) {
+                _context2.next = 19;
+                break;
+              }
+
+              _context2.next = 19;
+              return captureBuffers(x, y, x, y);
+
+            case 19:
+              // or do we need a pixel that is outside the last capture?
+              capturedRegion = model._capturedBuffers.area;
+
+              if (!(x < capturedRegion[0] || x > capturedRegion[2] || y < capturedRegion[1] || y > capturedRegion[3])) {
+                _context2.next = 23;
+                break;
+              }
+
+              _context2.next = 23;
+              return captureBuffers(x, y, x, y);
+
+            case 23:
+              model.selections = model._capturedBuffers.generateSelection(x, y, x, y);
+
+            case 24:
+              return _context2.abrupt("return", publicAPI.getSelectedData());
+
+            case 25:
+            case "end":
+              return _context2.stop();
+          }
+        }
+      }, _callee2);
+    }));
+
+    return function (_x6, _x7) {
+      return _ref3.apply(this, arguments);
+    };
+  }();
+
   publicAPI.updateSelectionFromXY = function (x, y) {
+    vtkWarningMacro('updateSelectionFromXY is deprecated, please use getSelectedDataForXY');
+
     if (model.pickingEnabled) {
       // First pick SVG representation
       for (var i = 0; i < model.widgets.length; ++i) {
@@ -473,20 +620,14 @@ function vtkWidgetManager(publicAPI, model) {
       } // Then pick regular representations.
 
 
-      var pickingAvailable = model.pickingAvailable;
-
       if (model.captureOn === CaptureOn.MOUSE_MOVE) {
-        pickingAvailable = captureBuffers(x, y, x, y);
-        renderFrontBuffer();
-      }
-
-      if (pickingAvailable) {
-        model.selections = model.selector.generateSelection(x, y, x, y);
+        captureBuffers(x, y, x, y);
       }
     }
   };
 
   publicAPI.updateSelectionFromMouseEvent = function (event) {
+    vtkWarningMacro('updateSelectionFromMouseEvent is deprecated, please use getSelectedDataForXY');
     var pageX = event.pageX,
         pageY = event.pageY;
 
@@ -603,7 +744,6 @@ var DEFAULT_VALUES = {
   widgets: [],
   renderer: null,
   viewType: ViewTypes.DEFAULT,
-  pickingAvailable: false,
   isAnimating: false,
   pickingEnabled: true,
   selections: null,

package/package.json

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