Add loaded meshes to sharing link

frontend/javascripts/admin/user/permissions_and_teams_modal_view.js

@@ -8,6 +8,7 @@ import update from "immutability-helper";
 import type { APIUser, APITeam, APITeamMembership } from "types/api_flow_types";
 import { updateUser, getEditableTeams } from "admin/admin_rest_api";
 import messages from "messages";
+import * as Utils from "libs/utils";
 
 const RadioButton = Radio.Button;
 const RadioGroup = Radio.Group;
@@ -129,7 +130,7 @@ class PermissionsAndTeamsModalView extends React.PureComponent<TeamRoleModalProp
   setPermissionsAndTeams = () => {
     const newUserPromises = this.props.users.map(user => {
       if (this.props.selectedUserIds.includes(user.id)) {
-        const newTeams = ((Object.values(this.state.selectedTeams): any): Array<APITeamMembership>);
+        const newTeams = Utils.values(this.state.selectedTeams);
         const newUser = Object.assign({}, user, { teams: newTeams });
         if (this.props.activeUser.isAdmin && this.props.selectedUserIds.length === 1) {
           // If the current user is admin and only one user is edited we also update the permissions.

frontend/javascripts/libs/task_pool.js

@@ -1,36 +1,50 @@
 // @flow
+import { type Saga, type Task, join, call, fork } from "oxalis/model/sagas/effect-generators";
 
-export default function processTaskWithPool<T>(
-  tasks: Array<() => Promise<T>>,
+export default function* processTaskWithPool(
+  tasks: Array<() => Saga<void>>,
   poolSize: number,
-): Promise<Array<T>> {
-  return new Promise((resolve, reject) => {
-    const promises = [];
-    let isFinalResolveScheduled = false;
+): Saga<void> {
+  const startedTasks: Array<Task<void>> = [];
+  let isFinalResolveScheduled = false;
+  let error = null;
 
-    const startNextTask = () => {
-      if (tasks.length === 0) {
-        if (!isFinalResolveScheduled) {
-          isFinalResolveScheduled = true;
+  function* forkSafely(fn): Saga<void> {
+    // Errors from forked tasks cannot be caught, see https://redux-saga.js.org/docs/advanced/ForkModel/#error-propagation
+    // However, the task pool should not abort if a single task fails.
+    // Therefore, use this wrapper to safely execute all tasks and possibly rethrow the last error in the end.
+    try {
+      yield* call(fn);
+    } catch (e) {
+      error = e;
+    }
+  }
+
+  function* startNextTask(): Saga<void> {
+    if (tasks.length === 0) {
+      if (!isFinalResolveScheduled) {
+        isFinalResolveScheduled = true;
 
-          // All tasks were kicked off, which is why all promises can be
-          // awaited now together.
-          Promise.all(promises).then(resolve, reject);
-        }
-        return;
+        // All tasks were kicked off, which is why all tasks can be
+        // awaited now together.
+        yield* join(startedTasks);
+        if (error != null) throw error;
       }
+      return;
+    }
 
-      const task = tasks.shift();
-      const newPromise = task();
-      promises.push(newPromise);
+    const task = tasks.shift();
+    const newTask = yield* fork(forkSafely, task);
+    startedTasks.push(newTask);
 
-      // If that promise is done, process a new one (that way,
-      // the pool size stays constant until the queue is almost empty.)
-      newPromise.then(startNextTask, startNextTask);
-    };
+    // If that task is done, process a new one (that way,
+    // the pool size stays constant until the queue is almost empty.)
+    yield* join(newTask);
+    yield* call(startNextTask);
+  }
 
-    for (let i = 0; i < poolSize; i++) {
-      startNextTask();
-    }
-  });
+  for (let i = 0; i < poolSize; i++) {
+    yield* fork(startNextTask);
+  }
+  // The saga will wait for all forked tasks to terminate before returning.
 }

frontend/javascripts/libs/utils.js

@@ -24,6 +24,11 @@ export function mod(x: number, n: number) {
   return ((x % n) + n) % n;
 }
 
+export function values<K, V>(o: { [K]: V }): Array<V> {
+  // $FlowIssue[incompatible-return] remove once https://github.com/facebook/flow/issues/2221 is fixed
+  return Object.values(o);
+}
+
 export function map2<A, B>(fn: (A, number) => B, tuple: [A, A]): [B, B] {
   const [x, y] = tuple;
   return [fn(x, 0), fn(y, 1)];
@@ -514,8 +519,8 @@ export function filterWithSearchQueryOR<T: { +[string]: mixed }, P: $Keys<T>>(
       _.some(properties, fieldName => {
         const value = typeof fieldName === "function" ? fieldName(model) : model[fieldName];
         if (value != null && (typeof value === "string" || value instanceof Object)) {
-          const values = getRecursiveValues(value);
-          return _.some(values, v => v != null && v.toString().match(regexp));
+          const recursiveValues = getRecursiveValues(value);
+          return _.some(recursiveValues, v => v != null && v.toString().match(regexp));
         } else {
           return false;
         }
@@ -545,8 +550,8 @@ export function filterWithSearchQueryAND<T: { +[string]: mixed }, P: $Keys<T>>(
         _.some(properties, fieldName => {
           const value = typeof fieldName === "function" ? fieldName(model) : model[fieldName];
           if (value !== null && (typeof value === "string" || value instanceof Object)) {
-            const values = getRecursiveValues(value);
-            return _.some(values, v => v != null && v.toString().match(pattern));
+            const recursiveValues = getRecursiveValues(value);
+            return _.some(recursiveValues, v => v != null && v.toString().match(pattern));
           } else {
             return false;
           }

frontend/javascripts/oxalis/api/api_latest.js

@@ -37,7 +37,10 @@ import {
 } from "oxalis/model/helpers/position_converter";
 import { callDeep } from "oxalis/view/right-border-tabs/tree_hierarchy_view_helpers";
 import { centerTDViewAction } from "oxalis/model/actions/view_mode_actions";
-import { changeActiveIsosurfaceCellAction } from "oxalis/model/actions/segmentation_actions";
+import {
+  loadAdHocMeshAction,
+  loadPrecomputedMeshAction,
+} from "oxalis/model/actions/segmentation_actions";
 import { discardSaveQueuesAction } from "oxalis/model/actions/save_actions";
 import {
   doWithToken,
@@ -79,10 +82,7 @@ import {
   getRotation,
   getRequestLogZoomStep,
 } from "oxalis/model/accessors/flycam_accessor";
-import {
-  loadMeshFromFile,
-  maybeFetchMeshFiles,
-} from "oxalis/view/right-border-tabs/segments_tab/segments_view_helper";
+import { maybeFetchMeshFiles } from "oxalis/view/right-border-tabs/segments_tab/segments_view_helper";
 import { overwriteAction } from "oxalis/model/helpers/overwrite_action_middleware";
 import { parseNml } from "oxalis/model/helpers/nml_helpers";
 import { rotate3DViewTo } from "oxalis/controller/camera_controller";
@@ -140,6 +140,7 @@ import * as Utils from "libs/utils";
 import dimensions from "oxalis/model/dimensions";
 import messages from "messages";
 import window, { location } from "libs/window";
+import DataLayer from "oxalis/model/data_layer";
 
 type OutdatedDatasetConfigurationKeys = "segmentationOpacity" | "isSegmentationDisabled";
 
@@ -1009,9 +1010,7 @@ class DataApi {
    */
   async reloadBuckets(layerName: string): Promise<void> {
     await Promise.all(
-      Object.keys(this.model.dataLayers).map(async currentLayerName => {
-        const dataLayer = this.model.dataLayers[currentLayerName];
-
+      Utils.values(this.model.dataLayers).map(async (dataLayer: DataLayer) => {
         if (dataLayer.name === layerName) {
           if (dataLayer.cube.isSegmentation) {
             await Model.ensureSavedState();
@@ -1030,7 +1029,7 @@ class DataApi {
     if (hasVolumeTracings(Store.getState().tracing)) {
       await Model.ensureSavedState();
     }
-    _.forEach(this.model.dataLayers, dataLayer => {
+    Utils.values(this.model.dataLayers).forEach((dataLayer: DataLayer) => {
       dataLayer.cube.collectAllBuckets();
       dataLayer.layerRenderingManager.refresh();
     });
@@ -1654,7 +1653,9 @@ class DataApi {
       }
     }
 
-    await loadMeshFromFile(segmentId, seedPosition, meshFileName, segmentationLayer, dataset);
+    Store.dispatch(
+      loadPrecomputedMeshAction(segmentId, seedPosition, meshFileName, effectiveLayerName),
+    );
   }
 
   /**
@@ -1666,7 +1667,7 @@ class DataApi {
    * api.data.computeMeshOnDemand(segmentId, currentPosition);
    */
   computeMeshOnDemand(segmentId: number, seedPosition: Vector3) {
-    Store.dispatch(changeActiveIsosurfaceCellAction(segmentId, seedPosition, true));
+    Store.dispatch(loadAdHocMeshAction(segmentId, seedPosition));
   }
 
   /**

frontend/javascripts/oxalis/controller/url_manager.js

@@ -22,12 +22,22 @@ import { validateUrlStateJSON } from "types/validation";
 
 const MAX_UPDATE_INTERVAL = 1000;
 
+type MeshUrlDescriptor = {|
+  +segmentId: number,
+  +seedPosition: Vector3,
+  +isPrecomputed: boolean,
+|};
+
 export type UrlStateByLayer = {
   [layerName: string]: {
+    meshInfo?: {
+      meshFileName: string,
+      meshes?: Array<MeshUrlDescriptor>,
+    },
     mappingInfo?: {
       mappingName: string,
       mappingType: MappingType,
-      agglomerateIdsToImport?: [number],
+      agglomerateIdsToImport?: Array<number>,
     },
   },
 };
@@ -173,14 +183,31 @@ class UrlManager {
       .map(node => ({ activeNode: node.id }))
       .getOrElse({});
 
-    const stateByLayer = {};
+    const stateByLayer: UrlStateByLayer = {};
     for (const layerName of Object.keys(state.temporaryConfiguration.activeMappingByLayer)) {
       const mappingInfo = state.temporaryConfiguration.activeMappingByLayer[layerName];
-      if (mappingInfo.mappingStatus === MappingStatusEnum.ENABLED) {
+      if (
+        mappingInfo.mappingStatus === MappingStatusEnum.ENABLED &&
+        mappingInfo.mappingName != null
+      ) {
         const { mappingName, mappingType } = mappingInfo;
         stateByLayer[layerName] = { mappingInfo: { mappingName, mappingType } };
       }
     }
+    for (const layerName of Object.keys(state.localSegmentationData)) {
+      const { isosurfaces, currentMeshFile } = state.localSegmentationData[layerName];
+      if (currentMeshFile != null) {
+        const { meshFileName } = currentMeshFile;
+        const meshes = Utils.values(isosurfaces)
+          .filter(({ isVisible }) => isVisible)
+          .map(({ segmentId, seedPosition, isPrecomputed }) => ({
+            segmentId,
+            seedPosition: V3.floor(seedPosition),
+            isPrecomputed,
+          }));
+        stateByLayer[layerName] = { meshInfo: { meshFileName, meshes } };
+      }
+    }
     const stateByLayerOptional = _.size(stateByLayer) > 0 ? { stateByLayer } : {};
 
     // $FlowIssue[incompatible-exact] See https://github.com/facebook/flow/issues/2977

frontend/javascripts/oxalis/merger_mode.js

@@ -13,9 +13,9 @@ import api from "oxalis/api/internal_api";
 import messages from "messages";
 
 type MergerModeState = {
-  treeColors: Object,
-  colorMapping: Object,
-  nodesPerSegment: Object,
+  treeColors: { [number]: ?number },
+  colorMapping: { [number]: number },
+  nodesPerSegment: { [number]: number },
   nodes: Array<NodeWithTreeId>,
   // A properly initialized merger mode should always
   // have a segmentationLayerName. However, some edge cases
@@ -41,7 +41,7 @@ function getTreeColor(treeId: number, mergerModeState: MergerModeState) {
   const { treeColors } = mergerModeState;
   let color = treeColors[treeId];
   // Generate a new color if tree was never seen before
-  if (color === undefined) {
+  if (color == null) {
     color = Math.ceil(127 * Math.random());
     treeColors[treeId] = color;
   }
@@ -252,8 +252,8 @@ function shuffleColorOfCurrentTree(mergerModeState: MergerModeState) {
     treeColors[activeTreeId] = undefined;
     // Applies the change of the color to all connected segments
     Object.keys(colorMapping).forEach(key => {
-      if (colorMapping[key] === oldColor) {
-        colorMapping[key] = getTreeColor(activeTreeId, mergerModeState);
+      if (colorMapping[+key] === oldColor) {
+        colorMapping[+key] = getTreeColor(activeTreeId, mergerModeState);
       }
     });
     // Update the segmentation

frontend/javascripts/oxalis/model.js

@@ -88,8 +88,7 @@ export class OxalisModel {
   }
 
   getAllLayers(): Array<DataLayer> {
-    // $FlowIssue[incompatible-return] remove once https://github.com/facebook/flow/issues/2221 is fixed
-    return Object.values(this.dataLayers);
+    return Utils.values(this.dataLayers);
   }
 
   getColorLayers(): Array<DataLayer> {
@@ -100,22 +99,18 @@ export class OxalisModel {
   }
 
   getSegmentationLayers(): Array<DataLayer> {
-    return Object.keys(this.dataLayers)
-      .map(k => this.dataLayers[k])
-      .filter(
-        dataLayer =>
-          getLayerByName(Store.getState().dataset, dataLayer.name).category === "segmentation",
-      );
+    return Utils.values(this.dataLayers).filter(
+      dataLayer =>
+        getLayerByName(Store.getState().dataset, dataLayer.name).category === "segmentation",
+    );
   }
 
   getSegmentationTracingLayers(): Array<DataLayer> {
-    return Object.keys(this.dataLayers)
-      .map(k => this.dataLayers[k])
-      .filter(dataLayer => {
-        const layer = getLayerByName(Store.getState().dataset, dataLayer.name);
+    return Utils.values(this.dataLayers).filter(dataLayer => {
+      const layer = getLayerByName(Store.getState().dataset, dataLayer.name);
 
-        return layer.category === "segmentation" && layer.tracingId != null;
-      });
+      return layer.category === "segmentation" && layer.tracingId != null;
+    });
   }
 
   getSomeSegmentationLayer(): ?DataLayer {

frontend/javascripts/oxalis/model/actions/actions.js

@@ -2,7 +2,7 @@
 import type { AnnotationActionTypes } from "oxalis/model/actions/annotation_actions";
 import type { DatasetAction } from "oxalis/model/actions/dataset_actions";
 import type { FlycamAction } from "oxalis/model/actions/flycam_actions";
-import type { IsosurfaceAction } from "oxalis/model/actions/segmentation_actions";
+import type { SegmentationAction } from "oxalis/model/actions/segmentation_actions";
 import type { SaveAction } from "oxalis/model/actions/save_actions";
 import type { SettingAction } from "oxalis/model/actions/settings_actions";
 import type { SkeletonTracingAction } from "oxalis/model/actions/skeletontracing_actions";
@@ -24,7 +24,7 @@ export type Action =
   | FlycamAction
   | UserAction
   | UiAction
-  | IsosurfaceAction;
+  | SegmentationAction;
 
 export const wkReadyAction = () => ({
   type: "WK_READY",

frontend/javascripts/oxalis/model/actions/annotation_actions.js

@@ -124,9 +124,6 @@ export type RefreshIsosurfacesAction = {
   type: "REFRESH_ISOSURFACES",
 };
 
-export type FinishedRefreshingIsosurfacesAction = {
-  type: "FINISHED_REFRESHING_ISOSURFACES",
-};
 export type RefreshIsosurfaceAction = {
   type: "REFRESH_ISOSURFACE",
   layerName: string,
@@ -195,7 +192,6 @@ export type AnnotationActionTypes =
   | UpdateIsosurfaceVisibilityAction
   | TriggerIsosurfaceDownloadAction
   | RefreshIsosurfacesAction
-  | FinishedRefreshingIsosurfacesAction
   | RefreshIsosurfaceAction
   | StartedLoadingIsosurfaceAction
   | FinishedLoadingIsosurfaceAction
@@ -367,10 +363,6 @@ export const refreshIsosurfacesAction = (): RefreshIsosurfacesAction => ({
   type: "REFRESH_ISOSURFACES",
 });
 
-export const finishedRefreshingIsosurfacesAction = (): FinishedRefreshingIsosurfacesAction => ({
-  type: "FINISHED_REFRESHING_ISOSURFACES",
-});
-
 export const refreshIsosurfaceAction = (
   layerName: string,
   cellId: number,

frontend/javascripts/oxalis/model/actions/flycam_actions.js

@@ -9,7 +9,6 @@ type SetPositionAction = {
   type: "SET_POSITION",
   position: Vector3,
   dimensionToSkip: ?number,
-  shouldRefreshIsosurface: boolean,
 };
 type SetRotationAction = { type: "SET_ROTATION", rotation: Vector3 };
 type SetDirectionAction = { type: "SET_DIRECTION", direction: Vector3 };
@@ -81,12 +80,10 @@ export const setZoomStepAction = (zoomStep: number): SetZoomStepAction => ({
 export const setPositionAction = (
   position: Vector3,
   dimensionToSkip: ?number,
-  shouldRefreshIsosurface: boolean = true,
 ): SetPositionAction => ({
   type: "SET_POSITION",
   position,
   dimensionToSkip,
-  shouldRefreshIsosurface,
 });
 export const setRotationAction = (rotation: Vector3): SetRotationAction => ({
   type: "SET_ROTATION",