update tiling

Author: annie-xd-wang

src/navigate/controller/sub_controllers/tiling.py

@@ -133,10 +133,19 @@ def __init__(self, view, parent_controller):
         self.cam_settings_widgets["FOV_Y"].get_variable().trace_add(
             "write", lambda *args: self.update_fov("x")
         )
-        self.stack_acq_widgets["abs_z_start"].get_variable().trace_add(
+        # primary z/f
+        self.primary_z_axis = self.stack_acq_widgets["z_device"].get().split(" - ")[1]
+        self.primary_f_axis = self.stack_acq_widgets["f_device"].get().split(" - ")[1]
+        self.stack_acq_widgets["z_device"].get_variable().trace_add(
+            "write", lambda *args: self.update_fov("z_device")
+        )
+        self.stack_acq_widgets["f_device"].get_variable().trace_add(
+            "write", lambda *args: self.update_fov("f_device")
+        )
+        self.stack_acq_widgets["start_position"].get_variable().trace_add(
             "write", lambda *args: self.update_fov("z")
         )
-        self.stack_acq_widgets["abs_z_end"].get_variable().trace_add(
+        self.stack_acq_widgets["end_position"].get_variable().trace_add(
             "write", lambda *args: self.update_fov("z")
         )
         self.stack_acq_widgets["start_focus"].get_variable().trace_add(
@@ -158,12 +167,6 @@ def __init__(self, view, parent_controller):
             self.variables[f"{axis}_fov"].trace_add(
                 "write", lambda *args, axis=axis: self.calculate_tiles(axis)
             )
-            self.variables[f"{axis}_start"].trace_add(
-                "write", lambda *args, axis=axis: self.update_fov(axis)
-            )
-            self.variables[f"{axis}_end"].trace_add(
-                "write", lambda *args, axis=axis: self.update_fov(axis)
-            )
 
             # Calculating Number of Tiles traces
             self.variables[f"{axis}_dist"].trace_add(
@@ -248,45 +251,7 @@ def set_table(self):
         pandas dataframe which is then set as the new table data.
         The table is then redrawn.
         """
-        if False in self.is_validated.values():
-            messagebox.showwarning(
-                title="Navigate",
-                message="Can't calculate positions, "
-                "please make sure all FOV Dists are correct!",
-            )
-            return
-
-        x_start = float(self.variables["x_start"].get())
-        x_stop = float(self.variables["x_end"].get())
-        x_tiles = int(self.variables["x_tiles"].get())
-
-        y_start = float(self.variables["y_start"].get())
-        y_stop = float(self.variables["y_end"].get())
-        y_tiles = int(self.variables["y_tiles"].get())
 
-        # shift z by coordinate origin of local z-stack
-        z_start = float(self.variables["z_start"].get()) - float(
-            self.stack_acq_widgets["start_position"].get()
-        )
-        z_stop = float(self.variables["z_end"].get()) - float(
-            self.stack_acq_widgets["end_position"].get()
-        )
-        z_tiles = int(self.variables["z_tiles"].get())
-
-        # Default to fixed theta
-        r_start = float(self.stage_position_vars["theta"].get())
-        r_stop = float(self.stage_position_vars["theta"].get())
-        r_tiles = 1
-
-        f_start = float(self.variables["f_start"].get()) - float(
-            self.stack_acq_widgets["start_focus"].get()
-        )
-        f_stop = float(self.variables["f_end"].get()) - float(
-            self.stack_acq_widgets["end_focus"].get()
-        )
-        f_tiles = int(self.variables["f_tiles"].get())
-
-        # for consistency, always go from low to high
         def sort_vars(a, b):
             """Sort two variables from low to high
 
@@ -305,38 +270,55 @@ def sort_vars(a, b):
             if a > b:
                 return b, a
             return a, b
+    
+        if False in self.is_validated.values():
+            messagebox.showwarning(
+                title="Navigate",
+                message="Can't calculate positions, "
+                "please make sure all FOV Dists are correct!",
+            )
+            return
+        
+        tiling_setting = {}
+        for axis in self._axes:
+            start_pos = float(self.variables[f"{axis}_start"].get())
+            stop_pos = float(self.variables[f"{axis}_end"].get())
+            tiles = int(self.variables[f"{axis}_tiles"].get())
+            fov = float(self.variables[f"{axis}_fov"].get())
+
+            if axis == self.primary_z_axis:
+                start_pos -= float(
+                    self.stack_acq_widgets["start_position"].get()
+                )
+                stop_pos -= float(
+                    self.stack_acq_widgets["end_position"].get()
+                )
+            elif axis == self.primary_f_axis:
+                start_pos -= float(
+                    self.stack_acq_widgets["start_focus"].get()
+                )
+                stop_pos -= float(
+                    self.stack_acq_widgets["end_focus"].get()
+                )
+
+            start_pos, stop_pos = sort_vars(start_pos, stop_pos)
+            tiling_setting[f"{axis}_start"] = start_pos
+            # tiling_setting[f"{axis}_stop"] = stop_pos
+            tiling_setting[f"{axis}_tiles"] = tiles
+            tiling_setting[f"{axis}_length"] = fov
 
-        x_start, x_stop = sort_vars(x_start, x_stop)
-        y_start, y_stop = sort_vars(y_start, y_stop)
-        z_start, z_stop = sort_vars(z_start, z_stop)
-        r_start, r_stop = sort_vars(r_start, r_stop)
-        f_start, f_stop = sort_vars(f_start, f_stop)
+        tiling_setting["theta_start"] = float(self.stage_position_vars["theta"].get())
+        # tiling_setting["theta_stop"] = float(self.stage_position_vars["theta"].get())
+        tiling_setting["theta_tiles"] = 1
+        tiling_setting["theta_length"] = 0
 
         overlap = float(self._percent_overlap) / 100
-        table_values = compute_tiles_from_bounding_box(
-            x_start=x_start,
-            x_tiles=x_tiles,
-            x_length=float(self.variables["x_fov"].get()),
-            x_overlap=overlap,
-            y_start=y_start,
-            y_tiles=y_tiles,
-            y_length=float(self.variables["y_fov"].get()),
-            y_overlap=overlap,
-            z_start=z_start,
-            z_tiles=z_tiles,
-            z_length=float(self.variables["z_fov"].get()),
-            z_overlap=overlap,
-            theta_start=r_start,
-            theta_tiles=r_tiles,
-            theta_length=0,
-            theta_overlap=overlap,
-            f_start=f_start,
-            f_tiles=f_tiles,
-            f_length=float(self.variables["f_fov"].get()),
-            f_overlap=overlap,
+        columns, table_values = compute_tiles_from_bounding_box(
+            overlap=overlap,
+            **tiling_setting
         )
 
-        update_table(self.multipoint_table, table_values)
+        update_table(self.multipoint_table, table_values, columns)
 
         # If we have additional axes, create self.d{axis} for each
         # additional axis, to ensure we keep track of the step size
@@ -498,39 +480,60 @@ def update_fov(self, axis=None):
         """
 
         if axis is None:
-            axis = self._axes
+            axes = self._axes
         elif isinstance(axis, str):
-            axis = [axis]
+            if axis == "z_device":
+                # get the new primary z axis
+                primary_z = self.stack_acq_widgets["z_device"].get().split(" - ")[1]
+                if self.primary_z_axis != primary_z:
+                    self.variables[f"{primary_z}_fov"].set(self.variables[f"{self.primary_z_axis}_fov"].get())
+                    self.variables[f"{self.primary_z_axis}_fov"].set(0)
+                    self.primary_z_axis = primary_z
+                return
+            elif axis == "f_device":
+                # get the new primary f axis
+                primary_f = self.stack_acq_widgets["f_device"].get().split(" - ")[1]
+                if self.primary_f_axis != primary_f:
+                    self.variables[f"{primary_f}_fov"].set(self.variables[f"{self.primary_f_axis}_fov"].get())
+                    self.variables[f"{self.primary_f_axis}_fov"].set(0)
+                    self.primary_f_axis = primary_f
+                return
+            else:
+                axes = [axis]
 
-        for ax in axis:
+        for ax in axes:
             try:
                 # Calculate signed fov
                 if ax == "y":
                     y = float(self.cam_settings_widgets["FOV_X"].get()) * sign(
                         float(self.variables["x_end"].get())
                         - float(self.variables["x_start"].get())
                     )
+                    axis = "y"
                 elif ax == "x":
                     x = float(self.cam_settings_widgets["FOV_Y"].get()) * sign(
                         float(self.variables["y_end"].get())
                         - float(self.variables["y_start"].get())
                     )
+                    axis = "x"
                 elif ax == "z":
                     z = float(self.stack_acq_widgets["end_position"].get()) - float(
                         self.stack_acq_widgets["start_position"].get()
                     )
+                    axis = self.primary_z_axis
                 elif ax == "f":
                     f = float(self.stack_acq_widgets["end_focus"].get()) - float(
                         self.stack_acq_widgets["start_focus"].get()
                     )
+                    axis = self.primary_f_axis
 
                 # for ax in self._axes:
                 # self._fov[ax] = locals().get(ax)
-                self.variables[f"{ax}_fov"].set(
+                self.variables[f"{axis}_fov"].set(
                     abs(locals().get(ax))
                 )  # abs(self._fov[ax]))
 
-                self.calculate_tiles(ax)
+                self.calculate_tiles(axis)
             except (TypeError, ValueError) as e:
                 logger.debug(
                     f"Controller - Tiling Wizard - Caught ValueError: {e}. "

src/navigate/tools/multipos_table_tools.py

@@ -61,24 +61,21 @@ def compute_tiles_from_bounding_box(
     x_start,
     x_tiles,
     x_length,
-    x_overlap,
     y_start,
     y_tiles,
     y_length,
-    y_overlap,
     z_start,
     z_tiles,
     z_length,
-    z_overlap,
     theta_start,
     theta_tiles,
     theta_length,
-    theta_overlap,
     f_start,
     f_tiles,
     f_length,
-    f_overlap,
+    overlap=0.1,
     f_track_with_z=False,
+    **kwargs,
 ):
     """Create a grid of ROIs to image based on start position, number of tiles, and
     signed FOV length in each dimension.
@@ -91,49 +88,58 @@ def compute_tiles_from_bounding_box(
         Number of tiles to take along x-dimension.
     x_length : float
         Signed length of the FOV along x-dimension.
-    x_overlap : float
-        Fractional overlap of ROIs along x-dimension.
     y_start : float
         Starting position along y-dimension.
     y_tiles : int
         Number of tiles to take along y-dimension.
     y_length : float
         Signed length of the FOV along y-dimension.
-    y_overlap : float
-        Fractional overlap of ROIs along y-dimension.
     z_start : float
         Starting position along z-dimension.
     z_tiles : int
         Number of tiles to take along z-dimension.
     z_length : float
         Signed length of the FOV along z-dimension.
-    z_overlap : float
-        Fractional overlap of ROIs along z-dimension.
     theta_start : float
         Starting position along rotation dimension.
     theta_tiles : int
         Number of tiles to take along rotation dimension.
     theta_length : float
         Signed length of the FOV along rotation dimension.
-    theta_overlap : float
-        Fractional overlap of ROIs along rotation dimension.
     f_start : float
         Starting position along focus dimension.
     f_tiles : int
         Number of tiles to take along focus dimension.
     f_length : float
         Signed length of the FOV along focus dimension.
-    f_overlap : float
-        Fractional overlap of ROIs along focus dimension.
+    overlap : float
+        Fractional overlap of ROIs.
     f_track_with_z : bool
         Make focus track with z/assume focus is z-dependent.
+    **kwargs : additional keyword arguments
+        axis_start: Starting position along that axis
+        axis_tiles: Number of tiles to take along axis
+        axis_length: Signed length of the FOV along axis
 
     Returns
     -------
-    np.array
+    result : tuple ([str], np.array)
+        axes
         (n_positions x (x, y, z, theta, f)) array of positions, gridding out the space
     """
 
+    # get additional axes
+    additional_settings = {}
+    for k in kwargs.keys():
+        if k.endswith("_start"):
+            axis = k[:-6]
+            if f"{axis}_tiles" in kwargs.keys() and f"{axis}_length" in kwargs.keys():
+                additional_settings[axis] = {
+                    "start": kwargs[f"{axis}_start"],
+                    "tiles": 1 if kwargs[f"{axis}_tiles"] <= 0 else kwargs[f"{axis}_tiles"],
+                    "step": kwargs[f"{axis}_length"] * (1 - overlap)
+                }
+
     # Error checking to prevent empty list when tiles are zero
     x_tiles = 1 if x_tiles <= 0 else x_tiles
     y_tiles = 1 if y_tiles <= 0 else y_tiles
@@ -142,11 +148,11 @@ def compute_tiles_from_bounding_box(
     f_tiles = 1 if f_tiles <= 0 else f_tiles
 
     # Calculate the step between the edge of each frame
-    x_step = x_length * (1 - x_overlap)
-    y_step = y_length * (1 - y_overlap)
-    z_step = z_length * (1 - z_overlap)
-    theta_step = theta_length * (1 - theta_overlap)
-    f_step = f_length * (1 - f_overlap)
+    x_step = x_length * (1 - overlap)
+    y_step = y_length * (1 - overlap)
+    z_step = z_length * (1 - overlap)
+    theta_step = theta_length * (1 - overlap)
+    f_step = f_length * (1 - overlap)
 
     # grid out each dimension from (x_start, y_start, z_start) in steps
     def dim_vector(start, n_tiles, step):
@@ -166,6 +172,11 @@ def dim_vector(start, n_tiles, step):
     # we assume theta FOVs have no thickness
     fs = dim_vector(f_start, f_tiles, f_step)
 
+    additional_coordinates = []
+    for axis in additional_settings:
+        values = additional_settings[axis]
+        additional_coordinates.append(dim_vector(values["start"], values["tiles"], values["step"]))
+
     if f_track_with_z:
         # grid out the 4D space...
         x, y, z, t = np.meshgrid(xs, ys, zs, thetas)
@@ -177,9 +188,14 @@ def dim_vector(start, n_tiles, step):
         ]  # This only works if len(fs) = len(zs)
         # TODO: Don't clip f. Practically fine for now.
     else:
-        x, y, z, t, f = np.meshgrid(xs, ys, zs, thetas, fs)
+        result = np.meshgrid(xs, ys, zs, thetas, fs, *additional_coordinates)
+
+    axes = ["x", "y", "z", "theta", "f"]
+    axes.extend(list(additional_settings.keys()))
+    table_values = np.vstack([v.ravel() for v in result]).T
 
-    return np.vstack([x.ravel(), y.ravel(), z.ravel(), t.ravel(), f.ravel()]).T
+    return (axes, table_values)
+    # return np.vstack([x.ravel(), y.ravel(), z.ravel(), t.ravel(), f.ravel()]).T
 
 
 def calc_num_tiles(dist, overlap, roi_length):
@@ -217,7 +233,7 @@ def calc_num_tiles(dist, overlap, roi_length):
     return int(num_tiles)
 
 
-def update_table(table, pos, append=False):
+def update_table(table, pos, axes, append=False):
     """Updates and redraws table based on given list.
 
     List is converted to a pandas dataframe before setting data in table.
@@ -229,6 +245,8 @@ def update_table(table, pos, append=False):
     pos: list or np.array
         List or np.array of positions to be added to table. Each row contains an X, Y,
         Z, R, F position
+    axes: list of str
+        List of axes
     append: bool
         Append the new positions to the table
 
@@ -237,7 +255,7 @@ def update_table(table, pos, append=False):
     None :
         Table is updated
     """
-    frame = pd.DataFrame(pos, columns=list("XYZRF"))
+    frame = pd.DataFrame(pos, columns=[axis.upper() for axis in axes])
     if append:
         table.model.df = table.model.df.append(frame, ignore_index=True)
     else: