Evaluate segmentation in infer neurons task

CHANGELOG.unreleased.md

@@ -11,6 +11,7 @@ For upgrade instructions, please check the [migration guide](MIGRATIONS.released
 [Commits](https://github.com/scalableminds/webknossos/compare/24.11.1...HEAD)
 
 ### Added
+- It is now possible to start a split-merger evaluation when starting a neuron inference. [#8221](https://github.com/scalableminds/webknossos/pull/8221)
 - When exploring remote URIs pasted from Neuroglancer, the format prefixes like `precomputed://` are now ignored, so users don’t have to remove them. [#8195](https://github.com/scalableminds/webknossos/pull/8195)
 
 ### Changed

app/controllers/JobController.scala

@@ -226,7 +226,13 @@ class JobController @Inject()(
                          datasetName: String,
                          layerName: String,
                          bbox: String,
-                         newDatasetName: String): Action[AnyContent] =
+                         newDatasetName: String,
+                         doEvaluation: Boolean,
+                         annotationId: Option[String],
+                         evalUseSparseTracing: Option[Boolean],
+                         evalMaxEdgeLength: Option[String],
+                         evalSparseTubeThresholdNm: Option[String],
+                         evalMinMergerPathLengthNm: Option[String]): Action[AnyContent] =
     sil.SecuredAction.async { implicit request =>
       log(Some(slackNotificationService.noticeFailedJobRequest)) {
         for {
@@ -248,6 +254,12 @@ class JobController @Inject()(
             "new_dataset_name" -> newDatasetName,
             "layer_name" -> layerName,
             "bbox" -> bbox,
+            "do_evaluation" -> doEvaluation,
+            "annotation_id" -> annotationId,
+            "eval_use_sparse_tracing" -> evalUseSparseTracing,
+            "eval_max_edge_length" -> evalMaxEdgeLength,
+            "eval_sparse_tube_threshold_nm" -> evalSparseTubeThresholdNm,
+            "eval_min_merger_path_length_nm" -> evalMinMergerPathLengthNm,
           )
           job <- jobService.submitJob(command, commandArgs, request.identity, dataset._dataStore) ?~> "job.couldNotRunNeuronInferral"
           js <- jobService.publicWrites(job)

app/models/job/Job.scala

@@ -52,6 +52,7 @@ case class Job(
   def datasetName: Option[String] = argAsStringOpt("dataset_name")
 
   private def argAsStringOpt(key: String) = (commandArgs \ key).toOption.flatMap(_.asOpt[String])
+  private def argAsBooleanOpt(key: String) = (commandArgs \ key).toOption.flatMap(_.asOpt[Boolean])
 
   def resultLink(organizationId: String): Option[String] =
     if (effectiveState != JobState.SUCCESS) None
@@ -63,6 +64,8 @@ case class Job(
           }
         case JobCommand.export_tiff | JobCommand.render_animation =>
           Some(s"/api/jobs/${this._id}/export")
+        case JobCommand.infer_neurons if this.argAsBooleanOpt("do_evaluation").getOrElse(false) =>
+          returnValue.map { resultAnnotationLink => resultAnnotationLink}
         case JobCommand.infer_nuclei | JobCommand.infer_neurons | JobCommand.materialize_volume_annotation |
             JobCommand.infer_with_model | JobCommand.infer_mitochondria | JobCommand.align_sections =>
           returnValue.map { resultDatasetName =>

conf/webknossos.latest.routes

@@ -264,7 +264,7 @@ POST          /jobs/run/computeMeshFile/:organizationId/:datasetName
 POST          /jobs/run/computeSegmentIndexFile/:organizationId/:datasetName                    controllers.JobController.runComputeSegmentIndexFileJob(organizationId: String, datasetName: String, layerName: String)
 POST          /jobs/run/exportTiff/:organizationId/:datasetName                                 controllers.JobController.runExportTiffJob(organizationId: String, datasetName: String, bbox: String, additionalCoordinates: Option[String], layerName: Option[String], mag: Option[String], annotationLayerName: Option[String], annotationId: Option[String], asOmeTiff: Boolean)
 POST          /jobs/run/inferNuclei/:organizationId/:datasetName                                controllers.JobController.runInferNucleiJob(organizationId: String, datasetName: String, layerName: String, newDatasetName: String)
-POST          /jobs/run/inferNeurons/:organizationId/:datasetName                               controllers.JobController.runInferNeuronsJob(organizationId: String, datasetName: String, layerName: String, bbox: String, newDatasetName: String)
+POST          /jobs/run/inferNeurons/:organizationId/:datasetName                               controllers.JobController.runInferNeuronsJob(organizationId: String, datasetName: String, layerName: String, bbox: String, newDatasetName: String, doEvaluation: Boolean, annotationId: Option[String],evalUseSparseTracing: Option[Boolean],evalMaxEdgeLength: Option[String],evalSparseTubeThresholdNm: Option[String],evalMinMergerPathLengthNm: Option[String])
 POST          /jobs/run/inferMitochondria/:organizationId/:datasetName                          controllers.JobController.runInferMitochondriaJob(organizationId: String, datasetName: String, layerName: String, bbox: String, newDatasetName: String)
 POST          /jobs/run/alignSections/:organizationId/:datasetName                              controllers.JobController.runAlignSectionsJob(organizationId: String, datasetName: String, layerName: String, newDatasetName: String, annotationId: Option[String])
 POST          /jobs/run/materializeVolumeAnnotation/:organizationId/:datasetName                controllers.JobController.runMaterializeVolumeAnnotationJob(organizationId: String, datasetName: String, fallbackLayerName: String, annotationId: String, annotationType: String, newDatasetName: String, outputSegmentationLayerName: String, mergeSegments: Boolean, volumeLayerName: Option[String])

frontend/javascripts/admin/api/jobs.ts

@@ -193,12 +193,26 @@ export function startNeuronInferralJob(
   layerName: string,
   bbox: Vector6,
   newDatasetName: string,
+  doEvaluation: boolean,
+  annotationId?: string,
+  useSparseTracing?: boolean,
+  evalMaxEdgeLength?: string,
+  evalSparseTubeThresholdNm?: string,
+  evalMinMergerPathLengthNm?: string,
 ): Promise<APIJob> {
   const urlParams = new URLSearchParams({
     layerName,
     bbox: bbox.join(","),
     newDatasetName,
+    doEvaluation: doEvaluation.toString(),
   });
+  if (doEvaluation) {
+    urlParams.append("annotationId", `${annotationId}`);
+    urlParams.append("evalUseSparseTracing", `${useSparseTracing}`);
+    urlParams.append("evalMaxEdgeLength", `${evalMaxEdgeLength}`);
+    urlParams.append("evalSparseTubeThresholdNm", `${evalSparseTubeThresholdNm}`);
+    urlParams.append("evalMinMergerPathLengthNm", `${evalMinMergerPathLengthNm}`);
+  }
   return Request.receiveJSON(
     `/api/jobs/run/inferNeurons/${organizationId}/${datasetName}?${urlParams.toString()}`,
     {

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

@@ -15,6 +15,9 @@ import {
   Switch,
   type FormInstance,
   Checkbox,
+  Collapse,
+  Col,
+  InputNumber,
 } from "antd";
 import {
   startNucleiInferralJob,
@@ -98,6 +101,7 @@ type StartJobFormProps = Props & {
   jobApiCall: (arg0: JobApiCallArgsType, form: FormInstance<any>) => Promise<void | APIJob>;
   jobName: keyof typeof jobNameToImagePath;
   description: React.ReactNode;
+  jobSpecificInputFields?: React.ReactNode | undefined;
   isBoundingBoxConfigurable?: boolean;
   chooseSegmentationLayer?: boolean;
   suggestedDatasetSuffix: string;
@@ -523,11 +527,84 @@ function ShouldUseTreesFormItem() {
   );
 }
 
+function CollapsibleEvaluationSettings({
+  isActive = false,
+  setActive,
+}: { isActive: boolean; setActive: (active: boolean) => void }) {
+  return (
+    <Collapse
+      style={{ marginBottom: 8 }}
+      onChange={() => setActive(!isActive)}
+      expandIcon={() => <Checkbox checked={isActive} />}
+      items={[
+        {
+          key: "evaluation",
+          label: "Evaluation Settings",
+          children: (
+            <Row>
+              <Col style={{ width: "100%" }}>
+                <Form.Item
+                  label="Use sparse ground truth tracing"
+                  name={["evaluationSettings", "useSparseTracing"]}
+                  valuePropName="checked"
+                  initialValue={false}
+                  tooltip="The evaluation mode can either be `dense`
+    in case all processes in the volume are annotated in the ground-truth.
+    If not, use the `sparse` mode."
+                >
+                  <Checkbox style={{ width: "100%" }} />
+                </Form.Item>
+                <Form.Item
+                  label="Max edge length in nm"
+                  name={["evaluationSettings", "maxEdgeLength"]}
+                  tooltip="Ground truth tracings can be densified so that
+    nodes are at most max_edge_length nm apart.
+    However, this can also introduce wrong nodes in curved processes."
+                >
+                  <InputNumber style={{ width: "100%" }} placeholder="None" />
+                </Form.Item>
+                <Form.Item
+                  label="Sparse tube threshold in nm"
+                  name={["evaluationSettings", "sparseTubeThresholdInNm"]}
+                  tooltip="Tube threshold for sparse evaluation,
+    determining if a process is too far from the ground-truth."
+                >
+                  <InputNumber style={{ width: "100%" }} placeholder="1000" />
+                </Form.Item>
+                <Form.Item
+                  label="Sparse minimum merger path length in nm"
+                  name={["evaluationSettings", "minimumMergerPathLengthInNm"]}
+                  tooltip="Minimum ground truth path length of a merger component
+    to be counted as a relevant merger (for sparse evaluation).
+    Note, the path length to neighboring nodes of a component is included for this comparison. This optimistic path length
+    estimation makes sure no relevant mergers are ignored."
+                >
+                  <InputNumber style={{ width: "100%" }} placeholder="800" />
+                </Form.Item>
+                <Form.Item name="useAnnotation" initialValue={true} />
+              </Col>
+            </Row>
+          ),
+        },
+      ]}
+      activeKey={isActive ? "evaluation" : []}
+    />
+  );
+}
+
 function StartJobForm(props: StartJobFormProps) {
   const isBoundingBoxConfigurable = props.isBoundingBoxConfigurable || false;
   const isSkeletonSelectable = props.isSkeletonSelectable || false;
   const chooseSegmentationLayer = props.chooseSegmentationLayer || false;
-  const { handleClose, jobName, jobApiCall, fixedSelectedLayer, title, description } = props;
+  const {
+    handleClose,
+    jobName,
+    jobApiCall,
+    fixedSelectedLayer,
+    title,
+    description,
+    jobSpecificInputFields,
+  } = props;
   const [form] = Form.useForm();
   const rawUserBoundingBoxes = useSelector((state: OxalisState) =>
     getUserBoundingBoxesFromState(state),
@@ -650,6 +727,7 @@ function StartJobForm(props: StartJobFormProps) {
         onChangeSelectedBoundingBox={(bBoxId) => form.setFieldsValue({ boundingBoxId: bBoxId })}
         value={form.getFieldValue("boundingBoxId")}
       />
+      {jobSpecificInputFields}
       {isSkeletonSelectable && <ShouldUseTreesFormItem />}
       {props.showWorkflowYaml ? (
         <CollapsibleWorkflowYamlEditor
@@ -707,6 +785,7 @@ export function NucleiDetectionForm() {
 export function NeuronSegmentationForm() {
   const dataset = useSelector((state: OxalisState) => state.dataset);
   const dispatch = useDispatch();
+  const [useEvaluation, setUseEvaluation] = React.useState(false);
   return (
     <StartJobForm
       handleClose={() => dispatch(setAIJobModalStateAction("invisible"))}
@@ -715,18 +794,38 @@ export function NeuronSegmentationForm() {
       title="AI Neuron Segmentation"
       suggestedDatasetSuffix="with_reconstructed_neurons"
       isBoundingBoxConfigurable
-      jobApiCall={async ({ newDatasetName, selectedLayer: colorLayer, selectedBoundingBox }) => {
-        if (!selectedBoundingBox) {
+      jobApiCall={async (
+        { newDatasetName, selectedLayer: colorLayer, selectedBoundingBox, annotationId },
+        form: FormInstance<any>,
+      ) => {
+        const evaluationSettings = form.getFieldValue("evaluationSettings");
+        if (!selectedBoundingBox || (useEvaluation && evaluationSettings == null)) {
           return;
         }
 
         const bbox = computeArrayFromBoundingBox(selectedBoundingBox.boundingBox);
+        if (!useEvaluation) {
+          return startNeuronInferralJob(
+            dataset.owningOrganization,
+            dataset.name,
+            colorLayer.name,
+            bbox,
+            newDatasetName,
+            useEvaluation,
+          );
+        }
         return startNeuronInferralJob(
           dataset.owningOrganization,
           dataset.name,
           colorLayer.name,
           bbox,
           newDatasetName,
+          useEvaluation,
+          annotationId,
+          evaluationSettings.useSparseTracing,
+          evaluationSettings.maxEdgeLength,
+          evaluationSettings.sparseTubeThresholdInNm,
+          evaluationSettings.minimumMergerPathLengthInNm,
         );
       }}
       description={
@@ -742,6 +841,9 @@ export function NeuronSegmentationForm() {
           </Space>
         </>
       }
+      jobSpecificInputFields={
+        <CollapsibleEvaluationSettings isActive={useEvaluation} setActive={setUseEvaluation} />
+      }
     />
   );
 }