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

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);

package/Widgets/Representations/CircleContextRepresentation.js

@@ -1,195 +1,73 @@
-import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import macro from '../../macros.js';
-import vtkActor from '../../Rendering/Core/Actor.js';
 import vtkCircleSource from '../../Filters/Sources/CircleSource.js';
-import vtkContextRepresentation from './ContextRepresentation.js';
-import vtkDataArray from '../../Common/Core/DataArray.js';
-import vtkGlyph3DMapper from '../../Rendering/Core/Glyph3DMapper.js';
-import vtkMatrixBuilder from '../../Common/Core/MatrixBuilder.js';
-import vtkPolyData from '../../Common/DataModel/PolyData.js';
-import vtkWidgetRepresentation from './WidgetRepresentation.js';
-import { ScalarMode } from '../../Rendering/Core/Mapper/Constants.js';
-import { mat3, vec3 } from 'gl-matrix';
+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; }
 // vtkCircleContextRepresentation methods
 // ----------------------------------------------------------------------------
 
 function vtkCircleContextRepresentation(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkCircleContextRepresentation'); // --------------------------------------------------------------------------
-  // 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
-    }),
-    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); // --------------------------------------------------------------------------
   // Generic rendering pipeline
   // --------------------------------------------------------------------------
 
-  model.pipelines = {
-    circle: {
-      source: publicAPI,
-      glyph: vtkCircleSource.newInstance({
-        resolution: model.glyphResolution,
-        radius: 1,
-        lines: model.drawBorder,
-        face: model.drawFace
-      }),
-      mapper: vtkGlyph3DMapper.newInstance({
-        orientationArray: 'direction',
-        scaleArray: 'scale',
-        scaleMode: vtkGlyph3DMapper.ScaleModes.SCALE_BY_COMPONENTS,
-        colorByArrayName: 'color',
-        scalarMode: ScalarMode.USE_POINT_FIELD_DATA
-      }),
-      actor: vtkActor.newInstance({
-        pickable: false,
-        _parentProp: publicAPI
-      })
-    }
-  };
-  model.pipelines.circle.actor.getProperty().setOpacity(0.2);
-  model.pipelines.circle.mapper.setOrientationModeToMatrix();
-  model.pipelines.circle.mapper.setResolveCoincidentTopology(true);
-  model.pipelines.circle.mapper.setResolveCoincidentTopologyPolygonOffsetParameters(-1, -1);
-  vtkWidgetRepresentation.connectPipeline(model.pipelines.circle);
-  publicAPI.addActor(model.pipelines.circle.actor);
-  model.transform = vtkMatrixBuilder.buildFromDegree(); // --------------------------------------------------------------------------
-
-  publicAPI.setGlyphResolution = macro.chain(publicAPI.setGlyphResolution, function (r) {
-    return model.pipelines.circle.glyph.setResolution(r);
-  }); // --------------------------------------------------------------------------
+  model._pipeline.actor.getProperty().setOpacity(0.2);
 
-  publicAPI.setDrawBorder = function (draw) {
-    model.pipelines.circle.glyph.setLines(draw);
-  }; // --------------------------------------------------------------------------
+  model._pipeline.mapper.setResolveCoincidentTopology(true);
 
+  model._pipeline.mapper.setRelativeCoincidentTopologyPolygonOffsetParameters(-1, -1); // --------------------------------------------------------------------------
 
-  publicAPI.setDrawFace = function (draw) {
-    model.pipelines.circle.glyph.setFace(draw);
-  }; // --------------------------------------------------------------------------
 
+  publicAPI.setGlyphResolution = macro.chain(publicAPI.setGlyphResolution, model._pipeline.glyph.setResolution); // --------------------------------------------------------------------------
 
-  publicAPI.setOpacity = function (opacity) {
-    model.pipelines.circle.actor.getProperty().setOpacity(opacity);
-  };
+  publicAPI.setDrawBorder = macro.chain(publicAPI.setDrawBorder, function (draw) {
+    return model._pipeline.glyph.setLines(draw);
+  }); // --------------------------------------------------------------------------
 
-  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,
-        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));
-      scale.setData(new Float32Array(3 * totalCount));
-      direction.setData(new Float32Array(9 * totalCount));
-      color.setData(new Float32Array(totalCount));
-    }
-
-    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();
-      typedArray.points[i * 3 + 0] = coord[0];
-      typedArray.points[i * 3 + 1] = coord[1];
-      typedArray.points[i * 3 + 2] = coord[2];
-      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];
-      var rotation = [].concat(_toConsumableArray(right), _toConsumableArray(up), _toConsumableArray(dir));
-      var scale3 = state.getScale3 ? state.getScale3() : [1, 1, 1];
-      scale3 = scale3.map(function (x) {
-        return x === 0 ? 2 * model.defaultScale : 2 * x;
-      }); // Reorient rotation and scale3 since the circle source faces X instead of Z
-
-      var reorientCircleSource4 = vtkMatrixBuilder.buildFromDegree().rotateFromDirections([1, 0, 0], [0, 0, 1]) // from X to Z
-      .getMatrix();
-      var reorientCircleSource3 = [];
-      mat3.fromMat4(reorientCircleSource3, reorientCircleSource4);
-      vec3.transformMat4(scale3, scale3, reorientCircleSource4);
-      mat3.multiply(rotation, rotation, reorientCircleSource3);
-
-      for (var j = 0; j < 9; j += 1) {
-        typedArray.direction[i * 9 + j] = rotation[j];
-      }
-
-      var scale1 = (state.getScale1 ? state.getScale1() : model.defaultScale) / 2;
-      typedArray.scale[i * 3 + 0] = scale1 * scaleFactor * scale3[0];
-      typedArray.scale[i * 3 + 1] = scale1 * scaleFactor * scale3[1];
-      typedArray.scale[i * 3 + 2] = scale1 * scaleFactor * scale3[2];
-      typedArray.color[i] = model.useActiveColor && isActive ? model.activeColor : state.getColor();
-    }
-
-    model.internalPolyData.modified();
-    outData[0] = model.internalPolyData;
-  }; // --------------------------------------------------------------------------
-  // Initialization
-  // --------------------------------------------------------------------------
+  publicAPI.setDrawFace = macro.chain(publicAPI.setDrawFace, function (draw) {
+    return model._pipeline.glyph.setFace(draw);
+  }); // --------------------------------------------------------------------------
 
+  publicAPI.setOpacity = function (opacity) {
+    model._pipeline.actor.getProperty().setOpacity(opacity);
+  };
 } // ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
 
-var DEFAULT_VALUES = {
-  glyphResolution: 32,
-  defaultScale: 1,
-  drawBorder: false,
-  drawFace: true
-}; // ----------------------------------------------------------------------------
+function defaultValues(initialValues) {
+  var _initialValues$pipeli, _initialValues$pipeli2, _initialValues$glyphR, _initialValues$drawBo, _initialValues$drawFa;
+
+  return _objectSpread(_objectSpread({
+    behavior: Behavior.CONTEXT,
+    glyphResolution: 32,
+    drawBorder: false,
+    drawFace: true
+  }, initialValues), {}, {
+    _pipeline: _objectSpread({
+      glyph: (_initialValues$pipeli = initialValues === null || initialValues === void 0 ? void 0 : (_initialValues$pipeli2 = initialValues.pipeline) === null || _initialValues$pipeli2 === void 0 ? void 0 : _initialValues$pipeli2.glyph) !== null && _initialValues$pipeli !== void 0 ? _initialValues$pipeli : vtkCircleSource.newInstance({
+        resolution: (_initialValues$glyphR = initialValues.glyphResolution) !== null && _initialValues$glyphR !== void 0 ? _initialValues$glyphR : 32,
+        radius: 1,
+        lines: (_initialValues$drawBo = initialValues.drawBorder) !== null && _initialValues$drawBo !== void 0 ? _initialValues$drawBo : false,
+        face: (_initialValues$drawFa = initialValues.drawFace) !== null && _initialValues$drawFa !== void 0 ? _initialValues$drawFa : true,
+        direction: [0, 0, 1]
+      })
+    }, initialValues === null || initialValues === void 0 ? void 0 : initialValues.pipeline)
+  });
+} // ----------------------------------------------------------------------------
+
 
 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']); // Object specific methods
+  vtkGlyphRepresentation.extend(publicAPI, model, defaultValues(initialValues));
+  macro.setGet(publicAPI, model, ['glyphResolution', 'drawFace', 'drawBorder']);
+  macro.get(publicAPI, model._pipeline, ['glyph', 'mapper', 'actor']); // Object specific methods
 
   vtkCircleContextRepresentation(publicAPI, model);
 } // ----------------------------------------------------------------------------

package/Widgets/Representations/ContextRepresentation.js

@@ -16,9 +16,6 @@ function vtkContextRepresentation(publicAPI, model) {
 
 
 var DEFAULT_VALUES = {
-  activeScaleFactor: 1.2,
-  activeColor: 1,
-  useActiveColor: true,
   behavior: Behavior.CONTEXT,
   pickable: false,
   dragable: true

package/Widgets/Representations/ConvexFaceContextRepresentation.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 { Behavior } from './WidgetRepresentation/Constants.js';
 import { RenderingTypes } from '../Core/WidgetManager/Constants.js';
 
@@ -23,21 +24,20 @@ function vtkConvexFaceContextRepresentation(publicAPI, model) {
   model.internalPolyData.getPoints().setData(model.points, 3);
   model.internalPolyData.getPolys().setData(model.cells);
 
-  function allocateSize(size) {
-    if (model.cells.length - 1 !== size) {
-      model.points = new Float32Array(size * 3);
-      model.cells = new Uint8Array(size + 1);
-      model.cells[0] = size;
+  function allocateSize(polyData, size) {
+    var points = allocateArray(polyData, 'points', size).getData();
+    var oldCellsSize = polyData.getPolys().getNumberOfValues();
+    var cells = allocateArray(polyData, 'polys', size + 1).getData();
+
+    if (oldCellsSize !== cells.length) {
+      cells[0] = size;
 
       for (var i = 0; i < size; i++) {
-        model.cells[i + 1] = i;
+        cells[i + 1] = i;
       }
-
-      model.internalPolyData.getPoints().setData(model.points, 3);
-      model.internalPolyData.getPolys().setData(model.cells);
     }
 
-    return model.points;
+    return points;
   } // --------------------------------------------------------------------------
   // Generic rendering pipeline
   // --------------------------------------------------------------------------
@@ -59,7 +59,7 @@ function vtkConvexFaceContextRepresentation(publicAPI, model) {
     var validState = list.filter(function (state) {
       return state.getOrigin();
     });
-    var points = allocateSize(validState.length);
+    var points = allocateSize(allocateSize, validState.length);
 
     for (var i = 0; i < validState.length; i++) {
       var coords = validState[i].getOrigin();

package/Widgets/Representations/CroppingOutlineRepresentation.js

@@ -4,6 +4,8 @@ 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 { origin } from './GlyphRepresentation.js';
+import { allocateArray } from './WidgetRepresentation.js';
 
 var vtkErrorMacro = macro.vtkErrorMacro; // prettier-ignore
 
@@ -25,9 +27,8 @@ function vtkCroppingOutlineRepresentation(publicAPI, model) {
   model.internalPolyData = vtkPolyData.newInstance({
     mtime: 0
   });
-  model.points = new Float32Array(8 * 3);
-  model.internalPolyData.getPoints().setData(model.points, 3);
-  model.internalPolyData.getLines().setData(Uint16Array.from(OUTLINE_ARRAY)); // --------------------------------------------------------------------------
+  allocateArray(model.internalPolyData, 'lines', OUTLINE_ARRAY.length).getData().set(OUTLINE_ARRAY);
+  var applyOrigin = origin(); // --------------------------------------------------------------------------
   // Generic rendering pipeline
   // --------------------------------------------------------------------------
 
@@ -50,15 +51,7 @@ function vtkCroppingOutlineRepresentation(publicAPI, model) {
     });
 
     if (list.length === 8) {
-      var pi = 0;
-
-      for (var i = 0; i < list.length; i++) {
-        var pt = list[i].getOrigin();
-        model.points[pi++] = pt[0];
-        model.points[pi++] = pt[1];
-        model.points[pi++] = pt[2];
-      }
-
+      applyOrigin(model.internalPolyData, list);
       model.internalPolyData.getPoints().modified();
       model.internalPolyData.modified();
       outData[0] = model.internalPolyData;