cgse 2024.7.0__py3-none-any.whl → 2025.0.1__py3-none-any.whl

egse/fov/fov_ui_controller.py

@@ -1,140 +0,0 @@
-"""
-This module provides the Controller (C) in the MVC pattern that makes up the FOV GUI application.
-"""
-
-import logging
-
-from PyQt5.QtCore import QTimer
-
-from egse.observer import Observer
-from egse.settings import Settings
-
-STAGES_SETTINGS = Settings.load("Huber Controller")
-
-MODULE_LOGGER = logging.getLogger(__name__)
-
-
-class FOVUIController(Observer):
-
-    def __init__(self, model, view):
-
-        """ Initialisation of the Controller in the MVC pattern that makes up the FOV GUI application.
-
-        :param model: Model in the MVC pattern that makes up the FOV GUI application.
-
-        :param view: View in the MVC pattern that makes up the FOV GUI application.
-        """
-
-        # MVC + Observer pattern
-
-        self.model = model
-        self.view = view
-        self.view.addObserver(self)
-
-        self.create_timer()
-
-        # Hexapod connected?
-
-        if self.model.is_connected_hexapod():
-
-            self.view.set_connection_state_hexapod("connected")
-            self.hexapod_connected = True
-
-        else:
-
-            self.view.set_connection_state_hexapod("disconnected")
-            self.stop_timer()
-            self.hexapod_connected = False
-
-        # Stages connected?
-
-        if self.model.is_connected_stages():
-
-            self.view.set_connection_state_stages("connected")
-            self.stages_connected = True
-
-        else:
-
-            self.view.set_connection_state_stages("disconnected")
-            self.stop_timer()
-            self.stages_connected = False
-
-        # Hexapod ánd Stages connected
-
-        if self.model.is_connected_hexapod() and self.model.is_connected_stages():
-
-            self.start_timer()
-
-    def create_timer(self):
-        """ Create a timer that will update the states every second."""
-
-        self.states_capture_timer = QTimer()
-
-        # This is only needed when the Timer needs to run in another Thread
-        # self.states_capture_timer.moveToThread(self)
-
-        self.states_capture_timer.timeout.connect(self.update_values)
-        self.states_capture_timer.setInterval(200)
-
-    def start_timer(self):
-        """ Start timer."""
-
-        self.states_capture_timer.start()
-
-    def stop_timer(self):
-        """ Stop timer."""
-
-        self.states_capture_timer.stop()
-
-    def update_values(self):
-        """ Update the position of the mechanisms and the source.
-
-        Fetch the position of the mechanisms from the model and update the GUI: the positions of the mechanisms need to
-        be updated, as well as the position of the source on the FOV.  The position of a mechanism can only be fetched
-        (and updated in the GUI) if there's a connection with the control server.
-
-        .. todo:: We need to know the focus position and not the position of the hexapod w.r.t.
-                  the homing position.
-        """
-
-        if not self.model.is_connected_hexapod():
-
-            MODULE_LOGGER.debug("Not connected to the hexapod control server")
-            self.view.set_connection_state_hexapod("disconnected")
-
-        elif not self.model.is_connected_stages():
-
-            MODULE_LOGGER.debug("Not connected to the stages control server")
-            self.view.set_connection_state_stages("disconnected")
-
-        else:
-
-            self.view.set_connection_state_hexapod("connected")
-            self.view.set_connection_state_stages("connected")
-
-            # Update position of the mechanisms
-            #   - SMA: distance from the optical axis + orientation of the scan mirror
-            #   - big rotation stage -> orientation
-            #   - hexapod -> focus position
-
-            self.view.update_sma(self.model.get_distance_translation_stage(),
-                                 self.model.get_rotation_angle_small_rotation_stage())
-            self.view.update_big_rotation_stage(self.model.get_rotation_angle_big_rotation_stage())
-            self.view.update_focus_position(self.model.get_focus_position())
-
-            # Focal-plane coordinates (x,y) [mm]
-
-            position = self.model.get_position()
-            self.view.update_source_position(position)
-
-        return
-
-    def update(self, changed_object):
-
-        return
-
-    def do(self, actions):
-
-        for action, value in actions.items():
-            MODULE_LOGGER.debug(f"do {action} with {value}")
-            print(f"do {action} with {value}")

egse/fov/fov_ui_model.py

@@ -1,200 +0,0 @@
-"""
-This module provides the Model (M) in the MVC pattern of the FOV GUI application.
-"""
-
-import logging
-from math import cos
-from math import radians
-from math import sin
-from math import tan
-
-from egse.coordinates import focal_plane_to_ccd_coordinates
-from egse.coordinates import undistorted_to_distorted_focal_plane_coordinates
-from egse.hexapod.symetrie.puna_ui import PunaUIModel
-from egse.settings import Settings
-from egse.setup import load_setup
-from egse.stages.huber.smc9300_ui import HuberUIModel
-
-STAGES_SETTINGS = Settings.load("Huber Controller")
-FOV_SETTINGS = Settings.load("Field-Of-View")
-
-MODULE_LOGGER = logging.getLogger(__name__)
-
-
-class FOVUIModel:
-
-    def __init__(self, type_hexapod, type_stages):
-        """ Initialisation of models for the Hexapod and the Stages.
-
-        :param type_hexapod: Hexapod implementation to use.  Choices are between:
-                             proxy, simulator, and hexapod.
-
-        :param type_stages: Stages implementation to use.  Choices are between:
-                            proxy, simulator, and huber.
-        """
-
-        self.hexapod_model = PunaUIModel(type_hexapod)
-        self.stages_model = HuberUIModel(type_stages)
-        self.setup = load_setup()
-
-    ##############
-    # Connectivity
-    ##############
-
-    def is_connected_hexapod(self):
-        """ Checks whether there's a connection with the hexapod.
-
-        :return: True if there's a connection with the hexapod, False otherwise.
-        """
-
-        return self.hexapod_model.is_device_connected()
-
-    def is_connected_stages(self):
-        """ Checks whether there's a connection with the stages.
-
-        :return: True if there's a connection with the stages, False otherwise.
-        """
-
-        return self.stages_model.is_device_connected()
-
-    def reconnect_hexapod(self):
-        """ Reconnects to the hexapod."""
-
-        self.hexapod_model.reconnect()
-
-    def reconnect_stages(self):
-        """ Reconnects to the stages."""
-
-        self.stages_model.reconnect()
-
-    ###########################################
-    # Position of the source on the focal plane
-    ###########################################
-
-    def get_position(self):
-        """ Calculates the coordinate of the source.
-
-        Calculates the coordinate of the source, given the position of the associated hexapod and stages, and taking
-        the field distortion into account.
-
-        :return: Dictionary with the following entries:
-                    - "angles": gnomonic distance from the optical axis and in-field angle [degrees]
-                    - "pixels": CCD coordinates (row, column) [pixels] and the corresponding CCD code
-                    - "mm": focal-plane coordinates (x, y) [mm]
-        """
-
-        offset_phi = self.setup.gse.stages.calibration.offset_phi
-        offset_alpha = self.setup.gse.stages.calibration.offset_alpha
-        alpha_correction_coefficients = self.setup.gse.stages.calibration.alpha_correction_coefficients
-
-        # Focal-plane coordinates [mm]
-
-        (x, y) = self.get_focal_plane_position()
-
-        # CCD coordinates [pixels]
-
-        (row, column, ccd_code) = focal_plane_to_ccd_coordinates(x, y, setup)
-
-        # Gnomonic distance to optical axis and in-field angle [degrees]
-
-        angle_small_rotation_stage = self.get_rotation_angle_small_rotation_stage()
-        theta = (angle_small_rotation_stage + offset_alpha - alpha_correction_coefficients[0]) \
-                / alpha_correction_coefficients[1]
-
-        position = {
-            "angles": (theta, offset_phi - self.get_rotation_angle_big_rotation_stage()),
-            "pixels": (row, column, ccd_code),
-            "mm": (x, y)
-        }
-
-        return position
-
-    def get_focal_plane_position(self):
-
-        """
-        Calculates and returns the focal-plane coordinates (x, y) [mm] of the source, given the
-        position of the associated hexapod and stages, and taking the field distortion into account.
-
-        :return: Focal-plane coordinates (x, y) [mm] of the source, given the position of the
-                 associated hexapod and stages, and taking the field distortion into account.
-
-        .. todo:: Check whether the light beam goes through the entrance pupil
-                  distance_sma / FOV_SETTINGS.HEIGHT_COLLIMATED_BEAM != math.tan(math.radians(angle_small_rotation_stage))
-        """
-
-        # Rotation angle of the big rotation stage [degrees]
-        # - counterclockwise rotation
-        # - 0° -> axis of the focal plane aligned with GL_FIX
-
-        angle_big_rotation_stage = self.get_rotation_angle_big_rotation_stage()
-
-        # Rotation angle of the small rotation stage [degrees]
-        # - clockwise rotation
-        # - 0° -> ?
-
-        angle_small_rotation_stage = self.get_rotation_angle_small_rotation_stage()
-
-        # Radial distance without field distortion [mm] and corresponding focal-plane coordinates [mm]
-        # Note that the height of the lower triangle is very close to the focal length
-
-        theta = 2 * angle_small_rotation_stage # [degrees]
-
-        radial_distance_undistorted = FOV_SETTINGS.FOCAL_LENGTH * tan(radians(theta))
-
-        x_undistorted = -radial_distance_undistorted * cos(-radians(angle_big_rotation_stage))
-        y_undistorted = -radial_distance_undistorted * sin(-radians(angle_big_rotation_stage))
-
-        x_distorted, y_distorted = \
-            undistorted_to_distorted_focal_plane_coordinates(x_undistorted, y_undistorted,
-                                                             FOV_SETTINGS.DISTORTION_COEFFICIENTS,
-                                                             FOV_SETTINGS.FOCAL_LENGTH)
-
-        return x_distorted, y_distorted
-
-    def get_focus_position(self):
-        """ Returns the focus position (z) [mm]. This is the distance between L6S2 and FPA_SEN.
-
-        :return: Focus position (z) [mm].
-        """
-
-        # Distance between FPA_SEN and L6S2 [mm]
-
-        return -self.hexapod_model.get_user_positions()[2]
-
-    def get_rotation_angle_big_rotation_stage(self):
-        """ Returns the rotation angle of the big rotation stage [degrees].
-
-        A positive angle corresponds to counterclockwise rotation.
-
-        :return: Rotation angle of the big rotation stage [degrees].
-
-        .. todo:: Where is angle = 0°?
-        """
-
-        # Counterclockwise rotation [degrees]
-
-        return self.stages_model.get_current_position(STAGES_SETTINGS.BIG_ROTATION_STAGE)
-
-    def get_rotation_angle_small_rotation_stage(self):
-        """ Returns the rotation angle of the small rotation stage [degrees].
-
-        :return: Rotation angle of the small rotation stage [degrees].
-
-        .. todo:: Where is angle = 0°?
-        """
-
-        # Counterclockwise rotation [degrees]
-
-        return self.stages_model.get_current_position(STAGES_SETTINGS.SMALL_ROTATION_STAGE)
-
-    def get_distance_translation_stage(self):
-        """ Returns the distance between the centre of the scan mirror and the optical axis [mm].
-
-        :return: Distance between the centre of the scan mirror and the optical axis [mm]
-
-        .. todo:: Properly define the zero position.
-        """
-
-        # Distance between the optical axis and the SMA [mm]
-
-        return self.stages_model.get_current_position(STAGES_SETTINGS.TRANSLATION_STAGE)

egse/fov/fov_ui_view.py

@@ -1,345 +0,0 @@
-"""
-This module provides the View (V) in the MVC pattern of the FOV GUI application.
-"""
-
-import logging
-
-from PyQt5.QtGui import QFont
-from PyQt5.QtGui import QPixmap
-from PyQt5.QtWidgets import QFrame
-from PyQt5.QtWidgets import QGridLayout
-from PyQt5.QtWidgets import QHBoxLayout
-from PyQt5.QtWidgets import QLabel
-from PyQt5.QtWidgets import QMainWindow
-from PyQt5.QtWidgets import QVBoxLayout
-
-from egse.config import find_file
-from egse.config import set_logger_levels
-from egse.gui.focalplane import FocalPlaneWidgetWithSourcePosition
-from egse.gui.mechanisms import BigRotationStageWidget
-from egse.gui.mechanisms import FocusPositionWidget
-from egse.gui.mechanisms import ScanMirrorAssemblyWidget
-from egse.observer import Observable
-from egse.settings import Settings
-from egse.state import UnknownStateError
-
-FOV_SETTINGS = Settings.load("Field-Of-View")
-
-logging.basicConfig(level=logging.DEBUG, format=Settings.LOG_FORMAT_FULL)
-MODULE_LOGGER = logging.getLogger(__name__)
-
-# Restrict the logging output for the following loggers.
-
-# Note that, in production, the logging level for the different loggers can be changed with a
-# service command `set_logging_level(logger_name, level)`.
-
-logger_levels = [
-    ("matplotlib", logging.WARNING),
-    ("egse.config", logging.WARNING),
-]
-
-set_logger_levels(logger_levels)
-
-
-FONT = QFont("Helvetica", 18)
-
-COORDINATE_SYSTEMS = {
-    "Focal plane": "Focal-plane coordinates [mm]",
-    "Pixels": "Pixel coordinates",
-    "Angles": "Angles"
-}
-
-
-class FOVUIView(QMainWindow, Observable):
-
-    def __init__(self):
-
-        """
-        Open a window and initialiase the GUI.  The GUI is divided into two parts.  On the
-        left there are three widgets, showing the current setting of the stages and the focus
-        position.  On the right the focal plane is shown, together with a blue circle indicating
-        the size of the field-of-view, and a red dot indicating the current position of the source.
-        """
-
-        super().__init__()
-
-        self.setGeometry(300, 300, 1500, 1000)
-        self.setWindowTitle("FOV Position GUI")
-
-        self.init_ui()
-
-    def init_ui(self):
-        """ Initialisation of the GUI.
-
-        The GUI is divided into two parts.  On the left there are three widgets, showing the current setting of the
-        stages and the focus position. On the right the focal plane is shown, together with a blue circle indicating the
-        size of the field-of-view, and a red dot indicating the current position of the source.
-        """
-
-        app_frame = QFrame()
-        app_frame.setObjectName("AppFrame")
-
-        # Toolbar
-
-        self.create_toolbar()
-
-        hbox = QHBoxLayout()
-
-        # Mechanisms
-
-        mechanisms_frame = QFrame()
-        mechanisms_frame.setObjectName("Mechanisms")
-
-        vbox_left = QGridLayout()
-        vbox_left.addWidget(self.create_sma_widget())
-        vbox_left.addWidget(self.create_big_rotation_stage_widget())
-        vbox_left.addWidget(self.create_focus_position_widget())
-
-        mechanisms_frame.setLayout(vbox_left)
-
-        # FOV
-
-        fpa_frame = QFrame()
-        fpa_frame.setObjectName("FOV")
-
-        vbox_right = QVBoxLayout()
-        vbox_right.addWidget(self.create_focal_plane_widget())
-
-        # Current source position
-
-        self.source_position_text = QLabel()        # "Current source position"
-        self.source_position_text.setFont(FONT)
-        vbox_right.addWidget(self.source_position_text)
-
-        self.source_position_angles_text = QLabel()        # (theta, phi)
-        self.source_position_angles_text.setIndent(50)
-        self.source_position_angles_text.setFont(FONT)
-        self.source_position_angles_text.setToolTip(
-            "Gnomonic distance to the optical axis " + u"\u03B8" + " = 90" + u"\u00B0" + " - 2" + u"\u03B1" +
-            " and in-field angle " + u"\u03C6")
-        vbox_right.addWidget(self.source_position_angles_text)
-
-        self.source_position_pixels_text = QLabel()        # (row, column)
-        self.source_position_pixels_text.setIndent(50)
-        self.source_position_pixels_text.setFont(FONT)
-        self.source_position_pixels_text.setToolTip(
-            "Pixel coordinates on specified CCD")
-        vbox_right.addWidget(self.source_position_pixels_text)
-
-        self.source_position_mm_text = QLabel()            # (xFP, yFP)
-        self.source_position_mm_text.setIndent(50)
-        self.source_position_mm_text.setFont(FONT)
-        self.source_position_mm_text.setToolTip("Focal-plane coordinates")
-        vbox_right.addWidget(self.source_position_mm_text)
-
-        fpa_frame.setLayout(vbox_right)
-
-        # Putting everything in place
-
-        hbox.addWidget(mechanisms_frame)
-        hbox.addWidget(fpa_frame)
-
-        app_frame.setLayout(hbox)
-
-        self.setCentralWidget(app_frame)
-
-    #########
-    # Toolbar
-    #########
-
-    def create_toolbar(self):
-        """ Create toolbar.
-
-        Two buttons are foreseen: one for reconnect with the hexapod and one to the stages.
-        """
-
-        self.connected_pix = QPixmap(
-            str(find_file("connected-100.png", in_dir="images"))).scaledToHeight(30, 1)
-        self.disconnected_pix = QPixmap(
-            str(find_file("disconnected-100.png", in_dir="images"))).scaledToHeight(30, 1)
-
-        self.reconnect_icon_hexapod = QLabel()
-        self.reconnect_icon_hexapod.setPixmap(self.connected_pix)
-
-        self.reconnect_icon_stages = QLabel()
-        self.reconnect_icon_stages.setPixmap(self.connected_pix)
-
-        # Putting everything in place
-
-        self.toolbar = self.addToolBar('MainToolbar')
-
-        hexapod_label = QLabel("Hexapod")
-        hexapod_label.setFont(FONT)
-        self.toolbar.addWidget(hexapod_label)
-        self.reconnect_icon_hexapod.setToolTip(
-            "Connection status of the hexapod")
-        self.toolbar.addWidget(self.reconnect_icon_hexapod)
-        self.toolbar.addSeparator()
-
-        stages_label = QLabel("Stages")
-        stages_label.setFont(FONT)
-        self.toolbar.addWidget(stages_label)
-        self.reconnect_icon_stages.setToolTip(
-            "Connection status of the stages")
-        self.toolbar.addWidget(self.reconnect_icon_stages)
-        self.toolbar.addSeparator()
-
-        return self.toolbar
-
-    #########
-    # Widgets
-    #########
-
-    def create_sma_widget(self):
-        """ Create widget showing the setting of the scan mirror assembly."""
-
-        self.sma = ScanMirrorAssemblyWidget()
-        return self.sma
-
-    def create_big_rotation_stage_widget(self):
-        """ Create widget showing the setting of the big rotation stage."""
-
-        self.big_rotation_stage = BigRotationStageWidget()
-        return self.big_rotation_stage
-
-    def create_focus_position_widget(self):
-        """ Create widget showing the focus position."""
-
-        self.focus_position = FocusPositionWidget()
-        return self.focus_position
-
-    def create_focal_plane_widget(self):
-        """ Create widget showing the position of the source in the focal plane."""
-
-        self.focal_plane = FocalPlaneWidgetWithSourcePosition()
-        return self.focal_plane
-
-    ##########
-    # Updating
-    ##########
-
-    def update_sma(self, distance, angle):
-        """ Update the shown configuration of the scan mirror assembly.
-
-        The orientation of the scan mirror must be changed, and the labels showing the distance from the scan
-        mirror to the optical axis (along the translation stage) and the orientation angle of the scan mirror must be
-        updated.
-
-        :param distance: Distance between the scan mirror and the optical axis (along the translation stage) for the new
-                         configuration of the scan mirror assembly [mm].
-
-        :param angle: Orientation angle of the scan mirror [degrees].
-        """
-
-        self.sma.update_plot(distance, angle)
-
-    def update_big_rotation_stage(self, angle):
-        """ Update the shown configuration of the big rotation stage.
-
-        The orientation of GL_ROT w.r.t. GL_FIX must be set to the given angle.
-
-        :param angle: Rotation angle for the new configuration of the big rotation stage [degrees].
-        """
-
-        self.big_rotation_stage.update(angle)
-
-    def update_focus_position(self, focus_position):
-        """ Update the shown focus position.
-
-        :param focus_position: New focus position [mm].
-        """
-
-        self.focus_position.update_plot(focus_position)
-
-    def update_source_position(self, position):
-
-        """ Update the position of the source in the focal plane to the given postion (x, y).
-
-        The red dot must move on the focal plane (movement may not be visible) and the text label with the focal-plane
-        coordinates must be updated.
-
-        :param position: Dictionary with the following entries:
-
-            - "angles": tuple with the field angles (theta, phi) [degrees];
-            - "pixels": tuple with the pixel coordinates (row, column) [pixels] and CCD code;
-            - "mm": tuple with the focal-plane coordinates (x, y) [mm].
-        """
-
-        (theta, phi) = position["angles"]
-        (row, column, ccd_code) = position["pixels"]
-        (x_fp, y_fp) = position["mm"]
-
-        # Update the red dot in the plot
-
-        self.focal_plane.update_source_position(x_fp, y_fp)
-
-        # Update the text label
-
-        if abs(x_fp) > FOV_SETTINGS.RADIUS_MM or abs(y_fp) > FOV_SETTINGS.RADIUS_MM:
-
-            MODULE_LOGGER.debug("Current source position: outside FOV")
-            self.source_position_text.setText(
-                "Current source position: outside FOV")
-            self.source_position_angles_text.setText("")
-            self.source_position_pixels_text.setText("")
-            self.source_position_mm_text.setText("")
-
-        else:
-
-            self.source_position_text.setText("Current source position:")
-            self.source_position_angles_text.setText(
-                u"\u2022" + "(" + u"\u03B8" + ", " + u"\u03C6" + ") [" + u"\u00B0" + "] = ({:.2f}, {:.2f})".format(theta, phi))
-
-            if ccd_code is None:
-
-                self.source_position_pixels_text.setText(
-                    u"\u2022" + " source doesn't fall on any CCD")
-
-            else:
-
-                self.source_position_pixels_text.setText(
-                    u"\u2022" + "(x<sub>CCD</sub>, y<sub>CCD</sub>) [pixels] = ({:.2f}, {:.2f}) on CCD ".format(column, row) + str(ccd_code))
-
-            self.source_position_mm_text.setText(
-                u"\u2022" + "(x<sub>FP</sub>, y<sub>FP</sub>) [mm] = ({:.2f}, {:.2f})".format(x_fp, y_fp))
-
-    ##############
-    # Connectivity
-    ##############
-
-    def set_connection_state_hexapod(self, state):
-        """ Sets the connection state for the Symétrie Hexapod.
-
-        :param state: Connectivity state to use for the Symétrie Hexapod.
-        """
-
-        if state == "connected":
-
-            self.reconnect_icon_hexapod.setPixmap(self.connected_pix)
-
-        elif state == "disconnected":
-
-            self.reconnect_icon_hexapod.setPixmap(self.disconnected_pix)
-
-        else:
-
-            raise UnknownStateError(
-                f"Unknown State ({state}) for the hexapod, expected 'connected' or 'disconnected'.")
-
-    def set_connection_state_stages(self, state):
-        """ Sets the connection state for the Huber stages.
-
-        :param state: Connectivity state to use for the Huber stages.
-        """
-
-        if state == "connected":
-
-            self.reconnect_icon_stages.setPixmap(self.connected_pix)
-
-        elif state == "disconnected":
-
-            self.reconnect_icon_stages.setPixmap(self.disconnected_pix)
-
-        else:
-
-            raise UnknownStateError(f"Unknown State ({state}) for the stages, expected 'connected' or 'disconnected'.")