@cornerstonejs/tools 0.56.1 → 0.56.3

package/src/utilities/viewportFilters/filterViewportsWithParallelNormals.ts

@@ -0,0 +1,26 @@
+import { vec3 } from 'gl-matrix';
+
+/**
+ * It filters the viewports that are looking in the same view as the camera
+ * It basically checks if the viewPlaneNormal is parallel to the camera viewPlaneNormal
+ * @param viewports - Array of viewports to filter
+ * @param camera - Camera to compare against
+ * @returns - Array of viewports with the same view
+ */
+export function filterViewportsWithParallelNormals(
+  viewports,
+  camera,
+  EPS = 0.999
+) {
+  return viewports.filter((viewport) => {
+    const vpCamera = viewport.getCamera();
+
+    const isParallel =
+      Math.abs(vec3.dot(vpCamera.viewPlaneNormal, camera.viewPlaneNormal)) >
+      EPS;
+
+    return isParallel;
+  });
+}
+
+export default filterViewportsWithParallelNormals;

package/src/utilities/viewportFilters/filterViewportsWithSameOrientation.ts

@@ -0,0 +1,15 @@
+import { utilities as csUtils } from '@cornerstonejs/core';
+
+export function filterViewportsWithSameOrientation(viewports, camera) {
+  return viewports.filter((viewport) => {
+    const vpCamera = viewport.getCamera();
+
+    // TODO: do we need any other checks, or is this sufficient?
+    return (
+      csUtils.isEqual(vpCamera.viewPlaneNormal, camera.viewPlaneNormal) &&
+      csUtils.isEqual(vpCamera.viewUp, camera.viewUp)
+    );
+  });
+}
+
+export default filterViewportsWithSameOrientation;

package/src/utilities/viewportFilters/filterViewportsWithToolEnabled.ts

@@ -0,0 +1,72 @@
+import type { Types } from '@cornerstonejs/core';
+import type { IToolGroup } from '../../types';
+import { ToolGroupManager } from '../../store';
+import { ToolModes } from '../../enums';
+
+const { Active, Passive, Enabled } = ToolModes;
+
+/**
+ * Given an array of viewports, returns a list of viewports that have the the specified tool enabled.
+ *
+ * @param viewports - An array of viewports.
+ * @param toolName - The name of the tool to filter on.
+ *
+ * @returns A filtered array of viewports.
+ */
+export default function filterViewportsWithToolEnabled(
+  viewports: Array<Types.IStackViewport | Types.IVolumeViewport>,
+  toolName: string
+): Array<Types.IStackViewport | Types.IVolumeViewport> {
+  const numViewports = viewports.length;
+
+  const viewportsWithToolEnabled = [];
+
+  for (let vp = 0; vp < numViewports; vp++) {
+    const viewport = viewports[vp];
+
+    const toolGroup = ToolGroupManager.getToolGroupForViewport(
+      viewport.id,
+      viewport.renderingEngineId
+    );
+
+    if (!toolGroup) {
+      continue;
+    }
+
+    const hasTool = _toolGroupHasActiveEnabledOrPassiveTool(
+      toolGroup,
+      toolName
+    );
+
+    if (hasTool) {
+      viewportsWithToolEnabled.push(viewport);
+    }
+  }
+
+  return viewportsWithToolEnabled;
+}
+
+/**
+ * Given a toolGroup, return true if it contains the tool with the given `toolName` and it is
+ * active, passive or enabled.
+ *
+ * @param toolGroup - The `toolGroup` to check.
+ * @param toolName - The name of the tool.
+ *
+ * @returns True if the tool is enabled, passive or active in the `toolGroup`.
+ */
+function _toolGroupHasActiveEnabledOrPassiveTool(
+  toolGroup: IToolGroup,
+  toolName: string
+) {
+  const { toolOptions } = toolGroup;
+  const tool = toolOptions[toolName];
+
+  if (!tool) {
+    return false;
+  }
+
+  const toolMode = tool.mode;
+
+  return toolMode === Active || toolMode === Passive || toolMode === Enabled;
+}

package/src/utilities/viewportFilters/getViewportIdsWithToolToRender.ts

@@ -0,0 +1,45 @@
+import { getEnabledElement } from '@cornerstonejs/core';
+import filterViewportsWithFrameOfReferenceUID from './filterViewportsWithFrameOfReferenceUID';
+import filterViewportsWithToolEnabled from './filterViewportsWithToolEnabled';
+import filterViewportsWithParallelNormals from './filterViewportsWithParallelNormals';
+
+/**
+ * Given a cornerstone3D enabled `element`, and a `toolName`, find all viewportIds
+ * looking at the same Frame Of Reference that have the tool with the given `toolName`
+ * active, passive or enabled.
+ *
+ * @param element - The target cornerstone3D enabled element.
+ * @param toolName - The string toolName.
+ * @param requireParallelNormals - If true, only return viewports that have parallel normals.
+ *
+ * @returns An array of viewportIds.
+ */
+export default function getViewportIdsWithToolToRender(
+  element: HTMLDivElement,
+  toolName: string,
+  requireParallelNormals = true
+): string[] {
+  const enabledElement = getEnabledElement(element);
+  const { renderingEngine, FrameOfReferenceUID } = enabledElement;
+
+  let viewports = renderingEngine.getViewports();
+
+  viewports = filterViewportsWithFrameOfReferenceUID(
+    viewports,
+    FrameOfReferenceUID
+  );
+  viewports = filterViewportsWithToolEnabled(viewports, toolName);
+
+  const viewport = renderingEngine.getViewport(enabledElement.viewportId);
+
+  if (requireParallelNormals) {
+    viewports = filterViewportsWithParallelNormals(
+      viewports,
+      viewport.getCamera()
+    );
+  }
+
+  const viewportIds = viewports.map((vp) => vp.id);
+
+  return viewportIds;
+}

package/src/utilities/viewportFilters/index.ts

@@ -0,0 +1,11 @@
+import filterViewportsWithFrameOfReferenceUID from './filterViewportsWithFrameOfReferenceUID';
+import filterViewportsWithToolEnabled from './filterViewportsWithToolEnabled';
+import getViewportIdsWithToolToRender from './getViewportIdsWithToolToRender';
+import filterViewportsWithParallelNormals from './filterViewportsWithParallelNormals';
+
+export {
+  filterViewportsWithToolEnabled,
+  filterViewportsWithFrameOfReferenceUID,
+  getViewportIdsWithToolToRender,
+  filterViewportsWithParallelNormals,
+};