pilotclient/src/blackgui/components/radarcomponent.cpp

/* Copyright (C) 2019
 * swift project Community / Contributors
 *
 * This file is part of swift project. It is subject to the license terms in the LICENSE file found in the top-level
 * directory of this distribution. No part of swift project, including this file, may be copied, modified, propagated,
 * or distributed except according to the terms contained in the LICENSE file.
 */

#include "ui_radarcomponent.h"
#include "blackgui/guiapplication.h"
#include "blackgui/infoarea.h"
#include "blackgui/components/radarcomponent.h"
#include "blackcore/context/contextnetwork.h"
#include "blackmisc/simulation/simulatedaircraft.h"

#include <QtMath>
#include <QStringBuilder>

using namespace BlackMisc;
using namespace BlackMisc::Aviation;
using namespace BlackMisc::Simulation;
using namespace BlackMisc::Geo;
using namespace BlackMisc::PhysicalQuantities;
using namespace BlackGui::Views;

namespace BlackGui
{
    namespace Components
    {
        CRadarComponent::CRadarComponent(QWidget *parent) :
            QFrame(parent),
            ui(new Ui::CRadarComponent)
        {
            ui->setupUi(this);

            ui->gv_RadarView->setScene(&m_scene);

            ui->cb_RadarRange->addItem(QString::number(0.5) % u" nm", 0.5);
            for (qreal r = 1.0; r < 10; r += 1)
            {
                ui->cb_RadarRange->addItem(QString::number(r) % u" nm", r);
            }
            for (qreal r = 10; r < 91; r += 10)
            {
                ui->cb_RadarRange->addItem(QString::number(r) % u" nm", r);
            }

            ui->cb_RadarRange->setCurrentText(QString::number(m_rangeNM) % u" nm");

            connect(ui->gv_RadarView, &CRadarView::radarViewResized, this, &CRadarComponent::fitInView);
            connect(ui->gv_RadarView, &CRadarView::zoomEvent, this, &CRadarComponent::changeRangeInSteps);
            connect(&m_updateTimer, &QTimer::timeout, this, &CRadarComponent::refreshTargets);

            connect(ui->cb_RadarRange, qOverload<int>(&QComboBox::currentIndexChanged), this, &CRadarComponent::changeRangeFromUserSelection);
            connect(ui->cb_Callsign, &QCheckBox::toggled, this, &CRadarComponent::refreshTargets);
            connect(ui->cb_Heading, &QCheckBox::toggled,  this, &CRadarComponent::refreshTargets);
            connect(ui->cb_Altitude, &QCheckBox::toggled, this, &CRadarComponent::refreshTargets);
            connect(ui->cb_GroundSpeed, &QCheckBox::toggled, this, &CRadarComponent::refreshTargets);
            connect(ui->cb_Grid, &QCheckBox::toggled, this, &CRadarComponent::toggleGrid);

            prepareScene();

            m_updateTimer.start(5000);
        }

        CRadarComponent::~CRadarComponent()
        { }

        bool CRadarComponent::setParentDockWidgetInfoArea(CDockWidgetInfoArea *parentDockableWidget)
        {
            CEnableForDockWidgetInfoArea::setParentDockWidgetInfoArea(parentDockableWidget);
            const bool c = connect(this->getParentInfoArea(), &CInfoArea::changedInfoAreaTabBarIndex, this, &CRadarComponent::onInfoAreaTabBarChanged);
            Q_ASSERT_X(c, Q_FUNC_INFO, "failed connect");
            Q_ASSERT_X(parentDockableWidget, Q_FUNC_INFO, "missing parent");
            return c && parentDockableWidget;
        }

        void CRadarComponent::prepareScene()
        {
            m_scene.addItem(&m_center);
            m_scene.addItem(&m_macroGraticule);
            m_scene.addItem(&m_microGraticule);
            m_scene.addItem(&m_radials);
            m_scene.addItem(&m_radarTargets);
            m_radarTargetPen.setCosmetic(true);
            addCenter();
            addGraticules();
            addRadials();
        }

        void CRadarComponent::addCenter()
        {
            QPen pen(Qt::white, 1);
            pen.setCosmetic(true);
            QGraphicsLineItem *lix = new QGraphicsLineItem{QLineF(-5.0, 0.0, 5.0, 0.0), &m_center};
            lix->setFlags(QGraphicsItem::ItemIgnoresTransformations);
            lix->setPen(pen);

            QGraphicsLineItem *liy = new QGraphicsLineItem(QLineF(0.0, -5.0, 0.0, 5.0), &m_center);
            liy->setFlags(QGraphicsItem::ItemIgnoresTransformations);
            liy->setPen(pen);
        }

        void CRadarComponent::addGraticules()
        {
            QPen pen(Qt::white, 1);
            pen.setCosmetic(true);

            // Macro graticule, drawn as full line at every 10 nm
            for (qreal range = 10.0; range < 101.0; range += 10.0)
            {
                QGraphicsEllipseItem *circle = new QGraphicsEllipseItem(-range, -range, 2.0 * range, 2.0 * range, &m_macroGraticule);
                circle->setPen(pen);
            }
            pen = QPen(Qt::gray, 1, Qt::DashLine);
            pen.setCosmetic(true);

            // Micro graticule, drawn as dash line at every 2.5 nm
            for (qreal range = 2.5; range < 9.9; range += 2.5)
            {
                QGraphicsEllipseItem *circle = new QGraphicsEllipseItem(-range, -range, 2.0 * range, 2.0 * range, &m_microGraticule);
                circle->setPen(pen);
            }
        }

        void CRadarComponent::addRadials()
        {
            QPen pen(Qt::gray, 1, Qt::DashDotDotLine);
            pen.setCosmetic(true);

            for (qreal angle = 0.0; angle < 359.0; angle += 30.0)
            {
                const QLineF line(0.0, 0.0, 100.0 * qCos(qDegreesToRadians(angle)), -100.0 * qSin(qDegreesToRadians(angle)));
                QGraphicsLineItem *li = new QGraphicsLineItem(line, &m_radials);
                li->setPen(pen);
            }
        }

        void CRadarComponent::refreshTargets()
        {
            if (!sGui || sGui->isShuttingDown()) { return; }

            qDeleteAll(m_radarTargets.childItems());

            if (sGui->getIContextNetwork() && sGui->getIContextNetwork()->isConnected())
            {
                if (isVisibleWidget())
                {
                    const CSimulatedAircraftList aircraft = sGui->getIContextNetwork()->getAircraftInRange();
                    for (const CSimulatedAircraft &sa : aircraft)
                    {
                        const double distanceNM  = sa.getRelativeDistance().value(CLengthUnit::NM());
                        const double bearingRad  = sa.getRelativeBearing().value(CAngleUnit::rad());
                        const int groundSpeedKts = sa.getGroundSpeed().valueInteger(CSpeedUnit::kts());

                        QPointF position(distanceNM * qSin(bearingRad), -distanceNM * qCos(bearingRad));

                        QGraphicsEllipseItem *dot = new QGraphicsEllipseItem(-2.0, -2.0, 4.0, 4.0, &m_radarTargets);
                        dot->setPos(position);
                        dot->setPen(m_radarTargetPen);
                        dot->setBrush(m_radarTargetPen.color());
                        dot->setFlags(QGraphicsItem::ItemIgnoresTransformations);

                        QGraphicsTextItem *tag = new QGraphicsTextItem(&m_radarTargets);
                        QString tagText;
                        if (ui->cb_Callsign->isChecked())
                        {
                            tagText += sa.getCallsignAsString() % u"\n";
                        }
                        if (ui->cb_Altitude->isChecked())
                        {
                            int flightLeveL = sa.getAltitude().valueInteger(CLengthUnit::ft()) / 100;
                            tagText += u"FL" % QStringLiteral("%1").arg(flightLeveL, 3, 10, QChar('0'));
                        }
                        if (ui->cb_GroundSpeed->isChecked())
                        {
                            if (!tagText.isEmpty()) tagText += QStringLiteral(" ");
                            tagText += QString::number(groundSpeedKts) % u" kt";
                        }

                        tag->setPlainText(tagText);
                        tag->setPos(position);
                        tag->setDefaultTextColor(Qt::green);
                        tag->setFlags(QGraphicsItem::ItemIgnoresTransformations);

                        if (ui->cb_Heading->isChecked() && groundSpeedKts > 3.0)
                        {
                            double headingRad = sa.getHeading().value(CAngleUnit::rad());
                            QPen pen(Qt::green, 1);
                            pen.setCosmetic(true);
                            QGraphicsLineItem *li = new QGraphicsLineItem(QLineF(0.0, 0.0, 20.0 * qSin(headingRad), -20.0 * qCos(headingRad)), dot);
                            li->setFlags(QGraphicsItem::ItemIgnoresTransformations);
                            li->setPen(pen);
                        }
                    }
                }
            }
        }

        void CRadarComponent::toggleGrid(bool checked)
        {
            m_macroGraticule.setVisible(checked);
            m_microGraticule.setVisible(checked);
            m_radials.setVisible(checked);
        }

        void CRadarComponent::fitInView()
        {
            ui->gv_RadarView->fitInView(-m_rangeNM, -m_rangeNM, 2.0 * m_rangeNM, 2.0 * m_rangeNM, Qt::KeepAspectRatio);
        }

        void CRadarComponent::changeRangeInSteps(bool zoomIn)
        {
            qreal direction = zoomIn ? 1.0 : -1.0;
            double factor = 10.0;
            if (m_rangeNM < 10.0 || (qFuzzyCompare(m_rangeNM, 10.0) && zoomIn))
            {
                factor = 1.0;
            }

            if (m_rangeNM < 1.0 || (qFuzzyCompare(m_rangeNM, 1.0) && zoomIn))
            {
                factor = 0.5;
            }

            m_rangeNM = m_rangeNM - direction * factor;
            m_rangeNM = qMin(90.0, qMax(0.5, m_rangeNM));
            ui->cb_RadarRange->setCurrentText(QString::number(m_rangeNM) % u" nm");
            fitInView();
        }

        void CRadarComponent::changeRangeFromUserSelection(int index)
        {
            double range = ui->cb_RadarRange->itemData(index).toDouble();
            if (! qFuzzyCompare(m_rangeNM, range))
            {
                m_rangeNM = range;
                fitInView();
            }
        }

        void CRadarComponent::onInfoAreaTabBarChanged(int index)
        {
            Q_UNUSED(index);

            // ignore in those cases
            if (!this->isVisibleWidget()) return;
            if (this->isParentDockWidgetFloating()) return;
            if (!sGui->getIContextNetwork()->isConnected()) return;

            // here I know I am the selected widget, update, but keep GUI responsive (hence I use a timer)
            QPointer<CRadarComponent> myself(this);
            QTimer::singleShot(1000, this, [ = ]
            {
                if (!myself) { return; }
                myself->refreshTargets();
            });

        }
    } // namespace
} // namespace