def __init__(self, parent=None):
qt.QWizardPage.__init__(self, parent)
#, name, fl)
layout = qt.QVBoxLayout(self)
layout.setContentsMargins(10, 10, 10, 10)
layout.setSpacing(5)
topWidget = qt.QWidget(self)
topLayout = qt.QGridLayout(topWidget)
topLayout.setContentsMargins(0, 0, 0, 0)
topLayout.setSpacing(5)
dirLabel = qt.QLabel("Directory", topWidget)
nameLabel = qt.QLabel("Prefix name", topWidget)
topLayout.addWidget(dirLabel, 0, 0)
topLayout.addWidget(nameLabel, 1, 0)
self.directory = qt.QLineEdit(topWidget)
self.outname = qt.QLineEdit(topWidget)
topLayout.addWidget(self.directory, 0, 1)
topLayout.addWidget(self.outname, 1, 1)
self.directory.returnPressed[()].connect(self.__directoryCheck)
butDirectory = qt.QPushButton("Find", topWidget)
butOutname = qt.QPushButton("Default", topWidget)
topLayout.addWidget(butDirectory, 0, 2)
topLayout.addWidget(butOutname, 1, 2)
butDirectory.clicked.connect(self.__openDirectory)
butOutname.clicked.connect(self.__defaultOutname)
lineSep = qt.QFrame(self)
lineSep.setFrameStyle(qt.QFrame.HLine | qt.QFrame.Sunken)
self.forceCheck = qt.QCheckBox("Force overwriting existing files",
self)
self.verboseCheck = qt.QCheckBox("Verbose mode", self)
layout.addWidget(topWidget)
layout.addWidget(lineSep)
layout.addWidget(self.forceCheck)
layout.addWidget(self.verboseCheck)
layout.addStretch()
self.__defaultOutname()
def __init__(self, parent=None, entries=None):
qt.QWidget.__init__(self, parent)
self.setLayout(qt.QVBoxLayout())
self._cbReconsType = QDataSourceWidget.getReconsTypeCombobox(
parent=self)
self.layout().addWidget(self._cbReconsType)
self._widgetGiveItI0 = qt.QWidget(parent=self)
self._widgetGiveItI0.setLayout(qt.QHBoxLayout())
self._giveItCheckBox = qt.QCheckBox('give It',
parent=self._widgetGiveItI0)
self._giveItCheckBox.setChecked(True)
self._giveItCheckBox.setToolTip('It is needed in order to produce the '
'absorption matrix and deduce the self'
' absorption matrices. If not '
'available then you will have to give '
'directly the absorption matrix and '
'the self absorption matrices.')
self._widgetGiveItI0.layout().addWidget(self._giveItCheckBox)
self._giveI0CheckBox = qt.QCheckBox('give I0',
parent=self._widgetGiveItI0)
self._giveI0CheckBox.setChecked(True)
self._giveI0CheckBox.setToolTip('I0 sinogram is used to normalized '
'sinograms. If this is not available '
'then you can enter a single value to '
'normalize sinograms.')
self._widgetGiveItI0.layout().addWidget(self._giveI0CheckBox)
self.layout().addWidget(self._widgetGiveItI0)
self._fbpSelectionTable = FBPSinoReconsSelectionTable(parent=self)
self.layout().addWidget(self._fbpSelectionTable)
self._txSelectionTable = TxSinoReconsSelectionTable(parent=self)
self.layout().addWidget(self._txSelectionTable)
self._fluoSelectionTable = FluoSinoReconsSelectionTable(parent=self)
self.layout().addWidget(self._fluoSelectionTable)
self._cbReconsType.currentIndexChanged.connect(self._updadeView)
self._giveI0CheckBox.toggled.connect(
self._txSelectionTable.setI0Enabled)
self._giveI0CheckBox.toggled.connect(
self._fluoSelectionTable.setI0Enabled)
self._giveItCheckBox.toggled.connect(
self._fluoSelectionTable.setItEnabled)
self.setNames(entries)
self._updadeView()
def __init__(self, parent=None, name=None, fl=0):
qt.QWidget.__init__(self, parent)
self.resize(321, 45)
CheckFieldLayout = qt.QHBoxLayout(self)
CheckFieldLayout.setContentsMargins(11, 11, 11, 11)
CheckFieldLayout.setSpacing(6)
self.CheckBox = qt.QCheckBox(self)
self.CheckBox.setText("CheckBox")
CheckFieldLayout.addWidget(self.CheckBox)
def __init__(self, parent=None, itemType=0):
super(LegendListItemWidget, self).__init__(parent)
# Dictionary to render checkboxes
self.cbDict = {}
self.labelDict = {}
self.iconDict = {}
# Keep checkbox and legend to get sizeHint
self.checkbox = qt.QCheckBox()
self.legend = qt.QLabel()
self.icon = LegendIcon()
# Context Menu and Editors
self.contextMenu = None
def __init__(self, parent=None):
qt.QWidget.__init__(self, parent)
self.mainLayout = qt.QHBoxLayout(self)
self.mainLayout.setContentsMargins(0, 0, 0, 0)
self.checkBox = qt.QCheckBox(self)
self.checkBox.setText("Use")
self.fileName = qt.QLineEdit(self)
self.fileName.setText("")
self.fileName.setReadOnly(True)
self.browse = qt.QPushButton(self)
self.browse.setAutoDefault(False)
self.browse.setText("Browse")
self.browse.clicked.connect(self.browseFile)
self.mainLayout.addWidget(self.checkBox)
self.mainLayout.addWidget(self.fileName)
self.mainLayout.addWidget(self.browse)
def __init__(self, parent=None, row=0, column=0):
qt.QWidget.__init__(self, parent)
self.mainLayout = qt.QHBoxLayout(self)
self.mainLayout.setContentsMargins(0, 0, 0, 0)
self.mainLayout.setSpacing(2)
self._row = row
self._column = column
self._selection = qt.QCheckBox(self)
self._selectionType = qt.QComboBox(self)
self._optionsList = ["sum", "avg"]
for option in self._optionsList:
self._selectionType.addItem(option[0].upper() + option[1:])
self._selectionType.setCurrentIndex(self._optionsList.index("avg"))
self.mainLayout.addWidget(self._selection)
self.mainLayout.addWidget(self._selectionType)
self._selection.clicked.connect(self._mySignal)
self._selectionType.activated[int].connect(self._preSignal)
def build(self):
self.mainLayout = qt.QGridLayout(self)
self.mainLayout.setContentsMargins(0, 0, 0, 0)
self.mainLayout.setSpacing(2)
# the normalization method
normalizationLabel = qt.QLabel(self)
normalizationLabel.setText("Method:")
self.normalizationOptions = ["Constant", "Flattened"]
self.normalizationSelector = qt.QComboBox(self)
for option in self.normalizationOptions:
self.normalizationSelector.addItem(option)
self.normalizationSelector.setCurrentIndex(1)
# the E0 value
self.e0CheckBox = qt.QCheckBox(self)
self.e0CheckBox.setText("Auto E0:")
self.e0CheckBox.setChecked(True)
self.e0SpinBox = qt.QDoubleSpinBox(self)
self.e0SpinBox.setMinimum(200.)
self.e0SpinBox.setMaximum(200000.)
self.e0SpinBox.setDecimals(2)
self.e0SpinBox.setSingleStep(0.2)
self.e0SpinBox.setEnabled(False)
# the jump
jumpLabel = qt.QLabel(self)
jumpLabel.setText("Jump:")
self.jumpLine = qt.QLineEdit(self)
self.jumpLine.setEnabled(False)
# the pre-edge
preEdgeLabel = qt.QLabel(self)
preEdgeLabel.setText("Pre-Edge")
self.preEdgeSelector = XASNormalizationWindow.PolynomSelector(self)
self.preEdgeSelector.setCurrentIndex(3)
# pre-edge regions
preEdgeStartLabel = qt.QLabel(self)
preEdgeStartLabel.setText("Begin:")
self.preEdgeStartBox = qt.QDoubleSpinBox(self)
self.preEdgeStartBox.setDecimals(2)
self.preEdgeStartBox.setMinimum(-2000.0)
self.preEdgeStartBox.setMaximum(-5.0)
self.preEdgeStartBox.setValue(-100)
self.preEdgeStartBox.setSingleStep(5.0)
self.preEdgeStartBox.setEnabled(True)
preEdgeEndLabel = qt.QLabel(self)
preEdgeEndLabel.setText("End:")
self.preEdgeEndBox = qt.QDoubleSpinBox(self)
self.preEdgeEndBox.setDecimals(2)
self.preEdgeEndBox.setMinimum(-200.0)
self.preEdgeEndBox.setMaximum(-1.0)
self.preEdgeEndBox.setValue(-40)
self.preEdgeEndBox.setSingleStep(5.0)
self.preEdgeEndBox.setEnabled(True)
# the post-edge
postEdgeLabel = qt.QLabel(self)
postEdgeLabel.setText("Post-Edge")
self.postEdgeSelector = XASNormalizationWindow.PolynomSelector(self)
self.postEdgeSelector.setCurrentIndex(3)
# post-edge regions
postEdgeStartLabel = qt.QLabel(self)
postEdgeStartLabel.setText("Begin:")
self.postEdgeStartBox = qt.QDoubleSpinBox(self)
self.postEdgeStartBox.setDecimals(2)
self.postEdgeStartBox.setMinimum(1.0)
self.postEdgeStartBox.setMaximum(3000.0)
self.postEdgeStartBox.setValue(10)
self.postEdgeStartBox.setSingleStep(5.0)
self.postEdgeStartBox.setEnabled(True)
postEdgeEndLabel = qt.QLabel(self)
postEdgeEndLabel.setText("End:")
self.postEdgeEndBox = qt.QDoubleSpinBox(self)
self.postEdgeEndBox.setDecimals(2)
self.postEdgeEndBox.setMinimum(10.0)
self.postEdgeEndBox.setMaximum(2000.0)
self.postEdgeEndBox.setValue(300)
self.postEdgeEndBox.setSingleStep(5.0)
self.postEdgeEndBox.setEnabled(True)
# arrange everything
self.mainLayout.addWidget(normalizationLabel, 0, 0)
self.mainLayout.addWidget(self.normalizationSelector, 0, 1)
self.mainLayout.addWidget(self.e0CheckBox, 1, 0)
self.mainLayout.addWidget(self.e0SpinBox, 1, 1)
self.mainLayout.addWidget(jumpLabel, 2, 0)
self.mainLayout.addWidget(self.jumpLine, 2, 1)
self.mainLayout.addWidget(preEdgeLabel, 3, 0)
self.mainLayout.addWidget(self.preEdgeSelector, 3, 1)
self.mainLayout.addWidget(preEdgeStartLabel, 4, 0)
self.mainLayout.addWidget(self.preEdgeStartBox, 4, 1)
self.mainLayout.addWidget(preEdgeEndLabel, 5, 0)
self.mainLayout.addWidget(self.preEdgeEndBox, 5, 1)
self.mainLayout.addWidget(postEdgeLabel, 6, 0)
self.mainLayout.addWidget(self.postEdgeSelector, 6, 1)
self.mainLayout.addWidget(postEdgeStartLabel, 7, 0)
self.mainLayout.addWidget(self.postEdgeStartBox, 7, 1)
self.mainLayout.addWidget(postEdgeEndLabel, 8, 0)
self.mainLayout.addWidget(self.postEdgeEndBox, 8, 1)
# connect
self.normalizationSelector.activated[int].connect(self._normalizationChanged)
self.e0CheckBox.toggled.connect(self._e0Toggled)
self.e0SpinBox.valueChanged[float].connect(self._e0Changed)
self.preEdgeSelector.activated[int].connect(self._preEdgeChanged)
self.preEdgeStartBox.valueChanged[float].connect(self._preEdgeStartChanged)
self.preEdgeEndBox.valueChanged[float].connect(self._preEdgeEndChanged)
self.postEdgeSelector.activated[int].connect(self._postEdgeChanged)
self.postEdgeStartBox.valueChanged[float].connect(self._postEdgeStartChanged)
self.postEdgeEndBox.valueChanged[float].connect(self._postEdgeEndChanged)
def __init__(self,
parent=None,
energy=None,
threshold=None,
useviewer=None,
name="Peak Identifier"):
qt.QWidget.__init__(self, parent)
self.setWindowTitle(name)
self.setWindowIcon(qt.QIcon(qt.QPixmap(IconDict['gioconda16'])))
if energy is None: energy = 5.9
if threshold is None: threshold = 0.030
if useviewer is None: useviewer = 0
self.__useviewer = useviewer
layout = qt.QVBoxLayout(self)
#heading
self.__energyHBox = qt.QWidget(self)
hbox = self.__energyHBox
hbox.layout = qt.QHBoxLayout(hbox)
hbox.layout.setContentsMargins(0, 0, 0, 0)
hbox.layout.setSpacing(0)
layout.addWidget(hbox)
hbox.layout.addWidget(qt.HorizontalSpacer(hbox))
l1 = qt.QLabel(hbox)
l1.setText('<b><nobr>Energy (keV)</nobr></b>')
hbox.layout.addWidget(l1)
self.energy = MyQLineEdit(hbox)
self.energy.setText("%.3f" % energy)
self.energy._validator = qt.CLocaleQDoubleValidator(self.energy)
self.energy.setValidator(self.energy._validator)
self.energy.setToolTip('Press enter to validate your energy')
hbox.layout.addWidget(self.energy)
hbox.layout.addWidget(qt.HorizontalSpacer(hbox))
self.energy.editingFinished.connect(self._energySlot)
#parameters
self.__hbox2 = qt.QWidget(self)
hbox2 = self.__hbox2
layout.addWidget(hbox2)
hbox2.layout = qt.QHBoxLayout(hbox2)
hbox2.layout.setContentsMargins(0, 0, 0, 0)
hbox2.layout.setSpacing(0)
font = hbox2.font()
font.setBold(1)
hbox2.setFont(font)
l2 = qt.QLabel(hbox2)
l2.setText('Energy Threshold (eV)')
self.threshold = qt.QSpinBox(hbox2)
self.threshold.setMinimum(0)
self.threshold.setMaximum(1000)
self.threshold.setValue(int(threshold * 1000))
self.k = qt.QCheckBox(hbox2)
self.k.setText('K')
self.k.setChecked(1)
self.l1 = qt.QCheckBox(hbox2)
self.l1.setText('L1')
self.l1.setChecked(1)
self.l2 = qt.QCheckBox(hbox2)
self.l2.setText('L2')
self.l2.setChecked(1)
self.l3 = qt.QCheckBox(hbox2)
self.l3.setText('L3')
self.l3.setChecked(1)
self.m = qt.QCheckBox(hbox2)
self.m.setText('M')
self.m.setChecked(1)
self.threshold.valueChanged[int].connect(self._thresholdSlot)
self.k.clicked.connect(self.mySlot)
self.l1.clicked.connect(self.mySlot)
self.l2.clicked.connect(self.mySlot)
self.l3.clicked.connect(self.mySlot)
self.m.clicked.connect(self.mySlot)
hbox2.layout.addWidget(l2)
hbox2.layout.addWidget(self.threshold)
hbox2.layout.addWidget(self.k)
hbox2.layout.addWidget(self.l1)
hbox2.layout.addWidget(self.l2)
hbox2.layout.addWidget(self.l3)
hbox2.layout.addWidget(self.m)
if self.__useviewer:
self.__browsertext = qt.QTextEdit(self)
layout.addWidget(self.__browsertext)
self.setEnergy(energy)
def _build(self):
#self.layout= qt.QVBoxLayout(self)
self.splitter = qt.QSplitter(self)
self.splitter.setOrientation(qt.Qt.Vertical)
self.list = qt.QTreeWidget(self.splitter)
self.list.setSelectionMode(qt.QAbstractItemView.ExtendedSelection)
self.mainTab = qt.QTabWidget(self.splitter)
self.cntTable = SpecFileCntTable.SpecFileCntTable()
self.mcaTable = SpecFileMcaTable.SpecFileMcaTable()
self.mainTab.addTab(self.cntTable, str("Counters"))
self.mainTab.addTab(self.mcaTable, str("MCA"))
self.mainTab.setCurrentWidget(self.mcaTable)
autoBox = qt.QWidget(self)
autoBoxLayout = qt.QGridLayout(autoBox)
autoBoxLayout.setContentsMargins(0, 0, 0, 0)
autoBoxLayout.setSpacing(0)
self.autoOffBox = qt.QCheckBox(autoBox)
self.autoOffBox.setText("Auto OFF")
self.autoAddBox = qt.QCheckBox(autoBox)
self.autoAddBox.setText("Auto ADD")
self.autoReplaceBox = qt.QCheckBox(autoBox)
self.autoReplaceBox.setText("Auto REPLACE")
row = 0
autoBoxLayout.addWidget(self.autoOffBox, row, 0)
autoBoxLayout.addWidget(self.autoAddBox, row, 1)
autoBoxLayout.addWidget(self.autoReplaceBox, row, 2)
if self.autoReplace:
self.autoAddBox.setChecked(False)
self.autoReplaceBox.setChecked(True)
else:
self.autoAddBox.setChecked(True)
self.autoReplaceBox.setChecked(False)
row += 1
if OBJECT3D:
self.object3DBox = qt.QCheckBox(autoBox)
self.object3DBox.setText("3D On")
self.object3DBox.setToolTip(
"Use OpenGL and enable 2D & 3D selections")
autoBoxLayout.addWidget(self.object3DBox, row, 0)
self.mcaTable.sigMcaDeviceSelected.connect(self.mcaDeviceSelected)
self.meshBox = qt.QCheckBox(autoBox)
self.meshBox.setText("2D On")
self.meshBox.setToolTip("Enable 2D selections (mesh and scatter)")
autoBoxLayout.addWidget(self.meshBox, row, 1)
self.forceMcaBox = qt.QCheckBox(autoBox)
self.forceMcaBox.setText("Force MCA")
self.forceMcaBox.setToolTip("Interpret selections as MCA")
autoBoxLayout.addWidget(self.forceMcaBox, row, 2)
self.mainLayout.addWidget(self.splitter)
self.mainLayout.addWidget(autoBox)
# --- list headers
labels = ["X", "S#", "Command", "Points", "Nb. Mca"]
ncols = len(labels)
self.list.setColumnCount(ncols)
self.list.setHeaderLabels(labels)
#size=50
#self.list.header().resizeSection(0, size)
#self.list.header().resizeSection(1, size)
#self.list.header().resizeSection(2, 4 * size)
#self.list.header().resizeSection(3, size)
#self.list.header().resizeSection(4, size)
self.list.header().setStretchLastSection(False)
if QTVERSION > '5.0.0':
self.list.header().setSectionResizeMode(0,
qt.QHeaderView.Interactive)
self.list.header().setSectionResizeMode(1,
qt.QHeaderView.Interactive)
self.list.header().setSectionResizeMode(2,
qt.QHeaderView.Interactive)
self.list.header().setSectionResizeMode(3,
qt.QHeaderView.Interactive)
self.list.header().setSectionResizeMode(4,
qt.QHeaderView.Interactive)
fm = self.list.header().fontMetrics()
if hasattr(fm, "width"):
size = fm.width("X")
else:
size = fm.maxWidth()
self.list.header().setMinimumSectionSize(size)
self.list.header().resizeSection(0, size)
# self.list.header().resizeSection(1, size * 4)
self.list.header().resizeSection(2, size * 25)
# self.list.header().resizeSection(3, size * 7)
# self.list.header().resizeSection(4, size * 8)
elif QTVERSION < '4.2.0':
self.list.header().setResizeMode(0, qt.QHeaderView.Stretch)
self.list.header().setResizeMode(1, qt.QHeaderView.Stretch)
self.list.header().setResizeMode(2, qt.QHeaderView.Interactive)
self.list.header().setResizeMode(3, qt.QHeaderView.Stretch)
self.list.header().setResizeMode(4, qt.QHeaderView.Stretch)
else:
self.list.header().setResizeMode(0,
qt.QHeaderView.ResizeToContents)
self.list.header().setResizeMode(1,
qt.QHeaderView.ResizeToContents)
self.list.header().setResizeMode(2, qt.QHeaderView.Interactive)
self.list.header().setResizeMode(3,
qt.QHeaderView.ResizeToContents)
self.list.header().setResizeMode(4,
qt.QHeaderView.ResizeToContents)
# --- signal handling
self.list.itemSelectionChanged.connect(self.__selectionChanged)
self.list.setContextMenuPolicy(qt.Qt.CustomContextMenu)
self.list.customContextMenuRequested.connect(self.__contextMenu)
self.list.itemClicked[qt.QTreeWidgetItem, int].connect( \
self.__singleClicked)
self.list.itemDoubleClicked[qt.QTreeWidgetItem, int].connect( \
self.__doubleClicked)
self.cntTable.sigSpecFileCntTableSignal.connect(self._cntSignal)
if QTVERSION > '4.2.0':
self.list.setSortingEnabled(False)
self.list.header().sectionDoubleClicked[int].connect( \
self.__headerSectionDoubleClicked)
if OBJECT3D:
self.object3DBox.clicked.connect(self._setObject3DBox)
if hasattr(self, 'meshBox'):
self.meshBox.clicked.connect(self._setMeshBox)
self.autoOffBox.clicked.connect(self._setAutoOff)
self.autoAddBox.clicked.connect(self._setAutoAdd)
self.autoReplaceBox.clicked.connect(self._setAutoReplace)
self.forceMcaBox.clicked.connect(self._setForcedMca)
self.mainTab.currentChanged[int].connect(self._tabChanged)
self.disableMca = 0 #(type=="scan")
self.disableScan = 0 #(type=="mca")
# -- last scan watcher
if QTVERSION > '5.0.0':
self.lastScanWatcher = qt.QTimer()
self.lastScanWatcher.setSingleShot(True)
self.lastScanWatcher.setInterval(2000) # 2 seconds
self.lastScanWatcher.timeout.connect(self._timerSlot)
else:
self.lastScanWatcher = None
# --- context menu
self.data = None
self.scans = []
def __init__(self, parent=None, name="Colormap Dialog"):
qt.QDialog.__init__(self, parent)
self.setWindowTitle(name)
self.title = name
self.colormapList = ["Greyscale", "Reverse Grey", "Temperature",
"Red", "Green", "Blue", "Many"]
# histogramData is tupel(bins, counts)
self.histogramData = None
# default values
self.dataMin = -10
self.dataMax = 10
self.minValue = 0
self.maxValue = 1
self.colormapIndex = 2
self.colormapType = 0
self.autoscale = False
self.autoscale90 = False
# main layout
vlayout = qt.QVBoxLayout(self)
vlayout.setContentsMargins(10, 10, 10, 10)
vlayout.setSpacing(0)
# layout 1 : -combo to choose colormap
# -autoscale button
# -autoscale 90% button
hbox1 = qt.QWidget(self)
hlayout1 = qt.QHBoxLayout(hbox1)
vlayout.addWidget(hbox1)
hlayout1.setContentsMargins(0, 0, 0, 0)
hlayout1.setSpacing(10)
# combo
self.combo = qt.QComboBox(hbox1)
for colormap in self.colormapList:
self.combo.addItem(colormap)
self.combo.activated[int].connect(self.colormapChange)
hlayout1.addWidget(self.combo)
# autoscale
self.autoScaleButton = qt.QPushButton("Autoscale", hbox1)
self.autoScaleButton.setCheckable(True)
self.autoScaleButton.setAutoDefault(False)
self.autoScaleButton.toggled[bool].connect(self.autoscaleChange)
hlayout1.addWidget(self.autoScaleButton)
# autoscale 90%
self.autoScale90Button = qt.QPushButton("Autoscale 90%", hbox1)
self.autoScale90Button.setCheckable(True)
self.autoScale90Button.setAutoDefault(False)
self.autoScale90Button.toggled[bool].connect(self.autoscale90Change)
hlayout1.addWidget(self.autoScale90Button)
# hlayout
hbox0 = qt.QWidget(self)
self.__hbox0 = hbox0
hlayout0 = qt.QHBoxLayout(hbox0)
hlayout0.setContentsMargins(0, 0, 0, 0)
hlayout0.setSpacing(0)
vlayout.addWidget(hbox0)
#hlayout0.addStretch(10)
self.buttonGroup = qt.QButtonGroup()
g1 = qt.QCheckBox(hbox0)
g1.setText("Linear")
g2 = qt.QCheckBox(hbox0)
g2.setText("Logarithmic")
g3 = qt.QCheckBox(hbox0)
g3.setText("Gamma")
self.buttonGroup.addButton(g1, 0)
self.buttonGroup.addButton(g2, 1)
self.buttonGroup.addButton(g3, 2)
self.buttonGroup.setExclusive(True)
if self.colormapType == 1:
self.buttonGroup.button(1).setChecked(True)
elif self.colormapType == 2:
self.buttonGroup.button(2).setChecked(True)
else:
self.buttonGroup.button(0).setChecked(True)
hlayout0.addWidget(g1)
hlayout0.addWidget(g2)
hlayout0.addWidget(g3)
vlayout.addWidget(hbox0)
self.buttonGroup.buttonClicked[int].connect(self.buttonGroupChange)
vlayout.addSpacing(20)
hboxlimits = qt.QWidget(self)
hboxlimitslayout = qt.QHBoxLayout(hboxlimits)
hboxlimitslayout.setContentsMargins(0, 0, 0, 0)
hboxlimitslayout.setSpacing(0)
self.slider = None
vlayout.addWidget(hboxlimits)
vboxlimits = qt.QWidget(hboxlimits)
vboxlimitslayout = qt.QVBoxLayout(vboxlimits)
vboxlimitslayout.setContentsMargins(0, 0, 0, 0)
vboxlimitslayout.setSpacing(0)
hboxlimitslayout.addWidget(vboxlimits)
# hlayout 2 : - min label
# - min texte
hbox2 = qt.QWidget(vboxlimits)
self.__hbox2 = hbox2
hlayout2 = qt.QHBoxLayout(hbox2)
hlayout2.setContentsMargins(0, 0, 0, 0)
hlayout2.setSpacing(0)
#vlayout.addWidget(hbox2)
vboxlimitslayout.addWidget(hbox2)
hlayout2.addStretch(10)
self.minLabel = qt.QLabel(hbox2)
self.minLabel.setText("Minimum")
hlayout2.addWidget(self.minLabel)
hlayout2.addSpacing(5)
hlayout2.addStretch(1)
self.minText = MyQLineEdit(hbox2)
self.minText.setFixedWidth(150)
self.minText.setAlignment(qt.Qt.AlignRight)
self.minText.returnPressed[()].connect(self.minTextChanged)
hlayout2.addWidget(self.minText)
# hlayout 3 : - min label
# - min text
hbox3 = qt.QWidget(vboxlimits)
self.__hbox3 = hbox3
hlayout3 = qt.QHBoxLayout(hbox3)
hlayout3.setContentsMargins(0, 0, 0, 0)
hlayout3.setSpacing(0)
#vlayout.addWidget(hbox3)
vboxlimitslayout.addWidget(hbox3)
hlayout3.addStretch(10)
self.maxLabel = qt.QLabel(hbox3)
self.maxLabel.setText("Maximum")
hlayout3.addWidget(self.maxLabel)
hlayout3.addSpacing(5)
hlayout3.addStretch(1)
self.maxText = MyQLineEdit(hbox3)
self.maxText.setFixedWidth(150)
self.maxText.setAlignment(qt.Qt.AlignRight)
self.maxText.returnPressed[()].connect(self.maxTextChanged)
hlayout3.addWidget(self.maxText)
# Graph widget for color curve...
self.c = PlotWidget(self, backend=None)
self.c.setGraphXLabel("Data Values")
self.c.setInteractiveMode('select')
self.marge = (abs(self.dataMax) + abs(self.dataMin)) / 6.0
self.minmd = self.dataMin - self.marge
self.maxpd = self.dataMax + self.marge
self.c.setGraphXLimits(self.minmd, self.maxpd)
self.c.setGraphYLimits(-11.5, 11.5)
x = [self.minmd, self.dataMin, self.dataMax, self.maxpd]
y = [-10, -10, 10, 10 ]
self.c.addCurve(x, y,
legend="ConstrainedCurve",
color='black',
symbol='o',
linestyle='-')
self.markers = []
self.__x = x
self.__y = y
labelList = ["","Min", "Max", ""]
for i in range(4):
if i in [1, 2]:
draggable = True
color = "blue"
else:
draggable = False
color = "black"
#TODO symbol
legend = "%d" % i
self.c.addXMarker(x[i],
legend=legend,
text=labelList[i],
draggable=draggable,
color=color)
self.markers.append((legend, ""))
self.c.setMinimumSize(qt.QSize(250,200))
vlayout.addWidget(self.c)
self.c.sigPlotSignal.connect(self.chval)
# colormap window can not be resized
self.setFixedSize(vlayout.minimumSize())
def __init__(self, parent=None):
qt.QWidget.__init__(self, parent)
self.setWindowTitle("StackROIBatchWindow")
self.setWindowIcon(qt.QIcon(qt.QPixmap(IconDict['gioconda16'])))
self.mainLayout = qt.QGridLayout(self)
self.mainLayout.setContentsMargins(0, 0, 0, 0)
# configuration file
configLabel = qt.QLabel(self)
configLabel.setText("ROI Configuration File:")
self._configLine = qt.QLineEdit(self)
self._configLine.setReadOnly(True)
self._configButton = qt.QPushButton(self)
self._configButton.setText("Browse")
self._configButton.setAutoDefault(False)
self._configButton.clicked.connect(self.browseConfigurationFile)
# output directory
outLabel = qt.QLabel(self)
outLabel.setText("Output dir:")
self._outLine = qt.QLineEdit(self)
self._outLine.setReadOnly(True)
self._outButton = qt.QPushButton(self)
self._outButton.setText('Browse')
self._outButton.setAutoDefault(False)
self._outButton.clicked.connect(self.browseOutputDir)
# output file name
fileLabel = qt.QLabel(self)
fileLabel.setText("Output file root:")
self._fileLine = qt.QLineEdit(self)
self._fileLine.setReadOnly(False)
self._fileLine.setText("ROI_images")
boxLabel = qt.QLabel(self)
boxLabel.setText("Options:")
self._boxContainer = qt.QWidget(self)
self._boxContainerLayout = qt.QHBoxLayout(self._boxContainer)
self._boxContainerLayout.setContentsMargins(0, 0, 0, 0)
self._boxContainerLayout.setSpacing(0)
# Net ROI
self._netBox = qt.QCheckBox(self._boxContainer)
self._netBox.setText("Calculate Net ROI")
self._netBox.setChecked(True)
self._netBox.setEnabled(False)
# xAtMax
self._xAtMaxBox = qt.QCheckBox(self._boxContainer)
self._xAtMaxBox.setText("Image X at Min/Max. Y")
self._xAtMaxBox.setChecked(False)
self._xAtMaxBox.setEnabled(True)
text = "Calculate the channel of the maximum and\n"
text += "the minimum value in the region.\n"
self._xAtMaxBox.setToolTip(text)
# generate tiff files
self._tiffBox = qt.QCheckBox(self._boxContainer)
self._tiffBox.setText("generate TIFF files")
self._tiffBox.setChecked(False)
self._tiffBox.setEnabled(True)
self._boxContainerLayout.addWidget(self._netBox)
self._boxContainerLayout.addWidget(self._xAtMaxBox)
self._boxContainerLayout.addWidget(self._tiffBox)
self.mainLayout.addWidget(configLabel, 0, 0)
self.mainLayout.addWidget(self._configLine, 0, 1)
self.mainLayout.addWidget(self._configButton, 0, 2)
self.mainLayout.addWidget(outLabel, 1, 0)
self.mainLayout.addWidget(self._outLine, 1, 1)
self.mainLayout.addWidget(self._outButton, 1, 2)
self.mainLayout.addWidget(fileLabel, 2, 0)
self.mainLayout.addWidget(self._fileLine, 2, 1)
self.mainLayout.addWidget(boxLabel, 3, 0)
self.mainLayout.addWidget(self._boxContainer, 3, 1, 1, 1)
def __init__(self, parent=None):
super(ObjectPrintConfigurationWidget, self).__init__(parent)
self.mainLayout = qt.QGridLayout(self)
self.mainLayout.setContentsMargins(0, 0, 0, 0)
self.mainLayout.setSpacing(2)
hbox = qt.QWidget()
hboxLayout = qt.QHBoxLayout(hbox)
hboxLayout.setContentsMargins(0, 0, 0, 0)
hboxLayout.setSpacing(2)
label = qt.QLabel(self)
label.setText("Units")
label.setAlignment(qt.Qt.AlignCenter)
self._pageButton = qt.QRadioButton()
self._pageButton.setText("Page")
self._inchButton = qt.QRadioButton()
self._inchButton.setText("Inches")
self._cmButton = qt.QRadioButton()
self._cmButton.setText("Centimeters")
self._buttonGroup = qt.QButtonGroup(self)
self._buttonGroup.addButton(self._pageButton)
self._buttonGroup.addButton(self._inchButton)
self._buttonGroup.addButton(self._cmButton)
self._buttonGroup.setExclusive(True)
# units
self.mainLayout.addWidget(label, 0, 0, 1, 4)
#self.mainLayout.addWidget(self._pageButton, 0, 1)
#self.mainLayout.addWidget(self._inchButton, 0, 2)
#self.mainLayout.addWidget(self._cmButton, 0, 3)
hboxLayout.addWidget(self._pageButton)
hboxLayout.addWidget(self._inchButton)
hboxLayout.addWidget(self._cmButton)
self.mainLayout.addWidget(hbox, 1, 0, 1, 4)
self._pageButton.setChecked(True)
# xOffset
label = qt.QLabel(self)
label.setText("X Offset:")
self.mainLayout.addWidget(label, 2, 0)
self._xOffset = qt.QLineEdit(self)
validator = qt.CLocaleQDoubleValidator(None)
self._xOffset.setValidator(validator)
self._xOffset.setText("0.0")
self.mainLayout.addWidget(self._xOffset, 2, 1)
# yOffset
label = qt.QLabel(self)
label.setText("Y Offset:")
self.mainLayout.addWidget(label, 2, 2)
self._yOffset = qt.QLineEdit(self)
validator = qt.CLocaleQDoubleValidator(None)
self._yOffset.setValidator(validator)
self._yOffset.setText("0.0")
self.mainLayout.addWidget(self._yOffset, 2, 3)
# width
label = qt.QLabel(self)
label.setText("Width:")
self.mainLayout.addWidget(label, 3, 0)
self._width = qt.QLineEdit(self)
validator = qt.CLocaleQDoubleValidator(None)
self._width.setValidator(validator)
self._width.setText("0.5")
self.mainLayout.addWidget(self._width, 3, 1)
# height
label = qt.QLabel(self)
label.setText("Height:")
self.mainLayout.addWidget(label, 3, 2)
self._height = qt.QLineEdit(self)
validator = qt.CLocaleQDoubleValidator(None)
self._height.setValidator(validator)
self._height.setText("0.5")
self.mainLayout.addWidget(self._height, 3, 3)
# aspect ratio
self._aspect = qt.QCheckBox(self)
self._aspect.setText("Keep screen aspect ratio")
self._aspect.setChecked(True)
self.mainLayout.addWidget(self._aspect, 4, 1, 1, 2)
def build(self, spacing=2):
layout = qt.QHBoxLayout(self)
layout.setContentsMargins(0, 0, 0, 0)
layout.setSpacing(spacing)
#column 0
c0 = qt.QWidget(self)
c0.layout = qt.QVBoxLayout(c0)
c0.layout.setContentsMargins(0, 0, 0, 0)
c0.layout.setSpacing(spacing)
c0l0 = qt.QLabel(c0)
c0l0.setText("Flux (photons/s)")
c0l1 = qt.QLabel(c0)
c0l1.setText("Active Area (cm2)")
c0.layout.addWidget(c0l0)
c0.layout.addWidget(c0l1)
#column 1
c1 = qt.QWidget(self)
c1.layout = qt.QVBoxLayout(c1)
c1.layout.setContentsMargins(0, 0, 0, 0)
c1.layout.setSpacing(spacing)
self.flux = MyQLineEdit(c1)
self.flux.setValidator(qt.QDoubleValidator(self.flux))
self.area = MyQLineEdit(c1)
self.area.setValidator(qt.QDoubleValidator(self.area))
c1.layout.addWidget(self.flux)
c1.layout.addWidget(self.area)
#column 2
c2 = qt.QWidget(self)
c2.layout = qt.QVBoxLayout(c2)
c2.layout.setContentsMargins(0, 0, 0, 0)
c2.layout.setSpacing(spacing)
c2l0 = qt.QLabel(c2)
c2l0.setText("x time(seconds)")
c2l1 = qt.QLabel(c2)
c2l1.setText("distance (cm)")
c2.layout.addWidget(c2l0)
c2.layout.addWidget(c2l1)
#column 3
c3 = qt.QWidget(self)
c3.layout = qt.QGridLayout(c3)
c3.layout.setContentsMargins(0, 0, 0, 0)
c3.layout.setSpacing(spacing)
self.time = MyQLineEdit(c3)
self.time.setValidator(qt.QDoubleValidator(self.time))
self.autoTimeCheckBox = qt.QCheckBox(c3)
self.autoTimeCheckBox.setText("Use Automatic Factor")
self.autoTimeCheckBox.setChecked(False)
self.autoTimeCheckBox.setToolTip(
"Attempt to read from the incoming data generating an error if factor not present"
)
self.distance = MyQLineEdit(c3)
self.distance.setValidator(qt.QDoubleValidator(self.distance))
c3.layout.addWidget(self.time, 0, 0)
c3.layout.addWidget(self.autoTimeCheckBox, 0, 1)
c3.layout.addWidget(self.distance, 1, 0)
layout.addWidget(c0)
layout.addWidget(c1)
layout.addWidget(c2)
layout.addWidget(c3)
def _build(self):
layout = qt.QVBoxLayout(self)
layout.setContentsMargins(11, 11, 11, 11)
gridwidget = qt.QWidget(self)
grid = QGridLayout(gridwidget)
grid.setContentsMargins(0, 0, 0, 0)
grid.setSpacing(6)
self.transmissionCheckBox = qt.QCheckBox(gridwidget)
self.transmissionCheckBox.setText("Transmission Tube")
voltage = qt.QLabel(gridwidget)
voltage.setText("Voltage")
self.voltage = qt.QLineEdit(gridwidget)
grid.addMultiCellWidget(self.transmissionCheckBox, 0 ,0, 0, 1)
grid.addWidget(voltage, 0 ,2)
grid.addWidget(self.voltage, 0 ,3)
#materials
mlabel = qt.QLabel(gridwidget)
mlabel.setText("Material")
dlabel = qt.QLabel(gridwidget)
dlabel.setText("Density (g/cm3)")
tlabel = qt.QLabel(gridwidget)
tlabel.setText("Thickness (cm)")
#anode
anodelabel = qt.QLabel(gridwidget)
anodelabel.setText("Anode")
self.anodeCombo = MyQComboBox(gridwidget, options = Elements.ElementList)
self.anodeDensity = qt.QLineEdit(gridwidget)
self.anodeThickness = qt.QLineEdit(gridwidget)
#window
windowlabel = qt.QLabel(gridwidget)
windowlabel.setText("Window")
self.windowCombo = MyQComboBox(gridwidget, options = Elements.ElementList)
self.windowDensity = qt.QLineEdit(gridwidget)
self.windowThickness = qt.QLineEdit(gridwidget)
grid.addWidget(mlabel, 1 ,1)
grid.addWidget(dlabel, 1 ,2)
grid.addWidget(tlabel, 1 ,3)
grid.addWidget(anodelabel, 2, 0)
grid.addWidget(self.anodeCombo, 2, 1)
grid.addWidget(self.anodeDensity, 2, 2)
grid.addWidget(self.anodeThickness, 2, 3)
grid.addWidget(windowlabel, 3, 0)
grid.addWidget(self.windowCombo, 3, 1)
grid.addWidget(self.windowDensity, 3, 2)
grid.addWidget(self.windowThickness, 3, 3)
#filter1
filter1label = qt.QLabel(gridwidget)
filter1label.setText("Filter")
self.filter1Combo = MyQComboBox(gridwidget, options = Elements.ElementList)
self.filter1Density = qt.QLineEdit(gridwidget)
self.filter1Thickness = qt.QLineEdit(gridwidget)
grid.addWidget(filter1label, 4, 0)
grid.addWidget(self.filter1Combo, 4, 1)
grid.addWidget(self.filter1Density, 4, 2)
grid.addWidget(self.filter1Thickness, 4, 3)
#angles
alphaelabel = qt.QLabel(gridwidget)
alphaelabel.setText("Alpha electron")
self.alphaE = qt.QLineEdit(gridwidget)
alphaxlabel = qt.QLabel(gridwidget)
alphaxlabel.setText("Alpha x-ray")
self.alphaX = qt.QLineEdit(gridwidget)
grid.addWidget(alphaelabel, 5, 2)
grid.addWidget(self.alphaE, 5, 3)
grid.addWidget(alphaxlabel, 6, 2)
grid.addWidget(self.alphaX, 6, 3)
#delta energy
deltalabel = qt.QLabel(gridwidget)
deltalabel.setText("Delta energy (keV) just for plotting")
self.delta = qt.QLineEdit(gridwidget)
grid.addMultiCellWidget(deltalabel, 7, 7, 0, 3)
grid.addWidget(self.delta, 7, 3)
layout.addWidget(gridwidget)
def __init__(self,parent = None,name = None,fl = 0):
qt.QWidget.__init__(self,parent)
self.setWindowTitle(str("FitConfigGUI"))
FitConfigGUILayout = qt.QHBoxLayout(self)
FitConfigGUILayout.setContentsMargins(11, 11, 11, 11)
FitConfigGUILayout.setSpacing(6)
Layout9 = qt.QHBoxLayout(None)
Layout9.setContentsMargins(0, 0, 0, 0)
Layout9.setSpacing(6)
Layout2 = qt.QGridLayout(None)
Layout2.setContentsMargins(0, 0, 0, 0)
Layout2.setSpacing(6)
self.BkgComBox = qt.QComboBox(self)
self.BkgComBox.addItem(str("Add Background"))
Layout2.addWidget(self.BkgComBox,1,1)
self.BkgLabel = qt.QLabel(self)
self.BkgLabel.setText(str("Background"))
Layout2.addWidget(self.BkgLabel,1,0)
self.FunComBox = qt.QComboBox(self)
self.FunComBox.addItem(str("Add Function(s)"))
Layout2.addWidget(self.FunComBox,0,1)
self.FunLabel = qt.QLabel(self)
self.FunLabel.setText(str("Function"))
Layout2.addWidget(self.FunLabel,0,0)
Layout9.addLayout(Layout2)
spacer = qt.QSpacerItem(20,20,
qt.QSizePolicy.Expanding,
qt.QSizePolicy.Minimum)
Layout9.addItem(spacer)
Layout6 = qt.QGridLayout(None)
Layout6.setContentsMargins(0, 0, 0, 0)
Layout6.setSpacing(6)
self.WeightCheckBox = qt.QCheckBox(self)
self.WeightCheckBox.setText(str("Weight"))
Layout6.addWidget(self.WeightCheckBox,0,0)
self.MCACheckBox = qt.QCheckBox(self)
self.MCACheckBox.setText(str("MCA Mode"))
Layout6.addWidget(self.MCACheckBox,1,0)
Layout9.addLayout(Layout6)
Layout6_2 = qt.QGridLayout(None)
Layout6_2.setContentsMargins(0, 0, 0, 0)
Layout6_2.setSpacing(6)
self.AutoFWHMCheckBox = qt.QCheckBox(self)
self.AutoFWHMCheckBox.setText(str("Auto FWHM"))
Layout6_2.addWidget(self.AutoFWHMCheckBox,0,0)
self.AutoScalingCheckBox = qt.QCheckBox(self)
self.AutoScalingCheckBox.setText(str("Auto Scaling"))
Layout6_2.addWidget(self.AutoScalingCheckBox,1,0)
Layout9.addLayout(Layout6_2)
spacer_2 = qt.QSpacerItem(20,20,qt.QSizePolicy.Expanding,
qt.QSizePolicy.Minimum)
Layout9.addItem(spacer_2)
Layout5 = qt.QGridLayout(None)
Layout5.setContentsMargins(0, 0, 0, 0)
Layout5.setSpacing(6)
self.PrintPushButton = qt.QPushButton(self)
self.PrintPushButton.setText(str("Print"))
Layout5.addWidget(self.PrintPushButton,1,0)
self.ConfigureButton = qt.QPushButton(self)
self.ConfigureButton.setText(str("Configure"))
Layout5.addWidget(self.ConfigureButton,0,0)
Layout9.addLayout(Layout5)
FitConfigGUILayout.addLayout(Layout9)
def __init__(self, parent=None):
qt.QGroupBox.__init__(self, parent)
self.setTitle("Function Definition")
self.mainLayout = qt.QGridLayout(self)
self.mainLayout.setContentsMargins(2, 2, 2, 2)
self.mainLayout.setSpacing(2)
row = 0
#actual fit function
self.fitFunctionCheckBox = qt.QCheckBox(self)
self.fitFunctionCheckBox.setText("Fit Function to be used")
self.fitFunctionCombo = qt.QComboBox(self)
self.fitFunctionCombo.addItem(str("None"))
self.fitFunctionCombo.activated[int].connect( \
self._fitFunctionComboActivated)
self.fitFunctionSetupButton = qt.QPushButton(self)
self.fitFunctionSetupButton.setText('SETUP')
self.fitFunctionSetupButton.setAutoDefault(False)
self.fitFunctionSetupButton.hide()
self.mainLayout.addWidget(self.fitFunctionCheckBox, row, 0)
self.mainLayout.addWidget(qt.HorizontalSpacer(self), row, 1)
self.mainLayout.addWidget(self.fitFunctionSetupButton, row, 2)
self.mainLayout.addWidget(self.fitFunctionCombo, row, 3)
row += 1
#background
self.backgroundCheckBox = qt.QCheckBox(self)
self.backgroundCheckBox.setText("Background function")
self.backgroundCombo = qt.QComboBox(self)
self.backgroundCombo.addItem(str("None"))
self.backgroundCombo.activated[int].connect( \
self._backgroundComboActivated)
self.backgroundSetupButton = qt.QPushButton(self)
self.backgroundSetupButton.setText('SETUP')
self.backgroundSetupButton.setAutoDefault(False)
self.backgroundSetupButton.hide()
self.mainLayout.addWidget(self.backgroundCheckBox, row, 0)
self.mainLayout.addWidget(qt.HorizontalSpacer(self), row, 1)
self.mainLayout.addWidget(self.backgroundSetupButton, row, 2)
self.mainLayout.addWidget(self.backgroundCombo, row, 3)
row += 1
#stripping
self.stripCheckBox = qt.QCheckBox(self)
self.stripCheckBox.setText(
"Non-analytical (or estimation) background algorithm")
self.stripCombo = qt.QComboBox(self)
self.stripCombo.addItem(str("Strip"))
self.stripCombo.addItem(str("SNIP"))
self.stripSetupButton = qt.QPushButton(self)
self.stripSetupButton.setText('SETUP')
self.stripSetupButton.setAutoDefault(False)
self.stripCombo.activated[int].connect(self._stripComboActivated)
self.mainLayout.addWidget(self.stripCheckBox, row, 0)
self.mainLayout.addWidget(qt.HorizontalSpacer(self), row, 1)
self.mainLayout.addWidget(self.stripSetupButton, row, 2)
self.mainLayout.addWidget(self.stripCombo, row, 3)
row += 1
self.snipWidthLabel = qt.QLabel(self)
self.snipWidthLabel.setText(str("SNIP Background Width"))
self.snipWidthSpin = qt.QSpinBox(self)
self.snipWidthSpin.setMinimum(1)
self.snipWidthSpin.setMaximum(300)
self.snipWidthSpin.setValue(10)
self.mainLayout.addWidget(self.snipWidthLabel, row, 0)
self.mainLayout.addWidget(self.snipWidthSpin, row, 3)
row += 1
self.stripWidthLabel = qt.QLabel(self)
self.stripWidthLabel.setText(str("Strip Background Width"))
self.stripWidthSpin = qt.QSpinBox(self)
self.stripWidthSpin.setMinimum(1)
self.stripWidthSpin.setMaximum(100)
self.stripWidthSpin.setValue(4)
self.mainLayout.addWidget(self.stripWidthLabel, row, 0)
self.mainLayout.addWidget(self.stripWidthSpin, row, 3)
row += 1
self.stripIterLabel = qt.QLabel(self)
self.stripIterLabel.setText(str("Strip Background Iterations"))
self.stripIterSpin = qt.QSpinBox(self)
self.stripIterSpin.setMinimum(0)
self.stripIterSpin.setMaximum(100000)
self.stripIterSpin.setValue(5000)
self.mainLayout.addWidget(self.stripIterLabel, row, 0)
self.mainLayout.addWidget(self.stripIterSpin, row, 3)
row += 1
self.stripFilterLabel = qt.QLabel(self)
text = str("Strip Background Smoothing Width (Savitsky-Golay)")
self.stripFilterLabel.setText(text)
self.stripFilterSpin = qt.QSpinBox(self)
self.stripFilterSpin.setMinimum(0)
self.stripFilterSpin.setMaximum(40)
self.stripFilterSpin.setSingleStep(2)
self.mainLayout.addWidget(self.stripFilterLabel, row, 0)
self.mainLayout.addWidget(self.stripFilterSpin, row, 3)
row += 1
#anchors
self.anchorsContainer = qt.QWidget(self)
anchorsContainerLayout = qt.QHBoxLayout(self.anchorsContainer)
anchorsContainerLayout.setContentsMargins(2, 2, 2, 2)
anchorsContainerLayout.setSpacing(2)
self.stripAnchorsCheckBox = qt.QCheckBox(self.anchorsContainer)
self.stripAnchorsCheckBox.setText(str("Strip Background use Anchors"))
anchorsContainerLayout.addWidget(self.stripAnchorsCheckBox)
self.stripAnchorsList = []
for i in range(4):
anchor = qt.QLineEdit(self.anchorsContainer)
anchor._v = qt.QDoubleValidator(anchor)
anchor.setValidator(anchor._v)
anchor.setText("0.0")
anchorsContainerLayout.addWidget(anchor)
self.stripAnchorsList.append(anchor)
self.mainLayout.addWidget(self.anchorsContainer, row, 0, 1, 4)
row += 1
#signals
self.fitFunctionSetupButton.clicked.connect(self.setupFitFunction)
self.backgroundSetupButton.clicked.connect(self.setupBackground)
self.stripSetupButton.clicked.connect(self.setupStrip)
def build(self):
self.mainLayout = qt.QGridLayout(self)
self.mainLayout.setContentsMargins(11, 11, 11, 11)
self.mainLayout.setSpacing(6)
#strip algorithm
self.stripComboLabel = qt.QLabel(self)
self.stripComboLabel.setText(
"Non-analytical (or estimation) background algorithm")
self.stripCombo = qt.QComboBox(self)
self.stripCombo.addItem(str("Strip"))
self.stripCombo.addItem(str("SNIP"))
self.stripCombo.activated[int].connect(self._stripComboActivated)
#SNIP width
self.snipWidthLabel = qt.QLabel(self)
self.snipWidthLabel.setText(str("SNIP Background Width"))
self.snipWidthSpin = qt.QSpinBox(self)
self.snipWidthSpin.setMaximum(300)
self.snipWidthSpin.setMinimum(0)
self.snipWidthSpin.valueChanged[int].connect(self._emitSignal)
#Strip width
self.stripWidthLabel = qt.QLabel(self)
self.stripWidthLabel.setText(str("Strip Background Width"))
self.stripWidthSpin = qt.QSpinBox(self)
self.stripWidthSpin.setMaximum(100)
self.stripWidthSpin.setMinimum(1)
self.stripWidthSpin.valueChanged[int].connect(self._emitSignal)
#Strip iterations
self.stripIterLabel = qt.QLabel(self)
self.stripIterLabel.setText(str("Strip Background Iterations"))
self.stripIterValue = qt.QLineEdit(self)
validator = qt.QIntValidator(self.stripIterValue)
self.stripIterValue._v = validator
self.stripIterValue.editingFinished[()].connect(self._emitSignal)
#Strip smoothing
self.stripFilterLabel = qt.QLabel(self)
self.stripFilterLabel.setText(
str("Strip Background Smoothing Width (Savitsky-Golay)"))
self.stripFilterSpin = qt.QSpinBox(self)
self.stripFilterSpin.setMinimum(1)
self.stripFilterSpin.setMaximum(40)
self.stripFilterSpin.setSingleStep(2)
self.stripFilterSpin.valueChanged[int].connect(self._emitSignal)
#anchors
self.anchorsContainer = qt.QWidget(self)
anchorsContainerLayout = qt.QHBoxLayout(self.anchorsContainer)
anchorsContainerLayout.setContentsMargins(0, 0, 0, 0)
anchorsContainerLayout.setSpacing(2)
self.stripAnchorsFlagCheck = qt.QCheckBox(self.anchorsContainer)
self.stripAnchorsFlagCheck.setText(str("Strip Background use Anchors"))
self.stripAnchorsFlagCheck.stateChanged[int].connect( \
self._emitSignal)
anchorsContainerLayout.addWidget(self.stripAnchorsFlagCheck)
#self.iterSpin = qt.QSpinBox(self)
#self.iterSpin.setMinimum(1)
maxnchannel = 16384 * 4
self.stripAnchorsList = []
for i in range(4):
anchorSpin = qt.QSpinBox(self.anchorsContainer)
anchorSpin.setMinimum(0)
anchorSpin.setMaximum(maxnchannel)
anchorSpin.valueChanged[int].connect(self._emitSignal)
anchorsContainerLayout.addWidget(anchorSpin)
self.stripAnchorsList.append(anchorSpin)
self.mainLayout.setColumnStretch(0, 1)
row = 0
self.mainLayout.addWidget(self.stripComboLabel, row, 0)
self.mainLayout.addWidget(self.stripCombo, row, 4)
row += 1
self.mainLayout.addWidget(self.snipWidthLabel, row, 0)
self.mainLayout.addWidget(self.snipWidthSpin, row, 4)
row += 1
self.mainLayout.addWidget(self.stripWidthLabel, row, 0)
self.mainLayout.addWidget(self.stripWidthSpin, row, 4)
row += 1
self.mainLayout.addWidget(self.stripIterLabel, row, 0)
self.mainLayout.addWidget(self.stripIterValue, row, 4)
row += 1
self.mainLayout.addWidget(self.stripFilterLabel, row, 0)
self.mainLayout.addWidget(self.stripFilterSpin, row, 4)
row += 1
self.mainLayout.addWidget(self.anchorsContainer, row, 0, 1, 5)
self._stripComboActivated(0)
def __init__(self, parent=None):
qt.QGroupBox.__init__(self, parent)
self.setTitle("Fit Control")
self.mainLayout = qt.QGridLayout(self)
self.mainLayout.setContentsMargins(2, 2, 2, 2)
self.mainLayout.setSpacing(2)
row = 0
#linear fit
self.fitAlgorithmLabel = qt.QLabel(self)
self.fitAlgorithmLabel.setText("Fit algorithm")
self.fitAlgorithmCombo = qt.QComboBox(self)
self.fitAlgorithmCombo.addItem(str("Levenberg-Marquardt"))
self.fitAlgorithmCombo.addItem(str("Linear Fit"))
self.mainLayout.addWidget(self.fitAlgorithmLabel, row, 0)
self.mainLayout.addWidget(qt.HorizontalSpacer(self), row, 1)
self.mainLayout.addWidget(self.fitAlgorithmCombo, row, 3)
row += 1
#weighting
self.weightLabel = qt.QLabel(self)
self.weightLabel.setText("Statistical weighting of data")
self.weightCombo = qt.QComboBox(self)
self.weightCombo.addItem(str("NO Weight"))
self.weightCombo.addItem(str("Poisson (1/Y)"))
self.mainLayout.addWidget(self.weightLabel, row, 0)
self.mainLayout.addWidget(qt.HorizontalSpacer(self), row, 1)
self.mainLayout.addWidget(self.weightCombo, row, 3)
row += 1
#function estimation policy
self.functionEstimationLabel = qt.QLabel(self)
self.functionEstimationLabel.setText("Function estimation policy")
self.functionEstimationCombo = qt.QComboBox(self)
self.functionEstimationCombo.addItem(str("Use configuration"))
self.functionEstimationCombo.addItem(str("Estimate once"))
self.functionEstimationCombo.addItem(str("Estimate always"))
self.functionEstimationCombo.setCurrentIndex(2)
self.mainLayout.addWidget(self.functionEstimationLabel, row, 0)
self.mainLayout.addWidget(self.functionEstimationCombo, row, 3)
row += 1
#background estimation policy
self.backgroundEstimationLabel = qt.QLabel(self)
text = "Background estimation policy"
self.backgroundEstimationLabel.setText(text)
self.backgroundEstimationCombo = qt.QComboBox(self)
self.backgroundEstimationCombo.addItem(str("Use configuration"))
self.backgroundEstimationCombo.addItem(str("Estimate once"))
self.backgroundEstimationCombo.addItem(str("Estimate always"))
self.backgroundEstimationCombo.setCurrentIndex(2)
self.mainLayout.addWidget(self.backgroundEstimationLabel, row, 0)
self.mainLayout.addWidget(self.backgroundEstimationCombo, row, 3)
row += 1
#number of iterations
self.iterLabel = qt.QLabel(self)
self.iterLabel.setText(str("Maximum number of fit iterations"))
self.iterSpin = qt.QSpinBox(self)
self.iterSpin.setMinimum(1)
self.iterSpin.setMaximum(10000)
self.iterSpin.setValue(10)
self.mainLayout.addWidget(self.iterLabel, row, 0)
self.mainLayout.addWidget(qt.HorizontalSpacer(self), row, 1)
self.mainLayout.addWidget(self.iterSpin, row, 3)
row += 1
#chi square handling
self.chi2Label = qt.QLabel(self)
self.chi2Label.setText(str("Minimum chi^2 difference (%)"))
if 0:
self.chi2Value = qt.QLineEdit(self)
self.chi2Value._v = qt.QDoubleValidator(self.chi2Value)
self.chi2Value.setValidator(self.chi2Value._v)
self.chi2Value.setText(str("0.001"))
else:
self.chi2Value = qt.QDoubleSpinBox(self)
self.chi2Value.setDecimals(4)
self.chi2Value.setMinimum(0.0001)
self.chi2Value.setMaximum(100.)
self.chi2Value.setSingleStep(0.0001)
self.chi2Value.setValue(0.001)
self.mainLayout.addWidget(self.chi2Label, row, 0)
self.mainLayout.addWidget(qt.HorizontalSpacer(self), row, 1)
self.mainLayout.addWidget(self.chi2Value, row, 3)
row += 1
#fitting region
self.regionTopLine = qt.QFrame(self)
self.regionTopLine.setFrameShape(qt.QFrame.HLine)
self.regionTopLine.setFrameShadow(qt.QFrame.Sunken)
self.regionTopLine.setFrameShape(qt.QFrame.HLine)
self.regionCheckBox = qt.QCheckBox(self)
self.regionCheckBox.setText(str("Limit fitting region to :"))
self.firstLabel = qt.QLabel(self)
firstLabel_font = qt.QFont(self.firstLabel.font())
firstLabel_font.setItalic(1)
self.firstLabel.setFont(firstLabel_font)
self.firstLabel.setText(str("First X Value "))
self.firstLabel.setAlignment(qt.Qt.AlignVCenter | qt.Qt.AlignRight)
self.firstValue = qt.QLineEdit(self)
self.firstValue._v = qt.QDoubleValidator(self.firstValue)
self.firstValue.setValidator(self.firstValue._v)
self.firstValue.setText(str("0."))
self.lastLabel = qt.QLabel(self)
lastLabel_font = qt.QFont(self.lastLabel.font())
lastLabel_font.setItalic(1)
self.lastLabel.setFont(lastLabel_font)
self.lastLabel.setText(str("Last X Value "))
self.lastLabel.setAlignment(qt.Qt.AlignVCenter | qt.Qt.AlignRight)
self.lastValue = qt.QLineEdit(self)
self.lastValue._v = qt.QDoubleValidator(self.lastValue)
self.lastValue.setValidator(self.lastValue._v)
self.lastValue.setText(str("1000."))
self.regionBottomLine = qt.QFrame(self)
self.regionBottomLine.setFrameShape(qt.QFrame.HLine)
self.regionBottomLine.setFrameShadow(qt.QFrame.Sunken)
self.regionBottomLine.setFrameShape(qt.QFrame.HLine)
self.mainLayout.addWidget(self.regionTopLine, row, 0, 1, 4)
row += 1
self.mainLayout.addWidget(self.regionCheckBox, row, 0)
self.mainLayout.addWidget(self.firstLabel, row, 1)
self.mainLayout.addWidget(self.firstValue, row, 3)
row += 1
self.mainLayout.addWidget(self.lastLabel, row, 1)
self.mainLayout.addWidget(self.lastValue, row, 3)
row += 1
self.mainLayout.addWidget(self.regionBottomLine, row, 0, 1, 4)
row += 1
def _build(self):
self.mainLayout = qt.QVBoxLayout(self)
autoBox = qt.QWidget(self)
autoBoxLayout = qt.QGridLayout(autoBox)
autoBoxLayout.setContentsMargins(0, 0, 0, 0)
autoBoxLayout.setSpacing(0)
self.autoOffBox = qt.QCheckBox(autoBox)
self.autoOffBox.setText("Auto OFF")
self.autoAddBox = qt.QCheckBox(autoBox)
self.autoAddBox.setText("Auto ADD")
self.autoReplaceBox = qt.QCheckBox(autoBox)
self.autoReplaceBox.setText("Auto REPLACE")
row = 0
autoBoxLayout.addWidget(self.autoOffBox, row, 0)
autoBoxLayout.addWidget(self.autoAddBox, row, 1)
autoBoxLayout.addWidget(self.autoReplaceBox, row, 2)
if self.autoReplace:
self.autoAddBox.setChecked(False)
self.autoReplaceBox.setChecked(True)
else:
self.autoAddBox.setChecked(True)
self.autoReplaceBox.setChecked(False)
row += 1
self.object3DBox = qt.QCheckBox(autoBox)
self.object3DBox.setText("3D On")
self.object3DBox.setToolTip("Use OpenGL and Enable 3-Axes selections")
autoBoxLayout.addWidget(self.object3DBox, row, 0)
self.meshBox = qt.QCheckBox(autoBox)
self.meshBox.setText("2D On")
self.meshBox.setToolTip("Enable 2-Axes selections (mesh and scatter)")
autoBoxLayout.addWidget(self.meshBox, row, 1)
self.forceMcaBox = qt.QCheckBox(autoBox)
self.forceMcaBox.setText("Force MCA")
self.forceMcaBox.setToolTip("Interpret selections as MCA")
autoBoxLayout.addWidget(self.forceMcaBox, row, 2)
self.mainLayout.addWidget(autoBox)
self.buttonBox = qt.QWidget(self)
buttonBox = self.buttonBox
self.buttonBoxLayout = qt.QHBoxLayout(buttonBox)
self.addButton = qt.QPushButton(buttonBox)
self.addButton.setText("ADD")
self.removeButton = qt.QPushButton(buttonBox)
self.removeButton.setText("REMOVE")
self.replaceButton = qt.QPushButton(buttonBox)
self.replaceButton.setText("REPLACE")
self.buttonBoxLayout.addWidget(self.addButton)
self.buttonBoxLayout.addWidget(self.removeButton)
self.buttonBoxLayout.addWidget(self.replaceButton)
self.mainLayout.addWidget(buttonBox)
# --- signal handling
self.object3DBox.clicked.connect(self._setObject3DBox)
self.meshBox.clicked.connect(self._setMeshBox)
self.autoOffBox.clicked.connect(self._setAutoOff)
self.autoAddBox.clicked.connect(self._setAutoAdd)
self.autoReplaceBox.clicked.connect(self._setAutoReplace)
self.forceMcaBox.clicked.connect(self._setForcedMca)
self.addButton.clicked.connect(self._addClickedSlot)
self.removeButton.clicked.connect(self._removeClicked)
self.replaceButton.clicked.connect(self._replaceClicked)
def __init__(self, parent=None, **kw):
qt.QDialog.__init__(self, parent)
self.setWindowTitle("Matplotlib preview - Resize to your taste")
self.mainLayout = qt.QGridLayout(self)
self.mainLayout.setContentsMargins(0, 0, 0, 0)
self.mainLayout.setSpacing(0)
self._lastGoodSize = None
self.axesLabelsWidget = qt.QWidget(self)
layout = qt.QHBoxLayout(self.axesLabelsWidget)
layout.setContentsMargins(0, 0, 0, 0)
layout.setSpacing(2)
xLabelLabel = qt.QLabel(self.axesLabelsWidget)
xLabelLabel.setText("X Axis Label: ")
self.xLabelLine = qt.QLineEdit(self.axesLabelsWidget)
yLabelLabel = qt.QLabel(self.axesLabelsWidget)
yLabelLabel.setText("Y Axis Label: ")
self.yLabelLine = qt.QLineEdit(self.axesLabelsWidget)
layout.addWidget(xLabelLabel)
layout.addWidget(self.xLabelLine)
layout.addWidget(yLabelLabel)
layout.addWidget(self.yLabelLine)
self.curveTable = MatplotlibCurveTable(self)
self.plot = QPyMcaMatplotlibSave(self, **kw)
self.plot.setCurveTable(self.curveTable)
self.actionsWidget = qt.QWidget(self)
layout = qt.QHBoxLayout(self.actionsWidget)
layout.setContentsMargins(0, 0, 0, 0)
layout.setSpacing(2)
self.doNotShowAgain = qt.QCheckBox(self.actionsWidget)
self.doNotShowAgain.setChecked(False)
self.doNotShowAgain.setText("Don't show again this dialog")
self.acceptButton = qt.QPushButton(self.actionsWidget)
self.acceptButton.setText("Accept")
self.acceptButton.setAutoDefault(False)
self.dismissButton = qt.QPushButton(self.actionsWidget)
self.dismissButton.setText("Dismiss")
self.dismissButton.setAutoDefault(False)
layout.addWidget(self.doNotShowAgain)
layout.addWidget(qt.HorizontalSpacer(self.actionsWidget))
layout.addWidget(self.acceptButton)
layout.addWidget(self.dismissButton)
horizontal = False
if horizontal:
self.mainLayout.addWidget(self.axesLabelsWidget, 0, 0)
self.mainLayout.addWidget(self.plot, 1, 0)
self.mainLayout.addWidget(self.curveTable, 1, 1)
self.mainLayout.addWidget(self.actionsWidget, 2, 0, 1, 2)
self.mainLayout.setColumnStretch(0, 1)
else:
self.mainLayout.addWidget(self.axesLabelsWidget, 0, 0)
self.mainLayout.addWidget(self.curveTable, 1, 0)
self.mainLayout.addWidget(self.plot, 2, 0)
self.mainLayout.addWidget(self.actionsWidget, 3, 0)
self.mainLayout.setRowStretch(1, 1)
self.xLabelLine.editingFinished[()].connect(self._xLabelSlot)
self.yLabelLine.editingFinished[()].connect(self._yLabelSlot)
self.acceptButton.clicked.connect(self.accept)
self.dismissButton.clicked.connect(self.reject)
def configureFilter(self):
if self._widget is None:
# construct a widget
msg = qt.QDialog()
msg.setWindowTitle("Deglitch Configuration")
msgLayout = qt.QGridLayout()
buttonLayout = qt.QHBoxLayout()
inpThreshold = qt.QDoubleSpinBox()
inpThreshold.setRange(0.,10.)
inpThreshold.setSingleStep(.1)
inpThreshold.setValue(self.threshold)
inpThreshold.setToolTip('Increase width for broad spikes')
inpWidth = qt.QSpinBox()
inpWidth.setRange(1,101)
inpWidth.setSingleStep(2)
inpWidth.setValue(self.width)
inpWidth.setToolTip('Set low threshold for multiple spikes of different markedness')
labelWidth = qt.QLabel('Width (must be odd)')
labelThreshold = qt.QLabel('Threshold (multiple of deviation)')
buttonOK = qt.QPushButton('Ok')
buttonOK.clicked.connect(msg.accept)
buttonCancel = qt.QPushButton('Cancel')
buttonCancel.clicked.connect(msg.reject)
allActiveBG = qt.QButtonGroup()
buttonAll = qt.QCheckBox('Apply to All')
buttonActive = qt.QCheckBox('Apply to Active')
allActiveBG.addButton(buttonAll, 0)
allActiveBG.addButton(buttonActive, 1)
buttonActive.setChecked(True)
buttonLayout.addWidget(qt.HorizontalSpacer())
buttonLayout.addWidget(buttonOK)
buttonLayout.addWidget(buttonCancel)
msgLayout.addWidget(labelWidth,0,0)
msgLayout.addWidget(inpWidth,0,1)
msgLayout.addWidget(labelThreshold,1,0)
msgLayout.addWidget(inpThreshold,1,1)
msgLayout.addWidget(buttonActive,2,0)
msgLayout.addWidget(buttonAll,2,1)
msgLayout.addLayout(buttonLayout,3,0,1,2)
msg.setLayout(msgLayout)
msg.inputWidth = inpWidth
msg.inputThreshold = inpThreshold
msg.applyToAll = buttonAll
self._widget = msg
self._widget.buttonActive = buttonActive
self._widget.buttonAll = buttonAll
if self._widget.exec():
self.threshold = float(self._widget.inputThreshold.value())
self.width = int(self._widget.inputWidth.value())
if not (self.width%2):
self.width += 1
if self._widget.buttonAll.isChecked():
_logger.debug('AllChecked')
self.removeSpikesAll()
elif self._widget.buttonActive.isChecked():
_logger.debug('ActiveChecked')
self.removeSpikesActive()
def paint(self, painter, option, modelIndex):
'''
:param painter:
:type painter: QPainter
:param option:
:type option: QStyleOptionViewItem
:param modelIndex:
:type modelIndex: QModelIndex
Here be docs..
'''
#painter.save()
# Rect geometry
width = option.rect.width()
height = option.rect.height()
left = option.rect.left()
top = option.rect.top()
rect = qt.QRect(qt.QPoint(left, top), qt.QSize(width, height))
rect = option.rect
# Calculate the icon rectangle
iconSize = self.icon.sizeHint()
# Calculate icon position
x = rect.left() + 2
y = rect.top() + int(.5 * (rect.height() - iconSize.height()))
iconRect = qt.QRect(qt.QPoint(x, y), iconSize)
# Calculate label rectangle
legendSize = qt.QSize(rect.width() - iconSize.width() - 30,
rect.height())
# Calculate label position
x = rect.left() + iconRect.width()
y = rect.top()
labelRect = qt.QRect(qt.QPoint(x, y), legendSize)
labelRect.translate(qt.QPoint(10, 0))
# Calculate the checkbox rectangle
x = rect.right() - 30
y = rect.top()
chBoxRect = qt.QRect(qt.QPoint(x, y), rect.bottomRight())
# Remember the rectangles
idx = modelIndex.row()
self.iconDict[idx] = iconRect
self.labelDict[idx] = labelRect
# Draw background first!
if option.state & qt.QStyle.State_MouseOver:
backgroundBrush = option.palette.highlight()
else:
backgroundBrush = convertToPyObject(
modelIndex.data(qt.Qt.BackgroundRole))
painter.fillRect(rect, backgroundBrush)
# Draw label
legendText = convertToPyObject(modelIndex.data(qt.Qt.DisplayRole))
textBrush = convertToPyObject(modelIndex.data(qt.Qt.ForegroundRole))
textAlign = convertToPyObject(modelIndex.data(qt.Qt.TextAlignmentRole))
painter.setBrush(textBrush)
painter.setFont(self.legend.font())
painter.drawText(labelRect, textAlign, legendText)
# Draw icon
iconColor = convertToPyObject(
modelIndex.data(LegendModel.iconColorRole))
iconLineWidth = convertToPyObject(
modelIndex.data(LegendModel.iconLineWidthRole))
iconSymbol = convertToPyObject(
modelIndex.data(LegendModel.iconSymbolRole))
icon = LegendIcon()
icon.resize(iconRect.size())
icon.move(iconRect.topRight())
icon.showSymbol = convertToPyObject(
modelIndex.data(LegendModel.showSymbolRole))
icon.showLine = convertToPyObject(
modelIndex.data(LegendModel.showLineRole))
icon.setSymbolColor(iconColor)
icon.setLineColor(iconColor)
icon.setLineWidth(iconLineWidth)
icon.setSymbol(iconSymbol)
icon.symbolOutlineBrush = backgroundBrush
icon.paint(painter, iconRect, option.palette)
# Draw the checkbox
if convertToPyObject(modelIndex.data(qt.Qt.CheckStateRole)):
checkState = qt.Qt.Checked
else:
checkState = qt.Qt.Unchecked
if sys.platform.upper().startswith("DARWIN"):
MAC_QT_4_8_4_ISSUE = True
else:
MAC_QT_4_8_4_ISSUE = False
if MAC_QT_4_8_4_ISSUE:
painter.save()
else:
# Remember the paint device
originalPaintDevice = painter.device()
# Painter needs to end before
painter.end()
try:
cb = self.cbDict[idx]
except KeyError:
cb = qt.QCheckBox()
self.cbDict[idx] = cb
cb.setCheckState(checkState)
cb.setGeometry(chBoxRect)
cb.render(painter.device(), chBoxRect.topLeft(), qt.QRegion(),
qt.QWidget.DrawChildren)
# Reset painter
if MAC_QT_4_8_4_ISSUE:
painter.restore()
else:
painter.begin(originalPaintDevice)
return
def __init__(self, parent=None):
qt.QWidget.__init__(self, parent)
self.setWindowTitle("StackXASBatchWindow")
self.setWindowIcon(qt.QIcon(qt.QPixmap(IconDict['gioconda16'])))
self.mainLayout = qt.QGridLayout(self)
self.mainLayout.setContentsMargins(0, 0, 0, 0)
# configuration file
configLabel = qt.QLabel(self)
configLabel.setText("XAS Configuration File:")
self._configLine = qt.QLineEdit(self)
self._configLine.setReadOnly(True)
self._configButton = qt.QPushButton(self)
self._configButton.setText("Browse")
self._configButton.setAutoDefault(False)
self._configButton.clicked.connect(self.browseConfigurationFile)
# output directory
outLabel = qt.QLabel(self)
outLabel.setText("Output dir:")
self._outLine = qt.QLineEdit(self)
self._outLine.setReadOnly(True)
self._outButton = qt.QPushButton(self)
self._outButton.setText('Browse')
self._outButton.setAutoDefault(False)
self._outButton.clicked.connect(self.browseOutputDir)
# output file name
fileLabel = qt.QLabel(self)
fileLabel.setText("Output file root:")
self._fileLine = qt.QLineEdit(self)
self._fileLine.setReadOnly(False)
self._fileLine.setText("XAS_Result")
boxLabel = qt.QLabel(self)
boxLabel.setText("Options:")
self._boxContainer = qt.QWidget(self)
self._boxContainerLayout = qt.QHBoxLayout(self._boxContainer)
self._boxContainerLayout.setContentsMargins(0, 0, 0, 0)
self._boxContainerLayout.setSpacing(0)
# Mask
self._maskBox = qt.QCheckBox(self._boxContainer)
self._maskBox.setText("Use selection mask")
self._maskBox.setChecked(True)
self._maskBox.setEnabled(False)
text = "If pixels are currently selected, only the spectra\n"
text += "associated to those pixels will be analyzed"
self._maskBox.setToolTip(text)
self._boxContainerLayout.addWidget(self._maskBox)
self.mainLayout.addWidget(configLabel, 0, 0)
self.mainLayout.addWidget(self._configLine, 0, 1)
self.mainLayout.addWidget(self._configButton, 0, 2)
self.mainLayout.addWidget(outLabel, 1, 0)
self.mainLayout.addWidget(self._outLine, 1, 1)
self.mainLayout.addWidget(self._outButton, 1, 2)
self.mainLayout.addWidget(fileLabel, 2, 0)
self.mainLayout.addWidget(self._fileLine, 2, 1)
self.mainLayout.addWidget(boxLabel, 3, 0)
self.mainLayout.addWidget(self._boxContainer, 3, 1, 1, 1)
def __init__(self, parent=None):
qt.QWidget.__init__(self, parent)
self.setWindowTitle("StackROIBatchWindow")
self.setWindowIcon(qt.QIcon(qt.QPixmap(IconDict['gioconda16'])))
self.mainLayout = qt.QGridLayout(self)
self.mainLayout.setContentsMargins(0, 0, 0, 0)
# configuration file
configLabel = qt.QLabel(self)
configLabel.setText("ROI Configuration File:")
self._configLine = qt.QLineEdit(self)
self._configLine.setReadOnly(True)
self._configButton = qt.QPushButton(self)
self._configButton.setText("Browse")
self._configButton.setAutoDefault(False)
self._configButton.clicked.connect(self.browseConfigurationFile)
# output directory
outdirLabel = qt.QLabel(self)
outdirLabel.setText("Output dir:")
self._outdirLine = qt.QLineEdit(self)
self._outdirLine.setReadOnly(True)
self._outdirButton = qt.QPushButton(self)
self._outdirButton.setText('Browse')
self._outdirButton.setAutoDefault(False)
self._outdirButton.clicked.connect(self.browseOutputDir)
# output root
outrootLabel = qt.QLabel(self)
outrootLabel.setText("Output root:")
self._outrootLabel = outrootLabel
self._outrootLine = qt.QLineEdit(self)
self._outrootLine.setReadOnly(False)
self._outrootLine.setText("IMAGES")
# output entry
outentryLabel = qt.QLabel(self)
outentryLabel.setText("Output entry:")
self._outentryLine = qt.QLineEdit(self)
self._outentryLine.setReadOnly(False)
self._outentryLine.setText("ROI_images")
# output process
outnameLabel = qt.QLabel(self)
outnameLabel.setText("Output process:")
self._outnameLabel = outnameLabel
self._outnameLine = qt.QLineEdit(self)
self._outnameLine.setText("roi_sum")
# process options
boxLabel1 = qt.QLabel(self)
boxLabel1.setText("Process options:")
self._boxContainer1 = qt.QWidget(self)
self._boxContainerLayout1 = qt.QHBoxLayout(self._boxContainer1)
self._boxContainerLayout1.setContentsMargins(0, 0, 0, 0)
self._boxContainerLayout1.setSpacing(0)
# save options
boxLabel2 = qt.QLabel(self)
boxLabel2.setText("Save options:")
self._boxContainer2 = qt.QWidget(self)
self._boxContainerLayout2 = qt.QHBoxLayout(self._boxContainer2)
self._boxContainerLayout2.setContentsMargins(0, 0, 0, 0)
self._boxContainerLayout2.setSpacing(0)
# Net ROI
self._netBox = qt.QCheckBox(self._boxContainer1)
self._netBox.setText("Calculate Net ROI")
self._netBox.setChecked(True)
self._netBox.setEnabled(False)
# xAtMax
self._xAtMaxBox = qt.QCheckBox(self._boxContainer1)
self._xAtMaxBox.setText("Image X at Min/Max. Y")
self._xAtMaxBox.setChecked(False)
self._xAtMaxBox.setEnabled(True)
text = "Calculate the channel of the maximum and\n"
text += "the minimum value in the region.\n"
self._xAtMaxBox.setToolTip(text)
# generate tiff files
self._tiffBox = qt.QCheckBox(self._boxContainer2)
self._tiffBox.setText("TIFF")
self._tiffBox.setChecked(False)
self._tiffBox.setEnabled(True)
# generate csv file
self._csvBox = qt.QCheckBox(self._boxContainer2)
self._csvBox.setText("CSV")
self._csvBox.setChecked(False)
self._csvBox.setEnabled(True)
# generate dat file
self._datBox = qt.QCheckBox(self._boxContainer2)
self._datBox.setText("DAT")
self._datBox.setChecked(False)
self._datBox.setEnabled(True)
# generate edf file
self._edfBox = qt.QCheckBox(self._boxContainer2)
self._edfBox.setText("EDF")
self._edfBox.setChecked(True)
self._edfBox.setEnabled(True)
# generate hdf5 file
self._h5Box = qt.QCheckBox(self._boxContainer2)
self._h5Box.setText("HDF5")
self._h5Box.setChecked(hasH5py)
self._h5Box.setEnabled(hasH5py)
self._h5Box.stateChanged.connect(self.toggleH5)
self.toggleH5(hasH5py)
# overwrite output
self._overwriteBox = qt.QCheckBox(self._boxContainer2)
self._overwriteBox.setText("Overwrite")
self._overwriteBox.setChecked(True)
self._overwriteBox.setEnabled(True)
# generate mutipage file
self._multipageBox = qt.QCheckBox(self._boxContainer2)
self._multipageBox.setText("Multipage")
self._multipageBox.setChecked(False)
self._multipageBox.setEnabled(True)
self._edfBox.stateChanged.connect(self.stateMultiPage)
self._tiffBox.stateChanged.connect(self.stateMultiPage)
self.stateMultiPage()
self._boxContainerLayout1.addWidget(self._netBox)
self._boxContainerLayout1.addWidget(self._xAtMaxBox)
self._boxContainerLayout2.addWidget(self._h5Box)
self._boxContainerLayout2.addWidget(self._edfBox)
self._boxContainerLayout2.addWidget(self._csvBox)
self._boxContainerLayout2.addWidget(self._datBox)
self._boxContainerLayout2.addWidget(self._tiffBox)
self._boxContainerLayout2.addWidget(self._overwriteBox)
self._boxContainerLayout2.addWidget(self._multipageBox)
i = 0
self.mainLayout.addWidget(configLabel, i, 0)
self.mainLayout.addWidget(self._configLine, i, 1)
self.mainLayout.addWidget(self._configButton, i, 2)
i += 1
self.mainLayout.addWidget(outdirLabel, i, 0)
self.mainLayout.addWidget(self._outdirLine, i, 1)
self.mainLayout.addWidget(self._outdirButton, i, 2)
i += 1
self.mainLayout.addWidget(outrootLabel, i, 0)
self.mainLayout.addWidget(self._outrootLine, i, 1)
i += 1
self.mainLayout.addWidget(outentryLabel, i, 0)
self.mainLayout.addWidget(self._outentryLine, i, 1)
i += 1
self.mainLayout.addWidget(outnameLabel, i, 0)
self.mainLayout.addWidget(self._outnameLine, i, 1)
i += 1
self.mainLayout.addWidget(boxLabel1, i, 0)
self.mainLayout.addWidget(self._boxContainer1, i, 1, 1, 1)
i += 1
self.mainLayout.addWidget(boxLabel2, i, 0)
self.mainLayout.addWidget(self._boxContainer2, i, 1, 1, 1)
def build(self):
layout = qt.QVBoxLayout(self)
layout.setContentsMargins(0, 0, 0, 0)
layout.setSpacing(0)
buttonGroup = qt.QGroupBox(self)
buttonGroup.layout = qt.QVBoxLayout(buttonGroup)
buttonGroup.layout.setContentsMargins(0, 0, 0, 0)
buttonGroup.layout.setSpacing(0)
layout.addWidget(buttonGroup)
self.fluxCheckBox = qt.QCheckBox(buttonGroup)
self.fluxCheckBox.setText("From fundamental parameters")
wf = qt.QWidget(buttonGroup)
wf.layout = qt.QHBoxLayout(wf)
wf.layout.setContentsMargins(0, 0, 0, 0)
wf.layout.setSpacing(0)
wf.layout.addWidget(qt.HorizontalSpacer(wf))
self.fundamentalWidget = FundamentalWidget(wf)
wf.layout.addWidget(self.fundamentalWidget)
wf.layout.addWidget(qt.HorizontalSpacer(wf))
self.matrixCheckBox = qt.QCheckBox(buttonGroup)
self.matrixCheckBox.setText("From matrix composition")
self.fluxCheckBox.setChecked(True)
wm = qt.QWidget(buttonGroup)
wm.layout = qt.QHBoxLayout(wm)
wm.layout.setContentsMargins(0, 0, 0, 0)
wm.layout.setSpacing(0)
wm.layout.addWidget(qt.HorizontalSpacer(wm))
referenceLabel = qt.QLabel(wm)
wm.layout.addWidget(referenceLabel)
referenceLabel.setText("Matrix Reference Element:")
#self.referenceCombo=MyQComboBox(wm)
#self.referenceCombo=qt.QComboBox(wm)
#self.referenceCombo.setEditable(True)
#self.referenceCombo.insertItem('Auto')
self.referenceLine = MyQLineEdit(wm)
wm.layout.addWidget(self.referenceLine)
self.referenceLine.setFixedWidth(
self.referenceLine.fontMetrics().width('#######'))
wm.layout.addWidget(qt.HorizontalSpacer(wm))
self.referenceLine.sigMyQLineEditSignal.connect( \
self._referenceLineSlot)
buttonGroup.layout.addWidget(self.fluxCheckBox)
buttonGroup.layout.addWidget(wf)
buttonGroup.layout.addWidget(self.matrixCheckBox)
buttonGroup.layout.addWidget(wm)
#self.fundamentalWidget.setEnabled(False)
self.attenuatorsCheckBox = qt.QCheckBox(self)
self.attenuatorsCheckBox.setText(
"Consider attenuators in calculations")
self.attenuatorsCheckBox.setDisabled(True)
#Multilayer secondary excitation
self.secondaryCheckBox = qt.QCheckBox(self)
self.secondaryCheckBox.setText("Consider secondary excitation")
self.tertiaryCheckBox = qt.QCheckBox(self)
self.tertiaryCheckBox.setText("Consider tertiary excitation")
layout.addWidget(self.attenuatorsCheckBox)
layout.addWidget(self.secondaryCheckBox)
layout.addWidget(self.tertiaryCheckBox)
#XRFMC secondary excitation
if XRFMC_FLAG:
self.xrfmcCheckBox = qt.QCheckBox(self)
self.xrfmcCheckBox.setText(
"use Monte Carlo code to correct higher order excitations")
layout.addWidget(self.xrfmcCheckBox)
#mM checkbox
self.mMolarCheckBox = qt.QCheckBox(self)
self.mMolarCheckBox.setText(
"Elemental mM concentrations (assuming 1 l of solution is 1000 * matrix_density grams)"
)
layout.addWidget(self.mMolarCheckBox)
layout.addWidget(qt.VerticalSpacer(self))
buttonGroup.show()
self.fluxCheckBox.clicked.connect(self._fluxCheckBoxSlot)
self.matrixCheckBox.clicked.connect(self.checkBoxSlot)
self.attenuatorsCheckBox.clicked.connect(self.checkBoxSlot)
self.secondaryCheckBox.clicked.connect(self._secondaryCheckBoxSlot)
self.tertiaryCheckBox.clicked.connect(self._tertiaryCheckBoxSlot)
if XRFMC_FLAG:
self.xrfmcCheckBox.clicked.connect(self._xrfmcCheckBoxSlot)
self.mMolarCheckBox.clicked.connect(self.checkBoxSlot)
self.fundamentalWidget.flux.sigMyQLineEditSignal.connect( \
self._mySignal)
self.fundamentalWidget.area.sigMyQLineEditSignal.connect( \
self._mySignal)
self.fundamentalWidget.time.sigMyQLineEditSignal.connect( \
self._mySignal)
self.fundamentalWidget.distance.sigMyQLineEditSignal.connect( \
self._mySignal)
self.fundamentalWidget.autoTimeCheckBox.clicked.connect( \
self.__autoTimeSlot)
def __init__(self, parent=None):
qt.QWidget.__init__(self, parent)
self.setWindowTitle("FastXRFLinearFitWindow")
self.setWindowIcon(qt.QIcon(qt.QPixmap(IconDict['gioconda16'])))
self.mainLayout = qt.QGridLayout(self)
self.mainLayout.setContentsMargins(0, 0, 0, 0)
# configuration file
configLabel = qt.QLabel(self)
configLabel.setText("Fit Configuration File:")
self._configLine = qt.QLineEdit(self)
self._configLine.setReadOnly(True)
self._configButton = qt.QPushButton(self)
self._configButton.setText("Browse")
self._configButton.setAutoDefault(False)
self._configButton.clicked.connect(self.browseConfigurationFile)
# output directory
outdirLabel = qt.QLabel(self)
outdirLabel.setText("Output dir:")
self._outdirLine = qt.QLineEdit(self)
self._outdirLine.setReadOnly(True)
self._outdirButton = qt.QPushButton(self)
self._outdirButton.setText('Browse')
self._outdirButton.setAutoDefault(False)
self._outdirButton.clicked.connect(self.browseOutputDir)
# output root
outrootLabel = qt.QLabel(self)
outrootLabel.setText("Output root:")
self._outrootLabel = outrootLabel
self._outrootLine = qt.QLineEdit(self)
self._outrootLine.setReadOnly(False)
self._outrootLine.setText("IMAGES")
# output entry
outentryLabel = qt.QLabel(self)
outentryLabel.setText("Output entry:")
self._outentryLine = qt.QLineEdit(self)
self._outentryLine.setReadOnly(False)
self._outentryLine.setText("images")
# output process
outnameLabel = qt.QLabel(self)
outnameLabel.setText("Output process:")
self._outnameLabel = outnameLabel
self._outnameLine = qt.QLineEdit(self)
self._outnameLine.setText("fast_xrf_fit")
# fit options
boxLabel1 = qt.QLabel(self)
boxLabel1.setText("Fit options:")
self._boxContainer1 = qt.QWidget(self)
self._boxContainerLayout1 = qt.QHBoxLayout(self._boxContainer1)
self._boxContainerLayout1.setContentsMargins(0, 0, 0, 0)
self._boxContainerLayout1.setSpacing(0)
# save options
boxLabel2 = qt.QLabel(self)
boxLabel2.setText("Save options:")
self._boxContainer2 = qt.QWidget(self)
self._boxContainerLayout2 = qt.QHBoxLayout(self._boxContainer2)
self._boxContainerLayout2.setContentsMargins(0, 0, 0, 0)
self._boxContainerLayout2.setSpacing(0)
# concentrations
self._concentrationsBox = qt.QCheckBox(self._boxContainer1)
self._concentrationsBox.setText("Concentrations")
self._concentrationsBox.setChecked(False)
self._concentrationsBox.setEnabled(True)
# diagnostics
self._diagnosticsBox = qt.QCheckBox(self._boxContainer1)
self._diagnosticsBox.setText("Diagnostics")
self._diagnosticsBox.setChecked(False)
self._diagnosticsBox.setEnabled(hasH5py)
# repeat fit on negative contributions
self._fitAgainBox = qt.QCheckBox(self._boxContainer1)
self._fitAgainBox.setText("Repeat fit on negative contributions")
self._fitAgainBox.setChecked(True)
self._fitAgainBox.setEnabled(True)
text = "Fit of pixels with negative peak area\n"
text += "contributions will be repeated.\n"
text += "This can seriously slow down the process\n"
text += "if your sample model is far from the truth."
self._fitAgainBox.setToolTip(text)
# generate tiff files
self._tiffBox = qt.QCheckBox(self._boxContainer2)
self._tiffBox.setText("TIFF")
self._tiffBox.setChecked(False)
self._tiffBox.setEnabled(True)
# generate csv file
self._csvBox = qt.QCheckBox(self._boxContainer2)
self._csvBox.setText("CSV")
self._csvBox.setChecked(False)
self._csvBox.setEnabled(True)
# generate dat file
self._datBox = qt.QCheckBox(self._boxContainer2)
self._datBox.setText("DAT")
self._datBox.setChecked(False)
self._datBox.setEnabled(True)
# generate edf file
self._edfBox = qt.QCheckBox(self._boxContainer2)
self._edfBox.setText("EDF")
self._edfBox.setChecked(True)
self._edfBox.setEnabled(True)
# generate hdf5 file
self._h5Box = qt.QCheckBox(self._boxContainer2)
self._h5Box.setText("HDF5")
self._h5Box.setChecked(hasH5py)
self._h5Box.setEnabled(hasH5py)
self._h5Box.stateChanged.connect(self.toggleH5)
self.toggleH5(hasH5py)
# overwrite output
self._overwriteBox = qt.QCheckBox(self._boxContainer2)
self._overwriteBox.setText("Overwrite")
self._overwriteBox.setChecked(True)
self._overwriteBox.setEnabled(True)
# generate mutipage file
self._multipageBox = qt.QCheckBox(self._boxContainer2)
self._multipageBox.setText("Multipage")
self._multipageBox.setChecked(False)
self._multipageBox.setEnabled(True)
self._edfBox.stateChanged.connect(self.stateMultiPage)
self._tiffBox.stateChanged.connect(self.stateMultiPage)
self.stateMultiPage()
self._boxContainerLayout1.addWidget(self._concentrationsBox)
self._boxContainerLayout1.addWidget(self._fitAgainBox)
self._boxContainerLayout1.addWidget(self._diagnosticsBox)
self._boxContainerLayout2.addWidget(self._h5Box)
self._boxContainerLayout2.addWidget(self._edfBox)
self._boxContainerLayout2.addWidget(self._csvBox)
self._boxContainerLayout2.addWidget(self._datBox)
self._boxContainerLayout2.addWidget(self._tiffBox)
self._boxContainerLayout2.addWidget(self._overwriteBox)
self._boxContainerLayout2.addWidget(self._multipageBox)
# weight method
self._weightWidget = qt.QWidget(self)
self._weightWidget.mainLayout = qt.QHBoxLayout(self._weightWidget)
self._weightWidget.mainLayout.setContentsMargins(0, 0, 0, 0)
self._weightWidget.mainLayout.setSpacing(0)
self._weightButtonGroup = qt.QButtonGroup(self._weightWidget)
i = 0
weightLabel = qt.QLabel(self)
weightLabel.setText("Weight policy: ")
for txt in [
"No Weight (Fastest)", "Average Weight (Fast)",
"Individual Weights (slow)"
]:
button = qt.QRadioButton(self._weightWidget)
button.setText(txt)
self._weightButtonGroup.addButton(button)
self._weightButtonGroup.setId(button, i)
self._weightWidget.mainLayout.addWidget(button)
i += 1
self._weightButtonGroup.buttons()[0].setChecked(True)
#self._weightWidget.mainLayout.addWidget(qt.HorizontalSpacer(self._weightWidget))
i = 0
self.mainLayout.addWidget(configLabel, i, 0)
self.mainLayout.addWidget(self._configLine, i, 1)
self.mainLayout.addWidget(self._configButton, i, 2)
i += 1
self.mainLayout.addWidget(outdirLabel, i, 0)
self.mainLayout.addWidget(self._outdirLine, i, 1)
self.mainLayout.addWidget(self._outdirButton, i, 2)
i += 1
self.mainLayout.addWidget(outrootLabel, i, 0)
self.mainLayout.addWidget(self._outrootLine, i, 1)
i += 1
self.mainLayout.addWidget(outentryLabel, i, 0)
self.mainLayout.addWidget(self._outentryLine, i, 1)
i += 1
self.mainLayout.addWidget(outnameLabel, i, 0)
self.mainLayout.addWidget(self._outnameLine, i, 1)
i += 1
self.mainLayout.addWidget(weightLabel, i, 0)
self.mainLayout.addWidget(self._weightWidget, i, 1, 1, 1)
i += 1
self.mainLayout.addWidget(boxLabel1, i, 0)
self.mainLayout.addWidget(self._boxContainer1, i, 1, 1, 1)
i += 1
self.mainLayout.addWidget(boxLabel2, i, 0)
self.mainLayout.addWidget(self._boxContainer2, i, 1, 1, 1)
def build(self, table, orientation, thickness, density, size=None):
if size is None: size = "medium"
layout = qt.QHBoxLayout(self)
if table:
#the material definition
matBox = qt.QWidget(self)
layout.addWidget(matBox)
matBoxLayout = qt.QVBoxLayout(matBox)
self.materialEditor = MaterialEditor.MaterialEditor(matBox,
comments=False,
height=7)
matBoxLayout.addWidget(self.materialEditor)
matBoxLayout.addWidget(qt.VerticalSpacer(matBox))
else:
self.materialEditor = None
#the matrix definition
sampleBox = qt.QWidget(self)
layout.addWidget(sampleBox)
if orientation == "vertical":
sampleBoxLayout = qt.QVBoxLayout(sampleBox)
else:
sampleBoxLayout = qt.QHBoxLayout(sampleBox)
#the image
if orientation == "vertical":
labelHBox = qt.QWidget(sampleBox)
sampleBoxLayout.addWidget(labelHBox)
labelHBoxLayout = qt.QHBoxLayout(labelHBox)
labelHBoxLayout.addWidget(qt.HorizontalSpacer(labelHBox))
label = MatrixImage.MatrixImage(labelHBox, size=size)
labelHBoxLayout.addWidget(label)
labelHBoxLayout.addWidget(qt.HorizontalSpacer(labelHBox))
else:
labelHBox = qt.QWidget(sampleBox)
sampleBoxLayout.addWidget(labelHBox)
labelHBoxLayout = qt.QVBoxLayout(labelHBox)
labelHBoxLayout.setContentsMargins(0, 0, 0, 0)
labelHBoxLayout.setSpacing(4)
label = MatrixImage.MatrixImage(labelHBox, size=size)
labelHBoxLayout.addWidget(label)
if orientation != "vertical":
labelHBoxLayout.addWidget(qt.VerticalSpacer(labelHBox))
self.imageLabel = label
#the input fields container
self.__gridSampleBox = qt.QWidget(sampleBox)
grid = self.__gridSampleBox
sampleBoxLayout.addWidget(grid)
if QTVERSION < '4.0.0':
gridLayout = qt.QGridLayout(grid, 6, 2, 11, 4)
else:
gridLayout = qt.QGridLayout(grid)
gridLayout.setContentsMargins(11, 11, 11, 11)
gridLayout.setSpacing(4)
#the angles
angle1Label = qt.QLabel(grid)
angle1Label.setText("Incoming Angle (deg.):")
self.__angle1Line = MyQLineEdit(grid)
self.__angle1Line.setReadOnly(False)
angle2Label = qt.QLabel(grid)
angle2Label.setText("Outgoing Angle (deg.):")
self.__angle2Line = MyQLineEdit(grid)
self.__angle2Line.setReadOnly(False)
self.__angle3Label = qt.QCheckBox(grid)
self.__angle3Label.setText("Scattering Angle (deg.):")
self.__angle3Line = MyQLineEdit(grid)
self.__angle3Line.setReadOnly(False)
self.__angle3Line.setDisabled(True)
if QTVERSION < '4.0.0':
angle1Label.setAlignment(qt.QLabel.WordBreak | \
qt.QLabel.AlignVCenter)
angle2Label.setAlignment(qt.QLabel.WordBreak | \
qt.QLabel.AlignVCenter)
else:
angle1Label.setAlignment(qt.Qt.AlignVCenter)
angle2Label.setAlignment(qt.Qt.AlignVCenter)
self.__angle3Label.setChecked(0)
gridLayout.addWidget(angle1Label, 0, 0)
gridLayout.addWidget(self.__angle1Line, 0, 1)
gridLayout.addWidget(angle2Label, 1, 0)
gridLayout.addWidget(self.__angle2Line, 1, 1)
gridLayout.addWidget(self.__angle3Label, 2, 0)
gridLayout.addWidget(self.__angle3Line, 2, 1)
rowoffset = 3
#thickness and density
if density:
densityLabel = qt.QLabel(grid)
densityLabel.setText("Sample Density (g/cm3):")
if QTVERSION < '4.0.0':
densityLabel.setAlignment(qt.QLabel.WordBreak | \
qt.QLabel.AlignVCenter)
else:
densityLabel.setAlignment(qt.Qt.AlignVCenter)
self.__densityLine = MyQLineEdit(grid)
self.__densityLine.setReadOnly(False)
gridLayout.addWidget(densityLabel, rowoffset, 0)
gridLayout.addWidget(self.__densityLine, rowoffset, 1)
rowoffset = rowoffset + 1
else:
self.__densityLine = None
if thickness:
thicknessLabel = qt.QLabel(grid)
thicknessLabel.setText("Sample Thickness (cm):")
if QTVERSION < '4.0.0':
thicknessLabel.setAlignment(qt.QLabel.WordBreak | \
qt.QLabel.AlignVCenter)
else:
thicknessLabel.setAlignment(qt.Qt.AlignVCenter)
self.__thicknessLine = MyQLineEdit(grid)
self.__thicknessLine.setReadOnly(False)
gridLayout.addWidget(thicknessLabel, rowoffset, 0)
gridLayout.addWidget(self.__thicknessLine, rowoffset, 1)
rowoffset = rowoffset + 1
else:
self.__thicknessLine = None
gridLayout.addWidget(qt.VerticalSpacer(grid), rowoffset, 0)
gridLayout.addWidget(qt.VerticalSpacer(grid), rowoffset, 1)
self.__angle1Line.sigMyQLineEditSignal.connect(self.__angle1Slot)
self.__angle2Line.sigMyQLineEditSignal.connect(self.__angle2Slot)
self.__angle3Line.sigMyQLineEditSignal.connect(self.__angle3Slot)
if self.__densityLine is not None:
self.__densityLine.sigMyQLineEditSignal.connect(self.__densitySlot)
if self.__thicknessLine is not None:
self.__thicknessLine.sigMyQLineEditSignal.connect(
self.__thicknessSlot)
self.__angle3Label.clicked.connect(self.__angle3LabelSlot)
if orientation == "vertical":
sampleBoxLayout.addWidget(qt.VerticalSpacer(sampleBox))
def __init__(self, parent=None):
qt.QWizardPage.__init__(self, parent)
layout= qt.QVBoxLayout(self)
layout.setContentsMargins(10, 10, 10, 10)
layout.setSpacing(5)
self.deadCheck= qt.QCheckBox("DeadTime correction", self)
self.liveCheck= qt.QCheckBox("LiveTime normalization", self)
lineSep= qt.QFrame(self)
lineSep.setFrameStyle(qt.QFrame.HLine|qt.QFrame.Sunken)
optWidget= qt.QWidget(self)
optLayout= qt.QHBoxLayout(optWidget)
self.sumCheck= qt.QCheckBox("SUM or", optWidget)
self.avgCheck= qt.QCheckBox("AVERAGE selected detectors", optWidget)
optLayout.addWidget(self.sumCheck, 0)
optLayout.addWidget(self.avgCheck, 1)
layout.addWidget(self.deadCheck)
layout.addWidget(self.liveCheck)
layout.addWidget(lineSep)
layout.addWidget(optWidget)
self.sumCheck.toggled[bool].connect(self.__sumCheckChanged)
self.avgCheck.toggled[bool].connect(self.__avgCheckChanged)
sumWidget= qt.QWidget(self)
sumLayout= qt.QHBoxLayout(sumWidget)
sumLayout.setContentsMargins(0, 0, 0, 0)
sumLayout.setSpacing(5)
butWidget= qt.QWidget(sumWidget)
butLayout= qt.QVBoxLayout(butWidget)
butLayout.setContentsMargins(0, 0, 0, 0)
butLayout.setSpacing(0)
self.sumTable= qt.QTableWidget(sumWidget)
self.sumTable.setRowCount(0)
self.sumTable.setColumnCount(1)
item = self.sumTable.horizontalHeaderItem(0)
if item is None:
item = qt.QTableWidgetItem("Detectors",
qt.QTableWidgetItem.Type)
item.setText("Detectors")
self.sumTable.setHorizontalHeaderItem(0, item)
self.sumTable.cellChanged[int,int].connect(self.__valueChanged)
buttonAdd= qt.QPushButton("Add", butWidget)
buttonDel= qt.QPushButton("Remove", butWidget)
butLayout.addWidget(buttonAdd)
butLayout.addWidget(buttonDel)
butLayout.addStretch()
buttonAdd.clicked.connect(self.__add)
buttonDel.clicked.connect(self.__remove)
sumLayout.addWidget(self.sumTable)
sumLayout.addWidget(butWidget)
layout.addWidget(sumWidget)
def __init__(self, parent=None):
qt.QWidget.__init__(self, parent)
FitParamFormLayout = qt.QVBoxLayout(self)
FitParamFormLayout.setContentsMargins(11, 11, 11, 11)
FitParamFormLayout.setSpacing(6)
self.mainTab = qt.QTabWidget(self)
self.tabFit = qt.QWidget()
tabFitLayout = qt.QVBoxLayout(self.tabFit)
tabFitLayout.setContentsMargins(11, 11, 11, 11)
tabFitLayout.setSpacing(6)
layout5 = Q3GridLayout(None)
#,1,1,
layout5.setContentsMargins(11, 11, 11, 11)
layout5.setSpacing(6)
self.functionCombo = qt.QComboBox(self.tabFit)
self.functionCombo.insertItem = self.functionCombo.addItem
self.functionLabel = qt.QLabel(self.tabFit)
self.functionLabel.setText("Fit Function")
self.functionCombo.insertItem(str("Mca Hypermet"))
self.functionCombo.insertItem(str("Mca Pseudo-Voigt"))
self.snipWidthLabel = qt.QLabel(self.tabFit)
self.snipWidthLabel.setText(str("SNIP Background Width"))
self.stripWidthLabel = qt.QLabel(self.tabFit)
self.stripWidthLabel.setText(str("Strip Background Width"))
self.stripIterValue = qt.QLineEdit(self.tabFit)
self.chi2Label = qt.QLabel(self.tabFit)
self.chi2Label.setText(str("Minimum chi^2 difference (%)"))
self.chi2Value = qt.QLineEdit(self.tabFit)
self.linearFitFlagCheck = qt.QCheckBox(self.tabFit)
self.linearFitFlagCheck.setText(
str("Perform a Linear Fit Fixing non-linear Parameters to Initial Values"
))
self.strategyCheckBox = qt.QCheckBox(self.tabFit)
self.strategyCheckBox.setText(
str("Perform a fit using the selected strategy"))
self.strategyCombo = qt.QComboBox(self.tabFit)
self.strategyCombo.addItem(str("Single Layer"))
self.strategySetupButton = qt.QPushButton(self.tabFit)
self.strategySetupButton.setText('SETUP')
self.strategySetupButton.setAutoDefault(False)
self.mainTab.addTab(self.tabFit, str("FIT"))
self.lastLabel = qt.QLabel(self.tabFit)
lastLabel_font = qt.QFont(self.lastLabel.font())
lastLabel_font.setItalic(1)
self.lastLabel.setFont(lastLabel_font)
self.lastLabel.setText(str("Last channel :"))
self.lastLabel.setAlignment(QLabelAlignVCenter | QLabelAlignRight)
self.regionCheck = qt.QCheckBox(self.tabFit)
self.regionCheck.setText(str("Limit fitting region to :"))
self.topLine = qt.QFrame(self.tabFit)
self.topLine.setFrameShape(qt.QFrame.HLine)
self.topLine.setFrameShadow(qt.QFrame.Sunken)
self.topLine.setFrameShape(qt.QFrame.HLine)
##########
self.weightLabel = qt.QLabel(self.tabFit)
self.weightLabel.setText("Statistical weighting of data")
self.weightCombo = qt.QComboBox(self.tabFit)
self.weightCombo.insertItem = self.weightCombo.addItem
self.weightCombo.insertItem(str("NO Weight"))
self.weightCombo.insertItem(str("Poisson (1/Y)"))
#self.weightCombo.insertItem(str("Poisson (1/Y2)"))
##########
self.iterLabel = qt.QLabel(self.tabFit)
self.iterLabel.setText(str("Number of fit iterations"))
self.contCombo = qt.QComboBox(self.tabFit)
self.contCombo.insertItem = self.contCombo.addItem
self.contCombo.insertItem(str("NO Continuum"))
self.contCombo.insertItem(str("Constant"))
self.contCombo.insertItem(str("Linear"))
self.contCombo.insertItem(str("Parabolic"))
self.contCombo.insertItem(str("Linear Polynomial"))
self.contCombo.insertItem(str("Exp. Polynomial"))
self.stripCombo = qt.QComboBox(self.tabFit)
self.stripCombo.insertItem = self.stripCombo.addItem
self.stripComboLabel = qt.QLabel(self.tabFit)
self.stripComboLabel.setText(
"Non-analytical (or estimation) background algorithm")
self.stripCombo.insertItem(str("Strip"))
self.stripCombo.insertItem(str("SNIP"))
self.stripCombo.activated[int].connect(self._stripComboActivated)
self.snipWidthSpin = Q3SpinBox(self.tabFit)
self.snipWidthSpin.setMaxValue(300)
self.snipWidthSpin.setMinValue(0)
self.stripWidthSpin = Q3SpinBox(self.tabFit)
self.stripWidthSpin.setMaxValue(100)
self.stripWidthSpin.setMinValue(1)
self.orderSpin = Q3SpinBox(self.tabFit)
self.orderSpin.setMaxValue(10)
self.orderSpin.setMinValue(1)
maxnchannel = 16384 * 4
self.maxSpin = Q3SpinBox(self.tabFit)
self.maxSpin.setMaxValue(maxnchannel)
self.maxSpin.setLineStep(128)
self.minSpin = Q3SpinBox(self.tabFit)
self.minSpin.setMaxValue(maxnchannel)
self.minSpin.setLineStep(128)
self.stripIterLabel = qt.QLabel(self.tabFit)
self.stripIterLabel.setText(str("Strip Background Iterations"))
self.iterSpin = Q3SpinBox(self.tabFit)
self.iterSpin.setMinValue(1)
self.stripFilterLabel = qt.QLabel(self.tabFit)
self.stripFilterLabel.setText(
str("Strip Background Smoothing Width (Savitsky-Golay)"))
self.stripFilterSpin = Q3SpinBox(self.tabFit)
self.stripFilterSpin.setMinValue(1)
self.stripFilterSpin.setMaxValue(40)
self.stripFilterSpin.setLineStep(2)
########
self.anchorsContainer = qt.QWidget(self.tabFit)
anchorsContainerLayout = qt.QHBoxLayout(self.anchorsContainer)
anchorsContainerLayout.setContentsMargins(0, 0, 0, 0)
anchorsContainerLayout.setSpacing(2)
self.stripAnchorsFlagCheck = qt.QCheckBox(self.anchorsContainer)
self.stripAnchorsFlagCheck.setText(str("Strip Background use Anchors"))
anchorsContainerLayout.addWidget(self.stripAnchorsFlagCheck)
self.stripAnchorsList = []
for i in range(4):
anchorSpin = Q3SpinBox(self.anchorsContainer)
anchorSpin.setMinValue(0)
anchorSpin.setMaxValue(maxnchannel)
anchorsContainerLayout.addWidget(anchorSpin)
self.stripAnchorsList.append(anchorSpin)
#######
self.firstLabel = qt.QLabel(self.tabFit)
firstLabel_font = qt.QFont(self.firstLabel.font())
firstLabel_font.setItalic(1)
self.firstLabel.setFont(firstLabel_font)
self.firstLabel.setText(str("First channel :"))
self.firstLabel.setAlignment(qt.Qt.AlignVCenter | qt.Qt.AlignRight)
self.typeLabel = qt.QLabel(self.tabFit)
self.typeLabel.setText(str("Continuum type"))
self.orderLabel = qt.QLabel(self.tabFit)
self.orderLabel.setText(str("Polynomial order"))
self.bottomLine = qt.QFrame(self.tabFit)
self.bottomLine.setFrameShape(qt.QFrame.HLine)
self.bottomLine.setFrameShadow(qt.QFrame.Sunken)
self.bottomLine.setFrameShape(qt.QFrame.HLine)
layout5.addMultiCellWidget(self.functionLabel, 0, 0, 0, 1)
layout5.addMultiCellWidget(self.functionCombo, 0, 0, 3, 4)
layout5.addMultiCellWidget(self.typeLabel, 1, 1, 0, 1)
layout5.addMultiCellWidget(self.contCombo, 1, 1, 3, 4)
layout5.addMultiCellWidget(self.orderLabel, 2, 2, 0, 1)
layout5.addMultiCellWidget(self.orderSpin, 2, 2, 3, 4)
layout5.addMultiCellWidget(self.stripComboLabel, 3, 3, 0, 1)
self.stripSetupButton = qt.QPushButton(self.tabFit)
self.stripSetupButton.setText('SETUP')
self.stripSetupButton.setAutoDefault(False)
layout5.addWidget(self.stripCombo, 3, 3)
layout5.addWidget(self.stripSetupButton, 3, 4)
layout5.addMultiCellWidget(self.snipWidthLabel, 4, 4, 0, 1)
layout5.addMultiCellWidget(self.snipWidthSpin, 4, 4, 3, 4)
layout5.addMultiCellWidget(self.stripWidthLabel, 5, 5, 0, 1)
layout5.addMultiCellWidget(self.stripWidthSpin, 5, 5, 3, 4)
layout5.addMultiCellWidget(self.stripIterLabel, 6, 6, 0, 1)
layout5.addMultiCellWidget(self.stripIterValue, 6, 6, 3, 4)
layout5.addMultiCellWidget(self.stripFilterLabel, 7, 7, 0, 1)
layout5.addMultiCellWidget(self.stripFilterSpin, 7, 7, 3, 4)
layout5.addMultiCellWidget(self.anchorsContainer, 8, 8, 0, 4)
layout5.addWidget(self.weightLabel, 9, 0)
layout5.addMultiCellWidget(self.weightCombo, 9, 9, 3, 4)
layout5.addWidget(self.iterLabel, 10, 0)
layout5.addWidget(qt.HorizontalSpacer(self.tabFit), 10, 1)
layout5.addMultiCellWidget(self.iterSpin, 10, 10, 3, 4)
layout5.addWidget(self.chi2Label, 11, 0)
layout5.addMultiCellWidget(self.chi2Value, 11, 11, 3, 4)
layout5.addMultiCellWidget(self.strategyCheckBox, 12, 12, 0, 4)
layout5.addWidget(self.strategyCombo, 12, 3)
layout5.addWidget(self.strategySetupButton, 12, 4)
layout5.addMultiCellWidget(self.linearFitFlagCheck, 13, 13, 0, 4)
layout5.addMultiCellWidget(self.topLine, 14, 15, 0, 4)
layout5.addMultiCellWidget(self.minSpin, 15, 16, 4, 4)
layout5.addWidget(self.regionCheck, 16, 0)
layout5.addMultiCellWidget(self.firstLabel, 16, 16, 2, 3)
layout5.addMultiCellWidget(self.lastLabel, 17, 17, 2, 3)
layout5.addWidget(self.maxSpin, 17, 4)
layout5.addMultiCellWidget(self.bottomLine, 18, 18, 0, 4)
tabFitLayout.addLayout(layout5)
includeWidget = qt.QWidget(self.tabFit)
includeLayout = Q3GridLayout(includeWidget)
includeLayout.setContentsMargins(0, 0, 0, 0)
includeLayout.setSpacing(3)
self.stepCheck = qt.QCheckBox(includeWidget)
self.stepCheck.setText(str("Step tail"))
includeLayout.addWidget(self.stepCheck, 2, 2)
self.escapeCheck = qt.QCheckBox(includeWidget)
self.escapeCheck.setText(str("Escape peaks"))
includeLayout.addWidget(self.escapeCheck, 1, 1)
self.includeLabel = qt.QLabel(includeWidget)
includeLabel_font = qt.QFont(self.includeLabel.font())
includeLabel_font.setBold(1)
self.includeLabel.setFont(includeLabel_font)
self.includeLabel.setText(str("Include:"))
includeLayout.addWidget(self.includeLabel, 0, 0)
self.sumCheck = qt.QCheckBox(includeWidget)
self.sumCheck.setText(str("Pile-up peaks"))
includeLayout.addWidget(self.sumCheck, 1, 2)
self.scatterCheck = qt.QCheckBox(includeWidget)
self.scatterCheck.setText(str("Scattering peaks"))
includeLayout.addWidget(self.scatterCheck, 1, 3)
self.stripCheck = qt.QCheckBox(includeWidget)
self.stripCheck.setText(str("Stripping"))
includeLayout.addWidget(self.stripCheck, 1, 0)
self.longCheck = qt.QCheckBox(includeWidget)
self.longCheck.setText(str("Long tail"))
includeLayout.addWidget(self.longCheck, 2, 1)
self.shortCheck = qt.QCheckBox(includeWidget)
self.shortCheck.setText(str("Short tail"))
includeLayout.addWidget(self.shortCheck, 2, 0)
#tabFitLayout.addLayout(includeLayout)
layout5.addMultiCellWidget(includeWidget, 18, 19, 0, 4)
spacer_2 = qt.QSpacerItem(20, 40,\
qt.QSizePolicy.Minimum,\
qt.QSizePolicy.Expanding)
tabFitLayout.addItem(spacer_2)
#self.mainTab.addTab(self.tabFit,str("FIT"))
self.tabDetector = qt.QWidget()
tabDetectorLayout = qt.QVBoxLayout(self.tabDetector)
tabDetectorLayout.setContentsMargins(11, 11, 11, 11)
tabDetectorLayout.setSpacing(6)
detLayout = Q3GridLayout(None)
detLayout.setContentsMargins(0, 0, 0, 0)
detLayout.setSpacing(2)
self.elementCombo = qt.QComboBox(self.tabDetector)
self.elementCombo.insertItem(0, str("Si"))
self.elementCombo.insertItem(1, str("Ge"))
self.elementCombo.insertItem(2, str("Cd1Te1"))
self.elementCombo.insertItem(3, str("Hg1I2"))
self.elementCombo.insertItem(4, str("Ga1As1"))
self.elementCombo.setEnabled(1)
self.elementCombo.setDuplicatesEnabled(0)
detLayout.addWidget(self.elementCombo, 0, 3)
self.elementLabel = qt.QLabel(self.tabDetector)
self.elementLabel.setText(str("Detector Composition"))
detLayout.addWidget(self.elementLabel, 0, 0)
self.escapeLabel = qt.QLabel(self.tabDetector)
self.escapeLabel.setText(str("Maximum Number of Escape energies"))
detLayout.addMultiCellWidget(self.escapeLabel, 3, 4, 0, 0)
#self.intensityValue0 = QLineEdit(self.tabDetector,"intensityValue0")
#self.intensityValue0.setText(str("1.0"))
#self.intensityValue0.setReadOnly(1)
self.nEscapeThreshold = Q3SpinBox(self.tabDetector)
self.nEscapeThreshold.setMaxValue(20)
self.nEscapeThreshold.setMinValue(1)
self.nEscapeThreshold.setValue(4)
#detLayout.addWidget(self.intensityValue0,3,3)
detLayout.addWidget(self.nEscapeThreshold, 3, 3)
spacer_4 = qt.QSpacerItem(89, 20,\
qt.QSizePolicy.Expanding,
qt.QSizePolicy.Minimum)
detLayout.addItem(spacer_4, 3, 1)
tabDetectorLayout.addLayout(detLayout)
self.calibLine = qt.QFrame(self.tabDetector)
self.calibLine.setFrameShape(qt.QFrame.HLine)
self.calibLine.setFrameShadow(qt.QFrame.Sunken)
self.calibLine.setFrameShape(qt.QFrame.HLine)
tabDetectorLayout.addWidget(self.calibLine)
layout5_2 = Q3GridLayout(None)
layout5_2.setContentsMargins(11, 11, 11, 11)
layout5_2.setSpacing(2)
self.zeroError = qt.QLineEdit(self.tabDetector)
layout5_2.addWidget(self.zeroError, 1, 5)
self.sumfacSepLabel = qt.QLabel(self.tabDetector)
sumfacSepLabel_font = qt.QFont(self.sumfacSepLabel.font())
sumfacSepLabel_font.setBold(1)
self.sumfacSepLabel.setFont(sumfacSepLabel_font)
self.sumfacSepLabel.setText(str("+/-"))
layout5_2.addWidget(self.sumfacSepLabel, 5, 4)
self.noiseLabel = qt.QLabel(self.tabDetector)
self.noiseLabel.setText(str("Detector noise (keV)"))
layout5_2.addWidget(self.noiseLabel, 3, 0)
self.gainCheck = qt.QCheckBox(self.tabDetector)
self.gainCheck.setText(str(""))
layout5_2.addWidget(self.gainCheck, 2, 2)
self.gainLabel = qt.QLabel(self.tabDetector)
self.gainLabel.setText(str("Spectrometer gain (keV/ch)"))
layout5_2.addWidget(self.gainLabel, 2, 0)
self.sumfacLabel = qt.QLabel(self.tabDetector)
self.sumfacLabel.setText(str("Pile-up Factor"))
layout5_2.addWidget(self.sumfacLabel, 5, 0)
self.noiseError = qt.QLineEdit(self.tabDetector)
layout5_2.addWidget(self.noiseError, 3, 5)
self.zeroValue = qt.QLineEdit(self.tabDetector)
layout5_2.addWidget(self.zeroValue, 1, 3)
self.fanoSepLabel = qt.QLabel(self.tabDetector)
fanoSepLabel_font = qt.QFont(self.fanoSepLabel.font())
fanoSepLabel_font.setBold(1)
self.fanoSepLabel.setFont(fanoSepLabel_font)
self.fanoSepLabel.setText(str("+/-"))
layout5_2.addWidget(self.fanoSepLabel, 4, 4)
self.fanoError = qt.QLineEdit(self.tabDetector)
layout5_2.addWidget(self.fanoError, 4, 5)
self.zeroSepLabel = qt.QLabel(self.tabDetector)
zeroSepLabel_font = qt.QFont(self.zeroSepLabel.font())
zeroSepLabel_font.setBold(1)
self.zeroSepLabel.setFont(zeroSepLabel_font)
self.zeroSepLabel.setText(str("+/-"))
layout5_2.addWidget(self.zeroSepLabel, 1, 4)
self.valueLabel = qt.QLabel(self.tabDetector)
valueLabel_font = qt.QFont(self.valueLabel.font())
valueLabel_font.setItalic(1)
self.valueLabel.setFont(valueLabel_font)
self.valueLabel.setText(str("Value"))
self.valueLabel.setAlignment(qt.Qt.AlignCenter)
layout5_2.addWidget(self.valueLabel, 0, 3)
layout5_2.addWidget(qt.HorizontalSpacer(self.tabDetector), 1, 1)
self.noiseValue = qt.QLineEdit(self.tabDetector)
layout5_2.addWidget(self.noiseValue, 3, 3)
self.fanoValue = qt.QLineEdit(self.tabDetector)
layout5_2.addWidget(self.fanoValue, 4, 3)
self.zeroLabel = qt.QLabel(self.tabDetector)
self.zeroLabel.setText(str("Spectrometer zero (keV)"))
layout5_2.addWidget(self.zeroLabel, 1, 0)
self.sumfacError = qt.QLineEdit(self.tabDetector)
layout5_2.addWidget(self.sumfacError, 5, 5)
self.noiseSepLabel = qt.QLabel(self.tabDetector)
noiseSepLabel_font = qt.QFont(self.noiseSepLabel.font())
noiseSepLabel_font.setBold(1)
self.noiseSepLabel.setFont(noiseSepLabel_font)
self.noiseSepLabel.setText(str("+/-"))
layout5_2.addWidget(self.noiseSepLabel, 3, 4)
self.sumfacCheck = qt.QCheckBox(self.tabDetector)
self.sumfacCheck.setText(str(""))
layout5_2.addWidget(self.sumfacCheck, 5, 2)
self.noiseCheck = qt.QCheckBox(self.tabDetector)
self.noiseCheck.setText(str(""))
layout5_2.addWidget(self.noiseCheck, 3, 2)
self.errorLabel = qt.QLabel(self.tabDetector)
errorLabel_font = qt.QFont(self.errorLabel.font())
errorLabel_font.setItalic(1)
self.errorLabel.setFont(errorLabel_font)
self.errorLabel.setText(str("Delta "))
self.errorLabel.setAlignment(QLabelAlignCenter)
layout5_2.addWidget(self.errorLabel, 0, 5)
self.fixedLabel = qt.QLabel(self.tabDetector)
fixedLabel_font = qt.QFont(self.fixedLabel.font())
fixedLabel_font.setItalic(1)
self.fixedLabel.setFont(fixedLabel_font)
self.fixedLabel.setText(str("Fixed "))
self.fixedLabel.setAlignment(qt.Qt.AlignVCenter)
layout5_2.addWidget(self.fixedLabel, 0, 2)
self.zeroCheck = qt.QCheckBox(self.tabDetector)
self.zeroCheck.setText(str(""))
layout5_2.addWidget(self.zeroCheck, 1, 2)
self.sumfacValue = qt.QLineEdit(self.tabDetector, )
layout5_2.addWidget(self.sumfacValue, 5, 3)
self.fanoLabel = qt.QLabel(self.tabDetector)
self.fanoLabel.setText(str("Fano factor (Si ~ 0.12, Ge ~ 0.1)"))
layout5_2.addWidget(self.fanoLabel, 4, 0)
self.gainValue = qt.QLineEdit(self.tabDetector)
layout5_2.addWidget(self.gainValue, 2, 3)
self.gainSepLabel = qt.QLabel(self.tabDetector)
gainSepLabel_font = qt.QFont(self.gainSepLabel.font())
gainSepLabel_font.setBold(1)
self.gainSepLabel.setFont(gainSepLabel_font)
self.gainSepLabel.setText(str("+/-"))
layout5_2.addWidget(self.gainSepLabel, 2, 4)
self.fanoCheck = qt.QCheckBox(self.tabDetector)
self.fanoCheck.setText(str(""))
layout5_2.addWidget(self.fanoCheck, 4, 2)
self.gainError = qt.QLineEdit(self.tabDetector)
layout5_2.addWidget(self.gainError, 2, 5)
self.ignoreSpectrumCalibration = qt.QCheckBox(self.tabDetector)
ignoreToolTip = "If checked, the starting calibration parameters "
ignoreToolTip += "will not be replaced by the input spectrum "
ignoreToolTip += "ones.\n"
self.ignoreSpectrumCalibration.setToolTip(ignoreToolTip)
ignoreText = "Ignore calibration from input data"
self.ignoreSpectrumCalibration.setText(ignoreText)
self.ignoreSpectrumCalibration.setChecked(False)
layout5_2.addWidget(self.ignoreSpectrumCalibration, 6, 0)
tabDetectorLayout.addLayout(layout5_2)
spacer_6 = qt.QSpacerItem(20, 2,\
qt.QSizePolicy.Minimum,\
qt.QSizePolicy.Expanding)
tabDetectorLayout.addItem(spacer_6)
self.mainTab.addTab(self.tabDetector, str("DETECTOR"))
self.TabBeam = qt.QWidget()
self.mainTab.addTab(self.TabBeam, str("BEAM"))
self.TabPeaks = qt.QWidget()
self.mainTab.addTab(self.TabPeaks, str("PEAKS"))
self.tabPeakShape = qt.QWidget()
tabPeakShapeLayout = Q3GridLayout(self.tabPeakShape)
tabPeakShapeLayout.setContentsMargins(11, 11, 11, 11)
tabPeakShapeLayout.setSpacing(2)
spacer_7 = qt.QSpacerItem(20, 90,\
qt.QSizePolicy.Minimum,\
qt.QSizePolicy.Expanding)
tabPeakShapeLayout.addItem(spacer_7, 8, 0)
self.staLabel = qt.QLabel(self.tabPeakShape)
self.staLabel.setText(str("Short Tail Area"))
tabPeakShapeLayout.addWidget(self.staLabel, 2, 0)
spacer_8 = qt.QSpacerItem(59, 20,\
qt.QSizePolicy.Expanding,\
qt.QSizePolicy.Minimum)
tabPeakShapeLayout.addItem(spacer_8, 1, 1)
self.fixedLabel_2 = qt.QLabel(self.tabPeakShape)
fixedLabel_2_font = qt.QFont(self.fixedLabel_2.font())
fixedLabel_2_font.setItalic(1)
self.fixedLabel_2.setFont(fixedLabel_2_font)
self.fixedLabel_2.setText(str("Fixed"))
self.fixedLabel_2.setAlignment(QLabelAlignVCenter)
tabPeakShapeLayout.addWidget(self.fixedLabel_2, 1, 2)
self.staCheck = qt.QCheckBox(self.tabPeakShape)
self.staCheck.setText(str(""))
tabPeakShapeLayout.addWidget(self.staCheck, 2, 2)
self.valueLabel_2 = qt.QLabel(self.tabPeakShape)
valueLabel_2_font = qt.QFont(self.valueLabel_2.font())
valueLabel_2_font.setItalic(1)
self.valueLabel_2.setFont(valueLabel_2_font)
self.valueLabel_2.setText(str("Value"))
self.valueLabel_2.setAlignment(QLabelAlignCenter)
tabPeakShapeLayout.addWidget(self.valueLabel_2, 1, 3)
self.staValue = qt.QLineEdit(self.tabPeakShape)
tabPeakShapeLayout.addWidget(self.staValue, 2, 3)
self.staSep = qt.QLabel(self.tabPeakShape)
staSep_font = qt.QFont(self.staSep.font())
staSep_font.setBold(1)
self.staSep.setFont(staSep_font)
self.staSep.setText(str("+/-"))
tabPeakShapeLayout.addWidget(self.staSep, 2, 4)
self.errorLabel_2 = qt.QLabel(self.tabPeakShape)
errorLabel_2_font = qt.QFont(self.errorLabel_2.font())
errorLabel_2_font.setItalic(1)
self.errorLabel_2.setFont(errorLabel_2_font)
self.errorLabel_2.setText(str("Error"))
self.errorLabel_2.setAlignment(QLabelAlignCenter)
tabPeakShapeLayout.addWidget(self.errorLabel_2, 1, 5)
self.staError = qt.QLineEdit(self.tabPeakShape)
tabPeakShapeLayout.addWidget(self.staError, 2, 5)
self.stsError = qt.QLineEdit(self.tabPeakShape)
tabPeakShapeLayout.addWidget(self.stsError, 3, 5)
self.stsSep = qt.QLabel(self.tabPeakShape)
stsSep_font = qt.QFont(self.stsSep.font())
stsSep_font.setBold(1)
self.stsSep.setFont(stsSep_font)
self.stsSep.setText(str("+/-"))
tabPeakShapeLayout.addWidget(self.stsSep, 3, 4)
self.stsValue = qt.QLineEdit(self.tabPeakShape)
tabPeakShapeLayout.addWidget(self.stsValue, 3, 3)
self.stsCheck = qt.QCheckBox(self.tabPeakShape)
self.stsCheck.setText(str(""))
tabPeakShapeLayout.addWidget(self.stsCheck, 3, 2)
self.stsLabel = qt.QLabel(self.tabPeakShape)
self.stsLabel.setText(str("Short Tail Slope"))
tabPeakShapeLayout.addWidget(self.stsLabel, 3, 0)
self.ltaLabel = qt.QLabel(self.tabPeakShape)
self.ltaLabel.setText(str("Long Tail Area"))
tabPeakShapeLayout.addWidget(self.ltaLabel, 4, 0)
self.ltaCheck = qt.QCheckBox(self.tabPeakShape)
self.ltaCheck.setText(str(""))
tabPeakShapeLayout.addWidget(self.ltaCheck, 4, 2)
self.ltaValue = qt.QLineEdit(self.tabPeakShape)
tabPeakShapeLayout.addWidget(self.ltaValue, 4, 3)
self.ltaSep = qt.QLabel(self.tabPeakShape)
ltaSep_font = qt.QFont(self.ltaSep.font())
ltaSep_font.setBold(1)
self.ltaSep.setFont(ltaSep_font)
self.ltaSep.setText(str("+/-"))
tabPeakShapeLayout.addWidget(self.ltaSep, 4, 4)
self.ltaError = qt.QLineEdit(self.tabPeakShape)
tabPeakShapeLayout.addWidget(self.ltaError, 4, 5)
self.ltsError = qt.QLineEdit(self.tabPeakShape)
tabPeakShapeLayout.addWidget(self.ltsError, 5, 5)
self.ltsSep = qt.QLabel(self.tabPeakShape)
ltsSep_font = qt.QFont(self.ltsSep.font())
ltsSep_font.setBold(1)
self.ltsSep.setFont(ltsSep_font)
self.ltsSep.setText(str("+/-"))
tabPeakShapeLayout.addWidget(self.ltsSep, 5, 4)
self.ltsValue = qt.QLineEdit(self.tabPeakShape)
tabPeakShapeLayout.addWidget(self.ltsValue, 5, 3)
self.ltsCheck = qt.QCheckBox(self.tabPeakShape)
self.ltsCheck.setText(str(""))
tabPeakShapeLayout.addWidget(self.ltsCheck, 5, 2)
self.ltsLabel = qt.QLabel(self.tabPeakShape)
self.ltsLabel.setText(str("Long Tail Slope"))
tabPeakShapeLayout.addWidget(self.ltsLabel, 5, 0)
# Step Height
self.shLabel = qt.QLabel(self.tabPeakShape)
self.shLabel.setText(str("Step Height"))
tabPeakShapeLayout.addWidget(self.shLabel, 6, 0)
self.shCheck = qt.QCheckBox(self.tabPeakShape)
self.shCheck.setText(str(""))
tabPeakShapeLayout.addWidget(self.shCheck, 6, 2)
self.shValue = qt.QLineEdit(self.tabPeakShape)
tabPeakShapeLayout.addWidget(self.shValue, 6, 3)
self.shSep = qt.QLabel(self.tabPeakShape)
shSep_font = qt.QFont(self.shSep.font())
shSep_font.setBold(1)
self.shSep.setFont(shSep_font)
self.shSep.setText(str("+/-"))
tabPeakShapeLayout.addWidget(self.shSep, 6, 4)
self.shError = qt.QLineEdit(self.tabPeakShape)
tabPeakShapeLayout.addWidget(self.shError, 6, 5)
# Pseudo-Voigt Eta Factor
self.etaLabel = qt.QLabel(self.tabPeakShape)
self.etaLabel.setText(str("Pseudo-Voigt Eta"))
tabPeakShapeLayout.addWidget(self.etaLabel, 7, 0)
self.etaCheck = qt.QCheckBox(self.tabPeakShape)
self.etaCheck.setText(str(""))
tabPeakShapeLayout.addWidget(self.etaCheck, 7, 2)
self.etaValue = qt.QLineEdit(self.tabPeakShape)
tabPeakShapeLayout.addWidget(self.etaValue, 7, 3)
self.etaSep = qt.QLabel(self.tabPeakShape)
etaSep_font = qt.QFont(self.etaSep.font())
etaSep_font.setBold(1)
self.etaSep.setFont(etaSep_font)
self.etaSep.setText(str("+/-"))
tabPeakShapeLayout.addWidget(self.etaSep, 7, 4)
self.etaError = qt.QLineEdit(self.tabPeakShape)
tabPeakShapeLayout.addWidget(self.etaError, 7, 5)
self.mainTab.addTab(self.tabPeakShape, str("PEAK SHAPE"))
FitParamFormLayout.addWidget(self.mainTab)
self.setTabOrder(self.mainTab, self.elementCombo)
self.setTabOrder(self.zeroCheck, self.zeroValue)
self.setTabOrder(self.zeroValue, self.zeroError)
self.setTabOrder(self.zeroError, self.gainCheck)
self.setTabOrder(self.gainCheck, self.gainValue)
self.setTabOrder(self.gainValue, self.gainError)
self.setTabOrder(self.gainError, self.noiseCheck)
self.setTabOrder(self.noiseCheck, self.noiseValue)
self.setTabOrder(self.noiseValue, self.noiseError)
self.setTabOrder(self.noiseError, self.fanoCheck)
self.setTabOrder(self.fanoCheck, self.fanoValue)
self.setTabOrder(self.fanoValue, self.fanoError)
self.setTabOrder(self.fanoError, self.staCheck)
self.setTabOrder(self.staCheck, self.staValue)
self.setTabOrder(self.staValue, self.staError)
self.setTabOrder(self.staError, self.stsCheck)
self.setTabOrder(self.stsCheck, self.stsValue)
self.setTabOrder(self.stsValue, self.stsError)
self.setTabOrder(self.stsError, self.ltaCheck)
self.setTabOrder(self.ltaCheck, self.ltaValue)
self.setTabOrder(self.ltaValue, self.ltaError)
self.setTabOrder(self.ltaError, self.ltsCheck)
self.setTabOrder(self.ltsCheck, self.ltsValue)
self.setTabOrder(self.ltsValue, self.ltsError)
self.setTabOrder(self.ltsError, self.shCheck)
self.setTabOrder(self.shCheck, self.shValue)
self.setTabOrder(self.shValue, self.shError)
self.setTabOrder(self.shError, self.contCombo)
self.setTabOrder(self.contCombo, self.stripCombo)
self.setTabOrder(self.stripCombo, self.iterSpin)
self.setTabOrder(self.iterSpin, self.chi2Value)
self.setTabOrder(self.chi2Value, self.regionCheck)
self.setTabOrder(self.regionCheck, self.minSpin)
self.setTabOrder(self.minSpin, self.maxSpin)
self.setTabOrder(self.maxSpin, self.stripCheck)
self.setTabOrder(self.stripCheck, self.escapeCheck)
self.setTabOrder(self.escapeCheck, self.sumCheck)
self.setTabOrder(self.sumCheck, self.scatterCheck)
self.setTabOrder(self.scatterCheck, self.shortCheck)
self.setTabOrder(self.shortCheck, self.longCheck)
self.setTabOrder(self.longCheck, self.stepCheck)
self._stripComboActivated(0)
def __init__(self, parent=None):
qt.QWidget.__init__(self, parent)
layout = qt.QGridLayout(self)
layout.setContentsMargins(10, 10, 10, 10)
layout.setSpacing(2)
# the flag to use it
useBox = qt.QWidget(self)
label = qt.QLabel(useBox)
label.setText("Use")
self.useCheckBox = qt.QCheckBox(useBox)
self.useCheckBox.setChecked(False)
self.useCheckBox.clicked.connect(self._useSlot)
useBoxLayout = qt.QHBoxLayout(useBox)
useBoxLayout.addWidget(label)
useBoxLayout.addWidget(self.useCheckBox)
layout.addWidget(useBox, 0, 0, 2, 1)
self.lineEditDict = {}
r = 0
c = 1
labels = ["Name", "Comment"]
for idx in range(len(labels)):
l = labels[idx]
label = qt.QLabel(self)
label.setText(l)
line = qt.QLineEdit(self)
line.editingFinished.connect(self._lineSlot)
line.setText("")
layout.addWidget(label, r, c)
layout.addWidget(line, r, c + 1)
self.lineEditDict[l.lower()] = line
r += 1
buttonsBox = qt.QWidget(self)
buttonsBoxLayout = qt.QHBoxLayout(buttonsBox)
self.buttonsDict = {}
actions = ["Load", "Save", "Show"]
slots = [self._loadSlot, self._saveSlot, self._showSlot]
buttonsBoxLayout.addWidget(qt.HorizontalSpacer(buttonsBox))
for i in range(len(slots)):
l = actions[i]
s = slots[i]
b = qt.QPushButton(buttonsBox)
b.setText(l)
b.setAutoDefault(False)
b.clicked.connect(s)
buttonsBoxLayout.addWidget(b)
self.buttonsDict[l.lower()] = b
buttonsBoxLayout.addWidget(qt.HorizontalSpacer(buttonsBox))
layout.addWidget(buttonsBox, 2, 0, 1, 3)
self.inputDir = None
self.outputDir = None
self.outputFilter = None
self.plotDialog = None
ddict = {}
ddict["use"] = 0
ddict["name"] = ""
ddict["comment"] = ""
ddict["energy"] = [0.0, 0.001]
ddict["transmission"] = [0.0, 1.0]
self._transmissionTable = ddict
self.update()
self.setTransmissionTable(ddict)
