Make segmentation output layer name for neuron detection configurable

CHANGELOG.unreleased.md

@@ -16,6 +16,7 @@ For upgrade instructions, please check the [migration guide](MIGRATIONS.released
 - Added support for blosc compressed N5 datasets. [#7465](https://github.com/scalableminds/webknossos/pull/7465)
 - Added route for triggering the compute segment index worker job. [#7471](https://github.com/scalableminds/webknossos/pull/7471)
 - Added thumbnails to the dashboard dataset list. [#7479](https://github.com/scalableminds/webknossos/pull/7479)
+- Added the option to configure the name of the output segmentation layer in the neuron inferral job. [#7472](https://github.com/scalableminds/webknossos/pull/7472)
 - Adhoc mesh rendering is now available for ND datasets.[#7394](https://github.com/scalableminds/webknossos/pull/7394)
 - Added the ability to compose a new dataset from existing dataset layers. This can be done with or without transforms (transforms will be derived from landmarks given via BigWarp CSV or WK NMLs). [#7395](https://github.com/scalableminds/webknossos/pull/7395)
 - When setting up WEBKNOSSOS from the git repository for development, the organization directory for storing datasets is now automatically created on startup. [#7517](https://github.com/scalableminds/webknossos/pull/7517)

app/controllers/JobsController.scala

@@ -4,10 +4,9 @@ import play.silhouette.api.Silhouette
 import com.scalableminds.util.geometry.Vec3Int
 import com.scalableminds.util.accesscontext.GlobalAccessContext
 import com.scalableminds.util.tools.Fox
-import models.dataset.DatasetDAO
+import models.dataset.{DataStoreDAO, DatasetDAO, DatasetService}
 import models.job._
 import models.organization.OrganizationDAO
-import models.dataset.DataStoreDAO
 import models.user.MultiUserDAO
 import play.api.i18n.Messages
 import play.api.libs.json._
@@ -53,6 +52,7 @@ class JobsController @Inject()(
     jobDAO: JobDAO,
     sil: Silhouette[WkEnv],
     datasetDAO: DatasetDAO,
+    datasetService: DatasetService,
     jobService: JobService,
     workerService: WorkerService,
     workerDAO: WorkerDAO,
@@ -149,6 +149,7 @@ class JobsController @Inject()(
         dataset <- datasetDAO.findOneByNameAndOrganization(datasetName, organization._id) ?~> Messages(
           "dataset.notFound",
           datasetName) ~> NOT_FOUND
+        _ <- datasetService.assertValidLayerName(layerName)
         command = JobCommand.compute_mesh_file
         commandArgs = Json.obj(
           "organization_name" -> organizationName,
@@ -173,6 +174,7 @@ class JobsController @Inject()(
         dataset <- datasetDAO.findOneByNameAndOrganization(datasetName, organization._id) ?~> Messages(
           "dataset.notFound",
           datasetName) ~> NOT_FOUND
+        _ <- datasetService.assertValidLayerName(layerName)
         command = JobCommand.compute_segment_index_file
         commandArgs = Json.obj(
           "organization_name" -> organizationName,
@@ -198,6 +200,8 @@ class JobsController @Inject()(
           dataset <- datasetDAO.findOneByNameAndOrganization(datasetName, organization._id) ?~> Messages(
             "dataset.notFound",
             datasetName) ~> NOT_FOUND
+          _ <- datasetService.assertValidDatasetName(newDatasetName)
+          _ <- datasetService.assertValidLayerName(layerName)
           command = JobCommand.infer_nuclei
           commandArgs = Json.obj(
             "organization_name" -> organizationName,
@@ -216,6 +220,7 @@ class JobsController @Inject()(
                          datasetName: String,
                          layerName: String,
                          bbox: String,
+                         outputSegmentationLayerName: String,
                          newDatasetName: String): Action[AnyContent] =
     sil.SecuredAction.async { implicit request =>
       log(Some(slackNotificationService.noticeFailedJobRequest)) {
@@ -226,6 +231,9 @@ class JobsController @Inject()(
           dataset <- datasetDAO.findOneByNameAndOrganization(datasetName, organization._id) ?~> Messages(
             "dataset.notFound",
             datasetName) ~> NOT_FOUND
+          _ <- datasetService.assertValidDatasetName(newDatasetName)
+          _ <- datasetService.assertValidLayerName(outputSegmentationLayerName)
+          _ <- datasetService.assertValidLayerName(layerName)
           multiUser <- multiUserDAO.findOne(request.identity._multiUser)
           _ <- Fox.runIf(!multiUser.isSuperUser)(jobService.assertBoundingBoxLimits(bbox, None))
           command = JobCommand.infer_neurons
@@ -234,6 +242,7 @@ class JobsController @Inject()(
             "dataset_name" -> datasetName,
             "new_dataset_name" -> newDatasetName,
             "layer_name" -> layerName,
+            "output_segmentation_layer_name" -> outputSegmentationLayerName,
             "webknossos_token" -> RpcTokenHolder.webknossosToken,
             "bbox" -> bbox,
           )
@@ -257,6 +266,8 @@ class JobsController @Inject()(
           dataset <- datasetDAO.findOneByNameAndOrganizationName(datasetName, organizationName) ?~> Messages(
             "dataset.notFound",
             datasetName) ~> NOT_FOUND
+          _ <- Fox.runOptional(layerName)(datasetService.assertValidLayerName)
+          _ <- Fox.runOptional(annotationLayerName)(datasetService.assertValidLayerName)
           _ <- jobService.assertBoundingBoxLimits(bbox, mag)
           userAuthToken <- wkSilhouetteEnvironment.combinedAuthenticatorService.findOrCreateToken(
             request.identity.loginInfo)
@@ -301,9 +312,12 @@ class JobsController @Inject()(
           dataset <- datasetDAO.findOneByNameAndOrganization(datasetName, organization._id) ?~> Messages(
             "dataset.notFound",
             datasetName) ~> NOT_FOUND
+          _ <- datasetService.assertValidLayerName(fallbackLayerName)
           userAuthToken <- wkSilhouetteEnvironment.combinedAuthenticatorService.findOrCreateToken(
             request.identity.loginInfo)
           command = JobCommand.materialize_volume_annotation
+          _ <- datasetService.assertValidDatasetName(newDatasetName)
+          _ <- datasetService.assertValidLayerName(outputSegmentationLayerName)
           commandArgs = Json.obj(
             "organization_name" -> organizationName,
             "dataset_name" -> datasetName,
@@ -333,6 +347,7 @@ class JobsController @Inject()(
           dataset <- datasetDAO.findOneByNameAndOrganization(datasetName, organization._id) ?~> Messages(
             "dataset.notFound",
             datasetName) ~> NOT_FOUND
+          _ <- datasetService.assertValidLayerName(layerName)
           command = JobCommand.find_largest_segment_id
           commandArgs = Json.obj(
             "organization_name" -> organizationName,
@@ -366,6 +381,8 @@ class JobsController @Inject()(
             bool2Fox(animationJobOptions.movieResolution == MovieResolutionSetting.SD) ?~> "job.renderAnimation.resolutionMustBeSD"
           }
           layerName = animationJobOptions.layerName
+          _ <- datasetService.assertValidLayerName(layerName)
+          _ <- Fox.runOptional(animationJobOptions.segmentationLayerName)(datasetService.assertValidLayerName)
           exportFileName = s"webknossos_animation_${formatDateForFilename(new Date())}__${datasetName}__$layerName.mp4"
           command = JobCommand.render_animation
           commandArgs = Json.obj(

app/models/dataset/DatasetService.scala

@@ -54,6 +54,12 @@ class DatasetService @Inject()(organizationDAO: OrganizationDAO,
       _ <- bool2Fox(name.length >= 3) ?~> "dataset.name.invalid.lessThanThreeCharacters"
     } yield ()
 
+  def assertValidLayerName(name: String): Fox[Unit] =
+    for {
+      _ <- bool2Fox(name.matches("[A-Za-z0-9_\\-\\.]*")) ?~> "dataset.layer.name.invalid.characters"
+      _ <- bool2Fox(!name.startsWith(".")) ?~> "dataset.layer.name.invalid.startsWithDot"
+    } yield ()
+
   def assertNewDatasetName(name: String, organizationId: ObjectId): Fox[Unit] =
     datasetDAO.findOneByNameAndOrganization(name, organizationId)(GlobalAccessContext).reverse
 

conf/webknossos.latest.routes

@@ -269,7 +269,7 @@ POST          /jobs/run/computeMeshFile/:organizationName/:datasetName
 POST          /jobs/run/computeSegmentIndexFile/:organizationName/:datasetName                  controllers.JobsController.runComputeSegmentIndexFileJob(organizationName: String, datasetName: String, layerName: String)
 POST          /jobs/run/exportTiff/:organizationName/:datasetName                               controllers.JobsController.runExportTiffJob(organizationName: String, datasetName: String, bbox: String, layerName: Option[String], mag: Option[String], annotationLayerName: Option[String], annotationId: Option[String], asOmeTiff: Boolean)
 POST          /jobs/run/inferNuclei/:organizationName/:datasetName                              controllers.JobsController.runInferNucleiJob(organizationName: String, datasetName: String, layerName: String, newDatasetName: String)
-POST          /jobs/run/inferNeurons/:organizationName/:datasetName                             controllers.JobsController.runInferNeuronsJob(organizationName: String, datasetName: String, layerName: String, bbox: String, newDatasetName: String)
+POST          /jobs/run/inferNeurons/:organizationName/:datasetName                             controllers.JobsController.runInferNeuronsJob(organizationName: String, datasetName: String, layerName: String, bbox: String, outputSegmentationLayerName: String, newDatasetName: String)
 POST          /jobs/run/materializeVolumeAnnotation/:organizationName/:datasetName              controllers.JobsController.runMaterializeVolumeAnnotationJob(organizationName: String, datasetName: String, fallbackLayerName: String, annotationId: String, annotationType: String, newDatasetName: String, outputSegmentationLayerName: String, mergeSegments: Boolean, volumeLayerName: Option[String])
 POST          /jobs/run/findLargestSegmentId/:organizationName/:datasetName                     controllers.JobsController.runFindLargestSegmentIdJob(organizationName: String, datasetName: String, layerName: String)
 POST          /jobs/run/renderAnimation/:organizationName/:datasetName                          controllers.JobsController.runRenderAnimationJob(organizationName: String, datasetName: String)

frontend/javascripts/admin/admin_rest_api.ts

@@ -1296,12 +1296,17 @@ export function startNeuronInferralJob(
   datasetName: string,
   layerName: string,
   bbox: Vector6,
+  outputSegmentationLayerName: string,
   newDatasetName: string,
 ): Promise<APIJob> {
+  const urlParams = new URLSearchParams({
+    layerName,
+    bbox: bbox.join(","),
+    outputSegmentationLayerName,
+    newDatasetName,
+  });
   return Request.receiveJSON(
-    `/api/jobs/run/inferNeurons/${organizationName}/${datasetName}?layerName=${layerName}&bbox=${bbox.join(
-      ",",
-    )}&newDatasetName=${newDatasetName}`,
+    `/api/jobs/run/inferNeurons/${organizationName}/${datasetName}?${urlParams.toString()}`,
     {
       method: "POST",
     },

frontend/javascripts/oxalis/view/action-bar/starting_job_modals.tsx

@@ -68,6 +68,10 @@ const jobNameToImagePath: Record<
   materialize_volume_annotation: "materialize_volume_annotation_example.jpg",
   invisible: "",
 };
+const jobTypeWithConfigurableOutputSegmentationLayerName = [
+  "materialize_volume_annotation",
+  "neuron_inferral",
+];
 type Props = {
   handleClose: () => void;
 };
@@ -566,23 +570,24 @@ function StartJobForm(props: StartJobFormProps) {
   initialOutputSegmentationLayerName = `${
     initialOutputSegmentationLayerName || "segmentation"
   }_corrected`;
-  // TODO: Other jobs also have an output segmentation layer. The names for these jobs should also be configurable.
-  const hasOutputSegmentationLayer = jobName === "materialize_volume_annotation";
+  const hasOutputSegmentationLayer =
+    jobTypeWithConfigurableOutputSegmentationLayerName.indexOf(jobName) > -1;
   const notAllowedOutputLayerNames = allLayers
     .filter((layer) => {
       // Existing layer names may not be used for the output layer. The only exception
       // is the name of the currently selected layer. This layer is the only one not
       // copied over from the original dataset to the output dataset.
       // Therefore, this name is available as the name for the output layer name.
       // That is why that layer is filtered out here.
-      const currentSelectedVolumeLayerName = form.getFieldValue("layerName") || initialLayerName;
+      const currentSelectedVolumeLayerName = chooseSegmentationLayer
+        ? form.getFieldValue("layerName") || initialLayerName
+        : undefined;
       return (
         getReadableNameOfVolumeLayer(layer, tracing) !== currentSelectedVolumeLayerName &&
         layer.name !== currentSelectedVolumeLayerName
       );
     })
     .map((layer) => getReadableNameOfVolumeLayer(layer, tracing) || layer.name);
-
   return (
     <Form
       onFinish={startJob}
@@ -672,9 +677,14 @@ export function NeuronSegmentationForm() {
       title="AI Neuron Segmentation"
       suggestedDatasetSuffix="with_reconstructed_neurons"
       isBoundingBoxConfigurable
-      jobApiCall={async ({ newDatasetName, selectedLayer: colorLayer, selectedBoundingBox }) => {
-        if (!selectedBoundingBox) {
-          return Promise.resolve();
+      jobApiCall={async ({
+        newDatasetName,
+        selectedLayer: colorLayer,
+        selectedBoundingBox,
+        outputSegmentationLayerName,
+      }) => {
+        if (!selectedBoundingBox || !outputSegmentationLayerName) {
+          return;
         }
 
         const bbox = computeArrayFromBoundingBox(selectedBoundingBox.boundingBox);
@@ -683,6 +693,7 @@ export function NeuronSegmentationForm() {
           dataset.name,
           colorLayer.name,
           bbox,
+          outputSegmentationLayerName,
           newDatasetName,
         );
       }}
@@ -788,9 +799,12 @@ export function MaterializeVolumeAnnotationModal({
           outputSegmentationLayerName,
         }) => {
           if (outputSegmentationLayerName == null) {
-            return Promise.resolve();
+            return;
           }
-          const volumeLayerName = getReadableNameOfVolumeLayer(segmentationLayer, tracing);
+          const volumeLayerName =
+            "fallbackLayer" in segmentationLayer && segmentationLayer.fallbackLayer != null
+              ? getReadableNameOfVolumeLayer(segmentationLayer, tracing)
+              : null;
           const baseSegmentationName = getBaseSegmentationName(segmentationLayer);
           return startMaterializingVolumeAnnotationJob(
             dataset.owningOrganization,