def __init__(self, display):
Tool.__init__(self, display)
self._lastVal = [0,0]
pa = self.setParameterMenu()
joy = JoystickButton()
joy.sigStateChanged.connect(self._joystickChanged)
self._menu.content.layout().insertWidget(1,joy)
self.pX = pa.addChild({
'name': 'X',
'type': 'int',
'value':0,})
self._pxChanged = lambda param, val, axis=0: self.pXYChanged(val, axis)
self.pX.sigValueChanged.connect(self._pxChanged)
self.pY = pa.addChild({
'name': 'Y',
'type': 'int',
'value':0,})
self._pyChanged = lambda param, val, axis=1: self.pXYChanged(val, axis)
self.pY.sigValueChanged.connect(self._pyChanged)
pAccept = pa.addChild({
'name': 'Accept',
'type': 'action'})
pAccept.sigActivated.connect(self.acceptChanges)
pReset = pa.addChild({
'name': 'Reset',
'type': 'action'})
pReset.sigActivated.connect(self.resetChanges)
def __init__(self, imageDisplay):
Tool.__init__(self, imageDisplay)
self.calFileTool = self.showGlobalTool(CalibrationFile)
pa = self.setParameterMenu()
self.createResultInDisplayParam(pa, value='[NEW, ADD]')
pB = pa.addChild({
'name':'Balance value range',
'type':'group'})
self.pBFrom = pB.addChild({
'name':'from',
'type':'float',
'value':0.001,
'limits':[0,1]})
self.pBTo = pB.addChild({
'name':'to',
'type':'float',
'value':0.02,
'limits':[0,1]})
self.pn = pa.addChild({
'name':'N steps',
'type':'int',
'value':10,
'limits':[3,1000]})
self.pUpdate = pa.addChild({
'name':'Update Calibration',
'type':'action',
'visible':False})
self.pUpdate.sigActivated.connect(self.updateCalibration)
def __init__(self, imageDisplay):
Tool.__init__(self, imageDisplay)
self.setChecked(True)
self._connected = []
self.interpolator = None
pa = self.setParameterMenu()
pSync = pa.addChild({
'name': 'Synchronize',
'value': 'Display',
'type': 'menu',
'highlight': True
})
pSync.aboutToShow.connect(self._buildLinkView)
pCont = pa.addChild({
'name': 'Continous',
'value': False,
'type': 'bool',
'tip': 'Fade between different images'
})
pCont.sigValueChanged.connect(self.setContinous)
def __init__(self, display):
Tool.__init__(self, display)
self.outDisplay = None
self._method = {
'tenengrad': parameters.tenengrad,
'modifiedLaplacian': parameters.modifiedLaplacian,
'varianceOfLaplacian': parameters.varianceOfLaplacian,
'normalizedGraylevelVariance':
parameters.normalizedGraylevelVariance
}
pa = self.setParameterMenu()
self.pLayer = pa.addChild({
'name': 'apply on',
'type': 'list',
'value': 'all layers',
'limits': ['all layers', 'last layer']
})
self.pNewDisplay = pa.addChild({
'name': 'create new display',
'type': 'bool',
'value': False
})
self.pMethod = pa.addChild({
'name': 'method',
'type': 'list',
'value': 'tenengrad',
'limits': self._method.keys()
})
def __init__(self, imageDisplay):
Tool.__init__(self, imageDisplay)
pa = self.setParameterMenu()
self.createResultInDisplayParam(pa)
self.pSize = pa.addChild({
'name': 'Size',
'type': 'int',
'value': 30,
'limits': [5, 1000]
})
self.pSetEvery = pa.addChild({
'name':
'Set every',
'type':
'bool',
'value':
False,
'tip':
'Otherwise value calculated as size/3.5'
})
self.pEvery = self.pSetEvery.addChild({
'name': 'value',
'type': 'int',
'value': 10,
'limits': [5, 1000],
'visible': False
})
self.pSetEvery.sigValueChanged.connect(
lambda p, v: self.pEvery.show(v))
def __init__(self, imageDisplay):
Tool.__init__(self, imageDisplay)
self._refImg = None
pa = self.setParameterMenu()
self._methods = {
# NAME: (FUNCTION, HISTOGRAM LEVELS)
"Reference image": (lambda x: scaleSignal(x, reference=self._refImg), None),
"Equalize histogram": (equalizeImage, None),
"Scale Background-Signal: 0-1": (lambda x: scaleSignal(x, backgroundToZero=True), [0, 1]),
"Scale signal +/-3std": (scaleSignal, [0, 1]),
"Maximum=1": (lambda img: img / np.nanmax(img), None),
"Average=1": (lambda img: img / np.nanmean(img), None),
"Minimum=0, Maximum=1": (self._scaleMinMax, [0, 1]),
}
self.pMethod = pa.addChild(
{"name": "Method", "type": "list", "value": "Scale signal +/-3std", "limits": list(self._methods.keys())}
)
self.pRefImgChoose = self.pMethod.addChild(
{"name": "Reference image", "value": "From display", "type": "menu", "visible": False}
)
self.pRefImg = self.pRefImgChoose.addChild({"name": "Chosen", "value": "-", "type": "str", "readonly": True})
self.pRefImgChoose.aboutToShow.connect(lambda menu: self.buildOtherDisplayLayersMenu(menu, self._setRefImg))
self.pMethod.sigValueChanged.connect(lambda p, v: self.pRefImgChoose.show(v == "Reference image"))
def __init__(self, display):
Tool.__init__(self, display)
self.outDisplay = None
self._method = {
'tenengrad': parameters.tenengrad,
'modifiedLaplacian': parameters.modifiedLaplacian,
'varianceOfLaplacian': parameters.varianceOfLaplacian,
'normalizedGraylevelVariance': parameters.normalizedGraylevelVariance
}
pa = self.setParameterMenu()
self.pLayer = pa.addChild({
'name': 'apply on',
'type': 'list',
'value': 'all layers',
'limits': ['all layers', 'last layer']})
self.pNewDisplay = pa.addChild({
'name': 'create new display',
'type': 'bool',
'value': False})
self.pMethod = pa.addChild({
'name': 'method',
'type': 'list',
'value': 'tenengrad',
'limits': list(self._method.keys())})
def __init__(self, display):
Tool.__init__(self, display)
pa = self.setParameterMenu()
# make some space for the color layer names:
# try:
self._menu.pTree.header().setResizeMode(QtWidgets.QHeaderView.Fixed)
# except AttributeError:
# self._menu.pTree.header().setSectionResizeMode(QtWidgets.QHeaderView.Fixed)
self._menu.pTree.setColumnWidth(0, 220)
self._menu.pTree.setColumnWidth(1, 20)
self.pAdd = pa.addChild({
'name': 'add',
'value': 'from display',
'type': 'menu'
})
self.pAdd.aboutToShow.connect(self.buildAddMenu)
pa.sigChildRemoved.connect(self.removeLayer)
w = self.display.widget
w.sigOverlayAdded.connect(self.addLayerControl)
w.sigOverlayRemoved.connect(self.removeLayerControl)
def __init__(self, display):
Tool.__init__(self, display)
self.scene = self.display.widget.view.scene()
self.rulers = []
self.rulersLen = []
self.scale = 1
self.scaleEditor = _ScaleEditor(self)
p = self.setParameterMenu()
pShow = p.addChild({"name": "Show", "type": "bool", "value": True})
pShow.sigValueChanged.connect(self.toggleShow)
self.pAngle = p.addChild({"name": "Show angle", "type": "bool", "value": False})
self.pColor = p.addChild({"name": "Color", "type": "color", "value": (255, 0, 0, 130)})
self.pSetScale = p.addChild({"name": "Set Scale", "type": "bool", "value": False})
self.pRatio = self.pSetScale.addChild(
{"name": "Aspect Ratio = 1", "type": "bool", "value": True, "visible": False}
)
self.pSetScale.sigValueChanged.connect(lambda param, val: [ch.show(val) for ch in param.children()])
pReset = p.addChild({"name": "reset", "type": "action", "value": True})
pReset.sigActivated.connect(self.reset)
def __init__(self, display):
Tool.__init__(self, display)
self.timer = QtCore.QTimer()
self.timer.timeout.connect(self._grabImage)
self.firstTime = True
pa = self.setParameterMenu()
self.pGrayscale = pa.addChild({
'name': 'Grayscale',
'type': 'bool',
'value': True})
self.pFloat = pa.addChild({
'name': 'To float',
'type': 'bool',
'value': True})
pFrequency = pa.addChild({
'name': 'Read frequency [Hz]',
'type': 'float',
'value': 20.0,
'limits':[0,1000]})
pFrequency.sigValueChanged.connect(self._setInterval)
self._setInterval(pFrequency, pFrequency.value())
self.pBuffer = pa.addChild({
'name': 'Buffer last n images',
'type': 'int',
'value': 0})
def __init__(self, imageDisplay):
Tool.__init__(self, imageDisplay)
pa = self.setParameterMenu()
self.createResultInDisplayParam(pa)
self.pSize = pa.addChild({
'name':'Size',
'type':'int',
'value':3,
'limits':[1, 1000]})
self.pThreshold = pa.addChild({
'name':'Threshold',
'type':'float',
'value':0.2,
'tip': 'ratio to exceed to be filtered'})
self.pCondition = pa.addChild({
'name':'Condition',
'type':'list',
'value':'>',
'limits': ['>', '<']})
self.pAddChangesLayer = pa.addChild({
'name':'Add changes layer',
'type':'bool',
'value':True})
def __init__(self, display):
Tool.__init__(self, display)
display.sigLayerChanged.connect(self._check)
display.sigNewLayer.connect(self._check)
pa = self.setParameterMenu()
pa.addChild({
'name': 'Separate color channels',
'type': 'action'
}).sigActivated.connect(self.separate)
pa.addChild({
'name': 'RG chromaticity',
'type': 'action',
'tip': rgChromaticity.__doc__
}).sigActivated.connect(self._chromaticity)
pa.addChild({
'name': 'Monochromatic wavelength',
'type': 'action',
'tip': monochromaticWavelength.__doc__
}).sigActivated.connect(self._monochromaticWavelength)
self.createResultInDisplayParam(pa, value='[ALLWAYS NEW]')
self._check()
def __init__(self, imageDisplay):
Tool.__init__(self, imageDisplay)
pa = self.setParameterMenu()
self.pSizeX = pa.addChild({
'name': 'X-size',
'type': 'int',
'value':300,
'limits':[1,1e6]})
self.pSizeY = pa.addChild({
'name': 'Y-size',
'type': 'int',
'value':300,
'limits':[1,1e6]})
self.pObject = pa.addChild({
'name': 'Object',
'type': 'list',
'limits':['current image', 'current color layer']})
self.pCriterion = pa.addChild({
'name': 'Criterion',
'type': 'list',
'limits':['==', '>', '<']})
self.pValue = pa.addChild({
'name': 'Value',
'type': 'float',
'value': 100})
def __init__(self, display):
Tool.__init__(self, display)
pa = self.setParameterMenu()
self.pMask = pa.addChild({
'name': 'Pixel mask from color layer',
'type': 'list',
'value': '',
'limits': []
})
self.pMaxPlots = pa.addChild({
'name': 'Max n plots',
'type': 'int',
'value': 100,
'min': 1
})
self.pDivideBG = pa.addChild({
'name': 'Divide background',
'type': 'bool',
'value': True
})
self.pBgSize = pa.addChild({
'name': 'Background median kernel size',
'type': 'int',
'value': 3,
'min': 1
})
self._menu.aboutToShow.connect(self._setPixelMaskOptions)
def __init__(self, display):
Tool.__init__(self, display)
self._refImg = None
pa = self.setParameterMenu()
self.createResultInDisplayParam(pa)
self.pOperation = pa.addChild({
'name':'Operation',
'type':'list',
'value':'fit',
'limits':['add', 'fit']})
self.pExecOn = pa.addChild({
'name':'Execute on',
'type':'list',
'value':'all images',
'limits':['all images', 'last image']})
pRefImgChoose = pa.addChild({
'name':'reference image',
'value':'from display',
'type':'menu'})
self.pRefImg = pRefImgChoose.addChild({
'name':'chosen',
'value':'-',
'type':'str',
'readonly':True})
pRefImgChoose.aboutToShow.connect(lambda menu:
self.buildOtherDisplayLayersMenu(menu, self._setRefImg) )
def __init__(self, display):
Tool.__init__(self, display)
self.timer = QtCore.QTimer()
self.timer.timeout.connect(self._grabImage)
self.firstTime = True
pa = self.setParameterMenu()
self.pGrayscale = pa.addChild({
'name': 'Grayscale',
'type': 'bool',
'value': True})
self.pFloat = pa.addChild({
'name': 'To float',
'type': 'bool',
'value': True})
pFrequency = pa.addChild({
'name': 'Read frequency [Hz]',
'type': 'float',
'value': 20.0,
'limits': [0, 1000]})
pFrequency.sigValueChanged.connect(self._setInterval)
self._setInterval(pFrequency, pFrequency.value())
self.pBuffer = pa.addChild({
'name': 'Buffer last n images',
'type': 'int',
'value': 0})
def __init__(self, display):
Tool.__init__(self, display)
pa = self.setParameterMenu()
self.pMask = pa.addChild({
'name':'Pixel mask from color layer',
'type':'list',
'value':'',
'limits':[]})
self.pMaxPlots = pa.addChild({
'name':'Max n plots',
'type':'int',
'value':100,
'limits':[1,1e5]})
self.pDivideBG = pa.addChild({
'name':'Divide background',
'type':'bool',
'value':True})
self.pBgSize = pa.addChild({
'name':'Background median kernel size',
'type':'int',
'value':3,
'limits':[1,1e5]})
self._menu.aboutToShow.connect(self._setPixelMaskOptions)
def __init__(self, imageDisplay):
Tool.__init__(self, imageDisplay)
# self._linked_display = None
self.setChecked(self.display.widget.view.vb.state['aspectLocked'])
pa = self.setParameterMenu()
pSync = pa.addChild({
'name': 'Synchronize',
'value': 'Display',
'type': 'menu',
'highlight': True
})
pSync.aboutToShow.connect(self._buildLinkView)
pRange = pa.addChild({
'name':
'autoRange',
'type':
'bool',
'value':
True,
'tip':
'''whether to fit view every time the input changes'''
})
pRange.sigValueChanged.connect(
lambda param, value: self.display.widget.setOpts(autoRange=value))
def __init__(self, imageDisplay):
Tool.__init__(self, imageDisplay)
pa = self.setParameterMenu()
self.createResultInDisplayParam(pa)
self.pSize = pa.addChild({
'name': 'Size',
'type': 'int',
'value': 3,
'min': 1
})
self.pThreshold = pa.addChild({
'name': 'Threshold',
'type': 'float',
'value': 0.2,
'tip': 'ratio to exceed to be filtered'
})
self.pCondition = pa.addChild({
'name': 'Condition',
'type': 'list',
'value': '>',
'limits': ['>', '<']
})
self.pAddChangesLayer = pa.addChild({
'name': 'Add changes layer',
'type': 'bool',
'value': True
})
def __init__(self, imageDisplay):
Tool.__init__(self, imageDisplay)
self.calFileTool = self.showGlobalTool(CalibrationFile)
pa = self.setParameterMenu()
self.createResultInDisplayParam(pa, value='[NEW, ADD]')
pB = pa.addChild({'name': 'Balance value range', 'type': 'group'})
self.pBFrom = pB.addChild({
'name': 'from',
'type': 'float',
'value': 0.001,
'limits': [0, 1]
})
self.pBTo = pB.addChild({
'name': 'to',
'type': 'float',
'value': 0.02,
'limits': [0, 1]
})
self.pn = pa.addChild({
'name': 'N steps',
'type': 'int',
'value': 10,
'limits': [3, 1000]
})
self.pUpdate = pa.addChild({
'name': 'Update Calibration',
'type': 'action',
'visible': False
})
self.pUpdate.sigActivated.connect(self.updateCalibration)
def __init__(self, imageDisplay):
Tool.__init__(self, imageDisplay)
_import()
self.calFileTool = self.showGlobalTool(CalibrationFile)
self.pa = self.setParameterMenu()
self._bg = None
self._method = None
self._inter, self._slope = None, None
pMeasure = self.pa.addChild({
'name': 'Calculate calibration array ...',
'type': 'empty'
})
self.createResultInDisplayParam(pMeasure)
self.pMethod = pMeasure.addChild({
'name': 'Method',
'type': 'list',
'value': 'as function',
'limits': ['average', 'as function']
})
pMeasure.addChild({
'name': 'Exposure times [s]',
'type': 'str',
'value': '... are taken from layer value',
'readonly': True
})
pFromDisplay = self.pa.addChild({
'name': 'Load calibration array ...',
'type': 'empty'
})
pFromDisplay.addChild({
'name': 'Intercept',
'type': 'menu',
'value': 'from display'
}).aboutToShow.connect(
lambda m, fn=self._interceptfromDisplay: self.
buildOtherDisplayLayersMenu(m, fn, includeThisDisplay=True))
pFromDisplay.addChild({
'name': 'Slope',
'type': 'menu',
'value': 'from display'
}).aboutToShow.connect(
lambda m, fn=self._slopefromDisplay: self.
buildOtherDisplayLayersMenu(m, fn, includeThisDisplay=True))
self.pUpdate = self.pa.addChild({
'name': 'Update calibration',
'type': 'action',
'visible': False
})
self.pUpdate.sigActivated.connect(self.updateCalibration)
def __init__(self, imageDisplay):
Tool.__init__(self, imageDisplay)
self.calFileTool = self.showGlobalTool(CalibrationFile)
self.camera = None
self.outDisplay = None
self.outDisplay2 = None
self._refDisplay = None
pa = self.setParameterMenu()
self.pRef = pa.addChild({
'name': 'Reference images',
'type': 'list',
'value': 'None',
'limits': ['None', 'From display', 'Every 2nd'],
'tip': 'Images of the same setup taken at the same exposure time'})
self.pRefFromDisplay = self.pRef.addChild({
'name': 'From display',
'type': 'menu',
'value': '[Choose]',
'visible': False})
self.pRefFromDisplay.aboutToShow.connect(self._buildRefFromDisplayMenu)
self.pRef.sigValueChanged.connect(lambda param, val:
self.pRefFromDisplay.show(val == 'From display'))
self.pPlotResult = pa.addChild({
'name': 'Plot NLF',
'type': 'bool',
'value': True})
self.pRange = pa.addChild({
'name': 'Set intensity range',
'type': 'bool',
'value': False})
self.pMin = self.pRange.addChild({
'name': 'Minimum',
'type': 'int',
'visible': False,
'value': 0})
self.pMax = self.pRange.addChild({
'name': 'Maximum',
'type': 'int',
'visible': False,
'value': 65000})
self.pRange.sigValueChanged.connect(lambda param, val:
[ch.show(val) for ch in self.pRange.childs])
self.pUpdate = pa.addChild({
'name': 'Update calibration',
'type': 'action',
'visible': False})
self.pUpdate.sigActivated.connect(self.updateCalibration)
def __init__(self, imageDisplay):
Tool.__init__(self, imageDisplay)
self.calFileTool = self.showGlobalTool(CalibrationFile)
self.camera = None
self.outDisplay = None
self.outDisplay2 = None
self._refDisplay = None
pa = self.setParameterMenu()
self.pRef = pa.addChild({
'name': 'Reference images',
'type': 'list',
'value':'None',
'limits': ['None', 'From display', 'Every 2nd'],
'tip':'Images of the same setup taken at the same exposure time'})
self.pRefFromDisplay = self.pRef.addChild({
'name':'From display',
'type':'menu',
'value':'[Choose]',
'visible':False})
self.pRefFromDisplay.aboutToShow.connect(self._buildRefFromDisplayMenu)
self.pRef.sigValueChanged.connect(lambda param, val:
self.pRefFromDisplay.show(val=='From display'))
self.pPlotResult = pa.addChild({
'name': 'Plot NLF',
'type': 'bool',
'value':True})
self.pRange = pa.addChild({
'name':'Set intensity range',
'type':'bool',
'value':False})
self.pMin = self.pRange.addChild({
'name':'Minimum',
'type':'int',
'visible':False,
'value':0})
self.pMax = self.pRange.addChild({
'name':'Maximum',
'type':'int',
'visible':False,
'value':65000})
self.pRange.sigValueChanged.connect(lambda param, val:
[ch.show(val) for ch in self.pRange.childs])
self.pUpdate = pa.addChild({
'name':'Update calibration',
'type':'action',
'visible':False})
self.pUpdate.sigActivated.connect(self.updateCalibration)
def __init__(self, plotDisplay):
Tool.__init__(self, plotDisplay)
pa = self.setParameterMenu()
self._menu.aboutToShow.connect(self._updateMenu)
p = pa.addChild({'name': '[All]', 'type': 'int', 'value': 1})
p.sigValueChanged.connect(self._pAllChanged)
def __init__(self, display):
Tool.__init__(self, display)
self._linked_display = None
self._menu = QtWidgets.QMenu()
self.setMenu(self._menu)
self._menu.aboutToShow.connect(self._buildMenu)
def __init__(self, imageDisplay):
Tool.__init__(self, imageDisplay)
#speed-up start
from scipy.ndimage.filters import median_filter, gaussian_filter, \
maximum_filter, minimum_filter
from skimage.restoration import nl_means_denoising
self.FILTER = {'median':median_filter,
'Gaussian':gaussian_filter,
'maximum':maximum_filter,
'minimum':minimum_filter,
'Non-local means':nl_means_denoising}
pa = self.setParameterMenu()
self.createResultInDisplayParam(pa)
self.pType = pa.addChild({
'name':'Type',
'type':'list',
'limits':self.FILTER.keys(),
'value':'median'})
self.pSeparate = pa.addChild({
'name':'Filter layers separate',
'type':'bool',
'value':True})
self.pSize = pa.addChild({
'name':'size',
'type':'int',
'value':3,
'limits':[1, 1000]})
self.pMode = pa.addChild({
'name':'mode',
'type':'list',
'limits':['reflect', 'constant', 'nearest', 'mirror', 'wrap'],
'value':'reflect'})
self.pCVal = pa.addChild({
'name':'cval',
'type':'float',
'value':0.0,
'limits':[0, 1000]})
self.pOrigin = pa.addChild({
'name':'origin',
'type':'int',
'value':0,
'limits':[0, 1000]})
self.pAddChangesLayer = pa.addChild({
'name':'Add changes layer',
'type':'bool',
'value':False})
def __init__(self, display):
Tool.__init__(self, display)
self._linked_displays = []
self._actions = []
self._menu = QtGui.QMenu()
self.setMenu(self._menu)
self._menu.aboutToShow.connect(self._buildMenu)
def __init__(self, display):
Tool.__init__(self, display)
self._linked_displays = []
self._actions = []
self._menu = QtGui.QMenu()
self.setMenu(self._menu)
self._menu.aboutToShow.connect(self._buildMenu)
def __init__(self, display):
Tool.__init__(self, display)
pa = self.setParameterMenu()
self.pSharp = pa.addChild({
'name': 'Equalize sharpness',
'type': 'bool',
'value': True})
def __init__(self, display):
Tool.__init__(self, display)
self._d = None
pa = self.setParameterMenu()
self.pX = pa.addChild({"name": "x", "type": "list"})
self.pY = pa.addChild({"name": "y", "type": "list"})
self._menu.aboutToShow.connect(self._buildMenu)
def __init__(self, imageDisplay):
Tool.__init__(self, imageDisplay)
self.display.showToolBar('Measurement')
pa = self.setParameterMenu()
self.createResultInDisplayParam(pa)
self.pParamFromName = pa.addChild({
'name': 'Get parameters from filename',
'type': 'bool',
'value': True,
'tip': '''Read voltage, current, temperature from filename
Filename has to have to following formating:
...
_e[EXPOSURE TIME IN MS]
_V[VOLTAGE in V]
_I[CURRENT IN A]
_T[TEMPERATURE in DEG C]...
float point number are written like that:
'0-015' for 0.015
'''})
self.pParamFromName.sigValueChanged.connect(lambda p, v:
[ch.show(not(v))
for ch in p.childs])
for name in ('First image', 'Second image'):
ch = self.pParamFromName.addChild({
'name': name,
'type': 'empty',
'highlight': True,
'visible': False})
ch.addChild({
'name': 'Exposure time',
'type': 'float',
'suffix': 's',
'siPrefix': True,
'value': 10})
ch.addChild({
'name': 'Voltage',
'type': 'float',
'suffix': 'V',
'siPrefix': True,
'value': 10})
ch.addChild({
'name': 'Current',
'type': 'float',
'suffix': 'A',
'siPrefix': True,
'value': 10})
ch.addChild({
'name': 'Temperature',
'type': 'float',
'suffix': 'DEG C',
'siPrefix': True,
'value': 20})
def __init__(self, display):
Tool.__init__(self, display)
self.setChecked(True)
self._linked_displays = []
self._actions = []
w = self.display.widget
pa = self.setParameterMenu()
pSync = pa.addChild({
'name':'Synchronize',
'value':'Display',
'type':'menu',
'highlight':True
})
pSync.aboutToShow.connect(self._buildLinkColorbar)
pFit = pa.addChild({
'name': 'Fit',
'type': 'action'})
pFit.sigActivated.connect(self._fit)
pLevels = pa.addChild({
'name': 'autoLevels',
'type': 'bool',
'value':w.opts['autoLevels']})
pLevels.sigValueChanged.connect(lambda param, value:
w.setOpts(autoLevels=value))
pRange = pa.addChild({
'name': 'autoHistogramRange',
'type': 'bool',
'value':w.opts['autoHistogramRange']})
pRange.sigValueChanged.connect(lambda param, value:
w.setOpts(autoHistogramRange=value))
self.pPrintView = pa.addChild({
'name': 'print view',
'type': 'bool',
'value':False})
self.pPrintView.sigValueChanged.connect(lambda param, value:
w.setHistogramPrintView(value, pShowHist.value()))
pShowHist = self.pPrintView.addChild({
'name': 'show histogram',
'type': 'bool',
'value':False})
pShowHist.sigValueChanged.connect(self._pShowHistChanged)
pLog = pa.addChild({
'name': 'Transform to base 10 logarithm',
'tip':'The absolute is taken to include negative values as well',
'type': 'action'})
pLog.sigActivated.connect(self._log10)
def __init__(self, imageDisplay):
Tool.__init__(self, imageDisplay)
self.methods = {
'absolute':self._absolute,
# 'relative':self._relative,
'positive':self._pos,
'negative':self._neg}
pa = self.setParameterMenu()
self.pRefLayer = pa.addChild({
'name': 'Reference Image',
'type': 'list',
'limits':[]})
self._menu.aboutToShow.connect(
lambda: self.pRefLayer.setLimits(self.display.layerNames()))
self.pMethod = pa.addChild({
'name': 'Method',
'type': 'list',
'limits':['absolute','positive', 'negative'] })
self.pAlpha = pa.addChild({
'name': 'Alpha',
'type': 'float',
'value':1,
'limits':[0,1]})
self.pFilter = pa.addChild({
'name': 'Filter values',
'type': 'bool',
'value':False})
self.pFilter.sigValueChanged.connect(lambda p,v:
[ch.show(v) for ch in p.childs])
self.pFilterRelative = self.pFilter.addChild({
'name': 'relative values',
'type': 'bool',
'value':False,
'visible':False,
'tip': 'True: filter values from 0 to 1 (100%)-max.value; False: absolute values'})
self.pFilterRelative.sigValueChanged.connect(self._filterRelativeChanged )
self.pFilterFrom = self.pFilter.addChild({
'name': 'From',
'type': 'float',
'value':0,
'visible':False,
'limits':[0,1] })
self.pFilterTo = self.pFilter.addChild({
'name': 'To',
'type': 'float',
'value':1,
'visible':False,
'limits':[0,1] })
def __init__(self, display):
Tool.__init__(self, display)
self.setChecked(True)
self._linked_displays = []
self._actions = []
w = self.display.widget
pa = self.setParameterMenu()
pSync = pa.addChild({
'name': 'Synchronize',
'value': 'Display',
'type': 'menu',
'highlight': True
})
pSync.aboutToShow.connect(self._buildLinkColorbar)
pFit = pa.addChild({
'name': 'Fit',
'type': 'action'})
pFit.sigActivated.connect(self._fit)
pLevels = pa.addChild({
'name': 'autoLevels',
'type': 'bool',
'value': w.opts['autoLevels']})
pLevels.sigValueChanged.connect(lambda param, value:
w.setOpts(autoLevels=value))
pRange = pa.addChild({
'name': 'autoHistogramRange',
'type': 'bool',
'value': w.opts['autoHistogramRange']})
pRange.sigValueChanged.connect(lambda param, value:
w.setOpts(autoHistogramRange=value))
self.pPrintView = pa.addChild({
'name': 'print view',
'type': 'bool',
'value': False})
self.pPrintView.sigValueChanged.connect(lambda param, value:
w.setHistogramPrintView(value, pShowHist.value()))
pShowHist = self.pPrintView.addChild({
'name': 'show histogram',
'type': 'bool',
'value': False})
pShowHist.sigValueChanged.connect(self._pShowHistChanged)
pLog = pa.addChild({
'name': 'Transform to base 10 logarithm',
'tip': 'The absolute is taken to include negative values as well',
'type': 'action'})
pLog.sigActivated.connect(self._log10)
def __init__(self, imageDisplay):
Tool.__init__(self, imageDisplay)
pa = self.setParameterMenu()
self.pMax = pa.addChild({
'name': 'Max plots',
'value': 20,
'type': 'int',
'min': 0})
def __init__(self, imageDisplay):
Tool.__init__(self, imageDisplay)
pa = self.setParameterMenu()
self.pMax = pa.addChild({
'name': 'Max plots',
'value': 20,
'type': 'int',
'limits': (0, 1e6)})
def __init__(self, plotDisplay):
Tool.__init__(self, plotDisplay)
pa = self.setParameterMenu()
self.pReference = pa.addChild({
'name':'Reference',
'type':'list',
'value':'min-max',
'limits':['min-max', 'mean+-3*std']})
def __init__(self, plotDisplay):
Tool.__init__(self, plotDisplay)
pa = self.setParameterMenu()
self._menu.aboutToShow.connect(self._updateMenu)
p = pa.addChild({
'name': '[All]',
'type': 'int',
'value': 1})
p.sigValueChanged.connect(self._pAllChanged)
def __init__(self, imageDisplay):
Tool.__init__(self, imageDisplay)
pa = self.setParameterMenu()
self.createResultInDisplayParam(pa)
self.pSize = pa.addChild({
'name':'Size',
'type':'int',
'value':30,
'limits':[5, 1000]})
def __init__(self, display):
Tool.__init__(self, display)
self.n_slices = 0
self._ROIs = []
a_show = QtWidgets.QAction('show', self)
a_show.setCheckable(True)
a_show.setChecked(True)
a_show.toggled.connect(self.toggleShow)
self.addAction(a_show)
def __init__(self, plotDisplay):
Tool.__init__(self, plotDisplay)
pa = self.setParameterMenu()
self.pReference = pa.addChild({
'name': 'Reference',
'type': 'list',
'value': 'min-max',
'limits': ['min-max', 'mean+-3*std']
})
def __init__(self, display):
Tool.__init__(self, display)
self.n_slices = 0
self._ROIs = []
a_show = QtWidgets.QAction('show', self)
a_show.setCheckable(True)
a_show.setChecked(True)
a_show.toggled.connect(self.toggleShow)
self.addAction(a_show)
def __init__(self, plotDisplay):
Tool.__init__(self, plotDisplay)
self.guess = None
pa = self.setParameterMenu()
self.pPlot = pa.addChild({
'name': 'Plot',
'type': 'list',
'value': 'All'
})
XVals = pa.addChild({
'name': 'X values',
'type': 'empty',
'highlight': True
})
self.pXFrom = XVals.addChild({
'name': 'From',
'type': 'float',
'value': 0
})
self.pXTo = XVals.addChild({
'name': 'To',
'type': 'float',
'value': 100
})
self.pXN = XVals.addChild({
'name': 'Number',
'type': 'int',
'value': 100,
'limits': [2, 10000]
})
self.pMethod = pa.addChild({
'name': 'Method',
'type': 'list',
'value': 'Poisson',
'limits': ['Poisson']
})
pManual = pa.addChild({
'name': 'Manually set initial guess',
'type': 'action'
})
pManual.sigActivated.connect(self._manualSetInitGuess)
self._menu.aboutToShow.connect(self._updateMenu)
def __init__(self, display):
Tool.__init__(self, display)
self._d = None
pa = self.setParameterMenu()
self.pX = pa.addChild({
'name':'x',
'type':'list'})
self.pY = pa.addChild({
'name':'y',
'type':'list'})
self._menu.aboutToShow.connect(self._buildMenu)
def __init__(self, display):
Tool.__init__(self, display)
self._d = None
pa = self.setParameterMenu()
self.pX = pa.addChild({
'name': 'x',
'type': 'list'})
self.pY = pa.addChild({
'name': 'y',
'type': 'list'})
self._menu.aboutToShow.connect(self._buildMenu)
def __init__(self, plotDisplay):
Tool.__init__(self, plotDisplay)
pa = self.setParameterMenu()
self._menu.aboutToShow.connect(self._updateMenu)
#self._menu.aboutToHide.connect(self.clear)
p = pa.addChild({
'name':'[All]',
'type':'list',
'value': 'SolidLine',
'limits':ENUM2STYLE.values()})
p.sigValueChanged.connect(self._pAllChanged)
def __init__(self, display):
Tool.__init__(self, display)
# OUTPUT DISPLAYS:
self.reconstructedDisplay = None
self.fourierDisplay = None
self.procFourierDisplay = None
self.differenceDisplay = None
# MENU:
pa = self.setParameterMenu()
pUpdate = pa.addChild({"name": "Update", "type": "action"})
pUpdate.sigActivated.connect(self.activate)
self.pHighPass = pa.addChild({"name": "High pass", "type": "slider", "value": 0, "limits": [0, 1]})
self.pLowPass = pa.addChild({"name": "Low pass", "type": "slider", "value": 0, "limits": [0, 1]})
pFilterValues = pa.addChild({"name": "Filter values", "type": "group"})
self.pSmallerThreshold = pFilterValues.addChild(
{"name": "smaller than", "type": "slider", "value": 0, "limits": [0, 1]}
)
self.pBiggerThreshold = pFilterValues.addChild(
{"name": "bigger than", "type": "slider", "value": 0, "limits": [0, 1]}
)
pDeleteArea = pa.addChild({"name": "Delete area", "type": "group"})
pDeleteAreaFrom = pDeleteArea.addChild({"name": "From", "type": "group"})
self.pAreaFromX = pDeleteAreaFrom.addChild({"name": "x", "type": "slider", "value": 0, "limits": [0, 1]})
self.pAreaFromY = pDeleteAreaFrom.addChild({"name": "y", "type": "slider", "value": 0, "limits": [0, 1]})
pDeleteAreaTo = pDeleteArea.addChild({"name": "To", "type": "group"})
self.pAreaToX = pDeleteAreaTo.addChild({"name": "x", "type": "slider", "value": 0, "limits": [0, 1]})
self.pAreaToY = pDeleteAreaTo.addChild({"name": "y", "type": "slider", "value": 0, "limits": [0, 1]})
pOutput = pa.addChild({"name": "Output", "type": "group"})
self.pDifferenceImage = pOutput.addChild({"name": "Difference Image", "type": "bool", "value": True})
self.pFourierImage = pOutput.addChild({"name": "Fourier Image", "type": "bool", "value": True})
self.pProcessedFourierImage = pOutput.addChild(
{"name": "Processed Fourier Image", "type": "bool", "value": True}
)
def __init__(self, imageDisplay):
Tool.__init__(self, imageDisplay)
self.setChecked(self.display.widget.view.vb.state['aspectLocked'])
pa = self.setParameterMenu()
pRange = pa.addChild({
'name': 'autoRange',
'type': 'bool',
'value':True,
'tip':'''whether to fit view every time the input changes'''})
pRange.sigValueChanged.connect(lambda param, value:
self.display.widget.setOpts(autoRange=value))
def restoreState(self, state):
Tool.restoreState(self, state)
old_ch = list(self._menu.p.childs[1:])
#remove old param:
pa = self._menu.p
pa.sigChildRemoved.disconnect(self.removeLayer)
for ch in old_ch:
pa.removeChild(ch)
pa.sigChildRemoved.connect(self.removeLayer)
for n, ch in enumerate(old_ch):
#load layers from file
img = state['c_layer_%i' %n]
self.display.widget.addColorLayer(img, name=ch.opts['name'], tip=ch.opts['name'])
def __init__(self, display):
Tool.__init__(self, display)
self._lastMoveVal = [0, 0]
pa = self.setParameterMenu()
joy = JoystickButton()
joy.sigStateChanged.connect(self._move_joystickChanged)
self._menu.addTopWidget(joy)
self.pX = pa.addChild({
'name': 'X',
'type': 'int',
'value': 0,
})
self._pxChanged = lambda param, val, axis=1: self._move_pXYChanged(
val, axis)
self.pX.sigValueChanged.connect(self._pxChanged)
self.pY = pa.addChild({
'name': 'Y',
'type': 'int',
'value': 0,
})
self._pyChanged = lambda param, val, axis=0: self._move_pXYChanged(
val, axis)
self.pY.sigValueChanged.connect(self._pyChanged)
pAccept = pa.addChild({'name': 'Accept', 'type': 'action'})
pAccept.sigActivated.connect(self._move_acceptChanges)
pReset = pa.addChild({'name': 'Reset', 'type': 'action'})
pReset.sigActivated.connect(self._move_resetChanges)
pa.addChild({'name': '---', 'type': 'empty'})
pTranspose = pa.addChild({'name': 'Rotate 90 DEG', 'type': 'action'})
pTranspose.sigActivated.connect(self._rot90)
pTranspose = pa.addChild({'name': 'Transpose', 'type': 'action'})
pTranspose.sigActivated.connect(self._transpose)
pMirrorX = pa.addChild({'name': 'Flip Horizontally', 'type': 'action'})
pMirrorX.sigActivated.connect(self._mirrorX)
pMirrorY = pa.addChild({'name': 'Flip Vertically', 'type': 'action'})
pMirrorY.sigActivated.connect(self._mirrorY)
def __init__(self, imageDisplay):
Tool.__init__(self, imageDisplay)
_import()
pa = self.setParameterMenu()
self.createResultInDisplayParam(pa)
self.pSTEremoval = pa.addChild({
'name': 'Single-time-effect removal',
'type': 'bool',
'value': True
})
self.pAverageAll = pa.addChild({
'name': 'Average all',
'type': 'bool',
'value': True
})
self.pAverageN = self.pAverageAll.addChild({
'name': 'New layer every every N images',
'type': 'int',
'value': 2,
'min': 2,
'visible': False
})
self.pAverageAll.sigValueChanged.connect(
lambda param, val: self.pAverageN.show(not val))
self.pChangesLayer = self.pSTEremoval.addChild({
'name': 'Add changes layer',
'type': 'bool',
'value': False
})
self.pNStd = self.pSTEremoval.addChild({
'name':
'nStd',
'type':
'float',
'value':
4,
'tip':
'factor image difference over local noise'
})
self.pSTEremoval.sigValueChanged.connect(
lambda p, v: [c.show(p.value()) for c in p.childs])
def __init__(self, display):
Tool.__init__(self, display)
self.textItems = []
pa = self.setParameterMenu()
self.pScales = pa.addChild({
'name': 'Text scales',
'type': 'bool',
'value': False
})
pAdd = self._menu.p.addChild({'name': 'Add', 'type': 'action'})
pAdd.sigActivated.connect(
lambda: self.view.scene().sigMouseClicked.connect(self._textAdd))
pAdd.sigActivated.connect(self._menu.hide)
pClear = pa.addChild({'name': 'Clear', 'type': 'action'})
pClear.sigActivated.connect(self._clear)
pColor = pa.addChild({
'name': 'Color',
'type': 'empty',
'highlight': True
})
self.pCFont = pColor.addChild({
'name': 'Font',
'type': 'color',
'value': (0, 0, 0)
})
self.pCFont.sigValueChanged.connect(self._fontColorChanged)
self.pCBg = pColor.addChild({
'name': 'Background',
'type': 'color',
'value': 'w'
})
self.pCBg.sigValueChanged.connect(self._fontBgChanged)
self.pFont = pa.addChild({
'name': 'Font',
'type': 'action',
'font': None
})
self.pFont.sigActivated.connect(self._setFont)
def __init__(self, imageDisplay):
Tool.__init__(self, imageDisplay)
pa = self.setParameterMenu()
self.pRNRows = pa.addChild({
'name': 'N rows',
'type': 'int',
'value':2,
'limits':[1,100]})
self.pSpace = pa.addChild({
'name': 'Space inbetween',
'type': 'int',
'value':30,
'limits':[0,1e5]})
def __init__(self, display):
Tool.__init__(self, display)
display.sigLayerChanged.connect(self._check)
display.sigNewLayer.connect(self._check)
pa = self.setParameterMenu()
pSep = pa.addChild({
'name': 'Separate color channels',
'type': 'action'})
pSep.sigActivated.connect(self.separate)
self.createResultInDisplayParam(pa)
self._check()
def restoreState(self, state):
Tool.restoreState(self, state)
old_ch = list(self._menu.p.childs[1:])
#remove old param:
pa = self._menu.p
pa.sigChildRemoved.disconnect(self.removeLayer)
for ch in old_ch:
pa.removeChild(ch)
pa.sigChildRemoved.connect(self.removeLayer)
for n, ch in enumerate(old_ch):
#load layers from file
img = state['c_layer_%i' % n]
self.display.widget.addColorLayer(img,
name=ch.opts['name'],
tip=ch.opts['name'])
def __init__(self, plotDisplay):
Tool.__init__(self, plotDisplay)
self.guess = None
pa = self.setParameterMenu()
self.pPlot = pa.addChild({
'name': 'Plot',
'type': 'list',
'value': 'All'})
XVals = pa.addChild({
'name': 'X values',
'type': 'empty',
'highlight': True})
self.pXFrom = XVals.addChild({
'name': 'From',
'type': 'float',
'value': 0})
self.pXTo = XVals.addChild({
'name': 'To',
'type': 'float',
'value': 100})
self.pXN = XVals.addChild({
'name': 'Number',
'type': 'int',
'value': 100,
'limits': [2, 10000]})
self.pMethod = pa.addChild({
'name': 'Method',
'type': 'list',
'value': 'Poisson',
'limits': ['Poisson']})
pManual = pa.addChild({
'name': 'Manually set initial guess',
'type': 'action'})
pManual.sigActivated.connect(self._manualSetInitGuess)
self._menu.aboutToShow.connect(self._updateMenu)
