@vertexvis/viewer 0.18.1 → 0.18.2-testing.0

package/dist/components/scene.js

@@ -0,0 +1,1508 @@
+/*!
+ * Copyright (c) 2023 Vertex Software LLC. All rights reserved.
+ */
+import { c as color, u as uri, a as async, b as uuid } from './browser.esm.js';
+import { I as InvalidResourceUrnError, a as InvalidCameraError, b as InvalidArgumentError } from './errors.js';
+import { v as vector3, b as boundingBox, a as boundingSphere, m as matrix4, q as quaternion, r as ray, p as point, d as dimensions } from './bundle.esm.js';
+import { v as vertexvis, t as toProtobuf, e as FramePerspectiveCamera, g as constrainViewVector, d as FrameOrthographicCamera, w as withPositionAndViewVector, h as fromBoundingBoxAndLookAtCamera } from './streamAttributes.js';
+import { t as toProtoDuration } from './bundle.esm2.js';
+
+const defaultColor = {
+  opacity: 255,
+  glossiness: 4,
+  diffuse: {
+    r: 0,
+    g: 0,
+    b: 0,
+    a: 0,
+  },
+  ambient: {
+    r: 0,
+    g: 0,
+    b: 0,
+    a: 0,
+  },
+  specular: {
+    r: 0,
+    g: 0,
+    b: 0,
+    a: 0,
+  },
+  emissive: {
+    r: 0,
+    g: 0,
+    b: 0,
+    a: 0,
+  },
+};
+/**
+ * This helper creats an rgb value color
+ * @param hex
+ * @param opacity
+ */
+const create = (r, g, b, opacity) => {
+  return Object.assign(Object.assign({}, defaultColor), { opacity: opacity !== null && opacity !== void 0 ? opacity : defaultColor.opacity, diffuse: {
+      r,
+      g,
+      b,
+      a: 0,
+    } });
+};
+/**
+ * This helper converts a hex string to a ColorMaterial object
+ * @param hex
+ * @param opacity
+ */
+const fromHex = (hex, opacity) => {
+  const color$1 = color.fromHexString(hex);
+  return Object.assign(Object.assign({}, defaultColor), { opacity: opacity !== null && opacity !== void 0 ? opacity : defaultColor.opacity, diffuse: color$1 != null ? Object.assign({}, color$1) : Object.assign({}, defaultColor.diffuse) });
+};
+
+const colorMaterial = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  defaultColor: defaultColor,
+  create: create,
+  fromHex: fromHex
+});
+
+function fromUrn(urn) {
+  var _a;
+  const uri$1 = uri.parse(urn);
+  if (uri$1.scheme !== 'urn' || uri$1.path == null) {
+    throw new Error('Invalid URN. Expected URN scheme.');
+  }
+  const [nid, resourceType, resourceId, ...subResourcePath] = uri$1.path.split(/[:/]/);
+  if (nid !== 'vertexvis' && nid !== 'vertex') {
+    throw new Error('Invalid URN. Expected URN to be vertex namespace');
+  }
+  if (nid === 'vertexvis') {
+    console.warn("vertexvis namespace is deprecated. Use 'vertex' for the namespace urn instead");
+  }
+  switch (resourceType) {
+    case 'stream-key':
+      const queries = fromQuery(uri$1.query);
+      const subResource = (_a = fromSubResourcePath(subResourcePath.join('/'))) !== null && _a !== void 0 ? _a : queries.find((q) => q.type === 'scene-view-state');
+      return {
+        resource: { type: 'stream-key', id: resourceId },
+        subResource,
+        queries: queries.filter((q) => q.type !== 'scene-view-state'),
+      };
+    default:
+      throw new InvalidResourceUrnError(`Invalid URN. Unknown resource type ${resourceType}`);
+  }
+}
+function fromSubResourcePath(path) {
+  if (path != null) {
+    const [subResourceType, subResourceId] = path.split('/');
+    switch (subResourceType) {
+      case 'scene-view-states':
+        return {
+          type: 'scene-view-state',
+          id: subResourceId,
+        };
+      default:
+        return undefined;
+    }
+  }
+}
+function fromQuery(query) {
+  if (query != null) {
+    return query.split('&').map((queryFragment) => {
+      const [resourceType, resourceId] = queryFragment.split('=');
+      switch (resourceType) {
+        case 'supplied-id':
+          return { type: 'supplied-id', id: resourceId };
+        case 'scene-view-state':
+          return { type: 'scene-view-state', id: resourceId };
+        default:
+          throw new Error('Invalid URN. Unknown query value type');
+      }
+    });
+  }
+  else {
+    return [];
+  }
+}
+
+const loadableResource = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  fromUrn: fromUrn
+});
+
+function isSceneViewStateId(identifier) {
+  return identifier.id != null;
+}
+function isSceneViewStateSuppliedId(identifier) {
+  return identifier.suppliedId != null;
+}
+
+/**
+ * A `SynchronizedClock` allows for approximating the time on a remote machine.
+ *
+ * During initialization, a known time of the remote host must be supplied. Once
+ * the remote time is known, this class can approximate the time on the remote
+ * machine from a date or duration.
+ *
+ * @example
+ * ```
+ * const knownRemoteTime = await getRemoteTime();
+ * const clock = new SynchronizedClock(knownRemoteTime);
+ *
+ * const localDate = new Date();
+ * const serverTime = clock.remoteTime(localDate);
+ *
+ * const remoteDate = await getRemoteTime();
+ * const localTime = clock.localTime(remoteDate);
+ *
+ * const currentRemoteTime = clock.remoteNow();
+ * ```
+ */
+class SynchronizedClock {
+  constructor(knownRemoteTime, knownLocalTime = new Date()) {
+    this.knownRemoteTime = knownRemoteTime;
+    this.knownLocalTime = knownLocalTime;
+  }
+  /**
+   * Computes an offset duration from when this clock was instantiated.
+   */
+  localOffset() {
+    return this.duration(this.knownLocalTime, this.localNow());
+  }
+  /**
+   * Approximates the local time from a remote timestamp or duration.
+   *
+   * @param remoteTimeOrDurationInMs A remote timestamp or duration.
+   */
+  localTime(remoteTimeOrDurationInMs) {
+    const remoteTime = typeof remoteTimeOrDurationInMs === 'number'
+      ? new Date(this.knownLocalTime.getTime() + remoteTimeOrDurationInMs)
+      : remoteTimeOrDurationInMs;
+    const duration = this.duration(this.knownRemoteTime, remoteTime);
+    return this.addDuration(this.knownLocalTime, duration);
+  }
+  /**
+   * Approximates an offset duration on the remote machine.
+   *
+   * @param localTime A local timestamp. Defaults to the current local time.
+   */
+  remoteOffset(localTime = new Date()) {
+    return this.duration(this.remoteTime(this.knownLocalTime), this.remoteTime(localTime));
+  }
+  /**
+   * Approximates the current time on the remote machine.
+   */
+  remoteNow() {
+    return this.remoteTime(this.localNow());
+  }
+  /**
+   * Approximates the remote time from either a local timestamp or duration.
+   *
+   * @param localTimeOrDurationInMs A local timestamp or duration.
+   */
+  remoteTime(localTimeOrDurationInMs) {
+    const localTime = typeof localTimeOrDurationInMs === 'number'
+      ? new Date(this.knownLocalTime.getTime() + localTimeOrDurationInMs)
+      : localTimeOrDurationInMs;
+    const duration = this.duration(this.knownLocalTime, localTime);
+    return this.addDuration(this.knownRemoteTime, duration);
+  }
+  addDuration(start, duration) {
+    return new Date(start.getTime() + duration);
+  }
+  duration(start, end) {
+    return end.getTime() - start.getTime();
+  }
+  localNow() {
+    return new Date(Date.now());
+  }
+}
+
+const DEFAULT_TIMEOUT_IN_MS = 1000 * 10;
+class StreamApiEventDispatcher {
+  constructor(stream, predicate, transform, timeout = DEFAULT_TIMEOUT_IN_MS) {
+    this.stream = stream;
+    this.predicate = predicate;
+    this.transform = transform;
+    this.timeout = timeout;
+    this.listeners = [];
+    this.handleMessage = this.handleMessage.bind(this);
+  }
+  on(listener) {
+    this.listeners = [...this.listeners, listener];
+    if (this.eventDisposable == null || this.requestDisposable == null) {
+      this.addListeners();
+    }
+  }
+  off(listener) {
+    this.listeners = this.listeners.filter((l) => l !== listener);
+    if (this.listeners.length === 0) {
+      this.removeListeners();
+    }
+  }
+  once() {
+    let handler;
+    return async.timeout(this.timeout, new Promise((resolve) => {
+      handler = (data) => {
+        resolve(data);
+        this.off(handler);
+      };
+      this.on(handler);
+    })).finally(() => {
+      this.off(handler);
+    });
+  }
+  handleMessage(msg) {
+    if (this.predicate(msg)) {
+      const transformed = this.transform(msg);
+      if (transformed != null) {
+        this.listeners.forEach((l) => l(transformed));
+      }
+    }
+  }
+  addListeners() {
+    this.eventDisposable = this.stream.onEvent(this.handleMessage);
+    this.requestDisposable = this.stream.onRequest(this.handleMessage);
+  }
+  removeListeners() {
+    var _a, _b;
+    (_a = this.eventDisposable) === null || _a === void 0 ? void 0 : _a.dispose();
+    (_b = this.requestDisposable) === null || _b === void 0 ? void 0 : _b.dispose();
+  }
+}
+
+class CameraRenderResult {
+  constructor(stream, decodeFrame, { animationId, correlationId }, timeout) {
+    this.data = undefined;
+    this.onAnimationCompleted = new StreamApiEventDispatcher(stream, (msg) => { var _a, _b, _c; return ((_c = (_b = (_a = msg.event) === null || _a === void 0 ? void 0 : _a.animationCompleted) === null || _b === void 0 ? void 0 : _b.animationId) === null || _c === void 0 ? void 0 : _c.hex) === animationId; }, (msg) => { var _a, _b, _c; return ((_c = (_b = (_a = msg.event) === null || _a === void 0 ? void 0 : _a.animationCompleted) === null || _b === void 0 ? void 0 : _b.animationId) === null || _c === void 0 ? void 0 : _c.hex) || undefined; }, timeout);
+    this.onFrameReceived = new StreamApiEventDispatcher(stream, (msg) => {
+      var _a, _b, _c;
+      return !!((_c = (_b = (_a = msg.request) === null || _a === void 0 ? void 0 : _a.drawFrame) === null || _b === void 0 ? void 0 : _b.frameCorrelationIds) === null || _c === void 0 ? void 0 : _c.some((id) => id === correlationId));
+    }, (msg) => {
+      var _a;
+      return ((_a = msg.request) === null || _a === void 0 ? void 0 : _a.drawFrame) != null
+        ? decodeFrame(msg.request.drawFrame)
+        : undefined;
+    }, timeout);
+  }
+}
+
+function buildSceneViewStateIdentifier(identifier) {
+  if (typeof identifier === 'string') {
+    return { sceneViewStateId: { hex: identifier } };
+  }
+  else if (isSceneViewStateId(identifier)) {
+    return { sceneViewStateId: { hex: identifier.id } };
+  }
+  else if (isSceneViewStateSuppliedId(identifier)) {
+    return { sceneViewStateSuppliedId: { value: identifier.suppliedId } };
+  }
+  else {
+    throw new Error('Unable to build scene view state identifier, input must be a string or `SceneViewStateIdentifier`.');
+  }
+}
+function buildQueryExpression(query, context) {
+  switch (query.type) {
+    case 'and':
+    case 'or':
+      return {
+        operand: {
+          itemCollection: {
+            queries: query.expressions.map((exp) => ({
+              sceneItemQuery: buildSceneItemQuery(exp),
+            })),
+          },
+        },
+      };
+    case 'not':
+      return {
+        not: {
+          expression: buildQueryExpression(query.query, context),
+        },
+      };
+    case 'item-id':
+    case 'supplied-id':
+      return {
+        operand: {
+          item: {
+            sceneItemQuery: buildSceneItemQuery(query),
+          },
+        },
+      };
+    case 'all':
+      return {
+        operand: {
+          root: {},
+        },
+      };
+    case 'scene-tree-range':
+      return {
+        operand: {
+          sceneTreeRange: {
+            start: query.range.start,
+            end: query.range.end,
+          },
+        },
+      };
+    case 'metadata':
+      return {
+        operand: {
+          metadata: {
+            valueFilter: query.filter,
+            keys: query.keys,
+            exactMatch: query.exactMatch,
+          },
+        },
+      };
+    case 'all-selected':
+      return {
+        operand: {
+          override: {
+            selection: {},
+          },
+        },
+      };
+    case 'point':
+      return {
+        operand: {
+          point: {
+            point: query.point,
+            viewport: context.dimensions,
+          },
+        },
+      };
+    case 'volume-intersection':
+      return {
+        operand: {
+          volume: {
+            frustumByRectangle: {
+              rectangle: query.rectangle,
+            },
+            exclusive: query.exclusive,
+            viewport: context.dimensions,
+          },
+        },
+      };
+    default:
+      return {};
+  }
+}
+function buildSceneOperation(query, operations, context) {
+  const operationTypes = buildOperationTypes(operations);
+  const queryExpression = buildQueryExpression(query, context);
+  return {
+    queryExpression,
+    operationTypes,
+  };
+}
+function buildSceneItemQuery(item) {
+  switch (item.type) {
+    case 'item-id':
+      return {
+        id: new vertexvis.protobuf.core.Uuid({
+          hex: item.value,
+        }),
+      };
+    case 'supplied-id':
+      return {
+        suppliedId: item.value,
+      };
+    default:
+      return {};
+  }
+}
+function buildFlyToOperation(frameCorrelationId, options, animation) {
+  const payload = {
+    frameCorrelationId: {
+      value: frameCorrelationId,
+    },
+    animation: animation
+      ? {
+        duration: toProtoDuration(animation.milliseconds),
+      }
+      : undefined,
+  };
+  switch (options.flyTo.type) {
+    case 'supplied': {
+      return Object.assign(Object.assign({}, payload), { itemSuppliedId: options.flyTo.data });
+    }
+    case 'internal': {
+      return Object.assign(Object.assign({}, payload), { itemId: new vertexvis.protobuf.core.Uuid({
+          hex: options.flyTo.data,
+        }) });
+    }
+    case 'camera': {
+      return Object.assign(Object.assign({}, payload), { camera: toProtobuf(options.flyTo.data) });
+    }
+    case 'bounding-box': {
+      return Object.assign(Object.assign({}, payload), { boundingBox: {
+          xmin: options.flyTo.data.min.x,
+          xmax: options.flyTo.data.max.x,
+          ymin: options.flyTo.data.min.y,
+          ymax: options.flyTo.data.max.y,
+          zmin: options.flyTo.data.min.z,
+          zmax: options.flyTo.data.max.z,
+        } });
+    }
+    default:
+      return {};
+  }
+}
+function buildOperationTypes(operations) {
+  return operations.map((op) => {
+    var _a, _b;
+    switch (op.type) {
+      case 'change-material':
+        return {
+          changeMaterial: {
+            material: {
+              d: op.material.opacity,
+              ns: op.material.glossiness,
+              ka: op.material.ambient,
+              kd: op.material.diffuse,
+              ks: op.material.specular,
+              ke: op.material.emissive,
+            },
+          },
+        };
+      case 'clear-override':
+        return {
+          changeMaterial: {},
+        };
+      case 'change-transform':
+        return {
+          changeTransform: {
+            transform: Object.assign({}, op.transform),
+          },
+        };
+      case 'clear-transform':
+        return {
+          clearTransform: {
+            cascade: op.cascade,
+          },
+        };
+      case 'hide':
+        return {
+          changeVisibility: {
+            visible: false,
+          },
+        };
+      case 'show':
+        return {
+          changeVisibility: {
+            visible: true,
+          },
+        };
+      case 'select':
+        return {
+          changeSelection: { selected: true },
+        };
+      case 'deselect':
+        return {
+          changeSelection: { selected: false },
+        };
+      case 'change-phantom':
+        return {
+          changePhantom: { phantom: (_a = op.phantomState) !== null && _a !== void 0 ? _a : true },
+        };
+      case 'clear-phantom':
+        return {
+          changePhantom: { phantom: false },
+        };
+      case 'change-end-item':
+        return {
+          changeEndItem: { endItem: (_b = op.endItemState) !== null && _b !== void 0 ? _b : true },
+        };
+      case 'clear-end-item':
+        return {
+          changeEndItem: { endItem: false },
+        };
+      default:
+        return {};
+    }
+  });
+}
+function toPbSceneViewStateFeatures(features) {
+  return features.map((feature) => {
+    switch (feature) {
+      case 'camera':
+        return vertexvis.protobuf.stream.SceneViewStateFeature
+          .SCENE_VIEW_STATE_FEATURE_CAMERA;
+      case 'material_overrides':
+        return vertexvis.protobuf.stream.SceneViewStateFeature
+          .SCENE_VIEW_STATE_FEATURE_MATERIAL_OVERRIDE;
+      case 'selection':
+        return vertexvis.protobuf.stream.SceneViewStateFeature
+          .SCENE_VIEW_STATE_FEATURE_SELECTION;
+      case 'visibility':
+        return vertexvis.protobuf.stream.SceneViewStateFeature
+          .SCENE_VIEW_STATE_FEATURE_VISIBILITY;
+      case 'transforms':
+        return vertexvis.protobuf.stream.SceneViewStateFeature
+          .SCENE_VIEW_STATE_FEATURE_TRANSFORM;
+      case 'cross_section':
+        return vertexvis.protobuf.stream.SceneViewStateFeature
+          .SCENE_VIEW_STATE_FEATURE_CROSS_SECTION;
+      default:
+        return vertexvis.protobuf.stream.SceneViewStateFeature
+          .SCENE_VIEW_STATE_FEATURE_INVALID;
+    }
+  });
+}
+
+const PI_OVER_360 = 0.008726646259972;
+class TerminalFlyToExecutor {
+  constructor(flyToOptions) {
+    this.flyToOptions = flyToOptions;
+  }
+  build() {
+    return this.flyToOptions;
+  }
+}
+class FlyToExecutor {
+  withItemId(id) {
+    return new TerminalFlyToExecutor({
+      flyTo: {
+        type: 'internal',
+        data: id,
+      },
+    });
+  }
+  withSuppliedId(id) {
+    return new TerminalFlyToExecutor({
+      flyTo: {
+        type: 'supplied',
+        data: id,
+      },
+    });
+  }
+  withCamera(camera) {
+    return new TerminalFlyToExecutor({
+      flyTo: {
+        type: 'camera',
+        data: camera,
+      },
+    });
+  }
+  withBoundingBox(boundingBox) {
+    return new TerminalFlyToExecutor({
+      flyTo: {
+        type: 'bounding-box',
+        data: boundingBox,
+      },
+    });
+  }
+  build() {
+    return this.flyToOptions;
+  }
+}
+/**
+ * The `Camera` class contains properties that reflect a world space position, a
+ * view direction (lookAt), and normalized vector representing the up direction.
+ *
+ * It also provides utility methods to update orientation of the camera and
+ * rerender the scene.
+ *
+ * This class in intended to treated as an immutable type. Any mutations return
+ * a new instance of the class with the updated properties.
+ */
+class Camera {
+  constructor(stream, aspect, data, boundingBox, decodeFrame, flyToOptions) {
+    this.stream = stream;
+    this.aspect = aspect;
+    this.data = data;
+    this.boundingBox = boundingBox;
+    this.decodeFrame = decodeFrame;
+    this.flyToOptions = flyToOptions;
+  }
+  fitCameraToBoundingBox(boundingBox$1, distance, viewVector) {
+    const vvec = vector3.scale(distance, vector3.normalize(viewVector));
+    const lookAt = boundingBox.center(boundingBox$1);
+    const position = vector3.subtract(lookAt, vvec);
+    return this.update({ lookAt, position, viewVector: vvec });
+  }
+  /**
+   * Returns the distance from the camera's position to the center
+   * of the provided bounding box (or the scene's visible bounding box if not provided).
+   *
+   * @param boundingBox - The bounding box to determine distance from.
+   */
+  signedDistanceToBoundingBoxCenter(boundingBox$1) {
+    const { position, viewVector } = withPositionAndViewVector(this.data);
+    const boundingBoxCenter = boundingBox.center(boundingBox$1 !== null && boundingBox$1 !== void 0 ? boundingBox$1 : this.boundingBox);
+    const cameraToCenter = vector3.subtract(boundingBoxCenter, position);
+    return (vector3.dot(viewVector, cameraToCenter) / vector3.magnitude(viewVector));
+  }
+  /**
+   * Specifies that the next render of the camera will be repositioned to one of
+   * the options specified in `options`.
+   *
+   * @param paramsOrQuery An object or query describing how the camera should
+   * be positioned.
+   */
+  flyTo(paramsOrQuery) {
+    if (typeof paramsOrQuery !== 'function') {
+      return this.updateFlyToOptions({
+        flyTo: this.buildFlyToType(paramsOrQuery),
+      });
+    }
+    else {
+      return this.updateFlyToOptions(paramsOrQuery(new FlyToExecutor()).build());
+    }
+  }
+  viewAll() {
+    return this.fitToBoundingBox(this.boundingBox);
+  }
+  /**
+   * Queues the rendering for a new frame using this camera. The returned
+   * promise will resolve when a frame is received that contains this camera.
+   */
+  async render(renderOptions) {
+    var _a, _b, _c;
+    if (this.flyToOptions == null && renderOptions != null) {
+      this.flyToOptions = {
+        flyTo: {
+          type: 'camera',
+          data: this.data,
+        },
+      };
+    }
+    try {
+      const corrId = uuid.create();
+      if (this.flyToOptions != null) {
+        const payload = buildFlyToOperation(corrId, this.flyToOptions, renderOptions === null || renderOptions === void 0 ? void 0 : renderOptions.animation);
+        const flyToResponse = await this.stream.flyTo(payload, true);
+        return new CameraRenderResult(this.stream, this.decodeFrame, {
+          correlationId: corrId,
+          animationId: ((_b = (_a = flyToResponse.flyTo) === null || _a === void 0 ? void 0 : _a.animationId) === null || _b === void 0 ? void 0 : _b.hex) || undefined,
+        }, ((_c = renderOptions === null || renderOptions === void 0 ? void 0 : renderOptions.animation) === null || _c === void 0 ? void 0 : _c.milliseconds) != null
+          ? renderOptions.animation.milliseconds + DEFAULT_TIMEOUT_IN_MS
+          : undefined);
+      }
+      else {
+        this.stream.replaceCamera({
+          camera: toProtobuf(this.data),
+          frameCorrelationId: { value: corrId },
+        });
+        return new CameraRenderResult(this.stream, this.decodeFrame, {
+          correlationId: corrId,
+        });
+      }
+    }
+    catch (e) {
+      console.warn('Error when performing render: ', e);
+      throw e;
+    }
+  }
+  /**
+   * Repositions the camera by rotating its current position around an axis.
+   *
+   * @param angleInRadians The angle, in radians, to rotate.
+   * @param axis A normalized vector to rotate around.
+   */
+  rotateAroundAxis(angleInRadians, axis) {
+    return this.rotateAroundAxisAtPoint(angleInRadians, this.data.lookAt, axis);
+  }
+  /**
+   * Aligns the camera to the plane defined by the provided position and normal.
+   * This will place the camera at the provided position, set the up vector to
+   * the provided normal, and place the lookAt on the defined plane. The point
+   * chosen for the lookAt will be determined using the current view vector.
+   *
+   * @param position The position to place the camera at.
+   * @param normal The normal of the plane to align to.
+   */
+  alignTo(position, normal) {
+    const worldX = vector3.normalize(vector3.cross(this.up, vector3.normalize(this.viewVector)));
+    const positiveWorldY = vector3.normalize(vector3.cross(vector3.normalize(this.viewVector), worldX));
+    // Invert the world y axis if the provided normal is more than 90 degrees from it
+    // to compute a proper angle to rotate the view vector by
+    const worldY = vector3.angleTo(normal, positiveWorldY) > Math.PI / 2
+      ? vector3.negate(positiveWorldY)
+      : positiveWorldY;
+    const localX = vector3.isEqual(worldY, normal)
+      ? worldX
+      : vector3.normalize(vector3.cross(worldY, normal));
+    const transformedViewVector = vector3.transformMatrix(this.viewVector, matrix4.makeRotation(quaternion.fromAxisAngle(localX, vector3.angleTo(normal, worldY))));
+    const lookAtRay = ray.create({
+      origin: position,
+      direction: vector3.normalize(transformedViewVector),
+    });
+    const lookAt = ray.at(lookAtRay, vector3.magnitude(this.viewVector));
+    return this.update({
+      position,
+      lookAt,
+      up: normal,
+    });
+  }
+  /**
+   * Updates the `position` and `up` vectors of the camera to the given standard
+   * view.
+   *
+   * @param standardView The standard view to apply.
+   * @returns A new camera.
+   */
+  standardView(standardView) {
+    return this.update({
+      position: standardView.position,
+      viewVector: vector3.subtract(vector3.origin(), standardView.position),
+      lookAt: vector3.origin(),
+      up: standardView.up,
+    });
+  }
+  buildFlyToType(options) {
+    if (options.boundingBox != null) {
+      return { type: 'bounding-box', data: options.boundingBox };
+    }
+    else if (options.camera != null) {
+      return { type: 'camera', data: options.camera };
+    }
+    else if (options.itemId != null) {
+      return { type: 'internal', data: options.itemId };
+    }
+    else if (options.itemSuppliedId != null) {
+      return { type: 'supplied', data: options.itemSuppliedId };
+    }
+    else {
+      throw new Error('Fly to must specify at least one option.');
+    }
+  }
+  computeClippingPlanes(camera) {
+    return fromBoundingBoxAndLookAtCamera(this.boundingBox, camera);
+  }
+}
+class PerspectiveCamera extends Camera {
+  constructor(stream, aspect, perspectiveData, boundingBox, decodeFrame, flyToOptions) {
+    super(stream, aspect, perspectiveData, boundingBox, decodeFrame, flyToOptions);
+    this.perspectiveData = perspectiveData;
+  }
+  /**
+   * Shifts the position of the camera by the given delta.
+   *
+   * @param delta The number of units to shift the camera on the X, Y, and Z
+   * axis.
+   */
+  moveBy(delta) {
+    return this.update({
+      position: vector3.add(this.position, delta),
+      lookAt: vector3.add(this.lookAt, delta),
+    });
+  }
+  rotateAroundAxisAtPoint(angleInRadians, point, axis) {
+    return this.update({
+      position: vector3.rotateAboutAxis(angleInRadians, this.position, axis, point),
+      lookAt: vector3.rotateAboutAxis(angleInRadians, this.lookAt, axis, point),
+      up: vector3.rotateAboutAxis(angleInRadians, this.up, axis, vector3.origin()),
+    });
+  }
+  fitToBoundingBox(boundingBox$1) {
+    var _a;
+    const radius = 1.1 *
+      vector3.magnitude(vector3.subtract(boundingBox$1.max, boundingBox.center(boundingBox$1)));
+    // ratio of the height of the frustum to the distance along the view vector
+    let hOverD = Math.tan(((_a = this.fovY) !== null && _a !== void 0 ? _a : 45) * PI_OVER_360);
+    if (this.aspect < 1.0) {
+      hOverD *= this.aspect;
+    }
+    const distance = Math.abs(radius / hOverD);
+    return super.fitCameraToBoundingBox(boundingBox$1, distance, this.viewVector);
+  }
+  update(camera) {
+    var _a;
+    const fovY = (_a = camera.fovY) !== null && _a !== void 0 ? _a : this.fovY;
+    return new PerspectiveCamera(this.stream, this.aspect, Object.assign(Object.assign(Object.assign({}, this.perspectiveData), camera), { fovY }), this.boundingBox, this.decodeFrame, this.flyToOptions);
+  }
+  toFrameCamera() {
+    var _a;
+    return new FramePerspectiveCamera(this.position, this.lookAt, this.up, this.near, this.far, this.aspectRatio, (_a = this.fovY) !== null && _a !== void 0 ? _a : 45);
+  }
+  get viewVector() {
+    return vector3.subtract(this.lookAt, this.position);
+  }
+  /**
+   * The position vector for the camera, in world space coordinates.
+   */
+  get position() {
+    return Object.assign({}, this.perspectiveData.position);
+  }
+  /**
+   * A normalized vector representing the up direction.
+   */
+  get up() {
+    return Object.assign({}, this.perspectiveData.up);
+  }
+  /**
+   * A vector, in world space coordinates, of where the camera is pointed at.
+   */
+  get lookAt() {
+    return Object.assign({}, this.perspectiveData.lookAt);
+  }
+  /**
+   * The camera's field of view.
+   */
+  get fovY() {
+    return this.perspectiveData.fovY;
+  }
+  /**
+   * The aspect ratio of the camera.
+   */
+  get aspectRatio() {
+    return this.aspect;
+  }
+  /**
+   * The camera's near clipping plane.
+   */
+  get near() {
+    const { near } = this.computeClippingPlanes(this.perspectiveData);
+    return near;
+  }
+  /**
+   * The camera's far clipping plane.
+   */
+  get far() {
+    const { far } = this.computeClippingPlanes(this.perspectiveData);
+    return far;
+  }
+  updateFlyToOptions(flyToOptions) {
+    return new PerspectiveCamera(this.stream, this.aspect, this.perspectiveData, this.boundingBox, this.decodeFrame, flyToOptions);
+  }
+}
+class OrthographicCamera extends Camera {
+  constructor(stream, aspect, orthographicData, boundingBox, decodeFrame, flyToOptions) {
+    super(stream, aspect, orthographicData, boundingBox, decodeFrame, flyToOptions);
+    this.orthographicData = orthographicData;
+  }
+  /**
+   * Shifts the position of the camera by the given delta.
+   *
+   * @param delta The number of units to shift the camera on the X, Y, and Z
+   * axis.
+   */
+  moveBy(delta) {
+    return this.update({
+      lookAt: vector3.add(this.lookAt, delta),
+    });
+  }
+  rotateAroundAxisAtPoint(angleInRadians, point, axis) {
+    const updatedLookAt = vector3.rotateAboutAxis(angleInRadians, this.lookAt, axis, point);
+    const updatedPosition = vector3.rotateAboutAxis(angleInRadians, this.position, axis, point);
+    const viewVector = constrainViewVector(vector3.subtract(updatedLookAt, updatedPosition), boundingSphere.create(this.boundingBox));
+    return this.update({
+      viewVector: viewVector,
+      lookAt: updatedLookAt,
+      up: vector3.rotateAboutAxis(angleInRadians, this.up, axis, vector3.origin()),
+    });
+  }
+  fitToBoundingBox(boundingBox) {
+    const boundingSphere$1 = boundingSphere.create(boundingBox);
+    const fitAll = super.fitCameraToBoundingBox(boundingBox, boundingSphere$1.radius, this.viewVector);
+    return this.update({
+      lookAt: fitAll.lookAt,
+      viewVector: fitAll.viewVector,
+      fovHeight: boundingSphere$1.radius * 2,
+    });
+  }
+  update(camera) {
+    return new OrthographicCamera(this.stream, this.aspect, Object.assign(Object.assign({}, this.orthographicData), camera), this.boundingBox, this.decodeFrame, this.flyToOptions);
+  }
+  toFrameCamera() {
+    return new FrameOrthographicCamera(constrainViewVector(this.viewVector, boundingSphere.create(this.boundingBox)), this.lookAt, this.up, this.near, this.far, this.aspectRatio, this.fovHeight);
+  }
+  get viewVector() {
+    return Object.assign({}, this.orthographicData.viewVector);
+  }
+  get position() {
+    return vector3.add(this.lookAt, vector3.negate(this.viewVector));
+  }
+  /**
+   * A normalized vector representing the up direction.
+   */
+  get up() {
+    return Object.assign({}, this.orthographicData.up);
+  }
+  /**
+   * A vector, in world space coordinates, of where the camera is pointed at.
+   */
+  get lookAt() {
+    return Object.assign({}, this.orthographicData.lookAt);
+  }
+  /**
+   * The camera's field of view.
+   */
+  get fovHeight() {
+    return this.orthographicData.fovHeight;
+  }
+  /**
+   * The aspect ratio of the camera.
+   */
+  get aspectRatio() {
+    return this.aspect;
+  }
+  /**
+   * The camera's near clipping plane.
+   */
+  get near() {
+    const { near } = this.computeClippingPlanes(this.orthographicData);
+    return near;
+  }
+  /**
+   * The camera's far clipping plane.
+   */
+  get far() {
+    const { far } = this.computeClippingPlanes(this.orthographicData);
+    return far;
+  }
+  updateFlyToOptions(flyToOptions) {
+    return new OrthographicCamera(this.stream, this.aspect, this.orthographicData, this.boundingBox, this.decodeFrame, flyToOptions);
+  }
+}
+
+/**
+ * The `Raycaster` class is here.
+ */
+class Raycaster {
+  constructor(stream, imageScaleProvider) {
+    this.stream = stream;
+    this.imageScaleProvider = imageScaleProvider;
+  }
+  /**
+   * Performs request on the stream to find items that intersect
+   * the given point.
+   *
+   * @param point The point to cast from looking for intersections.
+   */
+  async hitItems(point$1, options) {
+    const scale = this.imageScaleProvider();
+    const res = await this.stream.hitItems({
+      point: point.scale(point$1, (scale === null || scale === void 0 ? void 0 : scale.x) || 1, (scale === null || scale === void 0 ? void 0 : scale.y) || 1),
+      includeMetadata: options === null || options === void 0 ? void 0 : options.includeMetadata,
+    }, true);
+    return res.hitItems || undefined;
+  }
+}
+
+/**
+ * The `CrossSectioner` class is here.
+ */
+class CrossSectioner {
+  constructor(stream, data) {
+    this.stream = stream;
+    this.data = data;
+  }
+  /**
+   * Performs request on the stream to update the cross sectioning config.
+   *
+   * @param crossSectioning The new cross sectioning.
+   */
+  async update(crossSectioning) {
+    const res = await this.stream.updateCrossSectioning({
+      crossSectioning: {
+        sectionPlanes: crossSectioning.sectionPlanes,
+        highlightColor: crossSectioning.highlightColor,
+        lineWidth: (crossSectioning === null || crossSectioning === void 0 ? void 0 : crossSectioning.lineWidth) != null
+          ? { value: crossSectioning.lineWidth }
+          : null,
+      },
+    }, true);
+    return res.updateCrossSectioning || undefined;
+  }
+  current() {
+    return this.data;
+  }
+}
+
+/**
+ * A class to handle the building of operations for a scene.
+ */
+class SceneOperationBuilder {
+  constructor(operations = []) {
+    this.operations = operations;
+  }
+  /**
+   * Constructs the scene operations and returns a definition describing each
+   * operation.
+   */
+  build() {
+    return this.operations.concat();
+  }
+  materialOverride(material) {
+    return new SceneOperationBuilder(this.operations.concat([{ type: 'change-material', material }]));
+  }
+  show() {
+    return new SceneOperationBuilder(this.operations.concat([{ type: 'show' }]));
+  }
+  hide() {
+    return new SceneOperationBuilder(this.operations.concat([{ type: 'hide' }]));
+  }
+  select() {
+    return new SceneOperationBuilder(this.operations.concat([{ type: 'select' }]));
+  }
+  deselect() {
+    return new SceneOperationBuilder(this.operations.concat([{ type: 'deselect' }]));
+  }
+  clearMaterialOverrides() {
+    return new SceneOperationBuilder(this.operations.concat([{ type: 'clear-override' }]));
+  }
+  transform(matrix) {
+    return new SceneOperationBuilder(this.operations.concat([{ type: 'change-transform', transform: matrix }]));
+  }
+  clearTransforms(cascade = true) {
+    return new SceneOperationBuilder(this.operations.concat([{ type: 'clear-transform', cascade }]));
+  }
+  setPhantom(phantomState) {
+    return new SceneOperationBuilder(this.operations.concat([{ type: 'change-phantom', phantomState }]));
+  }
+  clearPhantom() {
+    return new SceneOperationBuilder(this.operations.concat([{ type: 'clear-phantom' }]));
+  }
+  setEndItem(endItemState) {
+    return new SceneOperationBuilder(this.operations.concat([{ type: 'change-end-item', endItemState }]));
+  }
+  clearEndItem() {
+    return new SceneOperationBuilder(this.operations.concat([{ type: 'clear-end-item' }]));
+  }
+}
+
+/**
+ * An interface that represents a query is "complete" and can be turned into an
+ * expression.
+ */
+class TerminalQuery {
+  constructor(inverted) {
+    this.inverted = inverted;
+  }
+  build() {
+    if (this.inverted) {
+      return {
+        type: 'not',
+        query: this.queryExpressionBuilder(),
+      };
+    }
+    else {
+      return this.queryExpressionBuilder();
+    }
+  }
+}
+class RootQuery {
+  constructor(inverted = false) {
+    this.inverted = inverted;
+  }
+  all() {
+    return new AllQuery();
+  }
+  not() {
+    return new NotQuery(!this.inverted);
+  }
+  withItemIds(ids) {
+    return new BulkQuery(ids, 'item-id', this.inverted);
+  }
+  withSuppliedIds(ids) {
+    return new BulkQuery(ids, 'supplied-id', this.inverted);
+  }
+  withItemId(id) {
+    return new SingleQuery({ type: 'item-id', value: id }, this.inverted);
+  }
+  withSuppliedId(id) {
+    return new SingleQuery({ type: 'supplied-id', value: id }, this.inverted);
+  }
+  withSceneTreeRange(range) {
+    return new SceneTreeRangeQuery(range, this.inverted);
+  }
+  withMetadata(filter, keys, exactMatch) {
+    return new MetadataQuery(filter, keys, exactMatch, this.inverted);
+  }
+  withSelected() {
+    return new AllSelectedQuery(this.inverted);
+  }
+  withPoint(point) {
+    return new PointQuery(point, this.inverted);
+  }
+  withVolumeIntersection(rectangle, exclusive) {
+    return new VolumeIntersectionQuery(rectangle, this.inverted, exclusive);
+  }
+}
+class NotQuery extends RootQuery {
+  constructor(inverted) {
+    super(inverted);
+  }
+}
+class AllQuery extends TerminalQuery {
+  constructor(inverted = false) {
+    super(inverted);
+  }
+  queryExpressionBuilder() {
+    return { type: 'all' };
+  }
+}
+class SceneTreeRangeQuery extends TerminalQuery {
+  constructor(range, inverted) {
+    super(inverted);
+    this.range = range;
+  }
+  queryExpressionBuilder() {
+    return {
+      type: 'scene-tree-range',
+      range: this.range,
+    };
+  }
+}
+class MetadataQuery extends TerminalQuery {
+  constructor(filter, keys, exactMatch, inverted) {
+    super(inverted);
+    this.filter = filter;
+    this.keys = keys;
+    this.exactMatch = exactMatch;
+  }
+  queryExpressionBuilder() {
+    return {
+      type: 'metadata',
+      filter: this.filter,
+      keys: this.keys,
+      exactMatch: this.exactMatch,
+    };
+  }
+}
+class AllSelectedQuery extends TerminalQuery {
+  constructor(inverted) {
+    super(inverted);
+  }
+  queryExpressionBuilder() {
+    return {
+      type: 'all-selected',
+    };
+  }
+}
+class PointQuery extends TerminalQuery {
+  constructor(point, inverted) {
+    super(inverted);
+    this.point = point;
+  }
+  queryExpressionBuilder() {
+    return {
+      type: 'point',
+      point: this.point,
+    };
+  }
+}
+class VolumeIntersectionQuery extends TerminalQuery {
+  constructor(rectangle, inverted, exclusive) {
+    super(inverted);
+    this.rectangle = rectangle;
+    this.exclusive = exclusive;
+  }
+  queryExpressionBuilder() {
+    return {
+      type: 'volume-intersection',
+      rectangle: this.rectangle,
+      exclusive: !!this.exclusive,
+    };
+  }
+}
+class BulkQuery extends TerminalQuery {
+  constructor(ids, type, inverted) {
+    super(inverted);
+    this.ids = ids;
+    this.type = type;
+  }
+  queryExpressionBuilder() {
+    return {
+      type: 'or',
+      expressions: this.ids.map((id) => {
+        return {
+          type: this.type,
+          value: id,
+        };
+      }),
+    };
+  }
+}
+class SingleQuery extends TerminalQuery {
+  constructor(query, inverted) {
+    super(inverted);
+    this.query = query;
+  }
+  queryExpressionBuilder() {
+    return Object.assign({}, this.query);
+  }
+  and() {
+    return new AndQuery([this.query], this.inverted);
+  }
+  or() {
+    return new OrQuery([this.query], this.inverted);
+  }
+}
+class OrQuery extends TerminalQuery {
+  constructor(expressions, inverted) {
+    super(inverted);
+    this.expressions = expressions;
+  }
+  queryExpressionBuilder() {
+    return { type: 'or', expressions: [...this.expressions] };
+  }
+  withItemId(id) {
+    return new OrQuery([...this.expressions, { type: 'item-id', value: id }], this.inverted);
+  }
+  withSuppliedId(id) {
+    return new OrQuery([...this.expressions, { type: 'supplied-id', value: id }], this.inverted);
+  }
+  or() {
+    return this;
+  }
+}
+class AndQuery extends TerminalQuery {
+  constructor(expressions, inverted) {
+    super(inverted);
+    this.expressions = expressions;
+  }
+  queryExpressionBuilder() {
+    return { type: 'and', expressions: [...this.expressions] };
+  }
+  withItemId(id) {
+    return new AndQuery([...this.expressions, { type: 'item-id', value: id }], this.inverted);
+  }
+  withSuppliedId(id) {
+    return new AndQuery([...this.expressions, { type: 'supplied-id', value: id }], this.inverted);
+  }
+  and() {
+    return this;
+  }
+}
+class SceneItemQueryExecutor {
+  where(query) {
+    const expression = query(new RootQuery()).build();
+    return new SceneItemOperationsBuilder(expression);
+  }
+}
+
+/**
+ * A class that is responsible for building operations for a specific scene.
+ * This executor requires a query, and expects `execute()` to be invoked in order
+ * for the changes to take effect.
+ */
+class SceneItemOperationsBuilder {
+  constructor(query, givenBuilder) {
+    this.query = query;
+    this.builder =
+      givenBuilder != null ? givenBuilder : new SceneOperationBuilder();
+  }
+  materialOverride(color) {
+    if (typeof color === 'string') {
+      return new SceneItemOperationsBuilder(this.query, this.builder.materialOverride(fromHex(color)));
+    }
+    else {
+      return new SceneItemOperationsBuilder(this.query, this.builder.materialOverride(color));
+    }
+  }
+  hide() {
+    return new SceneItemOperationsBuilder(this.query, this.builder.hide());
+  }
+  show() {
+    return new SceneItemOperationsBuilder(this.query, this.builder.show());
+  }
+  select() {
+    return new SceneItemOperationsBuilder(this.query, this.builder.select());
+  }
+  deselect() {
+    return new SceneItemOperationsBuilder(this.query, this.builder.deselect());
+  }
+  clearMaterialOverrides() {
+    return new SceneItemOperationsBuilder(this.query, this.builder.clearMaterialOverrides());
+  }
+  transform(matrix) {
+    if (Array.isArray(matrix)) {
+      if (matrix.length !== 16) {
+        throw new InvalidArgumentError('Matrix provided must contain exactly 16 values (4x4).');
+      }
+      return new SceneItemOperationsBuilder(this.query, this.builder.transform({
+        r0: {
+          x: matrix[0],
+          y: matrix[1],
+          z: matrix[2],
+          w: matrix[3],
+        },
+        r1: {
+          x: matrix[4],
+          y: matrix[5],
+          z: matrix[6],
+          w: matrix[7],
+        },
+        r2: {
+          x: matrix[8],
+          y: matrix[9],
+          z: matrix[10],
+          w: matrix[11],
+        },
+        r3: {
+          x: matrix[12],
+          y: matrix[13],
+          z: matrix[14],
+          w: matrix[15],
+        },
+      }));
+    }
+    else {
+      return new SceneItemOperationsBuilder(this.query, this.builder.transform(matrix));
+    }
+  }
+  clearTransforms(cascade = true) {
+    return new SceneItemOperationsBuilder(this.query, this.builder.clearTransforms(cascade));
+  }
+  setPhantom(phantomState) {
+    return new SceneItemOperationsBuilder(this.query, this.builder.setPhantom(phantomState));
+  }
+  clearPhantom() {
+    return new SceneItemOperationsBuilder(this.query, this.builder.clearPhantom());
+  }
+  setEndItem(endItemState) {
+    return new SceneItemOperationsBuilder(this.query, this.builder.setEndItem(endItemState));
+  }
+  clearEndItem() {
+    return new SceneItemOperationsBuilder(this.query, this.builder.clearEndItem());
+  }
+  build() {
+    return {
+      query: this.query,
+      operations: this.builder.build(),
+    };
+  }
+}
+class ItemsOperationExecutor {
+  constructor(sceneViewId, stream, dimensions, queryOperations) {
+    this.sceneViewId = sceneViewId;
+    this.stream = stream;
+    this.dimensions = dimensions;
+    this.queryOperations = queryOperations;
+  }
+  async execute(executionOptions) {
+    const pbOperations = this.queryOperations.map((op) => buildSceneOperation(op.query, op.operations, {
+      dimensions: this.dimensions,
+    }));
+    const request = {
+      sceneViewId: {
+        hex: this.sceneViewId,
+      },
+      operations: pbOperations,
+      suppliedCorrelationId: (executionOptions === null || executionOptions === void 0 ? void 0 : executionOptions.suppliedCorrelationId) != null
+        ? {
+          value: executionOptions === null || executionOptions === void 0 ? void 0 : executionOptions.suppliedCorrelationId,
+        }
+        : undefined,
+    };
+    await this.stream.createSceneAlteration(request);
+  }
+}
+/**
+ * A class that represents the `Scene` that has been loaded into the viewer. On
+ * it, you can retrieve attributes of the scene, such as the camera. It also
+ * contains methods for updating the scene and performing requests to rerender
+ * the scene.
+ */
+class Scene {
+  constructor(stream, frame, decodeFrame, imageScaleProvider, dimensions, sceneId, sceneViewId) {
+    this.stream = stream;
+    this.frame = frame;
+    this.decodeFrame = decodeFrame;
+    this.imageScaleProvider = imageScaleProvider;
+    this.dimensions = dimensions;
+    this.sceneId = sceneId;
+    this.sceneViewId = sceneViewId;
+  }
+  /**
+   * Applies the provided scene view state to the scene.
+   */
+  async applySceneViewState(sceneViewStateId, opts = {}) {
+    const pbIdField = buildSceneViewStateIdentifier(sceneViewStateId);
+    return await this.stream.loadSceneViewState(Object.assign(Object.assign({}, pbIdField), { frameCorrelationId: opts.suppliedCorrelationId
+        ? { value: opts.suppliedCorrelationId }
+        : undefined }), true);
+  }
+  /**
+   * Applies the specified features of the provided scene view state to the scene.
+   */
+  async applyPartialSceneViewState(sceneViewStateId, featuresToApply, opts = {}) {
+    const pbIdField = buildSceneViewStateIdentifier(sceneViewStateId);
+    const pbFeatures = toPbSceneViewStateFeatures(featuresToApply);
+    return await this.stream.loadSceneViewState(Object.assign(Object.assign({}, pbIdField), { frameCorrelationId: opts.suppliedCorrelationId
+        ? { value: opts.suppliedCorrelationId }
+        : undefined, sceneViewStateFeatureSubset: pbFeatures }), true);
+  }
+  /**
+   * Resets the view to its default state, with the ability to reset the camera to that of the base scene.
+   */
+  async reset(opts = {}) {
+    return await this.stream.resetSceneView({
+      includeCamera: opts.includeCamera,
+      frameCorrelationId: opts.suppliedCorrelationId
+        ? { value: opts.suppliedCorrelationId }
+        : undefined,
+    }, true);
+  }
+  /**
+   * Returns an executor that accepts a function as a parameter that contains one or many operations to apply
+   * to the scene view. The operations will be applied transactionally.
+   * @param operations
+   */
+  items(operations) {
+    const sceneOperations = operations(new SceneItemQueryExecutor());
+    const ops = Array.isArray(sceneOperations)
+      ? sceneOperations
+      : [sceneOperations];
+    const operationList = ops.reduce((acc, builder) => acc.concat(builder.build()), []);
+    return new ItemsOperationExecutor(this.sceneViewId, this.stream, this.dimensions, operationList);
+  }
+  /**
+   * An instance of the current camera of the scene.
+   */
+  camera() {
+    const { scene } = this.frame;
+    if (scene.camera.isOrthographic()) {
+      return new OrthographicCamera(this.stream, dimensions.aspectRatio(this.viewport()), {
+        viewVector: scene.camera.viewVector,
+        lookAt: scene.camera.lookAt,
+        up: scene.camera.up,
+        fovHeight: scene.camera.fovHeight,
+      }, this.frame.scene.boundingBox, this.decodeFrame);
+    }
+    else if (scene.camera.isPerspective()) {
+      return new PerspectiveCamera(this.stream, dimensions.aspectRatio(this.viewport()), {
+        position: scene.camera.position,
+        lookAt: scene.camera.lookAt,
+        up: scene.camera.up,
+        fovY: scene.camera.fovY,
+      }, this.frame.scene.boundingBox, this.decodeFrame);
+    }
+    else {
+      throw new InvalidCameraError('Cannot retrieve camera. Scene has an unknown or invalid camera type.');
+    }
+  }
+  boundingBox() {
+    return this.frame.scene.boundingBox;
+  }
+  /**
+   * CrossSectioner to update cross sectioning planes and get current configuration.
+   */
+  crossSectioning() {
+    return new CrossSectioner(this.stream, this.frame.scene.crossSection);
+  }
+  /**
+   * Raycaster to request items that intersect a point.
+   */
+  raycaster() {
+    return new Raycaster(this.stream, this.imageScaleProvider);
+  }
+  /**
+   * The current viewport of the scene, in pixels.
+   */
+  viewport() {
+    return this.frame.dimensions;
+  }
+  /**
+   * The current x and y scale of the rendered image.
+   */
+  scale() {
+    return this.imageScaleProvider() || point.create(1, 1);
+  }
+}
+
+export { Scene as S, SynchronizedClock as a, colorMaterial as c, fromUrn as f, loadableResource as l };
+
+//# sourceMappingURL=scene.js.map