grid.h

Go to the documentation of this file.

#ifndef GRID_H
#define GRID_H

#include "road.h"
#include "track.h"

#include <QObject>

#include <QString>
#include <unordered_map>
#include <vector>

struct hashFunc {
    size_t operator()(const PointRoad& p) const
    {
        size_t h1 = std::hash<double>()(p.x());
        size_t h2 = std::hash<double>()(p.y());
        return h1 ^ (h2 << 1);
    }
};

struct equalsFunc {
    bool operator()(const PointRoad& p1, const PointRoad& p2) const
    {
        return p1.samePointAs(p2);
    }
};

typedef std::unordered_map<PointRoad, int, hashFunc, equalsFunc> ExtremityPointMap; // for all node points
typedef std::unordered_map<long, Road> AllRoadMap;
//typedef std::unordered_map<long, Road&> AllRoadMap;   // for all roads (& do not recreate object)

class Grid : public QObject {
    Q_OBJECT
public:
    Grid();
    virtual ~Grid();

    void setTrackBoundingBox(double xMin, double xMax, double yMin, double yMax);

    void readFromCSV(QString filename);

    void addRoad(const std::vector<std::vector<double> >& listOfCoordinates, long edgeId);

    bool inFootPrint(double x, double y);

    void updateGrid(double x, double y);

    bool trackInGrid();

    void setDistance(PointGPS& p, Road& r);

    void buildMarkovMatrix();

    double computeDistanceFraction(PointGPS* prevPoint, PointGPS* curPoint, long prevRoadId, long curRoadId);
    std::vector<double> getProjectedPointAndDistance(PointGPS* p, Road* r);

    double getDistanceBetweenProjections(Point* projR1, Point* projR2, Road* r1);
    double getDistanceToExtremity(Point* projR1, int node, Road* r1);
    int getSegmentCounter(Point* p, Road* r);

    // test functions
    void outputInfos();
    std::string infos();
    AllRoadMap::iterator getRoadEntry(long id); // used to update neighbors (for markovmatrix)
    AllRoadMap* getRoads() { return &m_mapOfAllRoads; } // TODO const ?
    std::vector<PointRoad>* getPoints() { return &m_vectorOfPoints; }

    int getNoOfRoads() const { return m_mapOfAllRoads.size(); }
    int getNoOfPoints() const { return m_vectorOfPoints.size(); }
    double xMin() const { return m_xMin; }
    double xMax() const { return m_xMax; }
    double yMin() const { return m_yMin; }
    double yMax() const { return m_yMax; }
    double xMinGrid() const { return m_xMinGrid; }
    double xMaxGrid() const { return m_xMaxGrid; }
    double yMinGrid() const { return m_yMinGrid; }
    double yMaxGrid() const { return m_yMaxGrid; }

    AllRoadMap m_mapOfAllRoads;
    std::vector<PointRoad> m_vectorOfPoints;

signals:
    void signalMessage(QString);

protected:
    std::string m_gridFullName;
    ExtremityPointMap m_mapOfExtPoints; // temporary container during csv loading
    static long counter; // counter used to generate unique m_id (not used for Seattle data)

    double m_xMin; 
    double m_xMax; 
    double m_yMin; 
    double m_yMax; 

    double m_xMinGrid; 
    double m_xMaxGrid; 
    double m_yMinGrid; 
    double m_yMaxGrid; 
};

#endif // GRID_H