@kitware/vtk.js 28.10.2 → 28.11.0

package/Rendering/Core/AbstractImageMapper.js

@@ -1,50 +1,49 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkAbstractMapper3D from './AbstractMapper3D.js';
 import { F as createUninitializedBounds } from '../../Common/Core/Math/index.js';
 
+// ----------------------------------------------------------------------------
 // vtkAbstractImageMapper methods
 // ----------------------------------------------------------------------------
 
 function vtkAbstractImageMapper(publicAPI, model) {
   model.classHierarchy.push('vtkAbstractImageMapper');
-
-  publicAPI.getIsOpaque = function () {
-    return true;
-  };
-
-  publicAPI.getCurrentImage = function () {
-    return null;
-  };
-
-  publicAPI.getBoundsForSlice = function () {
+  publicAPI.getIsOpaque = () => true;
+  publicAPI.getCurrentImage = () => null;
+  publicAPI.getBoundsForSlice = () => {
     macro.vtkErrorMacro('vtkAbstractImageMapper.getBoundsForSlice - NOT IMPLEMENTED');
     return createUninitializedBounds();
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   slice: 0,
   customDisplayExtent: [0, 0, 0, 0, 0, 0],
   useCustomExtents: false,
   backgroundColor: [0, 0, 0, 1]
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 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
   vtkAbstractMapper3D.extend(publicAPI, model, initialValues);
   macro.setGet(publicAPI, model, ['slice', 'useCustomExtents']);
   macro.setGetArray(publicAPI, model, ['customDisplayExtent'], 6);
   macro.setGetArray(publicAPI, model, ['backgroundColor'], 4);
   vtkAbstractImageMapper(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
+// ----------------------------------------------------------------------------
 var vtkAbstractImageMapper$1 = {
-  extend: extend
+  extend
 };
 
 export { vtkAbstractImageMapper$1 as default, extend };

package/Rendering/Core/AbstractMapper.js

@@ -1,93 +1,75 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 
+// ----------------------------------------------------------------------------
 // vtkAbstractMapper methods
 // ----------------------------------------------------------------------------
 
 function vtkAbstractMapper(publicAPI, model) {
   model.classHierarchy.push('vtkAbstractMapper');
-
-  publicAPI.update = function () {
+  publicAPI.update = () => {
     publicAPI.getInputData();
   };
-
-  publicAPI.addClippingPlane = function (plane) {
+  publicAPI.addClippingPlane = plane => {
     if (!plane.isA('vtkPlane')) {
       return false;
     }
-
     if (!model.clippingPlanes.includes(plane)) {
       model.clippingPlanes.push(plane);
       publicAPI.modified();
       return true;
     }
-
     return false;
   };
-
-  publicAPI.getNumberOfClippingPlanes = function () {
-    return model.clippingPlanes.length;
-  };
-
-  publicAPI.removeAllClippingPlanes = function () {
+  publicAPI.getNumberOfClippingPlanes = () => model.clippingPlanes.length;
+  publicAPI.removeAllClippingPlanes = () => {
     if (model.clippingPlanes.length === 0) {
       return false;
     }
-
     model.clippingPlanes.length = 0;
     publicAPI.modified();
     return true;
   };
-
-  publicAPI.removeClippingPlane = function (clippingPlane) {
-    var i = model.clippingPlanes.indexOf(clippingPlane);
-
+  publicAPI.removeClippingPlane = clippingPlane => {
+    const i = model.clippingPlanes.indexOf(clippingPlane);
     if (i === -1) {
       return false;
     }
-
     model.clippingPlanes.splice(i, 1);
     publicAPI.modified();
     return true;
   };
-
-  publicAPI.getClippingPlanes = function () {
-    return model.clippingPlanes;
-  };
-
-  publicAPI.setClippingPlanes = function (planes) {
+  publicAPI.getClippingPlanes = () => model.clippingPlanes;
+  publicAPI.setClippingPlanes = planes => {
     if (!planes) {
       return;
     }
-
     if (!Array.isArray(planes)) {
       publicAPI.addClippingPlane(planes);
     } else {
-      var nbPlanes = planes.length;
-
-      for (var i = 0; i < nbPlanes && i < 6; i++) {
+      const nbPlanes = planes.length;
+      for (let i = 0; i < nbPlanes && i < 6; i++) {
         publicAPI.addClippingPlane(planes[i]);
       }
     }
   };
-
-  publicAPI.getClippingPlaneInDataCoords = function (propMatrix, i, hnormal) {
-    var clipPlanes = model.clippingPlanes;
-    var mat = propMatrix;
-
+  publicAPI.getClippingPlaneInDataCoords = (propMatrix, i, hnormal) => {
+    const clipPlanes = model.clippingPlanes;
+    const mat = propMatrix;
     if (clipPlanes) {
-      var n = clipPlanes.length;
-
+      const n = clipPlanes.length;
       if (i >= 0 && i < n) {
         // Get the plane
-        var plane = clipPlanes[i];
-        var normal = plane.getNormal();
-        var origin = plane.getOrigin(); // Compute the plane equation
+        const plane = clipPlanes[i];
+        const normal = plane.getNormal();
+        const origin = plane.getOrigin();
 
-        var v1 = normal[0];
-        var v2 = normal[1];
-        var v3 = normal[2];
-        var v4 = -(v1 * origin[0] + v2 * origin[1] + v3 * origin[2]); // Transform normal from world to data coords
+        // Compute the plane equation
+        const v1 = normal[0];
+        const v2 = normal[1];
+        const v3 = normal[2];
+        const v4 = -(v1 * origin[0] + v2 * origin[1] + v3 * origin[2]);
 
+        // Transform normal from world to data coords
         hnormal[0] = v1 * mat[0] + v2 * mat[4] + v3 * mat[8] + v4 * mat[12];
         hnormal[1] = v1 * mat[1] + v2 * mat[5] + v3 * mat[9] + v4 * mat[13];
         hnormal[2] = v1 * mat[2] + v2 * mat[6] + v3 * mat[10] + v4 * mat[14];
@@ -95,34 +77,36 @@ function vtkAbstractMapper(publicAPI, model) {
         return;
       }
     }
-
-    macro.vtkErrorMacro("Clipping plane index ".concat(i, " is out of range."));
+    macro.vtkErrorMacro(`Clipping plane index ${i} is out of range.`);
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   clippingPlanes: []
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 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.algo(publicAPI, model, 1, 0);
-
   if (!model.clippingPlanes) {
     model.clippingPlanes = [];
   }
-
   vtkAbstractMapper(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
+// ----------------------------------------------------------------------------
 var vtkAbstractMapper$1 = {
-  extend: extend
+  extend
 };
 
 export { vtkAbstractMapper$1 as default, extend };

package/Rendering/Core/AbstractMapper3D.js

@@ -1,59 +1,54 @@
-import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkAbstractMapper from './AbstractMapper.js';
 import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';
 import { F as createUninitializedBounds } from '../../Common/Core/Math/index.js';
 
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+// ----------------------------------------------------------------------------
 // vtkAbstractMapper methods
 // ----------------------------------------------------------------------------
 
 function vtkAbstractMapper3D(publicAPI, model) {
-  publicAPI.getBounds = function () {
-    macro.vtkErrorMacro("vtkAbstractMapper3D.getBounds - NOT IMPLEMENTED");
+  publicAPI.getBounds = () => {
+    macro.vtkErrorMacro(`vtkAbstractMapper3D.getBounds - NOT IMPLEMENTED`);
     return createUninitializedBounds();
   };
-
-  publicAPI.getCenter = function () {
-    var _model$center;
-
-    var bounds = publicAPI.getBounds();
+  publicAPI.getCenter = () => {
+    const bounds = publicAPI.getBounds();
     model.center = vtkBoundingBox.isValid(bounds) ? vtkBoundingBox.getCenter(bounds) : null;
-    return (_model$center = model.center) === null || _model$center === void 0 ? void 0 : _model$center.slice();
+    return model.center?.slice();
   };
-
-  publicAPI.getLength = function () {
-    var bounds = publicAPI.getBounds();
+  publicAPI.getLength = () => {
+    const bounds = publicAPI.getBounds();
     return vtkBoundingBox.getDiagonalLength(bounds);
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
+const defaultValues = initialValues => ({
+  bounds: [...vtkBoundingBox.INIT_BOUNDS],
+  center: [0, 0, 0],
+  viewSpecificProperties: {},
+  ...initialValues
+});
 
-var defaultValues = function defaultValues(initialValues) {
-  return _objectSpread({
-    bounds: _toConsumableArray(vtkBoundingBox.INIT_BOUNDS),
-    center: [0, 0, 0],
-    viewSpecificProperties: {}
-  }, initialValues);
-}; // ----------------------------------------------------------------------------
-
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, defaultValues(initialValues)); // Inheritance
-
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, defaultValues(initialValues));
+  // Inheritance
   vtkAbstractMapper.extend(publicAPI, model, initialValues);
   macro.setGet(publicAPI, model, ['viewSpecificProperties']);
   vtkAbstractMapper3D(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 
 var vtkAbstractMapper3D$1 = {
-  extend: extend
+  extend
 };
 
 export { vtkAbstractMapper3D$1 as default, extend };

package/Rendering/Core/AbstractPicker.js

@@ -1,13 +1,13 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 
+// ----------------------------------------------------------------------------
 // vtkAbstractPicker methods
 // ----------------------------------------------------------------------------
 
 function vtkAbstractPicker(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkAbstractPicker');
-
-  publicAPI.initialize = function () {
+  publicAPI.initialize = () => {
     model.renderer = null;
     model.selectionPoint[0] = 0.0;
     model.selectionPoint[1] = 0.0;
@@ -16,51 +16,55 @@ function vtkAbstractPicker(publicAPI, model) {
     model.pickPosition[1] = 0.0;
     model.pickPosition[2] = 0.0;
   };
-
-  publicAPI.initializePickList = function () {
+  publicAPI.initializePickList = () => {
     model.pickList = [];
   };
-
-  publicAPI.addPickList = function (actor) {
+  publicAPI.addPickList = actor => {
     model.pickList.push(actor);
   };
-
-  publicAPI.deletePickList = function (actor) {
-    var i = model.pickList.indexOf(actor);
-
+  publicAPI.deletePickList = actor => {
+    const i = model.pickList.indexOf(actor);
     if (i !== -1) {
       model.pickList.splice(i, 1);
     }
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   renderer: null,
   selectionPoint: [0.0, 0.0, 0.0],
   pickPosition: [0.0, 0.0, 0.0],
   pickFromList: 0,
   pickList: []
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 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, ['renderer']);
   macro.getArray(publicAPI, model, ['selectionPoint', 'pickPosition']);
   macro.setGet(publicAPI, model, ['pickFromList', 'pickList']);
   vtkAbstractPicker(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkAbstractPicker'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkAbstractPicker');
+
+// ----------------------------------------------------------------------------
 
 var vtkAbstractPicker$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkAbstractPicker$1 as default, extend, newInstance };