def __createManufacturerModel(self):
manufacturers = set([])
for detector in pyFAI.detectors.ALL_DETECTORS.values():
manufacturers.add(detector.MANUFACTURER)
hasOther = None in manufacturers
manufacturers.remove(None)
manufacturers = sorted(list(manufacturers))
model = qt.QStandardItemModel()
item = qt.QStandardItem("All")
item.setData("*", role=self._ManufacturerRole)
model.appendRow(item)
# TODO rework this thing with a delegate
separator = qt.QStandardItem(" ")
separator.setSelectable(False)
separator.setEnabled(False)
stricked = separator.font()
stricked.setStrikeOut(True)
separator.setFont(stricked)
model.appendRow(separator)
for manufacturer in manufacturers:
item = qt.QStandardItem(manufacturer)
item.setData(manufacturer, role=self._ManufacturerRole)
model.appendRow(item)
if hasOther:
item = qt.QStandardItem("Other")
item.setData(None, role=self._ManufacturerRole)
model.appendRow(item)
return model
def _init(self):
self.setCheckable(True)
isosurface = self.subject
color = isosurface.getColor()
visible = isosurface.isVisible()
self.setData(color, qt.Qt.DecorationRole)
self.setCheckState((visible and qt.Qt.Checked) or qt.Qt.Unchecked)
nameItem = qt.QStandardItem('Level')
sliderItem = IsoSurfaceLevelSlider(self.subject)
self.appendRow([nameItem, sliderItem])
nameItem = qt.QStandardItem('Color')
nameItem.setEditable(False)
valueItem = IsoSurfaceColorItem(self.subject)
self.appendRow([nameItem, valueItem])
nameItem = qt.QStandardItem('Opacity')
nameItem.setTextAlignment(qt.Qt.AlignLeft | qt.Qt.AlignTop)
nameItem.setEditable(False)
valueItem = IsoSurfaceAlphaItem(self.subject)
self.appendRow([nameItem, valueItem])
nameItem = qt.QStandardItem()
nameItem.setEditable(False)
valueItem = IsoSurfaceAlphaLegendItem(self.subject)
valueItem.setEditable(False)
self.appendRow([nameItem, valueItem])
def setSfView(self, sfView):
"""
Sets the ScalarFieldView this view is controlling.
:param sfView: A `ScalarFieldView`
"""
model = qt.QStandardItemModel()
model.setColumnCount(ModelColumns.ColumnMax)
model.setHorizontalHeaderLabels(['Name', 'Value'])
item = qt.QStandardItem()
item.setEditable(False)
model.appendRow([ViewSettingsItem(sfView, 'Style'), item])
item = qt.QStandardItem()
item.setEditable(False)
model.appendRow([DataSetItem(sfView, 'Data'), item])
item = IsoSurfaceCount(sfView)
item.setEditable(False)
model.appendRow([IsoSurfaceGroup(sfView, 'Isosurfaces'), item])
item = qt.QStandardItem()
item.setEditable(False)
model.appendRow([PlaneGroup(sfView, 'Cutting Plane'), item])
self.setModel(model)
def _createSplittingModel(self):
model = qt.QStandardItemModel(self)
item = qt.QStandardItem("Any")
item.setData("*", self.CodeRole)
model.appendRow(item)
for name in method_registry.IntegrationMethod.AVAILABLE_SPLITS:
label = self._HUMAN_READABLE.get(name, name)
item = qt.QStandardItem(label)
item.setData(name, self.CodeRole)
model.appendRow(item)
return model
def __init__(self, parent):
qt.QStandardItemModel.__init__(self, parent)
detectorClasses = set(pyFAI.detectors.ALL_DETECTORS.values())
def getNameAndManufacturer(detectorClass):
modelName = None
result = []
if hasattr(detectorClass, "MANUFACTURER"):
manufacturer = detectorClass.MANUFACTURER
else:
manufacturer = None
if isinstance(manufacturer, list):
for index, m in enumerate(manufacturer):
if m is None:
continue
modelName = detectorClass.aliases[index]
result.append((modelName, m, detectorClass))
else:
if hasattr(detectorClass, "aliases"):
if len(detectorClass.aliases) > 0:
modelName = detectorClass.aliases[0]
if modelName is None:
modelName = detectorClass.__name__
result.append((modelName, manufacturer, detectorClass))
return result
def sortingKey(item):
modelName, manufacturerName, _detector = item
if modelName:
modelName = modelName.lower()
if manufacturerName:
manufacturerName = manufacturerName.lower()
return modelName, manufacturerName
items = []
for c in detectorClasses:
items.extend(getNameAndManufacturer(c))
items = sorted(items, key=sortingKey)
for modelName, manufacturerName, detector in items:
if detector is pyFAI.detectors.Detector:
continue
item = qt.QStandardItem(modelName)
item.setData(detector, role=self.CLASS_ROLE)
item.setData(modelName, role=self.MODEL_ROLE)
item.setData(manufacturerName, role=self.MANUFACTURER_ROLE)
item2 = qt.QStandardItem(manufacturerName)
item2.setData(detector, role=self.CLASS_ROLE)
item2.setData(modelName, role=self.MODEL_ROLE)
item2.setData(manufacturerName, role=self.MANUFACTURER_ROLE)
self.appendRow([item, item2])
def setData(self, data, fromDataSelector=False):
self.__info.setEnabled(data is not None)
if data is None:
self.__model.clear()
else:
self.__model.clear()
if silx.io.is_dataset(data):
kind = "Dataset"
elif silx.io.is_group(data):
kind = "Group"
elif silx.io.is_file(data):
kind = "File"
else:
kind = "Unknown"
headers = []
basename = data.name.split("/")[-1]
if basename == "":
basename = "/"
headers.append("Basename")
self.__model.appendRow([qt.QStandardItem(basename)])
headers.append("Kind")
self.__model.appendRow([qt.QStandardItem(kind)])
if hasattr(data, "dtype"):
headers.append("Type")
text = self.__formatter.humanReadableType(data)
self.__model.appendRow([qt.QStandardItem(text)])
if hasattr(data, "shape"):
headers.append("Shape")
text = self.__formatter.humanReadableShape(data)
self.__model.appendRow([qt.QStandardItem(text)])
if hasattr(data, "attrs") and "NX_class" in data.attrs:
headers.append("NX_class")
value = data.attrs["NX_class"]
formatter = self.__formatter.textFormatter()
old = formatter.useQuoteForText()
formatter.setUseQuoteForText(False)
text = self.__formatter.textFormatter().toString(value)
formatter.setUseQuoteForText(old)
self.__model.appendRow([qt.QStandardItem(text)])
self.__model.setVerticalHeaderLabels(headers)
self.__data = data
def __createModel(self):
model = qt.QStandardItemModel(self)
model.setHorizontalHeaderLabels(["Device", "Platform", "Type", "PID", "DID"])
if pyopencl is None:
model.setColumnCount(5)
return model
for platformId, platform in enumerate(pyopencl.get_platforms()):
for deviceId, device in enumerate(platform.get_devices(pyopencl.device_type.ALL)):
self.__availableIds[(platformId, deviceId)] = model.rowCount()
typeName = pyopencl.device_type.to_string(device.type)
deviceName = qt.QStandardItem(device.name)
platformName = qt.QStandardItem(platform.name)
deviceType = qt.QStandardItem(typeName)
deviceItem = qt.QStandardItem(str(deviceId))
platformItem = qt.QStandardItem(str(platformId))
model.appendRow([deviceName, platformName, deviceType, platformItem, deviceItem])
return model
def _init(self):
nameItem = IsoSurfaceAddRemoveItem(self.subject)
valueItem = qt.QStandardItem()
valueItem.setEditable(False)
self.appendRow([nameItem, valueItem])
subject = self.subject
isosurfaces = subject.getIsosurfaces()
for isosurface in isosurfaces:
self.__addIsosurface(isosurface)
def __init__(self, subject, *args):
super(ViewSettingsItem, self).__init__(*args)
self.setEditable(False)
classes = BackgroundColorItem, ForegroundColorItem, HighlightColorItem
for cls in classes:
titleItem = qt.QStandardItem(cls.itemName)
titleItem.setEditable(False)
self.appendRow([titleItem, cls(subject)])
def __init__(self, subject, *args):
super(DataSetItem, self).__init__(*args)
self.setEditable(False)
klasses = [DataTypeItem, DataShapeItem, OffsetItem, ScaleItem]
for klass in klasses:
titleItem = qt.QStandardItem(klass.itemName)
titleItem.setEditable(False)
self.appendRow([titleItem, klass(subject)])
def __selectCode(self, code, model, view):
selection = view.selectionModel()
index = self.__indexFromCode(model, code)
if not index.isValid():
# Create this code, as it looks to be provided somehow
item = qt.QStandardItem(code)
item.setData(code, self.CodeRole)
model.appendRow(item)
index = self.__indexFromCode(model, code)
old = selection.blockSignals(True)
selection.select(index, qt.QItemSelectionModel.ClearAndSelect)
selection.blockSignals(old)
def _init(self):
valueItem = qt.QStandardItem()
valueItem.setEditable(False)
nameItem = PlaneVisibleItem(self.subject, 'Visible')
self.appendRow([nameItem, valueItem])
nameItem = qt.QStandardItem('Colormap')
nameItem.setEditable(False)
valueItem = PlaneColormapItem(self.subject)
self.appendRow([nameItem, valueItem])
nameItem = qt.QStandardItem('Normalization')
nameItem.setEditable(False)
valueItem = NormalizationNode(self.subject)
self.appendRow([nameItem, valueItem])
nameItem = qt.QStandardItem('Orientation')
nameItem.setEditable(False)
valueItem = PlaneOrientationItem(self.subject)
self.appendRow([nameItem, valueItem])
nameItem = qt.QStandardItem('Interpolation')
nameItem.setEditable(False)
valueItem = PlaneInterpolationItem(self.subject)
self.appendRow([nameItem, valueItem])
nameItem = qt.QStandardItem('Autoscale')
nameItem.setEditable(False)
valueItem = PlaneAutoScaleItem(self.subject)
self.appendRow([nameItem, valueItem])
nameItem = qt.QStandardItem('Min')
nameItem.setEditable(False)
valueItem = PlaneMinRangeItem(self.subject)
self.appendRow([nameItem, valueItem])
nameItem = qt.QStandardItem('Max')
nameItem.setEditable(False)
valueItem = PlaneMaxRangeItem(self.subject)
self.appendRow([nameItem, valueItem])
nameItem = qt.QStandardItem('Values<=Min')
nameItem.setEditable(False)
valueItem = PlaneDisplayBelowMinItem(self.subject)
self.appendRow([nameItem, valueItem])
def __init__(self, label="", dataset=None):
"""Constructor"""
super(_DatasetItemRow, self).__init__(label)
self.setEditable(False)
self.setDropEnabled(False)
self.setDragEnabled(False)
self.__name = qt.QStandardItem()
self.__name.setEditable(False)
self.__name.setDropEnabled(True)
self.__type = qt.QStandardItem()
self.__type.setEditable(False)
self.__type.setDropEnabled(False)
self.__type.setDragEnabled(False)
self.__shape = qt.QStandardItem()
self.__shape.setEditable(False)
self.__shape.setDropEnabled(False)
self.__shape.setDragEnabled(False)
self.setDataset(dataset)
def getRowItems(self):
"""Returns the list of items used for a specific row.
The first item should be this class.
:rtype: List[qt.QStandardItem]
"""
row = [self]
for _ in range(3):
item = qt.QStandardItem("")
item.setEditable(False)
item.setDragEnabled(False)
item.setDropEnabled(False)
row.append(item)
return row
def __init__(self, parent):
qt.QStandardItemModel.__init__(self, parent)
detectorClasses = set(pyFAI.detectors.ALL_DETECTORS.values())
def getClassModel(detectorClass):
modelName = None
if hasattr(detectorClass, "aliases"):
if len(detectorClass.aliases) > 0:
modelName = detectorClass.aliases[0]
if modelName is None:
modelName = detectorClass.__name__
return modelName
items = [(getClassModel(c), c) for c in detectorClasses]
items = sorted(items)
for detectorName, detector in items:
if detector is pyFAI.detectors.Detector:
continue
item = qt.QStandardItem(detectorName)
item.setData(detector, role=self.CLASS_ROLE)
self.appendRow(item)
def __init__(self, parent):
super(DetectorSelectorDrop, self).__init__(parent)
qt.loadUi(pyFAI.utils.get_ui_file("detector-selection-drop.ui"), self)
self.__detector = None
self.__dialogState = None
model = self.__createManufacturerModel()
self._manufacturerList.setModel(model)
selection = self._manufacturerList.selectionModel()
selection.selectionChanged.connect(self.__manufacturerChanged)
model = AllDetectorModel(self)
modelFilter = DetectorFilter(self)
modelFilter.setSourceModel(model)
self._modelList.setModel(modelFilter)
selection = self._modelList.selectionModel()
selection.selectionChanged.connect(self.__modelChanged)
customModel = qt.QStandardItemModel(self)
item = qt.QStandardItem("From file")
item.setData("FILE", role=self._CustomDetectorRole)
customModel.appendRow(item)
item = qt.QStandardItem("Manual definition")
item.setData("MANUAL", role=self._CustomDetectorRole)
customModel.appendRow(item)
self._customList.setModel(customModel)
self._customList.setFixedHeight(self._customList.sizeHintForRow(0) * 2)
selection = self._customList.selectionModel()
selection.selectionChanged.connect(self.__customSelectionChanged)
self.__splineFile = DataModel()
self._splineFile.setModel(self.__splineFile)
self._splineLoader.clicked.connect(self.loadSplineFile)
self.__splineFile.changed.connect(self.__splineFileChanged)
self._splineError.setVisible(False)
self.__descriptionFile = DataModel()
self.__descriptionFile.changed.connect(self.__descriptionFileChanged)
self._fileSelection.setModel(self.__descriptionFile)
self._fileLoader.clicked.connect(self.__loadDetectorFormFile)
self._fileResult.setVisible(False)
self._fileError.setVisible(False)
self._splinePanel.setVisible(False)
validator = validators.IntegerAndEmptyValidator()
validator.setBottom(0)
self._detectorWidth.setValidator(validator)
self._detectorHeight.setValidator(validator)
self.__detectorWidth = DataModel()
self.__detectorHeight = DataModel()
self.__pixelWidth = DataModel()
self.__pixelHeight = DataModel()
self._detectorWidth.setModel(self.__detectorWidth)
self._detectorHeight.setModel(self.__detectorHeight)
self._pixelWidth.setModel(self.__pixelWidth)
self._pixelHeight.setModel(self.__pixelHeight)
self._customResult.setVisible(False)
self._customError.setVisible(False)
self.__detectorWidth.changed.connect(self.__customDetectorChanged)
self.__detectorHeight.changed.connect(self.__customDetectorChanged)
self.__pixelWidth.changed.connect(self.__customDetectorChanged)
self.__pixelHeight.changed.connect(self.__customDetectorChanged)
self.__customDetector = None
def __init__(self, parent=None):
super(DetectorSelectorDrop, self).__init__(parent)
qt.loadUi(pyFAI.utils.get_ui_file("detector-selection-drop.ui"), self)
self.__detector = None
self.__dialogState = None
model = self.__createManufacturerModel()
self._manufacturerList.setModel(model)
selection = self._manufacturerList.selectionModel()
selection.selectionChanged.connect(self.__manufacturerChanged)
model = AllDetectorModel(self)
modelFilter = DetectorFilter(self)
modelFilter.setSourceModel(model)
self._detectorView.setModel(modelFilter)
self._detectorView.setSelectionMode(qt.QAbstractItemView.SingleSelection)
self._detectorView.setSelectionBehavior(qt.QAbstractItemView.SelectRows)
self._detectorView.setSelectionBehavior(qt.QAbstractItemView.SelectRows)
self._detectorView.setWordWrap(False)
header = self._detectorView.horizontalHeader()
# Manufacturer first
self.MANUFACTURER_COLUMN = 1
header.moveSection(self.MANUFACTURER_COLUMN, 0)
if qt.qVersion() < "5.0":
header.setSectionResizeMode = self.setResizeMode
header.setSectionResizeMode(0, qt.QHeaderView.ResizeToContents)
header.setSectionResizeMode(1, qt.QHeaderView.ResizeToContents)
header.setStretchLastSection(True)
selection = self._detectorView.selectionModel()
selection.selectionChanged.connect(self.__modelChanged)
self._detectorView.doubleClicked.connect(self.__selectAndAccept)
customModel = qt.QStandardItemModel(self)
item = qt.QStandardItem("From file")
item.setData("FILE", role=self._CustomDetectorRole)
customModel.appendRow(item)
item = qt.QStandardItem("Manual definition")
item.setData("MANUAL", role=self._CustomDetectorRole)
customModel.appendRow(item)
self._customList.setModel(customModel)
self._customList.setFixedHeight(self._customList.sizeHintForRow(0) * 2)
selection = self._customList.selectionModel()
selection.selectionChanged.connect(self.__customSelectionChanged)
self.__splineFile = DataModel()
self._splineFile.setModel(self.__splineFile)
self._splineLoader.clicked.connect(self.loadSplineFile)
self.__splineFile.changed.connect(self.__splineFileChanged)
self._splineError.setVisible(False)
self.__descriptionFile = DataModel()
self.__descriptionFile.changed.connect(self.__descriptionFileChanged)
self._fileSelection.setModel(self.__descriptionFile)
self._fileLoader.clicked.connect(self.__loadDetectorFormFile)
self._fileResult.setVisible(False)
self._fileError.setVisible(False)
self._splinePanel.setVisible(False)
validator = validators.IntegerAndEmptyValidator()
validator.setBottom(0)
self._detectorWidth.setValidator(validator)
self._detectorHeight.setValidator(validator)
self.__detectorWidth = DataModel()
self.__detectorHeight = DataModel()
self.__pixelWidth = DataModel()
self.__pixelHeight = DataModel()
self._detectorWidth.setModel(self.__detectorWidth)
self._detectorHeight.setModel(self.__detectorHeight)
self._pixelWidth.setModel(self.__pixelWidth)
self._pixelHeight.setModel(self.__pixelHeight)
self._customResult.setVisible(False)
self._customError.setVisible(False)
self.__detectorWidth.changed.connect(self.__customDetectorChanged)
self.__detectorHeight.changed.connect(self.__customDetectorChanged)
self.__pixelWidth.changed.connect(self.__customDetectorChanged)
self.__pixelHeight.changed.connect(self.__customDetectorChanged)
self.__customDetector = None
# By default select all the manufacturers
self.__selectAllRegistreredDetector()
