Multi-Resolution Volume Tracings

CHANGELOG.unreleased.md

@@ -11,10 +11,12 @@ For upgrade instructions, please check the [migration guide](MIGRATIONS.released
 [Commits](https://github.com/scalableminds/webknossos/compare/20.10.0...HEAD)
 
 ### Added
-- 
+- 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
+- New volume/hybrid annotations are now automatically multi-resolution volume annotations. [#4755](https://github.com/scalableminds/webknossos/pull/4755)
 - The position input of tracings now accepts decimal input. When losing focus the values are cut off at the comma. [#4803](https://github.com/scalableminds/webknossos/pull/4803)
+- Improved performance of volume annotations (brush and trace tool). [#4848](https://github.com/scalableminds/webknossos/pull/4848)
 - webknossos.org only: Accounts associated with new organizations can now be created even when a datastore is unreachable. The necessary folders are created lazily when needed. [#4846](https://github.com/scalableminds/webknossos/pull/4846)
 
 ### Fixed

MIGRATIONS.unreleased.md

@@ -6,7 +6,7 @@ This project adheres to [Calendar Versioning](http://calver.org/) `0Y.0M.MICRO`.
 User-facing changes are documented in the [changelog](CHANGELOG.released.md).
 
 ## Unreleased
--
+- To convert individual legacy volume annotations to multi-resolution volume annotations, download and re-upload them (upload may take a while).
 
 ### Postgres Evolutions:
-- 
+-

app/controllers/AnnotationController.scala

@@ -174,6 +174,22 @@ class AnnotationController @Inject()(
     }
   }
 
+  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/TracingStoreController.scala

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

app/controllers/WKTracingStoreController.scala

@@ -1,21 +1,27 @@
 package controllers
 
-import com.scalableminds.util.accesscontext.GlobalAccessContext
+import com.scalableminds.util.accesscontext.{DBAccessContext, GlobalAccessContext}
 import com.scalableminds.util.tools.{Fox, FoxImplicits}
 import javax.inject.Inject
-import models.annotation.{Annotation, AnnotationDAO, TracingStoreDAO, TracingStoreService}
+import models.annotation.{Annotation, AnnotationDAO, TracingStoreService}
 import models.user.time.TimeSpanService
 import oxalis.security.{WkEnv, WkSilhouetteEnvironment}
 import com.mohiva.play.silhouette.api.Silhouette
 import play.api.libs.json.{JsObject, Json}
 import models.annotation.AnnotationState._
+import models.binary.{DataSetDAO, DataSetService}
+import models.team.OrganizationDAO
+import play.api.i18n.Messages
+import play.api.mvc.{Action, AnyContent}
 
 import scala.concurrent.ExecutionContext
 
 class WKTracingStoreController @Inject()(tracingStoreService: TracingStoreService,
-                                         tracingStoreDAO: TracingStoreDAO,
                                          wkSilhouetteEnvironment: WkSilhouetteEnvironment,
                                          timeSpanService: TimeSpanService,
+                                         dataSetService: DataSetService,
+                                         organizationDAO: OrganizationDAO,
+                                         dataSetDAO: DataSetDAO,
                                          annotationDAO: AnnotationDAO,
                                          sil: Silhouette[WkEnv])(implicit ec: ExecutionContext)
     extends Controller
@@ -24,7 +30,7 @@ class WKTracingStoreController @Inject()(tracingStoreService: TracingStoreServic
   val bearerTokenService = wkSilhouetteEnvironment.combinedAuthenticatorService.tokenAuthenticatorService
 
   def handleTracingUpdateReport(name: String) = Action.async(parse.json) { implicit request =>
-    tracingStoreService.validateAccess(name) { dataStore =>
+    tracingStoreService.validateAccess(name) { _ =>
       for {
         tracingId <- (request.body \ "tracingId").asOpt[String].toFox
         annotation <- annotationDAO.findOneByTracingId(tracingId)(GlobalAccessContext)
@@ -49,4 +55,24 @@ class WKTracingStoreController @Inject()(tracingStoreService: TracingStoreServic
   private def ensureAnnotationNotFinished(annotation: Annotation) =
     if (annotation.state == Finished) Fox.failure("annotation already finshed")
     else Fox.successful(())
+
+  def dataSource(name: String, organizationName: String, dataSetName: String): Action[AnyContent] = Action.async {
+    implicit request =>
+      tracingStoreService.validateAccess(name) { _ =>
+        implicit val ctx: DBAccessContext = GlobalAccessContext
+        val organizationNameOpt = if (organizationName == "") None else Some(organizationName)
+        for {
+          organizationIdOpt <- Fox.runOptional(organizationNameOpt) {
+            organizationDAO.findOneByName(_)(GlobalAccessContext).map(_._id)
+          } ?~> Messages("organization.notFound", organizationNameOpt.getOrElse("")) ~> NOT_FOUND
+          organizationId <- Fox.fillOption(organizationIdOpt) {
+            dataSetDAO.getOrganizationForDataSet(dataSetName)(GlobalAccessContext)
+          } ?~> Messages("dataSet.noAccess", dataSetName) ~> FORBIDDEN
+          dataSet <- dataSetDAO.findOneByNameAndOrganization(dataSetName, organizationId) ?~> Messages(
+            "dataSet.noAccess",
+            dataSetName) ~> FORBIDDEN
+          dataSource <- dataSetService.dataSourceFor(dataSet)
+        } yield Ok(Json.toJson(dataSource))
+      }
+  }
 }

app/models/annotation/AnnotationService.scala

@@ -19,7 +19,7 @@ import com.scalableminds.webknossos.tracingstore.VolumeTracing.{VolumeTracing, V
 import com.scalableminds.webknossos.tracingstore.geometry.{Color, NamedBoundingBox}
 import com.scalableminds.webknossos.tracingstore.tracings._
 import com.scalableminds.webknossos.tracingstore.tracings.skeleton.{NodeDefaults, SkeletonTracingDefaults}
-import com.scalableminds.webknossos.tracingstore.tracings.volume.VolumeTracingDefaults
+import com.scalableminds.webknossos.tracingstore.tracings.volume.{VolumeTracingDefaults, VolumeTracingDownsampling}
 import com.typesafe.scalalogging.LazyLogging
 import javax.inject.Inject
 import models.annotation.AnnotationState._
@@ -117,7 +117,8 @@ class AnnotationService @Inject()(annotationInformationProvider: AnnotationInfor
       fallbackLayer.map(_.name),
       fallbackLayer.map(_.largestSegmentId).getOrElse(VolumeTracingDefaults.largestSegmentId),
       0,
-      VolumeTracingDefaults.zoomLevel
+      VolumeTracingDefaults.zoomLevel,
+      resolutions = VolumeTracingDownsampling.resolutionsForVolumeTracing(dataSource, fallbackLayer).map(point3DToProto)
     )
 
   def createTracings(

app/models/annotation/TracingStoreRpcClient.scala

@@ -1,23 +1,22 @@
 package models.annotation
 
-import java.io.{BufferedOutputStream, File, FileOutputStream}
+import java.io.File
 
-import akka.stream.scaladsl.{Source, StreamConverters}
+import akka.stream.scaladsl.Source
 import akka.util.ByteString
 import com.scalableminds.util.geometry.BoundingBox
-import com.scalableminds.util.io.{NamedEnumeratorStream, ZipIO}
+import com.scalableminds.util.io.ZipIO
 import com.scalableminds.webknossos.tracingstore.SkeletonTracing.{SkeletonTracing, SkeletonTracings}
 import com.scalableminds.webknossos.tracingstore.VolumeTracing.{VolumeTracing, VolumeTracings}
 import com.scalableminds.webknossos.tracingstore.tracings.TracingSelector
 import com.scalableminds.webknossos.datastore.rpc.RPC
 import com.scalableminds.util.tools.JsonHelper.boxFormat
 import com.scalableminds.util.tools.JsonHelper.optionFormat
 import com.scalableminds.util.tools.Fox
+import com.scalableminds.webknossos.datastore.models.datasource.{DataSource, DataSourceLike}
 import com.typesafe.scalalogging.LazyLogging
 import models.binary.{DataSet, DataStoreRpcClient}
 import net.liftweb.common.Box
-import play.api.libs.iteratee.Enumerator
-import play.api.libs.json.JsObject
 
 import scala.concurrent.ExecutionContext
 
@@ -198,4 +197,13 @@ class TracingStoreRpcClient(tracingStore: TracingStore, dataSet: DataSet, rpc: R
     } yield data
   }
 
+  def unlinkFallback(tracingId: String, dataSource: DataSourceLike): Fox[String] = {
+    logger.debug(s"Called to unlink fallback segmentation for tracing $tracingId." + baseInfo)
+    for {
+      newId: String <- rpc(s"${tracingStore.url}/tracings/volume/$tracingId/unlinkFallback")
+        .addQueryString("token" -> TracingStoreRpcClient.webKnossosToken)
+        .postWithJsonResponse[DataSourceLike, String](dataSource)
+    } yield newId
+  }
+
 }

app/models/annotation/nml/NmlParser.scala

@@ -43,8 +43,7 @@ object NmlParser extends LazyLogging with ProtoGeometryImplicits with ColorGener
 
   @SuppressWarnings(Array("TraversableHead")) //We check if volumes are empty before accessing the head
   def parse(name: String, nmlInputStream: InputStream, overwritingDataSetName: Option[String], isTaskUpload: Boolean)(
-      implicit m: MessagesProvider)
-    : Box[(Option[SkeletonTracing], Option[(VolumeTracing, String)], String, Option[String])] =
+      implicit m: MessagesProvider): Box[(Option[SkeletonTracing], Option[(VolumeTracing, String)], String)] =
     try {
       val data = XML.load(nmlInputStream)
       for {
@@ -97,7 +96,8 @@ object NmlParser extends LazyLogging with ProtoGeometryImplicits with ColorGener
                  0,
                  zoomLevel,
                  None,
-                 userBoundingBoxes
+                 userBoundingBoxes,
+                 organizationName
                ),
                volumes.head.location)
             )
@@ -106,21 +106,24 @@ object NmlParser extends LazyLogging with ProtoGeometryImplicits with ColorGener
           if (treesSplit.isEmpty) None
           else
             Some(
-              SkeletonTracing(dataSetName,
-                              treesSplit,
-                              time,
-                              taskBoundingBox,
-                              activeNodeId,
-                              editPosition,
-                              editRotation,
-                              zoomLevel,
-                              version = 0,
-                              None,
-                              treeGroupsAfterSplit,
-                              userBoundingBoxes)
+              SkeletonTracing(
+                dataSetName,
+                treesSplit,
+                time,
+                taskBoundingBox,
+                activeNodeId,
+                editPosition,
+                editRotation,
+                zoomLevel,
+                version = 0,
+                None,
+                treeGroupsAfterSplit,
+                userBoundingBoxes,
+                organizationName
+              )
             )
 
-        (skeletonTracing, volumeTracingWithDataLocation, description, organizationName)
+        (skeletonTracing, volumeTracingWithDataLocation, description)
       }
     } catch {
       case e: org.xml.sax.SAXParseException if e.getMessage.startsWith("Premature end of file") =>

app/models/annotation/nml/NmlResults.scala

@@ -17,8 +17,6 @@ object NmlResults extends LazyLogging {
 
     def description: Option[String] = None
 
-    def organizationName: Option[String] = None
-
     def succeeded: Boolean
 
     def toSuccessFox(implicit ec: ExecutionContext): Fox[NmlParseSuccess] = this match {
@@ -36,17 +34,14 @@ object NmlResults extends LazyLogging {
   case class NmlParseSuccess(fileName: String,
                              skeletonTracing: Option[SkeletonTracing],
                              volumeTracingWithDataLocation: Option[(VolumeTracing, String)],
-                             _description: String,
-                             organizationNameOpt: Option[String])
+                             _description: String)
       extends NmlParseResult {
     def succeeded = true
 
     override def bothTracingOpts = Some((skeletonTracing, volumeTracingWithDataLocation))
 
     override def description = Some(_description)
 
-    override def organizationName: Option[String] = organizationNameOpt
-
     override def withName(name: String): NmlParseResult = this.copy(fileName = name)
   }
 

app/models/annotation/nml/NmlService.scala

@@ -34,8 +34,8 @@ class NmlService @Inject()(temporaryFileCreator: TemporaryFileCreator)(implicit
                      overwritingDataSetName: Option[String],
                      isTaskUpload: Boolean)(implicit m: MessagesProvider): NmlParseResult =
     NmlParser.parse(name, inputStream, overwritingDataSetName, isTaskUpload) match {
-      case Full((skeletonTracing, volumeTracingWithDataLocation, description, organizationNameOpt)) =>
-        NmlParseSuccess(name, skeletonTracing, volumeTracingWithDataLocation, description, organizationNameOpt)
+      case Full((skeletonTracing, volumeTracingWithDataLocation, description)) =>
+        NmlParseSuccess(name, skeletonTracing, volumeTracingWithDataLocation, description)
       case Failure(msg, _, chain) => NmlParseFailure(name, msg + chain.map(_ => formatChain(chain)).getOrElse(""))
       case Empty                  => NmlParseEmpty(name)
     }
@@ -77,12 +77,8 @@ class NmlService @Inject()(temporaryFileCreator: TemporaryFileCreator)(implicit
 
     if (parseResults.length > 1) {
       parseResults.map {
-        case NmlParseSuccess(name, Some(skeletonTracing), volumeTracingOpt, description, organizationNameOpt) =>
-          NmlParseSuccess(name,
-                          Some(renameTrees(name, skeletonTracing)),
-                          volumeTracingOpt,
-                          description,
-                          organizationNameOpt)
+        case NmlParseSuccess(name, Some(skeletonTracing), volumeTracingOpt, description) =>
+          NmlParseSuccess(name, Some(renameTrees(name, skeletonTracing)), volumeTracingOpt, description)
         case r => r
       }
     } else {
@@ -101,12 +97,8 @@ class NmlService @Inject()(temporaryFileCreator: TemporaryFileCreator)(implicit
     }
 
     parseResults.map {
-      case NmlParseSuccess(name, Some(skeletonTracing), volumeTracingOpt, description, organizationNameOpt) =>
-        NmlParseSuccess(name,
-                        Some(wrapTreesInGroup(name, skeletonTracing)),
-                        volumeTracingOpt,
-                        description,
-                        organizationNameOpt)
+      case NmlParseSuccess(name, Some(skeletonTracing), volumeTracingOpt, description) =>
+        NmlParseSuccess(name, Some(wrapTreesInGroup(name, skeletonTracing)), volumeTracingOpt, description)
       case r => r
     }
   }

conf/messages

@@ -223,6 +223,8 @@ annotation.timelogging.read.failed=Time
 annotation.write.failed=Could not convert annotation to json
 annotation.noSkeleton=No skeleton tracing found for this annotation
 annotation.needsEitherSkeletonOrVolume=Annotation needs at least one of skeleton or volume
+annotation.unlinkFallback.explorationalsOnly=Could not unlink fallback segmentation (only allowed for explorational annotations).
+annotation.unlinkFallback.noVolume=Could not unlink fallback segmentation (only allowed for annotations with volume layer).
 annotation.makeHybrid.explorationalsOnly=Could not convert annotation to hybrid annotation because it is only allowed for explorational annotations.
 annotation.makeHybrid.failed=Could not convert to hybrid.
 annotation.makeHybrid.alreadyHybrid=Could not convert annotation to hybrid annotation because it is already a hybrid annotation.