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

package/Widgets/Representations/ImplicitPlaneRepresentation.js

@@ -11,7 +11,7 @@ import vtkPlane from '../../Common/DataModel/Plane.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';
 import vtkSphereSource from '../../Filters/Sources/SphereSource.js';
 import vtkStateBuilder from '../Core/StateBuilder.js';
-import vtkWidgetRepresentation from './WidgetRepresentation.js';
+import vtkWidgetRepresentation, { getPixelWorldHeightAtCoord } from './WidgetRepresentation.js';
 import WidgetManagerConst from '../Core/WidgetManager/Constants.js';
 import PropertyConst from '../../Rendering/Core/Property/Constants.js';
 
@@ -92,8 +92,8 @@ function vtkImplicitPlaneRepresentation(publicAPI, model) {
 
   model.plane = vtkPlane.newInstance();
   model.matrix = vtkMatrixBuilder.buildFromDegree();
-  model.pipelines = {};
-  model.pipelines.outline = {
+  model._pipelines = {};
+  model._pipelines.outline = {
     source: vtkCubeSource.newInstance(),
     mapper: vtkMapper.newInstance(),
     actor: vtkActor.newInstance({
@@ -101,15 +101,18 @@ function vtkImplicitPlaneRepresentation(publicAPI, model) {
       _parentProp: publicAPI
     })
   };
-  model.pipelines.plane = {
-    source: vtkClosedPolyLineToSurfaceFilter.newInstance(),
+  model._pipelines.plane = {
+    source: vtkCutter.newInstance({
+      cutFunction: model.plane
+    }),
+    filter: vtkClosedPolyLineToSurfaceFilter.newInstance(),
     mapper: vtkMapper.newInstance(),
     actor: vtkActor.newInstance({
       pickable: true,
       _parentProp: publicAPI
     })
   };
-  model.pipelines.origin = {
+  model._pipelines.origin = {
     source: vtkSphereSource.newInstance(),
     mapper: vtkMapper.newInstance(),
     actor: vtkActor.newInstance({
@@ -117,7 +120,7 @@ function vtkImplicitPlaneRepresentation(publicAPI, model) {
       _parentProp: publicAPI
     })
   };
-  model.pipelines.normal = {
+  model._pipelines.normal = {
     source: vtkCylinderSource.newInstance(),
     mapper: vtkMapper.newInstance(),
     actor: vtkActor.newInstance({
@@ -125,7 +128,7 @@ function vtkImplicitPlaneRepresentation(publicAPI, model) {
       _parentProp: publicAPI
     })
   };
-  model.pipelines.display2D = {
+  model._pipelines.display2D = {
     source: publicAPI,
     mapper: vtkPixelSpaceCallbackMapper.newInstance(),
     actor: vtkActor.newInstance({
@@ -134,21 +137,18 @@ function vtkImplicitPlaneRepresentation(publicAPI, model) {
     })
   }; // Plane generation pipeline
 
-  var cutter = vtkCutter.newInstance({
-    cutFunction: model.plane
-  });
-  cutter.setInputConnection(model.pipelines.outline.source.getOutputPort());
-  model.pipelines.plane.source.setInputConnection(cutter.getOutputPort());
-  vtkWidgetRepresentation.connectPipeline(model.pipelines.outline);
-  vtkWidgetRepresentation.connectPipeline(model.pipelines.plane);
-  vtkWidgetRepresentation.connectPipeline(model.pipelines.origin);
-  vtkWidgetRepresentation.connectPipeline(model.pipelines.normal);
-  vtkWidgetRepresentation.connectPipeline(model.pipelines.display2D);
-  publicAPI.addActor(model.pipelines.outline.actor);
-  publicAPI.addActor(model.pipelines.plane.actor);
-  publicAPI.addActor(model.pipelines.origin.actor);
-  publicAPI.addActor(model.pipelines.normal.actor);
-  publicAPI.addActor(model.pipelines.display2D.actor); // --------------------------------------------------------------------------
+  model._pipelines.plane.source.setInputConnection(model._pipelines.outline.source.getOutputPort());
+
+  vtkWidgetRepresentation.connectPipeline(model._pipelines.outline);
+  vtkWidgetRepresentation.connectPipeline(model._pipelines.plane);
+  vtkWidgetRepresentation.connectPipeline(model._pipelines.origin);
+  vtkWidgetRepresentation.connectPipeline(model._pipelines.normal);
+  vtkWidgetRepresentation.connectPipeline(model._pipelines.display2D);
+  publicAPI.addActor(model._pipelines.outline.actor);
+  publicAPI.addActor(model._pipelines.plane.actor);
+  publicAPI.addActor(model._pipelines.origin.actor);
+  publicAPI.addActor(model._pipelines.normal.actor);
+  publicAPI.addActor(model._pipelines.display2D.actor); // --------------------------------------------------------------------------
 
   publicAPI.requestData = function (inData, outData) {
     var state = inData[0];
@@ -165,46 +165,58 @@ function vtkImplicitPlaneRepresentation(publicAPI, model) {
     // Update cube parameters
     // --------------------------------
 
-    model.pipelines.outline.source.setCenter((bounds[0] + bounds[1]) * 0.5, (bounds[2] + bounds[3]) * 0.5, (bounds[4] + bounds[5]) * 0.5);
+    model._pipelines.outline.source.setCenter((bounds[0] + bounds[1]) * 0.5, (bounds[2] + bounds[3]) * 0.5, (bounds[4] + bounds[5]) * 0.5);
+
     var xRange = bounds[1] - bounds[0];
     var yRange = bounds[3] - bounds[2];
     var zRange = bounds[5] - bounds[4];
-    model.pipelines.outline.source.setXLength(xRange);
-    model.pipelines.outline.source.setYLength(yRange);
-    model.pipelines.outline.source.setZLength(zRange); // --------------------------------
+
+    model._pipelines.outline.source.setXLength(xRange);
+
+    model._pipelines.outline.source.setYLength(yRange);
+
+    model._pipelines.outline.source.setZLength(zRange); // --------------------------------
     // Update normal parameters
     // --------------------------------
 
+
     var pixelScale = 1;
 
     if (model.scaleInPixels) {
-      pixelScale = publicAPI.getPixelWorldHeightAtCoord(origin);
+      pixelScale = getPixelWorldHeightAtCoord(origin, model.displayScaleParams);
     }
 
-    model.pipelines.normal.source.set({
+    model._pipelines.normal.source.set({
       height: Math.max(xRange, yRange, zRange),
       radius: model.handleSizeRatio * Math.min(xRange, yRange, zRange) * model.axisScale * pixelScale,
       resolution: model.sphereResolution
     });
-    var yAxis = model.pipelines.normal.source.getOutputData();
+
+    var yAxis = model._pipelines.normal.source.getOutputData();
+
     var newAxis = vtkPolyData.newInstance();
     newAxis.shallowCopy(yAxis);
     newAxis.getPoints().setData(Float32Array.from(yAxis.getPoints().getData()), 3);
     newAxis.getPointData().removeAllArrays();
     model.matrix.identity().translate(origin[0], origin[1], origin[2]).rotateFromDirections([0, 1, 0], normal).apply(newAxis.getPoints().getData());
-    model.pipelines.normal.mapper.setInputData(newAxis); // --------------------------------
+
+    model._pipelines.normal.mapper.setInputData(newAxis); // --------------------------------
     // Update origin parameters
     // --------------------------------
 
-    model.pipelines.origin.actor.setPosition(origin);
+
+    model._pipelines.origin.actor.setPosition(origin);
+
     var handleScale = model.handleSizeRatio * Math.min(xRange, yRange, zRange) * pixelScale;
-    model.pipelines.origin.actor.setScale(handleScale, handleScale, handleScale); // --------------------------------
+
+    model._pipelines.origin.actor.setScale(handleScale, handleScale, handleScale); // --------------------------------
     // Update style since state changed
     // --------------------------------
 
-    vtkWidgetRepresentation.applyStyles(model.pipelines, model.representationStyle, state.getActive() && state.getActiveHandle());
+
+    vtkWidgetRepresentation.applyStyles(model._pipelines, model.representationStyle, state.getActive() && state.getActiveHandle());
     var output = vtkPolyData.newInstance();
-    output.shallowCopy(model.pipelines.plane.source.getOutputData());
+    output.shallowCopy(model._pipelines.plane.filter.getOutputData());
     outData[0] = output;
   }; // --------------------------------------------------------------------------
   // Set/Get Forwarding
@@ -213,13 +225,13 @@ function vtkImplicitPlaneRepresentation(publicAPI, model) {
 
   publicAPI.setSphereResolution = function (res) {
     model.sphereResolution = res;
-    return model.pipelines.origin.source.setPhiResolution(res) && model.pipelines.origin.source.setThetaResolution(res);
+    return model._pipelines.origin.source.setPhiResolution(res) && model._pipelines.origin.source.setThetaResolution(res);
   };
 
   publicAPI.setRepresentationStyle = function (style) {
     model.representationStyle = vtkWidgetRepresentation.mergeStyles(STYLE_PIPELINE_NAMES, model.representationStyle, style); // Apply static and inactive
 
-    vtkWidgetRepresentation.applyStyles(model.pipelines, model.representationStyle); // Force requestData to execute
+    vtkWidgetRepresentation.applyStyles(model._pipelines, model.representationStyle); // Force requestData to execute
 
     publicAPI.modified();
   }; // --------------------------------------------------------------------------
@@ -234,21 +246,28 @@ function vtkImplicitPlaneRepresentation(publicAPI, model) {
         outlineVisible = model.outlineVisible;
 
     if (renderingType === RenderingTypes.PICKING_BUFFER) {
-      model.pipelines.plane.actor.setVisibility(planeVisible);
-      model.pipelines.origin.actor.setVisibility(originVisible);
-      model.pipelines.normal.actor.setVisibility(normalVisible); //
+      model._pipelines.plane.actor.setVisibility(planeVisible);
+
+      model._pipelines.origin.actor.setVisibility(originVisible);
+
+      model._pipelines.normal.actor.setVisibility(normalVisible); //
 
-      model.pipelines.plane.actor.getProperty().setOpacity(1);
+
+      model._pipelines.plane.actor.getProperty().setOpacity(1);
     } else {
-      model.pipelines.outline.actor.setVisibility(outlineVisible && ctxVisible);
-      model.pipelines.plane.actor.setVisibility(planeVisible && hVisible);
-      model.pipelines.origin.actor.setVisibility(originVisible && hVisible);
-      model.pipelines.normal.actor.setVisibility(normalVisible && hVisible); //
+      model._pipelines.outline.actor.setVisibility(outlineVisible && ctxVisible);
+
+      model._pipelines.plane.actor.setVisibility(planeVisible && hVisible);
+
+      model._pipelines.origin.actor.setVisibility(originVisible && hVisible);
+
+      model._pipelines.normal.actor.setVisibility(normalVisible && hVisible); //
+
 
       var state = model.inputData[0];
 
       if (state) {
-        vtkWidgetRepresentation.applyStyles(model.pipelines, model.representationStyle, state.getActive() && state.getActiveHandle());
+        vtkWidgetRepresentation.applyStyles(model._pipelines, model.representationStyle, state.getActive() && state.getActiveHandle());
       }
     }
   }; // --------------------------------------------------------------------------
@@ -262,15 +281,15 @@ function vtkImplicitPlaneRepresentation(publicAPI, model) {
     state.setActiveHandle(prop);
 
     switch (prop) {
-      case model.pipelines.plane.actor:
+      case model._pipelines.plane.actor:
         state.setUpdateMethodName('updateFromPlane');
         break;
 
-      case model.pipelines.origin.actor:
+      case model._pipelines.origin.actor:
         state.setUpdateMethodName('updateFromOrigin');
         break;
 
-      case model.pipelines.normal.actor:
+      case model._pipelines.normal.actor:
         state.setUpdateMethodName('updateFromNormal');
         break;
 

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