@kitware/vtk.js 19.8.0 → 20.0.3

package/Widgets/Widgets3D/ShapeWidget/Constants.js

@@ -20,71 +20,10 @@ var ShapeBehavior = (_ShapeBehavior = {}, _defineProperty(_ShapeBehavior, Behavi
   FIXED: 0,
   FREE: 1
 }), _ShapeBehavior);
-var HorizontalTextPosition = {
-  OUTSIDE_LEFT: 'OUSIDE_LEFT',
-  INSIDE_LEFT: 'INSIDE_LEFT',
-  OUTSIDE_RIGHT: 'OUSIDE_RIGHT',
-  INSIDE_RIGHT: 'INSIDE_RIGHT',
-  MIDDLE: 'MIDDLE'
+var TextPosition = {
+  MIN: 'MIN',
+  CENTER: 'CENTER',
+  MAX: 'MAX'
 };
-var VerticalTextPosition = {
-  OUTSIDE_TOP: 'OUSIDE_TOP',
-  INSIDE_TOP: 'INSIDE_TOP',
-  OUTSIDE_BOTTOM: 'OUSIDE_BOTTOM',
-  INSIDE_BOTTOM: 'INSIDE_BOTTOM',
-  MIDDLE: 'MIDDLE'
-};
-function computeTextPosition(bounds, horizontalPosition, verticalPosition, textWidth, textHeight) {
-  var margin = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 0;
-  var x = 0;
-
-  switch (horizontalPosition) {
-    case HorizontalTextPosition.OUTSIDE_LEFT:
-      x = bounds[0] - textWidth - margin;
-      break;
-
-    case HorizontalTextPosition.INSIDE_LEFT:
-      x = bounds[0] + margin;
-      break;
-
-    case HorizontalTextPosition.MIDDLE:
-      x = 0.5 * (bounds[0] + bounds[1] - textWidth);
-      break;
-
-    case HorizontalTextPosition.INSIDE_RIGHT:
-      x = bounds[1] - textWidth - margin;
-      break;
-
-    case HorizontalTextPosition.OUTSIDE_RIGHT:
-      x = bounds[1] + margin;
-      break;
-  }
-
-  var y = 0;
-
-  switch (verticalPosition) {
-    case VerticalTextPosition.OUTSIDE_TOP:
-      y = bounds[3] + textHeight + margin;
-      break;
-
-    case VerticalTextPosition.INSIDE_TOP:
-      y = bounds[3] - margin;
-      break;
-
-    case VerticalTextPosition.MIDDLE:
-      y = 0.5 * (bounds[2] + bounds[3] + textWidth);
-      break;
-
-    case VerticalTextPosition.INSIDE_BOTTOM:
-      y = bounds[2] + textHeight + margin;
-      break;
-
-    case VerticalTextPosition.OUTSIDE_BOTTOM:
-      y = bounds[2] - margin;
-      break;
-  }
-
-  return [x, y, 0];
-}
 
-export { BehaviorCategory, HorizontalTextPosition, ShapeBehavior, VerticalTextPosition, computeTextPosition, ShapeBehavior as default };
+export { BehaviorCategory, ShapeBehavior, TextPosition, ShapeBehavior as default };

package/Widgets/Widgets3D/ShapeWidget/behavior.js

@@ -1,22 +1,21 @@
 import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import macro from '../../../macros.js';
-import { ShapeBehavior, BehaviorCategory } from './Constants.js';
-import vtkLabelRepresentation from '../../../Interaction/Widgets/LabelRepresentation.js';
-import { h as distance, a as subtract, d as dot, j as add, c as cross, x as squaredDistance } from '../../../vendor/gl-matrix/esm/vec3.js';
+import { q as vtkMath } from '../../../Common/Core/Math/index.js';
+import vtkBoundingBox from '../../../Common/DataModel/BoundingBox.js';
+import vtkPlane from '../../../Common/DataModel/Plane.js';
+import { ShapeBehavior, BehaviorCategory, TextPosition } from './Constants.js';
+import { boundPlane } from '../ResliceCursorWidget/helpers.js';
+import { a as subtract, d as dot, j as add, c as cross, x as squaredDistance, h as distance } from '../../../vendor/gl-matrix/esm/vec3.js';
 
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (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 = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
 var vtkErrorMacro = macro.vtkErrorMacro;
 var EPSILON = 1e-6;
-
-function makeBoundsFromPoints(point1, point2) {
-  return [Math.min(point1[0], point2[0]), Math.max(point1[0], point2[0]), Math.min(point1[1], point2[1]), Math.max(point1[1], point2[1]), Math.min(point1[2], point2[2]), Math.max(point1[2], point2[2])];
-}
-
 function widgetBehavior(publicAPI, model) {
   model.classHierarchy.push('vtkShapeWidgetProp');
+  model.keysDown = {};
 
   var superClass = _objectSpread({}, publicAPI); // --------------------------------------------------------------------------
   // Display 2D
@@ -25,18 +24,25 @@ function widgetBehavior(publicAPI, model) {
 
   publicAPI.setDisplayCallback = function (callback) {
     return model.representations[0].setDisplayCallback(callback);
+  };
+
+  publicAPI.setText = function (text) {
+    model.widgetState.getText().setText(text); // Recompute position
+
+    model.interactor.render();
   }; // --------------------------------------------------------------------------
   // Public methods
   // --------------------------------------------------------------------------
 
 
-  publicAPI.setModifierBehavior = function (behavior) {
-    Object.assign(model.modifierBehavior, behavior);
-  };
+  publicAPI.setResetAfterPointPlacement = model.factory.setResetAfterPointPlacement;
+  publicAPI.getResetAfterPointPlacement = model.factory.getResetAfterPointPlacement;
+  publicAPI.setModifierBehavior = model.factory.setModifierBehavior;
+  publicAPI.getModifierBehavior = model.factory.getModifierBehavior;
 
   publicAPI.isBehaviorActive = function (category, flag) {
     return Object.keys(model.keysDown).some(function (key) {
-      return model.keysDown[key] && model.modifierBehavior[key] && model.modifierBehavior[key][category] === flag;
+      return model.keysDown[key] && publicAPI.getModifierBehavior()[key] && publicAPI.getModifierBehavior()[key][category] === flag;
     });
   };
 
@@ -48,7 +54,7 @@ function widgetBehavior(publicAPI, model) {
 
   publicAPI.getActiveBehaviorFromCategory = function (category) {
     return Object.values(ShapeBehavior[category]).find(function (flag) {
-      return publicAPI.isBehaviorActive(category, flag) || !publicAPI.isOppositeBehaviorActive(category, flag) && model.modifierBehavior.None[category] === flag;
+      return publicAPI.isBehaviorActive(category, flag) || !publicAPI.isOppositeBehaviorActive(category, flag) && publicAPI.getModifierBehavior().None[category] === flag;
     });
   };
 
@@ -62,19 +68,7 @@ function widgetBehavior(publicAPI, model) {
   };
 
   publicAPI.isDraggingForced = function () {
-    return publicAPI.isBehaviorActive(BehaviorCategory.PLACEMENT, ShapeBehavior[BehaviorCategory.PLACEMENT].DRAG) || model.modifierBehavior.None[BehaviorCategory.PLACEMENT] === ShapeBehavior[BehaviorCategory.PLACEMENT].DRAG;
-  };
-
-  publicAPI.setVisibleOnFocus = function (visibleOnFocus) {
-    model.visibleOnFocus = visibleOnFocus;
-  };
-
-  publicAPI.setLabelTextCallback = function (callback) {
-    model.labelTextCallback = callback;
-  };
-
-  publicAPI.setResetAfterPointPlacement = function (reset) {
-    model.resetAfterPointPlacement = reset;
+    return publicAPI.isBehaviorActive(BehaviorCategory.PLACEMENT, ShapeBehavior[BehaviorCategory.PLACEMENT].DRAG) || publicAPI.getModifierBehavior().None[BehaviorCategory.PLACEMENT] === ShapeBehavior[BehaviorCategory.PLACEMENT].DRAG;
   };
 
   publicAPI.getPoint1 = function () {
@@ -104,16 +98,9 @@ function widgetBehavior(publicAPI, model) {
       model.point1Handle.deactivate();
       model.point2Handle.activate();
       model.activeState = model.point2Handle;
-
-      if (model.useHandles) {
-        model.point2Handle.setVisible(true);
-      }
-
+      model.point2Handle.setVisible(true);
       publicAPI.updateShapeBounds();
-
-      if (model.visibleOnFocus) {
-        model.shapeHandle.setVisible(true);
-      }
+      model.shapeHandle.setVisible(true);
     }
   };
 
@@ -123,49 +110,12 @@ function widgetBehavior(publicAPI, model) {
       model.point2Handle.setOrigin(model.point2);
       publicAPI.updateShapeBounds();
 
-      if (model.resetAfterPointPlacement) {
+      if (publicAPI.getResetAfterPointPlacement()) {
         publicAPI.reset();
       } else {
         publicAPI.loseFocus();
       }
     }
-  };
-
-  publicAPI.setPixelScale = function (pixelScale) {
-    model.pixelScale = pixelScale;
-    publicAPI.updateHandlesSize();
-  };
-
-  publicAPI.updateHandlesSize = function () {
-    if (model.pixelScale !== null) {
-      var scale = model.pixelScale * distance(model.apiSpecificRenderWindow.displayToWorld(0, 0, 0, model.renderer), model.apiSpecificRenderWindow.displayToWorld(1, 0, 0, model.renderer));
-      model.point1Handle.setScale1(scale);
-      model.point2Handle.setScale1(scale);
-    }
-  };
-
-  publicAPI.setVisibility = function (visibility) {
-    var modified = false;
-
-    if (model.useHandles) {
-      modified = superClass.setVisibility(visibility) || modified;
-    } else {
-      modified = model.shapeHandle.setVisible(visibility) || modified;
-    }
-
-    if (model.label) {
-      if (visibility) {
-        modified = model.label.setContainer(model.interactor.getContainer()) || modified;
-      } else {
-        modified = model.label.setContainer(null) || modified;
-      }
-    }
-
-    return modified;
-  };
-
-  publicAPI.getLabel = function () {
-    return model.label;
   }; // --------------------------------------------------------------------------
   // Private methods
   // --------------------------------------------------------------------------
@@ -211,21 +161,16 @@ function widgetBehavior(publicAPI, model) {
   var getCornersFromDiameter = function getCornersFromDiameter(point1, point2) {
     var center = [0.5 * (point1[0] + point2[0]), 0.5 * (point1[1] + point2[1]), 0.5 * (point1[2] + point2[2])];
     return getCornersFromRadius(center, point1);
-  };
-
-  publicAPI.setCorners = function (point1, point2) {
-    if (model.label && model.labelTextCallback) {
-      var _model$apiSpecificRen, _model$apiSpecificRen2;
+  }; // TODO: move to ShapeWidget/index.js
 
-      var bounds = makeBoundsFromPoints(point1, point2);
 
-      var screenPoint1 = (_model$apiSpecificRen = model.apiSpecificRenderWindow).worldToDisplay.apply(_model$apiSpecificRen, _toConsumableArray(point1).concat([model.renderer]));
+  publicAPI.getBounds = function () {
+    return model.point1 && model.point2 ? vtkMath.computeBoundsFromPoints(model.point1, model.point2, []) : vtkMath.uninitializeBounds([]);
+  }; // To be reimplemented by subclass
 
-      var screenPoint2 = (_model$apiSpecificRen2 = model.apiSpecificRenderWindow).worldToDisplay.apply(_model$apiSpecificRen2, _toConsumableArray(point2).concat([model.renderer]));
 
-      var screenBounds = [Math.min(screenPoint1[0], screenPoint2[0]), Math.max(screenPoint1[0], screenPoint2[0]), Math.min(screenPoint1[1], screenPoint2[1]), Math.max(screenPoint1[1], screenPoint2[1]), Math.min(screenPoint1[2], screenPoint2[2]), Math.max(screenPoint1[2], screenPoint2[2])];
-      model.labelTextCallback(bounds, screenBounds, model.label);
-    }
+  publicAPI.setCorners = function (point1, point2) {
+    publicAPI.updateTextPosition(point1, point2);
   };
 
   publicAPI.updateShapeBounds = function () {
@@ -275,6 +220,100 @@ function widgetBehavior(publicAPI, model) {
       }
     }
   };
+
+  var computePositionVector = function computePositionVector(textPosition, minPoint, maxPoint) {
+    var positionVector = [0, 0, 0];
+
+    switch (textPosition) {
+      case TextPosition.MIN:
+        break;
+
+      case TextPosition.MAX:
+        vtkMath.subtract(maxPoint, minPoint, positionVector);
+        break;
+
+      case TextPosition.CENTER:
+      default:
+        vtkMath.subtract(maxPoint, minPoint, positionVector);
+        vtkMath.multiplyScalar(positionVector, 0.5);
+        break;
+    }
+
+    return positionVector;
+  };
+
+  var computeTextPosition = function computeTextPosition(worldBounds, textPosition) {
+    var _model$apiSpecificRen, _model$apiSpecificRen2, _model$apiSpecificRen5;
+
+    var worldMargin = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+    var viewPlaneOrigin = model.manipulator.getOrigin();
+    var viewPlaneNormal = model.manipulator.getNormal();
+    var viewUp = model.renderer.getActiveCamera().getViewUp();
+    var positionMargin = Array.isArray(worldMargin) ? _toConsumableArray(worldMargin) : [worldMargin, worldMargin, viewPlaneOrigin ? worldMargin : 0]; // Map bounds from world positions to display positions
+
+    var minPoint = (_model$apiSpecificRen = model.apiSpecificRenderWindow).worldToDisplay.apply(_model$apiSpecificRen, _toConsumableArray(vtkBoundingBox.getMinPoint(worldBounds)).concat([model.renderer]));
+
+    var maxPoint = (_model$apiSpecificRen2 = model.apiSpecificRenderWindow).worldToDisplay.apply(_model$apiSpecificRen2, _toConsumableArray(vtkBoundingBox.getMaxPoint(worldBounds)).concat([model.renderer]));
+
+    var displayBounds = vtkMath.computeBoundsFromPoints(minPoint, maxPoint, []);
+    var planeOrigin = [];
+    var p1 = [];
+    var p2 = [];
+    var p3 = []; // If we are in a 2D projection
+
+    if (viewPlaneOrigin && viewPlaneNormal && viewUp && vtkBoundingBox.intersectPlane(displayBounds, viewPlaneOrigin, viewPlaneNormal)) {
+      var _model$apiSpecificRen3, _model$apiSpecificRen4;
+
+      // Map plane origin from world positions to display positions
+      var displayPlaneOrigin = (_model$apiSpecificRen3 = model.apiSpecificRenderWindow).worldToDisplay.apply(_model$apiSpecificRen3, _toConsumableArray(viewPlaneOrigin).concat([model.renderer])); // Map plane normal from world positions to display positions
+
+
+      var planeNormalPoint = vtkMath.add(viewPlaneOrigin, viewPlaneNormal, []);
+
+      var displayPlaneNormalPoint = (_model$apiSpecificRen4 = model.apiSpecificRenderWindow).worldToDisplay.apply(_model$apiSpecificRen4, _toConsumableArray(planeNormalPoint).concat([model.renderer]));
+
+      var displayPlaneNormal = vtkMath.subtract(displayPlaneNormalPoint, displayPlaneOrigin); // Project view plane into bounding box
+
+      var largeDistance = 10 * vtkBoundingBox.getDiagonalLength(displayBounds);
+      vtkPlane.projectPoint(vtkBoundingBox.getCenter(displayBounds), displayPlaneOrigin, displayPlaneNormal, planeOrigin);
+      var planeU = vtkMath.cross(viewUp, displayPlaneNormal, []);
+      vtkMath.normalize(planeU); // u
+
+      vtkMath.normalize(viewUp); // v
+
+      vtkMath.normalize(displayPlaneNormal); // w
+
+      vtkMath.multiplyAccumulate(planeOrigin, viewUp, -largeDistance, planeOrigin);
+      vtkMath.multiplyAccumulate(planeOrigin, planeU, -largeDistance, planeOrigin);
+      p1 = vtkMath.multiplyAccumulate(planeOrigin, planeU, 2 * largeDistance, []);
+      p2 = vtkMath.multiplyAccumulate(planeOrigin, viewUp, 2 * largeDistance, []);
+      p3 = planeOrigin;
+      boundPlane(displayBounds, planeOrigin, p1, p2);
+    } else {
+      planeOrigin = [displayBounds[0], displayBounds[2], displayBounds[4]];
+      p1 = [displayBounds[1], displayBounds[2], displayBounds[4]];
+      p2 = [displayBounds[0], displayBounds[3], displayBounds[4]];
+      p3 = [displayBounds[0], displayBounds[2], displayBounds[5]];
+    } // Compute horizontal, vertical and depth position
+
+
+    var u = computePositionVector(textPosition[0], planeOrigin, p1);
+    var v = computePositionVector(textPosition[1], planeOrigin, p2);
+    var w = computePositionVector(textPosition[2], planeOrigin, p3);
+    var finalPosition = planeOrigin;
+    vtkMath.add(finalPosition, u, finalPosition);
+    vtkMath.add(finalPosition, v, finalPosition);
+    vtkMath.add(finalPosition, w, finalPosition);
+    vtkMath.add(finalPosition, positionMargin, finalPosition);
+    return (_model$apiSpecificRen5 = model.apiSpecificRenderWindow).displayToWorld.apply(_model$apiSpecificRen5, finalPosition.concat([model.renderer]));
+  };
+
+  publicAPI.updateTextPosition = function (point1, point2) {
+    var bounds = vtkMath.computeBoundsFromPoints(point1, point2, []);
+    var screenPosition = computeTextPosition(bounds, model.widgetState.getTextPosition(), model.widgetState.getTextWorldMargin());
+    var textHandle = model.widgetState.getText();
+    textHandle.setOrigin(screenPosition);
+  };
   /*
    * If the widget has the focus, this method reset the widget
    * to it's state just after it grabbed the focus. Otherwise
@@ -290,11 +329,7 @@ function widgetBehavior(publicAPI, model) {
     model.shapeHandle.setVisible(false);
     model.point1 = null;
     model.point2 = null;
-
-    if (model.label) {
-      model.label.setLabelText('');
-    }
-
+    model.widgetState.getText().setVisible(false);
     model.point1Handle.setOrigin(model.point2Handle.getOrigin());
     model.point2Handle.setVisible(false);
     model.point2Handle.deactivate();
@@ -344,8 +379,9 @@ function widgetBehavior(publicAPI, model) {
         model.point2Handle.setOrigin(worldCoords);
         model.point2 = worldCoords;
         publicAPI.updateShapeBounds();
+        publicAPI.invokeInteractionEvent();
       }
-    } else if (model.useHandles && model.isDragging) {
+    } else if (model.isDragging) {
       if (model.activeState === model.point1Handle) {
         model.point1Handle.setOrigin(worldCoords);
         model.point1 = worldCoords;
@@ -428,7 +464,7 @@ function widgetBehavior(publicAPI, model) {
           publicAPI.invokeInteractionEvent();
           publicAPI.invokeEndInteractionEvent();
 
-          if (model.resetAfterPointPlacement) {
+          if (publicAPI.getResetAfterPointPlacement()) {
             publicAPI.reset();
           } else {
             publicAPI.loseFocus();
@@ -482,45 +518,23 @@ function widgetBehavior(publicAPI, model) {
   publicAPI.grabFocus = function () {
     if (!model.hasFocus) {
       publicAPI.reset();
-
-      if (!model.label) {
-        model.label = vtkLabelRepresentation.newInstance();
-      }
-
-      model.label.setRenderer(model.renderer);
-      model.label.buildRepresentation();
-      model.renderer.addViewProp(model.label);
-      model.label.setContainer(model.interactor.getContainer());
       model.point1Handle.activate();
       model.activeState = model.point1Handle;
-
-      if (model.useHandles) {
-        model.point1Handle.setVisible(true);
-      }
-
+      model.point1Handle.setVisible(true);
       model.shapeHandle.setVisible(false);
       model.interactor.requestAnimation(publicAPI);
     }
 
-    publicAPI.updateHandlesSize();
-    model.hasFocus = true;
+    superClass.grabFocus();
   }; // --------------------------------------------------------------------------
 
 
   publicAPI.loseFocus = function () {
     if (model.hasFocus) {
-      if (model.visibleOnFocus && !model.useHandles) {
-        model.shapeHandle.setVisible(false);
-      }
-
       model.interactor.cancelAnimation(publicAPI);
     }
 
-    if (model.label && !model.useHandles) {
-      model.label.setContainer(null);
-    }
-
-    if (!model.useHandles || !model.point1) {
+    if (!model.point1) {
       model.point1Handle.setVisible(false);
       model.point2Handle.setVisible(false);
     }
@@ -531,7 +545,7 @@ function widgetBehavior(publicAPI, model) {
     model.activeState = null;
     model.interactor.render();
     model.widgetManager.enablePicking();
-    model.hasFocus = false;
+    superClass.loseFocus();
   };
 }
 

package/Widgets/Widgets3D/ShapeWidget.js

@@ -1,20 +1,42 @@
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import macro from '../../macros.js';
+import vtkAbstractWidgetFactory from '../Core/AbstractWidgetFactory.js';
 import { BehaviorCategory, ShapeBehavior } from './ShapeWidget/Constants.js';
 
-var _None;
-var DEFAULT_VALUES = {
-  manipulator: null,
-  visibleOnFocus: true,
-  modifierBehavior: {
-    None: (_None = {}, _defineProperty(_None, BehaviorCategory.PLACEMENT, ShapeBehavior[BehaviorCategory.PLACEMENT].CLICK_AND_DRAG), _defineProperty(_None, BehaviorCategory.POINTS, ShapeBehavior[BehaviorCategory.POINTS].CORNER_TO_CORNER), _defineProperty(_None, BehaviorCategory.RATIO, ShapeBehavior[BehaviorCategory.RATIO].FREE), _None)
-  },
-  keysDown: {},
-  resetAfterPointPlacement: true,
-  useHandles: false,
-  pixelScale: 10
-};
-var vtkShapeWidget = {
-  DEFAULT_VALUES: DEFAULT_VALUES
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (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 = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function vtkShapeWidget(publicAPI, model) {
+  model.classHierarchy.push('vtkShapeWidget');
+  model.methodsToLink = ['scaleInPixels', 'textProps', 'fontProperties'];
+}
+
+function defaultValues(initialValues) {
+  var _None;
+
+  return _objectSpread({
+    manipulator: null,
+    modifierBehavior: {
+      None: (_None = {}, _defineProperty(_None, BehaviorCategory.PLACEMENT, ShapeBehavior[BehaviorCategory.PLACEMENT].CLICK_AND_DRAG), _defineProperty(_None, BehaviorCategory.POINTS, ShapeBehavior[BehaviorCategory.POINTS].CORNER_TO_CORNER), _defineProperty(_None, BehaviorCategory.RATIO, ShapeBehavior[BehaviorCategory.RATIO].FREE), _None)
+    },
+    resetAfterPointPlacement: false
+  }, initialValues);
+} // ----------------------------------------------------------------------------
+
+
+function extend(publicAPI, model) {
+  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, defaultValues(initialValues));
+  vtkAbstractWidgetFactory.extend(publicAPI, model, initialValues);
+  macro.setGet(publicAPI, model, ['modifierBehavior', 'resetAfterPointPlacement']);
+  vtkShapeWidget(publicAPI, model);
+} // ----------------------------------------------------------------------------
+
+var newInstance = macro.newInstance(extend, 'vtkShapeWidget');
+var vtkShapeWidget$1 = {
+  newInstance: newInstance,
+  extend: extend
 };
 
-export { DEFAULT_VALUES, vtkShapeWidget as default };
+export { vtkShapeWidget$1 as default, extend, newInstance };

package/macros.js

@@ -692,8 +692,17 @@ function algo(publicAPI, model, numberOfInputs, numberOfOutputs) {
       return;
     }
 
-    model.numberOfInputs++;
-    setInputConnection(outputPort, model.numberOfInputs - 1);
+    var portToFill = model.numberOfInputs;
+
+    while (portToFill && !model.inputData[portToFill - 1] && !model.inputConnection[portToFill - 1]) {
+      portToFill--;
+    }
+
+    if (portToFill === model.numberOfInputs) {
+      model.numberOfInputs++;
+    }
+
+    setInputConnection(outputPort, portToFill);
   }
 
   function addInputData(dataset) {
@@ -702,8 +711,17 @@ function algo(publicAPI, model, numberOfInputs, numberOfOutputs) {
       return;
     }
 
-    model.numberOfInputs++;
-    setInputData(dataset, model.numberOfInputs - 1);
+    var portToFill = model.numberOfInputs;
+
+    while (portToFill && !model.inputData[portToFill - 1] && !model.inputConnection[portToFill - 1]) {
+      portToFill--;
+    }
+
+    if (portToFill === model.numberOfInputs) {
+      model.numberOfInputs++;
+    }
+
+    setInputData(dataset, portToFill);
   }
 
   function getOutputData() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kitware/vtk.js",
-  "version": "19.8.0",
+  "version": "20.0.3",
   "description": "Visualization Toolkit for the Web",
   "keywords": [
     "3d",