# coding: utf-8 # /*########################################################################## # # Copyright (C) 2016-2018 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__ = ["V. Valls"] __license__ = "MIT" __date__ = "16/10/2020" import logging import os.path from silx.gui import qt import silx.gui.plot import silx.gui.icons from silx.gui.plot.tools import PositionInfo import pyFAI.utils from .AbstractCalibrationTask import AbstractCalibrationTask from ..CalibrationContext import CalibrationContext from ..helper.SynchronizeRawView import SynchronizeRawView from ..helper.MarkerManager import MarkerManager from ..helper.SynchronizeMaskToolColor import SynchronizeMaskToolColor from ..helper.SynchronizePlotBackground import SynchronizePlotBackground _logger = logging.getLogger(__name__) class _MaskToolsWidget(silx.gui.plot.MaskToolsWidget.MaskToolsWidget): """Inherite the silx mask to be able to save and restore internally imported/exported masks to the application model.""" sigUserMaskChanged = qt.Signal() """Emitted when the user changes the mask. sigMaskChanged on silx 0.9 to not provide that. This signal is used with a filter. """ def __init__(self, parent=None, plot=None): silx.gui.plot.MaskToolsWidget.MaskToolsWidget.__init__(self, parent=parent, plot=plot) self.__syncColor = SynchronizeMaskToolColor(self) self.sigMaskChanged.connect(self.__emitUserMaskChanged) def __emitUserMaskChanged(self): self.sigUserMaskChanged.emit() def __extractDirectory(self, filename): if filename is not None and filename != "": if os.path.exists(filename): if os.path.isdir(filename): return filename else: return os.path.dirname(filename) return None @property def maskFileDir(self): """The directory from which to load/save mask from/to files.""" model = CalibrationContext.instance().getCalibrationModel() experimentSettings = model.experimentSettingsModel() # Reach from the previous mask previousFile = experimentSettings.mask().filename() directory = self.__extractDirectory(previousFile) if directory is None: previousFile = experimentSettings.image().filename() directory = self.__extractDirectory(previousFile) if directory is None: directory = os.getcwd() return directory @maskFileDir.setter def maskFileDir(self, maskFileDir): # We dont need to store it pass def save(self, filename, kind): try: result = silx.gui.plot.MaskToolsWidget.MaskToolsWidget.save(self, filename, kind) self.__maskFilenameUpdated(filename) finally: pass return result def load(self, filename): """Override the fuction importing a new mask.""" try: result = silx.gui.plot.MaskToolsWidget.MaskToolsWidget.load(self, filename) self.__maskFilenameUpdated(filename) finally: pass return result def __maskFilenameUpdated(self, filename): model = CalibrationContext.instance().getCalibrationModel() experimentSettings = model.experimentSettingsModel() with experimentSettings.mask().lockContext() as mask: mask.setFilename(filename) mask.setSynchronized(True) def setSelectionMask(self, mask, copy=True): self.sigMaskChanged.disconnect(self.__emitUserMaskChanged) result = super(_MaskToolsWidget, self).setSelectionMask(mask, copy=copy) self.sigMaskChanged.connect(self.__emitUserMaskChanged) return result def showEvent(self, event): self.sigMaskChanged.disconnect(self.__emitUserMaskChanged) result = silx.gui.plot.MaskToolsWidget.MaskToolsWidget.showEvent(self, event) self.sigMaskChanged.connect(self.__emitUserMaskChanged) return result class MaskTask(AbstractCalibrationTask): def _initGui(self): qt.loadUi(pyFAI.utils.get_ui_file("calibration-mask.ui"), self) icon = silx.gui.icons.getQIcon("pyfai:gui/icons/task-mask") self.setWindowIcon(icon) self.initNextStep() self.__plot = None self.__plot = self.__createPlot(self._imageHolder) self.__plot.setObjectName("plot-mask") self.__plotBackground = SynchronizePlotBackground(self.__plot) markerModel = CalibrationContext.instance().getCalibrationModel().markerModel() self.__markerManager = MarkerManager(self.__plot, markerModel, pixelBasedPlot=True) handle = self.__plot.getWidgetHandle() handle.setContextMenuPolicy(qt.Qt.CustomContextMenu) handle.customContextMenuRequested.connect(self.__plotContextMenu) self.__maskPanel = _MaskToolsWidget(parent=self._toolHolder, plot=self.__plot) self.__maskPanel.setDirection(qt.QBoxLayout.TopToBottom) self.__maskPanel.setMultipleMasks("single") layout = self.__maskPanel.layout() layout.setContentsMargins(0, 0, 0, 0) layout = qt.QVBoxLayout(self._toolHolder) layout.addWidget(self.__maskPanel) layout.setContentsMargins(0, 0, 0, 0) self._toolHolder.setLayout(layout) layout = qt.QVBoxLayout(self._imageHolder) layout.addWidget(self.__plot) layout.setContentsMargins(1, 1, 1, 1) self._imageHolder.setLayout(layout) self.__maskPanel.sigUserMaskChanged.connect(self.__maskFromPlotChanged) self.widgetShow.connect(self.__widgetShow) self.widgetHide.connect(self.__widgetHide) self.__plotMaskChanged = False self.__modelMaskChanged = False self.__synchronizeRawView = SynchronizeRawView() self.__synchronizeRawView.registerTask(self) self.__synchronizeRawView.registerPlot(self.__plot) def __plotContextMenu(self, pos): plot = self.__plot from silx.gui.plot.actions.control import ZoomBackAction zoomBackAction = ZoomBackAction(plot=plot, parent=plot) menu = qt.QMenu(self) menu.addAction(zoomBackAction) menu.addSeparator() menu.addAction(self.__markerManager.createMarkPixelAction(menu, pos)) menu.addAction(self.__markerManager.createMarkGeometryAction(menu, pos)) action = self.__markerManager.createRemoveClosestMaskerAction(menu, pos) if action is not None: menu.addAction(action) handle = plot.getWidgetHandle() menu.exec_(handle.mapToGlobal(pos)) def __createPlot(self, parent): plot = silx.gui.plot.PlotWidget(parent=parent) plot.setKeepDataAspectRatio(True) plot.setDataMargins(0.1, 0.1, 0.1, 0.1) plot.setGraphXLabel("Y") plot.setGraphYLabel("X") plot.setAxesDisplayed(False) colormap = CalibrationContext.instance().getRawColormap() plot.setDefaultColormap(colormap) from silx.gui.plot import tools toolBar = tools.InteractiveModeToolBar(parent=self, plot=plot) plot.addToolBar(toolBar) toolBar = tools.ImageToolBar(parent=self, plot=plot) colormapDialog = CalibrationContext.instance().getColormapDialog() toolBar.getColormapAction().setColorDialog(colormapDialog) plot.addToolBar(toolBar) statusBar = self.__createPlotStatusBar(plot) plot.setStatusBar(statusBar) return plot def __createPlotStatusBar(self, plot): converters = [ ('X', lambda x, y: x), ('Y', lambda x, y: y), ('Value', self.__getImageValue)] hbox = qt.QHBoxLayout() hbox.setContentsMargins(0, 0, 0, 0) info = PositionInfo(plot=plot, converters=converters) info.setSnappingMode(True) statusBar = qt.QStatusBar(plot) statusBar.setSizeGripEnabled(False) statusBar.addWidget(info) return statusBar def __getImageValue(self, x, y): """Get value of top most image at position (x, y). :param float x: X position in plot coordinates :param float y: Y position in plot coordinates :return: The value at that point or 'n/a' """ value = 'n/a' if self.__plot is None: # It could happen at the creation of the plot # the creation of PositionInfo return value image = self.__plot.getImage("image") if image is None: return value data = image.getData(copy=False) ox, oy = image.getOrigin() sx, sy = image.getScale() row, col = (y - oy) / sy, (x - ox) / sx if row >= 0 and col >= 0: # Test positive before cast otherwise issue with int(-0.5) = 0 row, col = int(row), int(col) if (row < data.shape[0] and col < data.shape[1]): value = data[row, col] return value def _updateModel(self, model): self.__synchronizeRawView.registerModel(model.rawPlotView()) settings = model.experimentSettingsModel() settings.image().changed.connect(self.__imageUpdated) settings.mask().changed.connect(self.__maskFromModelChanged) self.__maskFromModelChanged() self.__imageUpdated() def __imageUpdated(self): image = self.model().experimentSettingsModel().image().value() if image is not None: self.__plot.addImage(image, legend="image", copy=False) self.__plot.setGraphXLimits(0, image.shape[0]) self.__plot.setGraphYLimits(0, image.shape[1]) self.__plot.resetZoom() else: self.__plot.removeImage("image") def __widgetShow(self): # Really make sure to be synchronized # We can't trust events from libs self.__modelMaskChanged = True self.__updateWidgetFromModel() def __widgetHide(self): self.__updateModelFromWidget() def __maskFromPlotChanged(self): self.__plotMaskChanged = True def __maskFromModelChanged(self): self.__modelMaskChanged = True if self.isVisible(): self.__updateWidgetFromModel() def __updateWidgetFromModel(self): """Update the widget using the mask from the model, only if needed""" if not self.__modelMaskChanged: return mask = self.model().experimentSettingsModel().mask().value() # FIXME if mask is none, the mask should be cleaned up if mask is not None: self.__maskPanel.setSelectionMask(mask) # Everything is synchronized now self.__plotMaskChanged = False self.__modelMaskChanged = False def __updateModelFromWidget(self): """Update the model using the mask stored on the widget, only if needed""" if not self.__plotMaskChanged: return mask = self.__maskPanel.getSelectionMask() maskModel = self.model().experimentSettingsModel().mask() maskModel.changed.disconnect(self.__maskFromModelChanged) maskModel.setValue(mask) maskModel.changed.connect(self.__maskFromModelChanged) # Everything is synchronized now self.__plotMaskChanged = False self.__modelMaskChanged = False