tomwer 1.2.0a1__py3-none-any.whl → 1.2.0a3__py3-none-any.whl

tomwer/gui/control/test/test_reducedarkflat_selector.py

@@ -0,0 +1,280 @@
+import numpy
+from silx.gui.utils.testutils import SignalListener
+from tomwer.tests.conftest import qtapp  # noqa F401
+from tomwer.gui.control.reducedarkflatselector import (
+    filter_selected_reduced_frames,
+    filter_unselected_reduced_frames,
+    ReduceDarkFlatSelectorWidget,
+    ReduceDarkFlatSelectorDialog,
+)
+
+
+def test_reduce_darkflat_selector(
+    qtapp,  # noqa F811
+):
+    widget = ReduceDarkFlatSelectorWidget()
+    widget.show()
+
+    widget.addReduceFrames(
+        {
+            0: numpy.random.random(100 * 100).reshape(100, 100),
+            1: numpy.random.random(100 * 100).reshape(100, 100),
+        }
+    )
+
+    widget.addReduceFrames(
+        {
+            "reduce_frames_name": "my_dict",
+            -1: numpy.random.random(100 * 100).reshape(100, 100),
+            2: numpy.random.random(100 * 100).reshape(100, 100),
+        }
+    )
+
+    config = widget.getConfiguration()
+    assert len(config) == 2
+    assert config[0]["reduce_frames_name"] == "reduced frames #0"
+    assert config[1]["reduce_frames_name"] == "my_dict"
+
+    widget.setConfiguration(
+        (
+            {
+                "reduce_frames_name": "toto frames",
+                "reduce_frames": (
+                    {
+                        "index": -1,  # -1 will be interpreated as at the end of the acquisition
+                        "data": numpy.random.random(20 * 20).reshape(20, 20),
+                        "selected": True,
+                    },
+                    {
+                        "index": 0,
+                        "data": numpy.random.random(20 * 20).reshape(20, 20),
+                        "selected": True,
+                    },
+                ),
+            },
+            {
+                "reduce_frames_name": "tata frames",
+                "reduce_frames": (
+                    {
+                        "index": "0.25r",
+                        "data": numpy.random.random(40 * 20).reshape(40, 20),
+                        "selected": False,
+                    },
+                ),
+            },
+        )
+    )
+
+    config = widget.getConfiguration()
+    assert len(config) == 2
+    # check selection has been well take into account
+    assert config[0]["reduce_frames"][0]["selected"]
+    assert config[0]["reduce_frames"][1]["selected"]
+    assert not config[1]["reduce_frames"][0]["selected"]
+
+    selected_frames = widget.getSelectedReduceFrames()
+    assert -1 in selected_frames
+    assert 0 in selected_frames
+    assert 0.25 not in selected_frames
+
+    # test receive twice the same 'reduce_frames_name'
+    widget.clear()
+    assert len(widget.getConfiguration()) == 0
+    for i in range(2):
+        widget.addReduceFrames(
+            {
+                "reduce_frames_name": "my_dict",
+                -1: numpy.random.random(100 * 100).reshape(100, 100),
+                2: numpy.random.random(100 * 100).reshape(100, 100),
+            }
+        )
+    assert len(widget.getConfiguration()) == 1
+
+
+def test_reduce_darkflat_selector_dialog(
+    qtapp,  # noqa F811
+):
+    dialog = ReduceDarkFlatSelectorDialog()
+
+    flat_sel_signal_listener = SignalListener()
+    dialog.sigSelectActiveAsFlats.connect(flat_sel_signal_listener)
+
+    dark_sel_signal_listener = SignalListener()
+    dialog.sigSelectActiveAsDarks.connect(dark_sel_signal_listener)
+
+    dialog.show()
+
+    dialog.addReduceFrames(
+        {
+            0: numpy.random.random(100 * 100).reshape(100, 100),
+            1: numpy.random.random(100 * 100).reshape(100, 100),
+        },
+        selected=(1,),
+    )
+
+    dialog.addReduceFrames(
+        {
+            "reduce_frames_name": "my_dict",
+            -1: numpy.random.random(100 * 100).reshape(100, 100),
+            2: numpy.random.random(100 * 100).reshape(100, 100),
+        },
+        selected=(-1,),
+    )
+
+    # check dark selection
+    assert dark_sel_signal_listener.callCount() == 0
+    dialog._darkSelected()
+    assert dark_sel_signal_listener.callCount() == 1
+    assert -1 in dark_sel_signal_listener.arguments()[0][0]
+
+    # check flat selection
+    assert flat_sel_signal_listener.callCount() == 0
+    dialog._flatSelected()
+    assert flat_sel_signal_listener.callCount() == 1
+    assert -1 in flat_sel_signal_listener.arguments()[0][0]
+
+    # check remove selected
+    dialog._removeSelected()
+    assert dialog._widget.getSelectedReduceFrames() == {}
+
+    # check clear selection
+    dialog.addReduceFrames(
+        {
+            "reduce_frames_name": "new dict",
+            -1: numpy.random.random(100 * 100).reshape(100, 100),
+            2: numpy.random.random(100 * 100).reshape(100, 100),
+        },
+        selected=(-1, 2),
+    )
+
+    assert len(dialog._widget.getSelectedReduceFrames()) == 2
+    dialog._clearSelection()
+    assert len(dialog._widget.getSelectedReduceFrames()) == 0
+
+
+def test_reduced_frames_filtering():
+    """
+    dummy test of the filter_selected_reduced_frames filter_unselected_reduced_frames function
+    """
+    check_reduce_frames_configuration(
+        filter_selected_reduced_frames(
+            (
+                {
+                    "reduce_frames_name": "toto frames",
+                    "reduce_frames": (
+                        {
+                            "index": -1,  # -1 will be interpreated as at the end of the acquisition
+                            "data": numpy.random.random(20 * 20).reshape(20, 20),
+                            "selected": True,
+                        },
+                        {
+                            "index": 0,
+                            "data": numpy.random.random(20 * 20).reshape(20, 20),
+                            "selected": True,
+                        },
+                    ),
+                },
+                {
+                    "reduce_frames_name": "tata frames",
+                    "reduce_frames": (
+                        {
+                            "index": "0.25r",
+                            "data": numpy.random.random(40 * 20).reshape(40, 20),
+                            "selected": False,
+                        },
+                    ),
+                },
+            )
+        ),
+        (
+            {
+                "reduce_frames_name": "toto frames",
+                "reduce_frames": (
+                    {
+                        "index": -1,  # -1 will be interpreated as at the end of the acquisition
+                        "data": numpy.random.random(20 * 20).reshape(20, 20),
+                        "selected": True,
+                    },
+                    {
+                        "index": 0,
+                        "data": numpy.random.random(20 * 20).reshape(20, 20),
+                        "selected": True,
+                    },
+                ),
+            },
+        ),
+    )
+
+    check_reduce_frames_configuration(
+        filter_unselected_reduced_frames(
+            (
+                {
+                    "reduce_frames_name": "toto frames",
+                    "reduce_frames": (
+                        {
+                            "index": -1,  # -1 will be interpreated as at the end of the acquisition
+                            "data": numpy.random.random(20 * 20).reshape(20, 20),
+                            "selected": True,
+                        },
+                        {
+                            "index": 0,
+                            "data": numpy.random.random(20 * 20).reshape(20, 20),
+                            "selected": False,
+                        },
+                    ),
+                },
+                {
+                    "reduce_frames_name": "tata frames",
+                    "reduce_frames": (
+                        {
+                            "index": "0.25r",
+                            "data": numpy.random.random(40 * 20).reshape(40, 20),
+                            "selected": False,
+                        },
+                    ),
+                },
+            )
+        ),
+        (
+            {
+                "reduce_frames_name": "toto frames",
+                "reduce_frames": (
+                    {
+                        "index": 0,
+                        "data": numpy.random.random(20 * 20).reshape(20, 20),
+                        "selected": False,
+                    },
+                ),
+            },
+            {
+                "reduce_frames_name": "tata frames",
+                "reduce_frames": (
+                    {
+                        "index": "0.25r",
+                        "data": numpy.random.random(40 * 20).reshape(40, 20),
+                        "selected": False,
+                    },
+                ),
+            },
+        ),
+    )
+
+    check_reduce_frames_configuration(filter_unselected_reduced_frames(()), ())
+
+
+def check_reduce_frames_configuration(config_1, config_2):
+    """
+    simple comparaison of two configurations
+    """
+    assert len(config_1) == len(config_2)
+    for reduce_frame_group_1, reduce_frame_group_2 in zip(config_1, config_2):
+        assert reduce_frame_group_1.get(
+            "reduce_frames_name", None
+        ) == reduce_frame_group_2.get("reduce_frames_name", None)
+
+        for reduce_frame_group_1, reduce_frame_group_2 in zip(
+            reduce_frame_group_1.get("reduce_frames", tuple()),
+            reduce_frame_group_2.get("reduce_frames", tuple()),
+        ):
+            assert reduce_frame_group_1["index"] == reduce_frame_group_2["index"]
+            assert reduce_frame_group_1["selected"] == reduce_frame_group_2["selected"]

tomwer/gui/reconstruction/axis/CompareImages.py

@@ -202,7 +202,7 @@ class CompareImages(_CompareImages.CompareImages):
     """Emit when cropping of the compared images has changed"""
 
     def __init__(self, parent=None, backend=None):
-        super().__init__(parent, backend)
+        super().__init__(parent, backend=backend)
         self.__cropComparedImages = True
 
     def cropComparedImages(self) -> bool:

tomwer/gui/reconstruction/axis/axis.py

@@ -101,8 +101,8 @@ class AxisWindow(qt.QMainWindow):
     sigLockModeChanged = qt.Signal()
     """Signal emitted when the lock on the method change"""
 
-    def __init__(self, axis_params, parent=None):
-        qt.QMainWindow.__init__(self, parent=parent)
+    def __init__(self, axis_params, parent=None, backend=None):
+        super().__init__(parent=parent)
         self._mainWidget = qt.QWidget(self)
         self._mainWidget.setLayout(qt.QVBoxLayout())
         self.setCentralWidget(self._mainWidget)
@@ -119,7 +119,9 @@ class AxisWindow(qt.QMainWindow):
         self._selectionGB.hide()
 
         # add widget for radio and sinogram axis
-        self._axisWidget = _AxisWidget(parent=self, axis_params=axis_params)
+        self._axisWidget = _AxisWidget(
+            parent=self, axis_params=axis_params, backend=backend
+        )
         self._mainWidget.layout().addWidget(self._axisWidget)
 
         self.setCentralWidget(self._mainWidget)
@@ -226,8 +228,8 @@ class _AxisWidget(qt.QMainWindow):
 
     sigSinogramReady = qt.Signal()
 
-    def __init__(self, parent, axis_params):
-        qt.QMainWindow.__init__(self, parent)
+    def __init__(self, parent, axis_params, backend=None):
+        super().__init__(parent)
         self._settingsWidget = None
         self.setDockOptions(qt.QMainWindow.AnimatedDocks)
 
@@ -253,7 +255,9 @@ class _AxisWidget(qt.QMainWindow):
         self.addDockWidget(qt.Qt.RightDockWidgetArea, self._controlDockWidget)
 
         self._axis_params = axis_params
-        self._radioAxis = RadioAxisWindow(parent=self, axis=axis_params)
+        self._radioAxis = RadioAxisWindow(
+            parent=self, axis=axis_params, backend=backend
+        )
         self._plotWidgets = qt.QWidget(self)
         self._plotWidgets.setLayout(qt.QVBoxLayout())
         self.setCentralWidget(self._plotWidgets)

tomwer/gui/reconstruction/axis/radioaxis.py

@@ -80,8 +80,8 @@ class RadioAxisWindow(qt.QMainWindow):
     sigPositionChanged = qt.Signal(tuple)
     """signal emitted when the center of rotation center change"""
 
-    def __init__(self, axis, parent=None):
-        qt.QMainWindow.__init__(self, parent)
+    def __init__(self, axis, parent=None, backend=None):
+        super().__init__(parent)
         if isinstance(axis, QAxisRP):
             self.__recons_params = axis
         else:
@@ -106,7 +106,7 @@ class RadioAxisWindow(qt.QMainWindow):
         # cache to know if the y origin has changed since
 
         self.setWindowFlags(qt.Qt.Widget)
-        self._plot = CompareImages(parent=self)
+        self._plot = CompareImages(parent=self, backend=backend)
         self._plot.setAutoResetZoom(False)
         _mode = CompareImages.VisualizationMode.COMPOSITE_A_MINUS_B
         self._plot.setVisualizationMode(_mode)
@@ -2565,10 +2565,18 @@ class _ManualFramesSelection(qt.QWidget):
         idx = self._frame1CB.findText(current_angle1)
         if idx >= 0:
             self._frame1CB.setCurrentIndex(idx)
+        if current_angle1 == current_angle2:
+            # if the two current angle are close then we consider it is better to look for angleX - angleX + 180 angles
+            # instead of finding back angles
+            self._findAssociatedAngle()
+        else:
+            idx = self._frame1CB.findText(current_angle1)
+            if idx >= 0:
+                self._frame1CB.setCurrentIndex(idx)
 
-        idx = self._frame2CB.findText(current_angle2)
-        if idx >= 0:
-            self._frame2CB.setCurrentIndex(idx)
+            idx = self._frame2CB.findText(current_angle2)
+            if idx >= 0:
+                self._frame2CB.setCurrentIndex(idx)
 
     def getFramesUrl(self, as_txt=False) -> tuple:
         """

tomwer/gui/reconstruction/darkref/darkrefcopywidget.py

@@ -253,6 +253,7 @@ class RefCopyWidget(qt.QGroupBox):
                 _logger.error(f"Fails to define flat url. Error is {e}")
                 return False
             else:
+                self._statusBar.showMessage(f"darks set from {url.path()}")
                 DarkRefsCopy.save_flats_to_be_copied(self.__save_dir, data=url)
                 return True
         return False
@@ -268,6 +269,7 @@ class RefCopyWidget(qt.QGroupBox):
                 _logger.error(f"Fails to define flat url. Error is {e}")
                 return False
             else:
+                self._statusBar.showMessage(f"darks set from {url.path()}")
                 DarkRefsCopy.save_darks_to_be_copied(self.__save_dir, data=url)
                 return True
         return False

tomwer/gui/reconstruction/darkref/darkrefwidget.py

@@ -33,7 +33,7 @@ import logging
 from silx.gui import qt
 
 from tomwer.core.process.reconstruction.darkref import params as dkrf
-from tomwer.core.process.reconstruction.darkref.darkrefs import DarkRefs
+from tomwer.core.process.reconstruction.darkref.darkrefs import DarkRefsTask
 from tomwer.core.scan.scanbase import TomwerScanBase
 from tomwer.gui.utils.sandboxes import RegularExpressionSandBox
 from tomwer.synctools.darkref import QDKRFRP
@@ -89,7 +89,7 @@ class DarkRefWidget(qt.QWidget):
         return self.mainWidget.recons_params
 
 
-class QDarkRefs(DarkRefs):
+class QDarkRefs(DarkRefsTask):
     def _computationStarts(self):
         pass
 
@@ -232,14 +232,14 @@ class _TabExpert(qt.QWidget):
             qt.QLabel("pyhst dark file pattern", parent=self._patternsWidget), 0, 0
         )
         self._darkLE = qt.QLineEdit(parent=self._patternsWidget)
-        self._darkLE.setToolTip(DarkRefs.getDarkPatternTooltip())
+        self._darkLE.setToolTip(DarkRefsTask.getDarkPatternTooltip())
         self._darkLE.editingFinished.connect(self._darkPatternEdited)
         self._patternsWidget.layout().addWidget(self._darkLE, 0, 1)
         self._patternsWidget.layout().addWidget(
             qt.QLabel("pyhst flat file pattern", parent=self._patternsWidget), 1, 0
         )
         self._refLE = qt.QLineEdit(parent=self._patternsWidget)
-        self._refLE.setToolTip(DarkRefs.getRefPatternTooltip())
+        self._refLE.setToolTip(DarkRefsTask.getRefPatternTooltip())
         self._refLE.editingFinished.connect(self._refPatternEdited)
 
         self._patternsWidget.layout().addWidget(self._refLE, 1, 1)

tomwer/gui/reconstruction/nabu/nabuconfig/phase.py

@@ -181,7 +181,9 @@ class NabuPaganinConfig(qt.QWidget, base._NabuStageConfigBase):
         label = DELTA_CHAR + " / " + BETA_CHAR
         self._db_label = qt.QLabel(label, self)
         self.layout().addWidget(self._db_label, 0, 0, 1, 1)
-        self._deltaBetaQLE = SelectionLineEdit("100.0", self)
+        self._deltaBetaQLE = SelectionLineEdit(
+            "100.0", self, allow_negative_indices=False
+        )
         self.layout().addWidget(self._deltaBetaQLE, 0, 1, 1, 3)
         self.registerWidget(self._db_label, "required")
         self.registerWidget(self._deltaBetaQLE, "required")

tomwer/gui/reconstruction/nabu/nabuconfig/preprocessing.py

@@ -372,42 +372,43 @@ class _NabuPreProcessingConfig(_NabuStageConfigBase, qt.QWidget):
         except Exception as e:
             _logger.error(e)
 
-    def _setConfiguration(self, conf):
-        if "flatfield" in conf:
-            ff = conf["flatfield"]
-            if ff is not None:
-                self._flatFieldCB.setChecked(bool(ff))
-        if "double_flatfield_enabled" in conf:
-            dff = conf["double_flatfield_enabled"]
-            if dff is not None:
-                self._dffCB.setChecked(bool(dff))
-        if "dff_sigma" in conf:
-            dff_sigma = conf["dff_sigma"]
-            if dff_sigma not in (None, "", "none"):
-                self._dffSigmaQDSB.setValue(float(dff_sigma))
-        if "ccd_filter_enabled" in conf:
-            ccd_filter = conf["ccd_filter_enabled"]
-            if ccd_filter not in (None, "", "none"):
-                self._ccdFilterCB.setChecked(bool(ccd_filter))
-        if "ccd_filter_threshold" in conf:
-            ccd_filter_threshold = conf["ccd_filter_threshold"]
-            if ccd_filter_threshold not in (None, "", "none"):
-                self._ccdThreshold.setValue(float(ccd_filter_threshold))
+    def _setConfiguration(self, conf: dict):
+        ff = conf.get("flatfield", None)
+        if ff is not None:
+            self._flatFieldCB.setChecked(bool(ff))
+
+        dff = conf.get("double_flatfield_enabled", None)
+        if dff is not None:
+            self._dffCB.setChecked(bool(dff))
+
+        dff_sigma = conf.get("dff_sigma", None)
+        if dff_sigma not in (None, "", "none"):
+            self._dffSigmaQDSB.setValue(float(dff_sigma))
+
+        ccd_filter = conf.get("ccd_filter_enabled", None)
+        if ccd_filter not in (None, "", "none"):
+            self._ccdFilterCB.setChecked(bool(ccd_filter))
+
+        ccd_filter_threshold = conf.get("ccd_filter_threshold", None)
+        if ccd_filter_threshold not in (None, "", "none"):
+            self._ccdThreshold.setValue(float(ccd_filter_threshold))
+
         normalize_srcurrent = conf.get("normalize_srcurrent", None)
         if normalize_srcurrent is not None:
             self.setNormalizeCurrent(bool(normalize_srcurrent))
-        if "take_logarithm" in conf:
-            take_logarithm = conf["take_logarithm"]
-            if take_logarithm not in (None, "", "none"):
-                self._takeLogarithmCB.setChecked(bool(take_logarithm))
-        if "log_min_clip" in conf:
-            clip_value = conf["log_min_clip"]
-            if clip_value not in (None, "", "none"):
-                self._clipMinLogValue.setValue(float(clip_value))
-        if "log_max_clip" in conf:
-            clip_value = conf["log_max_clip"]
-            if clip_value not in (None, "", "none"):
-                self._clipMaxLogValue.setValue(float(clip_value))
+
+        take_logarithm = conf.get("take_logarithm", None)
+        if take_logarithm not in (None, "", "none"):
+            self._takeLogarithmCB.setChecked(bool(take_logarithm))
+
+        clip_value = conf.get("log_min_clip", None)
+        if clip_value not in (None, "", "none"):
+            self._clipMinLogValue.setValue(float(clip_value))
+
+        clip_value = conf.get("log_max_clip", None)
+        if clip_value not in (None, "", "none"):
+            self._clipMaxLogValue.setValue(float(clip_value))
+
         sino_rings_correction = conf.get("sino_rings_correction", None)
         if sino_rings_correction is not None:
             if sino_rings_correction == "":

tomwer/gui/reconstruction/nabu/nabuconfig/reconstruction.py

@@ -71,7 +71,7 @@ class SliceGroupBox(qt.QGroupBox):
         self.layout().addWidget(self._modeCB)
         self._modeCB.setFocusPolicy(qt.Qt.FocusPolicy.NoFocus)
 
-        self._sliceQLE = SelectionLineEdit(parent=self)
+        self._sliceQLE = SelectionLineEdit(parent=self, allow_negative_indices=True)
         self.layout().addWidget(self._sliceQLE)
 
         spacer = qt.QWidget(parent=self)

tomwer/gui/reconstruction/normalization/intensity.py

@@ -58,13 +58,13 @@ class SinoNormWindow(qt.QMainWindow):
     sigConfigurationChanged = qt.Signal()
     """signal emit when the configuration change"""
 
-    def __init__(self, parent):
+    def __init__(self, parent, backend=None):
         qt.QMainWindow.__init__(self, parent)
         self._scan = None
         self.setWindowFlags(qt.Qt.Widget)
 
         # central widget
-        self._centralWidget = _Viewer(self)
+        self._centralWidget = _Viewer(self, backend=backend)
         self.setCentralWidget(self._centralWidget)
 
         # control widget (options + ctrl buttons)
@@ -198,13 +198,13 @@ class SinoNormWindow(qt.QMainWindow):
 
 
 class _Viewer(qt.QTabWidget):
-    def __init__(self, parent):
+    def __init__(self, parent, backend=None):
         if not isinstance(parent, SinoNormWindow):
             raise TypeError("Expect a NormIntensityWindow as parrent")
         qt.QTabWidget.__init__(self, parent)
-        self._projView = _ProjPlotWithROI(parent=self)
+        self._projView = _ProjPlotWithROI(parent=self, backend=backend)
         self.addTab(self._projView, "projection view")
-        self._sinoView = SinogramViewer(parent=self)
+        self._sinoView = SinogramViewer(parent=self, backend=backend)
         self.addTab(self._sinoView, "sinogram view")
 
         # connect signal / Slot

tomwer/gui/reconstruction/saaxis/corrangeselector.py

@@ -550,6 +550,7 @@ class _EstimatedCorWidget(qt.QGroupBox):
         self._relLabel.setVisible(manual_opt_visible)
         self._manualCORRel.setVisible(manual_opt_visible)
         self._manualCORAbs.setVisible(manual_opt_visible)
+        self._autoCorPB.setVisible(manual_opt_visible)
 
     def _relativePositionChanged(self, *args, **kwargs):
         if self._frameWidth is not None:

tomwer/gui/reconstruction/saaxis/saaxis.py

@@ -43,7 +43,7 @@ from silx.gui import qt
 from tomwer.core.process.reconstruction.axis import mode as axis_mode
 from tomwer.core.process.reconstruction.nabu.utils import _NabuMode
 from tomwer.core.process.reconstruction.saaxis.params import SAAxisParams
-from tomwer.core.process.reconstruction.saaxis.saaxis import SAAxisProcess
+from tomwer.core.process.reconstruction.saaxis.saaxis import SAAxisTask
 from tomwer.gui import icons
 from tomwer.gui.reconstruction.axis.radioaxis import _CalculationWidget
 from tomwer.gui.reconstruction.nabu.slices import NabuWindow
@@ -71,7 +71,7 @@ class ScorePlot(_ScorePlot, constructor=CorSelection):
                 scan.saaxis_params.score_method = self.getScoreMethod()
                 img_width = scan.dim_1
                 # update autofocus
-                SAAxisProcess.autofocus(scan)
+                SAAxisTask.autofocus(scan)
         else:
             img_width = None
         self.setVarScores(
@@ -145,7 +145,7 @@ class _SAAxisTabWidget(qt.QTabWidget):
     like slice to reconstruct, number of reconstruction, research width,
     nabu reconstruction parameters..."""
 
-    def __init__(self, parent):
+    def __init__(self, parent, backend=None):
         qt.QTabWidget.__init__(self, parent)
         # select slice & cor range
 
@@ -159,7 +159,7 @@ class _SAAxisTabWidget(qt.QTabWidget):
         nabu_icon = icons.getQIcon("nabu")
         self.addTab(self._nabuSettings, nabu_icon, "reconstruction settings")
         # results
-        self._resultsViewer = ScorePlot(self, variable_name="cor")
+        self._resultsViewer = ScorePlot(self, variable_name="cor", backend=backend)
         results_icon = icons.getQIcon("results")
         self.addTab(self._resultsViewer, results_icon, "reconstructed slices")
 
@@ -312,7 +312,7 @@ class SAAxisWindow(qt.QMainWindow):
     Widget used to determine half-automatically the center of rotation
     """
 
-    def __init__(self, parent=None):
+    def __init__(self, parent=None, backend=None):
         qt.QMainWindow.__init__(self, parent)
         self._scan = None
         self._automaticCorWidget = None
@@ -324,7 +324,7 @@ class SAAxisWindow(qt.QMainWindow):
 
         self._scanInfo = ScanNameLabelAndShape(self)
         self._mainWidget.layout().addWidget(self._scanInfo)
-        self._tabWidget = _SAAxisTabWidget(self)
+        self._tabWidget = _SAAxisTabWidget(self, backend=backend)
         self._mainWidget.layout().addWidget(self._tabWidget)
         self.setCentralWidget(self._mainWidget)
         # next and previous buttons for browsing the tab widget