@kitware/vtk.js 25.10.0 → 26.0.0-beta.2

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/PolyLineRepresentation.js

@@ -4,10 +4,10 @@ import vtkActor from '../../Rendering/Core/Actor.js';
 import vtkMapper from '../../Rendering/Core/Mapper.js';
 import { C as areEquals } from '../../Common/Core/Math/index.js';
 import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';
-import vtkPolyData from '../../Common/DataModel/PolyData.js';
 import vtkTubeFilter from '../../Filters/General/TubeFilter.js';
-import vtkWidgetRepresentation from './WidgetRepresentation.js';
+import vtkWidgetRepresentation, { allocateArray, getPixelWorldHeightAtCoord } from './WidgetRepresentation.js';
 import { RenderingTypes } from '../Core/WidgetManager/Constants.js';
+import vtkPolyData from '../../Common/DataModel/PolyData.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; }
 
@@ -24,36 +24,35 @@ function vtkPolyLineRepresentation(publicAPI, model) {
   // --------------------------------------------------------------------------
 
 
-  model.internalPolyData = vtkPolyData.newInstance({
+  var internalPolyData = vtkPolyData.newInstance({
     mtime: 0
   });
-  model.cells = [];
 
-  function allocateSize(size) {
-    var closePolyLine = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+  function allocateSize(polyData, size) {
+    var closePolyLine = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+    var points = null;
 
     if (size < 2) {
-      model.internalPolyData.getPoints().setData(new Float32Array([0, 0, 0]));
-      model.internalPolyData.getLines().setData(new Uint8Array(0));
-    } else if (!model.points || model.points.length !== size * 3) {
-      model.points = new Float32Array(size * 3);
-      model.cells = new Uint8Array(size + 1 + (closePolyLine ? 1 : 0));
-      model.cells[0] = model.cells.length - 1;
-
-      for (var i = 1; i < model.cells.length; i++) {
-        model.cells[i] = i - 1;
+      // FIXME: Why 1 point and not 0 ?
+      points = allocateArray(polyData, 'points', 1).getData();
+      points.set([0, 0, 0]);
+      allocateArray(polyData, 'lines', 0).getData();
+    } else if (!polyData.getPoints() || polyData.getPoints().length !== size * 3) {
+      points = allocateArray(polyData, 'points', size).getData();
+      var cellSize = size + 1 + (closePolyLine ? 1 : 0);
+      var cells = allocateArray(polyData, 'lines', cellSize).getData();
+      cells[0] = cells.length - 1;
+
+      for (var i = 1; i < cells.length; i++) {
+        cells[i] = i - 1;
       }
 
       if (closePolyLine) {
-        model.cells[model.cells.length - 1] = 0;
-        console.log('closePolyLine', closePolyLine, model.cells);
+        cells[cells.length - 1] = 0;
       }
-
-      model.internalPolyData.getPoints().setData(model.points, 3);
-      model.internalPolyData.getLines().setData(model.cells);
     }
 
-    return model.points;
+    return points;
   }
   /**
    * Change the line/tube thickness.
@@ -64,34 +63,39 @@ function vtkPolyLineRepresentation(publicAPI, model) {
   function applyLineThickness(lineThickness) {
     var scaledLineThickness = lineThickness;
 
-    if (publicAPI.getScaleInPixels()) {
-      var center = vtkBoundingBox.getCenter(model.internalPolyData.getBounds());
-      scaledLineThickness *= publicAPI.getPixelWorldHeightAtCoord(center);
+    if (publicAPI.getScaleInPixels() && internalPolyData) {
+      var center = vtkBoundingBox.getCenter(internalPolyData.getBounds());
+      scaledLineThickness *= getPixelWorldHeightAtCoord(center, model.displayScaleParams);
     }
 
-    model.tubes.setRadius(scaledLineThickness);
+    model._pipelines.tubes.filter.setRadius(scaledLineThickness);
   } // --------------------------------------------------------------------------
   // Generic rendering pipeline
   // --------------------------------------------------------------------------
 
 
-  model.mapper = vtkMapper.newInstance();
-  model.actor = vtkActor.newInstance({
-    parentProp: publicAPI
-  });
-  model.tubes = vtkTubeFilter.newInstance({
-    radius: model.lineThickness,
-    numberOfSides: 12,
-    capping: false
-  });
-  model.tubes.setInputConnection(publicAPI.getOutputPort());
-  model.mapper.setInputConnection(model.tubes.getOutputPort()); // model.mapper.setInputConnection(publicAPI.getOutputPort());
-
-  model.actor.setMapper(model.mapper);
-  publicAPI.addActor(model.actor); // --------------------------------------------------------------------------
+  model._pipelines = {
+    tubes: {
+      source: publicAPI,
+      filter: vtkTubeFilter.newInstance({
+        radius: model.lineThickness,
+        numberOfSides: 12,
+        capping: false
+      }),
+      mapper: vtkMapper.newInstance(),
+      actor: vtkActor.newInstance({
+        parentProp: publicAPI
+      })
+    }
+  };
+  vtkWidgetRepresentation.connectPipeline(model._pipelines.tubes);
+  publicAPI.addActor(model._pipelines.tubes.actor); // --------------------------------------------------------------------------
 
   publicAPI.requestData = function (inData, outData) {
-    var state = inData[0]; // Remove invalid and coincident points for tube filter.
+    var _state$getLineThickne, _state$getLineThickne2;
+
+    var state = inData[0];
+    outData[0] = internalPolyData; // Remove invalid and coincident points for tube filter.
 
     var list = publicAPI.getRepresentationStates(state).reduce(function (subStates, subState) {
       var subStateOrigin = subState.getOrigin && subState.getOrigin() ? subState.getOrigin() : null;
@@ -105,7 +109,7 @@ function vtkPolyLineRepresentation(publicAPI, model) {
       return subStates;
     }, []);
     var size = list.length;
-    var points = allocateSize(size, model.closePolyLine && size > 2);
+    var points = allocateSize(outData[0], size, model.closePolyLine && size > 2);
 
     if (points) {
       for (var i = 0; i < size; i++) {
@@ -116,10 +120,9 @@ function vtkPolyLineRepresentation(publicAPI, model) {
       }
     }
 
-    model.internalPolyData.modified();
-    var lineThickness = state.getLineThickness ? state.getLineThickness() : null;
-    applyLineThickness(lineThickness || model.lineThickness);
-    outData[0] = model.internalPolyData;
+    outData[0].modified();
+    var lineThickness = (_state$getLineThickne = (_state$getLineThickne2 = state.getLineThickness) === null || _state$getLineThickne2 === void 0 ? void 0 : _state$getLineThickne2.call(state)) !== null && _state$getLineThickne !== void 0 ? _state$getLineThickne : model.lineThickness;
+    applyLineThickness(lineThickness);
   };
   /**
    * When mousing over the line, if behavior != CONTEXT,
@@ -135,18 +138,18 @@ function vtkPolyLineRepresentation(publicAPI, model) {
   };
 
   publicAPI.updateActorVisibility = function (renderingType, ctxVisible, hVisible) {
+    var _state$getLineThickne3, _state$getLineThickne4;
+
     var state = model.inputData[0]; // Make lines/tubes thicker for picking
 
-    var lineThickness = state.getLineThickness ? state.getLineThickness() : null;
-    lineThickness = lineThickness || model.lineThickness;
+    var lineThickness = (_state$getLineThickne3 = (_state$getLineThickne4 = state.getLineThickness) === null || _state$getLineThickne4 === void 0 ? void 0 : _state$getLineThickne4.call(state)) !== null && _state$getLineThickne3 !== void 0 ? _state$getLineThickne3 : model.lineThickness;
 
     if (renderingType === RenderingTypes.PICKING_BUFFER) {
       lineThickness = Math.max(4, lineThickness);
     }
 
     applyLineThickness(lineThickness);
-    var isValid = model.points && model.points.length > 3;
-    return superClass.updateActorVisibility(renderingType, ctxVisible && isValid, hVisible && isValid);
+    return superClass.updateActorVisibility(renderingType, ctxVisible, hVisible);
   };
 } // ----------------------------------------------------------------------------
 // Object factory

package/Widgets/Representations/RectangleContextRepresentation.js

@@ -3,6 +3,7 @@ import vtkActor from '../../Rendering/Core/Actor.js';
 import vtkContextRepresentation from './ContextRepresentation.js';
 import vtkMapper from '../../Rendering/Core/Mapper.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';
+import { allocateArray } from './WidgetRepresentation.js';
 import { vec3 } from 'gl-matrix';
 
 // vtkRectangleContextRepresentation methods
@@ -14,6 +15,9 @@ function vtkRectangleContextRepresentation(publicAPI, model) {
   // Generic rendering pipeline
   // --------------------------------------------------------------------------
 
+  model.internalPolyData = vtkPolyData.newInstance({
+    mtime: 0
+  });
   model.mapper = vtkMapper.newInstance();
   model.actor = vtkActor.newInstance({
     parentProp: publicAPI
@@ -24,16 +28,6 @@ function vtkRectangleContextRepresentation(publicAPI, model) {
   model.actor.getProperty().setColor(0, 1, 0);
   publicAPI.addActor(model.actor); // --------------------------------------------------------------------------
 
-  publicAPI.setDrawBorder = function (draw) {
-    model.drawBorder = draw;
-  }; // --------------------------------------------------------------------------
-
-
-  publicAPI.setDrawFace = function (draw) {
-    model.drawFace = draw;
-  }; // --------------------------------------------------------------------------
-
-
   publicAPI.setOpacity = function (opacity) {
     model.actor.getProperty().setOpacity(opacity);
   }; // --------------------------------------------------------------------------
@@ -44,18 +38,18 @@ function vtkRectangleContextRepresentation(publicAPI, model) {
       return;
     }
 
-    var list = publicAPI.getRepresentationStates(inData[0]);
+    var list = publicAPI.getRepresentationStates(inData[0]); // FIXME: support list > 1.
+
     var state = list[0];
-    var dataset = vtkPolyData.newInstance();
 
-    if (state.getVisible() && state.getOrigin()) {
+    if (state !== null && state !== void 0 && state.getVisible() && state !== null && state !== void 0 && state.getOrigin()) {
       var point1 = state.getOrigin();
       var point2 = state.getCorner();
       var diagonal = [0, 0, 0];
       vec3.subtract(diagonal, point2, point1);
       var up = state.getUp();
       var upComponent = vec3.dot(diagonal, up);
-      var points = new Float32Array(4 * 3);
+      var points = allocateArray(model.internalPolyData, 'points', 4).getData();
       points[0] = point1[0];
       points[1] = point1[1];
       points[2] = point1[2];
@@ -68,24 +62,24 @@ function vtkRectangleContextRepresentation(publicAPI, model) {
       points[9] = point2[0] - upComponent * up[0];
       points[10] = point2[1] - upComponent * up[1];
       points[11] = point2[2] - upComponent * up[2];
-      dataset.getPoints().setData(points, 3);
 
       if (model.drawFace) {
         var polys = new Uint32Array([4, 0, 1, 2, 3]);
-        dataset.getPolys().setData(polys, 1);
+        model.internalPolyData.getPolys().setData(polys, 1);
       }
 
       if (model.drawBorder) {
         var line = new Uint32Array([5, 0, 1, 2, 3, 0]);
-        dataset.getLines().setData(line, 1);
+        model.internalPolyData.getLines().setData(line, 1);
       }
     } else {
-      dataset.getPoints().setData([], 0);
-      dataset.getPolys().setData([], 0);
-      dataset.getLines().setData([], 0);
+      model.internalPolyData.getPoints().setData([], 0);
+      model.internalPolyData.getPolys().setData([], 0);
+      model.internalPolyData.getLines().setData([], 0);
     }
 
-    outData[0] = dataset;
+    model.internalPolyData.modified();
+    outData[0] = model.internalPolyData;
   };
 
   publicAPI.getSelectedState = function (prop, compositeID) {
@@ -106,6 +100,7 @@ function extend(publicAPI, model) {
   Object.assign(model, DEFAULT_VALUES, initialValues);
   vtkContextRepresentation.extend(publicAPI, model, initialValues);
   macro.setGetArray(publicAPI, model, ['color'], 1);
+  macro.setGet(publicAPI, model, ['drawBorder', 'drawFace']);
   macro.get(publicAPI, model, ['mapper', 'actor']); // Object specific methods
 
   vtkRectangleContextRepresentation(publicAPI, model);

package/Widgets/Representations/SphereContextRepresentation.js

@@ -1,133 +1,54 @@
-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 _defineProperty from '@babel/runtime/helpers/defineProperty';
 import macro from '../../macros.js';
+import vtkSphereSource from '../../Filters/Sources/SphereSource.js';
+import vtkGlyphRepresentation from './GlyphRepresentation.js';
+import { Behavior } from './WidgetRepresentation/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; }
 
 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.setGlyphResolution = macro.chain(publicAPI.setGlyphResolution, model._pipeline.glyph.setThetaResolution, model._pipeline.glyph.setPhiResolution);
 
   publicAPI.setDrawBorder = function (draw) {
-    model.pipelines.circle.glyph.setLines(draw);
+    model._pipeline.glyph.setLines(draw);
   };
 
   publicAPI.setDrawFace = function (draw) {
-    model.pipelines.circle.glyph.setFace(draw);
+    model._pipeline.glyph.setFace(draw);
   };
 
   publicAPI.setOpacity = function (opacity) {
-    model.pipelines.circle.actor.getProperty().setOpacity(opacity);
-  };
-
-  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));
-    });
+    model._pipeline.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]);
-    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));
-    }
+  model._pipeline.actor.getProperty().setOpacity(0.2);
+}
 
-    var typedArray = {
-      points: points.getData(),
-      scale: scale.getData(),
-      color: color.getData()
-    };
+function defaultValues(initialValues) {
+  var _initialValues$glyphR, _initialValues$glyphR2;
 
-    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();
+  return _objectSpread({
+    glyphResolution: 32,
+    drawBorder: false,
+    drawFace: true,
+    behavior: Behavior.CONTEXT,
+    _pipeline: {
+      glyph: vtkSphereSource.newInstance({
+        phiResolution: (_initialValues$glyphR = initialValues.glyphResolution) !== null && _initialValues$glyphR !== void 0 ? _initialValues$glyphR : 32,
+        thetaResolution: (_initialValues$glyphR2 = initialValues.glyphResolution) !== null && _initialValues$glyphR2 !== void 0 ? _initialValues$glyphR2 : 32
+      })
     }
+  }, initialValues);
+} // ----------------------------------------------------------------------------
 
-    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']);
+  vtkGlyphRepresentation.extend(publicAPI, model, defaultValues(initialValues));
+  macro.setGet(publicAPI, model, ['glyphResolution']);
   vtkSphereContextRepresentation(publicAPI, model);
 } // ----------------------------------------------------------------------------