@kitware/vtk.js 28.10.2 → 28.11.1

package/Rendering/Core/Prop3D.js

@@ -1,78 +1,66 @@
 import { mat4, quat } from 'gl-matrix';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';
 import { A as degreesFromRadians, r as radiansFromDegrees, a as areMatricesEqual } from '../../Common/Core/Math/index.js';
 import vtkProp from './Prop.js';
 
+// ----------------------------------------------------------------------------
 // vtkProp3D methods
 // ----------------------------------------------------------------------------
 
 function vtkProp3D(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkProp3D');
-
-  publicAPI.addPosition = function (deltaXYZ) {
-    model.position = model.position.map(function (value, index) {
-      return value + deltaXYZ[index];
-    });
+  publicAPI.addPosition = deltaXYZ => {
+    model.position = model.position.map((value, index) => value + deltaXYZ[index]);
     publicAPI.modified();
   };
-
-  publicAPI.getOrientationWXYZ = function () {
-    var q = quat.create();
+  publicAPI.getOrientationWXYZ = () => {
+    const q = quat.create();
     mat4.getRotation(q, model.rotation);
-    var oaxis = new Float64Array(3);
-    var w = quat.getAxisAngle(oaxis, q);
+    const oaxis = new Float64Array(3);
+    const w = quat.getAxisAngle(oaxis, q);
     return [degreesFromRadians(w), oaxis[0], oaxis[1], oaxis[2]];
   };
-
-  publicAPI.rotateX = function (val) {
+  publicAPI.rotateX = val => {
     if (val === 0.0) {
       return;
     }
-
     mat4.rotateX(model.rotation, model.rotation, radiansFromDegrees(val));
     publicAPI.modified();
   };
-
-  publicAPI.rotateY = function (val) {
+  publicAPI.rotateY = val => {
     if (val === 0.0) {
       return;
     }
-
     mat4.rotateY(model.rotation, model.rotation, radiansFromDegrees(val));
     publicAPI.modified();
   };
-
-  publicAPI.rotateZ = function (val) {
+  publicAPI.rotateZ = val => {
     if (val === 0.0) {
       return;
     }
-
     mat4.rotateZ(model.rotation, model.rotation, radiansFromDegrees(val));
     publicAPI.modified();
   };
-
-  publicAPI.rotateWXYZ = function (degrees, x, y, z) {
+  publicAPI.rotateWXYZ = (degrees, x, y, z) => {
     if (degrees === 0.0 || x === 0.0 && y === 0.0 && z === 0.0) {
       return;
-    } // convert to radians
-
+    }
 
-    var angle = radiansFromDegrees(degrees);
-    var q = quat.create();
+    // convert to radians
+    const angle = radiansFromDegrees(degrees);
+    const q = quat.create();
     quat.setAxisAngle(q, [x, y, z], angle);
-    var quatMat = new Float64Array(16);
+    const quatMat = new Float64Array(16);
     mat4.fromQuat(quatMat, q);
     mat4.multiply(model.rotation, model.rotation, quatMat);
     publicAPI.modified();
   };
-
-  publicAPI.setOrientation = function (x, y, z) {
+  publicAPI.setOrientation = (x, y, z) => {
     if (x === model.orientation[0] && y === model.orientation[1] && z === model.orientation[2]) {
       return false;
     }
-
     model.orientation = [x, y, z];
     mat4.identity(model.rotation);
     publicAPI.rotateZ(z);
@@ -81,87 +69,61 @@ function vtkProp3D(publicAPI, model) {
     publicAPI.modified();
     return true;
   };
-
-  publicAPI.setUserMatrix = function (matrix) {
+  publicAPI.setUserMatrix = matrix => {
     if (areMatricesEqual(model.userMatrix, matrix)) {
       return false;
     }
-
     mat4.copy(model.userMatrix, matrix);
     publicAPI.modified();
     return true;
   };
-
-  publicAPI.getMatrix = function () {
+  publicAPI.getMatrix = () => {
     publicAPI.computeMatrix();
     return model.matrix;
   };
-
-  publicAPI.computeMatrix = function () {
+  publicAPI.computeMatrix = () => {
     // check whether or not need to rebuild the matrix
     if (publicAPI.getMTime() > model.matrixMTime.getMTime()) {
       mat4.identity(model.matrix);
-
       if (model.userMatrix) {
         mat4.multiply(model.matrix, model.matrix, model.userMatrix);
       }
-
       mat4.translate(model.matrix, model.matrix, model.origin);
       mat4.translate(model.matrix, model.matrix, model.position);
       mat4.multiply(model.matrix, model.matrix, model.rotation);
       mat4.scale(model.matrix, model.matrix, model.scale);
       mat4.translate(model.matrix, model.matrix, [-model.origin[0], -model.origin[1], -model.origin[2]]);
-      mat4.transpose(model.matrix, model.matrix); // check for identity
+      mat4.transpose(model.matrix, model.matrix);
 
+      // check for identity
       model.isIdentity = true;
-
-      for (var i = 0; i < 4; ++i) {
-        for (var j = 0; j < 4; ++j) {
+      for (let i = 0; i < 4; ++i) {
+        for (let j = 0; j < 4; ++j) {
           if ((i === j ? 1.0 : 0.0) !== model.matrix[i + j * 4]) {
             model.isIdentity = false;
           }
         }
       }
-
       model.matrixMTime.modified();
     }
   };
-
-  publicAPI.getCenter = function () {
-    return vtkBoundingBox.getCenter(model.bounds);
-  };
-
-  publicAPI.getLength = function () {
-    return vtkBoundingBox.getLength(model.bounds);
-  };
-
-  publicAPI.getXRange = function () {
-    return vtkBoundingBox.getXRange(model.bounds);
-  };
-
-  publicAPI.getYRange = function () {
-    return vtkBoundingBox.getYRange(model.bounds);
-  };
-
-  publicAPI.getZRange = function () {
-    return vtkBoundingBox.getZRange(model.bounds);
-  };
-
-  publicAPI.getUserMatrix = function () {
-    return model.userMatrix;
-  };
-
+  publicAPI.getCenter = () => vtkBoundingBox.getCenter(model.bounds);
+  publicAPI.getLength = () => vtkBoundingBox.getLength(model.bounds);
+  publicAPI.getXRange = () => vtkBoundingBox.getXRange(model.bounds);
+  publicAPI.getYRange = () => vtkBoundingBox.getYRange(model.bounds);
+  publicAPI.getZRange = () => vtkBoundingBox.getZRange(model.bounds);
+  publicAPI.getUserMatrix = () => model.userMatrix;
   function updateIdentityFlag() {
     publicAPI.computeMatrix();
   }
-
   publicAPI.onModified(updateIdentityFlag);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   origin: [0, 0, 0],
   position: [0, 0, 0],
   orientation: [0, 0, 0],
@@ -173,34 +135,43 @@ var DEFAULT_VALUES = {
   cachedProp3D: null,
   isIdentity: true,
   matrixMTime: 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.matrixMTime = {};
-  macro.obj(model.matrixMTime); // Build VTK API
+  macro.obj(model.matrixMTime);
 
+  // Build VTK API
   macro.get(publicAPI, model, ['bounds', 'isIdentity']);
   macro.getArray(publicAPI, model, ['orientation']);
-  macro.setGetArray(publicAPI, model, ['origin', 'position', 'scale'], 3); // Object internal instance
+  macro.setGetArray(publicAPI, model, ['origin', 'position', 'scale'], 3);
 
+  // Object internal instance
   model.matrix = mat4.identity(new Float64Array(16));
   model.rotation = mat4.identity(new Float64Array(16));
   model.userMatrix = mat4.identity(new Float64Array(16));
   model.transform = null; // FIXME
-  // Object methods
 
+  // Object methods
   vtkProp3D(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkProp3D');
 
-var newInstance = macro.newInstance(extend, 'vtkProp3D'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 var vtkProp3D$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkProp3D$1 as default, extend, newInstance };

package/Rendering/Core/Property/Constants.js

@@ -1,18 +1,18 @@
-var Shading = {
+const Shading = {
   FLAT: 0,
   GOURAUD: 1,
   PHONG: 2
 };
-var Representation = {
+const Representation = {
   POINTS: 0,
   WIREFRAME: 1,
   SURFACE: 2
 };
-var Interpolation = Shading;
+const Interpolation = Shading;
 var PropertyConst = {
-  Shading: Shading,
-  Representation: Representation,
-  Interpolation: Interpolation
+  Shading,
+  Representation,
+  Interpolation
 };
 
 export { Interpolation, Representation, Shading, PropertyConst as default };

package/Rendering/Core/Property.js

@@ -1,27 +1,22 @@
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import PropertyConst from './Property/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 Representation = PropertyConst.Representation,
-    Interpolation = PropertyConst.Interpolation;
-
+const {
+  Representation,
+  Interpolation
+} = PropertyConst;
 function notImplemented(method) {
-  return function () {
-    return macro.vtkErrorMacro("vtkProperty::".concat(method, " - NOT IMPLEMENTED"));
-  };
-} // ----------------------------------------------------------------------------
+  return () => macro.vtkErrorMacro(`vtkProperty::${method} - NOT IMPLEMENTED`);
+}
+
+// ----------------------------------------------------------------------------
 // vtkProperty methods
 // ----------------------------------------------------------------------------
 
-
 function vtkProperty(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkProperty');
-
-  publicAPI.setColor = function (r, g, b) {
+  publicAPI.setColor = (r, g, b) => {
     if (Array.isArray(r)) {
       if (model.color[0] !== r[0] || model.color[1] !== r[1] || model.color[2] !== r[2]) {
         model.color[0] = r[0];
@@ -35,79 +30,46 @@ function vtkProperty(publicAPI, model) {
       model.color[2] = b;
       publicAPI.modified();
     }
-
     publicAPI.setDiffuseColor(model.color);
     publicAPI.setAmbientColor(model.color);
     publicAPI.setSpecularColor(model.color);
   };
-
   publicAPI.computeCompositeColor = notImplemented('ComputeCompositeColor');
-
-  publicAPI.getColor = function () {
+  publicAPI.getColor = () => {
     // Inline computeCompositeColor
-    var norm = 0.0;
-
+    let norm = 0.0;
     if (model.ambient + model.diffuse + model.specular > 0) {
       norm = 1.0 / (model.ambient + model.diffuse + model.specular);
     }
-
-    for (var i = 0; i < 3; i++) {
+    for (let i = 0; i < 3; i++) {
       model.color[i] = norm * (model.ambient * model.ambientColor[i] + model.diffuse * model.diffuseColor[i] + model.specular * model.specularColor[i]);
     }
-
     return [].concat(model.color);
   };
-
-  publicAPI.setSpecularPower = function (specularPower) {
-    var roughness = 1 / Math.max(1.0, specularPower);
-
+  publicAPI.setSpecularPower = specularPower => {
+    const roughness = 1 / Math.max(1.0, specularPower);
     if (model.roughness !== roughness || model.specularPower !== specularPower) {
       model.specularPower = specularPower; // Specular power still needs to be set as long as webgl is using it (otherwise testShaderReplacementsClear fails)
-
       model.roughness = roughness;
       publicAPI.modified();
     }
   };
-
   publicAPI.addShaderVariable = notImplemented('AddShaderVariable');
+  publicAPI.setInterpolationToFlat = () => publicAPI.setInterpolation(Interpolation.FLAT);
+  publicAPI.setInterpolationToGouraud = () => publicAPI.setInterpolation(Interpolation.GOURAUD);
+  publicAPI.setInterpolationToPhong = () => publicAPI.setInterpolation(Interpolation.PHONG);
+  publicAPI.getInterpolationAsString = () => macro.enumToString(Interpolation, model.interpolation);
+  publicAPI.setRepresentationToWireframe = () => publicAPI.setRepresentation(Representation.WIREFRAME);
+  publicAPI.setRepresentationToSurface = () => publicAPI.setRepresentation(Representation.SURFACE);
+  publicAPI.setRepresentationToPoints = () => publicAPI.setRepresentation(Representation.POINTS);
+  publicAPI.getRepresentationAsString = () => macro.enumToString(Representation, model.representation);
+}
 
-  publicAPI.setInterpolationToFlat = function () {
-    return publicAPI.setInterpolation(Interpolation.FLAT);
-  };
-
-  publicAPI.setInterpolationToGouraud = function () {
-    return publicAPI.setInterpolation(Interpolation.GOURAUD);
-  };
-
-  publicAPI.setInterpolationToPhong = function () {
-    return publicAPI.setInterpolation(Interpolation.PHONG);
-  };
-
-  publicAPI.getInterpolationAsString = function () {
-    return macro.enumToString(Interpolation, model.interpolation);
-  };
-
-  publicAPI.setRepresentationToWireframe = function () {
-    return publicAPI.setRepresentation(Representation.WIREFRAME);
-  };
-
-  publicAPI.setRepresentationToSurface = function () {
-    return publicAPI.setRepresentation(Representation.SURFACE);
-  };
-
-  publicAPI.setRepresentationToPoints = function () {
-    return publicAPI.setRepresentation(Representation.POINTS);
-  };
-
-  publicAPI.getRepresentationAsString = function () {
-    return macro.enumToString(Representation, model.representation);
-  };
-} // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   color: [1, 1, 1],
   ambientColor: [1, 1, 1],
   diffuseColor: [1, 1, 1],
@@ -133,24 +95,33 @@ var DEFAULT_VALUES = {
   lighting: true,
   shading: false,
   materialName: null
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 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, ['lighting', 'interpolation', 'ambient', 'diffuse', 'metallic', 'roughness', 'normalStrength', 'emission', 'baseIOR', 'specular', 'specularPower', 'opacity', 'edgeVisibility', 'lineWidth', 'pointSize', 'backfaceCulling', 'frontfaceCulling', 'representation', 'diffuseTexture', 'metallicTexture', 'roughnessTexture', 'normalTexture', 'ambientOcclusionTexture', 'emissionTexture']);
-  macro.setGetArray(publicAPI, model, ['ambientColor', 'specularColor', 'diffuseColor', 'edgeColor'], 3); // Object methods
+  macro.setGetArray(publicAPI, model, ['ambientColor', 'specularColor', 'diffuseColor', 'edgeColor'], 3);
 
+  // Object methods
   vtkProperty(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 
-var newInstance = macro.newInstance(extend, 'vtkProperty'); // ----------------------------------------------------------------------------
+const newInstance = macro.newInstance(extend, 'vtkProperty');
+
+// ----------------------------------------------------------------------------
 
-var vtkProperty$1 = _objectSpread({
-  newInstance: newInstance,
-  extend: extend
-}, PropertyConst);
+var vtkProperty$1 = {
+  newInstance,
+  extend,
+  ...PropertyConst
+};
 
 export { vtkProperty$1 as default, extend, newInstance };

package/Rendering/Core/Property2D/Constants.js

@@ -1,9 +1,9 @@
-var DisplayLocation = {
+const DisplayLocation = {
   BACKGROUND: 0,
   FOREGROUND: 1
 };
 var Constants = {
-  DisplayLocation: DisplayLocation
+  DisplayLocation
 };
 
 export { DisplayLocation, Constants as default };

package/Rendering/Core/Property2D.js

@@ -1,72 +1,63 @@
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import Constants from './Property2D/Constants.js';
 import { Representation } from './Property/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 {
+  DisplayLocation
+} = Constants;
 
-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 DisplayLocation = Constants.DisplayLocation; // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 // vtkProperty2D methods
 // ----------------------------------------------------------------------------
 
 function vtkProperty2D(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkProperty2D');
+  publicAPI.setDisplayLocationToBackground = () => publicAPI.setDisplayLocation(DisplayLocation.BACKGROUND);
+  publicAPI.setDisplayLocationToForeground = () => publicAPI.setDisplayLocation(DisplayLocation.FOREGROUND);
+  publicAPI.setRepresentationToWireframe = () => publicAPI.setRepresentation(Representation.WIREFRAME);
+  publicAPI.setRepresentationToSurface = () => publicAPI.setRepresentation(Representation.SURFACE);
+  publicAPI.setRepresentationToPoints = () => publicAPI.setRepresentation(Representation.POINTS);
+  publicAPI.getRepresentationAsString = () => macro.enumToString(Representation, model.representation);
+}
 
-  publicAPI.setDisplayLocationToBackground = function () {
-    return publicAPI.setDisplayLocation(DisplayLocation.BACKGROUND);
-  };
-
-  publicAPI.setDisplayLocationToForeground = function () {
-    return publicAPI.setDisplayLocation(DisplayLocation.FOREGROUND);
-  };
-
-  publicAPI.setRepresentationToWireframe = function () {
-    return publicAPI.setRepresentation(Representation.WIREFRAME);
-  };
-
-  publicAPI.setRepresentationToSurface = function () {
-    return publicAPI.setRepresentation(Representation.SURFACE);
-  };
-
-  publicAPI.setRepresentationToPoints = function () {
-    return publicAPI.setRepresentation(Representation.POINTS);
-  };
-
-  publicAPI.getRepresentationAsString = function () {
-    return macro.enumToString(Representation, model.representation);
-  };
-} // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
-
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   color: [1, 1, 1],
   opacity: 1,
   pointSize: 1,
   lineWidth: 1,
   representation: Representation.SURFACE,
   displayLocation: DisplayLocation.FOREGROUND
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 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, ['opacity', 'lineWidth', 'pointSize', 'displayLocation', 'representation']);
-  macro.setGetArray(publicAPI, model, ['color'], 3); // Object methods
+  macro.setGetArray(publicAPI, model, ['color'], 3);
 
+  // Object methods
   vtkProperty2D(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkProperty2D'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkProperty2D');
+
+// ----------------------------------------------------------------------------
 
-var vtkProperty2D$1 = _objectSpread({
-  newInstance: newInstance,
-  extend: extend
-}, Constants);
+var vtkProperty2D$1 = {
+  newInstance,
+  extend,
+  ...Constants
+};
 
 export { vtkProperty2D$1 as default, extend, newInstance };