Scaling

src/manipulators/anyHandlesOutsideImage.js

@@ -12,11 +12,12 @@ import external from '../externalModules.js';
  */
 export default function(renderData, handles) {
   const image = renderData.image;
+  const { scaledImageFactor } = image.imageFrame;
   const imageRect = {
     left: 0,
     top: 0,
-    width: image.width,
-    height: image.height,
+    width: image.width * scaledImageFactor,
+    height: image.height * scaledImageFactor,
   };
 
   let handleOutsideImage = false;

src/manipulators/getHandlePixelPosition.js

@@ -24,9 +24,17 @@ export default function(eventData, interactionType) {
     offsetY = handleTouchOffset.y;
   }
 
-  return external.cornerstone.pageToPixel(
+  const enabledElement = external.cornerstone.getEnabledElement(element);
+  const { scaledImageFactor = 1 } = enabledElement.image.imageFrame;
+  const localPosition = external.cornerstone.pageToPixel(
     element,
     page.x + offsetX,
     page.y + offsetY
   );
+
+  return {
+    ...localPosition,
+    x: localPosition.x * scaledImageFactor,
+    y: localPosition.y * scaledImageFactor,
+  };
 }

src/manipulators/moveNewHandle.js

@@ -169,7 +169,10 @@ function _moveHandler(
   const activeTool = getActiveTool(element, buttons, interactionType);
 
   if (activeTool instanceof BaseAnnotationTool) {
-    activeTool.updateCachedStats(image, element, annotation);
+    const scaledAnnotation = JSON.parse(JSON.stringify(annotation));
+
+    activeTool.updateCachedStats(image, element, scaledAnnotation);
+    // activeTool.updateCachedStats(image, element, annotation);
   }
 
   const eventType = EVENTS.MEASUREMENT_MODIFIED;

src/stateManagement/imageIdSpecificStateManager.js

@@ -73,16 +73,22 @@ function newImageIdSpecificToolStateManager() {
       return;
     }
 
-    return getImageIdToolState(enabledElement.image.imageId, toolName);
+    return getImageIdToolState(
+      enabledElement.image.imageId,
+      toolName,
+      enabledElement.image.imageFrame.scaledImageFactor
+    );
   }
 
   // Here you can get state - used by tools as well as modules
   // That save state persistently
-  function getImageIdToolState(imageId, toolName) {
+  function getImageIdToolState(imageId, toolName, scaledImageFactor) {
     // If we don't have any tool state for this imageId, return undefined
     if (toolState.hasOwnProperty(imageId) === false) {
       return;
     }
+    //
+    // console.log(toolState);
 
     const imageIdToolState = toolState[imageId];
 
@@ -91,6 +97,35 @@ function newImageIdSpecificToolStateManager() {
       return;
     }
 
+    for (const tool of imageIdToolState[toolName].data) {
+      if (tool.handles === undefined || scaledImageFactor === undefined) {
+        continue;
+      }
+
+      for (const key of Object.keys(tool.handles)) {
+        if (
+          tool.handles[key].originalX === undefined ||
+          tool.handles[key].moving
+        ) {
+          tool.handles[key].originalX = tool.handles[key].x;
+        }
+
+        if (
+          tool.handles[key].originalY === undefined ||
+          tool.handles[key].moving
+        ) {
+          tool.handles[key].originalY = tool.handles[key].y;
+        }
+
+        tool.handles[key].x =
+          (tool.handles[key].originalX || tool.handles[key].x) /
+          scaledImageFactor;
+        tool.handles[key].y =
+          (tool.handles[key].originalY || tool.handles[key].y) /
+          scaledImageFactor;
+      }
+    }
+
     return imageIdToolState[toolName];
   }
 

src/stateManagement/toolState.js

@@ -38,6 +38,18 @@ function getElementToolStateManager(element) {
 function addToolState(element, toolName, measurementData) {
   const toolStateManager = getElementToolStateManager(element);
 
+  if (measurementData.handles !== undefined) {
+    const enabledElement = external.cornerstone.getEnabledElement(element);
+    const { scaledImageFactor } = enabledElement.image.imageFrame;
+
+    for (const key of Object.keys(measurementData.handles)) {
+      if (measurementData.handles[key].x !== undefined) {
+        measurementData.handles[key].x *= scaledImageFactor;
+        measurementData.handles[key].y *= scaledImageFactor;
+      }
+    }
+  }
+
   measurementData.uuid = measurementData.uuid || uuidv4();
   toolStateManager.add(element, toolName, measurementData);
 

src/tools/annotation/bidirectionalTool/utils/updatePerpendicularLineHandles.js

@@ -22,41 +22,44 @@ export default function updatePerpendicularLineHandles(
 
   const { start, end } = measurementData.handles;
   const { columnPixelSpacing = 1, rowPixelSpacing = 1 } = eventData.image;
+  const { scaledmageFactor = 1 } = eventData.image.imageFrame;
 
   if (start.x === end.x && start.y === end.y) {
-    startX = start.x;
-    startY = start.y;
-    endX = end.x;
-    endY = end.y;
+    startX = start.originalX;
+    startY = start.originalY;
+    endX = end.originalX;
+    endY = end.originalY;
   } else {
     // Mid point of long-axis line
     const mid = {
-      x: (start.x + end.x) / 2,
-      y: (start.y + end.y) / 2,
+      x: (start.originalX + end.originalX) / 2,
+      y: (start.originalY + end.originalY) / 2,
     };
 
     // Inclination of the perpendicular line
     const vector = getLineVector(
-      columnPixelSpacing,
-      rowPixelSpacing,
+      columnPixelSpacing * scaledmageFactor,
+      rowPixelSpacing * scaledmageFactor,
       start,
       end
     );
 
     const perpendicularLineLength = vector.length / 2;
-    const rowMultiplier = perpendicularLineLength / (2 * rowPixelSpacing);
-    const columnMultiplier = perpendicularLineLength / (2 * columnPixelSpacing);
+    const rowMultiplier =
+      perpendicularLineLength / (2 * rowPixelSpacing * scaledmageFactor);
+    const columnMultiplier =
+      perpendicularLineLength / (2 * columnPixelSpacing * scaledmageFactor);
 
     startX = mid.x + columnMultiplier * vector.y;
     startY = mid.y - rowMultiplier * vector.x;
     endX = mid.x - columnMultiplier * vector.y;
     endY = mid.y + rowMultiplier * vector.x;
   }
 
-  measurementData.handles.perpendicularStart.x = startX;
-  measurementData.handles.perpendicularStart.y = startY;
-  measurementData.handles.perpendicularEnd.x = endX;
-  measurementData.handles.perpendicularEnd.y = endY;
+  measurementData.handles.perpendicularStart.originalX = startX;
+  measurementData.handles.perpendicularStart.originalY = startY;
+  measurementData.handles.perpendicularEnd.originalX = endX;
+  measurementData.handles.perpendicularEnd.originalY = endY;
 
   return true;
 }