QePreFocalStation.hpp

#ifndef QEPREFOCALSTATION_HPP
#define QEPREFOCALSTATION_HPP
 
#include <QObject>
#include <QString>
#include <QWidget>
#include <QtUiPlugin/QDesignerExportWidget>
 
#include <qpalette.h>
#include <qcolor.h>
#include <qpainter.h>
#include <QtSvg/QtSvg>
#include <QtSvg/QSvgRenderer>
#include <QColor>
#include <QXmlStreamReader>
#include <elt/cut/widgets/widgets/QeRadialItemPlot.hpp>
 
#define _USE_MATH_DEFINES
#include <cmath>
#include <iostream>
#include <QColor>
#include <map>

class QDESIGNER_WIDGET_EXPORT QePreFocalStation : public QeRadialItemPlot {
    Q_OBJECT

    Q_PROPERTY(Configuration currentConfiguration READ getCurrentConfiguration WRITE setCurrentConfiguration NOTIFY currentConfigurationChanged)
    Q_PROPERTY(double a1b1ScienceFieldRadius READ getA1B1ScienceFieldRadius WRITE setA1B1ScienceFieldRadius NOTIFY a1b1ScienceFieldRadiusChanged)

    Q_PROPERTY(double betaWarningAngle READ getBetaWarningAngle WRITE setBetaWarningAngle NOTIFY betaWarningAngleChanged)

    Q_PROPERTY(double pfsRadius READ getPfsRadius WRITE setPfsRadius NOTIFY pfsRadiusChanged)

    Q_PROPERTY(ElementName prioritySB READ getPrioritySB WRITE setPrioritySB NOTIFY prioritySBChanged)
 
    /**************************************|
    |              SENSOR ARM A            |
    |**************************************/
    Q_PROPERTY(double currentSAAz_A READ getCurrentSAAzA  WRITE setCurrentSAAzA  NOTIFY currentSAAzChangedA )

    Q_PROPERTY(double currentSARadial_A READ getCurrentSARadialA  WRITE setCurrentSARadialA  NOTIFY currentSARadialChangedA )

    Q_PROPERTY(double targetSAAz_A READ getTargetSAAzA WRITE setTargetSAAzA NOTIFY targetSAAzChangedA )

    Q_PROPERTY(double targetSARadial_A READ getTargetSARadialA  WRITE setTargetSARadialA  NOTIFY targetSARadialChangedA )
 
    /**************************************|
    |              SENSOR ARM B            |
    |**************************************/
    Q_PROPERTY(double currentSAAz_B READ getCurrentSAAzB  WRITE setCurrentSAAzB  NOTIFY currentSAAzChangedB )

    Q_PROPERTY(double currentSARadial_B READ getCurrentSARadialB  WRITE setCurrentSARadialB  NOTIFY currentSARadialChangedB )

    Q_PROPERTY(double targetSAAz_B READ getTargetSAAzB WRITE setTargetSAAzB NOTIFY targetSAAzChangedB )

    Q_PROPERTY(double targetSARadial_B READ getTargetSARadialB  WRITE setTargetSARadialB  NOTIFY targetSARadialChangedB )
 
    /**************************************|
    |              SENSOR ARM C            |
    |**************************************/
    Q_PROPERTY(double currentSAAz_C READ getCurrentSAAzC  WRITE setCurrentSAAzC  NOTIFY currentSAAzChangedC )

    Q_PROPERTY(double currentSARadial_C READ getCurrentSARadialC  WRITE setCurrentSARadialC  NOTIFY currentSARadialChangedC )

    Q_PROPERTY(double targetSAAz_C READ getTargetSAAzC WRITE setTargetSAAzC NOTIFY targetSAAzChangedC )

    Q_PROPERTY(double targetSARadial_C READ getTargetSARadialC  WRITE setTargetSARadialC  NOTIFY targetSARadialChangedC )
 
 
public:
 
    enum Role {
        CURRENT,
        TARGET
    };
    Q_ENUM(Role);
 
    enum ElementName { A, B, C };
    Q_ENUM(ElementName);
 
    enum Configuration {
        None,
        A1B1,
        Coude,
        A3B3
    };
    Q_ENUM(Configuration);
 
    enum PositionCheck {
        OK,
        TOOCLOSE,
        COLLSION
    };
    Q_ENUM(PositionCheck);
 
    enum PFSSetup {
        PFS_A,
        PFS_B
    };

    explicit QePreFocalStation(QWidget *parent = Q_NULLPTR);
    virtual ~QePreFocalStation();

    Configuration getCurrentConfiguration(){ return m_currentConfiguration; }

    double getA1B1ScienceFieldRadius(){ return m_a1b1ScienceFieldRadius; }

    double getBetaWarningAngle(){ return m_betaWarningAngle; }

    double getPfsRadius() { return m_pfsRadius; }

    ElementName getPrioritySB() { return m_prioritySB; }
 
    /**************************************|
    |              SENSOR ARM A            |
    |**************************************/

    double getCurrentSAAzA(){ return m_currentSAAz_A; }

    double getCurrentSARadialA(){ return m_currentSARadial_A; }

    double getTargetSAAzA(){ return m_targetSAAz_A; }

    double getTargetSARadialA(){ return m_targetSARadial_A; }

    QPointF getCurrentBoxPosA(){ return m_currentBoxPos_A; }

    QPointF getTargetBoxPosA(){ return m_targetBoxPos_A; }
 
    /**************************************|
    |              SENSOR ARM B            |
    |**************************************/

    double getCurrentSAAzB(){ return m_currentSAAz_B; }

    double getCurrentSARadialB(){ return m_currentSARadial_B; }

    double getTargetSAAzB(){ return m_targetSAAz_B; }

    double getTargetSARadialB(){ return m_targetSARadial_B; }

    QPointF getCurrentBoxPosB(){ return m_currentBoxPos_B; }

    QPointF getTargetBoxPosB(){ return m_targetBoxPos_B; }
 
    /**************************************|
    |              SENSOR ARM C            |
    |**************************************/

    double getCurrentSAAzC(){ return m_currentSAAz_C; }

    double getCurrentSARadialC(){ return m_currentSARadial_C; }

    double getTargetSAAzC(){ return m_targetSAAz_C; }

    double getTargetSARadialC(){ return m_targetSARadial_C; }

    QPointF getCurrentBoxPosC(){ return m_currentBoxPos_C; }

    QPointF getTargetBoxPosC(){ return m_targetBoxPos_C; }
 
 
signals:

    void currentConfigurationChanged(Configuration newConfiguration);

    void a1b1ScienceFieldRadiusChanged(double newValue);

    void betaWarningAngleChanged(double newValue);

    void pfsRadiusChanged(double newValue);

    void prioritySBChanged(ElementName newValue);
 
    /**************************************|
    |              SENSOR ARM A            |
    |**************************************/

    void currentSAAzChangedA(double newValue);

    void currentSARadialChangedA(double newValue);

    void targetSAAzChangedA(double newValue);

    void targetSARadialChangedA(double newValue);
 
    /**************************************|
    |              SENSOR ARM B            |
    |**************************************/

    void currentSAAzChangedB(double newValue);

    void currentSARadialChangedB(double newValue);

    void targetSAAzChangedB(double newValue);

    void targetSARadialChangedB(double newValue);
 
    /**************************************|
    |              SENSOR ARM C            |
    |**************************************/

    void currentSAAzChangedC(double newValue);

    void currentSARadialChangedC(double newValue);

    void targetSAAzChangedC(double newValue);

    void targetSARadialChangedC(double newValue);
 
 
public slots:

    void setCurrentConfiguration (Configuration newConfiguration);

    void setCurrentConfigurationInt(int configuration){
        if (m_currentConfiguration == static_cast<Configuration>(configuration))
            return;
 
        m_currentConfiguration = static_cast<Configuration>(configuration);
        emit currentConfigurationChanged(m_currentConfiguration);
        this->m_warningZoneRadius = this->warningRadiuses[m_currentConfiguration];
        this->updateBackground();
        this->update();
    }
 
    void setPrioritySBInt(int priority_index){
        switch(priority_index){
        case 0:
            this->m_prioritySB = ElementName::A;
            break;
        case 1:
            this->m_prioritySB = ElementName::B;
            break;
        case 2:
            this->m_prioritySB = ElementName::C;
            break;
        default:
            return;
        }
 
 
        emit prioritySBChanged(this->m_prioritySB);
        this->update();
 
    }

    void setA1B1ScienceFieldRadius (double newValue);

    void setBetaWarningAngle (double newValue);

    void setPfsRadius(double newValue);

    void setPrioritySB(ElementName newValue);

    void changePFSSide(bool doReverse){
        this->m_reverse = doReverse;
        this->m_backgroundUpdateNeeded = true;
        this->update();
    }
 
    /**************************************|
    |              SENSOR ARM A            |
    |**************************************/

    void setCurrentSAAzA (double newValue);

    void setCurrentSARadialA (double newValue);

    void setTargetSAAzA(double newValue);

    void setTargetSARadialA(double newValue);
 
    /**************************************|
    |              SENSOR ARM B            |
    |**************************************/

    void setCurrentSAAzB (double newValue);

    void setCurrentSARadialB (double newValue);

    void setTargetSAAzB(double newValue);

    void setTargetSARadialB(double newValue);
 
    /**************************************|
    |              SENSOR ARM C            |
    |**************************************/

    void setCurrentSAAzC (double newValue);

    void setCurrentSARadialC (double newValue);

    void setTargetSAAzC(double newValue);

    void setTargetSARadialC(double newValue);
 
 
protected:
    void paintEvent(QPaintEvent *event) override;

    void paintDartBoard(QPainter *painter) override;

    void paintSA(QPainter *painter, QPointF *positionPoint, double azimuth, double radial, Role roleName, ElementName sbName);

    void updateSBColorAndText(Role roleName, QColor elementColor, QPen &currentPen, QString &sbName);

    QColor calculateColor(QColor baseColor, Role roleName);

    PositionCheck checkForCollisions(ElementName elementName);

    void drawM6ArmShadow(QPainter *painter, Configuration config);
 
 
private:
    struct ElementInfo {
        QString elementLabel;
        QColor elementCurrentColor;
    };
 
    QColor m_basicColor_A = QColor("#009DFF");
    QColor m_basicColor_B = QColor("#45fddc");
    QColor m_basicColor_C = QColor("#6A5ACD");
    QColor m_warningColor = QColor("magenta");
    QColor m_shadowColor = QColor(104, 101, 101, 50);
    QColor m_technicalFieldColor = QColor(219, 217, 209, 50);
    QColor m_scienceFieldColor = QColor(255, 187, 0, 100);
    QColor m_tooCloseColor = QColor("orange");
    QColor m_collisionColor = QColor("red");
    QString m_sbTextCurrent = "black";
    QString m_sbTextTarget = "#515151";
 
    QMap<ElementName, ElementInfo> elements = {
        {ElementName::A, {"A", m_basicColor_A}},
        {ElementName::B, {"B", m_basicColor_B}},
        {ElementName::C, {"C", m_basicColor_C}},
    };
 
    // Sensor Arm A
    double m_currentSAAz_A = 0.0;
    double m_currentSARadial_A = 0.0;
    double m_targetSAAz_A = 0.0;
    double m_targetSARadial_A = 0.0;
 
    // Sensor Arm B
    double m_currentSAAz_B = 0.0;
    double m_currentSARadial_B = 0.0;
    double m_targetSAAz_B = 0.0;
    double m_targetSARadial_B = 0.0;
 
    // Sensor Arm C
    double m_currentSAAz_C = 0.0;
    double m_currentSARadial_C = 0.0;
    double m_targetSAAz_C = 0.0;
    double m_targetSARadial_C = 0.0;
 
    bool m_backgroundUpdateNeeded = true;
 
 
    // The factor used to normalize arms length with respect to
    // generated focal plane radius (50.0)
    double m_arm_scale = 0.0;
 
    // Current and target positions of sensor arms
    // used for testing purposes
    QPointF m_currentBoxPos_A = QPointF(0.0, 0.0);
    QPointF m_currentBoxPos_B = QPointF(0.0, 0.0);
    QPointF m_currentBoxPos_C = QPointF(0.0, 0.0);
 
    QPointF m_targetBoxPos_A = QPointF(0.0, 0.0);
    QPointF m_targetBoxPos_B = QPointF(0.0, 0.0);
    QPointF m_targetBoxPos_C = QPointF(0.0, 0.0);
 
 
    const QString c_sensorBoxImagePath = ":/sensor_box.svg";
    QString m_originalXml;
    QString m_modifiedXml;
    QSvgRenderer m_svg;
 
    double m_pfsRadius = 995.0;
    double m_scienceFieldRadius = 397.0;
    double m_technicalFieldRadius;
    // In A1/B1 Configuration, science field radius if defined by configurable x
    // which: 5 >= x >= 2.5 arc mins (0.497 m)
    double m_a1b1ScienceFieldRadius = 497.0;
    // Shadow casted by M6C Mirror on technical field in coude configuration
    double m_m6cMirrorShadeRadius = 487;
    // Shadow casted by M6N Mirror on technical field in A3/B3 configuration
    double m_m6nMirrorShadeRadius = 746;
    // When SA length is beyond this radius, a warning is triggered
    // Because the current configuration is None by default,
    // SAs lengths are restricted by science field radius
    double m_warningZoneRadius = m_scienceFieldRadius;
    // Distance from the outermost circle to technical field.
    // If radial coordinate of SA is 0, SA is drawn with legth equal to the m_margin
    // representing completely retracted SA
    double m_margin = 0;
 
    Configuration m_currentConfiguration = Configuration::None;
 
    // Associate configuration modes with science field boundaries
    // (or mirror shadows overcating the technical field)
    // to easly retrieve radiuses that restrict warning zone
    QMap<Configuration, double> warningRadiuses = {
        {Configuration::None, m_scienceFieldRadius},
        {Configuration::A1B1, m_a1b1ScienceFieldRadius},
        {Configuration::Coude, m_m6cMirrorShadeRadius},
        {Configuration::A3B3, m_m6nMirrorShadeRadius},
        };
 
    // Angle values to determine whether 2 SAs are either too close each other
    // or they collide.
    // Converted to radians
    double m_collisionAngle = 50.0 * (M_PI/180);
    double m_betaWarningAngle = 10.0 * (M_PI/180);
 
    ElementName m_prioritySB;
    // False for PFS A, true for PFS B
    bool m_reverse = true;
 
};
 
 
#endif // QEPREFOCALSTATION_HPP