def update():
global p4, z, index, count
index -= 1
p4.setData(z=z[index % z.shape[0]])
count += 1
if count == 20:
p1.setData(z=pg.gaussianFilter(np.random.normal(size=(50, 50)), (1.5, 2)))
p3.setData(z=pg.gaussianFilter(np.random.normal(size=(50, 50)), (1.5, 1)))
count = 0
def mkData():
with pg.BusyCursor():
global data, cache, ui, xp
frames = ui.framesSpin.value()
width = ui.widthSpin.value()
height = ui.heightSpin.value()
cacheKey = (ui.dtypeCombo.currentText(), ui.rgbCheck.isChecked(),
frames, width, height)
if cacheKey not in cache:
if cacheKey[0] == 'uint8':
dt = xp.uint8
loc = 128
scale = 64
mx = 255
elif cacheKey[0] == 'uint16':
dt = xp.uint16
loc = 4096
scale = 1024
mx = 2**16
elif cacheKey[0] == 'float':
dt = xp.float
loc = 1.0
scale = 0.1
mx = 1.0
else:
raise ValueError(f"unable to handle dtype: {cacheKey[0]}")
if ui.rgbCheck.isChecked():
data = xp.random.normal(size=(frames, width, height, 3),
loc=loc,
scale=scale)
data = pg.gaussianFilter(data, (0, 6, 6, 0))
else:
data = xp.random.normal(size=(frames, width, height),
loc=loc,
scale=scale)
data = pg.gaussianFilter(data, (0, 6, 6))
if cacheKey[0] != 'float':
data = xp.clip(data, 0, mx)
data = data.astype(dt)
data[:, 10, 10:50] = mx
data[:, 9:12, 48] = mx
data[:, 8:13, 47] = mx
cache = {
cacheKey: data
} # clear to save memory (but keep one to prevent unnecessary regeneration)
data = cache[cacheKey]
updateLUT()
updateSize()
def __init__( self, parent=None):
super(PlotFrame, self).__init__(parent)
self.area = pg_dock.DockArea()
layout = QtGui.QHBoxLayout()
layout.addWidget(self.area)
self.setLayout(layout)
self.sketchDock = pg_dock.Dock("Skecthing", size=(500, 500)) ## give this dock the minimum possible size
self.measureDock = pg_dock.Dock("Measuring", size=(500,200))
self.area.addDock(self.sketchDock, 'top')
self.area.addDock(self.measureDock, 'bottom')
data = pg.gaussianFilter(np.random.normal(size=(256, 256)), (20, 20))
self.afmIm = pg.ImageItem(data)
self.afmIm.setZValue(-1000)
self.sketchPlot = pg.PlotWidget()
self.sketchPlot.enableAutoRange('x', True)
self.sketchPlot.enableAutoRange('y', True)
self.sketchPlot.setAspectLocked(lock=True, ratio=1)
self.sketchPlot.showGrid(x=1, y=1, alpha=0.8)
self.sketchDock.addWidget(self.sketchPlot, 0, 0)
self.histWidget = pg.HistogramLUTWidget()
self.sketchDock.addWidget(self.histWidget, 0, 1)
self.histWidget.setImageItem(self.afmIm)
self.sketchPlot.addItem(self.afmIm)
self.measurePlot = pg.PlotWidget()
self.measureDock.addWidget(self.measurePlot)
def updatePlot_after_remove_point(): #not implemented for PXRD
#global data
try:
selected = roi.getArrayRegion(self.app_ctr.bkg_sub.img,
self.img_pyqtgraph)
except:
pass
p2.plot(selected.sum(axis=0), clear=True)
x, y = [int(each) for each in self.roi.pos()]
w, h = [int(each) for each in self.roi.size()]
self.iso.setData(
pg.gaussianFilter(
self.app_ctr.bkg_sub.img[y:(y + h), x:(x + w)], (2, 2)))
self.iso.setPos(x, y)
if self.app_ctr.img_loader.frame_number == 0:
isoLine.setValue(self.app_ctr.bkg_sub.img[y:(y + h),
x:(x + w)].mean())
else:
pass
#print(isoLine.value(),self.current_image_no)
#plot others
plot_bkg_fit_gui_pyqtgraph(self.p2, self.p3, self.p4,
self.app_ctr.data, self.app_ctr.bkg_sub)
self.lcdNumber_potential.display(
self.app_ctr.data['potential'][-2])
self.lcdNumber_current.display(self.app_ctr.data['current'][-2])
self.lcdNumber_intensity.display(
self.app_ctr.data['peak_intensity'][-2])
self.lcdNumber_iso.display(isoLine.value())
def __init__(self):
## Create window with ImageView widget
super(RasterScan, self).__init__()
self.resize(800,800)
self.show()
## Create random 3D data set with noisy signals
img = pg.gaussianFilter(np.random.normal(size=(200, 200)), (5, 5)) * 20 + 100
img = img[np.newaxis,:,:]
decay = np.exp(-np.linspace(0,0.3,100))[:,np.newaxis,np.newaxis]
data = np.random.normal(size=(100, 200, 200))
data += img * decay
data += 2
## Add time-varying signal
sig = np.zeros(data.shape[0])
sig[30:] += np.exp(-np.linspace(1,10, 70))
sig[40:] += np.exp(-np.linspace(1,10, 60))
sig[70:] += np.exp(-np.linspace(1,10, 30))
sig = sig[:,np.newaxis,np.newaxis] * 3
data[:,50:60,50:60] += sig
## Display the data and assign each frame a time value from 1.0 to 3.0
self.setImage(data, xvals=np.linspace(1., 3., data.shape[0]))
def __init__(self, parent, **kwargs):
super(AppWindow,
self).__init__(parent) #, QtCore.Qt.WindowStaysOnTopHint)
self.addshortcut = QtWidgets.QShortcut(QtGui.QKeySequence("3"), self)
self.addshortcut.activated.connect(self.make3D)
self.regions = kwargs.get('regions', None)
self.short2d = QtWidgets.QShortcut(QtGui.QKeySequence("2"), self)
self.short2d.activated.connect(self.make2D)
self.saveShortcut = QtWidgets.QShortcut(QtGui.QKeySequence("Ctrl+S"),
self)
self.saveShortcut.activated.connect(self.saveAll)
self.setupUi(self)
self.plot = pg.PlotWidget()
self.curve = pg.PlotCurveItem(
) #name = name);C.setPen(color=col, width=3)
self.plot.addItem(self.curve)
self.exporter = PQG_ImageExporter(self.plot.plotItem)
#3D Plot
try:
self.plot3D = plot3DTools.AppWindow()
except:
pass
#2D plot (surface)
self.win = QtGui.QMainWindow()
self.win.resize(800, 800)
imv = pg.ImageView()
self.win.setCentralWidget(imv)
## Create random 3D data set with noisy signals
img = pg.gaussianFilter(np.random.normal(size=(200, 200)),
(5, 5)) * 20 + 100
img = img[np.newaxis, :, :]
decay = np.exp(-np.linspace(0, 0.3, 100))[:, np.newaxis, np.newaxis]
data = np.random.normal(size=(100, 200, 200))
data += img * decay
data += 2
## Add time-varying signal
sig = np.zeros(data.shape[0])
sig[30:] += np.exp(-np.linspace(1, 10, 70))
sig[40:] += np.exp(-np.linspace(1, 10, 60))
sig[70:] += np.exp(-np.linspace(1, 10, 30))
sig = sig[:, np.newaxis, np.newaxis] * 3
data[:, 50:60, 30:40] += sig
## Display the data and assign each frame a time value from 1.0 to 3.0
imv.setImage(data, xvals=np.linspace(1., 3., data.shape[0]))
## Set a custom color map
colors = [(0, 0, 0), (45, 5, 61), (84, 42, 55), (150, 87, 60),
(208, 171, 141), (255, 255, 255)]
cmap = pg.ColorMap(pos=np.linspace(0.0, 1.0, 6), color=colors)
imv.setColorMap(cmap)
self.makeMenu()
def testHistogramLUTWidget():
pg.mkQApp()
win = QtGui.QMainWindow()
win.show()
cw = QtGui.QWidget()
win.setCentralWidget(cw)
l = QtGui.QGridLayout()
cw.setLayout(l)
l.setSpacing(0)
v = pg.GraphicsView()
vb = pg.ViewBox()
vb.setAspectLocked()
v.setCentralItem(vb)
l.addWidget(v, 0, 0, 3, 1)
w = pg.HistogramLUTWidget(background='w')
l.addWidget(w, 0, 1)
data = pg.gaussianFilter(np.random.normal(size=(256, 256, 3)), (20, 20, 0))
for i in range(32):
for j in range(32):
data[i*8, j*8] += .1
img = pg.ImageItem(data)
vb.addItem(img)
vb.autoRange()
w.setImageItem(img)
QtGui.QApplication.processEvents()
win.close()
def createView(self):
z, y, x = 300, 200, 100
data = np.random.normal(size=(z, y, x))
data = pg.gaussianFilter(data, (5, 5, 5))
return dv.views.VolumeView(dv.models.VolumeModel(data), toolBar=True,
slicesMode=dv.models.AXIS_XYZ)
def process(self, dataIn, display=True):
# CtrlNode has created self.ctrls, which is a dict containing {ctrlName: widget}
sigma = self.ctrls['sigma'].value()
strength = self.ctrls['strength'].value()
output = dataIn - (strength *
pg.gaussianFilter(dataIn, (sigma, sigma)))
return {'dataOut': output}
def addIsocurve(self, level=0.):
iso = pg.IsocurveItem(level=level, pen='g')
iso.setZValue(1000)
iso.setData(pg.gaussianFilter(self.data, (5, 5)))
iso.setParentItem(self.image)
self.iso = iso
def init_data(self):
# Generate image data
data = np.random.normal(size=(200, 100))
data[20:80, 20:80] += 2.
data = pg.gaussianFilter(data, (3, 3))
data += np.random.normal(size=(200, 100)) * 0.1
self.set_data(data)
def __init__(self, parent=None):
# initialization of the superclass
super(VideoMainWindow, self).__init__(parent)
# setup the GUI
self.setupUi(self)
pg.setConfigOptions(background=pg.mkColor(0.5))
pg.setConfigOptions(foreground=pg.mkColor(0.3))
self.setWindowTitle('pyqtgraph example: Image Analysis')
# Preserve plot area's aspect ration so image always scales correctly
self.graphicsView.p1.setAspectLocked(True)
# Use a file dialog to choose tiff stack
file, mask = QFileDialog.getOpenFileName(self, 'Open a .tif/.tiff stack')
# Read image data
self.img_data_raw = volread(file)
frames = self.img_data_raw.shape[0]
# Transpose second and third axes (y, x) to correct orientation (x, y)
self.img_data = np.transpose(self.img_data_raw, (0, 2, 1))
# Flip each frame in the left/right direction, expected to be up/down
for i in range(frames):
self.img_data[i] = np.fliplr(self.img_data[i])
self.ptr = 0
self.lastTime = ptime.time()
self.fps = None
self.timer = QtCore.QTimer()
self.timer.timeout.connect(self.update)
self.timer.start(50) # 50 ms =~ 20 fps
# Levels/color control with a histogram
# TODO try with a HistogramLUTWidget
self.hist = pg.HistogramLUTItem()
self.hist.setImageItem(self.graphicsView.img)
self.graphicsView.widget.addItem(self.hist)
# Isocurve drawing
self.iso = pg.IsocurveItem(level=0.8, pen='g')
self.iso.setParentItem(self.graphicsView.img)
self.iso.setZValue(5)
# 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)
# Generate image data
self.graphicsView.img.setImage(self.img_data[0])
# self.graphicsView.img.scale(self.img_data.shape[1], self.img_data.shape[2])
self.hist.setLevels(self.img_data.min(), self.img_data.max())
# build isocurves from smoothed data
self.isoLine.setValue(self.img_data.max() / 2)
self.iso.setData(pg.gaussianFilter(self.img_data[0], (2, 2)))
def __init__(self):
self.graph = GraphicsLayoutWidget()
self.graph.setObjectName("stock UI")
self.label = pg.LabelItem(justify='right')
self.graph.addItem(self.label)
self.p1 = self.graph.addPlot(row=1, col=0)
self.p2 = self.graph.addPlot(row=2, col=0)
self.p1.showGrid(x=True, y=True, alpha=0.5)
self.region = pg.LinearRegionItem()
self.region.setZValue(10)
# Add the LinearRegionItem to the ViewBox, but tell the ViewBox to exclude this
# item when doing auto-range calculations.
self.p2.addItem(self.region, ignoreBounds=True)
#pg.dbg()
self.p1.setAutoVisible(y=True)
#create numpy arrays
#make the numbers large to show that the xrange shows data from 10000 to all the way 0
self.data1 = 10000 + 15000 * pg.gaussianFilter(
np.random.random(size=10000),
10) + 3000 * np.random.random(size=10000)
self.data2 = 15000 + 15000 * pg.gaussianFilter(
np.random.random(size=10000),
10) + 3000 * np.random.random(size=10000)
self.p1.plot(self.data1, pen="r")
self.p1.plot(self.data2, pen="g")
self.p2.plot(self.data1, pen="w")
self.region.sigRegionChanged.connect(self.update)
self.p1.sigRangeChanged.connect(self.updateRegion)
self.region.setRegion([1000, 2000])
#cross hair
self.vLine = pg.InfiniteLine(angle=90, movable=False)
self.hLine = pg.InfiniteLine(angle=0, movable=False)
self.p1.addItem(self.vLine, ignoreBounds=True)
self.p1.addItem(self.hLine, ignoreBounds=True)
self.vb = self.p1.vb
self.proxy = pg.SignalProxy(self.p1.scene().sigMouseMoved,
rateLimit=60,
slot=self.mouseMoved)
def process(self, view, display=True):
if view is not None:
self.view = view
self.view.addItem(self.iso)
self.view.addHistItem(self.isoLine)
self.iso.setData(pg.gaussianFilter(self.view.getImage(), (2, 2)))
return {'level': self.iso.level}
def process(self, view, display=True):
if view is not None:
self.view = view
self.view.addItem(self.iso)
self.view.addHistItem(self.isoLine)
self.iso.setData(pg.gaussianFilter(self.view.getImage(), (2, 2)))
return {'level': self.iso.level}
def read_image(self):
""" Acts like the device is measuring random images
"""
noise = np.random.normal(size=(self._size,
self._size)) * self._amplitude
img = pg.gaussianFilter(
np.random.normal(size=(self._size, self._size)), (5, 5)) * 20 + 100
tot = img + noise
return np.uint16(tot)
def createView(self):
data = pg.gaussianFilter(np.random.normal(size=(64, 64, 64)), (5, 5, 5))
volModel = dv.models.VolumeModel(data)
msv = dv.views.MultiSliceView(
None, {axis: {'model': volModel.getSlicesModel(axis),
'normalize': True}
for axis in [dv.models.AXIS_X, dv.models.AXIS_Y,
dv.models.AXIS_Z]})
return msv
def add_sea(self):
self.removeItem(self.grid)
z = pg.gaussianFilter(np.random.normal(size=(100, 100)), (1, 1))
self.sea = gl.GLSurfacePlotItem(z=z,
shader='shaded',
color=(0.5, 0.5, 1, 1),
smooth=True)
self.sea.translate(-50, -50, -1)
self.addItem(self.sea)
def updateIsocurve(self):
# #old
# cur_data = pg.gaussianFilter(self.imv.getImageItem().image, (4, 4))
# self.iso.setParentItem(self.imv.getImageItem())
cur_data = pg.gaussianFilter(self.img.image, (4, 4))
# self.iso.setParentItem(self.img)
self.iso.setData(cur_data) # this line takes too much process time
self.iso.setLevel(cur_data.max() / np.e)
self.iso.setZValue(1000)
def mkData():
with pg.BusyCursor():
global data, cache, ui
frames = ui.framesSpin.value()
width = ui.widthSpin.value()
height = ui.heightSpin.value()
dtype = (ui.dtypeCombo.currentText(), ui.rgbCheck.isChecked(), frames,
width, height)
if dtype not in cache:
if dtype[0] == 'uint8':
dt = np.uint8
loc = 128
scale = 64
mx = 255
elif dtype[0] == 'uint16':
dt = np.uint16
loc = 4096
scale = 1024
mx = 2**16
elif dtype[0] == 'float':
dt = np.float
loc = 1.0
scale = 0.1
if ui.rgbCheck.isChecked():
data = np.random.normal(size=(frames, width, height, 3),
loc=loc,
scale=scale)
data = pg.gaussianFilter(data, (0, 6, 6, 0))
else:
data = np.random.normal(size=(frames, width, height),
loc=loc,
scale=scale)
data = pg.gaussianFilter(data, (0, 6, 6))
if dtype[0] != 'float':
data = np.clip(data, 0, mx)
data = data.astype(dt)
cache = {
dtype: data
} # clear to save memory (but keep one to prevent unnecessary regeneration)
data = cache[dtype]
updateLUT()
updateSize()
def set_data(self, data):
self.data = data
# build isocurves from smoothed data
self.iso_curve.setData(pg.gaussianFilter(self.data, (2, 2)))
self.image_view.setImage(self.data)
self.update_roi()
print(self.hist.getLevels())
def main_controller():
app = QtWidgets.QApplication(sys.argv)
form = QtWidgets.QWidget()
Nx = 100
Ny = 200
data_random = np.random.normal(size=(Ny, Nx))
x = np.linspace(0, Nx - 1, Nx)
y = np.linspace(0, Ny - 1, Ny)
from pymodaq.daq_utils.daq_utils import gauss2D
data_red = 3 * gauss2D(x, 0.2 * Nx, Nx / 5, y, 0.3 * Ny, Ny / 5, 1,
90) * np.sin(x / 5)**2 + 0.1 * data_random
# data_red = pg.gaussianFilter(data_red, (2, 2))
data_green = 24 * gauss2D(x, 0.2 * Nx, Nx / 5, y, 0.3 * Ny, Ny / 5, 1, 0)
# data_green = pg.gaussianFilter(data_green, (2, 2))
data_green[70:80, 7:12] = np.nan
data_blue = 10 * gauss2D(x, 0.7 * Nx, Nx / 5, y, 0.2 * Ny, Ny / 5, 1)
data_blue = pg.gaussianFilter(data_blue, (2, 2))
prog = Viewer2D(form)
# prog.set_axis_scaling(scaling_options=utils.ScalingOptions(
# scaled_xaxis=utils.ScaledAxis(label="eV", units=None, offset=100, scaling=0.1),
# scaled_yaxis=utils.ScaledAxis(label="time", units='s', offset=-20, scaling=2)))
form.show()
#prog.auto_levels_action_sym.trigger()
#prog.view.actions['autolevels'].trigger()
data_spread = np.load('../../../resources/triangulation_data.npy')
# data_shuffled = data
# np.random.shuffle(data_shuffled)
# prog.show_data(utils.DataFromPlugins(name='mydata', distribution='spread',
# data=[data, data_shuffled]))
prog.view.get_action('histo').trigger()
prog.view.get_action('autolevels').trigger()
prog.show_data(
utils.DataFromPlugins(name='mydata',
distribution='uniform',
data=[data_red, data_green]))
#prog.show_data(utils.DataFromPlugins(name='mydata', distribution='spread', data=[data_spread]))
#prog.ROI_select_signal.connect(print_roi_select)
#prog.view.get_action('ROIselect').trigger()
#prog.view.ROIselect.setSize((20, 35))
#prog.view.ROIselect.setPos((45, 123))
prog.show_roi_target(True)
prog.move_scale_roi_target((50, 40), (20, 20))
QtWidgets.QApplication.processEvents()
# prog.setImage(data_spread=data)
#app.processEvents()
sys.exit(app.exec_())
def show_hide_iso(self):
if self.ui.isocurve_pb.isChecked():
self.ui.iso.show()
self.ui.isoLine.show()
self.ui.Show_histogram.setChecked(True)
self.show_hide_histogram()
if self.ui.isocurve_pb.isChecked() and self.image.red is not None:
self.ui.iso.setData(pg.gaussianFilter(self.image.red, (2, 2)))
else:
self.ui.iso.hide()
self.ui.isoLine.hide()
def do_stuff(self):
p = Parameter.create(name='params', type='group', children=self.params)
def change(param, changes):
print("tree changes:")
for param, change, data in changes:
path = p.childPath(param)
if path is not None:
childName = '.'.join(path)
else:
childName = param.name()
print(' parameter: %s' % childName)
print(' change: %s' % change)
print(' data: %s' % str(data))
print(' ----------')
p.sigTreeStateChanged.connect(change)
# create a parameter tree widget
t = ParameterTree()
t.setParameters(p, showTop=False)
t.setWindowTitle('pyqtgraph example: Parameter Tree')
# plot some data
plot = pg.PlotWidget()
n = 1000
xv = np.arange(n)
yv = 1 * pg.gaussianFilter(np.random.random(size=n), 10)
plot.plot(xv, yv, pen='r')
# make a second plot
plot2 = pg.PlotWidget()
plot2.plot(xv, yv, pen='g')
# set the layout of the widget
layout = QtGui.QGridLayout()
# layout.columnStretch(5)
layout.setColumnStretch(2, 2)
# NOTE: (widget, # y_row, x_row, y_span, x_span)
# layout.addWidget(QtGui.QLabel("Data monitor thing"), 0, 0, 1, 2)
layout.addWidget(t, 0, 0, 2, 1)
layout.addWidget(plot, 0, 2)
layout.addWidget(plot2, 1, 2)
self.setLayout(layout)
# test save/restore
s = p.saveState()
p.restoreState(s)
def createSlicesModel(imgSize, size):
"""
Creates an SlicesModel, generating random images of the given image size,
having size elements.
:param imgSize: (tupple) The image size
:param size: (int) The number of slices(images)
:return: (SlicesModel)
"""
s = size, imgSize[1], imgSize[0]
data = pg.gaussianFilter(np.random.normal(size=s), (5, 5, 5))
return dv.models.SlicesModel(data)
def getData(self, micId):
"""
Return the micrograph image data
:param micId: (int) The micrograph id
:return: The micrograph image data
"""
if micId not in self._cache:
c, r = self._imageSize
self._cache[micId] = pg.gaussianFilter(
np.random.normal(size=(r, c)), (5, 5))
return self._cache[micId]
def mkData():
with pg.BusyCursor():
global data, cache, ui
frames = ui.framesSpin.value()
width = ui.widthSpin.value()
height = ui.heightSpin.value()
dtype = (ui.dtypeCombo.currentText(), ui.rgbCheck.isChecked(), frames, width, height)
if dtype not in cache:
if dtype[0] == 'uint8':
dt = np.uint8
loc = 128
scale = 64
mx = 255
elif dtype[0] == 'uint16':
dt = np.uint16
loc = 4096
scale = 1024
mx = 2**16
elif dtype[0] == 'float':
dt = np.float
loc = 1.0
scale = 0.1
if ui.rgbCheck.isChecked():
data = np.random.normal(size=(frames,width,height,3), loc=loc, scale=scale)
data = pg.gaussianFilter(data, (0, 6, 6, 0))
else:
data = np.random.normal(size=(frames,width,height), loc=loc, scale=scale)
data = pg.gaussianFilter(data, (0, 6, 6))
if dtype[0] != 'float':
data = np.clip(data, 0, mx)
data = data.astype(dt)
data[:, 10, 10:50] = mx
data[:, 9:12, 48] = mx
data[:, 8:13, 47] = mx
cache = {dtype: data} # clear to save memory (but keep one to prevent unnecessary regeneration)
data = cache[dtype]
updateLUT()
updateSize()
def updateData():
global updateTime, fps
## Display the data
img = pg.gaussianFilter(np.random.normal(size=(200, 200)),
(5, 5)) * 20 + 100
imview.setImage(img, autoLevels=False, autoHistogramRange=False
) # Display new image and stop range from jumping around
QtCore.QTimer.singleShot(1, updateData) # Recursive call here
now = pg.ptime.time()
fps2 = 1.0 / (now - updateTime)
updateTime = now
fps = fps * 0.9 + fps2 * 0.1
imview.setWindowTitle('%0.1f fps (close window to stop)' % fps)
def createView(self):
imageView = dv.views.ImageView(parent=None, border_color='#FFAA33')
data = pg.gaussianFilter(np.random.normal(size=(512, 512)),
(5, 5))
imgModel = dv.models.ImageModel(data)
imageView.setModel(imgModel)
dim_x, dim_y = imgModel.getDim()
desc = ("<html><head/><body><p>"
"<span style=\" color:#0055ff;\">Dimensions: </span>"
"<span style=\" color:#000000;\">(%d,%d)</span></p>"
"</html>" % (dim_x, dim_y))
imageView.setImageInfo(text=desc)
return imageView
def set_data(self, data, slit_shape=None, pix_scale=0.1):
self.image_item.setImage(np.swapaxes(data.data, 0, 1))
self.hist.setLevels(np.nanmin(data.data.compressed().value),
np.nanmax(data.data.compressed().value))
self.iso.setData(pg.gaussianFilter(data.data.data.value, (2, 2)))
self.iso_line.setValue(np.median(data.data.compressed().value))
self.plot.setLabel('bottom',
text="X [{}]".format(
u.Unit(data.dispersion_unit.to_string())))
self.plot.setLabel('left',
text="Y [{}]".format(
u.Unit(data.cross_dispersion_unit.to_string())))
def getData(self, row, col=0):
""" Return the data (array like) for the item in this row, column.
Used by rendering of images in a given cell of the table.
"""
data = self._imgData.get(row)
if len(self._imgSize) == 2: # 2D Image
s = (self._imgSize[1], self._imgSize[0])
else: # Volume
s = (self._imgSize[2], self._imgSize[1], self._imgSize[0])
if data is None:
data = pg.gaussianFilter(np.random.normal(size=s),
[5 for _ in range(len(self._imgSize))])
self._imgData[row] = data
return data
def _setDataToNoise(self):
""" Sets image data to noise
"""
logger.debug("_setDataToNoise")
# img = np.random.randint(100, 150, size=(1216, 1936), dtype=np.uint16)
img = pg.gaussianFilter(np.random.normal(size=(300, 200)), (5, 5)) * 20
# img = np.random.normal(size=(300, 200)) * 100
# For testing issue 792
# maxVal = 1.0
# img = np.random.uniform(0.0, 1.0, size=(300, 300)) * maxVal
# img[200:205, :] = maxVal
self.setImage(img)
def init_data():
Nx = 100
Ny = 200
data_random = np.random.normal(size=(Ny, Nx))
x = np.linspace(0, Nx - 1, Nx)
y = np.linspace(0, Ny - 1, Ny)
from pymodaq.daq_utils.daq_utils import gauss2D
data_red = 3 * gauss2D(x, 0.2 * Nx, Nx / 5, y, 0.3 * Ny, Ny / 5, 1,
90) * np.sin(x / 5)**2
data_green = 24 * gauss2D(x, 0.2 * Nx, Nx / 5, y, 0.3 * Ny, Ny / 5, 1, 0)
data_blue = 10 * gauss2D(x, 0.7 * Nx, Nx / 5, y, 0.2 * Ny, Ny / 5, 1)
data_blue = pg.gaussianFilter(data_blue, (2, 2))
here = Path(__file__).parent
data_spread = np.load(str(here.joinpath('triangulation_data.npy')))
return data_red, data_green, data_blue, data_spread
def make_testdata(self): #create numpy arrays
#make the numbers large to show that the xrange shows data from 10000 to all the way 0
ntr = 1
npts = 10000
dt = 1e-2
dataX = np.linspace(0, dt, npts)
self.dt = np.mean(np.diff(dataX))
shortx = dataX[1500:5000]
t0 = shortx[0]
d = -200. + 10 * pg.gaussianFilter(np.random.random(
size=npts), 10) # + 10 * np.random.random(size=npts)
d[1500:5000] += -20 * (np.exp(-(shortx - t0) / 1e-3) -
np.exp(-(shortx - t0) / 0.25e-3))
dataY = d
# dataX = 10000 + 15000 * pg.gaussianFilter(np.random.random(size=10000), 10) + 3000 * np.random.random(size=10000)
return (dataX, dataY)
hist.vb.setMouseEnabled(y=False) # makes user interaction a little easier isoLine.setValue(0.8) isoLine.setZValue(1000) # bring iso line above contrast controls # Another plot area for displaying ROI data win.nextRow() p2 = win.addPlot(colspan=2) p2.setMaximumHeight(250) win.resize(800, 800) win.show() # Generate image data data = np.random.normal(size=(100, 200)) data[20:80, 20:80] += 2. data = pg.gaussianFilter(data, (3, 3)) data += np.random.normal(size=(100, 200)) * 0.1 img.setImage(data) hist.setLevels(data.min(), data.max()) # build isocurves from smoothed data iso.setData(pg.gaussianFilter(data, (2, 2))) # set position and scale of image img.scale(0.2, 0.2) img.translate(-50, 0) # zoom to fit imageo p1.autoRange()
def update():
z = self.amp * pg.gaussianFilter(np.random.normal(size=(self.x_size, self.y_size)), (1,1))
if self.rand_noise:
for x in range(20):
z[random.randint(0, self.x_size - 1), random.randint(0, self.y_size - 1)] = self.amp * 2
curve.setData(z=z)
def process(self, dataIn, display=True):
# CtrlNode has created self.ctrls, which is a dict containing {ctrlName: widget}
sigma = self.ctrls['sigma'].value()
strength = self.ctrls['strength'].value()
output = dataIn - (strength * pg.gaussianFilter(dataIn, (sigma,sigma)))
return {'dataOut': output}
## Add path to library (just for examples; you do not need this)
import numpy as np
import pyqtgraph as pg
import pyqtgraph.opengl as gl
from pyqtgraph.Qt import QtCore, QtGui
app = QtGui.QApplication([])
w = gl.GLViewWidget()
w.opts['distance'] = 200
w.show()
w.setWindowTitle('pyqtgraph example: GLImageItem')
## create volume data set to slice three images from
shape = (100,100,70)
data = pg.gaussianFilter(np.random.normal(size=shape), (4,4,4))
data += pg.gaussianFilter(np.random.normal(size=shape), (15,15,15))*15
## slice out three planes, convert to RGBA for OpenGL texture
levels = (-0.08, 0.08)
tex1 = pg.makeRGBA(data[shape[0]/2], levels=levels)[0] # yz plane
tex2 = pg.makeRGBA(data[:,shape[1]/2], levels=levels)[0] # xz plane
tex3 = pg.makeRGBA(data[:,:,shape[2]/2], levels=levels)[0] # xy plane
#tex1[:,:,3] = 128
#tex2[:,:,3] = 128
#tex3[:,:,3] = 128
## Create three image items from textures, add to view
v1 = gl.GLImageItem(tex1)
v1.translate(-shape[1]/2, -shape[2]/2, 0)
v1.rotate(90, 0,0,1)
# Interpret image data as row-major instead of col-major
pg.setConfigOptions(imageAxisOrder="row-major")
app = QtGui.QApplication([])
## Create window with ImageView widget
win = QtGui.QMainWindow()
win.resize(800, 800)
imv = pg.ImageView()
win.setCentralWidget(imv)
win.show()
win.setWindowTitle("pyqtgraph example: ImageView")
## Create random 3D data set with noisy signals
img = pg.gaussianFilter(np.random.normal(size=(200, 200)), (5, 5)) * 20 + 100
img = img[np.newaxis, :, :]
decay = np.exp(-np.linspace(0, 0.3, 100))[:, np.newaxis, np.newaxis]
data = np.random.normal(size=(100, 200, 200))
data += img * decay
data += 2
## Add time-varying signal
sig = np.zeros(data.shape[0])
sig[30:] += np.exp(-np.linspace(1, 10, 70))
sig[40:] += np.exp(-np.linspace(1, 10, 60))
sig[70:] += np.exp(-np.linspace(1, 10, 30))
sig = sig[:, np.newaxis, np.newaxis] * 3
data[:, 50:60, 30:40] += sig
# -*- coding: utf-8 -*-
"""
Tests use of IsoCurve item displayed with image
"""
import numpy as np
import pyqtgraph as pg
from pyqtgraph.Qt import QtGui, QtCore
app = QtGui.QApplication([])
## make pretty looping data
frames = 200
data = np.random.normal(size=(frames,30,30), loc=0, scale=100)
data = np.concatenate([data, data], axis=0)
data = pg.gaussianFilter(data, (10, 10, 10))[frames/2:frames + frames/2]
data[:, 15:16, 15:17] += 1
win = pg.GraphicsWindow()
win.setWindowTitle('pyqtgraph example: Isocurve')
vb = win.addViewBox()
img = pg.ImageItem(data[0])
vb.addItem(img)
vb.setAspectLocked()
## generate empty curves
curves = []
levels = np.linspace(data.min(), data.max(), 10)
for i in range(len(levels)):
v = levels[i]
## generate isocurve with automatic color selection
def createLayout(self):
print 'Creating layout...'
self.setWindowTitle('Interferometry Acquisition GUI')
#self.widget = QtGui.QWidget()
#self.setCentralWidget(self.widget)
self.layout = pg.LayoutWidget()
#self.widget.setLayout(self.layout)
self.setCentralWidget(self.layout)
#Create GUI
sizePolicyBt = QtGui.QSizePolicy(1, 1)
sizePolicyBt.setHorizontalStretch(0)
sizePolicyBt.setVerticalStretch(0)
self.btOpen = QtGui.QPushButton("Open\nprevious results")
sizePolicyBt.setHeightForWidth(self.btOpen.sizePolicy().hasHeightForWidth())
self.btOpen.setSizePolicy(sizePolicyBt);
self.btOpen.setStyleSheet("background-color: yellow; font-size: 16px; font: bold")
self.btStart = QtGui.QPushButton("Start\nacquisition")
sizePolicyBt.setHeightForWidth(self.btStart.sizePolicy().hasHeightForWidth())
self.btStart.setSizePolicy(sizePolicyBt);
self.btStart.setStyleSheet("background-color: green; font-size: 16px; font: bold")
self.btStart.clicked.connect(self.startAcquisition)
self.btStop = QtGui.QPushButton("Stop\nacquisition")
sizePolicyBt.setHeightForWidth(self.btStop.sizePolicy().hasHeightForWidth())
self.btStop.setSizePolicy(sizePolicyBt);
self.btStop.setStyleSheet("background-color: red; font-size: 16px; font: bold")
self.btStop.clicked.connect(self.stopAcquisition)
self.btStop.setEnabled(False)
self.paramTree = ParameterTree()
self.paramTree.setParameters(Parameters.paramObject, showTop=False)
self.paramTree.setWindowTitle('pyqtgraph example: Parameter Tree')
self.paramTree.setMinimumWidth(350)
self.paramTree.setMaximumWidth(350)
sizePolicyPt = QtGui.QSizePolicy(1,1)
sizePolicyPt.setHorizontalStretch(QtGui.QSizePolicy.Fixed)
sizePolicyPt.setVerticalStretch(1)
self.paramTree.setSizePolicy(sizePolicyPt);
## Create random 2D data
data = np.random.normal(size=(512, 512)) + pg.gaussianFilter(np.random.normal(size=(512, 512)), (5, 5)) * 20 + 100
data = data[:,:,np.newaxis]
data = data.repeat(3,2)
self.plotTl = pg.GraphicsView()
self.plotTlImage = pg.ImageItem(data[:,:,:]) #parent=self.plotTl
self.plotTlViewBox = pg.ViewBox()
self.plotTl.setCentralWidget(self.plotTlViewBox)
self.plotTlViewBox.addItem(self.plotTlImage)
self.plotTr = pg.PlotWidget(title="Interferometry", labels={'left': 'Signal amplitude (A.U.)', 'bottom': 'Distance (mm)'})
#self.plotTlViewBox2.addItem(self.plotTr)
self.plotTrCurve = self.plotTr.plot(pen=(255,0,0),name='C1') #Red
self.plotTrCurve2 = self.plotTr.plot(pen=(0,255,0),name='C2') #Green
#self.plotTlViewBox2.enableAutoRange('xy', True) ## stop auto-scaling after the first data set is plotted
#self.plotTr.addLegend('Test')
self.plotTr.setYRange(-1000, 1000)
self.plotBl = pg.PlotWidget(title="Distance", labels={'left': 'Distance (mm)', 'bottom': 'Number of acquisitions'})
self.plotBlCurve = self.plotBl.plot(pen=(255,0,0),name='C1')
self.plotBl.enableAutoRange('xy', True) ## stop auto-scaling after the first data set is plotted
self.plotBl.setMaximumWidth(3500)
self.tbInfo = QtGui.QTextEdit()
self.tbInfo.setEnabled(False)
palette = self.tbInfo.palette()
palette.setColor(QtGui.QPalette.Base, QtGui.QColor("white")) #White background
self.tbInfo.setPalette(palette)
self.tbInfo.setTextColor(QtGui.QColor("black"))
self.tbInfo.insertPlainText("Useful information will appear here.")
#Create list view of multiple items
self.tbStatus = QtGui.QListView()
self.tbStatus.setEnabled(False)
palette = self.tbStatus.palette()
palette.setColor(QtGui.QPalette.Base, QtGui.QColor("white")) #White background
self.tbStatus.setPalette(palette)
itemModelStatus = QtGui.QStandardItemModel(self.tbStatus)
self.tbStatus.setModel(itemModelStatus)
#Add system status
self.itemStatus = QtGui.QStandardItem()
self.setStatus(False)
itemModelStatus.appendRow(self.itemStatus)
#Add camera status
self.itemCameraStatus = QtGui.QStandardItem()
self.setCameraStatus(False)
itemModelStatus.appendRow(self.itemCameraStatus)
#Add memory usage
self.itemMemory = QtGui.QStandardItem("Acquisition board memory usage: N/A")
self.itemMemory.setForeground(QtGui.QColor("black"))
itemModelStatus.appendRow(self.itemMemory)
#Add max value position
self.itemMaxValPos = QtGui.QStandardItem("Maximum RF value position: N/A")
self.itemMaxValPos.setForeground(QtGui.QColor("black"))
itemModelStatus.appendRow(self.itemMaxValPos)
#layout.addWidget(QtGui.QLabel("These are two views of the same data. They should always display the same values."), 0, 0, 1, 2)
self.layout.addWidget(self.btOpen, 9, 6, 1, 1)
self.layout.addWidget(self.btStart, 9, 7, 1, 1)
self.layout.addWidget(self.btStop, 9, 8, 1, 1)
self.layout.addWidget(self.paramTree, 0, 0, 10, 3)
self.layout.addWidget(self.plotTl, 0, 3, 5, 3)
self.layout.addWidget(self.plotTr, 0, 6, 5, 3)
self.layout.addWidget(self.plotBl, 5, 3, 5, 3)
self.layout.addWidget(self.tbInfo, 5, 6, 2, 3)
self.layout.addWidget(self.tbStatus, 7, 6, 2, 3)
self.layout.layout.setColumnStretch(3,1)
self.layout.layout.setColumnStretch(4,1)
self.layout.layout.setColumnStretch(5,1)
self.layout.layout.setColumnStretch(6,1)
self.layout.layout.setColumnStretch(7,1)
self.layout.layout.setColumnStretch(8,1)
self.show()
self.resize(1500,800)
self.move(100,100)
Parameters.paramObject.param('Save/Restore functionality', 'Save State').sigActivated.connect(self.saveParam)
Parameters.paramObject.param('Save/Restore functionality', 'Restore State').sigActivated.connect(self.restoreParam)
Parameters.paramObject.child("Acquisition Parameters", "Rotation speed (%)").sigValueChanged.connect(self.motorSpeedChanged)
Parameters.paramObject.child("Trigger Options", "Acquisition mode").sigValueChanged.connect(self.triggerChanged)
Parameters.paramObject.child("Trigger Options", "Trigger amplitude").sigValueChanged.connect(self.triggerChanged)
Parameters.paramObject.child("Trigger Options", "Trigger switch 1/2").sigActivated.connect(self.triggerHalfSwitch)
# adding by emitting signal in different thread
self.workThread = AcquisitionWorker()
self.workThread.updateDataCamera.connect(self.setDataCurveTl)
self.workThread.updateDataInterf.connect(self.setDataCurveTr)
self.workThread.updateDataDistance.connect(self.setDataCurveBl)
self.workThread.updateDataDistance2.connect(self.setDataCurveBl2)
self.workThread.updateWire.connect(self.setWire)
self.workThread.setStatus.connect(self.setStatus)
self.workThread.setInfo.connect(self.setInfo)
self.testCount = 0;
#Fill the plots with dummy data
self.data = np.random.normal(size=(10,1000))
self.plotTrXAxis = np.arange(1000) * (0.01)
self.plotBlXAxis = np.arange(1000) * (1)
self.plotTrCurve.setData(x=self.plotTrXAxis,y=self.data[2%10],name='C1')
self.plotTrCurve2.setData(x=self.plotTrXAxis,y=self.data[3%10],name='C2')
self.plotBlCurve.setData(x=self.plotBlXAxis,y=self.data[4%10],name='C1')
self.valueTest = 1
app = QtGui.QApplication([])
w = gl.GLViewWidget()
w.show()
w.setWindowTitle('pyqtgraph example: GLSurfacePlot')
w.setCameraPosition(distance=50)
## Add a grid to the view
g = gl.GLGridItem()
g.scale(2,2,1)
g.setDepthValue(10) # draw grid after surfaces since they may be translucent
w.addItem(g)
## Simple surface plot example
## x, y values are not specified, so assumed to be 0:50
z = pg.gaussianFilter(np.random.normal(size=(50,50)), (1,1))
p1 = gl.GLSurfacePlotItem(z=z, shader='shaded', color=(0.5, 0.5, 1, 1))
p1.scale(16./49., 16./49., 1.0)
p1.translate(-18, 2, 0)
w.addItem(p1)
## Saddle example with x and y specified
x = np.linspace(-8, 8, 50)
y = np.linspace(-8, 8, 50)
z = 0.1 * ((x.reshape(50,1) ** 2) - (y.reshape(1,50) ** 2))
p2 = gl.GLSurfacePlotItem(x=x, y=y, z=z, shader='normalColor')
p2.translate(-10,-10,0)
w.addItem(p2)
def __init__(self):
super(Mainwindow, self).__init__()
self.exitAction = QtGui.QAction(QtGui.QIcon('close.png'), 'Exit', self)
self.exitAction.setShortcut('Ctrl+Q')
self.exitAction.setStatusTip('Exit application')
self.exitAction.triggered.connect(self.close)
self.statusBar()
self.menubar = self.menuBar()
self.fileMenu = self.menubar.addMenu('&File')
self.exitMenu = self.menubar.addMenu('&Exit')
#fileMenu.addAction(exitAction1)
#toolbar = self.addToolBar('Exit')
#toolbar.addAction(exitAction)
self.setGeometry(100, 100, 1000, 500)
self.setWindowTitle('BCI System Nanjing University Li Meng')
self.setWindowIcon(QtGui.QIcon('Icon_system.png'))
#---Left Docker
dockWidgetleft =QtGui.QDockWidget("Direction",self)
dockWidgetleft.setAllowedAreas(QtCore.Qt.LeftDockWidgetArea | QtCore.Qt.RightDockWidgetArea)
self.Leftdocker = LeftDockerWidget()
dockWidgetleft.setWidget(self.Leftdocker)
self.addDockWidget(QtCore.Qt.LeftDockWidgetArea, dockWidgetleft)
#---Right Docker
dockWidgetright =QtGui.QDockWidget("Status",self)
dockWidgetright.setAllowedAreas(QtCore.Qt.LeftDockWidgetArea | QtCore.Qt.RightDockWidgetArea)
self.Rightdocker = RightDockerWidget()
dockWidgetright.setWidget(self.Rightdocker)
self.addDockWidget(QtCore.Qt.RightDockWidgetArea, dockWidgetright)
#---Top Docker
dockWidgettop =QtGui.QDockWidget("Tool",self)
dockWidgettop.setAllowedAreas(QtCore.Qt.LeftDockWidgetArea | QtCore.Qt.RightDockWidgetArea)
self.Topdocker = TopDockerWidget()
dockWidgettop.setWidget(self.Topdocker)
self.addDockWidget(QtCore.Qt.TopDockWidgetArea, dockWidgettop)
w = gl.GLViewWidget()
#w.resize(6,800)
w.opts['distance'] = 200
w.setWindowTitle('pyqtgraph example: GLImageItem')
## create volume data set to slice three images from
shape = (100,100,70)
data = pg.gaussianFilter(np.random.normal(size=shape), (4,4,4))
data += pg.gaussianFilter(np.random.normal(size=shape), (15,15,15))*15
## slice out three planes, convert to RGBA for OpenGL texture
levels = (-0.08, 0.08)
tex1 = pg.makeRGBA(data[shape[0]/2], levels=levels)[0] # yz plane
tex2 = pg.makeRGBA(data[:,shape[1]/2], levels=levels)[0] # xz plane
tex3 = pg.makeRGBA(data[:,:,shape[2]/2], levels=levels)[0] # xy plane
v1 = gl.GLImageItem(tex1)
v1.translate(-shape[1]/2, -shape[2]/2, 0)
v1.rotate(90, 0,0,1)
v1.rotate(-90, 0,1,0)
w.addItem(v1)
v2 = gl.GLImageItem(tex2)
v2.translate(-shape[0]/2, -shape[2]/2, 0)
v2.rotate(-90, 1,0,0)
w.addItem(v2)
v3 = gl.GLImageItem(tex3)
v3.translate(-shape[0]/2, -shape[1]/2, 0)
w.addItem(v3)
ax = gl.GLAxisItem()
w.addItem(ax)
self.setCentralWidget(w);
self.resize(1200,500)
w = fc.widget()
layout.addWidget(fc.widget(), 0, 0, 2, 1)
## Create two ImageView widgets to display the raw and processed data with contrast
## and color control.
v1 = pg.ImageView()
v2 = pg.ImageView()
layout.addWidget(v1, 0, 1)
layout.addWidget(v2, 1, 1)
win.show()
## generate random input data
data = np.random.normal(size=(100,100))
data = 25 * pg.gaussianFilter(data, (5,5))
data += np.random.normal(size=(100,100))
data[40:60, 40:60] += 15.0
data[30:50, 30:50] += 15.0
#data += np.sin(np.linspace(0, 100, 1000))
#data = metaarray.MetaArray(data, info=[{'name': 'Time', 'values': np.linspace(0, 1.0, len(data))}, {}])
## Set the raw data as the input value to the flowchart
fc.setInput(dataIn=data)
## At this point, we need some custom Node classes since those provided in the library
## are not sufficient. Each node will define a set of input/output terminals, a
## processing function, and optionally a control widget (to be displayed in the
## flowchart control panel)
win.setCentralWidget(cw)
l = QtGui.QGridLayout()
cw.setLayout(l)
l.setSpacing(0)
v = pg.GraphicsView()
vb = pg.ViewBox()
vb.setAspectLocked()
v.setCentralItem(vb)
l.addWidget(v, 0, 0)
w = pg.HistogramLUTWidget()
l.addWidget(w, 0, 1)
data = pg.gaussianFilter(np.random.normal(size=(256, 256)), (20, 20))
for i in range(32):
for j in range(32):
data[i*8, j*8] += .1
img = pg.ImageItem(data)
#data2 = np.zeros((2,) + data.shape + (2,))
#data2[0,:,:,0] = data ## make non-contiguous array for testing purposes
#img = pg.ImageItem(data2[0,:,:,0])
vb.addItem(img)
vb.autoRange()
w.setImageItem(img)
## Start Qt event loop unless running in interactive mode.
if __name__ == '__main__':
p1 = win.addPlot(row=1, col=0)
p2 = win.addPlot(row=2, col=0)
region = pg.LinearRegionItem()
region.setZValue(10)
# Add the LinearRegionItem to the ViewBox, but tell the ViewBox to exclude this
# item when doing auto-range calculations.
p2.addItem(region, ignoreBounds=True)
#pg.dbg()
p1.setAutoVisible(y=True)
#create numpy arrays
#make the numbers large to show that the xrange shows data from 10000 to all the way 0
data1 = 10000 + 15000 * pg.gaussianFilter(np.random.random(size=10000), 10) + 3000 * np.random.random(size=10000)
data2 = 15000 + 15000 * pg.gaussianFilter(np.random.random(size=10000), 10) + 3000 * np.random.random(size=10000)
p1.plot(data1, pen="r")
p1.plot(data2, pen="g")
p2.plot(data1, pen="w")
def update():
region.setZValue(10)
minX, maxX = region.getRegion()
p1.setXRange(minX, maxX, padding=0)
region.sigRegionChanged.connect(update)
def updateRegion(window, viewRange):
