Bachelorarbeit-Rover/lib/Navigation/route.h

/**
 * @file route.h
 * @author Alexander Klein (alex@kleiax.de)
 * @brief Contains the class Point and Route
 * @version 0.1
 * @date 2022-01-31
 * 
 * @copyright Copyright (c) 2022
 * 
 */

#ifndef ROUTE_H
#define ROUTE_H

#include <Arduino.h>

#include <cstdint>
#include <list> 
#include <cmath>   

#define ROUTE_DEGREE_TO_RADIANT 0.01745
#define ROUTE_DISTANCE_BETWEEN_LATITUDE 111300
#define ROUTE_PI 3.14159265358979323846

/**
 * @brief A to handle points on the earth
 * 
 * The points inherits latidue and longitude as doubles
 * 
 */
class Point{
    public:
        /**
         * @brief Hold the data longitude and latitude
         * 
         */
        struct Coordinates {
            double lon;
            double lat;

            bool operator==(const Coordinates rhs) const {
                return ( this->lon == rhs.lon ) && ( this->lon == rhs.lon );
            }
        };

        /**
         * @brief The Accuracy is set by the constructor
         * 
         */
        enum Accuracy {
            none,
            fourDigOfCM,
            threeDigOfCM,
            twoDigOfCM,
            oneDigOfCM,
            imported
        };


        /**
         * @brief Construct a new Point object
         * 
         * @param lat latitude
         * @param lon longitude
         * @param horizontalAccuracy mm
         * @param coords Coordinates
         * @param imported if true than highest accuracy
         */
        Point(double lat, double lon, uint32_t horizontalAccuracy = 0);
        Point(int32_t lat, int32_t lon, uint32_t horizontalAccuracy = 0);
        Point(Coordinates coords, uint32_t horizontalAccuracy = 0);
        Point(Coordinates coords, bool imported);
        Point();

        /**
         * @brief Checks if to points are equal.
         * 
         * @param rhs 
         * @return true 
         * @return false 
         */
        bool operator==(const Point& rhs) const;

        /**
         * @brief Checks if the point is initalized.
         * 
         * @return true 
         * @return false 
         */
        bool isInit() const { return this->coordinates.lat + this->coordinates.lon; }

        /**
         * @brief Checks if the point is valid.
         * 
         * If the accuracy is higher than zero, true will be returned.
         * 
         * @return true 
         * @return false 
         */
        bool isValid() const { return (this->accuracy > 0) ? true : false; }

        /**
         * @brief Calculates the distance between to points.
         * 
         * @param point 
         * @return double meter
         */
        double distanceTo(const Coordinates& point) const;
        double distanceTo(const Point& point) const;

        /**
         * @brief Calculates the course to an other point.
         * 
         * @param point 
         * @return int16_t degree
         */
        int16_t courseTo(const Coordinates& point) const;
        int16_t courseTo(const Point& point) const;

        uint32_t getCreationTime() const { return this->creationTime; }
        double getLongitude() const { return this->coordinates.lon; }
        double getLatitude() const { return this->coordinates.lat; }
        Coordinates getCoordinates() const { return this->coordinates; }

        /**
         * @brief Get the Accuracy object
         * 
         * The higher the value, the greater the accuracy.
         * You can check it by Accuracy.
         * 
         * @return Accuracy 
         */
        Accuracy getAccuracy() { return this->accuracy; }

    private:
        void init(uint32_t horizontalAccuracy);

        Accuracy accuracy = Accuracy::none;
        Coordinates coordinates;

        uint32_t creationTime = 0;
};

/**
 * @brief Holds some route information
 * 
 */
struct RouteInfo{
    /**
     * @brief Selected number of Points
     */
    uint16_t currentPoint;

    /**
     * @brief Total points stored in route
     */
    uint16_t totalPoints;
};

/**
 * @brief A class to manage multiple points
 * 
 * The list of point presents a route which can be driven
 */
class Route {
    public:
        /**
         * @brief Construct a new Route object.
         */
        Route();

        /**
         * @brief Adds a point to the list.
         * 
         * @param point 
         */
        void addPointToRoute(Point point);

        /**
         * @brief Delete all points.
         * 
         */
        void clear();

        /**
         * @brief Select the first point as target.
         * 
         * @return Point 
         */
        Point startRoute();

        /**
         * @brief Select the last point as target.
         * 
         * @return Point 
         */
        Point endRoute();

        /**
         * @brief Get the next point and set it as target.
         * 
         * @return Point is zero if there are no more Points.
         */
        Point getNextPoint();

        /**
         * @brief Get the previous point and set it as target.
         * 
         * @return Point 
         */
        Point getPreviousPoint();

        /**
         * @brief Get the Route Info object
         * 
         * @return RouteInfo 
         */
        RouteInfo getRouteInfo();

        /**
         * @brief Get the Started object
         * 
         * The Route will be marked as started when startRoute or 
         * endRoute has been called.
         * 
         * @return true 
         * @return false 
         */
        bool getStarted() const { return this->started; }

    private:
        uint16_t currentPoint = 0;
        bool started = false;

        std::list<Point> points;
        std::list<Point>::iterator it;

};

#endif // ROUTE_H