@kitware/vtk.js 23.4.2 → 24.0.0-beta.1

package/Interaction/Widgets/OrientationMarkerWidget.js

@@ -30,7 +30,7 @@ function vtkOrientationMarkerWidget(publicAPI, model) {
   var selfSubscription = null;
 
   publicAPI.computeViewport = function () {
-    var parentRen = model.parentRenderer || model.interactor.getCurrentRenderer();
+    var parentRen = model.parentRenderer || model._interactor.getCurrentRenderer();
 
     var _parentRen$getViewpor = parentRen.getViewport(),
         _parentRen$getViewpor2 = _slicedToArray(_parentRen$getViewpor, 4),
@@ -39,7 +39,8 @@ function vtkOrientationMarkerWidget(publicAPI, model) {
         xMax = _parentRen$getViewpor2[2],
         yMax = _parentRen$getViewpor2[3];
 
-    var view = model.interactor.getView();
+    var view = model._interactor.getView();
+
     var canvasSize = view.getSize();
 
     var _view$getViewportSize = view.getViewportSize(parentRen),
@@ -76,12 +77,14 @@ function vtkOrientationMarkerWidget(publicAPI, model) {
   publicAPI.updateViewport = function () {
     if (model.enabled) {
       selfRenderer.setViewport.apply(selfRenderer, _toConsumableArray(publicAPI.computeViewport()));
-      model.interactor.render();
+
+      model._interactor.render();
     }
   };
 
   publicAPI.updateMarkerOrientation = function () {
-    var ren = model.parentRenderer || model.interactor.getCurrentRenderer();
+    var ren = model.parentRenderer || model._interactor.getCurrentRenderer();
+
     var currentCamera = ren.getActiveCamera();
 
     if (!currentCamera) {
@@ -125,12 +128,13 @@ function vtkOrientationMarkerWidget(publicAPI, model) {
         return;
       }
 
-      if (!model.interactor) {
+      if (!model._interactor) {
         vtkErrorMacro('Must set interactor before enabling orientation marker.');
         return;
       }
 
-      var ren = model.parentRenderer || model.interactor.getCurrentRenderer();
+      var ren = model.parentRenderer || model._interactor.getCurrentRenderer();
+
       var renderWindow = ren.getRenderWindow();
       renderWindow.addRenderer(selfRenderer);
 
@@ -143,9 +147,9 @@ function vtkOrientationMarkerWidget(publicAPI, model) {
       selfRenderer.setInteractive(false);
       selfRenderer.addViewProp(model.actor);
       model.actor.setVisibility(true);
-      onAnimationSub = model.interactor.onAnimation(publicAPI.updateMarkerOrientation);
-      onEndAnimationSub = model.interactor.onEndAnimation(publicAPI.updateMarkerOrientation);
-      resizeObserver.observe(model.interactor.getView().getCanvas());
+      onAnimationSub = model._interactor.onAnimation(publicAPI.updateMarkerOrientation);
+      onEndAnimationSub = model._interactor.onEndAnimation(publicAPI.updateMarkerOrientation);
+      resizeObserver.observe(model._interactor.getView().getCanvas());
       publicAPI.updateViewport();
       publicAPI.updateMarkerOrientation();
       model.enabled = true;
@@ -163,7 +167,7 @@ function vtkOrientationMarkerWidget(publicAPI, model) {
       model.actor.setVisibility(false);
       selfRenderer.removeViewProp(model.actor);
 
-      var _renderWindow = model.interactor.findPokedRenderer().getRenderWindow();
+      var _renderWindow = model._interactor.findPokedRenderer().getRenderWindow();
 
       if (_renderWindow) {
         _renderWindow.removeRenderer(selfRenderer);
@@ -253,7 +257,7 @@ function vtkOrientationMarkerWidget(publicAPI, model) {
 
 var DEFAULT_VALUES = {
   // actor: null,
-  // interactor: null,
+  // _interactor: null,
   viewportCorner: Constants.Corners.BOTTOM_LEFT,
   viewportSize: 0.2,
   minPixelSize: 50,
@@ -269,8 +273,9 @@ function extend(publicAPI, model) {
   macro.get(publicAPI, model, ['enabled', 'viewportCorner', 'viewportSize']); // NOTE: setting these while the widget is enabled will
   // not update the widget.
 
-  macro.setGet(publicAPI, model, ['interactor', 'minPixelSize', 'maxPixelSize', 'parentRenderer']);
-  macro.get(publicAPI, model, ['actor']); // Object methods
+  macro.setGet(publicAPI, model, ['_interactor', 'minPixelSize', 'maxPixelSize', 'parentRenderer']);
+  macro.get(publicAPI, model, ['actor']);
+  macro.moveToProtected(publicAPI, model, ['interactor']); // Object methods
 
   vtkOrientationMarkerWidget(publicAPI, model);
 } // ----------------------------------------------------------------------------

package/Interaction/Widgets/PiecewiseGaussianWidget.js

@@ -2,7 +2,7 @@ import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import macro from '../../macros.js';
-import { C as arrayRange } from '../../Common/Core/Math/index.js';
+import { D as arrayRange } from '../../Common/Core/Math/index.js';
 import WebworkerPromise from 'webworker-promise';
 import { W as WorkerFactory } from '../../_virtual/rollup-plugin-worker-loader__module_Sources/Interaction/Widgets/PiecewiseGaussianWidget/ComputeHistogram.worker.js';
 

package/Interaction/Widgets.js

@@ -1,43 +1,9 @@
-import vtkAbstractWidget from './Widgets/AbstractWidget.js';
-import vtkDistanceRepresentation from './Widgets/DistanceRepresentation.js';
-import vtkDistanceWidget from './Widgets/DistanceWidget.js';
-import vtkHandleRepresentation from './Widgets/HandleRepresentation.js';
-import vtkHandleWidget from './Widgets/HandleWidget.js';
-import vtkImageCroppingRegionsRepresentation from './Widgets/ImageCroppingRegionsRepresentation.js';
-import vtkImageCroppingRegionsWidget from './Widgets/ImageCroppingRegionsWidget.js';
-import vtkLabelRepresentation from './Widgets/LabelRepresentation.js';
-import vtkLabelWidget from './Widgets/LabelWidget.js';
-import vtkLineRepresentation from './Widgets/LineRepresentation.js';
-import vtkLineWidget from './Widgets/LineWidget.js';
 import vtkOrientationMarkerWidget from './Widgets/OrientationMarkerWidget.js';
 import vtkPiecewiseGaussianWidget from './Widgets/PiecewiseGaussianWidget.js';
-import vtkPointPlacer from './Widgets/PointPlacer.js';
-import vtkResliceCursor from './Widgets/ResliceCursor/ResliceCursor.js';
-import vtkResliceCursorLineRepresentation from './Widgets/ResliceCursor/ResliceCursorLineRepresentation.js';
-import vtkResliceCursorWidget from './Widgets/ResliceCursor/ResliceCursorWidget.js';
-import vtkSphereHandleRepresentation from './Widgets/SphereHandleRepresentation.js';
-import vtkWidgetRepresentation from './Widgets/WidgetRepresentation.js';
 
 var Widgets = {
-  vtkAbstractWidget: vtkAbstractWidget,
-  vtkDistanceRepresentation: vtkDistanceRepresentation,
-  vtkDistanceWidget: vtkDistanceWidget,
-  vtkHandleRepresentation: vtkHandleRepresentation,
-  vtkHandleWidget: vtkHandleWidget,
-  vtkImageCroppingRegionsRepresentation: vtkImageCroppingRegionsRepresentation,
-  vtkImageCroppingRegionsWidget: vtkImageCroppingRegionsWidget,
-  vtkLabelRepresentation: vtkLabelRepresentation,
-  vtkLabelWidget: vtkLabelWidget,
-  vtkLineRepresentation: vtkLineRepresentation,
-  vtkLineWidget: vtkLineWidget,
   vtkOrientationMarkerWidget: vtkOrientationMarkerWidget,
-  vtkPiecewiseGaussianWidget: vtkPiecewiseGaussianWidget,
-  vtkPointPlacer: vtkPointPlacer,
-  vtkResliceCursor: vtkResliceCursor,
-  vtkResliceCursorLineRepresentation: vtkResliceCursorLineRepresentation,
-  vtkResliceCursorWidget: vtkResliceCursorWidget,
-  vtkSphereHandleRepresentation: vtkSphereHandleRepresentation,
-  vtkWidgetRepresentation: vtkWidgetRepresentation
+  vtkPiecewiseGaussianWidget: vtkPiecewiseGaussianWidget
 };
 
 export { Widgets as default };

package/Proxy/Core/View2DProxy.js

@@ -1,7 +1,7 @@
 import macro from '../../macros.js';
 import vtkMouseRangeManipulator from '../../Interaction/Manipulators/MouseRangeManipulator.js';
 import vtkViewProxy from './ViewProxy.js';
-import { j as cross, D as getMajorAxisIndex } from '../../Common/Core/Math/index.js';
+import { j as cross, E as getMajorAxisIndex } from '../../Common/Core/Math/index.js';
 
 var DEFAULT_STEP_WIDTH = 512;
 

package/Rendering/Core/ColorTransferFunction.js

@@ -1,6 +1,6 @@
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import macro from '../../macros.js';
-import { h as hsv2rgb, i as isNan, E as isInf, F as rgb2hsv, G as rgb2lab, H as lab2rgb, I as floor } from '../../Common/Core/Math/index.js';
+import { h as hsv2rgb, i as isNan, F as isInf, G as rgb2hsv, H as rgb2lab, I as lab2rgb, J as floor } from '../../Common/Core/Math/index.js';
 import vtkScalarsToColors from '../../Common/Core/ScalarsToColors.js';
 import Constants from './ColorTransferFunction/Constants.js';
 

package/Rendering/Core/Coordinate.js

@@ -1,7 +1,7 @@
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import macro from '../../macros.js';
 import Constants from './Coordinate/Constants.js';
-import { J as round, I as floor } from '../../Common/Core/Math/index.js';
+import { K as round, J as floor } from '../../Common/Core/Math/index.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; }
 

package/Rendering/Core/CubeAxesActor.js

@@ -2,7 +2,7 @@ import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import { vec3, mat4 } from 'gl-matrix';
 import * as d3 from 'd3-scale';
-import { K as normalize2D, L as nearestPowerOfTwo } from '../../Common/Core/Math/index.js';
+import { L as normalize2D, M as nearestPowerOfTwo } from '../../Common/Core/Math/index.js';
 import macro from '../../macros.js';
 import vtkActor from './Actor.js';
 import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';

package/Rendering/Core/Glyph3DMapper.js

@@ -4,7 +4,7 @@ import { mat4, vec3, mat3 } from 'gl-matrix';
 import Constants from './Glyph3DMapper/Constants.js';
 import macro from '../../macros.js';
 import vtkMapper from './Mapper.js';
-import { M as createUninitializedBounds, n as norm } from '../../Common/Core/Math/index.js';
+import { N as createUninitializedBounds, n as norm } from '../../Common/Core/Math/index.js';
 import vtkBoundingBox from '../../Common/DataModel/BoundingBox.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; }

package/Rendering/Core/ImageMapper.js

@@ -2,7 +2,7 @@ import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import Constants from './ImageMapper/Constants.js';
 import macro from '../../macros.js';
 import vtkAbstractMapper from './AbstractMapper.js';
-import { A as clampValue, N as multiply3x3_vect3, M as createUninitializedBounds } from '../../Common/Core/Math/index.js';
+import { C as clampValue, O as multiply3x3_vect3, N as createUninitializedBounds } from '../../Common/Core/Math/index.js';
 import vtkPlane from '../../Common/DataModel/Plane.js';
 import CoincidentTopologyHelper from './Mapper/CoincidentTopologyHelper.js';
 import { vec3 } from 'gl-matrix';

package/Rendering/Core/InteractorObserver.js

@@ -54,7 +54,7 @@ function vtkInteractorObserver(publicAPI, model) {
   function subscribeToEvents() {
     vtkRenderWindowInteractor.handledEvents.forEach(function (eventName) {
       if (publicAPI["handle".concat(eventName)]) {
-        model.subscribedEvents.push(model.interactor["on".concat(eventName)](function (callData) {
+        model.subscribedEvents.push(model._interactor["on".concat(eventName)](function (callData) {
           if (model.processEvents) {
             return publicAPI["handle".concat(eventName)](callData);
           }
@@ -69,12 +69,12 @@ function vtkInteractorObserver(publicAPI, model) {
 
 
   publicAPI.setInteractor = function (i) {
-    if (i === model.interactor) {
+    if (i === model._interactor) {
       return;
     }
 
     unsubscribeFromEvents();
-    model.interactor = i;
+    model._interactor = i;
 
     if (i && model.enabled) {
       subscribeToEvents();
@@ -92,7 +92,7 @@ function vtkInteractorObserver(publicAPI, model) {
     unsubscribeFromEvents();
 
     if (enable) {
-      if (model.interactor) {
+      if (model._interactor) {
         subscribeToEvents();
       } else {
         vtkErrorMacro("\n          The interactor must be set before subscribing to events\n        ");
@@ -111,7 +111,7 @@ function vtkInteractorObserver(publicAPI, model) {
       return null;
     }
 
-    return model.interactor.getView().displayToWorld(x, y, z, renderer);
+    return model._interactor.getView().displayToWorld(x, y, z, renderer);
   }; //----------------------------------------------------------------------------
   // Description:
   // Transform from world to display coordinates.
@@ -122,14 +122,14 @@ function vtkInteractorObserver(publicAPI, model) {
       return null;
     }
 
-    return model.interactor.getView().worldToDisplay(x, y, z, renderer);
+    return model._interactor.getView().worldToDisplay(x, y, z, renderer);
   }; //----------------------------------------------------------------------------
 
 
   publicAPI.setPriority = function (priority) {
     var modified = superClass.setPriority(priority);
 
-    if (modified && model.interactor) {
+    if (modified && model._interactor) {
       unsubscribeFromEvents();
       subscribeToEvents();
     }
@@ -141,7 +141,7 @@ function vtkInteractorObserver(publicAPI, model) {
 
 var DEFAULT_VALUES = {
   enabled: true,
-  interactor: null,
+  // _interactor: null,
   priority: 0.0,
   processEvents: true,
   subscribedEvents: []
@@ -156,9 +156,10 @@ function extend(publicAPI, model) {
   macro.event(publicAPI, model, 'StartInteractionEvent');
   macro.event(publicAPI, model, 'EndInteractionEvent'); // Create get-only macros
 
-  macro.get(publicAPI, model, ['interactor', 'enabled']); // Create get-set macros
+  macro.get(publicAPI, model, ['_interactor', 'enabled']); // Create get-set macros
 
-  macro.setGet(publicAPI, model, ['priority', 'processEvents']); // For more macro methods, see "Sources/macros.js"
+  macro.setGet(publicAPI, model, ['priority', 'processEvents']);
+  macro.moveToProtected(publicAPI, model, ['interactor']); // For more macro methods, see "Sources/macros.js"
   // Object specific methods
 
   vtkInteractorObserver(publicAPI, model);

package/Rendering/Core/InteractorStyle.js

@@ -38,7 +38,9 @@ function vtkInteractorStyle(publicAPI, model) {
       }
 
       model.state = stateNames[key];
-      model.interactor.requestAnimation(publicAPI);
+
+      model._interactor.requestAnimation(publicAPI);
+
       publicAPI.invokeStartInteractionEvent({
         type: 'StartInteractionEvent'
       });
@@ -55,19 +57,22 @@ function vtkInteractorStyle(publicAPI, model) {
       }
 
       model.state = States.IS_NONE;
-      model.interactor.cancelAnimation(publicAPI);
+
+      model._interactor.cancelAnimation(publicAPI);
+
       publicAPI.invokeEndInteractionEvent({
         type: 'EndInteractionEvent'
       });
       publicAPI["invokeEnd".concat(key, "Event")]({
         type: "End".concat(key, "Event")
       });
-      model.interactor.render();
+
+      model._interactor.render();
     };
   }); //----------------------------------------------------------------------------
 
   publicAPI.handleKeyPress = function (callData) {
-    var rwi = model.interactor;
+    var rwi = model._interactor;
     var ac = null;
 
     switch (callData.key) {

package/Rendering/Core/Mapper.js

@@ -4,7 +4,7 @@ import vtkAbstractMapper3D from './AbstractMapper3D.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
 import vtkImageData from '../../Common/DataModel/ImageData.js';
 import vtkLookupTable from '../../Common/Core/LookupTable.js';
-import { M as createUninitializedBounds, i as isNan } from '../../Common/Core/Math/index.js';
+import { N as createUninitializedBounds, i as isNan } from '../../Common/Core/Math/index.js';
 import vtkScalarsToColors from '../../Common/Core/ScalarsToColors/Constants.js';
 import CoincidentTopologyHelper from './Mapper/CoincidentTopologyHelper.js';
 import Constants from './Mapper/Constants.js';

package/Rendering/Core/Prop.js

@@ -47,15 +47,15 @@ function vtkProp(publicAPI, model) {
   publicAPI.hasKey = notImplemented('hasKey');
 
   publicAPI.getNestedVisibility = function () {
-    return model.visibility && (!model.parentProp || model.parentProp.getNestedVisibility());
+    return model.visibility && (!model._parentProp || model._parentProp.getNestedVisibility());
   };
 
   publicAPI.getNestedPickable = function () {
-    return model.pickable && (!model.parentProp || model.parentProp.getNestedPickable());
+    return model.pickable && (!model._parentProp || model._parentProp.getNestedPickable());
   };
 
   publicAPI.getNestedDragable = function () {
-    return model.dragable && (!model.parentProp || model.parentProp.getNestedDragable());
+    return model.dragable && (!model._parentProp || model._parentProp.getNestedDragable());
   };
 
   publicAPI.getRedrawMTime = function () {
@@ -121,6 +121,7 @@ function vtkProp(publicAPI, model) {
 
 
 var DEFAULT_VALUES = {
+  // _parentProp: null,
   visibility: true,
   pickable: true,
   dragable: true,
@@ -139,7 +140,8 @@ function extend(publicAPI, model) {
 
   macro.obj(publicAPI, model);
   macro.get(publicAPI, model, ['estimatedRenderTime', 'allocatedRenderTime']);
-  macro.setGet(publicAPI, model, ['visibility', 'pickable', 'dragable', 'useBounds', 'renderTimeMultiplier', 'parentProp']); // Object methods
+  macro.setGet(publicAPI, model, ['visibility', 'pickable', 'dragable', 'useBounds', 'renderTimeMultiplier', '_parentProp']);
+  macro.moveToProtected(publicAPI, model, ['parentProp']); // Object methods
 
   vtkProp(publicAPI, model);
 } // ----------------------------------------------------------------------------

package/Rendering/Core/Prop3D.js

@@ -1,7 +1,7 @@
 import { mat4, quat } from 'gl-matrix';
 import macro from '../../macros.js';
 import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';
-import { y as degreesFromRadians, r as radiansFromDegrees } from '../../Common/Core/Math/index.js';
+import { A as degreesFromRadians, r as radiansFromDegrees } from '../../Common/Core/Math/index.js';
 import vtkProp from './Prop.js';
 
 // vtkProp3D methods

package/Rendering/Core/RenderWindowInteractor.js

@@ -1,6 +1,6 @@
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import macro from '../../macros.js';
-import { y as degreesFromRadians } from '../../Common/Core/Math/index.js';
+import { A as degreesFromRadians } from '../../Common/Core/Math/index.js';
 import Constants from './RenderWindowInteractor/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; }
@@ -119,7 +119,9 @@ function vtkRenderWindowInteractor(publicAPI, model) {
 
   function getScreenEventPositionFor(source) {
     var bounds = model.container.getBoundingClientRect();
-    var canvas = model.view.getCanvas();
+
+    var canvas = model._view.getCanvas();
+
     var scaleX = canvas.width / bounds.width;
     var scaleY = canvas.height / bounds.height;
     var position = {
@@ -301,9 +303,11 @@ function vtkRenderWindowInteractor(publicAPI, model) {
 
 
   function forceRender() {
-    if (model.view && model.enabled && model.enableRender) {
+    if (model._view && model.enabled && model.enableRender) {
       model.inRender = true;
-      model.view.traverseAllPasses();
+
+      model._view.traverseAllPasses();
+
       model.inRender = false;
     } // outside the above test so that third-party code can redirect
     // the render to the appropriate class
@@ -674,34 +678,36 @@ function vtkRenderWindowInteractor(publicAPI, model) {
   };
 
   publicAPI.setView = function (val) {
-    if (model.view === val) {
+    if (model._view === val) {
       return;
     }
 
-    model.view = val;
-    model.view.getRenderable().setInteractor(publicAPI);
+    model._view = val;
+
+    model._view.getRenderable().setInteractor(publicAPI);
+
     publicAPI.modified();
   };
 
   publicAPI.getFirstRenderer = function () {
-    var _model$view, _model$view$getRender, _model$view$getRender2;
+    var _model$_view, _model$_view$getRende, _model$_view$getRende2;
 
-    return (_model$view = model.view) === null || _model$view === void 0 ? void 0 : (_model$view$getRender = _model$view.getRenderable()) === null || _model$view$getRender === void 0 ? void 0 : (_model$view$getRender2 = _model$view$getRender.getRenderersByReference()) === null || _model$view$getRender2 === void 0 ? void 0 : _model$view$getRender2[0];
+    return (_model$_view = model._view) === null || _model$_view === void 0 ? void 0 : (_model$_view$getRende = _model$_view.getRenderable()) === null || _model$_view$getRende === void 0 ? void 0 : (_model$_view$getRende2 = _model$_view$getRende.getRenderersByReference()) === null || _model$_view$getRende2 === void 0 ? void 0 : _model$_view$getRende2[0];
   };
 
   publicAPI.findPokedRenderer = function () {
-    var _model$view2, _model$view2$getRende;
+    var _model$_view2, _model$_view2$getRend;
 
     var x = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
     var y = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
 
-    if (!model.view) {
+    if (!model._view) {
       return null;
     } // The original order of renderers needs to remain as
     // the first one is the one we want to manipulate the camera on.
 
 
-    var rc = (_model$view2 = model.view) === null || _model$view2 === void 0 ? void 0 : (_model$view2$getRende = _model$view2.getRenderable()) === null || _model$view2$getRende === void 0 ? void 0 : _model$view2$getRende.getRenderers();
+    var rc = (_model$_view2 = model._view) === null || _model$_view2 === void 0 ? void 0 : (_model$_view2$getRend = _model$_view2.getRenderable()) === null || _model$_view2$getRend === void 0 ? void 0 : _model$_view2$getRend.getRenderers();
 
     if (!rc) {
       return null;
@@ -718,7 +724,7 @@ function vtkRenderWindowInteractor(publicAPI, model) {
     while (count--) {
       var aren = rc[count];
 
-      if (model.view.isInViewport(x, y, aren) && aren.getInteractive()) {
+      if (model._view.isInViewport(x, y, aren) && aren.getInteractive()) {
         currentRenderer = aren;
         break;
       }
@@ -729,7 +735,7 @@ function vtkRenderWindowInteractor(publicAPI, model) {
         interactiveren = aren;
       }
 
-      if (viewportren === null && model.view.isInViewport(x, y, aren)) {
+      if (viewportren === null && model._view.isInViewport(x, y, aren)) {
         // Save this renderer in case we can't find one in the viewport that
         // is interactive.
         viewportren = aren;
@@ -995,7 +1001,7 @@ var DEFAULT_VALUES = {
   desiredUpdateRate: 30.0,
   stillUpdateRate: 2.0,
   container: null,
-  view: null,
+  // _view: null,
   recognizeGestures: true,
   currentGesture: 'Start',
   animationRequest: null,
@@ -1018,9 +1024,10 @@ function extend(publicAPI, model) {
     return macro.event(publicAPI, model, eventName);
   }); // Create get-only macros
 
-  macro.get(publicAPI, model, ['initialized', 'container', 'interactorStyle', 'lastFrameTime', 'recentAnimationFrameRate', 'view']); // Create get-set macros
+  macro.get(publicAPI, model, ['initialized', 'container', 'interactorStyle', 'lastFrameTime', 'recentAnimationFrameRate', '_view']); // Create get-set macros
 
-  macro.setGet(publicAPI, model, ['lightFollowCamera', 'enabled', 'enableRender', 'recognizeGestures', 'desiredUpdateRate', 'stillUpdateRate', 'picker']); // For more macro methods, see "Sources/macros.js"
+  macro.setGet(publicAPI, model, ['lightFollowCamera', 'enabled', 'enableRender', 'recognizeGestures', 'desiredUpdateRate', 'stillUpdateRate', 'picker']);
+  macro.moveToProtected(publicAPI, model, ['view']); // For more macro methods, see "Sources/macros.js"
   // Object specific methods
 
   vtkRenderWindowInteractor(publicAPI, model);

package/Rendering/Core/Renderer.js

@@ -1,8 +1,8 @@
 import { mat4, vec3 } from 'gl-matrix';
-import { newInstance as newInstance$1, get, setGet, getArray, setGetArray, vtkDebugMacro as vtkDebugMacro$1, vtkErrorMacro as vtkErrorMacro$1, vtkWarningMacro as vtkWarningMacro$1 } from '../../macros.js';
+import { newInstance as newInstance$1, get, setGet, getArray, setGetArray, moveToProtected, vtkDebugMacro as vtkDebugMacro$1, vtkErrorMacro as vtkErrorMacro$1, vtkWarningMacro as vtkWarningMacro$1 } from '../../macros.js';
 import vtkCamera from './Camera.js';
 import vtkLight from './Light.js';
-import { O as areBoundsInitialized, u as uninitializeBounds, r as radiansFromDegrees, d as dot, M as createUninitializedBounds } from '../../Common/Core/Math/index.js';
+import { P as areBoundsInitialized, u as uninitializeBounds, r as radiansFromDegrees, d as dot, N as createUninitializedBounds } from '../../Common/Core/Math/index.js';
 import vtkViewport from './Viewport.js';
 import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';
 
@@ -81,7 +81,7 @@ function vtkRenderer(publicAPI, model) {
   publicAPI.updateGeometry = notImplemented('updateGeometry');
 
   publicAPI.getVTKWindow = function () {
-    return model.renderWindow;
+    return model._renderWindow;
   };
 
   publicAPI.setLayer = function (layer) {
@@ -219,19 +219,24 @@ function vtkRenderer(publicAPI, model) {
       return;
     }
 
-    if (model.createdLight) {
-      publicAPI.removeLight(model.createdLight);
-      model.createdLight.delete();
-      model.createdLight = null;
+    if (model._createdLight) {
+      publicAPI.removeLight(model._createdLight);
+
+      model._createdLight.delete();
+
+      model._createdLight = null;
     }
 
-    model.createdLight = publicAPI.makeLight();
-    publicAPI.addLight(model.createdLight);
-    model.createdLight.setLightTypeToHeadLight(); // set these values just to have a good default should LightFollowCamera
+    model._createdLight = publicAPI.makeLight();
+    publicAPI.addLight(model._createdLight);
+
+    model._createdLight.setLightTypeToHeadLight(); // set these values just to have a good default should LightFollowCamera
     // be turned off.
 
-    model.createdLight.setPosition(publicAPI.getActiveCamera().getPosition());
-    model.createdLight.setFocalPoint(publicAPI.getActiveCamera().getFocalPoint());
+
+    model._createdLight.setPosition(publicAPI.getActiveCamera().getPosition());
+
+    model._createdLight.setFocalPoint(publicAPI.getActiveCamera().getFocalPoint());
   }; // requires the aspect ratio of the viewport as X/Y
 
 
@@ -508,9 +513,9 @@ function vtkRenderer(publicAPI, model) {
   };
 
   publicAPI.setRenderWindow = function (renderWindow) {
-    if (renderWindow !== model.renderWindow) {
-      model.vtkWindow = renderWindow;
-      model.renderWindow = renderWindow;
+    if (renderWindow !== model._renderWindow) {
+      model._vtkWindow = renderWindow;
+      model._renderWindow = renderWindow;
     }
   };
 
@@ -530,7 +535,7 @@ function vtkRenderer(publicAPI, model) {
       m1 = m2;
     }
 
-    var m3 = model.createdLight ? model.createdLight.getMTime() : 0;
+    var m3 = model._createdLight ? model._createdLight.getMTime() : 0;
 
     if (m3 > m1) {
       m1 = m3;
@@ -558,7 +563,6 @@ var DEFAULT_VALUES = {
   ambient: [1, 1, 1],
   allocatedRenderTime: 100,
   timeFactor: 1,
-  createdLight: null,
   automaticLightCreation: true,
   twoSidedLighting: true,
   lastRenderTimeInSeconds: -1,
@@ -604,10 +608,11 @@ function extend(publicAPI, model) {
 
   if (model.background.length === 3) model.background.push(1); // Build VTK API
 
-  get(publicAPI, model, ['renderWindow', 'allocatedRenderTime', 'timeFactor', 'lastRenderTimeInSeconds', 'numberOfPropsRendered', 'lastRenderingUsedDepthPeeling', 'selector']);
+  get(publicAPI, model, ['_renderWindow', 'allocatedRenderTime', 'timeFactor', 'lastRenderTimeInSeconds', 'numberOfPropsRendered', 'lastRenderingUsedDepthPeeling', 'selector']);
   setGet(publicAPI, model, ['twoSidedLighting', 'lightFollowCamera', 'automaticLightCreation', 'erase', 'draw', 'nearClippingPlaneTolerance', 'clippingRangeExpansion', 'backingStore', 'interactive', 'layer', 'preserveColorBuffer', 'preserveDepthBuffer', 'useDepthPeeling', 'occlusionRatio', 'maximumNumberOfPeels', 'delegate', 'backgroundTexture', 'texturedBackground', 'useShadows', 'pass']);
   getArray(publicAPI, model, ['actors', 'volumes', 'lights']);
-  setGetArray(publicAPI, model, ['background'], 4, 1.0); // Object methods
+  setGetArray(publicAPI, model, ['background'], 4, 1.0);
+  moveToProtected(publicAPI, model, ['renderWindow']); // Object methods
 
   vtkRenderer(publicAPI, model);
 } // ----------------------------------------------------------------------------

package/Rendering/Core/ScalarBarActor.js

@@ -2,7 +2,7 @@ import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import { vec3, mat4 } from 'gl-matrix';
 import * as d3 from 'd3-scale';
-import { L as nearestPowerOfTwo } from '../../Common/Core/Math/index.js';
+import { M as nearestPowerOfTwo } from '../../Common/Core/Math/index.js';
 import macro from '../../macros.js';
 import vtkActor from './Actor.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';

package/Rendering/Core/Viewport.js

@@ -136,7 +136,7 @@ function vtkViewport(publicAPI, model) {
 
 
 var DEFAULT_VALUES = {
-  vtkWindow: null,
+  // _vtkWindow: null,
   background: [0, 0, 0],
   background2: [0.2, 0.2, 0.2],
   gradientBackground: false,

package/Rendering/Core/VolumeMapper.js

@@ -1,5 +1,5 @@
 import macro from '../../macros.js';
-import { M as createUninitializedBounds } from '../../Common/Core/Math/index.js';
+import { N as createUninitializedBounds } from '../../Common/Core/Math/index.js';
 import Constants from './VolumeMapper/Constants.js';
 import vtkAbstractMapper from './AbstractMapper.js';
 

package/Rendering/OpenGL/Actor.js

@@ -12,9 +12,9 @@ function vtkOpenGLActor(publicAPI, model) {
 
   publicAPI.buildPass = function (prepass) {
     if (prepass) {
-      model.openGLRenderWindow = publicAPI.getFirstAncestorOfType('vtkOpenGLRenderWindow');
+      model._openGLRenderWindow = publicAPI.getFirstAncestorOfType('vtkOpenGLRenderWindow');
       model.openGLRenderer = publicAPI.getFirstAncestorOfType('vtkOpenGLRenderer');
-      model.context = model.openGLRenderWindow.getContext();
+      model.context = model._openGLRenderWindow.getContext();
       publicAPI.prepareNodes();
       publicAPI.addMissingNodes(model.renderable.getTextures());
       publicAPI.addMissingNode(model.renderable.getMapper());