driftlessmap 1.1.0__py3-none-any.whl

driftlessmap/image_reader.py

@@ -0,0 +1,186 @@
+"""Readers that normalize supported image files for :class:`ImageView`."""
+
+import colorsys
+from pathlib import Path
+
+import cv2
+import numpy as np
+import tifffile
+
+
+MAX_CHANNELS = 4
+RGB_COLORS = [(255, 0, 0), (0, 255, 0), (0, 0, 255)]
+CHANNEL_COLORS = [(128, 128, 128), (255, 0, 0), (0, 255, 0), (0, 0, 255)]
+CHANNEL_NAMES = ["Gray", "Red", "Green", "Blue"]
+HISTOLOGY_IMAGE_FILTERS = (
+    "TIFF (*.tif *.tiff)",
+    "CZI (*.czi)",
+    "JPEG (*.jpg *.jpeg)",
+    "PNG (*.png)",
+    "BMP (*.bmp)",
+)
+HISTOLOGY_IMAGE_FILTER = ";;".join(HISTOLOGY_IMAGE_FILTERS)
+
+
+def _hsv_colors(rgb_colors):
+    result = []
+    for red, green, blue in rgb_colors:
+        hue, saturation, value = colorsys.rgb_to_hsv(red, green, blue)
+        result.append((hue, saturation, value / 255))
+    return result
+
+
+def _set_channel_metadata(reader, rgb_colors, channel_names):
+    reader.rgb_colors = list(rgb_colors)
+    reader.channel_name = list(channel_names)
+    reader.hsv_colors = _hsv_colors(reader.rgb_colors)
+    reader.gamma_val = []
+
+
+class ImageReader(object):
+    """Read a conventional bitmap as an eight-bit RGB image."""
+
+    def __init__(self, image_file_path):
+        self.error_index = 0
+        self.is_czi = False
+        self.file_name_list = [str(Path(image_file_path).with_suffix(""))]
+        self.n_scenes = 1
+        self.n_pages = 1
+        self.scaling_val = None
+        self.is_rgb = True
+        self.pixel_type = "rgb24"
+        self.level = 255
+        self.n_channels = 3
+        self.data_type = "uint8"
+        _set_channel_metadata(self, RGB_COLORS, ["Red", "Green", "Blue"])
+
+        image = cv2.imread(str(image_file_path), cv2.IMREAD_COLOR)
+        if image is None:
+            raise ValueError("OpenCV could not decode the selected image.")
+        self.data = {"scene 0": cv2.cvtColor(image, cv2.COLOR_BGR2RGB)}
+        self.scale = {"scene 0": 1.0}
+
+
+class TIFFReader(object):
+    """Read grayscale, RGB, channel, or page-stack TIFF data."""
+
+    def __init__(self, image_file_path):
+        self.error_index = 0
+        self.is_czi = False
+        self.file_name_list = [str(Path(image_file_path).with_suffix(""))]
+        self.n_scenes = 0
+        self.n_pages = 1
+        self.scaling_val = None
+        self.software = None
+        self.is_imagej = False
+        self.is_rgb = False
+        self.pixel_type = None
+        self.level = None
+        self.n_channels = 0
+        self.data_type = None
+        self.data = {}
+        self.scale = {}
+        _set_channel_metadata(self, [], [])
+
+        with tifffile.TiffFile(image_file_path) as tiff_file:
+            self.n_scenes = len(tiff_file.series)
+            self.is_imagej = tiff_file.is_imagej
+            if tiff_file.pages:
+                self.software = tiff_file.pages[0].software
+            if self.n_scenes != 1:
+                self.error_index = 1
+                return
+
+            series = tiff_file.series[0]
+            image = np.asarray(series.asarray())
+            axes = series.axes
+
+        if image.dtype not in (np.dtype("uint8"), np.dtype("uint16")):
+            self.error_index = 2
+            return
+
+        self.data_type = image.dtype.name
+        self.level = int(np.iinfo(image.dtype).max)
+        bit_depth = image.dtype.itemsize * 8
+
+        if image.ndim == 2:
+            image = image[..., None]
+            self._set_grayscale(image, bit_depth, 1)
+        elif image.ndim == 3 and image.shape[-1] in (3, 4) and axes.endswith("S"):
+            self.is_rgb = True
+            self.pixel_type = "rgb{}".format(bit_depth * 3)
+            self.n_channels = 3
+            image = image[..., :3]
+            _set_channel_metadata(self, RGB_COLORS, ["Red", "Green", "Blue"])
+        elif image.ndim == 3 and "C" in axes:
+            channel_axis = axes.index("C")
+            image = np.moveaxis(image, channel_axis, -1)
+            self._set_grayscale(image, bit_depth, image.shape[-1])
+        elif image.ndim == 3 and axes.endswith("YX"):
+            self.n_pages = image.shape[0]
+            self.is_rgb = False
+            self.pixel_type = "gray{}".format(bit_depth)
+            self.n_channels = 1
+            _set_channel_metadata(self, CHANNEL_COLORS[:1], CHANNEL_NAMES[:1])
+        else:
+            self.error_index = 7
+            return
+
+        if self.n_channels > MAX_CHANNELS:
+            self.error_index = 8
+            return
+
+        self.data["scene 0"] = image
+        self.scale["scene 0"] = 1.0
+
+    def _set_grayscale(self, image, bit_depth, n_channels):
+        self.is_rgb = False
+        self.pixel_type = "gray{}".format(bit_depth)
+        self.n_channels = n_channels
+        _set_channel_metadata(
+            self, CHANNEL_COLORS[:n_channels], CHANNEL_NAMES[:n_channels]
+        )
+
+
+class ImagesReader(object):
+    """Read a folder of conventional images as deterministic RGB scenes."""
+
+    SUPPORTED_SUFFIXES = {".bmp", ".jpg", ".jpeg", ".png", ".tif", ".tiff"}
+
+    def __init__(self, folder_path):
+        self.error_index = 0
+        self.is_czi = False
+        self.is_rgb = True
+        self.n_channels = 3
+        self.n_pages = 1
+        self.level = 255
+        self.data_type = "uint8"
+        self.pixel_type = "rgb24"
+        self.scaling_val = None
+        _set_channel_metadata(self, RGB_COLORS, ["Red", "Green", "Blue"])
+        self.file_name_list = []
+        self.data = {}
+        self.scale = {}
+
+        paths = sorted(
+            (
+                path
+                for path in Path(folder_path).iterdir()
+                if path.is_file() and path.suffix.lower() in self.SUPPORTED_SUFFIXES
+            ),
+            key=lambda path: path.name.casefold(),
+        )
+        if not paths:
+            raise ValueError("The selected folder contains no supported images.")
+
+        for scene_id, path in enumerate(paths):
+            image = cv2.imread(str(path), cv2.IMREAD_COLOR)
+            if image is None:
+                raise ValueError("Could not decode image: {}".format(path.name))
+            self.file_name_list.append(path.stem)
+            self.data["scene {}".format(scene_id)] = cv2.cvtColor(
+                image, cv2.COLOR_BGR2RGB
+            )
+            self.scale["scene {}".format(scene_id)] = 1.0
+
+        self.n_scenes = len(self.data)

driftlessmap/image_stacks.py

@@ -0,0 +1,359 @@
+import colorsys
+import os
+import sys
+import numpy as np
+from PyQt6.QtWidgets import *
+from PyQt6.QtCore import *
+from PyQt6.QtGui import *
+import pyqtgraph as pg
+from pyqtgraph.Qt import QtGui, QtCore
+from .movable_points import TriangulationPoints
+
+
+class ClickableImage(pg.ImageItem):
+    class SignalProxy(QObject):
+        mouseHovered = pyqtSignal(object)  # id
+        mouseClicked = pyqtSignal(object)  # id
+
+    def __init__(self):
+        self._sigprox = ClickableImage.SignalProxy()
+        self.mouseHovered = self._sigprox.mouseHovered
+        self.mouseClicked = self._sigprox.mouseClicked
+
+        pg.ImageItem.__init__(self)
+
+        self.hist_data = None
+
+        self.setAcceptHoverEvents(True)
+        # self.setOpts(axisOrder='row-major')
+
+    def set_data(self, hist_image_data, scale=None):
+        # self.label_data = label
+        self.hist_data = hist_image_data
+        if scale is not None:
+            self.resetTransform()
+            self.scale(*scale)
+        self.setImage(self.hist_data, autoLevels=False)
+        # self.label_img.setImage(self.label_data, autoLevels=False)
+
+    def hoverEvent(self, event):
+        if event.isExit():
+            return
+        try:
+            pos = (event.pos())
+            id = 1  # self.label_data[int(event.pos().x()), int(event.pos().y())]
+        except (IndexError, AttributeError):
+            return
+        self.mouseHovered.emit(event)
+
+    def mouseClickEvent(self, event):
+        pos = (event.pos().x(), event.pos().y())
+        # This item owns background-image clicks. Accept before emitting because
+        # the callback may update or remove plot items that pyqtgraph also found
+        # under the cursor for this same click.
+        event.accept()
+        # print(pos)
+        # id = self.label_data[int(event.pos().x()), int(event.pos().y())]
+        self.mouseClicked.emit(pos)
+        # self.mouseClicked.emit([event, id])
+
+
+class SliceStack(pg.GraphicsLayoutWidget):
+    class SignalProxy(QObject):
+        mouseHovered = pyqtSignal(object)  # id
+        mouseClicked = pyqtSignal(object)  # id
+        sigKeyPressed = pyqtSignal(object)  # event
+
+    def __init__(self):
+        self._sigprox = SliceStack.SignalProxy()
+        self.sig_mouse_hovered = self._sigprox.mouseHovered
+        self.sig_mouse_clicked = self._sigprox.mouseClicked
+        self.sig_key_pressed = self._sigprox.sigKeyPressed
+
+        pg.GraphicsLayoutWidget.__init__(self)
+
+        self.data = None
+        self.vb = self.addViewBox()
+        self.setBackground('k')
+        self.vb.setAspectLocked()
+        self.vb.invertY(True)
+        self.vb.setAcceptHoverEvents(True)
+        # self.vb.enableAutoRange(enable=False)
+
+        self.base_layer = ClickableImage()
+        self.base_layer.mouseClicked.connect(self.mouse_clicked)
+        self.base_layer.mouseHovered.connect(self.mouse_hovered)
+
+        self.img_layer = pg.ImageItem()
+        self.img_layer.setCompositionMode(QPainter.CompositionMode.CompositionMode_Plus)
+
+        circle_follow = pg.PlotDataItem(pen=pg.mkPen('r', width=2, style=Qt.PenStyle.DashLine))
+        lasso_path = pg.PlotDataItem(pen=pg.mkPen(color=(0, 255, 255), width=3, style=Qt.PenStyle.DashLine),
+                                     symbolPen=(0, 255, 255), symbol='o', symbolSize=4)
+
+        ruler_path = pg.PlotDataItem(pen=pg.mkPen(color='y', width=3, style=Qt.PenStyle.DashLine),
+                                     symbolPen='y', symbolBrush='y', symbol='s', symbolSize=4)
+
+        overlay_img = pg.ImageItem()
+        overlay_img.setCompositionMode(QPainter.CompositionMode.CompositionMode_Plus)
+        overlay_contour = pg.ImageItem()
+        overlay_contour.setLevels(levels=(0, 1))
+
+        mask_img = pg.ImageItem()
+        mask_img.setLevels(levels=(0, 1))
+
+        tri_pnts = TriangulationPoints()
+        tri_pnts.setVisible(False)
+        self.tri_lines_list = []
+
+        grid_lines = pg.GridItem(pen=(128, 128, 128))
+        grid_lines.setVisible(False)
+
+        cell_pnts = pg.ScatterPlotItem(pen=(0, 255, 0), brush=(0, 255, 0), size=5, hoverSize=8)
+        probe_pnts = pg.ScatterPlotItem(pen=(0, 0, 255), brush=(0, 0, 255), symbol='s', size=5, hoverSize=8)
+        bregma_pnt = pg.ScatterPlotItem(pen=(180, 112, 57), brush=(180, 112, 57), symbol='star', size=10, hoverSize=15)
+
+        drawing_pnts = pg.PlotDataItem(pen=pg.mkPen(color=(255, 102, 0), width=2), brush=None)
+        contour_pnts = pg.PlotDataItem(pen=pg.mkPen(color=(255, 0, 255), width=3), brush=None)
+
+        probe_trajectory = pg.PlotDataItem(pen=pg.mkPen(color=(0, 0, 255), width=2), brush=None)
+
+        self.pre_trajectory_list = [pg.PlotDataItem(pen=pg.mkPen(color=(0, 0, 255), width=2), brush=None)]
+
+        self.image_dict = {'atlas-overlay': overlay_img,
+                           'overlay_contour': overlay_contour,
+                           'atlas-drawing': drawing_pnts,
+                           'atlas-contour': contour_pnts,
+                           'atlas-mask': mask_img,
+                           'grid_lines': grid_lines,
+                           'tri_pnts': tri_pnts,
+                           'circle_follow': circle_follow,
+                           'lasso_path': lasso_path,
+                           'atlas-probe': probe_pnts,
+                           'bregma_pnt': bregma_pnt,
+                           'ruler_path': ruler_path,
+                           'atlas-cells': cell_pnts,
+                           'atlas-trajectory': probe_trajectory}
+        self.image_dict_keys = list(self.image_dict.keys())
+
+        self.vb.addItem(self.base_layer)
+        self.vb.addItem(self.img_layer)
+
+        for i in range(len(self.image_dict)):
+            self.vb.addItem(self.image_dict[self.image_dict_keys[i]])
+
+        self.vb.addItem(self.pre_trajectory_list[0])
+
+    def set_data(self, data, scale=None):
+        if data.ndim != 3:
+            raise ValueError('Image data must have shape (height, width, channels).')
+        if data.shape[2] > len(self.image_list):
+            raise ValueError(
+                'DriftlessMap supports at most {} image channels.'.format(
+                    len(self.image_list)
+                )
+            )
+        self.data = data
+        if scale is not None:
+            self.resetTransform()
+            self.scale(*scale)
+        base_img = np.zeros(data.shape[:2], 'uint8')
+        self.base_layer.setImage(base_img)
+        self.img_layer.setImage(data)
+
+    def set_pre_design_vis_data(self, data):
+        n_probe = len(data)
+        exist_n_probes = len(self.pre_trajectory_list)
+        if n_probe < exist_n_probes:
+            del_ind = np.arange(n_probe, exist_n_probes)[::-1]
+            for i in del_ind:
+                self.vb.removeItem(self.pre_trajectory_list[i])
+                self.pre_trajectory_list[i].deleteLater()
+                del self.pre_trajectory_list[i]
+        elif n_probe > exist_n_probes:
+            for i in range(exist_n_probes, n_probe):
+                self.pre_trajectory_list.append(pg.PlotDataItem(pen=pg.mkPen(color=(0, 0, 255), width=2), brush=None))
+                self.vb.addItem(self.pre_trajectory_list[-1])
+
+        for i in range(n_probe):
+            self.pre_trajectory_list[i].setData(data[i])
+
+    def pre_trajectory_color_changed(self, col, lw):
+        for i in range(len(self.pre_trajectory_list)):
+            self.pre_trajectory_list[i].setPen(pg.mkPen(color=col, width=lw))
+
+    def remove_pre_trajectories_vis_lines(self):
+        del_ind = np.arange(len(self.pre_trajectory_list))[::-1]
+        for i in del_ind:
+            self.vb.removeItem(self.pre_trajectory_list[i])
+            self.pre_trajectory_list[i].deleteLater()
+            del self.pre_trajectory_list[i]
+            # self.pre_trajectory_list[i].updateItems(True)
+        self.pre_trajectory_list.clear()
+
+    def boundingRect(self):
+        return self.base_layer.boundingRect()
+
+    def mouse_hovered(self, event):
+        if event.isExit():
+            return
+        try:
+            pos = (event.pos())
+            id = 1  # self.label_data[int(event.pos().x()), int(event.pos().y())]
+        except (IndexError, AttributeError):
+            return
+        self.sig_mouse_hovered.emit(event)
+
+    def mouse_clicked(self, pos):
+        self.sig_mouse_clicked.emit(pos)
+
+    def keyPressEvent(self, event):
+        if event.key() == QtCore.Qt.Key.Key_Backspace:
+            print("Killing")
+            self.sig_key_pressed.emit('delete')
+
+
+class ImageStacks(pg.GraphicsLayoutWidget):
+    class SignalProxy(QObject):
+        sigMouseHovered = pyqtSignal(object)  # id
+        sigMouseClicked = pyqtSignal(object)  # id
+        sigKeyPressed = pyqtSignal(object)  # event
+
+    def __init__(self):
+        self._sigprox = ImageStacks.SignalProxy()
+        self.sig_mouse_hovered = self._sigprox.sigMouseHovered
+        self.sig_mouse_clicked = self._sigprox.sigMouseClicked
+        self.sig_key_pressed = self._sigprox.sigKeyPressed
+
+        pg.GraphicsLayoutWidget.__init__(self)
+
+        self.data = None
+        self.vb = self.addViewBox()
+        self.setBackground('k')
+        self.vb.setAspectLocked()
+        self.vb.invertY(True)
+        self.vb.setAcceptHoverEvents(True)
+        # self.vb.enableAutoRange(enable=False)
+
+        self.base_layer = ClickableImage()
+        self.base_layer.mouseClicked.connect(self.mouse_clicked)
+        self.base_layer.mouseHovered.connect(self.mouse_hovered)
+
+        img1 = pg.ImageItem()
+        img1.setCompositionMode(QPainter.CompositionMode.CompositionMode_Plus)
+        img2 = pg.ImageItem()
+        img2.setCompositionMode(QPainter.CompositionMode.CompositionMode_Plus)
+        img3 = pg.ImageItem()
+        img3.setCompositionMode(QPainter.CompositionMode.CompositionMode_Plus)
+        img4 = pg.ImageItem()
+        img4.setCompositionMode(QPainter.CompositionMode.CompositionMode_Plus)
+
+        circle_follow = pg.PlotDataItem(pen=pg.mkPen('r', width=2, style=Qt.PenStyle.DashLine))
+        lasso_path = pg.PlotDataItem(pen=pg.mkPen(color=(0, 255, 255), width=3, style=Qt.PenStyle.DashLine),
+                                     symbolPen=(0, 255, 255), symbol='o', symbolSize=4)
+        ruler_path = pg.PlotDataItem(pen=pg.mkPen(color='y', width=3, style=Qt.PenStyle.DashLine),
+                                     symbolPen='y', symbolBrush='y', symbol='s', symbolSize=4)
+
+        overlay_img = pg.ImageItem()
+        overlay_img.setCompositionMode(QPainter.CompositionMode.CompositionMode_Plus)
+        overlay_contour = pg.ImageItem()
+        overlay_contour.setLevels(levels=(0, 1))
+
+        mask_img = pg.ImageItem()
+        mask_img.setLevels(levels=(0, 1))
+
+        tri_pnts = TriangulationPoints()
+        tri_pnts.setVisible(False)
+        self.tri_lines_list = []
+
+        grid_lines = pg.GridItem(pen=(128, 128, 128))
+        grid_lines.setVisible(False)
+
+        probe_pnts = pg.ScatterPlotItem(pen=(0, 0, 255), brush=(0, 0, 255), symbol='s', size=5, hoverSize=8)
+        cell_pnts = pg.ScatterPlotItem(pen=(0, 255, 0), brush=(0, 255, 0), size=5, hoverSize=8)
+        blob_pnts = pg.ScatterPlotItem(pen=(55, 55, 55), brush=(55, 55, 55), symbol='s', size=5)
+        drawing_pnts = pg.PlotDataItem(pen=pg.mkPen(color=(255, 102, 0), width=2), brush=None)
+        contour_pnts = pg.PlotDataItem(pen=pg.mkPen(color=(255, 0, 255), width=3), brush=None)
+
+        probe_trajectory = pg.PlotDataItem(pen=pg.mkPen(color=(0, 0, 255), width=2), brush=None)
+
+        virus_img = pg.ImageItem()
+        virus_img.setLevels(levels=(0, 1))
+
+        self.image_list = [img1, img2, img3, img4]
+        self.image_dict = {'img-overlay': overlay_img,
+                           'overlay_contour': overlay_contour,
+                           'img-virus': virus_img,
+                           'img-contour': contour_pnts,
+                           'img-mask': mask_img,
+                           'grid_lines': grid_lines,
+                           'tri_pnts': tri_pnts,
+                           'circle_follow': circle_follow,
+                           'lasso_path': lasso_path,
+                           'ruler_path': ruler_path,
+                           'img-probe': probe_pnts,
+                           'img-cells': cell_pnts,
+                           'img-blob': blob_pnts,
+                           'img-drawing': drawing_pnts,
+                           'img-trajectory': probe_trajectory}
+        self.image_dict_keys = list(self.image_dict.keys())
+
+        self.vb.addItem(self.base_layer)
+        for i in range(4):
+            self.vb.addItem(self.image_list[i])
+            self.image_list[i].setVisible(False)
+
+        for i in range(len(self.image_dict)):
+            self.vb.addItem(self.image_dict[self.image_dict_keys[i]])
+
+    def set_data(self, data, scale=None):
+        self.data = data
+        if scale is not None:
+            self.resetTransform()
+            self.scale(*scale)
+        base_img = np.zeros(data.shape[:2], 'uint8')
+        self.base_layer.setImage(base_img)
+        for i in range(self.data.shape[2]):
+            self.image_list[i].setImage(self.data[:, :, i], autoLevels=False)
+            self.image_list[i].setVisible(True)
+        for i in range(self.data.shape[2], len(self.image_list)):
+            self.image_list[i].clear()
+            self.image_list[i].setVisible(False)
+
+    def set_lut(self, lut_list, bit_level):
+        for i in range(self.data.shape[2]):
+            self.image_list[i].setLevels(levels=(0, bit_level))
+            self.image_list[i].setLookupTable(lut_list[i])
+
+    def set_opacity(self, val):
+        if self.data is None:
+            return
+        for i in range(self.data.shape[2]):
+            self.image_list[i].setOpts(opacity=val)
+
+    def boundingRect(self):
+        return self.base_layer.boundingRect()
+
+    def mouse_hovered(self, event):
+        if event.isExit():
+            return
+        try:
+            pos = (event.pos())
+            id = 1  # self.label_data[int(event.pos().x()), int(event.pos().y())]
+        except (IndexError, AttributeError):
+            return
+        self.sig_mouse_hovered.emit(event)
+
+    def mouse_clicked(self, pos):
+        self.sig_mouse_clicked.emit(pos)
+
+    def change_background_color(self, color: tuple):
+        self.setBackground(color)
+
+    def keyPressEvent(self, event):
+        if event.key() == Qt.Key.Key_Backspace or event.key() == Qt.Key.Key_Delete:
+            print("Killing")
+            self.sig_key_pressed.emit('delete')
+        # elif event.key() == Qt.Key.Key_Enter or event.key() == Qt.Key.Key_Return:
+        #     print('enter')
+        #     self.sig_key_pressed.emit('enter')