Merge pull request #1009 from vasole/debian

Correct errors affecting Ubuntu 20.04

PyMca5/PyMcaGui/math/NNMAWindow.py

@@ -1,4 +1,4 @@
-#/*##########################################################################
+# /*##########################################################################
 # Copyright (C) 2004-2023 European Synchrotron Radiation Facility
 #
 # This file is part of the PyMca X-ray Fluorescence Toolkit developed at
@@ -31,6 +31,10 @@
 from PyMca5.PyMcaGui.math import PCAWindow
 from PyMca5.PyMcaGui import PyMcaQt as qt
 from PyMca5.PyMcaMath.mva import NNMAModule
+import logging
+
+_logger = logging.getLogger(__name__)
+
 
 class NNMAParametersDialog(qt.QDialog):
  def __init__(self, parent=None, options=[1, 2, 3, 4, 5, 10], regions=False):
@@ -42,15 +46,24 @@ def __init__(self, parent=None, options=[1, 2, 3, 4, 5, 10], regions=False):
 
  self.infoButton = qt.QPushButton(self)
  self.infoButton.setAutoDefault(False)
- self.infoButton.setText('About NNMA')
+ self.infoButton.setText("About NNMA")
  self.mainLayout.addWidget(self.infoButton)
  self.infoButton.clicked.connect(self._showInfo)
 
  #
  self.methodOptions = qt.QGroupBox(self)
- self.methodOptions.setTitle('NNMA Method to use')
- self.methods = ['RRI', 'NNSC', 'NMF', 'SNMF', 'NMFKL',
- 'FNMAI', 'ALS', 'FastHALS', 'GDCLS']
+ self.methodOptions.setTitle("NNMA Method to use")
+ self.methods = [
+ "RRI",
+ "NNSC",
+ "NMF",
+ "SNMF",
+ "NMFKL",
+ "FNMAI",
+ "ALS",
+ "FastHALS",
+ "GDCLS",
+ ]
  self.methodOptions.mainLayout = qt.QGridLayout(self.methodOptions)
  self.methodOptions.mainLayout.setContentsMargins(0, 0, 0, 0)
  self.methodOptions.mainLayout.setSpacing(2)
@@ -59,7 +72,7 @@ def __init__(self, parent=None, options=[1, 2, 3, 4, 5, 10], regions=False):
  for item in self.methods:
  rButton = qt.QRadioButton(self.methodOptions)
  self.methodOptions.mainLayout.addWidget(rButton, 0, i)
- #self.l.setAlignment(rButton, qt.Qt.AlignHCenter)
+ # self.l.setAlignment(rButton, qt.Qt.AlignHCenter)
  if i == 1:
  rButton.setChecked(True)
  rButton.setText(item)
@@ -74,17 +87,16 @@ def __init__(self, parent=None, options=[1, 2, 3, 4, 5, 10], regions=False):
  _logger.debug("Using deprecated signal")
  self.buttonGroup.buttonClicked[int].connect(self._slot)
 
-
  self.mainLayout.addWidget(self.methodOptions)
 
  # NNMA configuration parameters
  self.nnmaConfiguration = qt.QGroupBox(self)
- self.nnmaConfiguration.setTitle('NNMA Configuration')
+ self.nnmaConfiguration.setTitle("NNMA Configuration")
  self.nnmaConfiguration.mainLayout = qt.QGridLayout(self.nnmaConfiguration)
  self.nnmaConfiguration.mainLayout.setContentsMargins(0, 0, 0, 0)
  self.nnmaConfiguration.mainLayout.setSpacing(2)
  label = qt.QLabel(self.nnmaConfiguration)
- label.setText('Tolerance (0<eps<1000:')
+ label.setText("Tolerance (0<eps<1000:")
  self._tolerance = qt.QLineEdit(self.nnmaConfiguration)
  validator = qt.CLocaleQDoubleValidator(self._tolerance)
  self._tolerance.setValidator(validator)
@@ -93,7 +105,7 @@ def __init__(self, parent=None, options=[1, 2, 3, 4, 5, 10], regions=False):
  self.nnmaConfiguration.mainLayout.addWidget(label, 0, 0)
  self.nnmaConfiguration.mainLayout.addWidget(self._tolerance, 0, 1)
  label = qt.QLabel(self.nnmaConfiguration)
- label.setText('Maximum iterations:')
+ label.setText("Maximum iterations:")
  self._maxIterations = qt.QSpinBox(self.nnmaConfiguration)
  self._maxIterations.setMinimum(1)
  self._maxIterations.setMaximum(1000)
@@ -102,8 +114,7 @@ def __init__(self, parent=None, options=[1, 2, 3, 4, 5, 10], regions=False):
  self.nnmaConfiguration.mainLayout.addWidget(self._maxIterations, 1, 1)
  self.mainLayout.addWidget(self.nnmaConfiguration)
 
-
- #built in speed options
+ # built in speed options
  self.speedOptions = qt.QGroupBox(self)
  self.speedOptions.setTitle("Speed Options")
  self.speedOptions.mainLayout = qt.QGridLayout(self.speedOptions)
@@ -123,22 +134,21 @@ def __init__(self, parent=None, options=[1, 2, 3, 4, 5, 10], regions=False):
  self.binningCombo.addItem("%d" % option)
  self.speedOptions.mainLayout.addWidget(labelPC, 0, 0)
  self.speedOptions.mainLayout.addWidget(self.nPC, 0, 1)
- #self.speedOptions.mainLayout.addWidget(qt.HorizontalSpacer(self), 0, 2)
+ # self.speedOptions.mainLayout.addWidget(qt.HorizontalSpacer(self), 0, 2)
  self.speedOptions.mainLayout.addWidget(self.binningLabel, 1, 0)
  self.speedOptions.mainLayout.addWidget(self.binningCombo, 1, 1)
  self.binningCombo.setEnabled(True)
- self.binningCombo.activated[int].connect( \
- self._updatePlotFromBinningCombo)
+ self.binningCombo.activated[int].connect(self._updatePlotFromBinningCombo)
 
  if regions:
  self.__regions = True
  self.__addRegionsWidget()
  else:
  self.__regions = False
- #the optional plot
+ # the optional plot
  self.graph = None
 
- #the OK button
+ # the OK button
  hbox = qt.QWidget(self)
  hboxLayout = qt.QHBoxLayout(hbox)
  hboxLayout.setContentsMargins(0, 0, 0, 0)
@@ -170,51 +180,45 @@ def __init__(self, parent=None, options=[1, 2, 3, 4, 5, 10], regions=False):
  self._infoDocument.hide()
  self.mainLayout.addWidget(self._infoDocument)
 
-
  def _showInfo(self):
  self._infoDocument.show()
 
  def __addRegionsWidget(self):
- #Region handling
+ # Region handling
  self.regionsWidget = PCAWindow.RegionsWidget(self)
  self.regionsWidget.setEnabled(True)
- self.regionsWidget.sigRegionsWidgetSignal.connect( \
- self.regionsWidgetSlot)
- #the plot
+ self.regionsWidget.sigRegionsWidgetSignal.connect(self.regionsWidgetSlot)
+ # the plot
  self.graph = PCAWindow.ScanWindow.ScanWindow(self)
  self.graph.setEnabled(False)
  self.graph.sigPlotSignal.connect(self._graphSlot)
  if not self.__regions:
- #I am adding after instantiation
+ # I am adding after instantiation
  self.mainLayout.insertWidget(2, self.regionsWidget)
  self.mainLayout.addWidget(self.graph)
  self.__regions = True
 
  def regionsWidgetSlot(self, ddict):
  if ddict["nRegions"] > 0:
- fromValue = ddict['from']
- toValue  = ddict['to']
+ fromValue = ddict["from"]
+ toValue = ddict["to"]
  self.graph.setEnabled(True)
  self.graph.clearMarkers()
- self.graph.insertXMarker(fromValue,
- 'From',
- text='From',
- color='blue',
- draggable=True)
- self.graph.insertXMarker(toValue,
- 'To',
- text= 'To',
- color='blue',
- draggable=True)
+ self.graph.insertXMarker(
+ fromValue, "From", text="From", color="blue", draggable=True
+ )
+ self.graph.insertXMarker(
+ toValue, "To", text="To", color="blue", draggable=True
+ )
  self.graph.replot()
  else:
  self.graph.clearMarkers()
  self.graph.setEnabled(False)
 
  def _graphSlot(self, ddict):
- if ddict['event'] == "markerMoved":
- marker = ddict['label']
- value = ddict['x']
+ if ddict["event"] == "markerMoved":
+ marker = ddict["label"]
+ value = ddict["x"]
  signal = False
  if marker == "From":
  self.regionsWidget.fromLine.setText("%f" % value)
@@ -283,34 +287,33 @@ def updatePlot(self):
  self.graph.addCurve(x, y, legend=self._legend, replace=True)
 
  def setParameters(self, ddict):
- if 'options' in ddict:
+ if "options" in ddict:
  self.binningCombo.clear()
- for option in ddict['options']:
+ for option in ddict["options"]:
  self.binningCombo.addItem("%d" % option)
- if 'binning' in ddict:
- option = "%d" % ddict['binning']
+ if "binning" in ddict:
+ option = "%d" % ddict["binning"]
  for i in range(self.binningCombo.count()):
  if str(self.binningCombo.itemText(i)) == option:
  self.binningCombo.setCurrentIndex(i)
- if 'npc' in ddict:
- self.nPC.setValue(ddict['npc'])
- if 'method' in ddict:
- self.buttonGroup.buttons()[ddict['method']].setChecked(True)
- if 'regions' in ddict:
+ if "npc" in ddict:
+ self.nPC.setValue(ddict["npc"])
+ if "method" in ddict:
+ self.buttonGroup.buttons()[ddict["method"]].setChecked(True)
+ if "regions" in ddict:
  self.regionsWidget.setRegions(regions)
  return
 
  def getParameters(self):
  ddict = {}
  i = self.buttonGroup.checkedId()
- ddict['methodlabel'] = self.methods[i]
- ddict['function'] = NNMAModule.nnma
+ ddict["methodlabel"] = self.methods[i]
+ ddict["function"] = NNMAModule.nnma
  eps = float(self._tolerance.text())
  maxcount = self._maxIterations.value()
- ddict['binning'] = int(self.binningCombo.currentText())
- ddict['npc'] = self.nPC.value()
- ddict['kw'] = {'eps':eps,
- 'maxcount':maxcount}
+ ddict["binning"] = int(self.binningCombo.currentText())
+ ddict["npc"] = self.nPC.value()
+ ddict["kw"] = {"eps": eps, "maxcount": maxcount}
  mask = None
  if self.__regions:
  regions = self.regionsWidget.getRegions()
@@ -319,22 +322,30 @@ def getParameters(self):
  else:
  mask = numpy.zeros(self._binnedX.shape, dtype=numpy.uint8)
  for region in regions:
- mask[(self._binnedX >= region[0]) *\
- (self._binnedX <= region[1])] = 1
- ddict['regions'] = regions
+ mask[
+ (self._binnedX >= region[0]) * (self._binnedX <= region[1])
+ ] = 1
+ ddict["regions"] = regions
  # try to simplify life to the caller but can be hard if
  # spectral_binning has been applied because of the ambiguity
  # about if the spectral_mask is to be applied before or after
  # binning. The use of the 'regions' should be less prone to errors
- ddict['spectral_mask'] = mask
+ ddict["spectral_mask"] = mask
  else:
- ddict['regions'] = []
- ddict['spectral_mask'] = mask
+ ddict["regions"] = []
+ ddict["spectral_mask"] = mask
  return ddict
 
+
 class NNMAWindow(PCAWindow.PCAWindow):
- def setPCAData(self, images, eigenvalues=None, eigenvectors=None,
- imagenames = None, vectornames = None):
+ def setPCAData(
+ self,
+ images,
+ eigenvalues=None,
+ eigenvectors=None,
+ imagenames=None,
+ vectornames=None,
+ ):
  self.eigenValues = eigenvalues
  self.eigenVectors = eigenvectors
  if type(images) == type([]):
@@ -343,11 +354,11 @@ def setPCAData(self, images, eigenvalues=None, eigenvectors=None,
  nimages = images.shape[0]
  self.imageList = [0] * nimages
  for i in range(nimages):
- self.imageList[i] = images[i,:]
+ self.imageList[i] = images[i, :]
  if self.imageList[i].max() < 0:
  self.imageList[i] *= -1
  if self.eigenVectors is not None:
- self.eigenVectors [i] *= -1
+ self.eigenVectors[i] *= -1
  if imagenames is None:
  self.imageNames = []
  for i in range(nimages):
@@ -356,7 +367,7 @@ def setPCAData(self, images, eigenvalues=None, eigenvectors=None,
  self.imageNames = imagenames
 
  if self.imageList is not None:
- self.slider.setMaximum(len(self.imageList)-1)
+ self.slider.setMaximum(len(self.imageList) - 1)
  self.showImage(0)
  else:
  self.slider.setMaximum(0)
@@ -374,41 +385,50 @@ def setPCAData(self, images, eigenvalues=None, eigenvectors=None,
  if self.eigenValues is not None:
  self.vectorGraphTitles = []
  for i in range(nimages):
- self.vectorGraphTitles.append("%g %% explained intensity" %\
- self.eigenValues[i])
+ self.vectorGraphTitles.append(
+ "%g %% explained intensity" % self.eigenValues[i]
+ )
  self.vectorGraph.setGraphTitle(self.vectorGraphTitles[0])
 
  self.slider.setValue(0)
 
+
 def test2():
  app = qt.QApplication([])
  app.lastWindowClosed.connect(app.quit)
  dialog = NNMAParametersDialog(regions=True)
- #dialog.setParameters({'options':[1,3,5,7,9],'method':1, 'npc':8,'binning':3})
+ # dialog.setParameters({'options':[1,3,5,7,9],'method':1, 'npc':8,'binning':3})
  dialog.setModal(True)
  ret = dialog.exec()
  if ret:
  dialog.close()
  print(dialog.getParameters())
- #app.exec()
+ # app.exec()
+
 
 def test():
  app = qt.QApplication([])
  app.lastWindowClosed.connect(app.quit)
  container = NNMAWindow()
  data = numpy.arange(20000)
  data.shape = 2, 100, 100
- data[1, 0:100,0:50] = 100
- container.setPCAData(data, eigenvectors=[numpy.arange(100.), numpy.arange(100.)+10],
- imagenames=["I1", "I2"], vectornames=["V1", "V2"])
+ data[1, 0:100, 0:50] = 100
+ container.setPCAData(
+ data,
+ eigenvectors=[numpy.arange(100.0), numpy.arange(100.0) + 10],
+ imagenames=["I1", "I2"],
+ vectornames=["V1", "V2"],
+ )
  container.show()
+
  def theSlot(ddict):
- print(ddict['event'])
+ print(ddict["event"])
 
  container.sigMaskImageWidgetSignal.connect(theSlot)
  app.exec()
 
+
 if __name__ == "__main__":
  import numpy
- test2()
 
+ test2()