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

package/src/tools/displayTools/Contour/addOrUpdateContourSets.ts

@@ -1,28 +0,0 @@
-import { Types } from '@cornerstonejs/core';
-
-import {
-  SegmentationRepresentationConfig,
-  ToolGroupSpecificContourRepresentation,
-} from '../../../types';
-import { addContourSetsToElement } from './addContourSetsToElement';
-import { updateContourSets } from './updateContourSets';
-
-export function addOrUpdateContourSets(
-  viewport: Types.IVolumeViewport,
-  geometryIds: string[],
-  contourRepresentation: ToolGroupSpecificContourRepresentation,
-  contourRepresentationConfig: SegmentationRepresentationConfig
-) {
-  const { segmentationRepresentationUID } = contourRepresentation;
-  const actorUID = `CONTOUR_${segmentationRepresentationUID}`;
-  const actor = viewport.getActor(actorUID);
-
-  const addOrUpdateFn = actor ? updateContourSets : addContourSetsToElement;
-  addOrUpdateFn(
-    viewport,
-    geometryIds,
-    contourRepresentation,
-    contourRepresentationConfig,
-    actorUID
-  );
-}

package/src/tools/displayTools/Contour/contourConfig.ts

@@ -1,18 +0,0 @@
-import { ContourConfig } from '../../../types/ContourTypes';
-
-const defaultContourConfig: ContourConfig = {
-  renderOutline: true,
-  outlineWidthActive: 2,
-  outlineWidthInactive: 2,
-  outlineOpacity: 1,
-  outlineOpacityInactive: 0.85,
-  renderFill: true,
-  fillAlpha: 1,
-  fillAlphaInactive: 0,
-};
-
-function getDefaultContourConfig(): ContourConfig {
-  return defaultContourConfig;
-}
-
-export default getDefaultContourConfig;

package/src/tools/displayTools/Contour/contourConfigCache.ts

@@ -1,37 +0,0 @@
-type ConfigCache = {
-  segmentsHidden: Set<number>;
-  outlineWidthActive: number;
-  visibility: boolean;
-};
-
-/**
- * Config cache is used to store the config for a given segmentation
- * representation. This is used to avoid having to recompute the config
- * every time the user changes the active segment, and also for performance
- * reasons.
- */
-const configCachePerSegmentationRepresentationUID = new Map();
-
-export function getConfigCache(
-  segmentationRepresentationUID: string
-): ConfigCache {
-  return configCachePerSegmentationRepresentationUID.get(
-    segmentationRepresentationUID
-  );
-}
-
-export function setConfigCache(
-  segmentationRepresentationUID: string,
-  config: ConfigCache
-) {
-  configCachePerSegmentationRepresentationUID.set(
-    segmentationRepresentationUID,
-    config
-  );
-}
-
-export function deleteConfigCache(segmentationRepresentationUID: string) {
-  configCachePerSegmentationRepresentationUID.delete(
-    segmentationRepresentationUID
-  );
-}

package/src/tools/displayTools/Contour/contourDisplay.ts

@@ -1,175 +0,0 @@
-import {
-  getEnabledElementByIds,
-  Types,
-  utilities as csUtils,
-} from '@cornerstonejs/core';
-
-import Representations from '../../../enums/SegmentationRepresentations';
-import * as SegmentationConfig from '../../../stateManagement/segmentation/config/segmentationConfig';
-import * as SegmentationState from '../../../stateManagement/segmentation/segmentationState';
-import { getToolGroup } from '../../../store/ToolGroupManager';
-import {
-  RepresentationPublicInput,
-  SegmentationRepresentationConfig,
-  ToolGroupSpecificRepresentation,
-} from '../../../types/SegmentationStateTypes';
-import { addOrUpdateContourSets } from './addOrUpdateContourSets';
-import removeContourFromElement from './removeContourFromElement';
-import { deleteConfigCache } from './contourConfigCache';
-
-/**
- * It adds a new segmentation representation to the segmentation state
- * @param toolGroupId - The id of the toolGroup that the segmentation
- * belongs to
- * @param representationInput - RepresentationPublicInput
- * @param toolGroupSpecificConfig - The configuration that is specific to the toolGroup.
- * @returns The segmentationRepresentationUID
- */
-async function addSegmentationRepresentation(
-  toolGroupId: string,
-  representationInput: RepresentationPublicInput,
-  toolGroupSpecificConfig?: SegmentationRepresentationConfig
-): Promise<string> {
-  const { segmentationId } = representationInput;
-  const segmentationRepresentationUID = csUtils.uuidv4();
-  // Todo: make these configurable during representation input by user
-  const segmentsHidden = new Set() as Set<number>;
-  const visibility = true;
-  const colorLUTIndex = 0;
-  const active = true;
-  const toolGroupSpecificRepresentation: ToolGroupSpecificRepresentation = {
-    segmentationId,
-    segmentationRepresentationUID,
-    type: Representations.Contour,
-    segmentsHidden,
-    colorLUTIndex,
-    active,
-    segmentationRepresentationSpecificConfig: {},
-    segmentSpecificConfig: {},
-    config: {},
-  };
-  // Update the toolGroup specific configuration
-  if (toolGroupSpecificConfig) {
-    // Since setting configuration on toolGroup will trigger a segmentationRepresentation
-    // update event, we don't want to trigger the event twice, so we suppress
-    // the first one
-    const currentToolGroupConfig =
-      SegmentationConfig.getToolGroupSpecificConfig(toolGroupId);
-    const mergedConfig = csUtils.deepMerge(
-      currentToolGroupConfig,
-      toolGroupSpecificConfig
-    );
-    SegmentationConfig.setToolGroupSpecificConfig(toolGroupId, {
-      renderInactiveSegmentations:
-        mergedConfig.renderInactiveSegmentations || true,
-      representations: {
-        ...mergedConfig.representations,
-      },
-    });
-  }
-  SegmentationState.addSegmentationRepresentation(
-    toolGroupId,
-    toolGroupSpecificRepresentation
-  );
-  return segmentationRepresentationUID;
-}
-
-/**
- * It removes a segmentation representation from the tool group's viewports and
- * from the segmentation state
- * @param toolGroupId - The toolGroupId of the toolGroup that the
- * segmentationRepresentation belongs to.
- * @param segmentationRepresentationUID - This is the unique identifier
- * for the segmentation representation.
- * @param renderImmediate - If true, the viewport will be rendered
- * immediately after the segmentation representation is removed.
- */
-function removeSegmentationRepresentation(
-  toolGroupId: string,
-  segmentationRepresentationUID: string,
-  renderImmediate = false
-): void {
-  _removeContourFromToolGroupViewports(
-    toolGroupId,
-    segmentationRepresentationUID
-  );
-  SegmentationState.removeSegmentationRepresentation(
-    toolGroupId,
-    segmentationRepresentationUID
-  );
-
-  deleteConfigCache(segmentationRepresentationUID);
-
-  if (renderImmediate) {
-    const viewportsInfo = getToolGroup(toolGroupId).getViewportsInfo();
-    viewportsInfo.forEach(({ viewportId, renderingEngineId }) => {
-      const enabledElement = getEnabledElementByIds(
-        viewportId,
-        renderingEngineId
-      );
-      enabledElement.viewport.render();
-    });
-  }
-}
-
-/**
- * It renders the contour sets for the given segmentation
- * @param viewport - The viewport object
- * @param representation - ToolGroupSpecificRepresentation
- * @param toolGroupConfig - This is the configuration object for the tool group
- */
-async function render(
-  viewport: Types.IVolumeViewport,
-  representationConfig: ToolGroupSpecificRepresentation,
-  toolGroupConfig: SegmentationRepresentationConfig
-): Promise<void> {
-  const { segmentationId } = representationConfig;
-  const segmentation = SegmentationState.getSegmentation(segmentationId);
-  const contourData = segmentation.representationData[Representations.Contour];
-  const { geometryIds } = contourData;
-
-  if (!geometryIds?.length) {
-    console.warn(
-      `No contours found for segmentationId ${segmentationId}. Skipping render.`
-    );
-  }
-
-  // add the contour sets to the viewport
-  addOrUpdateContourSets(
-    viewport,
-    geometryIds,
-    representationConfig,
-    toolGroupConfig
-  );
-}
-
-function _removeContourFromToolGroupViewports(
-  toolGroupId: string,
-  segmentationRepresentationUID: string
-): void {
-  const toolGroup = getToolGroup(toolGroupId);
-
-  if (toolGroup === undefined) {
-    throw new Error(`ToolGroup with ToolGroupId ${toolGroupId} does not exist`);
-  }
-
-  const { viewportsInfo } = toolGroup;
-
-  for (const viewportInfo of viewportsInfo) {
-    const { viewportId, renderingEngineId } = viewportInfo;
-    const enabledElement = getEnabledElementByIds(
-      viewportId,
-      renderingEngineId
-    );
-    removeContourFromElement(
-      enabledElement.viewport.element,
-      segmentationRepresentationUID
-    );
-  }
-}
-
-export default {
-  render,
-  addSegmentationRepresentation,
-  removeSegmentationRepresentation,
-};

package/src/tools/displayTools/Contour/index.ts

@@ -1,3 +0,0 @@
-import contourDisplay from './contourDisplay';
-
-export { contourDisplay };

package/src/tools/displayTools/Contour/removeContourFromElement.ts

@@ -1,35 +0,0 @@
-import { getEnabledElement } from '@cornerstonejs/core';
-import type { Types } from '@cornerstonejs/core';
-
-/**
- * Remove the contour representation from the viewport's HTML Element.
- * NOTE: This function should not be called directly.
- *
- * @param element - The element that the segmentation is being added to.
- * @param segmentationRepresentationUID - The UID of the contour representation to remove.
- * @param removeFromCache - boolean
- *
- * @internal
- */
-function removeContourFromElement(
-  element: HTMLDivElement,
-  segmentationRepresentationUID: string,
-  removeFromCache = false // Todo
-): void {
-  const enabledElement = getEnabledElement(element);
-  const { viewport } = enabledElement;
-
-  const actorEntries = (viewport as Types.IVolumeViewport).getActors();
-
-  // remove actors whose id has the same prefix as the segmentationRepresentationUID
-  const actorUIDsToRemove = actorEntries
-    .map(({ uid }) =>
-      uid.includes(segmentationRepresentationUID) ? uid : undefined
-    )
-    .filter(Boolean);
-
-  // @ts-ignore
-  viewport.removeActors(actorUIDsToRemove);
-}
-
-export default removeContourFromElement;

package/src/tools/displayTools/Contour/updateContourSets.ts

@@ -1,155 +0,0 @@
-import { cache, Types } from '@cornerstonejs/core';
-import vtkActor from '@kitware/vtk.js/Rendering/Core/Actor';
-
-import {
-  SegmentationRepresentationConfig,
-  ToolGroupSpecificContourRepresentation,
-} from '../../../types';
-import { getConfigCache, setConfigCache } from './contourConfigCache';
-import { getSegmentSpecificConfig } from './utils';
-
-export function updateContourSets(
-  viewport: Types.IVolumeViewport,
-  geometryIds: string[],
-  contourRepresentation: ToolGroupSpecificContourRepresentation,
-  contourRepresentationConfig: SegmentationRepresentationConfig,
-  contourActorUID: string
-) {
-  const { segmentationRepresentationUID, segmentsHidden } =
-    contourRepresentation;
-  const newContourConfig = contourRepresentationConfig.representations.CONTOUR;
-  const cachedConfig = getConfigCache(segmentationRepresentationUID);
-
-  const contourSetsActor = viewport.getActor(contourActorUID);
-
-  if (!contourSetsActor) {
-    console.warn(
-      `No contour actor found for actorUID ${contourActorUID}. Skipping render.`
-    );
-    return;
-  }
-
-  const { actor } = contourSetsActor;
-
-  const newOutlineWithActive = newContourConfig.outlineWidthActive;
-
-  if (cachedConfig?.outlineWidthActive !== newOutlineWithActive) {
-    (actor as unknown as vtkActor)
-      .getProperty()
-      .setLineWidth(newOutlineWithActive);
-
-    setConfigCache(
-      segmentationRepresentationUID,
-      Object.assign({}, cachedConfig, {
-        outlineWidthActive: newOutlineWithActive,
-      })
-    );
-  }
-
-  const mapper = (actor as unknown as vtkActor).getMapper();
-  const lut = mapper.getLookupTable();
-
-  const segmentsToSetToInvisible = [];
-  const segmentsToSetToVisible = [];
-
-  for (const segmentIndex of segmentsHidden) {
-    if (!cachedConfig.segmentsHidden.has(segmentIndex)) {
-      segmentsToSetToInvisible.push(segmentIndex);
-    }
-  }
-
-  // the other way around
-  for (const segmentIndex of cachedConfig.segmentsHidden) {
-    if (!segmentsHidden.has(segmentIndex)) {
-      segmentsToSetToVisible.push(segmentIndex);
-    }
-  }
-
-  const mergedInvisibleSegments = Array.from(cachedConfig.segmentsHidden)
-    .filter((segmentIndex) => !segmentsToSetToVisible.includes(segmentIndex))
-    .concat(segmentsToSetToInvisible);
-
-  const { contourSets, segmentSpecificConfigs } = geometryIds.reduce(
-    (acc, geometryId) => {
-      const geometry = cache.getGeometry(geometryId);
-      const { data: contourSet } = geometry;
-      const segmentIndex = (contourSet as Types.IContourSet).getSegmentIndex();
-      const segmentSpecificConfig = getSegmentSpecificConfig(
-        contourRepresentation,
-        geometryId,
-        segmentIndex
-      );
-
-      acc.contourSets.push(contourSet);
-      acc.segmentSpecificConfigs[segmentIndex] = segmentSpecificConfig ?? {};
-
-      return acc;
-    },
-    { contourSets: [], segmentSpecificConfigs: {} }
-  );
-
-  const affectedSegments = [
-    ...mergedInvisibleSegments,
-    ...segmentsToSetToVisible,
-  ];
-
-  const hasCustomSegmentSpecificConfig = Object.values(
-    segmentSpecificConfigs
-  ).some((config) => Object.keys(config).length > 0);
-
-  let polyDataModified = false;
-
-  if (affectedSegments.length || hasCustomSegmentSpecificConfig) {
-    const appendPolyData = mapper.getInputData();
-    const appendScalars = appendPolyData.getPointData().getScalars();
-    const appendScalarsData = appendScalars.getData();
-    // below we will only manipulate the polyData of the contourSets that are affected
-    // by picking the correct offset in the scalarData array
-    let offset = 0;
-    contourSets.forEach((contourSet) => {
-      const segmentIndex = (contourSet as Types.IContourSet).getSegmentIndex();
-      const size = contourSet.getTotalNumberOfPoints();
-
-      if (
-        affectedSegments.includes(segmentIndex) ||
-        segmentSpecificConfigs[segmentIndex]?.fillAlpha // Todo: add others
-      ) {
-        const color = contourSet.getColor();
-        let visibility = mergedInvisibleSegments.includes(segmentIndex)
-          ? 0
-          : 255;
-
-        const segmentConfig = segmentSpecificConfigs[segmentIndex];
-        if (segmentConfig.fillAlpha !== undefined) {
-          visibility = segmentConfig.fillAlpha * 255;
-        }
-
-        for (let i = 0; i < size; ++i) {
-          appendScalarsData[offset + i * 4] = color[0];
-          appendScalarsData[offset + i * 4 + 1] = color[1];
-          appendScalarsData[offset + i * 4 + 2] = color[2];
-          appendScalarsData[offset + i * 4 + 3] = visibility;
-        }
-
-        polyDataModified = true;
-      }
-
-      offset = offset + size * 4;
-    });
-
-    if (polyDataModified) {
-      appendPolyData.modified();
-    }
-
-    setConfigCache(
-      segmentationRepresentationUID,
-      Object.assign({}, cachedConfig, {
-        segmentsHidden: new Set(segmentsHidden),
-      })
-    );
-
-    mapper.setLookupTable(lut);
-  }
-
-  viewport.render();
-}

package/src/tools/displayTools/Contour/utils.ts

@@ -1,116 +0,0 @@
-import { Enums, Types } from '@cornerstonejs/core';
-import vtkCellArray from '@kitware/vtk.js/Common/Core/CellArray';
-import vtkPoints from '@kitware/vtk.js/Common/Core/Points';
-import vtkPolyData from '@kitware/vtk.js/Common/DataModel/PolyData';
-import { ToolGroupSpecificContourRepresentation } from '../../../types';
-
-/**
- * If the segment specific config exists for the given segment id, it returns
- * the segment specific config. Otherwise, it looks for the segment specific
- * config for the given index. If it doesn't exist, it returns null.
- *
- * @param contourRepresentation -  The representation object that is passed
- * to the tool.
- * @param segmentId -  The id of the segment.
- * @param index -  The index of the segment in the list of segments.
- * @returns the segment specific config for the given segment id.
- *
- */
-export function getSegmentSpecificConfig(
-  contourRepresentation: ToolGroupSpecificContourRepresentation,
-  segmentId: string,
-  index: number
-) {
-  let segmentSpecificConfig =
-    contourRepresentation.segmentSpecificConfig?.[segmentId];
-
-  if (!segmentSpecificConfig) {
-    // try the index
-    segmentSpecificConfig =
-      contourRepresentation.segmentSpecificConfig?.[index];
-  }
-
-  if (!segmentSpecificConfig) {
-    return null;
-  }
-
-  return segmentSpecificConfig.CONTOUR;
-}
-
-/**
- * takes a geometry object as an argument
- * and throws an error if the geometry object is not a contour
- * @param geometry -  The geometry object to be rendered.
- */
-export function validateGeometry(geometry: Types.IGeometry): void {
-  if (!geometry) {
-    throw new Error(`No contours found for geometryId ${geometry.id}`);
-  }
-
-  const geometryId = geometry.id;
-
-  if (geometry.type !== Enums.GeometryType.CONTOUR) {
-    throw new Error(
-      `Geometry type ${geometry.type} not supported for rendering.`
-    );
-  }
-
-  if (!geometry.data) {
-    console.warn(
-      `No contours found for geometryId ${geometryId}. Skipping render.`
-    );
-    return;
-  }
-}
-
-/**
- * It takes a contourSet and returns a vtkPolyData for that contourSet. A contour set
- * is a collection of contours. Each contour is a collection of points. Each point
- * is x,y,z in the world coordinate system.
- *
- * @param contourSet -  the contour set that you want to convert to polyData
- * @returns A vtkPolyData object
- */
-export function getPolyData(contourSet: Types.IContourSet) {
-  const pointArray = [];
-
-  const points = vtkPoints.newInstance();
-  const lines = vtkCellArray.newInstance();
-
-  // this variable will indicate the index of the first point in the current line
-  // so we can correctly generate the point index list to add in the cellArray
-  let pointIndex = 0;
-  contourSet.getContours().forEach((contour: Types.IContour) => {
-    const pointList = contour.getPoints();
-    const flatPoints = contour.getFlatPointsArray();
-    const type = contour.getType();
-
-    // creating a point index list that defines a line
-    const pointIndexes = pointList.map(
-      (_, pointListIndex) => pointListIndex + pointIndex
-    );
-
-    // if close planar, add the first point index to the list
-    if (type === Enums.ContourType.CLOSED_PLANAR) {
-      pointIndexes.push(pointIndexes[0]);
-    }
-
-    const linePoints = Float32Array.from(flatPoints);
-    // add the current points into the point list
-    pointArray.push(...linePoints);
-    // add the point indexes into the cell array
-    lines.insertNextCell([...pointIndexes]);
-    // update the first point index
-    pointIndex = pointIndex + pointList.length;
-  });
-
-  // converts the pointArray into vtkPoints
-  points.setData(pointArray, 3);
-
-  // creates the polyData
-  const polygon = vtkPolyData.newInstance();
-  polygon.setPoints(points);
-  polygon.setLines(lines);
-
-  return polygon;
-}

package/src/tools/displayTools/Labelmap/addLabelmapToElement.ts

@@ -1,57 +0,0 @@
-import {
-  getEnabledElement,
-  addVolumesToViewports,
-  Types,
-  Enums,
-} from '@cornerstonejs/core';
-
-/**
- * It adds a labelmap segmentation representation of the viewport's HTML Element.
- * NOTE: This function should not be called directly.
- *
- * @param element - The element that will be rendered.
- * @param volumeId - The volume id of the labelmap.
- * @param segmentationRepresentationUID - The segmentation representation UID.
- *
- * @internal
- */
-async function addLabelmapToElement(
-  element: HTMLDivElement,
-  volumeId: string,
-  segmentationRepresentationUID: string
-): Promise<void> {
-  const enabledElement = getEnabledElement(element);
-  const { renderingEngine, viewport } = enabledElement;
-  const { id: viewportId } = viewport;
-
-  // Default to true since we are setting a new segmentation, however,
-  // in the event listener, we will make other segmentations visible/invisible
-  // based on the config
-  const visibility = true;
-  const immediateRender = false;
-  const suppressEvents = true;
-
-  // Todo: Right now we use MIP blend mode for the labelmap, since the
-  // composite blend mode has a non linear behavior regarding fill and line
-  // opacity. This should be changed to a custom labelmap blendMode which does
-  // what composite does, but with a linear behavior.
-  const volumeInputs: Types.IVolumeInput[] = [
-    {
-      volumeId,
-      actorUID: segmentationRepresentationUID,
-      visibility,
-      blendMode: Enums.BlendModes.MAXIMUM_INTENSITY_BLEND,
-    },
-  ];
-
-  // Add labelmap volumes to the viewports to be be rendered, but not force the render
-  await addVolumesToViewports(
-    renderingEngine,
-    volumeInputs,
-    [viewportId],
-    immediateRender,
-    suppressEvents
-  );
-}
-
-export default addLabelmapToElement;

package/src/tools/displayTools/Labelmap/index.ts

@@ -1,4 +0,0 @@
-import labelmapDisplay from './labelmapDisplay';
-import labelmapConfig from './labelmapConfig';
-
-export { labelmapDisplay, labelmapConfig };

package/src/tools/displayTools/Labelmap/labelmapConfig.ts

@@ -1,37 +0,0 @@
-import { LabelmapConfig } from '../../../types/LabelmapTypes';
-
-const defaultLabelmapConfig: LabelmapConfig = {
-  renderOutline: true,
-  outlineWidthActive: 3,
-  outlineWidthInactive: 2,
-  renderFill: true,
-  renderFillInactive: true,
-  fillAlpha: 0.7,
-  fillAlphaInactive: 0.65,
-  outlineOpacity: 1,
-  outlineOpacityInactive: 0.85,
-};
-
-function getDefaultLabelmapConfig(): LabelmapConfig {
-  return defaultLabelmapConfig;
-}
-
-// Checks if the labelmap config is valid, which means
-// if all the required fields are present and have the correct type
-function isValidLabelmapConfig(config): boolean {
-  return (
-    config &&
-    typeof config.renderOutline === 'boolean' &&
-    typeof config.outlineWidthActive === 'number' &&
-    typeof config.outlineWidthInactive === 'number' &&
-    typeof config.renderFill === 'boolean' &&
-    typeof config.renderFillInactive === 'boolean' &&
-    typeof config.fillAlpha === 'number' &&
-    typeof config.fillAlphaInactive === 'number' &&
-    typeof config.outlineOpacity === 'number' &&
-    typeof config.outlineOpacityInactive === 'number'
-  );
-}
-
-export default getDefaultLabelmapConfig;
-export { isValidLabelmapConfig };