microeye 2.3.2__py3-none-any.whl

microEye/hardware/pycromanager/devices.py

@@ -0,0 +1,461 @@
+import time
+from queue import Queue
+from typing import Union
+
+import numpy as np
+from pycromanager import (
+    Acquisition,
+    multi_d_acquisition_events,
+    start_headless,
+    stop_headless,
+)
+
+from microEye.hardware.cams.micam import miCamera
+from microEye.hardware.pycromanager.core import DEFAULT_BRIDGE_PORT, PycroCore
+from microEye.hardware.pycromanager.enums import DeviceType, PropertyType
+
+
+class PycroDevice:
+    def __init__(
+        self, label: str, type: DeviceType, port: int = DEFAULT_BRIDGE_PORT
+    ) -> None:
+        if not isinstance(type, DeviceType):
+            raise ValueError(f'Invalid device type: {type}')
+
+        self._port = port
+
+        if label is None or not isinstance(label, str):
+            if type == DeviceType.CameraDevice:
+                label = self._core.get_camera_device()
+            elif type == DeviceType.StageDevice:
+                label = self._core.get_focus_device()
+            elif type == DeviceType.XYStageDevice:
+                label = self._core.get_xy_stage_device()
+            elif type == DeviceType.AutoFocusDevice:
+                label = self._core.get_auto_focus_device()
+            elif type == DeviceType.GalvoDevice:
+                label = self._core.get_galvo_device()
+            elif type == DeviceType.SLMDevice:
+                label = self._core.get_slm_device()
+            elif type == DeviceType.ShutterDevice:
+                label = self._core.get_shutter_device()
+            else:
+                raise ValueError(
+                    f'Unsupported device type: {type}. Please provide a valid label.'
+                )
+
+        if self._core.get_device_type(label) != type:
+            raise ValueError(f'Label "{label}" is not a {type.name} device')
+
+        self._label = label
+        self._type = type
+
+    @property
+    def _core(self) -> PycroCore:
+        return PycroCore.instance(self._port)
+
+    @property
+    def device_type(self) -> DeviceType:
+        return self._type
+
+    @property
+    def label(self) -> str:
+        return self._label
+
+    @property
+    def busy(self) -> bool:
+        return self._core.device_busy(self._label)
+
+    @property
+    def name(self) -> float:
+        return self._core.get_device_name(self._label)
+
+    @name.setter
+    def name(self, value: str):
+        return
+        print('Setting PycroDevice name is not supported')
+
+    def wait_for_device(self):
+        self._core.wait_for_device(self._label)
+
+    def get_prop_names(self) -> list[str]:
+        return self._core.get_device_property_names(self._label)
+
+    def get_prop_values(self) -> dict:
+        return self._core.get_system_state()[self._label]
+
+    def has_property(self, prop_name: str) -> bool:
+        return self._core.has_property(self._label, prop_name)
+
+    def get_property(self, prop_name: str):
+        prop_value = self._core.get_property(self.label, prop_name)
+        prop_type = self.get_property_type(prop_name)
+
+        if prop_type == PropertyType.Undef:
+            return prop_value
+
+        python_type = prop_type.to_python()
+
+        return python_type(prop_value)
+
+    def get_property_type(self, prop_name: str) -> PropertyType:
+        return self._core.get_property_type(self.label, prop_name)
+
+    def set_property(self, prop_name: str, prop_value):
+        self._core.set_property(self.label, prop_name, prop_value)
+
+    def is_property_read_only(self, prop_name: str) -> bool:
+        return self._core.is_property_read_only(self.label, prop_name)
+
+    def get_allowed_property_values(self, prop_name: str) -> list:
+        return self._core.get_allowed_property_values(self.label, prop_name)
+
+    def get_property_limits(self, prop_name: str) -> tuple:
+        return self._core.get_property_limits(self.label, prop_name)
+
+    def property_tree(self):
+        tree = []
+        for prop in self.get_prop_names():
+            prop_type = self.get_property_type(prop)
+
+            if prop_type == PropertyType.Undef:
+                continue
+
+            python_type = prop_type.to_python()
+
+            prop_value = python_type(self.get_property(prop))
+
+            prop_read_only = self.is_property_read_only(prop)
+
+            prop_limits = self.get_property_limits(prop)
+
+            prop_allowed_values = self.get_allowed_property_values(prop)
+
+            # if any prop_limits is None, it means that the property has no limits
+            if any(limit is None for limit in prop_limits):
+                prop_limits = None
+
+            if prop_allowed_values:
+                prop_limits = [python_type(value) for value in prop_allowed_values]
+                python_type = list
+
+            tree.append(
+                {
+                    'name': prop,
+                    'type': python_type.__name__,
+                    'value': prop_value,
+                    'enabled': not prop_read_only,
+                    'limits': prop_limits,
+                }
+            )
+
+        return tree
+
+    def __str__(self) -> str:
+        return (
+            f'Device Type: {self.device_type.name}, '
+            f'Label: {self.label}, Name: {self.name}'
+        )
+
+
+class PycroCamera(PycroDevice, miCamera):
+    def __init__(self, label: str = None, port: int = DEFAULT_BRIDGE_PORT) -> None:
+        PycroDevice.__init__(self, label, DeviceType.CameraDevice, port)
+        miCamera.__init__(self)
+        # self._last_image = np.zeros((self.height, self.width))
+        # self._buffer = buffer if buffer is not None else Queue()
+
+    @property
+    def image_count(self) -> int:
+        return self._core.get_remaining_image_count()
+
+    @property
+    def width(self) -> int:
+        return self._core.get_image_width()
+
+    @width.setter
+    def width(self, value: int):
+        raise NotImplementedError('Cannot set camera width')
+
+    @property
+    def height(self) -> int:
+        return self._core.get_image_height()
+
+    @height.setter
+    def height(self, value: int):
+        raise NotImplementedError('Cannot set camera height')
+
+    @property
+    def ROI(self) -> tuple[int, int, int, int]:
+        return self._core.get_roi()
+
+    def set_roi(self, roi_x, roi_y, roi_width, roi_height):
+        self._core.set_roi(roi_x, roi_y, roi_width, roi_height, self.label)
+
+    def reset_roi(self):
+        self._core.clear_roi()
+
+    @property
+    def bit_depth(self) -> int:
+        return self._core.get_image_bit_depth()
+
+    @property
+    def bytes_per_pixel(self) -> int:
+        return int(np.ceil(self.bit_depth / 8))
+
+    @bytes_per_pixel.setter
+    def bytes_per_pixel(self, value: int):
+        pass
+
+    @property
+    def exposure_current(self) -> float:
+        return self._core.get_exposure(self._label)
+
+    @exposure_current.setter
+    def exposure_current(self, value: float):
+        self._core.set_exposure(value, self.label)
+
+    def setExposure(self, exposure: float):
+        self._core.set_exposure(exposure, self.label)
+
+    @property
+    def exposure_range(self) -> tuple[float, float]:
+        try:
+            return self.get_property_limits('Exposure')
+        except Exception as e:
+            return (0.1, 10000)
+
+    @exposure_range.setter
+    def exposure_range(self, value: tuple[float, float]):
+        return
+        print('PycroCamera: Setting exposure range is not supported')
+
+    def get_temperature(self) -> float:
+        try:
+            for prop in self.get_prop_names():
+                if 'temperature' in prop.lower():
+                    return float(self.get_property(prop))
+        except Exception as e:
+            print(f'Error getting temperature: {e}')
+        finally:
+            return -127.0  # noqa: B012
+
+    @property
+    def pixel_size_um(self) -> float:
+        return self._core.get_pixel_size_um()
+
+    def get_property(self, prop_name: str):
+        return self._core.get_property(self.label, prop_name)
+
+    def set_property(self, prop_name: str, prop_value):
+        self._core.set_property(self.label, prop_name, prop_value)
+
+    def get_image(self) -> np.ndarray:
+        return self._core.get_image().reshape((self.height, self.width))
+
+    # def get_image_buffer(self) -> np.ndarray:
+    #     return self._buffer.get().reshape((cam.height, cam.width))
+
+    def pop_image(self) -> np.ndarray:
+        return self._core.pop_next_image().reshape((self.height, self.width))
+
+    def get_tagged_image(self) -> tuple[np.ndarray, dict[str, str]]:
+        tagged = self._core.get_tagged_image()
+        return tagged.pix, tagged.tags
+
+    def snap_image(self, buffered=False):
+        if self.is_sequence_running():
+            print('Sequence already running')
+            return None
+
+        self.start_sequence_acquisition(0, 1)
+
+        # add timeout to avoid infinite loop
+        start = time.time()
+        while self.image_count == 0:
+            time.sleep(0.001)
+
+            if time.time() - start > 5:
+                print('Timeout: Could not snap image')
+                return None
+
+        img: np.ndarray = self.pop_image()
+        # if self._last_image is None or not np.allclose(self._last_image, img):
+        #     self._last_image = img.copy()
+        #     if buffered:
+        #         self._buffer.put(img)
+
+        return img
+
+    def start_continuous_acquisition(self, interval_ms: int = 0):
+        if self._core.is_sequence_running():
+            print('Sequence already running')
+            return
+
+        self._core.start_continuous_sequence_acquisition(interval_ms)
+
+    def is_sequence_running(self) -> bool:
+        return self._core.is_sequence_running(self._label)
+
+    def start_sequence_acquisition(self, interval_ms: float, num_time_points: int):
+        if self.is_sequence_running():
+            print('Sequence already running')
+            return
+
+        self._core.prepare_sequence_acquisition(self._label)
+        self._core.start_sequence_acquisition(
+            num_time_points, interval_ms, True, self._label
+        )
+
+    def stop_sequence_acquisition(self):
+        self._core.stop_sequence_acquisition(self._label)
+
+    def set_as_camera_device(self):
+        self._core.set_camera_device(self._label)
+
+    def populate_status(self):
+        self.status['Camera'] = {
+            'Class': self.__class__.__name__,
+            'Name': self._label,
+            'Type': self._type.name,
+        }
+
+        self.status['Exposure'] = {
+            'Value': self.exposure_current,
+            'Unit': 'ms',
+        }
+
+
+class PycroStage(PycroDevice):
+    def __init__(self, label: str = None, port: int = DEFAULT_BRIDGE_PORT) -> None:
+        super().__init__(label, DeviceType.StageDevice, port=port)
+
+    @property
+    def position(self) -> float:
+        return self._core.get_position(self.label)
+
+    @position.setter
+    def position(self, value: float):
+        self._core.set_position(value, self.label)
+
+    def move_rel(self, step: float):
+        self._core.set_relative_position(step, self.label)
+
+    def move_abs(self, position: float):
+        self._core.set_position(position, self.label)
+
+    def home(self):
+        return self._core.home(self.label)
+
+    def stop(self):
+        return self._core.stop(self.label)
+
+    def set_adapter_origin_z(self, new_z_um: float):
+        self._core.set_adapter_origin(new_z_um, self.label)
+
+    def set_origin(self):
+        self._core.set_origin(self.label)
+
+
+class PycroXYStage(PycroDevice):
+    def __init__(self, label: str = None, port: int = DEFAULT_BRIDGE_PORT) -> None:
+        super().__init__(label, DeviceType.XYStageDevice, port=port)
+
+    @property
+    def X(self) -> float:
+        return self._core.get_x_position(self.label)
+
+    @property
+    def Y(self) -> float:
+        return self._core.get_y_position(self.label)
+
+    @X.setter
+    def X(self, value: float):
+        self._core.set_xy_position(value, self.Y, self.label)
+
+    @Y.setter
+    def Y(self, value: float):
+        self._core.set_xy_position(self.X, value, self.label)
+
+    def move_rel(self, x: float, y: float):
+        self._core.set_relative_xy_position(x, y, self.label)
+
+    def move_abs(self, x: float, y: float):
+        self._core.set_xy_position(x, y, self.label)
+
+    def home(self):
+        return self._core.home(self.label)
+
+    def stop(self):
+        return self._core.stop(self.label)
+
+    def set_adapter_origin(self, new_x_um: float, new_y_um: float):
+        self._core.set_adapter_origin_xy(new_x_um, new_y_um, self.label)
+
+    def set_origin(self):
+        self._core.set_origin_xy(self.label)
+
+    def set_as_xy_stage_device(self):
+        self._core.set_xy_stage_device(self.label)
+
+
+if __name__ == '__main__':
+    import os
+    import time
+
+    import cv2
+
+    mm_path = 'C:/Program Files/Micro-Manager-2.0'
+    config = 'MMConfig_demo.cfg'
+    port = 1234
+
+    try:
+        start_headless(
+            mm_path,
+            config,
+            port=port,
+            # python_backend=True,
+        )
+
+        cam = PycroCamera('Camera', port=port)
+        cam.exposure_current = 50
+
+
+        cam.start_sequence_acquisition(0, 500)  # 0 ms interval for fastest acquisition
+
+        # def show_image(image, metadata):
+        #     cv2.imshow('Image', image)
+        #     cv2.waitKey(1)
+
+        # with Acquisition(show_display=False, image_process_fn=show_image) as acq:
+        #     events = multi_d_acquisition_events(
+        #         2000,
+        #     )  # events for 2000 time points
+        #     for dic in events:
+        #         dic['camera'] = 'DCam_1'
+        #     acq.acquire(events)
+
+        i = 0
+        while cam.is_sequence_running() or cam.image_count > 0:
+            # Check if there are images before trying to get one
+            if cam.image_count > 0:
+                img = cam.pop_image()
+                i += 1
+                cv2.imshow('', img)
+
+            key = cv2.waitKey(1)
+            if key == ord('q'):
+                cam.stop_sequence_acquisition()
+
+            print(
+                f'Remaining images: {cam.image_count:04d}',
+                f'| Iterations : {i:04d}',
+                end='\r',
+            )
+
+        cv2.destroyAllWindows()
+    except Exception as e:
+        import traceback
+        traceback.print_exc()
+    finally:
+        PycroCore._instances[port].close()

microEye/hardware/pycromanager/enums.py

@@ -0,0 +1,107 @@
+from enum import Enum
+
+
+# ActionType
+class ActionType(Enum):
+    NoAction = 0
+    BeforeGet = 1
+    AfterSet = 2
+    IsSequenceable = 3
+    AfterLoadSequence = 4
+    StartSequence = 5
+    StopSequence = 6
+
+# DeviceType
+class DeviceType(Enum):
+    UnknownType = 0
+    AnyType = 1
+    CameraDevice = 2
+    ShutterDevice = 3
+    StateDevice = 4
+    StageDevice = 5
+    XYStageDevice = 6
+    SerialDevice = 7
+    GenericDevice = 8
+    AutoFocusDevice = 9
+    CoreDevice = 10
+    ImageProcessorDevice = 11
+    SignalIODevice = 12
+    MagnifierDevice = 13
+    SLMDevice = 14
+    HubDevice = 15
+    GalvoDevice = 16
+
+# PropertyType
+class PropertyType(Enum):
+    Undef = 0
+    String = 1
+    Float = 2
+    Integer = 3
+
+    def to_python(self):
+        if self == PropertyType.String:
+            return str
+        elif self == PropertyType.Float:
+            return float
+        elif self == PropertyType.Integer:
+            return int
+        else:
+            return None
+
+    @classmethod
+    def to_dict(cls):
+        return {member.value: member for member in cls}
+
+    @classmethod
+    def from_java(cls, prop_jv):
+        value = prop_jv.swig_value() if hasattr(prop_jv, 'swig_value') else int(prop_jv)
+        members = cls.to_dict()
+        if value in members:
+            return members[value]
+        else:
+            raise ValueError('Invalid PropertyType value')
+
+# PortType
+class PortType(Enum):
+    InvalidPort = 0
+    SerialPort = 1
+    USBPort = 2
+    HIDPort = 3
+
+# FocusDirection
+class FocusDirection(Enum):
+    Unknown = 0
+    TowardSample = 1
+    AwayFromSample = 2
+
+# DeviceNotification
+class DeviceNotification(Enum):
+    Attention = 0
+    Done = 1
+    StatusChanged = 2
+
+# DeviceDetectionStatus
+class DeviceDetectionStatus(Enum):
+    Unimplemented = -2
+    Misconfigured = -1
+    CanNotCommunicate = 0
+    CanCommunicate = 1
+
+# DeviceInitializationState
+class DeviceInitializationState(Enum):
+    Uninitialized = 0
+    InitializedSuccessfully = 1
+    InitializationFailed = 2
+
+
+# MetadataProfiles
+class MetadataProfile(Enum):
+    Essential = 0
+    CameraLabel = 1
+    BitDepth = 2
+    ROIAndBinning = 3
+    Timing = 4
+    CameraSpecificTags = 5
+    PixelSize = 6
+    LegacyAcqEngMetadata = 7
+    SystemStateCache = 8

microEye/hardware/pycromanager/headless.py

@@ -0,0 +1,153 @@
+import os
+from dataclasses import dataclass
+from typing import Optional
+
+import yaml
+from mmpycorex.launcher import (
+    _JAVA_HEADLESS_SUBPROCESSES,
+    _PYMMCORES,
+    active_java_ports,
+    is_java_port_allocated,
+    logger,
+    server_terminated,
+    terminate_java_instances,
+)
+from pycromanager.headless import (
+    DEFAULT_BRIDGE_PORT,
+    start_headless,
+    stop_headless,
+)
+
+
+@dataclass
+class HeadlessInstance:
+    '''Data class to store information about a headless instance.'''
+
+    port: int
+    mm_app_path: str
+    config_file: Optional[str] = None
+    java_loc: Optional[str] = None
+    python_backend: bool = False
+    core_log_path: str = ''
+    buffer_size_mb: int = 1024
+    max_memory_mb: int = 2000
+    debug: bool = False
+    name: str = 'Unnamed Instance'
+
+    def __post_init__(self):
+        '''Generate a name if none was provided.'''
+        if self.name == 'Unnamed Instance':
+            backend = 'Python' if self.python_backend else 'Java'
+            self.name = f'{backend}_Backend_{self.port}'
+
+
+class HeadlessManager:
+    '''Manager class for headless Micro-Manager instances.'''
+
+    # Singleton instance
+    _instance = None
+
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+            cls._instance._initialized = False
+        return cls._instance
+
+    def __init__(self):
+        if self._initialized:
+            return
+        self._initialized = True
+        self._instances: dict[int, HeadlessInstance] = {}
+
+    @property
+    def instances(self) -> dict[int, HeadlessInstance]:
+        '''Get a dictionary of all running instances.'''
+        return self._instances.copy()
+
+    @property
+    def ports(self) -> list[int]:
+        '''Get a list of all ports in use.'''
+        return list(self._instances.keys())
+
+    def is_port_used(self, port: int) -> bool:
+        '''Check if a port is already in use.'''
+        return port in self._instances
+
+    def start_instance(self, instance_config: HeadlessInstance) -> bool:
+        '''Start a new headless instance with the given configuration.'''
+        if self.is_port_used(instance_config.port):
+            return False
+
+        try:
+            start_headless(
+                mm_app_path=instance_config.mm_app_path,
+                config_file=instance_config.config_file,
+                java_loc=instance_config.java_loc,
+                python_backend=False, # instance_config.python_backend,
+                core_log_path=instance_config.core_log_path,
+                buffer_size_mb=instance_config.buffer_size_mb,
+                max_memory_mb=instance_config.max_memory_mb,
+                port=instance_config.port,
+                debug=instance_config.debug,
+            )
+            self._instances[instance_config.port] = instance_config
+            return True
+        except Exception as e:
+            print(f'Failed to start headless instance: {e}')
+            return False
+
+    def stop_instance(self, port: int) -> bool:
+        '''Stop a specific headless instance by port.'''
+        if not self.is_port_used(port):
+            return False
+
+        try:
+            terminate_java_instances(debug=self._instances[port].debug, port=port)
+            del self._instances[port]
+            return True
+        except Exception as e:
+            print(f'Failed to stop headless instance: {e}')
+            return False
+
+    def stop_all_instances(self, debug=False) -> None:
+        '''Stop all running headless instances.'''
+        try:
+            terminate_java_instances(debug=debug)
+            self._instances.clear()
+            return True
+        except Exception as e:
+            print(f'Failed to stop headless instances: {e}')
+            return False
+
+    def get_instance(self, port: int) -> Optional[HeadlessInstance]:
+        '''Get instance information for a specific port.'''
+        return self._instances.get(port)
+
+    def save_config(self, filepath: str) -> bool:
+        '''Save the current configuration to a file.'''
+        # Implementation for saving configs to JSON/YAML
+        try:
+            with open(filepath, 'w') as f:
+                yaml.dump(self._instances, f)
+            return True
+        except Exception as e:
+            print(f'Failed to save configuration: {e}')
+            return False
+
+    def load_config(self, filepath: str) -> bool:
+        '''Load configuration from a file.'''
+        # Implementation for loading configs from JSON/YAML
+        # Each instance will be a dictionary with the port as the key
+        # They should be started and added if not confilicting with existing ones
+        try:
+            with open(filepath) as f:
+                _instances = yaml.load(f, Loader=yaml.FullLoader)
+
+            for port, instance in _instances.items():
+                if not self.is_port_used(port):
+                    self.start_instance(HeadlessInstance(**instance))
+
+            return True
+        except Exception as e:
+            print(f'Failed to load configuration: {e}')
+            return False