Use datastore segment index when loading ad-hoc meshes (#8922)

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

### Steps to test:
- Get a segment index file for l4_sample from
https://www.notion.so/scalableminds/Test-Datasets-c0563be9c4a4499dae4e16d9b2497cfb?source=copy_link#27db51644c63800ea207ee7674502373
and register it in the datasource-properties.json (merge with existing
attachments block if needed)
```
"attachments" : {
      "segmentIndex" : {
        "name" : "segment_index_file",
        "path" : "./segmentation/segmentIndex/l4_sample_segment_index_file.hdf5",
        "dataFormat" : "hdf5"
      },
}
```
- Load ad-hoc mesh from position `3629, 3489, 1024` (Segment 41)
- mesh should now show the second unconnected piece
<img width="305" height="262" alt="image"
src="https://github.com/user-attachments/assets/9717192f-e38b-4f33-8c26-19a020def3d5"
/>

- Also load adhoc mesh from volume annotation with some brushed
segments, should work without errors
- For static segmentation layer without segment index file, adhoc meshes
should still be loadable (they won’t show unconnected pieces though)
- Also load the same mesh via the backend fullMesh.stl route with `curl
'http://localhost:9000/data/datasets/68da42fbd90000f3132f9921/layers/segmentation/meshes/fullMesh.stl?token=secretSampleUserToken'
-X POST -H 'Accept-Encoding: gzip, deflate, br' -H 'content-type:
application/json' --data-raw '{"segmentId": 41, "mag": [8, 8, 2]}'
--output ~/out.stl` (insert dataset id from your local wk instance),
inspect result, e.g. in meshlab. Should also show both pieces.

### Issues:
- fixes #7615

some context: https://scm.slack.com/archives/C5AKLAV0B/p1757940808856039

------
- [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: Tom Herold <[email protected]>
Co-authored-by: Charlie Meister <[email protected]>
Co-authored-by: Charlie Meister <[email protected]>

Author: 3 people

frontend/javascripts/admin/rest_api.ts

@@ -80,6 +80,10 @@ import type { DatasourceConfiguration } from "types/schemas/datasource.types";
 import type { AnnotationTypeFilterEnum, LOG_LEVELS, Vector3 } from "viewer/constants";
 import Constants, { ControlModeEnum, AnnotationStateFilterEnum } from "viewer/constants";
 import type BoundingBox from "viewer/model/bucket_data_handling/bounding_box";
+import {
+  type LayerSourceInfo,
+  getDataOrTracingStoreUrl,
+} from "viewer/model/bucket_data_handling/wkstore_helper";
 import {
   parseProtoAnnotation,
   parseProtoListOfLong,
@@ -855,13 +859,18 @@ export function hasSegmentIndexInDataStore(
   );
 }
 
+export const hasSegmentIndexInDataStoreCached = _.memoize(hasSegmentIndexInDataStore, (...args) =>
+  args.join("::"),
+);
+
 export function getSegmentVolumes(
-  requestUrl: string,
+  layerSourceInfo: LayerSourceInfo,
   mag: Vector3,
   segmentIds: Array<number>,
   additionalCoordinates: AdditionalCoordinate[] | undefined | null,
   mappingName: string | null | undefined,
 ): Promise<number[]> {
+  const requestUrl = getDataOrTracingStoreUrl(layerSourceInfo);
   return doWithToken((token) =>
     Request.sendJSONReceiveJSON(`${requestUrl}/segmentStatistics/volume?token=${token}`, {
       data: { additionalCoordinates, mag, segmentIds, mappingName },
@@ -871,12 +880,13 @@ export function getSegmentVolumes(
 }
 
 export function getSegmentBoundingBoxes(
-  requestUrl: string,
+  layerSourceInfo: LayerSourceInfo,
   mag: Vector3,
   segmentIds: Array<number>,
   additionalCoordinates: AdditionalCoordinate[] | undefined | null,
   mappingName: string | null | undefined,
 ): Promise<Array<{ topLeft: Vector3; width: number; height: number; depth: number }>> {
+  const requestUrl = getDataOrTracingStoreUrl(layerSourceInfo);
   return doWithToken((token) =>
     Request.sendJSONReceiveJSON(`${requestUrl}/segmentStatistics/boundingBox?token=${token}`, {
       data: { additionalCoordinates, mag, segmentIds, mappingName },
@@ -1877,12 +1887,13 @@ type MeshRequest = {
 };
 
 export function computeAdHocMesh(
-  requestUrl: string,
+  layerSourceInfo: LayerSourceInfo,
   meshRequest: MeshRequest,
 ): Promise<{
   buffer: ArrayBuffer;
   neighbors: Array<number>;
 }> {
+  const requestUrl = getDataOrTracingStoreUrl(layerSourceInfo);
   const {
     positionWithPadding,
     additionalCoordinates,
@@ -1924,23 +1935,25 @@ export function computeAdHocMesh(
 }
 
 export function getBucketPositionsForAdHocMesh(
-  tracingStoreUrl: string,
-  tracingId: string,
+  layerSourceInfo: LayerSourceInfo,
   segmentId: number,
   cubeSize: Vector3,
   mag: Vector3,
   additionalCoordinates: AdditionalCoordinate[] | null | undefined,
+  mappingName: string | null | undefined,
 ): Promise<Vector3[]> {
+  const requestUrl = getDataOrTracingStoreUrl(layerSourceInfo);
   return doWithToken(async (token) => {
     const params = new URLSearchParams();
     params.set("token", token);
     const positions = await Request.sendJSONReceiveJSON(
-      `${tracingStoreUrl}/tracings/volume/${tracingId}/segmentIndex/${segmentId}?${params}`,
+      `${requestUrl}/segmentIndex/${segmentId}?${params}`,
       {
         data: {
           cubeSize,
           mag,
           additionalCoordinates,
+          mappingName,
         },
         method: "POST",
       },

frontend/javascripts/viewer/model/bucket_data_handling/wkstore_helper.ts

@@ -0,0 +1,20 @@
+import type { APIDataset } from "types/api_types";
+import type { StoreAnnotation } from "viewer/store";
+
+export type LayerSourceInfo = {
+  dataset: APIDataset;
+  annotation: StoreAnnotation | null;
+  tracingId: string | undefined;
+  segmentationLayerName: string;
+  useDataStore?: boolean | undefined | null;
+};
+
+export function getDataOrTracingStoreUrl(layerSourceInfo: LayerSourceInfo) {
+  const { dataset, annotation, segmentationLayerName, tracingId, useDataStore } = layerSourceInfo;
+  if (annotation == null || tracingId == null || useDataStore) {
+    return `${dataset.dataStore.url}/data/datasets/${dataset.id}/layers/${segmentationLayerName}`;
+  } else {
+    const tracingStoreHost = annotation?.tracingStore.url;
+    return `${tracingStoreHost}/tracings/volume/${tracingId}`;
+  }
+}

frontend/javascripts/viewer/model/sagas/meshes/ad_hoc_mesh_saga.ts

@@ -1,6 +1,7 @@
 import {
   computeAdHocMesh,
   getBucketPositionsForAdHocMesh,
+  hasSegmentIndexInDataStoreCached,
   sendAnalyticsEvent,
 } from "admin/rest_api";
 import ThreeDMap from "libs/ThreeDMap";
@@ -41,13 +42,14 @@ import {
   type LoadAdHocMeshAction,
   loadPrecomputedMeshAction,
 } from "viewer/model/actions/segmentation_actions";
+import type { LayerSourceInfo } from "viewer/model/bucket_data_handling/wkstore_helper";
 import type DataLayer from "viewer/model/data_layer";
 import type { MagInfo } from "viewer/model/helpers/mag_info";
 import { zoomedAddressToAnotherZoomStepWithInfo } from "viewer/model/helpers/position_converter";
 import type { Saga } from "viewer/model/sagas/effect-generators";
 import { select } from "viewer/model/sagas/effect-generators";
 import { Model } from "viewer/singletons";
-import Store from "viewer/store";
+import Store, { type StoreDataset, type VolumeTracing } from "viewer/store";
 import { getAdditionalCoordinatesAsString } from "../../accessors/flycam_accessor";
 import { ensureSceneControllerReady, ensureWkReady } from "../ready_sagas";
 
@@ -293,6 +295,25 @@ function removeMeshWithoutVoxels(
   }
 }
 
+function* getUsePositionsFromSegmentIndex(
+  volumeTracing: VolumeTracing | null | undefined,
+  dataset: StoreDataset,
+  layerName: string,
+  maybeTracingId?: string | null,
+): Saga<boolean> {
+  if (volumeTracing == null) {
+    return yield* call(
+      hasSegmentIndexInDataStoreCached,
+      dataset.dataStore.url,
+      dataset.id,
+      layerName,
+    );
+  }
+  return (
+    volumeTracing?.hasSegmentIndex && !volumeTracing.hasEditableMapping && maybeTracingId != null
+  );
+}
+
 function* loadFullAdHocMesh(
   layer: DataLayer,
   segmentId: number,
@@ -320,36 +341,54 @@ function* loadFullAdHocMesh(
   yield* put(startedLoadingMeshAction(layer.name, segmentId));
 
   const cubeSize = marchingCubeSizeInTargetMag();
-  const tracingStoreHost = yield* select((state) => state.annotation.tracingStore.url);
+  const dataset = yield* select((state) => state.dataset);
   const mag = magInfo.getMagByIndexOrThrow(zoomStep);
 
   const volumeTracing = yield* select((state) => getActiveSegmentationTracing(state));
+  const annotation = yield* select((state) => state.annotation);
   const visibleSegmentationLayer = yield* select((state) => getVisibleSegmentationLayer(state));
+  if (visibleSegmentationLayer == null) {
+    throw new Error(
+      "Loading the ad-hoc mesh failed because the visible segmentation layer must not be null.",
+    );
+  }
   // Fetch from datastore if no volumetracing ...
-  let useDataStore = volumeTracing == null || visibleSegmentationLayer?.tracingId == null;
+  let forceUsingDataStore = volumeTracing == null || visibleSegmentationLayer.tracingId == null;
   if (meshExtraInfo.useDataStore != null) {
     // ... except if the caller specified whether to use the data store ...
-    useDataStore = meshExtraInfo.useDataStore;
+    forceUsingDataStore = meshExtraInfo.useDataStore;
   } else if (volumeTracing?.hasEditableMapping) {
     // ... or if an editable mapping is active.
-    useDataStore = false;
+    forceUsingDataStore = false;
   }
 
-  // Segment stats can only be used for volume tracings that have a segment index
+  // Segment stats can only be used for segmentation layers that have a segment index
   // and that don't have editable mappings.
-  const usePositionsFromSegmentIndex =
-    volumeTracing?.hasSegmentIndex &&
-    !volumeTracing.hasEditableMapping &&
-    visibleSegmentationLayer?.tracingId != null;
+  const usePositionsFromSegmentIndex = yield* call(
+    getUsePositionsFromSegmentIndex,
+    volumeTracing,
+    dataset,
+    layer.name,
+    visibleSegmentationLayer.tracingId,
+  );
+
+  const layerSourceInfo: LayerSourceInfo = {
+    dataset,
+    annotation,
+    tracingId: visibleSegmentationLayer.tracingId,
+    segmentationLayerName: visibleSegmentationLayer.fallbackLayer ?? visibleSegmentationLayer.name,
+    useDataStore: forceUsingDataStore,
+  };
+
   let positionsToRequest = usePositionsFromSegmentIndex
     ? yield* getChunkPositionsFromSegmentIndex(
-        tracingStoreHost,
-        layer,
+        layerSourceInfo,
         segmentId,
         cubeSize,
         mag,
         clippedPosition,
         additionalCoordinates,
+        mappingName,
       )
     : [clippedPosition];
 
@@ -373,7 +412,7 @@ function* loadFullAdHocMesh(
       magInfo,
       isInitialRequest,
       removeExistingMesh && isInitialRequest,
-      useDataStore,
+      layerSourceInfo,
       !usePositionsFromSegmentIndex,
     );
     isInitialRequest = false;
@@ -390,22 +429,22 @@ function* loadFullAdHocMesh(
 }
 
 function* getChunkPositionsFromSegmentIndex(
-  tracingStoreHost: string,
-  layer: DataLayer,
+  layerSourceInfo: LayerSourceInfo,
   segmentId: number,
   cubeSize: Vector3,
   mag: Vector3,
   clippedPosition: Vector3,
   additionalCoordinates: AdditionalCoordinate[] | null | undefined,
+  mappingName: string | null | undefined,
 ) {
   const targetMagPositions = yield* call(
     getBucketPositionsForAdHocMesh,
-    tracingStoreHost,
-    layer.name,
+    layerSourceInfo,
     segmentId,
     cubeSize,
     mag,
     additionalCoordinates,
+    mappingName,
   );
   const mag1Positions = targetMagPositions.map((pos) => V3.scale3(pos, mag));
   return sortByDistanceTo(mag1Positions, clippedPosition) as Vector3[];
@@ -424,7 +463,7 @@ function* maybeLoadMeshChunk(
   magInfo: MagInfo,
   isInitialRequest: boolean,
   removeExistingMesh: boolean,
-  useDataStore: boolean,
+  layerSourceInfo: LayerSourceInfo,
   findNeighbors: boolean,
 ): Saga<Vector3[]> {
   const additionalCoordinates = yield* select((state) => state.flycam.additionalCoordinates);
@@ -445,17 +484,10 @@ function* maybeLoadMeshChunk(
   batchCounterPerSegment[segmentId]++;
   threeDMap.set(paddedPositionWithinLayer, true);
   const scaleFactor = yield* select((state) => state.dataset.dataSource.scale.factor);
-  const dataStoreHost = yield* select((state) => state.dataset.dataStore.url);
-  const datasetId = yield* select((state) => state.dataset.id);
-  const tracingStoreHost = yield* select((state) => state.annotation.tracingStore.url);
-  const dataStoreUrl = `${dataStoreHost}/data/datasets/${datasetId}/layers/${
-    layer.fallbackLayer != null ? layer.fallbackLayer : layer.name
-  }`;
-  const tracingStoreUrl = `${tracingStoreHost}/tracings/volume/${layer.name}`;
 
   if (isInitialRequest) {
     sendAnalyticsEvent("request_isosurface", {
-      mode: useDataStore ? "view" : "annotation",
+      mode: layerSourceInfo.useDataStore ? "view" : "annotation",
     });
   }
 
@@ -472,7 +504,7 @@ function* maybeLoadMeshChunk(
           context: null,
           fn: computeAdHocMesh,
         },
-        useDataStore ? dataStoreUrl : tracingStoreUrl,
+        layerSourceInfo,
         {
           positionWithPadding: paddedPositionWithinLayer,
           additionalCoordinates: additionalCoordinates || undefined,

frontend/javascripts/viewer/view/context_menu.tsx

@@ -146,10 +146,7 @@ import type {
 import { deleteNodeAsUserAction } from "viewer/model/actions/skeletontracing_actions_with_effects";
 import { type MutableNode, type Tree, TreeMap } from "viewer/model/types/tree_types";
 import Store from "viewer/store";
-import {
-  getVolumeRequestUrl,
-  withMappingActivationConfirmation,
-} from "viewer/view/right-border-tabs/segments_tab/segments_view_helper";
+import { withMappingActivationConfirmation } from "viewer/view/right-border-tabs/segments_tab/segments_view_helper";
 import { LayoutEvents, layoutEmitter } from "./layouting/layout_persistence";
 import { LoadMeshMenuItemLabel } from "./right-border-tabs/segments_tab/load_mesh_menu_item_label";
 
@@ -1690,26 +1687,26 @@ function ContextMenuInner() {
       if (visibleSegmentationLayer == null || !isSegmentIndexAvailable) return [];
       const tracingId = volumeTracing?.tracingId;
       const additionalCoordinates = flycam.additionalCoordinates;
-      const requestUrl = getVolumeRequestUrl(
+      const layerSourceInfo = {
         dataset,
         annotation,
         tracingId,
-        visibleSegmentationLayer,
-      );
+        segmentationLayerName: visibleSegmentationLayer.name,
+      };
       const magInfo = getMagInfo(visibleSegmentationLayer.mags);
       const layersFinestMag = magInfo.getFinestMag();
       const voxelSize = dataset.dataSource.scale;
 
       try {
         const [segmentSize] = await getSegmentVolumes(
-          requestUrl,
+          layerSourceInfo,
           layersFinestMag,
           [clickedSegmentOrMeshId],
           additionalCoordinates,
           mappingName,
         );
         const [boundingBoxInRequestedMag] = await getSegmentBoundingBoxes(
-          requestUrl,
+          layerSourceInfo,
           layersFinestMag,
           [clickedSegmentOrMeshId],
           additionalCoordinates,

frontend/javascripts/viewer/view/right-border-tabs/segments_tab/segment_statistics_modal.tsx

@@ -17,11 +17,7 @@ import { getBoundingBoxInMag1 } from "viewer/model/sagas/volume/helpers";
 import { voxelToVolumeInUnit } from "viewer/model/scaleinfo";
 import { api } from "viewer/singletons";
 import type { Segment } from "viewer/store";
-import {
-  type SegmentHierarchyGroup,
-  type SegmentHierarchyNode,
-  getVolumeRequestUrl,
-} from "./segments_view_helper";
+import type { SegmentHierarchyGroup, SegmentHierarchyNode } from "./segments_view_helper";
 
 const MODAL_ERROR_MESSAGE =
   "Segment statistics could not be fetched. Check the console for more details.";
@@ -104,12 +100,12 @@ export function SegmentStatisticsModal({
   const voxelSize = dataset.dataSource.scale;
   // Omit checking that all prerequisites for segment stats (such as a segment index) are
   // met right here because that should happen before opening the modal.
-  const requestUrl = getVolumeRequestUrl(
+  const storeInfoType = {
     dataset,
     annotation,
-    visibleSegmentationLayer.tracingId,
-    visibleSegmentationLayer,
-  );
+    tracingId: visibleSegmentationLayer.tracingId,
+    segmentationLayerName: visibleSegmentationLayer.name,
+  };
   const additionalCoordinates = useWkSelector((state) => state.flycam.additionalCoordinates);
   const hasAdditionalCoords = hasAdditionalCoordinates(additionalCoordinates);
   const additionalCoordinateStringForModal = getAdditionalCoordinatesAsString(
@@ -119,7 +115,6 @@ export function SegmentStatisticsModal({
   const segmentStatisticsObjects = useFetch(
     async () => {
       await api.tracing.save();
-      if (requestUrl == null) return;
       const maybeVolumeTracing =
         tracingId != null ? getVolumeTracingById(annotation, tracingId) : null;
       const maybeGetMappingName = () => {
@@ -132,14 +127,14 @@ export function SegmentStatisticsModal({
       };
       const segmentStatisticsObjects = await Promise.all([
         getSegmentVolumes(
-          requestUrl,
+          storeInfoType,
           layersFinestMag,
           segments.map((segment) => segment.id),
           additionalCoordinates,
           maybeGetMappingName(),
         ),
         getSegmentBoundingBoxes(
-          requestUrl,
+          storeInfoType,
           layersFinestMag,
           segments.map((segment) => segment.id),
           additionalCoordinates,