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

package/src/RenderingEngine/vtkClasses/vtkStreamingOpenGLVolumeMapper.js

@@ -1,331 +0,0 @@
-import { mat3, mat4, vec3 } from 'gl-matrix';
-import macro from '@kitware/vtk.js/macros';
-import vtkOpenGLVolumeMapper from '@kitware/vtk.js/Rendering/OpenGL/VolumeMapper';
-import { Filter } from '@kitware/vtk.js/Rendering/OpenGL/Texture/Constants';
-import { VtkDataTypes } from '@kitware/vtk.js/Common/Core/DataArray/Constants';
-import vtkDataArray from '@kitware/vtk.js/Common/Core/DataArray';
-import { Representation } from '@kitware/vtk.js/Rendering/Core/Property/Constants';
-
-const { vtkWarningMacro } = macro;
-/**
- * vtkStreamingOpenGLVolumeMapper - A dervied class of the core vtkOpenGLVolumeMapper class.
- * This class  replaces the buildBufferObjects function so that we progressively upload our textures
- * into GPU memory using the new methods on vtkStreamingOpenGLTexture.
- *
- *
- * @param {*} publicAPI The public API to extend
- * @param {*} model The private model to extend.
- */
-function vtkStreamingOpenGLVolumeMapper(publicAPI, model) {
-  model.classHierarchy.push('vtkStreamingOpenGLVolumeMapper');
-
-  /**
-   * buildBufferObjects - A fork of vtkOpenGLVolumeMapper's buildBufferObjects method.
-   * This fork performs most of the same actions, but builds the textures progressively using
-   * vtkStreamingOpenGLTexture's methods, and also prevents recomputation of the texture for each
-   * vtkStreamingOpenGLVolumeMapper using the texture.
-   *
-   *
-   * @param {*} ren The renderer.
-   * @param {*} actor The actor to build the buffer objects for.
-   */
-  publicAPI.buildBufferObjects = (ren, actor) => {
-    const image = model.currentInput;
-    if (!image) {
-      return;
-    }
-
-    const scalars = image.getPointData() && image.getPointData().getScalars();
-    if (!scalars) {
-      return;
-    }
-
-    const vprop = actor.getProperty();
-
-    if (!model.jitterTexture.getHandle()) {
-      const oTable = new Uint8Array(32 * 32);
-      for (let i = 0; i < 32 * 32; ++i) {
-        oTable[i] = 255.0 * Math.random();
-      }
-      model.jitterTexture.setMinificationFilter(Filter.LINEAR);
-      model.jitterTexture.setMagnificationFilter(Filter.LINEAR);
-      model.jitterTexture.create2DFromRaw(
-        32,
-        32,
-        1,
-        VtkDataTypes.UNSIGNED_CHAR,
-        oTable
-      );
-    }
-
-    const numComp = scalars.getNumberOfComponents();
-    const iComps = vprop.getIndependentComponents();
-    const numIComps = iComps ? numComp : 1;
-
-    // rebuild opacity tfun?
-    let toString = `${vprop.getMTime()}`;
-    if (model.opacityTextureString !== toString) {
-      const oWidth = 1024;
-      const oSize = oWidth * 2 * numIComps;
-      const ofTable = new Float32Array(oSize);
-      const tmpTable = new Float32Array(oWidth);
-
-      for (let c = 0; c < numIComps; ++c) {
-        const ofun = vprop.getScalarOpacity(c);
-        const opacityFactor =
-          model.renderable.getSampleDistance() /
-          vprop.getScalarOpacityUnitDistance(c);
-
-        const oRange = ofun.getRange();
-        ofun.getTable(oRange[0], oRange[1], oWidth, tmpTable, 1);
-        // adjust for sample distance etc
-        for (let i = 0; i < oWidth; ++i) {
-          ofTable[c * oWidth * 2 + i] =
-            1.0 - (1.0 - tmpTable[i]) ** opacityFactor;
-          ofTable[c * oWidth * 2 + i + oWidth] = ofTable[c * oWidth * 2 + i];
-        }
-      }
-
-      model.opacityTexture.releaseGraphicsResources(model._openGLRenderWindow);
-      model.opacityTexture.setMinificationFilter(Filter.LINEAR);
-      model.opacityTexture.setMagnificationFilter(Filter.LINEAR);
-
-      // use float texture where possible because we really need the resolution
-      // for this table. Errors in low values of opacity accumulate to
-      // visible artifacts. High values of opacity quickly terminate without
-      // artifacts.
-      if (
-        model._openGLRenderWindow.getWebgl2() ||
-        (model.context.getExtension('OES_texture_float') &&
-          model.context.getExtension('OES_texture_float_linear'))
-      ) {
-        model.opacityTexture.create2DFromRaw(
-          oWidth,
-          2 * numIComps,
-          1,
-          VtkDataTypes.FLOAT,
-          ofTable
-        );
-      } else {
-        const oTable = new Uint8Array(oSize);
-        for (let i = 0; i < oSize; ++i) {
-          oTable[i] = 255.0 * ofTable[i];
-        }
-        model.opacityTexture.create2DFromRaw(
-          oWidth,
-          2 * numIComps,
-          1,
-          VtkDataTypes.UNSIGNED_CHAR,
-          oTable
-        );
-      }
-      model.opacityTextureString = toString;
-    }
-
-    // rebuild color tfun?
-    toString = `${vprop.getMTime()}`;
-
-    if (model.colorTextureString !== toString) {
-      const cWidth = 1024;
-      const cSize = cWidth * 2 * numIComps * 3;
-      const cTable = new Uint8Array(cSize);
-      const tmpTable = new Float32Array(cWidth * 3);
-
-      for (let c = 0; c < numIComps; ++c) {
-        const cfun = vprop.getRGBTransferFunction(c);
-        const cRange = cfun.getRange();
-        cfun.getTable(cRange[0], cRange[1], cWidth, tmpTable, 1);
-        for (let i = 0; i < cWidth * 3; ++i) {
-          cTable[c * cWidth * 6 + i] = 255.0 * tmpTable[i];
-          cTable[c * cWidth * 6 + i + cWidth * 3] = 255.0 * tmpTable[i];
-        }
-      }
-
-      model.colorTexture.releaseGraphicsResources(model._openGLRenderWindow);
-      model.colorTexture.setMinificationFilter(Filter.LINEAR);
-      model.colorTexture.setMagnificationFilter(Filter.LINEAR);
-
-      model.colorTexture.create2DFromRaw(
-        cWidth,
-        2 * numIComps,
-        3,
-        VtkDataTypes.UNSIGNED_CHAR,
-        cTable
-      );
-      model.colorTextureString = toString;
-    }
-
-    // rebuild the scalarTexture if the data has changed
-    toString = `${image.getMTime()}`;
-
-    if (model.scalarTextureString !== toString) {
-      // Build the textures
-      const dims = image.getDimensions();
-
-      const previousTextureParameters =
-        model.scalarTexture.getTextureParameters();
-
-      const dataType = image.getPointData().getScalars().getDataType();
-      const data = image.getPointData().getScalars().getData();
-
-      let shouldReset = true;
-
-      if (
-        previousTextureParameters.dataType &&
-        previousTextureParameters.dataType === dataType
-      ) {
-        const previousTextureSize =
-          previousTextureParameters.width *
-          previousTextureParameters.height *
-          previousTextureParameters.depth *
-          previousTextureParameters.numComps;
-        if (data.length === previousTextureSize) {
-          shouldReset = false;
-        }
-      }
-
-      if (shouldReset) {
-        model.scalarTexture.setOglNorm16Ext(
-          model.context.getExtension('EXT_texture_norm16')
-        );
-
-        model.scalarTexture.releaseGraphicsResources(model._openGLRenderWindow);
-        model.scalarTexture.resetFormatAndType();
-
-        model.scalarTexture.create3DFilterableFromRaw(
-          dims[0],
-          dims[1],
-          dims[2],
-          numComp,
-          scalars.getDataType(),
-          scalars.getData(),
-          model.renderable.getPreferSizeOverAccuracy()
-        );
-      } else {
-        model.scalarTexture.deactivate();
-        model.scalarTexture.update3DFromRaw(data);
-      }
-
-      model.scalarTextureString = toString;
-    }
-
-    if (!model.tris.getCABO().getElementCount()) {
-      // build the CABO
-      const ptsArray = new Float32Array(12);
-      for (let i = 0; i < 4; i++) {
-        ptsArray[i * 3] = (i % 2) * 2 - 1.0;
-        ptsArray[i * 3 + 1] = i > 1 ? 1.0 : -1.0;
-        ptsArray[i * 3 + 2] = -1.0;
-      }
-
-      const cellArray = new Uint16Array(8);
-      cellArray[0] = 3;
-      cellArray[1] = 0;
-      cellArray[2] = 1;
-      cellArray[3] = 3;
-      cellArray[4] = 3;
-      cellArray[5] = 0;
-      cellArray[6] = 3;
-      cellArray[7] = 2;
-
-      const points = vtkDataArray.newInstance({
-        numberOfComponents: 3,
-        values: ptsArray,
-      });
-      points.setName('points');
-      const cells = vtkDataArray.newInstance({
-        numberOfComponents: 1,
-        values: cellArray,
-      });
-      model.tris.getCABO().createVBO(cells, 'polys', Representation.SURFACE, {
-        points,
-        cellOffset: 0,
-      });
-    }
-
-    model.VBOBuildTime.modified();
-  };
-
-  // publicAPI.getRenderTargetSize = () => {
-  //   // https://github.com/Kitware/vtk-js/blob/master/Sources/Rendering/OpenGL/VolumeMapper/index.js#L952
-  //   if (model.lastXYF > 1.43) {
-  //     const sz = model.framebuffer.getSize()
-  //     return [model.fvp[0] * sz[0], model.fvp[1] * sz[1]]
-  //   }
-
-  //   // This seems wrong, it assumes the renderWindow only has one renderer
-  //   // but I don't know if this stuff is correct...
-
-  //   const { usize, vsize } = model.openGLRenderer.getTiledSizeAndOrigin()
-
-  //   return [usize, vsize]
-  // }
-
-  // publicAPI.getRenderTargetSize = () => {
-  //   if (model._useSmallViewport) {
-  //     return [model._smallViewportWidth, model._smallViewportHeight]
-  //   }
-
-  //   return model._openGLRenderWindow.getFramebufferSize()
-  // }
-
-  publicAPI.getRenderTargetSize = () => {
-    if (model._useSmallViewport) {
-      return [model._smallViewportWidth, model._smallViewportHeight];
-    }
-
-    const { usize, vsize } = model._openGLRenderer.getTiledSizeAndOrigin();
-
-    return [usize, vsize];
-  };
-
-  publicAPI.getRenderTargetOffset = () => {
-    const { lowerLeftU, lowerLeftV } =
-      model._openGLRenderer.getTiledSizeAndOrigin();
-
-    return [lowerLeftU, lowerLeftV];
-  };
-
-  // TODO: it seems like this may be needed to reset the GPU memory associated
-  // with a volume
-  // publicAPI.hardReset = () => {
-  //   model.opacityTexture.releaseGraphicsResources(model._openGLRenderWindow);
-  //   model.colorTexture.releaseGraphicsResources(model._openGLRenderWindow);
-  //   model.scalarTexture.setOglNorm16Ext(
-  //     model.context.getExtension('EXT_texture_norm16')
-  //   );
-  //   model.scalarTexture.releaseGraphicsResources(model._openGLRenderWindow);
-  //   model.scalarTexture.resetFormatAndType();
-  // };
-}
-
-// ----------------------------------------------------------------------------
-// Object factory
-// ----------------------------------------------------------------------------
-
-// ----------------------------------------------------------------------------
-
-const DEFAULT_VALUES = {};
-
-export function extend(publicAPI, model, initialValues = {}) {
-  Object.assign(model, DEFAULT_VALUES, initialValues);
-
-  vtkOpenGLVolumeMapper.extend(publicAPI, model, initialValues);
-
-  model.scalarTexture = initialValues.scalarTexture;
-  model.previousState = {};
-
-  // Object methods
-  vtkStreamingOpenGLVolumeMapper(publicAPI, model);
-}
-
-// ----------------------------------------------------------------------------
-
-export const newInstance = macro.newInstance(
-  extend,
-  'vtkStreamingOpenGLVolumeMapper'
-);
-
-// ----------------------------------------------------------------------------
-
-export default { newInstance, extend };

package/src/Settings.ts

@@ -1,298 +0,0 @@
-/*
- * Constants
- */
-
-const DEFAULT_SETTINGS = Symbol('DefaultSettings');
-const RUNTIME_SETTINGS = Symbol('RuntimeSettings');
-const OBJECT_SETTINGS_MAP = Symbol('ObjectSettingsMap');
-const DICTIONARY = Symbol('Dictionary');
-
-/**
- * Settings
- */
-export default class Settings {
-  constructor(base?: Settings) {
-    const dictionary = Object.create(
-      base instanceof Settings && DICTIONARY in base ? base[DICTIONARY] : null
-    );
-    Object.seal(
-      Object.defineProperty(this, DICTIONARY, {
-        value: dictionary,
-      })
-    );
-  }
-
-  set(key: string, value: unknown): boolean {
-    return set(this[DICTIONARY], key, value, null);
-  }
-
-  get(key: string): unknown {
-    return get(this[DICTIONARY], key);
-  }
-
-  /**
-   * Unset a specific key or a set of keys within a namespace when the key ends with a dot (ASCII #46).
-   * If the key is ".", all keys will be removed and this command works as a reset.
-   * @param key - name The key to be unset or a namespace.
-   * @returns boolean
-   */
-  unset(key: string): boolean {
-    return unset(this[DICTIONARY], key + '');
-  }
-
-  forEach(callback: (key: string, value: unknown) => void): void {
-    iterate(this[DICTIONARY], callback);
-  }
-
-  extend(): Settings {
-    return new Settings(this);
-  }
-
-  /**
-   * Recursively import all properties from the given plain JavaScript object.
-   * This method has the opposite effect of the `dump` method.
-   * @param root - The root object whose properties will
-   * be imported.
-   */
-  import(root: Record<string, unknown>): void {
-    if (isPlainObject(root)) {
-      Object.keys(root).forEach((key) => {
-        set(this[DICTIONARY], key, root[key], null);
-      });
-    }
-  }
-
-  /**
-   * Build a JSON representation of the current internal state of this settings
-   * object. The returned object can be safely passed to `JSON.stringify`
-   * function.
-   * @returns The JSON representation of the current
-   * state of this settings instance
-   */
-  dump(): Record<string, unknown> {
-    const context = {};
-    iterate(this[DICTIONARY], (key, value) => {
-      if (typeof value !== 'undefined') {
-        deepSet(context, key, value);
-      }
-    });
-    return context;
-  }
-
-  static assert(subject: Settings): Settings {
-    return subject instanceof Settings
-      ? subject
-      : Settings.getRuntimeSettings();
-  }
-
-  static getDefaultSettings(subfield = null): Settings | any {
-    let defaultSettings = Settings[DEFAULT_SETTINGS];
-    if (!(defaultSettings instanceof Settings)) {
-      defaultSettings = new Settings();
-      Settings[DEFAULT_SETTINGS] = defaultSettings;
-    }
-
-    // Given subfield of 'segmentation' it will return all settings
-    // that starts with segmentation.*
-    if (subfield) {
-      const settingObj = {};
-      defaultSettings.forEach((name: string) => {
-        if (name.startsWith(subfield)) {
-          const setting = name.split(`${subfield}.`)[1];
-          settingObj[setting] = defaultSettings.get(name);
-        }
-      });
-      return settingObj;
-    }
-
-    return defaultSettings;
-  }
-
-  static getRuntimeSettings(): Settings {
-    let runtimeSettings = Settings[RUNTIME_SETTINGS];
-    if (!(runtimeSettings instanceof Settings)) {
-      runtimeSettings = new Settings(Settings.getDefaultSettings());
-      Settings[RUNTIME_SETTINGS] = runtimeSettings;
-    }
-    return runtimeSettings;
-  }
-
-  static getObjectSettings(subject: unknown, from?: unknown): Settings {
-    let settings = null;
-    if (subject instanceof Settings) {
-      settings = subject;
-    } else if (typeof subject === 'object' && subject !== null) {
-      let objectSettingsMap = Settings[OBJECT_SETTINGS_MAP];
-      if (!(objectSettingsMap instanceof WeakMap)) {
-        objectSettingsMap = new WeakMap();
-        Settings[OBJECT_SETTINGS_MAP] = objectSettingsMap;
-      }
-      settings = objectSettingsMap.get(subject);
-      if (!(settings instanceof Settings)) {
-        settings = new Settings(
-          Settings.assert(Settings.getObjectSettings(from))
-        );
-        objectSettingsMap.set(subject, settings);
-      }
-    }
-    return settings;
-  }
-
-  static extendRuntimeSettings(): Settings {
-    return Settings.getRuntimeSettings().extend();
-  }
-}
-
-/*
- * Local Helpers
- */
-
-function unset(dictionary: Record<string, unknown>, name: string): boolean {
-  if (name.endsWith('.')) {
-    let deleteCount = 0;
-    const namespace = name;
-    const base = namespace.slice(0, -1);
-    const deleteAll = base.length === 0;
-    for (const key in dictionary) {
-      if (
-        Object.prototype.hasOwnProperty.call(dictionary, key) &&
-        (deleteAll || key.startsWith(namespace) || key === base)
-      ) {
-        delete dictionary[key];
-        ++deleteCount;
-      }
-    }
-    return deleteCount > 0;
-  }
-  return delete dictionary[name];
-}
-
-function iterate(
-  dictionary: Record<string, unknown>,
-  callback: (key: string, value: unknown) => void
-): void {
-  for (const key in dictionary) {
-    callback(key, dictionary[key]);
-  }
-}
-
-function setAll(
-  dictionary: Record<string, unknown>,
-  prefix: string,
-  record: Record<string, unknown>,
-  references: WeakSet<Record<string, unknown>>
-): boolean {
-  let failCount: number;
-  if (references.has(record)) {
-    return set(dictionary, prefix, null, references);
-  }
-  references.add(record);
-  failCount = 0;
-  for (const field in record) {
-    if (Object.prototype.hasOwnProperty.call(record, field)) {
-      const key = field.length === 0 ? prefix : `${prefix}.${field}`;
-      if (!set(dictionary, key, record[field], references)) {
-        ++failCount;
-      }
-    }
-  }
-  references.delete(record);
-  return failCount === 0;
-}
-
-/**
- * Set the key-value pair on a given dictionary. If the given value is a
- * plain javascript object, every property of that object will also be set.
- * @param dictionary {Record<string, unknown>} The target dictionary
- * @param key {string} The given key
- * @param value {unknown} The given value
- * @param references {WeakSet<Record<string, unknown>>} references is a WeakSet
- *  instance used to keep track of which objects have already been iterated
- *  through preventing thus possible stack overflows caused by cyclic references
- * @returns {boolean} Returns true if every given key-value pair has been
- * successfully set
- */
-function set(
-  dictionary: Record<string, unknown>,
-  key: string,
-  value: unknown,
-  references: WeakSet<Record<string, unknown>>
-): boolean {
-  if (isValidKey(key)) {
-    if (isPlainObject(value)) {
-      return setAll(
-        dictionary,
-        key,
-        value as Record<string, unknown>,
-        references instanceof WeakSet ? references : new WeakSet()
-      );
-    }
-    dictionary[key] = value;
-    return true;
-  }
-  return false;
-}
-
-function get(dictionary: Record<string, unknown>, key: string): unknown {
-  return dictionary[key];
-}
-
-/**
- * Make sure the -provided key correctly formatted.
- * e.g.:
- *  "my.cool.property" (valid)
- *  "my.cool.property." (invalid)
- *  ".my.cool.property" (invalid)
- *  "my.cool..property" (invalid)
- * @param key {string} The property name to be used as key within the internal
- *  dictionary
- * @returns {boolean} True on success, false otherwise
- */
-function isValidKey(key: string): boolean {
-  let last: number, current: number, previous: number;
-  if (typeof key !== 'string' || (last = key.length - 1) < 0) {
-    return false;
-  }
-  previous = -1;
-  while ((current = key.indexOf('.', previous + 1)) >= 0) {
-    if (current - previous < 2 || current === last) {
-      return false;
-    }
-    previous = current;
-  }
-  return true;
-}
-
-function isPlainObject(subject: unknown) {
-  if (typeof subject === 'object' && subject !== null) {
-    const prototype = Object.getPrototypeOf(subject);
-    if (prototype === Object.prototype || prototype === null) {
-      return true;
-    }
-  }
-  return false;
-}
-
-function deepSet(context, key, value) {
-  const separator = key.indexOf('.');
-  if (separator >= 0) {
-    const subKey = key.slice(0, separator);
-    let subContext = context[subKey];
-    if (typeof subContext !== 'object' || subContext === null) {
-      const subContextValue = subContext;
-      subContext = {};
-      if (typeof subContextValue !== 'undefined') {
-        subContext[''] = subContextValue;
-      }
-      context[subKey] = subContext;
-    }
-    deepSet(subContext, key.slice(separator + 1, key.length), value);
-  } else {
-    context[key] = value;
-  }
-}
-
-/**
- * Initial Settings for the repository
- */
-Settings.getDefaultSettings().set('useCursors', true);