tomwer 1.3.26__py3-none-any.whl → 1.4.0__py3-none-any.whl

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

@@ -1,35 +1,8 @@
 # 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.
-#
-# ###########################################################################*/
-
-__authors__ = ["H. Payno"]
-__license__ = "MIT"
-__date__ = "11/02/2020"
+from __future__ import annotations
 
 
 import logging
-import typing
 
 from silx.gui import qt
 from silx.utils.enum import Enum as _Enum
@@ -40,6 +13,7 @@ from tomwer.gui.reconstruction.nabu.nabuconfig import base
 from tomwer.gui.reconstruction.nabu.nabuconfig.ctf import CTFConfig
 from tomwer.gui.utils.inputwidget import SelectionLineEdit
 from tomwer.gui.utils.scrollarea import QComboBoxIgnoreWheel as QComboBox
+from tomwer.gui import icons
 from tomwer.utils import docstring
 
 _logger = logging.getLogger(__name__)
@@ -63,7 +37,7 @@ class _NabuPhaseConfig(qt.QWidget, base._NabuStageConfigBase):
     modified
     """
 
-    def __init__(self, parent, scrollArea):
+    def __init__(self, parent):
         qt.QWidget.__init__(self, parent, stage=_NabuStages.PHASE)
         base._NabuStageConfigBase.__init__(self, stage=_NabuStages.PHASE)
         self.setLayout(qt.QGridLayout())
@@ -71,19 +45,19 @@ class _NabuPhaseConfig(qt.QWidget, base._NabuStageConfigBase):
         # phase method
         self._methodLabel = qt.QLabel("method", self)
         self.layout().addWidget(self._methodLabel, 1, 0, 1, 1)
-        self._methodCB = QComboBox(parent=self, scrollArea=scrollArea)
+        self._methodCB = QComboBox(parent=self)
         for method in _NabuPhaseMethod:
             self._methodCB.addItem(method.value)
         idx_ctf = self._methodCB.findText(_NabuPhaseMethod.CTF.value)
         self._methodCB.setItemData(
-            idx_ctf, "Contrast Transfert Function", qt.Qt.ToolTipRole
+            idx_ctf, "Contrast Transfer Function", qt.Qt.ToolTipRole
         )
         self.layout().addWidget(self._methodCB, 1, 1, 1, 3)
         self.registerWidget(self._methodLabel, "required")
         self.registerWidget(self._methodCB, "required")
 
         # paganin & ctf options
-        self._paganinOpts = NabuPaganinConfig(parent=self, scrollArea=scrollArea)
+        self._paganinOpts = NabuPaganinConfig(parent=self)
         self.layout().addWidget(self._paganinOpts, 2, 0, 3, 3)
 
         # unsharp options
@@ -118,6 +92,9 @@ class _NabuPhaseConfig(qt.QWidget, base._NabuStageConfigBase):
     def _methodChanged(self, *args, **kwargs):
         self._paganinOpts.setEnabled(self.getMethod() is not _NabuPhaseMethod.NONE)
         self._ctfOpts.setEnabled(self.getMethod() is _NabuPhaseMethod.CTF)
+        self._unsharpOpts.setDiscourageUnsharpMask(
+            self.getMethod() is _NabuPhaseMethod.NONE
+        )
         self.sigConfChanged.emit("method")
 
     def _signalConfChanged(self, param):
@@ -186,7 +163,7 @@ class NabuPaganinConfig(qt.QWidget, base._NabuStageConfigBase):
     modified
     """
 
-    def __init__(self, parent, scrollArea):
+    def __init__(self, parent):
         qt.QWidget.__init__(self, parent=parent, stage=_NabuStages.PHASE)
         base._NabuStageConfigBase.__init__(self, stage=_NabuStages.PHASE)
         self.setLayout(qt.QGridLayout())
@@ -205,7 +182,7 @@ class NabuPaganinConfig(qt.QWidget, base._NabuStageConfigBase):
         # paganin padding_type
         self._paddingLabel = qt.QLabel("padding", self)
         self.layout().addWidget(self._paddingLabel, 2, 0, 1, 1)
-        self._paddingTypeCB = QComboBox(self, scrollArea=scrollArea)
+        self._paddingTypeCB = QComboBox(self)
         self._paddingTypeCB.setToolTip(
             "Padding type for the filtering step " "in Paganin/CTR."
         )
@@ -275,8 +252,12 @@ class NabuUnsharpConfig(qt.QWidget, base._NabuStageConfigBase):
     def __init__(self, parent):
         qt.QWidget.__init__(self, parent=parent, stage=_NabuStages.PHASE)
         base._NabuStageConfigBase.__init__(self, stage=_NabuStages.PHASE)
+        self.__discourageUnSharpMask = False
         self.setLayout(qt.QGridLayout())
 
+        warning_icon = icons.getQIcon("warning")
+        warning_unsharp_no_phase = "Warning: applying unsharp mask without phase retrieval can lead to 'noisy' reconstruction"
+
         # unsharp coeff
         self._unsharpCoeffCB = qt.QCheckBox("unsharp coeff", self)
         self._unsharpCoeffCB.setToolTip(
@@ -293,6 +274,12 @@ class NabuUnsharpConfig(qt.QWidget, base._NabuStageConfigBase):
         self.layout().addWidget(self._unsharpCoeffQLE, 0, 1, 1, 1)
         self.registerWidget(self._unsharpCoeffCB, "optional")
         self._unsharpCoeffOpt = self.registerWidget(self._unsharpCoeffQLE, "optional")
+        # unsharp coeff warning
+        self._unSharpCoeffWarning = qt.QLabel("")
+        self._unSharpCoeffWarning.setToolTip(warning_unsharp_no_phase)
+        self._unSharpCoeffWarning.setPixmap(warning_icon.pixmap(20, state=qt.QIcon.On))
+        self.layout().addWidget(self._unSharpCoeffWarning, 0, 2, 1, 1)
+        self.registerWidget(self._unSharpCoeffWarning, "optional")
 
         # unsharp_sigma
         self._unsharpSigmaCB = qt.QCheckBox("unsharp sigma", self)
@@ -308,6 +295,12 @@ class NabuUnsharpConfig(qt.QWidget, base._NabuStageConfigBase):
         self.layout().addWidget(self._unsharpSigmaQLE, 1, 1, 1, 1)
         self.registerWidget(self._unsharpSigmaCB, "optional")
         self._unsharpSigmaOpt = self.registerWidget(self._unsharpSigmaQLE, "optional")
+        # unsharp coeff warning
+        self._unSharpSigmaWarning = qt.QLabel("")
+        self._unSharpSigmaWarning.setToolTip(warning_unsharp_no_phase)
+        self._unSharpSigmaWarning.setPixmap(warning_icon.pixmap(20, state=qt.QIcon.On))
+        self.layout().addWidget(self._unSharpSigmaWarning, 1, 2, 1, 1)
+        self.registerWidget(self._unSharpSigmaWarning, "optional")
 
         # set up
         self._unsharpCoeffCB.setChecked(False)
@@ -316,15 +309,18 @@ class NabuUnsharpConfig(qt.QWidget, base._NabuStageConfigBase):
         self._unsharpSigmaQLE.setText(str(0.8))
         self._showUnsharpCoeffQLE(False)
         self._showUnsharpSigmaQLE(False)
+        self._updateUnsharpMaskWarning()
 
         # signal / slot connection
         ## unsharp coeff
         self._unsharpCoeffCB.toggled.connect(self._showUnsharpCoeffQLE)
         self._unsharpCoeffCB.toggled.connect(self._unsharpCoeffChanged)
+        self._unsharpCoeffCB.toggled.connect(self._updateUnsharpMaskWarning)
         self._unsharpCoeffQLE.editingFinished.connect(self._unsharpCoeffChanged)
         ## unsharp sigma
         self._unsharpSigmaCB.toggled.connect(self._showUnsharpSigmaQLE)
         self._unsharpSigmaCB.toggled.connect(self._unsharpSigmaChanged)
+        self._unsharpSigmaCB.toggled.connect(self._updateUnsharpMaskWarning)
         self._unsharpSigmaQLE.editingFinished.connect(self._unsharpSigmaChanged)
 
     def _unsharpCoeffChanged(self, *args, **kwargs):
@@ -348,7 +344,7 @@ class NabuUnsharpConfig(qt.QWidget, base._NabuStageConfigBase):
     def _signalConfChanged(self, param):
         self.sigConfChanged.emit(param)
 
-    def getUnsharpCoeff(self) -> typing.Union[float, int]:
+    def getUnsharpCoeff(self) -> float | int:
         if self.isUnsharpCoeffActive():
             return float(self._unsharpCoeffQLE.text())
         else:
@@ -361,7 +357,7 @@ class NabuUnsharpConfig(qt.QWidget, base._NabuStageConfigBase):
             self._unsharpCoeffCB.setChecked(True)
             self._unsharpCoeffQLE.setText(str(coeff))
 
-    def getUnsharpSigma(self) -> typing.Union[float, int]:
+    def getUnsharpSigma(self) -> float | int:
         if self.isUnsharpSigmaActive():
             return float(self._unsharpSigmaQLE.text())
         else:
@@ -385,3 +381,25 @@ class NabuUnsharpConfig(qt.QWidget, base._NabuStageConfigBase):
             self.setUnsharpCoeff(float(conf["unsharp_coeff"]))
         if "unsharp_sigma" in conf:
             self.setUnsharpSigma(float(conf["unsharp_sigma"]))
+
+    def setDiscourageUnsharpMask(self, discourage: bool):
+        """Should we discourage the user to apply unsharp mask.
+        This is the case if he tries to apply an unsharp mask without phase retrieval.
+        """
+        self.__discourageUnSharpMask = discourage
+
+    def _updateUnsharpMaskWarning(self):
+        self._unSharpCoeffWarning.setVisible(
+            self.__discourageUnSharpMask and self._unsharpCoeffCB.isChecked()
+        )
+        self._unSharpSigmaWarning.setVisible(
+            self.__discourageUnSharpMask and self._unsharpSigmaCB.isChecked()
+        )
+
+    def setConfigurationLevel(self, level):
+        super().setConfigurationLevel(level)
+        # we also need to update the 'unsharp warning'
+        # note: at the moment if the basic configuration level is selected, without phase and some mask
+        # a warning will appear on bottom of the pahse GB. This is considered expected as this way we
+        # won't hide any warning.
+        self._updateUnsharpMaskWarning()

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

@@ -1,36 +1,8 @@
-# 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.
-#
-# ###########################################################################*/
-
-__authors__ = ["H. Payno"]
-__license__ = "MIT"
-__date__ = "06/12/2021"
-
+from __future__ import annotations
 
 import logging
-from typing import Optional, Union
 
+import sys
 from silx.gui import qt
 
 from tomwer.core.process.reconstruction.nabu.utils import (
@@ -56,7 +28,7 @@ class _NabuPreProcessingConfig(_NabuStageConfigBase, qt.QWidget):
     modified
     """
 
-    def __init__(self, parent, scrollArea):
+    def __init__(self, parent):
         _NabuStageConfigBase.__init__(self, stage=_NabuStages.PRE)
         qt.QWidget.__init__(self, parent)
         self.setLayout(qt.QGridLayout())
@@ -75,7 +47,7 @@ class _NabuPreProcessingConfig(_NabuStageConfigBase, qt.QWidget):
         self._dffSigmaLabel = qt.QLabel("sigma:", self)
         self._dffSigmaLabel.setAlignment(qt.Qt.AlignRight)
         self.layout().addWidget(self._dffSigmaLabel, 1, 2, 1, 1)
-        self._dffSigmaQDSB = QDoubleSpinBox(parent=self, scrollArea=scrollArea)
+        self._dffSigmaQDSB = QDoubleSpinBox(parent=self)
         self._dffSigmaQDSB.setMinimum(0.0)
         self._dffSigmaQDSB.setDecimals(2)
         self._dffSigmaQDSB.setSingleStep(0.1)
@@ -89,13 +61,13 @@ class _NabuPreProcessingConfig(_NabuStageConfigBase, qt.QWidget):
             self.registerWidget(self._dffSigmaQDSB, "required"),
         ]
 
-        ## sino ring corrcetion
+        ## sinogram ring correction
         self._sinoRingCorrectionCB = qt.QLabel("rings removal method", self)
         self._sinoRingCorrectionCB.setToolTip("Sinogram rings removal method")
         self.layout().addWidget(self._sinoRingCorrectionCB, 2, 0, 1, 2)
         self.registerWidget(self._sinoRingCorrectionCB, "required")
 
-        self._sinoRingCorrectionMthd = QComboBox(parent=self, scrollArea=scrollArea)
+        self._sinoRingCorrectionMthd = QComboBox(parent=self)
         for method in RingCorrectionMethod:
             self._sinoRingCorrectionMthd.addItem(method.value)
         ## force method to be None by default
@@ -105,7 +77,7 @@ class _NabuPreProcessingConfig(_NabuStageConfigBase, qt.QWidget):
         self.layout().addWidget(self._sinoRingCorrectionMthd, 2, 2, 1, 1)
         self.registerWidget(self._sinoRingCorrectionMthd, "required")
 
-        self._sinoRingsOpts = SinoRingsOptions(parent=self, scrollArea=scrollArea)
+        self._sinoRingsOpts = SinoRingsOptions(parent=self)
         self.layout().addWidget(self._sinoRingsOpts, 3, 1, 1, 3)
 
         ## ccd filter
@@ -118,7 +90,7 @@ class _NabuPreProcessingConfig(_NabuStageConfigBase, qt.QWidget):
         self._ccdHotspotLabel = qt.QLabel("threshold:", self)
         self._ccdHotspotLabel.setAlignment(qt.Qt.AlignRight)
         self.layout().addWidget(self._ccdHotspotLabel, 5, 2, 1, 1)
-        self._ccdThreshold = QDoubleSpinBox(self, scrollArea)
+        self._ccdThreshold = QDoubleSpinBox(self)
         self._ccdThreshold.setMinimum(0.0)
         self._ccdThreshold.setMaximum(999999)
         self._ccdThreshold.setSingleStep(0.01)
@@ -137,7 +109,9 @@ class _NabuPreProcessingConfig(_NabuStageConfigBase, qt.QWidget):
         ]
 
         ## sr current normalization
-        self._normalizeCurrent = qt.QCheckBox("normalize with current", self)
+        self._normalizeCurrent = qt.QCheckBox(
+            "Normalize by machine electric current", self
+        )
         self._normalizeCurrent.setToolTip(
             "Whether to normalize frames with Synchrotron Current. This can correct the effect of a beam refill not taken into account by flats."
         )
@@ -153,7 +127,7 @@ class _NabuPreProcessingConfig(_NabuStageConfigBase, qt.QWidget):
         self._clipMinLogValueLabel = qt.QLabel("log min clip value:", self)
         self._clipMinLogValueLabel.setAlignment(qt.Qt.AlignRight)
         self.layout().addWidget(self._clipMinLogValueLabel, 8, 2, 1, 1)
-        self._clipMinLogValue = QDoubleSpinBox(self, scrollArea=scrollArea)
+        self._clipMinLogValue = QDoubleSpinBox(self)
         self._clipMinLogValue.setMinimum(0.0)
         self._clipMinLogValue.setMaximum(9999999)
         self._clipMinLogValue.setSingleStep(0.01)
@@ -168,7 +142,7 @@ class _NabuPreProcessingConfig(_NabuStageConfigBase, qt.QWidget):
         self._clipMaxLogValueLabel = qt.QLabel("log max clip value:", self)
         self._clipMaxLogValueLabel.setAlignment(qt.Qt.AlignRight)
         self.layout().addWidget(self._clipMaxLogValueLabel, 9, 2, 1, 1)
-        self._clipMaxLogValue = QDoubleSpinBox(self, scrollArea=scrollArea)
+        self._clipMaxLogValue = QDoubleSpinBox(self)
         self._clipMaxLogValue.setMinimum(0.0)
         self._clipMaxLogValue.setMaximum(9999999)
         self._clipMaxLogValue.setSingleStep(0.01)
@@ -375,6 +349,8 @@ class _NabuPreProcessingConfig(_NabuStageConfigBase, qt.QWidget):
             "tilt_correction": tilt_correction,
             "autotilt_options": autotilt_opts,
             "normalize_srcurrent": int(self.getNormalizeCurrent()),
+            "rotate_projections_center": self._tiltCorrection.getRotateProjectionsCenter()
+            or "",
         }
 
     @docstring(_NabuStageConfigBase)
@@ -441,11 +417,16 @@ class _NabuPreProcessingConfig(_NabuStageConfigBase, qt.QWidget):
             tilt_correction=tilt_correction, auto_tilt_options=autotilt_options
         )
 
+        rotate_projections_center = conf.get("rotate_projections_center")
+        if rotate_projections_center == "":
+            rotate_projections_center = None
+        self._tiltCorrection.setRotateProjectionsCenter(rotate_projections_center)
+
 
 class SinoRingsOptions(qt.QWidget):
     _VO_DIMS = ("horizontaly", "horizontaly and vertically")
 
-    def __init__(self, parent=None, scrollArea=None, *args, **kwargs):
+    def __init__(self, parent=None, *args, **kwargs):
         super().__init__(parent, *args, **kwargs)
         self._method = None
         self.setLayout(qt.QFormLayout())
@@ -453,12 +434,12 @@ class SinoRingsOptions(qt.QWidget):
         self.layout().setSpacing(0)
         # munch parameters
         self._sigmaMunchLabel = qt.QLabel("sigma", self)
-        self._sigmaMunch = QDoubleSpinBox(self, scrollArea=scrollArea)
+        self._sigmaMunch = QDoubleSpinBox(self)
         self._sigmaMunch.setRange(0.0, 2147483647)
         self.layout().addRow(self._sigmaMunchLabel, self._sigmaMunch)
 
         self._levelsMunchLabel = qt.QLabel("levels", self)
-        self._levelsMunch = QSpinBox(self, scrollArea=scrollArea)
+        self._levelsMunch = QSpinBox(self)
         self._levelsMunch.setRange(0, 2147483647)
         self.layout().addRow(self._levelsMunchLabel, self._levelsMunch)
 
@@ -467,7 +448,7 @@ class SinoRingsOptions(qt.QWidget):
 
         # vo parameters
         self._snrVOLabel = qt.QLabel("snr", self)
-        self._snrVO = QDoubleSpinBox(self, scrollArea=scrollArea)
+        self._snrVO = QDoubleSpinBox(self)
         self._snrVO.setMinimum(0.0)
         tooltip = "Ratio used to locate large stripes. Greater is less sensitive."
         self._snrVO.setToolTip(tooltip)
@@ -475,7 +456,7 @@ class SinoRingsOptions(qt.QWidget):
         self.layout().addRow(self._snrVOLabel, self._snrVO)
 
         self._laSizeVOLabel = qt.QLabel("la_size", self)
-        self._laSizeVO = QSpinBox(self, scrollArea=scrollArea)
+        self._laSizeVO = QSpinBox(self)
         self._laSizeVO.setMinimum(0)
         tooltip = "Window size of the median filter to remove large stripes."
         self._laSizeVO.setToolTip(tooltip)
@@ -483,7 +464,7 @@ class SinoRingsOptions(qt.QWidget):
         self.layout().addRow(self._laSizeVOLabel, self._laSizeVO)
 
         self._smSizeVOLabel = qt.QLabel("sm_size", self)
-        self._smSizeVO = QSpinBox(self, scrollArea=scrollArea)
+        self._smSizeVO = QSpinBox(self)
         self._smSizeVO.setMinimum(0)
         tooltip = "Window size of the median filter to remove small-to-medium stripes."
         self._laSizeVO.setToolTip(tooltip)
@@ -491,18 +472,18 @@ class SinoRingsOptions(qt.QWidget):
         self.layout().addRow(self._smSizeVOLabel, self._smSizeVO)
 
         self._dimVOLabel = qt.QLabel("dimension", self)
-        self._dimVO = QComboBox(self, scrollArea=scrollArea)
+        self._dimVO = QComboBox(self)
         self._dimVO.addItems(self._VO_DIMS)
         self.layout().addRow(self._dimVOLabel, self._dimVO)
 
         # sino mean deringer
         self._sigmaLowLabel = qt.QLabel("signal low", self)
-        self._sigmaLow = QDoubleSpinBox(self, scrollArea=scrollArea)
+        self._sigmaLow = QDoubleSpinBox(self)
         self._sigmaLow.setMinimum(0.0)
         self._sigmaHighLabel = qt.QLabel("signal high", self)
         self.layout().addRow(self._sigmaLowLabel, self._sigmaLow)
 
-        self._sigmaHigh = QDoubleSpinBox(self, scrollArea=scrollArea)
+        self._sigmaHigh = QDoubleSpinBox(self)
         self._sigmaHigh.setMinimum(0.0)
         tooltip = (
             "sigma low and sigma high values are defining the standard deviation of "
@@ -536,7 +517,7 @@ class SinoRingsOptions(qt.QWidget):
         else:
             raise NotImplementedError
 
-    def setVoDim(self, dim: Union[int, str]):
+    def setVoDim(self, dim: int | str):
         if dim in ("1", 1, self._VO_DIMS[0]):
             self._dimVO.setCurrentText(self._VO_DIMS[0])
         elif dim in ("2", 2, self._VO_DIMS[1]):
@@ -691,24 +672,35 @@ class TiltCorrection(qt.QGroupBox):
         """
         )
         self.layout().addRow(self._autotiltOptsLabel, self._autoTiltOptions)
+        ## `rotate_projections_center` option
+        self._rotateProjectionCenter = RotateProjectionCenterWidget(self)
+        self._rotateProjectionCenter.setToolTip(
+            "\n".join(
+                (
+                    "Allows to correct detector tilt along beam orthogonal plan.",
+                    "By default the center of rotation is the middle of each radio, i.e ((Nx-1)/2.0, (Ny-1)/2.0).",
+                )
+            )
+        )
+        self.layout().addRow(self._rotateProjectionCenter)
 
         # set up
         self._autoManualRB.setChecked(True)
 
         # connect signal / slot
-        self._tiltManualRB.toggled.connect(self._updateVisiblity)
-        self._autoManualRB.toggled.connect(self._updateVisiblity)
+        self._tiltManualRB.toggled.connect(self._updateVisibility)
+        self._autoManualRB.toggled.connect(self._updateVisibility)
 
         self._tiltManualRB.toggled.connect(self._changed)
         self._autoManualRB.toggled.connect(self._changed)
         self._angleValueSB.valueChanged.connect(self._changed)
 
-        self._updateVisiblity()
+        self._updateVisibility()
 
     def _changed(self, *args, **kwargs):
         self.sigChanged.emit()
 
-    def _updateVisiblity(self):
+    def _updateVisibility(self):
         self._angleValueSB.setEnabled(self._tiltManualRB.isChecked())
         self._autoModeCB.setEnabled(self._autoManualRB.isChecked())
         self._autotiltOptsLabel.setVisible(self._autoManualRB.isChecked())
@@ -726,7 +718,7 @@ class TiltCorrection(qt.QGroupBox):
             return self._autoModeCB.currentText(), self._autoTiltOptions.text()
 
     def setTiltCorrection(
-        self, tilt_correction: str, auto_tilt_options: Optional[str] = None
+        self, tilt_correction: str, auto_tilt_options: str | None = None
     ) -> None:
         if tilt_correction in ("", None):
             self.setChecked(False)
@@ -741,3 +733,60 @@ class TiltCorrection(qt.QGroupBox):
             self._angleValueSB.setValue(float(tilt_correction))
         if auto_tilt_options is not None:
             self._autoTiltOptions.setText(auto_tilt_options)
+
+    def getRotateProjectionsCenter(self):
+        if self.isChecked():
+            return self._rotateProjectionCenter.getRotateProjectionsCenter()
+        else:
+            return None
+
+    def setRotateProjectionsCenter(self, values):
+        self._rotateProjectionCenter.setRotateProjectionsCenter(values=values)
+
+
+class RotateProjectionCenterWidget(qt.QWidget):
+
+    RANGE_MIN_VALUE = -sys.float_info.max
+    RANGE_MAX_VALUE = sys.float_info.max
+
+    def __init__(self, parent: qt.QWidget | None = None) -> None:
+        super().__init__(parent)
+        self.setLayout(qt.QHBoxLayout())
+        self._label = qt.QLabel("rotate projections center")
+        self.layout().addWidget(self._label)
+
+        self._xQLE = qt.QDoubleSpinBox(self)
+        self._xQLE.setRange(
+            RotateProjectionCenterWidget.RANGE_MIN_VALUE,
+            RotateProjectionCenterWidget.RANGE_MAX_VALUE,
+        )
+        self._xQLE.setPrefix("x=")
+        self._xQLE.setToolTip("Value should be in [-radio width, radio width]")
+        self._xQLE.setSuffix("px")
+        self.layout().addWidget(self._xQLE)
+
+        self._yQLE = qt.QDoubleSpinBox(self)
+        self._yQLE.setRange(
+            RotateProjectionCenterWidget.RANGE_MIN_VALUE,
+            RotateProjectionCenterWidget.RANGE_MAX_VALUE,
+        )
+        self._yQLE.setPrefix("y=")
+        self._xQLE.setToolTip("Value should be in [-radio heigh, radio heigh]")
+        self._yQLE.setSuffix("px")
+        self.layout().addWidget(self._yQLE)
+
+    def getRotateProjectionsCenter(self) -> tuple | None:
+        if self._xQLE.value() == 0 and self._yQLE.value() == 0:
+            return None
+        else:
+            return (self._xQLE.value(), self._yQLE.value())
+
+    def setRotateProjectionsCenter(self, values: tuple[float] | None):
+        if values is None:
+            self._xQLE.setValue(0.0)
+            self._yQLE.setValue(0.0)
+        elif not isinstance(values, (tuple, list)) and len(values) != 2:
+            raise TypeError("values should be a tuple of two elements")
+        else:
+            self._xQLE.setValue(values[0])
+            self._yQLE.setValue(values[1])