@kitware/vtk.js 33.0.0-beta.2 → 33.0.0-beta.3

package/Widgets/Widgets3D/ResliceCursorWidget/behavior.js

@@ -342,6 +342,23 @@ function widgetBehavior(publicAPI, model) {
     };
   };
 
+  /**
+   * Rotate a line by a specified angle
+   * @param {string} lineName The line name to rotate (e.g. YinX, ZinX, XinY, ZinY, XinZ, YinZ)
+   * @param {Number} radianAngle Applied angle in radian
+   */
+  publicAPI.setViewPlane = (viewType, normal, viewUp) => {
+    let newViewUp = viewUp;
+    if (newViewUp == null) {
+      newViewUp = model.widgetState.getPlanes()[viewType].viewUp;
+    }
+    model.widgetState.getPlanes()[viewType] = {
+      normal,
+      viewUp: newViewUp
+    };
+    updateState(model.widgetState, model._factory.getScaleInPixels(), model._factory.getRotationHandlePosition());
+  };
+
   // --------------------------------------------------------------------------
   // initialization
   // --------------------------------------------------------------------------

package/Widgets/Widgets3D/ResliceCursorWidget/helpers.js

@@ -113,6 +113,7 @@ function rotateVector(vectorToBeRotated, axis, angle) {
 }
 
 /**
+ * Return ['X'] if there are only 1 plane defined in the widget state.
  * Return ['X', 'Y'] if there are only 2 planes defined in the widget state.
  * Return ['X', 'Y', 'Z'] if there are 3 planes defined in the widget state.
  * @param {object} widgetState the state of the widget

package/Widgets/Widgets3D/ShapeWidget/behavior.js

@@ -290,6 +290,9 @@ function widgetBehavior(publicAPI, model) {
       const up = model._camera.getViewUp();
       const right = [];
       vec3.cross(right, up, normal);
+      vtkMath.normalize(right);
+      vec3.cross(up, normal, right);
+      vtkMath.normalize(up);
       model.shapeHandle.setUp(up);
       model.shapeHandle.setRight(right);
       model.shapeHandle.setDirection(normal);

package/_virtual/rollup-plugin-worker-loader__module_Sources/IO/Geometry/GLTFImporter/ORMTexture.worker.js

@@ -0,0 +1,296 @@
+import { c as createInlineWorkerFactory } from '../../../../rollup-plugin-web-worker-loader__helper__browser__createInlineWorkerFactory.js';
+
+var WorkerFactory = createInlineWorkerFactory(/* rollup-plugin-web-worker-loader */function () {
+(function () {
+  '__worker_loader_strict__';
+
+  var register = {exports: {}};
+
+  var _createClass$1 = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+  function _classCallCheck$1(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+  var TinyEmitter$1 = function () {
+    function TinyEmitter() {
+      _classCallCheck$1(this, TinyEmitter);
+
+      Object.defineProperty(this, '__listeners', {
+        value: {},
+        enumerable: false,
+        writable: false
+      });
+    }
+
+    _createClass$1(TinyEmitter, [{
+      key: 'emit',
+      value: function emit(eventName) {
+        if (!this.__listeners[eventName]) return this;
+
+        for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+          args[_key - 1] = arguments[_key];
+        }
+
+        var _iteratorNormalCompletion = true;
+        var _didIteratorError = false;
+        var _iteratorError = undefined;
+
+        try {
+          for (var _iterator = this.__listeners[eventName][Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+            var handler = _step.value;
+
+            handler.apply(undefined, args);
+          }
+        } catch (err) {
+          _didIteratorError = true;
+          _iteratorError = err;
+        } finally {
+          try {
+            if (!_iteratorNormalCompletion && _iterator.return) {
+              _iterator.return();
+            }
+          } finally {
+            if (_didIteratorError) {
+              throw _iteratorError;
+            }
+          }
+        }
+
+        return this;
+      }
+    }, {
+      key: 'once',
+      value: function once(eventName, handler) {
+        var _this = this;
+
+        var once = function once() {
+          _this.off(eventName, once);
+          handler.apply(undefined, arguments);
+        };
+
+        return this.on(eventName, once);
+      }
+    }, {
+      key: 'on',
+      value: function on(eventName, handler) {
+        if (!this.__listeners[eventName]) this.__listeners[eventName] = [];
+
+        this.__listeners[eventName].push(handler);
+
+        return this;
+      }
+    }, {
+      key: 'off',
+      value: function off(eventName, handler) {
+        if (handler) this.__listeners[eventName] = this.__listeners[eventName].filter(function (h) {
+          return h !== handler;
+        });else this.__listeners[eventName] = [];
+
+        return this;
+      }
+    }]);
+
+    return TinyEmitter;
+  }();
+
+  var tinyEmitter = TinyEmitter$1;
+
+  var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+  var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } };
+
+  var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
+
+  function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
+
+  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+  function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+  function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+  var TinyEmitter = tinyEmitter;
+
+  var MESSAGE_RESULT = 0;
+  var MESSAGE_EVENT = 1;
+
+  var RESULT_ERROR = 0;
+  var RESULT_SUCCESS = 1;
+
+  var DEFAULT_HANDLER = 'main';
+
+  var isPromise = function isPromise(o) {
+    return (typeof o === 'undefined' ? 'undefined' : _typeof(o)) === 'object' && o !== null && typeof o.then === 'function' && typeof o.catch === 'function';
+  };
+
+  function RegisterPromise(fn) {
+    var handlers = _defineProperty({}, DEFAULT_HANDLER, fn);
+    var sendPostMessage = self.postMessage.bind(self);
+
+    var server = new (function (_TinyEmitter) {
+      _inherits(WorkerRegister, _TinyEmitter);
+
+      function WorkerRegister() {
+        _classCallCheck(this, WorkerRegister);
+
+        return _possibleConstructorReturn(this, (WorkerRegister.__proto__ || Object.getPrototypeOf(WorkerRegister)).apply(this, arguments));
+      }
+
+      _createClass(WorkerRegister, [{
+        key: 'emit',
+        value: function emit(eventName) {
+          for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+            args[_key - 1] = arguments[_key];
+          }
+
+          if (args.length == 1 && args[0] instanceof TransferableResponse) {
+            sendPostMessage({ eventName: eventName, args: args }, args[0].transferable);
+          } else {
+            sendPostMessage({ eventName: eventName, args: args });
+          }
+          return this;
+        }
+      }, {
+        key: 'emitLocally',
+        value: function emitLocally(eventName) {
+          var _get2;
+
+          for (var _len2 = arguments.length, args = Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+            args[_key2 - 1] = arguments[_key2];
+          }
+
+          (_get2 = _get(WorkerRegister.prototype.__proto__ || Object.getPrototypeOf(WorkerRegister.prototype), 'emit', this)).call.apply(_get2, [this, eventName].concat(args));
+        }
+      }, {
+        key: 'operation',
+        value: function operation(name, handler) {
+          handlers[name] = handler;
+          return this;
+        }
+      }]);
+
+      return WorkerRegister;
+    }(TinyEmitter))();
+
+    var run = function run(messageId, payload, handlerName) {
+
+      var onSuccess = function onSuccess(result) {
+        if (result && result instanceof TransferableResponse) {
+          sendResult(messageId, RESULT_SUCCESS, result.payload, result.transferable);
+        } else {
+          sendResult(messageId, RESULT_SUCCESS, result);
+        }
+      };
+
+      var onError = function onError(e) {
+        sendResult(messageId, RESULT_ERROR, {
+          message: e.message,
+          stack: e.stack
+        });
+      };
+
+      try {
+        var result = runFn(messageId, payload, handlerName);
+        if (isPromise(result)) {
+          result.then(onSuccess).catch(onError);
+        } else {
+          onSuccess(result);
+        }
+      } catch (e) {
+        onError(e);
+      }
+    };
+
+    var runFn = function runFn(messageId, payload, handlerName) {
+      var handler = handlers[handlerName || DEFAULT_HANDLER];
+      if (!handler) throw new Error('Not found handler for this request');
+
+      return handler(payload, sendEvent.bind(null, messageId));
+    };
+
+    var sendResult = function sendResult(messageId, success, payload) {
+      var transferable = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];
+
+      sendPostMessage([MESSAGE_RESULT, messageId, success, payload], transferable);
+    };
+
+    var sendEvent = function sendEvent(messageId, eventName, payload) {
+      if (!eventName) throw new Error('eventName is required');
+
+      if (typeof eventName !== 'string') throw new Error('eventName should be string');
+
+      sendPostMessage([MESSAGE_EVENT, messageId, eventName, payload]);
+    };
+
+    self.addEventListener('message', function (_ref) {
+      var data = _ref.data;
+
+      if (Array.isArray(data)) {
+        run.apply(undefined, _toConsumableArray(data));
+      } else if (data && data.eventName) {
+        server.emitLocally.apply(server, [data.eventName].concat(_toConsumableArray(data.args)));
+      }
+    });
+
+    return server;
+  }
+
+  var TransferableResponse = function TransferableResponse(payload, transferable) {
+    _classCallCheck(this, TransferableResponse);
+
+    this.payload = payload;
+    this.transferable = transferable;
+  };
+
+  register.exports = RegisterPromise;
+  register.exports.TransferableResponse = TransferableResponse;
+
+  var registerWebworker = register.exports;
+
+  /**
+   *
+   * @param {ArrayBuffer} imageBuffer
+   * @param {string} mimeType
+   * @param {string} channel
+   * @returns {Promise<ImageData>}
+   */
+  registerWebworker(async _ref => {
+    let {
+      imageBuffer,
+      mimeType,
+      channel
+    } = _ref;
+    const channelsMap = {
+      r: 0,
+      g: 1,
+      b: 2
+    };
+    const blob = new Blob([imageBuffer], {
+      type: mimeType
+    });
+    const img = await createImageBitmap(blob);
+    const canvas = new OffscreenCanvas(img.width, img.height);
+    const ctx = canvas.getContext('2d');
+    ctx.drawImage(img, 0, 0, img.width, img.height);
+    const bitmap = ctx.getImageData(0, 0, img.width, img.height);
+    if (channel) {
+      const idx = channelsMap[channel];
+      for (let i = 0; i < bitmap.data.length; i += 4) {
+        const channelValue = bitmap.data[i + idx];
+        bitmap.data[i] = channelValue; // red channel
+        bitmap.data[i + 1] = channelValue; // green channel
+        bitmap.data[i + 2] = channelValue; // blue channel
+      }
+    }
+
+    return {
+      bitmap
+    };
+  });
+
+})();
+}, null);
+/* eslint-enable */
+
+export { WorkerFactory as W };

package/index.d.ts

@@ -54,6 +54,7 @@
 /// <reference path="./Common/DataModel/Triangle.d.ts" />
 /// <reference path="./Common/Transform/LandmarkTransform.d.ts" />
 /// <reference path="./Common/Transform/Transform.d.ts" />
+/// <reference path="./Filters/Core/ThresholdPoints.d.ts" />
 /// <reference path="./Filters/General/AppendPolyData.d.ts" />
 /// <reference path="./Filters/General/ClipClosedSurface.d.ts" />
 /// <reference path="./Filters/General/ContourLoopExtraction.d.ts" />
@@ -92,11 +93,15 @@
 /// <reference path="./IO/Core/ImageStream.d.ts" />
 /// <reference path="./IO/Core/WSLinkClient.d.ts" />
 /// <reference path="./IO/Geometry/DracoReader.d.ts" />
+/// <reference path="./IO/Geometry/GLTFImporter.d.ts" />
+/// <reference path="./IO/Geometry/IFCImporter.d.ts" />
 /// <reference path="./IO/Geometry/PLYReader.d.ts" />
 /// <reference path="./IO/Geometry/PLYWriter.d.ts" />
 /// <reference path="./IO/Geometry/STLReader.d.ts" />
 /// <reference path="./IO/Geometry/STLWriter.d.ts" />
 /// <reference path="./IO/Image/HDRReader.d.ts" />
+/// <reference path="./IO/Image/TGAReader.d.ts" />
+/// <reference path="./IO/Image/TIFFReader.d.ts" />
 /// <reference path="./IO/Misc/ElevationReader.d.ts" />
 /// <reference path="./IO/Misc/GCodeReader.d.ts" />
 /// <reference path="./IO/Misc/ITKImageReader.d.ts" />

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kitware/vtk.js",
-  "version": "33.0.0-beta.2",
+  "version": "33.0.0-beta.3",
   "description": "Visualization Toolkit for the Web",
   "keywords": [
     "3d",
@@ -43,6 +43,7 @@
     "shelljs": "0.8.5",
     "spark-md5": "3.0.2",
     "stream-browserify": "3.0.0",
+    "utif": "3.1.0",
     "webworker-promise": "0.5.0",
     "worker-loader": "3.0.8",
     "xmlbuilder2": "3.0.2"
@@ -52,8 +53,8 @@
     "@babel/eslint-parser": "7.22.11",
     "@babel/plugin-transform-runtime": "7.22.10",
     "@babel/preset-env": "7.22.10",
-    "@commitlint/cli": "16.2.4",
-    "@commitlint/config-conventional": "16.2.4",
+    "@commitlint/cli": "19.7.1",
+    "@commitlint/config-conventional": "19.7.1",
     "@mapbox/node-pre-gyp": "1.0.9",
     "@rollup/plugin-alias": "3.1.9",
     "@rollup/plugin-babel": "5.3.1",
@@ -61,6 +62,7 @@
     "@rollup/plugin-eslint": "8.0.2",
     "@rollup/plugin-json": "4.1.0",
     "@rollup/plugin-node-resolve": "13.1.3",
+    "@types/node": "^22.13.1",
     "autoprefixer": "10.4.7",
     "babel-loader": "8.2.5",
     "babel-plugin-istanbul": "6.1.1",
@@ -71,7 +73,7 @@
     "cross-env": "7.0.3",
     "css-loader": "6.7.1",
     "dotenv": "16.0.1",
-    "dox": "0.9.1",
+    "dox": "1.0.0",
     "eslint": "8.15.0",
     "eslint-config-airbnb": "19.0.4",
     "eslint-config-prettier": "8.5.0",
@@ -104,7 +106,7 @@
     "prettier": "2.6.2",
     "process": "0.11.10",
     "regenerator-runtime": "0.13.9",
-    "rollup": "2.73.0",
+    "rollup": "2.79.2",
     "rollup-plugin-auto-external": "2.0.0",
     "rollup-plugin-copy": "3.4.0",
     "rollup-plugin-ignore": "1.0.10",
@@ -118,14 +120,14 @@
     "string-replace-loader": "3.1.0",
     "style-loader": "3.3.1",
     "tape": "5.5.3",
-    "webpack": "5.76.0",
+    "webpack": "5.97.1",
     "webpack-bundle-analyzer": "4.5.0",
     "webpack-cli": "4.9.2",
     "webpack-dashboard": "3.3.7",
     "webpack-dev-server": "4.9.0",
     "webpack-merge": "5.8.0",
     "webpack-notifier": "1.15.0",
-    "wslink": "1.6.4",
+    "wslink": "1.12.4",
     "xml2js": "0.5.0"
   },
   "peerDependencies": {
@@ -141,7 +143,7 @@
     "lint": "eslint Sources Examples",
     "doc": "kw-doc -c ./Documentation/config.js",
     "doc:www": "npm t -- --single-run && kw-doc -c ./Documentation/config.js -s",
-    "doc:publish": "kw-doc -c ./Documentation/config.js -mp",
+    "doc:minified": "kw-doc -c ./Documentation/config.js -m",
     "doc:generate-api": "node ./Documentation/generate-api-docs.js",
     "example": "node ./Utilities/ExampleRunner/example-runner-cli.js -c ./Documentation/config.js",
     "example:https": "node ./Utilities/ExampleRunner/example-runner-cli.js --server-type https -c ./Documentation/config.js",
@@ -149,7 +151,7 @@
     "dev:esm": "npm run build:esm -- -w",
     "dev:umd": "webpack --watch --config webpack.dev.js --progress",
     "build": "npm run build:release",
-    "build:esm": "npm run patch-build-deps && rollup -c rollup.config.js",
+    "build:esm": "rollup -c rollup.config.js",
     "build:umd": "webpack --config webpack.prod.js --progress",
     "build:release": "npm run lint && concurrently \"cross-env NOLINT=1 npm run build:esm\" \"cross-env NOLINT=1 npm run build:umd\"",
     "release:create-packages": "node ./Utilities/ci/build-npm-package.js",
@@ -162,7 +164,7 @@
     "commit": "git cz",
     "semantic-release": "semantic-release",
     "prepare": "node ./Utilities/prepare.js",
-    "patch-build-deps": "patch-package --patch-dir ./Utilities/build/patches"
+    "postinstall": "patch-package"
   },
   "config": {
     "commitizen": {