def __init__(self):
QtGui.QSplitter.__init__(self)
self.setOrientation(QtCore.Qt.Horizontal)
self.plot = pg.PlotWidget()
self.addWidget(self.plot)
self.ctrl = QtGui.QWidget()
self.addWidget(self.ctrl)
self.layout = QtGui.QVBoxLayout()
self.layout.setSpacing(0)
self.layout.setContentsMargins(0, 0, 0, 0)
self.ctrl.setLayout(self.layout)
self.scanList = pg.TreeWidget()
self.layout.addWidget(self.scanList)
self.filter = FCEventDetection.EventFilter('eventFilter')
self.layout.addWidget(self.filter.ctrlWidget())
self.xCombo = QtGui.QComboBox()
self.yCombo = QtGui.QComboBox()
self.layout.addWidget(self.xCombo)
self.layout.addWidget(self.yCombo)
self.columns = []
self.scans = {} ## maps scan: (scatterPlotItem, treeItem, valid)
self.xCombo.currentIndexChanged.connect(self.invalidate)
self.yCombo.currentIndexChanged.connect(self.invalidate)
self.filter.sigStateChanged.connect(self.invalidate)
self.scanList.itemChanged.connect(self.itemChanged)
def makeObject(self, host):
typ = self.type()
args = self.args()
if typ == 'plot':
obj = pg.PlotWidget(name=self.name(), **args)
elif typ == 'imageView':
obj = pg.ImageView(**args)
elif typ == 'canvas':
obj = Canvas.Canvas(**args)
elif typ == 'fileInput':
obj = FileLoader.FileLoader(host.dataManager(), **args)
#elif typ == 'database':
#obj = DatabaseGui.DatabaseGui(host.dataManager(), **args)
elif typ == 'table':
obj = pg.TableWidget(**args)
elif typ == 'dataTree':
obj = pg.DataTreeWidget(**args)
elif typ == 'parameterTree':
obj = pg.parametertree.ParameterTree(**args)
elif typ == 'graphicsView':
obj = pg.GraphicsView(**args)
elif typ == 'graphicsLayout':
obj = pg.GraphicsLayoutWidget(**args)
elif typ == 'viewBox':
obj = pg.GraphicsView()
obj.setCentralItem(pg.ViewBox(**args))
else:
raise Exception(
"Cannot automatically create element '%s' (type=%s)" %
(self.name, typ))
#self.setObject(obj) ## handled indirectly..
return obj
def addPlotClicked(self):
plot = pg.PlotWidget()
self.plots.append(plot)
node = self.flowchart.createNode('PlotWidget')
name = node.name()
node.setPlot(plot)
dock = self._host_.dockArea.addDock(name=name, position='bottom')
dock.addWidget(plot)
def __init__(self):
QtGui.QWidget.__init__(self)
self.layout = QtGui.QVBoxLayout()
self.setLayout(self.layout)
self.imv1 = pg.ImageView()
self.layout.addWidget(self.imv1)
self.plt1 = pg.PlotWidget()
self.layout.addWidget(self.plt1)
self.base_time_rgn = pg.LinearRegionItem([0.07, 0.099])
self.test_time_rgn = pg.LinearRegionItem([0.104, 0.112])
for time_rgn in (self.base_time_rgn, self.test_time_rgn):
self.plt1.addItem(time_rgn)
time_rgn.sigRegionChangeFinished.connect(self.time_rgn_changed)
self.plot_data = []
def __init__(self, trackers):
self.trackers = trackers
self.nextFrame = None
pg.QtGui.QWidget.__init__(self)
self.timer = pg.QtCore.QTimer()
self.timer.timeout.connect(self.update)
self.layout = pg.QtGui.QGridLayout()
self.setLayout(self.layout)
self.plot = pg.PlotWidget(labels={'left': ('Position error', 'm'), 'bottom': ('Time', 's')})
self.plot.addLegend()
self.layout.addWidget(self.plot, 0, 0)
self.lines = [self.plot.plot(pen=(i, len(trackers)), name=trackers[i].dev.name()) for i in range(len(trackers))]
self.errors = [[] for i in range(len(trackers))]
self.cumulative = np.zeros((len(trackers), 3))
self.times = []
self.timer.start(2000)
trackers[0]._getImager().sigNewFrame.connect(self.newFrame)
self.show()
import acq4.pyqtgraph as pg
import acq4.util.SequenceRunner as SequenceRunner
from acq4.util import Qt
if not hasattr(QtCore, 'Signal'):
Qt.Signal = Qt.pyqtSignal
from .StimGenerator import *
app = Qt.QApplication([])
sg = StimGenerator()
sg.show()
sg.setMeta('x', units='s', dec=True, minStep=1e-6, step=0.5, siPrefix=True)
sg.setMeta('y', units='W', dec=True, minStep=1e-3, step=0.5, siPrefix=True)
sg.setMeta('xy', units='J', dec=True, minStep=1e-9, step=0.5, siPrefix=True)
plot = pg.PlotWidget()
plot.show()
def plotData():
rate = 1e3
nPts = 100
plot.clear()
params = {}
paramSpace = sg.listSequences()
for k in paramSpace:
params[k] = range(len(paramSpace[k]))
global seqPlots
seqPlots = []
def __init__(self, mod):
Qt.QWidget.__init__(self)
self.mod = weakref.ref(mod)
self.view = mod.view
# ROI state variables
self.lastPlotTime = None
self.ROIs = []
self.plotCurves = []
# Set up UI
self.roiLayout = Qt.QGridLayout()
self.roiLayout.setSpacing(0)
self.roiLayout.setContentsMargins(0,0,0,0)
self.setLayout(self.roiLayout)
# rect
rectPath = Qt.QPainterPath()
rectPath.addRect(0, 0, 1, 1)
self.rectBtn = pg.PathButton(path=rectPath)
# ellipse
ellPath = Qt.QPainterPath()
ellPath.addEllipse(0, 0, 1, 1)
self.ellipseBtn = pg.PathButton(path=ellPath)
# polygon
polyPath = Qt.QPainterPath()
polyPath.moveTo(0,0)
polyPath.lineTo(2,3)
polyPath.lineTo(3,1)
polyPath.lineTo(5,0)
polyPath.lineTo(2, -2)
polyPath.lineTo(0,0)
self.polygonBtn = pg.PathButton(path=polyPath)
# ruler
polyPath = Qt.QPainterPath()
polyPath.moveTo(0, 0)
polyPath.lineTo(3, -2)
polyPath.moveTo(0, 0)
polyPath.lineTo(3, 0)
polyPath.moveTo(1, 0)
polyPath.arcTo(-1, -1, 2, 2, 0, 33.69)
for i in range(5):
x = i * 3./4.
y = x * -2./3.
polyPath.moveTo(x, y)
polyPath.lineTo(x-0.2, y-0.3)
self.rulerBtn = pg.PathButton(path=polyPath)
self.roiLayout.addWidget(self.rectBtn, 0, 0)
self.roiLayout.addWidget(self.ellipseBtn, 0, 1)
self.roiLayout.addWidget(self.polygonBtn, 1, 0)
self.roiLayout.addWidget(self.rulerBtn, 1, 1)
self.roiTimeSpin = pg.SpinBox(value=5.0, suffix='s', siPrefix=True, dec=True, step=0.5, bounds=(0,None))
self.roiLayout.addWidget(self.roiTimeSpin, 2, 0, 1, 2)
self.roiPlotCheck = Qt.QCheckBox('Plot')
self.roiLayout.addWidget(self.roiPlotCheck, 3, 0, 1, 2)
self.roiPlot = pg.PlotWidget()
self.roiLayout.addWidget(self.roiPlot, 0, 2, self.roiLayout.rowCount(), 1)
self.rectBtn.clicked.connect(lambda: self.addROI('rect'))
self.ellipseBtn.clicked.connect(lambda: self.addROI('ellipse'))
self.polygonBtn.clicked.connect(lambda: self.addROI('polygon'))
self.rulerBtn.clicked.connect(lambda: self.addROI('ruler'))
def __init__(self, module):
self.hasQuit = False
self.module = module # handle to the rest of the application
self.interfaces = OrderedDict() # owner: widget
self.docks = OrderedDict() # owner: dock
# Start building UI
Qt.QMainWindow.__init__(self)
self.setWindowTitle('Camera')
self.cw = dockarea.DockArea()
self.setCentralWidget(self.cw)
self.gv = pg.GraphicsView()
self.gvDock = dockarea.Dock(name="View", widget=self.gv, hideTitle=True, size=(600,600))
self.cw.addDock(self.gvDock)
# set up ViewBox
self.view = pg.ViewBox()
self.view.enableAutoRange(x=False, y=False)
self.view.setAspectLocked(True)
self.gv.setCentralItem(self.view)
# And a plot area for displaying depth-related information
self.depthPlot = pg.PlotWidget(labels={'left': ('Depth', 'm')})
self.depthPlot.setYRange(0, 1e-3)
self.depthPlot.setXRange(-1, 1)
self.depthPlot.hideAxis('bottom')
self.depthPlot.setMouseEnabled(x=False)
self.depthDock = pg.dockarea.Dock(name='Depth', widget=self.depthPlot)
self.cw.addDock(self.depthDock, 'right')
self.depthDock.hide()
# Add a group that will track to the center of the view
# self.trackedGroup = pg.GroupItem()
# self.view.addItem(self.trackedGroup)
# search for all devices that provide a cameraModuleInterface() method
man = Manager.getManager()
devices = [man.getDevice(dev) for dev in man.listDevices()]
ifaces = OrderedDict([(dev.name(), dev.cameraModuleInterface(self)) for dev in devices if hasattr(dev, 'cameraModuleInterface')])
# add each device's control panel in ots own dock
haveDevs = False
for dev, iface in ifaces.items():
if iface is not None:
haveDevs = True
self.addInterface(dev, iface)
# Add explanatory label if no devices were found
if not haveDevs:
label = Qt.QLabel("No imaging devices available")
label.setAlignment(Qt.Qt.AlignHCenter | Qt.Qt.AlignVCenter)
dock = dockarea.Dock(name="nocamera", widget=label, size=(100, 500), hideTitle=True)
self.cw.addDock(dock, 'left', self.gvDock)
# Add a dock with ROI buttons and plot
self.roiWidget = ROIPlotter(self)
self.roiDock = dockarea.Dock(name='ROI Plot', widget=self.roiWidget, size=(400, 10))
self.cw.addDock(self.roiDock, 'bottom', self.gvDock)
# Add timelapse / z stack / mosaic controls
self.sequencerWidget = ImageSequencer(self)
self.sequencerDock = dockarea.Dock(name='Image Sequencer', widget=self.sequencerWidget, size=(200, 10))
self.cw.addDock(self.sequencerDock, 'right', self.roiDock)
#grid = pg.GridItem()
#self.view.addItem(grid)
#Scale bar
self.scaleBar = pg.ScaleBar(100e-6, offset=(-20,-20))
self.scaleBar.setParentItem(self.view)
## Set up status bar labels
self.recLabel = Qt.QLabel()
self.rgnLabel = Qt.QLabel()
self.xyLabel = Qt.QLabel()
self.tLabel = Qt.QLabel()
self.vLabel = Qt.QLabel()
self.vLabel.setFixedWidth(50)
self.setStatusBar(StatusBar())
font = self.xyLabel.font()
font.setPointSize(8)
labels = [self.recLabel, self.xyLabel, self.rgnLabel, self.tLabel, self.vLabel]
for label in labels:
label.setFont(font)
self.statusBar().insertPermanentWidget(0, label)
# Load previous window state
self.stateFile = os.path.join('modules', self.module.name + '_ui.cfg')
uiState = module.manager.readConfigFile(self.stateFile)
if 'geometry' in uiState:
geom = Qt.QRect(*uiState['geometry'])
self.setGeometry(geom)
if 'window' in uiState:
ws = Qt.QByteArray.fromPercentEncoding(uiState['window'])
self.restoreState(ws)
if 'docks' in uiState:
self.cw.restoreState(uiState['docks'], missing='ignore')
# done with UI
self.show()
self.centerView()
self.gv.scene().sigMouseMoved.connect(self.updateMouse)
def __init__(self, mod, dev, mode, recordDir):
self.mod = weakref.ref(mod)
self.dev = dev
self.mode = mode
self.writable = mode != None
self.recordDir = recordDir.getDir(self.dev, create=self.writable)
if self.writable:
self.recordDir.setInfo(mode=mode)
else:
mode = self.recordDir.info()['mode']
if mode[0] == 'v':
self.units = 'A'
else:
self.units = 'V'
self.rawDataFile = None
self.envelopeFile = None
self.spectrogramFile = None
self.resetDisplay = True
self.showNewRecords = True
Qt.QSplitter.__init__(self, Qt.Qt.Vertical)
self.plot = pg.PlotWidget(labels={
'left': ('Primary', self.units),
'bottom': ('Time', 's')
},
title="%s (%s)" % (dev, mode))
self.plot.setDownsampling(auto=True)
self.plot.setClipToView(True)
self.addWidget(self.plot)
self.envelopePlot = pg.PlotWidget(labels={
'left': ('Mean, Stdev, Peaks', self.units),
'bottom': ('Time', 's')
})
self.addWidget(self.envelopePlot)
self.specView = pg.PlotItem(labels={
'left': ('Frequency', 'Hz'),
'bottom': ('Time', 's')
})
self.spectrogram = pg.ImageView(view=self.specView)
self.specView.setAspectLocked(False)
self.spectrogram.imageItem.setAutoDownsample(True)
self.addWidget(self.spectrogram)
self.setStretchFactor(0, 10)
self.setStretchFactor(1, 15)
self.setStretchFactor(2, 30)
self.specLine = pg.InfiniteLine()
self.spectrogram.addItem(self.specLine)
self.envLine = pg.InfiniteLine(movable=True)
self.envelopePlot.addItem(self.envLine)
self.envLine.sigDragged.connect(self.lineDragged)
if not self.writable:
# Load previously collected data
self.loadRecord()
step=0.01,
siPrefix=True,
suffix='s')
layout.addWidget(postRgnStartSpin)
postRgnStopSpin = pg.SpinBox(value=0.700,
step=0.01,
siPrefix=True,
suffix='s')
layout.addWidget(postRgnStopSpin)
spl1 = Qt.QSplitter()
spl1.setOrientation(Qt.Qt.Vertical)
layout.addWidget(spl1, row=1, col=0, rowspan=1, colspan=8)
pw1 = pg.PlotWidget()
spl1.addWidget(pw1)
pw1.setLabel('left', 'Amplitude', 'A')
pw1.setLabel('bottom', 'Decay Tau', 's')
spl2 = Qt.QSplitter()
spl2.setOrientation(Qt.Qt.Horizontal)
spl1.addWidget(spl2)
pw2 = pg.PlotWidget(labels={'bottom': ('time', 's')})
spl2.addWidget(pw2)
tab = Qt.QTabWidget()
spl2.addWidget(tab)
## For viewing cell morphology
def __init__(self, image=None, **opts):
"""
CanvasItem displaying an image.
The image may be 2 or 3-dimensional.
Options:
image: May be a fileHandle, ndarray, or GraphicsItem.
handle: May optionally be specified in place of image
"""
## If no image was specified, check for a file handle..
if image is None:
image = opts.get('handle', None)
item = None
self.data = None
self.currentT = None
if isinstance(image, QtGui.QGraphicsItem):
item = image
elif isinstance(image, np.ndarray):
self.data = image
elif isinstance(image, DataManager.FileHandle):
opts['handle'] = image
self.handle = image
self.data = self.handle.read()
if 'name' not in opts:
opts['name'] = self.handle.shortName()
try:
if 'transform' in self.handle.info():
tr = pg.SRTTransform3D(self.handle.info()['transform'])
tr = pg.SRTTransform(tr) ## convert to 2D
opts['pos'] = tr.getTranslation()
opts['scale'] = tr.getScale()
opts['angle'] = tr.getRotation()
else: ## check for older info formats
if 'imagePosition' in self.handle.info():
opts['scale'] = self.handle.info()['pixelSize']
opts['pos'] = self.handle.info()['imagePosition']
elif 'Downsample' in self.handle.info():
### Needed to support an older format stored by 2p imager
if 'pixelSize' in self.handle.info():
opts['scale'] = self.handle.info()['pixelSize']
if 'microscope' in self.handle.info():
m = self.handle.info()['microscope']
print 'm: ', m
print 'mpos: ', m['position']
opts['pos'] = m['position'][0:2]
else:
info = self.data._info[-1]
opts['pos'] = info.get('imagePosition', None)
elif hasattr(self.data, '_info'):
info = self.data._info[-1]
opts['scale'] = info.get('pixelSize', None)
opts['pos'] = info.get('imagePosition', None)
else:
opts['defaultUserTransform'] = {'scale': (1e-5, 1e-5)}
opts['scalable'] = True
except:
debug.printExc(
'Error reading transformation for image file %s:' %
image.name())
if item is None:
item = pg.ImageItem()
CanvasItem.__init__(self, item, **opts)
self.histogram = pg.PlotWidget()
self.blockHistogram = False
self.histogram.setMaximumHeight(100)
self.levelRgn = pg.LinearRegionItem()
self.histogram.addItem(self.levelRgn)
self.updateHistogram(autoLevels=True)
# addWidget arguments: row, column, rowspan, colspan
self.layout.addWidget(self.histogram, self.layout.rowCount(), 0, 1, 3)
self.timeSlider = QtGui.QSlider(QtCore.Qt.Horizontal)
#self.timeSlider.setMinimum(0)
#self.timeSlider.setMaximum(self.data.shape[0]-1)
self.layout.addWidget(self.timeSlider, self.layout.rowCount(), 0, 1, 3)
self.timeSlider.valueChanged.connect(self.timeChanged)
self.timeSlider.sliderPressed.connect(self.timeSliderPressed)
self.timeSlider.sliderReleased.connect(self.timeSliderReleased)
thisRow = self.layout.rowCount()
self.edgeBtn = QtGui.QPushButton('Edge')
self.edgeBtn.clicked.connect(self.edgeClicked)
self.layout.addWidget(self.edgeBtn, thisRow, 0, 1, 1)
self.meanBtn = QtGui.QPushButton('Mean')
self.meanBtn.clicked.connect(self.meanClicked)
self.layout.addWidget(self.meanBtn, thisRow + 1, 0, 1, 1)
self.tvBtn = QtGui.QPushButton('tv denoise')
self.tvBtn.clicked.connect(self.tvClicked)
self.layout.addWidget(self.tvBtn, thisRow + 2, 0, 1, 1)
self.maxBtn = QtGui.QPushButton('Max no Filter')
self.maxBtn.clicked.connect(self.maxClicked)
self.layout.addWidget(self.maxBtn, thisRow, 1, 1, 1)
self.maxBtn2 = QtGui.QPushButton('Max w/Gaussian')
self.maxBtn2.clicked.connect(self.max2Clicked)
self.layout.addWidget(self.maxBtn2, thisRow + 1, 1, 1, 1)
self.maxMedianBtn = QtGui.QPushButton('Max w/Median')
self.maxMedianBtn.clicked.connect(self.maxMedianClicked)
self.layout.addWidget(self.maxMedianBtn, thisRow + 2, 1, 1, 1)
self.filterOrder = QtGui.QComboBox()
self.filterLabel = QtGui.QLabel('Order')
for n in range(1, 11):
self.filterOrder.addItem("%d" % n)
self.layout.addWidget(self.filterLabel, thisRow + 3, 2, 1, 1)
self.layout.addWidget(self.filterOrder, thisRow + 3, 3, 1, 1)
self.zPlanes = QtGui.QComboBox()
self.zPlanesLabel = QtGui.QLabel('# planes')
for s in ['All', '1', '2', '3', '4', '5']:
self.zPlanes.addItem("%s" % s)
self.layout.addWidget(self.zPlanesLabel, thisRow + 3, 0, 1, 1)
self.layout.addWidget(self.zPlanes, thisRow + 3, 1, 1, 1)
## controls that only appear if there is a time axis
self.timeControls = [
self.timeSlider, self.edgeBtn, self.maxBtn, self.meanBtn,
self.maxBtn2, self.maxMedianBtn, self.filterOrder, self.zPlanes
]
if self.data is not None:
self.updateImage(self.data)
self.graphicsItem().sigImageChanged.connect(self.updateHistogram)
self.levelRgn.sigRegionChanged.connect(self.levelsChanged)
self.levelRgn.sigRegionChangeFinished.connect(
self.levelsChangeFinished)
