tomwer 1.2.9__py3-none-any.whl → 1.3.0a0__py3-none-any.whl

tomwer/gui/stitching/z_stitching/fineestimation.py

@@ -10,7 +10,6 @@ from typing import Union
 from nabu.stitching import config as _nabu_stitching_config
 from nabu.stitching.config import StitchingType
 from nabu.stitching.overlap import OverlapStitchingStrategy
-from nabu.stitching.utils import ScoreMethod as _NabuScoreMethod
 from nabu.stitching.utils import ShiftAlgorithm as _NabuShiftAlgorithm
 from silx.gui import qt
 from tomoscan.serie import Serie
@@ -39,44 +38,8 @@ class Axis_N_Params(qt.QGroupBox):
         )
         self.layout().addRow("image registration method", self._imageRegMethodCB)
 
-        # window size
-        self._windowSize = qt.QSpinBox(self)
-        self._windowSizeLabel = qt.QLabel(
-            _nabu_stitching_config.KEY_WINDOW_SIZE.replace("_", " "), self
-        )
-        self.layout().addRow(self._windowSizeLabel, self._windowSize)
-        self._windowSize.setToolTip("research window width to find shifts")
-
-        # score method
-        self._scoreCB = qt.QComboBox(self)
-        for score_method in _NabuScoreMethod.values():
-            self._scoreCB.addItem(score_method)
-        self._scoreCBLabel = qt.QLabel(
-            _nabu_stitching_config.KEY_SCORE_METHOD.replace("_", " "), self
-        )
-        self.layout().addRow(self._scoreCBLabel, self._scoreCB)
-        self._windowSize.setToolTip(
-            "method to use in order to compute score and determine the best shift"
-        )
-
-        # connect signal / slot
-        self._imageRegMethodCB.currentTextChanged.connect(self._updatePossibleOpts)
-
         # set up
         self._imageRegMethodCB.setCurrentText(_NabuShiftAlgorithm.NONE.value)
-        self._updatePossibleOpts()
-
-    def getWindowSize(self):
-        return self._windowSize.value()
-
-    def setWindowSize(self, window_size):
-        return self._windowSize.setValue(int(window_size))
-
-    def getScoreMethod(self):
-        return _NabuScoreMethod.from_value(self._scoreCB.currentText())
-
-    def setScoreMethod(self, method):
-        self._scoreCB.setCurrentText(_NabuScoreMethod.from_value(method).value)
 
     def getCurrentMethod(self):
         return _NabuShiftAlgorithm.from_value(self._imageRegMethodCB.currentText())
@@ -89,13 +52,6 @@ class Axis_N_Params(qt.QGroupBox):
     def getOptsLine(self) -> str:
         current_method = self.getCurrentMethod()
         line_ = f"{_nabu_stitching_config.KEY_IMG_REG_METHOD}={current_method.value}"
-        if current_method is _NabuShiftAlgorithm.SHIFT_GRID:
-            line_ = ",".join(
-                (
-                    line_,
-                    f"{_nabu_stitching_config.KEY_WINDOW_SIZE}={self.getWindowSize()},{_nabu_stitching_config.KEY_SCORE_METHOD}={self.getScoreMethod().value}",
-                )
-            )
         return line_
 
     def setOptsLine(self, opt_line: str) -> None:
@@ -113,13 +69,6 @@ class Axis_N_Params(qt.QGroupBox):
             except Exception as e:
                 _logger.error(e)
 
-        score_method = opts.get(_nabu_stitching_config.KEY_SCORE_METHOD, None)
-        if score_method is not None:
-            try:
-                self.setScoreMethod(score_method)
-            except Exception as e:
-                _logger.error(e)
-
         img_reg_exp_method = opts.get(_nabu_stitching_config.KEY_IMG_REG_METHOD, None)
         if img_reg_exp_method is not None:
             try:
@@ -127,15 +76,6 @@ class Axis_N_Params(qt.QGroupBox):
             except Exception as e:
                 _logger.error(e)
 
-    def _updatePossibleOpts(self, *args, **kwargs):
-        current_method = self.getCurrentMethod()
-        self._windowSizeLabel.setVisible(
-            current_method is _NabuShiftAlgorithm.SHIFT_GRID
-        )
-        self._windowSize.setVisible(current_method is _NabuShiftAlgorithm.SHIFT_GRID)
-        self._scoreCBLabel.setVisible(current_method is _NabuShiftAlgorithm.SHIFT_GRID)
-        self._scoreCB.setVisible(current_method is _NabuShiftAlgorithm.SHIFT_GRID)
-
 
 class AutoRefineWidget(qt.QWidget):
     """

tomwer/gui/utils/buttons.py

@@ -1,39 +1,20 @@
-# coding: utf-8
-# /*##########################################################################
-# Copyright (C) 2017 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.
-#
-#############################################################################*/
-
 """
 Button of general usage.
 """
 
-__authors__ = ["H.Payno"]
-__license__ = "MIT"
-__date__ = "03/10/2018"
-
-
+import numpy
+import logging
+from typing import Optional, Union
 from silx.gui import qt
+from silx.gui.plot.tools.roi import RegionOfInterestManager
+from silx.gui.plot.items.roi import LineROI
+from silx.gui.plot.PlotToolButtons import PlotToolButton
 
 from tomwer.gui import icons
+from pyunitsystem.metricsystem import MetricSystem
+
+
+_logger = logging.getLogger(__file__)
 
 
 class PadlockButton(qt.QPushButton):
@@ -100,3 +81,105 @@ class TabBrowsersButtons(qt.QWidget):
 
     def _nextReleased(self, *args, **kwargs):
         self.sigNextReleased.emit()
+
+
+class TapeMeasureToolButton(PlotToolButton):
+    """Button to active measurement between two point of the plot"""
+
+    class TapeMeasureROI(LineROI):
+        def __init__(self, parent=None, pixel_size_m=None):
+            super().__init__(parent)
+            self._pixel_size_m = None
+            self.setPixelSize(pixel_size_m)
+
+        def setEndPoints(self, startPoint, endPoint):
+            distance_px = numpy.linalg.norm(endPoint - startPoint)
+            super().setEndPoints(startPoint=startPoint, endPoint=endPoint)
+            if self._pixel_size_m is None:
+                self._updateText(f"{distance_px :.1f}px")
+            else:
+                distance_m = distance_px * self._pixel_size_m
+                value, unit = MetricSystem.cast_metric_to_best_unit(distance_m)
+                self._updateText(f"{distance_px :.1f}px ({value:.2f}{unit})")
+
+        def setPixelSize(self, pixel_size_m: Optional[Union[tuple, float]]):
+            if isinstance(pixel_size_m, (tuple, list)):
+                assert (
+                    len(pixel_size_m) == 2
+                ), "expects at most two pixel size values (x and y values)"
+                if not numpy.isclose(pixel_size_m[0], pixel_size_m[1]):
+                    value, unit = MetricSystem.cast_metric_to_best_unit(pixel_size_m[0])
+                    _logger.warning(
+                        f"TapeMeasure is only handling square pixels for now. Will consider the pixel is {value:.2f}{unit}x{value:.2f}{unit}"
+                    )
+                pixel_size_m = pixel_size_m[0]
+            self._pixel_size_m = pixel_size_m
+
+    def __init__(self, parent=None, plot=None, pixel_size_mm=None):
+        super().__init__(parent=parent, plot=plot)
+        self._roiManager = None
+        self._lastRoiCreated = None
+        self._pixel_sixel_m = pixel_size_mm
+        self.setIcon(icons.getQIcon("ruler"))
+        self.setToolTip("measure distance between two pixels")
+        self.toggled.connect(self._callback)
+        self._connectPlot(plot)
+
+    def setPlot(self, plot):
+        return super().setPlot(plot)
+
+    def setPixelSize(self, pixel_size_m: Optional[Union[tuple, float]]):
+        self._pixel_sixel_m = pixel_size_m
+
+    def _callback(self, toggled):
+        if not self._roiManager:
+            return
+        if self._lastRoiCreated is not None:
+            self._lastRoiCreated.setVisible(self.isChecked())
+        if self.isChecked():
+            self._roiManager.start(
+                self.TapeMeasureROI,
+                self,
+            )
+            self.__interactiveModeStarted(self._roiManager)
+        else:
+            source = self._roiManager.getInteractionSource()
+            if source is self:
+                self._roiManager.stop()
+
+    def __interactiveModeStarted(self, roiManager):
+        roiManager.sigInteractiveModeFinished.connect(self.__interactiveModeFinished)
+
+    def __interactiveModeFinished(self):
+        roiManager = self._roiManager
+        if roiManager is not None:
+            roiManager.sigInteractiveModeFinished.disconnect(
+                self.__interactiveModeFinished
+            )
+        self.setChecked(False)
+
+    def _connectPlot(self, plot):
+        """
+        Called when the plot is connected to the widget
+        :param plot: :class:`.PlotWidget` instance
+        """
+        if plot is None:
+            return
+        self._roiManager = RegionOfInterestManager(plot)
+        self._roiManager.setColor("yellow")  # Set the color of ROI
+        self._roiManager.sigRoiAdded.connect(self._registerCurrentROI)
+
+    def _disconnectPlot(self, plot):
+        if plot and self._lastRoiCreated is not None:
+            self._roiManager.removeRoi(self._lastRoiCreated)
+            self._lastRoiCreated = None
+        return super()._disconnectPlot(plot)
+
+    def _registerCurrentROI(self, currentRoi):
+        if self._lastRoiCreated is None:
+            self._lastRoiCreated = currentRoi
+            self._lastRoiCreated.setPixelSize(self._pixel_sixel_m)
+        elif currentRoi != self._lastRoiCreated and self._roiManager is not None:
+            self._roiManager.removeRoi(self._lastRoiCreated)
+            self._lastRoiCreated = currentRoi
+            self._lastRoiCreated.setPixelSize(self._pixel_sixel_m)

tomwer/gui/utils/inputwidget.py

@@ -28,7 +28,7 @@ __date__ = "16/08/2018"
 
 import logging
 import os
-from typing import Optional
+from typing import Optional, Union
 
 import numpy
 from nxtomomill.io.config import TomoEDFConfig as EDFConfig
@@ -41,7 +41,7 @@ from tomwer.gui import icons
 from tomwer.gui.qlefilesystem import QLFileSystem
 from tomwer.io.utils import get_default_directory
 from tomwer.core.volume.volumefactory import VolumeFactory
-from tomwer.core.process.control.nxtomomill import NXtomomillNXDefaultOutput
+from tomwer.core.process.output import ProcessDataOutputDirMode
 
 from tomwer.core.volume import (
     EDFVolume,
@@ -271,42 +271,49 @@ class NXTomomillOutputDirSelector(qt.QWidget):
         self.__buttonGroup.setExclusive(True)
 
         tooltip = """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 - same folder as scan: create the NXtomos at the same level as the bliss input file or spec folder
+        \n - 'RAW_DATA' folder: create NXtomos on the default 'RAW_DATA' folder (bliss default folder, nearby the 'raw' folder).
         \n - 'PROCESSED_DATA' folder: create NXtomos on the default 'PROCESSED_DATA' folder (bliss default folder, nearby the 'raw' folder).
         \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._closeToBlissFileRB = qt.QRadioButton("near input file", self)
-        self._closeToBlissFileRB.setToolTip(tooltip)
-        self.layout().addWidget(self._closeToBlissFileRB, 0, 0, 1, 1)
-        self.__buttonGroup.addButton(self._closeToBlissFileRB)
+        self._inScanFolder = qt.QRadioButton("same folder as scan", self)
+        self._inScanFolder.setToolTip(tooltip)
+        self.layout().addWidget(self._inScanFolder, 0, 0, 1, 1)
+        self.__buttonGroup.addButton(self._inScanFolder)
         # output dir is the default 'reduced'folder
         self._processedDataFolderRB = qt.QRadioButton("'PROCESSED_DATA' folder", self)
         self._processedDataFolderRB.setToolTip(tooltip)
         self.layout().addWidget(self._processedDataFolderRB, 1, 0, 1, 1)
         self.__buttonGroup.addButton(self._processedDataFolderRB)
+        # output dir is the default 'reduced'folder
+        self._rawDataFolderRB = qt.QRadioButton("'RAW_DATA' folder", self)
+        self._rawDataFolderRB.setToolTip(tooltip)
+        self.layout().addWidget(self._rawDataFolderRB, 2, 0, 1, 1)
+        self.__buttonGroup.addButton(self._rawDataFolderRB)
         # manual
         self._manualRB = qt.QRadioButton("custom output directory", self)
         self._manualRB.setToolTip(tooltip)
-        self.layout().addWidget(self._manualRB, 2, 0, 1, 1)
+        self.layout().addWidget(self._manualRB, 3, 0, 1, 1)
         self._outputFolderQLE = QLFileSystem("", self)
-        self.layout().addWidget(self._outputFolderQLE, 2, 1, 1, 1)
+        self.layout().addWidget(self._outputFolderQLE, 3, 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, 2, 2, 1, 1)
+        self.layout().addWidget(self._selectButton, 3, 2, 1, 1)
         self.__buttonGroup.addButton(self._manualRB)
 
         # connect signal / slot
         self._selectButton.released.connect(self._selectOutpuFolder)
         self.__buttonGroup.buttonReleased.connect(self._updateVisiblity)
-        self._closeToBlissFileRB.toggled.connect(self._outputDirChanged)
-        self._processedDataFolderRB.toggled.connect(self._outputDirChanged)
-        self._manualRB.toggled.connect(self._outputDirChanged)
-        self._outputFolderQLE.editingFinished.connect(self._outputDirChanged)
+        self._inScanFolder.toggled.connect(self.sigChanged)
+        self._processedDataFolderRB.toggled.connect(self.sigChanged)
+        self._rawDataFolderRB.toggled.connect(self.sigChanged)
+        self._manualRB.toggled.connect(self.sigChanged)
+        self._outputFolderQLE.editingFinished.connect(self.sigChanged)
 
         # set up
         self._processedDataFolderRB.setChecked(True)
@@ -316,9 +323,6 @@ class NXTomomillOutputDirSelector(qt.QWidget):
         self._selectButton.setVisible(self._manualRB.isChecked())
         self._outputFolderQLE.setVisible(self._manualRB.isChecked())
 
-    def _outputDirChanged(self):
-        self.sigChanged.emit()
-
     def _selectOutpuFolder(self):  # pragma: no cover
         defaultDirectory = self._outputFolderQLE.text()
         if os.path.isdir(defaultDirectory):
@@ -334,13 +338,15 @@ class NXTomomillOutputDirSelector(qt.QWidget):
         self._outputFolderQLE.setText(dialog.selectedFiles()[0])
         self.sigChanged.emit()
 
-    def getOutputFolder(self) -> str:
+    def getOutputFolder(self) -> Union[str, ProcessDataOutputDirMode]:
         if self._manualRB.isChecked():
             return self._outputFolderQLE.text()
         elif self._processedDataFolderRB.isChecked():
-            return NXtomomillNXDefaultOutput.PROCESSED_DATA.value
-        elif self._closeToBlissFileRB.isChecked():
-            return NXtomomillNXDefaultOutput.NEAR_INPUT_FILE.value
+            return ProcessDataOutputDirMode.PROCESSED_DATA_FOLDER
+        elif self._inScanFolder.isChecked():
+            return ProcessDataOutputDirMode.IN_SCAN_FOLDER
+        elif self._rawDataFolderRB.isChecked():
+            return ProcessDataOutputDirMode.RAW_DATA_FOLDER
         else:
             raise RuntimeError("Use case - h52nx output dir - not handled")
 
@@ -348,15 +354,17 @@ class NXTomomillOutputDirSelector(qt.QWidget):
         old = self.blockSignals(True)
         self._manualRB.setChecked(output_folder is not None)
         try:
-            default_output = NXtomomillNXDefaultOutput.from_value(output_folder)
+            default_output = ProcessDataOutputDirMode.from_value(output_folder)
         except ValueError:
             self._outputFolderQLE.setText(output_folder)
             self._manualRB.setChecked(True)
         else:
-            if default_output is NXtomomillNXDefaultOutput.NEAR_INPUT_FILE:
+            if default_output is ProcessDataOutputDirMode.IN_SCAN_FOLDER:
                 self._processedDataFolderRB.setChecked(True)
-            elif default_output is NXtomomillNXDefaultOutput.PROCESSED_DATA:
-                self._closeToBlissFileRB.setChecked(True)
+            elif default_output is ProcessDataOutputDirMode.PROCESSED_DATA_FOLDER:
+                self._inScanFolder.setChecked(True)
+            elif default_output is ProcessDataOutputDirMode.RAW_DATA_FOLDER:
+                self._rawDataFolderRB.setChecked(True)
             else:
                 raise ValueError(f"default output not handled ({default_output})")
         finally:

tomwer/gui/utils/scandescription.py

@@ -64,6 +64,10 @@ class ScanNameLabelAndShape(qt.QWidget):
     def setScan(self, scan: Optional[TomwerScanBase]):
         if scan is None or scan.path is None:
             self.clear()
+        elif not isinstance(scan, TomwerScanBase):
+            raise TypeError(
+                f"Scan is expected to be an  instance of {TomwerScanBase}. Get {type(scan)} instead"
+            )
         else:
             assert isinstance(scan, TomwerScanBase)
             self._scanNameLabel.setText(scan.get_identifier().short_description())

tomwer/gui/utils/step.py

@@ -0,0 +1,144 @@
+import functools
+from silx.gui import qt
+from typing import Optional, Union
+from tomwer.gui.utils.qt_utils import block_signals
+
+
+class StepSizeSelectorWidget(qt.QGroupBox):
+    """
+    Widget to define some steps size (as float). Used by the Axis and the AxisOrdered widgets
+
+    :param str title: title to provide to the group box
+    :param str label: text for the label set at the left of the QLineEdit
+    :param fine_value: (optional) value to provide for 'fine' step
+    :param medium_value: (optional) value to provide for 'medium' step
+    :param rough_value: (optional) value to provide for 'rough' step
+    :param dtype: type of the step. Can be int or float
+    """
+
+    valueChanged = qt.Signal()
+
+    def __init__(
+        self,
+        parent=None,
+        title="",
+        label: str = "step size",
+        fine_value: [float, int, None] = 0.1,
+        medium_value: [float, int, None] = 0.5,
+        rough_value: [float, int, None] = 1.0,
+        unit: Optional[str] = "px",
+        dtype: Union[int, float] = float,
+    ):
+        assert fine_value is None or isinstance(
+            fine_value, dtype
+        ), f"fine_value is expected to be None or a {dtype}. Get {type(fine_value)}"
+        assert medium_value is None or isinstance(
+            medium_value, dtype
+        ), f"medium_value is expected to be None or a {dtype}. Get {type(medium_value)}"
+        assert rough_value is None or isinstance(
+            rough_value, dtype
+        ), f"rough_value is expected to be None or a {dtype}. Get {type(rough_value)}"
+        super().__init__(title, parent)
+        self._dtype = dtype
+        if unit is None:
+            unit = ""
+        else:
+            unit = f" {unit}"
+        self.setLayout(qt.QGridLayout())
+        self.layout().setSpacing(2)
+
+        # label
+        self.layout().addWidget(qt.QLabel(label), 0, 0, 3, 1)
+
+        # QLE manual step size
+        default_value = medium_value or fine_value or rough_value
+        self._manualLE = qt.QLineEdit(str(default_value), parent=self)
+        if dtype is float:
+            validator = qt.QDoubleValidator(parent=self._manualLE, decimals=2)
+            validator.setBottom(0.0)
+        elif dtype is int:
+            validator = qt.QIntValidator(parent=self._manualLE)
+            validator.setBottom(0)
+        else:
+            raise ValueError("dtype is expected to be int or float")
+        self._manualLE.setValidator(validator)
+        self.layout().addWidget(self._manualLE, 0, 1, 3, 1)
+
+        # buttons
+        buttons_font = self.font()
+        buttons_font.setPixelSize(10)
+        self._expectedValues = {}
+        # for each button associate the expected value
+
+        # fine
+        if fine_value is not None:
+            self._fineButton = qt.QPushButton(f"fine ({fine_value}{unit})", parent=self)
+            self._fineButton.setCheckable(True)
+            self._fineButton.setFont(buttons_font)
+            self.layout().addWidget(self._fineButton, 0, 2, 1, 1)
+            self._fineButton.released.connect(
+                functools.partial(self.setStepSize, fine_value)
+            )
+            self._expectedValues[self._fineButton] = fine_value
+        else:
+            self._fineButton = None
+
+        # medium
+        if medium_value is not None:
+            self._mediumButton = qt.QPushButton(
+                f"medium ({medium_value}{unit})", parent=self
+            )
+            self._mediumButton.setCheckable(True)
+            self._mediumButton.setFont(buttons_font)
+            self.layout().addWidget(self._mediumButton, 1, 2, 1, 1)
+            self._mediumButton.released.connect(
+                functools.partial(self.setStepSize, medium_value)
+            )
+            self._expectedValues[self._mediumButton] = medium_value
+        else:
+            self._mediumButton = None
+
+        # rough
+        if rough_value is not None:
+            self._roughButton = qt.QPushButton(
+                f"rough ({rough_value}{unit})", parent=self
+            )
+            self._roughButton.setCheckable(True)
+            self._roughButton.setFont(buttons_font)
+            self.layout().addWidget(self._roughButton, 2, 2, 1, 1)
+            self._roughButton.released.connect(
+                functools.partial(self.setStepSize, rough_value)
+            )
+            self._expectedValues[self._roughButton] = rough_value
+        else:
+            self._roughButton = None
+
+        # connect signal / slot
+        self._manualLE.textChanged.connect(self._updateButtonChecked)
+        self._manualLE.textChanged.connect(self.valueChanged)
+        # set up
+        self._updateButtonChecked(self._manualLE.text())
+
+    def _updateButtonChecked(self, text):
+        if text == "":
+            return
+        current_value = self._dtype(text)
+        for button, activation_value in self._expectedValues.items():
+            with block_signals(button):
+                button.setChecked(activation_value == current_value)
+
+    def getStepSize(self) -> Union[float, int]:
+        """
+
+        :return: displacement shift defined
+        :rtype: float
+        """
+        return self._dtype(self._manualLE.text())
+
+    def setStepSize(self, value: Union[float, int]):
+        """
+
+        :param float value: shift step
+        """
+        assert isinstance(value, self._dtype)
+        self._manualLE.setText(str(value))

tomwer/gui/utils/unitsystem.py

@@ -35,7 +35,7 @@ __date__ = "21/09/2018"
 import logging
 
 from silx.gui import qt
-from tomoscan.unitsystem import metricsystem
+from pyunitsystem import metricsystem
 
 from tomwer.core.utils.char import MU_CHAR
 
@@ -64,10 +64,7 @@ class PixelEntry(qt.QWidget):
         self.layout().addWidget(self._qlePixelSize)
 
         # connect signal / slot
-        self._qlePixelSize.editingFinished.connect(self._callbackEditingFinished)
-
-    def _callbackEditingFinished(self):
-        self.valueChanged.emit()
+        self._qlePixelSize.editingFinished.connect(self.valueChanged)
 
     def getValue(self):
         if self._qlePixelSize.text() in ("unknown", ""):