def createROI(self,x,y,coords = [], w = 8, h = 8, d = 9, algorithm = False, color = 'm'):
""" creates a ROI shape/label based on the input set of parameters
Arguments:
x - x position
y - y position
**coords - coordinates for a polygon
**w - width of rectangle
**h - height of rectangle
**d - diameter of circle
**algorithm - Boolean value, True if these labels are loaded
from an algorithm, and not from a click event
**color - color of ROI, green if click event, blue if
loaded from algorithm
"""
try:
if((algorithm == True) or (self.shapes == "Rectangle")):
width = w
height = h
roiRect = pg.ROI(pos=[x-(width/2), y-(height/2)], size=[width, height], snapSize=1.0, scaleSnap=True, translateSnap=True,
pen={'color': color, 'width': 4, 'style': QtCore.Qt.DashLine}, removable = True)
roiRect.addScaleHandle([1, 0.5], [0.5, 0.5])
roiRect.addScaleHandle([0.5, 0], [0.5, 0.5])
roiRect.addScaleHandle([0.5, 1], [0.5, 0.5])
roiRect.addScaleHandle([0, 0.5], [0.5, 0.5])
roiRect.addScaleHandle([0, 0], [1, 1]) # bottom,left handles scaling both vertically and horizontally
roiRect.addScaleHandle([1, 1], [0, 0]) # top,right handles scaling both vertically and horizontally
roiRect.addScaleHandle([1, 0], [0, 1]) # bottom,right handles scaling both vertically and horizontally
roiRect.addScaleHandle([0, 1], [1, 0])
roiRect.setAcceptedMouseButtons(QtCore.Qt.LeftButton)
roiRect.sigClicked.connect(self.removeROI)
if (algorithm == True):
self.algRois.append(roiRect)
else:
self.rectRois.append(roiRect)
self.parent.img.win.getView().addItem(roiRect)
print("Rectangle added at x = %d, y = %d" % (x, y))
elif(self.shapes == "Circle"):
xd = d
yd = d
roiCircle = pg.CircleROI([x- (xd/2), y - (yd/2)], size=[xd, yd], snapSize=0.1, scaleSnap=False, translateSnap=False,
pen={'color': color, 'width': 4, 'style': QtCore.Qt.DashLine}, removable = True)
roiCircle.addScaleHandle([0.1415, 0.707*1.2], [0.5, 0.5])
roiCircle.addScaleHandle([0.707 * 1.2, 0.1415], [0.5, 0.5])
roiCircle.addScaleHandle([0.1415, 0.1415], [0.5, 0.5])
roiCircle.addScaleHandle([0.5, 0.0], [0.5, 0.5]) # south
roiCircle.addScaleHandle([0.5, 1.0], [0.5, 0.5]) # north
roiCircle.setAcceptedMouseButtons(QtCore.Qt.LeftButton)
roiCircle.sigClicked.connect(self.removeROI)
self.circleRois.append(roiCircle)
self.parent.img.win.getView().addItem(roiCircle)
print("Circle added at x = %d, y = %d" % (x, y))
elif(self.shapes == "Polygon"):
roiPoly = pg.PolyLineROI(coords, pos = [x-375,y+150],
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)
roiPoly.sigHoverEvent.connect(self.removeROI)
roiPoly.sigRegionChanged.connect(self.removeROI)
self.polyRois.append(roiPoly)
self.parent.img.win.getView().addItem(roiPoly)
print("Polygon added at x = %d, y = %d" % (x, y))
else:
print("Choose a Shape.")
except AttributeError:
pass
def _activate_image_tab(self):
""" Initialization method for the image tab """
camera_width = self.spectrumlogic().camera_constraints.width
camera_height = self.spectrumlogic().camera_constraints.height
for read_mode in self.spectrumlogic().camera_constraints.read_modes:
if read_mode.name[:5] == "IMAGE":
self._image_tab.read_modes.addItem(read_mode.name,
read_mode.name)
if read_mode == self._image_read_mode:
self._image_tab.read_modes.setCurrentText(read_mode.name)
for acquisition_mode in AcquisitionMode.__members__:
if acquisition_mode != "MULTI_SCAN":
self._image_tab.acquisition_modes.addItem(
acquisition_mode, acquisition_mode)
if acquisition_mode == self._image_acquisition_mode:
self._image_tab.acquisition_modes.setCurrentText(
acquisition_mode)
self.image_exposure_time_widget = ScienDSpinBox()
self.image_exposure_time_widget.setMinimum(0)
self.image_exposure_time_widget.setValue(self._image_exposure_time)
self.image_exposure_time_widget.setSuffix('s')
self._image_tab.exposure_time_layout.addWidget(
self.image_exposure_time_widget)
for readout_speed in self.spectrumlogic(
).camera_constraints.readout_speeds:
self._image_tab.readout_speed.addItem(
"{:.2r}Hz".format(ScaledFloat(readout_speed)), readout_speed)
if readout_speed == self._image_readout_speed:
self._image_tab.readout_speed.setCurrentText("{:.2r}Hz".format(
ScaledFloat(readout_speed)))
self._image_tab.save.clicked.connect(partial(self.save_data, 0))
self._save_data_buttons.append(self._image_tab.save)
self._image_tab.acquire_dark.clicked.connect(
partial(self.start_dark_acquisition, 0))
self._acquire_dark_buttons.append(self._image_tab.acquire_dark)
self._image_tab.start_acquisition.clicked.connect(
partial(self.start_acquisition, 0))
self._start_acquisition_buttons.append(
self._image_tab.start_acquisition)
self._image_tab.stop_acquisition.clicked.connect(self.stop_acquisition)
self._stop_acquisition_buttons.append(self._image_tab.stop_acquisition)
self._image_tab.remove_dark.clicked.connect(
partial(self.remove_dark, 0))
self.my_colors = ColorScaleInferno()
self._image = pg.ImageItem(image=self._image_data,
axisOrder='row-major')
self._image.setLookupTable(self.my_colors.lut)
self._image_tab.graph.addItem(self._image)
self._colorbar = ColorbarWidget(self._image)
self._image_tab.colorbar.addWidget(self._colorbar)
self.track_colors = np.array(
[palette.c5, palette.c2, palette.c6, palette.c4])
self.plot_colors = self.track_colors
height = self.spectrumlogic().camera_constraints.height
for i in range(4):
self._track_buttons[i].setCheckable(True)
self._track_buttons[i].clicked.connect(
partial(self._manage_track_buttons, i))
tracks = self.spectrumlogic().active_tracks
if 2 * i < len(tracks):
top_pos = tracks[2 * i]
bottom_pos = tracks[2 * i + 1]
else:
top_pos = 0
bottom_pos = 10
color = self.track_colors[i].getRgb()
track_color = pg.mkBrush(color[0], color[1], color[2], 100)
track = pg.LinearRegionItem(
values=[top_pos, bottom_pos],
orientation=pg.LinearRegionItem.Horizontal,
brush=track_color)
track.setBounds([0, height])
track.hide()
self._track_selector.append(track)
self._image_tab.graph.addItem(track)
self._image_tab.image_advanced.setCheckable(True)
self._image_tab.image_advanced.clicked.connect(
self._manage_image_advanced_button)
self._image_advanced_widget = pg.ROI(
[0, 0], [camera_width, camera_height],
maxBounds=QRectF(QPoint(0, 0), QPoint(camera_width,
camera_height)))
self._image_advanced_widget.addScaleHandle((1, 0), (0, 1))
self._image_advanced_widget.addScaleHandle((0, 1), (1, 0))
self._image_advanced_widget.hide()
self._image_tab.graph.addItem(self._image_advanced_widget)
self._image_tab.horizontal_binning.setRange(1, camera_width - 1)
self._image_tab.vertical_binning.setRange(1, camera_height - 1)
self._image_tab.horizontal_binning.editingFinished.connect(
self.set_image_params)
self._image_tab.vertical_binning.editingFinished.connect(
self.set_image_params)
self._image_tab.read_modes.currentTextChanged.connect(
self.set_image_params)
self._image_tab.acquisition_modes.currentTextChanged.connect(
self.set_image_params)
self.image_exposure_time_widget.editingFinished.connect(
self.set_image_params)
self._image_tab.readout_speed.currentTextChanged.connect(
self.set_image_params)
def __init__(self, data, bins, sample, log=False, *args, **kwargs):
plt.close(
plt.gca().get_figure()
) # Mega hack to save the day (close annoying mpl figure....... not a fan). MDT = magic don't touch
pg.setConfigOption('background', 'w')
pg.setConfigOption('foreground', 'k')
super().__init__(*args, **kwargs)
self.l = QtGui.QGridLayout()
self.setLayout(self.l)
# Add plotItem to allow for axes
self.imv1 = CustomImageView(view=pg.PlotItem())
self.imv2 = pg.ImageView(view=pg.PlotItem())
#Insert widgets into layout
self.l.addWidget(self.imv1, 0, 0)
self.l.addWidget(self.imv2, 1, 0)
# Create the region-of-interest line segment
self.roi = pg.ROI([1, 0], [1, 1], pen='r', resizable=True)
self.roi.setSize([1, 0.1])
self.roi.addScaleHandle(
[0.5, 1],
[0.5, 0.5],
)
self.roi.addScaleHandle([0, 0.5], [0.5, 0.5])
self.roi.addRotateHandle([1.0, 1.0], [0.5, 0.5])
# Change color of roi markers
handleColor = QtGui.QColor(255, 102, 0)
for handle in self.roi.getHandles():
handle.pen.setColor(handleColor)
self.imv1.addItem(self.roi)
self.Data, self.bins = data, bins
if len(data) == 4:
with warnings.catch_warnings():
warnings.simplefilter("ignore")
self.data = np.divide(self.Data[0] * self.Data[-1],
self.Data[1] * self.Data[2])
self.data[self.Data[-1] == 0] = -np.nanmin(
self.data[self.data != 0])
else:
self.data = self.Data
# set unmeasured areas to negative value
if log:
self.data = np.log10(self.data + 1e-20)
# transpose data to comply with viewer requirements
self.data = self.data.transpose((2, 0, 1))
# Extract the sample
self.sample = sample
# Calculate the projection directions
self.axes = np.array(
[self.sample.calculateQxQyToHKL(*X) for X in self.sample.RotMat])
## Display the data
self.imv1.setImage(self.data,
xvals=self.bins[2][0, 0, :],
levels=(-1e-7, 1e-5),
autoLevels=False)
self.imv1.setHistogramRange(-8.5e-8, 1e-5)
# unlock aspect ratio
self.imv1.view.setAspectLocked(False)
# Generate and add correct labels to axes
self.xaxis = self.imv1.view.axes['bottom']['item']
self.yaxis = self.imv1.view.axes['left']['item']
self.xlabel = _tools.generateLabel(_tools.LengthOrder(self.axes[0]))
self.ylabel = _tools.generateLabel(_tools.LengthOrder(self.axes[1]))
self.xaxis.setLabel(text=self.xlabel, units='RLU')
self.yaxis.setLabel(text=self.ylabel, units='RLU')
# Setup color map for main window
self.setupColorscale(self.imv1)
# Calcualte scaling and offsets between image view and RLU axes
self.qxRange = np.diff(self.bins[0][[0, -1], 0, 0])
self.qyRange = np.diff(self.bins[1][0, [0, -1], 0])
self.ERange = np.diff(self.bins[2][0, 0, [0, -1]])
self.qxScale = self.qxRange * np.linalg.norm(
self.axes[0]) / self.bins[0].shape[0]
self.qyScale = self.qyRange * np.linalg.norm(
self.axes[1]) / self.bins[0].shape[1]
self.EScale = self.ERange / self.bins[0].shape[2]
self.qxCenter = self.bins[0][0, 0, 0] * np.linalg.norm(self.axes[0])
self.qyCenter = self.bins[1][0, 0, 0] * np.linalg.norm(self.axes[1])
self.ECenter = self.bins[2][0, 0, 0]
# Apply scaling and translation
img1Item = self.imv1.getImageItem()
img1Item.scale(self.qxScale, self.qyScale)
img1Item.translate(self.qxCenter / self.qxScale,
self.qyCenter / self.qyScale)
# Un-invert yaxis
self.imv1.view.getViewBox().invertY(False)
self.imv1.view.autoRange(True)
self.imv1.view.setAutoVisible(x=True, y=True)
# Add labels colormap for cut window
self.imv2.view.setLabel("left", "Energy", units='meV')
self.imv2.view.setLabel("bottom", "HKL", units='RLU')
self.setupColorscale(self.imv2)
# Hide all unneeded menus and uninvert yaxes
self.imv2.ui.roiBtn.hide()
self.imv2.ui.menuBtn.hide()
self.imv2.view.getViewBox().invertY(False)
# Extract projection matrix used for position calculation along cut
self.projectionMatrix = self.axes
self.projectionMatrix[0] *= 1 / np.linalg.norm(
self.projectionMatrix[0])
self.projectionMatrix[1] *= 1 / np.linalg.norm(
self.projectionMatrix[1])
self.xaxis2 = self.imv2.view.axes['bottom']['item']
self.yaxis2 = self.imv2.view.axes['left']['item']
self.xaxis2.tickStrings = lambda values, scale, spacing: self.XtickStrings(
self.roi, values, scale, spacing)
self.yaxis2.tickStrings = lambda values, scale, spacing: self.YtickStrings(
values, scale, spacing)
# Create function to be called when cut changes
# Connect update-function to correct slot
self.roi.sigRegionChanged.connect(self.update)
# Call update for initial position
self.update()
# Interpret image data as row-major instead of col-major
pg.setConfigOptions(imageAxisOrder='row-major')
pg.mkQApp()
win = pg.GraphicsLayoutWidget()
win.setWindowTitle('pyqtgraph example: Image Analysis')
# A plot area (ViewBox + axes) for displaying the image
p1 = win.addPlot(title="")
# Item for displaying image data
img = pg.ImageItem()
p1.addItem(img)
# Custom ROI for selecting an image region
roi = pg.ROI([-8, 14], [6, 5])
roi.addScaleHandle([0.5, 1], [0.5, 0.5])
roi.addScaleHandle([0, 0.5], [0.5, 0.5])
p1.addItem(roi)
roi.setZValue(10) # make sure ROI is drawn above image
# Isocurve drawing
iso = pg.IsocurveItem(level=0.8, pen='g')
iso.setParentItem(img)
iso.setZValue(5)
# Contrast/color control
hist = pg.HistogramLUTItem()
hist.setImageItem(img)
win.addItem(hist)
r2b = pg.PolyLineROI([[0,-20], [10,-10], [10,-30]], closed=False)
v2a.addItem(r2b)
v2a.disableAutoRange('xy')
#v2b.disableAutoRange('xy')
v2a.autoRange()
#v2b.autoRange()
text = """Building custom ROI types<Br>
ROIs can be built with a variety of different handle types<br>
that scale and rotate the roi around an arbitrary center location
"""
w3 = w.addLayout(row=1, col=0)
label3 = w3.addLabel(text, row=0, col=0)
v3 = w3.addViewBox(row=1, col=0, lockAspect=True)
r3a = pg.ROI([0,0], [10,10])
v3.addItem(r3a)
## handles scaling horizontally around center
r3a.addScaleHandle([1, 0.5], [0.5, 0.5])
r3a.addScaleHandle([0, 0.5], [0.5, 0.5])
## handles scaling vertically from opposite edge
r3a.addScaleHandle([0.5, 0], [0.5, 1])
r3a.addScaleHandle([0.5, 1], [0.5, 0])
## handles scaling both vertically and horizontally
r3a.addScaleHandle([1, 1], [0, 0])
r3a.addScaleHandle([0, 0], [1, 1])
r3b = pg.ROI([20,0], [10,10])
v3.addItem(r3b)
def __init__(self, parent = None):
self.parent = parent
#############################
## Dock 4: ROI histogram
#############################
self.d4 = Dock("ROI Histogram", size=(1, 1))
self.w4 = pg.PlotWidget(title="ROI histogram")
hist, bin = np.histogram(np.random.random(1000), bins=1000)
self.w4.plot(bin, hist, stepMode=True, fillLevel=0, brush=(0, 0, 255, 150), clear=True)
self.d4.addWidget(self.w4)
self.roiCheckbox = QtGui.QCheckBox('Update ROI')
self.roiCheckbox.setCheckState(True)
self.roiCheckbox.setTristate(False)
self.roiCheckbox.stateChanged.connect(self.updateRoiStatus)
# Layout
self.w4a = pg.LayoutWidget()
self.w4a.addWidget(self.roiCheckbox, row=0, col=0)
self.d4.addWidget(self.w4a)
#############################
# Local variables
#############################
self.updateRoiStatus = True
self.roiCurrent = None
# Custom ROI for selecting an image region
self.roi = pg.ROI(pos=[0, -250], size=[200, 200], snapSize=1.0, scaleSnap=True, translateSnap=True,
pen={'color': 'g', 'width': 4, 'style': QtCore.Qt.DashLine})
self.roi.addScaleHandle([1, 0.5], [0.5, 0.5])
self.roi.addScaleHandle([0.5, 0], [0.5, 0.5])
self.roi.addScaleHandle([0.5, 1], [0.5, 0.5])
self.roi.addScaleHandle([0, 0.5], [0.5, 0.5])
self.roi.addScaleHandle([0, 0], [1, 1]) # bottom,left handles scaling both vertically and horizontally
self.roi.addScaleHandle([1, 1], [0, 0]) # top,right handles scaling both vertically and horizontally
self.roi.addScaleHandle([1, 0], [0, 1]) # bottom,right handles scaling both vertically and horizontally
self.roi.addScaleHandle([0, 1], [1, 0])
self.roi.name = 'rect'
self.parent.img.w1.getView().addItem(self.roi)
self.roiPoly = pg.PolyLineROI([[300, -250], [300,-50], [500,-50], [500,-150], [375,-150], [375,-250]],
closed=True, snapSize=1.0, scaleSnap=True, translateSnap=True,
pen={'color': 'g', 'width': 4, 'style': QtCore.Qt.DashLine})
self.roiPoly.name = 'poly'
self.parent.img.w1.getView().addItem(self.roiPoly)
self.roiCircle = pg.CircleROI([600, -250], size=[200, 200], snapSize=0.1, scaleSnap=False, translateSnap=False,
pen={'color': 'g', 'width': 4, 'style': QtCore.Qt.DashLine})
self.roiCircle.addScaleHandle([0.1415, 0.707*1.2], [0.5, 0.5])
self.roiCircle.addScaleHandle([0.707 * 1.2, 0.1415], [0.5, 0.5])
self.roiCircle.addScaleHandle([0.1415, 0.1415], [0.5, 0.5])
self.roiCircle.addScaleHandle([0, 0.5], [0.5, 0.5])
self.roiCircle.addScaleHandle([0.5, 0.0], [0.5, 0.5])
self.roiCircle.addScaleHandle([0.5, 1.0], [0.5, 0.5])
self.roiCircle.addScaleHandle([1.0, 0.5], [0.5, 0.5])
self.roiCircle.name = 'circ'
self.parent.img.w1.getView().addItem(self.roiCircle)
self.rois = []
self.rois.append(self.roi)
self.rois.append(self.roiPoly)
self.rois.append(self.roiCircle)
for roi in self.rois:
roi.sigRegionChangeFinished.connect(self.updateRoi)
def __init__(self):
super().__init__()
# Read color map from here : http://www.kennethmoreland.com/color-advice/
self.cl = np.loadtxt(
'../intrinsic/extended-black-body-table-byte-0256.csv',
delimiter=',',
skiprows=1)
self.cmap = [QtGui.qRgb(*x[1:]) for x in self.cl]
self.cl = np.vstack(
(np.ones(self.cl.shape[0]), self.cl[:,
1:].transpose())).transpose()
self.c_data = np.array([])
self._c_slice = 0
self.S: Optional[Session] = None
# File model
home = str(Path.home())
self.file_model = QtWidgets.QFileSystemModel()
self.file_model.setFilter(QtCore.QDir.AllDirs | QtCore.QDir.Files
| QtCore.QDir.NoDotAndDotDot)
self.file_model.setNameFilters(["*.h5"])
self.file_model.setRootPath('/Volumes/Data/Vasiliki/')
self.main_widget = QtWidgets.QWidget(self)
# Layouts
self.h_layout = QtWidgets.QHBoxLayout(self.main_widget)
self.h_layout_cble = QtWidgets.QHBoxLayout()
self.h_layout_btn = QtWidgets.QHBoxLayout()
self.v_layout_left = QtWidgets.QVBoxLayout()
self.v_layout_right = QtWidgets.QVBoxLayout()
self.f_layout_trial = QtWidgets.QFormLayout()
self.h_layout_analysis = QtWidgets.QGridLayout()
left_scroll = QtWidgets.QScrollArea()
left_scroll.setWidgetResizable(True)
left_wdg = QtWidgets.QWidget()
left_wdg.setLayout(self.v_layout_left)
left_scroll.setWidget(left_wdg)
# Widgets
self.tree = QtWidgets.QTreeView(self)
self.tree.setModel(self.file_model)
self.tree.hideColumn(1)
self.tree.hideColumn(2)
self.tree.hideColumn(3)
self.tree.expanded.connect(self.expanded)
self.tree.selectionModel().currentChanged.connect(self.select_file)
# Trial structure fields
self.baseline_sb = QtWidgets.QSpinBox(self)
self.stim_sb = QtWidgets.QSpinBox(self)
self.recovery_sb = QtWidgets.QSpinBox(self)
self.frame_dur = QtWidgets.QSpinBox(self)
self.frame_dur.setRange(1, 1000)
self.baseline_sb.setValue(30)
self.stim_sb.setValue(30)
self.recovery_sb.setValue(20)
self.frame_dur.setValue(100)
self.baseline_sb.setMaximumWidth(50)
self.stim_sb.setMaximumWidth(50)
self.recovery_sb.setMaximumWidth(50)
self.frame_dur.setMaximumWidth(50)
self.analysis_btn = QtWidgets.QPushButton('&Analysis')
self.analysis_btn.clicked.connect(self.analyze)
self.movie_btn = QtWidgets.QPushButton('&Movie')
self.movie_btn.clicked.connect(self.export_movie)
self.resp_btn = QtWidgets.QPushButton('&Save response')
self.resp_btn.clicked.connect(self.export_resp)
self.tc_btn = QtWidgets.QPushButton('Save &time course')
self.tc_btn.clicked.connect(self.export_tc)
self.excel_btn = QtWidgets.QPushButton('Excel export')
self.excel_btn.clicked.connect(self.excel_export)
self.max_slider = LabeledSlider('Maximum value')
self.max_slider.setEnabled(False)
self.max_slider.setSingleStep(1)
self.max_slider.valueChanged.connect(self.max_df_changed)
self.slice_slider = LabeledSlider('Current frame')
self.slice_slider.setEnabled(False)
self.slice_slider.setSingleStep(1)
self.slice_slider.valueChanged.connect(self.slice_changed)
self.data_cb = QtWidgets.QComboBox(self)
self.data_cb.currentIndexChanged.connect(self.data_changed)
self.data_cb.setSizeAdjustPolicy(QtWidgets.QComboBox.AdjustToContents)
self.comment_le = QtWidgets.QLineEdit()
self.comment_le.setEnabled(False)
self.comment_le.editingFinished.connect(self.commenting)
# PyQtGraph
self.win = pg.GraphicsLayoutWidget(self)
self.plot_anat = self.win.addPlot(row=0, col=0)
self.plot_resp = self.win.addPlot(row=1, col=0)
self.resp_item = pg.ImageItem()
self.anat_item = pg.ImageItem()
self.plot_resp.addItem(self.resp_item)
self.plot_anat.addItem(self.anat_item)
roi_pen = pg.mkPen(color='y', width=2)
self.roi = pg.ROI([0, 0], [100, 100], pen=roi_pen)
self.roi_anat = pg.ROI([0, 0], [100, 100], movable=False, pen=roi_pen)
self.roi.addScaleHandle([0.5, 1], [0.5, 0.5])
self.roi.addScaleHandle([0, 0.5], [0.5, 0.5])
self.roi.sigRegionChanged.connect(self.roi_moved)
self.plot_resp.addItem(self.roi)
self.plot_anat.addItem(self.roi_anat)
self.roi.setZValue(10)
self.plot_widget = self.win.addPlot(row=2, col=0)
self.roi_plot = pg.PlotDataItem()
self.plot_widget.addItem(self.roi_plot)
# Adding widgets to layouts
self.v_layout_right.addWidget(self.win)
self.v_layout_left.addWidget(self.tree)
# self.h_layout_analysis.addSpacerItem(QtWidgets.QSpacerItem(300, 1, QtWidgets.QSizePolicy.Expanding))
self.f_layout_trial.addRow('Number of baseline frames',
self.baseline_sb)
self.f_layout_trial.addRow('Number of stimulation frames',
self.stim_sb)
self.f_layout_trial.addRow('Number of recovery frames',
self.recovery_sb)
self.f_layout_trial.addRow('Exposure time', self.frame_dur)
self.f_layout_trial.addRow("", self.analysis_btn)
self.h_layout_analysis.addLayout(self.f_layout_trial, 0, 0)
# self.h_layout_analysis.addItem(QtWidgets.QSpacerItem(1, 1, QtWidgets.QSizePolicy.Fixed,
# QtWidgets.QSizePolicy.Expanding), 0, 1)
self.v_layout_left.addLayout(self.h_layout_analysis)
self.v_layout_left.addWidget(self.max_slider)
self.h_layout_btn.addWidget(self.movie_btn)
self.h_layout_btn.addWidget(self.resp_btn)
self.h_layout_btn.addWidget(self.tc_btn)
self.h_layout_btn.addWidget(self.excel_btn)
self.h_layout_cble.addWidget(self.data_cb)
self.h_layout_cble.addWidget(self.comment_le)
self.v_layout_left.addLayout(self.h_layout_cble)
self.v_layout_left.addWidget(self.slice_slider)
self.v_layout_left.addLayout(self.h_layout_btn)
# self.h_layout.addLayout(self.v_layout_left)
self.h_layout.addWidget(left_scroll)
self.h_layout.addLayout(self.v_layout_right)
# Sizing
self.setMinimumSize(600, 800)
self.setSizePolicy(QtWidgets.QSizePolicy.Expanding,
QtWidgets.QSizePolicy.Expanding)
# self.tree.setMinimumSize(400, 800)
self.setCentralWidget(self.main_widget)
self.setWindowTitle('Flavo imaging explorer')
self.c_path = None
self.an_th = None
self.resp_btn.setEnabled(False)
self.tc_btn.setEnabled(False)
self.movie_btn.setEnabled(False)
self.excel_btn.setEnabled(False)
# Logging
self._logger = logging.getLogger('Intrinsiclog')
self._logger.setLevel(logging.DEBUG)
self._log_handler = RotatingFileHandler('Intrinsic.log',
maxBytes=int(1e6),
backupCount=1)
formatter = logging.Formatter(
'%(asctime)s :: %(filename)s :: %(funcName)s :: line %(lineno)d :: %(levelname)s :: %(message)s',
datefmt='%Y-%m-%d:%H:%M:%S')
self._log_handler.setFormatter(formatter)
self._logger.addHandler(self._log_handler)
sys.excepthook = handle_exception
self.statusBar().showMessage('Ready!', 1500)
def clear(self):
# print('self.clear()')
if hasattr(self, 'status') and self.status == 2: # if movie is playing
self._pause_movie()
# set slider
self.ui.horizontalSlider_currentFrame.setRange(0, 1)
self.ui.horizontalSlider_currentFrame.setValue(0)
self.ui.horizontalSlider_currentFrame.setEnabled(False)
# set current frame
self.ui.lineEdit_currframeNum.setText('0')
self.ui.lineEdit_currframeNum.setEnabled(False)
# setup pupil and led rois
if hasattr(self, 'pupil_roi'):
self.pupil_roi.setPos((20, 20))
self.pupil_roi.setSize((60, 60))
self.pupil_roi.setPen((0, 255, 0))
self.pupil_roi.removable = False
else:
self.pupil_roi = pg.ROI([20, 20], [60, 60],
pen=(0, 255, 0),
removable=False)
self.pupil_roi.handleSize = 10
self.pupil_roi.addScaleHandle([1, 0], [0, 1])
self.pupil_roi.addScaleHandle([0, 0], [1, 1])
self.pupil_roi.addScaleHandle([1, 1], [0, 0])
self.pupil_roi.addScaleHandle([0, 1], [1, 0])
self.movie_view.addItem(self.pupil_roi)
if hasattr(self, 'led_roi'):
self.led_roi.setPos((40, 40))
self.led_roi.setSize((20, 20))
self.led_roi.setPen((255, 0, 0))
self.led_roi.removable = False
else:
self.led_roi = pg.ROI(
[40, 40],
[20, 20],
pen=(255, 0, 0),
removable=False,
)
self.led_roi.handleSize = 10
self.led_roi.addScaleHandle([1, 0], [0, 1])
self.led_roi.addScaleHandle([0, 0], [1, 1])
self.led_roi.addScaleHandle([1, 1], [0, 0])
self.led_roi.addScaleHandle([0, 1], [1, 0])
self.movie_view.addItem(self.led_roi)
# set background image
# print('resetting image')
self.movie.setImage(np.zeros((100, 100), dtype=np.uint8))
# setup movie properties
self.video_capture = None
self.movie_path = None
self.movie_frame_num = 0
self.movie_frame_shape = (100, 100) # (height, width)
self.movie_fps = None
self.curr_frame_ind = None
self.last_pupil = (None, None) # (frame ind, pupil Ellipse)
self._show_movie_info()
# set buttons
self.ui.pushButton_pauseplay.setIcon(
QtGui.QIcon(os.path.join(PACKAGE_DIR, "res", "play.png")))
self.ui.pushButton_pauseplay.setEnabled(False)
self.ui.pushButton_saveConfig.setEnabled(False)
self.ui.pushButton_showResult.setEnabled(False)
self.ui.pushButton_process.setEnabled(False)
# initiated detector
self.detector = dt.PupilLedDetector(
led_roi=self._qt_roi_2_detector_roi(self.led_roi),
pupil_roi=self._qt_roi_2_detector_roi(self.pupil_roi))
self._show_detector_parameters()
# remove result
self.ui.textBrowser_results.setText('')
self.status = 0
def __init__(self, tail=False, eyes=False, **kwargs):
""" """
self.eyes = eyes
self.tail = tail
super().__init__(**kwargs)
# Draw ROI for tail selection:
if tail:
self.roi_tail = pg.PolyLineROI(
(
self.track_params["tail_start"],
(
self.track_params["tail_start"][0]
+ self.track_params["tail_length"][0],
self.track_params["tail_start"][1]
+ self.track_params["tail_length"][1],
),
),
pen=dict(color=(40, 5, 200), width=3),
)
# Prepare curve for plotting tracked tail position:
self.curve_tail = pg.PlotCurveItem(pen=dict(color=(230, 40, 5), width=3))
self.display_area.addItem(self.curve_tail)
self.initialise_roi(self.roi_tail)
else:
self.roi_tail = None
self.curve_tail = None
# Draw ROI for eyes region selection:
self.pre_th = [0, 0]
if eyes:
self.roi_eyes = pg.ROI(
pos=self.track_params["wnd_pos"],
size=self.track_params["wnd_dim"],
pen=dict(color=(5, 40, 200), width=3),
)
self.roi_eyes.addScaleHandle([0, 0], [1, 1])
self.roi_eyes.addScaleHandle([1, 1], [0, 0])
self.curves_eyes = [
pg.EllipseROI(
pos=(0, 0), size=(10, 10), movable=False, pen=dict(color=k, width=3)
)
for k in [(5, 40, 230), (40, 230, 5)]
]
for c in self.curves_eyes:
self.display_area.addItem(c)
[c.removeHandle(h) for h in c.getHandles()]
self.tgl_threshold_view = QCheckBox()
self.lbl_threshold_view = QLabel("View thresholded image")
self.layout_control.addWidget(self.tgl_threshold_view)
self.layout_control.addWidget(self.lbl_threshold_view)
self.initialise_roi(self.roi_eyes)
else:
self.roi_eyes = None
self.curves_eyes = None
def init_pyqtgraph(self):
area = DockArea()
area.setVisible(True)
d1 = Dock("Registered Image", size=(600, 600))
d2 = Dock("Horizontal Profile", size=(300, 200))
d3 = Dock("Vertical Profile", size=(300, 200))
d4 = Dock("Peaks Position", size=(600, 600))
area.addDock(d2, 'top')
area.addDock(d1, 'left', d2)
area.addDock(d4, 'above', d1)
area.addDock(d3, 'bottom', d2)
area.moveDock(d1, 'above', d4)
# registered image ara (left dock)
self.ui.image_view = pg.ImageView(view=pg.PlotItem())
self.ui.image_view.ui.menuBtn.hide()
self.ui.image_view.ui.roiBtn.hide()
d1.addWidget(self.ui.image_view)
# vertical rois
_color = self.roi['vertical']['color']
_pen = QtGui.QPen()
_pen.setColor(_color)
_pen.setWidthF(self.roi['width'])
_x0 = self.roi['vertical']['x0']
_y0 = self.roi['vertical']['y0']
_width = self.roi['vertical']['width']
_length = self.roi['vertical']['length']
_roi_id = pg.ROI([_x0, _y0], [_width, _length], pen=_pen, scaleSnap=True)
self.ui.image_view.addItem(_roi_id)
_roi_id.sigRegionChanged.connect(self.vertical_roi_moved)
self.vertical_profile = _roi_id
self.ui.image_view.addItem(self.vertical_profile)
# horizontal rois
_color = self.roi['horizontal']['color']
_pen = QtGui.QPen()
_pen.setColor(_color)
_pen.setWidthF(self.roi['width'])
_x0 = self.roi['horizontal']['x0']
_y0 = self.roi['horizontal']['y0']
_length = self.roi['horizontal']['length']
_width = self.roi['horizontal']['width']
_roi_id = pg.ROI([_x0, _y0], [_length, _width], pen=_pen, scaleSnap=True)
self.ui.image_view.addItem(_roi_id)
_roi_id.sigRegionChanged.connect(self.horizontal_roi_moved)
self.horizontal_profile = _roi_id
self.ui.image_view.addItem(self.horizontal_profile)
## right area
# horizontal profile area
self.ui.hori_profile = pg.PlotWidget()
self.ui.hori_profile.plot()
# slider and height
label1 = QtGui.QLabel("Length")
hori_length = QtGui.QSlider(QtCore.Qt.Horizontal)
hori_length.setMinimum(self.roi['horizontal']['min_length'])
hori_length.setMaximum(self.roi['horizontal']['max_length'])
hori_length.setValue(self.roi['horizontal']['length'])
hori_length.valueChanged.connect(self.horizontal_slider_length_changed)
self.horizontal_length_slider = hori_length
label2 = QtGui.QLabel("Width")
hori_width = QtGui.QSlider(QtCore.Qt.Horizontal)
hori_width.setMinimum(self.roi['horizontal']['min_width'])
hori_width.setMaximum(self.roi['horizontal']['max_width'])
hori_width.setValue(self.roi['horizontal']['width'])
hori_width.valueChanged.connect(self.horizontal_slider_width_changed)
self.horizontal_width_slider = hori_width
hori_layout= QtGui.QHBoxLayout()
hori_layout.addWidget(label1)
hori_layout.addWidget(hori_length)
hori_layout.addWidget(label2)
hori_layout.addWidget(hori_width)
hori_widget = QtGui.QWidget()
hori_widget.setLayout(hori_layout)
full_hori_layout = QtGui.QVBoxLayout()
full_hori_layout.addWidget(self.ui.hori_profile)
full_hori_layout.addWidget(hori_widget)
full_hori_widget = QtGui.QWidget()
full_hori_widget.setLayout(full_hori_layout)
d2.addWidget(full_hori_widget)
# vertical profile area
self.ui.verti_profile = pg.PlotWidget()
self.ui.verti_profile.plot()
# slider and height
label1 = QtGui.QLabel("Length")
verti_length = QtGui.QSlider(QtCore.Qt.Horizontal)
verti_length.setMinimum(self.roi['vertical']['min_length'])
verti_length.setMaximum(self.roi['vertical']['max_length'])
verti_length.setValue(self.roi['vertical']['length'])
verti_length.valueChanged.connect(self.vertical_slider_length_changed)
self.vertical_length_slider = verti_length
label2 = QtGui.QLabel("Width")
verti_width = QtGui.QSlider(QtCore.Qt.Horizontal)
verti_width.setMinimum(self.roi['vertical']['min_width'])
verti_width.setMaximum(self.roi['vertical']['max_width'])
verti_width.setValue(self.roi['vertical']['width'])
verti_width.valueChanged.connect(self.vertical_slider_width_changed)
self.vertical_width_slider = verti_width
verti_layout = QtGui.QHBoxLayout()
verti_layout.addWidget(label1)
verti_layout.addWidget(verti_length)
verti_layout.addWidget(label2)
verti_layout.addWidget(verti_width)
verti_widget = QtGui.QWidget()
verti_widget.setLayout(verti_layout)
full_verti_layout = QtGui.QVBoxLayout()
full_verti_layout.addWidget(self.ui.verti_profile)
full_verti_layout.addWidget(verti_widget)
full_verti_widget = QtGui.QWidget()
full_verti_widget.setLayout(full_verti_layout)
d3.addWidget(full_verti_widget)
# all peaks position
self.ui.peaks = pg.PlotWidget(title='Vertical and Horizontal Peaks')
self.ui.peaks.plot()
d4.addWidget(self.ui.peaks)
# set up layout
vertical_layout = QtGui.QVBoxLayout()
vertical_layout.addWidget(area)
self.ui.pyqtgraph_widget.setLayout(vertical_layout)
grid.addWidget(split1)
win = pg.GraphicsLayoutWidget()
win.setWindowTitle('pyqtgraph example: Image Analysis')
scroll= tab.addTab(qwid,"Spectrum")
split1.addWidget(win)
# A plot area (ViewBox + axes) for displaying the image
p1 = win.addPlot()
# Item for displaying image data
img = pg.ImageItem()
p1.addItem(img)
# Custom ROI for selecting an image region
bpos = [100,1]
roi = pg.ROI(bpos, [data.shape[1]/10, data.shape[0]/3])
roi.addScaleHandle([0.5, 1], [0.5, 0.5])
roi.addScaleHandle([0, 0.5], [0.5, 0.5])
p1.addItem(roi)
roi.setZValue(10) # make sure ROI is drawn above image
# Isocurve drawing
iso = pg.IsocurveItem(level=0.8, pen='g')
iso.setParentItem(img)
iso.setZValue(5)
# Contrast/color control
hist = pg.HistogramLUTItem()
hist.gradient.loadPreset("flame")
hist.setImageItem(img)
win.addItem(hist)
def myLayout(self):
self.layout = QtGui.QHBoxLayout(self) #the whole window, main layout
self.leftLayout = QtGui.QVBoxLayout()
self.middleLayout = QtGui.QVBoxLayout()
self.rightLayout = QtGui.QHBoxLayout()
self.controlsLayout = QtGui.QGridLayout()
self.lineoutsLayout = QtGui.QGridLayout()
self.cameraLayout = QtGui.QVBoxLayout()
self.plotLayout = QtGui.QVBoxLayout()
self.phaseLayout = QtGui.QVBoxLayout()
self.layout.addLayout(self.leftLayout)
self.layout.addLayout(self.middleLayout)
self.layout.addLayout(self.rightLayout)
self.middleLayout.addLayout(self.controlsLayout)
self.leftLayout.addLayout(self.lineoutsLayout)
self.leftLayout.addLayout(self.cameraLayout)
self.rightLayout.addLayout(self.plotLayout)
self.rightLayout.addLayout(self.phaseLayout)
self.plotWidget1 = pq.PlotWidget(title='BC1 horn antenna')
self.plotWidget1.setVisible(True)
self.plotWidget1.setMaximumSize(350, 170)
self.plot11 = self.plotWidget1.plot()
self.plotWidget2 = pq.PlotWidget(title='BC2 horn antenna')
self.plotWidget2.setVisible(True)
self.plotWidget2.setMaximumSize(350, 170)
self.plot21 = self.plotWidget2.plot(
axisItems=['signal sum', 'pixel', '', ''])
self.plotWidget3 = pq.PlotWidget(title='BC1 horn antenna trend')
self.plotWidget3.setVisible(True)
self.plotWidget3.setMaximumSize(350, 185)
self.plot31 = self.plotWidget3.plot()
self.plotWidget4 = pq.PlotWidget(title='BC2 horn antenna trend')
self.plotWidget4.setVisible(True)
self.plotWidget4.setMaximumSize(350, 185)
self.plot41 = self.plotWidget4.plot()
self.lineoutsLayout.addWidget(self.plotWidget1)
self.lineoutsLayout.addWidget(self.plotWidget3)
self.lineoutsLayout.addWidget(self.plotWidget2)
self.lineoutsLayout.addWidget(self.plotWidget4)
#camera image
#self.cameraWindow = pq.GraphicsLayoutWidget()
self.cameraWindow = pq.PlotWidget()
self.cameraWindow.setMaximumSize(350, 350)
#self.cameraWindow.setSizePolicy(QtGui.QSizePolicy.Expanding,QtGui.QSizePolicy.Expanding)
self.cameraLayout.addWidget(self.cameraWindow)
#self.view = self.cameraWindow.addViewBox()
#self.view.setAspectLocked(True)
self.img = pq.ImageItem(border='w')
self.cameraWindow.addItem(self.img)
#roi
self._roi = pq.ROI([300, 440], [self._pixX, self._pixY])
self._roi.addScaleHandle(1, 0)
self._roi.scaleSnap = True # Force ROI to integer snap positions
#self._roi.maxBounds = QtCore.QRect(0, 0, 1280, 1024)
self._roi.sigRegionChangeFinished.connect(self.change_roi)
self.cameraWindow.addItem(self._roi)
self._roi.setZValue(10) # make sure ROI is drawn above image
self.chooseScreenBox = QtGui.QComboBox()
self.chooseScreenBox.addItems(self.cameraNames)
#self.screenSelectedLabel = QtGui.QLabel("none selected")
#self.screenBoxLabel = QtGui.QLabel("select camera")
#self.cameraStartButton = QtGui.QPushButton("start camera")
#self.cameraStopButton = QtGui.QPushButton("stop camera")
self.saveImagesButton = QtGui.QPushButton("save images")
self.noImagesBox = QtGui.QSpinBox()
self.noImagesBox.setValue(5)
self.imageNameBox = QtGui.QLineEdit()
self.imageFolderNameBox = QtGui.QLineEdit()
#camera box
self.cameraBox = QtGui.QGroupBox()
sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Minimum,
QtGui.QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.cameraBox.sizePolicy().hasHeightForWidth())
self.cameraBox.setSizePolicy(sizePolicy)
self.cameraBox.setMinimumSize(QtCore.QSize(150, 0))
self.cameraBox.setMaximumSize(QtCore.QSize(200, 80))
#self.cameraBox.setObjectName("Select Camera")
self.chooseScreenBox = QtGui.QComboBox(self.cameraBox)
self.chooseScreenBox.setGeometry(QtCore.QRect(20, 20, 50, 15))
self.chooseScreenBox.setObjectName("chooseScreenBox")
self.chooseScreenBox.addItems(self.cameraNames)
self.screenSelectedLabel = QtGui.QLabel(self.cameraBox)
self.chooseScreenBox.setGeometry(QtCore.QRect(20, 50, 50, 15))
#self.screenSelectedLabel.setText("none selected")
self.screenBoxLabel = QtGui.QLabel(self.cameraBox)
self.screenBoxLabel.setText("select camera")
self.cameraStartButton = QtGui.QPushButton(self.cameraBox)
self.cameraStartButton.setText("start camera")
self.cameraStartButton.setGeometry(QtCore.QRect(20, 80, 20, 15))
self.cameraStopButton = QtGui.QPushButton("stop camera",
self.cameraBox)
self.cameraStopButton.setGeometry(QtCore.QRect(20, 110, 20, 15))
self.controlsLayout.addWidget(self.cameraBox)
self.saveImagesButton = QtGui.QPushButton("save images")
self.noImagesBox = QtGui.QSpinBox()
self.noImagesBox.setValue(5)
self.imageNameBox = QtGui.QLineEdit()
self.imageFolderNameBox = QtGui.QLineEdit()
self.VExpSpacer = QtGui.QSpacerItem(100, 100,
QtGui.QSizePolicy.Expanding,
QtGui.QSizePolicy.Expanding)
self.VFixSpacer = QtGui.QSpacerItem(100, 100,
QtGui.QSizePolicy.Expanding,
QtGui.QSizePolicy.Minimum)
self.VFixSmallSpacer = QtGui.QSpacerItem(100, 25,
QtGui.QSizePolicy.Expanding,
QtGui.QSizePolicy.Minimum)
#phase scan controls
self.scanPhaseRadioButtonLabel = QtGui.QLabel('Scan L00 phase')
self.scanPhaseRadioButton = QtGui.QRadioButton()
self.scanPhaseInitialLabel = QtGui.QLabel('initial phase')
self.scanPhaseFinalLabel = QtGui.QLabel('final phase')
self.scanPhaseFinal = QtGui.QDoubleSpinBox()
#self.controlsLayout.addWidget(self.screenBoxLabel,8,0)
#self.controlsLayout.addWidget(self.chooseScreenBox,9,0)
#self.controlsLayout.addWidget(self.screenSelectedLabel,10,0)
#self.controlsLayout.addWidget(self.cameraStartButton,11,0)
#self.controlsLayout.addWidget(self.cameraStopButton,12,0)
#self.controlsLayout.addItem(self.VExpSpacer,13,0)
#self.controlsLayout.addWidget(self.)
self.controlsLayout.addItem(self.VExpSpacer, 13, 0)
self.controlsLayout.addWidget(self.saveImagesButton, 14, 0)
self.controlsLayout.addWidget(self.noImagesBox, 15, 0)
self.controlsLayout.addWidget(QtGui.QLabel("file name"), 16, 0)
self.controlsLayout.addWidget(self.imageNameBox, 17, 0)
self.controlsLayout.addWidget(QtGui.QLabel("folder name"), 18, 0)
self.controlsLayout.addWidget(self.imageFolderNameBox, 19, 0)
self.controlsLayout.addItem(self.VExpSpacer, 20, 0)
self.saveBkgndButton = QtGui.QPushButton('Save Background')
self.saveBkgndButton.clicked.connect(self.saveBkgnd)
self.subtractBkgndButton = QtGui.QRadioButton()
self.subtractBkgndButton.setText('Subtract bkgnd')
self.controlsLayout.addWidget(self.saveBkgndButton, 21, 0)
self.controlsLayout.addWidget(self.subtractBkgndButton, 22, 0)
self.chooseScreenBox.activated.connect(self.updatescreenSelected)
self.cameraStartButton.clicked.connect(self.cameraStart)
self.cameraStopButton.clicked.connect(self.cameraStop)
self.saveImagesButton.clicked.connect(self.saveImages)
self.rightLayout.addLayout(self.plotLayout)
self.plotWidget5 = pq.PlotWidget(title='beam lineout')
self.plotWidget5.setVisible(True)
self.plotWidget5.setMaximumSize(350, 185)
self.plot51 = self.plotWidget5.plot()
self.plot52 = self.plotWidget5.plot()
self.plotWidget6 = pq.PlotWidget(title='beam trans. std trend')
self.plotWidget6.setVisible(True)
self.plotWidget6.setMaximumSize(350, 185)
self.plot61 = self.plotWidget6.plot()
#self.plotLayout.addWidget(self.plotWidget3)
#self.plotLayout.addWidget(self.plotWidget4)
self.plotLayout.addWidget(self.cameraWindow)
self.plotLayout.addWidget(self.plotWidget5)
self.plotLayout.addWidget(self.plotWidget6)
#phases
self.L00PhaseCrest = QtGui.QLineEdit()
self.L00PhaseCrest.setText('1000')
self.L00PhaseWrite = QtGui.QDoubleSpinBox()
self.L00PhaseWrite.setRange(0, 1000)
self.L00PhaseRead = QtGui.QLabel()
self.L01PhaseCrest = QtGui.QLineEdit()
self.L01PhaseCrest.setText('303')
self.L01PhaseWrite = QtGui.QDoubleSpinBox()
self.L01PhaseWrite.setRange(0, 1000)
self.L01PhaseRead = QtGui.QLabel()
self.L02PhaseCrest = QtGui.QLineEdit()
self.L02PhaseCrest.setText('163')
self.L02PhaseWrite = QtGui.QDoubleSpinBox()
self.L02PhaseWrite.setRange(0, 1000)
self.L02PhaseRead = QtGui.QLabel()
self.phaseLayout.addWidget(QtGui.QLabel("L00 crest phase"))
self.phaseLayout.addWidget(self.L00PhaseCrest)
self.phaseLayout.addWidget(QtGui.QLabel("L00 phase"))
self.phaseLayout.addWidget(self.L00PhaseWrite)
L00Phase = self.L00PhaseDevice.read_attribute('PhaseDifference').value
self.L00PhaseWrite.setValue(L00Phase)
self.L00PhaseWrite.valueChanged.connect(self.setL00Phase)
self.phaseLayout.addWidget(self.L00PhaseRead)
self.L00PhaseDevice.read_attribute('PhaseDifference').value
self.L00PhaseRead.setText(
str(self.L00PhaseDevice.read_attribute('PhaseDifference').value))
self.phaseLayout.addItem(self.VFixSpacer)
self.phaseLayout.addWidget(QtGui.QLabel("L01 crest phase"))
self.phaseLayout.addWidget(self.L01PhaseCrest)
self.phaseLayout.addWidget(QtGui.QLabel("L01 phase"))
self.phaseLayout.addWidget(self.L01PhaseWrite)
L01Phase = self.L01PhaseDevice.read_attribute('PhaseDifference').value
self.L01PhaseWrite.setValue(L01Phase)
self.L01PhaseWrite.valueChanged.connect(self.setL01Phase)
self.phaseLayout.addWidget(self.L01PhaseRead)
self.L01PhaseDevice.read_attribute('PhaseDifference').value
self.L01PhaseRead.setText(
str(self.L01PhaseDevice.read_attribute('PhaseDifference').value))
self.phaseLayout.addItem(self.VFixSpacer)
self.phaseLayout.addWidget(QtGui.QLabel("L02 crest phase"))
self.phaseLayout.addWidget(self.L02PhaseCrest)
self.phaseLayout.addWidget(QtGui.QLabel("L02 phase"))
self.phaseLayout.addWidget(self.L02PhaseWrite)
L02Phase = self.L02PhaseDevice.read_attribute('PhaseDifference').value
self.L02PhaseWrite.setValue(L02Phase)
self.L02PhaseWrite.valueChanged.connect(self.setL02Phase)
self.phaseLayout.addWidget(self.L02PhaseRead)
self.L02PhaseDevice.read_attribute('PhaseDifference').value
self.L02PhaseRead.setText(
str(self.L02PhaseDevice.read_attribute('PhaseDifference').value))
self.phaseLayout.addItem(self.VExpSpacer)
## 1) All spots identical and transform-invariant (top-left plot).
## In this case we can get a huge performance boost by pre-rendering the spot
## image and just drawing that image repeatedly.
n = 300
s1 = pg.ScatterPlotItem(size=10, pen=pg.mkPen(None), brush=pg.mkBrush(255, 255, 255, 120))
pos = np.random.normal(size=(2,n), scale=1e-5)
spots = [{'pos': pos[:,i], 'data': 1} for i in range(n)] + [{'pos': [0,0], 'data': 1}]
s1.addPoints(spots)
w1.addItem(s1)
s1.sigClicked.connect(clicked)
##################################################
################add ROI###########################
r1a = pg.ROI([-1e-5,-1e-5], [1e-5,1e-5])
w1.addItem(r1a)
## handles scaling horizontally around center
r1a.addScaleHandle([1, 0.5], [0.5, 0.5])
r1a.addScaleHandle([0, 0.5], [0.5, 0.5])
## handles scaling vertically from opposite edge
r1a.addScaleHandle([0.5, 0], [0.5, 1])
r1a.addScaleHandle([0.5, 1], [0.5, 0])
## handles scaling both vertically and horizontally
r1a.addScaleHandle([1, 1], [0, 0])
r1a.addScaleHandle([0, 0], [1, 1])
def updateROI(roi):
global lastClicked
def setup_figure(self):
"""
Runs once during App initialization, after setup()
This is the place to make all graphical interface initializations,
build plots, etc.
"""
# connect settings to ui
self.stepper_motor_hw.settings.x_position.connect_to_widget(
self.ui.x_pos_doubleSpinBox)
self.stepper_motor_hw.settings.y_position.connect_to_widget(
self.ui.y_pos_doubleSpinBox)
self.settings.scan_direction.connect_to_widget(self.ui.scan_comboBox)
self.settings.x_start.connect_to_widget(self.ui.x_start_doubleSpinBox)
self.settings.y_start.connect_to_widget(self.ui.y_start_doubleSpinBox)
self.settings.x_size.connect_to_widget(self.ui.x_size_doubleSpinBox)
self.settings.y_size.connect_to_widget(self.ui.y_size_doubleSpinBox)
self.settings.x_step.connect_to_widget(self.ui.x_step_doubleSpinBox)
self.settings.y_step.connect_to_widget(self.ui.y_step_doubleSpinBox)
self.settings.x_clicked.connect_to_widget(
self.ui.x_clicked_doubleSpinBox)
self.settings.y_clicked.connect_to_widget(
self.ui.y_clicked_doubleSpinBox)
self.settings.lock_position.connect_to_widget(
self.ui.lock_position_checkBox)
self.settings.save_positions.connect_to_widget(
self.ui.save_positions_checkBox)
self.settings.progress.connect_to_widget(self.ui.progressBar)
#stage ui base
self.stage_layout = pg.GraphicsLayoutWidget()
self.ui.stage_groupBox.layout().addWidget(self.stage_layout)
self.stage_plot = self.stage_layout.addPlot(title="Stage view")
# self.stage_plot.setXRange(0, 100)
# self.stage_plot.setYRange(0, 100)
# self.stage_plot.setLimits(xMin=0, xMax=100, yMin=0, yMax=100)
#region of interest - allows user to select scan area
self.scan_roi = pg.ROI([0, 0], [25, 25], movable=True)
self.handle1 = self.scan_roi.addScaleHandle([1, 1], [0, 0])
self.handle2 = self.scan_roi.addScaleHandle([0, 0], [1, 1])
self.scan_roi.sigRegionChangeFinished.connect(
self.mouse_update_scan_roi)
self.scan_roi.sigRegionChangeFinished.connect(self.update_ranges)
self.stage_plot.addItem(self.scan_roi)
#setup ui signals
self.ui.start_scan_pushButton.clicked.connect(self.start)
self.ui.interrupt_scan_pushButton.clicked.connect(self.interrupt)
self.ui.move_to_selected_pushButton.clicked.connect(
self.move_to_selected)
self.ui.export_positions_pushButton.clicked.connect(
self.export_positions)
self.ui.x_start_doubleSpinBox.valueChanged.connect(
self.update_roi_start)
self.ui.y_start_doubleSpinBox.valueChanged.connect(
self.update_roi_start)
self.ui.x_size_doubleSpinBox.valueChanged.connect(self.update_roi_size)
self.ui.y_size_doubleSpinBox.valueChanged.connect(self.update_roi_size)
self.ui.x_step_doubleSpinBox.valueChanged.connect(
self.update_roi_start)
self.ui.y_step_doubleSpinBox.valueChanged.connect(
self.update_roi_start)
self.ui.x_size_doubleSpinBox.valueChanged.connect(self.update_ranges)
self.ui.y_size_doubleSpinBox.valueChanged.connect(self.update_ranges)
self.ui.x_step_doubleSpinBox.valueChanged.connect(self.update_ranges)
self.ui.y_step_doubleSpinBox.valueChanged.connect(self.update_ranges)
#histogram for image
self.hist_lut = pg.HistogramLUTItem()
self.stage_layout.addItem(self.hist_lut)
#image on stage plot, will show intensity sums
self.img_item = pg.ImageItem()
self.stage_plot.addItem(self.img_item)
blank = np.zeros((3, 3))
self.img_item.setImage(image=blank) #placeholder image
self.hist_lut.setImageItem(self.img_item) #setup histogram
#arrow showing stage location
self.current_stage_pos_arrow = pg.ArrowItem()
self.current_stage_pos_arrow.setZValue(100)
self.stage_plot.addItem(self.current_stage_pos_arrow)
self.stepper_motor_hw.settings.x_position.updated_value.connect(
self.update_arrow_pos, QtCore.Qt.UniqueConnection)
self.stepper_motor_hw.settings.y_position.updated_value.connect(
self.update_arrow_pos, QtCore.Qt.UniqueConnection)
#Define crosshairs that will show up after scan, event handling.
self.vLine = pg.InfiniteLine(angle=90, movable=False, pen='r')
self.hLine = pg.InfiniteLine(angle=0, movable=False, pen='r')
self.stage_plot.scene().sigMouseClicked.connect(self.ch_click)
def make_imagepanel(self):
self.expectedPixels = (1920, 1200)
panel = QFrame()
panel.setFrameStyle(QFrame.Raised | QFrame.Panel)
MainPwig = pg.PlotWidget()
# Get the colormap
colormap = cm.get_cmap("nipy_spectral") # cm.get_cmap("CMRmap")
colormap._init()
lut = (colormap._lut * 255).view(
np.ndarray
) # Convert matplotlib colormap from 0-1 to 0 -255 for Qt
self.mainImage = pg.ImageItem()
self.mainImage.setLookupTable(lut)
MainPwig.addItem(self.mainImage)
MainPwig.setMaximumSize(640, 400)
sp = MainPwig.sizePolicy()
sp.setHorizontalPolicy(QSizePolicy.Fixed)
sp.setVerticalPolicy(QSizePolicy.Fixed)
MainPwig.setSizePolicy(sp)
layout = QGridLayout()
self.imagehistorycontainer = [pg.ImageItem() for i in range(2)
] #[QLabel() for i in range(3)]
for animage in self.imagehistorycontainer:
animage.setLookupTable(lut)
self.imagehistoryarray = [None, None, None, None]
for i, awidget in enumerate([pg.PlotWidget() for i in range(2)]):
awidget.setMaximumSize(213, 133)
sp = awidget.sizePolicy()
sp.setHorizontalPolicy(
QSizePolicy.Fixed) #setHeightForWidth( True)
sp.setVerticalPolicy(QSizePolicy.Fixed)
awidget.setSizePolicy(sp)
awidget.addItem(self.imagehistorycontainer[i])
layout.addWidget(awidget, i + 1, 4)
#Histogramplot
histplot = pg.PlotWidget()
self.histogramplot = [histplot.plot(), histplot.plot()]
self.histogramplot[0].setPen((255, 0, 0))
self.histogramplot[1].setPen((0, 255, 0))
self.xline = MainPwig.plot()
self.yline = MainPwig.plot()
self.xline.setPen((255, 0, 0))
self.yline.setPen((0, 255, 0))
#Region of interest
self.ROI = pg.ROI([100, 100], [400, 400])
MainPwig.addItem(self.ROI)
## handles scaling horizontally around center
self.ROI.addScaleHandle([1, 0.5], [0.5, 0.5])
self.ROI.addScaleHandle([0, 0.5], [0.5, 0.5])
## handles scaling vertically from opposite edge
self.ROI.addScaleHandle([0.5, 0], [0.5, 1])
self.ROI.addScaleHandle([0.5, 1], [0.5, 0])
## handles scaling both vertically and horizontally
self.ROI.addScaleHandle([1, 1], [0, 0])
self.ROI.addScaleHandle([0, 0], [1, 1])
layout.addWidget(histplot, 3, 4)
layout.addWidget(QLabel('Current image'), 0, 1)
layout.addWidget(MainPwig, 1, 0, 3, 3)
layout.addWidget(QLabel('NoMot'), 1, 5)
layout.addWidget(QLabel('MOT'), 2, 5)
layout.setAlignment(QtCore.Qt.AlignCenter)
panel.setLayout(layout)
return panel
def __init__(self):
#TemplateBaseClass.__init__(self)
# Initialize FrameGrabber
self.VMIcrtl = VMIcrtl_ext.VMIcrtl()
#Initialize window
self.win = pg.LayoutWidget() # Main layout
self.win.setWindowTitle('VMI GUI')
#Loadfile button
self.loadbutton = QtGui.QPushButton('Load Data')
self.loadbutton.clicked.connect(self.OpenFile)
#Take reference button
self.refbutton = QtGui.QPushButton('Save Reference')
self.refbutton.clicked.connect(self.SaveReference)
self.Prevbutton = QtGui.QPushButton('Preview')
self.Prevbutton.clicked.connect(self.PrevAcq)
self.FlatBGbutton = QtGui.QPushButton('Flat Corr')
self.FlatBGbutton.clicked.connect(self.LoadFlatCorrection)
self.Startbutton = QtGui.QPushButton('Start')
self.Startbutton.clicked.connect(self.StartAcq)
self.Stopbutton = QtGui.QPushButton('Stop')
self.Stopbutton.clicked.connect(self.StopAcq)
#Checkboxes
self.checkbox0 = QtGui.QCheckBox(
'Reference') #View the data feeded by the digitizer
self.checkbox0.clicked.connect(self.updatePlot)
self.checkbox1 = QtGui.QCheckBox(
'Refresh Viewer') #View the data feeded by the digitizer
self.checkbox1.clicked.connect(self.StreamOnOff)
self.checkbox2 = QtGui.QCheckBox('Norm Radial Distribution')
self.checkbox2.clicked.connect(self.NormalizeDscan)
self.checkbox3 = QtGui.QCheckBox('Norm TOF')
self.checkbox3.clicked.connect(self.NormalizeTOF)
# Center control buttons
self.cxlabel = QtGui.QLabel('Center X pos')
self.spinbox1 = QtGui.QDoubleSpinBox()
self.spinbox1.valueChanged.connect(self.updateROI)
self.spinbox1.setMaximum(400.0)
self.spinbox1.setMinimum(0.0)
self.spinbox1.setValue(204.0)
self.cylabel = QtGui.QLabel('Center Y pos')
self.spinbox2 = QtGui.QDoubleSpinBox()
self.spinbox2.valueChanged.connect(self.updateROI)
self.spinbox2.setMaximum(400.0)
self.spinbox2.setMinimum(0.0)
self.spinbox2.setValue(197.0)
#background removal buttons
self.BGbutton = QtGui.QPushButton('Load XUV BG')
self.BGbutton.clicked.connect(self.LoadBG)
self.bglabel = QtGui.QLabel('BG removal amount')
self.spinbox3 = QtGui.QDoubleSpinBox()
self.spinbox3.valueChanged.connect(self.updateBG)
self.spinbox3.setMaximum(10.0)
self.spinbox3.setMinimum(0.0)
self.spinbox3.setValue(1.0)
self.checkbox4 = QtGui.QCheckBox('BG removed ON/OFF')
self.checkbox4.clicked.connect(self.updateBG)
self.checkbox5 = QtGui.QCheckBox('pixels to energy')
self.checkbox5.clicked.connect(self.updatePlot)
self.EnCaliblabel = QtGui.QLabel('Energy Calibration coeff (x1e-6)')
self.spinbox4 = QtGui.QDoubleSpinBox()
self.spinbox4.valueChanged.connect(self.updatePlot)
self.spinbox4.setMaximum(10000.0)
self.spinbox4.setMinimum(0.0)
self.spinbox4.setValue(894.30)
self.NAcqLabel = QtGui.QLabel('Number of acquisitions')
self.spinbox5 = QtGui.QSpinBox()
self.spinbox5.valueChanged.connect(self.UpdateParameters)
self.spinbox5.setMaximum(100000)
self.spinbox5.setMinimum(0)
self.spinbox5.setValue(50)
self.checkbox6 = QtGui.QCheckBox('Dscan')
self.Dstart = QtGui.QLabel('Dstart')
self.spinbox6 = QtGui.QDoubleSpinBox()
#self.spinbox6.valueChanged.connect(self.updatePlot)
self.spinbox6.setMaximum(80.0)
self.spinbox6.setMinimum(0.0)
self.spinbox6.setValue(0.0)
self.Dstop = QtGui.QLabel('Dstop')
self.spinbox7 = QtGui.QDoubleSpinBox()
self.spinbox7.setMaximum(80.0)
self.spinbox7.setMinimum(0.0)
self.spinbox7.setValue(80.0)
self.Dstep = QtGui.QLabel('Dstep')
self.spinbox8 = QtGui.QDoubleSpinBox()
self.spinbox8.setMaximum(80.0)
self.spinbox8.setMinimum(0.0)
self.spinbox8.setValue(1.0)
self.ThLabel = QtGui.QLabel('Threshold')
self.spinbox9 = QtGui.QSpinBox()
self.spinbox9.valueChanged.connect(self.UpdateParameters)
self.spinbox9.setMaximum(255)
self.spinbox9.setMinimum(1)
self.spinbox9.setValue(1)
self.checkbox7 = QtGui.QCheckBox('Median Filter')
self.checkbox7.clicked.connect(self.UpdateParameters)
self.checkbox8 = QtGui.QCheckBox('Single Shot rec')
self.checkbox8.clicked.connect(self.UpdateParameters)
## Trigger mode
self.checkbox10 = QtGui.QCheckBox('Trigger ON/OFF')
self.checkbox10.clicked.connect(self.setTriggerMode)
self.ExpoLabel = QtGui.QLabel(' Exposure (us)')
self.spinbox10 = QtGui.QSpinBox()
self.spinbox10.valueChanged.connect(self.UpdateParameters)
self.spinbox10.setMaximum(990)
self.spinbox10.setMinimum(100)
self.spinbox10.setValue(500.0)
## save path
self.Savepath = '20161130_0000.dat'
self.SaveLabel = QtGui.QLabel('Save path:')
self.Savepathbutton = QtGui.QPushButton('...')
self.Savepathedit = QtGui.QLineEdit(self.Savepath)
self.Savepathedit.textChanged.connect(self.UpdateParameters)
self.Savepathbutton.clicked.connect(self.setDir)
## Progress bars
self.DprogressLabel = QtGui.QLabel('Dscan progress')
self.Dprogressbar = QtGui.QProgressBar()
self.Dprogressbar.setRange(0, 100)
self.progressLabel = QtGui.QLabel('Acq progress')
self.progressbar = QtGui.QProgressBar()
self.progressbar.setRange(0, 100)
self.infos = QtGui.QLabel(
'Center Position : X0= 0.0 / Y0= 0.0 ; ROI radius = 100.0 px')
self.graph = pg.GraphicsLayoutWidget()
# GUI layout
self.win.addWidget(self.loadbutton, row=0, col=0, colspan=1)
self.win.addWidget(self.refbutton, row=1, col=0, colspan=1)
self.win.addWidget(self.checkbox0, row=2, col=0, colspan=1)
self.win.addWidget(self.checkbox1, row=3, col=0, colspan=1)
self.win.addWidget(self.checkbox2, row=4, col=0, colspan=1)
self.win.addWidget(self.checkbox3, row=5, col=0, colspan=1)
self.win.addWidget(self.BGbutton, row=6, col=0)
self.win.addWidget(self.checkbox4, row=7, col=0)
self.win.addWidget(self.bglabel, row=8, col=0)
self.win.addWidget(self.spinbox3, row=9, col=0)
#self.win.addWidget(self.triggerlabel,row=11,col=2,colspan=1)
self.win.addWidget(self.checkbox10, row=11, col=2, colspan=1)
self.win.addWidget(self.ExpoLabel, row=12, col=2, colspan=1)
self.win.addWidget(self.spinbox10, row=13, col=2, colspan=1)
self.win.addWidget(self.cxlabel, row=10, col=0)
self.win.addWidget(self.spinbox1, row=11, col=0)
self.win.addWidget(self.cylabel, row=12, col=0)
self.win.addWidget(self.spinbox2, row=13, col=0)
self.win.addWidget(self.checkbox5, row=14, col=0)
self.win.addWidget(self.EnCaliblabel, row=15, col=0)
self.win.addWidget(self.spinbox4, row=16, col=0)
self.win.addWidget(self.Prevbutton, row=0, col=1, colspan=1)
self.win.addWidget(self.FlatBGbutton, row=0, col=2, colspan=1)
self.win.addWidget(self.Startbutton, row=1, col=1, colspan=1)
self.win.addWidget(self.Stopbutton, row=1, col=2, colspan=1)
self.win.addWidget(self.NAcqLabel, row=2, col=1)
self.win.addWidget(self.spinbox5, row=3, col=1, colspan=1)
self.win.addWidget(self.checkbox7, row=4, col=1, colspan=1)
self.win.addWidget(self.checkbox8, row=5, col=1, colspan=1)
self.win.addWidget(self.ThLabel, row=2, col=2)
self.win.addWidget(self.spinbox9, row=3, col=2, colspan=1)
self.win.addWidget(self.checkbox6, row=4, col=2, colspan=1)
self.win.addWidget(self.Dstart, row=5, col=2, colspan=1)
self.win.addWidget(self.spinbox6, row=6, col=2, colspan=1)
self.win.addWidget(self.Dstop, row=7, col=2, colspan=1)
self.win.addWidget(self.spinbox7, row=8, col=2, colspan=1)
self.win.addWidget(self.Dstep, row=9, col=2, colspan=1)
self.win.addWidget(self.spinbox8, row=10, col=2, colspan=1)
self.win.addWidget(self.SaveLabel, row=14, col=1, colspan=1)
self.win.addWidget(self.Savepathbutton, row=14, col=2, colspan=1)
self.win.addWidget(self.Savepathedit, row=15, col=1, colspan=2)
self.win.addWidget(self.progressLabel, row=17, col=0, colspan=1)
self.win.addWidget(self.progressbar, row=17, col=1, colspan=2)
self.win.addWidget(self.DprogressLabel, row=18, col=0, colspan=1)
self.win.addWidget(self.Dprogressbar, row=18, col=1, colspan=2)
self.win.addWidget(self.infos, row=18, col=3)
self.win.addWidget(self.graph, row=0, col=3, rowspan=18, colspan=6)
self.win.resize(1500, 1000)
#self.win.show()
# Graph layout for cartesian image
self.p1 = self.graph.addPlot(row=0, col=0, rowspan=2)
self.p1.setLabel(axis='left', text='Py (pixel)')
self.p1.setLabel(axis='bottom', text='Py (pixel)')
# Item for displaying image data
self.img = pg.ImageItem()
self.p1.addItem(self.img)
self.p1.setAspectLocked(True, ratio=1)
# Custom ROI for selecting an image region
self.roi = pg.CircleROI(
[100, 100],
[50, 50]) # first vector =[x0,y0], second vector =[lx,ly]
# self.roi.addScaleHandle([0.5, 1], [0.5, 0.5])
# self.roi.addScaleHandle([0, 0.5], [0.5, 0.5])
self.p1.addItem(self.roi)
self.roi.setZValue(10) # make sure ROI is drawn above image
self.roi.sigRegionChanged.connect(self.updatePlot)
# Isocurve drawing
self.iso = pg.IsocurveItem(level=0.8, pen='g')
self.iso.setParentItem(self.img)
self.iso.setZValue(5)
# Contrast/color control
self.hist = pg.HistogramLUTItem()
self.hist.setImageItem(self.img)
self.graph.addItem(self.hist, row=0, col=1, rowspan=2)
# Draggable line for setting isocurve level
self.isoLine = pg.InfiniteLine(angle=0, movable=True, pen='g')
self.hist.vb.addItem(self.isoLine)
self.hist.vb.setMouseEnabled(
y=False) # makes user interaction a little easier
self.isoLine.setValue(0.8)
self.isoLine.setZValue(1000) # bring iso line above contrast controls
self.isoLine.sigDragged.connect(self.updateIsocurve)
# Another plot area for displaying ROI data
self.graph.nextRow()
self.p0 = self.graph.addPlot(row=0, col=3, colspan=2)
self.p0.setLabel(axis='left', text='Radius (px)')
self.p0.setLabel(axis='bottom', text='Angle (°)')
self.imgpol = pg.ImageItem()
self.p0.addItem(self.imgpol)
self.histpol = pg.HistogramLUTItem()
self.histpol.setImageItem(self.imgpol)
self.graph.addItem(self.histpol, row=0, col=5)
self.histpol.setMaximumWidth(100)
self.graph.nextCol()
self.p2 = self.graph.addPlot(row=1, col=3, colspan=2)
self.p2.setLabel(axis='left', text='Signal (arb. u)')
self.p2.setLabel(axis='bottom', text='Momentum (pixel)')
self.graph.nextRow()
self.p3 = self.graph.addPlot(row=3, col=0, colspan=5)
self.p3.setLabel(axis='bottom', text='Delay (fs)')
self.p3.setLabel(axis='left', text='Momentum (px)')
self.Dscan = pg.ImageItem()
self.p3.addItem(self.Dscan)
self.histpol2 = pg.HistogramLUTItem()
self.histpol2.setImageItem(self.Dscan)
self.graph.addItem(self.histpol2, row=3, col=5)
self.histpol2.setMaximumWidth(100)
self.roipol = pg.ROI(
[50, 1],
[30, 150]) # first vector =[x0,y0], second vector =[lx,ly]
self.roipol.addScaleHandle([0.5, 1], [0.5, 0.5])
self.roipol.addScaleHandle([0, 0.5], [0.5, 0.5])
self.p0.addItem(self.roipol)
self.roipol.setZValue(10) # make sure ROI is drawn above image
self.roipol.sigRegionChanged.connect(self.updatePlot)
#Initialize the image
self.initimg = np.random.normal(size=(400, 400))
self.initimg[380:420, 380:420] += 2.
self.initimg = pg.gaussianFilter(self.initimg, (3, 3))
self.initimg += np.random.normal(size=(400, 400)) * 0.1
self.scan = VMITraceProcessing(self.initimg)
self.activeimg = self.scan.imgcart_raw
self.img.setImage(self.activeimg)
self.img.scale(1, 1)
self.img.translate(0, 0)
self.hist.setLevels(self.activeimg.min(), self.activeimg.max())
self.p1.autoRange()
self.scan.ImgCart2Pol([
self.roi.pos()[1] + self.roi.size()[0] / 2.0,
self.roi.pos()[0] + self.roi.size()[0] / 2.0
], self.roi.size())
self.imgpol.setImage(self.scan.imgpol)
self.imgDscan = np.zeros((400, 80))
# Infos from filedata
self.pname = ''
self.pnameBG = ''
self.fname = ''
# Initialise useful variables
self.BGimg = []
self.normDscan = []
self.normTOF = []
self.refRadialDist = []
self.refx0 = []
self.refy0 = []
self.cx = []
self.cy = []
#Timer object for realtime data
self.timer = QtCore.QTimer()
self.timer.timeout.connect(self.updatePlot)
#Update the gui
self.win.show()