436 lines
18 KiB
Python
436 lines
18 KiB
Python
import numpy as np
|
|
|
|
from .DataExtractorLyse import DataExtractorManager
|
|
from .WidgetPlot import WidgetPlot
|
|
|
|
import pyqtgraph as pg
|
|
from pyqtgraph import OrderedDict
|
|
from PyQt5.QtWidgets import QLabel, QLineEdit
|
|
from pyqtgraph import Qt
|
|
from pyqtgraph.Qt import QtCore
|
|
from PyQt5.QtWidgets import *
|
|
from PyQt5.QtCore import *
|
|
from PyQt5.QtGui import QRegExpValidator
|
|
from PyQt5.QtCore import QRegExp
|
|
|
|
from PIL import ImageColor
|
|
|
|
color_palette_html = ['#1f77b4',
|
|
'#ff7f0e',
|
|
'#2ca02c',
|
|
'#d62728',
|
|
'#9467bd',
|
|
'#8c564b',
|
|
'#e377c2',
|
|
'#7f7f7f',
|
|
'#bcbd22',
|
|
'#17becf']
|
|
|
|
color_palette = [ImageColor.getcolor(color, "RGB") for color in color_palette_html]
|
|
|
|
Gradients = OrderedDict([
|
|
('bw', {'ticks': [(0.0, (0, 0, 0, 255)), (1, (255, 255, 255, 255))], 'mode': 'rgb'}),
|
|
('hot', {'ticks': [(0.3333, (185, 0, 0, 255)), (0.6666, (255, 220, 0,
|
|
255)), (1, (255, 255, 255, 255)), (0, (0, 0, 0, 255))],
|
|
'mode': 'rgb'}),
|
|
('jet0', {'ticks': [(1, (166, 0, 0, 255)),
|
|
(0.32247191011235954, (0, 255, 255, 255)),
|
|
(0.11348314606741573, (0, 68, 255, 255)),
|
|
(0.6797752808988764, (255, 255, 0, 255)),
|
|
(0.902247191011236, (255, 0, 0, 255)),
|
|
(0.5022471910112359, (0, 255, 0, 255)),
|
|
(0.0, (0, 0, 166, 255))],
|
|
'mode': 'rgb'}),
|
|
('jet', {'ticks': [(1, (128, 0, 0, 255)),
|
|
(0.878431372549020, (255, 0, 0, 255)),
|
|
(0.627450980392157, (255, 255, 0, 255)),
|
|
(0.376470588235294, (0, 255, 255, 255)),
|
|
(0.125490196078431, (0, 0, 255, 255)),
|
|
(0.0, (0, 0, 131, 255))],
|
|
'mode': 'rgb'}),
|
|
('summer', {'ticks': [(1, (255, 255, 0, 255)), (0.0, (0, 170, 127, 255))], 'mode': 'rgb'}),
|
|
('space', {'ticks': [(0.562, (75, 215, 227, 255)), (0.087, (255, 170, 0, 254)), (0.332, (0, 255, 0, 255)),
|
|
(0.77, (85, 0, 255, 255)), (0.0, (255, 0, 0, 255)), (1.0, (255, 0, 127, 255))],
|
|
'mode': 'rgb'}),
|
|
('winter', {'ticks': [(1, (0, 255, 127, 255)), (0.0, (0, 0, 255, 255))], 'mode': 'rgb'})
|
|
])
|
|
|
|
|
|
class WidgetFakeColorPlot(WidgetPlot):
|
|
def __init__(self, title, data_path=None, data_group=None, Isocurve=False, Roi=True, HistogramLUT=False, colorbarText=True, **kwargs):
|
|
|
|
super().__init__(title, **kwargs)
|
|
|
|
self.colorbarText = colorbarText
|
|
|
|
self.analyse_panel_update = None
|
|
|
|
# set data extractor
|
|
if data_group is None or data_group == 'results':
|
|
self.data_extractor_manager = DataExtractorManager(data_path)
|
|
self.data_extractor_manager.add_data_extractor('data_img', 'array', data_path)
|
|
self.data_extractor_manager.add_data_extractor('x', 'array', (data_path[0], 'x'))
|
|
self.data_extractor_manager.add_data_extractor('y', 'array', (data_path[0], 'y'))
|
|
self.data_extractor_manager.add_data_extractor('warning', 'single', (data_path[0], 'warning'))
|
|
else:
|
|
self.data_extractor_manager = DataExtractorManager(data_path)
|
|
self.data_extractor_manager.add_data_extractor('data_img', 'image', (data_group, data_path[0], data_path[1]))
|
|
|
|
self.data_image = None
|
|
|
|
self.setMinimumHeight(550)
|
|
self.setMinimumWidth(550)
|
|
|
|
if Roi is True:
|
|
# Add y-axis data slider
|
|
self.axsumy = self.plots.addPlot(title="")
|
|
self.axsumy.setFixedWidth(300)
|
|
self.sumy = self.axsumy.plot()
|
|
self.sumy_data = self.axsumy.plot(pen=pg.mkPen(style=QtCore.Qt.DashLine, color=color_palette[1]))
|
|
|
|
# Add imaging
|
|
self.aximg = self.plots.addPlot(title="")
|
|
self.img = pg.ImageItem()
|
|
self.aximg.addItem(self.img)
|
|
|
|
# fixe the y-axis
|
|
if Roi is True:
|
|
self.axsumy.setYLink(self.aximg)
|
|
|
|
# Contrast/color control
|
|
self.colorbar = None
|
|
if HistogramLUT is True:
|
|
self.colorbar = pg.HistogramLUTItem()
|
|
self.colorbar.setImageItem(self.img)
|
|
self.colormap = Gradients['jet']
|
|
self.colorbar.gradient.restoreState(self.colormap)
|
|
self.plots.addItem(self.colorbar)
|
|
else:
|
|
colormap = pg.colormap.getFromMatplotlib('jet')
|
|
self.colorbar = pg.ColorBarItem(cmap=colormap, values=(0, 1))
|
|
self.colorbar.setImageItem(self.img, insert_in=self.aximg)
|
|
|
|
self.iso = None
|
|
self.roi = None
|
|
|
|
if Isocurve is True:
|
|
# Isocurve draplotsg
|
|
self.iso = pg.IsocurveItem(level=0, pen=color_palette[2])
|
|
self.iso.setParentItem(self.img)
|
|
self.iso.setZValue(5)
|
|
|
|
# Draggable line for setting isocurve level
|
|
self.isoLine = pg.InfiniteLine(angle=0, movable=True, pen=color_palette[2])
|
|
self.colorbar.vb.addItem(self.isoLine)
|
|
self.colorbar.vb.setMouseEnabled(y=False) # makes user interaction a little easier
|
|
self.isoLine.setValue(1000)
|
|
self.isoLine.setZValue(1000) # bring iso line above contrast controls
|
|
self.isoLine.sigDragged.connect(self.updateIsocurve)
|
|
|
|
self.plots.nextRow()
|
|
|
|
if Roi is True:
|
|
# Custom ROI for selecting an image region
|
|
self.roi = pg.ROI([500, 500], [300, 300], pen={'color': 'k', 'width': 4})
|
|
|
|
self.roi.addScaleHandle([1, 0], [0.5, 0.5])
|
|
self.roi.addScaleHandle([0, 1], [0.5, 0.5])
|
|
|
|
self.aximg.addItem(self.roi)
|
|
self.roi.setZValue(10) # make sure ROI is drawn above image
|
|
self.roi_ax = self.plots.addPlot()
|
|
self.roi_ax.setFixedHeight(300)
|
|
self.roi_ax.setFixedWidth(300)
|
|
|
|
self.roi_img = pg.ImageItem()
|
|
self.roi_ax.addItem(self.roi_img)
|
|
|
|
roi_colormap = pg.colormap.getFromMatplotlib('jet')
|
|
self.roi_img.setColorMap(roi_colormap)
|
|
|
|
self.roi.sigRegionChanged.connect(self.updateROI)
|
|
self.colorbar.sigLevelsChanged.connect(self.updateROI)
|
|
|
|
# Add x-axis data slider
|
|
self.axsumx = self.plots.addPlot()
|
|
self.axsumx.setFixedHeight(300)
|
|
self.axsumx.setXLink(self.aximg)
|
|
self.sumx = self.axsumx.plot()
|
|
self.sumx_data = self.axsumx.plot(pen=pg.mkPen(style=QtCore.Qt.DashLine, color=color_palette[1]))
|
|
|
|
# Monkey-patch the image to use our custom hover function.
|
|
# This is generally discouraged (you should subclass ImageItem instead),
|
|
# but it works for a very simple use like this.
|
|
self.img.hoverEvent = self.imageHoverEvent
|
|
|
|
self.plots.nextRow()
|
|
self.plots.nextColumn()
|
|
self.img.translate(-0.5, -0.5)
|
|
|
|
self.scalex = 1
|
|
self.scaley = 1
|
|
|
|
self.cx = 0
|
|
self.cy = 0
|
|
|
|
#Add text box for colorbar and ROI
|
|
self.colorbar_ROI_box = QSplitter()
|
|
self.colorbar_ROI_box.setOrientation(Qt.Horizontal)
|
|
|
|
if colorbarText is True:
|
|
# Add text box for colorbar
|
|
self.colorbar_box = QSplitter()
|
|
self.colorbar_box.setOrientation(Qt.Vertical)
|
|
|
|
self.colorbar_title = QLabel('Color Bar')
|
|
self.colorbar_title.setAlignment(Qt.AlignCenter)
|
|
|
|
self.colorbar_box_container = QSplitter()
|
|
self.colorbar_box_container.setOrientation(Qt.Horizontal)
|
|
|
|
self.colorbar_box_max_label = QLabel(' Max: ')
|
|
self.colorbar_box_max_label.setAlignment(Qt.AlignCenter)
|
|
self.colorbar_box_max_line = QLineEdit(self)
|
|
double_regex = QRegExp("^[-+0-9.]+$")
|
|
double_validator = QRegExpValidator(double_regex, self.colorbar_box_max_line)
|
|
self.colorbar_box_max_line.setValidator(double_validator)
|
|
self.colorbar_box_max_line.setAlignment(Qt.AlignLeft)
|
|
|
|
self.colorbar_box_min_label = QLabel(' Min: ')
|
|
self.colorbar_box_min_label.setAlignment(Qt.AlignCenter)
|
|
self.colorbar_box_min_line = QLineEdit(self)
|
|
double_regex = QRegExp("^[-+0-9.]+$")
|
|
double_validator = QRegExpValidator(double_regex, self.colorbar_box_min_line)
|
|
self.colorbar_box_min_line.setValidator(double_validator)
|
|
self.colorbar_box_min_line.setAlignment(Qt.AlignLeft)
|
|
|
|
self.colorbar_box_label = QSplitter()
|
|
self.colorbar_box_label.setOrientation(Qt.Vertical)
|
|
self.colorbar_box_line = QSplitter()
|
|
self.colorbar_box_line.setOrientation(Qt.Vertical)
|
|
self.colorbar_box_label.addWidget(self.colorbar_box_max_label)
|
|
self.colorbar_box_label.addWidget(self.colorbar_box_min_label)
|
|
self.colorbar_box_line.addWidget(self.colorbar_box_max_line)
|
|
self.colorbar_box_line.addWidget(self.colorbar_box_min_line)
|
|
|
|
self.colorbar_box_container.addWidget(self.colorbar_box_label)
|
|
self.colorbar_box_container.addWidget(self.colorbar_box_line)
|
|
|
|
self.colorbar_box.addWidget(self.colorbar_title)
|
|
self.colorbar_box.addWidget(self.colorbar_box_container)
|
|
|
|
self.colorbar_box_max_line.editingFinished.connect(self.update_colorbar_text)
|
|
self.colorbar_box_min_line.editingFinished.connect(self.update_colorbar_text)
|
|
|
|
if Roi is True:
|
|
#Add text box for ROI
|
|
self.roi_box = QSplitter()
|
|
self.roi_box.setOrientation(Qt.Vertical)
|
|
|
|
self.roi_box_title = QLabel('Region of Interest')
|
|
self.roi_box_title.setAlignment(Qt.AlignCenter)
|
|
|
|
self.roi_box_container = QSplitter()
|
|
self.roi_box_container.setOrientation(Qt.Horizontal)
|
|
self.roi_center_container = QSplitter()
|
|
self.roi_center_container.setOrientation(Qt.Horizontal)
|
|
self.roi_span_container = QSplitter()
|
|
self.roi_span_container.setOrientation(Qt.Horizontal)
|
|
|
|
self.roi_center_label = QSplitter()
|
|
self.roi_center_label.setOrientation(Qt.Vertical)
|
|
self.roi_center_line = QSplitter()
|
|
self.roi_center_line.setOrientation(Qt.Vertical)
|
|
|
|
self.roi_span_label = QSplitter()
|
|
self.roi_span_label.setOrientation(Qt.Vertical)
|
|
self.roi_span_line = QSplitter()
|
|
self.roi_span_line.setOrientation(Qt.Vertical)
|
|
|
|
self.roi_center_x_label = QLabel(' X: ')
|
|
self.roi_center_x_label.setAlignment(Qt.AlignCenter)
|
|
self.roi_center_x_line = QLineEdit(self)
|
|
double_regex = QRegExp("^[-+0-9.]+$")
|
|
double_validator = QRegExpValidator(double_regex, self.roi_center_x_line)
|
|
self.roi_center_x_line.setValidator(double_validator)
|
|
self.roi_center_x_line.setAlignment(Qt.AlignLeft)
|
|
|
|
self.roi_center_y_label = QLabel(' Y: ')
|
|
self.roi_center_y_label.setAlignment(Qt.AlignCenter)
|
|
self.roi_center_y_line = QLineEdit(self)
|
|
double_regex = QRegExp("^[-+0-9.]+$")
|
|
double_validator = QRegExpValidator(double_regex, self.roi_center_y_line)
|
|
self.roi_center_y_line.setValidator(double_validator)
|
|
self.roi_center_y_line.setAlignment(Qt.AlignLeft)
|
|
|
|
self.roi_span_x_label = QLabel(' X Span: ')
|
|
self.roi_span_x_label.setAlignment(Qt.AlignCenter)
|
|
self.roi_span_x_line = QLineEdit(self)
|
|
double_regex = QRegExp("^[-+0-9.]+$")
|
|
double_validator = QRegExpValidator(double_regex, self.roi_span_x_line)
|
|
self.roi_span_x_line.setValidator(double_validator)
|
|
self.roi_span_x_line.setAlignment(Qt.AlignLeft)
|
|
|
|
self.roi_span_y_label = QLabel(' Y Span: ')
|
|
self.roi_span_y_label.setAlignment(Qt.AlignCenter)
|
|
self.roi_span_y_line = QLineEdit(self)
|
|
double_regex = QRegExp("^[-+0-9.]+$")
|
|
double_validator = QRegExpValidator(double_regex, self.roi_span_y_line)
|
|
self.roi_span_y_line.setValidator(double_validator)
|
|
self.roi_span_y_line.setAlignment(Qt.AlignLeft)
|
|
|
|
self.roi_center_label.addWidget(self.roi_center_x_label)
|
|
self.roi_center_label.addWidget(self.roi_center_y_label)
|
|
self.roi_center_line.addWidget(self.roi_center_x_line)
|
|
self.roi_center_line.addWidget(self.roi_center_y_line)
|
|
self.roi_span_label.addWidget(self.roi_span_x_label)
|
|
self.roi_span_label.addWidget(self.roi_span_y_label)
|
|
self.roi_span_line.addWidget(self.roi_span_x_line)
|
|
self.roi_span_line.addWidget(self.roi_span_y_line)
|
|
|
|
self.roi_center_container.addWidget(self.roi_center_label)
|
|
self.roi_center_container.addWidget(self.roi_center_line)
|
|
self.roi_span_container.addWidget(self.roi_span_label)
|
|
self.roi_span_container.addWidget(self.roi_span_line)
|
|
|
|
self.roi_box_container.addWidget(self.roi_center_container)
|
|
self.roi_box_container.addWidget(self.roi_span_container)
|
|
self.roi_box.addWidget(self.roi_box_title)
|
|
self.roi_box.addWidget(self.roi_box_container)
|
|
|
|
self.roi_center_x_line.editingFinished.connect(self.updateROI_text)
|
|
self.roi_center_y_line.editingFinished.connect(self.updateROI_text)
|
|
self.roi_span_x_line.editingFinished.connect(self.updateROI_text)
|
|
self.roi_span_y_line.editingFinished.connect(self.updateROI_text)
|
|
|
|
self.colorbar_ROI_box.addWidget(self.colorbar_box)
|
|
self.colorbar_ROI_box.addWidget(self.roi_box)
|
|
|
|
self.bottom.addWidget(self.colorbar_ROI_box)
|
|
|
|
def update(self, h5_path):
|
|
|
|
data = self.data_extractor_manager.get_data(h5_path)
|
|
self.data_image = data['data_img']
|
|
|
|
try:
|
|
x = data['x']
|
|
y = data['y']
|
|
warning = data['warning']
|
|
except:
|
|
x = None
|
|
y = None
|
|
warning = None
|
|
|
|
if x is None:
|
|
x = np.linspace(0, self.data_image.shape[0], self.data_image.shape[0])
|
|
if y is None:
|
|
y = np.linspace(0, self.data_image.shape[1], self.data_image.shape[1])
|
|
|
|
# update plots
|
|
if self.colorbarText is True:
|
|
self.img.setImage(self.data_image.T, autoLevels=False)
|
|
else:
|
|
self.img.setImage(self.data_image.T, autoLevels=True)
|
|
self.colorbar.setLevels((np.min(self.data_image), np.max(self.data_image)))
|
|
|
|
if self.iso is not None:
|
|
self.iso.setData(self.data_image.T)
|
|
|
|
# set position and scale of image
|
|
newscalex = x[1] - x[0]
|
|
newscaley = y[1] - y[0]
|
|
|
|
transx = (x[0] - (self.cx - 0.5 * self.scalex)) / newscalex - 0.5
|
|
transy = (y[0] - (self.cy - 0.5 * self.scaley)) / newscaley - 0.5
|
|
|
|
self.img.scale(newscalex / self.scalex, newscaley / self.scaley)
|
|
self.img.translate(transx, transy)
|
|
|
|
self.scalex = newscalex
|
|
self.scaley = newscaley
|
|
|
|
self.cx = x[0]
|
|
self.cy = y[0]
|
|
|
|
# update the region of interest
|
|
if self.roi is not None:
|
|
self.updateROI()
|
|
|
|
# update table and warning
|
|
self.update_warning(warning)
|
|
|
|
if self.analyse_panel_update is not None:
|
|
self.analyse_panel_update()
|
|
|
|
def updateIsocurve(self):
|
|
self.iso.setLevel(self.isoLine.value())
|
|
|
|
def update_colorbar_text(self):
|
|
colorbar_max = self.colorbar_box_max_line.text()
|
|
colorbar_min = self.colorbar_box_min_line.text()
|
|
colorbar_max = float(colorbar_max)
|
|
colorbar_min = float(colorbar_min)
|
|
try:
|
|
self.colorbar.setLevels(min=colorbar_min, max=colorbar_max)
|
|
except:
|
|
self.colorbar.setLevels(low=colorbar_min, high=colorbar_max)
|
|
if self.roi is not None:
|
|
self.updateROI()
|
|
|
|
def updateROI(self):
|
|
selected = self.roi.getArrayRegion(self.data_image.T, self.img)
|
|
try:
|
|
levels = self.colorbar.getLevels()
|
|
except:
|
|
levels = self.colorbar.levels()
|
|
self.roi_img.setImage(selected, levels=levels)
|
|
|
|
colorbar_min, colorbar_max = levels
|
|
self.colorbar_box_max_line.setText(str(colorbar_max))
|
|
self.colorbar_box_min_line.setText(str(colorbar_min))
|
|
|
|
x_center, y_center = self.roi.pos()
|
|
x_span, y_span = self.roi.size()
|
|
x_center = x_center + x_span / 2
|
|
y_center = y_center + y_span / 2
|
|
self.roi_center_x_line.setText(str(x_center))
|
|
self.roi_center_y_line.setText(str(y_center))
|
|
self.roi_span_x_line.setText(str(x_span))
|
|
self.roi_span_y_line.setText(str(y_span))
|
|
|
|
roi_pos = self.roi.pos()
|
|
|
|
pos = int(selected.shape[0]/2)
|
|
x = np.linspace(roi_pos[1], roi_pos[1] + selected.shape[1], selected.shape[1])
|
|
self.sumy_data.setData(x=np.squeeze(selected[pos:pos+1, :]), y=x)
|
|
|
|
pos = int(selected.shape[1] / 2)
|
|
x = np.linspace(roi_pos[0], roi_pos[0] + selected.shape[0], selected.shape[0])
|
|
self.sumx_data.setData(x=x, y=np.squeeze(selected[:, pos:pos + 1]))
|
|
|
|
def updateROI_text(self):
|
|
x_center = float(self.roi_center_x_line.text())
|
|
y_center = float(self.roi_center_y_line.text())
|
|
x_span = float(self.roi_span_x_line.text())
|
|
y_span = float(self.roi_span_y_line.text())
|
|
x = x_center - x_span / 2
|
|
y = y_center - y_span / 2
|
|
self.roi.setPos((x, y))
|
|
self.roi.setSize((x_span, y_span))
|
|
|
|
def imageHoverEvent(self, event):
|
|
"""Show the position, pixel, and value under the mouse cursor.
|
|
"""
|
|
if event.isExit():
|
|
self.aximg.setTitle("")
|
|
return
|
|
pos = event.pos()
|
|
i, j = pos.y(), pos.x()
|
|
i = int(np.clip(i, 0, self.data_image.shape[0] - 1))
|
|
j = int(np.clip(j, 0, self.data_image.shape[1] - 1))
|
|
val = self.data_image[i, j]
|
|
ppos = self.img.mapToParent(pos)
|
|
x, y = ppos.x(), ppos.y()
|
|
self.aximg.setTitle("pos: (%0.1f, %0.1f) value: %g" % (x, y, val))
|