Merge pull request #808 from TheDeanLab/fix_exposure_time_error

camera exposure time in lightsheet mode

Author: AdvancedImagingUTSW

src/navigate/config/config.py

@@ -768,18 +768,18 @@ def verify_waveform_constants(manager, configuration):
                                 "amplitude"
                             ],
                             "offset": config_dict["remote_focus_device"]["offset"],
-                            "percent_smoothing": "0",
-                            "percent_delay": config_dict["remote_focus_device"][
-                                "delay_percent"
-                            ],
+                            # "percent_smoothing": "0",
+                            # "delay": config_dict["remote_focus_device"][
+                            #     "delay"
+                            # ],
                         },
                     )
                 else:
                     for k in [
                         "amplitude",
                         "offset",
-                        "percent_smoothing",
-                        "percent_delay",
+                        # "percent_smoothing",
+                        # "delay",
                     ]:
                         if k not in waveform_dict[microscope_name][zoom][laser].keys():
                             waveform_dict[microscope_name][zoom][laser][
@@ -893,6 +893,16 @@ def verify_waveform_constants(manager, configuration):
 
     # other_constants
     waveform_dict = configuration["waveform_constants"]
+    other_constants_dict = {
+        "remote_focus_settle_duration": "0",
+        "percent_smoothing": "0",
+        "remote_focus_delay": config_dict["remote_focus_device"][
+            "delay"
+        ],
+        "remote_focus_ramp_falling": config_dict["remote_focus_device"][
+            "ramp_falling"
+        ]
+    }
     if (
         "other_constants" not in waveform_dict.keys()
         or type(waveform_dict["other_constants"]) is not DictProxy
@@ -901,12 +911,30 @@ def verify_waveform_constants(manager, configuration):
             manager,
             waveform_dict,
             "other_constants",
-            {"remote_focus_settle_duration": "0"},
+            other_constants_dict,
         )
-    if "remote_focus_settle_duration" not in waveform_dict["other_constants"].keys():
-        waveform_dict["other_constants"]["remote_focus_settle_duration"] = "0"
-    else:
+    for k in other_constants_dict.keys():
         try:
-            float(waveform_dict["other_constants"]["remote_focus_settle_duration"])
-        except ValueError:
-            waveform_dict["other_constants"]["remote_focus_settle_duration"] = "0"
+            float(waveform_dict["other_constants"][k])
+        except (ValueError, KeyError):
+            waveform_dict["other_constants"][k] = "0"
+
+def verify_configuration(manager, configuration):
+    """Verify configuration files.
+    
+    Supports old version of configurations.
+    """
+    device_config = configuration["configuration"]["microscopes"]
+    for microscope_name in device_config.keys():
+        # camera
+        # delay_percent -> delay
+        camera_config = device_config[microscope_name]["camera"]
+        if "delay" not in camera_config.keys():
+            camera_config["delay"] = camera_config.get("delay_percent", 2)
+        # remote focus
+        # ramp_falling_percent -> ramp_falling
+        remote_focus_config = device_config[microscope_name]["remote_focus_device"]
+        if "ramp_falling" not in remote_focus_config.keys():
+            remote_focus_config["ramp_falling"] = remote_focus_config.get("ramp_falling_percent", 5)
+        if "delay" not in remote_focus_config.keys():
+            remote_focus_config["delay"] = remote_focus_config.get("delay_percent", 0)

src/navigate/controller/controller.py

@@ -78,6 +78,7 @@
     update_config_dict,
     verify_experiment_config,
     verify_waveform_constants,
+    verify_configuration,
     get_navigate_path,
 )
 from navigate.tools.file_functions import create_save_path, save_yaml_file
@@ -153,6 +154,7 @@ def __init__(
             waveform_templates=waveform_templates_path,
         )
 
+        verify_configuration(self.manager, self.configuration)
         verify_experiment_config(self.manager, self.configuration)
         verify_waveform_constants(self.manager, self.configuration)
 
@@ -950,6 +952,8 @@ def capture_image(self, command, mode, *args):
         )
 
         self.stop_acquisition_flag = False
+        start_time = time.time()
+        self.camera_setting_controller.update_readout_time()
 
         while True:
             if self.stop_acquisition_flag:
@@ -967,6 +971,7 @@ def capture_image(self, command, mode, *args):
                 )
                 self.execute("stop_acquire")
 
+
             # Display the Image in the View
             self.camera_view_controller.try_to_display_image(image_id=image_id)
             images_received += 1
@@ -978,6 +983,17 @@ def capture_image(self, command, mode, *args):
                 mode=mode,
                 stop=False,
             )
+            # update framerate
+            stop_time = time.time()
+            frames_per_second = images_received / (stop_time - start_time)
+            # Update the Framerate in the Camera Settings Tab
+            self.camera_setting_controller.framerate_widgets["max_framerate"].set(
+                frames_per_second
+            )
+
+            # Update the Framerate in the Acquire Bar to provide an estimate of
+            # the duration of time remaining.
+            self.acquire_bar_controller.framerate = frames_per_second
 
         logger.info(
             f"Navigate Controller - Captured {images_received}, " f"{mode} Images"
@@ -1223,18 +1239,10 @@ def update_event(self):
                     except RuntimeError:
                         time.sleep(0.001)
                         pass
-
-            elif event == "framerate":
-                # Update the Framerate in the Camera Settings Tab
-                self.camera_setting_controller.framerate_widgets["max_framerate"].set(
-                    value
-                )
-
-                # Update the Framerate in the Acquire Bar to provide an estimate of
-                # the duration of time remaining.
-                self.acquire_bar_controller.framerate = value
             elif event == "remove_positions":
                 self.multiposition_tab_controller.remove_positions(value)
+            elif event == "exposure_time":
+                self.channels_tab_controller.set_exposure_time(value[0], value[1])
 
     # def exit_program(self):
     #     """Exit the program.

src/navigate/controller/sub_controllers/camera_setting_controller.py

@@ -236,7 +236,7 @@ def populate_experiment_values(self):
         # Physical Dimensions
         self.calculate_physical_dimensions()
         # readout time
-        self.calculate_readout_time()
+        self.update_readout_time()
 
         # after initialization
         self.in_initialization = False
@@ -349,7 +349,7 @@ def update_sensor_mode(self, *args):
             self.show_verbose_info("Light Sheet Camera Readout Mode")
 
         # calculate readout time
-        self.calculate_readout_time()
+        self.update_readout_time()
 
     def update_exposure_time(self, exposure_time):
         """When camera exposure time is changed, recalculate readout time
@@ -360,7 +360,6 @@ def update_exposure_time(self, exposure_time):
             exposure time in seconds
         """
         self.framerate_widgets["exposure_time"].set(exposure_time)
-        self.calculate_readout_time()
 
     def update_roi(self, btn_name):
         """Update ROI width and height.
@@ -464,43 +463,23 @@ def calculate_physical_dimensions(self):
         self.roi_widgets["FOV_X"].set(physical_dimensions_x)
         self.roi_widgets["FOV_Y"].set(physical_dimensions_y)
 
-    def calculate_readout_time(self):
-        """Calculate camera readout time.
+    def update_readout_time(self):
+        """Update camera readout time.
 
 
         TODO: Highly specific to Hamamatsu Orca Flash 4.0.
         Should find a way to pass this from the camera to here.
         This should be moved to the camera device/API,
         ideally by calling a command from the camera.
         """
-
-        h = 9.74436e-6  # Readout timing constant
         sensor_mode = self.mode_widgets["Sensor"].get()
-        if (self.readout_speed == 1) and (sensor_mode == "Normal"):
-            h = 32.4812e-6
-        # the ROI height 'subarray_vsize'
-        vn = float(self.roi_widgets["Height"].get())
-        exposure_time = float(self.framerate_widgets["exposure_time"].get())
 
         if sensor_mode == "Normal":
-            #  Area sensor mode operation
-            if self.trigger_source == 1:
-                # Internal Trigger Source
-                readout_time = exposure_time - ((vn / 2) * h)
-
-            if self.trigger_active in [1, 2]:
-                #  External Trigger Source
-                #  Edge == 1, Level == 2
-                readout_time = exposure_time - ((vn / 2) * h + 10 * h)
-
-            elif self.trigger_active == 3:
-                #  External Trigger Source
-                #  Synchronous Readout == 3
-                readout_time = exposure_time - ((vn / 2) * h + 5 * h)
+            readout_time = self.camera_setting_dict["readout_time"]
 
         elif sensor_mode == "Light-Sheet":
             #  Progressive sensor mode operation
-            readout_time = exposure_time - 1 / (exposure_time + (vn + 10) * h)
+            readout_time = 0
 
         # return readout_time
         self.framerate_widgets["readout_time"].set(readout_time)

src/navigate/controller/sub_controllers/channels_tab_controller.py

@@ -848,3 +848,18 @@ def verify_experiment_values(self):
             if self.microscope_state_dict["timepoints"] < 1:
                 return "Timepoints should be at least 1!"
         return None
+    
+    def set_exposure_time(self, channel, exposure_time):
+        """Set exposure time for a specified channel
+        
+        Parameters
+        ----------
+        channel : str
+            Channel name, such as "channel_1", "channel_2",...
+        exposure_time : float
+            Exposure time in miliseconds.
+        """
+        idx = int(channel[channel.index('_')+1:]) - 1
+        self.channel_setting_controller.in_initialization = True
+        self.channel_setting_controller.view.exptime_variables[idx].set(exposure_time)
+        self.channel_setting_controller.in_initialization = False

src/navigate/controller/sub_controllers/waveform_popup_controller.py

@@ -161,6 +161,9 @@ def __init__(self, view, parent_controller, waveform_constants_path):
         self.variables["Delay"].trace_add("write", self.update_waveform_parameters)
         self.variables["Duty"].trace_add("write", self.update_waveform_parameters)
         self.variables["Smoothing"].trace_add("write", self.update_waveform_parameters)
+        self.variables["Ramp_falling"].trace_add(
+            "write", self.update_waveform_parameters
+        )
 
         # Save waveform constants
         self.view.get_buttons()["Save"].configure(command=self.save_waveform_constants)
@@ -380,26 +383,22 @@ def show_laser_info(self, *args):
         # Currently pulls from the original microscope configuration YAML file, not the
         # current microscope configuration according to the model
         self.update_waveform_parameters_flag = False
-        waveform_configuration = self.resolution_info["remote_focus_constants"][
-            self.resolution
-        ][self.mag][self.lasers[0]]
         self.widgets["Smoothing"].set(
-            waveform_configuration.get("percent_smoothing", 0)
+            self.resolution_info["other_constants"].get("percent_smoothing", 0)
         )
         self.widgets["Smoothing"].widget.trigger_focusout_validation()
-        self.widgets["Delay"].set(waveform_configuration.get("percent_delay", 7.5))
+        self.widgets["Delay"].set(
+            self.resolution_info["other_constants"].get("remote_focus_delay", 7.5)
+        )
         self.widgets["Delay"].widget.trigger_focusout_validation()
-        if "other_constants" not in self.resolution_info:
-            update_config_dict(
-                self.parent_controller.manager,
-                self.resolution_info,
-                "other_constants",
-                {"remote_focus_settle_duration": 0},
-            )
         self.widgets["Duty"].set(
             self.resolution_info["other_constants"]["remote_focus_settle_duration"]
         )
         self.widgets["Duty"].widget.trigger_focusout_validation()
+        self.widgets["Ramp_falling"].set(
+            self.resolution_info["other_constants"]["remote_focus_ramp_falling"]
+        )
+        self.widgets["Ramp_falling"].widget.trigger_focusout_validation()
         self.update_waveform_parameters_flag = True
 
         # update resolution value in central controller (menu)
@@ -491,21 +490,20 @@ def update_waveform_parameters(self, *args, **wargs):
             delay = float(self.widgets["Delay"].widget.get())
             duty_cycle = float(self.widgets["Duty"].widget.get())
             smoothing = float(self.widgets["Smoothing"].widget.get())
+            ramp_falling = float(self.widgets["Ramp_falling"].widget.get())
         except ValueError:
             return
 
         # Update the waveform parameters
         # all the lasers use the same delay, smoothing value
-        for laser in self.lasers:
-            self.resolution_info["remote_focus_constants"][self.resolution][self.mag][
-                laser
-            ]["percent_delay"] = delay
-            self.resolution_info["remote_focus_constants"][self.resolution][self.mag][
-                laser
-            ]["percent_smoothing"] = smoothing
         self.resolution_info["other_constants"][
             "remote_focus_settle_duration"
         ] = duty_cycle
+        self.resolution_info["other_constants"][
+            "remote_focus_ramp_falling"
+        ] = ramp_falling
+        self.resolution_info["other_constants"]["remote_focus_delay"] = delay
+        self.resolution_info["other_constants"]["percent_smoothing"] = smoothing
 
         # Pass the values to the parent controller.
         self.event_id = self.view.popup.after(

src/navigate/controller/sub_controllers/waveform_tab_controller.py

@@ -214,6 +214,8 @@ def plot_waveforms(self, event):
         # two pass
         for k in self.waveform_dict["camera_waveform"].keys():
             remote_focus_waveform = self.waveform_dict["remote_focus_waveform"][k]
+            if remote_focus_waveform is None:
+                continue
             max_remote_focus_waveform = np.maximum(max_remote_focus_waveform, np.max(remote_focus_waveform))
             min_remote_focus_waveform = np.minimum(min_remote_focus_waveform, np.min(remote_focus_waveform))
             camera_waveform = self.waveform_dict["camera_waveform"][k]

src/navigate/model/device_startup_functions.py

@@ -1240,7 +1240,11 @@ def load_devices(configuration, is_synthetic=False, plugin_devices={}) -> dict:
                 )
                 # if the serial number is with leading zeros, the yaml reader will convert it to a octal number
                 if camera_serial_number.startswith("0"):
-                    devices["camera"][build_ref_name("_", device["type"], int(camera_serial_number, 8))] = camera
+                    try:
+                        oct_num = int(camera_serial_number, 8)
+                        devices["camera"][build_ref_name("_", device["type"], oct_num)] = camera
+                    except ValueError:
+                        pass
             else:
                 device_ref_name = build_ref_name(
                     "_", device["type"], device["serial_number"]

src/navigate/model/devices/APIs/hamamatsu/HamamatsuAPI.py

@@ -641,6 +641,7 @@ class DCAMDEV_STRING(Structure):
     "sensor_mode": 4194832,  # 0x00400210, R/W, mode,  "SENSOR MODE"
     "defect_correct_mode": 4653072,  # 0x00470010, R/W, mode,  "DEFECT CORRECT MODE"
     "binning": 4198672,  # 0x00401110, R/W, mode, "BINNING"
+    "subarray_mode": 4202832,  # 0x00402150, R/W, mode,   "SUBARRAY MODE"
     "readout_speed": 4194576,  # 0x00400110, R/W, long,    "READOUT SPEED"
     "readout_direction": 4194608,  # 0x00400130, R/W, mode,   "READOUT DIRECTION"
     "readout_time": 4206608,  # 0x00403010, R/O, sec,   "TIMING READOUT TIME"
@@ -649,8 +650,8 @@ class DCAMDEV_STRING(Structure):
     "trigger_polarity": 1049120,  # 0x00100220, R/W, mode, "TRIGGER POLARITY"
     "trigger_source": 1048848,  # 0x00100110, R/W, mode,   "TRIGGER SOURCE"
     "trigger_delay": 1049184,  # 0x00100260,	/* R/W, sec,	"TRIGGER DELAY"
-    "internal_line_interval": 4208720,  # 0x00403850, R/W, sec,
-    # "INTERNAL LINE INTERVAL"
+    "internal_line_interval": 4208720,  # 0x00403850, R/W, sec,    "INTERNAL LINE INTERVAL"
+    "internal_line_speed": 4208704,  # 0x00403840, R/W, m/sec,    "INTERNAL LINE SPEED"
     "image_width": 4325904,  # 0x00420210, R/O, long, "IMAGE WIDTH"
     "image_height": 4325920,  # 0x00420220, R/O, long,    "IMAGE HEIGHT"
     "exposuretime_control": 2031920,  # 0x001F0130, R/W, mode,
@@ -1013,8 +1014,9 @@ def set_property_value(self, name, value):
             return False
 
         # Cast value to a multiple of step size
-        if property_value_step > 0:
-            value = int(value // property_value_step) * property_value_step
+        # The cast will cause accuracy problems when setting exposure time
+        # if property_value_step > 0:
+        #     value = int(value // property_value_step) * property_value_step
 
         if value < property_value_min:
             print(