map_viewer.cpp

Go to the documentation of this file.

#include "gui/map_viewer.h"
 
#include "gui/main_window.h"
 
#include <QPainter>
#include <QRandomGenerator>
#include <QTimer>
 
namespace Gui
{
 
    MapViewer::MapViewer(QWidget* parent)
        : QWidget(parent), m_WaitingForData(true),
          m_WaitingForDataTimer(new QTimer(this)), m_LoaderAngle(0),
          m_LoaderSize(100), m_LoaderSpeed(180.0f), m_LoaderSpan(270.0f),
          m_LoaderThickness(8), m_StartX{}, m_StartY{}, m_Size{},
          m_ActiveAgentId{}, m_TimeStamp{}
    {
        setObjectName("MapViewer");
 
        connect(m_WaitingForDataTimer, &QTimer::timeout, this, [this]() {
            qint64 elapsedMilliseconds = m_WaitingForDataElapsedTimer.elapsed();
            float deltaTimeSeconds =
                static_cast<float>(elapsedMilliseconds) / 1000.0f;
            m_LoaderAngle -= m_LoaderSpeed * deltaTimeSeconds;
            m_WaitingForDataElapsedTimer.restart();
            update();
        });
 
        setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
        UpdateRenderingArea();
 
        m_WaitingForDataElapsedTimer.start();
        WaitForData();
    }
 
    void
    MapViewer::paintEvent(QPaintEvent* event)
    {
        QPainter painter(this);
 
        if (m_WaitingForData) {
            DrawLoader(painter);
            return;
        }
 
        QByteArray mapData = MapManagement::MapManager::GetData();
        if (!mapData.isEmpty()) {
            int pixmapResolution{
                MapManagement::MapManager::GetImageResolution()
            };
            QPixmap pixmap(pixmapResolution, pixmapResolution);
            pixmap.loadFromData(mapData);
            painter.drawPixmap(m_StartX, m_StartY,
                               pixmap.scaled(m_Size, m_Size));
        }
 
        DrawRoutes(painter);
        DrawKeyframes(painter);
    }
 
    void
    MapViewer::resizeEvent(QResizeEvent* event)
    {
        UpdateRenderingArea();
    }
 
    void
    MapViewer::mousePressEvent(QMouseEvent* event)
    {
        event->ignore();
 
        // Only respond to left mouse button clicks
        if (event->button() != Qt::LeftButton) {
            return;
        }
 
        // Ignore clicks if they are outside the rendering area
        int x = static_cast<int>(event->position().x());
        int y = static_cast<int>(event->position().y());
        bool contained = (x >= m_StartX && x < (m_StartX + m_Size) &&
                          y >= m_StartY && y < (m_StartY + m_Size));
        if (!contained) {
            return;
        }
 
        // Relative coordinates of mouse click within the rendering area
        float xRel{ static_cast<float>(x - m_StartX) };
        float yRel{ static_cast<float>(y - m_StartY) };
 
        float size{ static_cast<float>(
            CoordinateConverter::CoordConv::GetSize()) };
 
        // Find relative coordinate within scenario space
        xRel = xRel * size / static_cast<float>(m_Size);
        yRel = yRel * size / static_cast<float>(m_Size);
        Core::CartesianCoordinate symmetricPosition{
            CoordinateConverter::CoordConv::AsymmetricToSymmetric(
                { xRel, yRel, 0 })
        };
 
        Core::Keyframe newKeyframe(m_ActiveAgentId, m_TimeStamp,
                                   symmetricPosition);
        KeyframeManagement::KeyframeManager::Instance().AddKeyframe(
            newKeyframe);
    }
 
    void
    MapViewer::UpdateRenderingArea()
    {
        int maxWidth = width();
        int maxHeight = height();
 
        m_Size = std::min(maxWidth, maxHeight);
        int marginX = maxWidth - m_Size;
        int marginY = maxHeight - m_Size;
 
        m_StartX = marginX / 2;
        m_StartY = marginY / 2;
    }
 
    void
    MapViewer::WaitForData()
    {
        m_WaitingForData = true;
        m_WaitingForDataTimer->start(16);
        setCursor(Qt::WaitCursor);
        update();
    }
 
    void
    MapViewer::DataReceived()
    {
        m_WaitingForData = false;
        m_WaitingForDataTimer->stop();
        setCursor(Qt::ArrowCursor);
        update();
    }
 
    void
    MapViewer::DrawKeyframes(QPainter& painter)
    {
        int radius = 8;
        int scenarioSize{ CoordinateConverter::CoordConv::GetSize() };
        auto keyframes =
            KeyframeManagement::KeyframeManager::Instance().GetKeyframes();
        for (const Core::Keyframe& keyframe : keyframes) {
            Core::CartesianCoordinate keyframePositionAsymmetric{
                CoordinateConverter::CoordConv::SymmetricToAsymmetric(
                    keyframe.Position)
            };
            int x{ static_cast<int>(
                keyframePositionAsymmetric.X / scenarioSize * m_Size +
                m_StartX - static_cast<float>(radius) / 2.0f) };
            int y{ static_cast<int>(
                keyframePositionAsymmetric.Y / scenarioSize * m_Size +
                m_StartY - static_cast<float>(radius) / 2.0f) };
 
            auto agent = std::find_if(m_Agents.first, m_Agents.second,
                                      [&](const Core::Agent& agent) {
                                          return agent.Id == keyframe.AgentId;
                                      });
            QColor color(Qt::magenta);
            if (agent != m_Agents.second) {
                color = QColor(QString::fromStdString(agent->Color));
            }
 
            painter.setPen(Qt::black);
            painter.setBrush({ color });
            painter.drawEllipse(x, y, radius, radius);
        }
    }
 
    void
    MapViewer::DrawRoutes(QPainter& painter)
    {
        QPen pen(Qt::red, 2);
        painter.setPen(pen);
        painter.setRenderHint(QPainter::Antialiasing);
 
        for (auto iter = m_Routes.first; iter != m_Routes.second; ++iter) {
            int agentId = iter->first;
            auto route = iter->second;
            for (int j = 0; j < route.size(); j++) {
                for (int k = 0; k < route[j].size() - 1; k++) {
                    Core::CartesianCoordinate asymmetricA =
                        CoordinateConverter::CoordConv::SymmetricToAsymmetric(
                            route[j][k]);
                    Core::CartesianCoordinate asymmetricB =
                        CoordinateConverter::CoordConv::SymmetricToAsymmetric(
                            route[j][k + 1]);
 
                    int x1{ static_cast<int>(
                        asymmetricA.X /
                            CoordinateConverter::CoordConv::GetSize() * m_Size +
                        m_StartX) };
                    int y1{ static_cast<int>(
                        asymmetricA.Y /
                            CoordinateConverter::CoordConv::GetSize() * m_Size +
                        m_StartY) };
                    int x2{ static_cast<int>(
                        asymmetricB.X /
                            CoordinateConverter::CoordConv::GetSize() * m_Size +
                        m_StartX) };
                    int y2{ static_cast<int>(
                        asymmetricB.Y /
                            CoordinateConverter::CoordConv::GetSize() * m_Size +
                        m_StartY) };
 
                    auto agent = std::find_if(m_Agents.first, m_Agents.second,
                                              [&](const Core::Agent& agent) {
                                                  return agent.Id == agentId;
                                              });
                    QColor color(Qt::magenta);
                    if (agent != m_Agents.second) {
                        color = QColor(QString::fromStdString(agent->Color));
                    }
 
                    painter.setPen({ color, 2 });
                    painter.drawLine(x1, y1, x2, y2);
                }
            }
        }
    }
 
    void
    MapViewer::DrawLoader(QPainter& painter) const
    {
        QColor hivemindOrange(227, 118, 39);
        QPen pen(hivemindOrange, m_LoaderThickness, Qt::SolidLine,
                 Qt::RoundCap);
        painter.setPen(pen);
        painter.setRenderHint(QPainter::Antialiasing);
 
        int x{ m_StartX + (m_Size - m_LoaderSize) / 2 };
        int y{ m_StartY + (m_Size - m_LoaderSize) / 2 };
 
        QRectF rectangle(x, y, m_LoaderSize, m_LoaderSize);
 
        // Multiply angles by 16 because Qt's angles are specified 1/16th of a
        // degree
        int spanAngle = static_cast<int>(m_LoaderSpan) * 16;
        int startAngle = static_cast<int>(m_LoaderAngle) * 16;
        painter.drawArc(rectangle, startAngle, spanAngle);
    }
 
    void
    MapViewer::UpdateRoutes(
        std::pair<CompileScenario::Scenario::RouteMap::iterator,
                  CompileScenario::Scenario::RouteMap::iterator>
            routes)
    {
        m_Routes = routes;
        update();
    }
 
    void
    MapViewer::UpdateAgents(std::pair<std::vector<Core::Agent>::iterator,
                                      std::vector<Core::Agent>::iterator>
                                agents)
    {
        m_Agents = agents;
        update();
    }
 
} // namespace Gui