Warn user when using precomputed meshes after brushing (#8218)

* Add key in volumetracing to store if volume bucket data has changed

* show warning in context menu for loading precomputed meshes when bucket data has changed

* avoid unnecessary rerenders in context menu

* ensure SET_VOLUME_BUCKET_DATA_HAS_CHANGED is dispatched when buckets are changed

* add missing file

* fix linting

* rename load_mesh_menu_item_label file

* use action creator instead of hardcoding action

* fix that volumeBucketDataHashChanged was not handled when the server sent it

* add comments

* update snapshots

* add changelog entry

* remove unintentional changelog entry

* change action property from layerName to tracingId

---------

Co-authored-by: Philipp Otto <philipp.4096@gmail.com>
Co-authored-by: Philipp Otto <philippotto@users.noreply.github.com>
Co-authored-by: Michael Büßemeyer <frameworklinux+MichaelBuessemeyer@users.noreply.github.com>

Author: 3 people

app/models/annotation/AnnotationService.scala

@@ -179,7 +179,8 @@ class AnnotationService @Inject()(
         mappingName = mappingName,
         mags = magsRestricted.map(vec3IntToProto),
         hasSegmentIndex = Some(fallbackLayer.isEmpty || fallbackLayerHasSegmentIndex),
-        additionalAxes = AdditionalAxis.toProto(additionalAxes)
+        additionalAxes = AdditionalAxis.toProto(additionalAxes),
+        volumeBucketDataHasChanged = Some(false)
       )
   }
 

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

@@ -45,6 +45,9 @@ export type SetSegmentGroupsAction = ReturnType<typeof setSegmentGroupsAction>;
 export type SetExpandedSegmentGroupsAction = ReturnType<typeof setExpandedSegmentGroupsAction>;
 export type SetHasEditableMappingAction = ReturnType<typeof setHasEditableMappingAction>;
 export type SetMappingIsLockedAction = ReturnType<typeof setMappingIsLockedAction>;
+export type SetVolumeBucketDataHasChangedAction = ReturnType<
+  typeof setVolumeBucketDataHasChangedAction
+>;
 
 export type ComputeQuickSelectForRectAction = ReturnType<typeof computeQuickSelectForRectAction>;
 export type ComputeQuickSelectForPointAction = ReturnType<typeof computeQuickSelectForPointAction>;
@@ -99,6 +102,7 @@ export type VolumeTracingAction =
   | FineTuneQuickSelectAction
   | CancelQuickSelectAction
   | ConfirmQuickSelectAction
+  | SetVolumeBucketDataHasChangedAction
   | BatchUpdateGroupsAndSegmentsAction;
 
 export const VolumeTracingSaveRelevantActions = [
@@ -437,3 +441,9 @@ export const batchUpdateGroupsAndSegmentsAction = (actions: BatchableUpdateSegme
 export const cancelQuickSelectAction = () => ({ type: "CANCEL_QUICK_SELECT" }) as const;
 
 export const confirmQuickSelectAction = () => ({ type: "CONFIRM_QUICK_SELECT" }) as const;
+
+export const setVolumeBucketDataHasChangedAction = (tracingId: string) =>
+  ({
+    type: "SET_VOLUME_BUCKET_DATA_HAS_CHANGED",
+    tracingId,
+  }) as const;

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

@@ -269,6 +269,7 @@ export function serverVolumeToClientVolumeTracing(tracing: ServerVolumeTracing):
     mappingName: tracing.mappingName,
     hasEditableMapping: tracing.hasEditableMapping,
     mappingIsLocked: tracing.mappingIsLocked,
+    volumeBucketDataHasChanged: tracing.volumeBucketDataHasChanged,
     hasSegmentIndex: tracing.hasSegmentIndex || false,
     additionalAxes: convertServerAdditionalAxesToFrontEnd(tracing.additionalAxes),
   };
@@ -377,6 +378,12 @@ function VolumeTracingReducer(
       return expandSegmentParents(state, action);
     }
 
+    case "SET_VOLUME_BUCKET_DATA_HAS_CHANGED": {
+      return updateVolumeTracing(state, action.tracingId, {
+        volumeBucketDataHasChanged: true,
+      });
+    }
+
     default: // pass
   }
 

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

@@ -15,7 +15,7 @@ import performQuickSelectML from "./quick_select_ml_saga";
 import getSceneController from "oxalis/controller/scene_controller_provider";
 import { getActiveSegmentationTracing } from "../accessors/volumetracing_accessor";
 import type { VolumeTracing } from "oxalis/store";
-import { ensureMaybeActiveMappingIsLocked } from "./saga_helpers";
+import { requestBucketModificationInVolumeTracing } from "./saga_helpers";
 
 function* shouldUseHeuristic() {
   const useHeuristic = yield* select((state) => state.userConfiguration.quickSelect.useHeuristic);
@@ -32,11 +32,11 @@ export default function* listenToQuickSelect(): Saga<void> {
         );
         if (volumeTracing) {
           // As changes to the volume layer will be applied, the potentially existing mapping should be locked to ensure a consistent state.
-          const { isMappingLockedIfNeeded } = yield* call(
-            ensureMaybeActiveMappingIsLocked,
+          const isModificationAllowed = yield* call(
+            requestBucketModificationInVolumeTracing,
             volumeTracing,
           );
-          if (!isMappingLockedIfNeeded) {
+          if (!isModificationAllowed) {
             return;
           }
         }

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

@@ -9,7 +9,10 @@ import { call, put, takeEvery } from "typed-redux-saga";
 import Toast from "libs/toast";
 import { Store } from "oxalis/singletons";
 import type { ActionPattern } from "@redux-saga/types";
-import { setMappingIsLockedAction } from "../actions/volumetracing_actions";
+import {
+  setMappingIsLockedAction,
+  setVolumeBucketDataHasChangedAction,
+} from "../actions/volumetracing_actions";
 import { MappingStatusEnum } from "oxalis/constants";
 
 export function* takeEveryUnlessBusy<P extends ActionPattern>(
@@ -113,4 +116,33 @@ export function* ensureMaybeActiveMappingIsLocked(
   }
 }
 
+export function* requestBucketModificationInVolumeTracing(
+  volumeTracing: VolumeTracing,
+): Saga<boolean> {
+  /*
+   * Should be called when the modification of bucket data is about to happen. If
+   * the saga returns false, the modification should be cancelled (this happens if
+   * the user is not okay with locking the mapping).
+   *
+   * In detail: When the bucket data of a volume tracing is supposed to be mutated, we need to do
+   * two things:
+   * 1) ensure that the current mapping (or no mapping) is locked so that the mapping is not
+   *    changed later (this would lead to inconsistent data). If the mapping state is not yet
+   *    locked, the user is asked whether it is okay to lock it.
+   *    If the user confirms this, the mapping is locked and we can continue with (2). If the
+   *    user denies the locking request, the original bucket mutation will NOT be executed.
+   * 2) volumeTracing.volumeBucketDataHasChanged will bet set to true if the user didn't
+   *    deny the request for locking the mapping.
+   */
+
+  const { isMappingLockedIfNeeded } = yield* call(ensureMaybeActiveMappingIsLocked, volumeTracing);
+  if (!isMappingLockedIfNeeded) {
+    return false;
+  }
+
+  // Mark that bucket data has changed
+  yield* put(setVolumeBucketDataHasChangedAction(volumeTracing.tracingId));
+  return true;
+}
+
 export default {};

frontend/javascripts/oxalis/model/sagas/volume/volume_interpolation_saga.ts

@@ -38,7 +38,7 @@ import { Model, api } from "oxalis/singletons";
 import type { OxalisState } from "oxalis/store";
 import { call, put } from "typed-redux-saga";
 import { createVolumeLayer, getBoundingBoxForViewport, labelWithVoxelBuffer2D } from "./helpers";
-import { ensureMaybeActiveMappingIsLocked } from "../saga_helpers";
+import { requestBucketModificationInVolumeTracing } from "../saga_helpers";
 
 /*
  * This saga is capable of doing segment interpolation between two slices.
@@ -436,8 +436,11 @@ export default function* maybeInterpolateSegmentationLayer(): Saga<void> {
     return;
   }
   // As the interpolation will be applied, the potentially existing mapping should be locked to ensure a consistent state.
-  const { isMappingLockedIfNeeded } = yield* call(ensureMaybeActiveMappingIsLocked, volumeTracing);
-  if (!isMappingLockedIfNeeded) {
+  const isModificationAllowed = yield* call(
+    requestBucketModificationInVolumeTracing,
+    volumeTracing,
+  );
+  if (!isModificationAllowed) {
     return;
   }
 

frontend/javascripts/oxalis/model/sagas/volumetracing_saga.tsx

@@ -82,7 +82,7 @@ import { select, take } from "oxalis/model/sagas/effect-generators";
 import listenToMinCut from "oxalis/model/sagas/min_cut_saga";
 import listenToQuickSelect from "oxalis/model/sagas/quick_select_saga";
 import {
-  ensureMaybeActiveMappingIsLocked,
+  requestBucketModificationInVolumeTracing,
   takeEveryUnlessBusy,
 } from "oxalis/model/sagas/saga_helpers";
 import {
@@ -223,11 +223,11 @@ export function* editVolumeLayerAsync(): Saga<any> {
 
     const activeCellId = yield* select((state) => enforceActiveVolumeTracing(state).activeCellId);
     // As changes to the volume layer will be applied, the potentially existing mapping should be locked to ensure a consistent state.
-    const { isMappingLockedIfNeeded } = yield* call(
-      ensureMaybeActiveMappingIsLocked,
+    const isModificationAllowed = yield* call(
+      requestBucketModificationInVolumeTracing,
       volumeTracing,
     );
-    if (!isMappingLockedIfNeeded) {
+    if (!isModificationAllowed) {
       continue;
     }
 
@@ -453,11 +453,11 @@ export function* floodFill(): Saga<void> {
     }
     // As the flood fill will be applied to the volume layer,
     // the potentially existing mapping should be locked to ensure a consistent state.
-    const { isMappingLockedIfNeeded } = yield* call(
-      ensureMaybeActiveMappingIsLocked,
+    const isModificationAllowed = yield* call(
+      requestBucketModificationInVolumeTracing,
       volumeTracing,
     );
-    if (!isMappingLockedIfNeeded) {
+    if (!isModificationAllowed) {
       continue;
     }
     yield* put(setBusyBlockingInfoAction(true, "Floodfill is being computed."));
@@ -603,6 +603,7 @@ export function* finishLayer(
 
   yield* put(registerLabelPointAction(layer.getUnzoomedCentroid()));
 }
+
 export function* ensureToolIsAllowedInMag(): Saga<any> {
   yield* take("INITIALIZE_VOLUMETRACING");
 

frontend/javascripts/oxalis/store.ts

@@ -264,6 +264,7 @@ export type VolumeTracing = TracingBase & {
   readonly hasEditableMapping?: boolean;
   readonly mappingIsLocked?: boolean;
   readonly hasSegmentIndex: boolean;
+  readonly volumeBucketDataHasChanged?: boolean;
 };
 export type ReadOnlyTracing = TracingBase & {
   readonly type: "readonly";

frontend/javascripts/oxalis/view/context_menu.tsx

@@ -131,6 +131,7 @@ import {
 import { hideContextMenuAction, setActiveUserBoundingBoxId } from "oxalis/model/actions/ui_actions";
 import { getDisabledInfoForTools } from "oxalis/model/accessors/tool_accessor";
 import FastTooltip from "components/fast_tooltip";
+import { LoadMeshMenuItemLabel } from "./right-border-tabs/segments_tab/load_mesh_menu_item_label";
 
 type ContextMenuContextValue = React.MutableRefObject<HTMLElement | null> | null;
 export const ContextMenuContext = createContext<ContextMenuContextValue>(null);
@@ -1179,7 +1180,9 @@ function getNoNodeContextMenuOptions(props: NoNodeContextMenuProps): ItemType[]
       segmentationLayerName,
       mappingInfo,
     ),
-    label: "Load Mesh (precomputed)",
+    label: (
+      <LoadMeshMenuItemLabel currentMeshFile={currentMeshFile} volumeTracing={volumeTracing} />
+    ),
   };
   const computeMeshAdHocItem = {
     key: "compute-mesh-adhc",
@@ -1434,12 +1437,13 @@ function ContextMenuInner(propsWithInputRef: Props) {
     maybeClickedMeshId != null ? maybeClickedMeshId : segmentIdAtPosition;
   const wasSegmentOrMeshClicked = clickedSegmentOrMeshId > 0;
 
-  const { dataset, tracing, flycam } = useSelector((state: OxalisState) => state);
+  const dataset = useSelector((state: OxalisState) => state.dataset);
   useEffect(() => {
     Store.dispatch(ensureSegmentIndexIsLoadedAction(visibleSegmentationLayer?.name));
   }, [visibleSegmentationLayer]);
-  const isSegmentIndexAvailable = useSelector((state: OxalisState) =>
-    getMaybeSegmentIndexAvailability(state.dataset, visibleSegmentationLayer?.name),
+  const isSegmentIndexAvailable = getMaybeSegmentIndexAvailability(
+    dataset,
+    visibleSegmentationLayer?.name,
   );
   const mappingName: string | null | undefined = useSelector((state: OxalisState) => {
     if (volumeTracing?.mappingName != null) return volumeTracing?.mappingName;
@@ -1453,6 +1457,7 @@ function ContextMenuInner(propsWithInputRef: Props) {
   const isLoadingVolumeAndBB = [isLoadingMessage, isLoadingMessage];
   const [segmentVolumeLabel, boundingBoxInfoLabel] = useFetch(
     async () => {
+      const { tracing, flycam } = Store.getState();
       // The value that is returned if the context menu is closed is shown if it's still loading
       if (contextMenuPosition == null || !wasSegmentOrMeshClicked) return isLoadingVolumeAndBB;
       if (visibleSegmentationLayer == null || !isSegmentIndexAvailable) return [];

frontend/javascripts/oxalis/view/right-border-tabs/segments_tab/load_mesh_menu_item_label.tsx

@@ -0,0 +1,37 @@
+import { WarningOutlined } from "@ant-design/icons";
+import FastTooltip from "components/fast_tooltip";
+import type { VolumeTracing } from "oxalis/store";
+import type { APIMeshFile } from "types/api_flow_types";
+
+type Props = {
+  currentMeshFile: APIMeshFile | null | undefined;
+  volumeTracing: VolumeTracing | null | undefined;
+};
+
+export function LoadMeshMenuItemLabel({ currentMeshFile, volumeTracing }: Props) {
+  const showWarning =
+    volumeTracing?.volumeBucketDataHasChanged ??
+    // For older annotations, volumeBucketDataHasChanged can be undefined.
+    // In that case, we still want to show a warning if no proofreading was
+    // done, but the mapping is still locked (i.e., the user brushed).
+    (!volumeTracing?.hasEditableMapping && volumeTracing?.mappingIsLocked);
+
+  return (
+    <span style={{ display: "flex", alignItems: "center", gap: "4px" }}>
+      <FastTooltip
+        title={
+          currentMeshFile != null
+            ? `Load mesh for centered segment from file ${currentMeshFile.meshFileName}`
+            : "There is no mesh file."
+        }
+      >
+        <span>Load Mesh (precomputed)</span>
+      </FastTooltip>
+      {showWarning && (
+        <FastTooltip title="Warning: The segmentation data has changed since the mesh file was created. The mesh may not match the current data.">
+          <WarningOutlined style={{ color: "var(--ant-color-warning)" }} />
+        </FastTooltip>
+      )}
+    </span>
+  );
+}