@cornerstonejs/core 2.0.0-beta.8 → 2.0.1

package/src/utilities/cacheUtils.ts

@@ -1,145 +0,0 @@
-import cache, { ImageVolume } from '../cache';
-import { Events } from '../enums';
-import eventTarget from '../eventTarget';
-import { getConfiguration, getShouldUseSharedArrayBuffer } from '../init';
-
-/**
- * This function will check if the cache optimization is enabled and if it is
- * it will check if the created volume was derived from an already cached stack
- * of images, if so it will go back to the image cache and create a view at the
- * correct offset of the bigger volume array buffer, this will save memory.
- *
- * @param volumeId - The volumeId that will be checked for cache optimization
- */
-export function setupCacheOptimizationEventListener(volumeId) {
-  const { enableCacheOptimization } = getConfiguration();
-  const shouldUseSAB = getShouldUseSharedArrayBuffer();
-
-  const performOptimization = enableCacheOptimization && shouldUseSAB;
-  if (!performOptimization) {
-    return;
-  }
-
-  eventTarget.addEventListenerOnce(
-    Events.IMAGE_VOLUME_LOADING_COMPLETED,
-    (evt) => {
-      if (evt.detail.volumeId !== volumeId) {
-        return;
-      }
-
-      const volume = cache.getVolume(volumeId);
-
-      performCacheOptimizationForVolume(volume);
-    }
-  );
-}
-
-/**
- * Performs cache optimization for a volume by replacing the pixel data of each image
- * in the image cache (if found) with a view of the volume's scalar data.
- * @param options - The options for cache optimization.
- * @param options.volumeId - The ID of the volume.
- */
-export function performCacheOptimizationForVolume(volume) {
-  if (!(volume instanceof ImageVolume)) {
-    return;
-  }
-
-  const scalarData = volume.getScalarData();
-
-  volume.imageCacheOffsetMap.size > 0
-    ? _processImageCacheOffsetMap(volume, scalarData)
-    : _processVolumeImages(volume, scalarData);
-}
-
-/**
- * This function will process the volume images and replace the pixel data of each
- * image in the image cache (if found) with a view of the volume's scalar data.
- * This function is used when the volume is derived from an already cached stack
- * of images.
- *
- * @param volume - The volume to process.
- * @param scalarData - The scalar data to use for the volume.
- */
-function _processImageCacheOffsetMap(volume, scalarData) {
-  volume.imageCacheOffsetMap.forEach(({ offset }, imageId) => {
-    const image = cache.getImage(imageId);
-    if (!image) {
-      return;
-    }
-
-    _updateImageWithScalarDataView(image, scalarData, offset);
-    cache.decrementImageCacheSize(image.sizeInBytes);
-  });
-}
-
-/**
- * This function will process the volume images and replace the pixel data of each
- * image in the image cache (if found) with a view of the volume's scalar data.
- * This function is used when the volume is not derived from an already cached stack
- * of images.
- *
- * @param volume - The volume to process.
- * @param scalarData - The scalar data to use for the volume.
- */
-function _processVolumeImages(volume, scalarData) {
-  let compatibleScalarData = scalarData;
-
-  const sampleImageIdWithImage = volume.imageIds.find((imageId) => {
-    const image = cache.getImage(imageId);
-    return image;
-  });
-
-  if (!sampleImageIdWithImage) {
-    return;
-  }
-
-  const sampleImage = cache.getImage(sampleImageIdWithImage);
-  const samplePixelData =
-    sampleImage.imageFrame?.pixelData || sampleImage.getPixelData();
-
-  // Check if the types of scalarData and pixelData are different.
-  if (scalarData.constructor !== samplePixelData.constructor) {
-    // If so, create a new typed array of the same type as pixelData and copy the values from scalarData.
-    compatibleScalarData = new samplePixelData.constructor(scalarData.length);
-
-    // Copy values from scalarData to compatibleScalarData.
-    compatibleScalarData.set(scalarData);
-  }
-
-  volume.imageIds.forEach((imageId) => {
-    const image = cache.getImage(imageId);
-    if (!image) {
-      return;
-    }
-
-    const index = volume.getImageIdIndex(imageId);
-    const offset = index * image.getPixelData().byteLength;
-
-    _updateImageWithScalarDataView(image, compatibleScalarData, offset);
-    cache.decrementImageCacheSize(image.sizeInBytes);
-  });
-}
-
-function _updateImageWithScalarDataView(image, scalarData, offset) {
-  const pixelData = image.imageFrame
-    ? image.imageFrame.pixelData
-    : image.getPixelData();
-
-  const view = new pixelData.constructor(
-    scalarData.buffer,
-    offset,
-    pixelData.length
-  );
-
-  image.getPixelData = () => view;
-
-  if (image.imageFrame) {
-    image.imageFrame.pixelData = view;
-  }
-
-  image.bufferView = {
-    buffer: scalarData.buffer,
-    offset,
-  };
-}

package/src/utilities/calculateViewportsSpatialRegistration.ts

@@ -1,67 +0,0 @@
-import { vec3, mat4 } from 'gl-matrix';
-import { IStackViewport, IVolumeViewport } from '../types';
-import spatialRegistrationMetadataProvider from './spatialRegistrationMetadataProvider';
-import { metaData } from '..';
-
-/**
- * Defines the allowed difference as a percent between the unit normals before
- * two planes are considered not coplanar.  Since this value is small compared
- * to the unit lenght, this value is approximately the angular difference, measured
- * in radians.  That is, allow about a 3 degrees variation.
- */
-const ALLOWED_DELTA = 0.05;
-
-/**
- * It calculates the registration matrix between two viewports (currently only
- * translation is supported)
- * If the viewports are in the same frame of reference, it will return early,
- * but otherwise it will use the current image's metadata to calculate the
- * translation between the two viewports and adds it to the spatialRegistrationModule
- * metadata provider
- *
- *
- * @param viewport1 - The first stack viewport
- * @param viewport2 - The second stack viewport
- */
-function calculateViewportsSpatialRegistration(
-  viewport1: IStackViewport | IVolumeViewport,
-  viewport2: IStackViewport | IVolumeViewport
-): void {
-  const imageId1 = viewport1.getCurrentImageId();
-  const imageId2 = viewport2.getCurrentImageId();
-
-  const imagePlaneModule1 = metaData.get('imagePlaneModule', imageId1);
-  const imagePlaneModule2 = metaData.get('imagePlaneModule', imageId2);
-
-  if (!imagePlaneModule1 || !imagePlaneModule2) {
-    console.log('Viewport spatial registration requires image plane module');
-    return;
-  }
-  const { imageOrientationPatient: iop2 } = imagePlaneModule2;
-  const isSameImagePlane = imagePlaneModule1.imageOrientationPatient.every(
-    (v, i) => Math.abs(v - iop2[i]) < ALLOWED_DELTA
-  );
-
-  if (!isSameImagePlane) {
-    console.log(
-      'Viewport spatial registration only supported for same orientation (hence translation only) for now',
-      imagePlaneModule1?.imageOrientationPatient,
-      imagePlaneModule2?.imageOrientationPatient
-    );
-    return;
-  }
-
-  const imagePositionPatient1 = imagePlaneModule1.imagePositionPatient;
-  const imagePositionPatient2 = imagePlaneModule2.imagePositionPatient;
-
-  const translation = vec3.subtract(
-    vec3.create(),
-    imagePositionPatient1,
-    imagePositionPatient2
-  );
-
-  const mat = mat4.fromTranslation(mat4.create(), translation);
-  spatialRegistrationMetadataProvider.add([viewport1.id, viewport2.id], mat);
-}
-
-export default calculateViewportsSpatialRegistration;

package/src/utilities/calibratedPixelSpacingMetadataProvider.ts

@@ -1,36 +0,0 @@
-import imageIdToURI from './imageIdToURI';
-import { IImageCalibration } from '../types';
-
-const state: Record<string, IImageCalibration> = {}; // Calibrated pixel spacing per imageId
-
-/**
- * Simple metadataProvider object to store metadata for calibrated spacings.
- * This can be added via cornerstone.metaData.addProvider(...) in order to store
- * and return calibrated pixel spacings when metaData type is "calibratedPixelSpacing".
- */
-const metadataProvider = {
-  /**
-   * Adds metadata for an imageId.
-   * @param imageId - the imageId for the metadata to store
-   * @param payload - the payload composed of new calibrated pixel spacings
-   */
-  add: (imageId: string, payload: IImageCalibration): void => {
-    const imageURI = imageIdToURI(imageId);
-    state[imageURI] = payload;
-  },
-
-  /**
-   * Returns the metadata for an imageId if it exists.
-   * @param type - the type of metadata to enquire about
-   * @param imageId - the imageId to enquire about
-   * @returns the calibrated pixel spacings for the imageId if it exists, otherwise undefined
-   */
-  get: (type: string, imageId: string): IImageCalibration => {
-    if (type === 'calibratedPixelSpacing') {
-      const imageURI = imageIdToURI(imageId);
-      return state[imageURI];
-    }
-  },
-};
-
-export default metadataProvider;

package/src/utilities/clamp.ts

@@ -1,5 +0,0 @@
-function clamp(value: number, min: number, max: number) {
-  return Math.max(min, Math.min(max, value));
-}
-
-export { clamp as default, clamp };

package/src/utilities/color.ts

@@ -1,33 +0,0 @@
-function componentToHex(c) {
-  const hex = c.toString(16);
-  return hex.length == 1 ? '0' + hex : hex;
-}
-
-/**
- * Converts RGB color values to a hexadecimal color string.
- * @param r - The red component value (0-255).
- * @param g - The green component value (0-255).
- * @param b - The blue component value (0-255).
- * @returns The hexadecimal color string representation.
- */
-function rgbToHex(r, g, b) {
-  return '#' + componentToHex(r) + componentToHex(g) + componentToHex(b);
-}
-
-/**
- * Converts a hexadecimal color code to an RGB object.
- * @param hex - The hexadecimal color code to convert.
- * @returns An object representing the RGB values of the color, or null if the input is invalid.
- */
-function hexToRgb(hex) {
-  const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
-  return result
-    ? {
-        r: parseInt(result[1], 16),
-        g: parseInt(result[2], 16),
-        b: parseInt(result[3], 16),
-      }
-    : null;
-}
-
-export { hexToRgb, rgbToHex };

package/src/utilities/colormap.ts

@@ -1,111 +0,0 @@
-import vtkColorMaps from '@kitware/vtk.js/Rendering/Core/ColorTransferFunction/ColorMaps';
-
-import { ColormapPublic, ColormapRegistration } from '../types';
-import isEqual from './isEqual';
-import { actorIsA } from './actorCheck';
-
-const _colormaps = new Map();
-
-/**
- * Register a colormap
- * @param name - name of the colormap
- * @param colormap - colormap object
- */
-function registerColormap(colormap: ColormapRegistration) {
-  _colormaps.set(colormap.Name, colormap);
-}
-
-/**
- * Get a colormap by name
- * @param name - name of the colormap
- * @returns colormap object
- */
-function getColormap(name) {
-  return _colormaps.get(name);
-}
-
-/**
- * Get all registered colormap names
- * @returns array of colormap names
- *
- */
-function getColormapNames() {
-  return Array.from(_colormaps.keys());
-}
-
-/**
- * Finds a colormap that matches the given RGB points.
- *
- * @param rgbPoints - The RGB points to match against the colormaps.
- * @returns  The matched colormap object or null if no match is found.
- */
-function findMatchingColormap(rgbPoints, actor): ColormapPublic | null {
-  const colormapsVTK = vtkColorMaps.rgbPresetNames.map((presetName) =>
-    vtkColorMaps.getPresetByName(presetName)
-  );
-
-  const colormapsCS3D = getColormapNames().map((colormapName) =>
-    getColormap(colormapName)
-  );
-
-  const colormaps = colormapsVTK.concat(colormapsCS3D);
-
-  // Find the colormap that matches the given RGB points
-  const matchedColormap = colormaps.find((colormap) => {
-    const { RGBPoints: presetRGBPoints } = colormap;
-
-    if (presetRGBPoints.length !== rgbPoints.length) {
-      return false;
-    }
-
-    for (let i = 0; i < presetRGBPoints.length; i += 4) {
-      if (
-        !isEqual(
-          presetRGBPoints.slice(i + 1, i + 4),
-          rgbPoints.slice(i + 1, i + 4)
-        )
-      ) {
-        return false;
-      }
-    }
-
-    return true;
-  });
-
-  if (!matchedColormap) {
-    return null;
-  }
-
-  const opacity = [];
-  if (actorIsA(actor, 'vtkVolume')) {
-    const opacityPoints = actor
-      .getProperty()
-      .getScalarOpacity(0)
-      .getDataPointer();
-
-    if (!opacityPoints) {
-      return {
-        name: matchedColormap.Name,
-      };
-    }
-
-    for (let i = 0; i < opacityPoints.length; i += 2) {
-      opacity.push({
-        value: opacityPoints[i],
-        opacity: opacityPoints[i + 1],
-      });
-    }
-  }
-
-  return {
-    name: matchedColormap.Name,
-    opacity,
-  };
-}
-
-export {
-  getColormap,
-  getColormapNames,
-  registerColormap,
-  findMatchingColormap,
-};

package/src/utilities/convertStackToVolumeViewport.ts

@@ -1,117 +0,0 @@
-import { IStackViewport, IVolumeViewport, Point3 } from '../types';
-import { setVolumesForViewports } from '../RenderingEngine/helpers';
-import {
-  createAndCacheVolume,
-  getUnknownVolumeLoaderSchema,
-} from '../loaders/volumeLoader';
-import { Events, OrientationAxis, ViewportType } from '../enums';
-
-/**
- * Converts a stack viewport to a volume viewport.
- *
- * @param params - The parameters for the conversion.
- * @param params.viewport - The stack viewport to convert.
- * @param params.options - The options for the conversion.
- * @param [params.options.volumeId] - The volumeId that will get generated, it should have the volume loader schema defined if not we will use the default one.
- * @param [params.options.viewportId] - The viewportId that will get used for new viewport. If not provided, the stack viewport id will be used.
- * @param [params.options.background] - The background color of the volume viewport.
- * @returns The converted volume viewport.
- */
-async function convertStackToVolumeViewport({
-  viewport,
-  options,
-}: {
-  viewport: IStackViewport;
-  options: {
-    volumeId: string;
-    viewportId?: string;
-    background?: Point3;
-    orientation?: OrientationAxis;
-  };
-}): Promise<IVolumeViewport> {
-  const renderingEngine = viewport.getRenderingEngine();
-
-  let { volumeId } = options;
-
-  // if there is no loader schema for the volume Id, we will use the default one
-  // which we can get from the volume loader
-  if (volumeId.split(':').length === 1) {
-    const schema = getUnknownVolumeLoaderSchema();
-    volumeId = `${schema}:${volumeId}`;
-  }
-
-  const { id, element } = viewport;
-  const viewportId = options.viewportId || id;
-
-  const imageIds = viewport.getImageIds();
-
-  // It is important to keep the camera before enabling the viewport
-  const prevCamera = viewport.getCamera();
-
-  // this will disable the stack viewport and remove it from the toolGroup
-  renderingEngine.enableElement({
-    viewportId,
-    type: ViewportType.ORTHOGRAPHIC,
-    element,
-    defaultOptions: {
-      background: options.background,
-      orientation: options.orientation,
-    },
-  });
-
-  // Ideally here we should be able to just create a local volume and not use the
-  // volume louder but we don't know if the stack is already pre-cached for all its
-  // imageIds or not so we just let the loader handle it and we have cache
-  // optimizations in place to avoid fetching the same imageId if it is already
-  // cached
-  const volume = await createAndCacheVolume(volumeId, {
-    imageIds,
-  });
-
-  volume.load();
-
-  // we should get the new viewport from the renderingEngine since the stack viewport
-  // was disabled and replaced with a volume viewport of the same id
-  const volumeViewport = <IVolumeViewport>(
-    renderingEngine.getViewport(viewportId)
-  );
-
-  setVolumesForViewports(
-    renderingEngine,
-    [
-      {
-        volumeId,
-      },
-    ],
-    [viewportId]
-  );
-
-  const volumeViewportNewVolumeHandler = () => {
-    if (!options.orientation) {
-      volumeViewport.setCamera({
-        ...prevCamera,
-      });
-    }
-    volumeViewport.render();
-
-    element.removeEventListener(
-      Events.VOLUME_VIEWPORT_NEW_VOLUME,
-      volumeViewportNewVolumeHandler
-    );
-  };
-
-  const addVolumeViewportNewVolumeListener = () => {
-    element.addEventListener(
-      Events.VOLUME_VIEWPORT_NEW_VOLUME,
-      volumeViewportNewVolumeHandler
-    );
-  };
-
-  addVolumeViewportNewVolumeListener();
-
-  volumeViewport.render();
-
-  return volumeViewport;
-}
-
-export { convertStackToVolumeViewport };

package/src/utilities/convertToGrayscale.ts

@@ -1,27 +0,0 @@
-export default function convertToGrayscale(
-  scalarData,
-  width: number,
-  height: number
-) {
-  const isRGBA = scalarData.length === width * height * 4;
-  const isRGB = scalarData.length === width * height * 3;
-  if (isRGBA || isRGB) {
-    const newScalarData = new Float32Array(width * height);
-    let offset = 0;
-    let destOffset = 0;
-    const increment = isRGBA ? 4 : 3;
-    for (let x = 0; x < width; x++) {
-      for (let y = 0; y < height; y++) {
-        const r = scalarData[offset];
-        const g = scalarData[offset + 1];
-        const b = scalarData[offset + 2];
-        newScalarData[destOffset] = (r + g + b) / 3;
-        offset += increment;
-        destOffset++;
-      }
-    }
-    return newScalarData;
-  } else {
-    return scalarData;
-  }
-}

package/src/utilities/convertVolumeToStackViewport.ts

@@ -1,125 +0,0 @@
-import * as Types from '../types';
-import cache, { ImageVolume } from '../cache';
-import { ViewportType } from '../enums';
-
-/**
- * Converts a volume viewport to a stack viewport.
- *
- * @param params - The parameters for the conversion.
- * @param params.viewport - The volume viewport to convert.
- * @param params.options - The conversion options.
- * @param [params.options.viewportId] - The new stackViewportId, If not provided, the volume viewport id will be used.
- * @param [params.options.background] - The background color of the stack viewport.
- * @param [params.options.decache] - Whether to decache the volume. Defaults to false.
- *
- * @returns The converted stack viewport.
- */
-async function convertVolumeToStackViewport({
-  viewport,
-  options,
-}: {
-  viewport: Types.IVolumeViewport;
-  options: {
-    viewportId?: string;
-    background?: Types.Point3;
-  };
-}): Promise<Types.IStackViewport> {
-  const volumeViewport = viewport;
-  const { id, element } = volumeViewport;
-  const renderingEngine = viewport.getRenderingEngine();
-  const imageIdIndex = viewport.getCurrentImageIdIndex();
-
-  const { background } = options;
-  const viewportId = options.viewportId || id;
-
-  const actorEntry = volumeViewport.getDefaultActor();
-  const { uid: volumeId } = actorEntry;
-  const volume = cache.getVolume(volumeId) as Types.IImageVolume;
-
-  if (!(volume instanceof ImageVolume)) {
-    throw new Error(
-      'Currently, you cannot decache a volume that is not an ImageVolume. So, unfortunately, volumes such as nifti  (which are basic Volume, without imageIds) cannot be decached.'
-    );
-  }
-
-  const viewportInput = {
-    viewportId,
-    type: ViewportType.STACK,
-    element,
-    defaultOptions: {
-      background,
-    },
-  };
-
-  renderingEngine.enableElement(viewportInput);
-
-  // Get the stack viewport that was created
-  const stackViewport = <Types.IStackViewport>(
-    renderingEngine.getViewport(viewportId)
-  );
-
-  // So here we have two scenarios that we need to handle:
-  // 1. the volume was derived from a stack and we need to decache it, this is easy
-  // since we just need purge the volume from the cache and those images will get
-  // their copy of the image back
-  // 2. It was actually a native volume and we need to decache it, this is a bit more
-  // complicated since then we need to decide on the imageIds for it to get
-  // decached to
-  const hasCachedImages = volume.imageCacheOffsetMap.size > 0;
-  // Initialize the variable to hold the final result
-  let isAllImagesCached = false;
-
-  if (hasCachedImages) {
-    // Check if every imageId in the volume is in the _imageCache
-    isAllImagesCached = volume.imageIds.every((imageId) =>
-      cache.getImage(imageId)
-    );
-  }
-
-  const volumeUsedInOtherViewports = renderingEngine
-    .getVolumeViewports()
-    .find((vp) => vp.hasVolumeId(volumeId));
-
-  volume.decache(!volumeUsedInOtherViewports && isAllImagesCached);
-
-  const stack = [...volume.imageIds].reverse();
-
-  let imageIdIndexToJump = Math.max(
-    volume.imageIds.length - imageIdIndex - 1,
-    0
-  );
-
-  // Check to see if the image is already cached or not. If it's not, we will use another
-  // nearby imageId for the first image to jump to. There seem to be a lot of side effects
-  // if we jump to an image that is not cached in stack viewport while we convert
-  // from a volume viewport. For example, if we switch back and forth between stack and volume,
-  // and then try to jump to an image that is not cached, the image will not render at
-  // all when the full volume is filled. I'm not sure why yet.
-  const imageToJump = cache.getImage(stack[imageIdIndexToJump]);
-  if (!imageToJump) {
-    let minDistance = Infinity;
-    let minDistanceIndex = null;
-
-    stack.forEach((imageId, index) => {
-      const image = cache.getImage(imageId);
-      if (image) {
-        const distance = Math.abs(imageIdIndexToJump - index);
-        if (distance < minDistance) {
-          minDistance = distance;
-          minDistanceIndex = index;
-        }
-      }
-    });
-
-    imageIdIndexToJump = minDistanceIndex;
-  }
-
-  await stackViewport.setStack(stack, imageIdIndexToJump ?? 0);
-
-  // Render the image
-  stackViewport.render();
-
-  return stackViewport;
-}
-
-export { convertVolumeToStackViewport };