/********************************************************************************
** Form generated from reading UI file 'exposurecalculatordialog.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_EXPOSURECALCULATORDIALOG_H
#define UI_EXPOSURECALCULATORDIALOG_H

#include <QtCore/QVariant>
#include <QtWidgets/QApplication>
#include <QtWidgets/QComboBox>
#include <QtWidgets/QDialog>
#include <QtWidgets/QDoubleSpinBox>
#include <QtWidgets/QFrame>
#include <QtWidgets/QGridLayout>
#include <QtWidgets/QHeaderView>
#include <QtWidgets/QLabel>
#include <QtWidgets/QPushButton>
#include <QtWidgets/QSpacerItem>
#include <QtWidgets/QSpinBox>
#include <QtWidgets/QTabWidget>
#include <QtWidgets/QTableWidget>
#include <QtWidgets/QVBoxLayout>
#include <QtWidgets/QWidget>
#include <klocalizedstring.h>
#include "qcustomplot.h"

QT_BEGIN_NAMESPACE

class Ui_ExposureCalculatorDialog
{
public:
    QGridLayout *gridLayout_4;
    QFrame *exposureCalculatorFrame;
    QGridLayout *gridLayout_2;
    QLabel *SQMLabel;
    QLabel *indiFocalRationLabel;
    QLabel *label;
    QDoubleSpinBox *noiseTolerance;
    QSpacerItem *horizontalSpacer_5;
    QLabel *indiCameraLabel;
    QLabel *bortleScaleLabel;
    QFrame *gainSelectionFrame;
    QLabel *gainSpinnerLabel;
    QSpinBox *gainSelector;
    QComboBox *gainISODiscreteSelector;
    QLabel *gainISOSelectorLabel;
    QLabel *gainSelectionFixedLabel;
    QFrame *calculationResult;
    QGridLayout *gridLayout_3;
    QGridLayout *gridLayout;
    QLabel *subShotNoise;
    QLabel *subTotalNoiseLabel;
    QLabel *subPollutionLabel;
    QLabel *subTotalNoise;
    QLabel *subShotNoiseLabel;
    QLabel *subPollutionElectrons;
    QSpacerItem *horizontalSpacer_3;
    QSpacerItem *horizontalSpacer_4;
    QLabel *subExposureTime;
    QLabel *subTimeLabel;
    QLabel *SensorType;
    QPushButton *downloadCameraB;
    QWidget *skyQualityColor;
    QLabel *bortleScaleValue;
    QSpacerItem *horizontalSpacer;
    QComboBox *cameraReadModeSelector;
    QDoubleSpinBox *userSkyQuality;
    QLabel *indiCameraReadMode;
    QDoubleSpinBox *filterBandwidth;
    QSpacerItem *horizontalSpacer_2;
    QComboBox *imagingCameraSelector;
    QDoubleSpinBox *indiFocalRatio;
    QCustomPlot *qCustomPlotSubExposure;
    QLabel *allowableNoiseLabel;
    QTabWidget *tabWidget;
    QWidget *tab;
    QVBoxLayout *verticalLayout;
    QTableWidget *exposureStackResult;
    QWidget *tab_2;
    QGridLayout *gridLayout_5;
    QLabel *exposureCountDifferential;
    QLabel *exposureCountLabel;
    QLabel *exposureCount;
    QCustomPlot *qCustomPlotIntegrationNoise;
    QSpacerItem *horizontalSpacer_6;
    QLabel *targetNoiseLable;
    QLabel *exposureDiffLabel;
    QDoubleSpinBox *targetNoiseRatio;

    void setupUi(QDialog *ExposureCalculatorDialog)
    {
        if (ExposureCalculatorDialog->objectName().isEmpty())
            ExposureCalculatorDialog->setObjectName("ExposureCalculatorDialog");
        ExposureCalculatorDialog->resize(438, 713);
        QSizePolicy sizePolicy(QSizePolicy::Policy::MinimumExpanding, QSizePolicy::Policy::MinimumExpanding);
        sizePolicy.setHorizontalStretch(0);
        sizePolicy.setVerticalStretch(0);
        sizePolicy.setHeightForWidth(ExposureCalculatorDialog->sizePolicy().hasHeightForWidth());
        ExposureCalculatorDialog->setSizePolicy(sizePolicy);
        ExposureCalculatorDialog->setMinimumSize(QSize(438, 713));
        ExposureCalculatorDialog->setMaximumSize(QSize(16777215, 16777215));
        ExposureCalculatorDialog->setSizeGripEnabled(true);
        gridLayout_4 = new QGridLayout(ExposureCalculatorDialog);
        gridLayout_4->setSpacing(3);
        gridLayout_4->setObjectName("gridLayout_4");
        gridLayout_4->setContentsMargins(3, 3, 3, 3);
        exposureCalculatorFrame = new QFrame(ExposureCalculatorDialog);
        exposureCalculatorFrame->setObjectName("exposureCalculatorFrame");
        exposureCalculatorFrame->setEnabled(true);
        QSizePolicy sizePolicy1(QSizePolicy::Policy::Expanding, QSizePolicy::Policy::Expanding);
        sizePolicy1.setHorizontalStretch(0);
        sizePolicy1.setVerticalStretch(0);
        sizePolicy1.setHeightForWidth(exposureCalculatorFrame->sizePolicy().hasHeightForWidth());
        exposureCalculatorFrame->setSizePolicy(sizePolicy1);
        exposureCalculatorFrame->setFrameShape(QFrame::StyledPanel);
        exposureCalculatorFrame->setFrameShadow(QFrame::Raised);
        gridLayout_2 = new QGridLayout(exposureCalculatorFrame);
        gridLayout_2->setSpacing(3);
        gridLayout_2->setObjectName("gridLayout_2");
        gridLayout_2->setContentsMargins(3, 3, 3, 3);
        SQMLabel = new QLabel(exposureCalculatorFrame);
        SQMLabel->setObjectName("SQMLabel");
        SQMLabel->setAlignment(Qt::AlignLeading|Qt::AlignLeft|Qt::AlignVCenter);
        SQMLabel->setWordWrap(true);

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

        indiFocalRationLabel = new QLabel(exposureCalculatorFrame);
        indiFocalRationLabel->setObjectName("indiFocalRationLabel");

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

        label = new QLabel(exposureCalculatorFrame);
        label->setObjectName("label");
        label->setMinimumSize(QSize(126, 0));

        gridLayout_2->addWidget(label, 1, 5, 1, 1);

        noiseTolerance = new QDoubleSpinBox(exposureCalculatorFrame);
        noiseTolerance->setObjectName("noiseTolerance");
        QSizePolicy sizePolicy2(QSizePolicy::Policy::MinimumExpanding, QSizePolicy::Policy::Fixed);
        sizePolicy2.setHorizontalStretch(0);
        sizePolicy2.setVerticalStretch(0);
        sizePolicy2.setHeightForWidth(noiseTolerance->sizePolicy().hasHeightForWidth());
        noiseTolerance->setSizePolicy(sizePolicy2);
        noiseTolerance->setMinimumSize(QSize(72, 0));
        noiseTolerance->setMinimum(0.250000000000000);
        noiseTolerance->setMaximum(500.000000000000000);
        noiseTolerance->setSingleStep(1.000000000000000);
        noiseTolerance->setValue(5.000000000000000);

        gridLayout_2->addWidget(noiseTolerance, 6, 7, 1, 1);

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

        gridLayout_2->addItem(horizontalSpacer_5, 6, 3, 1, 2);

        indiCameraLabel = new QLabel(exposureCalculatorFrame);
        indiCameraLabel->setObjectName("indiCameraLabel");

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

        bortleScaleLabel = new QLabel(exposureCalculatorFrame);
        bortleScaleLabel->setObjectName("bortleScaleLabel");
        bortleScaleLabel->setMinimumSize(QSize(107, 0));

        gridLayout_2->addWidget(bortleScaleLabel, 0, 5, 1, 1);

        gainSelectionFrame = new QFrame(exposureCalculatorFrame);
        gainSelectionFrame->setObjectName("gainSelectionFrame");
        QSizePolicy sizePolicy3(QSizePolicy::Policy::Fixed, QSizePolicy::Policy::Preferred);
        sizePolicy3.setHorizontalStretch(0);
        sizePolicy3.setVerticalStretch(0);
        sizePolicy3.setHeightForWidth(gainSelectionFrame->sizePolicy().hasHeightForWidth());
        gainSelectionFrame->setSizePolicy(sizePolicy3);
        gainSelectionFrame->setMinimumSize(QSize(180, 32));
        gainSelectionFrame->setFrameShape(QFrame::StyledPanel);
        gainSelectionFrame->setFrameShadow(QFrame::Raised);
        gainSpinnerLabel = new QLabel(gainSelectionFrame);
        gainSpinnerLabel->setObjectName("gainSpinnerLabel");
        gainSpinnerLabel->setGeometry(QRect(10, 3, 72, 27));
        gainSpinnerLabel->setMinimumSize(QSize(72, 27));
        QFont font;
        font.setPointSize(10);
        gainSpinnerLabel->setFont(font);
        gainSelector = new QSpinBox(gainSelectionFrame);
        gainSelector->setObjectName("gainSelector");
        gainSelector->setGeometry(QRect(90, 3, 81, 27));
        sizePolicy2.setHeightForWidth(gainSelector->sizePolicy().hasHeightForWidth());
        gainSelector->setSizePolicy(sizePolicy2);
        gainSelector->setMinimumSize(QSize(81, 27));
        gainISODiscreteSelector = new QComboBox(gainSelectionFrame);
        gainISODiscreteSelector->setObjectName("gainISODiscreteSelector");
        gainISODiscreteSelector->setGeometry(QRect(90, 3, 81, 27));
        sizePolicy2.setHeightForWidth(gainISODiscreteSelector->sizePolicy().hasHeightForWidth());
        gainISODiscreteSelector->setSizePolicy(sizePolicy2);
        gainISOSelectorLabel = new QLabel(gainSelectionFrame);
        gainISOSelectorLabel->setObjectName("gainISOSelectorLabel");
        gainISOSelectorLabel->setGeometry(QRect(10, 3, 72, 27));
        gainISOSelectorLabel->setMinimumSize(QSize(72, 27));
        gainSelectionFixedLabel = new QLabel(gainSelectionFrame);
        gainSelectionFixedLabel->setObjectName("gainSelectionFixedLabel");
        gainSelectionFixedLabel->setGeometry(QRect(10, 3, 151, 27));
        QSizePolicy sizePolicy4(QSizePolicy::Policy::Preferred, QSizePolicy::Policy::Fixed);
        sizePolicy4.setHorizontalStretch(0);
        sizePolicy4.setVerticalStretch(0);
        sizePolicy4.setHeightForWidth(gainSelectionFixedLabel->sizePolicy().hasHeightForWidth());
        gainSelectionFixedLabel->setSizePolicy(sizePolicy4);
        gainSelectionFixedLabel->setAlignment(Qt::AlignCenter);
        gainISODiscreteSelector->raise();
        gainSelectionFixedLabel->raise();
        gainSpinnerLabel->raise();
        gainSelector->raise();
        gainISOSelectorLabel->raise();

        gridLayout_2->addWidget(gainSelectionFrame, 6, 0, 1, 3);

        calculationResult = new QFrame(exposureCalculatorFrame);
        calculationResult->setObjectName("calculationResult");
        calculationResult->setFrameShape(QFrame::StyledPanel);
        calculationResult->setFrameShadow(QFrame::Raised);
        gridLayout_3 = new QGridLayout(calculationResult);
        gridLayout_3->setSpacing(3);
        gridLayout_3->setObjectName("gridLayout_3");
        gridLayout_3->setContentsMargins(2, 3, 2, 3);
        gridLayout = new QGridLayout();
        gridLayout->setSpacing(3);
        gridLayout->setObjectName("gridLayout");
        gridLayout->setContentsMargins(6, 1, -1, 1);
        subShotNoise = new QLabel(calculationResult);
        subShotNoise->setObjectName("subShotNoise");
        QSizePolicy sizePolicy5(QSizePolicy::Policy::MinimumExpanding, QSizePolicy::Policy::Preferred);
        sizePolicy5.setHorizontalStretch(0);
        sizePolicy5.setVerticalStretch(0);
        sizePolicy5.setHeightForWidth(subShotNoise->sizePolicy().hasHeightForWidth());
        subShotNoise->setSizePolicy(sizePolicy5);
        subShotNoise->setMinimumSize(QSize(40, 0));
        subShotNoise->setFrameShape(QFrame::StyledPanel);
        subShotNoise->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter);

        gridLayout->addWidget(subShotNoise, 0, 4, 1, 1);

        subTotalNoiseLabel = new QLabel(calculationResult);
        subTotalNoiseLabel->setObjectName("subTotalNoiseLabel");

        gridLayout->addWidget(subTotalNoiseLabel, 1, 3, 1, 1);

        subPollutionLabel = new QLabel(calculationResult);
        subPollutionLabel->setObjectName("subPollutionLabel");

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

        subTotalNoise = new QLabel(calculationResult);
        subTotalNoise->setObjectName("subTotalNoise");
        sizePolicy5.setHeightForWidth(subTotalNoise->sizePolicy().hasHeightForWidth());
        subTotalNoise->setSizePolicy(sizePolicy5);
        subTotalNoise->setMinimumSize(QSize(40, 0));
        subTotalNoise->setFrameShape(QFrame::StyledPanel);
        subTotalNoise->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter);

        gridLayout->addWidget(subTotalNoise, 1, 4, 1, 1);

        subShotNoiseLabel = new QLabel(calculationResult);
        subShotNoiseLabel->setObjectName("subShotNoiseLabel");

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

        subPollutionElectrons = new QLabel(calculationResult);
        subPollutionElectrons->setObjectName("subPollutionElectrons");
        sizePolicy5.setHeightForWidth(subPollutionElectrons->sizePolicy().hasHeightForWidth());
        subPollutionElectrons->setSizePolicy(sizePolicy5);
        subPollutionElectrons->setMinimumSize(QSize(40, 0));
        subPollutionElectrons->setFrameShape(QFrame::StyledPanel);
        subPollutionElectrons->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter);

        gridLayout->addWidget(subPollutionElectrons, 1, 1, 1, 1);

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

        gridLayout->addItem(horizontalSpacer_3, 0, 2, 1, 1);

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

        gridLayout->addItem(horizontalSpacer_4, 1, 2, 1, 1);

        subExposureTime = new QLabel(calculationResult);
        subExposureTime->setObjectName("subExposureTime");
        sizePolicy5.setHeightForWidth(subExposureTime->sizePolicy().hasHeightForWidth());
        subExposureTime->setSizePolicy(sizePolicy5);
        subExposureTime->setMinimumSize(QSize(40, 0));
        subExposureTime->setFrameShape(QFrame::StyledPanel);
        subExposureTime->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter);

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

        subTimeLabel = new QLabel(calculationResult);
        subTimeLabel->setObjectName("subTimeLabel");

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


        gridLayout_3->addLayout(gridLayout, 0, 0, 1, 1);


        gridLayout_2->addWidget(calculationResult, 7, 0, 1, 8);

        SensorType = new QLabel(exposureCalculatorFrame);
        SensorType->setObjectName("SensorType");
        SensorType->setMinimumSize(QSize(62, 0));

        gridLayout_2->addWidget(SensorType, 3, 7, 1, 1);

        downloadCameraB = new QPushButton(exposureCalculatorFrame);
        downloadCameraB->setObjectName("downloadCameraB");
        downloadCameraB->setEnabled(true);
        QSizePolicy sizePolicy6(QSizePolicy::Policy::Fixed, QSizePolicy::Policy::Fixed);
        sizePolicy6.setHorizontalStretch(0);
        sizePolicy6.setVerticalStretch(0);
        sizePolicy6.setHeightForWidth(downloadCameraB->sizePolicy().hasHeightForWidth());
        downloadCameraB->setSizePolicy(sizePolicy6);
        downloadCameraB->setMaximumSize(QSize(32, 16777215));
        downloadCameraB->setAutoDefault(false);

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

        skyQualityColor = new QWidget(exposureCalculatorFrame);
        skyQualityColor->setObjectName("skyQualityColor");
        sizePolicy6.setHeightForWidth(skyQualityColor->sizePolicy().hasHeightForWidth());
        skyQualityColor->setSizePolicy(sizePolicy6);
        skyQualityColor->setMinimumSize(QSize(28, 28));
        skyQualityColor->setMaximumSize(QSize(28, 28));

        gridLayout_2->addWidget(skyQualityColor, 0, 7, 1, 1);

        bortleScaleValue = new QLabel(exposureCalculatorFrame);
        bortleScaleValue->setObjectName("bortleScaleValue");
        bortleScaleValue->setMinimumSize(QSize(40, 0));
        bortleScaleValue->setMaximumSize(QSize(40, 40));
        bortleScaleValue->setAlignment(Qt::AlignCenter);

        gridLayout_2->addWidget(bortleScaleValue, 0, 6, 1, 1);

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

        gridLayout_2->addItem(horizontalSpacer, 0, 3, 1, 1);

        cameraReadModeSelector = new QComboBox(exposureCalculatorFrame);
        cameraReadModeSelector->setObjectName("cameraReadModeSelector");

        gridLayout_2->addWidget(cameraReadModeSelector, 4, 2, 1, 6);

        userSkyQuality = new QDoubleSpinBox(exposureCalculatorFrame);
        userSkyQuality->setObjectName("userSkyQuality");
        sizePolicy5.setHeightForWidth(userSkyQuality->sizePolicy().hasHeightForWidth());
        userSkyQuality->setSizePolicy(sizePolicy5);
        userSkyQuality->setMinimumSize(QSize(80, 27));
        userSkyQuality->setDecimals(3);

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

        indiCameraReadMode = new QLabel(exposureCalculatorFrame);
        indiCameraReadMode->setObjectName("indiCameraReadMode");

        gridLayout_2->addWidget(indiCameraReadMode, 4, 0, 1, 2);

        filterBandwidth = new QDoubleSpinBox(exposureCalculatorFrame);
        filterBandwidth->setObjectName("filterBandwidth");
        QSizePolicy sizePolicy7(QSizePolicy::Policy::Minimum, QSizePolicy::Policy::Fixed);
        sizePolicy7.setHorizontalStretch(0);
        sizePolicy7.setVerticalStretch(0);
        sizePolicy7.setHeightForWidth(filterBandwidth->sizePolicy().hasHeightForWidth());
        filterBandwidth->setSizePolicy(sizePolicy7);
        filterBandwidth->setMinimumSize(QSize(48, 27));
        filterBandwidth->setMaximumSize(QSize(16777215, 16777215));
        filterBandwidth->setDecimals(1);

        gridLayout_2->addWidget(filterBandwidth, 1, 7, 1, 1);

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

        gridLayout_2->addItem(horizontalSpacer_2, 1, 3, 1, 1);

        imagingCameraSelector = new QComboBox(exposureCalculatorFrame);
        imagingCameraSelector->setObjectName("imagingCameraSelector");

        gridLayout_2->addWidget(imagingCameraSelector, 3, 2, 1, 5);

        indiFocalRatio = new QDoubleSpinBox(exposureCalculatorFrame);
        indiFocalRatio->setObjectName("indiFocalRatio");
        sizePolicy5.setHeightForWidth(indiFocalRatio->sizePolicy().hasHeightForWidth());
        indiFocalRatio->setSizePolicy(sizePolicy5);
        indiFocalRatio->setMinimumSize(QSize(80, 27));

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

        qCustomPlotSubExposure = new QCustomPlot(exposureCalculatorFrame);
        qCustomPlotSubExposure->setObjectName("qCustomPlotSubExposure");
        sizePolicy1.setHeightForWidth(qCustomPlotSubExposure->sizePolicy().hasHeightForWidth());
        qCustomPlotSubExposure->setSizePolicy(sizePolicy1);
        qCustomPlotSubExposure->setMinimumSize(QSize(0, 180));

        gridLayout_2->addWidget(qCustomPlotSubExposure, 5, 0, 1, 8);

        allowableNoiseLabel = new QLabel(exposureCalculatorFrame);
        allowableNoiseLabel->setObjectName("allowableNoiseLabel");
        QSizePolicy sizePolicy8(QSizePolicy::Policy::Preferred, QSizePolicy::Policy::Preferred);
        sizePolicy8.setHorizontalStretch(0);
        sizePolicy8.setVerticalStretch(0);
        sizePolicy8.setHeightForWidth(allowableNoiseLabel->sizePolicy().hasHeightForWidth());
        allowableNoiseLabel->setSizePolicy(sizePolicy8);
        allowableNoiseLabel->setMinimumSize(QSize(122, 27));
        allowableNoiseLabel->setAlignment(Qt::AlignLeading|Qt::AlignLeft|Qt::AlignVCenter);

        gridLayout_2->addWidget(allowableNoiseLabel, 6, 5, 1, 1);

        tabWidget = new QTabWidget(exposureCalculatorFrame);
        tabWidget->setObjectName("tabWidget");
        tabWidget->setMinimumSize(QSize(0, 192));
        tab = new QWidget();
        tab->setObjectName("tab");
        verticalLayout = new QVBoxLayout(tab);
        verticalLayout->setSpacing(3);
        verticalLayout->setObjectName("verticalLayout");
        verticalLayout->setContentsMargins(3, 3, 3, 3);
        exposureStackResult = new QTableWidget(tab);
        exposureStackResult->setObjectName("exposureStackResult");
        exposureStackResult->setMinimumSize(QSize(380, 140));

        verticalLayout->addWidget(exposureStackResult);

        tabWidget->addTab(tab, QString());
        tab_2 = new QWidget();
        tab_2->setObjectName("tab_2");
        gridLayout_5 = new QGridLayout(tab_2);
        gridLayout_5->setSpacing(3);
        gridLayout_5->setObjectName("gridLayout_5");
        gridLayout_5->setContentsMargins(3, 3, 3, 3);
        exposureCountDifferential = new QLabel(tab_2);
        exposureCountDifferential->setObjectName("exposureCountDifferential");
        sizePolicy5.setHeightForWidth(exposureCountDifferential->sizePolicy().hasHeightForWidth());
        exposureCountDifferential->setSizePolicy(sizePolicy5);
        exposureCountDifferential->setMinimumSize(QSize(40, 0));

        gridLayout_5->addWidget(exposureCountDifferential, 0, 7, 1, 1);

        exposureCountLabel = new QLabel(tab_2);
        exposureCountLabel->setObjectName("exposureCountLabel");
        sizePolicy3.setHeightForWidth(exposureCountLabel->sizePolicy().hasHeightForWidth());
        exposureCountLabel->setSizePolicy(sizePolicy3);
        exposureCountLabel->setMinimumSize(QSize(67, 0));

        gridLayout_5->addWidget(exposureCountLabel, 0, 3, 1, 1);

        exposureCount = new QLabel(tab_2);
        exposureCount->setObjectName("exposureCount");
        sizePolicy5.setHeightForWidth(exposureCount->sizePolicy().hasHeightForWidth());
        exposureCount->setSizePolicy(sizePolicy5);
        exposureCount->setMinimumSize(QSize(40, 0));

        gridLayout_5->addWidget(exposureCount, 0, 4, 1, 2);

        qCustomPlotIntegrationNoise = new QCustomPlot(tab_2);
        qCustomPlotIntegrationNoise->setObjectName("qCustomPlotIntegrationNoise");
        sizePolicy.setHeightForWidth(qCustomPlotIntegrationNoise->sizePolicy().hasHeightForWidth());
        qCustomPlotIntegrationNoise->setSizePolicy(sizePolicy);
        qCustomPlotIntegrationNoise->setMinimumSize(QSize(378, 100));

        gridLayout_5->addWidget(qCustomPlotIntegrationNoise, 3, 0, 1, 8);

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

        gridLayout_5->addItem(horizontalSpacer_6, 0, 2, 1, 1);

        targetNoiseLable = new QLabel(tab_2);
        targetNoiseLable->setObjectName("targetNoiseLable");
        sizePolicy8.setHeightForWidth(targetNoiseLable->sizePolicy().hasHeightForWidth());
        targetNoiseLable->setSizePolicy(sizePolicy8);
        targetNoiseLable->setMinimumSize(QSize(110, 0));

        gridLayout_5->addWidget(targetNoiseLable, 0, 0, 1, 1);

        exposureDiffLabel = new QLabel(tab_2);
        exposureDiffLabel->setObjectName("exposureDiffLabel");
        sizePolicy6.setHeightForWidth(exposureDiffLabel->sizePolicy().hasHeightForWidth());
        exposureDiffLabel->setSizePolicy(sizePolicy6);
        exposureDiffLabel->setMinimumSize(QSize(19, 0));

        gridLayout_5->addWidget(exposureDiffLabel, 0, 6, 1, 1);

        targetNoiseRatio = new QDoubleSpinBox(tab_2);
        targetNoiseRatio->setObjectName("targetNoiseRatio");
        targetNoiseRatio->setMinimumSize(QSize(68, 0));
        targetNoiseRatio->setDecimals(2);
        targetNoiseRatio->setMaximum(2000.000000000000000);
        targetNoiseRatio->setValue(80.000000000000000);

        gridLayout_5->addWidget(targetNoiseRatio, 0, 1, 1, 1);

        tabWidget->addTab(tab_2, QString());

        gridLayout_2->addWidget(tabWidget, 8, 0, 1, 8);

        qCustomPlotSubExposure->raise();
        gainSelectionFrame->raise();
        noiseTolerance->raise();
        SQMLabel->raise();
        userSkyQuality->raise();
        skyQualityColor->raise();
        indiFocalRatio->raise();
        indiFocalRationLabel->raise();
        imagingCameraSelector->raise();
        indiCameraLabel->raise();
        bortleScaleValue->raise();
        cameraReadModeSelector->raise();
        indiCameraReadMode->raise();
        calculationResult->raise();
        downloadCameraB->raise();
        SensorType->raise();
        filterBandwidth->raise();
        allowableNoiseLabel->raise();
        label->raise();
        bortleScaleLabel->raise();
        tabWidget->raise();

        gridLayout_4->addWidget(exposureCalculatorFrame, 1, 0, 1, 1);

        QWidget::setTabOrder(userSkyQuality, indiFocalRatio);
        QWidget::setTabOrder(indiFocalRatio, filterBandwidth);
        QWidget::setTabOrder(filterBandwidth, imagingCameraSelector);
        QWidget::setTabOrder(imagingCameraSelector, cameraReadModeSelector);
        QWidget::setTabOrder(cameraReadModeSelector, gainSelector);
        QWidget::setTabOrder(gainSelector, gainISODiscreteSelector);
        QWidget::setTabOrder(gainISODiscreteSelector, noiseTolerance);
        QWidget::setTabOrder(noiseTolerance, targetNoiseRatio);
        QWidget::setTabOrder(targetNoiseRatio, tabWidget);
        QWidget::setTabOrder(tabWidget, exposureStackResult);
        QWidget::setTabOrder(exposureStackResult, downloadCameraB);

        retranslateUi(ExposureCalculatorDialog);

        tabWidget->setCurrentIndex(1);


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

    void retranslateUi(QDialog *ExposureCalculatorDialog)
    {
        ExposureCalculatorDialog->setWindowTitle(tr2i18n("Exposure Calculator", nullptr));
#if QT_CONFIG(tooltip)
        ExposureCalculatorDialog->setToolTip(QString());
#endif // QT_CONFIG(tooltip)
        SQMLabel->setText(tr2i18n("Sky Quality", nullptr));
        indiFocalRationLabel->setText(tr2i18n("Focal Ratio", nullptr));
        label->setText(tr2i18n("Filter Bandwidth", nullptr));
#if QT_CONFIG(tooltip)
        noiseTolerance->setToolTip(tr2i18n("Alter the bias of the noise sources", nullptr));
#endif // QT_CONFIG(tooltip)
        indiCameraLabel->setText(tr2i18n("Camera", nullptr));
        bortleScaleLabel->setText(tr2i18n("Bortle Class", nullptr));
        gainSpinnerLabel->setText(tr2i18n("Gain", nullptr));
#if QT_CONFIG(tooltip)
        gainSelector->setToolTip(tr2i18n("Select Camera Sensor Gain", nullptr));
#endif // QT_CONFIG(tooltip)
#if QT_CONFIG(tooltip)
        gainISODiscreteSelector->setToolTip(tr2i18n("Select DSLR ISO Value", nullptr));
#endif // QT_CONFIG(tooltip)
        gainISOSelectorLabel->setText(tr2i18n("ISO", nullptr));
        gainSelectionFixedLabel->setText(tr2i18n("Read noise constant", nullptr));
#if QT_CONFIG(tooltip)
        subShotNoise->setToolTip(tr2i18n("Noise in the sub-exposure from light pollution", nullptr));
#endif // QT_CONFIG(tooltip)
        subShotNoise->setText(QString());
        subTotalNoiseLabel->setText(tr2i18n("Total Noise", nullptr));
        subPollutionLabel->setText(tr2i18n("Pollution Electrons", nullptr));
#if QT_CONFIG(tooltip)
        subTotalNoise->setToolTip(tr2i18n("Total noise in the sub-exposure (light pollution + read-noise)", nullptr));
#endif // QT_CONFIG(tooltip)
        subTotalNoise->setText(QString());
        subShotNoiseLabel->setText(tr2i18n("Shot Noise", nullptr));
#if QT_CONFIG(tooltip)
        subPollutionElectrons->setToolTip(tr2i18n("Estimated light pollution electrons in the sub-exposure.", nullptr));
#endif // QT_CONFIG(tooltip)
        subPollutionElectrons->setText(QString());
#if QT_CONFIG(tooltip)
        subExposureTime->setToolTip(tr2i18n("Duration of Sub-exposure", nullptr));
#endif // QT_CONFIG(tooltip)
        subExposureTime->setText(QString());
        subTimeLabel->setText(tr2i18n("Exposure Time (sec)", nullptr));
        SensorType->setText(QString());
#if QT_CONFIG(tooltip)
        downloadCameraB->setToolTip(tr2i18n("Download additional camera data files", nullptr));
#endif // QT_CONFIG(tooltip)
        downloadCameraB->setText(tr2i18n("+", nullptr));
#if QT_CONFIG(tooltip)
        skyQualityColor->setToolTip(tr2i18n("Bortle Zone Color", nullptr));
#endif // QT_CONFIG(tooltip)
#if QT_CONFIG(tooltip)
        bortleScaleValue->setToolTip(tr2i18n("Bortle class value", nullptr));
#endif // QT_CONFIG(tooltip)
        bortleScaleValue->setText(tr2i18n("9", nullptr));
#if QT_CONFIG(tooltip)
        cameraReadModeSelector->setToolTip(tr2i18n("Select read mode on cameras with multiple read modes.", nullptr));
#endif // QT_CONFIG(tooltip)
#if QT_CONFIG(tooltip)
        userSkyQuality->setToolTip(tr2i18n("Adjust the quality of the sky", nullptr));
#endif // QT_CONFIG(tooltip)
        indiCameraReadMode->setText(tr2i18n("Read Mode", nullptr));
#if QT_CONFIG(tooltip)
        filterBandwidth->setToolTip(tr2i18n("Apply a compensation for an optical filter", nullptr));
#endif // QT_CONFIG(tooltip)
#if QT_CONFIG(tooltip)
        imagingCameraSelector->setToolTip(tr2i18n("Camera Data Selection", nullptr));
#endif // QT_CONFIG(tooltip)
#if QT_CONFIG(tooltip)
        qCustomPlotSubExposure->setToolTip(tr2i18n("Potential exposure time graph", nullptr));
#endif // QT_CONFIG(tooltip)
        allowableNoiseLabel->setText(tr2i18n("Noise Increase %", nullptr));
        tabWidget->setTabText(tabWidget->indexOf(tab), tr2i18n("Table", nullptr));
#if QT_CONFIG(tooltip)
        exposureCountDifferential->setToolTip(tr2i18n("Slope of time to noise ratio curve at current exposure count", nullptr));
#endif // QT_CONFIG(tooltip)
        exposureCountDifferential->setText(QString());
        exposureCountLabel->setText(tr2i18n("Exposures", nullptr));
#if QT_CONFIG(tooltip)
        exposureCount->setToolTip(tr2i18n("Calculated exposure count for integration", nullptr));
#endif // QT_CONFIG(tooltip)
        exposureCount->setText(tr2i18n("--", nullptr));
#if QT_CONFIG(tooltip)
        qCustomPlotIntegrationNoise->setToolTip(tr2i18n("Integration Time to Noise Ratio", nullptr));
#endif // QT_CONFIG(tooltip)
        targetNoiseLable->setText(tr2i18n("Time/Noise Ratio", nullptr));
        exposureDiffLabel->setText(tr2i18n("dy =", nullptr));
#if QT_CONFIG(tooltip)
        targetNoiseRatio->setToolTip(tr2i18n("Integration time to noise ratio (potential quality)", nullptr));
#endif // QT_CONFIG(tooltip)
        tabWidget->setTabText(tabWidget->indexOf(tab_2), tr2i18n("Graph", nullptr));
    } // retranslateUi

};

namespace Ui {
    class ExposureCalculatorDialog: public Ui_ExposureCalculatorDialog {};
} // namespace Ui

QT_END_NAMESPACE

#endif // EXPOSURECALCULATORDIALOG_H

