scenario.h

Go to the documentation of this file.

#pragma once
 
#include "core/serializer.h"
#include "keyframe_management/keyframe_manager.h"
#include "routemaker/routemaker.h"
 
#include <algorithm>
#include <memory>
#include <string>
 
namespace CompileScenario
{
 
    ///
    /// \brief The Scenario class represents a scenario with keyframes and
    /// routes.
    ///
    /// The Scenario class provides functionality for creating a scenario with
    /// keyframes and routes, as well as saving and loading the scenario to and
    /// from file.
    class Scenario : JSON
    {
      public:
        using RouteMap =
            std::map<int, std::vector<std::vector<Core::CartesianCoordinate>>>;
        ///
        /// \brief Constructs a new Scenario object with the given name, origin,
        /// and size. \param name The name of the scenario. \param origin The
        /// geographical coordinates of the origin. \param size The size of the
        /// scenario.
        Scenario(std::string name, Core::GeographicalCoordinate origin, int size);
 
        ///
        /// \brief Compiles the scenario into a map of routes.
        /// \return A map of routes.
        RouteMap& Compile();
 
        ///
        /// \brief Saves the scenario to a file with the given filename.
        /// \param filename The name of the file to save to.
        void save(std::string filename);
 
        ///
        /// \brief Loads a scenario from a file with the given filename.
        /// \param filename The name of the file to load from.
        void load(std::string filename);
 
        inline std::pair<RouteMap::iterator, RouteMap::iterator>
        GetRoutes()
        {
            return std::make_pair<RouteMap::iterator, RouteMap::iterator>(
                m_Routes.begin(), m_Routes.end());
        }
 
        inline std::pair<std::vector<Core::Agent>::iterator,
                         std::vector<Core::Agent>::iterator>
        GetAgents()
        {
            return std::make_pair<std::vector<Core::Agent>::iterator,
                                  std::vector<Core::Agent>::iterator>(
                m_Agents.begin(), m_Agents.end());
        }
 
        void AddAgent(Core::Agent newAgent);
 
        ///
        /// \brief Sets the origin of the scenario to the given geographical
        /// coordinates and size. \param GeoCoord The geographical coordinates
        /// of the origin. \param size The size of the scenario.
        void SetOrigin(Core::GeographicalCoordinate GeoCoord, int size);
 
      private:
        KeyframeManagement::KeyframeManager& m_KeyframeManager;
        std::vector<Core::Agent> m_Agents;
        RouteMap m_Routes;
        std::unique_ptr<Routemaker::Routemaker> m_Routemaker;
        std::string m_Name;
        Core::GeographicalCoordinate m_Origin;
        int m_Size;
 
        JSONSTART
        JSONSTRING(m_Name), JSONMEMBER(Core::GeographicalCoordinate, m_Origin),
            JSONINT(m_Size), JSONMEMBERVECTOR(Core::Agent, m_Agents),
            JSONMEMBER(KeyframeManagement::KeyframeManager,
                       m_KeyframeManager) JSONEND
    };
 
} // namespace CompileScenario