@cornerstonejs/core 2.0.0-beta.2 → 2.0.0-beta.21

package/src/RenderingEngine/vtkClasses/vtkSlabCamera.js

@@ -1,155 +0,0 @@
-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

@@ -1,47 +0,0 @@
-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

@@ -1,272 +0,0 @@
-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

@@ -1,159 +0,0 @@
-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 };