Live Collab M2 - Automatically update annotation to newest changes

frontend/javascripts/admin/rest_api.ts

@@ -767,8 +767,9 @@ export function getUpdateActionLog(
   annotationId: string,
   oldestVersion?: number,
   newestVersion?: number,
+  sortAscending: boolean = false,
 ): Promise<Array<APIUpdateActionBatch>> {
-  return doWithToken((token) => {
+  return doWithToken(async (token) => {
     const params = new URLSearchParams();
     params.set("token", token);
     if (oldestVersion != null) {
@@ -777,9 +778,14 @@ export function getUpdateActionLog(
     if (newestVersion != null) {
       params.set("newestVersion", newestVersion.toString());
     }
-    return Request.receiveJSON(
+    const log: APIUpdateActionBatch[] = await Request.receiveJSON(
       `${tracingStoreUrl}/tracings/annotation/${annotationId}/updateActionLog?${params}`,
     );
+
+    if (sortAscending) {
+      log.reverse();
+    }
+    return log;
   });
 }
 
@@ -1969,6 +1975,9 @@ export async function getAgglomeratesForSegmentsFromDatastore<T extends number |
   mappingId: string,
   segmentIds: Array<T>,
 ): Promise<Mapping> {
+  if (segmentIds.length === 0) {
+    return new Map();
+  }
   const segmentIdBuffer = serializeProtoListOfLong<T>(segmentIds);
   const listArrayBuffer: ArrayBuffer = await doWithToken((token) => {
     const params = new URLSearchParams({ token });
@@ -1999,6 +2008,9 @@ export async function getAgglomeratesForSegmentsFromTracingstore<T extends numbe
   annotationId: string,
   version?: number | null | undefined,
 ): Promise<Mapping> {
+  if (segmentIds.length === 0) {
+    return new Map();
+  }
   const params = new URLSearchParams({ annotationId });
   if (version != null) {
     params.set("version", version.toString());
@@ -2181,7 +2193,7 @@ export function getSynapseTypes(
   );
 }
 
-type MinCutTargetEdge = {
+export type MinCutTargetEdge = {
   position1: Vector3;
   position2: Vector3;
   segmentId1: number;

frontend/javascripts/libs/utils.ts

@@ -1,18 +1,12 @@
+import { Chalk } from "chalk";
 import dayjs from "dayjs";
 import naturalSort from "javascript-natural-sort";
 import window, { document, location } from "libs/window";
 import _ from "lodash";
 import type { APIDataset, APIUser, MapEntries } from "types/api_types";
+import type { BoundingBoxMinMaxType } from "types/bounding_box";
 import type { ArbitraryObject, Comparator } from "types/globals";
-import type {
-  BoundingBoxType,
-  ColorObject,
-  Point3,
-  TypedArray,
-  Vector3,
-  Vector4,
-  Vector6,
-} from "viewer/constants";
+import type { ColorObject, Point3, TypedArray, Vector3, Vector4, Vector6 } from "viewer/constants";
 import type { TreeGroup } from "viewer/model/types/tree_types";
 import type { BoundingBoxObject, NumberLike, SegmentGroup } from "viewer/store";
 
@@ -276,19 +270,23 @@ export function getRandomColor(): Vector3 {
   return randomColor as any as Vector3;
 }
 
-export function computeBoundingBoxFromArray(bb: Vector6): BoundingBoxType {
+export function computeBoundingBoxFromArray(bb: Vector6): BoundingBoxMinMaxType {
   const [x, y, z, width, height, depth] = bb;
   return {
     min: [x, y, z],
     max: [x + width, y + height, z + depth],
   };
 }
 
-export function computeBoundingBoxFromBoundingBoxObject(bb: BoundingBoxObject): BoundingBoxType {
+export function computeBoundingBoxFromBoundingBoxObject(
+  bb: BoundingBoxObject,
+): BoundingBoxMinMaxType {
   return computeBoundingBoxFromArray([...bb.topLeft, bb.width, bb.height, bb.depth]);
 }
 
-export function computeBoundingBoxObjectFromBoundingBox(bb: BoundingBoxType): BoundingBoxObject {
+export function computeBoundingBoxObjectFromBoundingBox(
+  bb: BoundingBoxMinMaxType,
+): BoundingBoxObject {
   const boundingBoxArray = computeArrayFromBoundingBox(bb);
   return {
     topLeft: [boundingBoxArray[0], boundingBoxArray[1], boundingBoxArray[2]],
@@ -298,7 +296,7 @@ export function computeBoundingBoxObjectFromBoundingBox(bb: BoundingBoxType): Bo
   };
 }
 
-export function computeArrayFromBoundingBox(bb: BoundingBoxType): Vector6 {
+export function computeArrayFromBoundingBox(bb: BoundingBoxMinMaxType): Vector6 {
   return [
     bb.min[0],
     bb.min[1],
@@ -309,11 +307,13 @@ export function computeArrayFromBoundingBox(bb: BoundingBoxType): Vector6 {
   ];
 }
 
-export function computeShapeFromBoundingBox(bb: BoundingBoxType): Vector3 {
+export function computeShapeFromBoundingBox(bb: BoundingBoxMinMaxType): Vector3 {
   return [bb.max[0] - bb.min[0], bb.max[1] - bb.min[1], bb.max[2] - bb.min[2]];
 }
 
-export function aggregateBoundingBox(boundingBoxes: Array<BoundingBoxObject>): BoundingBoxType {
+export function aggregateBoundingBox(
+  boundingBoxes: Array<BoundingBoxObject>,
+): BoundingBoxMinMaxType {
   if (boundingBoxes.length === 0) {
     return {
       min: [0, 0, 0],
@@ -344,8 +344,8 @@ export function aggregateBoundingBox(boundingBoxes: Array<BoundingBoxObject>): B
 }
 
 export function areBoundingBoxesOverlappingOrTouching(
-  firstBB: BoundingBoxType,
-  secondBB: BoundingBoxType,
+  firstBB: BoundingBoxMinMaxType,
+  secondBB: BoundingBoxMinMaxType,
 ) {
   let areOverlapping = true;
 
@@ -425,10 +425,6 @@ export function stringToNumberArray(s: string): Array<number> {
   return result;
 }
 
-export function concatVector3(a: Vector3, b: Vector3): Vector6 {
-  return [a[0], a[1], a[2], b[0], b[1], b[2]];
-}
-
 export function numberArrayToVector3(array: Array<number>): Vector3 {
   const output: Vector3 = [0, 0, 0];
 
@@ -1262,7 +1258,11 @@ export function notEmpty<TValue>(value: TValue | null | undefined): value is TVa
 
 export function isNumberMap(x: Map<NumberLike, NumberLike>): x is Map<number, number> {
   const { value } = x.entries().next();
-  return Boolean(value && typeof value[0] === "number");
+  if (value === undefined) {
+    // Let's assume a number map when the map is empty.
+    return true;
+  }
+  return Boolean(typeof value[0] === "number");
 }
 
 export function isBigInt(x: NumberLike): x is bigint {
@@ -1368,3 +1368,26 @@ export function areSetsEqual<T>(setA: Set<T>, setB: Set<T>) {
   }
   return true;
 }
+
+// ColoredLogger can be used to make certain log outputs easier to find (especially useful
+// when automatic logging of redux actions is enabled which makes the overall logging
+// very verbose).
+const chalk = new Chalk({ level: 3 });
+export const ColoredLogger = {
+  log: (...args: unknown[]) => {
+    // Simple wrapper to allow easy switching from colored to non-colored logs
+    console.log(...args);
+  },
+  logRed: (str: string, ...args: unknown[]) => {
+    console.log(chalk.bgRed(str), ...args);
+  },
+  logGreen: (str: string, ...args: unknown[]) => {
+    console.log(chalk.bgGreen(str), ...args);
+  },
+  logYellow: (str: string, ...args: unknown[]) => {
+    console.log(chalk.bgYellow(str), ...args);
+  },
+  logBlue: (str: string, ...args: unknown[]) => {
+    console.log(chalk.bgBlue(str), ...args);
+  },
+};

frontend/javascripts/libs/vector_input.tsx

@@ -2,7 +2,7 @@ import type { InputProps } from "antd";
 import * as Utils from "libs/utils";
 import _ from "lodash";
 import * as React from "react";
-import type { ServerBoundingBoxTypeTuple } from "types/api_types";
+import type { ServerBoundingBoxMinMaxTypeTuple } from "types/api_types";
 import type { Vector3, Vector6 } from "viewer/constants";
 import InputComponent from "viewer/view/components/input_component";
 
@@ -206,11 +206,11 @@ export class ArbitraryVectorInput extends BaseVector<number[]> {
 }
 
 type BoundingBoxInputProps = Omit<InputProps, "value"> & {
-  value: ServerBoundingBoxTypeTuple;
-  onChange: (arg0: ServerBoundingBoxTypeTuple) => void;
+  value: ServerBoundingBoxMinMaxTypeTuple;
+  onChange: (arg0: ServerBoundingBoxMinMaxTypeTuple) => void;
 };
 
-function boundingBoxToVector6(value: ServerBoundingBoxTypeTuple): Vector6 {
+function boundingBoxToVector6(value: ServerBoundingBoxMinMaxTypeTuple): Vector6 {
   const { topLeft, width, height, depth } = value;
   const [x, y, z] = topLeft;
   return [x, y, z, width, height, depth];