Auto-Select via SAM

frontend/javascripts/admin/admin_rest_api.ts

@@ -2369,6 +2369,7 @@ export async function getSamEmbedding(
     `/api/datasets/${dataset.owningOrganization}/${dataset.name}/layers/${layerName}/segmentAnythingEmbedding`,
     {
       data: { mag, boundingBox: embeddingBoxMag1.asServerBoundingBox() },
+      showErrorToast: false,
     },
   );
   return new Float32Array(buffer);

frontend/javascripts/libs/mjs.ts

@@ -350,6 +350,15 @@ const V3 = {
   isEqual(a: Vector3, b: Vector3) {
     return a[0] === b[0] && a[1] === b[1] && a[2] === b[2];
   },
+
+  alignWithMag(a: Vector3, mag: Vector3, ceil: boolean = false) {
+    const roundFn = ceil ? Math.ceil : Math.floor;
+    return [
+      roundFn(a[0] / mag[0]) * mag[0],
+      roundFn(a[1] / mag[1]) * mag[1],
+      roundFn(a[2] / mag[2]) * mag[2],
+    ] as Vector3;
+  },
 };
 
 const V4 = {

frontend/javascripts/oxalis/controller/combinations/tool_controls.ts

@@ -48,6 +48,7 @@ import {
 } from "oxalis/model/actions/proofread_actions";
 import { calculateGlobalPos } from "oxalis/model/accessors/view_mode_accessor";
 import { V3 } from "libs/mjs";
+import { setQuickSelectStateAction } from "oxalis/model/actions/ui_actions";
 
 export type ActionDescriptor = {
   leftClick?: string;
@@ -662,6 +663,8 @@ export class QuickSelectTool {
         Store.dispatch(confirmQuickSelectAction());
         quickSelectGeometry.detachTextureMask();
 
+        Store.dispatch(setQuickSelectStateAction("drawing"));
+
         const state = Store.getState();
         quickSelectGeometry.rotateToViewport();
 
@@ -683,7 +686,10 @@ export class QuickSelectTool {
         isDragging = false;
         // Identity equality is enough, since we want to catch the case
         // in which the user didn't move the mouse at all
-        if (startPos === currentPos) {
+        if (
+          startPos === currentPos ||
+          Store.getState().uiInformation.quickSelectState === "inactive"
+        ) {
           // clear rectangle because user didn't drag
           return;
         }
@@ -699,7 +705,11 @@ export class QuickSelectTool {
         _id: string | null | undefined,
         event: MouseEvent,
       ) => {
-        if (!isDragging || startPos == null) {
+        if (
+          !isDragging ||
+          startPos == null ||
+          Store.getState().uiInformation.quickSelectState === "inactive"
+        ) {
           return;
         }
         const newCurrentPos = V3.floor(calculateGlobalPos(Store.getState(), pos));

frontend/javascripts/oxalis/default_state.ts

@@ -238,7 +238,7 @@ const defaultState: OxalisState = {
     busyBlockingInfo: {
       isBusy: false,
     },
-    isQuickSelectActive: false,
+    quickSelectState: "inactive",
     areQuickSelectSettingsOpen: false,
   },
   localSegmentationData: {},

frontend/javascripts/oxalis/geometries/helper_geometries.ts

@@ -133,13 +133,22 @@ export class QuickSelectGeometry {
   }
 
   setCoordinates(startPosition: Vector3, endPosition: Vector3) {
-    const centerPosition = V3.scale(V3.add(startPosition, endPosition), 0.5);
-    const extentXYZ = V3.abs(V3.sub(endPosition, startPosition));
     const { activeViewport } = Store.getState().viewModeData.plane;
+    // Add a depth to the endPosition so that the extent of the geometry
+    // will have a depth of 1. Note that the extent is only used to scale
+    // the geometry. Since it is a plane, a depth scale factor of > 1 won't
+    // extrude it.
+    const endPositionWithDepth = V3.add(
+      endPosition,
+      Dimensions.transDim([0, 0, 1], activeViewport),
+    );
+
+    const centerPosition = V3.scale(V3.add(startPosition, endPosition), 0.5);
+    const extentXYZ = V3.abs(V3.sub(endPositionWithDepth, startPosition));
     const extentUVW = Dimensions.transDim(extentXYZ, activeViewport);
-    // Set the depth-component of the rectangle to 1
-    extentUVW[2] = 1;
 
+    // Note that the third dimension's value will be adapted again
+    // in adaptVisibilityForRendering.
     this.rectangle.position.set(...centerPosition);
     this.rectangle.scale.set(...extentUVW);
     this.rectangle.geometry.computeBoundingSphere();
@@ -165,6 +174,17 @@ export class QuickSelectGeometry {
     this.meshGroup.visible =
       Math.trunc(flycamPosition[thirdDim]) ===
       Math.trunc(this.rectangle.position.toArray()[thirdDim]);
+
+    if (this.meshGroup.visible) {
+      // If the group is visible, adapt the position's third dimension to
+      // be exactly at the third dimension of the flycam. Otherwise,
+      // the geometry might be invisible when the current position is
+      // fractional.
+      const pos = this.rectangle.position.toArray();
+      pos[thirdDim] = flycamPosition[thirdDim];
+      this.rectangle.position.set(...pos);
+      this.centerMarker.position.set(...pos);
+    }
   }
 
   getMeshGroup() {

frontend/javascripts/oxalis/model/actions/ui_actions.ts

@@ -1,5 +1,5 @@
 import type { AnnotationTool } from "oxalis/constants";
-import type { BorderOpenStatus, Theme } from "oxalis/store";
+import type { OxalisState, BorderOpenStatus, Theme } from "oxalis/store";
 
 type SetDropzoneModalVisibilityAction = ReturnType<typeof setDropzoneModalVisibilityAction>;
 type SetVersionRestoreVisibilityAction = ReturnType<typeof setVersionRestoreVisibilityAction>;
@@ -17,7 +17,7 @@ type SetBusyBlockingInfoAction = ReturnType<typeof setBusyBlockingInfoAction>;
 type SetPythonClientModalVisibilityAction = ReturnType<typeof setPythonClientModalVisibilityAction>;
 export type EnterAction = ReturnType<typeof enterAction>;
 export type EscapeAction = ReturnType<typeof escapeAction>;
-export type SetIsQuickSelectActiveAction = ReturnType<typeof setIsQuickSelectActiveAction>;
+export type SetQuickSelectStateAction = ReturnType<typeof setQuickSelectStateAction>;
 type ShowQuickSelectSettingsAction = ReturnType<typeof showQuickSelectSettingsAction>;
 
 export type UiAction =
@@ -37,7 +37,7 @@ export type UiAction =
   | SetBusyBlockingInfoAction
   | EnterAction
   | EscapeAction
-  | SetIsQuickSelectActiveAction
+  | SetQuickSelectStateAction
   | ShowQuickSelectSettingsAction;
 
 export const setDropzoneModalVisibilityAction = (visible: boolean) =>
@@ -121,12 +121,13 @@ export const escapeAction = () =>
   ({
     type: "ESCAPE",
   } as const);
-export const setIsQuickSelectActiveAction = (isActive: boolean) =>
+export const setQuickSelectStateAction = (
+  state: OxalisState["uiInformation"]["quickSelectState"],
+) =>
   ({
-    type: "SET_IS_QUICK_SELECT_ACTIVE",
-    isActive,
+    type: "SET_QUICK_SELECT_STATE",
+    state,
   } as const);
-
 export const showQuickSelectSettingsAction = (isOpen: boolean) =>
   ({
     type: "SET_ARE_QUICK_SELECT_SETTINGS_OPEN",

frontend/javascripts/oxalis/model/bucket_data_handling/bounding_box.ts

@@ -15,7 +15,7 @@ class BoundingBox {
   constructor(boundingBox: BoundingBoxType | null | undefined, maxRestriction?: Vector3) {
     this.boundingBox = boundingBox;
     // Min is including
-    this.min = [0, 0, 0];
+    this.min = [-Infinity, -Infinity, -Infinity];
     // Max is excluding
     this.max = maxRestriction != null ? _.clone(maxRestriction) : [Infinity, Infinity, Infinity];
 
@@ -29,8 +29,8 @@ class BoundingBox {
 
   getBoxForZoomStep = _.memoize((resolution: Vector3): BoundingBoxType => {
     // No `map` for performance reasons
-    const min = [0, 0, 0];
-    const max = [0, 0, 0];
+    const min = [0, 0, 0] as Vector3;
+    const max = [0, 0, 0] as Vector3;
 
     for (let i = 0; i < 3; i++) {
       const divisor = constants.BUCKET_WIDTH * resolution[i];
@@ -39,9 +39,7 @@ class BoundingBox {
     }
 
     return {
-      // @ts-expect-error ts-migrate(2322) FIXME: Type 'number[]' is not assignable to type 'Vector3... Remove this comment to see the full error message
       min,
-      // @ts-expect-error ts-migrate(2322) FIXME: Type 'number[]' is not assignable to type 'Vector3... Remove this comment to see the full error message
       max,
     };
   });
@@ -163,23 +161,21 @@ class BoundingBox {
     });
   }
 
-  alignWithMag(mag: Vector3, ceil: boolean = false): BoundingBox {
+  alignWithMag(mag: Vector3, strategy: "shrink" | "grow" | "ceil" | "floor"): BoundingBox {
     /*
      * Rounds the bounding box, so that both min and max are divisible by mag.
-     * :argument ceil: If true, the bounding box is enlarged when necessary. If false, it's shrinked when necessary.
+     * The strategy parameter controls how the coordinates are rounded:
+     * - shrink: ceils `min` and floors `max`
+     * - grow: floors `min` and ceils `max`
+     * - ceil: ceils `min` and `max`
+     * - floor: floors `min` and `max`
      */
     const align = (point: Vector3, round_fn: (vec: Vector3) => Vector3) =>
       V3.scale3(round_fn(V3.divide3(point, mag)), mag);
 
-    if (ceil) {
-      const min = align(this.min, V3.floor);
-      const max = align(this.max, V3.ceil);
-      return new BoundingBox({ min, max });
-    } else {
-      const min = align(this.min, V3.ceil);
-      const max = align(this.max, V3.floor);
-      return new BoundingBox({ min, max });
-    }
+    const min = align(this.min, strategy === "ceil" || strategy === "shrink" ? V3.ceil : V3.floor);
+    const max = align(this.max, strategy === "floor" || strategy === "shrink" ? V3.floor : V3.ceil);
+    return new BoundingBox({ min, max });
   }
 
   /*

frontend/javascripts/oxalis/model/reducers/ui_reducer.ts

@@ -108,9 +108,9 @@ function UiReducer(state: OxalisState, action: Action): OxalisState {
       });
     }
 
-    case "SET_IS_QUICK_SELECT_ACTIVE": {
+    case "SET_QUICK_SELECT_STATE": {
       return updateKey(state, "uiInformation", {
-        isQuickSelectActive: action.isActive,
+        quickSelectState: action.state,
       });
     }
 

frontend/javascripts/oxalis/model/sagas/quick_select_heuristic_saga.ts

@@ -519,17 +519,14 @@ export function* finalizeQuickSelect(
     size[secondDim],
   );
 
-  console.time("fill voxel buffer");
   for (let u = 0; u < size[firstDim]; u++) {
     for (let v = 0; v < size[secondDim]; v++) {
       if (mask.get(u, v, 0) > 0) {
         voxelBuffer2D.setValue(u, v, 1);
       }
     }
   }
-  console.timeEnd("fill voxel buffer");
 
-  console.time("label with voxel buffer");
   yield* call(
     labelWithVoxelBuffer2D,
     voxelBuffer2D,
@@ -538,7 +535,6 @@ export function* finalizeQuickSelect(
     labeledZoomStep,
     activeViewport,
   );
-  console.timeEnd("label with voxel buffer");
   yield* put(finishAnnotationStrokeAction(volumeTracing.tracingId));
   yield* put(registerLabelPointAction(boundingBoxMag1.getCenter()));
   yield* put(