Photom_v2

.gitignore

@@ -133,4 +133,5 @@ ToDo.txt
 defaults.txt
 
 copylot/_version.py
-.DS_Store
+.DS_Store
+.vscode/settings.json

copylot/assemblies/photom/demo/affine_T.yml

@@ -0,0 +1,4 @@
+affine_transform_yx:
+- [1.0, 0.0, 0.0]
+- [0.0, 1.0, 0.0]
+- [0.0, 0.0, 1.0]

copylot/assemblies/photom/demo/affine_T_2.yml

@@ -0,0 +1,4 @@
+affine_transform_yx:
+- [2.0, 0.0, 0.0]
+- [0.0, 2.0, 0.0]
+- [0.0, 0.0, 1.0]

copylot/assemblies/photom/demo/config.yml

@@ -0,0 +1,17 @@
+lasers:
+  - name: laser_1
+    power: 50
+  - name: laser_2
+    power: 30
+
+mirrors:
+  - name: mirror_1_VIS
+    COM_port: COM8
+    x_position: 0
+    y_position: 0
+    affine_matrix_path: ./copylot/assemblies/photom/demo/affine_T.yml
+  - name: mirror_2_IR
+    COM_port: COM9
+    x_position: 0
+    y_position: 0
+    affine_matrix_path: ./copylot/assemblies/photom/demo/affine_T_2.yml

copylot/assemblies/photom/demo/demo_affine_scan.py

@@ -0,0 +1,64 @@
+# %%
+import sys
+import os
+
+sys.path.append(os.path.join(os.pardir, os.pardir, os.pardir))
+import numpy as np
+import matplotlib as mpl
+import matplotlib.pyplot as plt
+
+from copylot.assemblies.photom.utils.scanning_algorithms import ScanAlgorithm
+from copylot.assemblies.photom.utils.affine_transform import AffineTransform
+
+mpl.rcParams['agg.path.chunksize'] = 20000
+
+# %%
+initial_coord = (549.5, 754.5)
+size = (300, 100)
+gap = 10
+shape = 'disk'
+sec_per_cycle = 0.003
+sg = ScanAlgorithm(initial_coord, size, gap, shape, sec_per_cycle)
+
+# coord = sg.generate_cornerline()
+coord = sg.generate_lissajous()
+# coord = sg.generate_sin()
+
+plt.figure()
+plt.plot(coord[0], coord[1])
+plt.show()
+
+# Load affine matrix
+trans_obj = AffineTransform(config_file='../settings/affine_transform.yml')
+
+# %%
+# compute affine matrix
+xv, yv = np.meshgrid(
+    np.linspace(1, 10, 10),
+    np.linspace(1, 10, 10),
+)
+coord = (list(xv.flatten()), list(yv.flatten()))
+pts1 = [
+    [xv[0, 0], yv[0, 0]],
+    [xv[-1, -1], yv[-1, -1]],
+    [xv[0, -1], yv[0, -1]],
+]
+
+pts2 = [
+    [xv[0, 0] + 1, yv[0, 0] + 1],
+    [xv[-1, -1] + 1, yv[-1, -1] + 1],
+    [xv[0, -1] + 1, yv[0, -1] + 1],
+]
+trans_obj.compute_affine_matrix(pts1, pts2)
+# %%
+trans_obj.save_matrix(config_file='./test.yml')
+# %%
+data_trans = trans_obj.apply_affine(coord)
+
+plt.figure()
+plt.plot(coord[0], coord[1])
+plt.plot(data_trans[0], data_trans[1])
+plt.legend(['raw', 'transformed'])
+plt.show()
+
+# %%

copylot/assemblies/photom/demo/demo_arduino_pwm.py

@@ -0,0 +1,106 @@
+# %%
+from copylot.assemblies.photom.photom import PhotomAssembly
+from copylot.assemblies.photom.utils import affine_transform
+from copylot.hardware.mirrors.optotune.mirror import OptoMirror
+
+# from copylot.assemblies.photom.photom_mock_devices import MockLaser, MockMirror
+from copylot.hardware.lasers.vortran.vortran import VortranLaser
+from copylot.hardware.cameras.flir.flir_camera import FlirCamera
+import time
+from copylot.assemblies.photom.utils.arduino import ArduinoPWM
+
+# %%
+config_file = './photom_VIS_config.yml'
+# Mock imports for the mirror and the lasers
+laser = VortranLaser('Mock Laser', port='COM9')
+mirror = OptoMirror(com_port='COM8')
+cam = FlirCamera()
+cam.open()
+
+# TODO: modify COM port based on the system
+arduino = ArduinoPWM(serial_port='COM10', baud_rate=115200)
+
+# %%
+# Make the photom device
+photom_device = PhotomAssembly(
+    laser=[laser],
+    mirror=[mirror],
+    affine_matrix_path=[r'./affine_T.yml'],
+    camera=[cam],
+)
+
+# %%
+# Perform calibration
+# Top-left and Bottom-right corners of the mirror ROI
+mirror_roi = [
+    [
+        0.018,
+        -0.005,
+    ],  # [x,y]
+    [
+        0.0,
+        0.013,
+    ],
+]  # [x,y]
+
+photom_device.camera[0].exposure = 10_000  # [us]
+photom_device.camera[0].gain = 0
+# photom_device.camera[0].pixel_format = 'Mono16'
+
+config_file = r'./test_auto_affineT.yml'
+
+photom_device.laser[0].power = 5  # [mW]
+photom_device.laser[0].pulse_mode = 0
+photom_device.laser[0].toggle_emission = True
+photom_device.calibrate_w_camera(
+    mirror_index=0,
+    camera_index=0,
+    rectangle_boundaries=mirror_roi,
+    grid_n_points=5,
+    config_file=config_file,
+    save_calib_stack_path='./calib_stack',
+    verbose=True,
+)
+photom_device.laser[0].toggle_emission = False
+
+# %%
+# Remove the camera from the photom_device so we can use it in the acquisiton engine
+photom_device.camera[0].exposure = 10_000  # [us]
+photom_device.camera = []
+
+
+# %%
+# Demo that laser should be in the center
+photom_device.laser[0].toggle_emission = True
+photom_device.set_position(0, [1024, 1224])  # center [y,x]
+time.sleep(3)
+photom_device.laser[0].toggle_emission = False
+# %%
+# Set the ablation parameters
+# Test the PWM signal
+duty_cycle = 50  # [%] (0-100)
+period_ms = 500  # [ms]
+total_duration_ms = 5_000  # [ms] total time to run the PWM signal
+reps = 2
+time_interval_s = 3
+photom_device.laser[0].pulse_power = 10  # [%]
+
+# %%
+# Ablate the cells
+# photom_device.set_position(0, [1024, 1224])  # center [y,x]
+photom_device.set_position(0, [0, 0])  # edge [y,x] might not be visble
+photom_device.laser[0].toggle_emission = 1
+time.sleep(0.2)
+photom_device.laser[0].pulse_mode = 1  # True enabled, False disabled
+time.sleep(0.2)
+frequency = 1000.0 / period_ms  # [Hz]
+arduino.set_pwm(duty_cycle, frequency, total_duration_ms)
+arduino.start_timelapse(repetitions=reps, time_interval_s=time_interval_s)
+# %%
+photom_device.laser[0].pulse_mode = 0  # True enabled, False disabled
+time.sleep(0.2)
+photom_device.laser[0].toggle_emission = 0
+time.sleep(0.2)
+photom_device.laser[0].power = 5.0  # [mW]
+
+# %%

copylot/assemblies/photom/demo/demo_calibration_camera.py

@@ -0,0 +1,106 @@
+# %%
+import numpy as np
+from scipy.ndimage import median_filter
+from skimage.feature import peak_local_max
+import napari
+from skimage import measure, filters
+from skimage.filters import gaussian
+import os
+from skimage.morphology import remove_small_objects
+
+
+# %%
+os.environ["DISPLAY"] = ":1002"
+viewer = napari.Viewer()
+
+# %%
+
+
+def find_objects_centroids(
+    image, sigma=5, threshold_rel=0.5, min_distance=10, min_area=3
+):
+    """
+    Calculate the centroids of blurred objects in an image, excluding hot pixels or small artifacts.
+
+    Parameters:
+    - image: 2D numpy array, single frame from the fluorescence microscopy data.
+    - sigma: Standard deviation for Gaussian filter to smooth the image.
+    - threshold_rel: Relative threshold for detecting peaks. Adjust according to image contrast.
+    - min_distance: The minimum distance between peaks detected.
+    - min_area: The minimum area of an object to be considered valid.
+
+    Returns:
+    - centroids: (N, 2) array where each row is (row, column) of an object's centroid.
+    """
+    # Smooth the image to enhance peak detection
+    smoothed_image = gaussian(image, sigma=sigma)
+
+    # Thresholding to isolate objects
+    threshold_value = filters.threshold_otsu(smoothed_image)
+    binary_image = smoothed_image > threshold_value * threshold_rel
+
+    # Remove small objects (hot pixels or small artifacts) from the binary image
+    cleaned_image = remove_small_objects(binary_image, min_size=min_area)
+
+    # Label the cleaned image to identify distinct objects
+    label_image = measure.label(cleaned_image)
+    properties = measure.regionprops(label_image)
+
+    # Calculate centroids of filtered objects
+    centroids = [prop.centroid for prop in properties if prop.area >= min_area]
+
+    return np.array(centroids)
+
+
+# %%
+# Define the rectangle and grid parameters
+n_points = 5  # Number of points per row/column in the grid
+rect_start_x, rect_start_y = 20, 20
+rect_end_x, rect_end_y = 80, 80
+frame_width, frame_height = 100, 100
+n_frames = 25  # Total number of frames
+px = 4  # Size of the point in the grid
+# Calculate intervals between points in the grid
+interval_x = (rect_end_x - rect_start_x) // (n_points - 1)
+interval_y = (rect_end_y - rect_start_y) // (n_points - 1)
+
+# Initialize frames
+frames = np.zeros((n_frames, frame_width, frame_height), dtype=np.float32)
+# Store the coordinates of the grid points per frame
+center_coords = np.zeros((n_frames, 2), dtype=np.float32)
+
+# Populate frames with the grid points
+for i in range(n_points):
+    for j in range(n_points):
+        frame_index = i * n_points + j
+        x = rect_start_x + j * interval_x
+        y = rect_start_y + i * interval_y
+        center_coords[frame_index] = [y, x]
+        # center_coords[frame_index, i, j] = [x, y]
+        frames[
+            frame_index, y - px // 2 : y + px // 2, x - px // 2 : x + px // 2
+        ] = 100  # Set the point to white
+
+for i in range(frames.shape[0]):
+    frames[i] = gaussian(frames[i], sigma=4)
+
+viewer.add_image(frames)
+
+print(center_coords)
+# %%
+centroids = []
+for i in range(frames.shape[0]):
+    coords = find_objects_centroids(
+        frames[i], sigma=3, threshold_rel=0.5, min_distance=10
+    )
+    centroids.append([i, np.round(coords[0][0]), np.round(coords[0][1])])
+
+centroids = np.array(centroids)
+viewer.add_points(centroids, size=5, face_color="red")
+print(centroids)
+
+# %%
+# compare with the ground truth
+assert np.allclose(centroids[:, 1:], center_coords, atol=1)
+
+# %%

copylot/assemblies/photom/demo/demo_draw_tetragon.py

@@ -0,0 +1,59 @@
+import sys
+from PyQt5.QtWidgets import (
+    QApplication,
+    QGraphicsView,
+    QGraphicsScene,
+    QGraphicsEllipseItem,
+    QMainWindow,
+)
+from PyQt5.QtCore import Qt
+from PyQt5.QtGui import QPolygonF, QPen
+
+
+class TetragonEditor(QMainWindow):
+    def __init__(self):
+        super().__init__()
+
+        self.setWindowTitle("Tetragon Editor")
+        self.setGeometry(100, 100, 800, 600)
+
+        # Create a QGraphicsView to display the scene
+        self.view = QGraphicsView(self)
+        self.view.setGeometry(10, 10, 780, 580)
+
+        # Create a QGraphicsScene
+        self.scene = QGraphicsScene()
+        self.view.setScene(self.scene)
+
+        # Create initial vertices for the tetragon
+        self.vertices = []
+        for x, y in [(100, 100), (200, 100), (200, 200), (100, 200)]:
+            vertex = QGraphicsEllipseItem(x - 5, y - 5, 10, 10)
+            vertex.setBrush(Qt.red)
+            vertex.setFlag(QGraphicsEllipseItem.ItemIsMovable)
+            self.vertices.append(vertex)
+            self.scene.addItem(vertex)
+
+    def getCoordinates(self):
+        return [vertex.pos() for vertex in self.vertices]
+
+    def resizeEvent(self, event):
+        # Resize the view when the main window is resized
+        self.view.setGeometry(10, 10, self.width() - 20, self.height() - 20)
+
+    def updateVertices(self, new_coordinates):
+        for vertex, (x, y) in zip(self.vertices, new_coordinates):
+            vertex.setPos(x, y)
+
+
+if __name__ == '__main__':
+    import os
+
+    os.environ["DISPLAY"] = ":1005"
+    app = QApplication(sys.argv)
+    window = TetragonEditor()
+    # print(window.getCoordinates())
+    # window.updateVertices([(10, 10), (300, 200), (0, 300), (200, 300)])
+    # print(window.getCoordinates())
+    window.show()
+    sys.exit(app.exec_())