class MapView(QSplitter):
sigRoiPixels = Signal(object)
sigRoiState = Signal(object)
sigAutoMaskState = Signal(object)
sigSelectMaskState = Signal(object)
def __init__(self,
header: NonDBHeader = None,
stream: str = 'primary',
field: str = 'primary'):
"""
A widget to display imageCube like dataset with ROI buttons
:param header: Xi-cam datahandler header
:param field: header's field param
"""
super(MapView, self).__init__()
# layout set up
self.setOrientation(Qt.Vertical)
self.imageview = MapViewWidget()
self.spectra = SpectraPlotWidget()
self.spectraSplitter = QSplitter()
self.spectraSplitter.addWidget(self.spectra)
# self.spectraSplitter.insertWidget(1, BetterButtons()) # add a 2D spectrum window
# self.spectra.getViewBox().setXRange(0, 4000) # set xrange
self.imageview_and_toolbar = QSplitter()
self.imageview_and_toolbar.setOrientation(Qt.Horizontal)
self.toolbar_and_param = QSplitter()
self.toolbar_and_param.setOrientation(Qt.Vertical)
#define tool bar
self.toolBar = QWidget()
self.gridlayout = QGridLayout()
self.toolBar.setLayout(self.gridlayout)
#add tool bar buttons
self.roiBtn = QToolButton()
self.roiBtn.setText('Manual ROI')
self.roiBtn.setCheckable(True)
self.roiMeanBtn = QToolButton()
self.roiMeanBtn.setText('ROI Mean')
self.autoMaskBtn = QToolButton()
self.autoMaskBtn.setText('Auto ROI')
self.autoMaskBtn.setCheckable(True)
self.selectMaskBtn = QToolButton()
self.selectMaskBtn.setText('Mark Select')
self.selectMaskBtn.setCheckable(True)
self.saveRoiBtn = QToolButton()
self.saveRoiBtn.setText('Save ROI')
self.saveRoiBtn.setCheckable(False)
self.loadRoiBtn = QToolButton()
self.loadRoiBtn.setText('Load ROI')
self.loadRoiBtn.setCheckable(False)
self.gridlayout.addWidget(self.roiBtn, 0, 0, 1, 1)
self.gridlayout.addWidget(self.autoMaskBtn, 0, 1, 1, 1)
self.gridlayout.addWidget(self.selectMaskBtn, 1, 0, 1, 1)
self.gridlayout.addWidget(self.roiMeanBtn, 1, 1, 1, 1)
self.gridlayout.addWidget(self.saveRoiBtn, 2, 0, 1, 1)
self.gridlayout.addWidget(self.loadRoiBtn, 2, 1, 1, 1)
self.parameterTree = ParameterTree()
self.parameter = Parameter(name='Threshhold',
type='group',
children=[
{
'name': 'Amide II',
'value': 0,
'type': 'float'
},
{
'name': "ROI type",
'values': ['+', '-'],
'value': '+',
'type': 'list'
},
])
self.parameter.child('Amide II').setOpts(step=0.1)
self.parameterTree.setParameters(self.parameter, showTop=False)
self.parameterTree.setHeaderLabels(['Params', 'Value'])
self.parameterTree.setIndentation(0)
# Assemble widgets
self.toolbar_and_param.addWidget(self.toolBar)
self.toolbar_and_param.addWidget(self.parameterTree)
self.toolbar_and_param.setSizes([1000,
1]) #adjust initial splitter size
self.imageview_and_toolbar.addWidget(self.toolbar_and_param)
self.imageview_and_toolbar.addWidget(self.imageview)
self.imageview_and_toolbar.setSizes([1, 1000
]) #adjust initial splitter size
self.addWidget(self.imageview_and_toolbar)
self.addWidget(self.spectraSplitter)
self.setSizes([1000, 1000]) # adjust initial splitter size
# readin header
self.imageview.setHeader(header, field='image')
self.spectra.setHeader(header, field='spectra')
self.header = header
#setup ROI item
sideLen = 10
self.roi = pg.PolyLineROI(positions=[[0, 0], [sideLen, 0],
[sideLen, sideLen], [0, sideLen]],
closed=True)
self.imageview.view.addItem(self.roi)
self.roiInitState = self.roi.getState()
self.roi.hide()
#constants
self.path = os.path.expanduser('~/')
self.pixSelection = {
'ROI': None,
'Mask': None
} # init pixel selection dict
# Connect signals
self.imageview.sigShowSpectra.connect(self.spectra.showSpectra)
self.spectra.sigEnergyChanged.connect(self.imageview.setEnergy)
self.roiBtn.clicked.connect(self.roiBtnClicked)
self.roi.sigRegionChangeFinished.connect(self.roiSelectPixel)
self.roi.sigRegionChangeFinished.connect(self.showSelectMask)
self.sigRoiPixels.connect(self.spectra.getSelectedPixels)
self.roiMeanBtn.clicked.connect(self.spectra.showMeanSpectra)
self.autoMaskBtn.clicked.connect(self.showAutoMask)
self.selectMaskBtn.clicked.connect(self.showSelectMask)
self.saveRoiBtn.clicked.connect(self.saveRoi)
self.loadRoiBtn.clicked.connect(self.loadRoi)
self.parameter.child('Amide II').sigValueChanged.connect(
self.showAutoMask)
self.parameter.child('Amide II').sigValueChanged.connect(
self.intersectSelection)
self.parameter.child('ROI type').sigValueChanged.connect(
self.intersectSelection)
def roiBtnClicked(self):
self.roiSelectPixel()
if self.roiBtn.isChecked():
self.imageview.cross.hide()
self.roi.show()
self.sigRoiState.emit((True, self.roi.getState()))
else:
self.roi.hide()
self.roi.setState(self.roiInitState)
self.sigRoiState.emit((False, self.roi.getState()))
def saveRoi(self):
parameterDict = {
name: self.parameter[name]
for name in self.parameter.names.keys()
}
roiStates = {
'roiBtn': self.roiBtn.isChecked(),
'maskBtn': self.autoMaskBtn.isChecked(),
'roiState': self.roi.getState(),
'parameter': parameterDict
}
filePath, fileName, canceled = uiSaveFile('Save ROI state', self.path,
"Pickle Files (*.pkl)")
if not canceled:
with open(filePath + fileName, 'wb') as f:
pickle.dump(roiStates, f)
MsgBox(
f'ROI state file was saved! \nFile Location: {filePath + fileName}'
)
def loadRoi(self):
filePath, fileName, canceled = uiGetFile('Open ROI state file',
self.path,
"Pickle Files (*.pkl)")
if not canceled:
with open(filePath + fileName, 'rb') as f:
roiStates = pickle.load(f)
self.roiBtn.setChecked(roiStates['roiBtn'])
self.roi.setState(roiStates['roiState'])
if roiStates['roiBtn']:
self.roi.show()
self.autoMaskBtn.setChecked(roiStates['maskBtn'])
self.selectMaskBtn.setChecked(True)
self.showSelectMask(True)
for k, v in roiStates['parameter'].items():
self.parameter[k] = v
MsgBox(f'ROI states were loaded from: \n{filePath + fileName}')
else:
return
def roiMove(self, roi):
roiState = roi.getState()
self.roi.setState(roiState)
def getImgShape(self, imgShape, rc2ind):
self.row, self.col = imgShape[0], imgShape[1]
self.rc2ind = rc2ind
# determine whether spectra data is sparse
if len(rc2ind) == self.row * self.col:
self.isDenseImage = True
else:
self.isDenseImage = False
#set up X,Y grid
x = np.linspace(0, self.col - 1, self.col)
y = np.linspace(self.row - 1, 0, self.row)
self.X, self.Y = np.meshgrid(x, y)
if self.isDenseImage:
self.fullMap = list(zip(self.Y.ravel(), self.X.ravel()))
else:
self.fullMap = list(rc2ind.keys())
# setup automask item
self.autoMask = np.ones((self.row, self.col))
self.autoMaskItem = pg.ImageItem(self.autoMask,
axisOrder="row-major",
autoLevels=True,
opacity=0.3)
self.imageview.view.addItem(self.autoMaskItem)
self.autoMaskItem.hide()
# setup selctmask item to mark selected pixels
self.selectMask = np.ones((self.row, self.col))
self.selectMaskItem = pg.ImageItem(self.selectMask,
axisOrder="row-major",
autoLevels=True,
opacity=0.3,
lut=np.array([[0, 0, 0],
[255, 0, 0]]))
self.imageview.view.addItem(self.selectMaskItem)
self.selectMaskItem.hide()
def roiSelectPixel(self):
if self.roiBtn.isChecked():
#get x,y positions list
xPos = self.roi.getArrayRegion(self.X, self.imageview.imageItem)
xPos = np.round(xPos[xPos > 0])
yPos = self.roi.getArrayRegion(self.Y, self.imageview.imageItem)
yPos = np.round(yPos[yPos > 0])
# extract x,y coordinate from selected region
selectedPixels = list(zip(yPos, xPos))
self.intersectSelection('ROI', selectedPixels)
self.sigRoiState.emit((True, self.roi.getState()))
else:
self.intersectSelection('ROI', None) # no ROI, select all pixels
self.sigRoiState.emit((False, self.roi.getState()))
def showSelectMask(self, signalReceived):
if self.selectMaskBtn.isChecked():
# show roi and autoMask
if self.roiBtn.isChecked():
self.roi.show()
self.sigRoiState.emit((True, self.roi.getState()))
if self.autoMaskBtn.isChecked():
self.autoMaskItem.show()
self.sigAutoMaskState.emit((True, self.autoMask))
# update and show mask
self.selectMaskItem.setImage(self.selectMask)
self.selectMaskItem.show()
self.sigSelectMaskState.emit((True, self.selectMask))
else:
self.selectMaskItem.hide()
self.sigSelectMaskState.emit((False, self.selectMask))
if signalReceived == False:
self.roi.hide()
self.autoMaskItem.hide()
self.sigRoiState.emit((False, self.roi.getState()))
self.sigAutoMaskState.emit((False, self.autoMask))
def showAutoMask(self):
if self.autoMaskBtn.isChecked():
# update and show mask
self.autoMask = self.imageview.makeMask(
[self.parameter['Amide II']])
self.autoMaskItem.setImage(self.autoMask)
self.autoMaskItem.show()
# select pixels
mask = self.autoMask.astype(np.bool)
selectedPixels = list(zip(self.Y[mask], self.X[mask]))
self.intersectSelection('Mask', selectedPixels)
self.sigAutoMaskState.emit((True, self.autoMask))
else:
self.autoMaskItem.hide()
self.autoMask[:, :] = 1
self.intersectSelection('Mask', None) # no mask, select all pixels
self.sigAutoMaskState.emit((False, self.autoMask))
def intersectSelection(self, selector, selectedPixels):
# update pixel selection dict
if (selector == 'ROI') or (selector == 'Mask'):
self.pixSelection[selector] = selectedPixels
# reverse ROI selection
if (self.parameter['ROI type'] == '-') and (self.pixSelection['ROI']
is not None):
roi_copy = self.pixSelection['ROI']
reverseROI = set(self.fullMap) - set(self.pixSelection['ROI'])
self.pixSelection['ROI'] = list(reverseROI)
if (self.pixSelection['ROI'] is None) and (self.pixSelection['Mask'] is
None):
if self.isDenseImage:
self.sigRoiPixels.emit(None) # no ROI, select all pixels
self.selectMask = np.ones((self.row, self.col))
else:
allSelected = np.array(list(self.rc2ind.keys()), dtype='int')
self.sigRoiPixels.emit(
allSelected) # no ROI, select all sparse rc2ind
self.selectMask = np.zeros((self.row, self.col))
self.selectMask[allSelected[:, 0], allSelected[:, 1]] = 1
self.selectMask = np.flipud(self.selectMask)
return
elif self.pixSelection['ROI'] is None:
allSelected = set(
self.pixSelection['Mask']) #de-duplication of pixels
elif self.pixSelection['Mask'] is None:
allSelected = set(
self.pixSelection['ROI']) #de-duplication of pixels
else:
allSelected = set(self.pixSelection['ROI']) & set(
self.pixSelection['Mask'])
if self.isDenseImage:
allSelected = np.array(list(allSelected),
dtype='int') # convert to array
else:
allSelected &= set(self.rc2ind.keys())
allSelected = np.array(list(allSelected), dtype='int')
self.selectMask = np.zeros((self.row, self.col))
if len(allSelected) > 0:
self.selectMask[allSelected[:, 0], allSelected[:, 1]] = 1
self.selectMask = np.flipud(self.selectMask)
self.sigRoiPixels.emit(allSelected)
# show SelectMask
self.showSelectMask(selector)
#recover ROI selection
if (self.parameter['ROI type'] == '-') and (self.pixSelection['ROI']
is not None):
self.pixSelection['ROI'] = roi_copy
class ClusteringParameters(ParameterTree):
sigParamChanged = Signal(object)
def __init__(self):
super(ClusteringParameters, self).__init__()
self.parameter = Parameter(
name='params',
type='group',
children=[{
'name': "Embedding",
'values': ['PCA', 'UMAP'],
'value': 'UMAP',
'type': 'list'
}, {
'name': "Components",
'value': 3,
'type': 'int'
}, {
'name': "Neighbors",
'value': 15,
'type': 'int'
}, {
'name': "Min Dist",
'value': 0.1,
'type': 'float'
}, {
'name': "Metric",
'values': ['euclidean', 'manhattan', 'correlation'],
'value': 'euclidean',
'type': 'list'
}, {
'name': "Normalization",
'values': ['L2', 'L1', 'None'],
'value': 'L2',
'type': 'list'
}, {
'name': "Wavenumber Range",
'value': '400, 4000',
'type': 'str'
}, {
'name': "Clusters",
'value': 3,
'type': 'int'
}, {
'name': "X Component",
'values': [1, 2, 3],
'value': 1,
'type': 'list'
}, {
'name': "Y Component",
'values': [1, 2, 3],
'value': 2,
'type': 'list'
}])
self.setParameters(self.parameter, showTop=False)
self.setIndentation(0)
self.parameter.child('Normalization').hide()
# change Fonts
self.fontSize = 12
font = QFont("Helvetica [Cronyx]", self.fontSize)
boldFont = QFont("Helvetica [Cronyx]", self.fontSize, QFont.Bold)
self.header().setFont(font)
for item in self.listAllItems():
if hasattr(item, 'widget'):
item.setFont(0, boldFont)
item.widget.setFont(font)
item.displayLabel.setFont(font)
item.widget.setMaximumHeight(40)
# connect signals
self.parameter.child('Embedding').sigValueChanged.connect(
self.updateMethod)
self.parameter.child('Components').sigValueChanged.connect(
self.setComponents)
for entry in ['Components', 'Clusters', 'X Component', 'Y Component']:
self.parameter.child(entry).sigValueChanged.connect(
partial(self.updateClusterParams, entry))
def updateMethod(self):
"""
Toggle parameter menu based on embedding method
:return: None
"""
if self.parameter["Embedding"] == 'UMAP':
self.parameter.child('Neighbors').show()
self.parameter.child('Min Dist').show()
self.parameter.child('Metric').show()
self.parameter.child('Normalization').hide()
else:
self.parameter.child('Neighbors').hide()
self.parameter.child('Min Dist').hide()
self.parameter.child('Metric').hide()
self.parameter.child('Normalization').show()
def setComponents(self):
N = self.parameter['Components']
for entry in ['X Component', 'Y Component']:
param = self.parameter.child(entry)
param.setLimits(list(range(1, N + 1)))
def updateClusterParams(self, name):
self.sigParamChanged.emit(name)
class PreprocessParameters(ParameterTree):
sigParamChanged = Signal(object)
def __init__(self):
super(PreprocessParameters, self).__init__()
self.parameter = Parameter(name='params', type='group',
children=[{'name': "Preprocess method",
'values': ['Kohler_EMSC','Rubberband'],
'value': 'Kohler_EMSC',
'type': 'list'},
{'name': "Anchor points",
'value': '400, 4000',
'type': 'str'},
{'name': "Fitting regions",
'value': '[(650, 750),(1780, 2680),(3680, 4000)]',
'type': 'str'},
{'name': "Interp method",
'value': 'linear',
'values': ['linear', 'quadratic', 'cubic'],
'type': 'list'}
])
self.setParameters(self.parameter, showTop=False)
self.setIndentation(0)
self.parameter.child('Interp method').hide()
self.parameter.child('Anchor points').hide()
# change Fonts
self.fontSize = 12
font = QFont("Helvetica [Cronyx]", self.fontSize)
boldFont = QFont("Helvetica [Cronyx]", self.fontSize, QFont.Bold)
self.header().setFont(font)
for item in self.listAllItems():
if hasattr(item, 'widget'):
item.setFont(0, boldFont)
item.widget.setFont(font)
item.displayLabel.setFont(font)
item.widget.setMaximumHeight(40)
# init params dict
self.argMap = {"Anchor points": 'anchors',
"Interp method": 'kind',
"Fitting regions": 'w_regions'
}
# set self.processArgs to default value
self.processArgs = {}
for child in self.parameter.childs:
if child.name() == "Anchor points":
self.processArgs['anchors'] = '400, 4000'
elif child.name() == "Interp method":
self.processArgs['kind'] = 'linear'
elif child.name() == "Fitting regions":
self.processArgs['w_regions'] = '[(650, 750), (1780, 2680), (3680, 4000)]'
# connect signals
self.parameter.child('Preprocess method').sigValueChanged.connect(self.updateMethod)
for name in self.argMap.keys():
self.parameter.child(name).sigValueChanged.connect(partial(self.updateParam, name))
def updateParam(self, name):
"""
get latest parameter values
:param name: parameter name
:return: None
"""
self.processArgs[self.argMap[name]] = self.parameter[name]
self.sigParamChanged.emit(self.processArgs)
def updateMethod(self):
"""
Toggle parameter menu based on fit method
:return:
"""
if self.parameter["Preprocess method"] == 'Kohler_EMSC':
self.parameter.child('Fitting regions').show()
self.parameter.child('Interp method').hide()
self.parameter.child('Anchor points').hide()
else:
self.parameter.child('Fitting regions').hide()
self.parameter.child('Interp method').show()
self.parameter.child('Anchor points').show()
class FactorizationParameters(ParameterTree):
def __init__(self, headermodel: QStandardItemModel,
selectionmodel: QItemSelectionModel):
super(FactorizationParameters, self).__init__()
self.headermodel = headermodel
self.selectionmodel = selectionmodel
self.parameter = Parameter(name='params',
type='group',
children=[{
'name': "Method",
'values': ['PCA', 'NMF', 'MCR'],
'value': 'PCA',
'type': 'list'
}, {
'name': "Components",
'value': 4,
'type': 'int'
}, {
'name': "Map 1 Component",
'values': [1, 2, 3, 4],
'value': 1,
'type': 'list'
}, {
'name': "Map 2 Component",
'values': [1, 2, 3, 4],
'value': 2,
'type': 'list'
}, {
'name': "Map 3 Component",
'values': [1, 2, 3, 4],
'value': 3,
'type': 'list'
}, {
'name': "Map 4 Component",
'values': [1, 2, 3, 4],
'value': 4,
'type': 'list'
}, {
'name': "Wavenumber Range",
'value': '800,1800',
'type': 'str'
}, {
'name': "Normalization",
'values': ['L2', 'L1', 'None'],
'value': 'L2',
'type': 'list'
}, {
'name': "C regressor",
'values': ['OLS', 'NNLS'],
'value': 'OLS',
'type': 'list'
}])
self.setParameters(self.parameter, showTop=False)
self.setIndentation(0)
#constants
self.method = 'PCA'
self.field = 'spectra'
# change Fonts
self.fontSize = 12
font = QFont("Helvetica [Cronyx]", self.fontSize)
boldFont = QFont("Helvetica [Cronyx]", self.fontSize, QFont.Bold)
self.header().setFont(font)
for item in self.listAllItems():
if hasattr(item, 'widget'):
item.setFont(0, boldFont)
item.widget.setFont(font)
item.displayLabel.setFont(font)
item.widget.setMaximumHeight(40)
# connect signals
self.parameter.child('Components').sigValueChanged.connect(
self.setNumComponents)
self.parameter.child('Method').sigValueChanged.connect(self.setMethod)
self.parameter.child('C regressor').hide()
def setMethod(self):
if self.parameter['Method'] == 'PCA':
self.parameter.child('Normalization').setToDefault()
self.parameter.child('Normalization').show()
self.parameter.child('C regressor').hide()
elif self.parameter['Method'] == 'NMF':
self.parameter.child('Normalization').hide()
self.parameter.child('C regressor').hide()
elif self.parameter['Method'] == 'MCR':
self.parameter.child('Normalization').hide()
self.parameter.child('C regressor').show()
def setNumComponents(self):
N = self.parameter['Components']
for i in range(4):
param = self.parameter.child(f'Map {i + 1} Component')
param.setLimits(list(range(1, N + 1)))
class DeviceProfiles(SettingsPlugin):
sigRequestRedraw = Signal()
sigRequestReduce = Signal()
sigSimulateCalibrant = Signal()
name = 'Device Profiles'
def __init__(self):
self.headermodel = None
self.selectionmodel = None
self.multiAI = MultiGeometry([])
self.AIs = dict()
widget = ParameterTree()
energy = SimpleParameter(name='Energy',
type='float',
value=10000,
siPrefix=True,
suffix='eV')
wavelength = SimpleParameter(name='Wavelength',
type='float',
value=1.239842e-6 / 10000,
siPrefix=True,
suffix='m')
self.parameter = Parameter(name="Device Profiles",
type='group',
children=[energy, wavelength])
widget.setParameters(self.parameter, showTop=False)
icon = QIcon(str(path('icons/calibrate.png')))
super(DeviceProfiles, self).__init__(icon, "Device Profiles", widget)
self.parameter.sigValueChanged.connect(self.sigRequestRedraw)
self.parameter.sigValueChanged.connect(self.sigRequestReduce)
self.parameter.sigTreeStateChanged.connect(self.simulateCalibrant)
self.parameter.sigTreeStateChanged.connect(self.genAIs)
self.parameter.sigValueChanged.connect(self.simulateCalibrant)
def simulateCalibrant(self, *args):
self.sigSimulateCalibrant.emit()
def genAIs(self, parent, changes):
for parameter, key, value in changes:
if parameter.name == 'Wavelength':
self.parameter.param('Energy').setValue(
1.239842e-6 / self.param('Wavelength').value(),
blockSignal=self.parameter.sigTreeStateChanged)
elif parameter.name == 'Energy':
self.parameter.param('Wavelength').setValue(
1.239842e-6 / self.param('Energy').value(),
blockSignal=self.WavelengthChanged)
for parameter in self.parameter.children():
if isinstance(parameter, DeviceParameter):
device = parameter.name()
ai = self.AI(device)
ai.set_wavelength(self.parameter['Wavelength'])
ai.detector = parameter['Detector']()
ai.detector.set_binning([parameter['Binning']] * 2)
ai.detector.set_pixel1(parameter['Pixel Size X'])
ai.detector.set_pixel2(parameter['Pixel Size Y'])
fit2d = ai.getFit2D()
fit2d['centerX'] = parameter['Center X']
fit2d['centerY'] = parameter['Center Y']
fit2d['directDist'] = parameter['Detector Distance'] * 1000
fit2d['tilt'] = parameter['Detector Tilt']
fit2d['tiltPlanRotation'] = parameter['Detector Rotation']
ai.setFit2D(**fit2d)
def AI(self, device):
if device not in self.AIs:
self.addDevice(device)
return self.AIs[device]
def setAI(self, ai: AzimuthalIntegrator, device: str):
self.AIs[device] = ai
self.multiAI.ais = self.AIs.values()
# propagate new ai to parameter
fit2d = ai.getFit2D()
try:
self.setSilence(True)
self.parameter.child(device,
'Detector').setValue(type(ai.detector))
self.parameter.child(device,
'Binning').setValue(ai.detector.binning[0])
self.parameter.child(device, 'Detector Tilt').setValue(
fit2d['tiltPlanRotation'])
self.parameter.child(device,
'Detector Rotation').setValue(fit2d['tilt'])
self.parameter.child(device, 'Pixel Size X').setValue(ai.pixel1)
self.parameter.child(device, 'Pixel Size Y').setValue(ai.pixel2)
self.parameter.child(device, 'Center X').setValue(fit2d['centerX'])
self.parameter.child(device, 'Center Y').setValue(fit2d['centerY'])
self.parameter.child(device, 'Detector Distance').setValue(
fit2d['directDist'] / 1000)
self.parameter.child('Wavelength').setValue(ai.wavelength)
finally:
self.setSilence(False)
self.simulateCalibrant()
def setSilence(self, silence):
if silence:
self.parameter.sigTreeStateChanged.disconnect(
self.simulateCalibrant)
self.parameter.sigTreeStateChanged.disconnect(self.genAIs)
else:
self.parameter.sigTreeStateChanged.connect(self.simulateCalibrant)
self.parameter.sigTreeStateChanged.connect(self.genAIs)
def addDevice(self, device):
try:
self.setSilence(True)
devicechild = DeviceParameter(device)
self.parameter.addChild(devicechild)
ai = AzimuthalIntegrator(wavelength=self.parameter['Wavelength'])
self.AIs[device] = ai
self.multiAI.ais = list(self.AIs.values())
finally:
self.setSilence(False)
def setModels(self, headermodel, selectionmodel):
self.headermodel = headermodel
self.headermodel.dataChanged.connect(self.dataChanged)
self.selectionmodel = selectionmodel
def dataChanged(self, start, end):
devices = self.headermodel.item(
self.selectionmodel.currentIndex()).header.devices()
for device in devices:
if device not in self.AIs:
self.addDevice(device)
def apply(self):
AI = AzimuthalIntegrator(
wavelength=self.parameter.child('Wavelength').value())
# if Calibration.isChecked():
# AI.setFit2D(self.getvalue('Detector Distance') * 1000.,
# self.getvalue('Center X'),
# self.getvalue('Center Y'),
# self.getvalue('Detector Tilt'),
# 360. - self.getvalue('Detector Rotation'),
# self.getvalue('Pixel Size Y') * 1.e6,
# self.getvalue('Pixel Size X') * 1.e6)
# elif self.wxdiffstyle.isChecked():
# AI.setFit2D(self.getvalue('Detector Distance') * 1000.,
# self.getvalue('Center X'),
# self.getvalue('Center Y'),
# self.getvalue('Detector Tilt') / 2. / np.pi * 360.,
# 360. - (2 * np.pi - self.getvalue('Detector Rotation')) / 2. / np.pi * 360.,
# self.getvalue('Pixel Size Y') * 1.e6,
# self.getvalue('Pixel Size X') * 1.e6)
# AI.set_wavelength(self.getvalue('Wavelength'))
# # print AI
activeCalibration = AI
def save(self):
self.apply()
return self.parameter.saveState(filter='user')
def restore(self, state):
pass
# self.parameter.restoreState(state, addChildren=False, removeChildren=False)
def wavelengthChanged(self):
self.param('Energy').setValue(1.239842e-6 /
self.param('Wavelength').value(),
blockSignal=self.EnergyChanged)
def energyChanged(self):
self.param('Wavelength').setValue(1.239842e-6 /
self.param('Energy').value(),
blockSignal=self.WavelengthChanged)
def wireup_parameter(self, parameter: Parameter):
parameter.child('test').sigValueChanged.connect(
lambda value: print(value))
