REFACTOR: moved functions in launchers to be in the same file as the class they are launching. Removed launcher methods from classes in data_structures to better separate the model from the view/controller. Made more changes to the import structure.

Author: hruth

src/pyxalign/__init__.py

@@ -2,23 +2,7 @@
 from . import io
 from .api import options
 from .api import enums
-
-from .interactions.master import launch_master_gui
-from .interactions.viewers.launchers import launch_array_viewer, launch_volume_viewer, launch_linked_array_viewer
-
-
-# Create a gui namespace using a simple class
-class _GUI:
-    """Namespace for GUI-related functions."""
-
-    launch_master_gui = staticmethod(launch_master_gui)
-    launch_array_viewer = staticmethod(launch_array_viewer)
-    launch_volume_viewer = staticmethod(launch_volume_viewer)
-    launch_linked_array_viewer = staticmethod(launch_linked_array_viewer)
-    
-
-
-gui = _GUI()
+from . import gui
 
 __all__ = [
     "data_structures",

src/pyxalign/data_structures/__init__.py

@@ -6,12 +6,14 @@
 """
 
 from .projections import PhaseProjections, ComplexProjections
-from .task import LaminographyAlignmentTask
-from .xrf_task import XRFTask
+from .task import LaminographyAlignmentTask, load_task
+from .xrf_task import XRFTask, load_xrf_task
 
 __all__ = [
     "ComplexProjections",
     "PhaseProjections",
     "LaminographyAlignmentTask",
     "XRFTask",
+    "load_task",
+    "load_xrf_task",
 ]

src/pyxalign/data_structures/projections.py

@@ -7,7 +7,6 @@
     get_center_of_rotation_from_different_resolution_alignment,
     get_shift_from_different_resolution_alignment,
 )
-from pyxalign.api.constants import divisor
 from pyxalign.api.options.plotting import PlotDataOptions
 from pyxalign.estimate_center import (
     estimate_center_of_rotation,
@@ -18,7 +17,6 @@
 from pyxalign.api import enums
 from pyxalign.api.options.alignment import AlignmentOptions
 from pyxalign.api.options.device import DeviceOptions
-from pyxalign.api.options import ProjectionViewerOptions
 
 from pyxalign.api.options.projections import (
     EstimateCenterOptions,
@@ -43,7 +41,6 @@
 
 from pyxalign.mask import estimate_reliability_region_mask, blur_masks
 from pyxalign.model_functions import symmetric_gaussian_2d
-from pyxalign.interactions.viewers.launchers import launch_projection_viewer
 import pyxalign.plotting.plotters as plotters
 from pyxalign.style.text import ordinal
 from pyxalign.timing.timer_utils import timer, clear_timer_globals
@@ -67,6 +64,7 @@
 from pyxalign.data_structures.positions import ProbePositions
 from pyxalign.api.types import ArrayType, r_type
 
+
 class TransformTracker:
     def __init__(
         self,
@@ -724,15 +722,6 @@ def save_projections_object(
         else:
             print(f"projections saved to {save_path}")
 
-    def launch_viewer(
-        self,
-        options: Optional[ProjectionViewerOptions] = None,
-        wait_until_closed: Optional[bool] = False,
-    ):
-        self.gui = launch_projection_viewer(
-            self, options, display_only=False, wait_until_closed=wait_until_closed
-        )
-
     def load_and_stage_shift(
         self,
         task_file_path: str,
@@ -801,8 +790,7 @@ def unwrap_phase(self, pinned_results: Optional[np.ndarray] = None) -> ArrayType
         )
         # this method does not need a mask
         bool_2 = (
-            self.options.phase_unwrap.method
-            == enums.PhaseUnwrapMethods.GRADIENT_INTEGRATION
+            self.options.phase_unwrap.method == enums.PhaseUnwrapMethods.GRADIENT_INTEGRATION
         ) and (self.options.phase_unwrap.gradient_integration.use_masks)
         use_masks = bool_1 or bool_2
         if use_masks is True and self.masks is None:
@@ -1013,3 +1001,5 @@ def get_kwargs_for_copying_to_new_projections_object(
         kwargs["projections"] = projections.data * 1
 
     return kwargs
+
+

src/pyxalign/data_structures/volume.py

@@ -5,7 +5,6 @@
 import astra
 import copy
 import h5py
-from PyQt5.QtWidgets import QApplication
 
 from pyxalign.api.constants import divisor
 from pyxalign.api.options.device import DeviceOptions
@@ -16,8 +15,6 @@
 import pyxalign.image_processing as ip
 from pyxalign import reconstruct
 from pyxalign.io.save import save_array_as_tiff
-from pyxalign.interactions.viewers.arrays import VolumeViewer
-from pyxalign.interactions.viewers.launchers import launch_volume_viewer
 from pyxalign.plotting.plotters import plot_slice_of_3D_array
 import pyxalign.data_structures.projections as projections
 from pyxalign.timing.timer_utils import timer
@@ -339,9 +336,6 @@ def save_as_h5(self, file_path: str):
         with h5py.File(file_path, "w") as F:
             F.create_dataset(name="volume", data=self.data)
 
-    def launch_viewer(self, wait_until_closed: bool = False):
-        self.gui = launch_volume_viewer(self.data, wait_until_closed=wait_until_closed)
-
 
 def get_tomogram_rotation_angles(
     reconstruction: np.ndarray,

src/pyxalign/data_structures/xrf_task.py

@@ -2,6 +2,7 @@
 import numpy as np
 import h5py
 import copy
+
 # from pyxalign.data_structures.task import LaminographyAlignmentTask
 from pyxalign.alignment.cross_correlation import CrossCorrelationAligner
 from pyxalign.api import enums
@@ -30,7 +31,7 @@ def __init__(
         masks: Optional[np.ndarray] = None,
         _initialize_from_loaded_data: bool = False,
         _loaded_projections_dict: Optional[dict[str, XRFProjections]] = None,
-    ):  
+    ):
         self.projection_options = projection_options
         self.alignment_options = alignment_options
         # force proper typing
@@ -53,9 +54,9 @@ def __init__(
             # reinforce references
             for channel, proj in self.projections_dict.items():
                 proj.options = self.projection_options
-            
+
         # if center_of_rotation is not None:
-            # self.center_of_rotation = center_of_rotation.astype(r_type)
+        # self.center_of_rotation = center_of_rotation.astype(r_type)
         # else:
         self._center_of_rotation = self.projections_dict[self._primary_channel].center_of_rotation
 
@@ -141,7 +142,6 @@ def primary_channel(self, new_channel: str):
             for channel in self.channels:
                 print(f"{channel}")
 
-
     def apply_staged_shift_to_all_channels(self, device_options: Optional[DeviceOptions] = None):
         for _, projections in self.projections_dict.items():
             projections.apply_staged_shift(device_options)
@@ -260,33 +260,12 @@ def save_task(self, file_path: str, save_channels: Optional[list[str]] = None):
             print(f"XRF task saved to {h5_obj.file.filename}{h5_obj.name}")
             h5_obj["task_file_type"] = "xrf"
 
-    # def launch_projections_viewer(self):
-
-
-#     # def launch_xrf_projections_viewer(self):
-
-# def load_task(file_path: str, exclude: list[str] = []) -> LaminographyAlignmentTask:
-#     print("Loading task from", file_path, "...")
-
-#     with h5py.File(file_path, "r") as h5_obj:
-#         # Load projections
-#         loaded_projections = load_projections(h5_obj, exclude)
-
-#         # Insert projections into task along with saved task options
-#         task = LaminographyAlignmentTask(
-#             options=load_options(h5_obj["options"], AlignmentTaskOptions),
-#             complex_projections=loaded_projections["complex_projections"],
-#             phase_projections=loaded_projections["phase_projections"],
-#         )
-
-#         print("Loading complete")
-
-#     return task
-
 
 def load_xrf_task(file_path: str, exclude_channels: Optional[list[str]] = None) -> XRFTask:
     with h5py.File(file_path, "r") as h5_obj:
-        xrf_projections_dict = load_xrf_projections(task_h5_obj=h5_obj, exclude_channels=exclude_channels)
+        xrf_projections_dict = load_xrf_projections(
+            task_h5_obj=h5_obj, exclude_channels=exclude_channels
+        )
         primary_channel = h5_obj["primary_channel"][()].decode()
         alignment_options = load_options(h5_obj["alignment_options"], AlignmentTaskOptions)
         projection_options = load_options(h5_obj["projection_options"], ProjectionOptions)
@@ -309,4 +288,3 @@ def load_xrf_task(file_path: str, exclude_channels: Optional[list[str]] = None)
     )
 
     return xrf_task
-

src/pyxalign/gui/__init__.py

@@ -0,0 +1,21 @@
+from ..interactions.viewers.xrf import (
+    launch_xrf_projections_viewer,
+    launch_xrf_volume_viewer,
+)
+from ..interactions.viewers.arrays import launch_projection_viewer, launch_volume_viewer
+from ..interactions.viewers.base import launch_array_viewer
+from ..interactions.master import launch_master_gui
+from ..interactions.viewers.base import (
+    launch_linked_array_viewer,
+    launch_array_viewer,
+)
+
+__all__ = [
+    "launch_master_gui",
+    "launch_array_viewer",
+    "launch_volume_viewer",
+    "launch_linked_array_viewer",
+    "launch_projection_viewer",
+    "launch_xrf_projections_viewer",
+    "launch_xrf_volume_viewer",
+]

src/pyxalign/interactions/viewers/arrays.py

@@ -1,16 +1,16 @@
 from typing import Callable, Optional
 import cupy as cp
 from pyxalign.api.maps import get_process_func_by_enum
-from pyxalign.api.options.options import ExperimentOptions
+from pyxalign.api.options import ProjectionViewerOptions
 from pyxalign.api.options.plotting import ArrayViewerOptions, ProjectionViewerOptions
 from pyxalign.api.options_utils import get_all_attribute_names
 import pyxalign.data_structures.projections as p
 from pyxalign.gpu_utils import return_cpu_array
-from pyxalign.interactions.mask import ThresholdSelector
 from pyxalign.interactions.options.options_editor import BasicOptionsEditor
 from pyxalign.interactions.utils.loading_decorator import loading_bar_wrapper
 from pyxalign.interactions.viewers.base import ArrayViewer, IndexSelectorWidget, MultiThreadedWidget
 from PyQt5.QtWidgets import (
+    QApplication,
     QWidget,
     QVBoxLayout,
     QHBoxLayout,
@@ -117,6 +117,7 @@ def start(self):
 
 class ProjectionViewer(MultiThreadedWidget):
     """Widget for viewing projections"""
+
     masks_created = pyqtSignal(np.ndarray)
 
     def __init__(
@@ -653,7 +654,35 @@ def return_angle_string(angle):
 
     def return_scan_string(scan_number):
         return f"<span style='color:#9FEDB9'>Scan {scan_number}</span>"
+
     title_strings = [
         f"{whitespace}{return_scan_string(scan)}{whitespace}{return_angle_string(angle)}"
-        for scan, angle in zip(scan_numbers, angles)]
+        for scan, angle in zip(scan_numbers, angles)
+    ]
     return title_strings
+
+
+def launch_projection_viewer(
+    projections: "p.Projections",
+    options: Optional[ProjectionViewerOptions] = None,
+    display_only: bool = False,
+    wait_until_closed: bool = False,
+) -> ProjectionViewer:
+    app = QApplication.instance() or QApplication([])
+    gui = ProjectionViewer(projections, options, display_only=display_only)
+    gui.show()
+    if wait_until_closed:
+        app.exec_()
+    return gui
+
+
+def launch_volume_viewer(
+    array_3d: np.ndarray,
+    wait_until_closed: bool = False,
+) -> VolumeViewer:
+    app = QApplication.instance() or QApplication([])
+    gui = VolumeViewer(volume=array_3d)
+    gui.show()
+    if wait_until_closed:
+        app.exec_()
+    return gui

src/pyxalign/interactions/viewers/base.py

@@ -686,3 +686,49 @@ def stepBy(self, steps):
                 else:
                     cur = a[0]
         self.setValue(cur)
+
+
+def launch_array_viewer(
+    array3d: np.ndarray,
+    options: Optional[ArrayViewerOptions] = None,
+    sort_idx: Optional[Sequence] = None,
+    extra_title_strings_list: Optional[list[str]] = None,
+    process_func: Optional[Callable] = None,
+    wait_until_closed: bool = False,
+):
+    app = QApplication.instance() or QApplication([])
+    gui = ArrayViewer(
+        array3d,
+        options,
+        sort_idx,
+        extra_title_strings_list=extra_title_strings_list,
+        process_func=process_func,
+    )
+    gui.setAttribute(Qt.WA_DeleteOnClose)
+    gui.show()
+    if wait_until_closed:
+        app.exec_()
+    return gui
+
+
+def launch_linked_array_viewer(
+    array_list: list[np.ndarray],
+    options: Optional[ArrayViewerOptions] = None,
+    sort_idx: Optional[Sequence] = None,
+    extra_title_strings_list: Optional[list[str]] = None,
+    process_func: Optional[Callable] = None,
+    wait_until_closed: bool = False,
+):
+    app = QApplication.instance() or QApplication([])
+    gui = LinkedArrayViewer(
+        array_list,
+        options,
+        sort_idx,
+        extra_title_strings_list=extra_title_strings_list,
+        process_func=process_func,
+    )
+    gui.setAttribute(Qt.WA_DeleteOnClose)
+    gui.show()
+    if wait_until_closed:
+        app.exec_()
+    return gui