Merge pull request #896 from annie-xd-wang/update-multiposition-table

Update multiposition table

Author: AdvancedImagingUTSW

src/navigate/config/config.py

@@ -673,22 +673,17 @@ def verify_experiment_config(manager, configuration):
     position_ids = []
     multipositions = configuration["experiment"]["MultiPositions"]
     for i, position in enumerate(multipositions):
-        for axis in ["x", "y", "z", "theta", "f"]:
             try:
-                position[axis] = float(position[axis])
-            except ValueError:
+                for j in range(5):
+                    float(position[j])
+            except (ValueError, KeyError):
                 position_ids.append(i)
-                break
+                
     for idx in position_ids[::-1]:
         del multipositions[idx]
     if len(multipositions) < 1:
-        multipositions.append(None)
-        update_config_dict(
-            manager,
-            multipositions,
-            0,
-            {"x": 10.0, "y": 10.0, "z": 10.0, "f": 10.0, "theta": 10.0},
-        )
+        multipositions.append([10.0, 10.0, 10.0, 10.0, 10.0])
+
     microscope_setting_dict["multiposition_count"] = len(multipositions)
 
 

src/navigate/config/experiment.yml

@@ -70,4 +70,4 @@ MicroscopeState:
   conpro_cycling_mode: Per Stack
   waveform_template: Default
 MultiPositions:
-  [{'x': 15000.0, 'y': 12000.0, 'z': 15500.0, 'theta': 0.0, 'f': 70000.0}, {'x': 35000.0, 'y': 42000.0, 'z': 15500.0, 'theta': 0.0, 'f': 70000.0}]
+  [[15000.0,12000.0,15500.0,0.0,70000.0], [35000.0,42000.0,15500.0,0.0,70000.0]]

src/navigate/controller/controller.py

@@ -456,12 +456,7 @@ def update_experiment_setting(self):
 
         # update multi-positions
         positions = self.multiposition_tab_controller.get_positions()
-        update_config_dict(
-            self.manager,
-            self.configuration["experiment"],
-            "MultiPositions",
-            positions,
-        )
+        self.configuration["experiment"]["MultiPositions"] = positions
         self.configuration["experiment"]["MicroscopeState"][
             "multiposition_count"
         ] = len(positions)

src/navigate/controller/sub_controllers/multi_position_controller.py

@@ -96,22 +96,22 @@ def set_positions(self, positions):
 
         Parameters
         ----------
-        positions : dict
+        positions : [[]]
             positions to be set
 
         Example
         -------
-        >>>    positions = {
-        >>>    0: {'x': 0, 'y': 0, 'z': 0, 'theta': 0, 'f': 0},
-        >>>    1: {'x': 1, 'y': 1, 'z': 1, 'theta': 1, 'f': 1},
-        >>>    2: {'x': 2, 'y': 2, 'z': 2, 'theta': 2, 'f': 2}}
+        >>>    positions = [
+        >>>    [0, 0, 0, 0, 0],
+        >>>    [1, 1, 1, 1, 1],
+        >>>    [2, 2, 2, 2, 2]]
         >>>    set_positions(positions)
         """
         axis_dict = {"x": "X", "y": "Y", "z": "Z", "theta": "R", "f": "F"}
         data = {}
 
-        for name in axis_dict:
-            data[axis_dict[name]] = list(pos[name] for pos in positions)
+        for i, name in enumerate(axis_dict.keys()):
+            data[axis_dict[name]] = list(pos[i] for pos in positions)
         self.table.model.df = pd.DataFrame(data)
         self.table.redraw()
         self.show_verbose_info("loaded new positions")
@@ -121,14 +121,13 @@ def get_positions(self):
 
         Returns
         -------
-        dict
-            positions in the format of {index: {axis: value}}
+        list
+            positions in the format of [[x, y, z, theta, f], ]
 
         Example
         -------
         >>> get_positions()
         """
-        axis_dict = {"X": "x", "Y": "y", "Z": "z", "R": "theta", "F": "f"}
         positions = []
         rows = self.table.model.df.shape[0]
         for i in range(rows):
@@ -139,10 +138,7 @@ def get_positions(self):
                 )
                 == 5
             ):
-                temp = dict(self.table.model.df.iloc[i])
-                positions.append({})
-                for k in axis_dict:
-                    positions[i][axis_dict[k]] = temp[k]
+                positions.append(temp)
         return positions
 
     def handle_double_click(self, event):

src/navigate/model/features/common_features.py

@@ -595,7 +595,7 @@ def signal_func(self):
         )
         if self.current_idx >= self.position_count:
             return False
-        pos_dict = self.multiposition_table[self.current_idx]
+        pos_dict = dict(zip(["x", "y", "z", "theta", "f"], self.multiposition_table[self.current_idx]))
         # pause data thread if necessary
         if self.current_idx == 0:
             temp = self.model.get_stage_position()
@@ -606,7 +606,7 @@ def signal_func(self):
                 )
             )
         else:
-            pre_stage_pos = self.multiposition_table[self.current_idx - 1]
+            pre_stage_pos = dict(zip(["x", "y", "z", "theta", "f"], self.multiposition_table[self.current_idx - 1]))
         delta_x = abs(pos_dict["x"] - pre_stage_pos["x"])
         delta_y = abs(pos_dict["y"] - pre_stage_pos["y"])
         delta_z = abs(pos_dict["z"] - pre_stage_pos["z"])
@@ -872,31 +872,32 @@ def pre_signal_func(self):
         #: float: The f position of the channel being acquired in the z-stack
         self.restore_f = pos_dict["f_pos"]
 
+        # position: x, y, z, theta, f
         if bool(microscope_state["is_multiposition"]):
             self.positions = self.model.configuration["experiment"]["MultiPositions"]
         else:
             self.positions = [
-                {
-                    "x": float(pos_dict["x_pos"]),
-                    "y": float(pos_dict["y_pos"]),
-                    "z": float(
+                [
+                    float(pos_dict["x_pos"]),
+                    float(pos_dict["y_pos"]),
+                    float(
                         microscope_state.get(
                             "stack_z_origin",
                             pos_dict["z_pos"],
                         )
                         if not self.get_origin
                         else pos_dict["z_pos"]
                     ),
-                    "theta": float(pos_dict["theta_pos"]),
-                    "f": float(
+                    float(pos_dict["theta_pos"]),
+                    float(
                         microscope_state.get(
                             "stack_focus_origin",
                             pos_dict["f_pos"],
                         )
                         if not self.get_origin
                         else pos_dict["f_pos"]
                     ),
-                }
+                ]
             ]
 
         # Setup next channel down here, to ensure defocus isn't merged into
@@ -910,6 +911,7 @@ def pre_signal_func(self):
             f"{self.start_z_position}"
         )
         self.current_position_idx = 0
+        self.current_position = dict(zip(["x", "y", "z", "theta", "f"], self.positions[0]))
         self.z_position_moved_time = 0
         self.need_to_move_new_position = True
         self.need_to_move_z_position = True
@@ -941,16 +943,20 @@ def signal_func(self):
         if self.model.stop_acquisition:
             return False
         data_thread_is_paused = False
+        
         # move stage X, Y, Theta
         if self.need_to_move_new_position:
             self.need_to_move_new_position = False
 
+            self.pre_position = self.current_position
+            self.current_position = dict(zip(["x", "y", "z", "theta", "f"], self.positions[self.current_position_idx]))
+
             # calculate first z, f position
             self.current_z_position = (
-                self.start_z_position + self.positions[self.current_position_idx]["z"]
+                self.start_z_position + self.current_position["z"]
             )
             self.current_focus_position = (
-                self.start_focus + self.positions[self.current_position_idx]["f"]
+                self.start_focus + self.current_position["f"]
             )
             if self.defocus is not None:
                 self.current_focus_position += self.defocus[
@@ -963,29 +969,29 @@ def signal_func(self):
                 map(
                     lambda ax: (
                         f"{ax}_abs",
-                        self.positions[self.current_position_idx][ax],
+                        self.current_position[ax],
                     ),
                     ["x", "y", "theta"],
                 )
             )
 
             if self.current_position_idx > 0:
                 delta_x = (
-                    self.positions[self.current_position_idx]["x"]
-                    - self.positions[self.current_position_idx - 1]["x"]
+                    self.current_position["x"]
+                    - self.pre_position["x"]
                 )
                 delta_y = (
-                    self.positions[self.current_position_idx]["y"]
-                    - self.positions[self.current_position_idx - 1]["y"]
+                    self.current_position["y"]
+                    - self.pre_position["y"]
                 )
                 delta_z = (
-                    self.positions[self.current_position_idx]["z"]
-                    - self.positions[self.current_position_idx - 1]["z"]
+                    self.current_position["z"]
+                    - self.pre_position["z"]
                     + self.z_stack_distance
                 )
                 delta_f = (
-                    self.positions[self.current_position_idx]["f"]
-                    - self.positions[self.current_position_idx - 1]["f"]
+                    self.current_position["f"]
+                    - self.pre_position["f"]
                     + self.f_stack_distance
                 )
             else:
@@ -1076,10 +1082,10 @@ def signal_end(self):
             self.z_position_moved_time = 0
             # calculate first z, f position
             self.current_z_position = (
-                self.start_z_position + self.positions[self.current_position_idx]["z"]
+                self.start_z_position + self.current_position["z"]
             )
             self.current_focus_position = (
-                self.start_focus + self.positions[self.current_position_idx]["f"]
+                self.start_focus + self.current_position["f"]
             )
             if (
                 self.z_stack_distance > self.stage_distance_threshold

test/config/test_config.py

@@ -362,7 +362,7 @@ def setUp(self):
         }
 
         multipositions_sample = [
-            {"x": 10.0, "y": 10.0, "z": 10.0, "f": 10.0, "theta": 10.0}
+            [10.0, 10.0, 10.0, 10.0, 10.0]
         ]
 
         self.experiment_sample = {
@@ -425,7 +425,7 @@ def test_load_empty_experiment_file(self):
 
         # MultiPositions
         for i, position in enumerate(self.experiment_sample["MultiPositions"]):
-            self.assert_equal_dict(position, experiement_config["MultiPositions"][i])
+            assert position == experiement_config["MultiPositions"][i]
 
     def test_load_experiment_file_with_missing_parameters(self):
         experiment = load_yaml_file(os.path.join(self.config_path, "experiment.yml"))

test/config/test_experiment.py

@@ -207,17 +207,11 @@ def test_microscope_state(self):
                 ), f"{key_key} is not of type {expected_values[key_key]}"
 
     def test_multiposition(self):
-        expected_values = {
-            "x": float,
-            "y": float,
-            "z": float,
-            "theta": float,
-            "f": float,
-        }
+        expected_values = [float, float, float, float, float]
         positions = self.data["MultiPositions"]
+        print("*** positions:", positions)
         for position in positions:
-            for key in position.keys():
-                self.assertIn(key, expected_values)
+            for i in range(len(expected_values)):
                 assert isinstance(
-                    position[key], expected_values[key]
-                ), f"{key} is not of type {expected_values[key]}"
+                    position[i], expected_values[i]
+                ), f"{i} is not of type {expected_values[i]}"

test/model/features/test_common_features.py

@@ -54,9 +54,9 @@ def _prepare_test(self, dummy_model_to_test_features):
         position_list = self.model.configuration["experiment"]["MultiPositions"]
         if len(position_list) < 5:
             for i in range(5):
-                pos = {}
-                for axis in ["x", "y", "z", "theta", "f"]:
-                    pos[axis] = random.randint(1, 10000)
+                pos = [0] * 5
+                for i in range(5):
+                    pos[i] = random.randint(1, 10000)
                 position_list.append(pos)
 
     def get_next_record(self, record_prefix, idx):
@@ -97,13 +97,13 @@ def z_stack_verification(self):
         else:
             pos_dict = self.model.configuration["experiment"]["StageParameters"]
             positions = [
-                {
-                    "x": pos_dict["x"],
-                    "y": pos_dict["y"],
-                    "z": self.config.get("stack_z_origin", pos_dict["z"]),
-                    "theta": pos_dict["theta"],
-                    "f": self.config.get("stack_focus_origin", pos_dict["f"]),
-                }
+                [
+                    pos_dict["x"],
+                    pos_dict["y"],
+                    self.config.get("stack_z_origin", pos_dict["z"]),
+                    pos_dict["theta"],
+                    self.config.get("stack_focus_origin", pos_dict["f"]),
+                ]
             ]
 
         z_step = self.config["step_size"]
@@ -141,14 +141,15 @@ def z_stack_verification(self):
 
             # x, y, theta
             pos_moved = self.model.signal_records[idx][1][0]
-            for axis in ["x", "y", "theta"]:
-                assert pos[axis] == pos_moved[axis + "_abs"], (
-                    f"should move to {axis}: {pos[axis]}, "
+            for i, axis in [(0,"x"), (1,"y"), (3,"theta")]:
+                assert pos[i] == pos_moved[axis + "_abs"], (
+                    f"should move to {axis}: {pos[i]}, "
                     f"but moved to {pos_moved[axis + '_abs']}"
                 )
 
-            z_pos = pos["z"] + self.config["start_position"]
-            f_pos = pos["f"] + self.config["start_focus"]
+            # (x, y, z, theta, f)
+            z_pos = pos[2] + self.config["start_position"]
+            f_pos = pos[4] + self.config["start_focus"]
 
             if mode == "per_z":
                 f_pos += selected_channels[0]["defocus"]

test/model/test_model.py

@@ -219,7 +219,14 @@ def test_multiposition_acquisition(model):
         model.__test_manager,  # noqa
         model.configuration["experiment"],
         "MultiPositions",
-        [{"x": 10.0, "y": 10.0, "z": 10.0, "theta": 10.0, "f": 10.0}],
+        [[10.0, 10.0, 10.0, 10.0, 10.0]],
+    )
+    model.configuration["experiment"]["MicroscopeState"]["image_mode"] = "z-stack"
+    model.configuration["experiment"]["MicroscopeState"]["number_z_steps"] = 10
+
+    model.configuration["experiment"]["MicroscopeState"]["step_size"] = 5.0
+    model.configuration["experiment"]["MicroscopeState"]["end_position"] = (
+        model.configuration["experiment"]["MicroscopeState"]["start_position"] + 15.0
     )
     model.run_command("acquire")