live update to proofreading actions

Author: philippotto

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

@@ -24,13 +24,13 @@ import type {
   SetMappingNameAction,
 } from "viewer/model/actions/settings_actions";
 import {
-  removeSegmentAction,
-  updateSegmentAction,
   type ClickSegmentAction,
   type RemoveSegmentAction,
   type SetSegmentsAction,
   type UpdateSegmentAction,
   type VolumeTracingAction,
+  removeSegmentAction,
+  updateSegmentAction,
 } from "viewer/model/actions/volumetracing_actions";
 import { updateKey2 } from "viewer/model/helpers/deep_update";
 import {
@@ -714,6 +714,7 @@ function VolumeTracingReducer(
           }
         }
       }
+      break;
     }
 
     default:

frontend/javascripts/viewer/model/sagas/mapping_saga.ts

@@ -257,7 +257,7 @@ function* watchChangedBucketsForLayer(layerName: string): Saga<never> {
     const mappingInfo = yield* select((state) =>
       getMappingInfo(state.temporaryConfiguration.activeMappingByLayer, layerName),
     );
-    const { mappingName, mappingType, mappingStatus } = mappingInfo;
+    const { mappingName, mappingStatus } = mappingInfo;
 
     if (mappingName == null || mappingStatus !== MappingStatusEnum.ENABLED) {
       return;
@@ -271,7 +271,7 @@ function* watchChangedBucketsForLayer(layerName: string): Saga<never> {
       let isBusy = yield* select((state) => state.uiInformation.busyBlockingInfo.isBusy);
       if (!isBusy) {
         const { cancel } = yield* race({
-          updateHdf5: call(updateLocalHdf5Mapping, layerName, layerInfo, mappingName, mappingType),
+          updateHdf5: call(updateLocalHdf5Mapping, layerName, layerInfo, mappingName),
           cancel: take(
             ((action: Action) =>
               action.type === "SET_BUSY_BLOCKING_INFO_ACTION" &&
@@ -397,7 +397,6 @@ function* handleSetMapping(
       layerName,
       layerInfo,
       mappingName,
-      mappingType,
       action,
       oldActiveMappingByLayer,
     );
@@ -408,23 +407,21 @@ function* handleSetHdf5Mapping(
   layerName: string,
   layerInfo: APIDataLayer,
   mappingName: string,
-  mappingType: MappingType,
   action: SetMappingAction,
   oldActiveMappingByLayer: Container<Record<string, ActiveMappingInfo>>,
 ): Saga<void> {
   if (yield* select((state) => getNeedsLocalHdf5Mapping(state, layerName))) {
-    yield* call(updateLocalHdf5Mapping, layerName, layerInfo, mappingName, mappingType);
+    yield* call(updateLocalHdf5Mapping, layerName, layerInfo, mappingName);
   } else {
     // An HDF5 mapping was set that is applied remotely. A reload is necessary.
     yield* call(reloadData, oldActiveMappingByLayer, action);
   }
 }
 
-function* updateLocalHdf5Mapping(
+export function* updateLocalHdf5Mapping(
   layerName: string,
   layerInfo: APIDataLayer,
   mappingName: string,
-  mappingType: MappingType,
 ): Saga<void> {
   const dataset = yield* select((state) => state.dataset);
   const annotation = yield* select((state) => state.annotation);
@@ -490,7 +487,7 @@ function* updateLocalHdf5Mapping(
     onlyB: newSegmentIds,
   });
 
-  yield* put(setMappingAction(layerName, mappingName, mappingType, { mapping }));
+  yield* put(setMappingAction(layerName, mappingName, "HDF5", { mapping }));
 }
 
 function* handleSetJsonMapping(

frontend/javascripts/viewer/model/sagas/proofread_saga.ts

@@ -395,17 +395,13 @@ function* handleSkeletonProofreadingAction(action: Action): Saga<void> {
         volumeTracingId,
       ),
     );
-    const mergedMapping = yield* call(
-      mergeAgglomeratesInMapping,
+    yield* call(
+      updateMappingWithMerge,
+      volumeTracingId,
       activeMapping,
       targetAgglomerateId,
       sourceAgglomerateId,
     );
-    yield* put(
-      setMappingAction(volumeTracingId, activeMapping.mappingName, activeMapping.mappingType, {
-        mapping: mergedMapping,
-      }),
-    );
   } else if (action.type === "DELETE_EDGE") {
     if (sourceAgglomerateId !== targetAgglomerateId) {
       Toast.error("Segments that should be split need to be in the same agglomerate.");
@@ -740,18 +736,13 @@ function* handleProofreadMergeOrMinCut(action: Action) {
       sourceInfo.unmappedId,
       targetInfo.unmappedId,
     );
-    const mergedMapping = yield* call(
-      mergeAgglomeratesInMapping,
+    yield* call(
+      updateMappingWithMerge,
+      volumeTracingId,
       activeMapping,
       targetAgglomerateId,
       sourceAgglomerateId,
     );
-
-    yield* put(
-      setMappingAction(volumeTracingId, activeMapping.mappingName, activeMapping.mappingType, {
-        mapping: mergedMapping,
-      }),
-    );
   } else if (action.type === "MIN_CUT_AGGLOMERATE") {
     if (sourceInfo.unmappedId === targetInfo.unmappedId) {
       Toast.error(
@@ -1248,10 +1239,9 @@ function* getPositionForSegmentId(volumeTracing: VolumeTracing, segmentId: numbe
   return position;
 }
 
-function* splitAgglomerateInMapping(
+function getSegmentIdsThatMapToAgglomerate(
   activeMapping: ActiveMappingInfo,
   sourceAgglomerateId: number,
-  volumeTracingId: string,
 ) {
   // Obtain all segment ids that map to sourceAgglomerateId
   const mappingEntries = Array.from(activeMapping.mapping as NumberLikeMap);
@@ -1263,10 +1253,17 @@ function* splitAgglomerateInMapping(
 
   // If the mapping contains BigInts, we need a BigInt for the filtering
   const comparableSourceAgglomerateId = adaptToType(sourceAgglomerateId);
-  const splitSegmentIds = mappingEntries
+  return mappingEntries
     .filter(([_segmentId, agglomerateId]) => agglomerateId === comparableSourceAgglomerateId)
     .map(([segmentId, _agglomerateId]) => segmentId);
+}
 
+function* splitAgglomerateInMapping(
+  activeMapping: ActiveMappingInfo,
+  sourceAgglomerateId: number,
+  volumeTracingId: string,
+) {
+  const splitSegmentIds = getSegmentIdsThatMapToAgglomerate(activeMapping, sourceAgglomerateId);
   const annotationId = yield* select((state) => state.annotation.annotationId);
   const tracingStoreUrl = yield* select((state) => state.annotation.tracingStore.url);
   // Ask the server to map the (split) segment ids. This creates a partial mapping
@@ -1313,6 +1310,61 @@ function mergeAgglomeratesInMapping(
   ) as Mapping;
 }
 
+export function* updateMappingWithMerge(
+  volumeTracingId: string,
+  activeMapping: ActiveMappingInfo,
+  targetAgglomerateId: number,
+  sourceAgglomerateId: number,
+) {
+  const mergedMapping = yield* call(
+    mergeAgglomeratesInMapping,
+    activeMapping,
+    targetAgglomerateId,
+    sourceAgglomerateId,
+  );
+  yield* put(
+    setMappingAction(volumeTracingId, activeMapping.mappingName, activeMapping.mappingType, {
+      mapping: mergedMapping,
+    }),
+  );
+}
+
+export function* updateMappingWithOmittedSplitPartners(
+  volumeTracingId: string,
+  activeMapping: ActiveMappingInfo,
+  sourceAgglomerateId: number,
+) {
+  /*
+   * sourceAgglomerateId was split. All segment ids that were mapped to sourceAgglomerateId,
+   * are removed from the activeMapping by this function.
+   * The return value of this function is the list of segment ids that were removed.
+   */
+
+  const mappingEntries = Array.from(activeMapping.mapping as NumberLikeMap);
+
+  const adaptToType =
+    mappingEntries.length > 0 && isBigInt(mappingEntries[0][0])
+      ? (el: number) => BigInt(el)
+      : (el: number) => el;
+  // If the mapping contains BigInts, we need a BigInt for the filtering
+  const comparableSourceAgglomerateId = adaptToType(sourceAgglomerateId);
+
+  const newMapping = new Map();
+
+  for (const entry of mappingEntries) {
+    const [key, value] = entry;
+    if (value !== comparableSourceAgglomerateId) {
+      newMapping.set(key, value);
+    }
+  }
+
+  yield* put(
+    setMappingAction(volumeTracingId, activeMapping.mappingName, activeMapping.mappingType, {
+      mapping: newMapping,
+    }),
+  );
+}
+
 function* gatherInfoForOperation(
   action: ProofreadMergeAction | MinCutAgglomerateWithPositionAction,
   preparation: Preparation,

frontend/javascripts/viewer/model/sagas/save_saga.ts

@@ -12,7 +12,11 @@ import messages from "messages";
 import { call, delay, fork, put, race, take, takeEvery } from "typed-redux-saga";
 import type { APIUpdateActionBatch } from "types/api_types";
 import { ControlModeEnum } from "viewer/constants";
-import { getMagInfo } from "viewer/model/accessors/dataset_accessor";
+import {
+  getLayerByName,
+  getMagInfo,
+  getMappingInfo,
+} from "viewer/model/accessors/dataset_accessor";
 import { selectTracing } from "viewer/model/accessors/tracing_accessor";
 import { FlycamActions } from "viewer/model/actions/flycam_actions";
 import {
@@ -29,9 +33,9 @@ import {
 } from "viewer/model/actions/skeletontracing_actions";
 import { ViewModeSaveRelevantActions } from "viewer/model/actions/view_mode_actions";
 import {
-  applyVolumeUpdateActionsFromServerAction,
   type InitializeVolumeTracingAction,
   VolumeTracingSaveRelevantActions,
+  applyVolumeUpdateActionsFromServerAction,
 } from "viewer/model/actions/volumetracing_actions";
 import compactSaveQueue from "viewer/model/helpers/compaction/compact_save_queue";
 import compactUpdateActions from "viewer/model/helpers/compaction/compact_update_actions";
@@ -65,6 +69,8 @@ import type {
 } from "viewer/store";
 import { getFlooredPosition, getRotation } from "../accessors/flycam_accessor";
 import type { BatchedAnnotationInitializationAction } from "../actions/annotation_actions";
+import { updateLocalHdf5Mapping } from "./mapping_saga";
+import { updateMappingWithMerge, updateMappingWithOmittedSplitPartners } from "./proofread_saga";
 import { takeEveryWithBatchActionSupport } from "./saga_helpers";
 
 const ONE_YEAR_MS = 365 * 24 * 3600 * 1000;
@@ -490,7 +496,7 @@ const VERSION_POLL_INTERVAL_READ_ONLY = 1 * 1000;
 const VERSION_POLL_INTERVAL_SINGLE_EDITOR = 1 * 1000;
 
 function* watchForSaveConflicts(): Saga<never> {
-  function* checkForNewVersion(): boolean {
+  function* checkForNewVersion(): Saga<boolean> {
     /*
      * Checks whether there is a newer version on the server. If so,
      * the saga tries to also update the current annotation to the newest
@@ -573,8 +579,7 @@ function* watchForSaveConflicts(): Saga<never> {
 
       console.log("newerActions", newerActions);
 
-      if (yield* canActionsBeIncorporated(newerActions)) {
-        yield* put(setVersionNumberAction(versionOnServer));
+      if (yield* tryToIncorporateActions(newerActions)) {
         return false;
       }
 
@@ -641,12 +646,18 @@ function* watchForSaveConflicts(): Saga<never> {
       // @ts-ignore
       ErrorHandling.notify(exception);
       // todop: remove again?
-      Toast.error(exception);
+      Toast.error(`${exception}`);
     }
   }
 }
 
-function* canActionsBeIncorporated(newerActions: APIUpdateActionBatch[]): Saga<boolean> {
+function* tryToIncorporateActions(newerActions: APIUpdateActionBatch[]): Saga<boolean> {
+  const refreshFunctionByTracing: Record<string, () => Saga<void>> = {};
+  function* finalize() {
+    for (const fn of Object.values(refreshFunctionByTracing)) {
+      yield* call(fn);
+    }
+  }
   for (const actionBatch of newerActions) {
     for (const action of actionBatch.value) {
       switch (action.name) {
@@ -712,6 +723,60 @@ function* canActionsBeIncorporated(newerActions: APIUpdateActionBatch[]): Saga<b
           break;
         }
 
+        // Proofreading
+        case "mergeAgglomerate": {
+          const activeMapping = yield* select(
+            (store) =>
+              store.temporaryConfiguration.activeMappingByLayer[action.value.actionTracingId],
+          );
+          yield* call(
+            updateMappingWithMerge,
+            action.value.actionTracingId,
+            activeMapping,
+            action.value.agglomerateId2,
+            action.value.agglomerateId1,
+          );
+          break;
+        }
+        case "splitAgglomerate": {
+          const activeMapping = yield* select(
+            (store) =>
+              store.temporaryConfiguration.activeMappingByLayer[action.value.actionTracingId],
+          );
+          yield* call(
+            updateMappingWithOmittedSplitPartners,
+            action.value.actionTracingId,
+            activeMapping,
+            action.value.agglomerateId,
+          );
+
+          const layerName = action.value.actionTracingId;
+
+          const mappingInfo = yield* select((state) =>
+            getMappingInfo(state.temporaryConfiguration.activeMappingByLayer, layerName),
+          );
+          const { mappingName } = mappingInfo;
+
+          if (mappingName == null) {
+            throw new Error(
+              "Could not apply splitAgglomerate because no active mapping was found.",
+            );
+          }
+
+          const dataset = yield* select((state) => state.dataset);
+          const layerInfo = getLayerByName(dataset, layerName);
+
+          refreshFunctionByTracing[layerName] = function* (): Saga<void> {
+            yield* call(updateLocalHdf5Mapping, layerName, layerInfo, mappingName);
+          };
+
+          break;
+        }
+
+        /*
+         * Currently not supported:
+         */
+
         // High-level annotation specific
         case "addLayerToAnnotation":
         case "addSegmentIndex":
@@ -725,13 +790,9 @@ function* canActionsBeIncorporated(newerActions: APIUpdateActionBatch[]): Saga<b
         // Volume
         case "removeFallbackLayer":
         case "updateSegmentGroups":
-        case "updateUserBoundingBoxesInVolumeTracing":
+        case "updateUserBoundingBoxesInVolumeTracing": // Wait for #8492 first.
         case "updateMappingName": // Refactor mapping activation first before implementing this.
 
-        // Proofreading
-        case "mergeAgglomerate":
-        case "splitAgglomerate":
-
         // Skeleton
         case "createTree":
         case "deleteEdge":
@@ -744,18 +805,21 @@ function* canActionsBeIncorporated(newerActions: APIUpdateActionBatch[]): Saga<b
         case "updateTreeGroups":
         case "moveTreeComponent":
         case "updateNode":
-        case "updateUserBoundingBoxesInSkeletonTracing":
+        case "updateUserBoundingBoxesInSkeletonTracing": // Wait for #8492 first.
 
         case "updateVolumeTracing": {
           console.log("cannot apply action", action.name);
+          yield* call(finalize);
           return false;
         }
         default: {
           action satisfies never;
         }
       }
     }
+    yield* put(setVersionNumberAction(actionBatch.version));
   }
+  yield* call(finalize);
   return true;
 }