@kitware/vtk.js 28.10.2 → 28.11.0

package/Rendering/Core/PointPicker.js

@@ -1,21 +1,22 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import { d as dot } from '../../Common/Core/Math/index.js';
 import vtkPicker from './Picker.js';
 
-var vtkErrorMacro = macro.vtkErrorMacro; // ----------------------------------------------------------------------------
+const {
+  vtkErrorMacro
+} = macro;
+
+// ----------------------------------------------------------------------------
 // vtkPointPicker methods
 // ----------------------------------------------------------------------------
 
 function vtkPointPicker(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkPointPicker');
-
-  publicAPI.intersectWithLine = function (p1, p2, tol, mapper) {
-    var tMin = Number.MAX_VALUE;
-
+  publicAPI.intersectWithLine = (p1, p2, tol, mapper) => {
+    let tMin = Number.MAX_VALUE;
     if (mapper.isA('vtkImageMapper') || mapper.isA('vtkImageArrayMapper')) {
-      var pickData = mapper.intersectWithLineForPointPicking(p1, p2);
-
+      const pickData = mapper.intersectWithLineForPointPicking(p1, p2);
       if (pickData) {
         tMin = pickData.t;
         model.pointIJK = pickData.ijk;
@@ -23,72 +24,59 @@ function vtkPointPicker(publicAPI, model) {
     } else if (mapper.isA('vtkMapper')) {
       tMin = publicAPI.intersectActorWithLine(p1, p2, tol, mapper);
     }
-
     return tMin;
   };
-
-  publicAPI.intersectActorWithLine = function (p1, p2, tol, mapper) {
+  publicAPI.intersectActorWithLine = (p1, p2, tol, mapper) => {
     // Get dataset
-    var input = mapper.getInputData(); // Determine appropriate info
-
-    var ptId = 0;
-    var numPts = input.getPoints().getNumberOfPoints();
+    const input = mapper.getInputData();
 
+    // Determine appropriate info
+    let ptId = 0;
+    const numPts = input.getPoints().getNumberOfPoints();
     if (numPts <= ptId) {
       return 2.0;
     }
-
-    var ray = [];
-
-    for (var i = 0; i < 3; i++) {
+    const ray = [];
+    for (let i = 0; i < 3; i++) {
       ray[i] = p2[i] - p1[i];
     }
-
-    var rayFactor = dot(ray, ray);
-
+    const rayFactor = dot(ray, ray);
     if (rayFactor === 0.0) {
       vtkErrorMacro('Cannot process points');
       return 2.0;
     }
-
-    var t;
-    var minPtId = -1;
-    var tMin = Number.MAX_VALUE;
-    var minPtDist = Number.MAX_VALUE;
-    var projXYZ = [];
-    var x = [];
-    var points = input.getPoints();
-
+    let t;
+    let minPtId = -1;
+    let tMin = Number.MAX_VALUE;
+    let minPtDist = Number.MAX_VALUE;
+    const projXYZ = [];
+    const x = [];
+    const points = input.getPoints();
     if (model.useCells) {
-      var cellData = input.getPolys().getData();
-      var nbPointsPerCell = cellData[0];
-      var nbCells = input.getPolys().getNumberOfCells();
-
-      for (var cellID = 0; cellID < nbCells; cellID++) {
-        var firstPointIndex = cellID * nbPointsPerCell + 1;
-        var lastPointIndex = firstPointIndex + nbPointsPerCell;
-
-        for (var pointIndex = firstPointIndex; pointIndex < lastPointIndex; pointIndex++) {
-          var pointDataIndex = cellData[pointIndex];
+      const cellData = input.getPolys().getData();
+      const nbPointsPerCell = cellData[0];
+      const nbCells = input.getPolys().getNumberOfCells();
+      for (let cellID = 0; cellID < nbCells; cellID++) {
+        const firstPointIndex = cellID * nbPointsPerCell + 1;
+        const lastPointIndex = firstPointIndex + nbPointsPerCell;
+        for (let pointIndex = firstPointIndex; pointIndex < lastPointIndex; pointIndex++) {
+          const pointDataIndex = cellData[pointIndex];
           points.getPoint(pointDataIndex, x);
-          t = (ray[0] * (x[0] - p1[0]) + ray[1] * (x[1] - p1[1]) + ray[2] * (x[2] - p1[2])) / rayFactor; // If we find a point closer than we currently have, see whether it
+          t = (ray[0] * (x[0] - p1[0]) + ray[1] * (x[1] - p1[1]) + ray[2] * (x[2] - p1[2])) / rayFactor;
+
+          // If we find a point closer than we currently have, see whether it
           // lies within the pick tolerance and clipping planes. We keep track
           // of the point closest to the line (use a fudge factor for points
           // nearly the same distance away.)
-
           if (t >= 0.0 && t <= 1.0 && t <= tMin + model.tolerance) {
-            var maxDist = 0.0;
-
-            for (var _i = 0; _i < 3; _i++) {
-              projXYZ[_i] = p1[_i] + t * ray[_i];
-              var dist = Math.abs(x[_i] - projXYZ[_i]);
-
+            let maxDist = 0.0;
+            for (let i = 0; i < 3; i++) {
+              projXYZ[i] = p1[i] + t * ray[i];
+              const dist = Math.abs(x[i] - projXYZ[i]);
               if (dist > maxDist) {
                 maxDist = dist;
               }
             } // end for i
-
-
             if (maxDist <= tol && maxDist < minPtDist) {
               // within tolerance
               minPtId = ptId;
@@ -97,72 +85,73 @@ function vtkPointPicker(publicAPI, model) {
             }
           }
         } // end for pointIndex
-
       } // end for cellID
-
     } else {
       // end if model.useCells
       for (ptId = 0; ptId < numPts; ptId++) {
         points.getPoint(ptId, x);
-        t = (ray[0] * (x[0] - p1[0]) + ray[1] * (x[1] - p1[1]) + ray[2] * (x[2] - p1[2])) / rayFactor; // If we find a point closer than we currently have, see whether it
+        t = (ray[0] * (x[0] - p1[0]) + ray[1] * (x[1] - p1[1]) + ray[2] * (x[2] - p1[2])) / rayFactor;
+
+        // If we find a point closer than we currently have, see whether it
         // lies within the pick tolerance and clipping planes. We keep track
         // of the point closest to the line (use a fudge factor for points
         // nearly the same distance away.)
-
         if (t >= 0.0 && t <= 1.0 && t <= tMin + model.tolerance) {
-          var _maxDist = 0.0;
-
-          for (var _i2 = 0; _i2 < 3; _i2++) {
-            projXYZ[_i2] = p1[_i2] + t * ray[_i2];
-
-            var _dist = Math.abs(x[_i2] - projXYZ[_i2]);
-
-            if (_dist > _maxDist) {
-              _maxDist = _dist;
+          let maxDist = 0.0;
+          for (let i = 0; i < 3; i++) {
+            projXYZ[i] = p1[i] + t * ray[i];
+            const dist = Math.abs(x[i] - projXYZ[i]);
+            if (dist > maxDist) {
+              maxDist = dist;
             }
           } // end for i
-
-
-          if (_maxDist <= tol && _maxDist < minPtDist) {
+          if (maxDist <= tol && maxDist < minPtDist) {
             // within tolerance
             minPtId = ptId;
-            minPtDist = _maxDist;
+            minPtDist = maxDist;
             tMin = t;
           }
         }
       }
     }
-
     model.pointId = minPtId;
     return tMin;
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   pointId: -1,
   pointIJK: [],
   useCells: false
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues); // Inheritance
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
 
+  // Inheritance
   vtkPicker.extend(publicAPI, model, initialValues);
   macro.getArray(publicAPI, model, ['pointIJK']);
   macro.get(publicAPI, model, ['pointId']);
   macro.setGet(publicAPI, model, ['useCells']);
   vtkPointPicker(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 
-var newInstance = macro.newInstance(extend, 'vtkPointPicker'); // ----------------------------------------------------------------------------
+const newInstance = macro.newInstance(extend, 'vtkPointPicker');
+
+// ----------------------------------------------------------------------------
 
 var vtkPointPicker$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkPointPicker$1 as default, extend, newInstance };

package/Rendering/Core/Prop/Constants.js

@@ -1,9 +1,9 @@
-var CoordinateSystem = {
+const CoordinateSystem = {
   DISPLAY: 0,
   WORLD: 1
 };
 var Constants = {
-  CoordinateSystem: CoordinateSystem
+  CoordinateSystem
 };
 
 export { CoordinateSystem, Constants as default };

package/Rendering/Core/Prop.js

@@ -1,144 +1,87 @@
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import Constants from './Prop/Constants.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; }
-var CoordinateSystem = Constants.CoordinateSystem;
-
+const {
+  CoordinateSystem
+} = Constants;
 function notImplemented(method) {
-  return function () {
-    return macro.vtkErrorMacro("vtkProp::".concat(method, " - NOT IMPLEMENTED"));
-  };
-} // ----------------------------------------------------------------------------
+  return () => macro.vtkErrorMacro(`vtkProp::${method} - NOT IMPLEMENTED`);
+}
+
+// ----------------------------------------------------------------------------
 // vtkProp methods
 // ----------------------------------------------------------------------------
 
-
 function vtkProp(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkProp');
-
-  publicAPI.getMTime = function () {
-    var m1 = model.mtime;
-
-    for (var index = 0; index < model.textures.length; ++index) {
-      var m2 = model.textures[index].getMTime();
-
+  publicAPI.getMTime = () => {
+    let m1 = model.mtime;
+    for (let index = 0; index < model.textures.length; ++index) {
+      const m2 = model.textures[index].getMTime();
       if (m2 > m1) {
         m1 = m2;
       }
     }
-
     return m1;
   };
-
-  publicAPI.processSelectorPixelBuffers = function (selector, pixeloffsets) {};
-
-  publicAPI.getNestedProps = function () {
-    return null;
-  };
-
-  publicAPI.getActors = function () {
-    return [];
-  };
-
-  publicAPI.getActors2D = function () {
-    return [];
-  };
-
-  publicAPI.getVolumes = function () {
-    return [];
-  };
-
+  publicAPI.processSelectorPixelBuffers = (selector, pixeloffsets) => {};
+  publicAPI.getNestedProps = () => null;
+  publicAPI.getActors = () => [];
+  publicAPI.getActors2D = () => [];
+  publicAPI.getVolumes = () => [];
   publicAPI.pick = notImplemented('pick');
   publicAPI.hasKey = notImplemented('hasKey');
-
-  publicAPI.getNestedVisibility = function () {
-    return model.visibility && (!model._parentProp || model._parentProp.getNestedVisibility());
-  };
-
-  publicAPI.getNestedPickable = function () {
-    return model.pickable && (!model._parentProp || model._parentProp.getNestedPickable());
-  };
-
-  publicAPI.getNestedDragable = function () {
-    return model.dragable && (!model._parentProp || model._parentProp.getNestedDragable());
-  };
-
-  publicAPI.getRedrawMTime = function () {
-    return model.mtime;
-  };
-
-  publicAPI.setEstimatedRenderTime = function (t) {
+  publicAPI.getNestedVisibility = () => model.visibility && (!model._parentProp || model._parentProp.getNestedVisibility());
+  publicAPI.getNestedPickable = () => model.pickable && (!model._parentProp || model._parentProp.getNestedPickable());
+  publicAPI.getNestedDragable = () => model.dragable && (!model._parentProp || model._parentProp.getNestedDragable());
+  publicAPI.getRedrawMTime = () => model.mtime;
+  publicAPI.setEstimatedRenderTime = t => {
     model.estimatedRenderTime = t;
     model.savedEstimatedRenderTime = t;
   };
-
-  publicAPI.restoreEstimatedRenderTime = function () {
+  publicAPI.restoreEstimatedRenderTime = () => {
     model.estimatedRenderTime = model.savedEstimatedRenderTime;
   };
-
-  publicAPI.addEstimatedRenderTime = function (t) {
+  publicAPI.addEstimatedRenderTime = t => {
     model.estimatedRenderTime += t;
   };
-
-  publicAPI.setAllocatedRenderTime = function (t) {
+  publicAPI.setAllocatedRenderTime = t => {
     model.allocatedRenderTime = t;
     model.savedEstimatedRenderTime = model.estimatedRenderTime;
     model.estimatedRenderTime = 0;
   };
-
-  publicAPI.getSupportsSelection = function () {
-    return false;
-  };
-
-  publicAPI.getTextures = function () {
-    return model.textures;
-  };
-
-  publicAPI.hasTexture = function (texture) {
-    return model.textures.indexOf(texture) !== -1;
-  };
-
-  publicAPI.addTexture = function (texture) {
+  publicAPI.getSupportsSelection = () => false;
+  publicAPI.getTextures = () => model.textures;
+  publicAPI.hasTexture = texture => model.textures.indexOf(texture) !== -1;
+  publicAPI.addTexture = texture => {
     if (texture && !publicAPI.hasTexture(texture)) {
       model.textures = model.textures.concat(texture);
       publicAPI.modified();
     }
   };
-
-  publicAPI.removeTexture = function (texture) {
-    var newTextureList = model.textures.filter(function (item) {
-      return item !== texture;
-    });
-
+  publicAPI.removeTexture = texture => {
+    const newTextureList = model.textures.filter(item => item !== texture);
     if (model.textures.length !== newTextureList.length) {
       model.textures = newTextureList;
       publicAPI.modified();
     }
   };
-
-  publicAPI.removeAllTextures = function () {
+  publicAPI.removeAllTextures = () => {
     model.textures = [];
     publicAPI.modified();
-  }; // not all mappers support all coordinate systems
-
-
-  publicAPI.setCoordinateSystemToWorld = function () {
-    return publicAPI.setCoordinateSystem(CoordinateSystem.WORLD);
   };
 
-  publicAPI.setCoordinateSystemToDisplay = function () {
-    return publicAPI.setCoordinateSystem(CoordinateSystem.DISPLAY);
-  };
-} // ----------------------------------------------------------------------------
+  // not all mappers support all coordinate systems
+  publicAPI.setCoordinateSystemToWorld = () => publicAPI.setCoordinateSystem(CoordinateSystem.WORLD);
+  publicAPI.setCoordinateSystemToDisplay = () => publicAPI.setCoordinateSystem(CoordinateSystem.DISPLAY);
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   // _parentProp: null,
   allocatedRenderTime: 10,
   coordinateSystem: CoordinateSystem.WORLD,
@@ -151,25 +94,34 @@ var DEFAULT_VALUES = {
   textures: [],
   useBounds: true,
   visibility: true
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 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, ['estimatedRenderTime', 'allocatedRenderTime']);
   macro.setGet(publicAPI, model, ['_parentProp', 'coordinateSystem', 'dragable', 'pickable', 'renderTimeMultiplier', 'useBounds', 'visibility']);
-  macro.moveToProtected(publicAPI, model, ['parentProp']); // Object methods
+  macro.moveToProtected(publicAPI, model, ['parentProp']);
 
+  // Object methods
   vtkProp(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkProp');
 
-var newInstance = macro.newInstance(extend, 'vtkProp'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
-var vtkProp$1 = _objectSpread({
-  newInstance: newInstance,
-  extend: extend
-}, Constants);
+var vtkProp$1 = {
+  newInstance,
+  extend,
+  ...Constants
+};
 
 export { vtkProp$1 as default, extend, newInstance };