Per-User State in Annotations: Camera, Visibility Toggles

CHANGELOG.unreleased.md

@@ -18,6 +18,7 @@ For upgrade instructions, please check the [migration guide](MIGRATIONS.released
 - Added the possibility for super users to retry manually cancelled jobs from the jobs list. [#8629](https://github.com/scalableminds/webknossos/pull/8629)
 - Added checkboxes to the segments tab that allow to show/hide individual segments. The visibility of segments that are not listed in the segments list can be controlled with a new "Hide unlisted segments" toggle in the layer settings. Additionally, you can right-click a segment in a data viewport and select "Only show this segment" (and similar functionality). [#8546](https://github.com/scalableminds/webknossos/pull/8546)
 - Instead of pasting a dataset position from the clipboard to the position input box, you can simply paste it without focussing the position input first. Furthermore, you can also paste a "hash string", such as `#1406,1794,1560,0,0.234,186`, as it can be found in WK URLs. Pasting such a string will also set the encoded zoom, rotation, viewport etc. Note that the `#` has to be included in the pasted text. You can also copy and paste an entire link, but note that the dataset or annotation id in the link will be ignored. [#8652](https://github.com/scalableminds/webknossos/pull/8652)
+- In shared annotations with multiple authors, some changes are now stored per user. This means that other users won’t see all those changes if their own diverge. This includes the current position and zoom, visibilities of trees, bounding boxes, and segments (as specified with the checkboxes in the lists), as well as which groups are expanded in the lists. The annotation owner’s user state is used as a fallback for users who haven’t explicitly changed these values themselves. [#8542](https://github.com/scalableminds/webknossos/pull/8542)
 
 ### Changed
 - Remove `data.maybe` dependency and replaced with regular Typescript types. [#8563](https://github.com/scalableminds/webknossos/pull/8563)

app/controllers/AnnotationController.scala

@@ -420,6 +420,8 @@ class AnnotationController @Inject()(
       newAnnotationProto <- tracingStoreClient.duplicateAnnotation(
         annotation._id,
         newAnnotationId,
+        annotation._user,
+        user._id,
         version = None,
         isFromTask = annotation._task.isDefined,
         datasetBoundingBox = dataSource.map(_.boundingBox)

app/controllers/AnnotationIOController.scala

@@ -413,7 +413,7 @@ class AnnotationIOController @Inject()(
 
   private def downloadExplorational(annotationId: ObjectId,
                                     typ: String,
-                                    issuingUser: Option[User],
+                                    requestingUser: Option[User],
                                     version: Option[Long],
                                     skipVolumeData: Boolean,
                                     volumeDataZipFormat: VolumeDataZipFormat)(implicit ctx: DBAccessContext) = {
@@ -425,10 +425,12 @@ class AnnotationIOController @Inject()(
         tracingStoreClient <- tracingStoreService.clientFor(dataset)
         fetchedAnnotationLayers <- Fox.serialCombined(annotation.skeletonAnnotationLayers)(
           tracingStoreClient.getSkeletonTracing(annotation._id, _, version))
+        annotationProto <- tracingStoreClient.getAnnotationProto(annotation._id, version)
         user <- userService.findOneCached(annotation._user)(GlobalAccessContext)
         taskOpt <- Fox.runOptional(annotation._task)(taskDAO.findOne)
         nmlStream = nmlWriter.toNmlStream(
           "temp",
+          annotationProto,
           fetchedAnnotationLayers,
           Some(annotation),
           dataset.voxelSize,
@@ -437,10 +439,11 @@ class AnnotationIOController @Inject()(
           conf.Http.uri,
           dataset.name,
           dataset._id,
-          Some(user),
+          user,
           taskOpt,
           skipVolumeData,
-          volumeDataZipFormat
+          volumeDataZipFormat,
+          requestingUser
         )
         nmlTemporaryFile = tempFileService.create()
         temporaryFileStream = new BufferedOutputStream(new FileOutputStream(new File(nmlTemporaryFile.toString)))
@@ -469,8 +472,10 @@ class AnnotationIOController @Inject()(
         } ?~> "annotation.download.fetchSkeletonLayer.failed"
         user <- userService.findOneCached(annotation._user)(GlobalAccessContext) ?~> "annotation.download.findUser.failed"
         taskOpt <- Fox.runOptional(annotation._task)(taskDAO.findOne(_)(GlobalAccessContext)) ?~> "task.notFound"
+        annotationProto <- tracingStoreClient.getAnnotationProto(annotation._id, version)
         nmlStream = nmlWriter.toNmlStream(
           name,
+          annotationProto,
           fetchedSkeletonLayers ::: fetchedVolumeLayers,
           Some(annotation),
           dataset.voxelSize,
@@ -479,10 +484,11 @@ class AnnotationIOController @Inject()(
           conf.Http.uri,
           dataset.name,
           dataset._id,
-          Some(user),
+          user,
           taskOpt,
           skipVolumeData,
-          volumeDataZipFormat
+          volumeDataZipFormat,
+          requestingUser
         )
         temporaryFile = tempFileService.create()
         zipper = ZipIO.startZip(new BufferedOutputStream(new FileOutputStream(new File(temporaryFile.toString))))
@@ -520,13 +526,13 @@ class AnnotationIOController @Inject()(
         zipMimeType
 
     for {
-      annotation <- provider.provideAnnotation(typ, annotationId, issuingUser) ~> NOT_FOUND
+      annotation <- provider.provideAnnotation(typ, annotationId, requestingUser) ~> NOT_FOUND
       restrictions <- provider.restrictionsFor(typ, annotationId) ?~> "annotation.restrictions.unavailable"
       name <- provider.nameFor(annotation) ?~> "annotation.name.impossible"
       fileExtension = exportExtensionForAnnotation(annotation)
       fileName = name + fileExtension
       mimeType = exportMimeTypeForAnnotation(annotation)
-      _ <- restrictions.allowDownload(issuingUser) ?~> "annotation.download.notAllowed" ~> FORBIDDEN
+      _ <- restrictions.allowDownload(requestingUser) ?~> "annotation.download.notAllowed" ~> FORBIDDEN
       dataset <- datasetDAO.findOne(annotation._dataset)(GlobalAccessContext) ?~> "dataset.notFoundForAnnotation" ~> NOT_FOUND
       organization <- organizationDAO.findOne(dataset._organization)(GlobalAccessContext) ?~> "organization.notFound" ~> NOT_FOUND
       temporaryFile <- annotationToTemporaryFile(dataset, annotation, name, organization._id) ?~> "annotation.writeTemporaryFile.failed"

app/controllers/TaskController.scala

@@ -67,7 +67,8 @@ class TaskController @Inject()(taskCreationService: TaskCreationService,
         taskParametersFull <- taskCreationService.createTracingsFromBaseAnnotations(taskParametersWithIds,
                                                                                     taskType,
                                                                                     dataset,
-                                                                                    dataSource)
+                                                                                    dataSource,
+                                                                                    request.identity._id)
         skeletonBaseOpts: List[Option[SkeletonTracing]] = taskCreationService.createTaskSkeletonTracingBases(
           taskParametersFull)
         volumeBaseOpts: List[Option[(VolumeTracing, Option[File])]] <- taskCreationService.createTaskVolumeTracingBases(

app/models/annotation/AnnotationLayerPrecedence.scala

@@ -2,14 +2,15 @@ package models.annotation
 
 import com.scalableminds.util.objectid.ObjectId
 import com.scalableminds.util.tools.{Fox, FoxImplicits}
-import com.scalableminds.webknossos.datastore.SkeletonTracing.SkeletonTracing
-import com.scalableminds.webknossos.datastore.VolumeTracing.VolumeTracing
+import com.scalableminds.webknossos.datastore.SkeletonTracing.{SkeletonTracing, SkeletonUserStateProto}
+import com.scalableminds.webknossos.datastore.VolumeTracing.{VolumeTracing, VolumeUserStateProto}
 import com.scalableminds.webknossos.datastore.geometry.{
   AdditionalCoordinateProto,
   NamedBoundingBoxProto,
   Vec3DoubleProto,
   Vec3IntProto
 }
+import com.scalableminds.webknossos.datastore.helpers.SkeletonTracingDefaults
 import com.scalableminds.webknossos.datastore.models.annotation.{
   AnnotationLayer,
   AnnotationLayerType,
@@ -27,6 +28,7 @@ case class RedundantTracingProperties(
     zoomLevel: Double,
     userBoundingBoxes: Seq[NamedBoundingBoxProto],
     editPositionAdditionalCoordinates: Seq[AdditionalCoordinateProto],
+    userStateBoundingBoxVisibilities: Map[String, (Seq[Int], Seq[Boolean])] // UserId → (bboxIds bboxVisibleStates)
 )
 
 trait AnnotationLayerPrecedence extends FoxImplicits {
@@ -54,7 +56,8 @@ trait AnnotationLayerPrecedence extends FoxImplicits {
         editRotation = p.editRotation,
         zoomLevel = p.zoomLevel,
         userBoundingBoxes = p.userBoundingBoxes,
-        editPositionAdditionalCoordinates = p.editPositionAdditionalCoordinates
+        editPositionAdditionalCoordinates = p.editPositionAdditionalCoordinates,
+        userStates = adaptSkeletonUserStates(skeletonTracing.userStates, p)
       )
     }.getOrElse(skeletonTracing)
 
@@ -66,10 +69,63 @@ trait AnnotationLayerPrecedence extends FoxImplicits {
         editRotation = p.editRotation,
         zoomLevel = p.zoomLevel,
         userBoundingBoxes = p.userBoundingBoxes,
-        editPositionAdditionalCoordinates = p.editPositionAdditionalCoordinates
+        editPositionAdditionalCoordinates = p.editPositionAdditionalCoordinates,
+        userStates = adaptVolumeUserStates(volumeTracing.userStates, p)
       )
     }.getOrElse(volumeTracing)
 
+  private def adaptSkeletonUserStates(
+      userStates: Seq[SkeletonUserStateProto],
+      oldPrecedenceLayerProperties: RedundantTracingProperties): Seq[SkeletonUserStateProto] = {
+    val adaptedExistingUserStates = userStates.map { userState =>
+      val userId = userState.userId
+      oldPrecedenceLayerProperties.userStateBoundingBoxVisibilities.get(userId) match {
+        case None => userState
+        case Some((precedenceBboxIds, precedenceBboxVisibilities)) =>
+          userState.copy(boundingBoxIds = precedenceBboxIds, boundingBoxVisibilities = precedenceBboxVisibilities)
+      }
+    }
+    // We also have to create new user states for the users the old precedence layer has, but the new precedence layer is missing.
+    val newUserPrecedenceProperties = oldPrecedenceLayerProperties.userStateBoundingBoxVisibilities.filter(tuple =>
+      !userStates.exists(_.userId == tuple._1))
+    val newUserStates = newUserPrecedenceProperties.map {
+      case (userId: String, (boundingBoxIds: Seq[Int], boundingBoxVisibilities: Seq[Boolean])) =>
+        SkeletonTracingDefaults
+          .emptyUserState(userId)
+          .copy(
+            boundingBoxIds = boundingBoxIds,
+            boundingBoxVisibilities = boundingBoxVisibilities
+          )
+    }
+    adaptedExistingUserStates ++ newUserStates
+  }
+
+  private def adaptVolumeUserStates(
+      userStates: Seq[VolumeUserStateProto],
+      oldPrecedenceLayerProperties: RedundantTracingProperties): Seq[VolumeUserStateProto] = {
+    val adaptedExistingUserStates = userStates.map { userState =>
+      val userId = userState.userId
+      oldPrecedenceLayerProperties.userStateBoundingBoxVisibilities.get(userId) match {
+        case None => userState
+        case Some((precedenceBboxIds, precedenceBboxVisibilities)) =>
+          userState.copy(boundingBoxIds = precedenceBboxIds, boundingBoxVisibilities = precedenceBboxVisibilities)
+      }
+    }
+    // We also have to create new user states for the users the old precedence layer has, but the new precedence layer is missing.
+    val newUserPrecedenceProperties = oldPrecedenceLayerProperties.userStateBoundingBoxVisibilities.filter(tuple =>
+      !userStates.exists(_.userId == tuple._1))
+    val newUserStates = newUserPrecedenceProperties.map {
+      case (userId: String, (boundingBoxIds: Seq[Int], boundingBoxVisibilities: Seq[Boolean])) =>
+        VolumeTracingDefaults
+          .emptyUserState(userId)
+          .copy(
+            boundingBoxIds = boundingBoxIds,
+            boundingBoxVisibilities = boundingBoxVisibilities
+          )
+    }
+    adaptedExistingUserStates ++ newUserStates
+  }
+
   protected def getOldPrecedenceLayerProperties(existingAnnotationId: Option[ObjectId],
                                                 existingAnnotationLayers: List[AnnotationLayer],
                                                 previousVersion: Option[Long],
@@ -138,7 +194,10 @@ trait AnnotationLayerPrecedence extends FoxImplicits {
           s.zoomLevel,
           s.userBoundingBoxes ++ s.userBoundingBox.map(
             com.scalableminds.webknossos.datastore.geometry.NamedBoundingBoxProto(0, None, None, None, _)),
-          s.editPositionAdditionalCoordinates
+          s.editPositionAdditionalCoordinates,
+          s.userStates
+            .map(userState => (userState.userId, (userState.boundingBoxIds, userState.boundingBoxVisibilities)))
+            .toMap
         )
       case Right(v) =>
         RedundantTracingProperties(
@@ -147,7 +206,10 @@ trait AnnotationLayerPrecedence extends FoxImplicits {
           v.zoomLevel,
           v.userBoundingBoxes ++ v.userBoundingBox.map(
             com.scalableminds.webknossos.datastore.geometry.NamedBoundingBoxProto(0, None, None, None, _)),
-          v.editPositionAdditionalCoordinates
+          v.editPositionAdditionalCoordinates,
+          v.userStates
+            .map(userState => (userState.userId, (userState.boundingBoxIds, userState.boundingBoxVisibilities)))
+            .toMap
         )
     }
 }

app/models/annotation/AnnotationMerger.scala

@@ -46,7 +46,12 @@ class AnnotationMerger @Inject()(datasetDAO: DatasetDAO, tracingStoreService: Tr
       Fox.empty
     else {
       for {
-        mergedAnnotationLayers <- mergeAnnotationsInTracingstore(annotations, datasetId, newId, toTemporaryStore) ?~> "Failed to merge annotations in tracingstore."
+        mergedAnnotationLayers <- mergeAnnotationsInTracingstore(
+          annotations,
+          datasetId,
+          newId,
+          userId,
+          toTemporaryStore) ?~> "Failed to merge annotations in tracingstore."
       } yield {
         Annotation(
           newId,
@@ -64,13 +69,16 @@ class AnnotationMerger @Inject()(datasetDAO: DatasetDAO, tracingStoreService: Tr
       annotations: List[Annotation],
       datasetId: ObjectId,
       newAnnotationId: ObjectId,
+      requestingUserId: ObjectId,
       toTemporaryStore: Boolean)(implicit ctx: DBAccessContext): Fox[List[AnnotationLayer]] =
     for {
       dataset <- datasetDAO.findOne(datasetId)
       tracingStoreClient: WKRemoteTracingStoreClient <- tracingStoreService.clientFor(dataset)
       mergedAnnotationProto <- tracingStoreClient.mergeAnnotationsByIds(annotations.map(_.id),
+                                                                        annotations.map(_._user),
                                                                         newAnnotationId,
-                                                                        toTemporaryStore)
+                                                                        toTemporaryStore,
+                                                                        requestingUserId)
       layers = mergedAnnotationProto.annotationLayers.map(AnnotationLayer.fromProto)
     } yield layers.toList
 

app/models/annotation/AnnotationService.scala

@@ -363,6 +363,8 @@ class AnnotationService @Inject()(
       duplicatedAnnotationProto <- tracingStoreClient.duplicateAnnotation(
         annotationBaseId,
         initializingAnnotationId,
+        annotationBase._user,
+        user._id,
         version = None,
         isFromTask = false, // isFromTask is when duplicate is called on a task annotation, not when a task is assigned
         datasetBoundingBox = None
@@ -531,8 +533,11 @@ class AnnotationService @Inject()(
                                                                                               volumeTracingIdOpt,
                                                                                               skeletonTracingOpt,
                                                                                               volumeTracingOpt)
+            // user state is not used in compound download, so the annotationProto can be a dummy one.
+            annotationProto = AnnotationProto("", 0L, Seq.empty, 0L)
             nml = nmlWriter.toNmlStream(
               name,
+              annotationProto,
               fetchedAnnotationLayersForAnnotation,
               Some(annotation),
               voxelSizeOpt,
@@ -541,10 +546,11 @@ class AnnotationService @Inject()(
               conf.Http.uri,
               datasetName,
               datasetId,
-              Some(user),
+              user,
               taskOpt,
               skipVolumeData,
-              volumeDataZipFormat
+              volumeDataZipFormat,
+              requestingUser = None
             )
           } yield (nml, volumeDataOpt)
       }