lost-sia 2.0.1-alpha12 → 2.0.1-alpha13

package/src/Annotation/ui/atoms/Node.tsx

@@ -1,21 +1,21 @@
-import { CSSProperties, MouseEvent, useEffect, useRef, useState } from "react";
-import { Point } from "../../../types";
-import mouse2 from "../../../utils/mouse2";
-import { AnnotationSettings } from "../../../types";
+import { CSSProperties, MouseEvent, useEffect, useRef, useState } from 'react'
+import { Point } from '../../../types'
+import mouse from '../../../utils/mouse'
+import { AnnotationSettings } from '../../../types'
 
 type NodeProps = {
-  index: number;
-  coordinates: Point;
-  annotationSettings: AnnotationSettings;
-  pageToStageOffset: Point;
-  svgScale: number;
-  svgTranslation: Point;
-  style: CSSProperties;
-  onDeleteNode: () => void;
-  onMoving: (index: number, coordinates: Point) => void;
-  onMoved: () => void;
-  onIsDraggingStateChanged: (bool) => void;
-};
+  index: number
+  coordinates: Point
+  annotationSettings: AnnotationSettings
+  pageToStageOffset: Point
+  svgScale: number
+  svgTranslation: Point
+  style: CSSProperties
+  onDeleteNode: () => void
+  onMoving: (index: number, coordinates: Point) => void
+  onMoved: () => void
+  onIsDraggingStateChanged: (bool) => void
+}
 
 const Node = ({
   index,
@@ -30,59 +30,59 @@ const Node = ({
   onMoved, // moving finished - send annotation changed event
   onIsDraggingStateChanged,
 }: NodeProps) => {
-  const [hasHalo, setHasHalo] = useState<boolean>(false);
-  const [isDragging, setIsDragging] = useState<boolean>(false);
+  const [hasHalo, setHasHalo] = useState<boolean>(false)
+  const [isDragging, setIsDragging] = useState<boolean>(false)
 
   // onMove and onMouseUp events are fired in the same frame
   // use a ref to access the updated value without waiting until the next frame
-  const [didItActuallyMove, setDidItActuallyMove] = useState<boolean>(false);
-  const didItActuallyMoveRef = useRef<boolean>(didItActuallyMove);
+  const [didItActuallyMove, setDidItActuallyMove] = useState<boolean>(false)
+  const didItActuallyMoveRef = useRef<boolean>(didItActuallyMove)
 
   useEffect(() => {
-    didItActuallyMoveRef.current = didItActuallyMove;
-  }, [didItActuallyMove]);
+    didItActuallyMoveRef.current = didItActuallyMove
+  }, [didItActuallyMove])
 
   const onMouseMove = (e: MouseEvent) => {
-    if (!isDragging) return;
+    if (!isDragging) return
 
     const antiScaledMousePositionInStageCoordinates =
-      mouse2.getAntiScaledMouseStagePosition(
+      mouse.getAntiScaledMouseStagePosition(
         e,
         pageToStageOffset,
         svgScale,
         svgTranslation,
-      );
+      )
 
     // only escalate event when mouse actually moved
     if (e.movementX !== 0 || e.movementY !== 0) {
-      setDidItActuallyMove(true);
-      onMoving(index, antiScaledMousePositionInStageCoordinates);
+      setDidItActuallyMove(true)
+      onMoving(index, antiScaledMousePositionInStageCoordinates)
     }
-  };
+  }
 
   useEffect(() => {
-    onIsDraggingStateChanged(isDragging);
-    if (!isDragging) return;
+    onIsDraggingStateChanged(isDragging)
+    if (!isDragging) return
 
     const handleMouseUp = () => {
-      setIsDragging(false);
-      if (didItActuallyMoveRef.current) onMoved();
-      setDidItActuallyMove(false);
-    };
+      setIsDragging(false)
+      if (didItActuallyMoveRef.current) onMoved()
+      setDidItActuallyMove(false)
+    }
 
-    window.addEventListener("mouseup", handleMouseUp);
+    window.addEventListener('mouseup', handleMouseUp)
 
     return () => {
-      window.removeEventListener("mouseup", handleMouseUp);
-    };
-  }, [isDragging]);
+      window.removeEventListener('mouseup', handleMouseUp)
+    }
+  }, [isDragging])
 
   const onMouseDown = (e: MouseEvent) => {
-    if (!annotationSettings.canEdit) return;
+    if (!annotationSettings.canEdit) return
 
-    if (e.ctrlKey) onDeleteNode();
-    else setIsDragging(true);
-  };
+    if (e.ctrlKey) onDeleteNode()
+    else setIsDragging(true)
+  }
 
   const renderHalo = () => {
     return (
@@ -94,21 +94,21 @@ const Node = ({
         onMouseDown={onMouseDown}
         onContextMenu={(e) => e.preventDefault()}
       />
-    );
-  };
+    )
+  }
 
   const renderInfiniteSelectionArea = () => {
     return (
       <circle
         cx={coordinates.x}
         cy={coordinates.y}
-        r={"100%"}
+        r={'100%'}
         style={{ opacity: 0 }}
         onMouseMove={(e) => onMouseMove(e)}
         onContextMenu={(e) => e.preventDefault()}
       />
-    );
-  };
+    )
+  }
 
   return (
     <g>
@@ -120,14 +120,14 @@ const Node = ({
         r={10 / svgScale}
         style={style}
         onMouseOver={() => {
-          if (annotationSettings.canEdit) setHasHalo(true);
+          if (annotationSettings.canEdit) setHasHalo(true)
         }}
         onMouseDown={onMouseDown}
         onMouseMove={(e) => onMouseMove(e)}
         onContextMenu={(e) => e.preventDefault()}
       />
     </g>
-  );
-};
+  )
+}
 
-export default Node;
+export default Node

package/src/Annotation/ui/tools/BBox.tsx

@@ -1,29 +1,29 @@
-import { CSSProperties, MouseEvent, useEffect, useRef, useState } from "react";
+import { CSSProperties, MouseEvent, useEffect, useRef, useState } from 'react'
 
 // rename type to avoid naming conflict
-import { AnnotationSettings, Point } from "../../../types";
-import Node from "../atoms/Node";
-import AnnotationMode from "../../../models/AnnotationMode";
-import mouse2 from "../../../utils/mouse2";
-import PolygonArea from "../atoms/PolygonArea";
-import Edge from "../atoms/Edge";
+import { AnnotationSettings, Point } from '../../../types'
+import Node from '../atoms/Node'
+import AnnotationMode from '../../../models/AnnotationMode'
+import mouse from '../../../utils/mouse'
+import PolygonArea from '../atoms/PolygonArea'
+import Edge from '../atoms/Edge'
 
 type BBoxProps = {
-  annotationMode: AnnotationMode;
-  annotationSettings: AnnotationSettings;
-  pageToStageOffset: Point;
-  startCoords: Point;
-  endCoords: Point;
-  svgScale: number;
-  svgTranslation: Point;
-  isSelected: boolean;
-  style: CSSProperties;
-  onDeleteNode: (coordinates: Point[]) => void;
-  onFinishAnnoCreate: () => void;
-  onIsDraggingStateChanged: (newDraggingState: boolean) => void;
-  onMoving: (coordinates: Point[]) => void; // during moving - update coordinates in parent
-  onMoved: () => void; // moving finished - send annotation changed event
-};
+  annotationMode: AnnotationMode
+  annotationSettings: AnnotationSettings
+  pageToStageOffset: Point
+  startCoords: Point
+  endCoords: Point
+  svgScale: number
+  svgTranslation: Point
+  isSelected: boolean
+  style: CSSProperties
+  onDeleteNode: (coordinates: Point[]) => void
+  onFinishAnnoCreate: () => void
+  onIsDraggingStateChanged: (newDraggingState: boolean) => void
+  onMoving: (coordinates: Point[]) => void // during moving - update coordinates in parent
+  onMoved: () => void // moving finished - send annotation changed event
+}
 
 const BBox = ({
   annotationMode,
@@ -47,144 +47,130 @@ const BBox = ({
     { x: startCoords.x, y: endCoords.y },
     endCoords,
     { x: endCoords.x, y: startCoords.y },
-  ];
+  ]
 
   const [isAnnoCreating, setIsAnnoCreating] = useState<boolean>(
     annotationMode === AnnotationMode.CREATE,
-  );
-  const [isAnnoDragging, setIsAnnoDragging] = useState<boolean>(false);
-  const [isEdgeDragging, setIsEdgeDragging] = useState<boolean>(false);
-  const [dragSelectedEdgeIndex, setDragSelectedEdgeIndex] = useState<number>(0);
+  )
+  const [isAnnoDragging, setIsAnnoDragging] = useState<boolean>(false)
+  const [isEdgeDragging, setIsEdgeDragging] = useState<boolean>(false)
+  const [dragSelectedEdgeIndex, setDragSelectedEdgeIndex] = useState<number>(0)
 
   // onMove and onMouseUp events are fired in the same frame
   // use a ref to access the updated value without waiting until the next frame
-  const [didAnnoActuallyMove, setDidAnnoActuallyMove] =
-    useState<boolean>(false);
-  const didAnnoActuallyMoveRef = useRef<boolean>(didAnnoActuallyMove);
+  const [didAnnoActuallyMove, setDidAnnoActuallyMove] = useState<boolean>(false)
+  const didAnnoActuallyMoveRef = useRef<boolean>(didAnnoActuallyMove)
 
   useEffect(() => {
-    didAnnoActuallyMoveRef.current = didAnnoActuallyMove;
-  }, [didAnnoActuallyMove]);
+    didAnnoActuallyMoveRef.current = didAnnoActuallyMove
+  }, [didAnnoActuallyMove])
 
   const onMouseDown = (e: MouseEvent) => {
-    if (annotationSettings.canEdit === false) return;
+    if (annotationSettings.canEdit === false) return
 
-    if (
-      isSelected &&
-      annotationMode !== AnnotationMode.CREATE &&
-      e.button === 0
-    )
-      setIsAnnoDragging(true);
-  };
+    if (isSelected && annotationMode !== AnnotationMode.CREATE && e.button === 0)
+      setIsAnnoDragging(true)
+  }
 
   const onMouseEdgeDown = (e: MouseEvent) => {
-    if (annotationSettings.canEdit === false) return;
+    if (annotationSettings.canEdit === false) return
 
-    if (
-      isSelected &&
-      annotationMode !== AnnotationMode.CREATE &&
-      e.button === 0
-    )
-      setIsEdgeDragging(true);
-  };
+    if (isSelected && annotationMode !== AnnotationMode.CREATE && e.button === 0)
+      setIsEdgeDragging(true)
+  }
 
   const onMouseMove = (e: MouseEvent) => {
     if (isAnnoDragging) {
       // we always get 4 coordinates (the rectangle corners)
       // only the top left and bottom right corner are important - other coordinates are redundant
-      const newRectangle: Point[] = [
-        { ...coordinates[0] },
-        { ...coordinates[2] },
-      ];
+      const newRectangle: Point[] = [{ ...coordinates[0] }, { ...coordinates[2] }]
 
       // apply mouse move to the rectangle coordinates
-      const movedCoordinates: Point[] = newRectangle.map(
-        (coordinate: Point) => {
-          return {
-            // counter the canvas scaling (it will be automatically applied when rendering the annotation coordinates)
-            x: (coordinate.x += e.movementX / svgScale),
-            y: (coordinate.y += e.movementY / svgScale),
-          };
-        },
-      );
+      const movedCoordinates: Point[] = newRectangle.map((coordinate: Point) => {
+        return {
+          // counter the canvas scaling (it will be automatically applied when rendering the annotation coordinates)
+          x: (coordinate.x += e.movementX / svgScale),
+          y: (coordinate.y += e.movementY / svgScale),
+        }
+      })
 
       // only escalate event when mouse actually moved
       if (e.movementX !== 0 || e.movementY !== 0) {
-        setDidAnnoActuallyMove(true);
-        onMoving(movedCoordinates);
+        setDidAnnoActuallyMove(true)
+        onMoving(movedCoordinates)
       }
     }
 
     if (annotationMode === AnnotationMode.CREATE) {
-      const mousePointInStage = mouse2.getAntiScaledMouseStagePosition(
+      const mousePointInStage = mouse.getAntiScaledMouseStagePosition(
         e,
         pageToStageOffset,
         svgScale,
         svgTranslation,
-      );
+      )
 
-      const newCoords: Point[] = [...coordinates];
+      const newCoords: Point[] = [...coordinates]
 
       // we always get 4 coordinates (the rectangle corners)
       // only the top left (start) is important - the end will be our mouse position and the others are redundant
-      const newRectangle: Point[] = [newCoords[0], mousePointInStage];
+      const newRectangle: Point[] = [newCoords[0], mousePointInStage]
 
-      onMoving(newRectangle);
+      onMoving(newRectangle)
     }
-  };
+  }
 
   useEffect(() => {
-    if (!isAnnoCreating) return;
+    if (!isAnnoCreating) return
 
     const handleMouseUp = (e: globalThis.MouseEvent) => {
       if (e.button === 2) {
-        onFinishAnnoCreate();
-        setIsAnnoCreating(false);
+        onFinishAnnoCreate()
+        setIsAnnoCreating(false)
       }
-    };
+    }
 
-    window.addEventListener("mouseup", handleMouseUp);
+    window.addEventListener('mouseup', handleMouseUp)
 
     return () => {
-      window.removeEventListener("mouseup", handleMouseUp);
-    };
-  }, [isAnnoCreating]);
+      window.removeEventListener('mouseup', handleMouseUp)
+    }
+  }, [isAnnoCreating])
 
   useEffect(() => {
-    onIsDraggingStateChanged(isAnnoDragging);
-    if (!isAnnoDragging) return;
+    onIsDraggingStateChanged(isAnnoDragging)
+    if (!isAnnoDragging) return
 
     const handleMouseUp = () => {
-      setIsAnnoDragging(false);
+      setIsAnnoDragging(false)
 
-      if (didAnnoActuallyMoveRef.current) onMoved();
-      setDidAnnoActuallyMove(false);
-    };
+      if (didAnnoActuallyMoveRef.current) onMoved()
+      setDidAnnoActuallyMove(false)
+    }
 
-    window.addEventListener("mouseup", handleMouseUp);
+    window.addEventListener('mouseup', handleMouseUp)
 
     return () => {
-      window.removeEventListener("mouseup", handleMouseUp);
-    };
-  }, [isAnnoDragging]);
+      window.removeEventListener('mouseup', handleMouseUp)
+    }
+  }, [isAnnoDragging])
 
   useEffect(() => {
-    onIsDraggingStateChanged(isEdgeDragging);
-    if (!isEdgeDragging) return;
+    onIsDraggingStateChanged(isEdgeDragging)
+    if (!isEdgeDragging) return
 
     const handleMouseUp = () => {
-      setIsEdgeDragging(false);
+      setIsEdgeDragging(false)
 
-      if (didAnnoActuallyMoveRef.current) onMoved();
-      setDidAnnoActuallyMove(false);
-    };
+      if (didAnnoActuallyMoveRef.current) onMoved()
+      setDidAnnoActuallyMove(false)
+    }
 
-    window.addEventListener("mouseup", handleMouseUp);
+    window.addEventListener('mouseup', handleMouseUp)
 
     return () => {
-      window.removeEventListener("mouseup", handleMouseUp);
-    };
-  }, [isEdgeDragging]);
+      window.removeEventListener('mouseup', handleMouseUp)
+    }
+  }, [isEdgeDragging])
 
   const renderNodes = () => {
     const svgNodes = coordinates.map((coordinate: Point, index: number) => (
@@ -198,78 +184,76 @@ const BBox = ({
         svgTranslation={svgTranslation}
         style={style}
         onDeleteNode={() => {
-          const newCoordinates = [...coordinates];
-          newCoordinates.splice(index, 1);
-          onDeleteNode(newCoordinates);
+          const newCoordinates = [...coordinates]
+          newCoordinates.splice(index, 1)
+          onDeleteNode(newCoordinates)
         }}
         onMoving={(index: number, newPoint: Point) => {
           // we always get 4 coordinates (the rectangle corners)
           // only the top left and bottom right corner are important - other coordinates are redundant
-          const newRectangle: Point[] = [coordinates[0], coordinates[2]];
+          const newRectangle: Point[] = [coordinates[0], coordinates[2]]
 
           // update start + end coordinates depending on which corner is moved
           switch (index) {
             case 0: // top left corner
-              newRectangle[0] = newPoint;
-              break;
+              newRectangle[0] = newPoint
+              break
             case 1: // bottom left corner
-              newRectangle[0].x = newPoint.x;
-              newRectangle[1].y = newPoint.y;
-              break;
+              newRectangle[0].x = newPoint.x
+              newRectangle[1].y = newPoint.y
+              break
             case 2: // bottom right corner
-              newRectangle[1] = newPoint;
-              break;
+              newRectangle[1] = newPoint
+              break
             case 3: // top right corner
-              newRectangle[1].x = newPoint.x;
-              newRectangle[0].y = newPoint.y;
-              break;
+              newRectangle[1].x = newPoint.x
+              newRectangle[0].y = newPoint.y
+              break
           }
 
-          onMoving(newRectangle);
+          onMoving(newRectangle)
         }}
         onMoved={() => onMoved()}
         onIsDraggingStateChanged={onIsDraggingStateChanged}
       />
-    ));
+    ))
 
-    return svgNodes;
-  };
+    return svgNodes
+  }
 
   const moveEdge = (edgeIndex: number, e: MouseEvent) => {
     // we always get 4 coordinates (the rectangle corners)
     // only the top left and bottom right corner are important - other coordinates are redundant
-    const newRectangle: Point[] = [coordinates[0], coordinates[2]];
+    const newRectangle: Point[] = [coordinates[0], coordinates[2]]
     switch (edgeIndex) {
       case 0:
-        newRectangle[0].x += e.movementX / svgScale;
-        break;
+        newRectangle[0].x += e.movementX / svgScale
+        break
       case 1:
-        newRectangle[1].y += e.movementY / svgScale;
-        break;
+        newRectangle[1].y += e.movementY / svgScale
+        break
       case 2:
-        newRectangle[1].x += e.movementX / svgScale;
-        break;
+        newRectangle[1].x += e.movementX / svgScale
+        break
       case 3:
-        newRectangle[0].y += e.movementY / svgScale;
-        break;
+        newRectangle[0].y += e.movementY / svgScale
+        break
     }
 
     // only escalate event when mouse actually moved
     if (e.movementX !== 0 || e.movementY !== 0) {
-      setDidAnnoActuallyMove(true);
-      onMoving(newRectangle);
+      setDidAnnoActuallyMove(true)
+      onMoving(newRectangle)
     }
-  };
+  }
 
   const renderEdges = () => {
     const svgEdges = coordinates.map((coordinate: Point, index: number) => {
       const endCoordinates: Point =
-        index + 1 < coordinates.length
-          ? coordinates[index + 1]
-          : coordinates[0];
+        index + 1 < coordinates.length ? coordinates[index + 1] : coordinates[0]
 
       // corresponding cursor for horizontal or vertical edges
-      const cursor = index % 2 === 0 ? "ew-resize" : "ns-resize";
+      const cursor = index % 2 === 0 ? 'ew-resize' : 'ns-resize'
 
       return (
         <Edge
@@ -282,31 +266,31 @@ const BBox = ({
           style={{ ...style, cursor }}
           onMouseDown={onMouseEdgeDown}
           onMouseMove={(e: MouseEvent) => {
-            setDragSelectedEdgeIndex(index);
-            if (isEdgeDragging) moveEdge(index, e);
+            setDragSelectedEdgeIndex(index)
+            if (isEdgeDragging) moveEdge(index, e)
           }}
         />
-      );
-    });
-    return svgEdges;
-  };
+      )
+    })
+    return svgEdges
+  }
 
   const renderInfiniteSelectionArea = (isForEdge: boolean) => {
     return (
       <circle
         cx={coordinates[0].x}
         cy={coordinates[0].y}
-        r={"100%"}
+        r={'100%'}
         style={{ opacity: 0 }}
         onMouseDown={onMouseDown}
         onMouseMove={(e: MouseEvent) => {
-          if (isForEdge && isEdgeDragging) moveEdge(dragSelectedEdgeIndex, e);
-          if (!isForEdge) onMouseMove(e);
+          if (isForEdge && isEdgeDragging) moveEdge(dragSelectedEdgeIndex, e)
+          if (!isForEdge) onMouseMove(e)
         }}
         onContextMenu={(e) => e.preventDefault()}
       />
-    );
-  };
+    )
+  }
 
   return (
     <g>
@@ -328,7 +312,7 @@ const BBox = ({
       {isSelected && annotationSettings.canEdit && renderEdges()}
       {isSelected && annotationMode !== AnnotationMode.CREATE && renderNodes()}
     </g>
-  );
-};
+  )
+}
 
-export default BBox;
+export default BBox