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

egse/visitedpositions.py

@@ -1,398 +0,0 @@
-"""
-This module provides a GUI to show the visited positions (i.e. the positions at which 
-the source was put during testing) on the focal plane.
-
-To start the GUI, start (i)python and type the following commands:
-
-    $ from egse import visitedpositions
-    $ view = visitedpositions.start_visited_positions_gui()
-
-Then you can add the visited locations as follows:
-
-    * in focal-plane coordinates (x_fp, y_fp) [mm]:
-        $ view.visit_focal_plane_position(x_fp, y_fp)
-
-    * in CCD coordinates (row, column) [pixel] on a given CCD:
-        $ view.visit_ccd_position(row, column, ccd_code)
-
-    * in field angles (theta, phi) [degrees]:
-        $ view.visit_field_angles(theta, phi)
-
-At each of these locations, a red dot will appear on the plot.  You can 
-switch between coordinate system (used in the plot) with the combobox
-below the plot window (focal-plane coordinates, pixel coordinates, and
-field angles).
-"""
-import pickle
-import threading
-from pathlib import Path
-
-import sys
-import zmq
-from PyQt5.QtCore import QLockFile
-from PyQt5.QtGui import (QFont, QIcon)
-from PyQt5.QtWidgets import (QApplication, QMainWindow, QFrame, QVBoxLayout, QStatusBar, QMessageBox)
-
-from egse.coordinates import ccd_to_focal_plane_coordinates, angles_to_focal_plane_coordinates, \
-    focal_plane_coordinates_to_angles
-from egse.gui.buttons import ToolTouchButton
-from egse.gui.focalplane import FocalPlaneWidgetWithVisitedPositions
-from egse.resource import get_resource
-from egse.settings import Settings
-from egse.zmq_ser import bind_address, connect_address
-
-FONT = QFont("Helvetica", 18)
-
-SETTINGS = Settings.load("Visited Positions UI")
-
-
-class VisitedPositionsUIController:
-
-    def __init__(self, view):
-        """ Create a controller for the visited-positions GUI.
-
-        Args:
-            - view: Visited-positions GUI.
-        """
-
-        super(VisitedPositionsUIController, self).__init__()
-
-        self.view = view
-
-        thread = threading.Thread(target=self.listen)
-        thread.daemon = True
-        thread.start()
-
-    def listen(self):
-        """ Listen on the PULL socket for visited positions.
-
-        If a visited position is received over the PULL socket, a red dot is placed at that position in the GUI.
-        """
-
-        context = zmq.Context.instance()
-        socket = context.socket(zmq.PULL)
-
-        socket.bind(self.get_bind_address)
-
-        while True:
-
-            pickle_string = socket.recv()
-            data = pickle.loads(pickle_string)
-
-            if isinstance(data, dict):
-
-                if "theta" in data and "phi" in data:
-                    self.visit_field_angles(data)
-
-            elif data == "clear":
-                self.clear()
-
-    def visit_field_angles(self, data):
-        """ Add a red dot at the given position on the focal-plane plot.
-
-        Args:
-            - data: Dictionary with the following entries:
-                - theta: Gnomonic distance to the optical axis [degrees]
-                - phi: In-field angle [degrees]
-        """
-
-        theta = data["theta"]
-        phi = data["phi"]
-
-        self.view.visit_field_angles(theta, phi)
-
-    def clear(self):
-        """ Clear all visited positions from the focal-plane plot."""
-
-        self.view.clear_visited_positions()
-
-    @property
-    def get_bind_address(self):
-        """ Returns bind address for the PULL socket.
-
-        Returns: Bind address for the PULL socket.
-        """
-
-        return bind_address(SETTINGS.PROTOCOL, SETTINGS.PORT,)
-
-
-class VisitedPositionsUIView(QMainWindow):
-
-    def __init__(self):
-        """ Open a window and initialise the GUI.
-
-        The focal plane is shown, together with a blue circle indicating the size of the field-of-view, and a red dots
-        indicating the positions that were visited so far.  Below this plot, you can find a combobox to switch between
-        coordinate systems (focal-plane coordinates, pixel coordinates, and field angles).
-        """
-
-        super().__init__()
-
-        self.setGeometry(300, 300, 1500, 1000)
-        self.setWindowTitle("Visited-Positions GUI")
-
-        self.init_ui()
-
-        self.thread = None
-
-        self.num_points = 0
-
-    def init_ui(self):
-        """ Initialisation of the GUI.
-
-        The focal plane is shown, together with a blue circle indicating
-        the size of the field-of-view, and a red dots indicating the positions that were visited so far.
-        Below this plot, you can find a combobox to switch between coordinate systems (focal-plane coordinates,
-        pixel coordinates, and field angles).
-        """
-
-        app_frame = QFrame()
-        app_frame.setObjectName("AppFrame")
-
-        # Statusbar
-
-        self.setStatusBar(QStatusBar(self))
-        self.status = self.statusBar()
-
-        # Toolbar
-
-        self.create_toolbar()
-
-        # Central widget
-
-        vbox_right = QVBoxLayout()
-
-        vbox_right.addWidget(self.create_focal_plane_widget())
-
-        app_frame.setLayout(vbox_right)
-
-        self.setCentralWidget(app_frame)
-
-    #########
-    # Toolbar
-    #########
-
-    def create_toolbar(self):
-        """ Create toolbar.
-
-        Currently doesn't do anything.
-        """
-        self.clear_button = ToolTouchButton(
-            name="clear_visited_positions",
-            width=25, height=25,
-            status_tip="Clear the visited positions",
-            selected=get_resource(":/icons/sponge.svg"),
-        )
-        self.clear_button.clicked.connect(self.clear_visited_positions)
-
-        # image_location = os.environ["PLATO_COMMON_EGSE_PATH"] + \
-        #     "/src/egse/images/"
-
-        # self.undo_pix = QPixmap(
-        #     image_location + "undo.png").scaledToHeight(30, 1)
-        #
-        # self.undo_icon = QLabel()
-        # self.undo_icon.setPixmap(self.undo_pix)
-        #
-        # # TODO Assign action to this button
-        #
-        # # Putting everything in place
-        #
-        self.toolbar = self.addToolBar('MainToolbar')
-        self.toolbar.addWidget(self.clear_button)
-
-        return self.toolbar
-
-    ####################
-    # Focal-plane widget
-    ####################
-
-    def create_focal_plane_widget(self):
-        """ Create widget showing the position of the source in the focal plane.
-        """
-
-        self.focal_plane = FocalPlaneWidgetWithVisitedPositions()
-        return self.focal_plane
-
-    ###################
-    # Visit position(s)
-    ###################
-
-    def visit_field_angles(self, theta, phi):
-        """ Add a red dot at the given position on the focal-plane plot.
-
-        Args:
-            - theta: Angular distance from the optical axis [degrees].
-            - phi: In-field angle [degrees].
-        """
-
-        # Conversion from field angles to focal-plane coordinates
-
-        x_fp, y_fp = angles_to_focal_plane_coordinates(theta, phi)
-
-        self.visit_focal_plane_position(x_fp, y_fp)
-
-    def visit_focal_plane_position(self, x_fp, y_fp):
-        """ Add a red dot at the given position on the focal-plan plot.
-
-        Args:
-            - x_fp: Focal-plane x-coordinate [mm].
-            - y_fp: Focal-plane y-coordinate [mm].
-        """
-
-        self.focal_plane.visit_position(x_fp, y_fp)
-
-        self.num_points += 1
-
-    def visit_ccd_position(self, row, column, ccd_code):
-        """ Add a red dot at the given position on the focal-plane plot.
-
-        Args:
-            - row: Row coordinate [pixels].
-            - column: Column coordinate [pixels].
-            - ccd_code: Code of the CCD [1, 2, 3, 4].
-        """
-
-        # Conversion from CCD coordinates to focal-plane coordinates
-
-        x_fp, y_fp = ccd_to_focal_plane_coordinates(row, column, ccd_code)
-        
-        self.visit_focal_plane_position(x_fp, y_fp)
-
-    ##########
-    # Clearing
-    ##########
-
-    def clear_visited_positions(self):
-        """ Clear all visited positions."""
-
-        self.focal_plane.clear_visited_positions()
-
-###########
-# Start GUI
-###########
-
-
-def start_visited_positions_gui():
-    """ Start the GUI showing the focal plane with the visited positions.
-    You can add extra visited locations as follows (assuming "view" is the name of the GUI instance)
-
-        * in focal-plane coordinates (x_fp, y_fp) [mm]:
-            $ view.visit_focal_plane_position(x_fp, y_fp)
-
-        * in pixel coordinates (row, column) [pixel] on a given CCD:
-            $ view.visit_ccd_position(row, column, ccd_code)
-
-        * in field angles (theta, phi) [degrees]:
-            $ view.visit_field_angles(theta, phi)
-    """
-
-    app = QApplication([])
-
-    view = VisitedPositionsUIView()
-
-    view.show()
-
-    return view
-
-
-def _send_data(data):
-    """ Send the given data to the visited-positions UI.
-
-    Args:
-        - data: Data to send to the visited-positions UI.
-    """
-
-    context = zmq.Context.instance()
-    socket = context.socket(zmq.PUSH)
-
-    protocol = SETTINGS.PROTOCOL
-    hostname = SETTINGS.HOSTNAME
-    port = SETTINGS.PORT
-
-    socket.connect(connect_address(protocol, hostname, port))
-
-    pickle_string = pickle.dumps(data)
-
-    socket.send(pickle_string)
-    socket.close()
-
-
-def clear_visited_positions():
-    """ Clear the visited positions from the visited-positions UI."""
-
-    data = "clear"
-    _send_data(data)
-
-
-def visit_field_angles(theta, phi):
-    """ Show the given position in the visited-positions GUI.
-
-    Args:
-        - theta: Angular distance from the optical axis [degrees].
-        - phi: Angle from the x-axis of the focal plane (i.e. in-field angle) [degrees].
-    """
-
-    data = {"theta": theta, "phi": phi}
-    _send_data(data)
-
-
-def visit_focal_plane_position(x_fp, y_fp):
-    """ Show the given position in the visited-positions GUI.
-
-    Args:
-        - x_fp: Focal-plane x-coordinate [mm].
-        - y_fp: Focal-plan y-coordinate [mm].
-    """
-
-    # Convert to field angles
-
-    theta, phi = focal_plane_coordinates_to_angles(x_fp, y_fp)
-    visit_field_angles(theta, phi)
-
-
-def visit_ccd_position(row, column, ccd_code):
-    """ Show the given position in the visited positions GUI.
-
-    Args:
-        - row: Row coordinate [pixels].
-        - column: Column coordinate [pixels].
-        - ccd_code: Code of the CCD for which the pixel coordinates are given.
-    """
-
-    # Convert to focal-plane coordinates
-
-    x_fp, y_fp = ccd_to_focal_plane_coordinates(row, column, ccd_code)
-    visit_focal_plane_position(x_fp, y_fp)
-
-
-def main():
-    """ Main method to launch the Process Manager GUI."""
-
-    lock_file = QLockFile(str(Path("~/visited_positions_ui.app.lock").expanduser()))
-
-    app = QApplication(sys.argv)
-    app.setWindowIcon(QIcon(str(get_resource(":/icons/radar.svg"))))
-
-    if lock_file.tryLock(100):
-        # Check whether the Process Manager CS is running
-        # (show a warning in a pop-up window if it's not)
-
-        view = VisitedPositionsUIView()
-        controller = VisitedPositionsUIController(view)
-
-        view.show()
-
-        return app.exec_()
-    else:
-        error_message = QMessageBox()
-        error_message.setIcon(QMessageBox.Warning)
-        error_message.setWindowTitle("Error")
-        error_message.setText("The Visited-Positions GUI application is already running!")
-        error_message.setStandardButtons(QMessageBox.Ok)
-
-        return error_message.exec()
-
-
-if __name__ == '__main__':
-    sys.exit(main())

egse/windowing.py

@@ -1,213 +0,0 @@
-"""
-This module provides functions and classes to extract and mosaic windows from a CCD image.
-
-Windowing is used to define areas in the CCD images that need to be down-linked as imagettes.
-The F-FEE and the N-FEE will use windowing to minimize the size of data packets sent to the
-F-DPU and N-DPU. A `WindowList` is used by the FEE and DPU to extract these imagettes from
-the full CCD image and to re-generate the CCD image from the individual imagettes.
-"""
-import logging
-from operator import itemgetter
-
-import numpy as np
-
-from egse.settings import Settings
-
-logger = logging.getLogger(__name__)
-
-win_settings = Settings.load("Windowing")
-
-
-class WindowSizeError(Exception):
-    """Raised when the requested window sizes are out-of-bounds."""
-    pass
-
-
-class CCDIndexError(KeyError):
-    """Raised when the CCD index is out-of-bounds."""
-    pass
-
-
-def extract_window_data(ccd_image: np.array, x_coord: int, y_coord: int, x_size: int, y_size: int, ccd_side: int) -> np.array:
-    """
-    Extract the window data from the given image.
-
-    Right and left side of the CCD have separate coordinate systems. The origin of both
-    coordinate systems is the first pixel read from the CCD. See FEE-DPU-IF-900 in the DPU-FEE
-    interface document (PLATO-DLR-PL-IC-002).
-
-    Parameters:
-
-    * **ccd_image**: ndarray - a two-dimensional array that contains the full image
-    * **x_coord**: int - x-coordinate for the requested window
-    * **y_coord**: int - y-coordinate for the requested window
-    * **x_size**: int - x-size of the requested window
-    * **y_size**: int - y-size of the requested window
-    * **ccd_side**: int - the CCD side (0 is left, 1 is right)
-
-    Returns: two-dimensional imagette (small window extracted from the full image)
-    """
-
-    # TODO
-    #   - What is the full image? Are the scan maps stripped off?
-    #   - The origin of the coordinate frame used to define the window is located in the serial pre-scan (not on the
-    #     CCD) and starts from the first row in the image area (which is not necessarily the same as v_start)
-
-    logger.debug("ccd size x, y = {}, {}".format(ccd_image.shape[0], ccd_image.shape[1]))
-    logger.debug("x_size, y_size: {}, {}".format(x_size, y_size))
-    logger.debug("x_coord, y_coord, ccd_side: {}, {}, {}".format(x_coord, y_coord, ccd_side))
-
-    if ccd_side == win_settings.CCD_SIDE_LEFT:
-        x1 = x_coord
-        x2 = x_coord + x_size
-        y1 = y_coord
-        y2 = y_coord + y_size
-        logger.debug("x1, x2, y1, y2 = {}, {}, {}, {}".format(x1, x2, y1, y2))
-        im = ccd_image[y1:y2, x1:x2]
-    elif ccd_side == win_settings.CCD_SIDE_RIGHT:
-        ccd_x_size = ccd_image.shape[0]
-        ccd_y_size = ccd_image.shape[1]
-        x1 = ccd_x_size - x_coord - x_size
-        x2 = ccd_x_size - x_coord
-        y1 = y_coord
-        y2 = y_coord + y_size
-        logger.debug("x1, x2, y1, y2 = {}, {}, {}, {}".format(x1, x2, y1, y2))
-        im = ccd_image[y1:y2, x1:x2]
-    else:
-        raise ValueError(f"CCD side argument should be 0 (left) or 1 (right), {ccd_side} was given.")
-
-    return im
-
-
-class WindowList:
-    """
-    The WindowList contains the window list for the FEE for one CCD.
-
-    A window is defined for a specific CCD, so there are four window lists.
-
-    Each element contains the coordinates for the window and the CCD side.  The size of the windows is identical for all
-    windows on a CCD and can be configured between 2x2 and 32x32 [default size is 10x10]. The window does not need to
-    be quadratic, i.e. x-size can be different from y-size.
-
-    **Developer information**
-
-    The internal representation of the window list is:
-
-        set((x_coord, y_coord, ccd_side), (x_coord, y_coord, ccd_side), ...)
-
-    """
-
-    def __init__(self):
-        """ Create an empty set"""
-
-        # A set is used for the internal representation of the window list, that
-        # prevents adding duplicate elements to the list.
-
-        self._window_list = set()
-
-        # Default window size in read from the global Settings
-
-        self._window_x_size = win_settings.DEFAULT_WINDOW_SIZE
-        self._window_y_size = win_settings.DEFAULT_WINDOW_SIZE
-
-    def __str__(self):
-
-        def _pp(list_):
-            """Pretty print a large list."""
-            if len(list_) > 10:
-                # FIXME: the representation could be better here...when time allows
-                return (
-                    f"[{list_[0]}, {list_[1]}, {list_[2]}, {list_[3]}, {list_[4]}"
-                    f", ..., "
-                    f"{list_[-2]}, {list_[-1]}]"
-                )
-            else:
-                return str(list_)
-
-        return (
-            f"Window size = ({self._window_x_size}, {self._window_y_size})\n"
-            f"Window List CCD 1: len={self.get_window_count(1)}, {_pp(self.get_window_list_for_ccd(1))}\n"
-            f"Window List CCD 2: len={self.get_window_count(2)}, {_pp(self.get_window_list_for_ccd(2))}\n"
-            f"Window List CCD 3: len={self.get_window_count(3)}, {_pp(self.get_window_list_for_ccd(3))}\n"
-            f"Window List CCD 4: len={self.get_window_count(4)}, {_pp(self.get_window_list_for_ccd(4))}\n"
-        )
-
-    def get_window_list(self):
-        """ Return the window list.
-
-        The list is a set of tuples, where each tuple contains the following information regarding one window:
-
-            (x, y, ccd_side)
-
-        The window list is sorted on y-coordinates first and x_coordinate second.
-        """
-
-        return sorted(self._window_list, key=itemgetter(1, 0))
-
-    def add_window(self, x: int, y: int, ccd_side):
-        """ Add a window to the window list.
-
-        The window is appended to the list, which renders the list unsorted.  Use the `sort()` method after all windows
-        have been added.
-
-        Args:
-            - x: Column or x-coordinate of the corner of the window closest to the readout node.
-            - y: Row or y-coordinate of the corner of the window closest to the readout node.
-            - ccd_side: CCD side.
-        """
-
-        # The window lists should be sorted first on the Y coordinate (rows), then the X-coordinate (columns).
-        #
-        # Internally however, the sets are not sorted because it would take too much time to keep the sets
-        # sorted when this is only needed when the actual window list is requested by the caller.
-        # Remember a list can take up to 100_000 elements.
-        #
-        # When a window list is requested using the `get_window_list()` method, a properly sorted list
-        # will be returned.
-
-        self._window_list.add((x, y, ccd_side))
-
-    def get_window_count(self) -> int:
-        """ Return the number of windows in the list.
-
-        Returns: Number of windows.
-        """
-
-        return len(self._window_list)
-
-    def set_window_size(self, x_size, y_size):
-        """ Set a new window size.
-
-        All windows have the same size. `x_size` and `y_size` do not have to be equal. The given size for both x and y
-        has to be within the range [2-32] inclusive.
-
-        Args:
-            - x_side: Window size on the x-axis [pixels].
-            - y_side: Window size on the y-axis [pixels].
-
-        Raises a **WindowSizeError** when a given size is out of range.
-        """
-
-        if win_settings.MIN_WINDOW_SIZE <= x_size <= win_settings.MAX_WINDOW_SIZE:
-
-            self._window_x_size = x_size
-
-        else:
-
-            raise WindowSizeError(f"Window size shall be [2, 32], {x_size} was given for x_size.")
-
-        if win_settings.MIN_WINDOW_SIZE <= y_size <= win_settings.MAX_WINDOW_SIZE:
-
-            self._window_y_size = y_size
-
-        else:
-
-            raise WindowSizeError(f"Window size shall be [2, 32], {y_size} was given for y_size.")
-
-    def get_window_size(self):
-        """ Return a tuple (x_size, y_size) containing the window size in pixels.
-
-        Returns: Tuple with the window size (x_size, y_size) [pixels].
-        """
-
-        return self._window_x_size, self._window_y_size

egse/zmq/__init__.py

@@ -1,28 +0,0 @@
-from enum import IntEnum
-
-
-class MessageIdentifier(IntEnum):
-    """
-    The first item in a multipart message that can be used to subscribe, filter and identify
-    messages.
-    """
-
-    # ALL shall not be used in the multipart message itself, but exists as an indicator for
-    # subscribing to all messages. The ALL shall be converted into b'' when subscribing.
-
-    ALL = 0x00
-
-    # Synchronisation to DPU Processor at time of reception
-
-    SYNC_TIMECODE = 0x80
-    SYNC_HK_PACKET = 0x81
-    SYNC_DATA_PACKET = 0x82
-    SYNC_ERROR_FLAGS = 0x85
-    SYNC_HK_DATA = 0x86
-
-    N_FEE_REGISTER_MAP = 0x83
-    NUM_CYCLES = 0x84
-
-    # Sending out all kinds of information
-
-    HDF5_FILENAMES = 0x90