def _show_boxes(self, state=None):
if self.ops is None:
return
handle_pen = pg.mkPen('#00000000')
if self.show_btn.isChecked():
if self.show_boxes:
[self.imview.removeItem(box) for box in self.tr_boxes]
if len(self.boxes) == 0:
for i in range(len(self.ops.pos_x)):
roi = pg.PolyLineROI([], closed=True, movable=False)
roi.handlePen = handle_pen
roi.setPoints(self.ops.grid_points[i])
self.boxes.append(roi)
self.imview.addItem(roi)
else:
[self.imview.addItem(box) for box in self.boxes]
else:
if self.show_boxes:
[self.imview.removeItem(box) for box in self.boxes]
if len(self.tr_boxes) == 0:
for i in range(len(self.ops.tf_grid_points)):
roi = pg.PolyLineROI([], closed=True, movable=False)
roi.handlePen = handle_pen
roi.setPoints(self.ops.tf_grid_points[i])
self.tr_boxes.append(roi)
self.imview.addItem(roi)
else:
[self.imview.addItem(box) for box in self.tr_boxes]
self.show_boxes = True
def mouseMoved(self, pos):
#print(evt[0])
#print("Image position:", self.imageItem.mapFromScene(pos))
#pdb.set_trace()
#if self.mouseButton1 == 'on':
#print('ButtonState:', QtCore.Qt.NoButton)
print('Moving Mouse')
#print(pos.button())
#pdb.set_trace()
#print(pos.button())
#pos = pos.scenePos()
if self.ui.radioAreaROI.isChecked():
#if self.button1 == 'on':
if self.view.scene().clickEvents:
if self.view.scene().clickEvents[0].button() == 1:
print('Saving xy')
#pdb.set_trace()
if self.view .sceneBoundingRect().contains(pos):
self.clicked.append(self.view.scene().clickEvents)
mousePoint = self.view.mapSceneToView(pos)
index = int(mousePoint.x())
if index > 0 and index < self.image.shape[self.axes['x']]:
#label.setText("<span style='font-size: 12pt'>x=%0.1f, <span style='color: red'>y1=%0.1f</span>, <span style='color: green'>y2=%0.1f</span>" % (mousePoint.x(), data1[index], data2[index]))
#print(mousePoint.x())
#print(mousePoint.y())
#return(mousePoint.x(), mousePoint.y())
#pdb.set_trace()
if self.ccroi:
self.view.removeItem( self.ccroi) #removed roi generated from previous movements
#self.croi.append([mousePoint.x(), mousePoint.y(), self.currentLayer])#crois is the current roi being selected
self.croi.append([mousePoint.x(), mousePoint.y(), self.currentLayer])
self.ccroi = pg.PolyLineROI(self.croi, closed = False)
self.view.addItem( self.ccroi)
print('appending roi coordinates')
print(self.croi) #crois is the current roi
else:
if self.croi:
if self.ccroi:
self.view.removeItem( self.ccroi) #remove the roi built has the mouse was dragged
#generate a novel key for dictionary holding rois
testname = 0
while testname in self.aroi.keys():
testname += 1
self.aroi[testname] = {self.currentLayer : self.croi}
#pdb.set_trace()
self.aaroi.append(pg.PolyLineROI(self.croi, closed= True))
self.view.addItem(self.aaroi[-1])
self.croi = []
self.ccroi =[]
print('transfered current roi (croi) to list for all rois (aroi)')
def __init__(self, *args, **kwargs):
super(SAXSViewerPluginBase, self).__init__(*args, **kwargs)
self.axesItem.invertY(False)
# Setup coordinates label
# self.coordinatesLbl = QLabel('--COORDINATES WILL GO HERE--')
# self.ui.gridLayout.addWidget(self.coordinatesLbl, 3, 0, 1, 1, alignment=Qt.AlignHCenter)
# Setup mask layer
# TODO -- put in mixin
self.maskimage = pg.ImageItem(opacity=.25, axisOrder='row-major')
self.view.addItem(self.maskimage)
# Setup calibration layer
# TODO -- put in mixin
self.calibrantimage = pg.ImageItem(opacity=.25)
self.view.addItem(self.calibrantimage)
# Empty ROI for later use
# TODO -- refactor poly masking
self.maskROI = pg.PolyLineROI([],
closed=True,
movable=False,
pen=pg.mkPen(color='r', width=2))
self.maskROI.handlePen = pg.mkPen(color='r', width=2)
self.maskROI.handleSize = 10
self.view.addItem(self.maskROI)
def update_roi(self, enable: bool = True):
"""Triggered when the ROI of the image changes"""
if enable:
if not self.use_roi:
self.set_status("Enabling ROI")
self.use_roi = True
if self.roi is None:
self.roi = pg.PolyLineROI(
[[10, 10], [20, 200], [100, 300], [300, 100]],
closed=True,
movable=True,
removable=True)
self.roi.sigRegionChangeFinished.connect(self.update_roi)
# self.roi.sigRemoveRequested.connect(lambda: self.update_roi(False))
self.disp_ctrl.widgets['img'].getView().addItem(self.roi)
self.set_status("Flagging ROI update")
self.roi_coords = None # Flags for the generation of coords on the next frame.
self.reset_status()
if not enable and self.use_roi:
self.set_status("Disabling ROI")
self.use_roi = False
self.disp_ctrl.widgets['img'].getView().removeItem(self.roi)
self.reset_status()
def zLineChanged(self):
print('zLineChanged')
#(ind, time) = self.timeIndex(self.ui.timeSlider)
if self.ignoreZLine:
return
(ind, time) = self.layerIndex(self.zLine)
print('ind')
print(ind)
print('time')
print(time)
print('zLineValue')
print(self.zLine.value())
if ind != self.currentLayer:
self.currentLayer = ind
self.updateImage()
#self.timeLine.setPos(time)
#self.emit(QtCore.SIGNAL('timeChanged'), ind, time)
self.sigTimeChanged.emit(ind, time)
#remove old rois
for croi in self.aaroi:
self.view.removeItem( croi)
#change layer number in textbox
self.ui.ztext.setText(str(self.currentLayer))
#re-draw rois for the new layer
for ckey in self.aroi.keys():
croi = self.aroi[ckey]
if self.currentLayer in croi.keys():
#pdb.set_trace()
if len(self.aroi[ckey][self.currentLayer]) == 2:
self.aaroi.append(pg.CircleROI(self.circlePosition(self.aroi[ckey][self.currentLayer]), [self.markerRadius, self.markerRadius]))
else:
self.aaroi.append(pg.PolyLineROI(self.aroi[ckey][self.currentLayer], closed= True))
self.view.addItem(self.aaroi[-1])
def __init__(self, xrd_form, rois_update = None):
PyQt5.QtGui.QWidget.__init__(self)
self.Omegas, self.Theta2s, self.grid = None, None, None
self.ui = xrd_form()
self.ui.setupUi(self)
self.imageView = self.ui.graphicsView
self.imageItem = self.imageView.getImageItem()
self.ui.pushButton.clicked.connect(self.selectFile)
# Add ROI
pens = []
rois = []
pens.append(pg.mkPen('y'))
rois.append(pg.PolyLineROI([[0, 0], [0, 50], [50, 50], [50, 0]], pen=pens[-1], closed=True))
for roi in rois:
self.imageView.addItem(roi)
if rois_update is not None :
for i, roi_update in enumerate(rois_update):
rois[i].sigRegionChanged.connect(lambda x : self.update(x, roi_update, pens[i]))
self.setAcceptDrops(True)
def add_roi(self):
if self._model.has_segmentation_image:
defaultx = self._model.segmentation_image.shape[0] / 2
defaulty = self._model.segmentation_image.shape[1] / 2
w = np.floor(
np.min([
self._model.segmentation_image.shape[0] / 10,
self._model.segmentation_image.shape[1] / 10
]))
roi = pg.PolyLineROI(
[[defaulty - w, defaultx - w], [defaulty - w, defaultx + w],
[defaulty + w, defaultx + w], [defaulty + w, defaultx - w]],
closed=True,
movable=True)
roi.sigRegionChanged.connect(self.update_roi_list)
label = "ROI_" + str(len(self.all_models.rois.keys()) + 1)
self.all_models.rois[label] = [roi, self.map_roi_to_image(roi)]
self._ui.ROIListView.addItem(label)
self._ui.graphicsView.view.addItem(roi)
self._filter_table_model.non_class_filterable_object_list.append(
label)
self._filter_table_model.class_list_changed([
row.label
for row in self._seg_class_model._color_table.values()
])
def add_rois_of_selected(self):
"""
Using find_contours to get list of contour coordinates in the binary mask, and then generate polygon rois based on these coordinates.
"""
for selected_index in self.selected_ML_Index:
contours = self.selected_cells_infor_dict['cell{}_verts'.format(
str(selected_index))]
# contours = find_contours(self.Mask[:,:,selected_index], 0.5) # Find iso-valued contours in a 2D array for a given level value.
for n, contour in enumerate(contours):
contour_coord_array = contours[n]
#Swap columns
contour_coord_array[:,
0], contour_coord_array[:,
1] = contour_coord_array[:,
1], contour_coord_array[:, 0].copy(
)
#Down sample the coordinates otherwise it will be too dense.
contour_coord_array_del = np.delete(
contour_coord_array,
np.arange(2, contour_coord_array.shape[0] - 3, 2), 0)
self.selected_cells_infor_dict['cell{}_ROIitem'.format(str(selected_index))] = \
pg.PolyLineROI(positions=contour_coord_array_del, closed=True)
self.Mask_edit_view.getView().addItem(
self.selected_cells_infor_dict['cell{}_ROIitem'.format(
str(selected_index))])
def test_getArrayRegion(transpose=False):
pr = pg.PolyLineROI([[0, 0], [27, 0], [0, 28]], closed=True)
pr.setPos(1, 1)
rois = [
(pg.ROI([1, 1], [27, 28], pen='y'), 'baseroi'),
(pg.RectROI([1, 1], [27, 28], pen='y'), 'rectroi'),
(pg.EllipseROI([1, 1], [27, 28], pen='y'), 'ellipseroi'),
(pr, 'polylineroi'),
]
for roi, name in rois:
# For some ROIs, resize should not be used.
testResize = not isinstance(roi, pg.PolyLineROI)
origMode = pg.getConfigOption('imageAxisOrder')
try:
if transpose:
pg.setConfigOptions(imageAxisOrder='row-major')
check_getArrayRegion(roi,
'roi/' + name,
testResize,
transpose=True)
else:
pg.setConfigOptions(imageAxisOrder='col-major')
check_getArrayRegion(roi, 'roi/' + name, testResize)
finally:
pg.setConfigOptions(imageAxisOrder=origMode)
def pol(arr):
## Create image to display
# arr = np.random.random((100,100))
## create GUI
app = QtGui.QApplication([])
w = pg.GraphicsWindow(size=(1000, 800), border=True)
w.setWindowTitle('pyqtgraph example: ROI Examples')
text = """Data Selection From Image.<br>\n
Drag an ROI """
w1 = w.addLayout(row=0, col=0)
label1 = w1.addLabel(text, row=0, col=0)
v1a = w1.addViewBox(row=1, col=0, lockAspect=True)
img1a = pg.ImageItem(arr)
# Get the colormap
colormap = cm.get_cmap("viridis") # cm.get_cmap("CMRmap")
colormap._init()
lut = (colormap._lut * 255).view(
np.ndarray) # Convert matplotlib colormap from 0-1 to 0 -255 for Qt
# Apply the colormap
img1a.setLookupTable(lut)
v1a.addItem(img1a)
v1a.disableAutoRange('xy')
v1a.autoRange()
rois = []
rois.append(
pg.PolyLineROI([[80, 60], [90, 30], [60, 40]], pen=(6, 9),
closed=True))
def update(roi):
roi.getArrayRegion(arr, img1a)
for roi in rois:
roi.sigRegionChanged.connect(update)
v1a.addItem(roi)
# update(rois[-1])
# mask=roi.getArrayRegion(arr, img1a)
## Start Qt event loop unless running in interactive mode or using pyside.
if __name__ == '__main__':
import sys
if (sys.flags.interactive != 1) or not hasattr(QtCore, 'PYQT_VERSION'):
QtGui.QApplication.instance().exec_()
mask = roi.getArrayRegion(arr, img1a)
pts = roi.getState()['points']
return mask, pts
def initROIs(self, img_shape):
"""Initialize the ROI markers"""
#
# Mask ROI
#
angles = np.linspace(0, 2 * np.pi, MASK_INIT_RESOLUTION)
xs = img_shape[0] * (1 + 0.9 * np.cos(angles)) / 2
ys = img_shape[1] * (1 + 0.9 * np.sin(angles)) / 2
mask_positions = np.vstack((xs, ys)).T
self.mask_ROI = pg.PolyLineROI(mask_positions,
closed=True,
pen=dict(color=(255, 0, 0), width=2))
self.mask_ROI.setVisible(False)
self.plot_area.vb.addItem(self.mask_ROI)
#
# Reconstruction ROI
#
self.ROI = pg.RectROI([20, 20], [20, 20], pen=(0, 9))
self.ROI.addRotateHandle([1, 0], [0.5, 0.5])
self.ROI.setVisible(False)
#
# Callback when the user stops moving a ROI.
#
self.ROI.sigRegionChangeFinished.connect(self._ROI_updated)
self.mask_ROI.sigRegionChangeFinished.connect(self._mask_ROI_updated)
self.plot_area.vb.addItem(self.ROI)
def add_roi(self, roi):
handles = roi.getHandles()
positions = []
for h in handles:
pos = (h.pos().x(), h.pos().y())
positions.append(pos)
r = pg.PolyLineROI(positions=positions, closed=True)
self.plot_item.addItem(r)
def __init__(self, w, h):
self.window2 = QtGui.QWidget()
self.window2.resize(w, h)
layout = QtGui.QGridLayout()
self.window2.setLayout(layout)
self.sl_frame = QtGui.QSlider()
self.sl_frame.setOrientation(QtCore.Qt.Horizontal)
self.sl_frame.setMinimum(1)
self.sl_frame.setMaximum(255)
self.sl_frame.setValue(1)
self.sl_frame.setTickPosition(QtGui.QSlider.TicksBelow)
self.sl_frame.setTickInterval(1000)
self.sl_frame.setGeometry(QtCore.QRect(9, 530, 640, 20))
self.sl_frame.valueChanged.connect(window.SlideFrame)
self.sl_frame.setEnabled(False)
self.End_button = QtGui.QPushButton()
self.End_button.setText("End")
self.End_button.clicked.connect(window.setEnd)
self.End_button.setGeometry(QtCore.QRect(600, 530, 50, 23))
self.Lableframe = QtGui.QLineEdit()
self.Lableframe.setEnabled(False)
self.Lableframe.setGeometry(QtCore.QRect(419, 530, 170, 20))
self.Lableframe.setFrame(False)
self.LableInOut = QtGui.QLineEdit()
self.LableInOut.setEnabled(False)
self.LableInOut.setGeometry(QtCore.QRect(419, 530, 170, 20))
self.LableInOut.setFrame(False)
self.LableInOut.setStyleSheet("background-color: red")
self.video_frame = QtGui.QLabel()
self.video_frame.setGeometry(QtCore.QRect(10, 40, 640, 480))
self.video_frame.setFrameShape(QtGui.QFrame.Box)
self.pg1 = pg.GraphicsView()
self.pg1.setStyleSheet("background: transparent")
self.pg1.setGeometry(QtCore.QRect(10, 40, 640, 480))
self.pg1.setFrameShape(QtGui.QFrame.Box)
self.pg1.setBackground(None)
self.roi = pg.PolyLineROI([[25, 25], [25, 450], [600, 450], [600, 25]],
pen=(6, 9),
closed=True)
self.pg1.addItem(self.roi)
self.roi_h = self.roi.getHandles()
layout.addWidget(self.LableInOut)
layout.addWidget(self.video_frame, 1, 0)
layout.addWidget(self.pg1, 1, 0)
layout.addWidget(self.sl_frame, 2, 0)
layout.addWidget(self.End_button, 4, 0)
layout.addWidget(self.Lableframe, 3, 0)
self.window2.show()
def addPolyLine(self):
[[xmin, xmax], [ymin, ymax]] = self.plot.viewRange()
self.poly_line = pg.PolyLineROI(positions=[
(xmin + (xmax - xmin) * .4, ymin + (ymax - ymin) * .4),
(xmin + (xmax - xmin) * .6, ymin + (ymax - ymin) * .6)
],
pen=pg.mkPen('g', width=2))
self.plot.addItem(self.poly_line)
self.updateTransPlot()
self.poly_line.sigRegionChangeFinished.connect(self.updateTransPlot)
def _plot_polygon(self, polygon_object):
"""
Plots polygon_object on plot and displays polygon over image
:param polygon_object:
:return:
"""
x_vertices, z_vertices = polygon_object.exterior.xy
fr = pg.PolyLineROI(np.vstack((x_vertices, z_vertices)).T, closed=True, pen=(0, 0, 255, 100), movable=False,
removable=False)
self.BP.universal_plot.addItem(fr)
def addPoly(self):
if self.poly is None and self.imagedata is not None:
self.click_event_bak = self.image.mouseClickEvent
self.double_click_event_bak = self.image.mouseDoubleClickEvent
self.image.mouseClickEvent = self.mouse_click_event
self.image.mouseDoubleClickEvent = self.mouse_double_click_event
vb = self.image.getViewBox()
vb.setCursor(Qt.CrossCursor)
self.poly = pg.PolyLineROI(positions=[(0, 0)])
self.addItem(self.poly)
self.poly.clearPoints()
self.poly_pts_pos = []
def activate_poly_mode(self, points=[]):
if self.poly_line_roi is None:
self.poly_line_roi = pg.PolyLineROI([], closed=True)
self.poly_line_roi.setPen("k")
self.addItem(self.poly_line_roi)
if len(points):
mode = "poly-modify"
self.set_poly_points(points)
else:
mode = "poly-create"
self.set_mouse_click_mode(mode)
return self.poly_line_roi
def pick(self, win, pos):
if self.win is None:
self.win = win
self.roisel = pg.PolyLineROI([], pen=(255, 0, 0))
self.view = self.ivl.ortho_views[self.win]
self.view.vb.addItem(self.roisel)
elif win != self.win:
return
xy = self._xy_coords(pos)
self._points.append(xy)
self.roisel.setPoints(self._points)
def createMask(self):
self.size = self.img1.max() / 10
self.pos = int(self.img1.mean())
self.scatter_mask = pg.PolyLineROI(
[[0, 0], [0, self.size], [self.size, self.size], [self.size, 0]],
pos=(self.pos, self.pos),
pen='r',
closed=True,
removable=True)
self.w1.addItem(self.scatter_mask)
def add_polygon_roi(self):
view = self.selection_view
x = (view.getView().viewRect().x()) * 0.3
y = (view.getView().viewRect().y()) * 0.3
a = (view.getView().viewRect().width() + x) * 0.3
b = (view.getView().viewRect().height() + y) * 0.3
c = (view.getView().viewRect().width() + x) * 0.7
d = (view.getView().viewRect().height() + y) * 0.7
polygon_roi = pg.PolyLineROI([[a,b], [c,b], [c,d], [a,d]], pen = view.pen,closed=True, movable=True, removable=True)
view.getView().addItem(polygon_roi)
view.append_to_roilist(polygon_roi)
def test_getArrayRegion():
pr = pg.PolyLineROI([[0, 0], [27, 0], [0, 28]], closed=True)
pr.setPos(1, 1)
rois = [
(pg.ROI([1, 1], [27, 28], pen='y'), 'baseroi'),
(pg.RectROI([1, 1], [27, 28], pen='y'), 'rectroi'),
(pg.EllipseROI([1, 1], [27, 28], pen='y'), 'ellipseroi'),
(pr, 'polylineroi'),
]
for roi, name in rois:
# For some ROIs, resize should not be used.
testResize = not isinstance(roi, pg.PolyLineROI)
check_getArrayRegion(roi, 'roi/'+name, testResize)
def updateMaskingMode(self, data):
self.maskingMode = data
if self.maskingMode == 0:
# display text
self.parent.label.setText("")
# do not display user mask
self.displayMask()
# remove ROIs
self.parent.img.win.getView().removeItem(self.mask_rect)
self.parent.img.win.getView().removeItem(self.mask_circle)
self.parent.img.win.getView().removeItem(self.mask_poly)
else:
# display text
self.parent.label.setText(self.masking_mode_message)
# display user mask
self.displayMask()
# init masks
if self.mask_rect is None:
# Rect mask
self.mask_rect = pg.ROI(pos=[-300, 0], size=[200, 200], snapSize=1.0, scaleSnap=True, translateSnap=True,
pen={'color': 'r', 'width': 4})
self.mask_rect.addScaleHandle([1, 0.5], [0.5, 0.5])
self.mask_rect.addScaleHandle([0.5, 0], [0.5, 0.5])
self.mask_rect.addScaleHandle([0.5, 1], [0.5, 0.5])
self.mask_rect.addScaleHandle([0, 0.5], [0.5, 0.5])
self.mask_rect.addScaleHandle([0, 0], [1, 1]) # bottom,left handles scaling both vertically and horizontally
self.mask_rect.addScaleHandle([1, 1], [0, 0]) # top,right handles scaling both vertically and horizontally
self.mask_rect.addScaleHandle([1, 0], [0, 1]) # bottom,right handles scaling both vertically and horizontally
self.mask_rect.addScaleHandle([0, 1], [1, 0])
# Circular mask
self.mask_circle = pg.CircleROI([-300, 600], size=[200, 200], snapSize=1.0, scaleSnap=True,
translateSnap=True, pen={'color': 'r', 'width': 4})
self.mask_circle.addScaleHandle([0.1415, 0.707 * 1.2], [0.5, 0.5])
self.mask_circle.addScaleHandle([0.707 * 1.2, 0.1415], [0.5, 0.5])
self.mask_circle.addScaleHandle([0.1415, 0.1415], [0.5, 0.5])
#self.mask_circle.addScaleHandle([0, 0.5], [0.5, 0.5]) # west: pyqtgraph error
self.mask_circle.addScaleHandle([0.5, 0.0], [0.5, 0.5]) # south
self.mask_circle.addScaleHandle([0.5, 1.0], [0.5, 0.5]) # north
#self.mask_circle.addScaleHandle([1.0, 0.5], [0.5, 0.5]) # east: pyqtgraph error
# Polygon mask
self.mask_poly = pg.PolyLineROI([[-300, 300], [-300,500], [-100,500],
[-100,400], [-225,400], [-225,300]],
closed=True, snapSize=1.0, scaleSnap=True, translateSnap=True,
pen={'color': 'r', 'width': 4})
# add ROIs
self.parent.img.win.getView().addItem(self.mask_rect)
self.parent.img.win.getView().addItem(self.mask_circle)
self.parent.img.win.getView().addItem(self.mask_poly)
if self.parent.args.v >= 1: print("Done updateMaskingMode: ", self.maskingMode)
def loadPolygonFromDatabase(self, pos, coords, color):
""" Used to draw labels on an image based on locations saved
in a database.
Arguments:
pos - position of the polygon
coords - coordinates of the corners
"""
roiPoly = pg.PolyLineROI(coords, pos=pos,
closed=True, snapSize=1.0, scaleSnap=True, translateSnap=True,
pen={'color': color, 'width': 4, 'style': QtCore.Qt.DashLine}, removable = True)
roiPoly.setAcceptedMouseButtons(QtCore.Qt.LeftButton)
roiPoly.sigClicked.connect(self.removeROI)
self.polyRois.append(roiPoly)
self.parent.img.win.getView().addItem(roiPoly)
print("Polygon added at x = %d, y = %d" % (coords[0][0], coords[0][1]))
def __init__(self, im_stack=None, e_list=None, refs=None, ref_names=None):
super(XANESViewer, self).__init__()
uic.loadUi('uis/XANESViewer.ui', self)
self.im_stack = im_stack
self.e_list = e_list
self.refs = refs
self.ref_names = ref_names
self.selected = self.ref_names
self.decon_ims, self.rfactor = xanes_fitting(self.im_stack,
self.e_list,
self.refs,
method='NNLS')
(self.dim1, self.dim3, self.dim2) = self.im_stack.shape
self.cn = int(self.dim2 // 2)
self.sz = np.max([int(self.dim2 * 0.15), int(self.dim3 * 0.15)])
self.image_roi = pg.PolyLineROI(
[[0, 0], [0, self.sz], [self.sz, self.sz], [self.sz, 0]],
pos=(int(self.dim2 // 2), int(self.dim3 // 2)),
maxBounds=QtCore.QRect(0, 0, self.dim3, self.dim2),
closed=True)
self.image_roi.addTranslateHandle([self.sz // 2, self.sz // 2], [2, 2])
self.stack_center = int(self.dim1 // 2)
self.stack_width = int(self.dim1 * 0.05)
#self.image_view.setCurrentIndex(self.stack_center)
self.image_view.addItem(self.image_roi)
self.xdata = self.e_list + self.sb_e_shift.value()
self.scrollBar_setup()
self.display_image_data()
self.display_references()
self.update_spectrum()
# connections
self.sb_e_shift.valueChanged.connect(self.update_spectrum)
self.sb_e_shift.valueChanged.connect(self.re_fit_xanes)
self.pb_edit_refs.clicked.connect(self.choose_refs)
self.image_roi.sigRegionChanged.connect(self.update_spectrum)
self.pb_save_chem_map.clicked.connect(self.save_chem_map)
self.pb_save_spe_fit.clicked.connect(self.pg_export_spec_fit)
self.hsb_xanes_stk.valueChanged.connect(self.display_image_data)
self.hsb_chem_map.valueChanged.connect(self.display_image_data)
def __init__(
self,
im: np.array,
parent: Optional[Any] = None,
):
super().__init__()
self.im = im
pg.setConfigOptions(imageAxisOrder="row-major")
self.setGeometry(50, 50, self.init_width, self.init_height)
self.setWindowTitle("ROI Maker")
# Initialize a central widget and a main layout.
self._central_widget = QtGui.QWidget(self)
self.setCentralWidget(self._central_widget)
self._layout = QtGui.QVBoxLayout()
self._central_widget.setLayout(self._layout)
self.setAutoFillBackground(True)
#-----------------------------------------------------------------------
# Initialize image viewing area.
# - Initialize a graphics layout for the image area.
self._graphics_layout = pg.GraphicsLayoutWidget()
self._layout.addWidget(self._graphics_layout)
self._layout.setStretch(0, 800)
# - Add a view box to enable scaling/panning and mouse drags.
self._view_box = self._graphics_layout.addViewBox(lockAspect=True,
row=0,
col=0,
invertY=True)
self._view_box.setMenuEnabled(False)
# - Add a image item to the view box.
self._image = pg.ImageItem()
self._view_box.addItem(self._image)
self._image.setImage(self.im)
self.roi = pg.PolyLineROI([[10, 10], [10, 30], [30, 30], [30, 10]],
closed=True)
self._view_box.addItem(self.roi)
self.show()
def plot_chirp_points(self):
if self.roi is None:
t_mid = (self.matrix.times[-1] - self.matrix.times[0]) / 2
n_w = self.matrix.wavelengths.shape[0] - 1
wls = self.matrix.wavelengths[int(n_w / 5)], self.matrix.wavelengths[int(2 * n_w / 5)], \
self.matrix.wavelengths[int(3 * n_w / 5)], self.matrix.wavelengths[int(4 * n_w / 5)]
self.roi = pg.PolyLineROI([[wls[0], t_mid], [wls[1], t_mid],
[wls[2], t_mid], [wls[3], t_mid]],
closed=False,
handlePen=pg.mkPen(color=(0, 255, 0),
width=5),
hoverPen=pg.mkPen(color=(0, 150, 0),
width=2),
handleHoverPen=pg.mkPen(color=(0, 150,
0),
width=3))
self.heat_map_plot.heat_map_plot.addItem(self.roi)
def polymask(self):
if self.activeaction is None:
self.activeaction = 'polymask'
left = self.dimg.experiment.getvalue('Center X') - 100
right = self.dimg.experiment.getvalue('Center X') + 100
up = self.dimg.experiment.getvalue('Center Y') - 100
down = self.dimg.experiment.getvalue('Center Y') + 100
self.maskROI = pg.PolyLineROI(
[[left, up], [left, down], [right, down], [right, up]],
pen=(6, 9),
closed=True)
self.viewbox.addItem(self.maskROI)
def checkPointMove(handle, pos, modifiers):
p = self.viewbox.mapToView(pos)
if 0 < p.y() < self.dimg.data.shape[0] and 0 < p.x(
) < self.dimg.data.shape[1]:
return True
return False
self.maskROI.checkPointMove = checkPointMove
else:
if self.activeaction == 'polymask':
self.activeaction = None
maskedarea = self.maskROI.getArrayRegion(
np.ones_like(self.dimg.data.T),
self.imageitem,
returnMappedCoords=True)
boundrect = self.viewbox.itemBoundingRect(self.maskROI)
leftpad = boundrect.x()
toppad = boundrect.y()
maskedarea = np.pad(maskedarea,
((int(leftpad), 0), (int(toppad), 0)),
mode='constant')
maskedarea = np.pad(
maskedarea,
((0, self.dimg.data.shape[0] - maskedarea.shape[0]),
(0, self.dimg.data.shape[1] - maskedarea.shape[1])),
mode='constant')
self.dimg.experiment.addtomask(maskedarea)
self.viewbox.removeItem(self.maskROI)
self.replot()
return
def __init__(self,
header: NonDBHeader = None,
field: str = None,
toolbar: QToolBar = None,
*args,
**kwargs):
super(SAXSViewerPluginBase, self).__init__(**kwargs)
self.axesItem.invertY(False)
# Setup coordinates label
# self.coordinatesLbl = QLabel('--COORDINATES WILL GO HERE--')
# self.ui.gridLayout.addWidget(self.coordinatesLbl, 3, 0, 1, 1, alignment=Qt.AlignHCenter)
# Setup mask layer
self.maskimage = pg.ImageItem(opacity=.25, axisOrder='row-major')
self.view.addItem(self.maskimage)
# Setup calibration layer
self.calibrantimage = pg.ImageItem(opacity=.25)
self.view.addItem(self.calibrantimage)
# Empty ROI for later use
self.maskROI = pg.PolyLineROI([],
closed=True,
movable=False,
pen=pg.mkPen(color='r', width=2))
self.maskROI.handlePen = pg.mkPen(color='r', width=2)
self.maskROI.handleSize = 10
self.view.addItem(self.maskROI)
# Connect toolbar handlers
self.toolbar = toolbar
if self.toolbar:
self.toolbar.modegroup.triggered.connect(self.redraw)
# Setup results cache
self.results = []
# Set header
if header: self.setHeader(header, field)
def configure_image_widgets(self):
if len(self.data.dims) == 3:
self.generate_marginal_for((0, ),
0,
0,
'xy',
cursors=False,
layout=self.content_layout)
self.generate_marginal_for((0, ),
1,
0,
'P',
cursors=False,
layout=self.content_layout)
else:
self.generate_marginal_for((),
0,
0,
'xy',
cursors=False,
layout=self.content_layout)
if self.SUMMED:
self.generate_marginal_for((0, ),
1,
0,
'P',
cursors=False,
layout=self.content_layout)
else:
self.generate_marginal_for((),
1,
0,
'P',
cursors=False,
layout=self.content_layout)
self.roi = pg.PolyLineROI([[0, 0], [50, 50]], closed=self.ROI_CLOSED)
self.views['xy'].view.addItem(self.roi)
self.roi.sigRegionChanged.connect(self.roi_changed)
self.main_layout.addLayout(self.content_layout, 0, 0)
def draw_image_and_rois(self, fix_roi=False):
# Get current axis range
x_range = self.plotWidget.getAxis('bottom').range
y_range = self.plotWidget.getAxis('left').range
# Remove imageItem
if self.imageItem:
self.imageItem.mousePressEvent = None
self.plotWidget.removeItem(self.imageItem)
del self.imageItem
# Remove ROIs from plot and delete
for roi_name, roi_selector in self.roi_selectors.items():
self.plotWidget.removeItem(roi_selector)
self.roi_selectors[roi_name] = None
del roi_selector
self.roi_selectors = {}
# Draw image
self.imageItem = pg.ImageItem(self.img_array)
self.plotWidget.addItem(self.imageItem)
if self.labelmode == 'add':
self.imageItem.mousePressEvent = self.add_node_at_mouse
# Draw ROIs
for roi_name, coords in self.roi_coords.items():
if roi_name == 'dims': # Ignore the label containing the image size
continue
roi_selector = pg.PolyLineROI(coords,
movable=False,
closed=True,
pen=QtGui.QPen(
QtGui.QColor(115, 194, 251)))
roi_selector.sigRegionChangeFinished.connect(
lambda roi: self.update_coords())
self.roi_selectors[roi_name] = roi_selector
self.plotWidget.addItem(roi_selector)
# Restore range
if fix_roi:
self.plotWidget.setRange(xRange=x_range, yRange=y_range, padding=0)
