@cornerstonejs/core 0.36.2 → 0.36.4

package/src/RenderingEngine/vtkClasses/vtkStreamingOpenGLVolumeMapper.js

@@ -0,0 +1,319 @@
+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];
+  };
+}
+
+// ----------------------------------------------------------------------------
+// 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

@@ -0,0 +1,294 @@
+/*
+ * 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);