@cornerstonejs/core 4.2.3 → 4.3.0

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

@@ -9,6 +9,7 @@ import type vtkRenderer from '@kitware/vtk.js/Rendering/Core/Renderer';
 declare abstract class BaseVolumeViewport extends Viewport {
     useCPURendering: boolean;
     private _FrameOfReferenceUID;
+    private sharpening;
     protected initialTransferFunctionNodes: TransferFunctionNodes;
     private globalDefaultProperties;
     private perVolumeIdDefaultProperties;
@@ -47,7 +48,10 @@ declare abstract class BaseVolumeViewport extends Viewport {
     setViewPlane(planeRestriction: PlaneRestriction): void;
     setViewReference(viewRef: ViewReference): void;
     private setThreshold;
-    setProperties({ voiRange, VOILUTFunction, invert, colormap, preset, interpolationType, slabThickness, sampleDistanceMultiplier, }?: VolumeViewportProperties, volumeId?: string, suppressEvents?: boolean): void;
+    setProperties({ voiRange, VOILUTFunction, invert, colormap, preset, interpolationType, slabThickness, sampleDistanceMultiplier, sharpening, }?: VolumeViewportProperties, volumeId?: string, suppressEvents?: boolean): void;
+    private setSharpening;
+    protected shouldUseCustomRenderPass(): boolean;
+    getRenderPasses: () => any[];
     resetToDefaultProperties(volumeId: string): void;
     private setPreset;
     setSampleDistanceMultiplier(multiplier: number): void;

package/dist/esm/RenderingEngine/BaseVolumeViewport.js

@@ -30,10 +30,12 @@ import * as metaData from '../metaData';
 import { getCameraVectors } from './helpers/getCameraVectors';
 import { isContextPoolRenderingEngine } from './helpers/isContextPoolRenderingEngine';
 import mprCameraValues from '../constants/mprCameraValues';
+import { createSharpeningRenderPass } from './renderPasses';
 class BaseVolumeViewport extends Viewport {
     constructor(props) {
         super(props);
         this.useCPURendering = false;
+        this.sharpening = 0;
         this.perVolumeIdDefaultProperties = new Map();
         this.viewportProperties = {};
         this.volumeIds = new Set();
@@ -69,6 +71,22 @@ class BaseVolumeViewport extends Viewport {
             };
             triggerEvent(this.element, Events.CAMERA_MODIFIED, eventDetail);
         };
+        this.setSharpening = (sharpening) => {
+            this.sharpening = sharpening;
+            this.render();
+        };
+        this.getRenderPasses = () => {
+            if (!this.shouldUseCustomRenderPass()) {
+                return null;
+            }
+            try {
+                return [createSharpeningRenderPass(this.sharpening)];
+            }
+            catch (e) {
+                console.warn('Failed to create sharpening render passes:', e);
+                return null;
+            }
+        };
         this.getDefaultProperties = (volumeId) => {
             let volumeProperties;
             if (volumeId !== undefined) {
@@ -114,6 +132,7 @@ class BaseVolumeViewport extends Viewport {
                 invert: invert,
                 slabThickness: slabThickness,
                 preset,
+                sharpening: this.sharpening,
             };
         };
         this.getColormap = (volumeId) => {
@@ -172,13 +191,16 @@ class BaseVolumeViewport extends Viewport {
             const devicePixelRatio = window.devicePixelRatio || 1;
             const { width, height } = this.canvas;
             const aspectRatio = width / height;
+            const [xMin, yMin, xMax, yMax] = renderer.getViewport();
+            const viewportWidth = xMax - xMin;
+            const viewportHeight = yMax - yMin;
             const canvasPosWithDPR = [
                 canvasPos[0] * devicePixelRatio,
                 canvasPos[1] * devicePixelRatio,
             ];
             const normalizedDisplay = [
-                canvasPosWithDPR[0] / width,
-                1 - canvasPosWithDPR[1] / height,
+                xMin + (canvasPosWithDPR[0] / width) * viewportWidth,
+                yMin + (1 - canvasPosWithDPR[1] / height) * viewportHeight,
                 0,
             ];
             const projCoords = renderer.normalizedDisplayToProjection(normalizedDisplay[0], normalizedDisplay[1], normalizedDisplay[2]);
@@ -209,8 +231,14 @@ class BaseVolumeViewport extends Viewport {
                 canvasPos[0] * devicePixelRatio,
                 canvasPos[1] * devicePixelRatio,
             ];
-            const { height } = this.canvas;
-            const displayCoord = [canvasPosWithDPR[0], height - canvasPosWithDPR[1]];
+            const renderer = this.getRenderer();
+            const { width, height } = this.canvas;
+            const [xMin, yMin, xMax, yMax] = renderer.getViewport();
+            const viewportWidth = xMax - xMin;
+            const viewportHeight = yMax - yMin;
+            const scaledX = (canvasPosWithDPR[0] / width) * viewportWidth * width;
+            const scaledY = (canvasPosWithDPR[1] / height) * viewportHeight * height;
+            const displayCoord = [scaledX, viewportHeight * height - scaledY];
             return [displayCoord[0], displayCoord[1], 0];
         };
         this.worldToCanvasTiled = (worldPos) => {
@@ -240,11 +268,16 @@ class BaseVolumeViewport extends Viewport {
             const renderer = this.getRenderer();
             const { width, height } = this.canvas;
             const aspectRatio = width / height;
+            const [xMin, yMin, xMax, yMax] = renderer.getViewport();
+            const viewportWidth = xMax - xMin;
+            const viewportHeight = yMax - yMin;
             const viewCoords = renderer.worldToView(worldPos[0], worldPos[1], worldPos[2]);
             const projCoords = renderer.viewToProjection(viewCoords[0], viewCoords[1], viewCoords[2], aspectRatio);
             const normalizedDisplay = renderer.projectionToNormalizedDisplay(projCoords[0], projCoords[1], projCoords[2]);
-            const canvasX = normalizedDisplay[0] * width;
-            const canvasY = (1 - normalizedDisplay[1]) * height;
+            const canvasNormalizedX = (normalizedDisplay[0] - xMin) / viewportWidth;
+            const canvasNormalizedY = (normalizedDisplay[1] - yMin) / viewportHeight;
+            const canvasX = canvasNormalizedX * width;
+            const canvasY = (1 - canvasNormalizedY) * height;
             const devicePixelRatio = window.devicePixelRatio || 1;
             const canvasCoordWithDPR = [
                 canvasX / devicePixelRatio,
@@ -720,7 +753,7 @@ class BaseVolumeViewport extends Viewport {
         };
         triggerEvent(this.element, Events.COLORMAP_MODIFIED, eventDetail);
     }
-    setProperties({ voiRange, VOILUTFunction, invert, colormap, preset, interpolationType, slabThickness, sampleDistanceMultiplier, } = {}, volumeId, suppressEvents = false) {
+    setProperties({ voiRange, VOILUTFunction, invert, colormap, preset, interpolationType, slabThickness, sampleDistanceMultiplier, sharpening, } = {}, volumeId, suppressEvents = false) {
         if (this.globalDefaultProperties == null) {
             this.setDefaultProperties({
                 voiRange,
@@ -761,6 +794,12 @@ class BaseVolumeViewport extends Viewport {
         if (sampleDistanceMultiplier !== undefined) {
             this.setSampleDistanceMultiplier(sampleDistanceMultiplier);
         }
+        if (typeof sharpening !== 'undefined') {
+            this.setSharpening(sharpening);
+        }
+    }
+    shouldUseCustomRenderPass() {
+        return this.sharpening > 0 && !this.useCPURendering;
     }
     resetToDefaultProperties(volumeId) {
         const properties = this.globalDefaultProperties;

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

@@ -20,6 +20,7 @@ declare class ContextPoolRenderingEngine extends BaseRenderingEngine {
     private _copyToOnscreenCanvas;
     private _resize;
     private getWidgetRenderers;
+    private getViewportRenderPasses;
     getRenderer(viewportId: string): vtkRenderer | undefined;
     disableElement(viewportId: string): void;
     destroy(): void;

package/dist/esm/RenderingEngine/ContextPoolRenderingEngine.js

@@ -200,6 +200,12 @@ class ContextPoolRenderingEngine extends BaseRenderingEngine {
             });
         }
         const renderWindow = offscreenMultiRenderWindow.getRenderWindow();
+        const view = renderWindow.getViews()[0];
+        const originalRenderPasses = view.getRenderPasses();
+        const viewportRenderPasses = this.getViewportRenderPasses(viewport.id);
+        if (viewportRenderPasses) {
+            view.setRenderPasses(viewportRenderPasses);
+        }
         this._resizeOffScreenCanvasForViewport(viewport, offScreenCanvasContainer, offscreenMultiRenderWindow);
         const renderer = offscreenMultiRenderWindow.getRenderer(viewport.id);
         const contextIndex = this.contextPool.getContextIndexForViewport(viewport.id);
@@ -222,6 +228,9 @@ class ContextPoolRenderingEngine extends BaseRenderingEngine {
         widgetRenderers.forEach((_, renderer) => {
             renderer.setDraw(false);
         });
+        if (originalRenderPasses) {
+            view.setRenderPasses(originalRenderPasses);
+        }
         const openGLRenderWindow = offscreenMultiRenderWindow.getOpenGLRenderWindow();
         const context = openGLRenderWindow.get3DContext();
         const offScreenCanvas = context.canvas;
@@ -310,6 +319,10 @@ class ContextPoolRenderingEngine extends BaseRenderingEngine {
         });
         return widgetRenderers;
     }
+    getViewportRenderPasses(viewportId) {
+        const viewport = this.getViewport(viewportId);
+        return viewport?.getRenderPasses ? viewport.getRenderPasses() : null;
+    }
     getRenderer(viewportId) {
         const contextIndex = this.contextPool?.getContextIndexForViewport(viewportId);
         const contextData = this.contextPool.getContextByIndex(contextIndex);

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

@@ -27,6 +27,7 @@ declare class StackViewport extends Viewport {
     private colormap;
     private voiRange;
     private voiUpdatedWithSetProperties;
+    private sharpening;
     private VOILUTFunction;
     private invert;
     private initialInvert;
@@ -76,6 +77,9 @@ declare class StackViewport extends Viewport {
     protected setInterpolationType: (interpolationType: InterpolationType) => void;
     private setInvertColor;
     private setColormap;
+    private setSharpening;
+    protected shouldUseCustomRenderPass(): boolean;
+    getRenderPasses: () => any[];
     private initializeElementDisabledHandler;
     resize: () => void;
     private _resizeCPU;
@@ -88,7 +92,7 @@ declare class StackViewport extends Viewport {
     private calibrateIfNecessary;
     setDefaultProperties(ViewportProperties: StackViewportProperties, imageId?: string): void;
     clearDefaultProperties(imageId?: string): void;
-    setProperties({ colormap, voiRange, VOILUTFunction, invert, interpolationType, }?: StackViewportProperties, suppressEvents?: boolean): void;
+    setProperties({ colormap, voiRange, VOILUTFunction, invert, interpolationType, sharpening, }?: StackViewportProperties, suppressEvents?: boolean): void;
     getDefaultProperties: (imageId?: string) => StackViewportProperties;
     getProperties: () => StackViewportProperties;
     resetCameraForResize: () => boolean;

package/dist/esm/RenderingEngine/StackViewport.js

@@ -44,7 +44,7 @@ import getSpacingInNormalDirection from '../utilities/getSpacingInNormalDirectio
 import getClosestImageId from '../utilities/getClosestImageId';
 import { adjustInitialViewUp } from '../utilities/adjustInitialViewUp';
 import { isContextPoolRenderingEngine } from './helpers/isContextPoolRenderingEngine';
-const EPSILON = 1;
+import { createSharpeningRenderPass } from './renderPasses';
 const log = coreLog.getLogger('RenderingEngine', 'StackViewport');
 class StackViewport extends Viewport {
     constructor(props) {
@@ -57,6 +57,7 @@ class StackViewport extends Viewport {
         this.globalDefaultProperties = {};
         this.perImageIdDefaultProperties = new Map();
         this.voiUpdatedWithSetProperties = false;
+        this.sharpening = 0;
         this.invert = false;
         this.initialInvert = false;
         this.initialTransferFunctionNodes = null;
@@ -65,6 +66,22 @@ class StackViewport extends Viewport {
         this.updateRenderingPipeline = () => {
             this._configureRenderingPipeline();
         };
+        this.setSharpening = (sharpening) => {
+            this.sharpening = sharpening;
+            this.render();
+        };
+        this.getRenderPasses = () => {
+            if (!this.shouldUseCustomRenderPass()) {
+                return null;
+            }
+            try {
+                return [createSharpeningRenderPass(this.sharpening)];
+            }
+            catch (e) {
+                console.warn('Failed to create sharpening render passes:', e);
+                return null;
+            }
+        };
         this.resize = () => {
             if (this.useCPURendering) {
                 this._resizeCPU();
@@ -115,6 +132,7 @@ class StackViewport extends Viewport {
                 interpolationType,
                 invert,
                 isComputedVOI: !voiUpdatedWithSetProperties,
+                sharpening: this.sharpening,
             };
         };
         this.resetCameraForResize = () => {
@@ -209,9 +227,13 @@ class StackViewport extends Viewport {
                 canvasPos[0] * devicePixelRatio,
                 canvasPos[1] * devicePixelRatio,
             ];
+            const viewport = renderer.getViewport();
+            const [xStart, yStart, xEnd, yEnd] = viewport;
+            const viewportWidth = xEnd - xStart;
+            const viewportHeight = yEnd - yStart;
             const normalizedDisplay = [
-                canvasPosWithDPR[0] / width,
-                1 - canvasPosWithDPR[1] / height,
+                xStart + (canvasPosWithDPR[0] / width) * viewportWidth,
+                yStart + (1 - canvasPosWithDPR[1] / height) * viewportHeight,
                 0,
             ];
             const projCoords = renderer.normalizedDisplayToProjection(normalizedDisplay[0], normalizedDisplay[1], normalizedDisplay[2]);
@@ -255,8 +277,12 @@ class StackViewport extends Viewport {
             const viewCoords = renderer.worldToView(worldPos[0], worldPos[1], worldPos[2]);
             const projCoords = renderer.viewToProjection(viewCoords[0], viewCoords[1], viewCoords[2], aspectRatio);
             const normalizedDisplay = renderer.projectionToNormalizedDisplay(projCoords[0], projCoords[1], projCoords[2]);
-            const canvasX = normalizedDisplay[0] * width;
-            const canvasY = (1 - normalizedDisplay[1]) * height;
+            const viewport = renderer.getViewport();
+            const [xStart, yStart, xEnd, yEnd] = viewport;
+            const viewportWidth = xEnd - xStart;
+            const viewportHeight = yEnd - yStart;
+            const canvasX = ((normalizedDisplay[0] - xStart) / viewportWidth) * width;
+            const canvasY = (1 - (normalizedDisplay[1] - yStart) / viewportHeight) * height;
             vtkCamera.setClippingRange(crange[0], crange[1]);
             const canvasCoordWithDPR = [
                 canvasX / devicePixelRatio,
@@ -508,6 +534,9 @@ class StackViewport extends Viewport {
         camera.setThicknessFromFocalPoint(0.1);
         camera.setFreezeFocalPoint(true);
     }
+    shouldUseCustomRenderPass() {
+        return this.sharpening > 0 && !this.useCPURendering;
+    }
     initializeElementDisabledHandler() {
         eventTarget.addEventListener(Events.ELEMENT_DISABLED, function elementDisabledHandler() {
             clearTimeout(this.debouncedTimeout);
@@ -629,7 +658,7 @@ class StackViewport extends Viewport {
             this.resetToDefaultProperties();
         }
     }
-    setProperties({ colormap, voiRange, VOILUTFunction, invert, interpolationType, } = {}, suppressEvents = false) {
+    setProperties({ colormap, voiRange, VOILUTFunction, invert, interpolationType, sharpening, } = {}, suppressEvents = false) {
         this.viewportStatus = this.csImage
             ? ViewportStatus.PRE_RENDER
             : ViewportStatus.LOADING;
@@ -639,6 +668,7 @@ class StackViewport extends Viewport {
             VOILUTFunction: this.globalDefaultProperties.VOILUTFunction ?? VOILUTFunction,
             invert: this.globalDefaultProperties.invert ?? invert,
             interpolationType: this.globalDefaultProperties.interpolationType ?? interpolationType,
+            sharpening: this.globalDefaultProperties.sharpening ?? sharpening,
         };
         if (typeof colormap !== 'undefined') {
             this.setColormap(colormap);
@@ -656,6 +686,9 @@ class StackViewport extends Viewport {
         if (typeof interpolationType !== 'undefined') {
             this.setInterpolationType(interpolationType);
         }
+        if (typeof sharpening !== 'undefined') {
+            this.setSharpening(sharpening);
+        }
     }
     resetProperties() {
         this.cpuRenderingInvalidated = true;
@@ -1452,7 +1485,7 @@ class StackViewport extends Viewport {
             renderingEngineId: this.renderingEngineId,
         };
         triggerEvent(this.element, Events.PRE_STACK_NEW_IMAGE, eventDetail);
-        return this.imagesLoader.loadImages([imageId], this).then((v) => {
+        return this.imagesLoader.loadImages([imageId], this).then(() => {
             return imageId;
         });
     }
@@ -1776,7 +1809,7 @@ class StackViewport extends Viewport {
                 return true;
             }
             viewRef.referencedImageURI ||= imageIdToURI(referencedImageId);
-            const { referencedImageURI: referencedImageURI } = viewRef;
+            const { referencedImageURI } = viewRef;
             const foundSliceIndex = this.imageKeyToIndexMap.get(referencedImageURI);
             if (options.asOverlay) {
                 const matchedImageId = this.matchImagesForOverlay(currentImageId, referencedImageId);
@@ -1843,7 +1876,7 @@ class StackViewport extends Viewport {
         }
         const { referencedImageId } = viewRef;
         viewRef.referencedImageURI ||= imageIdToURI(referencedImageId);
-        const { referencedImageURI: referencedImageURI } = viewRef;
+        const { referencedImageURI } = viewRef;
         const sliceIndex = this.imageKeyToIndexMap.get(referencedImageURI);
         if (sliceIndex === undefined) {
             log.error(`No image URI found for ${referencedImageURI}`);

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

@@ -51,6 +51,7 @@ declare class Viewport {
     addWidget: (widgetId: any, widget: any) => void;
     getWidget: (id: any) => any;
     getWidgets: () => any[];
+    getRenderPasses: () => any;
     removeWidgets: () => void;
     setRendered(): void;
     protected setColorTransform(voiRange: any, averageWhite: any): any;

package/dist/esm/RenderingEngine/Viewport.js

@@ -50,6 +50,9 @@ class Viewport {
         this.getWidgets = () => {
             return Array.from(this.viewportWidgets.values());
         };
+        this.getRenderPasses = () => {
+            return null;
+        };
         this.removeWidgets = () => {
             const widgets = this.getWidgets();
             widgets.forEach((widget) => {

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

@@ -0,0 +1,2 @@
+import { createSharpeningRenderPass } from './sharpeningRenderPass';
+export { createSharpeningRenderPass };

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

@@ -0,0 +1,2 @@
+import { createSharpeningRenderPass } from './sharpeningRenderPass';
+export { createSharpeningRenderPass };

package/dist/esm/RenderingEngine/renderPasses/sharpeningRenderPass.d.ts

@@ -0,0 +1,2 @@
+declare function createSharpeningRenderPass(intensity: number): any;
+export { createSharpeningRenderPass };

package/dist/esm/RenderingEngine/renderPasses/sharpeningRenderPass.js

@@ -0,0 +1,15 @@
+import vtkConvolution2DPass from '@kitware/vtk.js/Rendering/OpenGL/Convolution2DPass';
+import vtkForwardPass from '@kitware/vtk.js/Rendering/OpenGL/ForwardPass';
+function createSharpeningRenderPass(intensity) {
+    let renderPass = vtkForwardPass.newInstance();
+    if (intensity > 0) {
+        const convolutionPass = vtkConvolution2DPass.newInstance();
+        convolutionPass.setDelegates([renderPass]);
+        const k = Math.max(0, intensity);
+        convolutionPass.setKernelDimension(3);
+        convolutionPass.setKernel([-k, -k, -k, -k, 1 + 8 * k, -k, -k, -k, -k]);
+        renderPass = convolutionPass;
+    }
+    return renderPass;
+}
+export { createSharpeningRenderPass };

package/dist/esm/types/ViewportProperties.d.ts

@@ -9,4 +9,5 @@ export interface ViewportProperties {
     interpolationType?: InterpolationType;
     preset?: string;
     sampleDistanceMultiplier?: number;
+    sharpening?: number;
 }

package/dist/esm/version.d.ts

@@ -1 +1 @@
-export declare const version = "4.2.3";
+export declare const version = "4.3.0";

package/dist/esm/version.js

@@ -1 +1 @@
-export const version = '4.2.3';
+export const version = '4.3.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/core",
-  "version": "4.2.3",
+  "version": "4.3.0",
   "description": "Cornerstone3D Core",
   "module": "./dist/esm/index.js",
   "types": "./dist/esm/index.d.ts",
@@ -97,5 +97,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "d924485f9e0adcb67e8064f8a6356519d43cf36c"
+  "gitHead": "cf613e09e1bb68bd7859092ba02e9ce3603ce3da"
 }