routemaker.h

Go to the documentation of this file.

#pragma once
 
#include "core/types.h"
#include "height_management/height_manager.h"
#include "routemaker/graph.h"
 
#include <cstdint>
#include <list>
#include <vector>
 
namespace Routemaker
{
 
    struct Cell2D
    {
        uint32_t X, Y;
        bool Occupied;
    };
 
    /// \brief Main class responsible for handling creation of routes between
    /// keyframes.
    class Routemaker : public Graph<Cell2D>
    {
      public:
        /// \brief Instatiates a routemaker object, along with it's Heightmap
        /// member.
        ///
        /// The \p origin and \p size of the scenario are simply passed to the
        /// HeightMap member. In the case that the HeightMap class is converted
        /// to a singleton or the scenario class gains ownership over the
        /// Heightmap, they should not be necessary.
        ///
        /// \param origin The origin of the scenario in UTM coordinate space.
        /// \param size The size of the scenario in meters
        explicit Routemaker(const Core::UTMCoordinate& origin, int size);
 
        /// \brief Creates a a vector of coordinates defining a path between two
        /// keyframes.
        ///
        /// Utilizes methods from the Graph interface, namely GetNeighbors,
        /// GetCost, HasLineOfSight and BresenhamLine, to generate a path
        /// between \p a and \p b.
        ///
        /// \param a First keyframe to create to create path from
        /// \param b Second keyframe to create path from
        ///
        /// returns A vector of coordinates in symmetrical cartesian coordinate
        /// system space, which together forms a path.
        std::vector<Core::CartesianCoordinate>
        MakeRoute(const Core::Keyframe& a, const Core::Keyframe& b);
 
        /// \brief Get a node at a position
        ///
        /// \param x x-coordinate of position
        /// \param y y-coordinate of position
        /// \returns A shared pointer to the node at the specified location
        NodePtr GetNode(uint32_t x, uint32_t y) const;
 
        /// \brief Updates the origin coordinate and the size of the map
        ///
        /// \param UTMOrigin The new origin coordinate for the map
        /// \param size The new size of the map in meters
        void UpdateOrigin(Core::UTMCoordinate UTMOrigin, int size);
 
        void UpdateResolution();
 
      private:
        std::vector<NodePtr> GetNeighbors(NodePtr node) override;
 
        double GetCost(NodePtr a, NodePtr b) override;
 
        bool HasLineOfSight(NodePtr a, NodePtr b) override;
 
        void ResetNodes() override;
 
        /// \brief Calculates the <a
        /// href="https://www.cs.helsinki.fi/group/goa/mallinnus/lines/bresenh.html">Bresenham
        /// Line</a> between two nodes
        ///
        /// \param a Pointer to first node
        /// \param b Pointer to seconds node
        /// \returns A list of pointers to the nodes that make up the <a
        /// href="https://www.cs.helsinki.fi/group/goa/mallinnus/lines/bresenh.html">Bresenham
        /// Line</a>  between \p a and \p b.
        std::list<NodePtr> BresenhamLine(const NodePtr& a,
                                         const NodePtr& b) const;
 
      private:
        /// \brief All the nodes that make up the graph
        std::vector<NodePtr> m_Nodes;
 
        /// \brief HeightManager instance owned by Routemaker
        std::unique_ptr<HeightManagement::HeightManager> m_HeightMap;
 
        /// \brief Width (and height) of the active scenario
        int m_MapWidth;
 
        /// \brief Resolution of the routemaker in meters.
        ///
        /// A resolution of 3 meters would mean that any one move in vertical or
        /// horizontal direction would correspond to a 3 meter movement. A
        /// higher value increases performance of the routemaker, but decreases
        /// route fidelity.
        int m_RoutemakerRes;
 
        /// \brief Width (and height) of the routemaker
        ///
        /// Will always equal \a m_MapWidth divided by \a m_RoutemakerRes
        int m_RoutemakerWidth;
    };
 
} // namespace Routemaker