@cornerstonejs/core 0.36.2 → 0.36.4

package/src/utilities/getViewportImageCornersInWorld.ts

@@ -0,0 +1,102 @@
+import {
+  IImageData,
+  IStackViewport,
+  IVolumeViewport,
+  Point2,
+  Point3,
+} from '../types';
+
+/**
+ * Given a viewport, return the corners of the image in the viewport in world coordinates.
+ * Note that this is different than the corners of the canvas in world coordinates since
+ * an image can be zoomed out and the canvas can be larger than the image; hence, the
+ * corners of the canvas in world coordinates will be outside the image.
+ *
+ * @param viewport - The viewport to get the corners of.
+ * @returns The corners of the image in the viewport in world coordinates.
+ */
+export default function getViewportImageCornersInWorld(
+  viewport: IStackViewport | IVolumeViewport
+): Point3[] {
+  const { imageData, dimensions } = viewport.getImageData() as IImageData;
+  const { canvas } = viewport;
+
+  const topLeftCanvas: Point2 = [0, 0];
+  const topRightCanvas: Point2 = [canvas.width, 0];
+  const bottomRightCanvas: Point2 = [canvas.width, canvas.height];
+  const bottomLeftCanvas: Point2 = [0, canvas.height];
+
+  const topLeftWorld = viewport.canvasToWorld(topLeftCanvas);
+  const topRightWorld = viewport.canvasToWorld(topRightCanvas);
+  const bottomRightWorld = viewport.canvasToWorld(bottomRightCanvas);
+  const bottomLeftWorld = viewport.canvasToWorld(bottomLeftCanvas);
+
+  const topLeftImage = imageData.worldToIndex(topLeftWorld);
+  const topRightImage = imageData.worldToIndex(topRightWorld);
+  const bottomRightImage = imageData.worldToIndex(bottomRightWorld);
+  const bottomLeftImage = imageData.worldToIndex(bottomLeftWorld);
+
+  return _getStackViewportImageCorners({
+    dimensions,
+    imageData,
+    topLeftImage,
+    topRightImage,
+    bottomRightImage,
+    bottomLeftImage,
+    topLeftWorld,
+    topRightWorld,
+    bottomRightWorld,
+    bottomLeftWorld,
+  });
+}
+
+function _getStackViewportImageCorners({
+  dimensions,
+  imageData,
+  topLeftImage,
+  topRightImage,
+  bottomRightImage,
+  bottomLeftImage,
+  topLeftWorld,
+  topRightWorld,
+  bottomRightWorld,
+  bottomLeftWorld,
+}) {
+  const topLeftImageWorld = _isInBounds(topLeftImage, dimensions)
+    ? topLeftWorld
+    : (imageData.indexToWorld([0, 0, 0]) as Point3);
+
+  const topRightImageWorld = _isInBounds(topRightImage, dimensions)
+    ? topRightWorld
+    : (imageData.indexToWorld([dimensions[0] - 1, 0, 0]) as Point3);
+
+  const bottomRightImageWorld = _isInBounds(bottomRightImage, dimensions)
+    ? bottomRightWorld
+    : (imageData.indexToWorld([
+        dimensions[0] - 1,
+        dimensions[1] - 1,
+        0,
+      ]) as Point3);
+
+  const bottomLeftImageWorld = _isInBounds(bottomLeftImage, dimensions)
+    ? bottomLeftWorld
+    : (imageData.indexToWorld([0, dimensions[1] - 1, 0]) as Point3);
+
+  return [
+    topLeftImageWorld,
+    topRightImageWorld,
+    bottomLeftImageWorld,
+    bottomRightImageWorld,
+  ];
+}
+
+function _isInBounds(imageCoord, dimensions) {
+  return (
+    imageCoord[0] > 0 ||
+    imageCoord[0] < dimensions[0] - 1 ||
+    imageCoord[1] > 0 ||
+    imageCoord[1] < dimensions[1] - 1 ||
+    imageCoord[2] > 0 ||
+    imageCoord[2] < dimensions[2] - 1
+  );
+}

package/src/utilities/getViewportsWithImageURI.ts

@@ -0,0 +1,46 @@
+import { getRenderingEngine } from '../RenderingEngine';
+import { getRenderingEngines } from '../RenderingEngine/getRenderingEngine';
+import { IStackViewport, IVolumeViewport } from '../types';
+
+type Viewport = IStackViewport | IVolumeViewport;
+
+/**
+ * Get the viewport that is rendering the image with the given imageURI (imageId without
+ * the loader schema), this can be a stackViewport or a volumeViewport.
+ *
+ * @param renderingEngine - The rendering engine that is rendering the viewports
+ * @param imageURI - The imageURI of the image that is requested
+ * @returns A Viewport
+ */
+export default function getViewportsWithImageURI(
+  imageURI: string,
+  renderingEngineId?: string
+): Array<Viewport> {
+  // If rendering engine is not provided, use all rendering engines
+  let renderingEngines;
+  if (renderingEngineId) {
+    renderingEngines = [getRenderingEngine(renderingEngineId)];
+  } else {
+    renderingEngines = getRenderingEngines();
+  }
+
+  const viewports = [];
+  renderingEngines.forEach((renderingEngine) => {
+    const stackViewports = renderingEngine.getStackViewports();
+
+    const filteredStackViewports = stackViewports.filter((viewport) =>
+      viewport.hasImageURI(imageURI)
+    );
+
+    // If no stack viewport found but a volumeViewport is rendering the same data
+    const volumeViewports = renderingEngine.getVolumeViewports();
+
+    const filteredVolumeViewports = volumeViewports.filter((viewport) =>
+      viewport.hasImageURI(imageURI)
+    );
+
+    viewports.push(...filteredStackViewports, ...filteredVolumeViewports);
+  });
+
+  return viewports;
+}

package/src/utilities/getViewportsWithVolumeId.ts

@@ -0,0 +1,38 @@
+import { IVolumeViewport } from '../types';
+import {
+  getRenderingEngines,
+  getRenderingEngine,
+} from '../RenderingEngine/getRenderingEngine';
+
+/**
+ * Similar to {@link getVolumeViewportsContainingSameVolumes}, but uses the volumeId
+ * to filter viewports that contain the same volume.
+ *
+ * @returns VolumeViewport viewports array
+ */
+function getViewportsWithVolumeId(
+  volumeId: string,
+  renderingEngineId?: string
+): Array<IVolumeViewport> {
+  // If rendering engine is not provided, use all rendering engines
+  let renderingEngines;
+  if (renderingEngineId) {
+    renderingEngines = [getRenderingEngine(renderingEngineId)];
+  } else {
+    renderingEngines = getRenderingEngines();
+  }
+
+  const targetViewports = [];
+
+  renderingEngines.forEach((renderingEngine) => {
+    const viewports = renderingEngine.getVolumeViewports();
+    const filteredViewports = viewports.filter((vp) =>
+      vp.hasVolumeId(volumeId)
+    );
+    targetViewports.push(...filteredViewports);
+  });
+
+  return targetViewports;
+}
+
+export default getViewportsWithVolumeId;

package/src/utilities/getVoiFromSigmoidRGBTransferFunction.ts

@@ -0,0 +1,23 @@
+import vtkColorTransferFunction from '@kitware/vtk.js/Rendering/Core/ColorTransferFunction';
+
+export default function getVoiFromSigmoidRGBTransferFunction(
+  cfun: vtkColorTransferFunction
+): [number, number] {
+  let cfunRange = [];
+  // @ts-ignore: vtk d ts problem
+  const [lower, upper] = cfun.getRange();
+  cfun.getTable(lower, upper, 1024, cfunRange);
+  cfunRange = cfunRange.filter((v, k) => k % 3 === 0);
+  const cfunDomain = [...Array(1024).keys()].map((v, k) => {
+    return lower + ((upper - lower) / (1024 - 1)) * k;
+  });
+  const y1 = cfunRange[256];
+  const logy1 = Math.log((1 - y1) / y1);
+  const x1 = cfunDomain[256];
+  const y2 = cfunRange[256 * 3];
+  const logy2 = Math.log((1 - y2) / y2);
+  const x2 = cfunDomain[256 * 3];
+  const ww = Math.round((4 * (x2 - x1)) / (logy1 - logy2));
+  const wc = Math.round(x1 + (ww * logy1) / 4);
+  return [Math.round(wc - ww / 2), Math.round(wc + ww / 2)];
+}

package/src/utilities/getVolumeActorCorners.ts

@@ -0,0 +1,24 @@
+import { Point3 } from '../types';
+
+/**
+ * Converts `vtkVolumeActor` bounds to corners in world space.
+ *
+ * @param volumeActor - The `vtkVolumeActor`.
+ *
+ * @returns An array of the corners of the `volumeActor` in world space.
+ */
+export default function getVolumeActorCorners(volumeActor): Array<Point3> {
+  const imageData = volumeActor.getMapper().getInputData();
+  const bounds = imageData.extentToBounds(imageData.getExtent());
+
+  return [
+    [bounds[0], bounds[2], bounds[4]],
+    [bounds[0], bounds[2], bounds[5]],
+    [bounds[0], bounds[3], bounds[4]],
+    [bounds[0], bounds[3], bounds[5]],
+    [bounds[1], bounds[2], bounds[4]],
+    [bounds[1], bounds[2], bounds[5]],
+    [bounds[1], bounds[3], bounds[4]],
+    [bounds[1], bounds[3], bounds[5]],
+  ];
+}

package/src/utilities/getVolumeSliceRangeInfo.ts

@@ -0,0 +1,52 @@
+import getSliceRange from './getSliceRange';
+import getTargetVolumeAndSpacingInNormalDir from './getTargetVolumeAndSpacingInNormalDir';
+import {
+  ActorSliceRange,
+  IVolumeViewport,
+  ICamera,
+  VolumeActor,
+} from '../types';
+
+/**
+ * Calculates the slice range for the given volume based on its orientation
+ * @param viewport - Volume viewport
+ * @param volumeId - Id of one of the volumes loaded on the given viewport
+ * @returns slice range information
+ */
+function getVolumeSliceRangeInfo(
+  viewport: IVolumeViewport,
+  volumeId: string
+): {
+  sliceRange: ActorSliceRange;
+  spacingInNormalDirection: number;
+  camera: ICamera;
+} {
+  const camera = viewport.getCamera();
+  const { focalPoint, viewPlaneNormal } = camera;
+  const { spacingInNormalDirection, actorUID } =
+    getTargetVolumeAndSpacingInNormalDir(viewport, camera, volumeId);
+
+  if (!actorUID) {
+    throw new Error(
+      `Could not find image volume with id ${volumeId} in the viewport`
+    );
+  }
+
+  const actorEntry = viewport.getActor(actorUID);
+
+  if (!actorEntry) {
+    console.warn('No actor found for with actorUID of', actorUID);
+    return null;
+  }
+
+  const volumeActor = actorEntry.actor as VolumeActor;
+  const sliceRange = getSliceRange(volumeActor, viewPlaneNormal, focalPoint);
+
+  return {
+    sliceRange,
+    spacingInNormalDirection,
+    camera,
+  };
+}
+
+export default getVolumeSliceRangeInfo;

package/src/utilities/getVolumeViewportScrollInfo.ts

@@ -0,0 +1,32 @@
+import { IVolumeViewport } from '../types';
+import getVolumeSliceRangeInfo from './getVolumeSliceRangeInfo';
+
+/**
+ * Calculates the number os steps the volume can scroll based on its orientation
+ * @param viewport - Volume viewport
+ * @param volumeId - Id of one of the volumes loaded on the given viewport
+ * @returns number of steps the volume can scroll and its current position
+ */
+function getVolumeViewportScrollInfo(
+  viewport: IVolumeViewport,
+  volumeId: string
+) {
+  const { sliceRange, spacingInNormalDirection } = getVolumeSliceRangeInfo(
+    viewport,
+    volumeId
+  );
+
+  const { min, max, current } = sliceRange;
+
+  // Now we can see how many steps there are in this direction
+  const numScrollSteps = Math.round((max - min) / spacingInNormalDirection);
+
+  // Find out current frameIndex
+  const fraction = (current - min) / (max - min);
+  const floatingStepNumber = fraction * numScrollSteps;
+  const currentStepIndex = Math.round(floatingStepNumber);
+
+  return { numScrollSteps, currentStepIndex };
+}
+
+export default getVolumeViewportScrollInfo;

package/src/utilities/getVolumeViewportsContainingSameVolumes.ts

@@ -0,0 +1,58 @@
+import { IVolumeViewport } from '../types';
+import {
+  getRenderingEngines,
+  getRenderingEngine,
+} from '../RenderingEngine/getRenderingEngine';
+
+/**
+ * Returns the viewports containing the same volume actors (all actors) the same
+ * as the target viewport. If renderingEngineId is provided, it will only return
+ * viewports that are associated with the renderingEngineId; otherwise, it will
+ * return search in all rendering engines.
+ *
+ * This method is useful for finding viewports that are associated with the same
+ * volume (e.g., for tools that share state between viewports).
+ *
+ * @param viewport - target viewport
+ * @returns array of viewports that have the same volume actor as the target viewport
+ */
+function getVolumeViewportsContainingSameVolumes(
+  targetViewport: IVolumeViewport,
+  renderingEngineId?: string
+): Array<IVolumeViewport> {
+  // If rendering engine is not provided, use all rendering engines
+  let renderingEngines;
+  if (renderingEngineId) {
+    renderingEngines = [getRenderingEngine(renderingEngineId)];
+  } else {
+    renderingEngines = getRenderingEngines();
+  }
+
+  const sameVolumesViewports = [];
+
+  renderingEngines.forEach((renderingEngine) => {
+    const targetActors = targetViewport.getActors();
+    const viewports = renderingEngine.getVolumeViewports();
+
+    for (const vp of viewports) {
+      const vpActors = vp.getActors();
+
+      if (vpActors.length !== targetActors.length) {
+        continue;
+      }
+
+      // every targetActors should be in the vpActors
+      const sameVolumes = targetActors.every(({ uid }) =>
+        vpActors.find((vpActor) => uid === vpActor.uid)
+      );
+
+      if (sameVolumes) {
+        sameVolumesViewports.push(vp);
+      }
+    }
+  });
+
+  return sameVolumesViewports;
+}
+
+export default getVolumeViewportsContainingSameVolumes;

package/src/utilities/hasNaNValues.ts

@@ -0,0 +1,12 @@
+/**
+ * A function that checks if there is a value in the array that is NaN.
+ * or if the input is a number it just checks if it is NaN.
+ * @param input - The input to check if it is NaN.
+ * @returns - True if the input is NaN, false otherwise.
+ */
+export default function hasNaNValues(input: number[] | number): boolean {
+  if (Array.isArray(input)) {
+    return input.some((value) => Number.isNaN(value));
+  }
+  return Number.isNaN(input);
+}

package/src/utilities/imageIdToURI.ts

@@ -0,0 +1,10 @@
+/**
+ * Removes the data loader scheme from the imageId
+ *
+ * @param imageId - Image ID
+ * @returns imageId without the data loader scheme
+ */
+export default function imageIdToURI(imageId: string): string {
+  const colonIndex = imageId.indexOf(':');
+  return imageId.substring(colonIndex + 1);
+}

package/src/utilities/imageToWorldCoords.ts

@@ -0,0 +1,54 @@
+import { vec3 } from 'gl-matrix';
+import { metaData } from '..';
+import { Point2, Point3 } from '../types';
+
+/**
+ * Given the imageId and a 2d coordinates on the image space with [0,0] being the top left corner
+ * of the top left pixel, and options which includes the imageId, it returns the
+ * 3d coordinates on the world space.
+ * @param imageId - The image id
+ * @param imageCoords - The 2d coordinates on the image
+ * @returns The 3d coordinates on the world.
+ *
+ */
+export default function imageToWorldCoords(
+  imageId: string,
+  imageCoords: Point2
+): Point3 | undefined {
+  const imagePlaneModule = metaData.get('imagePlaneModule', imageId);
+
+  if (!imagePlaneModule) {
+    throw new Error(`No imagePlaneModule found for imageId: ${imageId}`);
+  }
+
+  const {
+    columnCosines,
+    columnPixelSpacing,
+    rowCosines,
+    rowPixelSpacing,
+    imagePositionPatient: origin,
+  } = imagePlaneModule;
+
+  // calculate the image coordinates in the world space
+  const imageCoordsInWorld = vec3.create();
+
+  // move from origin in the direction of the row cosines with the amount of
+  // row pixel spacing times the first element of the image coordinates vector
+  vec3.scaleAndAdd(
+    imageCoordsInWorld,
+    origin,
+    rowCosines,
+    // to accommodate the [0,0] being on the top left corner of the top left pixel
+    // but the origin is at the center of the top left pixel
+    rowPixelSpacing * (imageCoords[0] - 0.5)
+  );
+
+  vec3.scaleAndAdd(
+    imageCoordsInWorld,
+    imageCoordsInWorld,
+    columnCosines,
+    columnPixelSpacing * (imageCoords[1] - 0.5)
+  );
+
+  return Array.from(imageCoordsInWorld) as Point3;
+}

package/src/utilities/index.ts

@@ -0,0 +1,100 @@
+import csUtils from './invertRgbTransferFunction';
+import createSigmoidRGBTransferFunction from './createSigmoidRGBTransferFunction';
+import getVoiFromSigmoidRGBTransferFunction from './getVoiFromSigmoidRGBTransferFunction';
+import createLinearRGBTransferFunction from './createLinearRGBTransferFunction';
+import scaleRgbTransferFunction from './scaleRgbTransferFunction';
+import triggerEvent from './triggerEvent';
+import uuidv4 from './uuidv4';
+import getMinMax from './getMinMax';
+import getRuntimeId from './getRuntimeId';
+import imageIdToURI from './imageIdToURI';
+import calibratedPixelSpacingMetadataProvider from './calibratedPixelSpacingMetadataProvider';
+import isEqual from './isEqual';
+import isOpposite from './isOpposite';
+import createUint8SharedArray from './createUint8SharedArray';
+import createFloat32SharedArray from './createFloat32SharedArray';
+import createUint16SharedArray from './createUInt16SharedArray';
+import createInt16SharedArray from './createInt16SharedArray';
+import getClosestImageId from './getClosestImageId';
+import getSpacingInNormalDirection from './getSpacingInNormalDirection';
+import getTargetVolumeAndSpacingInNormalDir from './getTargetVolumeAndSpacingInNormalDir';
+import getVolumeActorCorners from './getVolumeActorCorners';
+import indexWithinDimensions from './indexWithinDimensions';
+import getVolumeViewportsContainingSameVolumes from './getVolumeViewportsContainingSameVolumes';
+import getViewportsWithVolumeId from './getViewportsWithVolumeId';
+import transformWorldToIndex from './transformWorldToIndex';
+import loadImageToCanvas from './loadImageToCanvas';
+import renderToCanvas from './renderToCanvas';
+import worldToImageCoords from './worldToImageCoords';
+import imageToWorldCoords from './imageToWorldCoords';
+import getVolumeSliceRangeInfo from './getVolumeSliceRangeInfo';
+import getVolumeViewportScrollInfo from './getVolumeViewportScrollInfo';
+import getSliceRange from './getSliceRange';
+import snapFocalPointToSlice from './snapFocalPointToSlice';
+import getImageSliceDataForVolumeViewport from './getImageSliceDataForVolumeViewport';
+import { isImageActor, actorIsA } from './actorCheck';
+import getViewportsWithImageURI from './getViewportsWithImageURI';
+import getClosestStackImageIndexForPoint from './getClosestStackImageIndexForPoint';
+import calculateViewportsSpatialRegistration from './calculateViewportsSpatialRegistration';
+import spatialRegistrationMetadataProvider from './spatialRegistrationMetadataProvider';
+import getViewportImageCornersInWorld from './getViewportImageCornersInWorld';
+import hasNaNValues from './hasNaNValues';
+import applyPreset from './applyPreset';
+import deepMerge from './deepMerge';
+import getScalingParameters from './getScalingParameters';
+import getScalarDataType from './getScalarDataType';
+
+// name spaces
+import * as planar from './planar';
+import * as windowLevel from './windowLevel';
+
+export {
+  csUtils as invertRgbTransferFunction,
+  createSigmoidRGBTransferFunction,
+  getVoiFromSigmoidRGBTransferFunction,
+  createLinearRGBTransferFunction,
+  scaleRgbTransferFunction,
+  triggerEvent,
+  imageIdToURI,
+  calibratedPixelSpacingMetadataProvider,
+  uuidv4,
+  planar,
+  getMinMax,
+  getRuntimeId,
+  isEqual,
+  isOpposite,
+  createFloat32SharedArray,
+  createUint8SharedArray,
+  createUint16SharedArray,
+  createInt16SharedArray,
+  windowLevel,
+  getClosestImageId,
+  getSpacingInNormalDirection,
+  getTargetVolumeAndSpacingInNormalDir,
+  getVolumeActorCorners,
+  indexWithinDimensions,
+  getVolumeViewportsContainingSameVolumes,
+  getViewportsWithVolumeId,
+  transformWorldToIndex,
+  loadImageToCanvas,
+  renderToCanvas,
+  worldToImageCoords,
+  imageToWorldCoords,
+  getVolumeSliceRangeInfo,
+  getVolumeViewportScrollInfo,
+  getSliceRange,
+  snapFocalPointToSlice,
+  getImageSliceDataForVolumeViewport,
+  isImageActor,
+  actorIsA,
+  getViewportsWithImageURI,
+  getClosestStackImageIndexForPoint,
+  calculateViewportsSpatialRegistration,
+  spatialRegistrationMetadataProvider,
+  getViewportImageCornersInWorld,
+  hasNaNValues,
+  applyPreset,
+  deepMerge,
+  getScalingParameters,
+  getScalarDataType,
+};

package/src/utilities/indexWithinDimensions.ts

@@ -0,0 +1,27 @@
+import { Point3 } from '../types';
+
+/**
+ * Returns true if the specified index is within the given dimensions.
+ *
+ * @param index - The index to check.
+ * @param dimensions - The dimensions to check against.
+ *
+ * @returns True if the index is in-bounds.
+ */
+export default function indexWithinDimensions(
+  index: Point3,
+  dimensions: Point3
+): boolean {
+  if (
+    index[0] < 0 ||
+    index[0] >= dimensions[0] ||
+    index[1] < 0 ||
+    index[1] >= dimensions[1] ||
+    index[2] < 0 ||
+    index[2] >= dimensions[2]
+  ) {
+    return false;
+  }
+
+  return true;
+}

package/src/utilities/invertRgbTransferFunction.ts

@@ -0,0 +1,36 @@
+/**
+ * A utility that can be used to invert (in place) an RgbTransferFunction.
+ *
+ * @example
+ * Grabbing a reference to the RGB Transfer function from the viewport:
+ * ```
+ * const rgbTransferFunction = viewport
+ *   .getActor()
+ *   .getProperty()
+ *   .getRGBTransferFunction(0);
+ *
+ * rgbTransferFunction.setRange(0, 5);
+ *
+ * invertRgbTransferFunction(rgbTransferFunction);
+ * ```
+ *
+ * @see {@link https://kitware.github.io/vtk-js/api/Rendering_Core_ColorTransferFunction.html|VTK.js: ColorTransferFunction}
+ * @param rgbTransferFunction
+ */
+export default function invertRgbTransferFunction(
+  rgbTransferFunction: any
+): void {
+  const size = rgbTransferFunction.getSize();
+
+  for (let index = 0; index < size; index++) {
+    const nodeValue1 = [];
+
+    rgbTransferFunction.getNodeValue(index, nodeValue1);
+
+    nodeValue1[1] = 1 - nodeValue1[1];
+    nodeValue1[2] = 1 - nodeValue1[2];
+    nodeValue1[3] = 1 - nodeValue1[3];
+
+    rgbTransferFunction.setNodeValue(index, nodeValue1);
+  }
+}

package/src/utilities/isEqual.ts

@@ -0,0 +1,27 @@
+/**
+ * returns equal if the two arrays are identical within the
+ * given tolerance.
+ *
+ * @param v1 - The first array of values
+ * @param v2 - The second array of values.
+ * @param tolerance - The acceptable tolerance, the default is 0.00001
+ *
+ * @returns True if the two values are within the tolerance levels.
+ */
+export default function isEqual(
+  v1: number[] | Float32Array,
+  v2: number[] | Float32Array,
+  tolerance = 1e-5
+): boolean {
+  if (v1.length !== v2.length) {
+    return false;
+  }
+
+  for (let i = 0; i < v1.length; i++) {
+    if (Math.abs(v1[i] - v2[i]) > tolerance) {
+      return false;
+    }
+  }
+
+  return true;
+}

package/src/utilities/isOpposite.ts

@@ -0,0 +1,23 @@
+import type Point3 from '../types/Point3';
+
+/**
+ * returns equal if the two vec3s are opposite within the
+ * given tolerance in each dimension.
+ *
+ * @param v1 - The first 3 vector
+ * @param v2 - The second 3 vector.
+ * @param tolerance - The acceptable tolerance.
+ *
+ * @returns True if the two values are within the tolerance levels.
+ */
+export default function isOpposite(
+  v1: Point3,
+  v2: Point3,
+  tolerance = 1e-5
+): boolean {
+  return (
+    Math.abs(v1[0] + v2[0]) < tolerance &&
+    Math.abs(v1[1] + v2[1]) < tolerance &&
+    Math.abs(v1[2] + v2[2]) < tolerance
+  );
+}