Multi-Resolution Volume Tracings

CHANGELOG.unreleased.md

@@ -14,9 +14,12 @@ For upgrade instructions, please check the [migration guide](MIGRATIONS.released
 - The total length of skeletons can now be measured using the dropdown in the tree list tab. Also, the frontend API received the methods `api.tracing.measureTreeLength` and `api.tracing.measureAllTrees`. [#4898](https://github.com/scalableminds/webknossos/pull/4898)
 - Introduced an indeterminate visibility state for groups in the tree tab if not all but only some of the group's children are visible. Before, the visibility of those groups was shown as not visible which made it hard to find the visible trees. [#4897](https://github.com/scalableminds/webknossos/pull/4897)
 - Dataset uploads on a specific Datastore can now be restricted to a single organization. [#4892](https://github.com/scalableminds/webknossos/pull/4892)
+- Added multi-resolution volume annotations. Note that already existing volume tracings will still only contain data in the first magnification. If you want to migrate an old volume tracing, you can download and re-import it. [#4755](https://github.com/scalableminds/webknossos/pull/4755)
 
 ### Changed
 - In the tree tab, all groups but the root group are now collapsed instead of expanded when opening a tracing. [#4897](https://github.com/scalableminds/webknossos/pull/4897)
+- New volume/hybrid annotations are now automatically multi-resolution volume annotations. [#4755](https://github.com/scalableminds/webknossos/pull/4755)
+- Improved performance of volume annotations (brush and trace tool). [#4848](https://github.com/scalableminds/webknossos/pull/4848)
 
 ### Fixed
 - Fixed the disappearing of dataset settings after switching between view mode and annotation mode. [#4845](https://github.com/scalableminds/webknossos/pull/4845)

MIGRATIONS.unreleased.md

@@ -6,7 +6,13 @@ This project adheres to [Calendar Versioning](http://calver.org/) `0Y.0M.MICRO`.
 User-facing changes are documented in the [changelog](CHANGELOG.released.md).
 
 ## Unreleased
--
+- As volume annotations in arbitrary magnifications are now supported and the behavior of magnification restrictions of tasks has changed (allow full zoom, but disable tools unless in correct magnification), you may want to restrict all volume and hybrid task types to mag 1 to achieve the old behavior (mag1-only):
+```
+update webknossos.tasktypes
+set settings_allowedmagnifications = '{"min":1,"max":1,"shouldRestrict":true}'
+where (tracingtype = 'volume' or tracingtype = 'hybrid')
+and (settings_allowedmagnifications is null or settings_allowedmagnifications::json->>'shouldRestrict'='false');
+```
 
 ### Postgres Evolutions:
 - [057-add-layer-specific-view-configs.sql](conf/evolutions/056-add-layer-specific-view-configs.sql)

app/controllers/AnnotationController.scala

@@ -166,14 +166,43 @@ class AnnotationController @Inject()(
     for {
       _ <- bool2Fox(AnnotationType.Explorational.toString == typ) ?~> "annotation.makeHybrid.explorationalsOnly"
       annotation <- provider.provideAnnotation(typ, id, request.identity)
-      _ <- annotationService.makeAnnotationHybrid(annotation) ?~> "annotation.makeHybrid.failed"
+      organization <- organizationDAO.findOne(request.identity._organization)
+      _ <- annotationService.makeAnnotationHybrid(annotation, organization.name) ?~> "annotation.makeHybrid.failed"
       updated <- provider.provideAnnotation(typ, id, request.identity)
       json <- annotationService.publicWrites(updated, Some(request.identity)) ?~> "annotation.write.failed"
     } yield {
       JsonOk(json)
     }
   }
 
+  def downsample(typ: String, id: String) = sil.SecuredAction.async { implicit request =>
+    for {
+      _ <- bool2Fox(AnnotationType.Explorational.toString == typ) ?~> "annotation.downsample.explorationalsOnly"
+      annotation <- provider.provideAnnotation(typ, id, request.identity)
+      _ <- annotationService.downsampleAnnotation(annotation) ?~> "annotation.downsample.failed"
+      updated <- provider.provideAnnotation(typ, id, request.identity)
+      json <- annotationService.publicWrites(updated, Some(request.identity)) ?~> "annotation.write.failed"
+    } yield {
+      JsonOk(json)
+    }
+  }
+
+  def unlinkFallback(typ: String, id: String) = sil.SecuredAction.async { implicit request =>
+    for {
+      _ <- bool2Fox(AnnotationType.Explorational.toString == typ) ?~> "annotation.unlinkFallback.explorationalsOnly"
+      annotation <- provider.provideAnnotation(typ, id, request.identity)
+      volumeTracingId <- annotation.volumeTracingId.toFox ?~> "annotation.unlinkFallback.noVolume"
+      dataSet <- dataSetDAO
+        .findOne(annotation._dataSet)(GlobalAccessContext) ?~> "dataSet.notFoundForAnnotation" ~> NOT_FOUND
+      dataSource <- dataSetService.dataSourceFor(dataSet).flatMap(_.toUsable) ?~> "dataSet.notImported"
+      tracingStoreClient <- tracingStoreService.clientFor(dataSet)
+      newTracingId <- tracingStoreClient.unlinkFallback(volumeTracingId, dataSource)
+      _ <- annotationDAO.updateVolumeTracingId(annotation._id, newTracingId)
+      updatedAnnotation <- provider.provideAnnotation(typ, id, request.identity)
+      js <- annotationService.publicWrites(updatedAnnotation, Some(request.identity))
+    } yield JsonOk(js)
+  }
+
   private def finishAnnotation(typ: String, id: String, issuingUser: User, timestamp: Long)(
       implicit ctx: DBAccessContext): Fox[(Annotation, String)] =
     for {

app/controllers/AnnotationIOController.scala

@@ -82,9 +82,7 @@ class AnnotationIOController @Inject()(nmlWriter: NmlWriter,
 
           for {
             _ <- bool2Fox(skeletonTracings.nonEmpty || volumeTracingsWithDataLocations.nonEmpty) ?~> "nml.file.noFile"
-            dataSet <- findDataSetForUploadedAnnotations(skeletonTracings,
-                                                         volumeTracingsWithDataLocations.map(_._1),
-                                                         parseSuccesses)
+            dataSet <- findDataSetForUploadedAnnotations(skeletonTracings, volumeTracingsWithDataLocations.map(_._1))
             tracingStoreClient <- tracingStoreService.clientFor(dataSet)
             mergedVolumeTracingIdOpt <- Fox.runOptional(volumeTracingsWithDataLocations.headOption) { _ =>
               for {
@@ -120,11 +118,10 @@ class AnnotationIOController @Inject()(nmlWriter: NmlWriter,
 
   private def findDataSetForUploadedAnnotations(
       skeletonTracings: List[SkeletonTracing],
-      volumeTracings: List[VolumeTracing],
-      parseSuccesses: List[NmlParseResult])(implicit mp: MessagesProvider, ctx: DBAccessContext): Fox[DataSet] =
+      volumeTracings: List[VolumeTracing])(implicit mp: MessagesProvider, ctx: DBAccessContext): Fox[DataSet] =
     for {
       dataSetName <- assertAllOnSameDataSet(skeletonTracings, volumeTracings) ?~> "nml.file.differentDatasets"
-      organizationNameOpt <- assertAllOnSameOrganization(parseSuccesses.flatMap(s => s.organizationName)) ?~> "nml.file.differentDatasets"
+      organizationNameOpt <- assertAllOnSameOrganization(skeletonTracings, volumeTracings) ?~> "nml.file.differentDatasets"
       organizationIdOpt <- Fox.runOptional(organizationNameOpt) {
         organizationDAO.findOneByName(_)(GlobalAccessContext).map(_._id)
       } ?~> Messages("organization.notFound", organizationNameOpt.getOrElse("")) ~> NOT_FOUND
@@ -172,14 +169,16 @@ class AnnotationIOController @Inject()(nmlWriter: NmlWriter,
       _ <- bool2Fox(volumes.forall(_.dataSetName == dataSetName))
     } yield dataSetName
 
-  private def assertAllOnSameOrganization(organizationNames: List[String]): Fox[Option[String]] =
-    if (organizationNames.isEmpty) Fox.successful(None)
-    else {
-      for {
-        organizationName <- organizationNames.headOption.toFox
-        _ <- bool2Fox(organizationNames.forall(name => name == organizationName))
-      } yield Some(organizationName)
-    }
+  private def assertAllOnSameOrganization(skeletons: List[SkeletonTracing],
+                                          volumes: List[VolumeTracing]): Fox[Option[String]] =
+    for {
+      organizationName: Option[String] <- volumes.headOption
+        .map(_.organizationName)
+        .orElse(skeletons.headOption.map(_.organizationName))
+        .toFox
+      _ <- bool2Fox(skeletons.forall(_.organizationName == organizationName))
+      _ <- bool2Fox(volumes.forall(_.organizationName == organizationName))
+    } yield organizationName
 
   private def adaptPropertiesToFallbackLayer(volumeTracing: VolumeTracing, dataSet: DataSet)(
       implicit ctx: DBAccessContext): Fox[VolumeTracing] =

app/controllers/TaskController.scala

@@ -9,13 +9,13 @@ import com.scalableminds.util.geometry.{BoundingBox, Point3D, Vector3D}
 import com.scalableminds.util.mvc.ResultBox
 import com.scalableminds.util.tools.{Fox, FoxImplicits, JsonHelper}
 import com.scalableminds.webknossos.tracingstore.SkeletonTracing.{SkeletonTracing, SkeletonTracingOpt, SkeletonTracings}
-import com.scalableminds.webknossos.tracingstore.VolumeTracing.{VolumeTracing, VolumeTracingOpt, VolumeTracings}
+import com.scalableminds.webknossos.tracingstore.VolumeTracing.VolumeTracing
+import com.scalableminds.webknossos.tracingstore.tracings.volume.ResolutionRestrictions
 import com.scalableminds.webknossos.tracingstore.tracings.{ProtoGeometryImplicits, TracingType}
 import javax.inject.Inject
-import models.annotation.nml.NmlResults.NmlParseResult
 import models.annotation.nml.NmlService
 import models.annotation._
-import models.binary.{DataSet, DataSetDAO, DataSetService}
+import models.binary.{DataSet, DataSetDAO}
 import models.project.{Project, ProjectDAO}
 import models.task._
 import models.team.{Team, TeamDAO}
@@ -74,7 +74,6 @@ class TaskController @Inject()(annotationDAO: AnnotationDAO,
                                dataSetDAO: DataSetDAO,
                                userTeamRolesDAO: UserTeamRolesDAO,
                                userService: UserService,
-                               dataSetService: DataSetService,
                                tracingStoreService: TracingStoreService,
                                teamDAO: TeamDAO,
                                taskDAO: TaskDAO,
@@ -88,7 +87,7 @@ class TaskController @Inject()(annotationDAO: AnnotationDAO,
     with ProtoGeometryImplicits
     with FoxImplicits {
 
-  val MAX_OPEN_TASKS = conf.WebKnossos.Tasks.maxOpenPerUser
+  private val MAX_OPEN_TASKS: Int = conf.WebKnossos.Tasks.maxOpenPerUser
 
   def read(taskId: String) = sil.SecuredAction.async { implicit request =>
     for {
@@ -114,8 +113,9 @@ class TaskController @Inject()(annotationDAO: AnnotationDAO,
     } yield result
   }
 
-  def duplicateAllBaseTracings(taskParametersList: List[TaskParameters],
-                               organizationId: ObjectId)(implicit ctx: DBAccessContext, m: MessagesProvider) =
+  private def duplicateAllBaseTracings(taskParametersList: List[TaskParameters], organizationId: ObjectId)(
+      implicit ctx: DBAccessContext,
+      m: MessagesProvider): Fox[List[TaskParameters]] =
     Fox.serialCombined(taskParametersList)(
       params =>
         Fox
@@ -141,9 +141,10 @@ class TaskController @Inject()(annotationDAO: AnnotationDAO,
       annotation: Annotation,
       params: TaskParameters,
       tracingStoreClient: TracingStoreRpcClient,
-      organizationId: ObjectId)(implicit ctx: DBAccessContext, m: MessagesProvider): Fox[String] =
+      organizationId: ObjectId,
+      resolutionRestrictions: ResolutionRestrictions)(implicit ctx: DBAccessContext, m: MessagesProvider): Fox[String] =
     annotation.volumeTracingId
-      .map(id => tracingStoreClient.duplicateVolumeTracing(id))
+      .map(id => tracingStoreClient.duplicateVolumeTracing(id, resolutionRestrictions = resolutionRestrictions))
       .getOrElse(
         annotationService
           .createVolumeTracingBase(
@@ -152,13 +153,15 @@ class TaskController @Inject()(annotationDAO: AnnotationDAO,
             params.boundingBox,
             params.editPosition,
             params.editRotation,
-            false
+            volumeShowFallbackLayer = false,
+            resolutionRestrictions = resolutionRestrictions
           )
-          .flatMap(tracingStoreClient.saveVolumeTracing(_)))
+          .flatMap(tracingStoreClient.saveVolumeTracing(_, resolutionRestrictions = resolutionRestrictions)))
 
-  def duplicateBaseTracings(baseAnnotation: BaseAnnotation, taskParameters: TaskParameters, organizationId: ObjectId)(
-      implicit ctx: DBAccessContext,
-      m: MessagesProvider) = {
+  private def duplicateBaseTracings(
+      baseAnnotation: BaseAnnotation,
+      taskParameters: TaskParameters,
+      organizationId: ObjectId)(implicit ctx: DBAccessContext, m: MessagesProvider): Fox[BaseAnnotation] = {
 
     @SuppressWarnings(Array("TraversableHead")) // We check if nonCancelledTaskAnnotations are empty before so head always works
     def checkForTask(taskId: ObjectId): Fox[Annotation] =
@@ -196,13 +199,16 @@ class TaskController @Inject()(annotationDAO: AnnotationDAO,
         duplicateSkeletonTracingOrCreateSkeletonTracingBase(annotation, taskParameters, tracingStoreClient).map(Some(_))
       else Fox.successful(None)
       newVolumeId <- if (taskType.tracingType == TracingType.volume || taskType.tracingType == TracingType.hybrid)
-        duplicateVolumeTracingOrCreateVolumeTracingBase(annotation, taskParameters, tracingStoreClient, organizationId)
-          .map(Some(_))
+        duplicateVolumeTracingOrCreateVolumeTracingBase(annotation,
+                                                        taskParameters,
+                                                        tracingStoreClient,
+                                                        organizationId,
+                                                        taskType.settings.resolutionRestrictions).map(Some(_))
       else Fox.successful(None)
     } yield BaseAnnotation(baseAnnotationIdValidated.id, newSkeletonId, newVolumeId)
   }
 
-  def createTaskSkeletonTracingBases(paramsList: List[TaskParameters])(
+  private def createTaskSkeletonTracingBases(paramsList: List[TaskParameters])(
       implicit ctx: DBAccessContext,
       m: MessagesProvider): Fox[List[Option[SkeletonTracing]]] =
     Fox.serialCombined(paramsList) { params =>
@@ -221,7 +227,7 @@ class TaskController @Inject()(annotationDAO: AnnotationDAO,
       } yield skeletonTracingOpt
     }
 
-  def createTaskVolumeTracingBases(paramsList: List[TaskParameters], organizationId: ObjectId)(
+  private def createTaskVolumeTracingBases(paramsList: List[TaskParameters], organizationId: ObjectId)(
       implicit ctx: DBAccessContext,
       m: MessagesProvider): Fox[List[Option[(VolumeTracing, Option[File])]]] =
     Fox.serialCombined(paramsList) { params =>
@@ -236,7 +242,8 @@ class TaskController @Inject()(annotationDAO: AnnotationDAO,
               params.boundingBox,
               params.editPosition,
               params.editRotation,
-              volumeShowFallbackLayer = false
+              volumeShowFallbackLayer = false,
+              resolutionRestrictions = taskType.settings.resolutionRestrictions
             )
             .map(v => Some((v, None)))
         } else Fox.successful(None)
@@ -296,7 +303,8 @@ class TaskController @Inject()(annotationDAO: AnnotationDAO,
                         params.boundingBox,
                         params.editPosition,
                         params.editRotation,
-                        volumeShowFallbackLayer = false
+                        volumeShowFallbackLayer = false,
+                        resolutionRestrictions = taskType.settings.resolutionRestrictions
                       )
                       .map(v => (v, None)))
 
@@ -449,6 +457,7 @@ class TaskController @Inject()(annotationDAO: AnnotationDAO,
       bool2Fox(fullTasks.forall(tuple => tuple._1.baseAnnotation.isDefined || tuple._2.isDefined || tuple._3.isDefined))
 
     def assertAllOnSameDataset(firstDatasetName: String): Fox[String] = {
+      @scala.annotation.tailrec
       def allOnSameDatasetIter(
           requestedTasksRest: List[(TaskParameters, Option[SkeletonTracing], Option[(VolumeTracing, Option[File])])],
           dataSetName: String): Boolean =
@@ -490,12 +499,8 @@ class TaskController @Inject()(annotationDAO: AnnotationDAO,
             case _          => savedId
           }
       }
-      volumeTracingIds: List[Box[Option[String]]] <- Fox.sequence(requestedTasks.map(_.map(_._3)).map {
-        case Full(Some((tracing, initialFile))) =>
-          tracingStoreClient.saveVolumeTracing(tracing, initialFile).map(Some(_))
-        case f: Failure => box2Fox(f)
-        case _          => Fox.successful(None)
-      })
+      volumeTracingIds: List[Box[Option[String]]] <- Fox.sequence(
+        requestedTasks.map(requestedTask => saveVolumeTracingIfPresent(requestedTask, tracingStoreClient)))
       skeletonTracingsIdsMerged = mergeTracingIds((requestedTasks.map(_.map(_._1)), skeletonTracingIds).zipped.toList,
                                                   isSkeletonId = true)
       volumeTracingsIdsMerged = mergeTracingIds((requestedTasks.map(_.map(_._1)), volumeTracingIds).zipped.toList,
@@ -526,6 +531,24 @@ class TaskController @Inject()(annotationDAO: AnnotationDAO,
     } yield Ok(Json.toJson(result))
   }
 
+  private def saveVolumeTracingIfPresent(
+      requestedTaskBox: Box[(TaskParameters, Option[SkeletonTracing], Option[(VolumeTracing, Option[File])])],
+      tracingStoreClient: TracingStoreRpcClient)(implicit ctx: DBAccessContext): Fox[Option[String]] =
+    requestedTaskBox.map { tuple =>
+      (tuple._1, tuple._3)
+    } match {
+      case Full((params: TaskParameters, Some((tracing, initialFile)))) =>
+        for {
+          taskTypeIdValidated <- ObjectId.parse(params.taskTypeId) ?~> "taskType.id.invalid"
+          taskType <- taskTypeDAO.findOne(taskTypeIdValidated) ?~> "taskType.notFound"
+          saveResult <- tracingStoreClient
+            .saveVolumeTracing(tracing, initialFile, resolutionRestrictions = taskType.settings.resolutionRestrictions)
+            .map(Some(_))
+        } yield saveResult
+      case f: Failure => box2Fox(f)
+      case _          => Fox.successful(None)
+    }
+
   private def warnIfTeamHasNoAccess(requestedTasks: List[TaskParameters], dataSet: DataSet)(
       implicit ctx: DBAccessContext): Fox[List[String]] = {
     val projectNames = requestedTasks.map(_.projectName).distinct

app/controllers/TaskTypeController.scala

@@ -66,6 +66,7 @@ class TaskTypeController @Inject()(taskTypeDAO: TaskTypeDAO,
         taskTypeIdValidated <- ObjectId.parse(taskTypeId) ?~> "taskType.id.invalid"
         taskType <- taskTypeDAO.findOne(taskTypeIdValidated) ?~> "taskType.notFound" ~> NOT_FOUND
         _ <- bool2Fox(taskTypeFromForm.tracingType == taskType.tracingType) ?~> "taskType.tracingTypeImmutable"
+        _ <- bool2Fox(taskTypeFromForm.settings.allowedMagnifications == taskType.settings.allowedMagnifications) ?~> "taskType.allowedMagnificationsImmutable"
         updatedTaskType = taskTypeFromForm.copy(_id = taskType._id)
         _ <- Fox.assertTrue(userService.isTeamManagerOrAdminOf(request.identity, taskType._team)) ?~> "notAllowed" ~> FORBIDDEN
         _ <- Fox

app/controllers/TracingStoreController.scala

@@ -43,4 +43,5 @@ class TracingStoreController @Inject()(tracingStoreService: TracingStoreService,
       } yield { Ok(Json.toJson(js)) }
     }
   }
+
 }