@cornerstonejs/core 0.36.3 → 0.36.5

package/src/RenderingEngine/vtkClasses/vtkSlabCamera.js

@@ -0,0 +1,155 @@
+import macro from '@kitware/vtk.js/macros';
+import vtkCamera from '@kitware/vtk.js/Rendering/Core/Camera';
+import { vec3, mat4 } from 'gl-matrix';
+import vtkMath from '@kitware/vtk.js/Common/Core/Math';
+
+/**
+ * vtkSlabCamera - A derived class of the core vtkCamera class
+ *
+ * This customization is necesssary because when we do coordinate transformations
+ * we need to set the cRange between [d, d + 0.1],
+ * where d is distance between the camera position and the focal point.
+ * While when we render we set to the clippingRange [0.01, d * 2],
+ * where d is the calculated from the bounds of all the actors.
+ *
+ * @param {*} publicAPI The public API to extend
+ * @param {*} model The private model to extend.
+ */
+function vtkSlabCamera(publicAPI, model) {
+  model.classHierarchy.push('vtkSlabCamera');
+
+  // Set up private variables and methods
+  const tmpMatrix = mat4.identity(new Float64Array(16));
+  const tmpvec1 = new Float64Array(3);
+
+  /**
+   * getProjectionMatrix - A fork of vtkCamera's getProjectionMatrix method.
+   * This fork performs most of the same actions, but define crange around
+   * model.distance when doing coordinate transformations.
+   */
+  publicAPI.getProjectionMatrix = (aspect, nearz, farz) => {
+    const result = mat4.create();
+
+    if (model.projectionMatrix) {
+      const scale = 1 / model.physicalScale;
+      vec3.set(tmpvec1, scale, scale, scale);
+
+      mat4.copy(result, model.projectionMatrix);
+      mat4.scale(result, result, tmpvec1);
+      mat4.transpose(result, result);
+      return result;
+    }
+
+    mat4.identity(tmpMatrix);
+
+    let cRange0 = model.clippingRange[0];
+    let cRange1 = model.clippingRange[1];
+    if (model.isPerformingCoordinateTransformation) {
+      /**
+       * NOTE: this is necessary because we want the coordinate transformation
+       * respect to the view plane (plane orthogonal to the camera and passing to
+       * the focal point).
+       *
+       * When vtk.js computes the coordinate transformations, it simply uses the
+       * camera matrix (no ray casting).
+       *
+       * However for the volume viewport the clipping range is set to be
+       * (-RENDERING_DEFAULTS.MAXIMUM_RAY_DISTANCE, RENDERING_DEFAULTS.MAXIMUM_RAY_DISTANCE).
+       * The clipping range is used in the camera method getProjectionMatrix().
+       * The projection matrix is used then for viewToWorld/worldToView methods of
+       * the renderer. This means that vkt.js will not return the coordinates of
+       * the point on the view plane (i.e. the depth coordinate will corresponded
+       * to the focal point).
+       *
+       * Therefore the clipping range has to be set to (distance, distance + 0.01),
+       * where now distance is the distance between the camera position and focal
+       * point. This is done internally, in our camera customization when the flag
+       * isPerformingCoordinateTransformation is set to true.
+       */
+      cRange0 = model.distance;
+      cRange1 = model.distance + 0.1;
+    }
+
+    const cWidth = cRange1 - cRange0;
+    const cRange = [
+      cRange0 + ((nearz + 1) * cWidth) / 2.0,
+      cRange0 + ((farz + 1) * cWidth) / 2.0,
+    ];
+
+    if (model.parallelProjection) {
+      // set up a rectangular parallelipiped
+      const width = model.parallelScale * aspect;
+      const height = model.parallelScale;
+
+      const xmin = (model.windowCenter[0] - 1.0) * width;
+      const xmax = (model.windowCenter[0] + 1.0) * width;
+      const ymin = (model.windowCenter[1] - 1.0) * height;
+      const ymax = (model.windowCenter[1] + 1.0) * height;
+
+      mat4.ortho(tmpMatrix, xmin, xmax, ymin, ymax, cRange[0], cRange[1]);
+      mat4.transpose(tmpMatrix, tmpMatrix);
+    } else if (model.useOffAxisProjection) {
+      throw new Error('Off-Axis projection is not supported at this time');
+    } else {
+      const tmp = Math.tan(vtkMath.radiansFromDegrees(model.viewAngle) / 2.0);
+      let width;
+      let height;
+      if (model.useHorizontalViewAngle === true) {
+        width = cRange0 * tmp;
+        height = (cRange0 * tmp) / aspect;
+      } else {
+        width = cRange0 * tmp * aspect;
+        height = cRange0 * tmp;
+      }
+
+      const xmin = (model.windowCenter[0] - 1.0) * width;
+      const xmax = (model.windowCenter[0] + 1.0) * width;
+      const ymin = (model.windowCenter[1] - 1.0) * height;
+      const ymax = (model.windowCenter[1] + 1.0) * height;
+      const znear = cRange[0];
+      const zfar = cRange[1];
+
+      tmpMatrix[0] = (2.0 * znear) / (xmax - xmin);
+      tmpMatrix[5] = (2.0 * znear) / (ymax - ymin);
+      tmpMatrix[2] = (xmin + xmax) / (xmax - xmin);
+      tmpMatrix[6] = (ymin + ymax) / (ymax - ymin);
+      tmpMatrix[10] = -(znear + zfar) / (zfar - znear);
+      tmpMatrix[14] = -1.0;
+      tmpMatrix[11] = (-2.0 * znear * zfar) / (zfar - znear);
+      tmpMatrix[15] = 0.0;
+    }
+
+    mat4.copy(result, tmpMatrix);
+
+    return result;
+  };
+}
+
+// ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+// ----------------------------------------------------------------------------
+
+const DEFAULT_VALUES = {
+  isPerformingCoordinateTransformation: false,
+};
+
+export function extend(publicAPI, model, initialValues = {}) {
+  Object.assign(model, DEFAULT_VALUES, initialValues);
+
+  vtkCamera.extend(publicAPI, model, initialValues);
+
+  macro.setGet(publicAPI, model, ['isPerformingCoordinateTransformation']);
+
+  // Object methods
+  vtkSlabCamera(publicAPI, model);
+}
+
+// ----------------------------------------------------------------------------
+
+export const newInstance = macro.newInstance(extend, 'vtkSlabCamera');
+
+// ----------------------------------------------------------------------------
+
+export default { newInstance, extend };

package/src/RenderingEngine/vtkClasses/vtkStreamingOpenGLRenderWindow.js

@@ -0,0 +1,47 @@
+import macro from '@kitware/vtk.js/macros';
+import vtkOpenGLRenderWindow from '@kitware/vtk.js/Rendering/OpenGL/RenderWindow';
+import vtkStreamingOpenGLViewNodeFactory from './vtkStreamingOpenGLViewNodeFactory';
+
+/**
+ * vtkStreamingOpenGLRenderWindow - A dervied class of the core vtkOpenGLRenderWindow class.
+ * The main purpose for this class extension is to add in our own node factory, so we can use
+ * our extended "streaming" classes for progressive texture loading.
+ *
+ *
+ * @param {*} publicAPI The public API to extend
+ * @param {*} model The private model to extend.
+ */
+function vtkStreamingOpenGLRenderWindow(publicAPI, model) {
+  model.classHierarchy.push('vtkStreamingOpenGLRenderWindow');
+}
+
+// ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+// ----------------------------------------------------------------------------
+
+export function extend(publicAPI, model, initialValues = {}) {
+  Object.assign(model, initialValues);
+
+  vtkOpenGLRenderWindow.extend(publicAPI, model, initialValues);
+
+  model.myFactory = vtkStreamingOpenGLViewNodeFactory.newInstance();
+  /* eslint-disable no-use-before-define */
+  model.myFactory.registerOverride('vtkRenderWindow', newInstance);
+  /* eslint-enable no-use-before-define */
+
+  // Object methods
+  vtkStreamingOpenGLRenderWindow(publicAPI, model);
+}
+
+// ----------------------------------------------------------------------------
+
+export const newInstance = macro.newInstance(
+  extend,
+  'vtkStreamingOpenGLRenderWindow'
+);
+
+// ----------------------------------------------------------------------------
+
+export default { newInstance, extend };

package/src/RenderingEngine/vtkClasses/vtkStreamingOpenGLTexture.js

@@ -0,0 +1,272 @@
+import macro from '@kitware/vtk.js/macros';
+import vtkOpenGLTexture from '@kitware/vtk.js/Rendering/OpenGL/Texture';
+import HalfFloat from '@kitware/vtk.js/Common/Core/HalfFloat';
+import { getConfiguration } from '../../init';
+
+/**
+ * vtkStreamingOpenGLTexture - A dervied class of the core vtkOpenGLTexture.
+ * This class has methods to update the texture memory on the GPU slice by slice
+ * in an efficient yet GPU-architecture friendly manner.
+ *
+ *
+ * @param {*} publicAPI The public API to extend
+ * @param {*} model The private model to extend.
+ */
+function vtkStreamingOpenGLTexture(publicAPI, model) {
+  model.classHierarchy.push('vtkStreamingOpenGLTexture');
+
+  const superCreate3DFilterableFromRaw = publicAPI.create3DFilterableFromRaw;
+
+  publicAPI.create3DFilterableFromRaw = (
+    width,
+    height,
+    depth,
+    numComps,
+    dataType,
+    data,
+    preferSizeOverAccuracy
+  ) => {
+    model.inputDataType = dataType;
+    model.inputNumComps = numComps;
+
+    superCreate3DFilterableFromRaw(
+      width,
+      height,
+      depth,
+      numComps,
+      dataType,
+      data,
+      preferSizeOverAccuracy
+    );
+  };
+
+  /**
+   * This function updates the GPU texture memory to match the current
+   * representation of data held in RAM.
+   *
+   * @param {Float32Array|Uint8Array|Int16Array|Uint16Array} data The data array which has been updated.
+   */
+  publicAPI.update3DFromRaw = (data) => {
+    const { updatedFrames } = model;
+
+    if (!updatedFrames.length) {
+      return;
+    }
+    model._openGLRenderWindow.activateTexture(publicAPI);
+    publicAPI.createTexture();
+    publicAPI.bind();
+
+    let bytesPerVoxel;
+    let TypedArrayConstructor;
+
+    if (data instanceof Uint8Array) {
+      bytesPerVoxel = 1;
+      TypedArrayConstructor = Uint8Array;
+    } else if (data instanceof Int16Array) {
+      bytesPerVoxel = 2;
+      TypedArrayConstructor = Int16Array;
+    } else if (data instanceof Uint16Array) {
+      bytesPerVoxel = 2;
+      TypedArrayConstructor = Uint16Array;
+    } else if (data instanceof Float32Array) {
+      bytesPerVoxel = 4;
+      TypedArrayConstructor = Float32Array;
+    } else {
+      throw new Error(`No support for given TypedArray.`);
+    }
+
+    for (let i = 0; i < updatedFrames.length; i++) {
+      if (updatedFrames[i]) {
+        model.fillSubImage3D(data, i, bytesPerVoxel, TypedArrayConstructor);
+      }
+    }
+
+    // Reset updatedFrames
+    model.updatedFrames = [];
+
+    if (model.generateMipmap) {
+      model.context.generateMipmap(model.target);
+    }
+
+    publicAPI.deactivate();
+    return true;
+  };
+
+  /**
+   * This function updates the GPU texture memory to match the current
+   * representation of data held in RAM.
+   *
+   * @param {Float32Array|Uint8Array} data The data array which has been updated.
+   * @param {number} frameIndex The frame to load in.
+   * @param {number} BytesPerVoxel The number of bytes per voxel in the data, so we don't have to constantly
+   * check the array type.
+   * @param {object} TypedArrayConstructor The constructor for the array type. Again so we don't have to constantly check.
+   */
+  model.fillSubImage3D = (
+    data,
+    frameIndex,
+    bytesPerVoxel,
+    TypedArrayConstructor
+  ) => {
+    const buffer = data.buffer;
+
+    const frameLength = model.width * model.height;
+    const frameLengthInBytes = frameLength * model.components * bytesPerVoxel;
+
+    const zOffset = frameIndex * frameLengthInBytes;
+    const rowLength = model.width * model.components;
+
+    const gl = model.context;
+
+    /**
+     * It appears that the implementation of texSubImage3D uses 2D textures to do the texture copy if
+     * MAX_TEXTURE_SIZE is greater than MAX_TEXTURE_SIZE_3D. As such if you make a single block too big
+     * the transfer messes up cleanly and you render a black box or some data if you are lucky.
+     *
+     * This block-size based on 2D texture size seems like the safest approach that should work on most systems.
+     *
+     * There are certainly further optimizations that could be done here, we can do bigger chunks with other systems
+     * But we need to find the _exact_ criteria. And then its not even guaranteed it'll be much faster.
+     */
+    const MAX_TEXTURE_SIZE = gl.getParameter(gl.MAX_TEXTURE_SIZE);
+    let blockHeight = Math.floor(
+      (bytesPerVoxel * MAX_TEXTURE_SIZE) / model.width
+    );
+
+    // Cap to actual frame height:
+    blockHeight = Math.min(blockHeight, model.height);
+    const { useNorm16Texture, preferSizeOverAccuracy } =
+      getConfiguration().rendering;
+    // TODO: there is currently a bug in chrome and safari which requires
+    // blockheight = 1 for norm16 textures:
+    // https://bugs.chromium.org/p/chromium/issues/detail?id=1408247
+    // https://bugs.webkit.org/show_bug.cgi?id=252039
+    if (useNorm16Texture && !preferSizeOverAccuracy) {
+      blockHeight = 1;
+    }
+
+    const multiRowBlockLength = rowLength * blockHeight;
+    const multiRowBlockLengthInBytes = multiRowBlockLength * bytesPerVoxel;
+
+    const normalBlocks = Math.floor(model.height / blockHeight);
+
+    const lastBlockHeight = model.height % blockHeight;
+    const multiRowLastBlockLength = rowLength * lastBlockHeight;
+
+    // Perform most blocks.
+    for (let block = 0; block < normalBlocks; block++) {
+      const yOffset = block * blockHeight;
+
+      let dataView = new TypedArrayConstructor(
+        buffer,
+        zOffset + block * multiRowBlockLengthInBytes,
+        multiRowBlockLength
+      );
+
+      if (
+        model.useHalfFloat &&
+        (TypedArrayConstructor === Uint16Array ||
+          TypedArrayConstructor === Int16Array)
+      ) {
+        // in the case we want to use halfFloat rendering (preferSizeOverAccuracy = true),
+        // we need to convert uint16 and int16 into fp16 format.
+        // This is the step where precision is lost for streaming volume viewport.
+        for (let idx = 0; idx < dataView.length; idx++) {
+          dataView[idx] = HalfFloat.toHalf(dataView[idx]);
+        }
+        if (TypedArrayConstructor === Int16Array) {
+          dataView = new Uint16Array(dataView);
+        }
+      }
+
+      gl.texSubImage3D(
+        model.target, // target
+        0, // mipMap level (always zero)
+        0, // xOffset
+        yOffset, // yOffset
+        frameIndex,
+        model.width,
+        blockHeight, //model.height,
+        1, // numFramesInBlock,
+        model.format,
+        model.openGLDataType,
+        dataView
+      );
+    }
+
+    // perform last block if present
+
+    if (lastBlockHeight !== 0) {
+      const yOffset = normalBlocks * blockHeight;
+
+      // Dataview of last block
+      const dataView = new TypedArrayConstructor(
+        buffer,
+        zOffset + normalBlocks * multiRowBlockLengthInBytes,
+        multiRowLastBlockLength
+      );
+
+      gl.texSubImage3D(
+        model.target, // target
+        0, // mipMap level (always zero)
+        0, // xOffset
+        yOffset, // yOffset
+        frameIndex,
+        model.width,
+        lastBlockHeight, //model.height,
+        1, // numFramesInBlock,
+        model.format,
+        model.openGLDataType,
+        dataView
+      );
+    }
+  };
+
+  publicAPI.getTextureParameters = () => {
+    return {
+      width: model.width,
+      height: model.height,
+      depth: model.depth,
+      numComps: model.inputNumComps,
+      dataType: model.inputDataType,
+    };
+  };
+
+  /**
+   * Called when a frame is loaded so that on next render we know which data to load in.
+   * @param {number} frameIndex The frame to load in.
+   */
+  publicAPI.setUpdatedFrame = (frameIndex) => {
+    model.updatedFrames[frameIndex] = true;
+  };
+}
+
+// ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+// ----------------------------------------------------------------------------
+
+const DEFAULT_VALUES = {
+  updatedFrames: [],
+};
+
+export function extend(publicAPI, model, initialValues = {}) {
+  Object.assign(model, DEFAULT_VALUES, initialValues);
+
+  vtkOpenGLTexture.extend(publicAPI, model, initialValues);
+
+  // Object methods
+  vtkStreamingOpenGLTexture(publicAPI, model);
+}
+
+// ----------------------------------------------------------------------------
+
+export const newInstance = macro.newInstance(
+  extend,
+  'vtkStreamingOpenGLTexture'
+);
+
+// ----------------------------------------------------------------------------
+
+export default { newInstance, extend };

package/src/RenderingEngine/vtkClasses/vtkStreamingOpenGLViewNodeFactory.js

@@ -0,0 +1,159 @@
+import macro from '@kitware/vtk.js/macros';
+// import vtkGenericWidgetRepresentation from '@kitware/vtk.js/Rendering/SceneGraph/GenericWidgetRepresentation'
+import vtkOpenGLActor from '@kitware/vtk.js/Rendering/OpenGL/Actor';
+import vtkOpenGLActor2D from '@kitware/vtk.js/Rendering/OpenGL/Actor2D';
+import vtkOpenGLCamera from '@kitware/vtk.js/Rendering/OpenGL/Camera';
+import vtkOpenGLGlyph3DMapper from '@kitware/vtk.js/Rendering/OpenGL/Glyph3DMapper';
+import vtkOpenGLImageMapper from '@kitware/vtk.js/Rendering/OpenGL/ImageMapper';
+import vtkOpenGLImageSlice from '@kitware/vtk.js/Rendering/OpenGL/ImageSlice';
+import vtkOpenGLPixelSpaceCallbackMapper from '@kitware/vtk.js/Rendering/OpenGL/PixelSpaceCallbackMapper';
+import vtkOpenGLPolyDataMapper from '@kitware/vtk.js/Rendering/OpenGL/PolyDataMapper';
+import vtkOpenGLRenderer from '@kitware/vtk.js/Rendering/OpenGL/Renderer';
+import vtkOpenGLSkybox from '@kitware/vtk.js/Rendering/OpenGL/Skybox';
+import vtkOpenGLSphereMapper from '@kitware/vtk.js/Rendering/OpenGL/SphereMapper';
+import vtkOpenGLStickMapper from '@kitware/vtk.js/Rendering/OpenGL/StickMapper';
+import vtkOpenGLTexture from '@kitware/vtk.js/Rendering/OpenGL/Texture';
+import vtkOpenGLVolume from '@kitware/vtk.js/Rendering/OpenGL/Volume';
+import vtkOpenGLVolumeMapper from '@kitware/vtk.js/Rendering/OpenGL/VolumeMapper';
+import vtkViewNodeFactory from '@kitware/vtk.js/Rendering/SceneGraph/ViewNodeFactory';
+import vtkStreamingOpenGLVolumeMapper from './vtkStreamingOpenGLVolumeMapper';
+
+/**
+ * vtkStreamingOpenGLViewNodeFactory - A fork of the vtkOpenGLViewNodeFactory,
+ * so that we can inject our custom derived "Streaming" classes.
+ *
+ * @param {*} publicAPI The public API to extend
+ * @param {*} model The private model to extend.
+ */
+function vtkStreamingOpenGLViewNodeFactory(publicAPI, model) {
+  // Set our className
+  model.classHierarchy.push('vtkStreamingOpenGLViewNodeFactory');
+
+  /**
+   * createNode - fork of createNode from vtkOpenGLViewNodeFactory.
+   * This fork is required to inject the properties from model.getModelInitialValues.
+   *
+   * @param {object} dataObject An instance of a vtk.js class.
+   */
+  publicAPI.createNode = (dataObject) => {
+    if (dataObject.isDeleted()) {
+      return null;
+    }
+
+    let cpt = 0;
+    let className = dataObject.getClassName(cpt++);
+    let isObject = false;
+    const keys = Object.keys(model.overrides);
+    while (className && !isObject) {
+      if (keys.indexOf(className) !== -1) {
+        isObject = true;
+      } else {
+        className = dataObject.getClassName(cpt++);
+      }
+    }
+
+    if (!isObject) {
+      return null;
+    }
+
+    const initialValues = model.getModelInitialValues(dataObject);
+
+    const vn = model.overrides[className](initialValues);
+    vn.setMyFactory(publicAPI);
+    return vn;
+  };
+
+  /**
+   * getModelInitialValues - This function allows us to pass textures down from our
+   * vtkSharedVolumeMapper to new instances of vtkStreamingOpenGLVolumeMapper.
+   * The prevents us from sharing memory.
+   *
+   * TODO: It would be beneficial to push similar, but generalized, functionality
+   * back to vtk.js in the future.
+   *
+   * @param {object} dataObject An instance of a vtk.js class.
+   */
+  model.getModelInitialValues = (dataObject) => {
+    const initialValues = {};
+
+    const className = dataObject.getClassName();
+
+    if (className === 'vtkSharedVolumeMapper') {
+      initialValues.scalarTexture = dataObject.getScalarTexture();
+    }
+
+    return initialValues;
+  };
+}
+
+// ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+const DEFAULT_VALUES = {};
+
+// ----------------------------------------------------------------------------
+
+export function extend(publicAPI, model, initialValues = {}) {
+  Object.assign(model, DEFAULT_VALUES, initialValues);
+
+  // Inheritance
+  vtkViewNodeFactory.extend(publicAPI, model, initialValues);
+
+  // Object methods
+  vtkStreamingOpenGLViewNodeFactory(publicAPI, model);
+
+  // Initialization
+  publicAPI.registerOverride('vtkActor', vtkOpenGLActor.newInstance);
+  publicAPI.registerOverride('vtkActor2D', vtkOpenGLActor2D.newInstance);
+  publicAPI.registerOverride('vtkCamera', vtkOpenGLCamera.newInstance);
+  publicAPI.registerOverride(
+    'vtkGlyph3DMapper',
+    vtkOpenGLGlyph3DMapper.newInstance
+  );
+  publicAPI.registerOverride(
+    'vtkImageMapper',
+    vtkOpenGLImageMapper.newInstance
+  );
+  publicAPI.registerOverride('vtkImageSlice', vtkOpenGLImageSlice.newInstance);
+  publicAPI.registerOverride('vtkMapper', vtkOpenGLPolyDataMapper.newInstance);
+  publicAPI.registerOverride(
+    'vtkPixelSpaceCallbackMapper',
+    vtkOpenGLPixelSpaceCallbackMapper.newInstance
+  );
+  publicAPI.registerOverride('vtkRenderer', vtkOpenGLRenderer.newInstance);
+  publicAPI.registerOverride('vtkSkybox', vtkOpenGLSkybox.newInstance);
+  publicAPI.registerOverride(
+    'vtkSphereMapper',
+    vtkOpenGLSphereMapper.newInstance
+  );
+  publicAPI.registerOverride(
+    'vtkStickMapper',
+    vtkOpenGLStickMapper.newInstance
+  );
+  publicAPI.registerOverride('vtkTexture', vtkOpenGLTexture.newInstance);
+  publicAPI.registerOverride('vtkVolume', vtkOpenGLVolume.newInstance);
+  publicAPI.registerOverride(
+    'vtkVolumeMapper',
+    vtkOpenGLVolumeMapper.newInstance
+  );
+  publicAPI.registerOverride(
+    'vtkSharedVolumeMapper',
+    vtkStreamingOpenGLVolumeMapper.newInstance
+  );
+  // publicAPI.registerOverride(
+  //   'vtkWidgetRepresentation',
+  //   vtkGenericWidgetRepresentation.newInstance
+  // )
+}
+
+// ----------------------------------------------------------------------------
+
+export const newInstance = macro.newInstance(
+  extend,
+  'vtkStreamingOpenGLViewNodeFactory'
+);
+
+// ----------------------------------------------------------------------------
+
+export default { newInstance, extend };