@kitware/vtk.js 28.10.2 → 28.11.0

package/Widgets/Representations/ConvexFaceContextRepresentation.js

@@ -1,4 +1,4 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkActor from '../../Rendering/Core/Actor.js';
 import vtkContextRepresentation from './ContextRepresentation.js';
 import vtkMapper from '../../Rendering/Core/Mapper.js';
@@ -7,12 +7,15 @@ import { allocateArray } from './WidgetRepresentation.js';
 import { Behavior } from './WidgetRepresentation/Constants.js';
 import { RenderingTypes } from '../Core/WidgetManager/Constants.js';
 
+// ----------------------------------------------------------------------------
 // vtkPlaneHandleRepresentation methods
 // ----------------------------------------------------------------------------
 
 function vtkConvexFaceContextRepresentation(publicAPI, model) {
   // Set our className
-  model.classHierarchy.push('vtkConvexFaceContextRepresentation'); // --------------------------------------------------------------------------
+  model.classHierarchy.push('vtkConvexFaceContextRepresentation');
+
+  // --------------------------------------------------------------------------
   // Internal polydata dataset
   // --------------------------------------------------------------------------
 
@@ -23,26 +26,23 @@ function vtkConvexFaceContextRepresentation(publicAPI, model) {
   model.cells = new Uint8Array([4, 0, 1, 2, 3]);
   model.internalPolyData.getPoints().setData(model.points, 3);
   model.internalPolyData.getPolys().setData(model.cells);
-
   function allocateSize(polyData, size) {
-    var points = allocateArray(polyData, 'points', size).getData();
-    var oldCellsSize = polyData.getPolys().getNumberOfValues();
-    var cells = allocateArray(polyData, 'polys', size + 1).getData();
-
+    const points = allocateArray(polyData, 'points', size).getData();
+    const oldCellsSize = polyData.getPolys().getNumberOfValues();
+    const cells = allocateArray(polyData, 'polys', size + 1).getData();
     if (oldCellsSize !== cells.length) {
       cells[0] = size;
-
-      for (var i = 0; i < size; i++) {
+      for (let i = 0; i < size; i++) {
         cells[i + 1] = i;
       }
     }
-
     return points;
-  } // --------------------------------------------------------------------------
+  }
+
+  // --------------------------------------------------------------------------
   // Generic rendering pipeline
   // --------------------------------------------------------------------------
 
-
   model.mapper = vtkMapper.newInstance({
     scalarVisibility: false
   });
@@ -52,46 +52,44 @@ function vtkConvexFaceContextRepresentation(publicAPI, model) {
   model.actor.getProperty().setOpacity(model.opacity);
   model.mapper.setInputConnection(publicAPI.getOutputPort());
   model.actor.setMapper(model.mapper);
-  publicAPI.addActor(model.actor); // --------------------------------------------------------------------------
+  publicAPI.addActor(model.actor);
 
-  publicAPI.requestData = function (inData, outData) {
-    var list = publicAPI.getRepresentationStates(inData[0]);
-    var validState = list.filter(function (state) {
-      return state.getOrigin();
-    });
-    var points = allocateSize(model.internalPolyData, validState.length);
+  // --------------------------------------------------------------------------
 
-    for (var i = 0; i < validState.length; i++) {
-      var coords = validState[i].getOrigin();
+  publicAPI.requestData = (inData, outData) => {
+    const list = publicAPI.getRepresentationStates(inData[0]);
+    const validState = list.filter(state => state.getOrigin());
+    const points = allocateSize(model.internalPolyData, validState.length);
+    for (let i = 0; i < validState.length; i++) {
+      const coords = validState[i].getOrigin();
       points[i * 3] = coords[0];
       points[i * 3 + 1] = coords[1];
       points[i * 3 + 2] = coords[2];
     }
-
     model.internalPolyData.modified();
     outData[0] = model.internalPolyData;
-  }; // --------------------------------------------------------------------------
+  };
 
+  // --------------------------------------------------------------------------
 
-  publicAPI.getSelectedState = function (prop, compositeID) {
-    var state = model.inputData[0];
-    var list = publicAPI.getRepresentationStates(state); // Update state orientation based on face
+  publicAPI.getSelectedState = (prop, compositeID) => {
+    const state = model.inputData[0];
+    const list = publicAPI.getRepresentationStates(state);
 
+    // Update state orientation based on face
     if (state.updateFromOriginRightUp) {
       state.updateFromOriginRightUp(list[0].getOrigin(), list[list.length - 1].getOrigin(), list[1].getOrigin());
     }
-
     return state;
-  }; // --------------------------------------------------------------------------
-
+  };
 
-  var superUpdateActorVisibility = publicAPI.updateActorVisibility;
+  // --------------------------------------------------------------------------
 
+  const superUpdateActorVisibility = publicAPI.updateActorVisibility;
   publicAPI.updateActorVisibility = function () {
-    var renderingType = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : RenderingTypes.FRONT_BUFFER;
-    var ctxVisible = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
-    var handleVisible = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
-
+    let renderingType = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : RenderingTypes.FRONT_BUFFER;
+    let ctxVisible = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+    let handleVisible = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
     switch (model.behavior) {
       case Behavior.HANDLE:
         if (renderingType === RenderingTypes.PICKING_BUFFER) {
@@ -99,43 +97,48 @@ function vtkConvexFaceContextRepresentation(publicAPI, model) {
         } else {
           model.actor.getProperty().setOpacity(model.opacity);
         }
-
         break;
-
       case Behavior.CONTEXT:
       default:
         model.actor.getProperty().setOpacity(model.opacity);
         break;
     }
-
     superUpdateActorVisibility(renderingType, ctxVisible, handleVisible);
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   defaultColor: [1, 0, 0.5],
   opacity: 0.2
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
   Object.assign(model, DEFAULT_VALUES, initialValues);
   vtkContextRepresentation.extend(publicAPI, model, initialValues);
   macro.setGetArray(publicAPI, model, ['defaultColor'], 3);
   macro.get(publicAPI, model, ['mapper', 'actor']);
-  macro.setGet(publicAPI, model, ['opacity']); // Object specific methods
+  macro.setGet(publicAPI, model, ['opacity']);
 
+  // Object specific methods
   vtkConvexFaceContextRepresentation(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkConvexFaceContextRepresentation'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkConvexFaceContextRepresentation');
+
+// ----------------------------------------------------------------------------
 
 var vtkConvexFaceContextRepresentation$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkConvexFaceContextRepresentation$1 as default, extend, newInstance };

package/Widgets/Representations/CroppingOutlineRepresentation.js

@@ -1,5 +1,4 @@
-import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkActor from '../../Rendering/Core/Actor.js';
 import vtkContextRepresentation from './ContextRepresentation.js';
 import vtkMapper from '../../Rendering/Core/Mapper.js';
@@ -7,20 +6,25 @@ import vtkPolyData from '../../Common/DataModel/PolyData.js';
 import { origin } from './GlyphRepresentation.js';
 import { allocateArray } from './WidgetRepresentation.js';
 
-var vtkErrorMacro = macro.vtkErrorMacro; // prettier-ignore
+const {
+  vtkErrorMacro
+} = macro;
 
-var OUTLINE_ARRAY = [2, 0, 1, 2, 0, 2, 2, 0, 4, 2, 1, 3, 2, 1, 5, 2, 2, 3, 2, 2, 6, 2, 3, 7, 2, 4, 5, 2, 4, 6, 2, 5, 7, 2, 6, 7]; // ----------------------------------------------------------------------------
+// prettier-ignore
+const OUTLINE_ARRAY = [2, 0, 1, 2, 0, 2, 2, 0, 4, 2, 1, 3, 2, 1, 5, 2, 2, 3, 2, 2, 6, 2, 3, 7, 2, 4, 5, 2, 4, 6, 2, 5, 7, 2, 6, 7];
+
+// ----------------------------------------------------------------------------
 // vtkCroppingOutlineRepresentation methods
 // ----------------------------------------------------------------------------
+
 // Represents a box outline given 8 points as corners.
 // Does not work with an arbitrary set of points. An oriented bounding box
 // algorithm may be implemented in the future.
-
 function vtkCroppingOutlineRepresentation(publicAPI, model) {
-  var _model$actor$getPrope;
-
   // Set our className
-  model.classHierarchy.push('vtkCroppingOutlineRepresentation'); // --------------------------------------------------------------------------
+  model.classHierarchy.push('vtkCroppingOutlineRepresentation');
+
+  // --------------------------------------------------------------------------
   // Internal polydata dataset
   // --------------------------------------------------------------------------
 
@@ -28,7 +32,9 @@ function vtkCroppingOutlineRepresentation(publicAPI, model) {
     mtime: 0
   });
   allocateArray(model.internalPolyData, 'lines', OUTLINE_ARRAY.length).getData().set(OUTLINE_ARRAY);
-  var applyOrigin = origin(publicAPI, model); // --------------------------------------------------------------------------
+  const applyOrigin = origin(publicAPI, model);
+
+  // --------------------------------------------------------------------------
   // Generic rendering pipeline
   // --------------------------------------------------------------------------
 
@@ -38,18 +44,15 @@ function vtkCroppingOutlineRepresentation(publicAPI, model) {
   model.actor = vtkActor.newInstance({
     parentProp: publicAPI
   });
-
-  (_model$actor$getPrope = model.actor.getProperty()).setEdgeColor.apply(_model$actor$getPrope, _toConsumableArray(model.edgeColor));
-
+  model.actor.getProperty().setEdgeColor(...model.edgeColor);
   model.mapper.setInputConnection(publicAPI.getOutputPort());
   model.actor.setMapper(model.mapper);
-  publicAPI.addActor(model.actor); // --------------------------------------------------------------------------
+  publicAPI.addActor(model.actor);
 
-  publicAPI.requestData = function (inData, outData) {
-    var list = publicAPI.getRepresentationStates(inData[0]).filter(function (state) {
-      return state.getOrigin && state.getOrigin();
-    });
+  // --------------------------------------------------------------------------
 
+  publicAPI.requestData = (inData, outData) => {
+    const list = publicAPI.getRepresentationStates(inData[0]).filter(state => state.getOrigin && state.getOrigin());
     if (list.length === 8) {
       applyOrigin(model.internalPolyData, list);
       model.internalPolyData.getPoints().modified();
@@ -59,30 +62,38 @@ function vtkCroppingOutlineRepresentation(publicAPI, model) {
       vtkErrorMacro('CroppingOutlineRepresentation did not get 8 states');
     }
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   edgeColor: [1, 1, 1]
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
   Object.assign(model, DEFAULT_VALUES, initialValues);
   vtkContextRepresentation.extend(publicAPI, model, initialValues);
   macro.setGetArray(publicAPI, model, ['edgeColor'], 3);
-  macro.get(publicAPI, model, ['mapper', 'actor']); // Object specific methods
+  macro.get(publicAPI, model, ['mapper', 'actor']);
 
+  // Object specific methods
   vtkCroppingOutlineRepresentation(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 
-var newInstance = macro.newInstance(extend, 'vtkCroppingOutlineRepresentation'); // ----------------------------------------------------------------------------
+const newInstance = macro.newInstance(extend, 'vtkCroppingOutlineRepresentation');
+
+// ----------------------------------------------------------------------------
 
 var vtkCroppingOutlineRepresentation$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkCroppingOutlineRepresentation$1 as default, extend, newInstance };

package/Widgets/Representations/CubeHandleRepresentation.js

@@ -1,43 +1,46 @@
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkCubeSource from '../../Filters/Sources/CubeSource.js';
 import vtkGlyphRepresentation from './GlyphRepresentation.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; }
+// ----------------------------------------------------------------------------
 // vtkCubeHandleRepresentation methods
 // ----------------------------------------------------------------------------
 
 function vtkCubeHandleRepresentation(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkCubeHandleRepresentation');
-} // ----------------------------------------------------------------------------
-// Object factory
+}
+
 // ----------------------------------------------------------------------------
+// Object factory
 // ----------------------------------------------------------------------------
 
-
+// ----------------------------------------------------------------------------
 function defaultValues(initialValues) {
-  return _objectSpread({
+  return {
     _pipeline: {
       glyph: vtkCubeSource.newInstance()
-    }
-  }, initialValues);
+    },
+    ...initialValues
+  };
 }
-
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  vtkGlyphRepresentation.extend(publicAPI, model, defaultValues(initialValues)); // Object specific methods
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  vtkGlyphRepresentation.extend(publicAPI, model, defaultValues(initialValues));
 
+  // Object specific methods
   vtkCubeHandleRepresentation(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkCubeHandleRepresentation'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkCubeHandleRepresentation');
+
+// ----------------------------------------------------------------------------
 
 var vtkCubeHandleRepresentation$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkCubeHandleRepresentation$1 as default, extend, newInstance };