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/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 => {
+    _.forEach(this.model.dataLayers, (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

@@ -6,7 +6,11 @@ import { V3 } from "libs/mjs";
 import { applyState } from "oxalis/model_initialization";
 import { getRotation, getPosition } from "oxalis/model/accessors/flycam_accessor";
 import { getSkeletonTracing, getActiveNode } from "oxalis/model/accessors/skeletontracing_accessor";
-import Store, { type OxalisState, type MappingType } from "oxalis/store";
+import Store, {
+  type OxalisState,
+  type MappingType,
+  type IsosurfaceInformation,
+} from "oxalis/store";
 import * as Utils from "libs/utils";
 import constants, {
   type ViewMode,
@@ -22,12 +26,22 @@ import { validateUrlStateJSON } from "types/validation";
 
 const MAX_UPDATE_INTERVAL = 1000;
 
+type Mesh = {|
+  +segmentId: number,
+  +seedPosition: Vector3,
+  +isPrecomputed: boolean,
+|};
+
 export type UrlStateByLayer = {
   [layerName: string]: {
+    meshInfo?: {
+      meshFileName: string,
+      meshes?: Array<Mesh>,
+    },
     mappingInfo?: {
       mappingName: string,
       mappingType: MappingType,
-      agglomerateIdsToImport?: [number],
+      agglomerateIdsToImport?: Array<number>,
     },
   },
 };
@@ -181,6 +195,20 @@ class UrlManager {
         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 }: IsosurfaceInformation) => isVisible)
+          .map(({ segmentId, seedPosition, isPrecomputed }: IsosurfaceInformation) => ({
+            segmentId,
+            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",

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

@@ -2,22 +2,42 @@
 
 import type { Vector3 } from "oxalis/constants";
 
-export type ChangeActiveIsosurfaceCellAction = {
-  type: "CHANGE_ACTIVE_ISOSURFACE_CELL",
+export type LoadAdHocMeshAction = {
+  type: "LOAD_AD_HOC_MESH_ACTION",
   cellId: number,
   seedPosition: Vector3,
-  shouldReload: boolean,
+  layerName?: string,
+};
+export type LoadPrecomputedMeshAction = {
+  type: "LOAD_PRECOMPUTED_MESH_ACTION",
+  cellId: number,
+  seedPosition: Vector3,
+  meshFileName: string,
+  layerName?: string,
 };
 
-export type IsosurfaceAction = ChangeActiveIsosurfaceCellAction;
+export type SegmentationAction = LoadAdHocMeshAction | LoadPrecomputedMeshAction;
+
+export const loadAdHocMeshAction = (
+  cellId: number,
+  seedPosition: Vector3,
+  layerName?: string,
+): LoadAdHocMeshAction => ({
+  type: "LOAD_AD_HOC_MESH_ACTION",
+  cellId,
+  seedPosition,
+  layerName,
+});
 
-export const changeActiveIsosurfaceCellAction = (
+export const loadPrecomputedMeshAction = (
   cellId: number,
   seedPosition: Vector3,
-  shouldReload: boolean,
-): ChangeActiveIsosurfaceCellAction => ({
-  type: "CHANGE_ACTIVE_ISOSURFACE_CELL",
+  meshFileName: string,
+  layerName?: string,
+): LoadPrecomputedMeshAction => ({
+  type: "LOAD_PRECOMPUTED_MESH_ACTION",
   cellId,
   seedPosition,
-  shouldReload,
+  meshFileName,
+  layerName,
 });