def build_ui(self):
self.remove_files_button = QtGui.QPushButton('Remove selected files')
self.remove_files_button.clicked.connect(self.rm_files)
self.viewer_frame = QtGui.QFrame()
self.viewer_layout = QtGui.QGridLayout()
self.viewer_frame.setLayout(self.viewer_layout)
self.wf_frame = QtGui.QFrame()
self.wf_layout = QtGui.QGridLayout()
self.wf_frame.setLayout(self.wf_layout)
self.wf_selector = QtGui.QComboBox()
lm = ListModel(self._wf_uris.keys())
self.wf_selector.setModel(lm)
self.wf_selector.currentIndexChanged.connect(
partial(self._set_wf_by_idx))
self.run_wf_button = QtGui.QPushButton(self._run_button_text)
self.run_wf_button.clicked.connect(self.toggle_run_wf)
self.vis_toggle = QtGui.QCheckBox('Realtime visualization')
self.wf_control = pt.ParameterTree()
self.wf_control.setHeaderLabels(['Operation', 'Settings'])
self.wf_layout.addWidget(self.wf_selector, 0, 0, 1, 2)
self.wf_layout.addWidget(self.run_wf_button, 1, 0, 1, 1)
self.wf_layout.addWidget(self.vis_toggle, 1, 1, 1, 1)
self.wf_layout.addWidget(self.wf_control, 2, 0, 1, 2)
#self.wf_control.itemClicked.connect(self._display_wf_item)
self.batch_control = QtGui.QWidget()
self.batch_list = QtGui.QListWidget()
self.batch_layout = QtGui.QGridLayout()
self.batch_control.setLayout(self.batch_layout)
self.batch_layout.addWidget(self.batch_list, 0, 0, 1, 1)
self.batch_layout.addWidget(self.remove_files_button, 1, 0, 1, 1)
self.batch_list.setSelectionMode(
QtGui.QAbstractItemView.ExtendedSelection)
def __init__(self,
reserved: Iterable[str] = None,
parent=None,
window_flags=Qt.WindowFlags()):
super(MetadataDialog, self).__init__(parent, window_flags)
self.reserved = set(reserved or [])
self.parameter_tree = pt.ParameterTree(showHeader=False)
self.parameter_tree.setParameters(self.parameter, showTop=False)
calibrate_button = QPushButton("&Acquire")
self.buttons = QDialogButtonBox(Qt.Horizontal)
# Add calibration button that accepts the dialog (closes with 1 status)
self.buttons.addButton(calibrate_button, QDialogButtonBox.AcceptRole)
# Add a cancel button that will reject the dialog (closes with 0 status)
self.buttons.addButton(QDialogButtonBox.Cancel)
self.buttons.rejected.connect(self.reject)
self.buttons.accepted.connect(self.accept)
outer_layout = QVBoxLayout()
outer_layout.addWidget(self.parameter_tree)
outer_layout.addWidget(self.buttons)
outer_layout.setSpacing(0)
outer_layout.setContentsMargins(0, 0, 0, 0)
self.setLayout(outer_layout)
def __init__(self, parent=None):
QtGui.QSplitter.__init__(self, QtCore.Qt.Horizontal)
self.ctrlPanel = QtGui.QSplitter(QtCore.Qt.Vertical)
self.addWidget(self.ctrlPanel)
self.fieldList = QtGui.QListWidget()
self.fieldList.setSelectionMode(self.fieldList.ExtendedSelection)
self.ptree = ptree.ParameterTree(showHeader=False)
self.filter = DataFilterParameter()
self.colorMap = ColorMapParameter()
self.params = ptree.Parameter.create(name='params', type='group', children=[self.filter, self.colorMap])
self.ptree.setParameters(self.params, showTop=False)
self.plot = PlotWidget()
self.ctrlPanel.addWidget(self.fieldList)
self.ctrlPanel.addWidget(self.ptree)
self.addWidget(self.plot)
bg = pg.mkColor(pg.getConfigOption('background'))
bg.setAlpha(150)
self.filterText = pg.TextItem(border=pg.getConfigOption('foreground'), color=bg)
self.filterText.setPos(60,20)
self.filterText.setParentItem(self.plot.plotItem)
self.data = None
self.mouseOverField = None
self.scatterPlot = None
self.style = dict(pen=None, symbol='o')
self.fieldList.itemSelectionChanged.connect(self.fieldSelectionChanged)
self.filter.sigFilterChanged.connect(self.filterChanged)
self.colorMap.sigColorMapChanged.connect(self.updatePlot)
def __init__(self, parent=None):
super().__init__(parent=parent)
self.textbox = TextBoxHandler(parent=self)
self.cm_params = pt.ParameterTree(parent=self)
self.addTab(self.textbox, "Log")
self.addTab(self.cm_params, "Parameters")
def setupUi(self):
"""Set up the UI for tomography plugin"""
self.toolbar = Toolbar()
self.centerwidget = QtGui.QTabWidget()
self.centerwidget.setDocumentMode(True)
self.centerwidget.setTabsClosable(True)
self.bottomwidget = viewers.RunConsole()
self.functionwidget = QUiLoader().load('xicam/gui/tomographyleft.ui')
self.functionwidget.functionsList.setAlignment(QtCore.Qt.AlignBottom)
self.functionwidget.addFunctionButton.setToolTip('Add function to pipeline')
self.functionwidget.clearButton.setToolTip('Clear pipeline')
self.functionwidget.fileButton.setToolTip('Save/Load pipeline')
self.functionwidget.moveDownButton.setToolTip('Move selected function down')
self.functionwidget.moveUpButton.setToolTip('Move selected function up')
self.addfunctionmenu = QtGui.QMenu()
self.functionwidget.addFunctionButton.setMenu(self.addfunctionmenu)
self.functionwidget.addFunctionButton.setPopupMode(QtGui.QToolButton.ToolButtonPopupMode.InstantPopup)
self.functionwidget.addFunctionButton.setArrowType(QtCore.Qt.NoArrow)
filefuncmenu = QtGui.QMenu()
icon = QtGui.QIcon()
icon.addPixmap(QtGui.QPixmap("xicam/gui/icons_55.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.openaction = QtGui.QAction(icon, 'Open', filefuncmenu)
icon = QtGui.QIcon()
icon.addPixmap(QtGui.QPixmap("xicam/gui/icons_59.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.saveaction = QtGui.QAction(icon, 'Save', filefuncmenu)
icon = QtGui.QIcon()
icon.addPixmap(QtGui.QPixmap("xicam/gui/icons_56.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.refreshaction = QtGui.QAction(icon, 'Reset', filefuncmenu)
filefuncmenu.addActions([self.openaction, self.saveaction, self.refreshaction])
self.functionwidget.fileButton.setMenu(filefuncmenu)
self.functionwidget.fileButton.setPopupMode(QtGui.QToolButton.ToolButtonPopupMode.InstantPopup)
self.functionwidget.fileButton.setArrowType(QtCore.Qt.NoArrow)
leftwidget = QtGui.QSplitter(QtCore.Qt.Vertical)
paramtree = pt.ParameterTree()
self.param_form = QtGui.QStackedWidget()
self.param_form.addWidget(paramtree)
self.property_table = pg.TableWidget()
self.property_table.verticalHeader().hide()
self.property_table.horizontalHeader().setStretchLastSection(True)
self.property_table.setSizePolicy(QtGui.QSizePolicy.Preferred, QtGui.QSizePolicy.Expanding)
leftwidget.addWidget(self.param_form)
leftwidget.addWidget(self.functionwidget)
icon_functions = QtGui.QIcon(QtGui.QPixmap("xicam/gui/icons_49.png"))
icon_properties = QtGui.QIcon(QtGui.QPixmap("xicam/gui/icons_61.png")) #metadata icon
self.leftmodes = [(leftwidget, icon_functions),(self.property_table,icon_properties)]
def test_opts():
paramSpec = [
dict(name='bool', type='bool', readonly=True),
dict(name='color', type='color', readonly=True),
]
param = pt.Parameter.create(name='params', type='group', children=paramSpec)
tree = pt.ParameterTree()
tree.setParameters(param)
assert _getWidget(param.param('bool')).isEnabled() is False
assert _getWidget(param.param('bool')).isEnabled() is False
def __init__(self, parent=None):
super().__init__(parent)
self.setWindowTitle("Configuration")
self.config = config.global_settings
self.pt = pgp.ParameterTree()
self.setLayout(QtWidgets.QVBoxLayout())
self.layout().addWidget(self.pt)
self.createForm()
self.setMinimumHeight(400)
self.setMinimumWidth(600)
def __init__(self):
pg.QtGui.QWidget.__init__(self)
self.layout = pg.QtGui.QGridLayout()
self.setLayout(self.layout)
self.v_splitter = pg.QtGui.QSplitter()
self.v_splitter.setOrientation(pg.QtCore.Qt.Vertical)
self.distance_plot = DistancePlot()
self.ptree = ptree.ParameterTree(showHeader=False)
self.ptree.setParameters(self.distance_plot.params)
self.layout.addWidget(self.v_splitter)
self.v_splitter.addWidget(self.ptree)
self.v_splitter.addWidget(self.distance_plot.grid)
self.v_splitter.setSizes([1, 5000])
def __init__(
self,
parent: Optional[QtWidgets.QWidget] = None,
*,
pin: bool = False,
content_layout: Optional[QtWidgets.QLayout] = None,
default_display_type: DisplayTypes = DisplayTypes.detailed_screen,
scroll_option: ScrollOptions = ScrollOptions.auto,
):
super().__init__(parent=parent)
self._update_title()
self._tree = parametertree.ParameterTree(parent=self, showHeader=False)
self._tree.setAlternatingRowColors(False)
self._save_action = ptypes.ActionParameter(name='Save Suite')
self._tree.addParameters(self._save_action)
self._save_action.sigActivated.connect(self.save)
self._bar = pcdsutils.qt.QPopBar(title='Suite',
parent=self,
widget=self._tree,
pin=pin)
self._tree.setSizePolicy(QtWidgets.QSizePolicy.MinimumExpanding,
QtWidgets.QSizePolicy.MinimumExpanding)
self._tree.setMinimumSize(250, 150)
self._content_frame = QtWidgets.QFrame(self)
self._content_frame.setObjectName("content")
self._content_frame.setFrameShape(QtWidgets.QFrame.StyledPanel)
# Content frame layout: configurable
# Defaults to [content] [content] [content] ... in one line
if content_layout is None:
content_layout = QtWidgets.QHBoxLayout()
self._content_frame.setLayout(content_layout)
# Horizontal box layout: [PopBar] [Content Frame]
layout = QtWidgets.QHBoxLayout()
self.setLayout(layout)
layout.setSpacing(1)
layout.setContentsMargins(0, 0, 0, 0)
layout.addWidget(self._bar)
layout.addWidget(self._content_frame)
self.embedded_dock = None
self.default_display_type = default_display_type
self.scroll_option = scroll_option
def add_param_tree(self):
self.ptree = ptree.ParameterTree(showHeader=False)
self.filter = DataFilterParameter()
params = ptree.Parameter.create(name='params',
type='group',
children=[self.filter])
self.ptree.setParameters(params, showTop=False)
self.filter_layout.addWidget(self.ptree)
self.filterText = TextItem(border=getConfigOption('foreground'))
self.filterText.setPos(60, 20)
self.filterText.setParentItem(self.plot.plotItem)
self.filter.sigFilterChanged.connect(self.filterChanged)
self.filter.setFields([('butterFilter', {'units': 'Hz'})])
def __init__(self, parent=None):
super(DatasetDialog, self).__init__(parent)
self.params = ptree.Parameter.create(name='datasetParameters',
title='Dataset parameters',
type='group',
children=[{'name': 'name',
'type': 'str',
'value': 'dataset'},
{'name': 'dtype',
'title': 'datatype',
'type': 'str',
'value': 'float'},
{'name': 'shape',
'type': 'str',
'value': '(0),'},
{'name': 'maxshape',
'type': 'str',
'value': '(None,)'},
{'name': 'chunks',
'type': 'str',
'value': 'True'}])
layout = QtGui.QVBoxLayout()
paramTree = ptree.ParameterTree(showHeader=False)
paramTree.setParameters(self.params)
self.tabWidget = QtGui.QTabWidget()
self.tabWidget.addTab(paramTree, 'Structure')
attrTree = ptree.ParameterTree(showHeader=False)
self.attrs = XtensibleParam(name='attrs', title='Attributes')
attrTree.setParameters(self.attrs)
self.tabWidget.addTab(attrTree, 'Attributes')
layout.addWidget(self.tabWidget)
buttonBox = QtGui.QDialogButtonBox(QtGui.QDialogButtonBox.Ok | QtGui.QDialogButtonBox.Cancel, QtCore.Qt.Horizontal)
buttonBox.accepted.connect(self.accept)
buttonBox.rejected.connect(self.reject)
layout.addWidget(buttonBox)
self.setLayout(layout)
def test_types():
paramSpec = [
dict(name='float', type='float'),
dict(name='int', type='int'),
dict(name='str', type='str'),
dict(name='list', type='list', values=['x','y','z']),
dict(name='dict', type='list', values={'x':1, 'y':3, 'z':7}),
dict(name='bool', type='bool'),
dict(name='color', type='color'),
]
param = pt.Parameter.create(name='params', type='group', children=paramSpec)
tree = pt.ParameterTree()
tree.setParameters(param)
all_objs = {
'int0': 0, 'int':7, 'float': -0.35, 'bigfloat': 1e129, 'npfloat': np.float(5),
'npint': np.int(5),'npinf': np.inf, 'npnan': np.nan, 'bool': True,
'complex': 5+3j, 'str': 'xxx', 'unicode': asUnicode('µ'),
'list': [1,2,3], 'dict': {'1': 2}, 'color': pg.mkColor('k'),
'brush': pg.mkBrush('k'), 'pen': pg.mkPen('k'), 'none': None
}
if hasattr(QtCore, 'QString'):
all_objs['qstring'] = QtCore.QString('xxxµ')
# float
types = ['int0', 'int', 'float', 'bigfloat', 'npfloat', 'npint', 'npinf', 'npnan', 'bool']
check_param_types(param.child('float'), float, float, 0.0, all_objs, types)
# int
types = ['int0', 'int', 'float', 'bigfloat', 'npfloat', 'npint', 'bool']
inttyps = int if sys.version[0] >= '3' else (int, long)
check_param_types(param.child('int'), inttyps, int, 0, all_objs, types)
# str (should be able to make a string out of any type)
types = all_objs.keys()
strtyp = str if sys.version[0] >= '3' else unicode
check_param_types(param.child('str'), strtyp, asUnicode, '', all_objs, types)
# bool (should be able to make a boolean out of any type?)
types = all_objs.keys()
check_param_types(param.child('bool'), bool, bool, False, all_objs, types)
# color
types = ['color', 'int0', 'int', 'float', 'npfloat', 'npint', 'list']
init = QtGui.QColor(128, 128, 128, 255)
check_param_types(param.child('color'), QtGui.QColor, pg.mkColor, init, all_objs, types)
def test_limits_enforcement():
p = pt.Parameter.create(name='params', type='group', children=[
dict(name='float', type='float', limits=[0, 1]),
dict(name='int', type='int', bounds=[0, 1]),
dict(name='list', type='list', values=['x', 'y']),
dict(name='dict', type='list', values={'x': 1, 'y': 2}),
])
t = pt.ParameterTree()
t.setParameters(p)
for k, vin, vout in [('float', -1, 0),
('float', 2, 1),
('int', -1, 0),
('int', 2, 1),
('list', 'w', 'x'),
('dict', 'w', 1)]:
p[k] = vin
assert p[k] == vout
def __init__(self, parent=None):
super(GroupDialog, self).__init__(parent)
self.params = ptree.Parameter.create(name='groupParameters',
title='Group attributes',
type='group',
children=[{'name': 'name', 'title': 'Name', 'type': 'str',
'value': 'group'},
XtensibleParam(name='attrs', title='Attributes')])
layout = QtGui.QVBoxLayout()
paramTree = ptree.ParameterTree(showHeader=False)
paramTree.setParameters(self.params)
layout.addWidget(paramTree)
buttonBox = QtGui.QDialogButtonBox(QtGui.QDialogButtonBox.Ok | QtGui.QDialogButtonBox.Cancel, QtCore.Qt.Horizontal)
buttonBox.accepted.connect(self.accept)
buttonBox.rejected.connect(self.reject)
layout.addWidget(buttonBox)
self.setLayout(layout)
def __init__(self):
pg.QtGui.QWidget.__init__(self)
self.layout = pg.QtGui.QGridLayout()
self.setLayout(self.layout)
self.h_splitter = pg.QtGui.QSplitter()
self.h_splitter.setOrientation(pg.QtCore.Qt.Horizontal)
self.layout.addWidget(self.h_splitter, 0, 0)
self.control_panel_splitter = pg.QtGui.QSplitter()
self.control_panel_splitter.setOrientation(pg.QtCore.Qt.Vertical)
self.h_splitter.addWidget(self.control_panel_splitter)
self.update_button = pg.QtGui.QPushButton("Update Results")
self.control_panel_splitter.addWidget(self.update_button)
self.ptree = ptree.ParameterTree(showHeader=False)
self.control_panel_splitter.addWidget(self.ptree)
self.matrix_widget = MatrixWidget()
self.h_splitter.addWidget(self.matrix_widget)
self.tabs = Tabs()
self.h_splitter.addWidget(self.tabs)
self.h_splitter.setSizes([300, 600, 400])
def __init__(self, parent=None):
super(DirReader, self).__init__(parent=parent)
self.settings = QtCore.QSettings('dataviz', 'dirreader')
self.baseDirLabel = QtGui.QLabel('Base directory')
self.baseDirEdit = QtGui.QLineEdit('.')
self.baseDirButton = QtGui.QPushButton('Open')
self.baseDirButton.clicked.connect(self.selectBaseDir)
self.baseDirWidget = QtGui.QWidget()
layout = QtGui.QHBoxLayout()
self.baseDirWidget.setLayout(layout)
layout.addWidget(self.baseDirLabel)
layout.addWidget(self.baseDirEdit)
layout.addWidget(self.baseDirButton)
self.pathTree = ptree.ParameterTree(showHeader=False)
self.pathRules = PathParams(name='Path rules')
self.pathTree.setParameters(self.pathRules, showTop=True)
self.setLayout(QtGui.QVBoxLayout())
self.layout().addWidget(self.baseDirWidget)
self.layout().addWidget(self.pathTree)
def test_data_race():
# Ensure widgets don't override user setting of param values whether
# they connect the signal before or after it's added to a tree
p = pt.Parameter.create(name='int', type='int', value=0)
t = pt.ParameterTree()
def override():
p.setValue(1)
p.sigValueChanged.connect(override)
t.setParameters(p)
pi = next(iter(p.items))
assert pi.param is p
pi.widget.setValue(2)
assert p.value() == pi.widget.value() == 1
p.sigValueChanged.disconnect(override)
p.sigValueChanged.connect(override)
pi.widget.setValue(2)
assert p.value() == pi.widget.value() == 1
def test_limits_enforcement_after_limits_changed():
p = pt.Parameter.create(name='params',
type='group',
children=[
dict(name='float', type='float', limits=[0,
1]),
dict(name='int', type='int', bounds=[-2, 2]),
dict(name='list',
type='list',
limits=['w', 'x', 'y']),
dict(name='dict',
type='list',
limits={
'w': -2,
'x': 1,
'y': 2
}),
])
t = pt.ParameterTree()
t.setParameters(p)
for k, vin, limits, vout in [('float', 0.5, [1, 5], 1),
('float', 2.5, [-5., -1], -1),
('int', 0, [3, 5], 3),
('int', 4, [-53, -5], -5),
('list', 'w', ['x', 'y'], 'x'),
('dict', ('w', -2), {
'x': 1,
'y': 2
}, 1)]:
if k == 'dict':
p[k] = vin[0]
assert p[k] == vin[1]
else:
p[k] = vin
assert p[k] == vin
p.child(k).setLimits(limits)
assert p[k] == vout
def __init__(self, parent=None):
QtGui.QSplitter.__init__(self, QtCore.Qt.Horizontal)
self.ctrlPanel = QtGui.QSplitter(QtCore.Qt.Vertical)
self.addWidget(self.ctrlPanel)
self.fieldList = QtGui.QListWidget()
self.fieldList.setSelectionMode(self.fieldList.ExtendedSelection)
self.ptree = ptree.ParameterTree(showHeader=False)
self.filter = DataFilterParameter()
self.colorMap = ColorMapParameter()
self.params = ptree.Parameter.create(
name='params', type='group', children=[self.filter, self.colorMap])
self.ptree.setParameters(self.params, showTop=False)
self.plot = PlotWidget()
self.ctrlPanel.addWidget(self.fieldList)
self.ctrlPanel.addWidget(self.ptree)
self.addWidget(self.plot)
self.data = None
self.style = dict(pen=None, symbol='o')
self.fieldList.itemSelectionChanged.connect(self.fieldSelectionChanged)
self.filter.sigFilterChanged.connect(self.filterChanged)
self.colorMap.sigColorMapChanged.connect(self.updatePlot)
def __init__(self, app, *args, **kwargs):
super().__init__(*args, **kwargs)
self.app = app
self.pcm_params = {'vmin': 0, 'vmax': 20}
splitter = QSplitter()
# DRAWING
drawing_area_widget = QWidget(splitter) # container widget
drawing_area_layout = QVBoxLayout(
drawing_area_widget) # vertical layout
# graphics area
graphics_layout = pg.GraphicsLayoutWidget(drawing_area_widget)
drawing_area_layout.addWidget(graphics_layout)
self.viewbox = graphics_layout.addViewBox(lockAspect=True,
invertY=False,
enableMenu=False)
self.tec_map_img = image_items.TecMapImageItem(config.theta_grid,
config.radius_grid)
self.viewbox.addItem(self.tec_map_img)
self.draw_img = image_items.DrawingImage('r', self.tec_map_img)
self.viewbox.addItem(self.draw_img)
self.hover_img = image_items.HoverImage(np.zeros((1000, 1000)))
self.viewbox.addItem(self.hover_img)
# Buttons
button_area_widget = QWidget(drawing_area_widget)
drawing_area_layout.addWidget(button_area_widget)
button_area_layout = QHBoxLayout(button_area_widget)
self._add_button("Clean", button_area_layout, self.map_clean)
self._add_button("Save", button_area_layout, self.app.map_save)
self._add_button("Next", button_area_layout, self.app.map_next)
# cross section plot
self.cross_section_plot = graphics_layout.addPlot()
self.cross_section_plot.setMaximumWidth(300)
self.cross_section_plot.setLimits(minXRange=10,
maxXRange=40,
yMin=30,
yMax=90,
xMin=0)
self.cross_section_line = self.cross_section_plot.plot()
self.cross_section_mlat = pg.InfiniteLine(angle=0)
self.cross_section_plot.addItem(self.cross_section_mlat)
self.proxy = pg.SignalProxy(self.hover_img.scene().sigMouseMoved,
rateLimit=60,
slot=self.mouseMoved)
# status bar
self.status_bar = QStatusBar()
self.setStatusBar(self.status_bar)
self.status_bar.showMessage(self.app.map_indicator)
# PARAMETERS
settings_area_widget = QWidget(splitter)
settings_area_layout = QVBoxLayout(settings_area_widget)
self.param_object = parametertree.Parameter.create(
name='params', type='group', children=param_descriptor)
self.param_object.sigTreeStateChanged.connect(self.parameter_changed)
param_tree = parametertree.ParameterTree(parent=settings_area_widget,
showHeader=False)
param_tree.addParameters(self.param_object)
settings_area_layout.addWidget(param_tree)
# TOP LEVEL
splitter.addWidget(drawing_area_widget)
splitter.addWidget(settings_area_widget)
splitter.setStretchFactor(0, 1)
self.setCentralWidget(splitter)
self.setWindowTitle("TEC Label Creator")
self.setGeometry(100, 100, 1200, 600)
self.show()
def __init__(self, boc, expt_id, cell_id):
self.boc = boc
self.data_set = boc.get_ophys_experiment_data(
ophys_experiment_id=expt_id)
self.lsn_tmp = self.data_set.get_stimulus_template(
'locally_sparse_noise')
# setup cell selector
cells = self.data_set.get_cell_specimen_ids()
self.cell_selector = CellSelector()
roi_img = (self.data_set.get_roi_mask_array() *
np.array(cells)[:, None, None]).max(axis=0)
max_img = self.data_set.get_max_projection()
self.cell_selector.set_images(max_img, roi_img)
# setup spike detector
self.spike_detector = SpikeDetector()
# setup averager
self.averager = TriggeredAverager()
# make stimulus frame locations easier to look up
self.lsn_id = None
QtGui.QWidget.__init__(self)
self.hs = pg.QtGui.QSplitter()
self.hs.setOrientation(pg.QtCore.Qt.Horizontal)
self.vs1 = pg.QtGui.QSplitter()
self.vs1.setOrientation(pg.QtCore.Qt.Vertical)
self.params = pt.Parameter(name='params',
type='group',
children=[
self.cell_selector.params,
self.spike_detector.params,
self.averager.params,
])
self.tree = pt.ParameterTree(showHeader=False)
self.tree.setParameters(self.params, showTop=False)
self.vs1.addWidget(self.tree)
self.expt_imv = pg.ImageView()
self.cell_selector.set_imageview(self.expt_imv)
self.vs1.addWidget(self.expt_imv)
self.vs2 = pg.QtGui.QSplitter()
self.vs2.setOrientation(pg.QtCore.Qt.Vertical)
self.plt1 = pg.PlotWidget()
self.plt2 = pg.PlotWidget()
self.plt2.setXLink(self.plt1)
self.spike_detector.set_plots(self.plt1, self.plt2)
self.sta_imv = pg.ImageView()
self.averager.set_imageview(self.sta_imv)
self.vs2.addWidget(self.plt1)
self.vs2.addWidget(self.plt2)
self.vs2.addWidget(self.sta_imv)
self.hs.addWidget(self.vs1)
self.hs.addWidget(self.vs2)
self.layout = QtGui.QGridLayout()
self.setLayout(self.layout)
self.layout.addWidget(self.hs)
self.resize(1400, 800)
self.hs.setSizes([600, 600])
self.show()
self.cell_selector.cell_selection_changed.connect(self.loadCell)
self.spike_detector.parameters_changed.connect(self.updateSpikes)
self.averager.parameters_changed.connect(self.updateOutput)
self.loadCell()
# ######## SAVE THIS FOR DEBUGGING SEG FAULTS; issues are usually doing something outside the gui thread
# import sys
#
#
# def trace(frame, event, arg):
# print "%s, %s:%d" % (event, frame.f_code.co_filename, frame.f_lineno)
# return trace
#
#
# sys.settrace(trace)
app = QApplication([])
## Create window with ImageView widget
win = QMainWindow()
win.resize(800, 800)
p = pg.PlotWidget()
range = np.arange(0,50,1)
p.plot(range,models.Gaussian1D.evaluate(range,10,30,5),pen={'color':'r','width':2})
p.show()
fitter = FitParameter(p)
tree = pt.ParameterTree()
tree.setParameters(fitter,showTop=False)
win.setCentralWidget(tree)
win.setWindowTitle('Fitting')
win.show()
QApplication.instance().exec_()
def __init__(self, paths, worker, parent=None):
"""
Class that holds image to be processed by HipRMC, image after it has been centered, and HipRMC output
Attributes
----------
emitter : threads.Emitter
Holds and emits a signal when fHipRMc done processing
interrupt : bool
flag - set true if rmc processing was interrupted; affects post-rmc processes
cameraLocation : tuple
2-tuple (x,y) of camera location on input image
rmcView : ximcam.RmcView.rncView
Timeline viewer which holds and displays HipRMC output
orig_image: np.array
Original input image
edited_image : np.array
Image with camera location adjusted to its center
orig_view : pyqtgraph.ImageView
Holds the original image
edited_view : pyqtgraph.ImageView
Holds the image after camera location adjustment
image_holder : QtGui.StackedWidget
Main widget of plugin. Holds original and edited images, as well as HipRMC output, in tabs
scatteringParams : pyqtgraph.parametertree
Occupies right side of main widget. Holds configparams
configparams : pyqtgraph.Parameter
Class held by scatteringParams which holds parameter values for HipRMC
output, err : str
Output and error from HipRMC subprocess call
headings : QtGui.QTabBar
Displays name of corresponding tab of image_holder
Parameters
----------
paths : str/list of str
Path to input dataset
worker: threads.Worker
Worker which queues up jobs and runs them on a QtCore.QThreadpool
parent : QtGui.QWidget
parent widget
args
Additional arguments
kwargs
Additional keyword arguments
"""
super(inOutViewer, self).__init__(parent=parent)
self.emitter = threads.Emitter()
self.interrupt = False
self.cameraLocation = config.activeExperiment.center
self.rmc_view= None
self.edited_image = None
self.worker = worker
# holders for original and edited images
self.orig_view = LogViewer()
self.orig_view.setContentsMargins(0,0,0,0)
self.edited_view = LogViewer()
self.edited_view.setContentsMargins(0,0,0,0)
if type(paths) == list:
self.path = paths[0]
else:
self.path = paths
self.image_holder = QtGui.QStackedWidget()
self.image_holder.setContentsMargins(0,0,0,0)
# configuring right widget
sideWidget = QtGui.QWidget()
sideWidgetFormat = QtGui.QVBoxLayout()
sideWidgetFormat.setContentsMargins(0, 0, 0, 0)
# if paths is None, inOutViewer will only hold HipRMC output and the images/parameter table are not necessary
if paths is not None:
self.orig_image = np.transpose(loader.loadimage(self.path))
if len(self.orig_image.shape) > 2:
self.orig_image = np.transpose(self.orig_image).swapaxes(0,1)
while len(self.orig_image.shape) > 2:
self.orig_image = self.orig_image[:,:,0]
self.orig_view.setImage(self.orig_image)
self.orig_view.autoRange()
try:
start_size = max(self.orig_image.shape)/10
except ValueError:
msg.showMessage("Image must be 2-D")
scatteringHolder = QtGui.QStackedWidget()
image_name = self.path.split('/')[-1].split('.')[0]
self.scatteringParams = pt.ParameterTree()
params = [{'name': 'Num tiles', 'type': 'int', 'value': 1, 'default': 1},
{'name': 'Loading factor', 'type': 'float', 'value': 0.5, 'default': 0.5},
{'name': 'Scale factor', 'type': 'int', 'value': 32, 'default': 32},
{'name': 'Numsteps factor', 'type': 'int', 'value': 100, 'default': 100},
{'name': 'Model start size', 'type': 'int', 'value': start_size},
{'name': 'Save name', 'type': 'str', 'value': 'hiprmc_' + image_name},
{'name': 'Mask image', 'type': 'str'}]
self.configparams = pt.Parameter.create(name='Configuration', type='group', children=params)
self.scatteringParams.setParameters(self.configparams, showTop=False)
scatteringHolder.addWidget(self.scatteringParams)
# # is there a better way to check for correct dimensions?
# if len(self.orig_image.shape) > 2:
# shape = (self.orig_image.shape[1], self.orig_image.shape[2])
# else:
# shape = self.orig_image.shape
self.drawROI(0, 0, self.orig_image.shape[0], self.orig_image.shape[1], 'r',
self.orig_view.getImageItem().getViewBox())
scatteringHolder.setFixedHeight(300)
sideWidgetFormat.addWidget(scatteringHolder)
centerButton = QtGui.QPushButton("Center camera location")
runButton = QtGui.QPushButton("Run RMC processing")
stopButton = QtGui.QPushButton("Stop RMC")
sideWidgetFormat.addSpacing(5)
sideWidgetFormat.addWidget(centerButton)
sideWidgetFormat.addSpacing(5)
sideWidgetFormat.addWidget(runButton)
sideWidgetFormat.addSpacing(5)
sideWidgetFormat.addWidget(stopButton)
sideWidgetFormat.addStretch(10)
sideWidget.setLayout(sideWidgetFormat)
# connect buttons to processing
centerButton.clicked.connect(self.center)
runButton.clicked.connect(self.runRMC)
stopButton.clicked.connect(self.stop_threads)
# tab headings for main widget
self.headings = QtGui.QTabBar(self)
self.headings.addTab('Original Image')
self.headings.addTab('Recentered Image')
self.headings.addTab('RMC Timeline')
self.headings.addTab('FFT RMC Timeline')
self.headings.setShape(QtGui.QTabBar.TriangularSouth)
leftWidget = QtGui.QWidget()
sidelayout = QtGui.QVBoxLayout()
sidelayout.addWidget(self.image_holder)
sidelayout.addWidget(self.headings)
leftWidget.setLayout(sidelayout)
fullPlugin = QtGui.QSplitter()
fullPlugin.addWidget(leftWidget)
fullPlugin.addWidget(sideWidget)
h = QtGui.QHBoxLayout()
h.setContentsMargins(0, 0, 0, 0)
h.addWidget(fullPlugin)
self.setLayout(h)
self.image_holder.addWidget(self.orig_view)
self.image_holder.addWidget(self.edited_view)
self.headings.currentChanged.connect(self.currentChanged)
self.image_holder.currentChanged.connect(self.headings.setCurrentIndex)
def __init__(self):
super().__init__()
self.area = pgda.DockArea()
self.setCentralWidget(self.area)
self.resize(1000,500)
self.setWindowTitle('app-icp12-gui')
# Create Docks
dock1 = pgda.Dock("PORT", size=(300, 300))
dock2 = pgda.Dock("GRAPH", size=(500, 300))
dock3 = pgda.Dock("SETTING", size=(400, 300))
self.area.addDock(dock1, 'left')
self.area.addDock(dock2, 'right')
self.area.addDock(dock3, 'right')
# Create Tree
a0 = PinTreeWidgetItem(["A0"], color='b')
a1 = PinTreeWidgetItem(["A1"], color='g')
a2 = PinTreeWidgetItem(["A2"], color='r')
a3 = PinTreeWidgetItem(["A3"], color='c')
a5 = PinTreeWidgetItem(["A5"], color='y')
b0 = PinTreeWidgetItem(["B0"], analog=False)
b1 = PinTreeWidgetItem(["B1"], analog=False)
b2 = PinTreeWidgetItem(["B2"], color='w')
c0 = PinTreeWidgetItem(["C0"], analog=False)
c1 = PinTreeWidgetItem(["C1"], analog=False)
c2 = PinTreeWidgetItem(["C2"], analog=False)
c6 = PinTreeWidgetItem(["C6"], analog=False)
c7 = PinTreeWidgetItem(["C7"], analog=False)
self.d1tree = pg.TreeWidget()
self.d1tree.setColumnCount(5)
self.d1tree.addTopLevelItem(a0)
self.d1tree.addTopLevelItem(a1)
self.d1tree.addTopLevelItem(a2)
self.d1tree.addTopLevelItem(a3)
self.d1tree.addTopLevelItem(a5)
self.d1tree.addTopLevelItem(b0)
self.d1tree.addTopLevelItem(b1)
self.d1tree.addTopLevelItem(b2)
self.d1tree.addTopLevelItem(c0)
self.d1tree.addTopLevelItem(c1)
self.d1tree.addTopLevelItem(c2)
self.d1tree.addTopLevelItem(c6)
self.d1tree.addTopLevelItem(c7)
[i.cbx_analog.clicked.connect(self.reg_plot) for i in self.d1tree.listAllItems() ]
self.d1tree.setHeaderLabels(["Name", "Type", "Status", "Analog", "Record"])
self.d1tree.header().setResizeMode(QtWidgets.QHeaderView.ResizeToContents)
# self.d1tree.header().setStretchLastSection(False)
dock1.addWidget(self.d1tree)
self.d1tree.setEnabled(False)
# Create Graph
d2view = pg.GraphicsView()
d2layout = pg.GraphicsLayout(border=(100,100,100))
d2view.setCentralItem(d2layout)
self.d2label = d2layout.addLabel("Plot")
d2layout.nextRow()
self.d2plot = d2layout.addPlot()
self.d2plot.setLabel('left', 'Voltatge', units='V')
self.d2plot.setLabel('bottom', 'Samples', units='-')
self.d2plot.setXRange(0,g_samples)
self.d2plot.setYRange(-1, 6)
self.d2plot.showGrid(x=True, y=True)
self.d2plot_leg = self.d2plot.addLegend()
dock2.addWidget(d2view)
# Create ParamterTree
self.device_parameter = DeviceParameter(name='DEVICE')
self.device_parameter.sigConnectionChanged.connect(self.d1tree.setEnabled)
params = [
self.device_parameter,
{'name': 'LOGGING', 'type': 'group', 'children': [
{'name': 'Dummy', 'type': 'list', 'values': ['1', '2'], 'value': '2'},
]},
{'name': 'SIGNAL', 'type': 'group', 'children': [
{'name': 'Dummy', 'type': 'list', 'values': ['1', '2'], 'value': '2'},
]},
{'name': 'SCALE', 'type': 'group', 'children': [
{'name': 'Dummy', 'type': 'list', 'values': ['1', '2'], 'value': '2'},
]},
{'name': 'TRIGGER', 'type': 'group', 'children': [
{'name': 'Dummy', 'type': 'list', 'values': ['1', '2'], 'value': '2'},
]},
{'name': 'DISPLAY', 'type': 'group', 'children': [
{'name': 'Dummy', 'type': 'list', 'values': ['1', '2'], 'value': '2'},
]},
{'name': 'CONTROL', 'type': 'group', 'children': [
{'name': 'Dummy', 'type': 'list', 'values': ['1', '2'], 'value': '2'},
]},
{'name': 'SAVE/LOAD', 'type': 'group', 'children': [
{'name': 'Save State', 'type': 'action'},
{'name': 'Load State', 'type': 'action', 'children': [
{'name': 'Add missing items', 'type': 'bool', 'value': True},
{'name': 'Remove extra items', 'type': 'bool', 'value': True},
]},
]},
]
self.d3param = pgpt.Parameter.create(name='params', type='group', children=params)
self.d3param.sigTreeStateChanged.connect(self.change)
for ch1 in self.d3param.children():
ch1.sigValueChanging.connect(self.changing)
for ch2 in ch1.children():
ch2.sigValueChanging.connect(self.changing)
self.d3param.param('SAVE/LOAD', 'Save State').sigActivated.connect(self.save)
self.d3param.param('SAVE/LOAD', 'Load State').sigActivated.connect(self.load)
d3tree = pgpt.ParameterTree()
d3tree.setParameters(self.d3param, showTop=False)
d3tree.setWindowTitle('pyqtgraph example Parameter Tree')
dock3.addWidget(d3tree)
self.timer = QtCore.QTimer(self)
self.timer.timeout.connect(self.update)
self.timer.start(0)
self.timer_counter = 0
self.old_time = time.time()
dict(name='useCache', title='useCache: ', type='bool', value=True),
dict(name='mode',
title=translate('ScatterPlot', 'Mode: '),
type='list',
values={
translate('ScatterPlot', 'New Item'): 'newItem',
translate('ScatterPlot', 'Reuse Item'): 'reuseItem',
translate('ScatterPlot', 'Simulate Pan/Zoom'): 'panZoom',
translate('ScatterPlot', 'Simulate Hover'): 'hover'
},
value='reuseItem'),
])
for c in param.children():
c.setDefault(c.value())
pt = ptree.ParameterTree(showHeader=False)
pt.setParameters(param)
p = pg.PlotWidget()
splitter = QtWidgets.QSplitter()
splitter.addWidget(pt)
splitter.addWidget(p)
splitter.show()
data = {}
item = pg.ScatterPlotItem()
hoverBrush = pg.mkBrush('y')
ptr = 0
lastTime = time()
fps = None
timer = QtCore.QTimer()
def __init__(self, default_session, notes_session):
pg.QtGui.QWidget.__init__(self)
self.default_session = default_session
self.notes_session = notes_session
self.layout = pg.QtGui.QGridLayout()
self.setLayout(self.layout)
self.h_splitter = pg.QtGui.QSplitter()
self.h_splitter.setOrientation(pg.QtCore.Qt.Horizontal)
self.pair_analyzer = PairAnalysis()
self.fit_explorer = None
self.ctrl_panel = self.pair_analyzer.ctrl_panel
self.user_params = self.ctrl_panel.user_params
self.output_params = self.ctrl_panel.output_params
self.ptree = ptree.ParameterTree(showHeader=False)
self.pair_param = Parameter.create(name='Current Pair', type='str', readonly=True)
self.ptree.addParameters(self.pair_param)
self.ptree.addParameters(self.user_params, showTop=False)
self.fit_ptree = ptree.ParameterTree(showHeader=False)
self.fit_ptree.addParameters(self.output_params, showTop=False)
self.save_btn = pg.FeedbackButton('Save Analysis')
self.expt_btn = pg.QtGui.QPushButton('Set Experiments')
self.fit_btn = pg.QtGui.QPushButton('Fit Responses')
self.ic_plot = self.pair_analyzer.ic_plot
self.vc_plot = self.pair_analyzer.vc_plot
self.select_ptree = ptree.ParameterTree(showHeader=False)
self.hash_select = Parameter.create(name='Hashtags', type='group', children=
[{'name': 'With multiple selected:', 'type': 'list', 'values': ['Include if any appear', 'Include if all appear'], 'value': 'Include if any appear'}]+
[{'name': '#', 'type': 'bool'}] +
[{'name': ht, 'type': 'bool'} for ht in comment_hashtag[1:]])
self.rigs = db.query(db.Experiment.rig_name).distinct().all()
self.operators = db.query(db.Experiment.operator_name).distinct().all()
self.rig_select = Parameter.create(name='Rig', type='group', children=[{'name': rig[0], 'type': 'bool'} for rig in self.rigs])
self.operator_select = Parameter.create(name='Operator', type='group', children=[{'name': operator[0], 'type': 'bool'} for operator in self.operators])
self.data_type = Parameter.create(name='Reduce data to:', type='group', children=[
{'name': 'Pairs with data', 'type': 'bool', 'value': True},
{'name': 'Synapse is None', 'type': 'bool'}])
[self.select_ptree.addParameters(param) for param in [self.data_type, self.rig_select, self.operator_select, self.hash_select]]
self.experiment_browser = self.pair_analyzer.experiment_browser
self.v_splitter = pg.QtGui.QSplitter()
self.v_splitter.setOrientation(pg.QtCore.Qt.Vertical)
self.expt_splitter = pg.QtGui.QSplitter()
self.expt_splitter.setOrientation(pg.QtCore.Qt.Vertical)
self.h_splitter.addWidget(self.expt_splitter)
self.expt_splitter.addWidget(self.select_ptree)
self.expt_splitter.addWidget(self.expt_btn)
self.h_splitter.addWidget(self.v_splitter)
self.v_splitter.addWidget(self.experiment_browser)
self.v_splitter.addWidget(self.ptree)
self.v_splitter.addWidget(self.fit_btn)
self.v_splitter.addWidget(self.fit_ptree)
self.v_splitter.addWidget(self.save_btn)
self.v_splitter.setSizes([200, 20, 20,400, 20])
# self.next_pair_button = pg.QtGui.QPushButton("Load Next Pair")
# self.v_splitter.addWidget(self.next_pair_button)
self.h_splitter.addWidget(self.vc_plot.grid)
self.h_splitter.addWidget(self.ic_plot.grid)
self.fit_compare = self.pair_analyzer.fit_compare
self.meta_compare = self.pair_analyzer.meta_compare
self.v2_splitter = pg.QtGui.QSplitter()
self.v2_splitter.setOrientation(pg.QtCore.Qt.Vertical)
self.v2_splitter.addWidget(self.fit_compare)
self.v2_splitter.addWidget(self.meta_compare)
self.h_splitter.addWidget(self.v2_splitter)
self.h_splitter.setSizes([100, 200, 200, 200, 500])
self.layout.addWidget(self.h_splitter)
self.fit_compare.hide()
self.meta_compare.hide()
self.setGeometry(280, 130, 1500, 900)
self.show()
# self.next_pair_button.clicked.connect(self.load_next_pair)
self.experiment_browser.itemSelectionChanged.connect(self.selected_pair)
self.save_btn.clicked.connect(self.save_to_db)
self.expt_btn.clicked.connect(self.get_expts)
self.fit_btn.clicked.connect(self.pair_analyzer.fit_response_update)
