[WIP] Live Collab M3 - Follow ups for agglomerate skeletons and meshes

biome.jsonc

@@ -120,9 +120,7 @@
 
   "overrides": [
     {
-      "includes": [
-        "**/package.json"
-      ],
+      "includes": ["**/package.json"],
       "formatter": {
         "lineWidth": 1
       }

frontend/javascripts/admin/api/mesh.ts

@@ -24,6 +24,7 @@ export type MeshSegmentInfo = {
 type ListMeshChunksRequest = {
   meshFileName: string;
   segmentId: number;
+  annotationVersion: number | undefined | null;
 };
 
 export function getMeshFileChunksForSegment(
@@ -41,6 +42,7 @@ export function getMeshFileChunksForSegment(
   // editableMappingTracingId should be the tracing id, not the editable mapping id.
   // If this is set, it is assumed that the request is about an editable mapping.
   editableMappingTracingId: string | null | undefined,
+  annotationVersion: number | undefined | null,
 ): Promise<MeshSegmentInfo> {
   return doWithToken((token) => {
     const params = new URLSearchParams();
@@ -54,6 +56,7 @@ export function getMeshFileChunksForSegment(
     const payload: ListMeshChunksRequest = {
       meshFileName: meshFile.name,
       segmentId,
+      annotationVersion,
     };
     return Request.sendJSONReceiveJSON(
       `${dataStoreUrl}/data/datasets/${datasetId}/layers/${layerName}/meshes/chunks?${params}`,
@@ -71,7 +74,7 @@ type MeshChunkDataRequest = {
   segmentId: number | null; // Only relevant for neuroglancer precomputed meshes
 };
 
-type MeshChunkDataRequestList = {
+export type MeshChunkDataRequestList = {
   meshFileName: string;
   requests: MeshChunkDataRequest[];
 };

frontend/javascripts/admin/rest_api.ts

@@ -880,11 +880,12 @@ export function getSegmentVolumes(
   segmentIds: Array<number>,
   additionalCoordinates: AdditionalCoordinate[] | undefined | null,
   mappingName: string | null | undefined,
+  annotationVersion: number | undefined,
 ): Promise<number[]> {
   const requestUrl = getDataOrTracingStoreUrl(layerSourceInfo);
   return doWithToken((token) =>
     Request.sendJSONReceiveJSON(`${requestUrl}/segmentStatistics/volume?token=${token}`, {
-      data: { additionalCoordinates, mag, segmentIds, mappingName },
+      data: { additionalCoordinates, mag, segmentIds, mappingName, annotationVersion },
       method: "POST",
     }),
   );
@@ -896,6 +897,7 @@ type SegmentStatisticsParametersMeshBased = {
   mappingName?: string | null;
   additionalCoordinates?: AdditionalCoordinate[] | null;
   meshFileName?: string | null;
+  annotationVersion: number | undefined;
 };
 
 export function getSegmentSurfaceArea(
@@ -905,6 +907,7 @@ export function getSegmentSurfaceArea(
   segmentIds: Array<number>,
   additionalCoordinates: AdditionalCoordinate[] | undefined | null,
   mappingName: string | null | undefined,
+  annotationVersion: number | undefined,
 ): Promise<number[]> {
   const requestUrl = getDataOrTracingStoreUrl(layerSourceInfo);
   return doWithToken((token) => {
@@ -914,6 +917,7 @@ export function getSegmentSurfaceArea(
       mappingName,
       additionalCoordinates,
       meshFileName,
+      annotationVersion,
     };
     return Request.sendJSONReceiveJSON(
       `${requestUrl}/segmentStatistics/surfaceArea?token=${token}`,
@@ -931,11 +935,12 @@ export function getSegmentBoundingBoxes(
   segmentIds: Array<number>,
   additionalCoordinates: AdditionalCoordinate[] | undefined | null,
   mappingName: string | null | undefined,
+  annotationVersion: number | 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 },
+      data: { additionalCoordinates, mag, segmentIds, mappingName, annotationVersion },
       method: "POST",
     }),
   );
@@ -1823,6 +1828,7 @@ type MeshRequest = {
   mappingName: string | null | undefined;
   mappingType: MappingType | null | undefined;
   findNeighbors: boolean;
+  annotationVersion: number;
 };
 
 export function computeAdHocMesh(
@@ -1880,6 +1886,7 @@ export function getBucketPositionsForAdHocMesh(
   mag: Vector3,
   additionalCoordinates: AdditionalCoordinate[] | null | undefined,
   mappingName: string | null | undefined,
+  annotationVersion: number,
 ): Promise<Vector3[]> {
   const requestUrl = getDataOrTracingStoreUrl(layerSourceInfo);
   return doWithToken(async (token) => {
@@ -1893,6 +1900,7 @@ export function getBucketPositionsForAdHocMesh(
           mag,
           additionalCoordinates,
           mappingName,
+          annotationVersion,
         },
         method: "POST",
       },

frontend/javascripts/libs/diffable_map.ts

@@ -1,3 +1,5 @@
+import isEqual from "lodash-es/isEqual";
+
 const defaultItemsPerBatch = 1000;
 let idCounter = 0;
 const idSymbol = Symbol("id");
@@ -417,9 +419,11 @@ class DiffableMap<K extends number, V> implements NotEnumerableByObject {
               ? "null"
               : v === undefined
                 ? "undefined"
-                : typeof v === "object"
-                  ? JSON.stringify(v)
-                  : String(v);
+                : v instanceof DiffableMap
+                  ? v.toString()
+                  : typeof v === "object"
+                    ? JSON.stringify(v)
+                    : String(v);
           return `${k} => ${vStr}`;
         })
         .join(", ");
@@ -468,11 +472,16 @@ function shallowCopy<K extends number, V>(template: DiffableMap<K, V>): Diffable
 export function diffDiffableMaps<K extends number, V>(
   mapA: DiffableMap<K, V>,
   mapB: DiffableMap<K, V>,
+  useDeepEqualityCheck: boolean = false,
 ): {
   changed: Array<K>;
   onlyA: Array<K>;
   onlyB: Array<K>;
 } {
+  const areDifferent = useDeepEqualityCheck
+    ? (valueA: V | undefined, valueB: V | undefined) => !isEqual(valueA, valueB)
+    : (valueA: V | undefined, valueB: V | undefined) => valueA !== valueB;
+
   // For the edge case that one of the maps is empty, we will consider them dependent, anyway
   const areDiffsDependent = mapA.getId() === mapB.getId() || mapA.size() === 0 || mapB.size() === 0;
   let idx = 0;
@@ -506,7 +515,7 @@ export function diffDiffableMaps<K extends number, V>(
 
       for (const key of setA.values()) {
         if (setB.has(key)) {
-          if (currentMapA.get(key) !== currentMapB.get(key)) {
+          if (areDifferent(currentMapA.get(key), currentMapB.get(key))) {
             changed.push(key);
           } else {
             // The key exists in both chunks, do not emit this key.
@@ -530,32 +539,32 @@ export function diffDiffableMaps<K extends number, V>(
     idx++;
   }
 
-  if (!areDiffsDependent) {
-    // Since, the DiffableMaps don't share the same structure, we might have
-    // aggregated false-positives, meaning onlyA and onlyB can include the same
-    // keys, which might or might not belong to the changed set.
-    // Construct a set for fast lookup
-    const setA = new Set(onlyA);
-    // Intersection of onlyA and onlyB:
-    const missingChangedIds = onlyB.filter((id) => setA.has(id));
-    const missingChangedIdSet = new Set(missingChangedIds);
-    const newOnlyA = onlyA.filter((id) => !missingChangedIdSet.has(id));
-    const newOnlyB = onlyB.filter((id) => !missingChangedIdSet.has(id));
-    // Ensure that these elements are not equal before adding them to "changed"
-    const newChanged = changed.concat(
-      missingChangedIds.filter((id) => mapA.getOrThrow(id) !== mapB.getOrThrow(id)),
-    );
+  if (areDiffsDependent) {
     return {
-      changed: newChanged,
-      onlyA: newOnlyA,
-      onlyB: newOnlyB,
+      changed,
+      onlyA,
+      onlyB,
     };
   }
 
+  // Since, the DiffableMaps don't share the same structure, we might have
+  // aggregated false-positives, meaning onlyA and onlyB can include the same
+  // keys, which might or might not belong to the changed set.
+  // Construct a set for fast lookup
+  const setA = new Set(onlyA);
+  // Intersection of onlyA and onlyB:
+  const missingChangedIds = onlyB.filter((id) => setA.has(id));
+  const missingChangedIdSet = new Set(missingChangedIds);
+  const newOnlyA = onlyA.filter((id) => !missingChangedIdSet.has(id));
+  const newOnlyB = onlyB.filter((id) => !missingChangedIdSet.has(id));
+  // Ensure that these elements are not equal before adding them to "changed"
+  const newChanged = changed.concat(
+    missingChangedIds.filter((id) => areDifferent(mapA.getOrThrow(id), mapB.getOrThrow(id))),
+  );
   return {
-    changed,
-    onlyA,
-    onlyB,
+    changed: newChanged,
+    onlyA: newOnlyA,
+    onlyB: newOnlyB,
   };
 }
 

frontend/javascripts/libs/mjs.ts

@@ -5,6 +5,7 @@
 import mjs, { type Matrix4x4, type Vector16 } from "mjs";
 import type { Vector2, Vector3, Vector4 } from "viewer/constants";
 import { chunk3 } from "viewer/model/helpers/chunk";
+import { mod } from "./utils";
 
 const { M4x4: BareM4x4, V2: BareV2, V3: BareV3 } = mjs(Array);
 
@@ -359,6 +360,10 @@ const V3 = {
   },
 
   multiply: scale3,
+
+  mod(a: Vector3, m: number): Vector3 {
+    return [mod(a[0], m), mod(a[1], m), mod(a[2], m)];
+  },
 };
 
 const V4 = {

frontend/javascripts/libs/number_like_map_wrapper.ts

@@ -3,17 +3,11 @@ import { getAdaptToTypeFunction } from "./utils";
 
 export class NumberLikeMapWrapper<T extends number | bigint> {
   private readonly map: Map<T, T>;
-  private readonly adapt: (key: number) => T;
+  private readonly adaptKey: (key: number) => T;
 
   constructor(mapping: Mapping) {
     this.map = mapping as Map<T, T>;
-    this.adapt = getAdaptToTypeFunction(mapping) as (key: number) => T;
-  }
-
-  private convertKey(key: number): T {
-    // Adapt numeric keys (or values) to number or bigint depending
-    // on the current mapping type.
-    return this.adapt(key);
+    this.adaptKey = getAdaptToTypeFunction(mapping) as (key: number) => T;
   }
 
   get size(): number {
@@ -25,23 +19,27 @@ export class NumberLikeMapWrapper<T extends number | bigint> {
   }
 
   delete(key: number): boolean {
-    return this.map.delete(this.convertKey(key));
+    return this.map.delete(this.adaptKey(key));
   }
 
   get(key: number): T | undefined {
-    return this.map.get(this.convertKey(key));
+    return this.map.get(this.adaptKey(key));
   }
 
-  getAsNumber(key: number): number {
-    return Number(this.get(key));
+  getAsNumber(key: number): number | undefined {
+    const val = this.get(key);
+    if (val === undefined) {
+      return val;
+    }
+    return Number(val);
   }
 
   has(key: number): boolean {
-    return this.map.has(this.convertKey(key));
+    return this.map.has(this.adaptKey(key));
   }
 
   set(key: number, value: T): this {
-    this.map.set(this.convertKey(key), value);
+    this.map.set(this.adaptKey(key), value);
     return this;
   }
 }

frontend/javascripts/libs/utils.ts

@@ -593,6 +593,56 @@ export function diffArrays<T>(
   };
 }
 
+/*
+ * Diffs two number based arrays. The input is not manipulated.
+ * Returns three arrays in the from of { both, onlyA, onlyB }.
+ * both contains the numbers present in both arrays;
+ * onlyA the numbers present only in array a;
+ * onlyB the numbers present only in array b.
+ */
+export function diffNumberArrays(
+  a: number[],
+  b: number[],
+): { both: number[]; onlyA: number[]; onlyB: number[] } {
+  // Create sorted copies to avoid mutating inputs
+  const A = [...a].sort((x, y) => x - y);
+  const B = [...b].sort((x, y) => x - y);
+
+  const both: number[] = [];
+  const onlyA: number[] = [];
+  const onlyB: number[] = [];
+
+  let indexA = 0;
+  let indexB = 0;
+
+  while (indexA < A.length && indexB < B.length) {
+    if (A[indexA] === B[indexB]) {
+      both.push(A[indexA]);
+      indexA++;
+      indexB++;
+    } else if (A[indexA] < B[indexB]) {
+      onlyA.push(A[indexA]);
+      indexA++;
+    } else {
+      onlyB.push(B[indexB]);
+      indexB++;
+    }
+  }
+
+  // Remaining elements
+  while (indexA < A.length) {
+    onlyA.push(A[indexA]);
+    indexA++;
+  }
+
+  while (indexB < B.length) {
+    onlyB.push(B[indexB]);
+    indexB++;
+  }
+
+  return { both, onlyA, onlyB };
+}
+
 export function diffMaps<K, V>(
   stateA: Map<K, V>,
   stateB: Map<K, V>,

frontend/javascripts/test/backend_snapshot_tests/annotations.e2e.ts

@@ -256,7 +256,9 @@ describe("Annotation API (E2E)", () => {
         ],
       },
     ];
-    const createTreesUpdateActions = Array.from(diffTrees(tracingId, new DiffableMap(), trees));
+    const createTreesUpdateActions = Array.from(
+      diffTrees(tracingId, new DiffableMap(), trees, false),
+    );
     const updateTreeGroupsUpdateAction = updateTreeGroups(treeGroups, tracingId);
     const [saveQueue] = addVersionNumbers(
       createSaveQueueFromUpdateActions(
@@ -280,7 +282,9 @@ describe("Annotation API (E2E)", () => {
     const createdExplorational = await createExplorational(datasetId, "skeleton", false, null);
     const { tracingId } = createdExplorational.annotationLayers[0];
     let trees = createTreeMapFromTreeArray(generateDummyTrees(5, 6));
-    const createTreesUpdateActions = Array.from(diffTrees(tracingId, new DiffableMap(), trees));
+    const createTreesUpdateActions = Array.from(
+      diffTrees(tracingId, new DiffableMap(), trees, false),
+    );
     const metadata = [
       {
         key: "city",

frontend/javascripts/test/fixtures/dataset_server_object.ts

@@ -23,6 +23,7 @@ const sampleColorLayer: APIColorLayer = {
 };
 
 export const sampleHdf5AgglomerateName = "sampleHdf5Mapping";
+export const sampleMappingFileName = "sampleMappingFile";
 // this is a uint32 segmentation layer
 const sampleSegmentationLayer: APISegmentationLayer = {
   name: "segmentation",