# -*- coding: utf-8 *-*
from diaGrabber import _utils
import sys
from copy import deepcopy
import pyqtgraph.parametertree.parameterTypes as pTypes
from pyqtgraph.parametertree import Parameter, ParameterTree, ParameterItem, registerParameterType
import pyqtgraph.dockarea as pgDock
from pyqtgraph.Qt import QtGui
from pyqtgraph import ViewBox
from pyqtgraph import LineSegmentROI, AxisItem
[docs]class preferenceDock(object):
def __init__(self, plotClass):
self.plotClass = plotClass
self.exist = False
[docs] def build(self,preferences_size):
self.exist = True
self.size = preferences_size
self.tab = QtGui.QTabWidget()#TabWidget()
#build main tab
self.main = mainTab(self)
#add main tab to tab-instance
self.tab.addTab(self.main, 'Main')
for d in self.plotClass.display_list:
self.addPrefTab(d)
#create new dock
self.pref_dock = pgDock.Dock("Preferences", size=(self.size, 1))
#add tab-instance to dock
self.pref_dock.addWidget(self.tab)
#add dock to area
self.addToArea()
#autosave
self.main.saveWidgetLayout()
[docs] def createNewDisplay(self):
display = self.plotClass._createNewDisplay()
self.addPrefTab(display)
self.addToArea()
#autosave
self.main.saveWidgetLayout()
[docs] def addPrefTab(self,display):
#add a tab owned by its display
display.prefTab = preferenceTab(display, self)
self.tab.addTab(display.prefTab, str(display.index))
[docs] def removeTab(self, tab):
self.tab.removeTab(self.tab.indexOf(tab))
#autosave
self.main.saveWidgetLayout()
[docs] def addToArea(self):
##append parameterTree-instance to dockarea
self.plotClass.area.addDock(self.pref_dock, 'left')
self.pref_dock.setStretch(x=self.size)
[docs]class mainTab(ParameterTree):
def __init__(self, prefDock):
self.plotClass = prefDock.plotClass
super(mainTab, self).__init__()
params = []
params.append({'name': 'Add widget', 'type': 'action'})
params.append(
{'name': 'Save/Restore widget-layout', 'type': 'group', 'children': [
{'name': 'Save', 'type': 'action', 'children': [
{'name': 'Save to file', 'type': 'bool', 'value': False},
{'name': 'Filename', 'type': 'str', 'value': 'preferences/my_widget_layout'},
]},
{'name': 'Restore', 'type': 'action', 'children': [
{'name': 'Restore from file', 'type': 'bool', 'value': False},
{'name': 'Filename', 'type': 'str', 'value': 'preferences/my_widget_layout'},
]},
]})
if self.plotClass.interactive:
params.append(
readoutPlotRates(self.plotClass, name='Readout/Plot-Rates'))
## Create tree of Parameter objects
self.p= Parameter.create(name='params', type='group', children=params)
self.p.param('Add widget').sigActivated.connect(prefDock.createNewDisplay)
self.p.param('Save/Restore widget-layout', 'Save').sigActivated.connect(self.saveWidgetLayout)
self.p.param('Save/Restore widget-layout', 'Restore').sigActivated.connect(self.restoreWidgetLayout)
self.setParameters(self.p, showTop=False)
[docs] def saveWidgetLayout(self):
#global stateWidgetLayout
self.stateWidgetLayout = self.plotClass.area.saveState()
if self.p['Save/Restore widget-layout', 'Save', 'Save to file']:
#write state to file
filename = self.p['Save/Restore widget-layout', 'Save', 'Filename']
_utils.prepareFileSystem(filename)
saveWidgetFile = open(filename, "w")
saveWidgetFile.write(str(self.stateWidgetLayout))
saveWidgetFile.close()
[docs] def restoreWidgetLayout(self):
#global stateWidgetLayout
if self.p['Save/Restore widget-layout', 'Restore', 'Restore from file']:
filename = self.p['Save/Restore widget-layout', 'Restore', 'Filename']
self.stateWidgetLayout = saveWidgetFile = eval(open(filename, "r").read())
self.plotClass.area.restoreState(self.stateWidgetLayout)
[docs]class preferenceTab(ParameterTree):
'''
the preference tab that belongs to each Display
'''
def __init__(self,display, prefDock):
self.plotClass = prefDock.plotClass
self.prefDock = prefDock
self.display = display
super(preferenceTab, self).__init__()
params = []
params = []
params.append({'name': 'Remove widget', 'type': 'action'})
self.plot_merge_dims = plotMergeDims(self, self.display, name='Plot merge-dimensions')
params.append(self.plot_merge_dims)
self.slice_image = sliceImage(self, self.display, name='Slice Image')
params.append(self.slice_image)
self.plot_basis_dims = plotBasisDims(self, self.display, name='Plot basis-dimensions')
params.append(self.plot_basis_dims)
params.append(
viewOptions(self, self.display, name='View Options'))
self.save_restore = saveRestorePrefs(self, name='Save/Restore preferences')
params.append(self.save_restore)
## Create tree of Parameter objects
self.p = Parameter.create(name='params', type='group', children=params)
self.p.param('Remove widget').sigActivated.connect(self.remove)
self.p.sigTreeStateChanged.connect(self.printChange)
self.setParameters(self.p, showTop=False)
#autosave
self.statePreferences = self.p.saveState()
self.showTabOnClick()
## If anything changes in the tree, print a message
[docs] def printChange(self, param, changes):
print("tree changes:")
for param, change, data in changes:
path = self.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(' ----------')
[docs] def remove(self):
self.plotClass._removeDisplay(self.display.index)
self.prefDock.removeTab(self)
[docs] def showTabOnClick(self):
def newMouseClickEvent(ev):
'''add to normal mouseClickEvent the feature
to show the corresponding prefTab when clicking on the display'''
self.prefDock.tab.setCurrentWidget(self)
ViewBox.mouseClickEvent(self.display.view.vb, ev)
self.display.view.mouseClickEvent = newMouseClickEvent
[docs]class saveRestorePrefs(pTypes.GroupParameter):
def __init__(self,prefTab, **opts):#
self.prefTab = prefTab
opts['type'] = 'group'
opts['value'] = True
opts['children'] = [
{'name': 'Save', 'type': 'action'},
{'name': 'Restore', 'type': 'action', 'children': [
{'name': 'Add missing items', 'type': 'bool', 'value': True},
{'name': 'Remove extra items', 'type': 'bool', 'value': True},
]},
]
pTypes.GroupParameter.__init__(self, **opts)
##SAVE PREFERENCES
self.param('Save').sigActivated.connect(self.savePreferences)
self.param('Restore').sigActivated.connect(self.restorePreferences)
[docs] def savePreferences(self):
#global statePreferences
self.prefTab.statePreferences = self.prefTab.p.saveState()
[docs] def restorePreferences(self, sgn,state = None,add_missing_remove_extra=None):
print state,888
if state == None:
state = self.prefTab.statePreferences
if add_missing_remove_extra == None:
#global statePreferences
add = self.param('Restore', 'Add missing items')
rem = self.param('Restore', 'Remove extra items')
else:
add,rem = add_missing_remove_extra,add_missing_remove_extra
self.prefTab.p.restoreState(state, addChildren=add, removeChildren=rem)
[docs]class plotBasisDims(pTypes.GroupParameter):
def __init__(self,prefTab, display, **opts):#
self.display = display
self.prefTab = prefTab
self.concBasisDict = {} #basis_index, concBasis-instance
opts['type'] = 'bool'
opts['value'] = True
pTypes.GroupParameter.__init__(self, **opts)
self.basis_opt = []
for n,b in enumerate(self.display._basis_dim):
plot_basis = b._basisIndex in self.display.show_basis
self.basis_opt.append(self.addChild({'name': b.name, 'type': 'bool', 'value': plot_basis}))
if plot_basis:
self.addPlotRange(n,b)
else:
self.addConcentrateOpt(n,b)
self.param(b.name).sigValueChanged.connect(self.changePlotStatus)
#self.plot_types = self.addChild({'name': 'Available Plot-Types', 'type': 'group'})
#self.setAvailablePlotTypes()
[docs] def addPlotRange(self,n,b):
#print self.parentC.nBasis,9999
#if self.parentC.nBasis == 1:
self.display._changeTitleOpt(b)
self.basis_opt[n].addChild({'name': 'Plot-Range', 'type': 'group', 'children': [
{'name': 'from', 'type': 'int', 'value': 0, 'limits': (0, b.resolution-1)},
{'name': 'to', 'type': 'int', 'value':b.resolution, 'limits': (1, b.resolution-1)},
{'name': 'step', 'type': 'int', 'value': 1, 'limits': (1, b.resolution-1)},
]})
self.param(b.name,'Plot-Range','from').sigValueChanged.connect(self.changePlotRangeFrom)
self.param(b.name,'Plot-Range','to').sigValueChanged.connect(self.changePlotRangeTo)
self.param(b.name,'Plot-Range','step').sigValueChanged.connect(self.changePlotRangeStep)
[docs] def addConcentrateOpt(self,n,b):
self.concBasisDict[b.name] = self.basis_opt[n].addChild(
ConcentrateOpt(n,self.display,b, self.concBasisDict, name='Concentrate-Basis') )
[docs] def changePlotRangeFrom(self):
for n,b in enumerate(self.display._basis_dim):
try:
new = self.param(b.name, 'Plot-Range','from')
#if not new.valueIsDefault():
orig=self.display.basis_dim_plot_range[n]
self.display.basis_dim_plot_range[n] = slice(new.value(),orig.stop,orig.step)
except Exception:#basis-dim isnt active
pass
self.display.update()
[docs] def changePlotRangeTo(self):
for n,b in enumerate(self.display._basis_dim):
try:
new = self.param(b.name, 'Plot-Range','to')
#if not new.valueIsDefault():
orig=self.display.basis_dim_plot_range[n]
self.display.basis_dim_plot_range[n] = slice(orig.start,new.value(),orig.step)
except Exception:#basis-dim isnt active
pass
self.display.update()
[docs] def changePlotRangeStep(self):
for n,b in enumerate(self.display._basis_dim):
try:
new = self.param(b.name, 'Plot-Range','step')
#if not new.valueIsDefault():
orig=self.display.basis_dim_plot_range[n]
self.display.basis_dim_plot_range[n] = slice(orig.start,orig.stop,new.value())
except Exception:#basis-dim isnt active
pass
self.display.update()
[docs] def changePlotStatus(self):
for n,b in enumerate(self.display._basis_dim):
pa = self.param(b.name)
if (not pa.value() and n in self.display.show_basis
and len(self.display.show_basis) ==1):
#dont shut down last (active) dimension
pa.setValue(True, blockSignal=self.changePlotStatus)
else:
#remove all children
self.basis_opt[n].clearChildren()
#max 2 basis-dim to view
if (
(pa.value() and pa.defaultValue()) or
(pa.value() and len(self.display.show_basis) < 2)):
if not pa.value():
pa.setValue(True, blockSignal=self.changePlotStatus)
#print n,self.parentC.show_basis
if n not in self.display.show_basis:
self.display.show_basis.append(n)
self.display.show_basis.sort()#show_basis has to be sorted
self.display.basis_dim_plot_range[n] = slice(None,None,None)
#.parentC.nBasis += 1
self.display.create()
self.prefTab.showTabOnClick()
self.addPlotRange(n,b)
#because 'as-time' will only be shown for2+basis-dims
#it has to be reinitialized
for i,ba in enumerate(self.display._basis_dim):
if i not in self.display.show_basis: # if concentrated
if ba != b:#change only other conc. basis
self.concBasisDict[ba.name].setPAsTime()
else:
if pa.value():
pa.setValue(False, blockSignal=self.changePlotStatus)
if n in self.display.show_basis:
self.display.show_basis.pop(self.display.show_basis.index(n))
#self.display.nBasis -= 1
if len(self.display.show_basis) == 0: #no basis to show
self.param(b.name).setValue(True)
break#do not create concentrato opts if reset to active basis
self.display.create()
self.prefTab.showTabOnClick()
self.display.concentrate_basis_dim[n] = "sum"
self.addConcentrateOpt(n,b)
self.display.scale_plot = True
self.display.update()
#def setAvailablePlotTypes(self):
#self.plot_types.clearChildren()
##sys.exit()
##2d-plot
##if len(self.display.show_basis) == 0:
## self.plot_types.addChild({'name': 'Nothing', 'type': 'bool', 'value': True})
##sys.exit()
#if len(self.display.show_basis) == 1:
#self.linePlot = self.plot_types.addChild({'name': 'Line-Plot', 'type': 'bool', 'value': True})
#self.linePlot.sigValueChanged.connect(self.changeLinePlot)
#self.scatterPlot = self.plot_types.addChild({'name': 'Scatter-Plot', 'type': 'bool', 'value': False})
#self.scatterPlot.sigValueChanged.connect(self.changeScatterPlot)
#elif len(self.display.show_basis) == 2:
#self.plot_types.addChild({'name': '3D-Plot', 'type': 'bool', 'value': True})
#self.plot_types.addChild({'name': 'Image', 'type': 'bool', 'value': False})
#def changeScatterPlot(self):
#if self.scatterPlot.value():
#self.display.plot_type = "scatter"
#self.linePlot.setValue(False, blockSignal=self.changeLinePlot)
#else:
#self.display.plot_type = "line"
#self.linePlot.setValue(True, blockSignal=self.changeLinePlot)
#self.display.create()
#def changeLinePlot(self):
#if self.linePlot.value():
#self.display.plot_type = "line"
#self.scatterPlot.setValue(False, blockSignal=self.changeScatterPlot)
#else:
#self.display.plot_type = "scatter"
#self.scatterPlot.setValue(True, blockSignal=self.changeScatterPlot)
#self.display.create()
[docs]class ConcentrateOpt(pTypes.GroupParameter):
def __init__(self, n,display, b, concBasisDict, **opts):
self.n = n
self.basis = b
self.display = display
self.concBasisDict = concBasisDict
pTypes.GroupParameter.__init__(self, **opts)
self.pMean=self.addChild({'name': 'mean', 'type': 'bool', 'value': True})
self.pSum=self.addChild({'name': 'sum', 'type': 'bool', 'value': False})
self.pMax=self.addChild({'name': 'max', 'type': 'bool', 'value': False})
self.pMin=self.addChild({'name': 'min', 'type': 'bool', 'value': False})
self.pAtPosition=self.addChild({'name': 'at position', 'type': 'int', 'value': -1, 'limits': (-1, self.basis.resolution-1)})
self.pValue=self.addChild({'name': ' value', 'type': 'float', 'value': 0, 'readonly': True})
#self.pAsMerge=self.addChild({'name': '*as merge*', 'type': 'bool', 'value': False})
self.setPAsTime()
self.pAtPosition.sigValueChanged.connect(self.changePlotRangeToPosition)
self.pSum.sigValueChanged.connect(self.concentrateViaSum)
#self.param('sum').connect(self.concentrateViaSum)
self.pMean.sigValueChanged.connect(self.concentrateViaMean)
self.pMin.sigValueChanged.connect(self.concentrateViaMin)
self.pMax.sigValueChanged.connect(self.concentrateViaMax)
#init default
self.concentrateViaMean()
[docs] def setPAsTime(self):
if len(self.display.show_basis) == 2:
#does pAsTime exist?
try:
self.pAsTime.setValue(False) # as standard
except AttributeError: # no: create it
self.pAsTime = self.addChild({'name': 'as time', 'type': 'bool', 'value': False})
self.pAsTime.sigValueChanged.connect(self.changeAsTime)
[docs] def changeAsTime(self):
if self.pAsTime.value() == True:
#set other options to false/default
self.pSum.setValue(False, blockSignal=self.concentrateViaSum)
self.pMean.setValue(False, blockSignal=self.concentrateViaMean)
self.pMin.setValue(False, blockSignal=self.concentrateViaMin)
self.pMax.setValue(False, blockSignal=self.concentrateViaMax)
self.pAtPosition.setToDefault()
#set 'as-time' values of the other conc. basis to false
for i,b in enumerate(self.display._basis_dim):
if i not in self.display.show_basis: # if concentrated
if b != self.basis:#change only other conc. basis
self.concBasisDict[b.name].pAsTime.setValue(False)
#restore plot range
self.display.basis_dim_plot_range[self.n] = slice(None,None,None)
self.display.concentrate_basis_dim[self.n] = "time"
self.display._changeTitleOpt(self.basis, "time")
else:
self.display._changeTitleOpt(self.basis)
if self.pMean.value() == False:
self.pMean.setValue(True)#, blockSignal=self.concentrateViaMean)
self.scale_plot=True
self.display.update()
[docs] def concentrateViaSum(self):
if self.pSum.value() == True:
#set other options to false/default
if len(self.display.show_basis) == 2:
self.pAsTime.setValue(False, blockSignal=self.changeAsTime)
self.pMean.setValue(False, blockSignal=self.concentrateViaMean)
self.pMin.setValue(False, blockSignal=self.concentrateViaMin)
self.pMax.setValue(False, blockSignal=self.concentrateViaMax)
self.pAtPosition.setToDefault()
#restore plot range
self.display.basis_dim_plot_range[self.n] = slice(None,None,None)
self.display.concentrate_basis_dim[self.n] = "sum"
self.display._changeTitleOpt(self.basis, "sum")
else:
self.display._changeTitleOpt(self.basis)
if self.pMean.value() == False:
self.pMean.setValue(True)#, blockSignal=self.concentrateViaMean)
self.scale_plot=True
self.display.update()
[docs] def concentrateViaMean(self):
if self.pMean.value() == True:
#set other options to false/default
self.pSum.setValue(False, blockSignal=self.concentrateViaSum)
self.pMin.setValue(False, blockSignal=self.concentrateViaMin)
self.pMax.setValue(False, blockSignal=self.concentrateViaMax)
self.pAtPosition.setToDefault()
if len(self.display.show_basis) == 2:
self.pAsTime.setValue(False, blockSignal=self.changeAsTime)
#restore plot range
self.display.basis_dim_plot_range[self.n] = slice(None,None,None)
self.display.concentrate_basis_dim[self.n] = "mean"
self.display._changeTitleOpt(self.basis, "mean")
else:
self.display._changeTitleOpt(self.basis)
if self.pSum.value() == False:
self.pSum.setValue(True)#, blockSignal=self.concentrateViaMean)
self.scale_plot=True
self.display.update()
[docs] def concentrateViaMin(self):
if self.pMin.value() == True:
#set other options to false/default
self.pSum.setValue(False, blockSignal=self.concentrateViaSum)
self.pMean.setValue(False, blockSignal=self.concentrateViaMean)
self.pMax.setValue(False, blockSignal=self.concentrateViaMax)
self.pAtPosition.setToDefault()
if len(self.display.show_basis) == 2:
self.pAsTime.setValue(False, blockSignal=self.changeAsTime)
#restore plot range
self.display.basis_dim_plot_range[self.n] = slice(None,None,None)
self.display.concentrate_basis_dim[self.n] = "min"
self.display._changeTitleOpt(self.basis, "min")
else:
self.display._changeTitleOpt(self.basis)
if self.pMean.value() == False:
self.pMean.setValue(True)#, blockSignal=self.concentrateViaMean)
self.scale_plot=True
self.display.update()
[docs] def concentrateViaMax(self):
if self.pMax.value() == True:
#set other options to false/default
self.pSum.setValue(False, blockSignal=self.concentrateViaSum)
self.pMean.setValue(False, blockSignal=self.concentrateViaMean)
self.pMin.setValue(False, blockSignal=self.concentrateViaMin)
self.pAtPosition.setToDefault()
if len(self.display.show_basis) == 2:
self.pAsTime.setValue(False, blockSignal=self.changeAsTime)
#restore plot range
self.display.basis_dim_plot_range[self.n] = slice(None,None,None)
self.display.concentrate_basis_dim[self.n] = "max"
self.display._changeTitleOpt(self.basis, "max")
else:
self.display._changeTitleOpt(self.basis)
if self.pMean.value() == False:
self.pMean.setValue(True)#, blockSignal=self.concentrateViaMean)
self.scale_plot=True
self.display.update()
[docs] def changePlotRangeToPosition(self):
#for n,b in enumerate(self.display._basis_dim):
# if not self.param(b.name).value():
if not self.pAtPosition.valueIsDefault():
position = self.pAtPosition.value()
#get value for position
value=self.display.basisMatrix[self.n][position]
self.pValue.setValue(value)
#set other options to false
self.pSum.setValue(False, blockSignal=self.concentrateViaSum)
self.pMean.setValue(False, blockSignal=self.concentrateViaMean)
self.pMin.setValue(False, blockSignal=self.concentrateViaMin)
self.pMax.setValue(False, blockSignal=self.concentrateViaMax)
if len(self.display.show_basis) == 2:
self.pAsTime.setValue(False, blockSignal=self.changeAsTime)
#set plot range
self.display.basis_dim_plot_range[self.n] = position
self.display.concentrate_basis_dim[self.n] = "pos"
self.display._changeTitleOpt(self.basis, "%.3f" % value)
else:#position is default "-1"
self.pValue.setToDefault()
self.display._changeTitleOpt(self.basis)
if self.pMean.value() == False:
self.pMean.setValue(True)#, blockSignal=self.concentrateViaMean)
self.display.scale_plot = True
self.display.update()
[docs]class sliceImage(pTypes.GroupParameter):
def __init__(self, prefTab, display, **opts):
#self.parentC = parentC
self.display = display
self.prefTab = prefTab
opts['type'] = 'bool'
opts['value'] = False
pTypes.GroupParameter.__init__(self, **opts)
self.activate = self.addChild({'name': 'activate', 'type': 'bool', 'value': False, 'tip': "activate to slice an image - this only works for 2+ active basisDimensions"})
self.activate.sigValueChanged.connect(self.changeActivate)
[docs] def changeActivate(self):
if self.activate.value():
if len(self.display.show_basis) == 1:
self.errorMsg = self.addChild({'name': 'Error', 'type': 'str', 'value': "Need at least two active basisDimensions"})
else:
av_displays= ["-"]
for i in range(1,self.prefTab.prefDock.tab.count()):
#exclude own display-pref-tab
if str(self.display.index) != self.prefTab.prefDock.tab.tabText(i):
av_displays.append(self.prefTab.prefDock.tab.tabText(i) )
if len(av_displays) == 1:
self.which_display = self.addChild({'name': 'Error:', 'type': 'str', 'value': "Add another widget!"})
else:
#value="-"
self.which_display = self.addChild({'name': 'slice to display', 'type': 'list', 'values': av_displays, 'value': av_displays[0]})
self.which_display.sigValueChanged.connect(self.changeWhichDisplay)
#self.which_display = self.addChild(chooseWhichDisplay(self, self.display,self.prefTab.prefDock.tab, name="slice to display") )
else:
try:
self.removeChild(self.errorMsg)
except Exception:
pass # no eror msg to delete
try:
self.removeChild(self.which_display)
#when i'm the master_display
#try: #deslave slave_display
self.slave_display.prefTab.save_restore.restorePreferences(True)
try:
self.slave_display.prefTab.slice_image.removeChild(
self.slave_display.prefTab.slice_image.pSlave)
except Exception:
pass
except Exception:
#cant remove this child, because it does not exist
#this child dont exist because this display is the slice-output(chosendisplay)
##when i'm slave_display:
try:
self.removeChild(self.pSlave)
#show all hidden preferences
self.prefTab.save_restore.restorePreferences(True)
except Exception:
pass
try:
self.display.plot.removeItem(self.display.plot.lineRoi)
except AttributeError:
pass # no roi-line generated so far
try:
self.removeChild(self.which_basis)
except Exception:
pass # no display chosen, so no basis-dimto choose
try: #unblock 'conentrate-opt' of last sliceBasis
self.recentSliceBasis.parent().show()
except Exception: #no last parameter exist
pass
[docs] def changeWhichDisplay(self):
#if a display was chosen
if self.which_display.value() != self.which_display.defaultValue():
#get tab-index from tab-text
self.slave_display = None
for i in range(self.prefTab.prefDock.tab.count()):
if self.prefTab.prefDock.tab.tabText(i) == str(self.which_display.value()):
self.slave_display = self.prefTab.prefDock.tab.widget(i).display
break
if self.slave_display == None:
sys.exit("ERRORsearchcode 23675367")
#transfer the parameter-state from active (master)preference tab to
# preference tab of the chosen display (slave)
masterState = self.prefTab.p.saveState()
slaveState = self.slave_display.prefTab.p.saveState()
slaveState = _utils.adaptMasterStaticsToSlaveDict(masterState,slaveState)
self.slave_display.prefTab.save_restore.restorePreferences(True, slaveState, True)
#save last preferences (to restore, when slave_display is not a slave of self.display)
self.slave_display.prefTab.save_restore.savePreferences()
self.slave_display.prefTab.slice_image.pSlave = self.slave_display.prefTab.slice_image.addChild({'name': 'SLAVE OF Widget', 'type': 'str', 'value': str(self.display.index),'readonly': True})
#hide activate-button - slave can only be unslaved via master
self.slave_display.prefTab.slice_image.activate.hide()
#self.slave_display.prefTab.slice_image.activate.setValue("True", blockSignal=self.slave_display.prefTab.slice_image.changeActivate)
#hide all options which a slave mustn't handle
for c in self.slave_display.prefTab.plot_basis_dims.children():
self.slave_display.prefTab.p.param(
self.slave_display.prefTab.plot_basis_dims.name(),c.name()).hide()
for c in self.slave_display.prefTab.plot_merge_dims.children():
self.slave_display.prefTab.p.param(
self.slave_display.prefTab.plot_merge_dims.name(),c.name()).hide()
for c in self.slave_display.prefTab.save_restore.children():
self.slave_display.prefTab.p.param(
self.slave_display.prefTab.save_restore.name(),c.name()).hide()
try:
self.removeChild(self.which_basis)
except Exception:
pass # no chooseWhichConcBasis-instance to remove
#generate a which-basis list containing all concentrated basis-dims
show_basis = ["-"]
self.basis_name_index={}
for i,b in enumerate(self.slave_display._basis_dim):
if i not in self.slave_display.show_basis:
show_basis.append(b.name)
self.basis_name_index[b.name]= i
if len(show_basis) == 1:
self.which_basis = self.addChild({'name': 'Error:', 'type': 'str', 'value': "No conc. basisDim to show!"})
else:
#value="-"
self.which_basis = self.addChild({'name': "show conc. basis", 'type': 'list', 'values': show_basis, 'value': show_basis[0]})
self.which_basis.sigValueChanged.connect(self.changeWhichBasis)
[docs] def changeWhichBasis(self):
#if basis-dim was chosen
if self.which_basis.value() != self.which_basis.defaultValue():
##add slice-ROI:
thirdLenX = int( len(self.display.basisMatrix[self.display.show_basis[0]])/3 )
halfLenY = int( len(self.display.basisMatrix[self.display.show_basis[1]])/2 )
startX = self.display.basisMatrix[self.display.show_basis[0]][thirdLenX]
startY = self.display.basisMatrix[self.display.show_basis[1]][halfLenY]
stopX = self.display.basisMatrix[self.display.show_basis[0]][-thirdLenX]
stopY = startY#self.display.basisMatrix[self.display.show_basis[1]][-thirdLenY]
#only draw one line - so remove old ones
try:
self.display.plot.removeItem(self.display.plot.lineRoi)
except AttributeError:
pass # no line to remove
#new roi-line
self.display.plot.lineRoi = LineSegmentROI([[startX, startY], [stopX,stopY]], pen='r')
#add new roi-line to plot
self.display.plot.addItem(self.display.plot.lineRoi)
#set chosen concentrated basis to concentrateOption: 'as time'
# thats necassary go get a slice-able-3d-array
try: #unblock 'conentrate-opt' of last sliceBasis
self.recentSliceBasis.parent().show()
except Exception: #no last parameter exist
pass
self.recentSliceBasis = self.prefTab.plot_basis_dims.concBasisDict[
self.which_basis.value()]
self.recentSliceBasis.pAsTime.setValue(True)
self.recentSliceBasis.parent().hide()
#y-axis becoms the new appeared-basis-axis
self.slave_display.show_basis[0] = self.basis_name_index[self.which_basis.value()]
shown_basis = self.slave_display.show_basis[0]
self.slave_display._setAxisLabels()
self.firstAutoRange = True
def updateROIline():
slicedImg = self.display.plot.lineRoi.getArrayRegion(
self.display.merge_extract,
self.display.plot.imageItem, axes=(1,2))
y0=0
yscale=1 # doesn't matter because yAxis wont be shown
x0=self.slave_display._basis_dim[shown_basis]._include_range[0]
x1=self.slave_display._basis_dim[shown_basis]._include_range[1]
xscale = (x1-x0) / self.slave_display._basis_dim[shown_basis].resolution
if self.slave_display.transpose_axes:
p = [y0, x0]
s = [yscale, xscale]
self.slave_display.view.showAxis("bottom", show=False)
else:
p =[x0, y0]
s = [xscale, yscale]
self.slave_display.view.showAxis("left", show=False)
self.slave_display.plot.setImage(slicedImg, autoRange = self.firstAutoRange, pos = p,scale=s)
self.firstAutoRange = False
self.display.plot.lineRoi.sigRegionChanged.connect(updateROIline)
#copy title from masterdisplay
self.slave_display.title_opt = deepcopy(self.display.title_opt)
#change title
appear_basis = self.display._basis_dim[
self.basis_name_index[self.which_basis.value()]]
self.slave_display._changeTitleOpt(appear_basis)
self.slave_display._changeTitleOpt(
self.display._basis_dim[self.display.show_basis[0]],"slice")
self.slave_display._changeTitleOpt(
self.display._basis_dim[self.display.show_basis[1]],"slice")
updateROIline()
[docs]class plotMergeDims(pTypes.GroupParameter):
def __init__(self, prefTab, display, **opts):
#self.parentC = parentC
self.display = display
self.prefTab = prefTab
opts['type'] = 'bool'
opts['value'] = True
pTypes.GroupParameter.__init__(self, **opts)
#self.basis_opt = []
self.mergeToPlot = []
self.asDensity = []
for n,m in enumerate(self.display._merge_dim):
is_merge_in_view = n in self.display.show_merge
#is_merge_in_view = self.parentC.
#plot_basis = b._basisIndex in self.parentC.show_basis
self.mergeToPlot.append(self.addChild({'name': m.name, 'type': 'bool', 'value':is_merge_in_view}))
self.param(m.name).sigValueChanged.connect(self.changePlotMerge)
self.asDensity.append(self.mergeToPlot[-1].addChild({'name': "as density", 'type': 'bool', 'value':False,'enabled':False}))
self.asDensity[-1].sigValueChanged.connect(self.changeAsDensity)
self.changePlotMerge()
[docs] def changePlotMerge(self):
for n,m in enumerate(self.mergeToPlot):
if m.value() == True:
#show_density = False
#if not m.hasChildren():
self.asDensity[n].show()
#else:
# self.asDensity[n].hide()
if n not in self.display.show_merge:
#deactivate all other merges in case of imagePlot
if len(self.display.show_basis) != 1:
for j in self.display.show_merge:
if j != n:
self.mergeToPlot[j].setValue(False, blockSignal=self.changePlotMerge)
self.asDensity[j].hide()
#self.mergeToPlot[j].clearChildren()
self.display.show_merge.pop(self.display.show_merge.index(j))
self.display.show_merge.append(n)
if not m.value():
#if m.hasChildren():
self.asDensity[n].hide()
if n in self.display.show_merge:
#dont remove the last shown merge
if len(self.display.show_merge) == 1:
m.setValue(True)#, blockSignal=self.changePlotMerge)
else:
self.display.show_merge.pop(
self.display.show_merge.index(n))
#self.display.create()
if len(self.display.show_basis) == 1:
self.display._createCurves1D()
#self.prefTab.showTabOnClick()
else:
self.display._setTitle()
self.display.update()
[docs] def changeAsDensity(self):
for n,m in enumerate(self.display._merge_dim):
try:
show_as_density = self.param(m.name, "as density").value()
self.display.show_merge_as_density[n] = show_as_density
if show_as_density:
m.use_unit = "PointDensity"
#self.display.title_additive.append("PointDensity")
else:
m.use_unit = m.unit
#i=self.display.title_additive.index("PointDensity")
#self.display.title_additive.pop(i)
except Exception:#merge not in show_merge
pass
self.display._setTitle()
self.display._setAxisLabels()
self.display.update()
[docs]class viewOptions(pTypes.GroupParameter):
def __init__(self, prefTab, display, **opts):
#self.parentC = parentC
self.display = display
self.prefTab = prefTab
opts['type'] = 'bool'
opts['value'] = True
pTypes.GroupParameter.__init__(self, **opts)
self.lockAspect = self.addChild({'name': "lockAspect", 'type': 'bool', 'value':False})
self.crosshair = self.addChild({'name': "Crosshair", 'type': 'bool', 'value':False})
self.plotOverlay = self.addChild({'name': "PlotOverlay", 'type': 'bool', 'value':False})
self.transposeAxes = self.addChild({'name': 'transpose Axes', 'type': 'bool', 'value': False})
#if len(self.display.show_basis) == 1:
self.autoRangeX = self.addChild({'name': 'autoRange X', 'type': 'bool', 'value': False})
self.autoRangeY = self.addChild({'name': 'autoRange Y', 'type': 'bool', 'value': False})
self.plotOverlay.sigValueChanged.connect(self.changePlotOverlay)
self.transposeAxes.sigValueChanged.connect(self.changeTransposeAxes)
self.lockAspect.sigValueChanged.connect(self.changeLockAspect)
self.autoRangeX.sigValueChanged.connect(self.changeAutoRangeX)
self.autoRangeY.sigValueChanged.connect(self.changeAutoRangeY)
self.crosshair.sigValueChanged.connect(self.changeCrosshair)
[docs] def changeCrosshair(self):
if self.crosshair.value():
self.display._setCrosshair()
else:
self.display._unsetCrosshair()
[docs] def changeTransposeAxes(self):
#self.display._mirrowAxisLabels()
self.display.transpose_axes = self.transposeAxes.value()
self.display.scale_plot = True
self.display._setAxisLabels()
#for n,b in enumerate(self.display._basis_dim):
#try:
#if self.transposeAxes.value() == True:
#self.display.transpose_axes = True
#if len(self.display.show_basis) == 1:
#self.display._mirrowAxisLabels1D()
#else:
#self.display._mirrowAxisLabels2D()
#else:
#self.display.transpose_axes = False
#if len(self.display.show_basis) == 1:
#self.display._restoreAxisLabels1D()
#else:
#self.display._restoreAxisLabels2D()
#except Exception:#basis-dim isnt active
#pass
self.display.update()
[docs] def changePlotOverlay(self):
if self.plotOverlay.value():
self.display.addPlotOverlay()
else:
self.display.removePlotOverlay()
# self.display.enableAutoRangeX = False
self.display.update()
[docs] def changeAutoRangeX(self):
if self.autoRangeX.value():
self.display.enableAutoRangeX = True
else:
self.display.enableAutoRangeX = False
self.display.update()
[docs] def changeAutoRangeY(self):
if self.autoRangeY.value():
self.display.enableAutoRangeY = True
else:
self.display.enableAutoRangeY = False
self.display.update()
[docs] def changeLockAspect(self):
if self.lockAspect.value():
self.display.view.setAspectLocked(True)
else:
self.display.view.setAspectLocked(False)
self.display.scale_plot = True
self.display.update()
[docs]class readoutPlotRates(pTypes.GroupParameter):
def __init__(self,parentC,**opts):#
#self.parentC = parentC
self.parentC = parentC
opts['type'] = 'bool'
opts['value'] = True
pTypes.GroupParameter.__init__(self, **opts)
#self.merge_opt = []
#mergeTogether(name='Together')
self.paramFPS = self.addChild(
{'name': 'Plot frames per second', 'type': 'int', 'value': self.parentC.fps, 'limits': (1, 200)})
self.paramLimitLPS = self.addChild(
{'name': 'Limit readout-rate', 'type': 'bool', 'value': self.parentC.limitReadoutRate}
)
self.changeLimitReadoutRate()
self.readoutEveryNLine = self.addChild(
{'name': 'Readout every n line (+-)', 'type': 'int', 'value': self.parentC.matrixClass._getReadoutEveryNLine()})
self.paramFPS.sigValueChanged.connect(self.changeFPS)
self.paramLimitLPS.sigValueChanged.connect(self.changeLimitReadoutRate)
self.readoutEveryNLine.sigValueChanged.connect(self.changeReadoutEveryNLine)
[docs] def changeFPS(self):
self.parentC._setFPS(self.paramFPS.value())
[docs] def changeLimitReadoutRate(self):
self.parentC.limitReadoutRate = self.paramLimitLPS.value()
if self.paramLimitLPS.value():
self.paramLPS = self.paramLimitLPS.addChild({'name': 'lines per second', 'type': 'int', 'value': self.parentC.lps, 'limits': (0, 100000)})
self.paramLPS.sigValueChanged.connect(self.changeLPS)
self.changeLPS()
else:
self.changeLPS()
try:
self.paramLimitLPS.removeChild(self.paramLPS)
except AttributeError:#paramLPS not defined yet
pass
[docs] def changeLPS(self):
try:
self.parentC._setLPS(self.paramLPS.value())
except AttributeError:#paramLPS not defined jet
self.parentC._setLPS(0)
[docs] def changeReadoutEveryNLine(self):
self.parentC.matrixClass._setReadoutEveryNLine(self.readoutEveryNLine.value())
