Calculate surface area of segments (#8928)

- Adds surface area segment stat, based on mesh triangle surfaces
- Fixes fullMesh loading with ad-hoc meshes, also used in
render_animation worker jobs

### URL of deployed dev instance (used for testing):
- https://meshsurfacearea.webknossos.xyz

### Steps to test:
- For dataset with segment index file, and also for volume annotation:
- Context menu should now have explicitly triggered loading of segment
statistics
  - Surface area should be included

### TODOs:
- [x] Fix Infinity/NaN
- [x] Validate math/output value against meshlab
- [x] move to segment statistics route
- [x] also allow for adhoc/volume/proofreading?
- [x] Frontend
   - [x] Add surface area segment statistic
- [x] Move segment statistic out of toplevel rightclick menu to save
computation
- [x] Select correct combination of meshing parameters for the new route
- [x] Wait for #8922 to enable static layer ad-hoc without seedPosition
- [x] Re-Test proofreading ad-hoc, do we need to set
editableMappingTracingId or is the layer doing this for us already?

### Issues:
- fixes #8610

------
- [x] Added changelog entry (create a `$PR_NUMBER.md` file in
`unreleased_changes` or use `./tools/create-changelog-entry.py`)
- [x] Removed dev-only changes like prints and application.conf edits
- [x] Considered [common edge
cases](../blob/master/.github/common_edge_cases.md)
- [x] Needs datastore update after deployment

---------

Co-authored-by: Philipp Otto <[email protected]>
Co-authored-by: Michael Büßemeyer <[email protected]>

Author: 3 people

app/controllers/WKRemoteDataStoreController.scala

@@ -246,7 +246,7 @@ class WKRemoteDataStoreController @Inject()(
     Action.async { implicit request =>
       dataStoreService.validateAccess(name, key) { _ =>
         for {
-          dataset <- datasetDAO.findOne(datasetId)(GlobalAccessContext) ~> NOT_FOUND
+          dataset <- datasetDAO.findOne(datasetId)(GlobalAccessContext) ?~> Messages("dataset.notFound", datasetId) ~> NOT_FOUND
           layers <- datasetLayerDAO.findAllForDataset(dataset._id)
           magsAndLinkedMags <- Fox.serialCombined(layers)(l => datasetService.getPathsForDataLayer(dataset._id, l.name))
           magLinkInfos = magsAndLinkedMags.map(_.map { case (mag, linkedMags) => MagLinkInfo(mag, linkedMags) })
@@ -261,18 +261,17 @@ class WKRemoteDataStoreController @Inject()(
     Action.async { implicit request =>
       dataStoreService.validateAccess(name, key) { _ =>
         for {
-          dataset <- datasetDAO.findOne(datasetId)(GlobalAccessContext)
+          dataset <- datasetDAO.findOne(datasetId)(GlobalAccessContext) ?~> Messages("dataset.notFound", datasetId) ~> NOT_FOUND
           dataSource <- datasetService.dataSourceFor(dataset)
         } yield Ok(Json.toJson(dataSource))
       }
-
     }
 
   def updateDataSource(name: String, key: String, datasetId: ObjectId): Action[DataSource] =
     Action.async(validateJson[DataSource]) { implicit request =>
       dataStoreService.validateAccess(name, key) { _ =>
         for {
-          dataset <- datasetDAO.findOne(datasetId)(GlobalAccessContext) ~> NOT_FOUND
+          dataset <- datasetDAO.findOne(datasetId)(GlobalAccessContext) ?~> Messages("dataset.notFound", datasetId) ~> NOT_FOUND
           _ <- Fox.runIf(!dataset.isVirtual)(
             datasetDAO.updateDataSource(datasetId,
                                         name,

app/controllers/WKRemoteTracingStoreController.scala

@@ -17,6 +17,7 @@ import models.annotation._
 import models.dataset.{DatasetDAO, DatasetService}
 import models.user.UserDAO
 import models.user.time.TimeSpanService
+import play.api.i18n.Messages
 import play.api.libs.json.Json
 import play.api.mvc.{Action, AnyContent, PlayBodyParsers}
 import scalapb.GeneratedMessage
@@ -155,12 +156,22 @@ class WKRemoteTracingStoreController @Inject()(tracingStoreService: TracingStore
       tracingStoreService.validateAccess(name, key) { _ =>
         implicit val ctx: DBAccessContext = GlobalAccessContext
         for {
-          dataset <- datasetDAO.findOne(datasetId) ?~> "dataset.notFound" ~> NOT_FOUND
+          dataset <- datasetDAO.findOne(datasetId) ?~> Messages("dataset.notFound", datasetId) ~> NOT_FOUND
           dataStore <- datasetService.dataStoreFor(dataset)
         } yield Ok(Json.toJson(dataStore.url))
       }
     }
 
+  def getDataSource(name: String, key: String, datasetId: ObjectId): Action[AnyContent] =
+    Action.async { implicit request =>
+      tracingStoreService.validateAccess(name, key) { _ =>
+        for {
+          dataset <- datasetDAO.findOne(datasetId)(GlobalAccessContext) ?~> Messages("dataset.notFound", datasetId) ~> NOT_FOUND
+          dataSource <- datasetService.dataSourceFor(dataset)
+        } yield Ok(Json.toJson(dataSource))
+      }
+    }
+
   def createTracing(name: String,
                     key: String,
                     annotationId: ObjectId,

conf/messages

@@ -276,6 +276,7 @@ mesh.file.lookup.failed=Failed to look up mesh file “{0}”
 mesh.file.readVersion.failed=Failed to read format version from file “{0}”
 mesh.file.readMappingName.failed=Failed to read mapping name from mesh file “{0}”
 mesh.meshFileName.required=Trying to load mesh from mesh file, but mesh file name was not supplied.
+mesh.loadFull.failed=Failed to load full segment mesh.
 
 segmentIndexFile.notFound=Could not find requested segment index file
 

conf/webknossos.latest.routes

@@ -103,12 +103,12 @@ GET           /datasets/:datasetId/layers/:layer/thumbnail
 POST          /datasets/:datasetId/layers/:layer/segmentAnythingMask                            controllers.DatasetController.segmentAnythingMask(datasetId: ObjectId, layer: String, intensityMin: Option[Float], intensityMax: Option[Float])
 PUT           /datasets/:datasetId/clearThumbnailCache                                          controllers.DatasetController.removeFromThumbnailCache(datasetId: ObjectId)
 GET           /datasets/:datasetName/isValidNewName                                             controllers.DatasetController.isValidNewName(datasetName: String)
-GET           /datasets/:datasetId                                                              controllers.DatasetController.read(datasetId: ObjectId, sharingToken: Option[String])
 DELETE        /datasets/:datasetId/deleteOnDisk                                                 controllers.DatasetController.deleteOnDisk(datasetId: ObjectId)
 POST          /datasets/:datasetId/reserveAttachmentUploadToPath                                controllers.DatasetController.reserveAttachmentUploadToPath(datasetId: ObjectId)
 POST          /datasets/:datasetId/finishAttachmentUploadToPath                                 controllers.DatasetController.finishAttachmentUploadToPath(datasetId: ObjectId)
 POST          /datasets/:datasetId/reserveUploadToPathsForPreliminary                           controllers.DatasetController.reserveUploadToPathsForPreliminary(datasetId: ObjectId)
 POST          /datasets/:datasetId/finishUploadToPaths                                          controllers.DatasetController.finishUploadToPaths(datasetId: ObjectId)
+GET           /datasets/:datasetId                                                              controllers.DatasetController.read(datasetId: ObjectId, sharingToken: Option[String])
 POST          /datasets/compose                                                                 controllers.DatasetController.compose()
 POST          /datasets/reserveUploadToPaths                                                    controllers.DatasetController.reserveUploadToPaths()
 
@@ -152,6 +152,7 @@ GET           /tracingstores/:name/datasetId
 GET           /tracingstores/:name/annotationId                                                 controllers.WKRemoteTracingStoreController.annotationIdForTracing(name: String, key: String, tracingId: String)
 GET           /tracingstores/:name/dataStoreUri/:datasetId                                      controllers.WKRemoteTracingStoreController.dataStoreUriForDataset(name: String, key: String, datasetId: ObjectId)
 POST          /tracingstores/:name/createTracing                                                controllers.WKRemoteTracingStoreController.createTracing(name: String, key: String, annotationId: ObjectId, previousVersion: Long)
+GET           /tracingstores/:name/datasources/:datasetId                                       controllers.WKRemoteTracingStoreController.getDataSource(name: String, key: String, datasetId: ObjectId)
 
 # User access tokens for datastore authentication
 POST          /userToken/generate                                                               controllers.UserTokenController.generateTokenForDataStore()

frontend/javascripts/admin/rest_api.ts

@@ -879,6 +879,41 @@ export function getSegmentVolumes(
   );
 }
 
+type SegmentStatisticsParametersMeshBased = {
+  mag: Vector3;
+  segmentIds: number[];
+  mappingName?: string | null;
+  additionalCoordinates?: AdditionalCoordinate[] | null;
+  meshFileName?: string | null;
+};
+
+export function getSegmentSurfaceArea(
+  layerSourceInfo: LayerSourceInfo,
+  mag: Vector3,
+  meshFileName: string | undefined | null,
+  segmentIds: Array<number>,
+  additionalCoordinates: AdditionalCoordinate[] | undefined | null,
+  mappingName: string | null | undefined,
+): Promise<number[]> {
+  const requestUrl = getDataOrTracingStoreUrl(layerSourceInfo);
+  return doWithToken((token) => {
+    const data: SegmentStatisticsParametersMeshBased = {
+      mag,
+      segmentIds,
+      mappingName,
+      additionalCoordinates,
+      meshFileName,
+    };
+    return Request.sendJSONReceiveJSON(
+      `${requestUrl}/segmentStatistics/surfaceArea?token=${token}`,
+      {
+        data,
+        method: "POST",
+      },
+    );
+  });
+}
+
 export function getSegmentBoundingBoxes(
   layerSourceInfo: LayerSourceInfo,
   mag: Vector3,

frontend/javascripts/libs/format_utils.ts

@@ -293,7 +293,7 @@ export const nmFactorToUnit3D = new Map([
   [1e99, "Ym³"],
 ]);
 
-// Accepts an volume that is interpreted in the given unit and returns a string
+// Accepts a volume that is interpreted in the given unit and returns a string
 // that uses a readable unit to represent the volume.
 // E.g. formatNumberToVolume(0.003, Unit.m) == "3000.0 cm³"
 export function formatNumberToVolume(

frontend/javascripts/viewer/model/accessors/volumetracing_accessor.ts

@@ -947,3 +947,14 @@ export function getReadableNameOfVolumeLayer(
     ? getReadableNameByVolumeTracingId(tracing, layer.tracingId)
     : null;
 }
+
+export function getCurrentMappingName(state: WebknossosState) {
+  const visibleSegmentationLayer = getVisibleSegmentationLayer(state);
+  const volumeTracing = getActiveSegmentationTracing(state);
+  if (volumeTracing?.mappingName != null) return volumeTracing?.mappingName;
+  const mappingInfo = getMappingInfo(
+    state.temporaryConfiguration.activeMappingByLayer,
+    visibleSegmentationLayer?.name,
+  );
+  return mappingInfo.mappingName;
+}