driftlessmap 1.1.0__py3-none-any.whl

driftlessmap/movable_points.py

@@ -0,0 +1,254 @@
+import os
+import sys
+import numpy as np
+import pyqtgraph as pg
+from PyQt6.QtCore import *
+from pyqtgraph.Qt import QtGui, QtCore
+
+
+class MovablePoints(pg.GraphItem):
+    mouseHovered = pyqtSignal(object)
+    mouseDragged = pyqtSignal(object)
+    mouseClicked = pyqtSignal(object)
+
+    def __init__(self):
+        self.dragPoint = None
+        self.dragOffset = None
+        pg.GraphItem.__init__(self)
+        self.data = None
+        self.y_range = None
+
+    def setData(self, **kwds):
+        self.data = kwds
+        if 'pos' in self.data:
+            if self.y_range is None:
+                self.y_range = self.data['pos'][-1, 1]
+            self.npts = self.data['pos'].shape[0]
+            self.data['data'] = np.empty(self.npts, dtype=[('index', int)])
+            self.data['data']['index'] = np.arange(self.npts)
+        self.updateGraph()
+
+    def updateGraph(self):
+        pg.GraphItem.setData(self, **self.data)
+
+    def mouseDragEvent(self, ev):
+        if ev.button() != QtCore.Qt.MouseButton.LeftButton:
+            ev.ignore()
+            return
+
+        if ev.isStart():
+            pos = ev.buttonDownPos()
+            pts = self.scatter.pointsAt(pos)
+            if len(pts) == 0:
+                # self.mouseClicked.emit(ev)
+                ev.ignore()
+                return
+            self.dragPoint = pts[0]
+            ind = pts[0].data()[0]
+            if ind in [0, self.npts-1]:
+                return
+            self.dragOffset = self.data['pos'][ind] - pos
+        elif ev.isFinish():
+            self.dragPoint = None
+            return
+        else:
+            if self.dragPoint is None:
+                ev.ignore()
+                return
+
+        ind = self.dragPoint.data()[0]
+        temp_pos = ev.pos()
+        if temp_pos[0] <= self.data['pos'][ind - 1, 0]:
+            temp_pos[0] = self.data['pos'][ind - 1, 0] + 1
+        if temp_pos[0] >= self.data['pos'][ind + 1, 0]:
+            temp_pos[0] = self.data['pos'][ind + 1, 0] - 1
+
+        self.data['pos'][ind] = temp_pos + self.dragOffset
+        self.data['pos'][self.data['pos'][:, 1] > self.y_range, 1] = self.y_range
+        self.data['pos'][self.data['pos'][:, 1] < 0, 1] = 0
+        self.updateGraph()
+        self.mouseDragged.emit((ev, ind))
+        ev.accept()
+
+    def clear(self):
+        self.scatter.clear()
+
+
+
+class TriangulationPoints(pg.GraphItem):
+    mouseHovered = pyqtSignal(object)
+    mouseDragged = pyqtSignal(object)
+    mouseClicked = pyqtSignal(object)
+
+    def __init__(self):
+        self.dragPoint = None
+        self.dragOffset = None
+        pg.GraphItem.__init__(self)
+        self.scatter.sigClicked.connect(self.onclick)
+        self.data = None
+        self.y_range = None
+        self.x_range = None
+
+    def setData(self, **kwds):
+        self.data = kwds
+        if 'pos' in self.data:
+            self.npts = self.data['pos'].shape[0]
+            self.data['data'] = np.empty(self.npts, dtype=[('index', int)])
+            self.data['data']['index'] = np.arange(self.npts)
+        self.update_graph()
+
+    def set_range(self, x_range, y_range):
+        self.x_range = x_range
+        self.y_range = y_range
+
+    def mouseDragEvent(self, ev):
+        if ev.button() != Qt.MouseButton.LeftButton:
+            ev.ignore()
+            return
+
+        if ev.isStart():
+            pos = ev.buttonDownPos()
+            pts = self.scatter.pointsAt(pos)
+            if len(pts) == 0:
+                # self.mouseClicked.emit(ev)
+                ev.ignore()
+                return
+            self.dragPoint = pts[0]
+            ind = pts[0].data()[0]
+
+            self.dragOffset = self.data['pos'][ind] - pos
+        elif ev.isFinish():
+            self.dragPoint = None
+            return
+        else:
+            if self.dragPoint is None:
+                ev.ignore()
+                return
+
+        ind = self.dragPoint.data()[0]
+        temp_pos = ev.pos()
+        if temp_pos[0] <= 0:
+            temp_pos[0] = 0
+        if temp_pos[0] >= self.x_range:
+            temp_pos[0] = self.x_range
+        if temp_pos[1] <= 0:
+            temp_pos[1] = 0
+        if temp_pos[1] >= self.y_range:
+            temp_pos[1] = self.y_range
+
+        self.data['pos'][ind] = temp_pos + self.dragOffset
+
+        self.update_graph()
+        self.mouseDragged.emit((ev, ind))
+        ev.accept()
+
+    def update_graph(self):
+        pg.GraphItem.setData(self, **self.data)
+
+    def onclick(self, ev, point):
+        ind = point[0].data()[0]
+        self.mouseClicked.emit((ev, ind))
+
+
+
+
+
+class TriangulationPointsTest(pg.ScatterPlotItem):
+    mouseHovered = pyqtSignal(object)
+    mouseDragged = pyqtSignal(object)
+    mouseClicked = pyqtSignal(object)
+
+    def __init__(self):
+
+        pg.ScatterPlotItem.__init__(self)
+        self.sigClicked.connect(self.onclick)
+
+        self.data = None
+
+        self.y_range = None
+        self.x_range = None
+
+        self.drag_point = None
+        self.drag_offset = None
+
+        dtype = [
+            ('x', float),
+            ('y', float),
+            ('size', float),
+            ('symbol', object),
+            ('pen', object),
+            ('brush', object),
+            ('visible', bool),
+            ('data', object),
+            ('hovered', bool),
+            ('item', object),
+            ('index', int),
+            ('sourceRect', [
+                ('x', int),
+                ('y', int),
+                ('w', int),
+                ('h', int)
+            ])
+        ]
+
+        self.data = np.empty(0, dtype=dtype)
+
+    def setData(self, **kwds):
+        self.data = kwds
+        if 'pos' in self.data:
+            self.npts = self.data['pos'].shape[0]
+            self.data['data'] = np.empty(self.npts, dtype=[('index', int)])
+            self.data['data']['index'] = np.arange(self.npts)
+        # self.update_graph()
+
+    def set_range(self, x_range, y_range):
+        self.x_range = x_range
+        self.y_range = y_range
+
+    def mouseDragEvent(self, ev):
+        if ev.button() != Qt.MouseButton.LeftButton:
+            ev.ignore()
+            return
+
+        if ev.isStart():
+            pos = ev.buttonDownPos()
+            pts = self.pointsAt(pos)
+            if len(pts) == 0:
+                # self.mouseClicked.emit(ev)
+                ev.ignore()
+                return
+            self.dragPoint = pts[0]
+            ind = pts[0].data()[0]
+
+            self.drag_offset = self.data['pos'][ind] - pos
+        elif ev.isFinish():
+            self.drag_point = None
+            return
+        else:
+            if self.drag_point is None:
+                ev.ignore()
+                return
+
+        ind = self.dragPoint.data()[0]
+        temp_pos = ev.pos()
+        if temp_pos[0] <= 0:
+            temp_pos[0] = 0
+        if temp_pos[0] >= self.x_range:
+            temp_pos[0] = self.x_range
+        if temp_pos[1] <= 0:
+            temp_pos[1] = 0
+        if temp_pos[1] >= self.y_range:
+            temp_pos[1] = self.y_range
+
+        self.data['pos'][ind] = temp_pos + self.dragOffset
+
+        self.setData(pos=self.data['pos'])
+        self.mouseDragged.emit((ev, ind))
+        ev.accept()
+
+    # def update_graph(self):
+    #     pg.ScatterPlotItem.setData(self, **self.data)
+
+    def onclick(self, ev, point):
+        ind = point[0].data()[0]
+        self.mouseClicked.emit((ev, ind))

driftlessmap/obj_items.py

@@ -0,0 +1,122 @@
+import os
+import pickle
+import pyqtgraph as pg
+import pyqtgraph.opengl as gl
+import numpy as np
+import scipy.ndimage as ndi
+
+
+def get_object_vis_color(color):
+    vis_color = (color[0] / 255, color[1] / 255, color[2] / 255, 1)
+    return vis_color
+
+
+def create_plot_points_in_3d(data_dict):
+    data_list = data_dict['data']
+    pnts = data_list[0]
+    for i in range(1, len(data_list)):
+        pnts = np.vstack([pnts, data_list[i]])
+    vis_color = get_object_vis_color(data_dict['vis_color'])
+    vis_points = gl.GLScatterPlotItem(pos=pnts, color=vis_color, size=3)
+    return vis_points
+
+
+def create_probe_line_in_3d(data_dict):
+    pos = np.stack([data_dict['insertion_coords_3d'], data_dict['terminus_coords_3d']], axis=0)
+    vis_color = get_object_vis_color(data_dict['vis_color'])
+    probe_line = gl.GLLinePlotItem(pos=pos, color=vis_color, width=2, mode='line_strip')
+    return probe_line
+
+
+def create_drawing_in_3d(data_dict):
+    data_list = data_dict['data']
+    pos = data_list[0]
+    for i in range(1, len(data_list)):
+        pos = np.vstack([pos, data_list[i]])
+
+    vis_color = get_object_vis_color(data_dict['vis_color'])
+    if data_dict['plot_mode'] == 'area':
+        drawing_obj = gl.GLScatterPlotItem(pos=pos, color=vis_color, size=3, pxMode=True)
+    else:
+        drawing_obj = gl.GLLinePlotItem(pos=pos, color=vis_color, width=2, mode='line_strip')
+    return drawing_obj
+
+
+def create_contour_line_in_3d(data_dict):
+    data_list = data_dict['data']
+    pos = data_list[0]
+    for i in range(1, len(data_list)):
+        pos = np.vstack([pos, data_list[i]])
+    if np.any(pos[0] != pos[-1]):
+        pos = np.vstack([pos, pos[0]])
+
+    vis_color = get_object_vis_color(data_dict['vis_color'])
+    contour_obj = gl.GLLinePlotItem(pos=pos, color=vis_color, width=2, mode='line_strip')
+    return contour_obj
+
+
+def make_3d_gl_widget(data_dict, obj_type):
+    if obj_type == 'merged probe':
+        obj_3d = create_probe_line_in_3d(data_dict)
+    elif obj_type == 'merged virus':
+        obj_3d = create_plot_points_in_3d(data_dict)
+    elif obj_type == 'merged cells':
+        obj_3d = create_plot_points_in_3d(data_dict)
+    elif obj_type == 'merged contour':
+        obj_3d = create_contour_line_in_3d(data_dict)
+    else:
+        obj_3d = create_drawing_in_3d(data_dict)
+    return obj_3d
+
+
+def render_volume(atlas_data, atlas_folder, factor=2, level=0.1):
+    da_data = atlas_data.copy()
+    img = np.ascontiguousarray(da_data[::factor, ::factor, ::factor])
+    verts, faces = pg.isosurface(ndi.gaussian_filter(img.astype('float64'), (2, 2, 2)), np.max(da_data) * level)
+
+    md = gl.MeshData(vertexes=verts * factor, faces=faces)
+
+    outfile = open(os.path.join(atlas_folder, 'atlas_meshdata.pkl'), 'wb')
+    pickle.dump(md, outfile)
+    outfile.close()
+
+    return md
+
+
+def render_small_volume(
+    label_id,
+    save_path,
+    atlas_data,
+    atlas_label,
+    factor=2,
+    level=0.1,
+    progress=None,
+):
+    if progress is not None:
+        progress(0.0, "copying atlas intensities")
+    temp_atlas = atlas_data.copy()
+    if progress is not None:
+        progress(0.2, "masking the selected structure")
+    temp_atlas[atlas_label != label_id] = 0
+    if progress is not None:
+        progress(0.4, "downsampling the structure volume")
+    pimg = np.ascontiguousarray(temp_atlas[::factor, ::factor, ::factor])
+    if progress is not None:
+        progress(0.5, "smoothing the structure volume")
+    smoothed = ndi.gaussian_filter(pimg.astype("float64"), (2, 2, 2))
+    if progress is not None:
+        progress(0.75, "extracting the mesh surface")
+    verts, faces = pg.isosurface(smoothed, np.max(temp_atlas) * level)
+    # small_verts_list[str(id)] = verts
+    # small_faces_list[str(id)] = faces
+
+    md = gl.MeshData(vertexes=verts * factor, faces=faces)
+
+    if progress is not None:
+        progress(0.9, "saving the generated mesh")
+    outfile = open(os.path.join(save_path, '{}.pkl'.format(label_id)), 'wb')
+    pickle.dump(md, outfile)
+    outfile.close()
+    if progress is not None:
+        progress(1.0, "mesh complete")
+