Support multiple segmentation layers

MIGRATIONS.unreleased.md

@@ -7,4 +7,6 @@ User-facing changes are documented in the [changelog](CHANGELOG.released.md).
 
 ## Unreleased
 
+- For webknossos.org: Change `publicDemoDatasetUrl` in the `features`-block within `application.conf` to be an actionable URL. For example, append `/createExplorative/hybrid?fallbackLayerName=segmentation` to the URL so that a new annotation is created if a user clicks on `Open a Demo Dataset` in the dashboard.
+
 ### Postgres Evolutions:

app/controllers/AnnotationController.scala

@@ -28,7 +28,7 @@ import scala.concurrent.ExecutionContext
 import scala.concurrent.duration._
 
 case class CreateExplorationalParameters(typ: String,
-                                         withFallback: Option[Boolean],
+                                         fallbackLayerName: Option[String],
                                          resolutionRestrictions: Option[ResolutionRestrictions])
 object CreateExplorationalParameters {
   implicit val jsonFormat: OFormat[CreateExplorationalParameters] = Json.format[CreateExplorationalParameters]
@@ -159,7 +159,7 @@ class AnnotationController @Inject()(
           request.identity,
           dataSet._id,
           tracingType,
-          request.body.withFallback.getOrElse(true),
+          request.body.fallbackLayerName,
           request.body.resolutionRestrictions.getOrElse(ResolutionRestrictions.empty)
         ) ?~> "annotation.create.failed"
         _ = analyticsService.track(CreateAnnotationEvent(request.identity: User, annotation: Annotation))
@@ -168,16 +168,17 @@ class AnnotationController @Inject()(
       } yield JsonOk(json)
     }
 
-  def makeHybrid(typ: String, id: String): Action[AnyContent] = sil.SecuredAction.async { implicit request =>
-    for {
-      _ <- bool2Fox(AnnotationType.Explorational.toString == typ) ?~> "annotation.makeHybrid.explorationalsOnly"
-      annotation <- provider.provideAnnotation(typ, id, request.identity)
-      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 makeHybrid(typ: String, id: String, fallbackLayerName: Option[String]): Action[AnyContent] =
+    sil.SecuredAction.async { implicit request =>
+      for {
+        _ <- bool2Fox(AnnotationType.Explorational.toString == typ) ?~> "annotation.makeHybrid.explorationalsOnly"
+        annotation <- provider.provideAnnotation(typ, id, request.identity)
+        organization <- organizationDAO.findOne(request.identity._organization)
+        _ <- annotationService.makeAnnotationHybrid(annotation, organization.name, fallbackLayerName) ?~> "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): Action[AnyContent] = sil.SecuredAction.async { implicit request =>
     for {

app/controllers/LegacyApiController.scala

@@ -147,7 +147,7 @@ class LegacyApiController @Inject()(annotationController: AnnotationController,
 
   def annotationMakeHybrid(typ: String, id: String): Action[AnyContent] = sil.SecuredAction.async { implicit request =>
     for {
-      result <- annotationController.makeHybrid(typ, id)(request)
+      result <- annotationController.makeHybrid(typ, id, None)(request)
     } yield replaceVisibilityInResultJson(result)
   }
 

app/models/annotation/AnnotationService.scala

@@ -139,17 +139,23 @@ class AnnotationService @Inject()(
       dataSet: DataSet,
       dataSource: DataSource,
       tracingType: TracingType.Value,
-      withFallback: Boolean,
+      fallbackLayerNameOpt: Option[String],
       resolutionRestrictions: ResolutionRestrictions,
       organizationName: String,
       oldTracingId: Option[String] = None)(implicit ctx: DBAccessContext): Fox[(Option[String], Option[String])] = {
-    def getFallbackLayer: Option[SegmentationLayer] =
-      if (withFallback) {
-        dataSource.dataLayers.flatMap {
-          case layer: SegmentationLayer => Some(layer)
-          case _                        => None
-        }.headOption
-      } else None
+
+    def getFallbackLayer(fallbackLayerName: String): Fox[SegmentationLayer] =
+      for {
+        fallbackLayer <- dataSource.dataLayers
+          .filter(dl => dl.name == fallbackLayerName)
+          .flatMap {
+            case layer: SegmentationLayer => Some(layer)
+            case _                        => None
+          }
+          .headOption
+          .toFox
+        _ <- bool2Fox(fallbackLayer.elementClass != ElementClass.uint64) ?~> "annotation.volume.uint64"
+      } yield fallbackLayer
 
     tracingType match {
       case TracingType.skeleton =>
@@ -170,8 +176,7 @@ class AnnotationService @Inject()(
       case TracingType.volume =>
         for {
           client <- tracingStoreService.clientFor(dataSet)
-          fallbackLayer = getFallbackLayer
-          _ <- bool2Fox(fallbackLayer.forall(_.elementClass != ElementClass.uint64)) ?~> "annotation.volume.uint64"
+          fallbackLayer <- Fox.runOptional(fallbackLayerNameOpt)(getFallbackLayer)
           volumeTracing <- createVolumeTracing(dataSource,
                                                organizationName,
                                                fallbackLayer,
@@ -181,8 +186,7 @@ class AnnotationService @Inject()(
       case TracingType.hybrid =>
         for {
           client <- tracingStoreService.clientFor(dataSet)
-          fallbackLayer = getFallbackLayer
-          _ <- bool2Fox(fallbackLayer.forall(_.elementClass != ElementClass.uint64)) ?~> "annotation.volume.uint64"
+          fallbackLayer <- Fox.runOptional(fallbackLayerNameOpt)(getFallbackLayer)
           skeletonTracingId <- client.saveSkeletonTracing(
             SkeletonTracingDefaults.createInstance.copy(dataSetName = dataSet.name,
                                                         editPosition = dataSource.center,
@@ -199,7 +203,7 @@ class AnnotationService @Inject()(
   def createExplorationalFor(user: User,
                              _dataSet: ObjectId,
                              tracingType: TracingType.Value,
-                             withFallback: Boolean,
+                             fallbackLayerName: Option[String],
                              resolutionRestrictions: ResolutionRestrictions)(implicit ctx: DBAccessContext,
                                                                              m: MessagesProvider): Fox[Annotation] =
     for {
@@ -210,7 +214,7 @@ class AnnotationService @Inject()(
       tracingIds <- createTracingsForExplorational(dataSet,
                                                    usableDataSource,
                                                    tracingType,
-                                                   withFallback,
+                                                   fallbackLayerName,
                                                    resolutionRestrictions,
                                                    organization.name)
       teamId <- selectSuitableTeam(user, dataSet) ?~> "annotation.create.forbidden"
@@ -228,27 +232,29 @@ class AnnotationService @Inject()(
       annotation
     }
 
-  def makeAnnotationHybrid(annotation: Annotation, organizationName: String)(
+  def makeAnnotationHybrid(annotation: Annotation, organizationName: String, fallbackLayerName: Option[String])(
       implicit ctx: DBAccessContext): Fox[Unit] = {
     def createNewTracings(dataSet: DataSet, dataSource: DataSource) = annotation.tracingType match {
       case TracingType.skeleton =>
         createTracingsForExplorational(dataSet,
                                        dataSource,
                                        TracingType.volume,
-                                       withFallback = true,
+                                       fallbackLayerName,
                                        ResolutionRestrictions.empty,
                                        organizationName).flatMap {
           case (_, Some(volumeId)) => annotationDAO.updateVolumeTracingId(annotation._id, volumeId)
           case _                   => Fox.failure("unexpectedReturn")
         }
       case TracingType.volume =>
-        createTracingsForExplorational(dataSet,
-                                       dataSource,
-                                       TracingType.skeleton,
-                                       withFallback = false,
-                                       ResolutionRestrictions.empty,
-                                       organizationName,
-                                       annotation.volumeTracingId).flatMap {
+        createTracingsForExplorational(
+          dataSet,
+          dataSource,
+          TracingType.skeleton,
+          fallbackLayerNameOpt = None, // unused when creating skeleton
+          ResolutionRestrictions.empty,
+          organizationName,
+          annotation.volumeTracingId
+        ).flatMap {
           case (Some(skeletonId), _) => annotationDAO.updateSkeletonTracingId(annotation._id, skeletonId)
           case _                     => Fox.failure("unexpectedReturn")
         }

conf/webknossos.latest.routes

@@ -114,7 +114,7 @@ PUT           /annotations/:typ/:id/reset                                      c
 PATCH         /annotations/:typ/:id/transfer                                   controllers.AnnotationController.transfer(typ: String, id: String)
 
 GET           /annotations/:typ/:id/info                                       controllers.AnnotationController.info(typ: String, id: String, timestamp: Long)
-PATCH         /annotations/:typ/:id/makeHybrid                                 controllers.AnnotationController.makeHybrid(typ: String, id: String)
+PATCH         /annotations/:typ/:id/makeHybrid                                 controllers.AnnotationController.makeHybrid(typ: String, id: String, fallbackLayerName: Option[String])
 PATCH         /annotations/:typ/:id/downsample                                 controllers.AnnotationController.downsample(typ: String, id: String)
 PATCH         /annotations/:typ/:id/unlinkFallback                             controllers.AnnotationController.unlinkFallback(typ: String, id: String)
 DELETE        /annotations/:typ/:id                                            controllers.AnnotationController.cancel(typ: String, id: String)

frontend/javascripts/admin/admin_rest_api.js

@@ -675,14 +675,14 @@ export function getAnnotationInformation(
 export function createExplorational(
   datasetId: APIDatasetId,
   typ: TracingType,
-  withFallback: boolean,
+  fallbackLayerName: ?string,
   resolutionRestrictions: ?APIResolutionRestrictions,
   options?: RequestOptions = {},
 ): Promise<APIAnnotation> {
   const url = `/api/datasets/${datasetId.owningOrganization}/${datasetId.name}/createExplorational`;
   return Request.sendJSONReceiveJSON(
     url,
-    Object.assign({}, { data: { typ, withFallback, resolutionRestrictions } }, options),
+    Object.assign({}, { data: { typ, fallbackLayerName, resolutionRestrictions } }, options),
   );
 }
 
@@ -761,9 +761,13 @@ export async function importVolumeTracing(tracing: Tracing, dataFile: File): Pro
   );
 }
 
-export function convertToHybridTracing(annotationId: string): Promise<void> {
+export function convertToHybridTracing(
+  annotationId: string,
+  fallbackLayerName: ?string,
+): Promise<void> {
   return Request.receiveJSON(`/api/annotations/Explorational/${annotationId}/makeHybrid`, {
     method: "PATCH",
+    fallbackLayerName,
   });
 }