@kitware/vtk.js 28.10.2 → 28.11.1

package/Rendering/Core/Actor.js

@@ -1,156 +1,128 @@
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import { mat4, vec3 } from 'gl-matrix';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';
 import vtkProp3D from './Prop3D.js';
 import vtkProperty from './Property.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; }
+const {
+  vtkDebugMacro
+} = macro;
 
-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 vtkDebugMacro = macro.vtkDebugMacro; // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 // vtkActor methods
 // ----------------------------------------------------------------------------
 
 function vtkActor(publicAPI, model) {
   // Set our className
-  model.classHierarchy.push('vtkActor'); // Capture 'parentClass' api for internal use
-
-  var superClass = _objectSpread({}, publicAPI);
+  model.classHierarchy.push('vtkActor');
 
-  publicAPI.getActors = function () {
-    return [publicAPI];
+  // Capture 'parentClass' api for internal use
+  const superClass = {
+    ...publicAPI
   };
-
-  publicAPI.getIsOpaque = function () {
+  publicAPI.getActors = () => [publicAPI];
+  publicAPI.getIsOpaque = () => {
     if (model.forceOpaque) {
       return true;
     }
-
     if (model.forceTranslucent) {
       return false;
-    } // make sure we have a property
-
-
+    }
+    // make sure we have a property
     if (!model.property) {
       // force creation of a property
       publicAPI.getProperty();
     }
+    let isOpaque = model.property.getOpacity() >= 1.0;
 
-    var isOpaque = model.property.getOpacity() >= 1.0; // are we using an opaque texture, if any?
-
-    isOpaque = isOpaque && (!model.texture || !model.texture.isTranslucent()); // are we using an opaque scalar array, if any?
+    // are we using an opaque texture, if any?
+    isOpaque = isOpaque && (!model.texture || !model.texture.isTranslucent());
 
+    // are we using an opaque scalar array, if any?
     isOpaque = isOpaque && (!model.mapper || model.mapper.getIsOpaque());
     return isOpaque;
   };
-
-  publicAPI.hasTranslucentPolygonalGeometry = function () {
+  publicAPI.hasTranslucentPolygonalGeometry = () => {
     if (model.mapper === null) {
       return false;
-    } // make sure we have a property
-
-
+    }
+    // make sure we have a property
     if (model.property === null) {
       // force creation of a property
       publicAPI.setProperty(publicAPI.makeProperty());
-    } // is this actor opaque ?
-
+    }
 
+    // is this actor opaque ?
     return !publicAPI.getIsOpaque();
   };
-
   publicAPI.makeProperty = vtkProperty.newInstance;
-
-  publicAPI.getProperty = function () {
+  publicAPI.getProperty = () => {
     if (model.property === null) {
       model.property = publicAPI.makeProperty();
     }
-
     return model.property;
   };
-
-  publicAPI.getBounds = function () {
+  publicAPI.getBounds = () => {
     if (model.mapper === null) {
       return model.bounds;
-    } // Check for the special case when the mapper's bounds are unknown
-
-
-    var bds = model.mapper.getBounds();
+    }
 
+    // Check for the special case when the mapper's bounds are unknown
+    const bds = model.mapper.getBounds();
     if (!bds || bds.length !== 6) {
       return bds;
-    } // Check for the special case when the actor is empty.
-
+    }
 
+    // Check for the special case when the actor is empty.
     if (bds[0] > bds[1]) {
       model.mapperBounds = bds.concat(); // copy the mapper's bounds
-
       model.bounds = [1, -1, 1, -1, 1, -1];
       model.boundsMTime.modified();
       return bds;
-    } // Check if we have cached values for these bounds - we cache the
+    }
+
+    // Check if we have cached values for these bounds - we cache the
     // values returned by model.mapper.getBounds() and we store the time
     // of caching. If the values returned this time are different, or
     // the modified time of this class is newer than the cached time,
     // then we need to rebuild.
-
-
     if (!model.mapperBounds || bds[0] !== model.mapperBounds[0] || bds[1] !== model.mapperBounds[1] || bds[2] !== model.mapperBounds[2] || bds[3] !== model.mapperBounds[3] || bds[4] !== model.mapperBounds[4] || bds[5] !== model.mapperBounds[5] || publicAPI.getMTime() > model.boundsMTime.getMTime()) {
       vtkDebugMacro('Recomputing bounds...');
       model.mapperBounds = bds.concat(); // copy the mapper's bounds
-
-      var bbox = [];
+      const bbox = [];
       vtkBoundingBox.getCorners(bds, bbox);
       publicAPI.computeMatrix();
-      var tmp4 = new Float64Array(16);
+      const tmp4 = new Float64Array(16);
       mat4.transpose(tmp4, model.matrix);
-      bbox.forEach(function (pt) {
-        return vec3.transformMat4(pt, pt, tmp4);
-      });
-      /* eslint-disable no-multi-assign */
+      bbox.forEach(pt => vec3.transformMat4(pt, pt, tmp4));
 
+      /* eslint-disable no-multi-assign */
       model.bounds[0] = model.bounds[2] = model.bounds[4] = Number.MAX_VALUE;
       model.bounds[1] = model.bounds[3] = model.bounds[5] = -Number.MAX_VALUE;
       /* eslint-enable no-multi-assign */
 
-      model.bounds = model.bounds.map(function (d, i) {
-        return i % 2 === 0 ? bbox.reduce(function (a, b) {
-          return a > b[i / 2] ? b[i / 2] : a;
-        }, d) : bbox.reduce(function (a, b) {
-          return a < b[(i - 1) / 2] ? b[(i - 1) / 2] : a;
-        }, d);
-      });
+      model.bounds = model.bounds.map((d, i) => i % 2 === 0 ? bbox.reduce((a, b) => a > b[i / 2] ? b[i / 2] : a, d) : bbox.reduce((a, b) => a < b[(i - 1) / 2] ? b[(i - 1) / 2] : a, d));
       model.boundsMTime.modified();
     }
-
     return model.bounds;
   };
-
-  publicAPI.getMTime = function () {
-    var mt = superClass.getMTime();
-
+  publicAPI.getMTime = () => {
+    let mt = superClass.getMTime();
     if (model.property !== null) {
-      var time = model.property.getMTime();
+      const time = model.property.getMTime();
       mt = time > mt ? time : mt;
     }
-
     if (model.backfaceProperty !== null) {
-      var _time = model.backfaceProperty.getMTime();
-
-      mt = _time > mt ? _time : mt;
+      const time = model.backfaceProperty.getMTime();
+      mt = time > mt ? time : mt;
     }
-
     return mt;
   };
-
-  publicAPI.getRedrawMTime = function () {
-    var mt = model.mtime;
-
+  publicAPI.getRedrawMTime = () => {
+    let mt = model.mtime;
     if (model.mapper !== null) {
-      var time = model.mapper.getMTime();
+      let time = model.mapper.getMTime();
       mt = time > mt ? time : mt;
-
       if (model.mapper.getInput() !== null) {
         // FIXME !!! getInputAlgorithm / getInput
         model.mapper.getInputAlgorithm().update();
@@ -158,53 +130,59 @@ function vtkActor(publicAPI, model) {
         mt = time > mt ? time : mt;
       }
     }
-
     return mt;
   };
-
-  publicAPI.getSupportsSelection = function () {
-    return model.mapper ? model.mapper.getSupportsSelection() : false;
-  };
-
-  publicAPI.processSelectorPixelBuffers = function (selector, pixelOffsets) {
+  publicAPI.getSupportsSelection = () => model.mapper ? model.mapper.getSupportsSelection() : false;
+  publicAPI.processSelectorPixelBuffers = (selector, pixelOffsets) => {
     if (model.mapper && model.mapper.processSelectorPixelBuffers) {
       model.mapper.processSelectorPixelBuffers(selector, pixelOffsets);
     }
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   mapper: null,
   property: null,
   backfaceProperty: null,
   forceOpaque: false,
   forceTranslucent: false,
   bounds: [1, -1, 1, -1, 1, -1]
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 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);
 
-  vtkProp3D.extend(publicAPI, model, initialValues); // vtkTimeStamp
+  // Inheritance
+  vtkProp3D.extend(publicAPI, model, initialValues);
 
+  // vtkTimeStamp
   model.boundsMTime = {};
-  macro.obj(model.boundsMTime); // Build VTK API
+  macro.obj(model.boundsMTime);
 
+  // Build VTK API
   macro.set(publicAPI, model, ['property']);
-  macro.setGet(publicAPI, model, ['backfaceProperty', 'forceOpaque', 'forceTranslucent', 'mapper']); // Object methods
+  macro.setGet(publicAPI, model, ['backfaceProperty', 'forceOpaque', 'forceTranslucent', 'mapper']);
 
+  // Object methods
   vtkActor(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkActor');
 
-var newInstance = macro.newInstance(extend, 'vtkActor'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 var vtkActor$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkActor$1 as default, extend, newInstance };

package/Rendering/Core/Actor2D.js

@@ -1,110 +1,94 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkCoordinate from './Coordinate.js';
 import vtkProp from './Prop.js';
 import vtkProperty2D from './Property2D.js';
 import { Coordinate } from './Coordinate/Constants.js';
 
+// ----------------------------------------------------------------------------
 // vtkActor2D methods
 // ----------------------------------------------------------------------------
 
 function vtkActor2D(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkActor2D');
-
-  publicAPI.getActors2D = function () {
-    return publicAPI;
-  };
-
-  publicAPI.getIsOpaque = function () {
+  publicAPI.getActors2D = () => publicAPI;
+  publicAPI.getIsOpaque = () => {
     // make sure we have a property
     if (!model.property) {
       // force creation of a property
       publicAPI.getProperty();
     }
+    let isOpaque = model.property.getOpacity() >= 1.0;
 
-    var isOpaque = model.property.getOpacity() >= 1.0; // are we using an opaque texture, if any?
-
+    // are we using an opaque texture, if any?
     isOpaque = isOpaque && (!model.texture || !model.texture.isTranslucent());
     return isOpaque;
   };
-
-  publicAPI.hasTranslucentPolygonalGeometry = function () {
+  publicAPI.hasTranslucentPolygonalGeometry = () => {
     if (model.mapper === null) {
       return false;
-    } // make sure we have a property
-
-
+    }
+    // make sure we have a property
     if (model.property === null) {
       // force creation of a property
       publicAPI.setProperty(publicAPI.makeProperty());
-    } // is this actor opaque ?
-
+    }
 
+    // is this actor opaque ?
     return !publicAPI.getIsOpaque();
   };
-
   publicAPI.makeProperty = vtkProperty2D.newInstance;
-
-  publicAPI.getProperty = function () {
+  publicAPI.getProperty = () => {
     if (model.property === null) {
       model.property = publicAPI.makeProperty();
     }
-
     return model.property;
-  }; //----------------------------------------------------------------------------
-  // Set the Prop2D's position in display coordinates.
-
+  };
 
-  publicAPI.setDisplayPosition = function (XPos, YPos) {
+  //----------------------------------------------------------------------------
+  // Set the Prop2D's position in display coordinates.
+  publicAPI.setDisplayPosition = (XPos, YPos) => {
     model.positionCoordinate.setCoordinateSystem(Coordinate.DISPLAY);
     model.positionCoordinate.setValue(XPos, YPos, 0.0);
-  }; //----------------------------------------------------------------------------
-
+  };
 
-  publicAPI.setWidth = function (w) {
-    var pos = model.position2Coordinate.getValue();
+  //----------------------------------------------------------------------------
+  publicAPI.setWidth = w => {
+    const pos = model.position2Coordinate.getValue();
     model.position2Coordinate.setCoordinateSystemToNormalizedViewport();
     model.position2Coordinate.setValue(w, pos[1]);
-  }; //----------------------------------------------------------------------------
-
+  };
 
-  publicAPI.setHeight = function (w) {
-    var pos = model.position2Coordinate.getValue();
+  //----------------------------------------------------------------------------
+  publicAPI.setHeight = w => {
+    const pos = model.position2Coordinate.getValue();
     model.position2Coordinate.setCoordinateSystemToNormalizedViewport();
     model.position2Coordinate.setValue(pos[0], w);
-  }; //----------------------------------------------------------------------------
-
-
-  publicAPI.getWidth = function () {
-    return model.position2Coordinate.getValue()[0];
-  }; //----------------------------------------------------------------------------
-
-
-  publicAPI.getHeight = function () {
-    return model.position2Coordinate.getValue()[1];
   };
 
-  publicAPI.getMTime = function () {
-    var mt = model.mtime;
+  //----------------------------------------------------------------------------
+  publicAPI.getWidth = () => model.position2Coordinate.getValue()[0];
 
+  //----------------------------------------------------------------------------
+  publicAPI.getHeight = () => model.position2Coordinate.getValue()[1];
+  publicAPI.getMTime = () => {
+    let mt = model.mtime;
     if (model.property !== null) {
-      var time = model.property.getMTime();
+      const time = model.property.getMTime();
       mt = time > mt ? time : mt;
     }
-
     mt = model.positionCoordinate.getMTime() > mt ? model.positionCoordinate.getMTime() : mt;
-    mt = model.positionCoordinate2.getMTime() > mt ? model.positionCoordinate2.getMTime() : mt; // TBD: Handle array of textures here.
+    mt = model.positionCoordinate2.getMTime() > mt ? model.positionCoordinate2.getMTime() : mt;
+
+    // TBD: Handle array of textures here.
 
     return mt;
   };
-
-  publicAPI.getRedrawMTime = function () {
-    var mt = model.mtime;
-
+  publicAPI.getRedrawMTime = () => {
+    let mt = model.mtime;
     if (model.mapper !== null) {
-      var time = model.mapper.getMTime();
+      let time = model.mapper.getMTime();
       mt = time > mt ? time : mt;
-
       if (model.mapper.getInput() !== null) {
         // FIXME !!! getInputAlgorithm / getInput
         model.mapper.getInputAlgorithm().update();
@@ -112,68 +96,70 @@ function vtkActor2D(publicAPI, model) {
         mt = time > mt ? time : mt;
       }
     }
-
     return mt;
   };
-
-  publicAPI.getBounds = function () {
+  publicAPI.getBounds = () => {
     // does our mapper support bounds
     if (typeof publicAPI.getMapper().getBounds === 'function') {
       model.useBounds = true;
       return publicAPI.getMapper().getBounds();
     }
-
     model.useBounds = false;
     return [];
-  }; // Description:
+  };
+
+  // Description:
   // Return the actual vtkCoordinate reference that the mapper should use
   // to position the actor. This is used internally by the mappers and should
   // be overridden in specialized subclasses and otherwise ignored.
+  publicAPI.getActualPositionCoordinate = () => model.positionCoordinate;
+  publicAPI.getActualPositionCoordinate2 = () => model.positionCoordinate2;
+}
 
-
-  publicAPI.getActualPositionCoordinate = function () {
-    return model.positionCoordinate;
-  };
-
-  publicAPI.getActualPositionCoordinate2 = function () {
-    return model.positionCoordinate2;
-  };
-} // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   mapper: null,
   property: null,
   layerNumber: 0,
   positionCoordinate: null,
   positionCoordinate2: null
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 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
   vtkProp.extend(publicAPI, model, initialValues);
   model.positionCoordinate = vtkCoordinate.newInstance();
   model.positionCoordinate.setCoordinateSystemToViewport();
   model.positionCoordinate2 = vtkCoordinate.newInstance();
   model.positionCoordinate2.setCoordinateSystemToNormalizedViewport();
   model.positionCoordinate2.setValue(0.5, 0.5);
-  model.positionCoordinate2.setReferenceCoordinate(model.positionCoordinate); // Build VTK API
+  model.positionCoordinate2.setReferenceCoordinate(model.positionCoordinate);
 
+  // Build VTK API
   macro.set(publicAPI, model, ['property']);
-  macro.setGet(publicAPI, model, ['mapper']); // Object methods
+  macro.setGet(publicAPI, model, ['mapper']);
 
+  // Object methods
   vtkActor2D(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkActor2D');
 
-var newInstance = macro.newInstance(extend, 'vtkActor2D'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 var vtkActor2D$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkActor2D$1 as default, extend, newInstance };

package/Rendering/Core/AnnotatedCubeActor/Presets.js

@@ -1,12 +1,10 @@
-var STYLES = {
+const STYLES = {
   default: {
     defaultStyle: {
       fontStyle: 'bold',
       fontFamily: 'Arial',
       fontColor: 'black',
-      fontSizeScale: function fontSizeScale(res) {
-        return res / 2;
-      },
+      fontSizeScale: res => res / 2,
       faceColor: 'white',
       edgeThickness: 0.1,
       edgeColor: 'black',
@@ -64,23 +62,19 @@ var STYLES = {
     }
   }
 };
-
 function applyDefinitions(definitions, cubeActor) {
   cubeActor.set(definitions);
 }
-
 function applyPreset(name, cubeActor) {
   return applyDefinitions(STYLES[name], cubeActor);
 }
-
 function registerStylePreset(name, definitions) {
   STYLES[name] = definitions;
 }
-
 var AnnotatedCubePresets = {
-  applyDefinitions: applyDefinitions,
-  applyPreset: applyPreset,
-  registerStylePreset: registerStylePreset
+  applyDefinitions,
+  applyPreset,
+  registerStylePreset
 };
 
 export { AnnotatedCubePresets as default };