@kitware/vtk.js 28.10.2 → 28.11.1

package/Rendering/Core/InteractorStyle.js

@@ -1,18 +1,19 @@
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkInteractorObserver from './InteractorObserver.js';
 import vtkInteractorStyleConstants from './InteractorStyle/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; }
+const {
+  States
+} = vtkInteractorStyleConstants;
 
-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 States = vtkInteractorStyleConstants.States; // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 // Global methods
 // ----------------------------------------------------------------------------
+
 // Add module-level functions or api that you want to expose statically via
 // the next section...
 
-var stateNames = {
+const stateNames = {
   Rotate: States.IS_ROTATE,
   Pan: States.IS_PAN,
   Spin: States.IS_SPIN,
@@ -20,100 +21,87 @@ var stateNames = {
   CameraPose: States.IS_CAMERA_POSE,
   WindowLevel: States.IS_WINDOW_LEVEL,
   Slice: States.IS_SLICE
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 // vtkInteractorStyle methods
 // ----------------------------------------------------------------------------
 
 function vtkInteractorStyle(publicAPI, model) {
   // Set our className
-  model.classHierarchy.push('vtkInteractorStyle'); // Public API methods
-  // create bunch of Start/EndState methods
-
-  Object.keys(stateNames).forEach(function (key) {
-    macro.event(publicAPI, model, "Start".concat(key, "Event"));
+  model.classHierarchy.push('vtkInteractorStyle');
 
-    publicAPI["start".concat(key)] = function () {
+  // Public API methods
+  // create bunch of Start/EndState methods
+  Object.keys(stateNames).forEach(key => {
+    macro.event(publicAPI, model, `Start${key}Event`);
+    publicAPI[`start${key}`] = () => {
       if (model.state !== States.IS_NONE) {
         return;
       }
-
       model.state = stateNames[key];
-
       model._interactor.requestAnimation(publicAPI);
-
       publicAPI.invokeStartInteractionEvent({
         type: 'StartInteractionEvent'
       });
-      publicAPI["invokeStart".concat(key, "Event")]({
-        type: "Start".concat(key, "Event")
+      publicAPI[`invokeStart${key}Event`]({
+        type: `Start${key}Event`
       });
     };
-
-    macro.event(publicAPI, model, "End".concat(key, "Event"));
-
-    publicAPI["end".concat(key)] = function () {
+    macro.event(publicAPI, model, `End${key}Event`);
+    publicAPI[`end${key}`] = () => {
       if (model.state !== stateNames[key]) {
         return;
       }
-
       model.state = States.IS_NONE;
-
       model._interactor.cancelAnimation(publicAPI);
-
       publicAPI.invokeEndInteractionEvent({
         type: 'EndInteractionEvent'
       });
-      publicAPI["invokeEnd".concat(key, "Event")]({
-        type: "End".concat(key, "Event")
+      publicAPI[`invokeEnd${key}Event`]({
+        type: `End${key}Event`
       });
-
       model._interactor.render();
     };
-  }); //----------------------------------------------------------------------------
-
-  publicAPI.handleKeyPress = function (callData) {
-    var rwi = model._interactor;
-    var ac = null;
+  });
 
+  //----------------------------------------------------------------------------
+  publicAPI.handleKeyPress = callData => {
+    const rwi = model._interactor;
+    let ac = null;
     switch (callData.key) {
       case 'r':
       case 'R':
         callData.pokedRenderer.resetCamera();
         rwi.render();
         break;
-
       case 'w':
       case 'W':
         ac = callData.pokedRenderer.getActors();
-        ac.forEach(function (anActor) {
-          var prop = anActor.getProperty();
-
+        ac.forEach(anActor => {
+          const prop = anActor.getProperty();
           if (prop.setRepresentationToWireframe) {
             prop.setRepresentationToWireframe();
           }
         });
         rwi.render();
         break;
-
       case 's':
       case 'S':
         ac = callData.pokedRenderer.getActors();
-        ac.forEach(function (anActor) {
-          var prop = anActor.getProperty();
-
+        ac.forEach(anActor => {
+          const prop = anActor.getProperty();
           if (prop.setRepresentationToSurface) {
             prop.setRepresentationToSurface();
           }
         });
         rwi.render();
         break;
-
       case 'v':
       case 'V':
         ac = callData.pokedRenderer.getActors();
-        ac.forEach(function (anActor) {
-          var prop = anActor.getProperty();
-
+        ac.forEach(anActor => {
+          const prop = anActor.getProperty();
           if (prop.setRepresentationToPoints) {
             prop.setRepresentationToPoints();
           }
@@ -122,31 +110,41 @@ function vtkInteractorStyle(publicAPI, model) {
         break;
     }
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   state: States.IS_NONE,
   handleObservers: 1,
   autoAdjustCameraClippingRange: 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);
 
-  vtkInteractorObserver.extend(publicAPI, model, initialValues); // Object specific methods
+  // Inheritance
+  vtkInteractorObserver.extend(publicAPI, model, initialValues);
 
+  // Object specific methods
   vtkInteractorStyle(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkInteractorStyle'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkInteractorStyle');
+
+// ----------------------------------------------------------------------------
 
-var vtkInteractorStyle$1 = _objectSpread({
-  newInstance: newInstance,
-  extend: extend
-}, vtkInteractorStyleConstants);
+var vtkInteractorStyle$1 = {
+  newInstance,
+  extend,
+  ...vtkInteractorStyleConstants
+};
 
 export { vtkInteractorStyle$1 as default, extend, newInstance };

package/Rendering/Core/Light.js

@@ -1,91 +1,77 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import { l as normalize, r as radiansFromDegrees } from '../../Common/Core/Math/index.js';
 import { vec3 } from 'gl-matrix';
 
-var LIGHT_TYPES = ['HeadLight', 'CameraLight', 'SceneLight']; // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const LIGHT_TYPES = ['HeadLight', 'CameraLight', 'SceneLight'];
+
+// ----------------------------------------------------------------------------
 // vtkLight methods
 // ----------------------------------------------------------------------------
 
 function vtkLight(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkLight');
-  var tmpVec = new Float64Array(3);
-
-  publicAPI.getTransformedPosition = function () {
+  const tmpVec = new Float64Array(3);
+  publicAPI.getTransformedPosition = () => {
     if (model.transformMatrix) {
       vec3.transformMat4(tmpVec, model.position, model.transformMatrix);
     } else {
       vec3.set(tmpVec, model.position[0], model.position[1], model.position[2]);
     }
-
     return tmpVec;
   };
-
-  publicAPI.getTransformedFocalPoint = function () {
+  publicAPI.getTransformedFocalPoint = () => {
     if (model.transformMatrix) {
       vec3.transformMat4(tmpVec, model.focalPoint, model.transformMatrix);
     } else {
       vec3.set(tmpVec, model.focalPoint[0], model.focalPoint[1], model.focalPoint[2]);
     }
-
     return tmpVec;
   };
-
-  publicAPI.getDirection = function () {
+  publicAPI.getDirection = () => {
     if (model.directionMTime < model.mtime) {
       vec3.sub(model.direction, model.focalPoint, model.position);
       normalize(model.direction);
       model.directionMTime = model.mtime;
     }
-
     return model.direction;
-  }; // Sets the direction from a vec3 instead of a focal point
-
+  };
 
-  publicAPI.setDirection = function (directionVector) {
-    var newFocalPoint = new Float64Array(3);
+  // Sets the direction from a vec3 instead of a focal point
+  publicAPI.setDirection = directionVector => {
+    const newFocalPoint = new Float64Array(3);
     vec3.sub(newFocalPoint, model.position, directionVector);
     model.focalPoint = newFocalPoint;
   };
-
-  publicAPI.setDirectionAngle = function (elevation, azimuth) {
-    var elevationRadians = radiansFromDegrees(elevation);
-    var azimuthRadians = radiansFromDegrees(azimuth);
+  publicAPI.setDirectionAngle = (elevation, azimuth) => {
+    const elevationRadians = radiansFromDegrees(elevation);
+    const azimuthRadians = radiansFromDegrees(azimuth);
     publicAPI.setPosition(Math.cos(elevationRadians) * Math.sin(azimuthRadians), Math.sin(elevationRadians), Math.cos(elevationRadians) * Math.cos(azimuthRadians));
     publicAPI.setFocalPoint(0, 0, 0);
     publicAPI.setPositional(0);
   };
-
-  publicAPI.setLightTypeToHeadLight = function () {
+  publicAPI.setLightTypeToHeadLight = () => {
     publicAPI.setLightType('HeadLight');
   };
-
-  publicAPI.setLightTypeToCameraLight = function () {
+  publicAPI.setLightTypeToCameraLight = () => {
     publicAPI.setLightType('CameraLight');
   };
-
-  publicAPI.setLightTypeToSceneLight = function () {
+  publicAPI.setLightTypeToSceneLight = () => {
     publicAPI.setTransformMatrix(null);
     publicAPI.setLightType('SceneLight');
   };
+  publicAPI.lightTypeIsHeadLight = () => model.lightType === 'HeadLight';
+  publicAPI.lightTypeIsSceneLight = () => model.lightType === 'SceneLight';
+  publicAPI.lightTypeIsCameraLight = () => model.lightType === 'CameraLight';
+}
 
-  publicAPI.lightTypeIsHeadLight = function () {
-    return model.lightType === 'HeadLight';
-  };
-
-  publicAPI.lightTypeIsSceneLight = function () {
-    return model.lightType === 'SceneLight';
-  };
-
-  publicAPI.lightTypeIsCameraLight = function () {
-    return model.lightType === 'CameraLight';
-  };
-} // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   switch: true,
   intensity: 1,
   color: [1, 1, 1],
@@ -101,25 +87,33 @@ var DEFAULT_VALUES = {
   shadowAttenuation: 1,
   direction: [0, 0, 0],
   directionMTime: 0
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 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.setGet(publicAPI, model, ['intensity', 'switch', 'positional', 'exponent', 'coneAngle', 'coneFalloff', 'transformMatrix', 'lightType', 'shadowAttenuation', 'attenuationValues']);
-  macro.setGetArray(publicAPI, model, ['color', 'position', 'focalPoint', 'attenuationValues'], 3); // Object methods
+  macro.setGetArray(publicAPI, model, ['color', 'position', 'focalPoint', 'attenuationValues'], 3);
 
+  // Object methods
   vtkLight(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkLight'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkLight');
+
+// ----------------------------------------------------------------------------
 
 var vtkLight$1 = {
-  newInstance: newInstance,
-  extend: extend,
-  LIGHT_TYPES: LIGHT_TYPES
+  newInstance,
+  extend,
+  LIGHT_TYPES
 };
 
 export { LIGHT_TYPES, vtkLight$1 as default, extend, newInstance };

package/Rendering/Core/Mapper/CoincidentTopologyHelper.js

@@ -1,26 +1,23 @@
 import otherStaticMethods from './Static.js';
-import macro from '../../../macros.js';
+import { m as macro } from '../../../macros2.js';
 
 /* eslint-disable arrow-body-style */
-
 function addCoincidentTopologyMethods(publicAPI, model, nameList) {
-  nameList.forEach(function (item) {
-    publicAPI["get".concat(item.method)] = function () {
-      return model[item.key];
-    };
-
-    publicAPI["set".concat(item.method)] = function (factor, offset) {
+  nameList.forEach(item => {
+    publicAPI[`get${item.method}`] = () => model[item.key];
+    publicAPI[`set${item.method}`] = (factor, offset) => {
       model[item.key] = {
-        factor: factor,
-        offset: offset
+        factor,
+        offset
       };
     };
   });
 }
+const CATEGORIES = ['Polygon', 'Line', 'Point'];
 
-var CATEGORIES = ['Polygon', 'Line', 'Point']; // CoincidentTopology static methods ------------------------------------------
+// CoincidentTopology static methods ------------------------------------------
 
-var staticOffsetModel = {
+const staticOffsetModel = {
   Polygon: {
     factor: 2,
     offset: 0
@@ -34,21 +31,18 @@ var staticOffsetModel = {
     offset: -2
   }
 };
-var staticOffsetAPI = {};
-addCoincidentTopologyMethods(staticOffsetAPI, staticOffsetModel, CATEGORIES.map(function (key) {
-  return {
-    key: key,
-    method: "ResolveCoincidentTopology".concat(key, "OffsetParameters")
-  };
-}));
-
+const staticOffsetAPI = {};
+addCoincidentTopologyMethods(staticOffsetAPI, staticOffsetModel, CATEGORIES.map(key => ({
+  key,
+  method: `ResolveCoincidentTopology${key}OffsetParameters`
+})));
 function implementCoincidentTopologyMethods(publicAPI, model) {
   if (model.resolveCoincidentTopology === undefined) {
     model.resolveCoincidentTopology = false;
   }
+  macro.setGet(publicAPI, model, ['resolveCoincidentTopology']);
 
-  macro.setGet(publicAPI, model, ['resolveCoincidentTopology']); // Relative methods
-
+  // Relative methods
   model.topologyOffset = {
     Polygon: {
       factor: 0,
@@ -62,54 +56,49 @@ function implementCoincidentTopologyMethods(publicAPI, model) {
       factor: 0,
       offset: 0
     }
-  }; // Add Static methods to our instance
+  };
 
-  Object.keys(otherStaticMethods).forEach(function (methodName) {
+  // Add Static methods to our instance
+  Object.keys(otherStaticMethods).forEach(methodName => {
     publicAPI[methodName] = otherStaticMethods[methodName];
   });
-  Object.keys(staticOffsetAPI).forEach(function (methodName) {
+  Object.keys(staticOffsetAPI).forEach(methodName => {
     publicAPI[methodName] = staticOffsetAPI[methodName];
   });
-  addCoincidentTopologyMethods(publicAPI, model.topologyOffset, CATEGORIES.map(function (key) {
-    return {
-      key: key,
-      method: "RelativeCoincidentTopology".concat(key, "OffsetParameters")
-    };
-  }));
-
-  publicAPI.getCoincidentTopologyPolygonOffsetParameters = function () {
-    var globalValue = staticOffsetAPI.getResolveCoincidentTopologyPolygonOffsetParameters();
-    var localValue = publicAPI.getRelativeCoincidentTopologyPolygonOffsetParameters();
+  addCoincidentTopologyMethods(publicAPI, model.topologyOffset, CATEGORIES.map(key => ({
+    key,
+    method: `RelativeCoincidentTopology${key}OffsetParameters`
+  })));
+  publicAPI.getCoincidentTopologyPolygonOffsetParameters = () => {
+    const globalValue = staticOffsetAPI.getResolveCoincidentTopologyPolygonOffsetParameters();
+    const localValue = publicAPI.getRelativeCoincidentTopologyPolygonOffsetParameters();
     return {
       factor: globalValue.factor + localValue.factor,
       offset: globalValue.offset + localValue.offset
     };
   };
-
-  publicAPI.getCoincidentTopologyLineOffsetParameters = function () {
-    var globalValue = staticOffsetAPI.getResolveCoincidentTopologyLineOffsetParameters();
-    var localValue = publicAPI.getRelativeCoincidentTopologyLineOffsetParameters();
+  publicAPI.getCoincidentTopologyLineOffsetParameters = () => {
+    const globalValue = staticOffsetAPI.getResolveCoincidentTopologyLineOffsetParameters();
+    const localValue = publicAPI.getRelativeCoincidentTopologyLineOffsetParameters();
     return {
       factor: globalValue.factor + localValue.factor,
       offset: globalValue.offset + localValue.offset
     };
   };
-
-  publicAPI.getCoincidentTopologyPointOffsetParameter = function () {
-    var globalValue = staticOffsetAPI.getResolveCoincidentTopologyPointOffsetParameters();
-    var localValue = publicAPI.getRelativeCoincidentTopologyPointOffsetParameters();
+  publicAPI.getCoincidentTopologyPointOffsetParameter = () => {
+    const globalValue = staticOffsetAPI.getResolveCoincidentTopologyPointOffsetParameters();
+    const localValue = publicAPI.getRelativeCoincidentTopologyPointOffsetParameters();
     return {
       factor: globalValue.factor + localValue.factor,
       offset: globalValue.offset + localValue.offset
     };
   };
 }
-
 var CoincidentTopologyHelper = {
-  implementCoincidentTopologyMethods: implementCoincidentTopologyMethods,
-  staticOffsetAPI: staticOffsetAPI,
-  otherStaticMethods: otherStaticMethods,
-  CATEGORIES: CATEGORIES
+  implementCoincidentTopologyMethods,
+  staticOffsetAPI,
+  otherStaticMethods,
+  CATEGORIES
 };
 
 export { CATEGORIES, CoincidentTopologyHelper as default };

package/Rendering/Core/Mapper/Constants.js

@@ -1,9 +1,9 @@
-var ColorMode = {
+const ColorMode = {
   DEFAULT: 0,
   MAP_SCALARS: 1,
   DIRECT_SCALARS: 2
 };
-var ScalarMode = {
+const ScalarMode = {
   DEFAULT: 0,
   USE_POINT_DATA: 1,
   USE_CELL_DATA: 2,
@@ -11,14 +11,14 @@ var ScalarMode = {
   USE_CELL_FIELD_DATA: 4,
   USE_FIELD_DATA: 5
 };
-var GetArray = {
+const GetArray = {
   BY_ID: 0,
   BY_NAME: 1
 };
 var Constants = {
-  ColorMode: ColorMode,
-  GetArray: GetArray,
-  ScalarMode: ScalarMode
+  ColorMode,
+  GetArray,
+  ScalarMode
 };
 
 export { ColorMode, GetArray, ScalarMode, Constants as default };

package/Rendering/Core/Mapper/Static.js

@@ -1,6 +1,6 @@
-var resolveCoincidentTopologyPolygonOffsetFaces = 1;
-var resolveCoincidentTopology = 0;
-var RESOLVE_COINCIDENT_TOPOLOGY_MODE = ['VTK_RESOLVE_OFF', 'VTK_RESOLVE_POLYGON_OFFSET'];
+let resolveCoincidentTopologyPolygonOffsetFaces = 1;
+let resolveCoincidentTopology = 0;
+const RESOLVE_COINCIDENT_TOPOLOGY_MODE = ['VTK_RESOLVE_OFF', 'VTK_RESOLVE_POLYGON_OFFSET'];
 function getResolveCoincidentTopologyPolygonOffsetFaces() {
   return resolveCoincidentTopologyPolygonOffsetFaces;
 }
@@ -11,30 +11,33 @@ function getResolveCoincidentTopology() {
   return resolveCoincidentTopology;
 }
 function setResolveCoincidentTopology() {
-  var mode = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+  let mode = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
   resolveCoincidentTopology = mode;
 }
 function setResolveCoincidentTopologyToDefault() {
   setResolveCoincidentTopology(0); // VTK_RESOLVE_OFF
 }
+
 function setResolveCoincidentTopologyToOff() {
   setResolveCoincidentTopology(0); // VTK_RESOLVE_OFF
 }
+
 function setResolveCoincidentTopologyToPolygonOffset() {
   setResolveCoincidentTopology(1); // VTK_RESOLVE_POLYGON_OFFSET
 }
+
 function getResolveCoincidentTopologyAsString() {
   return RESOLVE_COINCIDENT_TOPOLOGY_MODE[resolveCoincidentTopology];
 }
 var otherStaticMethods = {
-  getResolveCoincidentTopologyAsString: getResolveCoincidentTopologyAsString,
-  getResolveCoincidentTopologyPolygonOffsetFaces: getResolveCoincidentTopologyPolygonOffsetFaces,
-  getResolveCoincidentTopology: getResolveCoincidentTopology,
-  setResolveCoincidentTopology: setResolveCoincidentTopology,
-  setResolveCoincidentTopologyPolygonOffsetFaces: setResolveCoincidentTopologyPolygonOffsetFaces,
-  setResolveCoincidentTopologyToDefault: setResolveCoincidentTopologyToDefault,
-  setResolveCoincidentTopologyToOff: setResolveCoincidentTopologyToOff,
-  setResolveCoincidentTopologyToPolygonOffset: setResolveCoincidentTopologyToPolygonOffset
+  getResolveCoincidentTopologyAsString,
+  getResolveCoincidentTopologyPolygonOffsetFaces,
+  getResolveCoincidentTopology,
+  setResolveCoincidentTopology,
+  setResolveCoincidentTopologyPolygonOffsetFaces,
+  setResolveCoincidentTopologyToDefault,
+  setResolveCoincidentTopologyToOff,
+  setResolveCoincidentTopologyToPolygonOffset
 };
 
 export { RESOLVE_COINCIDENT_TOPOLOGY_MODE, otherStaticMethods as default, getResolveCoincidentTopology, getResolveCoincidentTopologyAsString, getResolveCoincidentTopologyPolygonOffsetFaces, setResolveCoincidentTopology, setResolveCoincidentTopologyPolygonOffsetFaces, setResolveCoincidentTopologyToDefault, setResolveCoincidentTopologyToOff, setResolveCoincidentTopologyToPolygonOffset };