ViewProxy

Methods

Source

index.d.ts

import vtkActor from '../../../Rendering/Core/Actor';
import vtkAbstractRepresentationProxy from '../AbstractRepresentationProxy';
import { Vector3, Vector4 } from '../../../types';
import vtkCamera from '../../../Rendering/Core/Camera';
import vtkRenderWindowInteractor from '../../../Rendering/Core/RenderWindowInteractor';
import vtkInteractorStyle from '../../../Rendering/Core/InteractorStyle';
import { vtkSubscription, vtkObject } from '../../../interfaces';
import vtkRenderer from '../../../Rendering/Core/Renderer';
import vtkRenderWindow from '../../../Rendering/Core/RenderWindow';
import vtkOpenGLRenderWindow from '../../../Rendering/OpenGL/RenderWindow';
import vtkWebGPURenderWindow from '../../../Rendering/WebGPU/RenderWindow';
import { VtkProxy } from '../../../macros';

export interface vtkViewProxy extends VtkProxy {
  setPresetToInteractor3D(nameOrDefinitions: string | Object): boolean;
  setPresetToInteractor2D(nameOrDefinitions: string | Object): boolean;

  setOrientationAxesType(type: string): void;
  setOrientationAxesVisibility(visible: boolean): boolean;
  registerOrientationAxis(name: string, actor: vtkActor): void;
  unregisterOrientationAxis(name: string): void;
  listOrientationAxis(): string[];
  setPresetToOrientationAxes(nameOrDefinitions: string | Object): boolean;

  setContainer(container: HTMLElement | null): void;
  resize(): void;
  renderLater(): void;
  render(blocking?: boolean): void;
  resetCamera(): void;

  addRepresentation(representation: vtkAbstractRepresentationProxy): void;
  removeRepresentation(representation: vtkAbstractRepresentationProxy): void;

  // TODO correct?
  captureImage(opts: { format: string } & Object): Array<Promise<string>>;
  openCaptureImage(target: string): void;

  // TODO corner annotations

  setBackground(color: Vector3 | Vector4): void;
  getBackground(): Vector3 | Vector4;

  setAnimation(enable: boolean, requester?: vtkObject);

  updateOrientation(
    axisIndex: 0 | 1 | 2,
    orientation: -1 | 1,
    viewUp: Vector3,
    animateSteps: number
  ): Promise<void>;
  moveCamera(
    focalPoint: Vector3,
    position: Vector3,
    viewUp: Vector3,
    animateSteps: number
  ): Promise<void>;

  resetOrientation(animateSteps: number): void;
  rotate(angle): void;

  focusTo(focalPoint: Vector3): void;

  getCamera(): vtkCamera;
  // getAnnotationOpacity
  getContainer(): HTMLElement | null;
  // getCornerAnnotation
  getInteractor(): vtkRenderWindowInteractor;
  getInteractorStyle2D(): vtkInteractorStyle;
  getInteractorStyle3D(): vtkInteractorStyle;
  getApiSpecificRenderWindow(): vtkOpenGLRenderWindow | vtkWebGPURenderWindow;
  getOrientationAxesType(): string;
  getPresetToOrientationAxes(): any;
  getRenderer(): vtkRenderer;
  getRenderWindow(): vtkRenderWindow;
  getRepresentations(): vtkAbstractRepresentationProxy[];
  getUseParallelRendering(): boolean;
  getDisableAnimation(): boolean;
  setDisableAnimation(disabled: boolean): boolean;

  onResize(
    cb: (size: { width: number; height: number }) => void
  ): vtkSubscription;

  // TODO proxy property mappings
}

export default vtkViewProxy;

index.js

import * as macro from 'vtk.js/Sources/macros';

import vtkAnnotatedCubeActor from 'vtk.js/Sources/Rendering/Core/AnnotatedCubeActor';
import vtkAxesActor from 'vtk.js/Sources/Rendering/Core/AxesActor';
import vtkCornerAnnotation from 'vtk.js/Sources/Interaction/UI/CornerAnnotation';
import vtkInteractorStyleManipulator from 'vtk.js/Sources/Interaction/Style/InteractorStyleManipulator';
import vtkMatrixBuilder from 'vtk.js/Sources/Common/Core/MatrixBuilder';
import 'vtk.js/Sources/Rendering/Misc/RenderingAPIs';
import vtkOrientationMarkerWidget from 'vtk.js/Sources/Interaction/Widgets/OrientationMarkerWidget';
import vtkRenderer from 'vtk.js/Sources/Rendering/Core/Renderer';
import vtkRenderWindow from 'vtk.js/Sources/Rendering/Core/RenderWindow';
import vtkRenderWindowInteractor from 'vtk.js/Sources/Rendering/Core/RenderWindowInteractor';

import InteractionPresets from 'vtk.js/Sources/Interaction/Style/InteractorStyleManipulator/Presets';
import AnnotatedCubePresets from 'vtk.js/Sources/Rendering/Core/AnnotatedCubeActor/Presets';

const EPSILON = 0.000001;

// ----------------------------------------------------------------------------
// vtkViewProxy methods
// ----------------------------------------------------------------------------

function vtkViewProxy(publicAPI, model) {
  // Set our className
  model.classHierarchy.push('vtkViewProxy');

  // Private --------------------------------------------------------------------

  function updateAnnotationColor() {
    const [r, g, b] = model.renderer.getBackground();
    model.cornerAnnotation.getAnnotationContainer().style.color =
      r + g + b > 1.5 ? 'black' : 'white';
  }

  // Setup --------------------------------------------------------------------
  model.renderWindow = vtkRenderWindow.newInstance();
  model.renderer = vtkRenderer.newInstance({ background: [0, 0, 0] });
  model.renderWindow.addRenderer(model.renderer);

  model._openGLRenderWindow = model.renderWindow.newAPISpecificView();
  model.renderWindow.addView(model._openGLRenderWindow);

  model.interactor = vtkRenderWindowInteractor.newInstance();
  model.interactor.setView(model._openGLRenderWindow);

  model.interactorStyle3D = vtkInteractorStyleManipulator.newInstance();
  model.interactorStyle2D = vtkInteractorStyleManipulator.newInstance();

  /**
   * Internal function used by publicAPI.resetCamera()
   */
  model._resetCamera = (bounds = null) => model.renderer.resetCamera(bounds);

  // Apply default interaction styles
  InteractionPresets.applyPreset('3D', model.interactorStyle3D);
  InteractionPresets.applyPreset('2D', model.interactorStyle2D);

  model.cornerAnnotation = vtkCornerAnnotation.newInstance();

  // Setup interaction
  model.interactor.setInteractorStyle(
    model.useParallelRendering
      ? model.interactorStyle2D
      : model.interactorStyle3D
  );
  model.camera = model.renderer.getActiveCamera();
  model.camera.setParallelProjection(!!model.useParallelRendering);

  // Orientation axis setup -------------------------------------------------

  model.orientationAxesArrow = vtkAxesActor.newInstance();
  model.orientationAxesCube = vtkAnnotatedCubeActor.newInstance();
  AnnotatedCubePresets.applyPreset('default', model.orientationAxesCube);
  AnnotatedCubePresets.applyPreset('lps', model.orientationAxesCube);

  model.orientationAxesMap = {
    arrow: model.orientationAxesArrow,
    cube: model.orientationAxesCube,
  };
  model.orientationWidget = vtkOrientationMarkerWidget.newInstance({
    actor: model.orientationAxesArrow,
    interactor: model.renderWindow.getInteractor(),
  });
  model.orientationWidget.setEnabled(true);
  model.orientationWidget.setViewportCorner(
    vtkOrientationMarkerWidget.Corners.BOTTOM_LEFT
  );
  model.orientationWidget.setViewportSize(0.1);

  // API ----------------------------------------------------------------------

  publicAPI.setPresetToInteractor3D = (nameOrDefinitions) => {
    if (Array.isArray(nameOrDefinitions)) {
      return InteractionPresets.applyDefinitions(
        nameOrDefinitions,
        model.interactorStyle3D
      );
    }
    return InteractionPresets.applyPreset(
      nameOrDefinitions,
      model.interactorStyle3D
    );
  };

  // --------------------------------------------------------------------------

  publicAPI.setPresetToInteractor2D = (nameOrDefinitions) => {
    if (Array.isArray(nameOrDefinitions)) {
      return InteractionPresets.applyDefinitions(
        nameOrDefinitions,
        model.interactorStyle2D
      );
    }
    return InteractionPresets.applyPreset(
      nameOrDefinitions,
      model.interactorStyle2D
    );
  };

  // --------------------------------------------------------------------------

  publicAPI.setOrientationAxesType = (type) => {
    const actor = model.orientationAxesMap[type];
    if (actor) {
      model.orientationAxesType = type;
      model.orientationWidget.setActor(actor);
      publicAPI.renderLater();
    }
  };

  // --------------------------------------------------------------------------

  publicAPI.registerOrientationAxis = (name, actor) => {
    model.orientationAxesMap[name] = actor;
  };

  // --------------------------------------------------------------------------

  publicAPI.unregisterOrientationAxis = (name) => {
    delete model.orientationAxesMap[name];
  };

  // --------------------------------------------------------------------------

  publicAPI.listOrientationAxis = () => Object.keys(model.orientationAxesMap);

  // --------------------------------------------------------------------------

  publicAPI.setPresetToOrientationAxes = (nameOrDefinitions) => {
    let changeDetected = false;
    if (typeof nameOrDefinitions === 'string') {
      if (model.presetToOrientationAxes !== nameOrDefinitions) {
        model.presetToOrientationAxes = nameOrDefinitions;
        changeDetected = AnnotatedCubePresets.applyPreset(
          nameOrDefinitions,
          model.orientationAxesCube
        );
        publicAPI.modified();
      }
      return changeDetected;
    }
    model.presetToOrientationAxes = 'Custom';
    changeDetected = AnnotatedCubePresets.applyDefinitions(
      nameOrDefinitions,
      model.orientationAxesCube
    );
    publicAPI.modified();
    return changeDetected;
  };

  // --------------------------------------------------------------------------

  publicAPI.setContainer = (container) => {
    const orientationWidgetEnabled = model.orientationWidget.getEnabled();

    if (model.container) {
      model.orientationWidget.setEnabled(false);
      model.interactor.unbindEvents(model.container);
      model._openGLRenderWindow.setContainer(null);
      model.cornerAnnotation.setContainer(null);
    }

    model.container = container;

    if (container) {
      model._openGLRenderWindow.setContainer(container);
      model.cornerAnnotation.setContainer(container);
      model.interactor.initialize();
      model.interactor.bindEvents(container);
      model.orientationWidget.setEnabled(orientationWidgetEnabled);
    }
  };

  // --------------------------------------------------------------------------

  publicAPI.resize = () => {
    if (model.container) {
      const dims = model.container.getBoundingClientRect();
      if (dims.width === dims.height && dims.width === 0) {
        return;
      }
      const devicePixelRatio = window.devicePixelRatio || 1;
      const width = Math.max(10, Math.floor(devicePixelRatio * dims.width));
      const height = Math.max(10, Math.floor(devicePixelRatio * dims.height));
      model._openGLRenderWindow.setSize(width, height);
      publicAPI.invokeResize({ width, height });
      publicAPI.renderLater();
    }
  };

  // --------------------------------------------------------------------------

  publicAPI.renderLater = () => {
    publicAPI.render(false);
  };

  // --------------------------------------------------------------------------

  publicAPI.render = (blocking = true) => {
    if (model.representations.length > 0 && model.resetCameraOnFirstRender) {
      model.resetCameraOnFirstRender = false;
      publicAPI.resetCamera();
    }
    model.orientationWidget.updateMarkerOrientation();
    model.renderer.resetCameraClippingRange();
    if (blocking) {
      model.renderWindow.render();
    } else {
      setTimeout(model.renderWindow.render, 0);
    }
  };

  // --------------------------------------------------------------------------

  publicAPI.addRepresentation = (representation) => {
    if (!representation) {
      return;
    }
    if (model.representations.indexOf(representation) === -1) {
      model.representations.push(representation);
      model.renderer.addViewProp(representation);
    }
  };

  // --------------------------------------------------------------------------

  publicAPI.removeRepresentation = (representation) => {
    if (!representation) {
      return;
    }
    if (model.representations.indexOf(representation) !== -1) {
      model.representations = model.representations.filter(
        (r) => r !== representation
      );
      model.renderer.removeViewProp(representation);
    }

    if (model.representations.length === 0) {
      model.resetCameraOnFirstRender = true;
    }
  };

  // --------------------------------------------------------------------------

  publicAPI.setCameraParameters = ({
    position,
    focalPoint,
    bounds,
    parallelScale,
    viewAngle,
  }) => {
    if (position != null) {
      model.camera.setPosition(...position);
    }
    if (focalPoint != null) {
      model.camera.setFocalPoint(...focalPoint);
    }
    if (bounds != null) {
      model.renderer.resetCameraClippingRange(bounds);
    } else {
      model.renderer.resetCameraClippingRange();
    }
    if (parallelScale != null) {
      model.camera.setParallelScale(parallelScale);
    }
    if (viewAngle != null) {
      model.camera.setViewAngle(viewAngle);
    }
  };

  // --------------------------------------------------------------------------

  publicAPI.resetCamera = () => {
    model._resetCamera();
    model.interactorStyle2D.setCenterOfRotation(model.camera.getFocalPoint());
    model.interactorStyle3D.setCenterOfRotation(model.camera.getFocalPoint());
    publicAPI.renderLater();
  };

  // --------------------------------------------------------------------------

  publicAPI.captureImage = ({ format = 'image/png', ...opts } = {}) =>
    model.renderWindow.captureImages(format, opts)[0];

  // --------------------------------------------------------------------------

  publicAPI.openCaptureImage = (target = '_blank') => {
    const image = new Image();
    return publicAPI.captureImage().then((imageURL) => {
      image.src = imageURL;
      const w = window.open('', target);
      w.document.write(image.outerHTML);
      w.document.title = 'vtk.js Image Capture';
      window.focus();
    });
  };

  // --------------------------------------------------------------------------

  publicAPI.setCornerAnnotation = (corner, templateString) => {
    model.cornerAnnotation.updateTemplates({
      [corner]: (meta) =>
        vtkCornerAnnotation.applyTemplate(templateString, meta),
    });
  };

  // --------------------------------------------------------------------------

  publicAPI.setCornerAnnotations = (annotations, useTemplateString = false) => {
    if (useTemplateString) {
      Object.keys(annotations).forEach((key) => {
        publicAPI.setCornerAnnotation(key, annotations[key]);
      });
    } else {
      model.cornerAnnotation.updateTemplates(annotations);
    }
  };

  // --------------------------------------------------------------------------

  publicAPI.updateCornerAnnotation = (meta) =>
    model.cornerAnnotation.updateMetadata(meta);

  // --------------------------------------------------------------------------

  publicAPI.setAnnotationOpacity = (opacity) => {
    if (model.annotationOpacity !== Number(opacity)) {
      model.annotationOpacity = Number(opacity);
      model.cornerAnnotation.getAnnotationContainer().style.opacity = opacity;
      publicAPI.modified();
    }
  };

  // --------------------------------------------------------------------------

  publicAPI.setBackground = macro.chain(
    model.renderer.setBackground,
    updateAnnotationColor
  );

  // --------------------------------------------------------------------------

  publicAPI.getBackground = model.renderer.getBackground;

  // --------------------------------------------------------------------------

  publicAPI.setAnimation = (enable, requester = publicAPI) => {
    if (model.disableAnimation && enable) {
      return;
    }
    if (enable) {
      model.renderWindow.getInteractor().requestAnimation(requester);
    } else {
      const skipWarning =
        requester === publicAPI ||
        `${requester}`.indexOf('ViewProxy.moveCamera.') === 0;
      model.renderWindow
        .getInteractor()
        .cancelAnimation(requester, skipWarning);
    }
  };

  // --------------------------------------------------------------------------

  publicAPI.updateOrientation = (
    axisIndex,
    orientation,
    viewUp,
    animateSteps = 0
  ) => {
    if (axisIndex === undefined) {
      return Promise.resolve();
    }

    const originalPosition = model.camera.getPosition();
    const originalViewUp = model.camera.getViewUp();
    const originalFocalPoint = model.camera.getFocalPoint();

    model.axis = axisIndex;
    model.orientation = orientation;
    model.viewUp = viewUp;
    const position = model.camera.getFocalPoint();
    position[model.axis] += model.orientation;
    model.camera.setPosition(...position);
    model.camera.setViewUp(...viewUp);
    model.renderer.resetCamera();

    const destFocalPoint = model.camera.getFocalPoint();
    const destPosition = model.camera.getPosition();
    const destViewUp = model.camera.getViewUp();

    // Reset to original to prevent initial render flash
    model.camera.setFocalPoint(...originalFocalPoint);
    model.camera.setPosition(...originalPosition);
    model.camera.setViewUp(...originalViewUp);

    return publicAPI.moveCamera(
      destFocalPoint,
      destPosition,
      destViewUp,
      animateSteps
    );
  };

  // --------------------------------------------------------------------------

  publicAPI.moveCamera = (focalPoint, position, viewUp, animateSteps = 0) => {
    const originalFocalPoint = model.camera.getFocalPoint();
    const originalPosition = model.camera.getPosition();
    const originalViewUp = model.camera.getViewUp();

    const animationStack = [
      {
        focalPoint,
        position,
        viewUp,
      },
    ];

    if (animateSteps) {
      const deltaFocalPoint = [
        (originalFocalPoint[0] - focalPoint[0]) / animateSteps,
        (originalFocalPoint[1] - focalPoint[1]) / animateSteps,
        (originalFocalPoint[2] - focalPoint[2]) / animateSteps,
      ];
      const deltaPosition = [
        (originalPosition[0] - position[0]) / animateSteps,
        (originalPosition[1] - position[1]) / animateSteps,
        (originalPosition[2] - position[2]) / animateSteps,
      ];
      const deltaViewUp = [
        (originalViewUp[0] - viewUp[0]) / animateSteps,
        (originalViewUp[1] - viewUp[1]) / animateSteps,
        (originalViewUp[2] - viewUp[2]) / animateSteps,
      ];

      const needSteps =
        deltaFocalPoint[0] ||
        deltaFocalPoint[1] ||
        deltaFocalPoint[2] ||
        deltaPosition[0] ||
        deltaPosition[1] ||
        deltaPosition[2] ||
        deltaViewUp[0] ||
        deltaViewUp[1] ||
        deltaViewUp[2];

      const focalPointDeltaAxisCount = deltaFocalPoint
        .map((i) => (Math.abs(i) < EPSILON ? 0 : 1))
        .reduce((a, b) => a + b, 0);
      const positionDeltaAxisCount = deltaPosition
        .map((i) => (Math.abs(i) < EPSILON ? 0 : 1))
        .reduce((a, b) => a + b, 0);
      const viewUpDeltaAxisCount = deltaViewUp
        .map((i) => (Math.abs(i) < EPSILON ? 0 : 1))
        .reduce((a, b) => a + b, 0);
      const rotation180Only =
        viewUpDeltaAxisCount === 1 &&
        positionDeltaAxisCount === 0 &&
        focalPointDeltaAxisCount === 0;

      if (needSteps) {
        if (rotation180Only) {
          const availableAxes = originalFocalPoint
            .map((fp, i) =>
              Math.abs(originalPosition[i] - fp) < EPSILON ? i : null
            )
            .filter((i) => i !== null);
          const axisCorrectionIndex = availableAxes.find(
            (v) => Math.abs(deltaViewUp[v]) < EPSILON
          );
          for (let i = 0; i < animateSteps; i++) {
            const newViewUp = [
              viewUp[0] + (i + 1) * deltaViewUp[0],
              viewUp[1] + (i + 1) * deltaViewUp[1],
              viewUp[2] + (i + 1) * deltaViewUp[2],
            ];
            newViewUp[axisCorrectionIndex] = Math.sin(
              (Math.PI * i) / (animateSteps - 1)
            );
            animationStack.push({
              focalPoint,
              position,
              viewUp: newViewUp,
            });
          }
        } else {
          for (let i = 0; i < animateSteps; i++) {
            animationStack.push({
              focalPoint: [
                focalPoint[0] + (i + 1) * deltaFocalPoint[0],
                focalPoint[1] + (i + 1) * deltaFocalPoint[1],
                focalPoint[2] + (i + 1) * deltaFocalPoint[2],
              ],
              position: [
                position[0] + (i + 1) * deltaPosition[0],
                position[1] + (i + 1) * deltaPosition[1],
                position[2] + (i + 1) * deltaPosition[2],
              ],
              viewUp: [
                viewUp[0] + (i + 1) * deltaViewUp[0],
                viewUp[1] + (i + 1) * deltaViewUp[1],
                viewUp[2] + (i + 1) * deltaViewUp[2],
              ],
            });
          }
        }
      }
    }

    if (animationStack.length === 1) {
      // update camera directly
      model.camera.set(animationStack.pop());
      model.renderer.resetCameraClippingRange();
      if (model.interactor.getLightFollowCamera()) {
        model.renderer.updateLightsGeometryToFollowCamera();
      }
      return Promise.resolve();
    }

    return new Promise((resolve, reject) => {
      const now = performance.now().toString();
      const animationRequester = `ViewProxy.moveCamera.${now}`;
      publicAPI.setAnimation(true, animationRequester);
      let intervalId = null;
      const consumeAnimationStack = () => {
        if (animationStack.length) {
          const {
            focalPoint: cameraFocalPoint,
            position: cameraPosition,
            viewUp: cameraViewUp,
          } = animationStack.pop();
          model.camera.setFocalPoint(...cameraFocalPoint);
          model.camera.setPosition(...cameraPosition);
          model.camera.setViewUp(...cameraViewUp);
          model.renderer.resetCameraClippingRange();

          if (model.interactor.getLightFollowCamera()) {
            model.renderer.updateLightsGeometryToFollowCamera();
          }
        } else {
          clearInterval(intervalId);
          publicAPI.setAnimation(false, animationRequester);
          resolve();
        }
      };
      intervalId = setInterval(consumeAnimationStack, 1);
    });
  };

  // --------------------------------------------------------------------------

  publicAPI.resetOrientation = (animateSteps = 0) =>
    publicAPI.updateOrientation(
      model.axis,
      model.orientation,
      model.viewUp,
      animateSteps
    );

  // --------------------------------------------------------------------------

  publicAPI.rotate = (angle) => {
    const { viewUp, focalPoint, position } = model.camera.get(
      'viewUp',
      'focalPoint',
      'position'
    );
    const axis = [
      focalPoint[0] - position[0],
      focalPoint[1] - position[1],
      focalPoint[2] - position[2],
    ];

    vtkMatrixBuilder
      .buildFromDegree()
      .rotate(Number.isNaN(angle) ? 90 : angle, axis)
      .apply(viewUp);

    model.camera.setViewUp(...viewUp);
    model.camera.modified();
    model.orientationWidget.updateMarkerOrientation();
    model.renderWindow.render();
  };

  // --------------------------------------------------------------------------

  publicAPI.focusTo = macro.chain(
    model.camera.setFocalPoint,
    model.interactorStyle2D.setCenterOfRotation,
    model.interactorStyle3D.setCenterOfRotation
  );

  // --------------------------------------------------------------------------

  publicAPI.delete = macro.chain(() => {
    publicAPI.setContainer(null);
    model.orientationWidget.setEnabled(false);
    model.orientationWidget.delete();
    model.orientationAxesArrow.delete();
    model.orientationAxesCube.delete();
    model.interactorStyle2D.delete();
    model.interactorStyle3D.delete();
    model.cornerAnnotation.delete();
    // in reverse order
    model.interactor.delete();
    model.renderer.delete();
    model._openGLRenderWindow.delete();
    model.renderWindow.delete();
  }, publicAPI.delete);

  // --------------------------------------------------------------------------
  // Initialization from state or input
  // --------------------------------------------------------------------------

  publicAPI.resetOrientation();
  updateAnnotationColor();
}

// ----------------------------------------------------------------------------
// Object factory
// ----------------------------------------------------------------------------

const DEFAULT_VALUES = {
  representations: [],
  sectionName: 'view',
  annotationOpacity: 1,
  resetCameraOnFirstRender: true,
  presetToOrientationAxes: 'lps',
  orientationAxesType: 'arrow',
  disableAnimation: false,
  axis: 1,
  orientation: 0,
  viewUp: [0, 0, 1],
};

// ----------------------------------------------------------------------------

function extend(publicAPI, model, initialValues = {}) {
  Object.assign(model, DEFAULT_VALUES, initialValues);

  macro.obj(publicAPI, model);
  macro.setGet(publicAPI, model, [
    'name',
    'disableAnimation',
    'resetCameraOnFirstRender',
  ]);
  macro.get(publicAPI, model, [
    'annotationOpacity',
    'camera',
    'container',
    'cornerAnnotation',
    'interactor',
    'interactorStyle2D',
    'interactorStyle3D',
    '_openGLRenderWindow', // todo breaking? convert to apiSpecificWindow
    'orientationAxesType',
    'presetToOrientationAxes',
    'renderer',
    'renderWindow',
    'representations',
    'useParallelRendering',
  ]);
  macro.moveToProtected(publicAPI, model, ['openGLRenderWindow']);
  macro.event(publicAPI, model, 'Resize');

  // Object specific methods
  vtkViewProxy(publicAPI, model);

  // Proxy handling
  macro.proxy(publicAPI, model);
  macro.proxyPropertyMapping(publicAPI, model, {
    orientationAxesVisibility: {
      modelKey: 'orientationWidget',
      property: 'enabled',
    },
    orientationAxesCorner: {
      modelKey: 'orientationWidget',
      property: 'viewportCorner',
    },
    orientationAxesSize: {
      modelKey: 'orientationWidget',
      property: 'viewportSize',
    },
    cameraViewUp: { modelKey: 'camera', property: 'viewUp', modified: false },
    cameraPosition: {
      modelKey: 'camera',
      property: 'position',
      modified: false,
    },
    cameraFocalPoint: {
      modelKey: 'camera',
      property: 'focalPoint',
      modified: false,
    },
  });
}

// ----------------------------------------------------------------------------

export const newInstance = macro.newInstance(extend, 'vtkViewProxy');

// ----------------------------------------------------------------------------

export default { newInstance, extend };