@cornerstonejs/tools 2.0.0-beta.1 → 2.0.0-beta.3

package/src/tools/annotation/RectangleROITool.ts

@@ -45,7 +45,6 @@ import {
   TextBoxHandle,
   ToolProps,
   PublicToolProps,
-  InteractionTypes,
   SVGDrawingHelper,
 } from '../../types';
 import { RectangleROIAnnotation } from '../../types/ToolSpecificAnnotationTypes';
@@ -56,6 +55,8 @@ import {
 import { StyleSpecifier } from '../../types/AnnotationStyle';
 import { getModalityUnit } from '../../utilities/getModalityUnit';
 import { isViewportPreScaled } from '../../utilities/viewport/isViewportPreScaled';
+import { pointInShapeCallback } from '../../utilities/';
+import { BasicStatsCalculator } from '../../utilities/math/basic';
 
 const { transformWorldToIndex } = csUtils;
 
@@ -97,6 +98,7 @@ const { transformWorldToIndex } = csUtils;
  *
  * Read more in the Docs section of the website.
  */
+
 class RectangleROITool extends AnnotationTool {
   static toolName;
 
@@ -119,6 +121,8 @@ class RectangleROITool extends AnnotationTool {
       configuration: {
         shadow: true,
         preventHandleOutsideImage: false,
+        getTextLines: defaultGetTextLines,
+        statsCalculator: BasicStatsCalculator,
       },
     }
   ) {
@@ -654,21 +658,11 @@ class RectangleROITool extends AnnotationTool {
 
       const { viewPlaneNormal, viewUp } = viewport.getCamera();
 
-      const modalityUnitOptions = {
-        isPreScaled: isViewportPreScaled(viewport, targetId),
-
-        isSuvScaled: this.isSuvScaled(
-          viewport,
-          targetId,
-          annotation.metadata.referencedImageId
-        ),
-      };
-
       // If cachedStats does not exist, or the unit is missing (as part of import/hydration etc.),
       // force to recalculate the stats from the points
       if (
         !data.cachedStats[targetId] ||
-        data.cachedStats[targetId].areaUnit === undefined
+        data.cachedStats[targetId].areaUnit == null
       ) {
         data.cachedStats[targetId] = {
           Modality: null,
@@ -684,8 +678,7 @@ class RectangleROITool extends AnnotationTool {
           viewPlaneNormal,
           viewUp,
           renderingEngine,
-          enabledElement,
-          modalityUnitOptions
+          enabledElement
         );
       } else if (annotation.invalidated) {
         this._throttledCalculateCachedStats(
@@ -693,8 +686,7 @@ class RectangleROITool extends AnnotationTool {
           viewPlaneNormal,
           viewUp,
           renderingEngine,
-          enabledElement,
-          modalityUnitOptions
+          enabledElement
         );
 
         // If the invalidated data is as a result of volumeViewport manipulation
@@ -786,7 +778,22 @@ class RectangleROITool extends AnnotationTool {
 
       renderStatus = true;
 
-      const textLines = this._getTextLines(data, targetId);
+      const options = this.getLinkedTextBoxStyle(styleSpecifier, annotation);
+      if (!options.visibility) {
+        data.handles.textBox = {
+          hasMoved: false,
+          worldPosition: <Types.Point3>[0, 0, 0],
+          worldBoundingBox: {
+            topLeft: <Types.Point3>[0, 0, 0],
+            topRight: <Types.Point3>[0, 0, 0],
+            bottomLeft: <Types.Point3>[0, 0, 0],
+            bottomRight: <Types.Point3>[0, 0, 0],
+          },
+        };
+        continue;
+      }
+
+      const textLines = this.configuration.getTextLines(data, targetId);
       if (!textLines || textLines.length === 0) {
         continue;
       }
@@ -811,7 +818,7 @@ class RectangleROITool extends AnnotationTool {
         textBoxPosition,
         canvasCoordinates,
         {},
-        this.getLinkedTextBoxStyle(styleSpecifier, annotation)
+        options
       );
 
       const { x: left, y: top, width, height } = boundingBox;
@@ -845,33 +852,6 @@ class RectangleROITool extends AnnotationTool {
     };
   };
 
-  /**
-   * _getTextLines - Returns the Area, mean and std deviation of the area of the
-   * target volume enclosed by the rectangle.
-   *
-   * @param data - The annotation tool-specific data.
-   * @param targetId - The volumeId of the volume to display the stats for.
-   * @param isPreScaled - Whether the viewport is pre-scaled or not.
-   */
-  _getTextLines = (data, targetId: string): string[] | undefined => {
-    const cachedVolumeStats = data.cachedStats[targetId];
-    const { area, mean, max, stdDev, areaUnit, modalityUnit } =
-      cachedVolumeStats;
-
-    if (mean === undefined) {
-      return;
-    }
-
-    const textLines: string[] = [];
-
-    textLines.push(`Area: ${roundNumber(area)} ${areaUnit}`);
-    textLines.push(`Mean: ${roundNumber(mean)} ${modalityUnit}`);
-    textLines.push(`Max: ${roundNumber(max)} ${modalityUnit}`);
-    textLines.push(`Std Dev: ${roundNumber(stdDev)} ${modalityUnit}`);
-
-    return textLines;
-  };
-
   /**
    * _calculateCachedStats - For each volume in the frame of reference that a
    * tool instance in particular viewport defines as its target volume, find the
@@ -888,11 +868,10 @@ class RectangleROITool extends AnnotationTool {
     viewPlaneNormal,
     viewUp,
     renderingEngine,
-    enabledElement,
-    modalityUnitOptions
+    enabledElement
   ) => {
     const { data } = annotation;
-    const { viewportId, renderingEngineId } = enabledElement;
+    const { viewportId, renderingEngineId, viewport } = enabledElement;
 
     const worldPos1 = data.handles.points[0];
     const worldPos2 = data.handles.points[3];
@@ -945,6 +924,12 @@ class RectangleROITool extends AnnotationTool {
         const kMin = Math.min(worldPos1Index[2], worldPos2Index[2]);
         const kMax = Math.max(worldPos1Index[2], worldPos2Index[2]);
 
+        const boundsIJK = [
+          [iMin, iMax],
+          [jMin, jMax],
+          [kMin, kMax],
+        ] as [Types.Point2, Types.Point2, Types.Point2];
+
         const { worldWidth, worldHeight } = getWorldWidthAndHeightFromCorners(
           viewPlaneNormal,
           viewUp,
@@ -955,48 +940,15 @@ class RectangleROITool extends AnnotationTool {
 
         const area = Math.abs(worldWidth * worldHeight) / (scale * scale);
 
-        let count = 0;
-        let mean = 0;
-        let stdDev = 0;
-        let max = -Infinity;
+        const modalityUnitOptions = {
+          isPreScaled: isViewportPreScaled(viewport, targetId),
 
-        const yMultiple = dimensions[0];
-        const zMultiple = dimensions[0] * dimensions[1];
-
-        //Todo: this can be replaced by pointInShapeCallback....
-        // This is a triple loop, but one of these 3 values will be constant
-        // In the planar view.
-        for (let k = kMin; k <= kMax; k++) {
-          for (let j = jMin; j <= jMax; j++) {
-            for (let i = iMin; i <= iMax; i++) {
-              const value = scalarData[k * zMultiple + j * yMultiple + i];
-
-              if (value > max) {
-                max = value;
-              }
-
-              count++;
-              mean += value;
-            }
-          }
-        }
-
-        mean /= count;
-
-        for (let k = kMin; k <= kMax; k++) {
-          for (let j = jMin; j <= jMax; j++) {
-            for (let i = iMin; i <= iMax; i++) {
-              const value = scalarData[k * zMultiple + j * yMultiple + i];
-
-              const valueMinusMean = value - mean;
-
-              stdDev += valueMinusMean * valueMinusMean;
-            }
-          }
-        }
-
-        stdDev /= count;
-        stdDev = Math.sqrt(stdDev);
+          isSuvScaled: this.isSuvScaled(
+            viewport,
+            targetId,
+            annotation.metadata.referencedImageId
+          ),
+        };
 
         const modalityUnit = getModalityUnit(
           metadata.Modality,
@@ -1004,12 +956,23 @@ class RectangleROITool extends AnnotationTool {
           modalityUnitOptions
         );
 
+        const pointsInShape = pointInShapeCallback(
+          imageData,
+          () => true,
+          this.configuration.statsCalculator.statsCallback,
+          boundsIJK
+        );
+
+        const stats = this.configuration.statsCalculator.getStatistics();
+
         cachedStats[targetId] = {
           Modality: metadata.Modality,
           area,
-          mean,
-          stdDev,
-          max,
+          mean: stats[1]?.value,
+          stdDev: stats[2]?.value,
+          max: stats[0]?.value,
+          statsArray: stats,
+          pointsInShape: pointsInShape,
           areaUnit: getCalibratedAreaUnits(null, image),
           modalityUnit,
         };
@@ -1044,5 +1007,30 @@ class RectangleROITool extends AnnotationTool {
   };
 }
 
+/**
+ * _getTextLines - Returns the Area, mean and std deviation of the area of the
+ * target volume enclosed by the rectangle.
+ *
+ * @param data - The annotation tool-specific data.
+ * @param targetId - The volumeId of the volume to display the stats for.
+ */
+function defaultGetTextLines(data, targetId: string): string[] {
+  const cachedVolumeStats = data.cachedStats[targetId];
+  const { area, mean, max, stdDev, areaUnit, modalityUnit } = cachedVolumeStats;
+
+  if (mean === undefined) {
+    return;
+  }
+
+  const textLines: string[] = [];
+
+  textLines.push(`Area: ${roundNumber(area)} ${areaUnit}`);
+  textLines.push(`Mean: ${roundNumber(mean)} ${modalityUnit}`);
+  textLines.push(`Max: ${roundNumber(max)} ${modalityUnit}`);
+  textLines.push(`Std Dev: ${roundNumber(stdDev)} ${modalityUnit}`);
+
+  return textLines;
+}
+
 RectangleROITool.toolName = 'RectangleROI';
 export default RectangleROITool;

package/src/tools/base/AnnotationDisplayTool.ts

@@ -102,6 +102,10 @@ abstract class AnnotationDisplayTool extends BaseTool {
 
       // for this specific tool
       toolSpecificAnnotations.forEach((annotation) => {
+        if (!annotation.metadata?.referencedImageId) {
+          return;
+        }
+
         // if the annotation is drawn on the same imageId
         const referencedImageURI = utilities.imageIdToURI(
           annotation.metadata.referencedImageId

package/src/tools/base/AnnotationTool.ts

@@ -18,10 +18,12 @@ import {
   EventTypes,
   ToolHandle,
   InteractionTypes,
+  ToolProps,
+  PublicToolProps,
 } from '../../types';
 import { StyleSpecifier } from '../../types/AnnotationStyle';
 
-/**
+/**-q
  * Abstract class for tools which create and display annotations on the
  * cornerstone3D canvas. In addition, it provides a base class for segmentation
  * tools that require drawing an annotation before running the segmentation strategy
@@ -37,6 +39,19 @@ abstract class AnnotationTool extends AnnotationDisplayTool {
   // Abstract Methods - Must be implemented.
   // ===================================================================
 
+  constructor(toolProps: PublicToolProps, defaultToolProps: ToolProps) {
+    super(toolProps, defaultToolProps);
+
+    if (toolProps.configuration?.getTextLines) {
+      this.configuration.getTextLines = toolProps.configuration.getTextLines;
+    }
+
+    if (toolProps.configuration?.statsCalculator) {
+      this.configuration.statsCalculator =
+        toolProps.configuration.statsCalculator;
+    }
+  }
+
   /**
    * @abstract addNewAnnotation Creates a new annotation based on the clicked mouse position
    *
@@ -79,7 +94,8 @@ abstract class AnnotationTool extends AnnotationDisplayTool {
   abstract toolSelectedCallback(
     evt: EventTypes.InteractionEventType,
     annotation: Annotation,
-    interactionType: InteractionTypes
+    interactionType: InteractionTypes,
+    canvasCoords?: Types.Point2
   ): void;
 
   /**
@@ -185,24 +201,26 @@ abstract class AnnotationTool extends AnnotationDisplayTool {
 
     const { data } = annotation;
     const { points, textBox } = data.handles;
-    const { worldBoundingBox } = textBox;
 
-    if (worldBoundingBox) {
-      const canvasBoundingBox = {
-        topLeft: viewport.worldToCanvas(worldBoundingBox.topLeft),
-        topRight: viewport.worldToCanvas(worldBoundingBox.topRight),
-        bottomLeft: viewport.worldToCanvas(worldBoundingBox.bottomLeft),
-        bottomRight: viewport.worldToCanvas(worldBoundingBox.bottomRight),
-      };
+    if (textBox) {
+      const { worldBoundingBox } = textBox;
+      if (worldBoundingBox) {
+        const canvasBoundingBox = {
+          topLeft: viewport.worldToCanvas(worldBoundingBox.topLeft),
+          topRight: viewport.worldToCanvas(worldBoundingBox.topRight),
+          bottomLeft: viewport.worldToCanvas(worldBoundingBox.bottomLeft),
+          bottomRight: viewport.worldToCanvas(worldBoundingBox.bottomRight),
+        };
 
-      if (
-        canvasCoords[0] >= canvasBoundingBox.topLeft[0] &&
-        canvasCoords[0] <= canvasBoundingBox.bottomRight[0] &&
-        canvasCoords[1] >= canvasBoundingBox.topLeft[1] &&
-        canvasCoords[1] <= canvasBoundingBox.bottomRight[1]
-      ) {
-        data.handles.activeHandleIndex = null;
-        return textBox;
+        if (
+          canvasCoords[0] >= canvasBoundingBox.topLeft[0] &&
+          canvasCoords[0] <= canvasBoundingBox.bottomRight[0] &&
+          canvasCoords[1] >= canvasBoundingBox.topLeft[1] &&
+          canvasCoords[1] <= canvasBoundingBox.bottomRight[1]
+        ) {
+          data.handles.activeHandleIndex = null;
+          return textBox;
+        }
       }
     }
 
@@ -240,6 +258,11 @@ abstract class AnnotationTool extends AnnotationDisplayTool {
     // for the textBox.
 
     return {
+      visibility: this.getStyle(
+        'textBoxVisibility',
+        specifications,
+        annotation
+      ),
       fontFamily: this.getStyle(
         'textBoxFontFamily',
         specifications,

package/src/tools/base/index.ts

@@ -1,4 +1,5 @@
 import BaseTool from './BaseTool';
 import AnnotationTool from './AnnotationTool';
+import AnnotationDisplayTool from './AnnotationDisplayTool';
 
-export { BaseTool, AnnotationTool };
+export { BaseTool, AnnotationTool, AnnotationDisplayTool };

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

@@ -2,6 +2,7 @@ import {
   getEnabledElementByIds,
   Types,
   utilities as csUtils,
+  StackViewport,
 } from '@cornerstonejs/core';
 
 import Representations from '../../../enums/SegmentationRepresentations';
@@ -128,6 +129,13 @@ async function render(
   const contourData = segmentation.representationData[Representations.Contour];
   const { geometryIds } = contourData;
 
+
+  // We don't have a good way to handle stack viewports for contours at the moment.
+  // Plus, if we add a segmentation to one viewport, it gets added to all the viewports in the toolGroup too.
+  if (viewport instanceof StackViewport) {
+    return;
+  }
+
   if (!geometryIds?.length) {
     console.warn(
       `No contours found for segmentationId ${segmentationId}. Skipping render.`

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

@@ -276,6 +276,9 @@ function _setLabelmapColorAndOpacity(
     isActiveLabelmap
   );
 
+  // Todo: the below loop probably can be optimized so that we don't hit it
+  // unless a config has changed. Right now we get into the following loop
+  // even for brush drawing which does not makes sense
   for (let i = 0; i < numColors; i++) {
     const segmentIndex = i;
     const segmentColor = colorLUT[segmentIndex];
@@ -413,7 +416,7 @@ function _needsTransferFunctionUpdate(
       renderFill,
       renderOutline,
       outlineWidth,
-      segmentColor,
+      segmentColor: segmentColor.slice(), // Create a copy
       segmentsHidden: new Set(segmentsHidden), // Create a copy
     });
 

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

@@ -1,4 +1,4 @@
-import { getEnabledElement } from '@cornerstonejs/core';
+import { StackViewport, getEnabledElement } from '@cornerstonejs/core';
 import type { Types } from '@cornerstonejs/core';
 
 /**
@@ -19,6 +19,11 @@ function removeLabelmapFromElement(
   const enabledElement = getEnabledElement(element);
   const { viewport } = enabledElement;
 
+  if (viewport instanceof StackViewport) {
+    // Todo: we don't have stack segmentation yet
+    return;
+  }
+
   (viewport as Types.IVolumeViewport).removeVolumeActors([
     segmentationRepresentationUID,
   ]);

package/src/tools/displayTools/SegmentationDisplayTool.ts

@@ -143,26 +143,20 @@ class SegmentationDisplayTool extends BaseTool {
         const config = this._getMergedRepresentationsConfig(toolGroupId);
 
         const viewportsRenderList = [];
+        const display =
+          representation.type === Representations.Labelmap
+            ? labelmapDisplay
+            : contourDisplay;
+
         for (const viewport of toolGroupViewports) {
-          if (representation.type == Representations.Labelmap) {
-            viewportsRenderList.push(
-              labelmapDisplay.render(
-                viewport as Types.IVolumeViewport,
-                representation,
-                config
-              )
-            );
-          } else if (representation.type == Representations.Contour) {
-            viewportsRenderList.push(
-              contourDisplay.render(
-                viewport as Types.IVolumeViewport,
-                representation,
-                config
-              )
-            );
-          }
-        }
+          const renderedViewport = display.render(
+            viewport as Types.IVolumeViewport,
+            representation,
+            config
+          );
 
+          viewportsRenderList.push(renderedViewport);
+        }
         return viewportsRenderList;
       }
     );

package/src/tools/index.ts

@@ -1,4 +1,4 @@
-import { BaseTool, AnnotationTool } from './base';
+import { BaseTool, AnnotationTool, AnnotationDisplayTool } from './base';
 import PanTool from './PanTool';
 import TrackballRotateTool from './TrackballRotateTool';
 import WindowLevelTool from './WindowLevelTool';
@@ -10,7 +10,9 @@ import VolumeRotateMouseWheelTool from './VolumeRotateMouseWheelTool';
 import MIPJumpToClickTool from './MIPJumpToClickTool';
 import CrosshairsTool from './CrosshairsTool';
 import MagnifyTool from './MagnifyTool';
+import AdvancedMagnifyTool from './AdvancedMagnifyTool';
 import ReferenceLinesTool from './ReferenceLinesTool';
+import OverlayGridTool from './OverlayGridTool';
 //
 import BidirectionalTool from './annotation/BidirectionalTool';
 import LengthTool from './annotation/LengthTool';
@@ -38,11 +40,13 @@ import RectangleROIThresholdTool from './segmentation/RectangleROIThresholdTool'
 import RectangleROIStartEndThresholdTool from './segmentation/RectangleROIStartEndThresholdTool';
 import BrushTool from './segmentation/BrushTool';
 import PaintFillTool from './segmentation/PaintFillTool';
+import OrientationMarkerTool from './OrientationMarkerTool';
 
 export {
   // ~~ BASE
   BaseTool,
   AnnotationTool,
+  AnnotationDisplayTool,
   // Manipulation Tools
   PanTool,
   TrackballRotateTool,
@@ -57,6 +61,7 @@ export {
   // Annotation Tools
   CrosshairsTool,
   ReferenceLinesTool,
+  OverlayGridTool,
   BidirectionalTool,
   LengthTool,
   ProbeTool,
@@ -78,7 +83,9 @@ export {
   RectangleROIStartEndThresholdTool,
   BrushTool,
   MagnifyTool,
+  AdvancedMagnifyTool,
   ReferenceLines,
   PaintFillTool,
   ScaleOverlayTool,
+  OrientationMarkerTool,
 };

package/src/tools/segmentation/BrushTool.ts

@@ -1,4 +1,5 @@
 import { cache, getEnabledElement, StackViewport } from '@cornerstonejs/core';
+import { vec3 } from 'gl-matrix';
 
 import type { Types } from '@cornerstonejs/core';
 import type {
@@ -8,7 +9,10 @@ import type {
   SVGDrawingHelper,
 } from '../../types';
 import { BaseTool } from '../base';
-import { fillInsideSphere } from './strategies/fillSphere';
+import {
+  fillInsideSphere,
+  thresholdInsideSphere,
+} from './strategies/fillSphere';
 import { eraseInsideSphere } from './strategies/eraseSphere';
 import {
   thresholdInsideCircle,
@@ -59,10 +63,11 @@ class BrushTool extends BaseTool {
       configuration: {
         strategies: {
           FILL_INSIDE_CIRCLE: fillInsideCircle,
-          THRESHOLD_INSIDE_CIRCLE: thresholdInsideCircle,
           ERASE_INSIDE_CIRCLE: eraseInsideCircle,
           FILL_INSIDE_SPHERE: fillInsideSphere,
           ERASE_INSIDE_SPHERE: eraseInsideSphere,
+          THRESHOLD_INSIDE_CIRCLE: thresholdInsideCircle,
+          THRESHOLD_INSIDE_SPHERE: thresholdInsideSphere,
         },
         strategySpecificConfiguration: {
           THRESHOLD_INSIDE_CIRCLE: {
@@ -277,24 +282,42 @@ class BrushTool extends BaseTool {
     const enabledElement = getEnabledElement(element);
     const { viewport } = enabledElement;
     const { canvasToWorld } = viewport;
+    const camera = viewport.getCamera();
     const { brushSize } = this.configuration;
-    // Center of circle in canvas Coordinates
 
-    const radius = brushSize;
+    const viewUp = vec3.fromValues(
+      camera.viewUp[0],
+      camera.viewUp[1],
+      camera.viewUp[2]
+    );
+    const viewPlaneNormal = vec3.fromValues(
+      camera.viewPlaneNormal[0],
+      camera.viewPlaneNormal[1],
+      camera.viewPlaneNormal[2]
+    );
+    const viewRight = vec3.create();
 
-    const bottomCanvas: Types.Point2 = [
+    vec3.cross(viewRight, viewUp, viewPlaneNormal);
+
+    // in the world coordinate system, the brushSize is the radius of the circle
+    // in mm
+    const centerCursorInWorld: Types.Point3 = canvasToWorld([
       centerCanvas[0],
-      centerCanvas[1] + radius,
-    ];
-    const topCanvas: Types.Point2 = [centerCanvas[0], centerCanvas[1] - radius];
-    const leftCanvas: Types.Point2 = [
-      centerCanvas[0] - radius,
-      centerCanvas[1],
-    ];
-    const rightCanvas: Types.Point2 = [
-      centerCanvas[0] + radius,
       centerCanvas[1],
-    ];
+    ]);
+
+    const bottomCursorInWorld = vec3.create();
+    const topCursorInWorld = vec3.create();
+    const leftCursorInWorld = vec3.create();
+    const rightCursorInWorld = vec3.create();
+
+    // Calculate the bottom and top points of the circle in world coordinates
+    for (let i = 0; i <= 2; i++) {
+      bottomCursorInWorld[i] = centerCursorInWorld[i] - viewUp[i] * brushSize;
+      topCursorInWorld[i] = centerCursorInWorld[i] + viewUp[i] * brushSize;
+      leftCursorInWorld[i] = centerCursorInWorld[i] - viewRight[i] * brushSize;
+      rightCursorInWorld[i] = centerCursorInWorld[i] + viewRight[i] * brushSize;
+    }
 
     const { brushCursor } = this._hoverData;
     const { data } = brushCursor;
@@ -304,10 +327,10 @@ class BrushTool extends BaseTool {
     }
 
     data.handles.points = [
-      canvasToWorld(bottomCanvas),
-      canvasToWorld(topCanvas),
-      canvasToWorld(leftCanvas),
-      canvasToWorld(rightCanvas),
+      bottomCursorInWorld,
+      topCursorInWorld,
+      leftCursorInWorld,
+      rightCursorInWorld,
     ];
 
     data.invalidated = false;

package/src/tools/segmentation/PaintFillTool.ts

@@ -90,7 +90,10 @@ class PaintFillTool extends BaseTool {
 
     const index = transformWorldToIndex(segmentation.imageData, worldPos);
 
-    const fixedDimension = this.getFixedDimension(viewPlaneNormal, direction);
+    const fixedDimension = this.getFixedDimension(
+      viewPlaneNormal,
+      direction as number[]
+    );
 
     if (fixedDimension === undefined) {
       console.warn('Oblique paint fill not yet supported');
@@ -169,8 +172,12 @@ class PaintFillTool extends BaseTool {
     for (let b = 0; b < boundaries.length; b++) {
       const j = boundaries[b][1];
 
-      if (j < minJ) minJ = j;
-      if (j > maxJ) maxJ = j;
+      if (j < minJ) {
+        minJ = j;
+      }
+      if (j > maxJ) {
+        maxJ = j;
+      }
     }
 
     const framesModified = [];