tomwer 1.0.4__py3-none-any.whl → 1.1.0__py3-none-any.whl

tomwer/gui/reconstruction/scores/scoreplot.py

@@ -35,20 +35,25 @@ __license__ = "MIT"
 __date__ = "25/02/2021"
 
 
+import os
+import weakref
+import numpy
+import logging
+from typing import Union
+from contextlib import AbstractContextManager
+from matplotlib import image as _matplotlib_image
 from silx.gui import qt
 from silx.gui.plot import PlotWidget
+from tomwer.io.utils.utils import get_slice_data
 from tomwer.gui.reconstruction.saaxis.dimensionwidget import DimensionWidget
 from tomwer.gui.visualization.dataviewer import ImageStack
 from tomwer.gui.utils.vignettes import VignettesQDialog
-from contextlib import AbstractContextManager
 from tomwer.gui.utils.buttons import PadlockButton
 from tomwer.gui import icons
+from tomwer.gui import settings
 from tomwer.io.utils.h5pyutils import DatasetReader
 from tomwer.core.process.reconstruction.scores.params import ScoreMethod
-from typing import Union
-import weakref
-import numpy
-import logging
+from tomwer.io.utils import get_default_directory
 
 _logger = logging.getLogger(__name__)
 
@@ -310,7 +315,7 @@ class CorSelection(VariableSelection):
             self._absoluteVarValueLE,
         )
         try:
-            import pyopencl  # noqa F401
+            import pyopencl  # noqa F401 pylint: disable=E0401
         except Exception:
             idx = self._scoreMethodCB.findText(ScoreMethod.TOMO_CONSISTENCY.value)
             if idx >= 0:
@@ -495,10 +500,20 @@ class ScorePlot(qt.QWidget):
         self.setLayout(qt.QGridLayout())
         # main plot
         self._plot = ImageStack(self, show_overview=False)
+        self._plot.getPlotWidget().setYAxisInverted(settings.Y_AXIS_DOWNWARD)
+
         self._plot.getPlotWidget().setKeepDataAspectRatio(True)
         self._plot._sliderDockWidget.hide()
         self._plot.getPlotWidget().getColorBarWidget().hide()
         self._plot.getPlotWidget().getPositionInfoWidget().hide()
+        # add save all action
+        save_all_icon = icons.getQIcon("multi-document-save")
+        self._saveAllSnapshot = qt.QAction(
+            save_all_icon, "save all screenshot as png", self
+        )
+        toolbar = self._plot.getPlotWidget().toolBar()
+        toolbar.addSeparator()
+        toolbar.addAction(self._saveAllSnapshot)
         # hide dock widget
         self._plot._reconsInfoDockWidget.hide()
         self._plot._tableDockWidget.hide()
@@ -563,6 +578,7 @@ class ScorePlot(qt.QWidget):
             self._varSelectedFromVignettes
         )
         self._varValueWidget.sigScoreMethodChanged.connect(self._updateScores)
+        self._saveAllSnapshot.triggered.connect(self._saveAllReconstructedSlices)
 
         # set up
         # for now we don't want to use the volume and voxel size
@@ -570,8 +586,8 @@ class ScorePlot(qt.QWidget):
         self._voxelSizeW.hide()
         self._axisLabel.hide()
 
-    def __init_subclass__(cls, constructor, **kwargs):
-        super().__init_subclass__(**kwargs)
+    def __init_subclass__(cls, constructor, **kwargs):  # pylint: disable=E0302
+        super().__init_subclass__()
         cls._CorSlectionBuilder = constructor
 
     def getScoreMethod(self):
@@ -711,7 +727,8 @@ class ScorePlot(qt.QWidget):
             self._plot.setUrls(urls=self._urls)
             self._varSlider.setVarValues(self._var_values)
             old = self._varSlider.blockSignals(True)
-            self._varSlider.setVarValue(self._var_values[0])
+            if len(self._var_values) > 0:
+                self._varSlider.setVarValue(self._var_values[0])
             self._varSlider.blockSignals(old)
 
         old = self._varValueWidget.blockSignals(True)
@@ -790,6 +807,47 @@ class ScorePlot(qt.QWidget):
             )
         )
 
+    def _saveAllReconstructedSlices(self):  # pragma: no cover
+        """
+        save all reconstructed slices to a folder provided by the user
+        """
+        dialog = qt.QFileDialog(self, directory=get_default_directory())
+        dialog.setFileMode(qt.QFileDialog.DirectoryOnly)
+        if not dialog.exec_():
+            dialog.close()
+            return
+
+        output_folder = dialog.selectedFiles()[0]
+        try:
+            self.saveReconstructedSlicesTo(output_folder=output_folder)
+        except Exception as e:
+            _logger.error(f"Fail to save snapshots. Error is {e}")
+        else:
+            _logger.info(f"snapshots have been saved to {output_folder}")
+
+    def saveReconstructedSlicesTo(self, output_folder):
+        """dump all slices with score as name"""
+        # make sure the output dir exists
+        os.makedirs(output_folder, exist_ok=True)
+
+        i_missing_score = 0
+        for score, slice_url in zip(self._var_values, self._urls):
+            try:
+                data = get_slice_data(slice_url)
+                if score is None:
+                    file_name = f"no_score_{i_missing_score}.png"
+                    i_missing_score += 1
+                else:
+                    file_name = f"{score}.png"
+                _matplotlib_image.imsave(
+                    os.path.join(output_folder, file_name),
+                    data,
+                    format="png",
+                )
+
+            except Exception as e:
+                _logger.error(f"Failed to dump {slice_url.path()}. Raison is {e}")
+
 
 class _VarSlider(qt.QWidget):
     def __init__(self, parent, orientation):
@@ -823,55 +881,3 @@ class _VarSlider(qt.QWidget):
 
     def value(self):
         return self._slider.value()
-
-
-if __name__ == "__main__":
-    from silx.image.phantomgenerator import PhantomGenerator
-    from silx.io.url import DataUrl
-    import tempfile
-    import os
-    import h5py
-    import shutil
-    from scipy import stats
-
-    app = qt.QApplication([])
-    img_width = 216
-    data = PhantomGenerator.get2DPhantomSheppLogan(n=img_width)
-    nb_cor = 50
-    urls = []
-    slices_folder = tempfile.mkdtemp()
-    for i in range(nb_cor):
-        noise = (
-            numpy.random.random(img_width * img_width).reshape(img_width, img_width)
-            * 100.0
-        )
-        file_path = os.path.join(slices_folder, "slice_{}.hdf5".format(i))
-        with h5py.File(file_path, mode="a") as h5f:
-            h5f["data"] = noise + data
-        urls.append(DataUrl(file_path=file_path, data_path="data", scheme="silx"))
-    variance = 1
-    mu = 0.5
-    sigma = numpy.sqrt(variance)
-    x = numpy.linspace(mu - 3 * sigma, mu + 3 * sigma, nb_cor)
-    scores = stats.norm.pdf(x, mu, sigma)
-
-    cor_values = numpy.linspace(80, 120, nb_cor)
-    scores_dict = {}
-    for cor, url, score in zip(cor_values, urls, scores):
-        scores_dict[cor] = (url, score)
-
-    window1 = ScorePlot(variable_name="var x")
-    window1.setVarScores(scores=scores_dict, score_method="std")
-    window1.show()
-    from tomwer.core.scan.scanbase import TomwerScanBase
-    from tomwer.core.process.reconstruction.saaxis.params import SAAxisParams
-    from tomwer.core.process.reconstruction.saaxis.saaxis import SAAxisProcess
-
-    scan = TomwerScanBase()
-    scan.saaxis_params = SAAxisParams()
-    scan.saaxis_params.scores = scores_dict
-    SAAxisProcess.autofocus(scan)
-    window1.setScan(scan)
-    app.exec_()
-
-    shutil.rmtree(slices_folder)

tomwer/gui/reconstruction/test/test_axis.py

@@ -29,8 +29,8 @@ __date__ = "16/06/2021"
 
 from tomwer.gui.reconstruction.axis import AxisWindow
 from tomwer.gui.reconstruction.axis.radioaxis import _ManualFramesSelection
-from tomwer.test.utils import skip_gui_test
-from tomwer.test.utils import UtilsTest
+from tomwer.tests.utils import skip_gui_test
+from tomwer.tests.utils import UtilsTest
 from tomwer.core.process.reconstruction.axis.mode import AxisMode
 from tomwer.core.scan.edfscan import EDFTomoScan
 from tomwer.synctools.axis import QAxisRP

tomwer/gui/reconstruction/test/test_lamino.py

@@ -35,8 +35,8 @@ import pytest
 from silx.gui import qt
 from tomwer.core import settings
 from tomwer.gui.reconstruction.lamino.tofu import TofuWindow
-from tomwer.test.utils import UtilsTest
-from tomwer.test.utils import skip_gui_test
+from tomwer.tests.utils import UtilsTest
+from tomwer.tests.utils import skip_gui_test
 
 
 @pytest.mark.skipif(skip_gui_test(), reason="skip gui test")

tomwer/gui/reconstruction/test/test_nabu.py

@@ -29,7 +29,7 @@ __date__ = "05/02/2020"
 
 import os
 from silx.gui import qt
-from tomwer.test.utils import skip_gui_test
+from tomwer.tests.utils import skip_gui_test
 from tomwer.gui.reconstruction.nabu.nabuflow import NabuFlowControl
 from tomwer.gui.reconstruction.nabu.nabuconfig.preprocessing import (
     _NabuPreProcessingConfig,
@@ -116,6 +116,7 @@ class TestNabuPreProcConfig(TestCaseQt):
             "log_min_clip": 1e-6,
             "log_max_clip": 10.0,
             "take_logarithm": True,
+            "normalize_srcurrent": 0,
             "sino_rings_correction": _RingCorrectionMethod.NONE.value,
             "sino_rings_options": "sigma=1.0 ; levels=10",
             "tilt_correction": "",
@@ -134,6 +135,7 @@ class TestNabuPreProcConfig(TestCaseQt):
             "log_min_clip": 1e-3,
             "log_max_clip": 250.0,
             "take_logarithm": False,
+            "normalize_srcurrent": 1,
             "sino_rings_correction": _RingCorrectionMethod.MUNCH.value,
             "sino_rings_options": "sigma=1.4 ; levels=11",
             "tilt_correction": "1d-correlation",
@@ -162,6 +164,10 @@ class TestNabuPhaseConfig(TestCaseQt):
             "padding_type": "edge",
             "unsharp_coeff": 0,
             "unsharp_sigma": 0,
+            "beam_shape": "parallel",
+            "ctf_advanced_params": " length_scale=1e-05; lim1=1e-05; lim2=0.2; normalize_by_mean=True",
+            "ctf_geometry": " z1_v=None; z1_h=None; detec_pixel_size=None; magnification=True",
+            "ctf_translations_file": "",
         }
         self.assertEqual(self.nabuWidget.getConfiguration(), ini_conf)
 
@@ -173,6 +179,10 @@ class TestNabuPhaseConfig(TestCaseQt):
             "padding_type": "zeros",
             "unsharp_coeff": 3.6,
             "unsharp_sigma": 2.1,
+            "beam_shape": "cone",
+            "ctf_advanced_params": " length_scale=1e-05; lim1=1e-05; lim2=0.2; normalize_by_mean=True",
+            "ctf_geometry": " z1_v=0.0; z1_h=0.0; detec_pixel_size=None; magnification=True",
+            "ctf_translations_file": "",
         }
         self.nabuWidget.setConfiguration(conf)
         self.nabuWidget.show()
@@ -225,6 +235,7 @@ class TestNabuReconstructionConfig(TestCaseQt):
             "positivity_constraint": 1,
             "translation_movements_file": "",
             "clip_outer_circle": 0,
+            "centered_axis": 0,
         }
         self.assertEqual(self.nabuWidget.getConfiguration(), ini_conf)
 
@@ -251,6 +262,7 @@ class TestNabuReconstructionConfig(TestCaseQt):
             "positivity_constraint": 0,
             "translation_movements_file": "my_file.csv",
             "clip_outer_circle": 1,
+            "centered_axis": 1,
         }
         self.nabuWidget.setConfiguration(ini_conf)
         self.qapp.processEvents()
@@ -268,6 +280,7 @@ class TestNabuReconstructionConfig(TestCaseQt):
         self.assertFalse(subRegionWidget._zSubRegion._maxQLE.isEnabled())
         self.assertFalse(self.nabuWidget._preconditioningFilter.isChecked())
         self.assertTrue(self.nabuWidget._clipOuterCircleCB.isChecked())
+        self.assertTrue(self.nabuWidget._centeredAxisCB.isChecked())
 
         # check the generated configuration
         self.assertEqual(self.nabuWidget.getConfiguration(), ini_conf)

tomwer/gui/reconstruction/test/test_saaxis.py

@@ -27,7 +27,7 @@ __license__ = "MIT"
 __date__ = "03/02/2021"
 
 
-from tomwer.test.utils import skip_gui_test
+from tomwer.tests.utils import skip_gui_test
 from tomwer.gui.reconstruction.saaxis.dimensionwidget import DimensionWidget
 from tomoscan.unitsystem import metricsystem
 from silx.gui.utils.testutils import TestCaseQt
@@ -41,7 +41,6 @@ from tomwer.core.process.reconstruction.scores import ComputedScore
 from tomwer.core.process.reconstruction.scores.params import ScoreMethod
 from silx.io.url import DataUrl
 from silx.gui import qt
-import unittest
 import pytest
 import numpy
 import shutil
@@ -203,19 +202,11 @@ class TestSAAxisWindow(TestCaseQt):
             self.assertEqual(configuration[key], res_conf[key])
 
     def testSetResults(self):
-        """Test setting results"""
+        """Test setting results and saving result to a folder"""
         self._window.setCorScores(self._cor_scores, score_method="standard deviation")
-
-
-def suite():
-    test_suite = unittest.TestSuite()
-    for ui in (
-        TestDimensionWidget,
-        TestSAAxisWindow,
-    ):
-        test_suite.addTest(unittest.defaultTestLoader.loadTestsFromTestCase(ui))
-    return test_suite
-
-
-if __name__ == "__main__":
-    unittest.main(defaultTest="suite")
+        # test saving snapshots
+        with tempfile.TemporaryDirectory() as output_png_imgs:
+            final_dir = os.path.join(output_png_imgs, "test/create/it")
+            self._window.saveReconstructedSlicesTo(final_dir)
+            assert os.path.exists(final_dir)
+            assert len(os.listdir(final_dir)) == len(self._cor_scores)

tomwer/gui/reconstruction/test/test_sadeltabeta.py

@@ -27,7 +27,7 @@ __license__ = "MIT"
 __date__ = "09/06/2021"
 
 
-from tomwer.test.utils import skip_gui_test
+from tomwer.tests.utils import skip_gui_test
 from silx.gui.utils.testutils import TestCaseQt
 from tomwer.core.utils.scanutils import MockHDF5
 from tomwer.gui.reconstruction.sadeltabeta import SADeltaBetaWindow
@@ -36,7 +36,6 @@ from tomwer.core.process.reconstruction.scores.params import ScoreMethod
 from tomwer.core.process.reconstruction.scores import ComputedScore
 from silx.io.url import DataUrl
 from silx.gui import qt
-import unittest
 import pytest
 import numpy
 import shutil
@@ -132,14 +131,9 @@ class TestSADeltaBetaWindow(TestCaseQt):
     def testSetResults(self):
         """Test setting results"""
         self._window.setDBScores(self._cor_scores, score_method="total variation")
-
-
-def suite():
-    test_suite = unittest.TestSuite()
-    for ui in (TestSADeltaBetaWindow,):
-        test_suite.addTest(unittest.defaultTestLoader.loadTestsFromTestCase(ui))
-    return test_suite
-
-
-if __name__ == "__main__":
-    unittest.main(defaultTest="suite")
+        # test saving snapshots
+        with tempfile.TemporaryDirectory() as output_png_imgs:
+            final_dir = os.path.join(output_png_imgs, "test/create/it")
+            self._window.saveReconstructedSlicesTo(final_dir)
+            assert os.path.exists(final_dir)
+            assert len(os.listdir(final_dir)) == len(self._cor_scores)

tomwer/gui/stackplot.py

@@ -44,7 +44,8 @@ import logging
 from tomwer.gui import icons
 import functools
 import time
-from collections import namedtuple, Iterable
+from collections import namedtuple
+from typing import Iterable, Optional
 
 logger = logging.getLogger(__name__)
 
@@ -204,7 +205,7 @@ class _QImageStackPlot(qt.QWidget):
         self._qspinbox.blockSignals(False)
 
     def createStackImageInstance(self):
-        return _StackImage()
+        return _StackImage(images=None)
 
     def showImage(self, index):
         """
@@ -232,25 +233,6 @@ class _QImageStackPlot(qt.QWidget):
         self._qspinbox.blockSignals(False)
         self._qslider.blockSignals(False)
 
-    def setImage(self, index, data):
-        """
-        Set the given data as the image for the given index
-
-        :param int index: the index of the image to set
-        :param numpy.ndarray data: the image
-        """
-        _data = data
-        if data is None:
-            _data = self.IMG_NOT_FOUND
-        self.images[index] = _data
-
-    def isEmpty(self):
-        """
-
-        :return bool: True if no reconstruction has been set yet
-        """
-        return self.images.empty()
-
     def clear(self):
         self.setImages(None)
 
@@ -388,10 +370,6 @@ class _QImageFileStackPlot(_QImageStackPlot):
             self._qslider.valueChanged.connect(self.changeActiveImageFrmQSlider)
             self._qspinbox.valueChanged.connect(self.changeActiveImageFrmQSpinBox)
 
-    def setLoadingImage(self, sliceNb):
-        """Set the status of the image to not loaded"""
-        self.setImage(sliceNb, _QImageFileStackPlot.IMG_LOADING)
-
     def setImages(self, imagesFiles):
         """
         Set the stack of images files
@@ -497,7 +475,7 @@ class _QImageFileStackPlot(_QImageStackPlot):
 
 
 class _StackImage(object):
-    def __init__(self, images):
+    def __init__(self, images: Optional[Iterable]):
         _images = images
         if _images is None:
             _images = {}
@@ -516,6 +494,11 @@ class _StackImage(object):
         else:
             return self._images[index]
 
+    def setImages(self, images: Iterable):
+        self.clear()
+        for image in images:
+            self.addImage(image)
+
     def size(self):
         return len(self._images)
 
@@ -543,9 +526,9 @@ class _StackImageToLoad(_StackImage, qt.QObject):
     """Signal emitted when the loading mode is changed. Parameter are new mode,
     old mode"""
 
-    def __init__(self, loadingMode=LAZY_LOADING):
+    def __init__(self, loadingMode=LAZY_LOADING, images: Optional[Iterable] = None):
         assert loadingMode in (LAZY_LOADING, ASAP_LOADING, ON_SHOW_LOADING)
-        _StackImage.__init__(self, images=None)
+        _StackImage.__init__(self, images=images)
         qt.QObject.__init__(self)
         self._mode = loadingMode
         self._url_to_index = {}

tomwer/gui/test/test_axis_gui.py

@@ -1,7 +1,7 @@
 from tomwer.gui.reconstruction.axis.radioaxis import AxisTabWidget
 from tomwer.synctools.axis import QAxisRP
 from silx.gui.utils.testutils import TestCaseQt
-from tomwer.test.utils import skip_gui_test
+from tomwer.tests.utils import skip_gui_test
 import pytest
 
 
@@ -13,14 +13,14 @@ class TestGetNabuCorOpts(TestCaseQt):
         """
         axis_params = QAxisRP()
         widget = AxisTabWidget(recons_params=axis_params)
-        assert axis_params.get_nabu_cor_options() == "side='all'"
+        assert axis_params.get_nabu_cor_options_as_str() == "side='all'"
         widget._calculationWidget._corOpts.setText("low_pass=2")
         widget._calculationWidget._corOpts.editingFinished.emit()
-        assert axis_params.get_nabu_cor_options() == "side='all' ; low_pass=2"
+        assert axis_params.get_nabu_cor_options_as_str() == "side='all' ; low_pass=2"
         widget._calculationWidget._corOpts.setText("low_pass=2 ; high_pass=10")
         widget._calculationWidget._sideCB.setCurrentText("left")
         widget._calculationWidget._corOpts.editingFinished.emit()
         assert (
-            axis_params.get_nabu_cor_options()
+            axis_params.get_nabu_cor_options_as_str()
             == "side='left' ; low_pass=2 ; high_pass=10"
         )

tomwer/gui/test/test_qfolder_dialog.py

@@ -0,0 +1,12 @@
+import pytest
+from tomwer.tests.conftest import qtapp  # noqa F401
+from tomwer.gui.qfolderdialog import QDataDialog
+
+
+@pytest.mark.parametrize("multi_selection", (True, False))
+def test_qdata_dialog(
+    qtapp,  # noqa F401
+    multi_selection,
+):
+    dialog = QDataDialog(parent=None, multiSelection=multi_selection)
+    dialog.files_selected()

tomwer/gui/utils/inputwidget.py

@@ -249,45 +249,57 @@ class NXTomomillOutputDirSelector(qt.QWidget):
     sigChanged = qt.Signal()
     """Signal emit when the output directory of the nx file change"""
 
+    DEFAULT_PROCESSED_DIR = (
+        "{scan_parent_dir_basename}/../PROCESSED_DATA/{scan_dir_name}"
+    )
+    """Default pattern to find the 'processed' directory"""
+
     def __init__(self, parent=None):
         qt.QWidget.__init__(self, parent)
         self.setLayout(qt.QGridLayout())
         self.__buttonGroup = qt.QButtonGroup(self)
         self.__buttonGroup.setExclusive(True)
 
-        # automatic
-        self._automaticRB = qt.QRadioButton("automatic", self)
-        self._automaticRB.setToolTip(
-            "Define the output directory of the "
-            "nexus (.nx) file. Will be created at the"
-            " same level as the bliss input file "
-            "(.h5)"
-        )
-        self.layout().addWidget(self._automaticRB, 0, 0, 1, 1)
-        self.__buttonGroup.addButton(self._automaticRB)
+        tooltip = f"""Define the output directory of the nexus (.nx) file. Options are:
+        \n - next to bliss file: create the NXtomos at the same level as the bliss input file
+        \n - 'PROCESSED_DATA' folder: create NXtomos on the default 'PROCESSED_DATA' folder (bliss default folder, nearby the 'raw' folder). Uses {self.DEFAULT_PROCESSED_DIR} pattern
+        \n - user defined folder: users can provide their own folders using keywords for string formatting such as 'scan_dir_name', 'scan_basename' or 'scan_parent_dir_basename'
+        """
+
+        # output dir is the folder containing the .nx file
+        self._closeToNxRB = qt.QRadioButton("next to bliss file", self)
+        self._closeToNxRB.setToolTip(tooltip)
+        self.layout().addWidget(self._closeToNxRB, 0, 0, 1, 1)
+        self.__buttonGroup.addButton(self._closeToNxRB)
+        # output dir is the default 'reduced'folder
+        self._processedFolderRB = qt.QRadioButton("'PROCESSED_DATA' folder", self)
+        self._processedFolderRB.setToolTip(tooltip)
+        self.layout().addWidget(self._processedFolderRB, 1, 0, 1, 1)
+        self.__buttonGroup.addButton(self._processedFolderRB)
         # manual
-        self._manualRB = qt.QRadioButton("personalized output directory", self)
-        self._manualRB.setToolTip("Define yourself the output directory")
-        self.layout().addWidget(self._manualRB, 1, 0, 1, 1)
+        self._manualRB = qt.QRadioButton("custom output directory", self)
+        self._manualRB.setToolTip(tooltip)
+        self.layout().addWidget(self._manualRB, 2, 0, 1, 1)
         self._outputFolderQLE = qt.QLineEdit("", self)
-        self.layout().addWidget(self._outputFolderQLE, 1, 1, 1, 1)
+        self.layout().addWidget(self._outputFolderQLE, 2, 1, 1, 1)
         self._selectButton = qt.QPushButton("", self)
         style = qt.QApplication.style()
         icon_opendir = style.standardIcon(qt.QStyle.SP_DirOpenIcon)
         self._selectButton.setIcon(icon_opendir)
         self._selectButton.setToolTip("select output directory")
-        self.layout().addWidget(self._selectButton, 1, 2, 1, 1)
+        self.layout().addWidget(self._selectButton, 2, 2, 1, 1)
         self.__buttonGroup.addButton(self._manualRB)
 
         # connect signal / slot
         self._selectButton.released.connect(self._selectOutpuFolder)
         self.__buttonGroup.buttonReleased.connect(self._updateVisiblity)
-        self._automaticRB.toggled.connect(self._outputDirChanged)
+        self._closeToNxRB.toggled.connect(self._outputDirChanged)
+        self._processedFolderRB.toggled.connect(self._outputDirChanged)
         self._manualRB.toggled.connect(self._outputDirChanged)
         self._outputFolderQLE.editingFinished.connect(self._outputDirChanged)
 
         # set up
-        self._automaticRB.setChecked(True)
+        self._closeToNxRB.setChecked(True)
         self._updateVisiblity()
 
     def _updateVisiblity(self, *args, **kwargs):
@@ -297,7 +309,7 @@ class NXTomomillOutputDirSelector(qt.QWidget):
     def _outputDirChanged(self):
         self.sigChanged.emit()
 
-    def _selectOutpuFolder(self):
+    def _selectOutpuFolder(self):  # pragma: no cover
         defaultDirectory = self._outputFolderQLE.text()
         if os.path.isdir(defaultDirectory):
             defaultDirectory = get_default_directory()
@@ -315,14 +327,23 @@ class NXTomomillOutputDirSelector(qt.QWidget):
     def getOutputFolder(self) -> Union[None, str]:
         if self._manualRB.isChecked():
             return self._outputFolderQLE.text()
+        elif self._processedFolderRB.isChecked():
+            return self.DEFAULT_PROCESSED_DIR
         else:
             return None
 
     def setOutputFolder(self, output_folder: Optional[str]):
         old = self.blockSignals(True)
         self._manualRB.setChecked(output_folder is not None)
-        if output_folder is not None:
-            self._outputFolderQLE.setText(output_folder)
+        if output_folder is None:
+            self._closeToNxRB.setChecked()
+        else:
+            is_default_processed_folder = output_folder == self.DEFAULT_PROCESSED_DIR
+            if is_default_processed_folder:
+                self._processedFolderRB.setChecked(True)
+            else:
+                self._outputFolderQLE.setText(output_folder)
+                self._manualRB.setChecked(True)
         self._updateVisiblity()
         self.blockSignals(old)
 
@@ -359,7 +380,7 @@ class _ConfigFileSelector(qt.QWidget):
     def _clearFilePath(self):
         self._lineEdit.clear()
 
-    def _selectCFGFile(self):
+    def _selectCFGFile(self):  # pragma: no cover
         dialog = qt.QFileDialog(self)
         dialog.setFileMode(qt.QFileDialog.ExistingFile)