@cornerstonejs/core 2.18.7 → 2.18.9

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

@@ -7,6 +7,7 @@ import vtkDataArray from '@kitware/vtk.js/Common/Core/DataArray';
 import { Representation } from '@kitware/vtk.js/Rendering/Core/Property/Constants';
 import vtkOpenGLTexture from '@kitware/vtk.js/Rendering/OpenGL/Texture';
 import { getConstructorFromType } from '../../utilities/getBufferConfiguration';
+import { getCanUseNorm16Texture } from '../../init';
 function vtkStreamingOpenGLVolumeMapper(publicAPI, model) {
     model.classHierarchy.push('vtkStreamingOpenGLVolumeMapper');
     publicAPI.buildBufferObjects = (ren, actor) => {
@@ -132,7 +133,7 @@ function vtkStreamingOpenGLVolumeMapper(publicAPI, model) {
             }
             if (shouldReset) {
                 const norm16Ext = model.context.getExtension('EXT_texture_norm16');
-                model.scalarTexture.setOglNorm16Ext(norm16Ext);
+                model.scalarTexture.setOglNorm16Ext(getCanUseNorm16Texture() ? norm16Ext : null);
                 model.scalarTexture.resetFormatAndType();
                 model.scalarTexture.setTextureParameters({
                     width: dims[0],

package/dist/esm/init.d.ts

@@ -1,5 +1,6 @@
 import type { Cornerstone3DConfig } from './types';
 declare function init(configuration?: Cornerstone3DConfig): boolean;
+declare function getCanUseNorm16Texture(): boolean;
 declare function setUseCPURendering(status: boolean, updateViewports?: boolean): void;
 declare function setPreferSizeOverAccuracy(status: boolean): void;
 declare function canRenderFloatTextures(): boolean;
@@ -11,4 +12,4 @@ declare function getConfiguration(): Cornerstone3DConfig;
 declare function setConfiguration(c: Cornerstone3DConfig): void;
 declare function getWebWorkerManager(): any;
 declare function peerImport(moduleId: string): Promise<any>;
-export { init, getShouldUseCPURendering, isCornerstoneInitialized, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, peerImport, resetInitialization, };
+export { init, getShouldUseCPURendering, isCornerstoneInitialized, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, peerImport, resetInitialization, getCanUseNorm16Texture, };

package/dist/esm/init.js

@@ -2,6 +2,7 @@ import { getRenderingEngines } from './RenderingEngine/getRenderingEngine';
 let csRenderInitialized = false;
 import deepMerge from './utilities/deepMerge';
 import CentralizedWebWorkerManager from './webWorkerManager/webWorkerManager';
+import { getSupportedTextureFormats } from './utilities/textureSupport';
 const defaultConfig = {
     gpuTier: { tier: 2 },
     isMobile: false,
@@ -17,6 +18,7 @@ let config = {
     rendering: { ...defaultConfig.rendering },
 };
 let webWorkerManager = null;
+let canUseNorm16Texture = false;
 function _getGLContext() {
     const canvas = document.createElement('canvas');
     const gl = canvas.getContext('webgl2') ||
@@ -29,14 +31,8 @@ function _hasActiveWebGLContext() {
     return (gl instanceof WebGLRenderingContext || gl instanceof WebGL2RenderingContext);
 }
 function _hasNorm16TextureSupport() {
-    const gl = _getGLContext();
-    if (gl) {
-        const ext = gl.getExtension('EXT_texture_norm16');
-        if (ext) {
-            return true;
-        }
-    }
-    return false;
+    const supportedTextureFormats = getSupportedTextureFormats();
+    return supportedTextureFormats.norm16 && supportedTextureFormats.norm16Linear;
 }
 function isIOS() {
     if (/iPad|iPhone|iPod/.test(navigator.platform)) {
@@ -52,6 +48,7 @@ function init(configuration = config) {
     if (csRenderInitialized) {
         return csRenderInitialized;
     }
+    canUseNorm16Texture = _hasNorm16TextureSupport();
     config = deepMerge(defaultConfig, configuration);
     if (isIOS()) {
         if (configuration.rendering?.preferSizeOverAccuracy) {
@@ -75,6 +72,9 @@ function init(configuration = config) {
     }
     return csRenderInitialized;
 }
+function getCanUseNorm16Texture() {
+    return canUseNorm16Texture;
+}
 function setUseCPURendering(status, updateViewports = true) {
     config.rendering.useCPURendering = status;
     csRenderInitialized = true;
@@ -129,4 +129,4 @@ function getWebWorkerManager() {
 async function peerImport(moduleId) {
     return config.peerImport(moduleId);
 }
-export { init, getShouldUseCPURendering, isCornerstoneInitialized, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, peerImport, resetInitialization, };
+export { init, getShouldUseCPURendering, isCornerstoneInitialized, setUseCPURendering, setPreferSizeOverAccuracy, resetUseCPURendering, getConfiguration, setConfiguration, getWebWorkerManager, canRenderFloatTextures, peerImport, resetInitialization, getCanUseNorm16Texture, };

package/dist/esm/utilities/textureSupport.d.ts

@@ -0,0 +1,4 @@
+export declare function getSupportedTextureFormats(): {
+    norm16: boolean;
+    norm16Linear: boolean;
+};

package/dist/esm/utilities/textureSupport.js

@@ -0,0 +1,101 @@
+const canvasSize = 4;
+const texWidth = 5;
+const texHeight = 1;
+const pixelToCheck = [1, 1];
+function main({ ext, filterType, texData, internalFormat, glDataType }) {
+    try {
+        const canvas = document.createElement('canvas');
+        canvas.width = canvasSize;
+        canvas.height = canvasSize;
+        const gl = canvas.getContext('webgl2');
+        if (!gl) {
+            return false;
+        }
+        const vs = `#version 300 es
+    void main() {
+      gl_PointSize = ${canvasSize.toFixed(1)};
+      gl_Position = vec4(0, 0, 0, 1);
+    }
+  `;
+        const fs = `#version 300 es
+    precision highp float;
+    precision highp int;
+    precision highp sampler2D;
+
+    uniform sampler2D u_image;
+
+    out vec4 color;
+
+    void main() {
+        vec4 intColor = texture(u_image, gl_PointCoord.xy);
+        color = vec4(vec3(intColor.rrr), 1);
+    }
+    `;
+        let extToUse;
+        if (ext) {
+            extToUse = gl.getExtension(ext);
+            if (!extToUse) {
+                return false;
+            }
+        }
+        const vertexShader = gl.createShader(gl.VERTEX_SHADER);
+        gl.shaderSource(vertexShader, vs);
+        gl.compileShader(vertexShader);
+        if (!gl.getShaderParameter(vertexShader, gl.COMPILE_STATUS)) {
+            return false;
+        }
+        const fragmentShader = gl.createShader(gl.FRAGMENT_SHADER);
+        gl.shaderSource(fragmentShader, fs);
+        gl.compileShader(fragmentShader);
+        if (!gl.getShaderParameter(fragmentShader, gl.COMPILE_STATUS)) {
+            return false;
+        }
+        const program = gl.createProgram();
+        gl.attachShader(program, vertexShader);
+        gl.attachShader(program, fragmentShader);
+        gl.linkProgram(program);
+        if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
+            return false;
+        }
+        const tex = gl.createTexture();
+        gl.bindTexture(gl.TEXTURE_2D, tex);
+        gl.texImage2D(gl.TEXTURE_2D, 0, internalFormat(gl, extToUse), texWidth, texHeight, 0, gl.RED, glDataType(gl, extToUse), texData);
+        const filter = filterType === 'LINEAR' ? gl.LINEAR : gl.NEAREST;
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, filter);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, filter);
+        gl.useProgram(program);
+        gl.drawArrays(gl.POINTS, 0, 1);
+        const pixel = new Uint8Array(4);
+        gl.readPixels(pixelToCheck[0], pixelToCheck[1], 1, 1, gl.RGBA, gl.UNSIGNED_BYTE, pixel);
+        const [r, g, b] = pixel;
+        const webglLoseContext = gl.getExtension('WEBGL_lose_context');
+        if (webglLoseContext) {
+            webglLoseContext.loseContext();
+        }
+        return r === g && g === b && r !== 0;
+    }
+    catch (e) {
+        return false;
+    }
+}
+export function getSupportedTextureFormats() {
+    const norm16TexData = new Int16Array([
+        32767, 2000, 3000, 4000, 5000, 16784, 7000, 8000, 9000, 32767,
+    ]);
+    return {
+        norm16: main({
+            ext: 'EXT_texture_norm16',
+            filterType: 'NEAREST',
+            texData: norm16TexData,
+            internalFormat: (gl, ext) => ext.R16_SNORM_EXT,
+            glDataType: (gl) => gl.SHORT,
+        }),
+        norm16Linear: main({
+            ext: 'EXT_texture_norm16',
+            filterType: 'LINEAR',
+            texData: norm16TexData,
+            internalFormat: (gl, ext) => ext.R16_SNORM_EXT,
+            glDataType: (gl) => gl.SHORT,
+        }),
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/core",
-  "version": "2.18.7",
+  "version": "2.18.9",
   "description": "Cornerstone3D Core",
   "module": "./dist/esm/index.js",
   "types": "./dist/esm/index.d.ts",
@@ -82,5 +82,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "313a569eec20e132ea5f0929e10b34bd5ea63ba2"
+  "gitHead": "e3ff43396e9170f4350143ed1f48218c8afb90de"
 }