/********************************************************************************
** Form generated from reading UI file 'opsfocusprocess.ui'
**
** Created by: Qt User Interface Compiler version 6.11.1
**
** WARNING! All changes made in this file will be lost when recompiling UI file!
********************************************************************************/

#ifndef UI_OPSFOCUSPROCESS_H
#define UI_OPSFOCUSPROCESS_H

#include <QtCore/QVariant>
#include <QtWidgets/QApplication>
#include <QtWidgets/QCheckBox>
#include <QtWidgets/QComboBox>
#include <QtWidgets/QDoubleSpinBox>
#include <QtWidgets/QGridLayout>
#include <QtWidgets/QGroupBox>
#include <QtWidgets/QHBoxLayout>
#include <QtWidgets/QLabel>
#include <QtWidgets/QPushButton>
#include <QtWidgets/QSpacerItem>
#include <QtWidgets/QSpinBox>
#include <QtWidgets/QVBoxLayout>
#include <QtWidgets/QWidget>
#include <klocalizedstring.h>

QT_BEGIN_NAMESPACE

class Ui_OpsFocusProcess
{
public:
    QVBoxLayout *verticalLayout_3;
    QGridLayout *gridLayoutProcess;
    QLabel *focusStarMeasureLabel;
    QLabel *label_22;
    QHBoxLayout *horizontalLayout_7;
    QComboBox *focusSEPProfile;
    QPushButton *editFocusProfile;
    QLabel *focusStarPSFLabel;
    QComboBox *focusStarPSF;
    QLabel *label_6;
    QLabel *focusFramesCountLabel;
    QLabel *label_28;
    QSpinBox *focusFramesCount;
    QDoubleSpinBox *focusR2Limit;
    QCheckBox *focusUseWeights;
    QComboBox *focusCurveFit;
    QComboBox *focusStarMeasure;
    QComboBox *focusDetection;
    QLabel *focusCurveFitLabel;
    QComboBox *focusAlgorithm;
    QCheckBox *focusRefineCurveFit;
    QLabel *focusR2LimitLabel;
    QLabel *focusHFRFramesCountLabel;
    QSpinBox *focusHFRFramesCount;
    QGridLayout *gridLayoutProcessBucket;
    QLabel *focusThresholdLabel;
    QSpinBox *focusGaussianKernelSize;
    QLabel *focusGaussianKernelSizeLabel;
    QLabel *focusGaussianSigmaLabel;
    QLabel *focusMultiRowAverageLabel;
    QDoubleSpinBox *focusThreshold;
    QSpinBox *focusMultiRowAverage;
    QDoubleSpinBox *focusGaussianSigma;
    QLabel *focusToleranceLabel;
    QDoubleSpinBox *focusTolerance;
    QCheckBox *focusDenoise;
    QGroupBox *focusDonut;
    QGridLayout *gridLayout;
    QLabel *label;
    QDoubleSpinBox *focusTimeDilation;
    QLabel *label_2;
    QDoubleSpinBox *focusOutlierRejection;
    QGroupBox *focusScanStartPos;
    QGridLayout *gridLayout_2;
    QLabel *label_4;
    QDoubleSpinBox *focusScanStepSizeFactor;
    QCheckBox *focusScanAlwaysOn;
    QLabel *label_3;
    QSpinBox *focusScanDatapoints;
    QSpacerItem *verticalSpacer;

    void setupUi(QWidget *OpsFocusProcess)
    {
        if (OpsFocusProcess->objectName().isEmpty())
            OpsFocusProcess->setObjectName("OpsFocusProcess");
        OpsFocusProcess->resize(578, 529);
        verticalLayout_3 = new QVBoxLayout(OpsFocusProcess);
        verticalLayout_3->setObjectName("verticalLayout_3");
        gridLayoutProcess = new QGridLayout();
        gridLayoutProcess->setSpacing(3);
        gridLayoutProcess->setObjectName("gridLayoutProcess");
        gridLayoutProcess->setSizeConstraint(QLayout::SetNoConstraint);
        focusStarMeasureLabel = new QLabel(OpsFocusProcess);
        focusStarMeasureLabel->setObjectName("focusStarMeasureLabel");
        QSizePolicy sizePolicy(QSizePolicy::Policy::Preferred, QSizePolicy::Policy::Fixed);
        sizePolicy.setHorizontalStretch(0);
        sizePolicy.setVerticalStretch(0);
        sizePolicy.setHeightForWidth(focusStarMeasureLabel->sizePolicy().hasHeightForWidth());
        focusStarMeasureLabel->setSizePolicy(sizePolicy);

        gridLayoutProcess->addWidget(focusStarMeasureLabel, 2, 0, 1, 1);

        label_22 = new QLabel(OpsFocusProcess);
        label_22->setObjectName("label_22");
        sizePolicy.setHeightForWidth(label_22->sizePolicy().hasHeightForWidth());
        label_22->setSizePolicy(sizePolicy);

        gridLayoutProcess->addWidget(label_22, 1, 0, 1, 1);

        horizontalLayout_7 = new QHBoxLayout();
        horizontalLayout_7->setSpacing(3);
        horizontalLayout_7->setObjectName("horizontalLayout_7");
        focusSEPProfile = new QComboBox(OpsFocusProcess);
        focusSEPProfile->setObjectName("focusSEPProfile");

        horizontalLayout_7->addWidget(focusSEPProfile);

        editFocusProfile = new QPushButton(OpsFocusProcess);
        editFocusProfile->setObjectName("editFocusProfile");

        horizontalLayout_7->addWidget(editFocusProfile);


        gridLayoutProcess->addLayout(horizontalLayout_7, 0, 3, 1, 1);

        focusStarPSFLabel = new QLabel(OpsFocusProcess);
        focusStarPSFLabel->setObjectName("focusStarPSFLabel");
        sizePolicy.setHeightForWidth(focusStarPSFLabel->sizePolicy().hasHeightForWidth());
        focusStarPSFLabel->setSizePolicy(sizePolicy);

        gridLayoutProcess->addWidget(focusStarPSFLabel, 2, 2, 1, 1);

        focusStarPSF = new QComboBox(OpsFocusProcess);
        focusStarPSF->addItem(QString());
        focusStarPSF->setObjectName("focusStarPSF");

        gridLayoutProcess->addWidget(focusStarPSF, 2, 3, 1, 1);

        label_6 = new QLabel(OpsFocusProcess);
        label_6->setObjectName("label_6");
        sizePolicy.setHeightForWidth(label_6->sizePolicy().hasHeightForWidth());
        label_6->setSizePolicy(sizePolicy);

        gridLayoutProcess->addWidget(label_6, 0, 0, 1, 1);

        focusFramesCountLabel = new QLabel(OpsFocusProcess);
        focusFramesCountLabel->setObjectName("focusFramesCountLabel");
        sizePolicy.setHeightForWidth(focusFramesCountLabel->sizePolicy().hasHeightForWidth());
        focusFramesCountLabel->setSizePolicy(sizePolicy);

        gridLayoutProcess->addWidget(focusFramesCountLabel, 4, 2, 1, 1);

        label_28 = new QLabel(OpsFocusProcess);
        label_28->setObjectName("label_28");
        sizePolicy.setHeightForWidth(label_28->sizePolicy().hasHeightForWidth());
        label_28->setSizePolicy(sizePolicy);

        gridLayoutProcess->addWidget(label_28, 0, 2, 1, 1);

        focusFramesCount = new QSpinBox(OpsFocusProcess);
        focusFramesCount->setObjectName("focusFramesCount");
        sizePolicy.setHeightForWidth(focusFramesCount->sizePolicy().hasHeightForWidth());
        focusFramesCount->setSizePolicy(sizePolicy);
        focusFramesCount->setMinimum(1);

        gridLayoutProcess->addWidget(focusFramesCount, 4, 3, 1, 1);

        focusR2Limit = new QDoubleSpinBox(OpsFocusProcess);
        focusR2Limit->setObjectName("focusR2Limit");
        sizePolicy.setHeightForWidth(focusR2Limit->sizePolicy().hasHeightForWidth());
        focusR2Limit->setSizePolicy(sizePolicy);
        focusR2Limit->setMinimum(0.000000000000000);
        focusR2Limit->setMaximum(1.000000000000000);
        focusR2Limit->setSingleStep(0.010000000000000);
        focusR2Limit->setValue(0.800000000000000);

        gridLayoutProcess->addWidget(focusR2Limit, 3, 3, 1, 1);

        focusUseWeights = new QCheckBox(OpsFocusProcess);
        focusUseWeights->setObjectName("focusUseWeights");
        sizePolicy.setHeightForWidth(focusUseWeights->sizePolicy().hasHeightForWidth());
        focusUseWeights->setSizePolicy(sizePolicy);

        gridLayoutProcess->addWidget(focusUseWeights, 3, 0, 1, 2);

        focusCurveFit = new QComboBox(OpsFocusProcess);
        focusCurveFit->addItem(QString());
        focusCurveFit->addItem(QString());
        focusCurveFit->addItem(QString());
        focusCurveFit->addItem(QString());
        focusCurveFit->setObjectName("focusCurveFit");

        gridLayoutProcess->addWidget(focusCurveFit, 1, 3, 1, 1);

        focusStarMeasure = new QComboBox(OpsFocusProcess);
        focusStarMeasure->addItem(QString());
        focusStarMeasure->addItem(QString());
        focusStarMeasure->addItem(QString());
        focusStarMeasure->addItem(QString());
        focusStarMeasure->addItem(QString());
        focusStarMeasure->addItem(QString());
        focusStarMeasure->addItem(QString());
        focusStarMeasure->addItem(QString());
        focusStarMeasure->addItem(QString());
        focusStarMeasure->setObjectName("focusStarMeasure");

        gridLayoutProcess->addWidget(focusStarMeasure, 2, 1, 1, 1);

        focusDetection = new QComboBox(OpsFocusProcess);
        focusDetection->addItem(QString());
        focusDetection->addItem(QString());
        focusDetection->addItem(QString());
        focusDetection->addItem(QString());
        focusDetection->addItem(QString());
        focusDetection->setObjectName("focusDetection");
        sizePolicy.setHeightForWidth(focusDetection->sizePolicy().hasHeightForWidth());
        focusDetection->setSizePolicy(sizePolicy);

        gridLayoutProcess->addWidget(focusDetection, 0, 1, 1, 1);

        focusCurveFitLabel = new QLabel(OpsFocusProcess);
        focusCurveFitLabel->setObjectName("focusCurveFitLabel");
        focusCurveFitLabel->setEnabled(true);
        sizePolicy.setHeightForWidth(focusCurveFitLabel->sizePolicy().hasHeightForWidth());
        focusCurveFitLabel->setSizePolicy(sizePolicy);

        gridLayoutProcess->addWidget(focusCurveFitLabel, 1, 2, 1, 1);

        focusAlgorithm = new QComboBox(OpsFocusProcess);
        focusAlgorithm->addItem(QString());
        focusAlgorithm->addItem(QString());
        focusAlgorithm->addItem(QString());
        focusAlgorithm->addItem(QString());
        focusAlgorithm->setObjectName("focusAlgorithm");
        sizePolicy.setHeightForWidth(focusAlgorithm->sizePolicy().hasHeightForWidth());
        focusAlgorithm->setSizePolicy(sizePolicy);

        gridLayoutProcess->addWidget(focusAlgorithm, 1, 1, 1, 1);

        focusRefineCurveFit = new QCheckBox(OpsFocusProcess);
        focusRefineCurveFit->setObjectName("focusRefineCurveFit");

        gridLayoutProcess->addWidget(focusRefineCurveFit, 4, 0, 1, 2);

        focusR2LimitLabel = new QLabel(OpsFocusProcess);
        focusR2LimitLabel->setObjectName("focusR2LimitLabel");
        sizePolicy.setHeightForWidth(focusR2LimitLabel->sizePolicy().hasHeightForWidth());
        focusR2LimitLabel->setSizePolicy(sizePolicy);
        focusR2LimitLabel->setAlignment(Qt::AlignLeading|Qt::AlignLeft|Qt::AlignVCenter);

        gridLayoutProcess->addWidget(focusR2LimitLabel, 3, 2, 1, 1);

        focusHFRFramesCountLabel = new QLabel(OpsFocusProcess);
        focusHFRFramesCountLabel->setObjectName("focusHFRFramesCountLabel");

        gridLayoutProcess->addWidget(focusHFRFramesCountLabel, 5, 2, 1, 1);

        focusHFRFramesCount = new QSpinBox(OpsFocusProcess);
        focusHFRFramesCount->setObjectName("focusHFRFramesCount");
        sizePolicy.setHeightForWidth(focusHFRFramesCount->sizePolicy().hasHeightForWidth());
        focusHFRFramesCount->setSizePolicy(sizePolicy);
        focusHFRFramesCount->setMinimum(1);

        gridLayoutProcess->addWidget(focusHFRFramesCount, 5, 3, 1, 1);


        verticalLayout_3->addLayout(gridLayoutProcess);

        gridLayoutProcessBucket = new QGridLayout();
        gridLayoutProcessBucket->setSpacing(0);
        gridLayoutProcessBucket->setObjectName("gridLayoutProcessBucket");
        focusThresholdLabel = new QLabel(OpsFocusProcess);
        focusThresholdLabel->setObjectName("focusThresholdLabel");
        sizePolicy.setHeightForWidth(focusThresholdLabel->sizePolicy().hasHeightForWidth());
        focusThresholdLabel->setSizePolicy(sizePolicy);

        gridLayoutProcessBucket->addWidget(focusThresholdLabel, 1, 0, 1, 1);

        focusGaussianKernelSize = new QSpinBox(OpsFocusProcess);
        focusGaussianKernelSize->setObjectName("focusGaussianKernelSize");
        sizePolicy.setHeightForWidth(focusGaussianKernelSize->sizePolicy().hasHeightForWidth());
        focusGaussianKernelSize->setSizePolicy(sizePolicy);
        focusGaussianKernelSize->setMinimum(3);
        focusGaussianKernelSize->setMaximum(15);
        focusGaussianKernelSize->setSingleStep(2);
        focusGaussianKernelSize->setValue(5);

        gridLayoutProcessBucket->addWidget(focusGaussianKernelSize, 1, 3, 1, 1);

        focusGaussianKernelSizeLabel = new QLabel(OpsFocusProcess);
        focusGaussianKernelSizeLabel->setObjectName("focusGaussianKernelSizeLabel");
        sizePolicy.setHeightForWidth(focusGaussianKernelSizeLabel->sizePolicy().hasHeightForWidth());
        focusGaussianKernelSizeLabel->setSizePolicy(sizePolicy);

        gridLayoutProcessBucket->addWidget(focusGaussianKernelSizeLabel, 1, 2, 1, 1);

        focusGaussianSigmaLabel = new QLabel(OpsFocusProcess);
        focusGaussianSigmaLabel->setObjectName("focusGaussianSigmaLabel");
        sizePolicy.setHeightForWidth(focusGaussianSigmaLabel->sizePolicy().hasHeightForWidth());
        focusGaussianSigmaLabel->setSizePolicy(sizePolicy);

        gridLayoutProcessBucket->addWidget(focusGaussianSigmaLabel, 0, 2, 1, 1);

        focusMultiRowAverageLabel = new QLabel(OpsFocusProcess);
        focusMultiRowAverageLabel->setObjectName("focusMultiRowAverageLabel");
        sizePolicy.setHeightForWidth(focusMultiRowAverageLabel->sizePolicy().hasHeightForWidth());
        focusMultiRowAverageLabel->setSizePolicy(sizePolicy);

        gridLayoutProcessBucket->addWidget(focusMultiRowAverageLabel, 0, 0, 1, 1);

        focusThreshold = new QDoubleSpinBox(OpsFocusProcess);
        focusThreshold->setObjectName("focusThreshold");
        focusThreshold->setEnabled(true);
        sizePolicy.setHeightForWidth(focusThreshold->sizePolicy().hasHeightForWidth());
        focusThreshold->setSizePolicy(sizePolicy);
        focusThreshold->setMinimum(90.000000000000000);
        focusThreshold->setMaximum(500.000000000000000);
        focusThreshold->setSingleStep(10.000000000000000);
        focusThreshold->setValue(150.000000000000000);

        gridLayoutProcessBucket->addWidget(focusThreshold, 1, 1, 1, 1);

        focusMultiRowAverage = new QSpinBox(OpsFocusProcess);
        focusMultiRowAverage->setObjectName("focusMultiRowAverage");
        sizePolicy.setHeightForWidth(focusMultiRowAverage->sizePolicy().hasHeightForWidth());
        focusMultiRowAverage->setSizePolicy(sizePolicy);
        focusMultiRowAverage->setMinimum(1);
        focusMultiRowAverage->setMaximum(15);
        focusMultiRowAverage->setSingleStep(2);
        focusMultiRowAverage->setValue(3);

        gridLayoutProcessBucket->addWidget(focusMultiRowAverage, 0, 1, 1, 1);

        focusGaussianSigma = new QDoubleSpinBox(OpsFocusProcess);
        focusGaussianSigma->setObjectName("focusGaussianSigma");
        sizePolicy.setHeightForWidth(focusGaussianSigma->sizePolicy().hasHeightForWidth());
        focusGaussianSigma->setSizePolicy(sizePolicy);
        focusGaussianSigma->setMinimum(0.100000000000000);
        focusGaussianSigma->setMaximum(10.000000000000000);
        focusGaussianSigma->setSingleStep(0.100000000000000);
        focusGaussianSigma->setValue(1.500000000000000);

        gridLayoutProcessBucket->addWidget(focusGaussianSigma, 0, 3, 1, 1);

        focusToleranceLabel = new QLabel(OpsFocusProcess);
        focusToleranceLabel->setObjectName("focusToleranceLabel");
        sizePolicy.setHeightForWidth(focusToleranceLabel->sizePolicy().hasHeightForWidth());
        focusToleranceLabel->setSizePolicy(sizePolicy);

        gridLayoutProcessBucket->addWidget(focusToleranceLabel, 2, 0, 1, 1);

        focusTolerance = new QDoubleSpinBox(OpsFocusProcess);
        focusTolerance->setObjectName("focusTolerance");
        sizePolicy.setHeightForWidth(focusTolerance->sizePolicy().hasHeightForWidth());
        focusTolerance->setSizePolicy(sizePolicy);
        focusTolerance->setMinimum(0.010000000000000);
        focusTolerance->setMaximum(20.000000000000000);
        focusTolerance->setSingleStep(0.100000000000000);
        focusTolerance->setValue(1.000000000000000);

        gridLayoutProcessBucket->addWidget(focusTolerance, 2, 1, 1, 1);

        focusDenoise = new QCheckBox(OpsFocusProcess);
        focusDenoise->setObjectName("focusDenoise");
        sizePolicy.setHeightForWidth(focusDenoise->sizePolicy().hasHeightForWidth());
        focusDenoise->setSizePolicy(sizePolicy);

        gridLayoutProcessBucket->addWidget(focusDenoise, 2, 2, 1, 2);


        verticalLayout_3->addLayout(gridLayoutProcessBucket);

        focusDonut = new QGroupBox(OpsFocusProcess);
        focusDonut->setObjectName("focusDonut");
        sizePolicy.setHeightForWidth(focusDonut->sizePolicy().hasHeightForWidth());
        focusDonut->setSizePolicy(sizePolicy);
        focusDonut->setFlat(true);
        focusDonut->setCheckable(true);
        focusDonut->setChecked(false);
        gridLayout = new QGridLayout(focusDonut);
        gridLayout->setObjectName("gridLayout");
        label = new QLabel(focusDonut);
        label->setObjectName("label");
        label->setEnabled(true);
        sizePolicy.setHeightForWidth(label->sizePolicy().hasHeightForWidth());
        label->setSizePolicy(sizePolicy);

        gridLayout->addWidget(label, 0, 0, 1, 1);

        focusTimeDilation = new QDoubleSpinBox(focusDonut);
        focusTimeDilation->setObjectName("focusTimeDilation");
        focusTimeDilation->setEnabled(true);
        sizePolicy.setHeightForWidth(focusTimeDilation->sizePolicy().hasHeightForWidth());
        focusTimeDilation->setSizePolicy(sizePolicy);
        focusTimeDilation->setMinimum(1.000000000000000);
        focusTimeDilation->setMaximum(20.000000000000000);
        focusTimeDilation->setValue(1.000000000000000);

        gridLayout->addWidget(focusTimeDilation, 0, 1, 1, 1);

        label_2 = new QLabel(focusDonut);
        label_2->setObjectName("label_2");
        label_2->setEnabled(true);
        sizePolicy.setHeightForWidth(label_2->sizePolicy().hasHeightForWidth());
        label_2->setSizePolicy(sizePolicy);

        gridLayout->addWidget(label_2, 0, 2, 1, 1);

        focusOutlierRejection = new QDoubleSpinBox(focusDonut);
        focusOutlierRejection->setObjectName("focusOutlierRejection");
        focusOutlierRejection->setEnabled(true);
        sizePolicy.setHeightForWidth(focusOutlierRejection->sizePolicy().hasHeightForWidth());
        focusOutlierRejection->setSizePolicy(sizePolicy);
        focusOutlierRejection->setMaximum(0.400000000000000);
        focusOutlierRejection->setSingleStep(0.100000000000000);
        focusOutlierRejection->setValue(0.200000000000000);

        gridLayout->addWidget(focusOutlierRejection, 0, 3, 1, 1);


        verticalLayout_3->addWidget(focusDonut);

        focusScanStartPos = new QGroupBox(OpsFocusProcess);
        focusScanStartPos->setObjectName("focusScanStartPos");
        sizePolicy.setHeightForWidth(focusScanStartPos->sizePolicy().hasHeightForWidth());
        focusScanStartPos->setSizePolicy(sizePolicy);
        focusScanStartPos->setFlat(true);
        focusScanStartPos->setCheckable(true);
        focusScanStartPos->setChecked(false);
        gridLayout_2 = new QGridLayout(focusScanStartPos);
        gridLayout_2->setObjectName("gridLayout_2");
        label_4 = new QLabel(focusScanStartPos);
        label_4->setObjectName("label_4");
        label_4->setEnabled(true);
        sizePolicy.setHeightForWidth(label_4->sizePolicy().hasHeightForWidth());
        label_4->setSizePolicy(sizePolicy);

        gridLayout_2->addWidget(label_4, 1, 2, 1, 1);

        focusScanStepSizeFactor = new QDoubleSpinBox(focusScanStartPos);
        focusScanStepSizeFactor->setObjectName("focusScanStepSizeFactor");
        focusScanStepSizeFactor->setEnabled(true);
        sizePolicy.setHeightForWidth(focusScanStepSizeFactor->sizePolicy().hasHeightForWidth());
        focusScanStepSizeFactor->setSizePolicy(sizePolicy);
        focusScanStepSizeFactor->setMinimum(0.100000000000000);
        focusScanStepSizeFactor->setMaximum(10.000000000000000);
        focusScanStepSizeFactor->setValue(1.000000000000000);

        gridLayout_2->addWidget(focusScanStepSizeFactor, 1, 3, 1, 1);

        focusScanAlwaysOn = new QCheckBox(focusScanStartPos);
        focusScanAlwaysOn->setObjectName("focusScanAlwaysOn");
        focusScanAlwaysOn->setEnabled(true);
        sizePolicy.setHeightForWidth(focusScanAlwaysOn->sizePolicy().hasHeightForWidth());
        focusScanAlwaysOn->setSizePolicy(sizePolicy);
        focusScanAlwaysOn->setChecked(true);

        gridLayout_2->addWidget(focusScanAlwaysOn, 0, 0, 1, 2);

        label_3 = new QLabel(focusScanStartPos);
        label_3->setObjectName("label_3");
        label_3->setEnabled(true);
        sizePolicy.setHeightForWidth(label_3->sizePolicy().hasHeightForWidth());
        label_3->setSizePolicy(sizePolicy);

        gridLayout_2->addWidget(label_3, 0, 2, 1, 1);

        focusScanDatapoints = new QSpinBox(focusScanStartPos);
        focusScanDatapoints->setObjectName("focusScanDatapoints");
        focusScanDatapoints->setEnabled(true);
        sizePolicy.setHeightForWidth(focusScanDatapoints->sizePolicy().hasHeightForWidth());
        focusScanDatapoints->setSizePolicy(sizePolicy);
        focusScanDatapoints->setReadOnly(false);
        focusScanDatapoints->setMinimum(5);
        focusScanDatapoints->setMaximum(11);
        focusScanDatapoints->setSingleStep(2);

        gridLayout_2->addWidget(focusScanDatapoints, 0, 3, 1, 1);


        verticalLayout_3->addWidget(focusScanStartPos);

        verticalSpacer = new QSpacerItem(20, 40, QSizePolicy::Policy::Minimum, QSizePolicy::Policy::Expanding);

        verticalLayout_3->addItem(verticalSpacer);

#if QT_CONFIG(shortcut)
        focusStarMeasureLabel->setBuddy(focusStarMeasure);
        label_22->setBuddy(focusAlgorithm);
        focusStarPSFLabel->setBuddy(focusStarPSF);
        label_6->setBuddy(focusDetection);
        focusFramesCountLabel->setBuddy(focusFramesCount);
        label_28->setBuddy(focusSEPProfile);
        focusCurveFitLabel->setBuddy(focusCurveFit);
        focusR2LimitLabel->setBuddy(focusR2Limit);
        focusThresholdLabel->setBuddy(focusThreshold);
        focusGaussianKernelSizeLabel->setBuddy(focusGaussianKernelSize);
        focusGaussianSigmaLabel->setBuddy(focusGaussianSigma);
        focusMultiRowAverageLabel->setBuddy(focusMultiRowAverage);
        focusToleranceLabel->setBuddy(focusTolerance);
        label->setBuddy(focusTimeDilation);
        label_2->setBuddy(focusOutlierRejection);
#endif // QT_CONFIG(shortcut)
        QWidget::setTabOrder(focusDetection, focusSEPProfile);
        QWidget::setTabOrder(focusSEPProfile, editFocusProfile);
        QWidget::setTabOrder(editFocusProfile, focusAlgorithm);
        QWidget::setTabOrder(focusAlgorithm, focusCurveFit);
        QWidget::setTabOrder(focusCurveFit, focusStarMeasure);
        QWidget::setTabOrder(focusStarMeasure, focusStarPSF);
        QWidget::setTabOrder(focusStarPSF, focusUseWeights);
        QWidget::setTabOrder(focusUseWeights, focusR2Limit);
        QWidget::setTabOrder(focusR2Limit, focusRefineCurveFit);
        QWidget::setTabOrder(focusRefineCurveFit, focusFramesCount);
        QWidget::setTabOrder(focusFramesCount, focusMultiRowAverage);
        QWidget::setTabOrder(focusMultiRowAverage, focusGaussianSigma);
        QWidget::setTabOrder(focusGaussianSigma, focusThreshold);
        QWidget::setTabOrder(focusThreshold, focusGaussianKernelSize);
        QWidget::setTabOrder(focusGaussianKernelSize, focusTolerance);

        retranslateUi(OpsFocusProcess);

        focusCurveFit->setCurrentIndex(0);
        focusDetection->setCurrentIndex(3);
        focusAlgorithm->setCurrentIndex(3);


        QMetaObject::connectSlotsByName(OpsFocusProcess);
    } // setupUi

    void retranslateUi(QWidget *OpsFocusProcess)
    {
        OpsFocusProcess->setWindowTitle(tr2i18n("Focus Process", nullptr));
        focusStarMeasureLabel->setText(tr2i18n("Measure:", nullptr));
#if QT_CONFIG(tooltip)
        label_22->setToolTip(QString());
#endif // QT_CONFIG(tooltip)
        label_22->setText(tr2i18n("Algorithm:", nullptr));
        editFocusProfile->setText(QString());
        focusStarPSFLabel->setText(tr2i18n("PSF:", nullptr));
        focusStarPSF->setItemText(0, tr2i18n("Gaussian", nullptr));

#if QT_CONFIG(tooltip)
        focusStarPSF->setToolTip(tr2i18n("<html><head/><body><p>The type of PSF to use when Measure is set to FWHM:</p><ul style=\"margin-top: 0px; margin-bottom: 0px; margin-left: 0px; margin-right: 0px; -qt-list-indent: 1;\"><li style=\" margin-top:0px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;\"><span style=\" font-weight:600;\">Gaussian</span>: Uses a 2D Gaussian. This is an experimental feature.</li></ul></body></html>", nullptr));
#endif // QT_CONFIG(tooltip)
#if QT_CONFIG(tooltip)
        label_6->setToolTip(QString());
#endif // QT_CONFIG(tooltip)
        label_6->setText(tr2i18n("Detection:", nullptr));
#if QT_CONFIG(tooltip)
        focusFramesCountLabel->setToolTip(QString());
#endif // QT_CONFIG(tooltip)
        focusFramesCountLabel->setText(tr2i18n("Average Over:", nullptr));
#if QT_CONFIG(tooltip)
        label_28->setToolTip(QString());
#endif // QT_CONFIG(tooltip)
        label_28->setText(tr2i18n("SEP Profile:", nullptr));
#if QT_CONFIG(tooltip)
        focusFramesCount->setToolTip(tr2i18n("<html><head/><body><p>Number of frames to capture at each focuser position.</p></body></html>", nullptr));
#endif // QT_CONFIG(tooltip)
        focusFramesCount->setSuffix(tr2i18n(" frames", nullptr));
#if QT_CONFIG(tooltip)
        focusR2Limit->setToolTip(tr2i18n("<html><head/><body><p>Set a minimum for the acceptable R\302\262 when performing an Autofocus run.  The value is between 0 (no fit) and 1 (perfect fit).  0.8 is a good start.  If the minimum is not met,  Autofocus will rerun once to try to improve the R\302\262. Currently only available for the Linear 1 Pass algorithm when using a Curve Fit of Hyperbola or Parabola. </p></body></html>", nullptr));
#endif // QT_CONFIG(tooltip)
#if QT_CONFIG(tooltip)
        focusUseWeights->setToolTip(tr2i18n("<html><head/><body><p>Check to use the standard deviation of the star HFR or FWHM as a weighting to the curve fitting algorithm. If unchecked, all data points are given equal weighting. Currently only available when using Full Field (multiple stars) and a Curve Fit of Hyperbola or Parabola under the Linear 1 Pass algorithm. </p></body></html>", nullptr));
#endif // QT_CONFIG(tooltip)
        focusUseWeights->setText(tr2i18n("Use Weights", nullptr));
        focusCurveFit->setItemText(0, tr2i18n("Quadratic", nullptr));
        focusCurveFit->setItemText(1, tr2i18n("Hyperbola", nullptr));
        focusCurveFit->setItemText(2, tr2i18n("Parabola", nullptr));
        focusCurveFit->setItemText(3, tr2i18n("Gaussian", nullptr));

#if QT_CONFIG(tooltip)
        focusCurveFit->setToolTip(tr2i18n("<html><head/><body><p>Select the type of curve to fit to the data:</p><ul style=\"margin-top: 0px; margin-bottom: 0px; margin-left: 0px; margin-right: 0px; -qt-list-indent: 1;\"><li style=\" margin-top:0px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;\"><span style=\" font-weight:600;\">Quadratic</span>: Uses a polynomial fit of degree 2. This is currently the default option and currently the only option for all Algorithms except Linear 1 Pass.</li><li style=\" margin-top:0px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;\"><span style=\" font-weight:600;\">Hyperbola</span>: Fits a hyperbola to the data points. This is currently only available for the Linear 1 Pass Algorithm.</li><li style=\" margin-top:0px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;\"><span style=\" font-weight:600;\">Parabola</span>: Fits a parabola to the data points. This is currently only available "
                        "for the Linear 1 Pass Algorithm.</li></ul></body></html>", nullptr));
#endif // QT_CONFIG(tooltip)
        focusStarMeasure->setItemText(0, tr2i18n("HFR", nullptr));
        focusStarMeasure->setItemText(1, tr2i18n("HFR Adj", nullptr));
        focusStarMeasure->setItemText(2, tr2i18n("FWHM", nullptr));
        focusStarMeasure->setItemText(3, tr2i18n("# Stars", nullptr));
        focusStarMeasure->setItemText(4, tr2i18n("Fourier", nullptr));
        focusStarMeasure->setItemText(5, tr2i18n("StdDev", nullptr));
        focusStarMeasure->setItemText(6, tr2i18n("Sobel", nullptr));
        focusStarMeasure->setItemText(7, tr2i18n("Laplassian", nullptr));
        focusStarMeasure->setItemText(8, tr2i18n("Canny", nullptr));

#if QT_CONFIG(tooltip)
        focusStarMeasure->setToolTip(tr2i18n("<html><head/><body><p>Select the Measure to use when fitting a curve for Linear 1 Pass:</p><ul style=\"margin-top: 0px; margin-bottom: 0px; margin-left: 0px; margin-right: 0px; -qt-list-indent: 1;\"><li style=\" margin-top:0px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;\"><span style=\" font-weight:600;\">HFR</span>: Half Flux Radius. Uses an algorithm to calculate the radius of a circle centred on the star centroid that encapsulates half the star's flux.</li><ul style=\"margin-top: 0px; margin-bottom: 0px; margin-left: 0px; margin-right: 0px; -qt-list-indent: 1;\"><li style=\" margin-top:0px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;\"><span style=\" font-weight:600;\">HFR Adj</span>: Adjusted Half Flux Radius. Normalises the HFR for peak intensity. </li></ul><li style=\" margin-top:0px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;\"><span style=\" font-weight:600;\""
                        ">FWHM</span>: Full Width Half Maximum. Curve fits a PSF to each star centroid and uses the curve to calculate the FWHM. </li><li style=\" margin-top:0px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;\"><span style=\" font-weight:600;\"># Stars</span>: Number of stars. The number of detected stars at optimum focus will be a maximum. </li><li style=\" margin-top:0px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;\"><span style=\" font-weight:600;\">Fourier</span>: Fourier power calculation. Uses the Fourier Transform Power approach developed by Tan and Schulz in https://arxiv.org/pdf/2201.12466.pdf. At optimum focus the power in frequency space [result of the fourier transform] will be a maximum. </li><li style=\" margin-top:0px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;\"><span style=\" font-weight:600;\">StdDev</span>: Uses variance / mean of image pixels. It is intended "
                        "for star fields. This is an experimental feature that requires openCV to be installed.</li><li style=\" margin-top:0px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;\"><span style=\" font-weight:600;\">Sobel</span>: Uses the Sobel Edge Detection algorithm.  It is intended for non-stellar fields,  e.g. Solar,  Lunar or planetary.  This is an experimental feature that requires openCV to be installed.</li><li style=\" margin-top:0px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;\"><span style=\" font-weight:600;\">Laplassian: </span>Uses the Laplassian Edge Detection algorithm.  It is intended for non-stellar fields,  e.g. Solar,  Lunar or planetary.  This is an experimental feature that requires openCV to be installed.</li></ul><ul style=\"margin-top: 0px; margin-bottom: 0px; margin-left: 0px; margin-right: 0px; -qt-list-indent: 1;\"><li style=\" margin-top:0px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-b"
                        "lock-indent:0; text-indent:0px;\"><span style=\" font-weight:600;\">Canny: </span>Uses the Canny Edge Detection algorithm.  It is intended for non-stellar fields,  e.g. Solar,  Lunar or planetary.  This is an experimental feature that requires openCV to be installed.</li></ul></body></html>", nullptr));
#endif // QT_CONFIG(tooltip)
        focusDetection->setItemText(0, tr2i18n("Gradient", nullptr));
        focusDetection->setItemText(1, tr2i18n("Centroid", nullptr));
        focusDetection->setItemText(2, tr2i18n("Threshold", nullptr));
        focusDetection->setItemText(3, tr2i18n("SEP", nullptr));
        focusDetection->setItemText(4, tr2i18n("Bahtinov", nullptr));

#if QT_CONFIG(tooltip)
        focusDetection->setToolTip(tr2i18n("<html><head/><body><p>Star detection method:</p><ul style=\"margin-top: 0px; margin-bottom: 0px; margin-left: 0px; margin-right: 0px; -qt-list-indent: 1;\"><li style=\" margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;\"><span style=\" font-weight:600;\">SEP:</span> Source Extractor and Photometry, an efficient source detection method based on Source Extractor (Bertin and Arnouts 1996; Bertin 2016). See <a href=\"https://joss.theoj.org/papers/10.21105/joss.00058.pdf\"><span style=\" text-decoration: underline; color:#0000ff;\">SEP: Source Extractor as a library</span></a> in the Journal of Open Source Software.</li><li style=\" margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;\"><span style=\" font-weight:600;\">Centroid</span>: a source detection based on estimating star mass around signal peaks.</li><li style=\" margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block"
                        "-indent:0; text-indent:0px;\"><span style=\" font-weight:600;\">Gradient</span>: a single source detection based on the Sobel filter. Initial or full-field analysis will use SEP instead of this method.</li><li style=\" margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;\"><span style=\" font-weight:600;\">Threshold</span>: a single source detection based on pixel values. Initial or full-field analysis will use SEP instead of this method.</li></ul></body></html>", nullptr));
#endif // QT_CONFIG(tooltip)
        focusCurveFitLabel->setText(tr2i18n("Curve Fit:", nullptr));
        focusAlgorithm->setItemText(0, tr2i18n("Iterative", nullptr));
        focusAlgorithm->setItemText(1, tr2i18n("Polynomial", nullptr));
        focusAlgorithm->setItemText(2, tr2i18n("Linear", nullptr));
        focusAlgorithm->setItemText(3, tr2i18n("Linear 1 Pass", nullptr));

#if QT_CONFIG(tooltip)
        focusAlgorithm->setToolTip(tr2i18n("<html><head/><body><p>Select focus process algorithm:</p><ul style=\"margin-top: 0px; margin-bottom: 0px; margin-left: 0px; margin-right: 0px; -qt-list-indent: 1;\"><li style=\" margin-top:12px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;\"><span style=\" font-weight:600;\">Iterative</span>: Moves focuser by discreet steps initially decided by the step size. Once a curve slope is calculated,  further step sizes are calculated to reach optimal solution. The algorithm stops when the measured HFR is within percentage Tolerance of the minimum HFR recorded in the procedure.</li><li style=\" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;\"><span style=\" font-weight:600;\">Polynomial</span>: Starts with iterative method.  Upon crossing to the other side of the V-Curve,  polynomial fitting coefficients along with possible minimum solution are calculated. This algorithm can be faster than purely iterative approac"
                        "h given a good data set.</li><li style=\" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;\"><span style=\" font-weight:600;\">Linear</span>: Samples focus inward in a regular fashion, using 2 passes.  The algorithm can be slow, but it is more resilient to backlash.  Start with the focuser positioned near good focus.  Set Initial Step Size and Max Travel for the desired sampling interval and range around start focus position.  Tolerance should be around 5%.</li><li style=\" margin-top:0px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;\"><span style=\" font-weight:600;\">Linear 1 Pass</span>: Starts like <span style=\" font-weight:600;\">Linear</span> but after completing the 1st pass, instead of doing a 2nd pass,  moves straight to the minimum HFR value calculated.  Use Curve Fit of Hyperbola or Parabola.</li></ul></body></html>", nullptr));
#endif // QT_CONFIG(tooltip)
#if QT_CONFIG(tooltip)
        focusRefineCurveFit->setToolTip(tr2i18n("<html><head/><body><p>Check to run an outlier pass when all datapoints have been taken. The pass uses Peirce's Criteria for outlier threshold detection. If there are outliers, these are removed and curve fitting rerun. If the R\302\262 is improved by the process then this new dataset is used and outliers highlighted on the v-curve. </p></body></html>", nullptr));
#endif // QT_CONFIG(tooltip)
        focusRefineCurveFit->setText(tr2i18n("Refine Curve Fit", nullptr));
        focusR2LimitLabel->setText(tr2i18n("R\302\262 Limit:", nullptr));
        focusHFRFramesCountLabel->setText(tr2i18n("Average HFR Check:", nullptr));
#if QT_CONFIG(tooltip)
        focusHFRFramesCount->setToolTip(tr2i18n("Number of frames to capture when running in-sequence HFR Check. If using Linear 1 Pass, the point of optimum focus will also capture this number of frames.", nullptr));
#endif // QT_CONFIG(tooltip)
        focusHFRFramesCount->setSuffix(tr2i18n(" frames", nullptr));
#if QT_CONFIG(tooltip)
        focusThresholdLabel->setToolTip(QString());
#endif // QT_CONFIG(tooltip)
        focusThresholdLabel->setText(tr2i18n("Threshold:", nullptr));
#if QT_CONFIG(tooltip)
        focusGaussianKernelSize->setToolTip(tr2i18n("<html><head/><body><p>The gaussian blur kernel size. Used for blurring the image before for instance the Bahtinov edge detection.</p></body></html>", nullptr));
#endif // QT_CONFIG(tooltip)
        focusGaussianKernelSizeLabel->setText(tr2i18n("Kernel size:", nullptr));
        focusGaussianSigmaLabel->setText(tr2i18n("Sigma:", nullptr));
        focusMultiRowAverageLabel->setText(tr2i18n("Num. of rows:", nullptr));
#if QT_CONFIG(tooltip)
        focusThreshold->setToolTip(tr2i18n("<html><body><p>Increase to restrict the centroid to bright cores. Decrease to enclose fuzzy stars.</p></body></html>", nullptr));
#endif // QT_CONFIG(tooltip)
        focusThreshold->setSuffix(tr2i18n(" %", nullptr));
#if QT_CONFIG(tooltip)
        focusMultiRowAverage->setToolTip(tr2i18n("<html><head/><body><p>Combine this number of rows in the Bahtinov max average calculation. Change this value might help to match the Bahtinov lines on the star pattern more accurate.</p></body></html>", nullptr));
#endif // QT_CONFIG(tooltip)
#if QT_CONFIG(tooltip)
        focusGaussianSigma->setToolTip(tr2i18n("<html><head/><body><p>The gaussian blur sigma value. Used for blurring the image before for instance the Bahtinov edge detection.</p></body></html>", nullptr));
#endif // QT_CONFIG(tooltip)
#if QT_CONFIG(tooltip)
        focusToleranceLabel->setToolTip(QString());
#endif // QT_CONFIG(tooltip)
        focusToleranceLabel->setText(tr2i18n("Tolerance:", nullptr));
#if QT_CONFIG(tooltip)
        focusTolerance->setToolTip(tr2i18n("Decrease value to narrow optimal focus point solution radius. Increase to expand solution radius", nullptr));
#endif // QT_CONFIG(tooltip)
        focusTolerance->setSuffix(tr2i18n(" %", nullptr));
#if QT_CONFIG(tooltip)
        focusDenoise->setToolTip(tr2i18n("Check to denoise the image before further processing.", nullptr));
#endif // QT_CONFIG(tooltip)
        focusDenoise->setText(tr2i18n("Denoise", nullptr));
#if QT_CONFIG(tooltip)
        focusDonut->setToolTip(tr2i18n("<html><head/><body><p>Check to enable Donut Busting functionality. Use on telescopes with a central obstruction that create donut shaped stars when defocused.</p></body></html>", nullptr));
#endif // QT_CONFIG(tooltip)
        focusDonut->setTitle(tr2i18n("Donut Buster", nullptr));
        label->setText(tr2i18n("Time Dilation x:", nullptr));
#if QT_CONFIG(tooltip)
        focusTimeDilation->setToolTip(tr2i18n("<html><head/><body><p>The furthest datapoints have their exposure times increased by this factor. The in focus datapoint exposure is not increased. Intermediate points have their exposures scaled appropriately.</p><p>Set to 1 to disable this option.</p></body></html>", nullptr));
#endif // QT_CONFIG(tooltip)
        focusTimeDilation->setPrefix(QString());
        label_2->setText(tr2i18n("Outlier Rejection:", nullptr));
#if QT_CONFIG(tooltip)
        focusOutlierRejection->setToolTip(tr2i18n("<html><head/><body><p>How aggressively to apply Outlier Rejection. Higher values reject more outliers.</p><p>Refine Curve Fit must be set for this option to be active.</p></body></html>", nullptr));
#endif // QT_CONFIG(tooltip)
#if QT_CONFIG(tooltip)
        focusScanStartPos->setToolTip(tr2i18n("<html><head/><body><p>Check to scan for a start position. The algorithm will look for a minimum data point using Num Datapoints.</p></body></html>", nullptr));
#endif // QT_CONFIG(tooltip)
        focusScanStartPos->setTitle(tr2i18n("Scan for Start Position", nullptr));
#if QT_CONFIG(tooltip)
        label_4->setToolTip(QString());
#endif // QT_CONFIG(tooltip)
        label_4->setText(tr2i18n("Initial Step Size x:", nullptr));
#if QT_CONFIG(tooltip)
        focusScanStepSizeFactor->setToolTip(tr2i18n("Scan for Start Position uses a step size = Initial Step Size multiplied by Initial Step Size x.", nullptr));
#endif // QT_CONFIG(tooltip)
#if QT_CONFIG(tooltip)
        focusScanAlwaysOn->setToolTip(tr2i18n("Check to always run Scan for Start Position, uncheck to only run after a failed Autofocus.", nullptr));
#endif // QT_CONFIG(tooltip)
        focusScanAlwaysOn->setText(tr2i18n("Always On", nullptr));
        label_3->setText(tr2i18n("Num Datapoints:", nullptr));
#if QT_CONFIG(tooltip)
        focusScanDatapoints->setToolTip(tr2i18n("The number of datapoints to use during Scan for Start Position.", nullptr));
#endif // QT_CONFIG(tooltip)
    } // retranslateUi

};

namespace Ui {
    class OpsFocusProcess: public Ui_OpsFocusProcess {};
} // namespace Ui

QT_END_NAMESPACE

#endif // OPSFOCUSPROCESS_H

