@kitware/vtk.js 23.4.0 → 24.0.0-beta.1

package/Interaction/Widgets/SphereHandleRepresentation.js

@@ -1,370 +0,0 @@
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import macro from '../../macros.js';
-import vtkActor from '../../Rendering/Core/Actor.js';
-import vtkCellPicker from '../../Rendering/Core/CellPicker.js';
-import vtkHandleRepresentation from './HandleRepresentation.js';
-import vtkInteractorObserver from '../../Rendering/Core/InteractorObserver.js';
-import vtkMapper from '../../Rendering/Core/Mapper.js';
-import { f as distance2BetweenPoints, n as norm } from '../../Common/Core/Math/index.js';
-import vtkProperty from '../../Rendering/Core/Property.js';
-import vtkSphereSource from '../../Filters/Sources/SphereSource.js';
-import { InteractionState } from './HandleRepresentation/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; }
-// vtkSphereHandleRepresentation methods
-// ----------------------------------------------------------------------------
-
-function vtkSphereHandleRepresentation(publicAPI, model) {
-  // Set our className
-  model.classHierarchy.push('vtkSphereHandleRepresentation');
-
-  var superClass = _objectSpread({}, publicAPI);
-
-  publicAPI.getActors = function () {
-    return [model.actor];
-  };
-
-  publicAPI.getNestedProps = function () {
-    return publicAPI.getActors();
-  };
-
-  publicAPI.placeWidget = function () {
-    var boundsArray = [];
-
-    if (Array.isArray(arguments.length <= 0 ? undefined : arguments[0])) {
-      boundsArray = arguments.length <= 0 ? undefined : arguments[0];
-    } else {
-      for (var i = 0; i < arguments.length; i++) {
-        boundsArray.push(i < 0 || arguments.length <= i ? undefined : arguments[i]);
-      }
-    }
-
-    if (boundsArray.length !== 6) {
-      return;
-    }
-
-    var newBounds = [];
-    var center = [];
-    publicAPI.adjustBounds(boundsArray, newBounds, center);
-    publicAPI.setWorldPosition(center);
-
-    for (var _i = 0; _i < 6; _i++) {
-      model.initialBounds[_i] = newBounds[_i];
-    }
-
-    model.initialLength = Math.sqrt((newBounds[1] - newBounds[0]) * (newBounds[1] - newBounds[0]) + (newBounds[3] - newBounds[2]) * (newBounds[3] - newBounds[2]) + (newBounds[5] - newBounds[4]) * (newBounds[5] - newBounds[4]));
-  };
-
-  publicAPI.setSphereRadius = function (radius) {
-    model.sphere.setRadius(radius);
-    publicAPI.modified();
-  };
-
-  publicAPI.getSphereRadius = function () {
-    return model.sphere.getRadius();
-  };
-
-  publicAPI.getBounds = function () {
-    var radius = model.sphere.getRadius();
-    var center = model.sphere.getCenter();
-    var bounds = [];
-    bounds[0] = model.placeFactor * (center[0] - radius);
-    bounds[1] = model.placeFactor * (center[0] + radius);
-    bounds[2] = model.placeFactor * (center[1] - radius);
-    bounds[3] = model.placeFactor * (center[1] + radius);
-    bounds[4] = model.placeFactor * (center[2] - radius);
-    bounds[5] = model.placeFactor * (center[2] + radius);
-    return bounds;
-  };
-
-  publicAPI.setWorldPosition = function (position) {
-    model.sphere.setCenter(position);
-    superClass.setWorldPosition(model.sphere.getCenter());
-  };
-
-  publicAPI.setDisplayPosition = function (position) {
-    superClass.setDisplayPosition(position);
-    publicAPI.setWorldPosition(model.worldPosition.getValue());
-  };
-
-  publicAPI.setHandleSize = function (size) {
-    superClass.setHandleSize(size);
-    model.currentHandleSize = model.handleSize;
-  };
-
-  publicAPI.computeInteractionState = function (pos) {
-    model.visibility = 1;
-    var pos3d = [pos[0], pos[1], 0.0];
-    model.cursorPicker.pick(pos3d, model.renderer);
-    var pickedActor = model.cursorPicker.getDataSet();
-
-    if (pickedActor) {
-      model.interactionState = InteractionState.SELECTING;
-    } else {
-      model.interactionState = InteractionState.OUTSIDE;
-
-      if (model.activeRepresentation) {
-        model.visibility = 0;
-      }
-    }
-
-    return model.interactionState;
-  };
-
-  publicAPI.determineConstraintAxis = function (constraint, x) {
-    // Look for trivial cases
-    if (!model.constrained) {
-      return -1;
-    }
-
-    if (constraint >= 0 && constraint < 3) {
-      return constraint;
-    } // Okay, figure out constraint. First see if the choice is
-    // outside the hot spot
-
-
-    if (!model.waitingForMotion) {
-      var pickedPosition = model.cursorPicker.getPickPosition();
-      var d2 = distance2BetweenPoints(pickedPosition, model.startEventPosition);
-      var tol = model.hotSpotSize * model.initialLength;
-
-      if (d2 > tol * tol) {
-        model.waitingForMotion = 0;
-        return model.cursorPicker.getCellId();
-      }
-
-      model.waitingForMotion = 1;
-      model.waitCount = 0;
-      return -1;
-    }
-
-    if (model.waitingForMotion && x) {
-      model.waitingForMotion = 0;
-      var v = [];
-      v[0] = Math.abs(x[0] - model.startEventPosition[0]);
-      v[1] = Math.abs(x[1] - model.startEventPosition[1]);
-      v[2] = Math.abs(x[2] - model.startEventPosition[2]);
-
-      if (v[0] > v[1]) {
-        return v[0] > v[2] ? 0 : 2;
-      }
-
-      return v[1] > v[2] ? 1 : 2;
-    }
-
-    return -1;
-  };
-
-  publicAPI.startComplexWidgetInteraction = function (startEventPos) {
-    // Record the current event position, and the rectilinear wipe position.
-    model.startEventPosition[0] = startEventPos[0];
-    model.startEventPosition[1] = startEventPos[1];
-    model.startEventPosition[2] = 0.0;
-    model.lastEventPosition[0] = startEventPos[0];
-    model.lastEventPosition[1] = startEventPos[1];
-    var pos = [startEventPos[0], startEventPos[1], 0];
-    model.cursorPicker.pick(pos, model.renderer);
-    var pickedActor = model.cursorPicker.getDataSet();
-
-    if (pickedActor) {
-      model.interactionState = InteractionState.SELECTING;
-      model.constraintAxis = publicAPI.determineConstraintAxis(-1, null);
-      model.lastPickPosition = model.cursorPicker.getPickPosition();
-    } else {
-      model.interactionState = InteractionState.OUTSIDE;
-      model.constraintAxis = -1;
-    }
-  };
-
-  publicAPI.displayToWorld = function (eventPos, z) {
-    return vtkInteractorObserver.computeDisplayToWorld(model.renderer, eventPos[0], eventPos[1], z);
-  };
-
-  publicAPI.complexWidgetInteraction = function (eventPos) {
-    var focalPoint = vtkInteractorObserver.computeWorldToDisplay(model.renderer, model.lastPickPosition[0], model.lastPickPosition[1], model.lastPickPosition[2]);
-    var z = focalPoint[2];
-    var prevPickPoint = publicAPI.displayToWorld(model.lastEventPosition, z);
-    var pickPoint = publicAPI.displayToWorld(eventPos, z);
-
-    if (model.interactionState === InteractionState.SELECTING || model.interactionState === InteractionState.TRANSLATING) {
-      if (!model.waitingForMotion || model.waitCount++ > 3) {
-        model.constraintAxis = publicAPI.determineConstraintAxis(model.constraintAxis, pickPoint);
-
-        if (model.interactionState === InteractionState.SELECTING && !model.translationMode) {
-          publicAPI.moveFocus(prevPickPoint, pickPoint);
-        } else {
-          publicAPI.translate(prevPickPoint, pickPoint);
-        }
-      }
-    } else if (model.interactionState === InteractionState.SCALING) {
-      publicAPI.scale(prevPickPoint, pickPoint, eventPos);
-    }
-
-    model.lastEventPosition[0] = eventPos[0];
-    model.lastEventPosition[1] = eventPos[1];
-    publicAPI.modified();
-  };
-
-  publicAPI.moveFocus = function (p1, p2) {
-    // get the motion vector
-    var v = [];
-    v[0] = p2[0] - p1[0];
-    v[1] = p2[1] - p1[1];
-    v[2] = p2[2] - p1[2];
-    var focus = model.sphere.getCenter();
-
-    if (model.constraintAxis >= 0) {
-      focus[model.constraintAxis] += v[model.constraintAxis];
-    } else {
-      focus[0] += v[0];
-      focus[1] += v[1];
-      focus[2] += v[2];
-    }
-
-    publicAPI.setWorldPosition(focus);
-  };
-
-  publicAPI.translate = function (p1, p2) {
-    // get the motion vector
-    var v = [];
-    v[0] = p2[0] - p1[0];
-    v[1] = p2[1] - p1[1];
-    v[2] = p2[2] - p1[2];
-    var pos = model.sphere.getCenter();
-
-    if (model.constraintAxis >= 0) {
-      // move along axis
-      for (var i = 0; i < 3; i++) {
-        if (i !== model.constraintAxis) {
-          v[i] = 0.0;
-        }
-      }
-    }
-
-    var newFocus = [];
-
-    for (var _i2 = 0; _i2 < 3; _i2++) {
-      newFocus[_i2] = pos[_i2] + v[_i2];
-    }
-
-    publicAPI.setWorldPosition(newFocus);
-    var radius = publicAPI.sizeHandlesInPixels(1.0, newFocus);
-    radius *= model.currentHandleSize / model.handleSize;
-    model.sphere.setRadius(radius);
-  };
-
-  publicAPI.sizeBounds = function () {
-    var center = model.sphere.getCenter();
-    var radius = publicAPI.sizeHandlesInPixels(1.0, center);
-    radius *= model.currentHandleSize / model.handleSize;
-    model.sphere.setRadius(radius);
-  };
-
-  publicAPI.scale = function (p1, p2, eventPos) {
-    // get the motion vector
-    var v = [];
-    v[0] = p2[0] - p1[0];
-    v[1] = p2[1] - p1[1];
-    v[2] = p2[2] - p1[2];
-    var bounds = publicAPI.getBounds(); // Compute the scale factor
-
-    var sf = norm(v) / Math.sqrt((bounds[1] - bounds[0]) * (bounds[1] - bounds[0]) + (bounds[3] - bounds[2]) * (bounds[3] - bounds[2]) + (bounds[5] - bounds[4]) * (bounds[5] - bounds[4]));
-
-    if (eventPos[1] > model.lastEventPosition[1]) {
-      sf += 1.0;
-    } else {
-      sf = 1.0 - sf;
-    }
-
-    model.currentHandleSize *= sf;
-    model.currentHandleSize = model.currentHandleSize < 0.001 ? 0.001 : model.currentHandleSize;
-    publicAPI.sizeBounds();
-  };
-
-  publicAPI.highlight = function (highlight) {
-    if (highlight) {
-      publicAPI.applyProperty(model.selectProperty);
-    } else {
-      publicAPI.applyProperty(model.property);
-    }
-  };
-
-  publicAPI.buildRepresentation = function () {
-    if (model.renderer) {
-      if (!model.placed) {
-        model.validPick = 1;
-        model.placed = 1;
-      }
-
-      publicAPI.sizeBounds();
-      model.sphere.update();
-      publicAPI.modified();
-    }
-  };
-
-  publicAPI.applyProperty = function (property) {
-    model.actor.setProperty(property);
-  };
-} // ----------------------------------------------------------------------------
-// Object factory
-// ----------------------------------------------------------------------------
-
-
-var DEFAULT_VALUES = {
-  actor: null,
-  mapper: null,
-  sphere: null,
-  cursorPicker: null,
-  lastPickPosition: [0, 0, 0],
-  lastEventPosition: [0, 0],
-  constraintAxis: -1,
-  translationMode: 1,
-  property: null,
-  selectProperty: null,
-  placeFactor: 1,
-  waitingForMotion: 0,
-  hotSpotSize: 0.05
-}; // ----------------------------------------------------------------------------
-
-function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues); // Inheritance
-
-  vtkHandleRepresentation.extend(publicAPI, model, initialValues);
-  macro.setGet(publicAPI, model, ['glyphResolution', 'defaultScale']);
-  macro.setGet(publicAPI, model, ['translationMode', 'property', 'selectProperty']);
-  macro.get(publicAPI, model, ['actor']);
-  model.sphere = vtkSphereSource.newInstance();
-  model.sphere.setThetaResolution(16);
-  model.sphere.setPhiResolution(8);
-  model.mapper = vtkMapper.newInstance();
-  model.mapper.setInputConnection(model.sphere.getOutputPort());
-  model.actor = vtkActor.newInstance({
-    parentProp: publicAPI
-  });
-  model.actor.setMapper(model.mapper);
-  publicAPI.setHandleSize(15);
-  model.currentHandleSize = model.handleSize;
-  model.cursorPicker = vtkCellPicker.newInstance();
-  model.cursorPicker.setPickFromList(1);
-  model.cursorPicker.initializePickList();
-  model.cursorPicker.addPickList(model.actor);
-  model.property = vtkProperty.newInstance();
-  model.property.setColor(1, 1, 1);
-  model.selectProperty = vtkProperty.newInstance();
-  model.selectProperty.setColor(0, 1, 0);
-  model.actor.setProperty(model.property); // Object methods
-
-  vtkSphereHandleRepresentation(publicAPI, model);
-} // ----------------------------------------------------------------------------
-
-var newInstance = macro.newInstance(extend, 'vtkSphereHandleRepresentation'); // ----------------------------------------------------------------------------
-
-var vtkSphereHandleRepresentation$1 = {
-  newInstance: newInstance,
-  extend: extend
-};
-
-export { vtkSphereHandleRepresentation$1 as default, extend, newInstance };

package/Interaction/Widgets/WidgetRepresentation.js

@@ -1,121 +0,0 @@
-import macro from '../../macros.js';
-import vtkInteractorObserver from '../../Rendering/Core/InteractorObserver.js';
-import vtkProp from '../../Rendering/Core/Prop.js';
-
-var vtkErrorMacro = macro.vtkErrorMacro; // ----------------------------------------------------------------------------
-// vtkWidgetRepresentation methods
-// ----------------------------------------------------------------------------
-
-function vtkWidgetRepresentation(publicAPI, model) {
-  // Set our className
-  model.classHierarchy.push('vtkWidgetRepresentation');
-
-  publicAPI.getPickedActor = function (x, y, z, picker) {
-    picker.pick(x, y, z, model.renderer);
-    return picker.getActors[0];
-  };
-
-  publicAPI.adjustBounds = function (bounds, newBounds, center) {
-    if (bounds.length !== 6) {
-      vtkErrorMacro("vtkWidgetRepresentation::adjustBounds Can't process bounds, not enough values...");
-      return;
-    }
-
-    center[0] = (bounds[0] + bounds[1]) / 2.0;
-    center[1] = (bounds[2] + bounds[3]) / 2.0;
-    center[2] = (bounds[4] + bounds[5]) / 2.0;
-    newBounds[0] = center[0] + model.placeFactor * (bounds[0] - center[0]);
-    newBounds[1] = center[0] + model.placeFactor * (bounds[1] - center[0]);
-    newBounds[2] = center[1] + model.placeFactor * (bounds[2] - center[1]);
-    newBounds[3] = center[1] + model.placeFactor * (bounds[3] - center[1]);
-    newBounds[4] = center[2] + model.placeFactor * (bounds[4] - center[2]);
-    newBounds[5] = center[2] + model.placeFactor * (bounds[5] - center[2]);
-  };
-
-  publicAPI.sizeHandlesInPixels = function (factor, pos) {
-    var renderer = model.renderer;
-
-    if (!model.validPick || !renderer || !renderer.getActiveCamera()) {
-      return model.handleSize * factor * model.initialLength;
-    }
-
-    var focalPoint = vtkInteractorObserver.computeWorldToDisplay(renderer, pos[0], pos[1], pos[2]);
-    var z = focalPoint[2];
-    var x = focalPoint[0] - model.handleSize / 2.0;
-    var y = focalPoint[1] - model.handleSize / 2.0;
-    var lowerLeft = vtkInteractorObserver.computeDisplayToWorld(renderer, x, y, z);
-    x = focalPoint[0] + model.handleSize / 2.0;
-    y = focalPoint[1] + model.handleSize / 2.0;
-    var upperRight = vtkInteractorObserver.computeDisplayToWorld(renderer, x, y, z);
-    var radius = 0.0;
-
-    for (var i = 0; i < 3; i++) {
-      radius += (upperRight[i] - lowerLeft[i]) * (upperRight[i] - lowerLeft[i]);
-    }
-
-    return factor * (Math.sqrt(radius) / 2.0);
-  };
-
-  publicAPI.sizeHandlesRelativeToViewport = function (factor, pos) {
-    var renderer = model.renderer;
-
-    if (!model.validPick || !renderer || !renderer.getActiveCamera()) {
-      return model.handleSize * factor * model.initialLength;
-    }
-
-    var viewport = renderer.getViewport();
-    var view = renderer.getRenderWindow().getViews()[0];
-    var winSize = view.getViewportSize(renderer);
-    var focalPoint = vtkInteractorObserver.computeWorldToDisplay(renderer, pos[0], pos[1], pos[2]);
-    var z = focalPoint[2];
-    var x = winSize[0] * viewport[0];
-    var y = winSize[1] * viewport[1];
-    var windowLowerLeft = vtkInteractorObserver.computeDisplayToWorld(renderer, x, y, z);
-    x = winSize[0] * viewport[2];
-    y = winSize[1] * viewport[3];
-    var windowUpperRight = vtkInteractorObserver.computeDisplayToWorld(renderer, x, y, z);
-    var radius = 0.0;
-
-    for (var i = 0; i < 3; i++) {
-      radius += (windowUpperRight[i] - windowLowerLeft[i]) * (windowUpperRight[i] - windowLowerLeft[i]);
-    }
-
-    return factor * (Math.sqrt(radius) / 2.0);
-  };
-} // ----------------------------------------------------------------------------
-// Object factory
-// ----------------------------------------------------------------------------
-
-
-var DEFAULT_VALUES = {
-  renderer: null,
-  interactionState: 0,
-  startEventPosition: [0.0, 0.0, 0.0],
-  lastEventPosition: [0.0, 0.0, 0.0],
-  placeFactor: 0.5,
-  placed: 0,
-  handleSize: 0.05,
-  validPick: 0,
-  initialBounds: [0.0, 1.0, 0.0, 1.0, 0.0, 1.0],
-  initialLength: 0.0,
-  needToRender: 0
-}; // ----------------------------------------------------------------------------
-
-function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues); // Inheritance
-
-  vtkProp.extend(publicAPI, model, initialValues);
-  macro.setGet(publicAPI, model, ['renderer', 'handleSize', 'placeFactor', 'needToRender', 'interactionState']); // Object methods
-
-  vtkWidgetRepresentation(publicAPI, model);
-} // ----------------------------------------------------------------------------
-
-var newInstance = macro.newInstance(extend, 'vtkWidgetRepresentation'); // ----------------------------------------------------------------------------
-
-var vtkWidgetRepresentation$1 = {
-  newInstance: newInstance,
-  extend: extend
-};
-
-export { vtkWidgetRepresentation$1 as default, extend, newInstance };

package/Widgets/Representations/SphereContextRepresentation.js

@@ -1,131 +0,0 @@
-import vtkDataArray from '../../Common/Core/DataArray.js';
-import vtkPolyData from '../../Common/DataModel/PolyData.js';
-import vtkSphereSource from '../../Filters/Sources/SphereSource.js';
-import vtkActor from '../../Rendering/Core/Actor.js';
-import vtkGlyph3DMapper from '../../Rendering/Core/Glyph3DMapper.js';
-import { ScalarMode } from '../../Rendering/Core/Mapper/Constants.js';
-import vtkContextRepresentation from './ContextRepresentation.js';
-import vtkWidgetRepresentation from './WidgetRepresentation.js';
-import macro from '../../macros.js';
-
-function vtkSphereContextRepresentation(publicAPI, model) {
-  model.classHierarchy.push('vtkSphereContextRepresentation');
-  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);
-  model.pipelines = {
-    circle: {
-      source: publicAPI,
-      glyph: vtkSphereSource.newInstance({
-        phiResolution: model.glyphResolution,
-        thetaResolution: model.glyphResolution
-      }),
-      mapper: vtkGlyph3DMapper.newInstance({
-        scaleArray: 'scale',
-        scaleMode: vtkGlyph3DMapper.ScaleModes.SCALE_BY_MAGNITUDE,
-        colorByArrayName: 'color',
-        scalarMode: ScalarMode.USE_POINT_FIELD_DATA
-      }),
-      actor: vtkActor.newInstance({
-        pickable: false,
-        parentProp: publicAPI
-      })
-    }
-  };
-  model.pipelines.circle.actor.getProperty().setOpacity(0.2);
-  vtkWidgetRepresentation.connectPipeline(model.pipelines.circle);
-  publicAPI.addActor(model.pipelines.circle.actor);
-  publicAPI.setGlyphResolution = macro.chain(publicAPI.setGlyphResolution, function (r) {
-    return model.pipelines.circle.glyph.setResolution(r);
-  });
-
-  publicAPI.setDrawBorder = function (draw) {
-    model.pipelines.circle.glyph.setLines(draw);
-  };
-
-  publicAPI.setDrawFace = function (draw) {
-    model.pipelines.circle.glyph.setFace(draw);
-  };
-
-  publicAPI.setOpacity = function (opacity) {
-    model.pipelines.circle.actor.getProperty().setOpacity(opacity);
-  };
-
-  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]).filter(function (state) {
-      return state.getOrigin && state.getOrigin() && state.isVisible && state.isVisible();
-    });
-    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 += 1) {
-      var state = list[i];
-      var isActive = state.getActive();
-      var scaleFactor = isActive ? model.activeScaleFactor : 1;
-      var coord = state.getOrigin();
-      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);
-      typedArray.color[i] = model.useActiveColor && isActive ? model.activeColor : state.getColor();
-    }
-
-    model.internalPolyData.modified();
-    outData[0] = model.internalPolyData;
-  };
-}
-
-var DEFAULT_VALUES = {
-  glyphResolution: 32,
-  defaultScale: 1,
-  drawBorder: false,
-  drawFace: true
-}; // ----------------------------------------------------------------------------
-
-function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues);
-  vtkContextRepresentation.extend(publicAPI, model, initialValues);
-  macro.setGet(publicAPI, model, ['glyphResolution', 'defaultScale']);
-  macro.get(publicAPI, model, ['glyph', 'mapper', 'actor']);
-  vtkSphereContextRepresentation(publicAPI, model);
-} // ----------------------------------------------------------------------------
-
-var newInstance = macro.newInstance(extend, 'vtkSphereContextRepresentation');
-var vtkSphereContextRepresentation$1 = {
-  newInstance: newInstance,
-  extend: extend
-};
-
-export { vtkSphereContextRepresentation$1 as default, extend, newInstance };