path: root/src/mainwindow.cpp

#include "mainwindow.h"

// qt
#include <QComboBox>
#include <QDoubleSpinBox>
#include <QFormLayout>
#include <QGroupBox>
#include <QHBoxLayout>
#include <QLabel>
#include <QOpenGLWidget>
#include <QShortcut>
#include <QStyle>
#include <QTimer>

// optical design
#include "graphicsscene.h"
#include "graphicsview.h"
#include "opticaldesign.h"

MainWindow::MainWindow(QWidget* parent)
    : QMainWindow{parent}
    , m_scene{new GraphicsScene{this}}
    , m_view{new GraphicsView{m_scene, this}}
    , m_design{new OpticalDesign{this}}
{
    initUi();
    initShortcuts();
}

MainWindow::~MainWindow() {}

void MainWindow::initUi()
{
    setMinimumSize({640, 480});

    qDebug() << "global settings path:"
             << GlobalSettings::instance()->fileName();

    const auto mainWidget = new QWidget{this};

    const auto mainLayout = new QHBoxLayout{mainWidget};
    mainWidget->setLayout(mainLayout);

    const auto leftPanel = new QWidget{mainWidget};
    const auto leftLayout = new QFormLayout{mainWidget};
    leftLayout->setLabelAlignment(Qt::AlignVCenter | Qt::AlignRight);
    mainLayout->addLayout(leftLayout);

    // left panel
    const auto connectWidgetToProperty = [this](
                                             const auto widget,
                                             const auto widgetSignal,
                                             const auto widgetSetter,
                                             const auto propertyObject,
                                             const auto propertySignal,
                                             const auto propertySetter
                                         ) {
        connect(widget, widgetSignal, propertyObject, propertySetter);
        connect(propertyObject, propertySignal, widget, widgetSetter);
    };

    using MinValue = double;
    using MaxValue = double;
    using SingleStep = double;

    const auto newGroup = [mainWidget, leftLayout](const QString&& title) {
        const auto group = new QGroupBox{std::move(title), mainWidget};
        const auto layout = new QFormLayout{group};
        leftLayout->addRow(group);

        return group;
    };

    const auto lenseGroup = newGroup(tr("Lense"));
    const auto sensorGroup = newGroup(tr("Sensor"));
    const auto rangeGroup = newGroup(tr("Range"));
    const auto laserGroup = newGroup(tr("Laser"));
    const auto scannerBodyGroup = newGroup(tr("Scanner Body"));
    const auto resultsGroup = newGroup(tr("Results"));

    auto addFormPair = [this, leftLayout, connectWidgetToProperty](
                           const QString text,
                           const auto propertySignal,
                           const auto propertyGetter,
                           const auto propertySetter,
                           const MinValue minValue,
                           const MaxValue maxValue,
                           const SingleStep singleStep = 0.1,
                           const QGroupBox* groupBox = nullptr
                       ) {
        const auto spinBox = new QDoubleSpinBox{centralWidget()};
        spinBox->setRange(minValue, maxValue);
        spinBox->setSingleStep(singleStep);
        spinBox->setValue(std::bind(propertyGetter, m_design)());

        connect(
            spinBox,
            &QDoubleSpinBox::valueChanged,
            m_design,
            propertySetter
        );
        connect(m_design, propertySignal, spinBox, &QDoubleSpinBox::setValue);
        connect(
            m_design,
            propertySignal,
            m_scene,
            std::bind(&GraphicsScene::update, m_scene, m_design)
        );

        if (groupBox)
        {
            const auto formLayout =
                qobject_cast<QFormLayout*>(groupBox->layout());
            Q_ASSERT(formLayout);
            formLayout->addRow(text, spinBox);
        }
        else
        {
            leftLayout->addRow(text, spinBox);
        }
    };

    using Decimals = int;
    auto addFormLabel = [this, leftLayout](
                            const QString text,
                            const auto propertySignal,
                            const Decimals decimals = 2,
                            const QGroupBox* groupBox = nullptr
                        ) {
        const auto label = new QLabel{centralWidget()};

        connect(
            m_design,
            propertySignal,
            label,
            [label, decimals, text](const auto value) {
                label->setText(QString::number(value, 'F', decimals));
            }
        );

        if (groupBox)
        {
            const auto formLayout =
                qobject_cast<QFormLayout*>(groupBox->layout());
            Q_ASSERT(formLayout);
            formLayout->addRow(text, label);
        }
        else
        {
            leftLayout->addRow(text, label);
        }
    };

    const auto createLenseApertureComboBox = [this](QFormLayout* formLayout) {
        Q_ASSERT(formLayout);

        const auto comboBox = new QComboBox{centralWidget()};

        using namespace orphex;
        const auto metaEnum = QMetaEnum::fromType<LenseAperture>();

        for (int i{0}; i < metaEnum.keyCount(); ++i)
        {
            const auto key = metaEnum.key(i);
            const auto value = metaEnum.value(i);
            const auto text =
                QString{key}
                    .replace(QStringLiteral("F"), QStringLiteral("1/"))
                    .replace(QChar{'_'}, QChar{'.'});

            comboBox->addItem(text, value);
        }

        // update property on combobox change
        connect(
            comboBox,
            &QComboBox::currentIndexChanged,
            m_design,
            [this, metaEnum, comboBox](const auto index) {
                m_design->set_lenseAperture(
                    comboBox->currentData().value<LenseAperture>()
                );

                qDebug() << m_design->get_lenseAperture();
            }
        );

        // update combobox on property change
        const auto onApertureChanged = [this, comboBox](const auto value) {
            comboBox->setCurrentIndex(
                comboBox->findData(QVariant::fromValue(value))
            );
        };
        connect(
            m_design,
            qOverload<LenseAperture>(&OpticalDesign::lenseApertureChanged),
            comboBox,
            onApertureChanged
        );

        onApertureChanged(m_design->get_lenseAperture());

        connect(
            m_design,
            qOverload<>(&OpticalDesign::lenseApertureChanged),
            m_scene,
            std::bind(&GraphicsScene::update, m_scene, m_design)
        );

        formLayout->addRow(tr("A&perture:"), comboBox);
    };

    addFormPair(
        tr("&Axis Angle (°):"),
        qOverload<double>(&OpticalDesign::opticalAxisAngleDegreesChanged),
        &OpticalDesign::get_opticalAxisAngleDegrees,
        &OpticalDesign::set_opticalAxisAngleDegrees,
        MinValue{10.},
        MaxValue{85.},
        SingleStep{0.1},
        lenseGroup
    );

    addFormPair(
        tr("&Y pos (mm):"),
        qOverload<double>(&OpticalDesign::lenseYPosMmChanged),
        &OpticalDesign::get_lenseYPosMm,
        &OpticalDesign::set_lenseYPosMm,
        MinValue{10.},
        MaxValue{500.},
        SingleStep{1.},
        lenseGroup
    );

    addFormPair(
        tr("&Focal Distance (mm):"),
        qOverload<double>(&OpticalDesign::focalDistanceMmChanged),
        &OpticalDesign::get_focalDistanceMm,
        &OpticalDesign::set_focalDistanceMm,
        MinValue{1.},
        MaxValue{45.},
        SingleStep{0.1},
        lenseGroup
    );
    addFormPair(
        tr("&Back Focal Distance (mm):"),
        qOverload<double>(&OpticalDesign::backFocalDistanceMmChanged),
        &OpticalDesign::get_backFocalDistanceMm,
        &OpticalDesign::set_backFocalDistanceMm,
        MinValue{1.},
        MaxValue{45.},
        SingleStep{0.1},
        lenseGroup
    );

    createLenseApertureComboBox(
        qobject_cast<QFormLayout*>(lenseGroup->layout())
    );

    addFormPair(
        tr("Body Max Diameter (mm):"),
        qOverload<double>(&OpticalDesign::lenseBodyMaxDiameterMmChanged),
        &OpticalDesign::get_lenseBodyMaxDiameterMm,
        &OpticalDesign::set_lenseBodyMaxDiameterMm,
        MinValue{1.},
        MaxValue{100.},
        SingleStep{1.},
        lenseGroup
    );

    addFormPair(
        tr("Body Length (mm):"),
        qOverload<double>(&OpticalDesign::lenseBodyLengthMmChanged),
        &OpticalDesign::get_lenseBodyLengthMm,
        &OpticalDesign::set_lenseBodyLengthMm,
        MinValue{1.},
        MaxValue{100.},
        SingleStep{1.},
        lenseGroup
    );

    addFormPair(
        tr("&Width (mm):"),
        qOverload<double>(&OpticalDesign::sensorWidthMmChanged),
        &OpticalDesign::get_sensorWidthMm,
        &OpticalDesign::set_sensorWidthMm,
        MinValue{1.},
        MaxValue{30.},
        SingleStep{0.1},
        sensorGroup
    );

    addFormPair(
        tr("&Height (mm):"),
        qOverload<double>(&OpticalDesign::sensorHeightMmChanged),
        &OpticalDesign::get_sensorHeightMm,
        &OpticalDesign::set_sensorHeightMm,
        MinValue{1.},
        MaxValue{30.},
        SingleStep{0.1},
        sensorGroup
    );

    addFormPair(
        tr("Cell W&idth (µm):"),
        qOverload<double>(&OpticalDesign::sensorCellWidthUmChanged),
        &OpticalDesign::get_sensorCellWidthUm,
        &OpticalDesign::set_sensorCellWidthUm,
        MinValue{1.},
        MaxValue{30.},
        SingleStep{0.1},
        sensorGroup
    );

    addFormPair(
        tr("Cell H&eight (µm):"),
        qOverload<double>(&OpticalDesign::sensorCellHeightUmChanged),
        &OpticalDesign::get_sensorCellHeightUm,
        &OpticalDesign::set_sensorCellHeightUm,
        MinValue{1.},
        MaxValue{30.},
        SingleStep{0.1},
        sensorGroup
    );

    addFormPair(
        tr("Vertical &Offset (mm):"),
        qOverload<double>(&OpticalDesign::sensorVerticalOffsetMmChanged),
        &OpticalDesign::get_sensorVerticalOffsetMm,
        &OpticalDesign::set_sensorVerticalOffsetMm,
        MinValue{-50.},
        MaxValue{50.},
        SingleStep{0.1},
        sensorGroup
    );

    addFormPair(
        tr("Z &Base (mm):"),
        qOverload<double>(&OpticalDesign::zBaseMmChanged),
        &OpticalDesign::get_zBaseMm,
        &OpticalDesign::set_zBaseMm,
        MinValue{1.},
        MaxValue{10000.},
        SingleStep{1.},
        rangeGroup
    );

    addFormPair(
        tr("Z &Range (mm):"),
        qOverload<double>(&OpticalDesign::zRangeMmChanged),
        &OpticalDesign::get_zRangeMm,
        &OpticalDesign::set_zRangeMm,
        MinValue{1.},
        MaxValue{10000.},
        SingleStep{1.},
        rangeGroup
    );

    addFormPair(
        tr("Body Diameter (mm):"),
        qOverload<double>(&OpticalDesign::laserBodyDiameterMmChanged),
        &OpticalDesign::get_laserBodyDiameterMm,
        &OpticalDesign::set_laserBodyDiameterMm,
        MinValue{1.},
        MaxValue{100.},
        SingleStep{1.},
        laserGroup
    );

    addFormPair(
        tr("Body Length (mm):"),
        qOverload<double>(&OpticalDesign::laserBodyLengthMmChanged),
        &OpticalDesign::get_laserBodyLengthMm,
        &OpticalDesign::set_laserBodyLengthMm,
        MinValue{1.},
        MaxValue{100.},
        SingleStep{1.},
        laserGroup
    );

    addFormPair(
        tr("Angle (°):"),
        qOverload<double>(&OpticalDesign::laserAngleDegreesChanged),
        &OpticalDesign::get_laserAngleDegrees,
        &OpticalDesign::set_laserAngleDegrees,
        MinValue{1.},
        MaxValue{180.},
        SingleStep{1.},
        laserGroup
    );
    addFormPair(
        tr("Z Offest (mm):"),
        qOverload<double>(&OpticalDesign::laserZOffsetMmChanged),
        &OpticalDesign::get_laserZOffsetMm,
        &OpticalDesign::set_laserZOffsetMm,
        MinValue{-100.},
        MaxValue{100.},
        SingleStep{1.},
        laserGroup
    );

    addFormPair(
        tr("Wall Thickness (mm):"),
        qOverload<double>(&OpticalDesign::scannerBodyWallThicknessMmChanged),
        &OpticalDesign::get_scannerBodyWallThicknessMm,
        &OpticalDesign::set_scannerBodyWallThicknessMm,
        MinValue{1.},
        MaxValue{30.},
        SingleStep{1.},
        scannerBodyGroup
    );

    addFormPair(
        tr("Front Wall Offset (mm):"),
        qOverload<double>(&OpticalDesign::scannerBodyFrontWallOffsetMmChanged),
        &OpticalDesign::get_scannerBodyFrontWallOffsetMm,
        &OpticalDesign::set_scannerBodyFrontWallOffsetMm,
        MinValue{-50.},
        MaxValue{50.},
        SingleStep{1.},
        scannerBodyGroup
    );

    addFormLabel(
        tr("Sensor/Lense Angle (°):"),
        qOverload<double>(&OpticalDesign::sensorLenseAngleDegreesChanged),
        Decimals{3},
        resultsGroup
    );

    addFormLabel(
        tr("FoV (YZ, V) (°):"),
        qOverload<double>(&OpticalDesign::vFoVDegreesChanged),
        Decimals{3},
        resultsGroup
    );

    // addFormLabel(
    //     tr("Actual Z Base (mm):"),
    //     qOverload<double>(&OpticalDesign::actualZBaseMmChanged),
    //     Decimals{2},
    //     resultsGroup
    // );

    {
        const auto actualZBaseTextLabel = new QLabel{centralWidget()};

        connect(
            m_design,
            &OpticalDesign::actualZBaseTextChanged,
            actualZBaseTextLabel,
            &QLabel::setText
        );

        auto formLayout = qobject_cast<QFormLayout*>(resultsGroup->layout());
        Q_ASSERT(formLayout);
        formLayout->addRow(tr("Actual Z Base (mm):"), actualZBaseTextLabel);
    }

    addFormLabel(
        tr("Actual Z Range (mm):"),
        qOverload<double>(&OpticalDesign::actualZRangeMmChanged),
        Decimals{2},
        resultsGroup
    );

    addFormLabel(
        tr("Lense-Sensor Distance (mm):"),
        qOverload<double>(&OpticalDesign::lenseSensorDistanceMmChanged),
        Decimals{2},
        resultsGroup
    );

    addFormLabel(
        tr("Front Sharp Distance (mm):"),
        qOverload<double>(&OpticalDesign::frontSharpDistanceMmChanged),
        Decimals{2},
        resultsGroup
    );

    addFormLabel(
        tr("Back Sharp Distance (mm):"),
        qOverload<double>(&OpticalDesign::backSharpDistanceMmChanged),
        Decimals{2},
        resultsGroup
    );

    addFormLabel(
        tr("Depth Of Field (mm):"),
        qOverload<double>(&OpticalDesign::depthOfFieldMmChanged),
        Decimals{2},
        resultsGroup
    );

    // graphics view
    const auto openGlWidget = new QOpenGLWidget{centralWidget()};
    QSurfaceFormat surfaceFormat{};
    surfaceFormat.setSamples(4);
    openGlWidget->setFormat(surfaceFormat);
    m_view->setViewport(openGlWidget);
    // m_view->centerOn({0, 0});
    // m_view->ensureVisible(QRectF{m_scene->sceneRect()});

    mainLayout->addWidget(m_view);
    setCentralWidget(mainWidget);

    connect(
        m_design,
        qOverload<double>(&OpticalDesign::opticalAxisAngleDegreesChanged),
        this,
        [](const auto value) { qDebug() << "angle changed:" << value; }
    );

    m_view->setTransformationAnchor(GraphicsView::AnchorViewCenter);
    m_view->scale(5, 5);
    m_view->setTransformationAnchor(GraphicsView::AnchorUnderMouse);
    m_view->centerOn({0, -m_design->get_lenseYPosMm()});

    m_scene->update(m_design);
}

void MainWindow::initShortcuts()
{
    new QShortcut{Qt::CTRL | Qt::Key_Q, this, this, &MainWindow::close};
}