Merge pull request #841 from TheDeanLab/828-save-waveform-constants-with-acquisition-and-generate-method-to-load-it

828 save waveform constants with acquisition and generate method to load it

Author: AdvancedImagingUTSW

docs/source/user_guide/gui_walkthrough.rst

@@ -22,10 +22,10 @@ File
 
 The :guilabel:`File` menu lets a user create, load and save
 :ref:`experiment files <user_guide/software_configuration:experiment file>`,
-which store the states of the GUI and the hardware. This is useful if a user wants to 
+which store the states of the GUI and the hardware. The menu also provides an option to load and save :ref:`waveform constants files <user_guide/software_configuration:waveform constants file>` to store the waveform constants used for a given experiment. This is useful if a user wants to
 perform an experiment with the same parameters multiple times, but close the software 
-in between acquisitions. To facilitate reproducibility, an `experiment.yml` file is 
-always saved with collected image data.
+in between acquisitions. To facilitate reproducibility, `experiment.yml` and `waveform_constants.yml` files are
+always saved with the collected image data.
 
 The :guilabel:`File` menu also provides access to toggle the :guilabel:`Save Data` flag,
 also found under :guilabel:`Timepoint Settings` in the 

docs/source/user_guide/images/menu_file.png

@@ -6,5 +6,9 @@
   "Confocal-Projection": {
     "repeat": timepoints,
     "expand": n_plane,
-  }
+  },
+    "Bidirectional": {
+      "repeat": 1,
+      "expand": 2,
+    }
 }

src/navigate/config/waveform_templates.yml

@@ -737,11 +737,19 @@ def execute(self, command, *args):
                 return
             saving_settings = self.configuration["experiment"]["Saving"]
             file_directory = create_save_path(saving_settings)
+
+            # Save the experiment.yaml file.
             save_yaml_file(
-                file_directory,
-                self.configuration["experiment"],
+                file_directory=file_directory,
+                content_dict=self.configuration["experiment"],
                 filename="experiment.yml",
             )
+
+            # Save the waveform_constants.yaml file.
+            save_yaml_file(file_directory=file_directory,
+                           content_dict=self.configuration['waveform_constants'],
+                           filename="waveform_constants.yml")
+
             self.camera_setting_controller.solvent = self.configuration["experiment"][
                 "Saving"
             ]["solvent"]

src/navigate/controller/controller.py

@@ -65,9 +65,15 @@
 from navigate.tools.file_functions import save_yaml_file, load_yaml_file
 from navigate.tools.decorators import FeatureList
 from navigate.tools.common_functions import load_module_from_file
-from navigate.config.config import get_navigate_path
 
 
+# Misc. Local Imports
+from navigate.config.config import (
+    update_config_dict,
+    verify_waveform_constants,
+    get_navigate_path,
+)
+
 # Logger Setup
 p = __name__.split(".")[1]
 logger = logging.getLogger(p)
@@ -88,8 +94,10 @@ def __init__(self, char=None, keysym=None):
         """
         #: str: The character that was pressed.
         self.char = char
+
         #: str: The key that was pressed.
         self.keysym = keysym
+
         #: int: The state of the keyboard.
         self.state = 0
 
@@ -108,24 +116,34 @@ def __init__(self, view, parent_controller=None):
             The parent controller.
         """
         super().__init__(view, parent_controller)
+
         #: Controller: The parent controller.
         self.parent_controller = parent_controller
+
         #: tk.canvas: The view class.
         self.view = view
+
         #: tkinter.StringVar: Resolution value.
         self.resolution_value = tk.StringVar()
+
         #: tkinter.IntVar: Feature id value.
         self.feature_id_val = tk.IntVar()
+
         #: tkinter.IntVar: Disable stage limits.
         self.disable_stage_limits = tk.IntVar()
+
         #: FakeEvent: Fake event.
         self.fake_event = None
+
         #: list: List of feature list names.
         self.feature_list_names = []
+
         #: int: System feature list count.
         self.system_feature_list_count = 0
+
         #: int: Feature list count.
         self.feature_list_count = 0
+
         #: str: Feature list file name.
         self.feature_list_file_name = "feature_lists.yaml"
 
@@ -186,6 +204,20 @@ def initialize_menus(self):
                     "<Control-S>",
                     "<Control_L-S>",
                 ],
+                "Load Waveform Constants": [
+                    "standard",
+                    self.load_waveform_constants,
+                    None,
+                    None,
+                    None,
+                ],
+                "Save Waveform Constants": [
+                    "standard",
+                    self.save_waveform_constants,
+                    None,
+                    None,
+                    None,
+                ],
                 "add_separator": [None],
                 "Toggle Save Data": [
                     "standard",
@@ -690,6 +722,45 @@ def save_experiment(self, *args):
             return
         save_yaml_file("", self.parent_controller.configuration["experiment"], filename)
 
+    def save_waveform_constants(self):
+        """Save a waveform constants file
+
+        Updates model.waveform_constants and saves it to file
+
+        """
+        filename = filedialog.asksaveasfilename(
+            defaultextension=".yml", filetypes=[("Yaml file", "*.yml *.yaml")]
+        )
+        if not filename:
+            return
+        save_yaml_file(
+            "", self.parent_controller.configuration["waveform_constants"], filename
+        )
+
+    def load_waveform_constants(self):
+        """Load a waveform constants file"""
+
+        filename = filedialog.askopenfilename(
+            defaultextension=".yml", filetypes=[("Yaml files", "*.yml *.yaml")]
+        )
+        if not filename:
+            return
+
+        update_config_dict(
+            self.parent_controller.manager,
+            self.parent_controller.configuration,
+            "waveform_constants",
+            filename,
+        )
+        verify_waveform_constants(
+            self.parent_controller.manager, self.parent_controller.configuration
+        )
+
+        if hasattr(self.parent_controller, "waveform_popup_controller"):
+            self.parent_controller.waveform_popup_controller.populate_experiment_values(
+                force_update=True
+            )
+
     def load_images(self):
         """Load images from a file."""
         filenames = filedialog.askopenfilenames(
@@ -762,9 +833,13 @@ def popup_autofocus_setting(self, *args):
         )
 
     def popup_waveform_setting(self):
+        """Pop up the Waveform setting window.
+
+        If the window is already open, show it. Otherwise, create a new one."""
         if hasattr(self.parent_controller, "waveform_popup_controller"):
             self.parent_controller.waveform_popup_controller.showup()
             return
+
         waveform_constants_popup = WaveformParameterPopupWindow(
             self.view, self.parent_controller.configuration_controller
         )

src/navigate/controller/sub_controllers/menu_controller.py

@@ -75,44 +75,57 @@ def __init__(self, view, parent_controller, waveform_constants_path):
         ]
         #: dict: Galvo constants for the microscope.
         self.galvo_setting = self.resolution_info["galvo_constants"]
+
         #: ConfigurationController: The configuration controller.
         self.configuration_controller = self.parent_controller.configuration_controller
+
         #: str: The path to the waveform constants file.
         self.waveform_constants_path = waveform_constants_path
 
         # Get mode and mag widgets
         #: dict: The widgets for the mode and magnification.
         self.widgets = self.view.get_widgets()
+
         #: dict: The variables for the mode and magnification.
         self.variables = self.view.get_variables()
 
         # Get configuration
         #: list: The lasers.
         self.lasers = self.configuration_controller.lasers_info
 
-        # Initialize
         #: str: The current resolution.
         self.resolution = None
+
         #: str: The current magnification.
         self.mag = None
+
         #: str: The current microscope operation mode.
         self.mode = "stop"
+
         #: dict: Remote focus experiment dictionary.
         self.remote_focus_experiment_dict = None
+
         #: bool: Flag to update galvo device.
         self.update_galvo_device_flag = None
+
         #: bool: Flag to update waveform parameters.
         self.update_waveform_parameters_flag = False
+
         #: bool: Flag to enable/disable waveforms.
         self.waveforms_enabled = True
+
         #: dict: Dictionary of amplitude values.
         self.amplitude_dict = None
+
         #: float: the minimum value of remote focus device
         self.laser_min = 0
+
         #: float: the maximum value of remote focus device
         self.laser_max = 1.0
+
         #: dict: Dictionary of galvo minimum values
         self.galvo_min = {}
+
         #: dict: Dictionary of galvo maximum values
         self.galvo_max = {}
 
@@ -289,19 +302,25 @@ def configure_widget_range(self):
         # amplitude.
         #
 
-    def populate_experiment_values(self):
+    def populate_experiment_values(self, force_update=False):
         """Set experiment values."""
         self.remote_focus_experiment_dict = self.parent_controller.configuration[
             "experiment"
         ]["MicroscopeState"]
         resolution_value = self.remote_focus_experiment_dict["microscope_name"]
         zoom_value = self.remote_focus_experiment_dict["zoom"]
         mag = zoom_value
-        if (
-            self.widgets["Mode"].get() == resolution_value
+        if (not force_update
+            and self.widgets["Mode"].get() == resolution_value
             and self.widgets["Mag"].get() == mag
         ):
             return
+
+        # Microscope information
+        self.resolution_info = self.parent_controller.configuration[
+            "waveform_constants"
+        ]
+        self.galvo_setting = self.resolution_info["galvo_constants"]
         self.widgets["Mode"].set(resolution_value)
         self.show_magnification(mag)
 

src/navigate/controller/sub_controllers/waveform_popup_controller.py

@@ -77,7 +77,7 @@ def __init__(self, configuration):
 
         #: dict: Sweep times for different channels
         self.sweep_times = None
-        
+
         #: dict: exposure times for different channels
         self.exposure_times = None
 
@@ -132,6 +132,7 @@ def calculate_all_waveforms(self, microscope_name, exposure_times, sweep_times):
                 exposure_time = exposure_times[channel_key]
                 sweep_time = sweep_times[channel_key]
 
+                # Create 5V TTL for 1 camera exposure.
                 self.waveform_dict[channel_key] = camera_exposure(
                     sample_rate=self.sample_rate,
                     sweep_time=sweep_time,

src/navigate/model/devices/daq/daq_base.py

@@ -36,7 +36,11 @@
 # Third Party Imports
 
 # Local Imports
-from navigate.model.waveforms import remote_focus_ramp, smooth_waveform
+from navigate.model.waveforms import (
+    remote_focus_ramp,
+    smooth_waveform,
+    remote_focus_ramp_triangular,
+)
 
 # # Logger Setup
 p = __name__.split(".")[1]
@@ -114,12 +118,21 @@ def adjust(self, exposure_times, sweep_times, offset=None):
         waveform : numpy.ndarray
             Waveform for the remote focus device.
         """
+        # to determine if the waveform has to be triangular
+        sensor_mode = self.configuration["experiment"]["CameraParameters"][
+            "sensor_mode"
+        ]
+        readout_direction = self.configuration["experiment"]["CameraParameters"][
+            "readout_direction"
+        ]
 
         self.waveform_dict = dict.fromkeys(self.waveform_dict, None)
         microscope_state = self.configuration["experiment"]["MicroscopeState"]
         waveform_constants = self.configuration["waveform_constants"]
         imaging_mode = microscope_state["microscope_name"]
         zoom = microscope_state["zoom"]
+        # ramp_type = self.configuration["configuration"]["microscopes"][
+        #     self.microscope_name]['remote focus device']['ramp_type']
         self.sample_rate = self.configuration["configuration"]["microscopes"][
             self.microscope_name
         ]["daq"]["sample_rate"]
@@ -182,16 +195,32 @@ def adjust(self, exposure_times, sweep_times, offset=None):
                     remote_focus_offset += offset
 
                 # Calculate the Waveforms
-                self.waveform_dict[channel_key] = remote_focus_ramp(
-                    sample_rate=self.sample_rate,
-                    exposure_time=exposure_time,
-                    sweep_time=self.sweep_time,
-                    remote_focus_delay=remote_focus_delay,
-                    camera_delay=self.camera_delay,
-                    fall=remote_focus_ramp_falling,
-                    amplitude=remote_focus_amplitude,
-                    offset=remote_focus_offset,
-                )
+                if sensor_mode == "Light-Sheet" and (
+                    readout_direction == "Bidirectional"
+                    or readout_direction == "Rev. Bidirectional"
+                ):
+                    self.waveform_dict[channel_key] = remote_focus_ramp_triangular(
+                        sample_rate=self.sample_rate,
+                        exposure_time=exposure_time,
+                        sweep_time=self.sweep_time,
+                        remote_focus_delay=remote_focus_delay,
+                        camera_delay=self.camera_delay,
+                        amplitude=remote_focus_amplitude,
+                        offset=remote_focus_offset,
+                    )
+                    samples *= 2
+
+                else:
+                    self.waveform_dict[channel_key] = remote_focus_ramp(
+                        sample_rate=self.sample_rate,
+                        exposure_time=exposure_time,
+                        sweep_time=self.sweep_time,
+                        remote_focus_delay=remote_focus_delay,
+                        camera_delay=self.camera_delay,
+                        fall=remote_focus_ramp_falling,
+                        amplitude=remote_focus_amplitude,
+                        offset=remote_focus_offset,
+                    )
 
                 # Smooth the Waveform if specified
                 if percent_smoothing > 0:
@@ -209,4 +238,3 @@ def adjust(self, exposure_times, sweep_times, offset=None):
                 ] = self.remote_focus_min_voltage
 
         return self.waveform_dict
-