Make ad-hoc meshes compatible with ND segmentations

CHANGELOG.unreleased.md

@@ -11,10 +11,9 @@ For upgrade instructions, please check the [migration guide](MIGRATIONS.released
 [Commits](https://github.com/scalableminds/webknossos/compare/23.12.0...HEAD)
 
 ### Added
-- Zarr datasets can now be directly uploaded to WEBKNOSSOS. [#7397](https://github.com/scalableminds/webknossos/pull/7397)
-- Added support for reading uint24 rgb layers in datasets with zarr2/zarr3/n5/neuroglancerPrecomputed format, as used for voxelytics predictions. [#7413](https://github.com/scalableminds/webknossos/pull/7413)
-- Adding a remote dataset can now be done by providing a Neuroglancer URI. [#7416](https://github.com/scalableminds/webknossos/pull/7416)
-- Added a filter to the Task List->Stats column to quickly filter for tasks with "Prending", "In-Progress" or "Finished" instances. [#7430](https://github.com/scalableminds/webknossos/pull/7430)
+- Added support for S3-compliant object storage services (e.g. MinIO) as a storage backend for remote datasets. [#7453](https://github.com/scalableminds/webknossos/pull/7453)
+- 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)
 - Adhoc mesh rendering is now available for ND datasets.[#7394](https://github.com/scalableminds/webknossos/pull/7394)
 
 ### Changed

frontend/javascripts/oxalis/api/api_latest.ts

@@ -139,6 +139,7 @@ import Constants, {
   AnnotationToolEnum,
   TDViewDisplayModeEnum,
   MappingStatusEnum,
+  EMPTY_OBJECT,
 } from "oxalis/constants";
 import DataLayer from "oxalis/model/data_layer";
 import type { OxalisModel } from "oxalis/model";
@@ -2257,8 +2258,12 @@ class DataApi {
       layerName,
     ).name;
 
-    if (Store.getState().localSegmentationData[effectiveLayerName].meshes[segmentId] != null) {
+    if (Store.getState().localSegmentationData[effectiveLayerName].meshes?.[segmentId] != null) {
       Store.dispatch(updateMeshVisibilityAction(effectiveLayerName, segmentId, isVisible));
+    } else {
+      throw new Error(
+        `Mesh for segment ${segmentId} was not found in OxalisState.localSegmentationData.`,
+      );
     }
   }
 
@@ -2275,8 +2280,12 @@ class DataApi {
       layerName,
     ).name;
 
-    if (Store.getState().localSegmentationData[effectiveLayerName].meshes[segmentId] != null) {
+    if (Store.getState().localSegmentationData[effectiveLayerName].meshes?.[segmentId] != null) {
       Store.dispatch(removeMeshAction(effectiveLayerName, segmentId));
+    } else {
+      throw new Error(
+        `Mesh for segment ${segmentId} was not found in OxalisState.localSegmentationData.`,
+      );
     }
   }
 
@@ -2293,7 +2302,7 @@ class DataApi {
       layerName,
     ).name;
     const segmentIds = Object.keys(
-      Store.getState().localSegmentationData[effectiveLayerName].meshes,
+      Store.getState().localSegmentationData[effectiveLayerName].meshes || EMPTY_OBJECT,
     );
 
     for (const segmentId of segmentIds) {

frontend/javascripts/oxalis/constants.ts

@@ -381,3 +381,4 @@ export enum BLEND_MODES {
 
 export const Identity4x4 = new Float32Array([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);
 export const IdentityTransform = { type: "affine", affineMatrix: Identity4x4 } as const;
+export const EMPTY_OBJECT = {};

frontend/javascripts/oxalis/controller/segment_mesh_controller.ts

@@ -34,28 +34,17 @@ export default class SegmentMeshController {
     layerName: string,
     additionalCoordinates?: AdditionalCoordinate[] | null,
   ): boolean {
-    const additionalCoordinatesString = getAdditionalCoordinatesAsString(
-      additionalCoordinates || null,
+    return (
+      this.getMeshGroups(getAdditionalCoordinatesAsString(additionalCoordinates), layerName, id) !=
+      null
     );
-
-    if (
-      this.meshesGroupsPerSegmentationId[additionalCoordinatesString] == null ||
-      this.meshesGroupsPerSegmentationId[additionalCoordinatesString][layerName] == null
-    )
-      return false;
-
-    const segments = this.meshesGroupsPerSegmentationId[additionalCoordinatesString][layerName];
-    if (!segments) {
-      return false;
-    }
-    return segments[id] != null;
   }
 
   addMeshFromVertices(
     vertices: Float32Array,
     segmentationId: number,
     layerName: string,
-    additionalCoordinates?: AdditionalCoordinate[],
+    additionalCoordinates?: AdditionalCoordinate[] | undefined | null,
   ): void {
     if (vertices.length === 0) return;
     let bufferGeometry = new THREE.BufferGeometry();
@@ -71,7 +60,7 @@ export default class SegmentMeshController {
       null,
       NO_LOD_MESH_INDEX,
       layerName,
-      additionalCoordinates || null,
+      additionalCoordinates,
     );
   }
 
@@ -113,114 +102,67 @@ export default class SegmentMeshController {
     scale: Vector3 | null = null,
     lod: number,
     layerName: string,
-    additionalCoordinates: AdditionalCoordinate[] | null,
+    additionalCoordinates: AdditionalCoordinate[] | null | undefined,
   ): void {
-    const additionalCoordinatesString = getAdditionalCoordinatesAsString(
-      additionalCoordinates || null,
+    const additionalCoordinatesString = getAdditionalCoordinatesAsString(additionalCoordinates);
+    const newGroup = new THREE.Group();
+    const keys = [additionalCoordinatesString, layerName, segmentationId, lod];
+    _.set(
+      this.meshesGroupsPerSegmentationId,
+      keys,
+      _.get(this.meshesGroupsPerSegmentationId, keys, newGroup),
     );
-    if (this.meshesGroupsPerSegmentationId[additionalCoordinatesString] == null) {
-      this.meshesGroupsPerSegmentationId[additionalCoordinatesString] = {};
-    }
-
-    if (this.meshesGroupsPerSegmentationId[additionalCoordinatesString][layerName] == null) {
-      this.meshesGroupsPerSegmentationId[additionalCoordinatesString][layerName] = {};
-    }
-    if (
-      this.meshesGroupsPerSegmentationId[additionalCoordinatesString][layerName][segmentationId] ==
-      null
-    ) {
-      this.meshesGroupsPerSegmentationId[additionalCoordinatesString][layerName][segmentationId] =
-        {};
+    if (lod === NO_LOD_MESH_INDEX) {
+      this.meshesLODRootGroup.addNoLODSupportedMesh(newGroup);
+    } else {
+      this.meshesLODRootGroup.addLODMesh(newGroup, lod);
     }
-    if (
-      this.meshesGroupsPerSegmentationId[additionalCoordinatesString][layerName][segmentationId][
-        lod
-      ] == null
-    ) {
-      const newGroup = new THREE.Group();
-      this.meshesGroupsPerSegmentationId[additionalCoordinatesString][layerName][segmentationId][
-        lod
-      ] = newGroup;
-      if (lod === NO_LOD_MESH_INDEX) {
-        this.meshesLODRootGroup.addNoLODSupportedMesh(newGroup);
-      } else {
-        this.meshesLODRootGroup.addLODMesh(newGroup, lod);
-      }
-      // @ts-ignore
-      newGroup.cellId = segmentationId;
-      if (scale != null) {
-        newGroup.scale.copy(new THREE.Vector3(...scale));
-      }
+    // @ts-ignore
+    newGroup.cellId = segmentationId;
+    if (scale != null) {
+      newGroup.scale.copy(new THREE.Vector3(...scale));
     }
     const mesh = this.constructMesh(segmentationId, geometry);
     if (offset) {
       mesh.translateX(offset[0]);
       mesh.translateY(offset[1]);
       mesh.translateZ(offset[2]);
     }
-    this.meshesGroupsPerSegmentationId[additionalCoordinatesString][layerName][segmentationId][
-      lod
-    ].add(mesh);
+    this.addMeshToMeshGroups(additionalCoordinatesString, layerName, segmentationId, lod, mesh);
   }
 
-  removeMeshById(
-    segmentationId: number,
-    layerName: string,
-    additionalCoordinates: AdditionalCoordinate[] | null,
-  ): void {
-    // either remove a mesh for specific additional coordinates, or remove all meshes for a segment per default.
-    let additionalCoordinatesToRemoveMeshes;
-    if (additionalCoordinates == null) {
-      additionalCoordinatesToRemoveMeshes = Object.keys(this.meshesGroupsPerSegmentationId);
-    } else {
-      additionalCoordinatesToRemoveMeshes = [
-        getAdditionalCoordinatesAsString(additionalCoordinates),
-      ];
-    }
-    for (const additionalCoordinatesString of additionalCoordinatesToRemoveMeshes) {
-      if (
-        this.meshesGroupsPerSegmentationId[additionalCoordinatesString] == null ||
-        this.meshesGroupsPerSegmentationId[additionalCoordinatesString][layerName] == null ||
-        this.meshesGroupsPerSegmentationId[additionalCoordinatesString][layerName][
-          segmentationId
-        ] == null
-      ) {
-        return;
-      }
-      _.forEach(
-        this.meshesGroupsPerSegmentationId[additionalCoordinatesString][layerName][segmentationId],
-        (meshGroup, lod) => {
-          const lodNumber = parseInt(lod);
-          if (lodNumber !== NO_LOD_MESH_INDEX) {
-            this.meshesLODRootGroup.removeLODMesh(meshGroup, lodNumber);
-          } else {
-            this.meshesLODRootGroup.removeNoLODSupportedMesh(meshGroup);
-          }
-        },
-      );
-      delete this.meshesGroupsPerSegmentationId[additionalCoordinatesString][layerName][
-        segmentationId
-      ];
+  removeMeshById(segmentationId: number, layerName: string): void {
+    const additionalCoordinates = Store.getState().flycam.additionalCoordinates;
+    const additionalCoordKey = getAdditionalCoordinatesAsString(additionalCoordinates);
+    if (this.getMeshGroups(additionalCoordKey, layerName, segmentationId) == null) {
+      return;
     }
+    _.forEach(
+      this.getMeshGroups(additionalCoordKey, layerName, segmentationId),
+      (meshGroup, lod) => {
+        const lodNumber = parseInt(lod);
+        if (lodNumber !== NO_LOD_MESH_INDEX) {
+          this.meshesLODRootGroup.removeLODMesh(meshGroup, lodNumber);
+        } else {
+          this.meshesLODRootGroup.removeNoLODSupportedMesh(meshGroup);
+        }
+      },
+    );
+    this.removeMeshFromMeshGroups(additionalCoordKey, layerName, segmentationId);
   }
 
   getMeshGeometryInBestLOD(
     segmentId: number,
     layerName: string,
     additionalCoordinates?: AdditionalCoordinate[] | null,
   ): THREE.Group {
-    const additionalCoordinatesString = getAdditionalCoordinatesAsString(
-      additionalCoordinates || null,
-    );
-
+    const additionalCoordKey = getAdditionalCoordinatesAsString(additionalCoordinates);
     const bestLod = Math.min(
-      ...Object.keys(
-        this.meshesGroupsPerSegmentationId[additionalCoordinatesString][layerName][segmentId],
-      ).map((lodVal) => parseInt(lodVal)),
+      ...Object.keys(this.getMeshGroups(additionalCoordKey, layerName, segmentId)).map((lodVal) =>
+        parseInt(lodVal),
+      ),
     );
-    return this.meshesGroupsPerSegmentationId[additionalCoordinatesString][layerName][segmentId][
-      bestLod
-    ];
+    return this.getMeshGroupsByLOD(additionalCoordinates, layerName, segmentId, bestLod);
   }
 
   setMeshVisibility(
@@ -229,20 +171,10 @@ export default class SegmentMeshController {
     layerName: string,
     additionalCoordinates?: AdditionalCoordinate[] | null,
   ): void {
-    const additionalCoordinatesString = getAdditionalCoordinatesAsString(
-      additionalCoordinates || null,
-    );
-
-    if (this.meshesGroupsPerSegmentationId[additionalCoordinatesString] == null) {
-      return;
-    }
-
-    _.forEach(
-      this.meshesGroupsPerSegmentationId[additionalCoordinatesString][layerName][id],
-      (meshGroup) => {
-        meshGroup.visible = visibility;
-      },
-    );
+    const additionalCoordKey = getAdditionalCoordinatesAsString(additionalCoordinates);
+    _.forEach(this.getMeshGroups(additionalCoordKey, layerName, id), (meshGroup) => {
+      meshGroup.visible = visibility;
+    });
   }
 
   setMeshColor(id: number, layerName: string): void {
@@ -296,4 +228,40 @@ export default class SegmentMeshController {
     this.meshesLODRootGroup.add(directionalLight2);
     this.meshesLODRootGroup.add(pointLight);
   }
+
+  getMeshGroupsByLOD(
+    additionalCoordinates: AdditionalCoordinate[] | null | undefined,
+    layerName: string,
+    segmentationId: number,
+    lod: number,
+  ) {
+    const additionalCoordKey = getAdditionalCoordinatesAsString(additionalCoordinates);
+    const keys = [additionalCoordKey, layerName, segmentationId, lod];
+    return _.get(this.meshesGroupsPerSegmentationId, keys, null);
+  }
+
+  getMeshGroups(additionalCoordKey: string, layerName: string, segmentationId: number) {
+    const keys = [additionalCoordKey, layerName, segmentationId];
+    return _.get(this.meshesGroupsPerSegmentationId, keys, null);
+  }
+
+  addMeshToMeshGroups(
+    additionalCoordKey: string,
+    layerName: string,
+    segmentationId: number,
+    lod: number,
+    mesh: THREE.Mesh<THREE.BufferGeometry, THREE.MeshLambertMaterial>,
+  ) {
+    this.meshesGroupsPerSegmentationId[additionalCoordKey][layerName][segmentationId][lod].add(
+      mesh,
+    );
+  }
+
+  removeMeshFromMeshGroups(
+    additionalCoordinateKey: string,
+    layerName: string,
+    segmentationId: number,
+  ) {
+    delete this.meshesGroupsPerSegmentationId[additionalCoordinateKey][layerName][segmentationId];
+  }
 }

frontend/javascripts/oxalis/controller/url_manager.ts

@@ -274,9 +274,12 @@ class UrlManager {
     for (const layerName of Object.keys(state.localSegmentationData)) {
       const { meshes: localMeshes, currentMeshFile } = state.localSegmentationData[layerName];
       const currentMeshFileName = currentMeshFile?.meshFileName;
-      const meshes = Utils.values(localMeshes)
-        .filter(({ isVisible }) => isVisible)
-        .map(mapMeshInfoToUrlMeshDescriptor);
+      const meshes =
+        localMeshes != null
+          ? Utils.values(localMeshes as Record<number, MeshInformation>)
+              .filter(({ isVisible }) => isVisible)
+              .map(mapMeshInfoToUrlMeshDescriptor)
+          : [];
 
       if (currentMeshFileName != null || meshes.length > 0) {
         stateByLayer[layerName] = {

frontend/javascripts/oxalis/model/accessors/flycam_accessor.ts

@@ -274,7 +274,7 @@ function _getPosition(flycam: Flycam): Vector3 {
 }
 
 export function getAdditionalCoordinatesAsString(
-  additionalCoordinates: AdditionalCoordinate[] | null,
+  additionalCoordinates: AdditionalCoordinate[] | null | undefined,
 ): string {
   if (additionalCoordinates != null && additionalCoordinates.length > 0) {
     return additionalCoordinates