# coding: utf-8
# /*##########################################################################
#
# Copyright (c) 2016-2020 European Synchrotron Radiation Facility
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
#
# ###########################################################################*/
"""
This module contains an :class:`DataFileDialog`.
"""
__authors__ = ["V. Valls"]
__license__ = "MIT"
__date__ = "14/02/2018"
import enum
import logging
from silx.gui import qt
from silx.gui.hdf5.Hdf5Formatter import Hdf5Formatter
import silx.io
from .AbstractDataFileDialog import AbstractDataFileDialog
import fabio
_logger = logging.getLogger(__name__)
class _DataPreview(qt.QWidget):
"""Provide a preview of the selected image"""
def __init__(self, parent=None):
super(_DataPreview, self).__init__(parent)
self.__formatter = Hdf5Formatter(self)
self.__data = None
self.__info = qt.QTableView(self)
self.__model = qt.QStandardItemModel(self)
self.__info.setModel(self.__model)
self.__info.horizontalHeader().hide()
self.__info.horizontalHeader().setStretchLastSection(True)
layout = qt.QVBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
layout.addWidget(self.__info)
self.setLayout(layout)
def colormap(self):
return None
def setColormap(self, colormap):
# Ignored
pass
def sizeHint(self):
return qt.QSize(200, 200)
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 __imageItem(self):
image = self.__plot.getImage("data")
return image
def data(self):
if self.__data is not None:
if hasattr(self.__data, "name"):
# in case of HDF5
if self.__data.name is None:
# The dataset was closed
self.__data = None
return self.__data
def clear(self):
self.__data = None
self.__info.setText("")
[docs]class DataFileDialog(AbstractDataFileDialog):
"""The `DataFileDialog` class provides a dialog that allow users to select
any datasets or groups from an HDF5-like file.
The `DataFileDialog` class enables a user to traverse the file system in
order to select an HDF5-like file. Then to traverse the file to select an
HDF5 node.
.. image:: img/datafiledialog.png
The selected data is any kind of group or dataset. It can be restricted
to only existing datasets or only existing groups using
:meth:`setFilterMode`. A callback can be defining using
:meth:`setFilterCallback` to filter even more data which can be returned.
Filtering data which can be returned by a `DataFileDialog` can be done like
that:
.. code-block:: python
# Force to return only a dataset
dialog = DataFileDialog()
dialog.setFilterMode(DataFileDialog.FilterMode.ExistingDataset)
.. code-block:: python
def customFilter(obj):
if "NX_class" in obj.attrs:
return obj.attrs["NX_class"] in [b"NXentry", u"NXentry"]
return False
# Force to return an NX entry
dialog = DataFileDialog()
# 1st, filter out everything which is not a group
dialog.setFilterMode(DataFileDialog.FilterMode.ExistingGroup)
# 2nd, check what NX_class is an NXentry
dialog.setFilterCallback(customFilter)
Executing a `DataFileDialog` can be done like that:
.. code-block:: python
dialog = DataFileDialog()
result = dialog.exec_()
if result:
print("Selection:")
print(dialog.selectedFile())
print(dialog.selectedUrl())
else:
print("Nothing selected")
If the selection is a dataset you can access to the data using
:meth:`selectedData`.
If the selection is a group or if you want to read the selected object on
your own you can use the `silx.io` API.
.. code-block:: python
url = dialog.selectedUrl()
with silx.io.open(url) as data:
pass
Or by loading the file first
.. code-block:: python
url = dialog.selectedDataUrl()
with silx.io.open(url.file_path()) as h5:
data = h5[url.data_path()]
Or by using `h5py` library
.. code-block:: python
url = dialog.selectedDataUrl()
with h5py.File(url.file_path(), mode="r") as h5:
data = h5[url.data_path()]
"""
[docs] class FilterMode(enum.Enum):
"""This enum is used to indicate what the user may select in the
dialog; i.e. what the dialog will return if the user clicks OK."""
AnyNode = 0
"""Any existing node from an HDF5-like file."""
ExistingDataset = 1
"""An existing HDF5-like dataset."""
ExistingGroup = 2
"""An existing HDF5-like group. A file root is a group."""
def __init__(self, parent=None):
AbstractDataFileDialog.__init__(self, parent=parent)
self.__filter = DataFileDialog.FilterMode.AnyNode
self.__filterCallback = None
[docs] def selectedData(self):
"""Returns the selected data by using the :meth:`silx.io.get_data`
API with the selected URL provided by the dialog.
If the URL identify a group of a file it will raise an exception. For
group or file you have to use on your own the API :meth:`silx.io.open`.
:rtype: numpy.ndarray
:raise ValueError: If the URL do not link to a dataset
"""
url = self.selectedUrl()
return silx.io.get_data(url)
def _createPreviewWidget(self, parent):
previewWidget = _DataPreview(parent)
previewWidget.setSizePolicy(qt.QSizePolicy.Expanding, qt.QSizePolicy.Expanding)
return previewWidget
def _createSelectorWidget(self, parent):
# There is no selector
return None
def _createPreviewToolbar(self, parent, dataPreviewWidget, dataSelectorWidget):
# There is no toolbar
return None
def _isDataSupportable(self, data):
"""Check if the selected data can be supported at one point.
If true, the data selector will be checked and it will update the data
preview. Else the selecting is disabled.
:rtype: bool
"""
# Everything is supported
return True
def _isFabioFilesSupported(self):
# Everything is supported
return False
def _isDataSupported(self, data):
"""Check if the data can be returned by the dialog.
If true, this data can be returned by the dialog and the open button
will be enabled. If false the button will be disabled.
:rtype: bool
"""
if self.__filter == DataFileDialog.FilterMode.AnyNode:
accepted = True
elif self.__filter == DataFileDialog.FilterMode.ExistingDataset:
accepted = silx.io.is_dataset(data)
elif self.__filter == DataFileDialog.FilterMode.ExistingGroup:
accepted = silx.io.is_group(data)
else:
raise ValueError("Filter %s is not supported" % self.__filter)
if not accepted:
return False
if self.__filterCallback is not None:
try:
return self.__filterCallback(data)
except Exception:
_logger.error("Error while executing custom callback", exc_info=True)
return False
return True
[docs] def setFilterCallback(self, callback):
"""Set the filter callback. This filter is applied only if the filter
mode (:meth:`filterMode`) first accepts the selected data.
It is not supposed to be set while the dialog is being used.
:param callable callback: Define a custom function returning a boolean
and taking as argument an h5-like node. If the function returns true
the dialog can return the associated URL.
"""
self.__filterCallback = callback
[docs] def setFilterMode(self, mode):
"""Set the filter mode.
It is not supposed to be set while the dialog is being used.
:param DataFileDialog.FilterMode mode: The new filter.
"""
self.__filter = mode
[docs] def fileMode(self):
"""Returns the filter mode.
:rtype: DataFileDialog.FilterMode
"""
return self.__filter
def _displayedDataInfo(self, dataBeforeSelection, dataAfterSelection):
"""Returns the text displayed under the data preview.
This zone is used to display error in case or problem of data selection
or problems with IO.
:param numpy.ndarray dataAfterSelection: Data as it is after the
selection widget (basically the data from the preview widget)
:param numpy.ndarray dataAfterSelection: Data as it is before the
selection widget (basically the data from the browsing widget)
:rtype: bool
"""
return u""
