@kitware/vtk.js 25.9.2 → 26.0.0-beta.1

package/Widgets/Representations/CubeHandleRepresentation.js

@@ -1,123 +1,34 @@
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import macro from '../../macros.js';
-import vtkActor from '../../Rendering/Core/Actor.js';
 import vtkCubeSource from '../../Filters/Sources/CubeSource.js';
-import vtkDataArray from '../../Common/Core/DataArray.js';
-import vtkGlyph3DMapper from '../../Rendering/Core/Glyph3DMapper.js';
-import vtkHandleRepresentation from './HandleRepresentation.js';
-import vtkPolyData from '../../Common/DataModel/PolyData.js';
-import { ScalarMode } from '../../Rendering/Core/Mapper/Constants.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'); // --------------------------------------------------------------------------
-  // Internal polydata dataset
-  // --------------------------------------------------------------------------
-
-  model.internalPolyData = vtkPolyData.newInstance({
-    mtime: 0
-  });
-  model.internalArrays = {
-    points: model.internalPolyData.getPoints(),
-    scale: vtkDataArray.newInstance({
-      name: 'scale',
-      numberOfComponents: 3,
-      empty: true
-    }),
-    color: vtkDataArray.newInstance({
-      name: 'color',
-      numberOfComponents: 1,
-      empty: true
-    })
-  };
-  model.internalPolyData.getPointData().addArray(model.internalArrays.scale);
-  model.internalPolyData.getPointData().addArray(model.internalArrays.color); // --------------------------------------------------------------------------
-  // Generic rendering pipeline
-  // --------------------------------------------------------------------------
-
-  model.mapper = vtkGlyph3DMapper.newInstance({
-    scaleArray: 'scale',
-    colorByArrayName: 'color',
-    scalarMode: ScalarMode.USE_POINT_FIELD_DATA
-  });
-  model.actor = vtkActor.newInstance({
-    parentProp: publicAPI
-  });
-  model.glyph = vtkCubeSource.newInstance();
-  model.mapper.setInputConnection(publicAPI.getOutputPort(), 0);
-  model.mapper.setInputConnection(model.glyph.getOutputPort(), 1);
-  model.actor.setMapper(model.mapper);
-  publicAPI.addActor(model.actor);
-  var superGetRepresentationStates = publicAPI.getRepresentationStates;
-
-  publicAPI.getRepresentationStates = function () {
-    var input = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : model.inputData[0];
-    return superGetRepresentationStates(input).filter(function (state) {
-      var _state$getOrigin, _state$isVisible;
-
-      return ((_state$getOrigin = state.getOrigin) === null || _state$getOrigin === void 0 ? void 0 : _state$getOrigin.call(state)) && ((_state$isVisible = state.isVisible) === null || _state$isVisible === void 0 ? void 0 : _state$isVisible.call(state));
-    });
-  }; // --------------------------------------------------------------------------
-
-
-  publicAPI.requestData = function (inData, outData) {
-    var _model$internalArrays = model.internalArrays,
-        points = _model$internalArrays.points,
-        scale = _model$internalArrays.scale,
-        color = _model$internalArrays.color;
-    var list = publicAPI.getRepresentationStates(inData[0]);
-    var totalCount = list.length;
-
-    if (color.getNumberOfValues() !== totalCount) {
-      // Need to resize dataset
-      points.setData(new Float32Array(3 * totalCount));
-      scale.setData(new Float32Array(3 * totalCount));
-      color.setData(new Float32Array(totalCount));
-    }
-
-    var typedArray = {
-      points: points.getData(),
-      scale: scale.getData(),
-      color: color.getData()
-    };
-
-    for (var i = 0; i < totalCount; i++) {
-      var state = list[i];
-      var isActive = state.getActive();
-      var scaleFactor = isActive ? model.activeScaleFactor : 1;
-      var coord = state.getOrigin();
-
-      if (coord) {
-        typedArray.points[i * 3 + 0] = coord[0];
-        typedArray.points[i * 3 + 1] = coord[1];
-        typedArray.points[i * 3 + 2] = coord[2];
-        typedArray.scale[i] = scaleFactor * (state.getScale1 ? state.getScale1() : model.defaultScale);
-
-        if (publicAPI.getScaleInPixels()) {
-          typedArray.scale[i] *= publicAPI.getPixelWorldHeightAtCoord(coord);
-        }
-
-        typedArray.color[i] = model.useActiveColor && isActive ? model.activeColor : state.getColor();
-      }
-    }
-
-    model.internalPolyData.modified();
-    outData[0] = model.internalPolyData;
-  };
+  model.classHierarchy.push('vtkCubeHandleRepresentation');
 } // ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 
-var DEFAULT_VALUES = {}; // ----------------------------------------------------------------------------
+function defaultValues(initialValues) {
+  return _objectSpread({
+    _pipeline: {
+      glyph: vtkCubeSource.newInstance()
+    }
+  }, initialValues);
+}
 
 function extend(publicAPI, model) {
   var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues);
-  vtkHandleRepresentation.extend(publicAPI, model, initialValues);
-  macro.get(publicAPI, model, ['glyph', 'mapper', 'actor', 'defaultScale']); // Object specific methods
+  vtkGlyphRepresentation.extend(publicAPI, model, defaultValues(initialValues)); // Object specific methods
 
   vtkCubeHandleRepresentation(publicAPI, model);
 } // ----------------------------------------------------------------------------

package/Widgets/Representations/GlyphRepresentation.js

@@ -0,0 +1,320 @@
+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 vtkWidgetRepresentation, { allocateArray, getPixelWorldHeightAtCoord } 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();
+      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 colors = allocateArray(polyData, 'color', states.length, 'Uint8Array', // RGB
+    3).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];
+    }
+  };
+}
+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;
+
+      return ((_state$getOrigin = state.getOrigin) === null || _state$getOrigin === void 0 ? void 0 : _state$getOrigin.call(state)) && ((_state$isVisible = state.isVisible) === null || _state$isVisible === void 0 ? void 0 : _state$isVisible.call(state));
+    });
+  }; // --------------------------------------------------------------------------
+
+
+  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$pipeli, _initialValues$pipeli2, _initialValues$pipeli3, _initialValues$pipeli4, _initialValues$pipeli5, _initialValues$pipeli6, _initialValues$pipeli7, _initialValues$pipeli8, _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$pipeli = (_initialValues$pipeli2 = initialValues.pipeline) === null || _initialValues$pipeli2 === void 0 ? void 0 : _initialValues$pipeli2.source) !== null && _initialValues$pipeli !== void 0 ? _initialValues$pipeli : publicAPI,
+      glyph: (_initialValues$pipeli3 = (_initialValues$pipeli4 = initialValues.pipeline) === null || _initialValues$pipeli4 === void 0 ? void 0 : _initialValues$pipeli4.glyph) !== null && _initialValues$pipeli3 !== void 0 ? _initialValues$pipeli3 : // in case glyph was provided
+      vtkSphereSource.newInstance({
+        phiResolution: 8,
+        thetaResolution: 8
+      }),
+      mapper: (_initialValues$pipeli5 = (_initialValues$pipeli6 = initialValues.pipeline) === null || _initialValues$pipeli6 === void 0 ? void 0 : _initialValues$pipeli6.mapper) !== null && _initialValues$pipeli5 !== void 0 ? _initialValues$pipeli5 : // in case mapper was provided
+      vtkGlyph3DMapper.newInstance({
+        scalarMode: ScalarMode.USE_POINT_FIELD_DATA
+      }),
+      actor: (_initialValues$pipeli7 = (_initialValues$pipeli8 = initialValues.pipeline) === null || _initialValues$pipeli8 === void 0 ? void 0 : _initialValues$pipeli8.actor) !== null && _initialValues$pipeli7 !== void 0 ? _initialValues$pipeli7 : // 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(),
+      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/HandleRepresentation.js

@@ -1,5 +1,4 @@
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import macro from '../../macros.js';
 import vtkWidgetRepresentation from './WidgetRepresentation.js';
 import { Behavior } from './WidgetRepresentation/Constants.js';
 
@@ -18,9 +17,6 @@ function vtkHandleRepresentation(publicAPI, model) {
 
 
 var DEFAULT_VALUES = {
-  activeScaleFactor: 1.2,
-  activeColor: 1,
-  useActiveColor: true,
   behavior: Behavior.HANDLE,
   pickable: true,
   dragable: true,
@@ -33,7 +29,6 @@ function extend(publicAPI, model) {
   var newDefault = _objectSpread(_objectSpread({}, DEFAULT_VALUES), initialValues);
 
   vtkWidgetRepresentation.extend(publicAPI, model, newDefault);
-  macro.setGet(publicAPI, model, ['activeScaleFactor', 'activeColor', 'useActiveColor']);
   vtkHandleRepresentation(publicAPI, model);
 } // ----------------------------------------------------------------------------