@kitware/vtk.js 28.10.2 → 28.11.1

package/Proxy/Core/ProxyManager/properties.js

@@ -1,142 +1,119 @@
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
-
-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; }
-
 function addVPropertyHandlingAPI(publicAPI, model) {
   // --------------------------------------------------------------------------
   // Property management
   // --------------------------------------------------------------------------
-  publicAPI.getSections = function () {
-    var sections = [];
-    var source = publicAPI.getActiveSource();
 
+  publicAPI.getSections = () => {
+    const sections = [];
+    const source = publicAPI.getActiveSource();
     if (!source) {
       return [];
     }
-
-    var view = publicAPI.getActiveView();
-
+    const view = publicAPI.getActiveView();
     if (source) {
-      var section = source.getProxySection();
-
+      const section = source.getProxySection();
       if (section.ui.length) {
         sections.push(Object.assign(section, {
           collapsed: model.collapseState[section.name]
         }));
       }
     }
-
     if (source && view) {
-      var representation = publicAPI.getRepresentation(source, view);
-
+      const representation = publicAPI.getRepresentation(source, view);
       if (representation) {
-        var _section = representation.getProxySection();
-
-        if (_section.ui.length) {
-          sections.push(Object.assign(_section, {
-            collapsed: model.collapseState[_section.name]
+        const section = representation.getProxySection();
+        if (section.ui.length) {
+          sections.push(Object.assign(section, {
+            collapsed: model.collapseState[section.name]
           }));
         }
       }
     }
-
     if (view) {
-      var _section2 = view.getProxySection();
-
-      if (_section2.ui.length) {
-        sections.push(Object.assign(_section2, {
-          collapsed: model.collapseState[_section2.name]
+      const section = view.getProxySection();
+      if (section.ui.length) {
+        sections.push(Object.assign(section, {
+          collapsed: model.collapseState[section.name]
         }));
       }
     }
-
     return sections;
-  }; // --------------------------------------------------------------------------
+  };
 
+  // --------------------------------------------------------------------------
 
-  publicAPI.updateCollapseState = function (name, state) {
+  publicAPI.updateCollapseState = (name, state) => {
     model.collapseState[name] = state;
     publicAPI.modified();
-  }; // --------------------------------------------------------------------------
-
+  };
 
-  publicAPI.applyChanges = function (changeSet) {
-    var groupBy = {};
-    var keys = Object.keys(changeSet);
-    var count = keys.length;
+  // --------------------------------------------------------------------------
 
+  publicAPI.applyChanges = changeSet => {
+    const groupBy = {};
+    const keys = Object.keys(changeSet);
+    let count = keys.length;
     while (count--) {
-      var key = keys[count];
-
-      var _key$split = key.split(':'),
-          _key$split2 = _slicedToArray(_key$split, 2),
-          id = _key$split2[0],
-          prop = _key$split2[1];
-
+      const key = keys[count];
+      const [id, prop] = key.split(':');
       if (!groupBy[id]) {
         groupBy[id] = {};
       }
-
       if (changeSet[key] === '__command_execute__') {
-        var obj = publicAPI.getProxyById(id);
-
+        const obj = publicAPI.getProxyById(id);
         if (obj) {
           obj[prop]();
         }
       } else {
         groupBy[id][prop] = changeSet[key];
       }
-    } // Apply changes
-
+    }
 
-    var objIds = Object.keys(groupBy);
+    // Apply changes
+    const objIds = Object.keys(groupBy);
     count = objIds.length;
-
     while (count--) {
-      var _id = objIds[count];
-
-      var _obj = publicAPI.getProxyById(_id);
-
-      if (_obj) {
-        _obj.set(groupBy[_id]);
+      const id = objIds[count];
+      const obj = publicAPI.getProxyById(id);
+      if (obj) {
+        obj.set(groupBy[id]);
       }
     }
-
     publicAPI.modified();
     publicAPI.renderAllViews();
-  }; // --------------------------------------------------------------------------
+  };
+
+  // --------------------------------------------------------------------------
   // Color Management
   // --------------------------------------------------------------------------
 
-
-  publicAPI.getLookupTable = function (arrayName, options) {
+  publicAPI.getLookupTable = (arrayName, options) => {
     if (!model.lookupTables[arrayName]) {
-      model.lookupTables[arrayName] = publicAPI.createProxy('Proxy', 'LookupTable', _objectSpread({
-        arrayName: arrayName
-      }, options));
+      model.lookupTables[arrayName] = publicAPI.createProxy('Proxy', 'LookupTable', {
+        arrayName,
+        ...options
+      });
     }
-
     return model.lookupTables[arrayName];
-  }; // --------------------------------------------------------------------------
+  };
 
+  // --------------------------------------------------------------------------
 
-  publicAPI.getPiecewiseFunction = function (arrayName, options) {
+  publicAPI.getPiecewiseFunction = (arrayName, options) => {
     if (!model.piecewiseFunctions[arrayName]) {
-      model.piecewiseFunctions[arrayName] = publicAPI.createProxy('Proxy', 'PiecewiseFunction', _objectSpread({
-        arrayName: arrayName
-      }, options));
+      model.piecewiseFunctions[arrayName] = publicAPI.createProxy('Proxy', 'PiecewiseFunction', {
+        arrayName,
+        ...options
+      });
     }
-
     return model.piecewiseFunctions[arrayName];
-  }; // --------------------------------------------------------------------------
+  };
 
+  // --------------------------------------------------------------------------
 
-  publicAPI.rescaleTransferFunctionToDataRange = function (arrayName, dataRange) {
-    var lut = publicAPI.getLookupTable(arrayName);
-    var pwf = publicAPI.getPiecewiseFunction(arrayName);
+  publicAPI.rescaleTransferFunctionToDataRange = (arrayName, dataRange) => {
+    const lut = publicAPI.getLookupTable(arrayName);
+    const pwf = publicAPI.getPiecewiseFunction(arrayName);
     lut.setDataRange(dataRange[0], dataRange[1]);
     pwf.setDataRange(dataRange[0], dataRange[1]);
   };

package/Proxy/Core/ProxyManager/state.js

@@ -1,65 +1,59 @@
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import vtk from '../../../vtk.js';
 import vtkPiecewiseFunctionProxy from '../PiecewiseFunctionProxy.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; }
-
 function getProperties(proxy) {
-  var props = {};
-  proxy.listPropertyNames().forEach(function (name) {
+  const props = {};
+  proxy.listPropertyNames().forEach(name => {
     props[name] = proxy.getPropertyByName(name).value;
   });
   return props;
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Proxy State Handling
 // ----------------------------------------------------------------------------
 
-
 function addStateAPI(publicAPI, model) {
   publicAPI.loadState = function (state) {
-    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-    return new Promise(function (resolve, reject) {
-      var proxyMapping = {};
-      var $oldToNewIdMapping = {};
-      var cameras = {};
-      var datasetHandler = options.datasetHandler || vtk;
-      var sourcePromises = [];
-      state.sources.forEach(function (_ref) {
-        var id = _ref.id,
-            group = _ref.group,
-            name = _ref.name,
-            props = _ref.props;
-        sourcePromises.push(Promise.resolve(datasetHandler(props.dataset)).then(function (dataset) {
+    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    return new Promise((resolve, reject) => {
+      const proxyMapping = {};
+      const $oldToNewIdMapping = {};
+      const cameras = {};
+      const datasetHandler = options.datasetHandler || vtk;
+      const sourcePromises = [];
+      state.sources.forEach(_ref => {
+        let {
+          id,
+          group,
+          name,
+          props
+        } = _ref;
+        sourcePromises.push(Promise.resolve(datasetHandler(props.dataset)).then(dataset => {
           if (dataset) {
-            var proxy = publicAPI.createProxy(group, name);
+            const proxy = publicAPI.createProxy(group, name);
             proxy.setName(props.name);
             proxy.setInputData(dataset, props.type);
             proxyMapping[id] = proxy;
             return proxy;
           }
-
           return null;
         }));
       });
-      Promise.all(sourcePromises).then(function () {
-        var views = publicAPI.getViews();
-        state.views.forEach(function (_ref2) {
-          var id = _ref2.id,
-              group = _ref2.group,
-              name = _ref2.name,
-              props = _ref2.props,
-              camera = _ref2.camera;
-          var proxy = null;
-
+      Promise.all(sourcePromises).then(() => {
+        const views = publicAPI.getViews();
+        state.views.forEach(_ref2 => {
+          let {
+            id,
+            group,
+            name,
+            props,
+            camera
+          } = _ref2;
+          let proxy = null;
           if (state.options.recycleViews) {
-            proxy = views.find(function (v) {
-              return v.getProxyGroup() === group && v.getProxyName() === name && v.getName() === props.name;
-            });
+            proxy = views.find(v => v.getProxyGroup() === group && v.getProxyName() === name && v.getName() === props.name);
           }
-
           if (!proxy) {
             proxy = publicAPI.createProxy(group, name, {
               disableAnimation: true
@@ -67,104 +61,103 @@ function addStateAPI(publicAPI, model) {
           } else {
             proxy.setDisableAnimation(true);
           }
-
           proxy.set(props, true);
           proxyMapping[id] = proxy;
           cameras[id] = camera;
         });
-
         function updateView(view) {
           if (!proxyMapping[view] || !cameras[view]) {
             return;
           }
-
-          proxyMapping[view].resetOrientation().then(function () {
+          proxyMapping[view].resetOrientation().then(() => {
             proxyMapping[view].getCamera().set(cameras[view]);
             proxyMapping[view].getRenderer().updateLightsGeometryToFollowCamera();
             proxyMapping[view].renderLater();
           });
         }
-
-        state.representations.forEach(function (_ref3) {
-          var source = _ref3.source,
-              view = _ref3.view,
-              props = _ref3.props;
-          var proxy = publicAPI.getRepresentation(proxyMapping[source], proxyMapping[view]);
+        state.representations.forEach(_ref3 => {
+          let {
+            source,
+            view,
+            props
+          } = _ref3;
+          const proxy = publicAPI.getRepresentation(proxyMapping[source], proxyMapping[view]);
           proxy.set(props, true);
           updateView(view);
-        }); // restore luts and pwfs after restoring reps to avoid
-        // rep initialization from resetting restored luts/pwfs
+        });
 
-        Object.keys(state.fields).forEach(function (fieldName) {
-          var _state$fields$fieldNa = state.fields[fieldName],
-              lookupTable = _state$fields$fieldNa.lookupTable,
-              piecewiseFunction = _state$fields$fieldNa.piecewiseFunction;
-          var lutProxy = publicAPI.getLookupTable(fieldName, lookupTable);
+        // restore luts and pwfs after restoring reps to avoid
+        // rep initialization from resetting restored luts/pwfs
+        Object.keys(state.fields).forEach(fieldName => {
+          const {
+            lookupTable,
+            piecewiseFunction
+          } = state.fields[fieldName];
+          const lutProxy = publicAPI.getLookupTable(fieldName, lookupTable);
           lutProxy.setPresetName(lookupTable.presetName);
-          lutProxy.setDataRange.apply(lutProxy, _toConsumableArray(lookupTable.dataRange));
-          var pwfProxy = publicAPI.getPiecewiseFunction(fieldName, piecewiseFunction);
-
+          lutProxy.setDataRange(...lookupTable.dataRange);
+          const pwfProxy = publicAPI.getPiecewiseFunction(fieldName, piecewiseFunction);
           switch (piecewiseFunction.mode) {
             case vtkPiecewiseFunctionProxy.Mode.Gaussians:
               pwfProxy.setGaussians(piecewiseFunction.gaussians);
               break;
-
             case vtkPiecewiseFunctionProxy.Mode.Points:
               pwfProxy.setPoints(piecewiseFunction.points);
               break;
-
             case vtkPiecewiseFunctionProxy.Mode.Nodes:
               pwfProxy.setNodes(piecewiseFunction.nodes);
               break;
           }
-
           pwfProxy.setMode(piecewiseFunction.mode);
-          pwfProxy.setDataRange.apply(pwfProxy, _toConsumableArray(piecewiseFunction.dataRange));
-        }); // Apply camera no matter what
+          pwfProxy.setDataRange(...piecewiseFunction.dataRange);
+        });
 
-        Object.keys(cameras).forEach(updateView); // Create id mapping
+        // Apply camera no matter what
+        Object.keys(cameras).forEach(updateView);
 
-        Object.keys(proxyMapping).forEach(function (originalId) {
-          var newId = proxyMapping[originalId].getProxyId();
+        // Create id mapping
+        Object.keys(proxyMapping).forEach(originalId => {
+          const newId = proxyMapping[originalId].getProxyId();
           $oldToNewIdMapping[originalId] = newId;
-        }); // Re-enable animation on views
+        });
 
-        state.views.forEach(function (_ref4) {
-          var id = _ref4.id;
+        // Re-enable animation on views
+        state.views.forEach(_ref4 => {
+          let {
+            id
+          } = _ref4;
           proxyMapping[id].setDisableAnimation(false);
         });
-        resolve(_objectSpread(_objectSpread({}, state.userData), {}, {
-          $oldToNewIdMapping: $oldToNewIdMapping
-        }));
+        resolve({
+          ...state.userData,
+          $oldToNewIdMapping
+        });
       }).catch(reject);
     });
   };
-
   publicAPI.saveState = function () {
-    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    var userData = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-    return new Promise(function (resolve, reject) {
-      var sources = publicAPI.getSources(); // const representations = publicAPI.getRepresentations();
-
-      var views = publicAPI.getViews(); // Extract handlers
-
-      var datasetHandler = options.datasetHandler || function (d) {
-        return d.getState();
-      };
-
+    let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    let userData = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    return new Promise((resolve, reject) => {
+      const sources = publicAPI.getSources();
+      // const representations = publicAPI.getRepresentations();
+      const views = publicAPI.getViews();
+
+      // Extract handlers
+      const datasetHandler = options.datasetHandler || (d => d.getState());
       delete options.datasetHandler;
-      var datasets = [];
-      var fieldNames = new Set();
-      var state = {
-        userData: userData,
-        options: options,
+      const datasets = [];
+      const fieldNames = new Set();
+      const state = {
+        userData,
+        options,
         sources: [],
         views: [],
         representations: [],
         fields: {}
       };
-      sources.forEach(function (source) {
-        var dataset = Promise.resolve(datasetHandler(source.getDataset(), source));
+      sources.forEach(source => {
+        const dataset = Promise.resolve(datasetHandler(source.getDataset(), source));
         datasets.push(dataset);
         state.sources.push({
           id: source.getProxyId(),
@@ -173,22 +166,23 @@ function addStateAPI(publicAPI, model) {
           props: {
             name: source.getName(),
             type: source.getType(),
-            dataset: dataset
+            dataset
           }
         });
       });
-      views.forEach(function (view) {
-        var camera = view.getCamera().get('position', 'viewUp', 'focalPoint');
+      views.forEach(view => {
+        const camera = view.getCamera().get('position', 'viewUp', 'focalPoint');
         state.views.push({
           id: view.getProxyId(),
           group: view.getProxyGroup(),
           name: view.getProxyName(),
           props: Object.assign(getProperties(view), view.get('axis', 'orientation', 'viewUp')),
-          camera: camera
-        }); // Loop over view representations
+          camera
+        });
 
-        var representations = view.getRepresentations();
-        representations.forEach(function (representation) {
+        // Loop over view representations
+        const representations = view.getRepresentations();
+        representations.forEach(representation => {
           state.representations.push({
             source: representation.getInput().getProxyId(),
             view: view.getProxyId(),
@@ -197,25 +191,21 @@ function addStateAPI(publicAPI, model) {
           fieldNames.add(representation.getColorBy()[0]);
         });
       });
-      fieldNames.forEach(function (fieldName) {
+      fieldNames.forEach(fieldName => {
         state.fields[fieldName] = {
           lookupTable: publicAPI.getLookupTable(fieldName).get('mode', 'presetName', 'rgbPoints', 'hsvPoints', 'nodes', 'arrayName', 'arrayLocation', 'dataRange'),
           piecewiseFunction: publicAPI.getPiecewiseFunction(fieldName).get('mode', 'gaussians', 'points', 'nodes', 'arrayName', 'arrayLocation', 'dataRange')
         };
       });
-      Promise.all(datasets).then(function () {
-        var _loop = function _loop(i) {
-          state.sources[i].props.dataset.then(function (value) {
+      Promise.all(datasets).then(() => {
+        // Patch datasets in state to the result of the promises
+        for (let i = 0; i < state.sources.length; i++) {
+          state.sources[i].props.dataset.then(value => {
             state.sources[i].props.dataset = value;
           });
-        };
-
-        // Patch datasets in state to the result of the promises
-        for (var i = 0; i < state.sources.length; i++) {
-          _loop(i);
-        } // provide valide state
-
+        }
 
+        // provide valide state
         resolve(state);
       }).catch(reject);
     });

package/Proxy/Core/ProxyManager/view.js

@@ -1,108 +1,98 @@
-import macro from '../../../macros.js';
+import { m as macro } from '../../../macros2.js';
 
 function addViewHandlingAPI(publicAPI, model) {
-  publicAPI.create3DView = function (options) {
-    return publicAPI.createProxy('Views', 'View3D', options);
-  }; // --------------------------------------------------------------------------
+  publicAPI.create3DView = options => publicAPI.createProxy('Views', 'View3D', options);
 
+  // --------------------------------------------------------------------------
 
-  publicAPI.create2DView = function (options) {
-    return publicAPI.createProxy('Views', 'View2D', options);
-  }; // --------------------------------------------------------------------------
+  publicAPI.create2DView = options => publicAPI.createProxy('Views', 'View2D', options);
 
+  // --------------------------------------------------------------------------
 
-  publicAPI.render = function (view) {
-    var viewToRender = view || publicAPI.getActiveView();
-
+  publicAPI.render = view => {
+    const viewToRender = view || publicAPI.getActiveView();
     if (viewToRender) {
       viewToRender.renderLater();
     }
-  }; // --------------------------------------------------------------------------
+  };
 
+  // --------------------------------------------------------------------------
 
   publicAPI.renderAllViews = function () {
-    var blocking = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
-    var allViews = publicAPI.getViews();
-
-    for (var i = 0; i < allViews.length; i++) {
+    let blocking = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+    const allViews = publicAPI.getViews();
+    for (let i = 0; i < allViews.length; i++) {
       allViews[i].render(blocking);
     }
-  }; // --------------------------------------------------------------------------
+  };
 
+  // --------------------------------------------------------------------------
 
   publicAPI.setAnimationOnAllViews = function () {
-    var enable = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
-    var allViews = publicAPI.getViews().filter(function (v) {
-      return !enable || v.getContainer();
-    });
-
-    for (var i = 0; i < allViews.length; i++) {
+    let enable = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+    const allViews = publicAPI.getViews().filter(v => !enable || v.getContainer());
+    for (let i = 0; i < allViews.length; i++) {
       allViews[i].setAnimation(enable, publicAPI);
     }
-  }; // --------------------------------------------------------------------------
+  };
 
+  // --------------------------------------------------------------------------
 
   function clearAnimations() {
     model.animating = false;
-    var allViews = publicAPI.getViews();
-
-    for (var i = 0; i < allViews.length; i++) {
+    const allViews = publicAPI.getViews();
+    for (let i = 0; i < allViews.length; i++) {
       allViews[i].setAnimation(false, publicAPI);
     }
-  } // --------------------------------------------------------------------------
+  }
 
+  // --------------------------------------------------------------------------
 
   publicAPI.autoAnimateViews = function () {
-    var debouceTimout = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 250;
-
+    let debouceTimout = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 250;
     if (!model.animating) {
       model.animating = true;
-      var allViews = publicAPI.getViews().filter(function (v) {
-        return v.getContainer();
-      });
-
-      for (var i = 0; i < allViews.length; i++) {
+      const allViews = publicAPI.getViews().filter(v => v.getContainer());
+      for (let i = 0; i < allViews.length; i++) {
         allViews[i].setAnimation(true, publicAPI);
       }
-
       model.clearAnimations = macro.debounce(clearAnimations, debouceTimout);
     }
-
     model.clearAnimations();
-  }; // --------------------------------------------------------------------------
-
+  };
 
-  publicAPI.resizeAllViews = function () {
-    var allViews = publicAPI.getViews();
+  // --------------------------------------------------------------------------
 
-    for (var i = 0; i < allViews.length; i++) {
+  publicAPI.resizeAllViews = () => {
+    const allViews = publicAPI.getViews();
+    for (let i = 0; i < allViews.length; i++) {
       allViews[i].resize();
     }
-  }; // --------------------------------------------------------------------------
-
+  };
 
-  publicAPI.resetCamera = function (view) {
-    var viewToRender = view || publicAPI.getActiveView();
+  // --------------------------------------------------------------------------
 
+  publicAPI.resetCamera = view => {
+    const viewToRender = view || publicAPI.getActiveView();
     if (viewToRender && viewToRender.resetCamera) {
       viewToRender.resetCamera();
     }
-  }; // --------------------------------------------------------------------------
-
+  };
 
-  publicAPI.createRepresentationInAllViews = function (source) {
-    var allViews = publicAPI.getViews();
+  // --------------------------------------------------------------------------
 
-    for (var i = 0; i < allViews.length; i++) {
+  publicAPI.createRepresentationInAllViews = source => {
+    const allViews = publicAPI.getViews();
+    for (let i = 0; i < allViews.length; i++) {
       publicAPI.getRepresentation(source, allViews[i]);
     }
-  }; // --------------------------------------------------------------------------
-
+  };
 
-  publicAPI.resetCameraInAllViews = function () {
-    var allViews = publicAPI.getViews();
+  // --------------------------------------------------------------------------
 
-    for (var i = 0; i < allViews.length; i++) {
+  publicAPI.resetCameraInAllViews = () => {
+    const allViews = publicAPI.getViews();
+    for (let i = 0; i < allViews.length; i++) {
       allViews[i].resetCamera();
     }
   };