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

package/Widgets/Core/WidgetManager.js

@@ -4,19 +4,14 @@ import _regeneratorRuntime from '@babel/runtime/regenerator';
 import { r as radiansFromDegrees } from '../../Common/Core/Math/index.js';
 import { FieldAssociations } from '../../Common/DataModel/DataSet/Constants.js';
 import macro from '../../macros.js';
-import vtkSelectionNode from '../../Common/DataModel/SelectionNode.js';
 import WidgetManagerConst from './WidgetManager/Constants.js';
-import vtkSVGRepresentation from '../SVG/SVGRepresentation.js';
 import { WIDGET_PRIORITY } from './AbstractWidget/Constants.js';
-import { diff } from './WidgetManager/vdom.js';
 
 var ViewTypes = WidgetManagerConst.ViewTypes,
     RenderingTypes = WidgetManagerConst.RenderingTypes,
     CaptureOn = WidgetManagerConst.CaptureOn;
 var vtkErrorMacro = macro.vtkErrorMacro,
     vtkWarningMacro = macro.vtkWarningMacro;
-var createSvgElement = vtkSVGRepresentation.createSvgElement,
-    createSvgDomElement = vtkSVGRepresentation.createSvgDomElement;
 var viewIdCount = 1; // ----------------------------------------------------------------------------
 // Helper
 // ----------------------------------------------------------------------------
@@ -34,17 +29,9 @@ function extractRenderingComponents(renderer) {
     camera: camera
   };
 } // ----------------------------------------------------------------------------
-
-function createSvgRoot(id) {
-  var svgRoot = createSvgDomElement('svg');
-  svgRoot.setAttribute('version', '1.1');
-  svgRoot.setAttribute('baseProfile', 'full');
-  return svgRoot;
-} // ----------------------------------------------------------------------------
 // vtkWidgetManager methods
 // ----------------------------------------------------------------------------
 
-
 function vtkWidgetManager(publicAPI, model) {
   if (!model.viewId) {
     model.viewId = "view-".concat(viewIdCount++);
@@ -52,13 +39,7 @@ function vtkWidgetManager(publicAPI, model) {
 
   model.classHierarchy.push('vtkWidgetManager');
   var propsWeakMap = new WeakMap();
-  var widgetToSvgMap = new WeakMap();
-  var svgVTrees = new WeakMap();
   var subscriptions = []; // --------------------------------------------------------------------------
-  // Internal variable
-  // --------------------------------------------------------------------------
-
-  model.svgRoot = createSvgRoot(model.viewId); // --------------------------------------------------------------------------
   // API internal
   // --------------------------------------------------------------------------
 
@@ -85,142 +66,6 @@ function vtkWidgetManager(publicAPI, model) {
       viewId: model.viewId
     }));
   } // --------------------------------------------------------------------------
-  // internal SVG API
-  // --------------------------------------------------------------------------
-
-
-  var pendingSvgRenders = new WeakMap();
-
-  function enableSvgLayer() {
-    var container = model._apiSpecificRenderWindow.getReferenceByName('el');
-
-    var canvas = model._apiSpecificRenderWindow.getCanvas();
-
-    container.insertBefore(model.svgRoot, canvas.nextSibling);
-    var containerStyles = window.getComputedStyle(container);
-
-    if (containerStyles.position === 'static') {
-      container.style.position = 'relative';
-    }
-  }
-
-  function disableSvgLayer() {
-    var container = model._apiSpecificRenderWindow.getReferenceByName('el');
-
-    container.removeChild(model.svgRoot);
-  }
-
-  function removeFromSvgLayer(viewWidget) {
-    var group = widgetToSvgMap.get(viewWidget);
-
-    if (group) {
-      widgetToSvgMap.delete(viewWidget);
-      svgVTrees.delete(viewWidget);
-      model.svgRoot.removeChild(group);
-    }
-  }
-
-  function setSvgSize() {
-    var _model$_apiSpecificRe = model._apiSpecificRenderWindow.getViewportSize(model._renderer),
-        _model$_apiSpecificRe2 = _slicedToArray(_model$_apiSpecificRe, 2),
-        cwidth = _model$_apiSpecificRe2[0],
-        cheight = _model$_apiSpecificRe2[1];
-
-    var ratio = window.devicePixelRatio || 1;
-    var bwidth = String(cwidth / ratio);
-    var bheight = String(cheight / ratio);
-    var viewBox = "0 0 ".concat(cwidth, " ").concat(cheight);
-    var origWidth = model.svgRoot.getAttribute('width');
-    var origHeight = model.svgRoot.getAttribute('height');
-    var origViewBox = model.svgRoot.getAttribute('viewBox');
-
-    if (origWidth !== bwidth) {
-      model.svgRoot.setAttribute('width', bwidth);
-    }
-
-    if (origHeight !== bheight) {
-      model.svgRoot.setAttribute('height', bheight);
-    }
-
-    if (origViewBox !== viewBox) {
-      model.svgRoot.setAttribute('viewBox', viewBox);
-    }
-  }
-
-  function setSvgRootStyle() {
-    var viewport = model._renderer.getViewport().map(function (v) {
-      return v * 100;
-    });
-
-    model.svgRoot.setAttribute('style', "position: absolute; left: ".concat(viewport[0], "%; top: ").concat(100 - viewport[3], "%; width: ").concat(viewport[2] - viewport[0], "%; height: ").concat(viewport[3] - viewport[1], "%;"));
-  }
-
-  function updateSvg() {
-    if (model.useSvgLayer) {
-      var _loop = function _loop(i) {
-        var widget = model.widgets[i];
-        var svgReps = widget.getRepresentations().filter(function (r) {
-          return r.isA('vtkSVGRepresentation');
-        });
-        var pendingContent = [];
-
-        if (widget.getVisibility()) {
-          pendingContent = svgReps.filter(function (r) {
-            return r.getVisibility();
-          }).map(function (r) {
-            return r.render();
-          });
-        }
-
-        var promise = Promise.all(pendingContent);
-        var renders = pendingSvgRenders.get(widget) || [];
-        renders.push(promise);
-        pendingSvgRenders.set(widget, renders);
-        promise.then(function (vnodes) {
-          var pendingRenders = pendingSvgRenders.get(widget) || [];
-          var idx = pendingRenders.indexOf(promise);
-
-          if (model.deleted || widget.isDeleted() || idx === -1) {
-            return;
-          } // throw away previous renders
-
-
-          pendingRenders = pendingRenders.slice(idx + 1);
-          pendingSvgRenders.set(widget, pendingRenders);
-          var oldVTree = svgVTrees.get(widget);
-          var newVTree = createSvgElement('g');
-
-          for (var ni = 0; ni < vnodes.length; ni++) {
-            newVTree.appendChild(vnodes[ni]);
-          }
-
-          var widgetGroup = widgetToSvgMap.get(widget);
-          var node = widgetGroup;
-          var patchFns = diff(oldVTree, newVTree);
-
-          for (var j = 0; j < patchFns.length; j++) {
-            node = patchFns[j](node);
-          }
-
-          if (!widgetGroup && node) {
-            // add
-            model.svgRoot.appendChild(node);
-            widgetToSvgMap.set(widget, node);
-          } else if (widgetGroup && !node) {
-            // delete
-            widgetGroup.remove();
-            widgetToSvgMap.delete(widget);
-          }
-
-          svgVTrees.set(widget, newVTree);
-        });
-      };
-
-      for (var i = 0; i < model.widgets.length; i++) {
-        _loop(i);
-      }
-    }
-  } // --------------------------------------------------------------------------
   // Widget scaling
   // --------------------------------------------------------------------------
 
@@ -451,10 +296,10 @@ function vtkWidgetManager(publicAPI, model) {
 
   publicAPI.renderWidgets = function () {
     if (model.pickingEnabled && model.captureOn === CaptureOn.MOUSE_RELEASE) {
-      var _model$_apiSpecificRe3 = model._apiSpecificRenderWindow.getSize(),
-          _model$_apiSpecificRe4 = _slicedToArray(_model$_apiSpecificRe3, 2),
-          w = _model$_apiSpecificRe4[0],
-          h = _model$_apiSpecificRe4[1];
+      var _model$_apiSpecificRe = model._apiSpecificRenderWindow.getSize(),
+          _model$_apiSpecificRe2 = _slicedToArray(_model$_apiSpecificRe, 2),
+          w = _model$_apiSpecificRe2[0],
+          h = _model$_apiSpecificRe2[1];
 
       captureBuffers(0, 0, w, h);
     }
@@ -480,11 +325,6 @@ function vtkWidgetManager(publicAPI, model) {
 
     model._selector.setFieldAssociation(FieldAssociations.FIELD_ASSOCIATION_POINTS);
 
-    subscriptions.push(model._interactor.onRenderEvent(updateSvg));
-    subscriptions.push(renderer.onModified(setSvgRootStyle));
-    setSvgRootStyle();
-    subscriptions.push(model._apiSpecificRenderWindow.onModified(setSvgSize));
-    setSvgSize();
     subscriptions.push(model._apiSpecificRenderWindow.onModified(updateDisplayScaleParams));
     subscriptions.push(model._camera.onModified(updateDisplayScaleParams));
     updateDisplayScaleParams();
@@ -515,10 +355,6 @@ function vtkWidgetManager(publicAPI, model) {
     if (model.pickingEnabled) {
       publicAPI.enablePicking();
     }
-
-    if (model.useSvgLayer) {
-      enableSvgLayer();
-    }
   };
 
   function addWidgetInternal(viewWidget) {
@@ -556,7 +392,6 @@ function vtkWidgetManager(publicAPI, model) {
   function removeWidgetInternal(viewWidget) {
     model._renderer.removeActor(viewWidget);
 
-    removeFromSvgLayer(viewWidget);
     viewWidget.delete();
   }
 
@@ -592,7 +427,7 @@ function vtkWidgetManager(publicAPI, model) {
 
   publicAPI.getSelectedDataForXY = /*#__PURE__*/function () {
     var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(x, y) {
-      var i, widget, hoveredSVGReps, selection, capturedRegion;
+      var capturedRegion;
       return _regeneratorRuntime.wrap(function _callee2$(_context2) {
         while (1) {
           switch (_context2.prev = _context2.next) {
@@ -600,68 +435,37 @@ function vtkWidgetManager(publicAPI, model) {
               model.selections = null;
 
               if (!model.pickingEnabled) {
-                _context2.next = 24;
-                break;
-              }
-
-              i = 0;
-
-            case 3:
-              if (!(i < model.widgets.length)) {
-                _context2.next = 16;
+                _context2.next = 10;
                 break;
               }
 
-              widget = model.widgets[i];
-              hoveredSVGReps = widget.getRepresentations().filter(function (r) {
-                return r.isA('vtkSVGRepresentation') && r.getHover() != null;
-              });
-
-              if (!hoveredSVGReps.length) {
-                _context2.next = 13;
-                break;
-              }
-
-              selection = vtkSelectionNode.newInstance();
-              selection.getProperties().compositeID = hoveredSVGReps[0].getHover();
-              selection.getProperties().widget = widget;
-              selection.getProperties().representation = hoveredSVGReps[0];
-              model.selections = [selection];
-              return _context2.abrupt("return", publicAPI.getSelectedData());
-
-            case 13:
-              ++i;
-              _context2.next = 3;
-              break;
-
-            case 16:
               if (!(!model._capturedBuffers || model.captureOn === CaptureOn.MOUSE_MOVE)) {
-                _context2.next = 19;
+                _context2.next = 5;
                 break;
               }
 
-              _context2.next = 19;
+              _context2.next = 5;
               return captureBuffers(x, y, x, y);
 
-            case 19:
+            case 5:
               // or do we need a pixel that is outside the last capture?
               capturedRegion = model._capturedBuffers.area;
 
               if (!(x < capturedRegion[0] || x > capturedRegion[2] || y < capturedRegion[1] || y > capturedRegion[3])) {
-                _context2.next = 23;
+                _context2.next = 9;
                 break;
               }
 
-              _context2.next = 23;
+              _context2.next = 9;
               return captureBuffers(x, y, x, y);
 
-            case 23:
+            case 9:
               model.selections = model._capturedBuffers.generateSelection(x, y, x, y);
 
-            case 24:
+            case 10:
               return _context2.abrupt("return", publicAPI.getSelectedData());
 
-            case 25:
+            case 11:
             case "end":
               return _context2.stop();
           }
@@ -678,24 +482,7 @@ function vtkWidgetManager(publicAPI, model) {
     vtkWarningMacro('updateSelectionFromXY is deprecated, please use getSelectedDataForXY');
 
     if (model.pickingEnabled) {
-      // First pick SVG representation
-      for (var i = 0; i < model.widgets.length; ++i) {
-        var widget = model.widgets[i];
-        var hoveredSVGReps = widget.getRepresentations().filter(function (r) {
-          return r.isA('vtkSVGRepresentation') && r.getHover() != null;
-        });
-
-        if (hoveredSVGReps.length) {
-          var selection = vtkSelectionNode.newInstance();
-          selection.getProperties().compositeID = hoveredSVGReps[0].getHover();
-          selection.getProperties().widget = widget;
-          selection.getProperties().representation = hoveredSVGReps[0];
-          model.selections = [selection];
-          return;
-        }
-      } // Then pick regular representations.
-
-
+      // Then pick regular representations.
       if (model.captureOn === CaptureOn.MOUSE_MOVE) {
         captureBuffers(x, y, x, y);
       }
@@ -707,10 +494,10 @@ function vtkWidgetManager(publicAPI, model) {
     var pageX = event.pageX,
         pageY = event.pageY;
 
-    var _model$_apiSpecificRe5 = model._apiSpecificRenderWindow.getCanvas().getBoundingClientRect(),
-        top = _model$_apiSpecificRe5.top,
-        left = _model$_apiSpecificRe5.left,
-        height = _model$_apiSpecificRe5.height;
+    var _model$_apiSpecificRe3 = model._apiSpecificRenderWindow.getCanvas().getBoundingClientRect(),
+        top = _model$_apiSpecificRe3.top,
+        left = _model$_apiSpecificRe3.left,
+        height = _model$_apiSpecificRe3.height;
 
     var x = pageX - left;
     var y = height - (pageY - top);
@@ -730,8 +517,7 @@ function vtkWidgetManager(publicAPI, model) {
 
     var _model$selections$0$g2 = model.selections[0].getProperties(),
         widget = _model$selections$0$g2.widget,
-        representation = _model$selections$0$g2.representation; // prop is undefined for SVG representation, widget is undefined for handle
-    // representation.
+        representation = _model$selections$0$g2.representation; // widget is undefined for handle representation.
 
 
     if (model.previousSelectedData && model.previousSelectedData.prop === prop && model.previousSelectedData.widget === widget && model.previousSelectedData.compositeID === compositeID) {
@@ -781,26 +567,6 @@ function vtkWidgetManager(publicAPI, model) {
     return publicAPI.grabFocus(null);
   };
 
-  publicAPI.setUseSvgLayer = function (useSvgLayer) {
-    if (useSvgLayer !== model.useSvgLayer) {
-      model.useSvgLayer = useSvgLayer;
-
-      if (model._renderer) {
-        if (useSvgLayer) {
-          enableSvgLayer(); // force a render so svg widgets can be drawn
-
-          updateSvg();
-        } else {
-          disableSvgLayer();
-        }
-      }
-
-      return true;
-    }
-
-    return false;
-  };
-
   var superDelete = publicAPI.delete;
 
   publicAPI.delete = function () {
@@ -828,7 +594,6 @@ var DEFAULT_VALUES = {
   selections: null,
   previousSelectedData: null,
   widgetInFocus: null,
-  useSvgLayer: true,
   captureOn: CaptureOn.MOUSE_MOVE
 }; // ----------------------------------------------------------------------------
 
@@ -841,7 +606,7 @@ function extend(publicAPI, model) {
     name: 'viewType',
     enum: ViewTypes
   }]);
-  macro.get(publicAPI, model, ['selections', 'widgets', 'viewId', 'pickingEnabled', 'useSvgLayer']); // Object specific methods
+  macro.get(publicAPI, model, ['selections', 'widgets', 'viewId', 'pickingEnabled']); // Object specific methods
 
   vtkWidgetManager(publicAPI, model);
 } // ----------------------------------------------------------------------------

package/Widgets/Representations/ArrowHandleRepresentation.js

@@ -2,21 +2,19 @@ import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import macro from '../../macros.js';
 import vtkActor from '../../Rendering/Core/Actor.js';
 import vtkArrow2DSource from '../../Filters/Sources/Arrow2DSource.js';
-import vtkDataArray from '../../Common/Core/DataArray.js';
-import vtkGlyph3DMapper from '../../Rendering/Core/Glyph3DMapper.js';
-import vtkHandleRepresentation from './HandleRepresentation.js';
+import vtkGlyphRepresentation from './GlyphRepresentation.js';
 import vtkMatrixBuilder from '../../Common/Core/MatrixBuilder.js';
 import vtkPixelSpaceCallbackMapper from '../../Rendering/Core/PixelSpaceCallbackMapper.js';
-import vtkPolyData from '../../Common/DataModel/PolyData.js';
 import vtkConeSource from '../../Filters/Sources/ConeSource.js';
 import vtkSphereSource from '../../Filters/Sources/SphereSource.js';
 import vtkCircleSource from '../../Filters/Sources/CircleSource.js';
 import vtkCubeSource from '../../Filters/Sources/CubeSource.js';
 import vtkViewFinderSource from '../../Filters/Sources/ViewFinderSource.js';
 import Constants from '../Widgets3D/LineWidget/Constants.js';
-import { ScalarMode } from '../../Rendering/Core/Mapper/Constants.js';
 import { mat4, mat3, vec3 } from 'gl-matrix';
 import { RenderingTypes } from '../Core/WidgetManager/Constants.js';
+import { OrientationModes } from '../../Rendering/Core/Glyph3DMapper/Constants.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; }
 
@@ -35,35 +33,11 @@ function vtkArrowHandleRepresentation(publicAPI, model) {
   // Internal polydata dataset
   // --------------------------------------------------------------------------
 
-
-  model.internalPolyData = vtkPolyData.newInstance({
-    mtime: 0
-  });
-  model.internalArrays = {
-    points: model.internalPolyData.getPoints(),
-    scale: vtkDataArray.newInstance({
-      name: 'scale',
-      numberOfComponents: 1,
-      empty: true
-    }),
-    color: vtkDataArray.newInstance({
-      name: 'color',
-      numberOfComponents: 1,
-      empty: true
-    }),
-    direction: vtkDataArray.newInstance({
-      name: 'direction',
-      numberOfComponents: 9,
-      empty: true
-    })
-  };
-  model.internalPolyData.getPointData().addArray(model.internalArrays.scale);
-  model.internalPolyData.getPointData().addArray(model.internalArrays.color);
-  model.internalPolyData.getPointData().addArray(model.internalArrays.direction);
   /**
    * Set the shape for the glyph according to lineWidget state inputs
    */
 
+
   function createGlyph(shape) {
     var _representationToSour;
 
@@ -148,23 +122,12 @@ function vtkArrowHandleRepresentation(publicAPI, model) {
   model.displayActor.setMapper(model.displayMapper);
   model.displayMapper.setInputConnection(publicAPI.getOutputPort());
   publicAPI.addActor(model.displayActor);
-  model.alwaysVisibleActors = [model.displayActor];
-  model.mapper = vtkGlyph3DMapper.newInstance({
-    orientationArray: 'direction',
-    scaleArray: 'scale',
-    colorByArrayName: 'color',
-    scalarMode: ScalarMode.USE_POINT_FIELD_DATA
-  });
-  model.mapper.setOrientationModeToMatrix();
-  model.mapper.setInputConnection(publicAPI.getOutputPort());
-  model.actor = vtkActor.newInstance({
-    parentProp: publicAPI
-  });
-  model.actor.setMapper(model.mapper);
-  publicAPI.addActor(model.actor); // --------------------------------------------------------------------------
+  model.alwaysVisibleActors = [model.displayActor]; // --------------------------------------------------------------------------
 
   publicAPI.setGlyphResolution = macro.chain(publicAPI.setGlyphResolution, function (r) {
-    return model.glyph.setPhiResolution(r) && model.glyph.setThetaResolution(r);
+    return model._pipeline.glyph.setPhiResolution(r);
+  }, function (r) {
+    return model._pipeline.glyph.setThetaResolution(r);
   }); // --------------------------------------------------------------------------
 
   function callbackProxy(coords) {
@@ -255,76 +218,32 @@ function vtkArrowHandleRepresentation(publicAPI, model) {
     return orientationRotation;
   }
 
-  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;
+  function applyOrientation(polyData, states) {
+    model._pipeline.mapper.setOrientationArray('orientation');
 
-      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.mapper.setOrientationMode(OrientationModes.MATRIX);
 
-  publicAPI.requestDataInternal = function (inData, outData) {
-    var _model$internalArrays = model.internalArrays,
-        points = _model$internalArrays.points,
-        scale = _model$internalArrays.scale,
-        color = _model$internalArrays.color,
-        direction = _model$internalArrays.direction;
-    var list = publicAPI.getRepresentationStates(inData[0]);
-    var totalCount = list.length;
-
-    if (color.getNumberOfValues() !== totalCount) {
-      // Need to resize dataset
-      points.setData(new Float32Array(3 * totalCount), 3);
-      scale.setData(new Float32Array(totalCount));
-      color.setData(new Float32Array(totalCount));
-      direction.setData(new Float32Array(9 * totalCount));
-    }
+    var orientation = allocateArray(polyData, 'orientation', states.length, 'Float32Array', 9).getData();
+    var defaultScale3 = [1, 1, 1];
 
-    var typedArray = {
-      points: points.getData(),
-      scale: scale.getData(),
-      color: color.getData(),
-      direction: direction.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];
-        var scale3 = state.getScale3 ? state.getScale3() : [1, 1, 1];
-        scale3 = scale3.map(function (x) {
-          return x === 0 ? 2 * model.defaultScale : 2 * x;
-        });
-        var rotation = getGlyphRotation(scale3);
-        typedArray.direction.set(rotation, 9 * i);
-        typedArray.scale[i] = scaleFactor * (state.getScale1 ? state.getScale1() : model.defaultScale);
-
-        if (publicAPI.getScaleInPixels()) {
-          typedArray.scale[i] *= publicAPI.getPixelWorldHeightAtCoord(coord);
-        }
+    for (var i = 0; i < states.length; ++i) {
+      var _states$i$getScale, _states$i$getScale2, _states$i;
 
-        typedArray.color[i] = model.useActiveColor && isActive ? model.activeColor : state.getColor();
-      }
+      var scale3 = (_states$i$getScale = (_states$i$getScale2 = (_states$i = states[i]).getScale3) === null || _states$i$getScale2 === void 0 ? void 0 : _states$i$getScale2.call(_states$i)) !== null && _states$i$getScale !== void 0 ? _states$i$getScale : defaultScale3;
+      var rotation = getGlyphRotation(scale3);
+      orientation.set(rotation, 9 * i);
     }
+  }
 
-    model.internalPolyData.modified();
-    outData[0] = model.internalPolyData;
-  };
+  publicAPI.setDirection(applyOrientation);
+  publicAPI.setNoOrientation(applyOrientation);
 
   publicAPI.requestData = function (inData, outData) {
     var _publicAPI$getReprese;
 
+    // FIXME: shape should NOT be mixin, but a representation property.
     var shape = (_publicAPI$getReprese = publicAPI.getRepresentationStates(inData[0])[0]) === null || _publicAPI$getReprese === void 0 ? void 0 : _publicAPI$getReprese.getShape();
-    var shouldCreateGlyph = model.glyph == null;
+    var shouldCreateGlyph = model._pipeline.glyph == null;
 
     if (model.shape !== shape && Object.values(ShapeType).includes(shape)) {
       model.shape = shape;
@@ -332,11 +251,12 @@ function vtkArrowHandleRepresentation(publicAPI, model) {
     }
 
     if (shouldCreateGlyph && model.shape) {
-      model.glyph = createGlyph(model.shape);
-      model.mapper.setInputConnection(model.glyph.getOutputPort(), 1);
+      model._pipeline.glyph = createGlyph(model.shape);
+
+      model._pipeline.mapper.setInputConnection(model._pipeline.glyph.getOutputPort(), 1);
     }
 
-    publicAPI.requestDataInternal(inData, outData);
+    return superClass.requestData(inData, outData);
   };
 
   publicAPI.updateActorVisibility = function () {
@@ -362,7 +282,6 @@ function vtkArrowHandleRepresentation(publicAPI, model) {
 
 function defaultValues(initialValues) {
   return _objectSpread({
-    defaultScale: 1,
     faceCamera: null,
     orientation: [1, 0, 0],
     shape: ShapeType.SPHERE,
@@ -374,8 +293,7 @@ function defaultValues(initialValues) {
 function extend(publicAPI, model) {
   var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
   Object.assign(model, defaultValues(initialValues));
-  vtkHandleRepresentation.extend(publicAPI, model, initialValues);
-  macro.get(publicAPI, model, ['glyph', 'mapper', 'actor']);
+  vtkGlyphRepresentation.extend(publicAPI, model, initialValues);
   macro.setGetArray(publicAPI, model, ['visibilityFlagArray'], 2);
   macro.setGetArray(publicAPI, model, ['orientation'], 3);
   macro.setGetArray(publicAPI, model, ['viewMatrix'], 16);