@kitware/vtk.js 23.4.2 → 23.4.4

package/Widgets/Representations/GlyphRepresentation.js

@@ -0,0 +1,325 @@
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import macro from '../../macros.js';
+import vtkActor from '../../Rendering/Core/Actor.js';
+import vtkGlyph3DMapper from '../../Rendering/Core/Glyph3DMapper.js';
+import vtkHandleRepresentation from './HandleRepresentation.js';
+import vtkContextRepresentation from './ContextRepresentation.js';
+import vtkSphereSource from '../../Filters/Sources/SphereSource.js';
+import vtkPolyData from '../../Common/DataModel/PolyData.js';
+import { ScalarMode } from '../../Rendering/Core/Mapper/Constants.js';
+import { getPixelWorldHeightAtCoord } from '../Core/WidgetManager.js';
+import vtkWidgetRepresentation, { allocateArray } from './WidgetRepresentation.js';
+import { Behavior } from './WidgetRepresentation/Constants.js';
+import { OrientationModes } from '../../Rendering/Core/Glyph3DMapper/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; }
+// vtkGlyphRepresentation methods
+// ----------------------------------------------------------------------------
+
+function origin(publicAPI, model) {
+  return function (polyData, states) {
+    var points = allocateArray(polyData, 'points', states.length).getData();
+    var j = 0;
+
+    for (var i = 0; i < states.length; ++i) {
+      var coord = states[i].getOrigin(model.scaleInPixels && model.displayScaleParams);
+      points[j++] = coord[0];
+      points[j++] = coord[1];
+      points[j++] = coord[2];
+    }
+  };
+}
+function noPosition(publicAPI, model) {
+  return function (polyData, states) {
+    allocateArray(polyData, 'points', 0);
+  };
+}
+function color3(publicAPI, model) {
+  return function (polyData, states) {
+    model._pipeline.mapper.setColorByArrayName('color');
+
+    var colorArray = allocateArray(polyData, 'color', states.length, 'Uint8Array', // RGBA
+    4);
+    var colors = colorArray.getData();
+    var j = 0;
+
+    for (var i = 0; i < states.length; ++i) {
+      var c3 = states[i].getColor3();
+
+      if (states[i].getActive() && model.useActiveColor) {
+        c3 = model.activeColor;
+      }
+
+      colors[j++] = c3[0];
+      colors[j++] = c3[1];
+      colors[j++] = c3[2];
+      colors[j++] = states[i].getOpacity();
+    }
+
+    colorArray.dataChange();
+  };
+}
+function color(publicAPI, model) {
+  return function (polyData, states) {
+    model._pipeline.mapper.setColorByArrayName('color');
+
+    var colors = allocateArray(polyData, 'color', states.length).getData();
+
+    for (var i = 0; i < states.length; ++i) {
+      var c = states[i].getColor();
+
+      if (states[i].getActive() && model.useActiveColor) {
+        c = model.activeColor;
+      }
+
+      colors[i] = c;
+    }
+  };
+}
+function noColor(publicAPI, model) {
+  return function (polyData, states) {
+    model._pipeline.mapper.setColorByArrayName(null);
+  };
+}
+function scale3(publicAPI, model) {
+  return function (polyData, states) {
+    model._pipeline.mapper.setScaleArray('scale');
+
+    model._pipeline.mapper.setScaleFactor(1);
+
+    model._pipeline.mapper.setScaling(true);
+
+    model._pipeline.mapper.setScaleMode(vtkGlyph3DMapper.ScaleModes.SCALE_BY_COMPONENTS);
+
+    var scales = allocateArray(polyData, 'scale', states.length, 'Float32Array', 3).getData();
+    var j = 0;
+
+    for (var i = 0; i < states.length; ++i) {
+      var _state$getScale, _state$getScale2;
+
+      var state = states[i];
+      var scaleFactor = state.getActive() ? model.activeScaleFactor : 1;
+
+      if (publicAPI.getScaleInPixels()) {
+        scaleFactor *= getPixelWorldHeightAtCoord(state.getOrigin(), model.displayScaleParams);
+      }
+
+      var scale = (_state$getScale = (_state$getScale2 = state.getScale3) === null || _state$getScale2 === void 0 ? void 0 : _state$getScale2.call(state)) !== null && _state$getScale !== void 0 ? _state$getScale : model.defaultScale;
+      scales[j++] = scaleFactor * scale[0];
+      scales[j++] = scaleFactor * scale[1];
+      scales[j++] = scaleFactor * scale[2];
+    }
+  };
+}
+function scale1(publicAPI, model) {
+  return function (polyData, states) {
+    model._pipeline.mapper.setScaleArray('scale');
+
+    model._pipeline.mapper.setScaleFactor(1);
+
+    model._pipeline.mapper.setScaling(true);
+
+    var scales = allocateArray(polyData, 'scale', states.length).getData();
+
+    for (var i = 0; i < states.length; ++i) {
+      var _state$getScale3, _state$getScale4;
+
+      var state = states[i];
+      var scaleFactor = state.getActive() ? model.activeScaleFactor : 1;
+
+      if (publicAPI.getScaleInPixels()) {
+        scaleFactor *= getPixelWorldHeightAtCoord(state.getOrigin(), model.displayScaleParams);
+      }
+
+      var scale = (_state$getScale3 = (_state$getScale4 = state.getScale1) === null || _state$getScale4 === void 0 ? void 0 : _state$getScale4.call(state)) !== null && _state$getScale3 !== void 0 ? _state$getScale3 : model.defaultScale;
+      scales[i] = scaleFactor * scale;
+    }
+  };
+}
+function noScale(publicAPI, model) {
+  return function (polyData, states) {
+    model._pipeline.mapper.setScaleArray(null);
+
+    model._pipeline.mapper.setScaleFactor(model.defaultScale);
+
+    model._pipeline.mapper.setScaling(model.defaultScale !== 1);
+  };
+}
+function direction(publicAPI, model) {
+  return function (polyData, states) {
+    model._pipeline.mapper.setOrientationArray('orientation');
+
+    model._pipeline.mapper.setOrientationMode(OrientationModes.MATRIX);
+
+    var orientation = allocateArray(polyData, 'orientation', states.length, 'Float32Array', 9).getData();
+
+    for (var i = 0; i < states.length; ++i) {
+      var state = states[i];
+      var right = state.getRight ? state.getRight() : [1, 0, 0];
+      var up = state.getUp ? state.getUp() : [0, 1, 0];
+      var dir = state.getDirection ? state.getDirection() : [0, 0, 1];
+      orientation.set(right, 9 * i);
+      orientation.set(up, 9 * i + 3);
+      orientation.set(dir, 9 * i + 6);
+    }
+  };
+}
+function noOrientation(publicAPI, model) {
+  return function (polyData, states) {
+    model._pipeline.mapper.setOrientationArray(null);
+  };
+}
+
+function vtkGlyphRepresentation(publicAPI, model) {
+  // Set our className
+  model.classHierarchy.push('vtkGlyphRepresentation');
+
+  var superClass = _objectSpread({}, publicAPI);
+
+  var internalPolyData = vtkPolyData.newInstance({
+    mtime: 0
+  });
+
+  function hasMixin(states) {
+    for (var _len = arguments.length, requiredMixins = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+      requiredMixins[_key - 1] = arguments[_key];
+    }
+
+    return requiredMixins.every(function (requiredMixin) {
+      var _states$, _states$$;
+
+      return ((_states$ = states[0]) === null || _states$ === void 0 ? void 0 : (_states$$ = _states$["get".concat(macro.capitalize(requiredMixin))]) === null || _states$$ === void 0 ? void 0 : _states$$.call(_states$)) != null;
+    });
+  } // --------------------------------------------------------------------------
+  // Generic rendering pipeline
+  // --------------------------------------------------------------------------
+  // --------------------------------------------------------------------------
+
+
+  publicAPI.getRepresentationStates = function () {
+    var input = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : model.inputData[0];
+    return superClass.getRepresentationStates(input).filter(function (state) {
+      var _state$getOrigin, _state$isVisible, _state$isVisible2;
+
+      return ((_state$getOrigin = state.getOrigin) === null || _state$getOrigin === void 0 ? void 0 : _state$getOrigin.call(state)) && ((_state$isVisible = (_state$isVisible2 = state.isVisible) === null || _state$isVisible2 === void 0 ? void 0 : _state$isVisible2.call(state)) !== null && _state$isVisible !== void 0 ? _state$isVisible : true);
+    });
+  }; // --------------------------------------------------------------------------
+
+
+  publicAPI.getMixins = function (states) {
+    var glyphProperties = {};
+
+    if (hasMixin(states, 'origin')) {
+      glyphProperties.position = model.applyMixin.origin;
+    } else {
+      glyphProperties.position = model.applyMixin.noPosition;
+    }
+
+    if (hasMixin(states, 'color3')) {
+      glyphProperties.color = model.applyMixin.color3;
+    } else if (hasMixin(states, 'color')) {
+      glyphProperties.color = model.applyMixin.color;
+    } else {
+      glyphProperties.color = model.applyMixin.noColor;
+    }
+
+    if (hasMixin(states, 'scale3')) {
+      glyphProperties.scale = model.applyMixin.scale3;
+    } else if (hasMixin(states, 'scale1')) {
+      glyphProperties.scale = model.applyMixin.scale1;
+    } else {
+      glyphProperties.scale = model.applyMixin.noScale;
+    }
+
+    if (hasMixin(states, 'direction')) {
+      glyphProperties.orientation = model.applyMixin.direction;
+    } else {
+      glyphProperties.orientation = model.applyMixin.noOrientation;
+    }
+
+    return glyphProperties;
+  };
+
+  publicAPI.requestData = function (inData, outData) {
+    var states = publicAPI.getRepresentationStates(inData[0]);
+    outData[0] = internalPolyData;
+    var glyphProperties = publicAPI.getMixins(states);
+    Object.values(glyphProperties).forEach(function (property) {
+      return property(internalPolyData, states);
+    });
+    internalPolyData.getPoints().modified();
+    internalPolyData.modified();
+  };
+
+  vtkWidgetRepresentation.connectPipeline(model._pipeline);
+  publicAPI.addActor(model._pipeline.actor);
+} // ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+
+function defaultValues(publicAPI, model, initialValues) {
+  var _initialValues$_pipel, _initialValues$_pipel2, _initialValues$_pipel3, _initialValues$_pipel4, _initialValues$_pipel5, _initialValues$_pipel6, _initialValues$_pipel7, _initialValues$_pipel8, _initialValues$applyM, _initialValues$applyM2, _initialValues$applyM3, _initialValues$applyM4, _initialValues$applyM5, _initialValues$applyM6, _initialValues$applyM7, _initialValues$applyM8, _initialValues$applyM9, _initialValues$applyM10, _initialValues$applyM11, _initialValues$applyM12, _initialValues$applyM13, _initialValues$applyM14, _initialValues$applyM15, _initialValues$applyM16, _initialValues$applyM17, _initialValues$applyM18, _initialValues$applyM19, _initialValues$applyM20;
+
+  return _objectSpread(_objectSpread({
+    defaultScale: 1
+  }, initialValues), {}, {
+    _pipeline: _objectSpread({
+      source: (_initialValues$_pipel = (_initialValues$_pipel2 = initialValues._pipeline) === null || _initialValues$_pipel2 === void 0 ? void 0 : _initialValues$_pipel2.source) !== null && _initialValues$_pipel !== void 0 ? _initialValues$_pipel : publicAPI,
+      glyph: (_initialValues$_pipel3 = (_initialValues$_pipel4 = initialValues._pipeline) === null || _initialValues$_pipel4 === void 0 ? void 0 : _initialValues$_pipel4.glyph) !== null && _initialValues$_pipel3 !== void 0 ? _initialValues$_pipel3 : // in case glyph was provided
+      vtkSphereSource.newInstance({
+        phiResolution: 8,
+        thetaResolution: 8
+      }),
+      mapper: (_initialValues$_pipel5 = (_initialValues$_pipel6 = initialValues._pipeline) === null || _initialValues$_pipel6 === void 0 ? void 0 : _initialValues$_pipel6.mapper) !== null && _initialValues$_pipel5 !== void 0 ? _initialValues$_pipel5 : // in case mapper was provided
+      vtkGlyph3DMapper.newInstance({
+        scalarMode: ScalarMode.USE_POINT_FIELD_DATA
+      }),
+      actor: (_initialValues$_pipel7 = (_initialValues$_pipel8 = initialValues._pipeline) === null || _initialValues$_pipel8 === void 0 ? void 0 : _initialValues$_pipel8.actor) !== null && _initialValues$_pipel7 !== void 0 ? _initialValues$_pipel7 : // in case actor was provided
+      vtkActor.newInstance({
+        parentProp: publicAPI
+      })
+    }, initialValues._pipeline),
+    applyMixin: _objectSpread({
+      origin: (_initialValues$applyM = (_initialValues$applyM2 = initialValues.applyMixin) === null || _initialValues$applyM2 === void 0 ? void 0 : _initialValues$applyM2.origin) !== null && _initialValues$applyM !== void 0 ? _initialValues$applyM : origin(publicAPI, model),
+      noPosition: (_initialValues$applyM3 = (_initialValues$applyM4 = initialValues.applyMixin) === null || _initialValues$applyM4 === void 0 ? void 0 : _initialValues$applyM4.noPosition) !== null && _initialValues$applyM3 !== void 0 ? _initialValues$applyM3 : noPosition(),
+      color3: (_initialValues$applyM5 = (_initialValues$applyM6 = initialValues.applyMixin) === null || _initialValues$applyM6 === void 0 ? void 0 : _initialValues$applyM6.color3) !== null && _initialValues$applyM5 !== void 0 ? _initialValues$applyM5 : color3(publicAPI, model),
+      color: (_initialValues$applyM7 = (_initialValues$applyM8 = initialValues.applyMixin) === null || _initialValues$applyM8 === void 0 ? void 0 : _initialValues$applyM8.color) !== null && _initialValues$applyM7 !== void 0 ? _initialValues$applyM7 : color(publicAPI, model),
+      noColor: (_initialValues$applyM9 = (_initialValues$applyM10 = initialValues.applyMixin) === null || _initialValues$applyM10 === void 0 ? void 0 : _initialValues$applyM10.noColor) !== null && _initialValues$applyM9 !== void 0 ? _initialValues$applyM9 : noColor(publicAPI, model),
+      scale3: (_initialValues$applyM11 = (_initialValues$applyM12 = initialValues.applyMixin) === null || _initialValues$applyM12 === void 0 ? void 0 : _initialValues$applyM12.scale3) !== null && _initialValues$applyM11 !== void 0 ? _initialValues$applyM11 : scale3(publicAPI, model),
+      scale1: (_initialValues$applyM13 = (_initialValues$applyM14 = initialValues.applyMixin) === null || _initialValues$applyM14 === void 0 ? void 0 : _initialValues$applyM14.scale1) !== null && _initialValues$applyM13 !== void 0 ? _initialValues$applyM13 : scale1(publicAPI, model),
+      noScale: (_initialValues$applyM15 = (_initialValues$applyM16 = initialValues.applyMixin) === null || _initialValues$applyM16 === void 0 ? void 0 : _initialValues$applyM16.noScale) !== null && _initialValues$applyM15 !== void 0 ? _initialValues$applyM15 : noScale(publicAPI, model),
+      direction: (_initialValues$applyM17 = (_initialValues$applyM18 = initialValues.applyMixin) === null || _initialValues$applyM18 === void 0 ? void 0 : _initialValues$applyM18.direction) !== null && _initialValues$applyM17 !== void 0 ? _initialValues$applyM17 : direction(publicAPI, model),
+      noOrientation: (_initialValues$applyM19 = (_initialValues$applyM20 = initialValues.applyMixin) === null || _initialValues$applyM20 === void 0 ? void 0 : _initialValues$applyM20.noOrientation) !== null && _initialValues$applyM19 !== void 0 ? _initialValues$applyM19 : noOrientation(publicAPI, model)
+    }, initialValues.applyMixin)
+  });
+} // ----------------------------------------------------------------------------
+
+
+function extend(publicAPI, model) {
+  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+
+  if (initialValues.behavior === Behavior.CONTEXT) {
+    vtkContextRepresentation.extend(publicAPI, model, defaultValues(publicAPI, model, initialValues));
+  } else {
+    vtkHandleRepresentation.extend(publicAPI, model, defaultValues(publicAPI, model, initialValues));
+  }
+
+  macro.setGet(publicAPI, model._pipeline, ['defaultScale']);
+  macro.get(publicAPI, model._pipeline, ['glyph', 'mapper', 'actor']); // Expose the mixin functions to allow overwriting
+
+  macro.setGet(publicAPI, model.applyMixin, Object.keys(model.applyMixin)); // Object specific methods
+
+  vtkGlyphRepresentation(publicAPI, model);
+} // ----------------------------------------------------------------------------
+
+var newInstance = macro.newInstance(extend, 'vtkGlyphRepresentation'); // ----------------------------------------------------------------------------
+
+var vtkGlyphRepresentation$1 = {
+  newInstance: newInstance,
+  extend: extend
+};
+
+export { color, color3, vtkGlyphRepresentation$1 as default, direction, extend, newInstance, noColor, noOrientation, noPosition, noScale, origin, scale1, scale3 };

package/Widgets/Representations/LineHandleRepresentation.js

@@ -0,0 +1,116 @@
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import macro from '../../macros.js';
+import vtkActor from '../../Rendering/Core/Actor.js';
+import vtkGlyphRepresentation from './GlyphRepresentation.js';
+import vtkPixelSpaceCallbackMapper from '../../Rendering/Core/PixelSpaceCallbackMapper.js';
+import vtkCylinderSource from '../../Filters/Sources/CylinderSource.js';
+import { allocateArray } from './WidgetRepresentation.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 INFINITE_RATIO = 100000; // ----------------------------------------------------------------------------
+// vtkLineHandleRepresentation methods
+// ----------------------------------------------------------------------------
+
+function vtkLineHandleRepresentation(publicAPI, model) {
+  // Set our className
+  model.classHierarchy.push('vtkLineHandleRepresentation'); // --------------------------------------------------------------------------
+  // Generic rendering pipeline
+  // --------------------------------------------------------------------------
+
+  /*
+   * displayActors and displayMappers are used to render objects in HTML, allowing objects
+   * to be 'rendered' internally in a VTK scene without being visible on the final output
+   */
+
+  model.displayMapper = vtkPixelSpaceCallbackMapper.newInstance();
+  model.displayActor = vtkActor.newInstance({
+    parentProp: publicAPI
+  }); // model.displayActor.getProperty().setOpacity(0); // don't show in 3D
+
+  model.displayActor.setMapper(model.displayMapper);
+  model.displayMapper.setInputConnection(publicAPI.getOutputPort());
+  publicAPI.addActor(model.displayActor);
+  model.alwaysVisibleActors = [model.displayActor]; // --------------------------------------------------------------------------
+
+  publicAPI.setGlyphResolution = macro.chain(publicAPI.setGlyphResolution, model._pipeline.glyph.setThetaResolution, model._pipeline.glyph.setPhiResolution); // --------------------------------------------------------------------------
+
+  function callbackProxy(coords) {
+    if (model.displayCallback) {
+      var filteredList = [];
+      var states = publicAPI.getRepresentationStates();
+
+      for (var i = 0; i < states.length; i++) {
+        if (states[i].getActive()) {
+          filteredList.push(coords[i]);
+        }
+      }
+
+      if (filteredList.length) {
+        model.displayCallback(filteredList);
+        return;
+      }
+    }
+
+    model.displayCallback();
+  }
+
+  publicAPI.setDisplayCallback = function (callback) {
+    model.displayCallback = callback;
+    model.displayMapper.setCallback(callback ? callbackProxy : null);
+  };
+  /**
+   * Overwrite scale3 to optionally make lines infinite
+   */
+
+
+  var superScale3 = publicAPI.getScale3();
+  publicAPI.setScale3(function (polyData, states) {
+    superScale3(polyData, states);
+
+    if (model.infiniteLine) {
+      var scales = allocateArray(polyData, 'scale', states.length, 'Float32Array', 3).getData();
+
+      for (var i = 0; i < states.length; ++i) {
+        scales[3 * i + 2] = INFINITE_RATIO;
+      }
+    }
+  });
+} // ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+
+function defaultValues(initialValues) {
+  var _initialValues$glyphR;
+
+  return _objectSpread({
+    infiniteLine: true,
+    glyphResolution: 4,
+    _pipeline: {
+      glyph: vtkCylinderSource.newInstance({
+        resolution: (_initialValues$glyphR = initialValues.glyphResolution) !== null && _initialValues$glyphR !== void 0 ? _initialValues$glyphR : 4,
+        direction: [0, 0, 1]
+      })
+    }
+  }, initialValues);
+} // ----------------------------------------------------------------------------
+
+
+function extend(publicAPI, model) {
+  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  vtkGlyphRepresentation.extend(publicAPI, model, defaultValues(initialValues));
+  macro.setGet(publicAPI, model, ['infiniteLine', 'glyphResolution']); // Object specific methods
+
+  vtkLineHandleRepresentation(publicAPI, model);
+} // ----------------------------------------------------------------------------
+
+var newInstance = macro.newInstance(extend, 'vtkLineHandleRepresentation'); // ----------------------------------------------------------------------------
+
+var vtkLineHandleRepresentation$1 = {
+  newInstance: newInstance,
+  extend: extend
+};
+
+export { vtkLineHandleRepresentation$1 as default, extend, newInstance };

package/Widgets/Representations/ResliceCursorContextRepresentation.js

@@ -1,7 +1,7 @@
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import macro from '../../macros.js';
-import { g as subtract, Q as multiplyAccumulate, l as normalize, j as cross } from '../../Common/Core/Math/index.js';
+import { j as subtract, Q as multiplyAccumulate, g as normalize, k as cross } from '../../Common/Core/Math/index.js';
 import vtkActor from '../../Rendering/Core/Actor.js';
 import vtkCylinderSource from '../../Filters/Sources/CylinderSource.js';
 import vtkMapper from '../../Rendering/Core/Mapper.js';

package/Widgets/Representations/WidgetRepresentation.js

@@ -1,7 +1,7 @@
 import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import macro from '../../macros.js';
 import vtkProp from '../../Rendering/Core/Prop.js';
-import { g as subtract, d as dot } from '../../Common/Core/Math/index.js';
+import { j as subtract, d as dot } from '../../Common/Core/Math/index.js';
 import { Behavior } from './WidgetRepresentation/Constants.js';
 import { RenderingTypes } from '../Core/WidgetManager/Constants.js';
 import { CATEGORIES } from '../../Rendering/Core/Mapper/CoincidentTopologyHelper.js';

package/Widgets/Widgets3D/AngleWidget.js

@@ -3,7 +3,7 @@ import vtkAbstractWidgetFactory from '../Core/AbstractWidgetFactory.js';
 import vtkPlanePointManipulator from '../Manipulators/PlaneManipulator.js';
 import vtkPolyLineRepresentation from '../Representations/PolyLineRepresentation.js';
 import vtkSphereHandleRepresentation from '../Representations/SphereHandleRepresentation.js';
-import { g as subtract, R as angleBetweenVectors } from '../../Common/Core/Math/index.js';
+import { j as subtract, R as angleBetweenVectors } from '../../Common/Core/Math/index.js';
 import widgetBehavior from './AngleWidget/behavior.js';
 import generateState from './AngleWidget/state.js';
 import { ViewTypes } from '../Core/WidgetManager/Constants.js';

package/Widgets/Widgets3D/InteractiveOrientationWidget.d.ts

@@ -0,0 +1,40 @@
+import vtkAbstractWidgetFactory from './../Core/AbstractWidgetFactory';
+import { Bounds } from './../../types';
+import { ViewTypes } from './../Core/WidgetManager/Constants';
+
+export interface vtkInteractiveOrientationWidget extends vtkAbstractWidgetFactory {
+  /**
+   * Set the widget bounds
+   * 
+   * @param {Bounds} bounds The widget bounds
+   */
+  setBounds(bounds: Bounds): void;
+
+  /**
+   * @param {ViewTypes} viewType
+   */
+  getRepresentationForViewType(viewType: ViewTypes): unknown;
+}
+
+/**
+ * Method use to decorate a given object (publicAPI+model) with vtkInteractiveOrientationWidget characteristics.
+ *
+ * @param publicAPI object on which methods will be bounds (public)
+ * @param model object on which data structure will be bounds (protected)
+ * @param {object} [initialValues] (default: {})
+ */
+export function extend(publicAPI: object, model: object, initialValues? : Record<string, unknown>): void;
+
+/**
+ * Creates a new instance of vtkInteractiveOrientationWidget
+ * 
+ * @param {object} [initialValues] for pre-setting some of its content
+ */
+export function newInstance(initialValues? : Record<string, unknown>): vtkInteractiveOrientationWidget;
+
+export declare const vtkInteractiveOrientationWidget: {
+	newInstance: typeof newInstance,
+	extend: typeof extend,
+};
+
+export default vtkInteractiveOrientationWidget;

package/Widgets/Widgets3D/LabelWidget/behavior.js

@@ -0,0 +1,157 @@
+import macro from '../../../macros.js';
+
+function widgetBehavior(publicAPI, model) {
+  model.classHierarchy.push('vtkLabelWidgetProp');
+  model._isDragging = false; // --------------------------------------------------------------------------
+  // Public methods
+  // --------------------------------------------------------------------------
+
+  publicAPI.setText = function (text) {
+    model.widgetState.getText().setText(text);
+
+    model._interactor.render();
+  };
+
+  publicAPI.getText = function () {
+    return model.widgetState.getText().getText();
+  }; // --------------------------------------------------------------------------
+  // Display 2D
+  // --------------------------------------------------------------------------
+
+
+  publicAPI.setDisplayCallback = function (callback) {
+    return model.representations[0].setDisplayCallback(callback);
+  }; // --------------------------------------------------------------------------
+  // Interactor events
+  // --------------------------------------------------------------------------
+
+
+  function ignoreKey(e) {
+    return e.altKey || e.controlKey || e.shiftKey;
+  } // --------------------------------------------------------------------------
+  // Left press: Select handle to drag / Place text handle
+  // --------------------------------------------------------------------------
+
+
+  publicAPI.handleLeftButtonPress = function (e) {
+    var _model$activeState$ge, _model$activeState, _model$activeState$ge2;
+
+    if (!model.activeState || !model.activeState.getActive() || !model.pickable || ignoreKey(e)) {
+      return macro.VOID;
+    }
+
+    var manipulator = (_model$activeState$ge = (_model$activeState = model.activeState) === null || _model$activeState === void 0 ? void 0 : (_model$activeState$ge2 = _model$activeState.getManipulator) === null || _model$activeState$ge2 === void 0 ? void 0 : _model$activeState$ge2.call(_model$activeState)) !== null && _model$activeState$ge !== void 0 ? _model$activeState$ge : model.manipulator;
+
+    if (model.activeState === model.widgetState.getMoveHandle() && manipulator) {
+      var worldCoords = manipulator.handleEvent(e, model._apiSpecificRenderWindow); // Commit handle to location
+
+      var moveHandle = model.widgetState.getMoveHandle();
+      moveHandle.setOrigin(worldCoords);
+      model.widgetState.getText().setOrigin(moveHandle.getOrigin());
+      publicAPI.loseFocus();
+    } else if (model.dragable) {
+      model._isDragging = true;
+
+      model._apiSpecificRenderWindow.setCursor('grabbing');
+
+      model._interactor.requestAnimation(publicAPI);
+    }
+
+    publicAPI.invokeStartInteractionEvent();
+    return macro.EVENT_ABORT;
+  }; // --------------------------------------------------------------------------
+  // Left release: Finish drag
+  // --------------------------------------------------------------------------
+
+
+  publicAPI.handleLeftButtonRelease = function () {
+    if (!model.activeState || !model.activeState.getActive() || !model.pickable) {
+      return macro.VOID;
+    }
+
+    if (model._isDragging) {
+      model._apiSpecificRenderWindow.setCursor('pointer');
+
+      model.widgetState.deactivate();
+
+      model._interactor.cancelAnimation(publicAPI);
+
+      model._isDragging = false;
+    } else if (model.activeState !== model.widgetState.getMoveHandle()) {
+      model.widgetState.deactivate();
+    }
+
+    if (model.hasFocus && !model.activeState || model.activeState && !model.activeState.getActive()) {
+      model._widgetManager.enablePicking();
+
+      model._interactor.render();
+    }
+
+    publicAPI.invokeEndInteractionEvent();
+    return macro.EVENT_ABORT;
+  }; // --------------------------------------------------------------------------
+  // Mouse move: Drag selected handle / Handle follow the mouse
+  // --------------------------------------------------------------------------
+
+
+  publicAPI.handleMouseMove = function (callData) {
+    var _model$activeState$ge3, _model$activeState2, _model$activeState2$g;
+
+    var manipulator = (_model$activeState$ge3 = (_model$activeState2 = model.activeState) === null || _model$activeState2 === void 0 ? void 0 : (_model$activeState2$g = _model$activeState2.getManipulator) === null || _model$activeState2$g === void 0 ? void 0 : _model$activeState2$g.call(_model$activeState2)) !== null && _model$activeState$ge3 !== void 0 ? _model$activeState$ge3 : model.manipulator;
+
+    if (manipulator && model.pickable && model.dragable && model.activeState && model.activeState.getActive() && !ignoreKey(callData)) {
+      var worldCoords = manipulator.handleEvent(callData, model._apiSpecificRenderWindow);
+
+      if (worldCoords.length && (model.activeState === model.widgetState.getMoveHandle() || model._isDragging)) {
+        model.activeState.setOrigin(worldCoords);
+        model.widgetState.getText().setOrigin(model.activeState.getOrigin());
+        publicAPI.invokeInteractionEvent();
+        return macro.EVENT_ABORT;
+      }
+    }
+
+    return macro.VOID;
+  }; // --------------------------------------------------------------------------
+  // Focus API
+  // --------------------------------------------------------------------------
+
+
+  publicAPI.reset = function () {
+    model.widgetState.getMoveHandle().setOrigin(null);
+    model.widgetState.getText().setOrigin(null);
+    model.widgetState.getText().setText('');
+  };
+
+  publicAPI.grabFocus = function () {
+    if (!model.hasFocus) {
+      publicAPI.reset();
+      model.activeState = model.widgetState.getMoveHandle();
+      model.widgetState.getMoveHandle().activate();
+
+      model._interactor.requestAnimation(publicAPI);
+
+      publicAPI.invokeStartInteractionEvent();
+    }
+
+    model.hasFocus = true;
+  };
+
+  publicAPI.loseFocus = function () {
+    if (model.hasFocus) {
+      model._interactor.cancelAnimation(publicAPI);
+
+      publicAPI.invokeEndInteractionEvent();
+    }
+
+    model.widgetState.deactivate();
+    model.widgetState.getMoveHandle().deactivate();
+    model.activeState = null;
+    model.hasFocus = false;
+
+    model._widgetManager.enablePicking();
+
+    model._interactor.render();
+  };
+}
+
+export { widgetBehavior as default };