@cornerstonejs/core 2.0.0-beta.8 → 2.0.1

package/dist/esm/RenderingEngine/helpers/createVolumeActor.d.ts

@@ -0,0 +1,12 @@
+import type { VolumeActor } from './../../types/IActor';
+import type BlendModes from '../../enums/BlendModes';
+interface createVolumeActorInterface {
+    volumeId: string;
+    callback?: ({ volumeActor, volumeId, }: {
+        volumeActor: VolumeActor;
+        volumeId: string;
+    }) => void;
+    blendMode?: BlendModes;
+}
+declare function createVolumeActor(props: createVolumeActorInterface, element: HTMLDivElement, viewportId: string, suppressEvents?: boolean): Promise<VolumeActor>;
+export default createVolumeActor;

package/dist/esm/RenderingEngine/helpers/createVolumeActor.js

@@ -1,10 +1,10 @@
 import vtkVolume from '@kitware/vtk.js/Rendering/Core/Volume';
 import { loadVolume } from '../../loaders/volumeLoader';
 import createVolumeMapper from './createVolumeMapper';
-import { triggerEvent } from '../../utilities';
+import triggerEvent from '../../utilities/triggerEvent';
 import { Events } from '../../enums';
 import setDefaultVolumeVOI from './setDefaultVolumeVOI';
-async function createVolumeActor(props, element, viewportId, suppressEvents = false, useNativeDataType = false) {
+async function createVolumeActor(props, element, viewportId, suppressEvents = false) {
     const { volumeId, callback, blendMode } = props;
     const imageVolume = await loadVolume(volumeId);
     if (!imageVolume) {
@@ -17,14 +17,13 @@ async function createVolumeActor(props, element, viewportId, suppressEvents = fa
     }
     const volumeActor = vtkVolume.newInstance();
     volumeActor.setMapper(volumeMapper);
-    const numberOfComponents = imageData
-        .getPointData()
-        .getScalars()
-        .getNumberOfComponents();
+    const { numberOfComponents } = imageData.get('numberOfComponents');
+    const volumeProperty = volumeActor.getProperty();
+    volumeProperty.set({ viewportId: viewportId });
     if (numberOfComponents === 3) {
         volumeActor.getProperty().setIndependentComponents(false);
     }
-    await setDefaultVolumeVOI(volumeActor, imageVolume, useNativeDataType);
+    await setDefaultVolumeVOI(volumeActor, imageVolume);
     if (callback) {
         callback({ volumeActor, volumeId });
     }
@@ -49,4 +48,3 @@ function triggerVOIModified(element, viewportId, volumeActor, volumeId) {
     triggerEvent(element, Events.VOI_MODIFIED, voiModifiedEventDetail);
 }
 export default createVolumeActor;
-//# sourceMappingURL=createVolumeActor.js.map

package/dist/esm/RenderingEngine/helpers/createVolumeMapper.d.ts

@@ -0,0 +1,4 @@
+import type vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
+import type vtkOpenGLTexture from '@kitware/vtk.js/Rendering/OpenGL/Texture';
+import type vtkVolumeMapper from '@kitware/vtk.js/Rendering/Core/VolumeMapper';
+export default function createVolumeMapper(imageData: vtkImageData, vtkOpenGLTexture: vtkOpenGLTexture): vtkVolumeMapper;

package/dist/esm/RenderingEngine/helpers/createVolumeMapper.js

@@ -13,4 +13,3 @@ export default function createVolumeMapper(imageData, vtkOpenGLTexture) {
     volumeMapper.setScalarTexture(vtkOpenGLTexture);
     return volumeMapper;
 }
-//# sourceMappingURL=createVolumeMapper.js.map

package/dist/esm/RenderingEngine/helpers/getOrCreateCanvas.d.ts

@@ -0,0 +1,3 @@
+export declare const EPSILON = 0.0001;
+export declare function createViewportElement(element: HTMLDivElement): HTMLDivElement;
+export default function getOrCreateCanvas(element: HTMLDivElement): HTMLCanvasElement;

package/dist/esm/RenderingEngine/helpers/getOrCreateCanvas.js

@@ -25,16 +25,16 @@ export default function getOrCreateCanvas(element) {
     const canvasSelector = `canvas.${CANVAS_CSS_CLASS}`;
     const viewportElement = `div.${VIEWPORT_ELEMENT}`;
     const internalDiv = element.querySelector(viewportElement) || createViewportElement(element);
-    const canvas = (internalDiv.querySelector(canvasSelector) ||
-        createCanvas(internalDiv));
+    const existingCanvas = internalDiv.querySelector(canvasSelector);
+    if (existingCanvas) {
+        return existingCanvas;
+    }
+    const canvas = createCanvas(internalDiv);
     const rect = internalDiv.getBoundingClientRect();
     const devicePixelRatio = window.devicePixelRatio || 1;
     const width = Math.ceil(rect.width * devicePixelRatio);
     const height = Math.ceil(rect.height * devicePixelRatio);
     canvas.width = width;
     canvas.height = height;
-    canvas.style.width = (width + EPSILON) / devicePixelRatio + 'px';
-    canvas.style.height = (height + EPSILON) / devicePixelRatio + 'px';
     return canvas;
 }
-//# sourceMappingURL=getOrCreateCanvas.js.map

package/dist/esm/RenderingEngine/helpers/index.d.ts

@@ -0,0 +1,8 @@
+import createVolumeActor from './createVolumeActor';
+import createVolumeMapper from './createVolumeMapper';
+import getOrCreateCanvas from './getOrCreateCanvas';
+import setVolumesForViewports from './setVolumesForViewports';
+import addVolumesToViewports from './addVolumesToViewports';
+import volumeNewImageEventDispatcher from './volumeNewImageEventDispatcher';
+import addImageSlicesToViewports from './addImageSlicesToViewports';
+export { createVolumeActor, createVolumeMapper, getOrCreateCanvas, setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports, volumeNewImageEventDispatcher, };

package/dist/esm/RenderingEngine/helpers/index.js

@@ -6,4 +6,3 @@ import addVolumesToViewports from './addVolumesToViewports';
 import volumeNewImageEventDispatcher from './volumeNewImageEventDispatcher';
 import addImageSlicesToViewports from './addImageSlicesToViewports';
 export { createVolumeActor, createVolumeMapper, getOrCreateCanvas, setVolumesForViewports, addVolumesToViewports, addImageSlicesToViewports, volumeNewImageEventDispatcher, };
-//# sourceMappingURL=index.js.map

package/dist/esm/RenderingEngine/helpers/isRgbaSourceRgbDest.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (src: any, dest: any) => boolean;
+export default _default;

package/dist/esm/RenderingEngine/helpers/isRgbaSourceRgbDest.js

@@ -1,2 +1 @@
 export default (src, dest) => src.length * 3 === dest.byteLength * 4;
-//# sourceMappingURL=isRgbaSourceRgbDest.js.map

package/dist/esm/RenderingEngine/helpers/setDefaultVolumeVOI.d.ts

@@ -0,0 +1,3 @@
+import type { VolumeActor, IImageVolume } from '../../types';
+declare function setDefaultVolumeVOI(volumeActor: VolumeActor, imageVolume: IImageVolume): Promise<void>;
+export default setDefaultVolumeVOI;

package/dist/esm/RenderingEngine/helpers/setDefaultVolumeVOI.js

@@ -1,19 +1,20 @@
 import { loadAndCacheImage } from '../../loaders/imageLoader';
 import * as metaData from '../../metaData';
-import { getMinMax, windowLevel } from '../../utilities';
+import getMinMax from '../../utilities/getMinMax';
+import * as windowLevel from '../../utilities/windowLevel';
 import { RequestType } from '../../enums';
-import cache from '../../cache';
+import cache from '../../cache/cache';
 const PRIORITY = 0;
 const REQUEST_TYPE = RequestType.Prefetch;
-async function setDefaultVolumeVOI(volumeActor, imageVolume, useNativeDataType) {
+async function setDefaultVolumeVOI(volumeActor, imageVolume) {
     let voi = getVOIFromMetadata(imageVolume);
-    if (!voi && imageVolume?.imageIds?.length) {
-        voi = await getVOIFromMinMax(imageVolume, useNativeDataType);
+    if (!voi && imageVolume.imageIds.length) {
+        voi = await getVOIFromMiddleSliceMinMax(imageVolume);
         voi = handlePreScaledVolume(imageVolume, voi);
     }
-    if ((voi?.lower === 0 && voi?.upper === 0) ||
-        voi?.lower === undefined ||
-        voi?.upper === undefined) {
+    if ((voi.lower === 0 && voi.upper === 0) ||
+        voi.lower === undefined ||
+        voi.upper === undefined) {
         return;
     }
     volumeActor
@@ -41,39 +42,33 @@ function getVOIFromMetadata(imageVolume) {
         const imageIdIndex = Math.floor(imageIds.length / 2);
         const imageId = imageIds[imageIdIndex];
         const voiLutModule = metaData.get('voiLutModule', imageId);
-        if (voiLutModule && voiLutModule.windowWidth && voiLutModule.windowCenter) {
+        if (voiLutModule?.windowWidth && voiLutModule.windowCenter) {
             const { windowWidth, windowCenter } = voiLutModule;
-            voi = {
-                windowWidth: Array.isArray(windowWidth) ? windowWidth[0] : windowWidth,
-                windowCenter: Array.isArray(windowCenter)
-                    ? windowCenter[0]
-                    : windowCenter,
-            };
+            const width = Array.isArray(windowWidth) ? windowWidth[0] : windowWidth;
+            const center = Array.isArray(windowCenter)
+                ? windowCenter[0]
+                : windowCenter;
+            if (width !== 0) {
+                voi = { windowWidth: width, windowCenter: center };
+            }
         }
     }
     else {
-        voi = metadata?.voiLut?.[0];
+        voi = metadata.voiLut[0];
     }
-    if (voi) {
+    if (voi && (voi.windowWidth !== 0 || voi.windowCenter !== 0)) {
         const { lower, upper } = windowLevel.toLowHighRange(Number(voi.windowWidth), Number(voi.windowCenter));
-        return {
-            lower,
-            upper,
-        };
+        return { lower, upper };
     }
+    return undefined;
 }
-async function getVOIFromMinMax(imageVolume, useNativeDataType) {
+async function getVOIFromMiddleSliceMinMax(imageVolume) {
     const { imageIds } = imageVolume;
-    const scalarData = imageVolume.getScalarData();
     const imageIdIndex = Math.floor(imageIds.length / 2);
     const imageId = imageVolume.imageIds[imageIdIndex];
     const generalSeriesModule = metaData.get('generalSeriesModule', imageId) || {};
     const { modality } = generalSeriesModule;
     const modalityLutModule = metaData.get('modalityLutModule', imageId) || {};
-    const numImages = imageIds.length;
-    const bytesPerImage = scalarData.byteLength / numImages;
-    const voxelsPerImage = scalarData.length / numImages;
-    const bytePerPixel = scalarData.BYTES_PER_ELEMENT;
     const scalingParameters = {
         rescaleSlope: modalityLutModule.rescaleSlope,
         rescaleIntercept: modalityLutModule.rescaleIntercept,
@@ -89,16 +84,10 @@ async function getVOIFromMinMax(imageVolume, useNativeDataType) {
             };
         }
     }
-    const byteOffset = imageIdIndex * bytesPerImage;
     const options = {
-        targetBuffer: {
-            type: useNativeDataType ? undefined : 'Float32Array',
-        },
         priority: PRIORITY,
         requestType: REQUEST_TYPE,
-        useNativeDataType,
         preScale: {
-            enabled: true,
             scalingParameters: scalingParametersToUse,
         },
     };
@@ -106,27 +95,13 @@ async function getVOIFromMinMax(imageVolume, useNativeDataType) {
     if (!imageVolume.referencedImageIds?.length) {
         image = await loadAndCacheImage(imageId, { ...options, ignoreCache: true });
     }
-    const imageScalarData = image
-        ? image.getPixelData()
-        : _getImageScalarDataFromImageVolume(imageVolume, byteOffset, bytePerPixel, voxelsPerImage);
+    const imageScalarData = image.getPixelData();
     const { min, max } = getMinMax(imageScalarData);
     return {
         lower: min,
         upper: max,
     };
 }
-function _getImageScalarDataFromImageVolume(imageVolume, byteOffset, bytePerPixel, voxelsPerImage) {
-    const { scalarData } = imageVolume;
-    const { buffer } = scalarData;
-    if (scalarData.BYTES_PER_ELEMENT !== bytePerPixel) {
-        byteOffset *= scalarData.BYTES_PER_ELEMENT / bytePerPixel;
-    }
-    const TypedArray = scalarData.constructor;
-    const imageScalarData = new TypedArray(voxelsPerImage);
-    const volumeBufferView = new TypedArray(buffer, byteOffset, voxelsPerImage);
-    imageScalarData.set(volumeBufferView);
-    return imageScalarData;
-}
 function _isCurrentImagePTPrescaled(modality, imageVolume) {
     if (modality !== 'PT' || !imageVolume.isPreScaled) {
         return false;
@@ -137,4 +112,3 @@ function _isCurrentImagePTPrescaled(modality, imageVolume) {
     return true;
 }
 export default setDefaultVolumeVOI;
-//# sourceMappingURL=setDefaultVolumeVOI.js.map

package/dist/esm/RenderingEngine/helpers/setVolumesForViewports.d.ts

@@ -0,0 +1,3 @@
+import type { IVolumeInput, IRenderingEngine } from '../../types';
+declare function setVolumesForViewports(renderingEngine: IRenderingEngine, volumeInputs: IVolumeInput[], viewportIds: string[], immediateRender?: boolean, suppressEvents?: boolean): Promise<void>;
+export default setVolumesForViewports;

package/dist/esm/RenderingEngine/helpers/setVolumesForViewports.js

@@ -17,4 +17,3 @@ async function setVolumesForViewports(renderingEngine, volumeInputs, viewportIds
     return;
 }
 export default setVolumesForViewports;
-//# sourceMappingURL=setVolumesForViewports.js.map

package/dist/esm/RenderingEngine/helpers/viewportTypeToViewportClass.d.ts

@@ -0,0 +1,8 @@
+import type { ViewportInput, IViewport } from '../../types/IViewport';
+interface ViewportConstructor {
+    new (viewportInput: ViewportInput): IViewport;
+}
+declare const viewportTypeToViewportClass: {
+    [key: string]: ViewportConstructor;
+};
+export default viewportTypeToViewportClass;

package/dist/esm/RenderingEngine/helpers/viewportTypeToViewportClass.js

@@ -3,12 +3,13 @@ import VolumeViewport from '../VolumeViewport';
 import ViewportType from '../../enums/ViewportType';
 import VolumeViewport3D from '../VolumeViewport3D';
 import VideoViewport from '../VideoViewport';
+import WSIViewport from '../WSIViewport';
 const viewportTypeToViewportClass = {
     [ViewportType.ORTHOGRAPHIC]: VolumeViewport,
     [ViewportType.PERSPECTIVE]: VolumeViewport,
     [ViewportType.STACK]: StackViewport,
     [ViewportType.VOLUME_3D]: VolumeViewport3D,
     [ViewportType.VIDEO]: VideoViewport,
+    [ViewportType.WHOLE_SLIDE]: WSIViewport,
 };
 export default viewportTypeToViewportClass;
-//# sourceMappingURL=viewportTypeToViewportClass.js.map

package/dist/esm/RenderingEngine/helpers/viewportTypeUsesCustomRenderingPipeline.d.ts

@@ -0,0 +1 @@
+export default function viewportTypeUsesCustomRenderingPipeline(viewportType: string): any;

package/dist/esm/RenderingEngine/helpers/viewportTypeUsesCustomRenderingPipeline.js

@@ -2,4 +2,3 @@ import viewportTypeToViewportClass from './viewportTypeToViewportClass';
 export default function viewportTypeUsesCustomRenderingPipeline(viewportType) {
     return viewportTypeToViewportClass[viewportType].useCustomRenderingPipeline;
 }
-//# sourceMappingURL=viewportTypeUsesCustomRenderingPipeline.js.map

package/dist/esm/RenderingEngine/helpers/volumeNewImageEventDispatcher.d.ts

@@ -0,0 +1,4 @@
+import type { EventTypes } from '../../types';
+export declare function resetVolumeNewImageState(viewportId: string): void;
+declare function volumeNewImageEventDispatcher(cameraEvent: EventTypes.CameraModifiedEvent): void;
+export default volumeNewImageEventDispatcher;

package/dist/esm/RenderingEngine/helpers/volumeNewImageEventDispatcher.js

@@ -1,7 +1,7 @@
-import { getImageSliceDataForVolumeViewport, triggerEvent, } from '../../utilities';
+import getImageSliceDataForVolumeViewport from '../../utilities/getImageSliceDataForVolumeViewport';
+import triggerEvent from '../../utilities/triggerEvent';
 import { Events } from '../../enums';
 import { getRenderingEngine } from '../getRenderingEngine';
-import BaseVolumeViewport from '../BaseVolumeViewport';
 const state = {};
 export function resetVolumeNewImageState(viewportId) {
     if (state[viewportId] !== undefined) {
@@ -12,8 +12,8 @@ function volumeNewImageEventDispatcher(cameraEvent) {
     const { renderingEngineId, viewportId } = cameraEvent.detail;
     const renderingEngine = getRenderingEngine(renderingEngineId);
     const viewport = renderingEngine.getViewport(viewportId);
-    if (!(viewport instanceof BaseVolumeViewport)) {
-        throw new Error(`volumeNewImageEventDispatcher: viewport is not a BaseVolumeViewport`);
+    if (!('setVolumes' in viewport)) {
+        throw new Error(`volumeNewImageEventDispatcher: viewport does not have setVolumes method`);
     }
     if (state[viewport.id] === undefined) {
         state[viewport.id] = 0;
@@ -37,4 +37,3 @@ function volumeNewImageEventDispatcher(cameraEvent) {
     triggerEvent(viewport.element, Events.VOLUME_NEW_IMAGE, eventDetail);
 }
 export default volumeNewImageEventDispatcher;
-//# sourceMappingURL=volumeNewImageEventDispatcher.js.map

package/dist/esm/RenderingEngine/index.d.ts

@@ -0,0 +1,8 @@
+import RenderingEngine from './RenderingEngine';
+import getRenderingEngine from './getRenderingEngine';
+import VolumeViewport from './VolumeViewport';
+import StackViewport from './StackViewport';
+import VolumeViewport3D from './VolumeViewport3D';
+import { createVolumeActor, createVolumeMapper, getOrCreateCanvas } from './helpers';
+export { getRenderingEngine, RenderingEngine, VolumeViewport, VolumeViewport3D, createVolumeActor, createVolumeMapper, getOrCreateCanvas, StackViewport, };
+export default RenderingEngine;

package/dist/esm/RenderingEngine/index.js

@@ -6,4 +6,3 @@ import VolumeViewport3D from './VolumeViewport3D';
 import { createVolumeActor, createVolumeMapper, getOrCreateCanvas, } from './helpers';
 export { getRenderingEngine, RenderingEngine, VolumeViewport, VolumeViewport3D, createVolumeActor, createVolumeMapper, getOrCreateCanvas, StackViewport, };
 export default RenderingEngine;
-//# sourceMappingURL=index.js.map

package/dist/esm/RenderingEngine/renderingEngineCache.d.ts

@@ -0,0 +1,8 @@
+import type { IRenderingEngine } from '../types';
+declare const renderingEngineCache: {
+    get: (id: string) => IRenderingEngine;
+    set: (re: IRenderingEngine) => void;
+    delete: (id: string) => boolean;
+    getAll: () => IRenderingEngine[];
+};
+export default renderingEngineCache;

package/dist/esm/RenderingEngine/renderingEngineCache.js

@@ -28,4 +28,3 @@ const renderingEngineCache = {
     },
 };
 export default renderingEngineCache;
-//# sourceMappingURL=renderingEngineCache.js.map

package/dist/esm/RenderingEngine/vtkClasses/index.d.ts

@@ -0,0 +1,5 @@
+import vtkOffscreenMultiRenderWindow from './vtkOffscreenMultiRenderWindow';
+import vtkSharedVolumeMapper from './vtkSharedVolumeMapper';
+import vtkStreamingOpenGLTexture from './vtkStreamingOpenGLTexture';
+import vtkSlabCamera from './vtkSlabCamera';
+export { vtkOffscreenMultiRenderWindow, vtkSharedVolumeMapper, vtkStreamingOpenGLTexture, vtkSlabCamera };

package/dist/esm/RenderingEngine/vtkClasses/index.js

@@ -3,4 +3,3 @@ import vtkSharedVolumeMapper from './vtkSharedVolumeMapper';
 import vtkStreamingOpenGLTexture from './vtkStreamingOpenGLTexture';
 import vtkSlabCamera from './vtkSlabCamera';
 export { vtkOffscreenMultiRenderWindow, vtkSharedVolumeMapper, vtkStreamingOpenGLTexture, vtkSlabCamera, };
-//# sourceMappingURL=index.js.map

package/dist/esm/RenderingEngine/vtkClasses/vtkOffscreenMultiRenderWindow.d.ts

@@ -0,0 +1,7 @@
+export function extend(publicAPI: any, model: any, initialValues?: {}): void;
+export const newInstance: any;
+declare namespace _default {
+    export { newInstance };
+    export { extend };
+}
+export default _default;

package/dist/esm/RenderingEngine/vtkClasses/vtkOffscreenMultiRenderWindow.js

@@ -79,4 +79,3 @@ export function extend(publicAPI, model, initialValues = {}) {
 }
 export const newInstance = macro.newInstance(extend);
 export default { newInstance, extend };
-//# sourceMappingURL=vtkOffscreenMultiRenderWindow.js.map

package/dist/esm/RenderingEngine/vtkClasses/vtkSharedVolumeMapper.d.ts

@@ -0,0 +1,7 @@
+export function extend(publicAPI: any, model: any, initialValues?: {}): void;
+export const newInstance: any;
+declare namespace _default {
+    export { newInstance };
+    export { extend };
+}
+export default _default;

package/dist/esm/RenderingEngine/vtkClasses/vtkSharedVolumeMapper.js

@@ -19,4 +19,3 @@ export function extend(publicAPI, model, initialValues = {}) {
 }
 export const newInstance = macro.newInstance(extend, 'vtkSharedVolumeMapper');
 export default { newInstance, extend };
-//# sourceMappingURL=vtkSharedVolumeMapper.js.map

package/dist/esm/RenderingEngine/vtkClasses/vtkSlabCamera.d.ts

@@ -0,0 +1,142 @@
+import { mat4 } from 'gl-matrix';
+import type { vtkObject } from '@kitware/vtk.js/interfaces';
+import type { Range } from '@kitware/vtk.js/types';
+interface ICameraInitialValues {
+    position?: number[];
+    focalPoint?: number[];
+    viewUp?: number[];
+    directionOfProjection?: number[];
+    parallelProjection?: boolean;
+    useHorizontalViewAngle?: boolean;
+    viewAngle?: number;
+    parallelScale?: number;
+    clippingRange?: number[];
+    windowCenter?: number[];
+    viewPlaneNormal?: number[];
+    useOffAxisProjection?: boolean;
+    screenBottomLeft?: number[];
+    screenBottomRight?: number[];
+    screenTopRight?: number[];
+    freezeFocalPoint?: boolean;
+    physicalTranslation?: number[];
+    physicalScale?: number;
+    physicalViewUp?: number[];
+    physicalViewNorth?: number[];
+}
+export interface vtkSlabCamera extends vtkObject {
+    applyTransform(transformMat4: mat4): void;
+    azimuth(angle: number): void;
+    computeClippingRange(bounds: number[]): Range;
+    computeDistance(): void;
+    computeViewParametersFromPhysicalMatrix(mat: mat4): void;
+    computeViewParametersFromViewMatrix(vmat: mat4): void;
+    deepCopy(sourceCamera: vtkSlabCamera): void;
+    dolly(amount: number): void;
+    elevation(angle: number): void;
+    getCameraLightTransformMatrix(): void;
+    getClippingRange(): number[];
+    getClippingRangeByReference(): number[];
+    getCompositeProjectionMatrix(aspect: number, nearz: number, farz: number): mat4;
+    getDirectionOfProjection(): number[];
+    getDirectionOfProjectionByReference(): number[];
+    getDistance(): number;
+    getFocalPoint(): number[];
+    getFocalPointByReference(): number[];
+    getFreezeFocalPoint(): boolean;
+    setFreezeFocalPoint(freeze: boolean): void;
+    getFrustumPlanes(aspect: number): void;
+    getOrientation(): void;
+    getOrientationWXYZ(): void;
+    getParallelProjection(): boolean;
+    getParallelScale(): number;
+    getPhysicalScale(): number;
+    getPhysicalToWorldMatrix(result: mat4): void;
+    getPhysicalTranslation(): number[];
+    getPhysicalTranslationByReference(): number[];
+    getPhysicalViewNorth(): number[];
+    getPhysicalViewNorthByReference(): number[];
+    getPhysicalViewUp(): number[];
+    getPhysicalViewUpByReference(): number[];
+    getPosition(): number[];
+    getPositionByReference(): number[];
+    getProjectionMatrix(aspect: number, nearz: number, farz: number): null | mat4;
+    getRoll(): void;
+    getScreenBottomLeft(): number[];
+    getScreenBottomLeftByReference(): number[];
+    getScreenBottomRight(): number[];
+    getScreenBottomRightByReference(): number[];
+    getScreenTopRight(): number[];
+    getScreenTopRightByReference(): number[];
+    getThickness(): number;
+    getUseHorizontalViewAngle(): boolean;
+    getUseOffAxisProjection(): boolean;
+    getViewAngle(): number;
+    getViewMatrix(): null | mat4;
+    getViewPlaneNormal(): number[];
+    getViewPlaneNormalByReference(): number[];
+    getViewUp(): number[];
+    getViewUpByReference(): number[];
+    getWindowCenter(): number[];
+    getWindowCenterByReference(): number[];
+    getWorldToPhysicalMatrix(result: mat4): void;
+    getIsPerformingCoordinateTransformation(status: boolean): void;
+    orthogonalizeViewUp(): void;
+    physicalOrientationToWorldDirection(ori: number[]): number[];
+    pitch(angle: number): void;
+    roll(angle: number): void;
+    setClippingRange(near: number, far: number): boolean;
+    setClippingRange(clippingRange: number[]): boolean;
+    setClippingRangeFrom(clippingRange: number[]): boolean;
+    setDeviceAngles(alpha: number, beta: number, gamma: number, screen: number): boolean;
+    setDirectionOfProjection(x: number, y: number, z: number): boolean;
+    setDistance(distance: number): boolean;
+    setFocalPoint(x: number, y: number, z: number): boolean;
+    setFocalPointFrom(focalPoint: number[]): boolean;
+    setObliqueAngles(alpha: number, beta: number): boolean;
+    setOrientationWXYZ(degrees: number, x: number, y: number, z: number): boolean;
+    setParallelProjection(parallelProjection: boolean): boolean;
+    setParallelScale(parallelScale: number): boolean;
+    setPhysicalScale(physicalScale: number): boolean;
+    setPhysicalTranslation(x: number, y: number, z: number): boolean;
+    setPhysicalTranslationFrom(physicalTranslation: number[]): boolean;
+    setPhysicalViewNorth(x: number, y: number, z: number): boolean;
+    setPhysicalViewNorthFrom(physicalViewNorth: number[]): boolean;
+    setPhysicalViewUp(x: number, y: number, z: number): boolean;
+    setPhysicalViewUpFrom(physicalViewUp: number[]): boolean;
+    setPosition(x: number, y: number, z: number): boolean;
+    setProjectionMatrix(mat: mat4): boolean;
+    setRoll(angle: number): boolean;
+    setScreenBottomLeft(x: number, y: number, z: number): boolean;
+    setScreenBottomLeft(screenBottomLeft: number[]): boolean;
+    setScreenBottomLeftFrom(screenBottomLeft: number[]): boolean;
+    setScreenBottomRight(x: number, y: number, z: number): boolean;
+    setScreenBottomRight(screenBottomRight: number[]): boolean;
+    setScreenBottomRightFrom(screenBottomRight: number[]): boolean;
+    setScreenTopRight(x: number, y: number, z: number): boolean;
+    setScreenTopRight(screenTopRight: number[]): boolean;
+    setScreenTopRightFrom(screenTopRight: number[]): boolean;
+    setThickness(thickness: number): boolean;
+    setThicknessFromFocalPoint(thickness: number): boolean;
+    setUseHorizontalViewAngle(useHorizontalViewAngle: boolean): boolean;
+    setUseOffAxisProjection(useOffAxisProjection: boolean): boolean;
+    setViewAngle(viewAngle: number): boolean;
+    setViewMatrix(mat: mat4): boolean;
+    setViewUp(x: number, y: number, z: number): boolean;
+    setViewUp(viewUp: number[]): boolean;
+    setViewUpFrom(viewUp: number[]): boolean;
+    setWindowCenter(x: number, y: number): boolean;
+    setWindowCenterFrom(windowCenter: number[]): boolean;
+    translate(x: number, y: number, z: number): void;
+    yaw(angle: number): void;
+    zoom(factor: number): void;
+    setIsPerformingCoordinateTransformation(status: boolean): void;
+    computeCameraLightTransform(): void;
+}
+declare function extend(publicAPI: any, model: any, initialValues?: ICameraInitialValues): void;
+declare const newInstance: (initialValues?: ICameraInitialValues) => vtkSlabCamera;
+declare const _default: {
+    newInstance: (initialValues?: ICameraInitialValues) => vtkSlabCamera;
+    extend: typeof extend;
+};
+export default _default;
+export { newInstance, extend };

package/dist/esm/RenderingEngine/vtkClasses/vtkSlabCamera.js

@@ -84,4 +84,3 @@ function vtkSlabCamera(publicAPI, model) {
 }
 export default { newInstance, extend };
 export { newInstance, extend };
-//# sourceMappingURL=vtkSlabCamera.js.map

package/dist/esm/RenderingEngine/vtkClasses/vtkStreamingOpenGLRenderWindow.d.ts

@@ -0,0 +1,7 @@
+export function extend(publicAPI: any, model: any, initialValues?: {}): void;
+export const newInstance: any;
+declare namespace _default {
+    export { newInstance };
+    export { extend };
+}
+export default _default;

package/dist/esm/RenderingEngine/vtkClasses/vtkStreamingOpenGLRenderWindow.js

@@ -13,4 +13,3 @@ export function extend(publicAPI, model, initialValues = {}) {
 }
 export const newInstance = macro.newInstance(extend, 'vtkStreamingOpenGLRenderWindow');
 export default { newInstance, extend };
-//# sourceMappingURL=vtkStreamingOpenGLRenderWindow.js.map

package/dist/esm/RenderingEngine/vtkClasses/vtkStreamingOpenGLTexture.d.ts

@@ -0,0 +1,7 @@
+export function extend(publicAPI: any, model: any, initialValues?: {}): void;
+export const newInstance: any;
+declare namespace _default {
+    export { newInstance };
+    export { extend };
+}
+export default _default;