@cornerstonejs/core 5.0.0-beta.1 → 5.0.0

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

@@ -6,6 +6,74 @@ import getRenderingEngine from './getRenderingEngine';
 import VolumeViewport from './VolumeViewport';
 import StackViewport from './StackViewport';
 import VolumeViewport3D from './VolumeViewport3D';
+import { defaultRenderPathResolver, DefaultRenderPathResolver, GenericViewport, ViewportProjectionService, viewportProjection } from './GenericViewport';
+import ECGGenericViewport, { createDefaultECGRenderPaths, createECGRenderPathResolver, DefaultECGDataProvider, ecgProjection } from './GenericViewport/ECG';
+import VideoGenericViewport, { createDefaultVideoRenderPaths, createVideoRenderPathResolver, DefaultVideoDataProvider, videoProjection } from './GenericViewport/Video';
+import PlanarViewport, { createDefaultPlanarRenderPaths, createPlanarRenderPathResolver, DefaultPlanarDataProvider, planarProjection } from './GenericViewport/Planar';
+import GenericVolumeViewport3D, { createDefaultVolume3DRenderPaths, createVolume3DRenderPathResolver, DefaultVolume3DDataProvider, volume3DProjection } from './GenericViewport/Volume3D';
+import WSIGenericViewport, { createDefaultWSIRenderPaths, createWSIRenderPathResolver, DefaultWSIDataProvider, wsiProjection } from './GenericViewport/WSI';
 export * from './helpers';
-export { getRenderingEngine, RenderingEngine, BaseRenderingEngine, TiledRenderingEngine, ContextPoolRenderingEngine, VolumeViewport, VolumeViewport3D, StackViewport, };
+export type { BuiltInViewportProjectionByKind, BuiltInViewportProjectionByType, BuiltInViewportProjectionKind, BuiltInViewportProjectionType, ProjectionPresentationForKind, ProjectionPresentationForViewport, ProjectionPresentationForViewportType, ProjectionPosition, ProjectionPresentation, ProjectionRequest, ProjectionScale, ProjectionSnapshotForKind, ProjectionSnapshotForViewport, ProjectionSnapshotForViewportType, ProjectionSnapshot, ProjectionSpaces, ProjectionTransforms, ProjectionViewStateForKind, ProjectionViewStateForViewport, ProjectionViewStateForViewportType, ProjectionWriteOptions, ViewportProjectionAdapter, } from './GenericViewport';
+export type { ECGProjectionPresentation, ECGProjectionRequest, ECGProjectionSnapshot, ECGViewState, } from './GenericViewport/ECG';
+export type { VideoProjectionPresentation, VideoProjectionRequest, VideoProjectionSnapshot, VideoViewState, } from './GenericViewport/Video';
+export type { PlanarDisplayArea, PlanarProjectionPresentation, PlanarProjectionRequest, PlanarProjectionSnapshot, PlanarViewPresentation, PlanarViewPresentationSelector, PlanarViewState, } from './GenericViewport/Planar';
+export type { WSIProjectionPresentation, WSIProjectionRequest, WSIProjectionSnapshot, WSIViewState, } from './GenericViewport/WSI';
+export type { Volume3DCamera, Volume3DProjectionPresentation, Volume3DProjectionRequest, Volume3DProjectionSnapshot, } from './GenericViewport/Volume3D';
+declare const renderingEngineExportsV2: {
+    GenericViewport: typeof GenericViewport;
+    DefaultRenderPathResolver: typeof DefaultRenderPathResolver;
+    defaultRenderPathResolver: DefaultRenderPathResolver;
+    ViewportProjectionService: typeof ViewportProjectionService;
+    viewportProjection: ViewportProjectionService;
+    ECGGenericViewport: typeof ECGGenericViewport;
+    createDefaultECGRenderPaths: typeof createDefaultECGRenderPaths;
+    createECGRenderPathResolver: typeof createECGRenderPathResolver;
+    DefaultECGDataProvider: typeof DefaultECGDataProvider;
+    ecgProjection: {
+        adapter: import("./GenericViewport").ViewportProjectionAdapter<import("./GenericViewport").ECGViewState, import("../types").ViewPresentation, import("./GenericViewport").ECGProjectionSnapshot>;
+        getSnapshot: typeof import("./GenericViewport/ECG/ecgProjectionSnapshot").getECGProjectionSnapshot;
+    };
+    VideoGenericViewport: typeof VideoGenericViewport;
+    createDefaultVideoRenderPaths: typeof createDefaultVideoRenderPaths;
+    createVideoRenderPathResolver: typeof createVideoRenderPathResolver;
+    DefaultVideoDataProvider: typeof DefaultVideoDataProvider;
+    videoProjection: {
+        adapter: import("./GenericViewport").ViewportProjectionAdapter<import("./GenericViewport").VideoViewState, import("../types").ViewPresentation, import("./GenericViewport").VideoProjectionSnapshot>;
+        getSnapshot: typeof import("./GenericViewport/Video/videoProjectionSnapshot").getVideoProjectionSnapshot;
+    };
+    PlanarViewport: typeof PlanarViewport;
+    createDefaultPlanarRenderPaths: typeof createDefaultPlanarRenderPaths;
+    createPlanarRenderPathResolver: typeof createPlanarRenderPathResolver;
+    DefaultPlanarDataProvider: typeof DefaultPlanarDataProvider;
+    planarProjection: {
+        adapter: import("./GenericViewport").ViewportProjectionAdapter<import("./GenericViewport").PlanarViewState, import("..").PlanarViewPresentation, import("./GenericViewport").PlanarProjectionSnapshot>;
+        getSnapshot: typeof import("./GenericViewport/Planar/planarProjectionSnapshot").getPlanarProjectionSnapshot;
+        getZoom: typeof import("./GenericViewport/Planar/planarProjectionSnapshot").getPlanarProjectionZoom;
+        getScale: typeof import("./GenericViewport/Planar/planarProjectionSnapshot").getPlanarProjectionScale;
+        getPan: typeof import("./GenericViewport/Planar/planarProjectionSnapshot").getPlanarProjectionPan;
+        resolveICamera: typeof import("./GenericViewport/Planar/planarRenderCamera").resolvePlanarICamera;
+        derivePresentation: typeof import("./GenericViewport/Planar/planarRenderCamera").derivePlanarPresentation;
+        applyToRenderer: typeof import("./GenericViewport/Planar/planarRenderCamera").applyPlanarICameraToRenderer;
+        createImageSliceBasis: typeof import("./GenericViewport/Planar/planarSliceBasis").createPlanarImageSliceBasis;
+        createVolumeSliceBasis: typeof import("./GenericViewport/Planar/planarSliceBasis").createPlanarVolumeSliceBasis;
+    };
+    VolumeViewport3D: typeof GenericVolumeViewport3D;
+    createDefaultVolume3DRenderPaths: typeof createDefaultVolume3DRenderPaths;
+    createVolume3DRenderPathResolver: typeof createVolume3DRenderPathResolver;
+    DefaultVolume3DDataProvider: typeof DefaultVolume3DDataProvider;
+    volume3DProjection: {
+        adapter: import("./GenericViewport").ViewportProjectionAdapter<import("./GenericViewport").Volume3DCamera, import("./GenericViewport").Volume3DProjectionPresentation, import("./GenericViewport").Volume3DProjectionSnapshot>;
+        getSnapshot: typeof import("./GenericViewport/Volume3D/volume3DProjectionSnapshot").getVolume3DProjectionSnapshot;
+    };
+    WSIGenericViewport: typeof WSIGenericViewport;
+    createDefaultWSIRenderPaths: typeof createDefaultWSIRenderPaths;
+    createWSIRenderPathResolver: typeof createWSIRenderPathResolver;
+    DefaultWSIDataProvider: typeof DefaultWSIDataProvider;
+    wsiProjection: {
+        adapter: import("./GenericViewport").ViewportProjectionAdapter<import("./GenericViewport").WSIViewState, import("../types").ViewPresentation, import("./GenericViewport").WSIProjectionSnapshot>;
+        getSnapshot: typeof import("./GenericViewport/WSI/wsiProjectionSnapshot").getWSIProjectionSnapshot;
+    };
+};
+declare const LegacyVolumeViewport3D: typeof VolumeViewport3D;
+export { getRenderingEngine, RenderingEngine, BaseRenderingEngine, TiledRenderingEngine, ContextPoolRenderingEngine, VolumeViewport, LegacyVolumeViewport3D, StackViewport, GenericVolumeViewport3D, GenericViewport, DefaultRenderPathResolver, defaultRenderPathResolver, ViewportProjectionService, viewportProjection, ECGGenericViewport, createDefaultECGRenderPaths, createECGRenderPathResolver, DefaultECGDataProvider, ecgProjection, VideoGenericViewport, createDefaultVideoRenderPaths, createVideoRenderPathResolver, DefaultVideoDataProvider, videoProjection, PlanarViewport, createDefaultPlanarRenderPaths, createPlanarRenderPathResolver, DefaultPlanarDataProvider, planarProjection, VolumeViewport3D, createDefaultVolume3DRenderPaths, createVolume3DRenderPathResolver, DefaultVolume3DDataProvider, volume3DProjection, WSIGenericViewport, createDefaultWSIRenderPaths, createWSIRenderPathResolver, DefaultWSIDataProvider, wsiProjection, renderingEngineExportsV2, };
 export default RenderingEngine;

package/dist/esm/RenderingEngine/index.js

@@ -6,6 +6,45 @@ import getRenderingEngine from './getRenderingEngine';
 import VolumeViewport from './VolumeViewport';
 import StackViewport from './StackViewport';
 import VolumeViewport3D from './VolumeViewport3D';
+import { defaultRenderPathResolver, DefaultRenderPathResolver, GenericViewport, ViewportProjectionService, viewportProjection, } from './GenericViewport';
+import ECGGenericViewport, { createDefaultECGRenderPaths, createECGRenderPathResolver, DefaultECGDataProvider, ecgProjection, } from './GenericViewport/ECG';
+import VideoGenericViewport, { createDefaultVideoRenderPaths, createVideoRenderPathResolver, DefaultVideoDataProvider, videoProjection, } from './GenericViewport/Video';
+import PlanarViewport, { createDefaultPlanarRenderPaths, createPlanarRenderPathResolver, DefaultPlanarDataProvider, planarProjection, } from './GenericViewport/Planar';
+import GenericVolumeViewport3D, { createDefaultVolume3DRenderPaths, createVolume3DRenderPathResolver, DefaultVolume3DDataProvider, volume3DProjection, } from './GenericViewport/Volume3D';
+import WSIGenericViewport, { createDefaultWSIRenderPaths, createWSIRenderPathResolver, DefaultWSIDataProvider, wsiProjection, } from './GenericViewport/WSI';
 export * from './helpers';
-export { getRenderingEngine, RenderingEngine, BaseRenderingEngine, TiledRenderingEngine, ContextPoolRenderingEngine, VolumeViewport, VolumeViewport3D, StackViewport, };
+const renderingEngineExportsV2 = {
+    GenericViewport,
+    DefaultRenderPathResolver,
+    defaultRenderPathResolver,
+    ViewportProjectionService,
+    viewportProjection,
+    ECGGenericViewport,
+    createDefaultECGRenderPaths,
+    createECGRenderPathResolver,
+    DefaultECGDataProvider,
+    ecgProjection,
+    VideoGenericViewport,
+    createDefaultVideoRenderPaths,
+    createVideoRenderPathResolver,
+    DefaultVideoDataProvider,
+    videoProjection,
+    PlanarViewport,
+    createDefaultPlanarRenderPaths,
+    createPlanarRenderPathResolver,
+    DefaultPlanarDataProvider,
+    planarProjection,
+    VolumeViewport3D: GenericVolumeViewport3D,
+    createDefaultVolume3DRenderPaths,
+    createVolume3DRenderPathResolver,
+    DefaultVolume3DDataProvider,
+    volume3DProjection,
+    WSIGenericViewport,
+    createDefaultWSIRenderPaths,
+    createWSIRenderPathResolver,
+    DefaultWSIDataProvider,
+    wsiProjection,
+};
+const LegacyVolumeViewport3D = VolumeViewport3D;
+export { getRenderingEngine, RenderingEngine, BaseRenderingEngine, TiledRenderingEngine, ContextPoolRenderingEngine, VolumeViewport, LegacyVolumeViewport3D, StackViewport, GenericVolumeViewport3D, GenericViewport, DefaultRenderPathResolver, defaultRenderPathResolver, ViewportProjectionService, viewportProjection, ECGGenericViewport, createDefaultECGRenderPaths, createECGRenderPathResolver, DefaultECGDataProvider, ecgProjection, VideoGenericViewport, createDefaultVideoRenderPaths, createVideoRenderPathResolver, DefaultVideoDataProvider, videoProjection, PlanarViewport, createDefaultPlanarRenderPaths, createPlanarRenderPathResolver, DefaultPlanarDataProvider, planarProjection, VolumeViewport3D, createDefaultVolume3DRenderPaths, createVolume3DRenderPathResolver, DefaultVolume3DDataProvider, volume3DProjection, WSIGenericViewport, createDefaultWSIRenderPaths, createWSIRenderPathResolver, DefaultWSIDataProvider, wsiProjection, renderingEngineExportsV2, };
 export default RenderingEngine;

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

@@ -0,0 +1,38 @@
+import vtkCamera from '@kitware/vtk.js/Rendering/Core/Camera';
+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[];
+    aspectRatio?: number[];
+}
+declare module '@kitware/vtk.js/Rendering/Core/Camera' {
+    interface vtkCamera {
+        getAspectRatio(): [x: number, y: number];
+        setAspectRatio(aspectRatio: [x: number, y: number]): boolean;
+    }
+}
+export type extendedVtkCamera = vtkCamera;
+export declare function extend(publicAPI: any, model: any, initialValues?: {}): void;
+export declare const newInstance: (initialValues?: ICameraInitialValues) => extendedVtkCamera;
+declare const _default: {
+    newInstance: (initialValues?: ICameraInitialValues) => extendedVtkCamera;
+    extend: typeof extend;
+};
+export default _default;

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

@@ -0,0 +1,35 @@
+import macro from '@kitware/vtk.js/macros';
+import vtkCamera from '@kitware/vtk.js/Rendering/Core/Camera';
+import { getProjectionScaleMatrix } from '../helpers/getProjectionScaleMatrix';
+import { getNormalizedAspectRatio } from '../../utilities/getNormalizedAspectRatio';
+import { mat4 } from 'gl-matrix';
+function extendedVtkCamera(publicAPI, model) {
+    model.classHierarchy.push('extendedVtkCamera');
+    const superGetProjectionMatrix = publicAPI.getProjectionMatrix;
+    publicAPI.getProjectionMatrix = (aspect, nearZ, farZ) => {
+        const matrix = superGetProjectionMatrix(aspect, nearZ, farZ);
+        const [sx, sy] = getNormalizedAspectRatio(model.aspectRatio);
+        if (sx !== 1.0 || sy !== 1.0) {
+            const scaleMatrix = getProjectionScaleMatrix([sx, sy]);
+            mat4.multiply(matrix, scaleMatrix, matrix);
+        }
+        return matrix;
+    };
+    publicAPI.getAspectRatio = () => {
+        return model.aspectRatio;
+    };
+    publicAPI.setAspectRatio = (aspectRatio) => {
+        model.aspectRatio = aspectRatio;
+    };
+}
+const DEFAULT_VALUES = {
+    aspectRatio: [1, 1],
+};
+export function extend(publicAPI, model, initialValues = {}) {
+    Object.assign(model, DEFAULT_VALUES, initialValues);
+    vtkCamera.extend(publicAPI, model, initialValues);
+    macro.setGet(publicAPI, model, ['aspectRatio']);
+    extendedVtkCamera(publicAPI, model);
+}
+export const newInstance = macro.newInstance(extend, 'extendedVtkCamera');
+export default { newInstance, extend };

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

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

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

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

package/dist/esm/RenderingEngine/vtkClasses/vtkSharedImageResliceMapper.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/vtkSharedImageResliceMapper.js

@@ -0,0 +1,21 @@
+import macro from '@kitware/vtk.js/macros';
+import vtkImageResliceMapper from '@kitware/vtk.js/Rendering/Core/ImageResliceMapper';
+function vtkSharedImageResliceMapper(publicAPI, model) {
+    model.classHierarchy.push('vtkSharedImageResliceMapper');
+    const superDelete = publicAPI.delete;
+    publicAPI.delete = () => {
+        model.scalarTexture = null;
+        superDelete();
+    };
+}
+const DEFAULT_VALUES = {
+    scalarTexture: null,
+};
+export function extend(publicAPI, model, initialValues = {}) {
+    Object.assign(model, DEFAULT_VALUES, initialValues);
+    vtkImageResliceMapper.extend(publicAPI, model, initialValues);
+    macro.setGet(publicAPI, model, ['scalarTexture']);
+    vtkSharedImageResliceMapper(publicAPI, model);
+}
+export const newInstance = macro.newInstance(extend, 'vtkSharedImageResliceMapper');
+export default { newInstance, extend };

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

@@ -131,6 +131,8 @@ export interface vtkSlabCamera extends vtkObject {
     zoom(factor: number): void;
     setIsPerformingCoordinateTransformation(status: boolean): void;
     computeCameraLightTransform(): void;
+    getAspectRatio(): [x: number, y: number];
+    setAspectRatio(aspectRatio: [x: number, y: number]): boolean;
 }
 declare function extend(publicAPI: any, model: any, initialValues?: ICameraInitialValues): void;
 declare const newInstance: (initialValues?: ICameraInitialValues) => vtkSlabCamera;

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

@@ -1,13 +1,15 @@
 import macro from '@kitware/vtk.js/macros';
-import vtkCamera from '@kitware/vtk.js/Rendering/Core/Camera';
+import extendedVtkCamera from './extendedVtkCamera';
 import vtkMath from '@kitware/vtk.js/Common/Core/Math';
 import { vec3, mat4 } from 'gl-matrix';
+import { getProjectionScaleMatrix } from '../helpers/getProjectionScaleMatrix';
+import { getNormalizedAspectRatio } from '../../utilities/getNormalizedAspectRatio';
 const DEFAULT_VALUES = {
     isPerformingCoordinateTransformation: false,
 };
 function extend(publicAPI, model, initialValues = {}) {
     Object.assign(model, DEFAULT_VALUES, initialValues);
-    vtkCamera.extend(publicAPI, model, initialValues);
+    extendedVtkCamera.extend(publicAPI, model, initialValues);
     macro.setGet(publicAPI, model, ['isPerformingCoordinateTransformation']);
     vtkSlabCamera(publicAPI, model);
 }
@@ -78,6 +80,11 @@ function vtkSlabCamera(publicAPI, model) {
             tmpMatrix[11] = (-2.0 * znear * zfar) / (zfar - znear);
             tmpMatrix[15] = 0.0;
         }
+        const [sx, sy] = getNormalizedAspectRatio(model.aspectRatio);
+        if (sx !== 1.0 || sy !== 1.0) {
+            const scaleMatrix = getProjectionScaleMatrix([sx, sy]);
+            mat4.multiply(tmpMatrix, scaleMatrix, tmpMatrix);
+        }
         mat4.copy(result, tmpMatrix);
         return result;
     };

package/dist/esm/RenderingEngine/vtkClasses/vtkStreamingOpenGLImageResliceMapper.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;