Commit ba736506 authored by payno's avatar payno
Browse files

Merge branch 'save_components' into 'master'

Save components

See merge request julia.garriga/darfix!42
parents edf9704a 98603df5
Pipeline #21222 passed with stage
in 2 minutes and 17 seconds
......@@ -89,7 +89,8 @@ class Dataset(qt.QObject):
self.dark_filename = dark_filename
self.filenames = filenames
self.__dims = AcquisitionDims()
self._dimensions_values = None
# Keys: dimensions names, values: dimensions values
self._dimensions_values = {}
# Initialize data
self._file_series = fabio.open_series(first_filename=raw_filename,
......@@ -325,7 +326,7 @@ class Dataset(qt.QObject):
unique values.
"""
self.__dims.clear()
self._dimensions_values = None
self._dimensions_values = {}
keys = numpy.array(list(self.metadata[0].get_keys(kind)))
values = numpy.array([[data.get_value(kind=kind, name=key)[0] for data
......@@ -357,18 +358,14 @@ class Dataset(qt.QObject):
:returns: array_like
"""
if self._dimensions_values is None:
if not self._dimensions_values:
data = self.metadata
# Use only metadata of high intensity data
if self._filter_data:
data = numpy.array(self.metadata)[self.threshold]
values = numpy.empty((self.__dims.ndim, len(data)))
for row, metadata_frame in enumerate(data):
for dimension in self.__dims:
val = metadata_frame.get_value(kind=dimension[1].kind, name=dimension[1].name)
values[dimension[0]][row] = val[0]
self._dimensions_values = values
for dimension in self.__dims:
values = numpy.empty((len(data)))
for row, metadata_frame in enumerate(data):
values[row] = (metadata_frame.get_value(kind=dimension[1].kind,
name=dimension[1].name)[0])
self._dimensions_values[dimension[1].name] = values
return self._dimensions_values
def __deepcopy__(self, memo):
......
......@@ -42,7 +42,7 @@ class PCAWidget(qt.QMainWindow):
"""
Widget to apply PCA to a set of images and plot the eigenvalues found.
"""
signalComputed = qt.Signal()
sigComputed = qt.Signal()
def __init__(self, parent=None):
qt.QWidget.__init__(self, parent)
......@@ -102,4 +102,4 @@ class PCAWidget(qt.QMainWindow):
vals = [item for sublist in vals for item in sublist]
self._plot.show()
self._plot.addCurve(numpy.arange(len(vals)), vals, symbol='.', linestyle=' ')
self.signalComputed.emit()
self.sigComputed.emit()
......@@ -26,26 +26,21 @@
__authors__ = ["J. Garriga"]
__license__ = "MIT"
__date__ = "28/01/2020"
__date__ = "07/02/2020"
import numpy
from silx.gui import qt
from silx.gui import icons
from silx.gui.colors import Colormap
from silx.gui.plot import ScatterView, StackView, Plot1D
from silx.gui.widgets.FrameBrowser import HorizontalSliderWithBrowser
import darfix
from darfix.core.blindSourceSeparation import Method, BSS
from .operationThread import OperationThread
from .displayComponentsWidget import DisplayComponentsWidget
class BSSWidget(qt.QMainWindow):
"""
Widget to apply blind source separation.
"""
signalComputed = qt.Signal()
def __init__(self, parent=None):
qt.QMainWindow.__init__(self, parent)
......@@ -88,7 +83,10 @@ class BSSWidget(qt.QMainWindow):
self.splitter = qt.QSplitter(qt.Qt.Vertical)
self.splitter.addWidget(top_widget)
self.setCentralWidget(self.splitter)
self._init_plots()
self._displayComponentsWidget = DisplayComponentsWidget()
self.splitter.addWidget(self._displayComponentsWidget)
self._displayComponentsWidget.hide()
self.computeButton.clicked.connect(self._computeBSS)
self.detectButton.clicked.connect(self._detectComp)
......@@ -110,88 +108,6 @@ class BSSWidget(qt.QMainWindow):
self.BSS = BSS(self.dataset.hi_data)
self.computeButton.setEnabled(True)
self.detectButton.setEnabled(True)
self.bottom_widget.hide()
self._activateCurvesPlot(True)
if self.dataset.reshaped_data is not None:
self._plot_rocking_curves.showMotors(True)
self._toolbar.show()
self._plot_rocking_curves.resetDimensions()
# Motor dimension and index
self.dimension = 0
self.index = 0
for dimension in self.dataset.dims:
self._plot_rocking_curves.addDimension(dimension[1].name)
else:
self._plot_rocking_curves.showMotors(False)
self._toolbar.hide()
def _init_plots(self):
"""
Initialize the plots to show in the widget: a stackview window and a plot1d.
The first plot will be used to show the components found with the bss, the
second one will show the rocking curves and, if so, let the user filter them
by the moving motor.
"""
self._sv_components = StackView(parent=self)
self._sv_components.setColormap(Colormap(
name=darfix.config.DEFAULT_COLORMAP_NAME,
normalization='linear',
vmin=None,
vmax=None))
self._sv_components.setGraphTitle("Components")
self._sv_components.sigFrameChanged.connect(self._setCurve)
self._plot_rocking_curves = PlotRockingCurves()
self._plot_rocking_curves.sigFrameChanged.connect(self._updateFrameNumber)
self._plot_rocking_curves.sigMotorChanged.connect(self._updateMotorAxis)
self._plot_rocking_curves.sigActiveCurveChanged.connect(self._activeCurveChanged)
self._scatter_rocking_curves = ScatterView()
self._scatter_rocking_curves.hide()
self._toolbar = qt.QToolBar(parent=self)
self._toolbar.setIconSize(self._toolbar.iconSize() * 1.2)
curves_icon = icons.getQIcon('darfix:gui/icons/curves')
scatter_icon = icons.getQIcon('darfix:gui/icons/scatter')
self.curves_action = qt.QAction(curves_icon, "Curves", self)
self.curves_action.setCheckable(True)
self.curves_action.setChecked(True)
self.colormap_action = qt.QAction(scatter_icon, "Scatter", self)
self.colormap_action.setCheckable(True)
self.curves_action.toggled.connect(self._activateCurvesPlot)
self.colormap_action.triggered.connect(self.curves_action.toggle)
self._toolbar.addAction(self.curves_action)
self._toolbar.addAction(self.colormap_action)
self._toolbar.setOrientation(qt.Qt.Vertical)
self._toolbar.hide()
self.bottom_widget = qt.QWidget(self)
layout = qt.QGridLayout()
componentsLabel = qt.QLabel("Components")
rockingCurvesLabel = qt.QLabel("Rocking curves")
font = qt.QFont()
font.setBold(True)
componentsLabel.setFont(font)
rockingCurvesLabel.setFont(font)
layout.addWidget(componentsLabel, 1, 0, 1, 2, qt.Qt.AlignCenter)
layout.addWidget(rockingCurvesLabel, 1, 3, 1, 2, qt.Qt.AlignCenter)
layout.addWidget(self._sv_components, 2, 0, 2, 2)
layout.addWidget(self._plot_rocking_curves, 2, 3, 2, 2)
layout.addWidget(self._scatter_rocking_curves, 2, 3, 2, 2)
layout.addWidget(self._toolbar, 2, 5, 2, 1)
self.bottom_widget.setLayout(layout)
self.bottom_widget.hide()
self.splitter.addWidget(self.bottom_widget)
def _activateCurvesPlot(self, checked=False):
if checked:
self.colormap_action.setChecked(False)
self._scatter_rocking_curves.hide()
self._plot_rocking_curves.show()
else:
self._plot_rocking_curves.hide()
self._scatter_rocking_curves.show()
def _computeBSS(self):
"""
......@@ -213,11 +129,11 @@ class BSSWidget(qt.QMainWindow):
raise ValueError('BSS method not managed')
self._thread.setArgs(n_comp)
self._thread.finished.connect(self._setPlot)
self._thread.finished.connect(self._displayComponents)
self._thread.start()
def _setPlot(self):
self._thread.finished.disconnect(self._setPlot)
def _displayComponents(self):
self._thread.finished.disconnect(self._displayComponents)
comp, self.W = self._thread.data
n_comp = int(self.nComponentsLE.text())
if comp.shape[0] < n_comp:
......@@ -228,25 +144,17 @@ class BSSWidget(qt.QMainWindow):
msg.setStandardButtons(qt.QMessageBox.Ok)
msg.exec_()
self.comp = comp.reshape(n_comp, self.dataset.data.shape[1], self.dataset.data.shape[2])
self._sv_components.setStack(self.comp)
self._plot_rocking_curves.getPlot().clear()
self._plot_rocking_curves.getPlot().setGraphYLabel("Values")
for i in range(len(self.W.T)):
self._plot_rocking_curves.getPlot().addCurve(numpy.arange(len(self.W.T[i])), self.W.T[i], legend=str(i))
if self.dataset.reshaped_data is not None:
values = self.dataset.get_dimensions_values().astype(numpy.float)
colormap = Colormap(name='jet', normalization='linear')
self._scatter_rocking_curves.setData(values[0], values[1], self.W.T[0])
self._scatter_rocking_curves.setColormap(colormap)
self._scatter_rocking_curves.getPlotWidget().setGraphXLabel(self.dataset.dims.get(0).name)
self._scatter_rocking_curves.getPlotWidget().setGraphYLabel(self.dataset.dims.get(1).name)
self._scatter_rocking_curves.resetZoom()
self._plot_rocking_curves.getPlot().setActiveCurve("0")
self.bottom_widget.show()
self._displayComponentsWidget.show()
self.computeButton.setEnabled(True)
self.nComponentsLE.setEnabled(True)
if numpy.any(self.dataset.li_data):
# If filter data is activated, the matrix W has reduced dimensionality, so reshaping is not possible
# Create empty array with shape the total number of frames
W = numpy.zeros((self.dataset.nframes, n_comp))
# Set actual values of W where threshold of filter is True
W[self.dataset.threshold] = self.W
self.W = W
self._displayComponentsWidget.setComponents(self.comp, self.W, self.dataset.get_dimensions_values())
def _detectComp(self):
txt = self.maxNumComp.text()
......@@ -267,165 +175,3 @@ class BSSWidget(qt.QMainWindow):
components = len(vals[vals > 0.01])
self.detectButton.setEnabled(True)
self.nComponentsLE.setText(str(components))
def _activeCurveChanged(self, prev_legend=None, legend=None):
if legend:
self._setComponent(int(legend))
def _setComponent(self, index=None):
if index is not None:
status = self._sv_components.blockSignals(True)
self._sv_components.setFrameNumber(index)
self._sv_components.blockSignals(status)
values = self.dataset.get_dimensions_values().astype(numpy.float)
if self.dataset.reshaped_data is not None:
self._scatter_rocking_curves.setData(values[0], values[1], self.W.T[index])
def _setCurve(self, index=-1):
if index >= 0:
status = self._plot_rocking_curves.blockSignals(True)
self._plot_rocking_curves.getPlot().setActiveCurve(str(index))
self._plot_rocking_curves.blockSignals(status)
values = self.dataset.get_dimensions_values().astype(numpy.float)
if self.dataset.reshaped_data is not None:
self._scatter_rocking_curves.setData(values[0], values[1], self.W.T[index])
def _updateMotorAxis(self, axis=-1):
"""
Updates the motor to show the rocking curve from.
:param int axis: 0 if no motor is chosen, else axis of the motor.
"""
if axis == 0:
self._plot_rocking_curves.getPlot().setGraphYLabel("Values")
# Whole rocking curves are showed
self._plot_rocking_curves.clear()
for i in range(len(self.W.T)):
self._plot_rocking_curves.addCurve(numpy.arange(len(self.W.T[i])), self.W.T[i], legend=str(i))
self._plot_rocking_curves.getBrowser().setEnabled(False)
elif axis != -1 and axis is not None:
self._plot_rocking_curves.getPlot().setGraphYLabel(self._plot_rocking_curves.getDimensionsCB().currentText())
self.dimension = axis - 1
self._plot_rocking_curves.clear()
self._plot_rocking_curves.getBrowser().setEnabled(True)
self._plot_rocking_curves.getBrowser().setRange(0, len(self.dataset.dims.get(self.dimension).unique_values) - 1)
self._plot_rocking_curves.getBrowser().setValue(0)
for i in range(len(self.W.T)):
if numpy.any(self.dataset.li_data):
# If filter data is activated, the matrix W has reduced dimensionality, so reshaping is not possible
# Create empty array with shape the total number of frames
W = numpy.empty(self.dataset.threshold.shape)
# Set actual values of W where threshold of filter is True
W[self.dataset.threshold] = self.W.T[i]
# Take only the thresholds for the dimension
threshold = numpy.take(self.dataset.threshold.reshape(self.dataset.dims.shape), 0, axis=self.dimension)
# Reshape W into the dimensions and take the first element of the chosen dimension
W = numpy.take(W.reshape(self.dataset.dims.shape), 0, self.dimension)
# Take only the values of W that correspond to high intensity data
W = W[threshold]
else:
W = numpy.take(self.W.T[i].reshape(self.dataset.dims.shape), 0, self.dimension)
self._plot_rocking_curves.addCurve(numpy.arange(len(W)), W, legend=str(i))
else:
raise ValueError('Axis %s is not managed' % axis)
def _updateFrameNumber(self, index):
"""Update the current plot.
:param index: index of the frame to be displayed
"""
self.index = index
self._plot_rocking_curves.clear()
for i in range(len(self.W.T)):
if numpy.any(self.dataset.li_data):
# If filter data is activated, the matrix W has reduced dimensionality, so reshaping is not possible
# Create empty array with shape the total number of frames
W = numpy.empty(self.dataset.threshold.shape)
# Set actual values of W where threshold of filter is True
W[self.dataset.threshold] = self.W.T[i]
# Take only the thresholds for the dimension
threshold = numpy.take(self.dataset.threshold.reshape(self.dataset.dims.shape), self.index, axis=self.dimension)
# Reshape W into the dimensions and take the chosen element and dimension
W = numpy.take(W.reshape(self.dataset.dims.shape), self.index, self.dimension)
# Take only the values of W that correspond to high intensity data
W = W[threshold]
else:
W = numpy.take(self.W.T[i].reshape(self.dataset.dims.shape), self.index, self.dimension)
self._plot_rocking_curves.addCurve(numpy.arange(len(W)), W, legend=str(i))
class PlotRockingCurves(qt.QMainWindow):
sigFrameChanged = qt.Signal(int)
sigMotorChanged = qt.Signal(int)
sigActiveCurveChanged = qt.Signal(object, object)
def __init__(self, parent=None):
qt.QMainWindow.__init__(self, parent)
self._plot = Plot1D()
self._plot.setGraphTitle("Rocking curves")
self._plot.setGraphXLabel("Image id")
self._plot.sigActiveCurveChanged.connect(self.sigActiveCurveChanged)
self._motors = qt.QWidget()
self._motors.setLayout(self._motorsLayout())
self._motors.hide()
layout = qt.QVBoxLayout()
layout.addWidget(self._plot)
layout.addWidget(self._motors)
centralWidget = qt.QWidget()
centralWidget.setLayout(layout)
self.setCentralWidget(centralWidget)
self.addCurve = self._plot.addCurve
def _motorsLayout(self):
# If dataset data is reshaped
# Creates widget to move through the motors dimensions
layout = qt.QHBoxLayout()
cb_label = qt.QLabel("Static motor:")
self._cb = qt.QComboBox()
self._cb.setCurrentIndex(0)
# Default: all of the rocking curves are shown
self._cb.addItem("None")
browser_label = qt.QLabel("Motor index:")
self._browser = HorizontalSliderWithBrowser()
self._browser.setRange(0, 0)
# Browser only activated with choosen dimension
self._browser.setEnabled(False)
# Connect browser
self._browser.valueChanged[int].connect(self.sigFrameChanged)
# Connect combobox
self._cb.currentIndexChanged.connect(self.sigMotorChanged)
layout.addWidget(cb_label)
layout.addWidget(self._cb)
layout.addWidget(browser_label)
layout.addWidget(self._browser)
return layout
def getPlot(self):
return self._plot
def getBrowser(self):
return self._browser
def getDimensionsCB(self):
return self._cb
def clear(self):
self._plot.clear()
def showMotors(self, show=True):
self._motors.setVisible(show)
def addDimension(self, dimension):
self._cb.addItem(dimension)
def resetDimensions(self):
for i in range(1, self._cb.count()):
self._cb.removeItem(i)
......@@ -45,7 +45,7 @@ class DatasetSelectionWidget(qt.QTabWidget):
If both options are filled up, only the files in the list of filenames
are read.
"""
signalProgress = qt.Signal(int)
sigProgressChanged = qt.Signal(int)
def __init__(self, parent=None):
qt.QTabWidget.__init__(self, parent)
......@@ -90,7 +90,7 @@ class DatasetSelectionWidget(qt.QTabWidget):
self._dataset = Dataset(filenames=self._rawFilesData.getFiles(),
dark_filename=self._darkFilenameData.getFilename(),
load_data=False, filter_data=self._filterData)
self._dataset.signalProgress.connect(self.updateProgress)
self._dataset.sigProgressChanged.connect(self.updateProgress)
_logger.info("Loading data urls")
self._dataset.load_data(0.3)
_logger.info("Loading data")
......@@ -102,7 +102,7 @@ class DatasetSelectionWidget(qt.QTabWidget):
return self._dataset
def updateProgress(self, progress):
self.signalProgress.emit(progress)
self.sigProgressChanged.emit(progress)
def __filterData(self, filterData):
self._filterData = filterData
......
# coding: utf-8
# /*##########################################################################
#
# Copyright (c) 2017-2019 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.
#
# ###########################################################################*/
__authors__ = ["J. Garriga"]
__license__ = "MIT"
__date__ = "07/02/2020"
import numpy
from silx.gui import qt
from silx.gui import icons
from silx.gui.colors import Colormap
from silx.gui.plot import ScatterView, StackView, Plot1D
from silx.gui.widgets.FrameBrowser import HorizontalSliderWithBrowser
import darfix
from darfix.io.utils import write_components
class DisplayComponentsWidget(qt.QMainWindow):
"""
Widget to apply blind source separation.
"""
def __init__(self, parent=None):
qt.QMainWindow.__init__(self, parent)
# Widget with the type of bss and the number of components to compute
widget = qt.QWidget(self)
self._sv_components = StackView(parent=self)
self._sv_components.setColormap(Colormap(
name=darfix.config.DEFAULT_COLORMAP_NAME,
normalization='linear',
vmin=None,
vmax=None))
self._sv_components.setGraphTitle("Components")
self._sv_components.sigFrameChanged.connect(self._setCurve)
self._plot_rocking_curves = PlotRockingCurves()
self._plot_rocking_curves.sigFrameChanged.connect(self._updateFrameNumber)
self._plot_rocking_curves.sigMotorChanged.connect(self._updateMotorAxis)
self._plot_rocking_curves.sigActiveCurveChanged.connect(self._activeCurveChanged)
self._scatter_rocking_curves = ScatterView()
self._scatter_rocking_curves.hide()
self._toolbar = qt.QToolBar(parent=self)
self._toolbar.setIconSize(self._toolbar.iconSize() * 1.2)
curves_icon = icons.getQIcon('darfix:gui/icons/curves')
scatter_icon = icons.getQIcon('darfix:gui/icons/scatter')
self.curves_action = qt.QAction(curves_icon, "Curves", self)
self.curves_action.setCheckable(True)
self.curves_action.setChecked(True)
self.colormap_action = qt.QAction(scatter_icon, "Scatter", self)
self.colormap_action.setCheckable(True)
self.curves_action.toggled.connect(self._activateCurvesPlot)
self.colormap_action.triggered.connect(self.curves_action.toggle)
self._toolbar.addAction(self.curves_action)
self._toolbar.addAction(self.colormap_action)
self._toolbar.setOrientation(qt.Qt.Vertical)
self._toolbar.hide()
self.bottom_widget = qt.QWidget(self)
layout = qt.QGridLayout()
componentsLabel = qt.QLabel("Components")
rockingCurvesLabel = qt.QLabel("Rocking curves")
font = qt.QFont()
font.setBold(True)
componentsLabel.setFont(font)
rockingCurvesLabel.setFont(font)
layout.addWidget(componentsLabel, 1, 0, 1, 2, qt.Qt.AlignCenter)
layout.addWidget(rockingCurvesLabel, 1, 3, 1, 2, qt.Qt.AlignCenter)
layout.addWidget(self._sv_components, 2, 0, 2, 2)
layout.addWidget(self._plot_rocking_curves, 2, 3, 2, 2)
layout.addWidget(self._scatter_rocking_curves, 2, 3, 2, 2)
layout.addWidget(self._toolbar, 2, 5, 2, 1)
self.saveB = qt.QPushButton("Save components")
self.saveB.pressed.connect(self._saveComp)
layout.addWidget(self.saveB, 4, 4, 1, -1)
widget.setLayout(layout)
self.setCentralWidget(widget)
def hideButton(self):
self._computeB.hide()
def showButton(self):
self._computeB.show()
def setComponents(self, components, W, dimensions):
"""
Components setter. Updates the plots with the components and their
corresponding rocking curves.
:param array_like components: stack of images with the components
:param array_like W: array with the rocking curves intensity
:param dict dimensions: dictionary with the values of the dimensions
"""
self.components = components
self.W = W
self.dimensions = dimensions
self._activateCurvesPlot(True)
self._sv_components.setStack(self.components)
self._plot_rocking_curves.getPlot().clear()
self._plot_rocking_curves.getPlot().setGraphYLabel("Values")
for i in range(len(self.W.T)):
self._plot_rocking_curves.getPlot().addCurve(numpy.arange(len(self.W.T[i])),
self.W.T[i], legend=str(i))
if self.dimensions:
colormap = Colormap(name='jet', normalization='linear')
keys = list(self.dimensions.keys())
self._scatter_rocking_curves.getPlotWidget().setGraphXLabel(keys[0])
self._scatter_rocking_curves.getPlotWidget().setGraphYLabel(keys[1])
self._scatter_rocking_curves.setData(
self.dimensions[keys[0]].astype(numpy.float),
self.dimensions[keys[1]].astype(numpy.float), self.W.T[0])
self._scatter_rocking_curves.setColormap(colormap)
self._scatter_rocking_curves.resetZoom()
self._plot_rocking_curves.showMotors(True)
self._toolbar.show()
self._plot_rocking_curves.resetDimensions()
# Motor dimension and index
self.dimension = 0
self.index = 0