zlevelsetter.py

# -*- coding: utf-8 -*-
"""
Created on Fri Oct 25 09:39:14 2019

@author: brandt
"""
from PyQt5 import QtWidgets, QtCore
import numpy as np
import math


class ZLevelSetter(QtWidgets.QLabel):
    """
    Allows refining settings for the focus-z-stacking
    :return:
    """

    sizeChanged = QtCore.pyqtSignal()

    def __init__(self):
        super(ZLevelSetter, self).__init__()
        layout = QtWidgets.QVBoxLayout()
        self.setLayout(layout)

        self.radioGroup = QtWidgets.QButtonGroup()

        layout.addWidget(self._createRangeGroupBox())
        layout.addLayout(self._createLevelSelectionLayout())

        self._addRadioBtnsToGroup()
        self._updateLevels()

    def _createRangeGroupBox(self):
        """
        Creates Widgets for setting range of z-levels
        :return:
        """
        rangeGroupBox = QtWidgets.QGroupBox('Select Range of z-steps')
        rangeGroupBox.setMinimumHeight(80)
        rangesLayout = QtWidgets.QHBoxLayout()
        rangeGroupBox.setLayout(rangesLayout)

        self.minLevelSpinbox = QtWidgets.QSpinBox()
        self.minLevelSpinbox.setMinimum(-1000)
        self.minLevelSpinbox.setMaximum(1000)
        self.minLevelSpinbox.setValue(0)
        self.minLevelSpinbox.valueChanged.connect(self._minLevelBoxChanged)
        self.maxLevelSpinbox = QtWidgets.QSpinBox()
        self.maxLevelSpinbox.setValue(50)
        self._minLevelBoxChanged()

        self.numLevelsSpinbox = QtWidgets.QSpinBox()
        self.numLevelsSpinbox.setMinimum(1)
        self.numLevelsSpinbox.setMaximum(100)
        self.numLevelsSpinbox.setValue(5)

        for box in [self.minLevelSpinbox, self.maxLevelSpinbox, self.numLevelsSpinbox]:
            box.valueChanged.connect(self._updateLevels)

        minLabel = QtWidgets.QLabel('z_min\n(µm): ')
        maxLabel = QtWidgets.QLabel(', z_max\n(µm): ')
        numLabel = QtWidgets.QLabel(', Num.\nsteps: ')

        rangesLayout.addWidget(minLabel)
        rangesLayout.addWidget(self.minLevelSpinbox)
        rangesLayout.addWidget(maxLabel)
        rangesLayout.addWidget(self.maxLevelSpinbox)
        rangesLayout.addWidget(numLabel)
        rangesLayout.addWidget(self.numLevelsSpinbox)

        return rangeGroupBox

    def _createLevelSelectionLayout(self):
        """
        Creates the Parent Group for selecting mode of level distribution
        :return:
        """
        modeLayout = QtWidgets.QHBoxLayout()
        modeLayout.addWidget(self._createLinGroup())
        modeLayout.addWidget(self._createLogGroup())
        modeLayout.addWidget(self._createCustomGroup())
        return modeLayout

    def _createLinGroup(self):
        """
        Creates Widget group for linear level distribution
        :return:
        """
        linGroup = QtWidgets.QGroupBox()
        linLayout = QtWidgets.QVBoxLayout()
        linGroup.setLayout(linLayout)
        linGroup.sizePolicy().setVerticalPolicy(QtWidgets.QSizePolicy.Expanding)

        self.linChecker = QtWidgets.QRadioButton('Linear')
        self.linChecker.setChecked(True)
        self.linChecker.toggled.connect(self._updateLevels)
        linLayout.addWidget(self.linChecker)

        self.linPreviewLayout = QtWidgets.QVBoxLayout()
        linLayout.addLayout(self.linPreviewLayout)
        self.linPreviewSteps = []
        self._updateLinPreview()
        return linGroup

    def _createLogGroup(self):
        """
        Creates Widget group for logarithmic level distribution
        :return:
        """
        logGroup = QtWidgets.QGroupBox()
        logLayout = QtWidgets.QVBoxLayout()
        logGroup.setLayout(logLayout)
        logGroup.sizePolicy().setVerticalPolicy(QtWidgets.QSizePolicy.Expanding)

        self.logChecker = QtWidgets.QRadioButton('Logarithmic')
        self.logChecker.setChecked(False)
        self.logChecker.toggled.connect(self._updateLevels)
        logLayout.addWidget(self.logChecker)

        self.logPreviewLayout = QtWidgets.QVBoxLayout()
        logLayout.addLayout(self.logPreviewLayout)

        self.logPreviewSteps = []
        self._updateLogPreview()
        return logGroup

    def _createCustomGroup(self):
        """
        Creates Widget group for custom level distribution
        :return:
        """
        customGroup = QtWidgets.QGroupBox()
        customLayout = QtWidgets.QVBoxLayout()
        customGroup.setLayout(customLayout)
        customGroup.sizePolicy().setVerticalPolicy(QtWidgets.QSizePolicy.Expanding)

        self.customChecker = QtWidgets.QRadioButton('Custom')
        self.customChecker.setChecked(False)
        self.customChecker.toggled.connect(self._updateLevels)
        customLayout.addWidget(self.customChecker)

        self.customPreviewLayout = QtWidgets.QVBoxLayout()
        customLayout.addLayout(self.customPreviewLayout)
        self.customPreviewSteps = []
        self._updateCustomPreview()
        return customGroup

    def _updateLevels(self):
        """
        Updates the previewed levels for all modes
        :return:
        """
        self._updateLinPreview()
        self._updateLogPreview()
        self._updateCustomPreview()
        self._updateSize()

    def _updateLinPreview(self):
        """
        Updates linear level preview
        :return:
        """
        for entry in self.linPreviewSteps:
            entry.setParent(None)
        zRange = np.linspace(self.minLevelSpinbox.value(), self.maxLevelSpinbox.value(), self.numLevelsSpinbox.value())

        self.linPreviewSteps = []
        for val in zRange:
            newLabel = QtWidgets.QLabel(str(round(val, 1)))
            newLabel.setEnabled(self.linChecker.isChecked())
            self.linPreviewSteps.append(newLabel)
            self.linPreviewLayout.addWidget(newLabel)

    def _updateLogPreview(self):
        """
        Updates logarithmic level preview
        :return:
        """
        base = 2
        for entry in self.logPreviewSteps:
            entry.setParent(None)
        zmin = self.minLevelSpinbox.value()
        zmax = self.maxLevelSpinbox.value()
        diff = -(zmin-1)
        zmin = math.log((zmin+diff), base)
        zmax = math.log((zmax+diff), base)

        zRange = np.logspace(zmin, zmax, self.numLevelsSpinbox.value(), base=base)

        self.logPreviewSteps = []
        for val in zRange:
            val -= diff
            newLabel = QtWidgets.QLabel(str(round(val, 1)))
            newLabel.setEnabled(self.logChecker.isChecked())
            self.logPreviewSteps.append(newLabel)
            self.logPreviewLayout.addWidget(newLabel)

    def _updateCustomPreview(self):
        """
        Updates custom level preview
        :return:
        """
        numCurrentEntries = len(self.customPreviewSteps)
        numDesiredEntries = self.numLevelsSpinbox.value()
        indicesToRemove = []

        for i in range(max([numCurrentEntries, numDesiredEntries])):
            if i < numCurrentEntries:
                self.customPreviewSteps[i].setEnabled(self.customChecker.isChecked())

            elif i >= numCurrentEntries:
                newEntry = QtWidgets.QLineEdit()
                newEntry.setEnabled(self.customChecker.isChecked())
                self.customPreviewSteps.append(newEntry)
                self.customPreviewLayout.addWidget(newEntry)

            if i >= numDesiredEntries:
                indicesToRemove.append(i)

        for i in sorted(indicesToRemove, reverse=True):
            entry = self.customPreviewSteps[i]
            entry.setParent(None)
            self.customPreviewSteps.remove(entry)

    def _updateSize(self):
        """
        Updates the size so that all entries are well visible
        :return:
        """
        width = 400
        height = 170 + self.numLevelsSpinbox.value()*23
        self.setFixedSize(width, height)
        self.sizeChanged.emit()

    def _minLevelBoxChanged(self):
        """
        Adjusts maxLevelSpinbox to show always values larger then minLevelSpinbox
        :return:
        """
        self.maxLevelSpinbox.setMinimum(self.minLevelSpinbox.value()+1)
        self.maxLevelSpinbox.setMaximum(self.maxLevelSpinbox.value()+1000)

    def _addRadioBtnsToGroup(self):
        """
        Group Radio Buttons to have them in exclusive check mode
        :return:
        """
        self.radioGroup.addButton(self.linChecker)
        self.radioGroup.addButton(self.logChecker)
        self.radioGroup.addButton(self.customChecker)

    def getZLevels(self):
        """
        retrieves the z-levels according to the chosen settings
        :return:
        """
        zLevels = []
        if self.linChecker.isChecked():
            zLevels = [float(entry.text()) for entry in self.linPreviewSteps]
        elif self.logChecker.isChecked():
            zLevels = [float(entry.text()) for entry in self.logPreviewSteps]
        elif self.customChecker.isChecked():
            try:
                zLevels = self._getCustomLevels()
            except ValueError:
                QtWidgets.QMessageBox.critical(self, 'Error', 'Invalid entry in custom level selection')
                raise ValueError
        return np.array(zLevels)

    def _getCustomLevels(self):
        """
        Reads out the custom level range
        :return:
        """
        levels = []
        for lineEdit in self.customPreviewSteps:
            try:
                levels.append(float(lineEdit.text()))
            except:
                raise ValueError
        return sorted(levels)