Lock mapping once the volume annotation was changed by the user

CHANGELOG.unreleased.md

@@ -27,6 +27,7 @@ For upgrade instructions, please check the [migration guide](MIGRATIONS.released
 - Admins and Team Managers can now also download job exports for jobs of other users, if they have the link. [#7462](https://github.com/scalableminds/webknossos/pull/7462)
 - Updated some dependencies of the backend code (play 2.9, sbt 1.9, minor upgrades for others) for optimized performance. [#7366](https://github.com/scalableminds/webknossos/pull/7366)
 - Processing jobs can now be distributed to multiple webknossos-workers with finer-grained configurability. Compare migration guide. [#7463](https://github.com/scalableminds/webknossos/pull/7463)
+- HDF5 agglomerate mappings are now pinned to a volume annotation layer once the user performs a volume annotation action while a mapping is active. [#7549](https://github.com/scalableminds/webknossos/pull/7549)
 - Removed Swagger/OpenAPI json description of the HTTP API. [#7494](https://github.com/scalableminds/webknossos/pull/7494)
 - Updated antd UI library from version 4.24.8 to 4.24.15. [#7505](https://github.com/scalableminds/webknossos/pull/7505)
 - Changed the default dataset search mode to also search in subfolders. [#7539](https://github.com/scalableminds/webknossos/pull/7539)

frontend/javascripts/oxalis/model/accessors/volumetracing_accessor.ts

@@ -525,35 +525,56 @@ export function getMappingInfoForVolumeTracing(
   return getMappingInfo(state.temporaryConfiguration.activeMappingByLayer, tracingId);
 }
 
-export function hasEditableMapping(
+function getVolumeTracingForLayerName(
   state: OxalisState,
   layerName?: string | null | undefined,
-): boolean {
+): VolumeTracing | null | undefined {
   if (layerName != null) {
     // This needs to be checked before calling getRequestedOrDefaultSegmentationTracingLayer,
     // as the function will throw an error if layerName is given but a corresponding tracing layer
     // does not exist.
     const layer = getSegmentationLayerByName(state.dataset, layerName);
     const tracing = getTracingForSegmentationLayer(state, layer);
 
-    if (tracing == null) return false;
+    if (tracing == null) return null;
   }
 
   const volumeTracing = getRequestedOrDefaultSegmentationTracingLayer(state, layerName);
 
+  return volumeTracing;
+}
+
+export function hasEditableMapping(
+  state: OxalisState,
+  layerName?: string | null | undefined,
+): boolean {
+  const volumeTracing = getVolumeTracingForLayerName(state, layerName);
+
   if (volumeTracing == null) return false;
 
   return !!volumeTracing.mappingIsEditable;
 }
 
+export function isMappingPinned(
+  state: OxalisState,
+  layerName?: string | null | undefined,
+): boolean {
+  const volumeTracing = getVolumeTracingForLayerName(state, layerName);
+
+  if (volumeTracing == null) return false;
+
+  return !!volumeTracing.mappingIsPinned;
+}
+
 export function isMappingActivationAllowed(
   state: OxalisState,
   mappingName: string | null | undefined,
   layerName?: string | null | undefined,
 ): boolean {
   const isEditableMappingActive = hasEditableMapping(state, layerName);
+  const isActiveMappingPinned = isMappingPinned(state, layerName);
 
-  if (!isEditableMappingActive) return true;
+  if (!isEditableMappingActive && !isActiveMappingPinned) return true;
 
   const volumeTracing = getRequestedOrDefaultSegmentationTracingLayer(state, layerName);
 

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

@@ -43,6 +43,7 @@ export type RemoveSegmentAction = ReturnType<typeof removeSegmentAction>;
 export type DeleteSegmentDataAction = ReturnType<typeof deleteSegmentDataAction>;
 export type SetSegmentGroupsAction = ReturnType<typeof setSegmentGroupsAction>;
 export type SetMappingIsEditableAction = ReturnType<typeof setMappingIsEditableAction>;
+export type SetMappingIsPinnedAction = ReturnType<typeof setMappingIsPinnedAction>;
 
 export type ComputeQuickSelectForRectAction = ReturnType<typeof computeQuickSelectForRectAction>;
 export type MaybePrefetchEmbeddingAction = ReturnType<typeof maybePrefetchEmbeddingAction>;
@@ -89,6 +90,7 @@ export type VolumeTracingAction =
   | SetLargestSegmentIdAction
   | SetSelectedSegmentsOrGroupAction
   | SetMappingIsEditableAction
+  | SetMappingIsPinnedAction
   | InitializeEditableMappingAction
   | ComputeQuickSelectForRectAction
   | MaybePrefetchEmbeddingAction
@@ -356,6 +358,11 @@ export const setMappingIsEditableAction = () =>
     type: "SET_MAPPING_IS_EDITABLE",
   } as const);
 
+export const setMappingIsPinnedAction = () =>
+  ({
+    type: "SET_MAPPING_IS_PINNED",
+  } as const);
+
 export const computeQuickSelectForRectAction = (
   startPosition: Vector3,
   endPosition: Vector3,

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

@@ -229,6 +229,7 @@ export function serverVolumeToClientVolumeTracing(tracing: ServerVolumeTracing):
     userBoundingBoxes,
     mappingName: tracing.mappingName,
     mappingIsEditable: tracing.mappingIsEditable,
+    mappingIsPinned: tracing.mappingIsPinned,
     hasSegmentIndex: tracing.hasSegmentIndex || false,
     additionalAxes: convertServerAdditionalAxesToFrontEnd(tracing.additionalAxes),
   };
@@ -391,18 +392,27 @@ function VolumeTracingReducer(
 
     case "SET_MAPPING_NAME": {
       // Editable mappings cannot be disabled or switched for now
-      if (volumeTracing.mappingIsEditable) return state;
+      if (volumeTracing.mappingIsEditable || volumeTracing.mappingIsPinned) return state;
 
       const { mappingName, mappingType } = action;
       return setMappingNameReducer(state, volumeTracing, mappingName, mappingType);
     }
 
     case "SET_MAPPING_IS_EDITABLE": {
       // Editable mappings cannot be disabled or switched for now
-      if (volumeTracing.mappingIsEditable) return state;
+      // An editable mapping is always pinned.
+      if (volumeTracing.mappingIsEditable && volumeTracing.mappingIsPinned) return state;
 
       return updateVolumeTracing(state, volumeTracing.tracingId, {
         mappingIsEditable: true,
+        mappingIsPinned: true,
+      });
+    }
+    case "SET_MAPPING_IS_PINNED": {
+      if (volumeTracing.mappingIsPinned) return state;
+
+      return updateVolumeTracing(state, volumeTracing.tracingId, {
+        mappingIsPinned: true,
       });
     }
 

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

@@ -413,10 +413,11 @@ export function serverCreateTracing(timestamp: number) {
 export function updateMappingName(
   mappingName: string | null | undefined,
   isEditable: boolean | undefined,
+  isPinned: boolean | undefined,
 ) {
   return {
     name: "updateMappingName",
-    value: { mappingName, isEditable },
+    value: { mappingName, isEditable, isPinned },
   } as const;
 }
 export function splitAgglomerate(

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

@@ -57,6 +57,7 @@ import type {
 } from "oxalis/model/actions/annotation_actions";
 import { addUserBoundingBoxAction } from "oxalis/model/actions/annotation_actions";
 import {
+  setMappingNameAction,
   updateTemporarySettingAction,
   updateUserSettingAction,
 } from "oxalis/model/actions/settings_actions";
@@ -70,6 +71,7 @@ import type {
 import {
   finishAnnotationStrokeAction,
   registerLabelPointAction,
+  setMappingIsPinnedAction,
   setSelectedSegmentsOrGroupAction,
   updateSegmentAction,
 } from "oxalis/model/actions/volumetracing_actions";
@@ -214,6 +216,25 @@ export function* editVolumeLayerAsync(): Saga<any> {
     }
 
     const activeCellId = yield* select((state) => enforceActiveVolumeTracing(state).activeCellId);
+    const activeMappingByLayer = yield* select(
+      (state) => state.temporaryConfiguration.activeMappingByLayer,
+    );
+    const isSomeMappingActive = volumeTracing.tracingId in activeMappingByLayer;
+    if (isSomeMappingActive && !volumeTracing.mappingIsPinned) {
+      // A mapping that is active and is annotated on needs to be pinned to ensure a consistent state in the future.
+      // See https://github.com/scalableminds/webknossos/issues/5431 for more information.
+      const activeMapping = activeMappingByLayer[volumeTracing.tracingId];
+      if (activeMapping.mappingName) {
+        yield* put(
+          setMappingNameAction(
+            volumeTracing.tracingId,
+            activeMapping.mappingName,
+            activeMapping.mappingType,
+          ),
+        );
+        yield* put(setMappingIsPinnedAction());
+      }
+    }
 
     if (isDrawing && activeCellId === 0) {
       yield* call(
@@ -670,8 +691,16 @@ export function* diffVolumeTracing(
       yield removeFallbackLayer();
     }
 
-    if (prevVolumeTracing.mappingName !== volumeTracing.mappingName) {
-      yield updateMappingName(volumeTracing.mappingName, volumeTracing.mappingIsEditable);
+    if (
+      prevVolumeTracing.mappingName !== volumeTracing.mappingName ||
+      prevVolumeTracing.mappingIsPinned !== volumeTracing.mappingIsPinned
+    ) {
+      const action = updateMappingName(
+        volumeTracing.mappingName,
+        volumeTracing.mappingIsEditable,
+        volumeTracing.mappingIsPinned,
+      );
+      yield action;
     }
   }
 }

frontend/javascripts/oxalis/store.ts

@@ -254,6 +254,7 @@ export type VolumeTracing = TracingBase & {
   readonly fallbackLayer?: string;
   readonly mappingName?: string | null | undefined;
   readonly mappingIsEditable?: boolean;
+  readonly mappingIsPinned?: boolean;
   readonly hasSegmentIndex: boolean;
 };
 export type ReadOnlyTracing = TracingBase & {

frontend/javascripts/oxalis/view/left-border-tabs/mapping_settings_view.tsx

@@ -25,6 +25,7 @@ import * as Utils from "libs/utils";
 import {
   getEditableMappingForVolumeTracingId,
   hasEditableMapping,
+  isMappingPinned,
 } from "oxalis/model/accessors/volumetracing_accessor";
 
 const { Option, OptGroup } = Select;
@@ -43,6 +44,7 @@ type StateProps = {
   mappingType: MappingType;
   mappingColors: Array<number> | null | undefined;
   editableMapping: EditableMapping | null | undefined;
+  isMappingPinned: boolean;
   isMergerModeEnabled: boolean;
   allowUpdate: boolean;
   isEditableMappingActive: boolean;
@@ -91,7 +93,6 @@ class MappingSettingsView extends React.Component<Props, State> {
   handleChangeHideUnmappedSegments = (hideUnmappedIds: boolean) => {
     this.props.setHideUnmappedIds(this.props.layerName, hideUnmappedIds);
   };
-
   handleChangeMapping = (packedMappingNameWithCategory: string): void => {
     const [mappingName, mappingType] = unpackMappingNameAndCategory(packedMappingNameWithCategory);
 
@@ -173,6 +174,7 @@ class MappingSettingsView extends React.Component<Props, State> {
       (shouldMappingBeEnabled || this.props.isMergerModeEnabled) &&
       this.props.mapping &&
       this.props.hideUnmappedIds != null;
+    const isDisabled = this.props.isEditableMappingActive || this.props.isMappingPinned;
     return (
       <React.Fragment>
         {
@@ -191,7 +193,7 @@ class MappingSettingsView extends React.Component<Props, State> {
                   label="ID Mapping"
                   // Assume that the mappings are being loaded if they are null
                   loading={shouldMappingBeEnabled && this.props.segmentationLayer?.mappings == null}
-                  disabled={this.props.isEditableMappingActive}
+                  disabled={isDisabled}
                 />
               </div>
 
@@ -210,7 +212,7 @@ class MappingSettingsView extends React.Component<Props, State> {
                   {...selectValueProp}
                   onChange={this.handleChangeMapping}
                   notFoundContent="No mappings found."
-                  disabled={this.props.isEditableMappingActive}
+                  disabled={isDisabled}
                 >
                   {renderCategoryOptions(availableMappings, "JSON")}
                   {renderCategoryOptions(availableAgglomerates, "HDF5")}
@@ -262,6 +264,7 @@ function mapStateToProps(state: OxalisState, ownProps: OwnProps) {
     allowUpdate: state.tracing.restrictions.allowUpdate,
     editableMapping,
     isEditableMappingActive: hasEditableMapping(state, ownProps.layerName),
+    isMappingPinned: isMappingPinned(state, ownProps.layerName),
   };
 }
 

frontend/javascripts/test/sagas/volumetracing/volumetracing_saga.spec.ts

@@ -12,13 +12,15 @@ import { convertFrontendBoundingBoxToServer } from "oxalis/model/reducers/reduce
 import { enforce } from "libs/utils";
 import { pushSaveQueueTransaction } from "oxalis/model/actions/save_actions";
 import * as VolumeTracingActions from "oxalis/model/actions/volumetracing_actions";
+import { setMappingNameAction } from "oxalis/model/actions/settings_actions";
 import VolumeTracingReducer from "oxalis/model/reducers/volumetracing_reducer";
 import defaultState from "oxalis/default_state";
 import mockRequire from "mock-require";
 import sinon from "sinon";
 import test from "ava";
 import { expectValueDeepEqual, execCall } from "test/helpers/sagaHelpers";
 import { withoutUpdateTracing } from "test/helpers/saveHelpers";
+import { ActiveMappingInfo } from "oxalis/store";
 
 mockRequire("app", {
   currentUser: {
@@ -109,6 +111,18 @@ const initialState = update(defaultState, {
     },
   },
 });
+
+const dummyActiveMapping: ActiveMappingInfo = {
+  mappingName: "dummy-mapping-name",
+  mapping: {},
+  mappingKeys: [],
+  mappingColors: [],
+  hideUnmappedIds: false,
+  mappingStatus: "ENABLED",
+  mappingSize: 0,
+  mappingType: "HDF5",
+};
+
 const ACTIVE_CELL_ID = 5;
 const setActiveCellAction = VolumeTracingActions.setActiveCellAction(ACTIVE_CELL_ID);
 const startEditingAction = VolumeTracingActions.startEditingAction([0, 0, 0], OrthoViews.PLANE_XY);
@@ -185,6 +199,7 @@ test("VolumeTracingSaga should create a volume layer (saga test)", (t) => {
     zoomStep: 0,
   });
   saga.next(ACTIVE_CELL_ID); // pass active cell id
+  saga.next({});
   expectValueDeepEqual(
     t,
     saga.next([]), // pass empty additional coords
@@ -225,6 +240,7 @@ test("VolumeTracingSaga should add values to volume layer (saga test)", (t) => {
   }); // pass labeled resolution
 
   saga.next(ACTIVE_CELL_ID); // pass active cell id
+  saga.next({});
   expectValueDeepEqual(
     t,
     saga.next([]), // pass empty additional coords
@@ -275,6 +291,7 @@ test("VolumeTracingSaga should finish a volume layer (saga test)", (t) => {
   }); // pass labeled resolution
 
   saga.next(ACTIVE_CELL_ID); // pass active cell id
+  saga.next({});
   expectValueDeepEqual(
     t,
     saga.next([]), // pass empty additional coords
@@ -332,6 +349,7 @@ test("VolumeTracingSaga should finish a volume layer in delete mode (saga test)"
     zoomStep: 0,
   }); // pass labeled resolution
   saga.next(ACTIVE_CELL_ID); // pass active cell id
+  saga.next({});
   expectValueDeepEqual(
     t,
     saga.next([]), // pass empty additional coords
@@ -386,3 +404,40 @@ test("VolumeTracingSaga should ignore brush action when busy (saga test)", (t) =
     take("START_EDITING"),
   );
 });
+
+test("VolumeTracingSaga should pin an active mapping upon first volume annotation", (t) => {
+  const saga = editVolumeLayerAsync();
+  saga.next();
+  saga.next();
+  expectValueDeepEqual(t, saga.next(true), take("START_EDITING"));
+  saga.next(startEditingAction);
+  saga.next({
+    isBusy: false,
+  });
+  saga.next(volumeTracing);
+  saga.next(OverwriteModeEnum.OVERWRITE_ALL);
+  saga.next(AnnotationToolEnum.BRUSH);
+  saga.next(false);
+  // pass labeled resolution
+  saga.next({
+    resolution: [1, 1, 1],
+    zoomStep: 0,
+  });
+  saga.next(ACTIVE_CELL_ID); // pass active cell id
+  expectValueDeepEqual(
+    t,
+    saga.next({ [volumeTracing.tracingId]: dummyActiveMapping }),
+    put(
+      setMappingNameAction(
+        volumeTracing.tracingId,
+        dummyActiveMapping.mappingName as string,
+        dummyActiveMapping.mappingType,
+      ),
+    ),
+  );
+  expectValueDeepEqual(
+    t,
+    saga.next([]), // pass empty additional coords
+    put(VolumeTracingActions.setMappingIsPinnedAction()),
+  );
+});

frontend/javascripts/types/api_flow_types.ts

@@ -765,6 +765,7 @@ export type ServerVolumeTracing = ServerTracingBase & {
   resolutions?: Array<Point3>;
   mappingName?: string | null | undefined;
   mappingIsEditable?: boolean;
+  mappingIsPinned?: boolean;
   hasSegmentIndex?: boolean;
 };
 export type ServerTracing = ServerSkeletonTracing | ServerVolumeTracing;